This source file includes following definitions.
- move_addr_to_kernel
- move_addr_to_user
- get_fd
- socki_lookup
- sockfd_lookup
- sock_alloc
- sock_release_peer
- sock_release
- sock_lseek
- sock_read
- sock_write
- sock_readdir
- sock_ioctl
- sock_select
- sock_close
- sock_fasync
- sock_wake_async
- sock_awaitconn
- sock_socket
- sock_socketpair
- sock_bind
- sock_listen
- sock_accept
- sock_connect
- sock_getsockname
- sock_getpeername
- sock_send
- sock_sendto
- sock_recv
- sock_recvfrom
- sock_setsockopt
- sock_getsockopt
- sock_shutdown
- sock_fcntl
- sys_socketcall
- sock_register
- sock_unregister
- proto_init
- sock_init
- socket_get_info
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48 #include <linux/config.h>
49 #include <linux/signal.h>
50 #include <linux/errno.h>
51 #include <linux/sched.h>
52 #include <linux/mm.h>
53 #include <linux/kernel.h>
54 #include <linux/major.h>
55 #include <linux/stat.h>
56 #include <linux/socket.h>
57 #include <linux/fcntl.h>
58 #include <linux/net.h>
59 #include <linux/interrupt.h>
60 #include <linux/netdevice.h>
61
62 #include <asm/system.h>
63 #include <asm/segment.h>
64
65 static int sock_lseek(struct inode *inode, struct file *file, off_t offset,
66 int whence);
67 static int sock_read(struct inode *inode, struct file *file, char *buf,
68 int size);
69 static int sock_write(struct inode *inode, struct file *file, char *buf,
70 int size);
71 static int sock_readdir(struct inode *inode, struct file *file,
72 struct dirent *dirent, int count);
73 static void sock_close(struct inode *inode, struct file *file);
74 static int sock_select(struct inode *inode, struct file *file, int which, select_table *seltable);
75 static int sock_ioctl(struct inode *inode, struct file *file,
76 unsigned int cmd, unsigned long arg);
77 static int sock_fasync(struct inode *inode, struct file *filp, int on);
78
79
80
81
82
83
84
85
86 static struct file_operations socket_file_ops = {
87 sock_lseek,
88 sock_read,
89 sock_write,
90 sock_readdir,
91 sock_select,
92 sock_ioctl,
93 NULL,
94 NULL,
95 sock_close,
96 NULL,
97 sock_fasync
98 };
99
100
101
102
103 static struct proto_ops *pops[NPROTO];
104
105
106
107 static int sockets_in_use = 0;
108
109
110
111
112
113
114 #define MAX_SOCK_ADDR 128
115
116 static int move_addr_to_kernel(void *uaddr, int ulen, void *kaddr)
117 {
118 int err;
119 if(ulen<0||ulen>MAX_SOCK_ADDR)
120 return -EINVAL;
121 if(ulen==0)
122 return 0;
123 if((err=verify_area(VERIFY_READ,uaddr,ulen))<0)
124 return err;
125 memcpy_fromfs(kaddr,uaddr,ulen);
126 return 0;
127 }
128
129 static int move_addr_to_user(void *kaddr, int klen, void *uaddr, int *ulen)
130 {
131 int err;
132 int len;
133
134
135 if((err=verify_area(VERIFY_WRITE,ulen,sizeof(*ulen)))<0)
136 return err;
137 len=get_fs_long(ulen);
138 if(len>klen)
139 len=klen;
140 if(len<0 || len> MAX_SOCK_ADDR)
141 return -EINVAL;
142 if(len)
143 {
144 if((err=verify_area(VERIFY_WRITE,uaddr,len))<0)
145 return err;
146 memcpy_tofs(uaddr,kaddr,len);
147 }
148 put_fs_long(len,ulen);
149 return 0;
150 }
151
152
153
154
155
156 static int get_fd(struct inode *inode)
157 {
158 int fd;
159 struct file *file;
160
161
162
163
164
165 file = get_empty_filp();
166 if (!file)
167 return(-1);
168
169 for (fd = 0; fd < NR_OPEN; ++fd)
170 if (!current->files->fd[fd])
171 break;
172 if (fd == NR_OPEN)
173 {
174 file->f_count = 0;
175 return(-1);
176 }
177
178 FD_CLR(fd, ¤t->files->close_on_exec);
179 current->files->fd[fd] = file;
180 file->f_op = &socket_file_ops;
181 file->f_mode = 3;
182 file->f_flags = O_RDWR;
183 file->f_count = 1;
184 file->f_inode = inode;
185 if (inode)
186 inode->i_count++;
187 file->f_pos = 0;
188 return(fd);
189 }
190
191
192
193
194
195
196
197
198 inline struct socket *socki_lookup(struct inode *inode)
199 {
200 return &inode->u.socket_i;
201 }
202
203
204
205
206
207 static inline struct socket *sockfd_lookup(int fd, struct file **pfile)
208 {
209 struct file *file;
210 struct inode *inode;
211
212 if (fd < 0 || fd >= NR_OPEN || !(file = current->files->fd[fd]))
213 return NULL;
214
215 inode = file->f_inode;
216 if (!inode || !inode->i_sock)
217 return NULL;
218
219 if (pfile)
220 *pfile = file;
221
222 return socki_lookup(inode);
223 }
224
225
226
227
228 static struct socket *sock_alloc(void)
229 {
230 struct inode * inode;
231 struct socket * sock;
232
233 inode = get_empty_inode();
234 if (!inode)
235 return NULL;
236
237 inode->i_mode = S_IFSOCK;
238 inode->i_sock = 1;
239 inode->i_uid = current->uid;
240 inode->i_gid = current->gid;
241
242 sock = &inode->u.socket_i;
243 sock->state = SS_UNCONNECTED;
244 sock->flags = 0;
245 sock->ops = NULL;
246 sock->data = NULL;
247 sock->conn = NULL;
248 sock->iconn = NULL;
249 sock->next = NULL;
250 sock->wait = &inode->i_wait;
251 sock->inode = inode;
252 sock->fasync_list = NULL;
253 sockets_in_use++;
254 return sock;
255 }
256
257
258
259
260
261 static inline void sock_release_peer(struct socket *peer)
262 {
263 peer->state = SS_DISCONNECTING;
264 wake_up_interruptible(peer->wait);
265 sock_wake_async(peer, 1);
266 }
267
268
269 static void sock_release(struct socket *sock)
270 {
271 int oldstate;
272 struct socket *peersock, *nextsock;
273
274 if ((oldstate = sock->state) != SS_UNCONNECTED)
275 sock->state = SS_DISCONNECTING;
276
277
278
279
280
281 for (peersock = sock->iconn; peersock; peersock = nextsock)
282 {
283 nextsock = peersock->next;
284 sock_release_peer(peersock);
285 }
286
287
288
289
290
291
292 peersock = (oldstate == SS_CONNECTED) ? sock->conn : NULL;
293 if (sock->ops)
294 sock->ops->release(sock, peersock);
295 if (peersock)
296 sock_release_peer(peersock);
297 --sockets_in_use;
298 iput(SOCK_INODE(sock));
299 }
300
301
302
303
304
305 static int sock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
306 {
307 return(-ESPIPE);
308 }
309
310
311
312
313
314
315 static int sock_read(struct inode *inode, struct file *file, char *ubuf, int size)
316 {
317 struct socket *sock;
318 int err;
319
320 if (!(sock = socki_lookup(inode)))
321 {
322 printk("NET: sock_read: can't find socket for inode!\n");
323 return(-EBADF);
324 }
325 if (sock->flags & SO_ACCEPTCON)
326 return(-EINVAL);
327
328 if(size<0)
329 return -EINVAL;
330 if(size==0)
331 return 0;
332 if ((err=verify_area(VERIFY_WRITE,ubuf,size))<0)
333 return err;
334 return(sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)));
335 }
336
337
338
339
340
341
342 static int sock_write(struct inode *inode, struct file *file, char *ubuf, int size)
343 {
344 struct socket *sock;
345 int err;
346
347 if (!(sock = socki_lookup(inode)))
348 {
349 printk("NET: sock_write: can't find socket for inode!\n");
350 return(-EBADF);
351 }
352
353 if (sock->flags & SO_ACCEPTCON)
354 return(-EINVAL);
355
356 if(size<0)
357 return -EINVAL;
358 if(size==0)
359 return 0;
360
361 if ((err=verify_area(VERIFY_READ,ubuf,size))<0)
362 return err;
363 return(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));
364 }
365
366
367
368
369
370 static int sock_readdir(struct inode *inode, struct file *file, struct dirent *dirent,
371 int count)
372 {
373 return(-EBADF);
374 }
375
376
377
378
379
380
381 int sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
382 unsigned long arg)
383 {
384 struct socket *sock;
385
386 if (!(sock = socki_lookup(inode)))
387 {
388 printk("NET: sock_ioctl: can't find socket for inode!\n");
389 return(-EBADF);
390 }
391 return(sock->ops->ioctl(sock, cmd, arg));
392 }
393
394
395 static int sock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
396 {
397 struct socket *sock;
398
399 if (!(sock = socki_lookup(inode)))
400 {
401 printk("NET: sock_select: can't find socket for inode!\n");
402 return(0);
403 }
404
405
406
407
408
409 if (sock->ops && sock->ops->select)
410 return(sock->ops->select(sock, sel_type, wait));
411 return(0);
412 }
413
414
415 void sock_close(struct inode *inode, struct file *filp)
416 {
417 struct socket *sock;
418
419
420
421
422
423 if (!inode)
424 return;
425
426 if (!(sock = socki_lookup(inode)))
427 {
428 printk("NET: sock_close: can't find socket for inode!\n");
429 return;
430 }
431 sock_fasync(inode, filp, 0);
432 sock_release(sock);
433 }
434
435
436
437
438
439 static int sock_fasync(struct inode *inode, struct file *filp, int on)
440 {
441 struct fasync_struct *fa, *fna=NULL, **prev;
442 struct socket *sock;
443 unsigned long flags;
444
445 if (on)
446 {
447 fna=(struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
448 if(fna==NULL)
449 return -ENOMEM;
450 }
451
452 sock = socki_lookup(inode);
453
454 prev=&(sock->fasync_list);
455
456 save_flags(flags);
457 cli();
458
459 for(fa=*prev; fa!=NULL; prev=&fa->fa_next,fa=*prev)
460 if(fa->fa_file==filp)
461 break;
462
463 if(on)
464 {
465 if(fa!=NULL)
466 {
467 kfree_s(fna,sizeof(struct fasync_struct));
468 restore_flags(flags);
469 return 0;
470 }
471 fna->fa_file=filp;
472 fna->magic=FASYNC_MAGIC;
473 fna->fa_next=sock->fasync_list;
474 sock->fasync_list=fna;
475 }
476 else
477 {
478 if(fa!=NULL)
479 {
480 *prev=fa->fa_next;
481 kfree_s(fa,sizeof(struct fasync_struct));
482 }
483 }
484 restore_flags(flags);
485 return 0;
486 }
487
488 int sock_wake_async(struct socket *sock, int how)
489 {
490 if (!sock || !sock->fasync_list)
491 return -1;
492 switch (how)
493 {
494 case 0:
495 kill_fasync(sock->fasync_list, SIGIO);
496 break;
497 case 1:
498 if (!(sock->flags & SO_WAITDATA))
499 kill_fasync(sock->fasync_list, SIGIO);
500 break;
501 case 2:
502 if (sock->flags & SO_NOSPACE)
503 {
504 kill_fasync(sock->fasync_list, SIGIO);
505 sock->flags &= ~SO_NOSPACE;
506 }
507 break;
508 }
509 return 0;
510 }
511
512
513
514
515
516
517 int sock_awaitconn(struct socket *mysock, struct socket *servsock, int flags)
518 {
519 struct socket *last;
520
521
522
523
524 if (!(servsock->flags & SO_ACCEPTCON))
525 {
526 return(-EINVAL);
527 }
528
529
530
531
532
533 mysock->next = NULL;
534 cli();
535 if (!(last = servsock->iconn))
536 servsock->iconn = mysock;
537 else
538 {
539 while (last->next)
540 last = last->next;
541 last->next = mysock;
542 }
543 mysock->state = SS_CONNECTING;
544 mysock->conn = servsock;
545 sti();
546
547
548
549
550
551 wake_up_interruptible(servsock->wait);
552 sock_wake_async(servsock, 0);
553
554 if (mysock->state != SS_CONNECTED)
555 {
556 if (flags & O_NONBLOCK)
557 return -EINPROGRESS;
558
559 interruptible_sleep_on(mysock->wait);
560 if (mysock->state != SS_CONNECTED &&
561 mysock->state != SS_DISCONNECTING)
562 {
563
564
565
566
567
568
569
570 if (mysock->conn == servsock)
571 {
572 cli();
573 if ((last = servsock->iconn) == mysock)
574 servsock->iconn = mysock->next;
575 else
576 {
577 while (last->next != mysock)
578 last = last->next;
579 last->next = mysock->next;
580 }
581 sti();
582 }
583 return(mysock->conn ? -EINTR : -EACCES);
584 }
585 }
586 return(0);
587 }
588
589
590
591
592
593
594
595 static int sock_socket(int family, int type, int protocol)
596 {
597 int i, fd;
598 struct socket *sock;
599 struct proto_ops *ops;
600
601
602 for (i = 0; i < NPROTO; ++i)
603 {
604 if (pops[i] == NULL) continue;
605 if (pops[i]->family == family)
606 break;
607 }
608
609 if (i == NPROTO)
610 {
611 return -EINVAL;
612 }
613
614 ops = pops[i];
615
616
617
618
619
620
621
622 if ((type != SOCK_STREAM && type != SOCK_DGRAM &&
623 type != SOCK_SEQPACKET && type != SOCK_RAW &&
624 type != SOCK_PACKET) || protocol < 0)
625 return(-EINVAL);
626
627
628
629
630
631
632
633 if (!(sock = sock_alloc()))
634 {
635 printk("NET: sock_socket: no more sockets\n");
636 return(-ENOSR);
637
638 }
639
640 sock->type = type;
641 sock->ops = ops;
642 if ((i = sock->ops->create(sock, protocol)) < 0)
643 {
644 sock_release(sock);
645 return(i);
646 }
647
648 if ((fd = get_fd(SOCK_INODE(sock))) < 0)
649 {
650 sock_release(sock);
651 return(-EINVAL);
652 }
653
654 return(fd);
655 }
656
657
658
659
660
661 static int sock_socketpair(int family, int type, int protocol, unsigned long usockvec[2])
662 {
663 int fd1, fd2, i;
664 struct socket *sock1, *sock2;
665 int er;
666
667
668
669
670
671
672 if ((fd1 = sock_socket(family, type, protocol)) < 0)
673 return(fd1);
674 sock1 = sockfd_lookup(fd1, NULL);
675 if (!sock1->ops->socketpair)
676 {
677 sys_close(fd1);
678 return(-EINVAL);
679 }
680
681
682
683
684
685 if ((fd2 = sock_socket(family, type, protocol)) < 0)
686 {
687 sys_close(fd1);
688 return(-EINVAL);
689 }
690
691 sock2 = sockfd_lookup(fd2, NULL);
692 if ((i = sock1->ops->socketpair(sock1, sock2)) < 0)
693 {
694 sys_close(fd1);
695 sys_close(fd2);
696 return(i);
697 }
698
699 sock1->conn = sock2;
700 sock2->conn = sock1;
701 sock1->state = SS_CONNECTED;
702 sock2->state = SS_CONNECTED;
703
704 er=verify_area(VERIFY_WRITE, usockvec, 2 * sizeof(int));
705 if(er)
706 {
707 sys_close(fd1);
708 sys_close(fd2);
709 return er;
710 }
711 put_fs_long(fd1, &usockvec[0]);
712 put_fs_long(fd2, &usockvec[1]);
713
714 return(0);
715 }
716
717
718
719
720
721
722
723
724
725
726 static int sock_bind(int fd, struct sockaddr *umyaddr, int addrlen)
727 {
728 struct socket *sock;
729 int i;
730 char address[MAX_SOCK_ADDR];
731 int err;
732
733 if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
734 return(-EBADF);
735
736 if (!(sock = sockfd_lookup(fd, NULL)))
737 return(-ENOTSOCK);
738
739 if((err=move_addr_to_kernel(umyaddr,addrlen,address))<0)
740 return err;
741
742 if ((i = sock->ops->bind(sock, (struct sockaddr *)address, addrlen)) < 0)
743 {
744 return(i);
745 }
746 return(0);
747 }
748
749
750
751
752
753
754
755
756 static int sock_listen(int fd, int backlog)
757 {
758 struct socket *sock;
759
760 if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
761 return(-EBADF);
762 if (!(sock = sockfd_lookup(fd, NULL)))
763 return(-ENOTSOCK);
764
765 if (sock->state != SS_UNCONNECTED)
766 {
767 return(-EINVAL);
768 }
769
770 if (sock->ops && sock->ops->listen)
771 sock->ops->listen(sock, backlog);
772 sock->flags |= SO_ACCEPTCON;
773 return(0);
774 }
775
776
777
778
779
780
781
782
783
784
785 static int sock_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen)
786 {
787 struct file *file;
788 struct socket *sock, *newsock;
789 int i;
790 char address[MAX_SOCK_ADDR];
791 int len;
792
793 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
794 return(-EBADF);
795 if (!(sock = sockfd_lookup(fd, &file)))
796 return(-ENOTSOCK);
797 if (sock->state != SS_UNCONNECTED)
798 {
799 return(-EINVAL);
800 }
801 if (!(sock->flags & SO_ACCEPTCON))
802 {
803 return(-EINVAL);
804 }
805
806 if (!(newsock = sock_alloc()))
807 {
808 printk("NET: sock_accept: no more sockets\n");
809 return(-ENOSR);
810
811 }
812 newsock->type = sock->type;
813 newsock->ops = sock->ops;
814 if ((i = sock->ops->dup(newsock, sock)) < 0)
815 {
816 sock_release(newsock);
817 return(i);
818 }
819
820 i = newsock->ops->accept(sock, newsock, file->f_flags);
821 if ( i < 0)
822 {
823 sock_release(newsock);
824 return(i);
825 }
826
827 if ((fd = get_fd(SOCK_INODE(newsock))) < 0)
828 {
829 sock_release(newsock);
830 return(-EINVAL);
831 }
832
833 if (upeer_sockaddr)
834 {
835 newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
836 move_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
837 }
838 return(fd);
839 }
840
841
842
843
844
845
846
847 static int sock_connect(int fd, struct sockaddr *uservaddr, int addrlen)
848 {
849 struct socket *sock;
850 struct file *file;
851 int i;
852 char address[MAX_SOCK_ADDR];
853 int err;
854
855 if (fd < 0 || fd >= NR_OPEN || (file=current->files->fd[fd]) == NULL)
856 return(-EBADF);
857 if (!(sock = sockfd_lookup(fd, &file)))
858 return(-ENOTSOCK);
859
860 if((err=move_addr_to_kernel(uservaddr,addrlen,address))<0)
861 return err;
862
863 switch(sock->state)
864 {
865 case SS_UNCONNECTED:
866
867 break;
868 case SS_CONNECTED:
869
870 if(sock->type == SOCK_DGRAM)
871 break;
872 return -EISCONN;
873 case SS_CONNECTING:
874
875
876
877
878
879
880
881 break;
882 default:
883 return(-EINVAL);
884 }
885 i = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, file->f_flags);
886 if (i < 0)
887 {
888 return(i);
889 }
890 return(0);
891 }
892
893
894
895
896
897
898 static int sock_getsockname(int fd, struct sockaddr *usockaddr, int *usockaddr_len)
899 {
900 struct socket *sock;
901 char address[MAX_SOCK_ADDR];
902 int len;
903 int err;
904
905 if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
906 return(-EBADF);
907 if (!(sock = sockfd_lookup(fd, NULL)))
908 return(-ENOTSOCK);
909
910 err=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
911 if(err)
912 return err;
913 if((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
914 return err;
915 return 0;
916 }
917
918
919
920
921
922
923 static int sock_getpeername(int fd, struct sockaddr *usockaddr, int *usockaddr_len)
924 {
925 struct socket *sock;
926 char address[MAX_SOCK_ADDR];
927 int len;
928 int err;
929
930 if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
931 return(-EBADF);
932 if (!(sock = sockfd_lookup(fd, NULL)))
933 return(-ENOTSOCK);
934
935 err=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
936 if(err)
937 return err;
938 if((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
939 return err;
940 return 0;
941 }
942
943
944
945
946
947
948 static int sock_send(int fd, void * buff, int len, unsigned flags)
949 {
950 struct socket *sock;
951 struct file *file;
952 int err;
953
954 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
955 return(-EBADF);
956 if (!(sock = sockfd_lookup(fd, NULL)))
957 return(-ENOTSOCK);
958
959 if(len<0)
960 return -EINVAL;
961 err=verify_area(VERIFY_READ, buff, len);
962 if(err)
963 return err;
964 return(sock->ops->send(sock, buff, len, (file->f_flags & O_NONBLOCK), flags));
965 }
966
967
968
969
970
971
972
973 static int sock_sendto(int fd, void * buff, int len, unsigned flags,
974 struct sockaddr *addr, int addr_len)
975 {
976 struct socket *sock;
977 struct file *file;
978 char address[MAX_SOCK_ADDR];
979 int err;
980
981 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
982 return(-EBADF);
983 if (!(sock = sockfd_lookup(fd, NULL)))
984 return(-ENOTSOCK);
985
986 if(len<0)
987 return -EINVAL;
988 err=verify_area(VERIFY_READ,buff,len);
989 if(err)
990 return err;
991
992 if((err=move_addr_to_kernel(addr,addr_len,address))<0)
993 return err;
994
995 return(sock->ops->sendto(sock, buff, len, (file->f_flags & O_NONBLOCK),
996 flags, (struct sockaddr *)address, addr_len));
997 }
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008 static int sock_recv(int fd, void * buff, int len, unsigned flags)
1009 {
1010 struct socket *sock;
1011 struct file *file;
1012 int err;
1013
1014 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
1015 return(-EBADF);
1016
1017 if (!(sock = sockfd_lookup(fd, NULL)))
1018 return(-ENOTSOCK);
1019
1020 if(len<0)
1021 return -EINVAL;
1022 if(len==0)
1023 return 0;
1024 err=verify_area(VERIFY_WRITE, buff, len);
1025 if(err)
1026 return err;
1027
1028 return(sock->ops->recv(sock, buff, len,(file->f_flags & O_NONBLOCK), flags));
1029 }
1030
1031
1032
1033
1034
1035
1036
1037 static int sock_recvfrom(int fd, void * buff, int len, unsigned flags,
1038 struct sockaddr *addr, int *addr_len)
1039 {
1040 struct socket *sock;
1041 struct file *file;
1042 char address[MAX_SOCK_ADDR];
1043 int err;
1044 int alen;
1045 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
1046 return(-EBADF);
1047 if (!(sock = sockfd_lookup(fd, NULL)))
1048 return(-ENOTSOCK);
1049 if(len<0)
1050 return -EINVAL;
1051 if(len==0)
1052 return 0;
1053
1054 err=verify_area(VERIFY_WRITE,buff,len);
1055 if(err)
1056 return err;
1057
1058 len=sock->ops->recvfrom(sock, buff, len, (file->f_flags & O_NONBLOCK),
1059 flags, (struct sockaddr *)address, &alen);
1060
1061 if(len<0)
1062 return len;
1063 if(addr!=NULL && (err=move_addr_to_user(address,alen, addr, addr_len))<0)
1064 return err;
1065
1066 return len;
1067 }
1068
1069
1070
1071
1072
1073
1074 static int sock_setsockopt(int fd, int level, int optname, char *optval, int optlen)
1075 {
1076 struct socket *sock;
1077 struct file *file;
1078
1079 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
1080 return(-EBADF);
1081 if (!(sock = sockfd_lookup(fd, NULL)))
1082 return(-ENOTSOCK);
1083
1084 return(sock->ops->setsockopt(sock, level, optname, optval, optlen));
1085 }
1086
1087
1088
1089
1090
1091
1092 static int sock_getsockopt(int fd, int level, int optname, char *optval, int *optlen)
1093 {
1094 struct socket *sock;
1095 struct file *file;
1096
1097 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
1098 return(-EBADF);
1099 if (!(sock = sockfd_lookup(fd, NULL)))
1100 return(-ENOTSOCK);
1101
1102 if (!sock->ops || !sock->ops->getsockopt)
1103 return(0);
1104 return(sock->ops->getsockopt(sock, level, optname, optval, optlen));
1105 }
1106
1107
1108
1109
1110
1111
1112 static int sock_shutdown(int fd, int how)
1113 {
1114 struct socket *sock;
1115 struct file *file;
1116
1117 if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
1118 return(-EBADF);
1119 if (!(sock = sockfd_lookup(fd, NULL)))
1120 return(-ENOTSOCK);
1121
1122 return(sock->ops->shutdown(sock, how));
1123 }
1124
1125
1126
1127
1128
1129
1130 int sock_fcntl(struct file *filp, unsigned int cmd, unsigned long arg)
1131 {
1132 struct socket *sock;
1133
1134 sock = socki_lookup (filp->f_inode);
1135 if (sock != NULL && sock->ops != NULL && sock->ops->fcntl != NULL)
1136 return(sock->ops->fcntl(sock, cmd, arg));
1137 return(-EINVAL);
1138 }
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151 asmlinkage int sys_socketcall(int call, unsigned long *args)
1152 {
1153 int er;
1154 switch(call)
1155 {
1156 case SYS_SOCKET:
1157 er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
1158 if(er)
1159 return er;
1160 return(sock_socket(get_fs_long(args+0),
1161 get_fs_long(args+1),
1162 get_fs_long(args+2)));
1163 case SYS_BIND:
1164 er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
1165 if(er)
1166 return er;
1167 return(sock_bind(get_fs_long(args+0),
1168 (struct sockaddr *)get_fs_long(args+1),
1169 get_fs_long(args+2)));
1170 case SYS_CONNECT:
1171 er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
1172 if(er)
1173 return er;
1174 return(sock_connect(get_fs_long(args+0),
1175 (struct sockaddr *)get_fs_long(args+1),
1176 get_fs_long(args+2)));
1177 case SYS_LISTEN:
1178 er=verify_area(VERIFY_READ, args, 2 * sizeof(long));
1179 if(er)
1180 return er;
1181 return(sock_listen(get_fs_long(args+0),
1182 get_fs_long(args+1)));
1183 case SYS_ACCEPT:
1184 er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
1185 if(er)
1186 return er;
1187 return(sock_accept(get_fs_long(args+0),
1188 (struct sockaddr *)get_fs_long(args+1),
1189 (int *)get_fs_long(args+2)));
1190 case SYS_GETSOCKNAME:
1191 er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
1192 if(er)
1193 return er;
1194 return(sock_getsockname(get_fs_long(args+0),
1195 (struct sockaddr *)get_fs_long(args+1),
1196 (int *)get_fs_long(args+2)));
1197 case SYS_GETPEERNAME:
1198 er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
1199 if(er)
1200 return er;
1201 return(sock_getpeername(get_fs_long(args+0),
1202 (struct sockaddr *)get_fs_long(args+1),
1203 (int *)get_fs_long(args+2)));
1204 case SYS_SOCKETPAIR:
1205 er=verify_area(VERIFY_READ, args, 4 * sizeof(long));
1206 if(er)
1207 return er;
1208 return(sock_socketpair(get_fs_long(args+0),
1209 get_fs_long(args+1),
1210 get_fs_long(args+2),
1211 (unsigned long *)get_fs_long(args+3)));
1212 case SYS_SEND:
1213 er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));
1214 if(er)
1215 return er;
1216 return(sock_send(get_fs_long(args+0),
1217 (void *)get_fs_long(args+1),
1218 get_fs_long(args+2),
1219 get_fs_long(args+3)));
1220 case SYS_SENDTO:
1221 er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));
1222 if(er)
1223 return er;
1224 return(sock_sendto(get_fs_long(args+0),
1225 (void *)get_fs_long(args+1),
1226 get_fs_long(args+2),
1227 get_fs_long(args+3),
1228 (struct sockaddr *)get_fs_long(args+4),
1229 get_fs_long(args+5)));
1230 case SYS_RECV:
1231 er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));
1232 if(er)
1233 return er;
1234 return(sock_recv(get_fs_long(args+0),
1235 (void *)get_fs_long(args+1),
1236 get_fs_long(args+2),
1237 get_fs_long(args+3)));
1238 case SYS_RECVFROM:
1239 er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));
1240 if(er)
1241 return er;
1242 return(sock_recvfrom(get_fs_long(args+0),
1243 (void *)get_fs_long(args+1),
1244 get_fs_long(args+2),
1245 get_fs_long(args+3),
1246 (struct sockaddr *)get_fs_long(args+4),
1247 (int *)get_fs_long(args+5)));
1248 case SYS_SHUTDOWN:
1249 er=verify_area(VERIFY_READ, args, 2* sizeof(unsigned long));
1250 if(er)
1251 return er;
1252 return(sock_shutdown(get_fs_long(args+0),
1253 get_fs_long(args+1)));
1254 case SYS_SETSOCKOPT:
1255 er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));
1256 if(er)
1257 return er;
1258 return(sock_setsockopt(get_fs_long(args+0),
1259 get_fs_long(args+1),
1260 get_fs_long(args+2),
1261 (char *)get_fs_long(args+3),
1262 get_fs_long(args+4)));
1263 case SYS_GETSOCKOPT:
1264 er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));
1265 if(er)
1266 return er;
1267 return(sock_getsockopt(get_fs_long(args+0),
1268 get_fs_long(args+1),
1269 get_fs_long(args+2),
1270 (char *)get_fs_long(args+3),
1271 (int *)get_fs_long(args+4)));
1272 default:
1273 return(-EINVAL);
1274 }
1275 }
1276
1277
1278
1279
1280
1281
1282
1283 int sock_register(int family, struct proto_ops *ops)
1284 {
1285 int i;
1286
1287 cli();
1288 for(i = 0; i < NPROTO; i++)
1289 {
1290 if (pops[i] != NULL)
1291 continue;
1292 pops[i] = ops;
1293 pops[i]->family = family;
1294 sti();
1295 return(i);
1296 }
1297 sti();
1298 return(-ENOMEM);
1299 }
1300
1301
1302
1303
1304
1305
1306
1307 int sock_unregister(int family)
1308 {
1309 int i;
1310
1311 cli();
1312 for(i = 0; i < NPROTO; i++)
1313 {
1314 if (pops[i] == NULL)
1315 continue;
1316 if(pops[i]->family == family)
1317 {
1318 pops[i]=NULL;
1319 sti();
1320 return(i);
1321 }
1322 }
1323 sti();
1324 return(-ENOENT);
1325 }
1326
1327 void proto_init(void)
1328 {
1329 extern struct net_proto protocols[];
1330 struct net_proto *pro;
1331
1332
1333 pro = protocols;
1334 while (pro->name != NULL)
1335 {
1336 (*pro->init_func)(pro);
1337 pro++;
1338 }
1339
1340 }
1341
1342
1343 void sock_init(void)
1344 {
1345 int i;
1346
1347 printk("Swansea University Computer Society NET3.019\n");
1348
1349
1350
1351
1352
1353 for (i = 0; i < NPROTO; ++i) pops[i] = NULL;
1354
1355
1356
1357
1358
1359 proto_init();
1360
1361 #ifdef CONFIG_NET
1362
1363
1364
1365
1366 dev_init();
1367
1368
1369
1370
1371
1372 bh_base[NET_BH].routine= net_bh;
1373 #endif
1374 }
1375
1376 int socket_get_info(char *buffer, char **start, off_t offset, int length)
1377 {
1378 int len = sprintf(buffer, "sockets: used %d\n", sockets_in_use);
1379 if (offset >= len)
1380 {
1381 *start = buffer;
1382 return 0;
1383 }
1384 *start = buffer + offset;
1385 len -= offset;
1386 if (len > length)
1387 len = length;
1388 return len;
1389 }