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