1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Generic socket support routines. Memory allocators, socket lock/release 7 * handler for protocols to use and generic option handler. 8 * 9 * 10 * Version: $Id: sock.c,v 1.117 2002/02/01 22:01:03 davem Exp $ 11 * 12 * Authors: Ross Biro 13 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 14 * Florian La Roche, <flla@stud.uni-sb.de> 15 * Alan Cox, <A.Cox@swansea.ac.uk> 16 * 17 * Fixes: 18 * Alan Cox : Numerous verify_area() problems 19 * Alan Cox : Connecting on a connecting socket 20 * now returns an error for tcp. 21 * Alan Cox : sock->protocol is set correctly. 22 * and is not sometimes left as 0. 23 * Alan Cox : connect handles icmp errors on a 24 * connect properly. Unfortunately there 25 * is a restart syscall nasty there. I 26 * can't match BSD without hacking the C 27 * library. Ideas urgently sought! 28 * Alan Cox : Disallow bind() to addresses that are 29 * not ours - especially broadcast ones!! 30 * Alan Cox : Socket 1024 _IS_ ok for users. (fencepost) 31 * Alan Cox : sock_wfree/sock_rfree don't destroy sockets, 32 * instead they leave that for the DESTROY timer. 33 * Alan Cox : Clean up error flag in accept 34 * Alan Cox : TCP ack handling is buggy, the DESTROY timer 35 * was buggy. Put a remove_sock() in the handler 36 * for memory when we hit 0. Also altered the timer 37 * code. The ACK stuff can wait and needs major 38 * TCP layer surgery. 39 * Alan Cox : Fixed TCP ack bug, removed remove sock 40 * and fixed timer/inet_bh race. 41 * Alan Cox : Added zapped flag for TCP 42 * Alan Cox : Move kfree_skb into skbuff.c and tidied up surplus code 43 * Alan Cox : for new sk_buff allocations wmalloc/rmalloc now call alloc_skb 44 * Alan Cox : kfree_s calls now are kfree_skbmem so we can track skb resources 45 * Alan Cox : Supports socket option broadcast now as does udp. Packet and raw need fixing. 46 * Alan Cox : Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so... 47 * Rick Sladkey : Relaxed UDP rules for matching packets. 48 * C.E.Hawkins : IFF_PROMISC/SIOCGHWADDR support 49 * Pauline Middelink : identd support 50 * Alan Cox : Fixed connect() taking signals I think. 51 * Alan Cox : SO_LINGER supported 52 * Alan Cox : Error reporting fixes 53 * Anonymous : inet_create tidied up (sk->reuse setting) 54 * Alan Cox : inet sockets don't set sk->type! 55 * Alan Cox : Split socket option code 56 * Alan Cox : Callbacks 57 * Alan Cox : Nagle flag for Charles & Johannes stuff 58 * Alex : Removed restriction on inet fioctl 59 * Alan Cox : Splitting INET from NET core 60 * Alan Cox : Fixed bogus SO_TYPE handling in getsockopt() 61 * Adam Caldwell : Missing return in SO_DONTROUTE/SO_DEBUG code 62 * Alan Cox : Split IP from generic code 63 * Alan Cox : New kfree_skbmem() 64 * Alan Cox : Make SO_DEBUG superuser only. 65 * Alan Cox : Allow anyone to clear SO_DEBUG 66 * (compatibility fix) 67 * Alan Cox : Added optimistic memory grabbing for AF_UNIX throughput. 68 * Alan Cox : Allocator for a socket is settable. 69 * Alan Cox : SO_ERROR includes soft errors. 70 * Alan Cox : Allow NULL arguments on some SO_ opts 71 * Alan Cox : Generic socket allocation to make hooks 72 * easier (suggested by Craig Metz). 73 * Michael Pall : SO_ERROR returns positive errno again 74 * Steve Whitehouse: Added default destructor to free 75 * protocol private data. 76 * Steve Whitehouse: Added various other default routines 77 * common to several socket families. 78 * Chris Evans : Call suser() check last on F_SETOWN 79 * Jay Schulist : Added SO_ATTACH_FILTER and SO_DETACH_FILTER. 80 * Andi Kleen : Add sock_kmalloc()/sock_kfree_s() 81 * Andi Kleen : Fix write_space callback 82 * Chris Evans : Security fixes - signedness again 83 * Arnaldo C. Melo : cleanups, use skb_queue_purge 84 * 85 * To Fix: 86 * 87 * 88 * This program is free software; you can redistribute it and/or 89 * modify it under the terms of the GNU General Public License 90 * as published by the Free Software Foundation; either version 91 * 2 of the License, or (at your option) any later version. 92 */ 93 94 #include <linux/capability.h> 95 #include <linux/config.h> 96 #include <linux/errno.h> 97 #include <linux/types.h> 98 #include <linux/socket.h> 99 #include <linux/in.h> 100 #include <linux/kernel.h> 101 #include <linux/module.h> 102 #include <linux/proc_fs.h> 103 #include <linux/seq_file.h> 104 #include <linux/sched.h> 105 #include <linux/timer.h> 106 #include <linux/string.h> 107 #include <linux/sockios.h> 108 #include <linux/net.h> 109 #include <linux/mm.h> 110 #include <linux/slab.h> 111 #include <linux/interrupt.h> 112 #include <linux/poll.h> 113 #include <linux/tcp.h> 114 #include <linux/init.h> 115 116 #include <asm/uaccess.h> 117 #include <asm/system.h> 118 119 #include <linux/netdevice.h> 120 #include <net/protocol.h> 121 #include <linux/skbuff.h> 122 #include <net/request_sock.h> 123 #include <net/sock.h> 124 #include <net/xfrm.h> 125 #include <linux/ipsec.h> 126 127 #include <linux/filter.h> 128 129 #ifdef CONFIG_INET 130 #include <net/tcp.h> 131 #endif 132 133 /* Take into consideration the size of the struct sk_buff overhead in the 134 * determination of these values, since that is non-constant across 135 * platforms. This makes socket queueing behavior and performance 136 * not depend upon such differences. 137 */ 138 #define _SK_MEM_PACKETS 256 139 #define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256) 140 #define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS) 141 #define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS) 142 143 /* Run time adjustable parameters. */ 144 __u32 sysctl_wmem_max = SK_WMEM_MAX; 145 __u32 sysctl_rmem_max = SK_RMEM_MAX; 146 __u32 sysctl_wmem_default = SK_WMEM_MAX; 147 __u32 sysctl_rmem_default = SK_RMEM_MAX; 148 149 /* Maximal space eaten by iovec or ancilliary data plus some space */ 150 int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512); 151 152 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen) 153 { 154 struct timeval tv; 155 156 if (optlen < sizeof(tv)) 157 return -EINVAL; 158 if (copy_from_user(&tv, optval, sizeof(tv))) 159 return -EFAULT; 160 161 *timeo_p = MAX_SCHEDULE_TIMEOUT; 162 if (tv.tv_sec == 0 && tv.tv_usec == 0) 163 return 0; 164 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1)) 165 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ); 166 return 0; 167 } 168 169 static void sock_warn_obsolete_bsdism(const char *name) 170 { 171 static int warned; 172 static char warncomm[TASK_COMM_LEN]; 173 if (strcmp(warncomm, current->comm) && warned < 5) { 174 strcpy(warncomm, current->comm); 175 printk(KERN_WARNING "process `%s' is using obsolete " 176 "%s SO_BSDCOMPAT\n", warncomm, name); 177 warned++; 178 } 179 } 180 181 static void sock_disable_timestamp(struct sock *sk) 182 { 183 if (sock_flag(sk, SOCK_TIMESTAMP)) { 184 sock_reset_flag(sk, SOCK_TIMESTAMP); 185 net_disable_timestamp(); 186 } 187 } 188 189 190 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) 191 { 192 int err = 0; 193 int skb_len; 194 195 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces 196 number of warnings when compiling with -W --ANK 197 */ 198 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >= 199 (unsigned)sk->sk_rcvbuf) { 200 err = -ENOMEM; 201 goto out; 202 } 203 204 /* It would be deadlock, if sock_queue_rcv_skb is used 205 with socket lock! We assume that users of this 206 function are lock free. 207 */ 208 err = sk_filter(sk, skb, 1); 209 if (err) 210 goto out; 211 212 skb->dev = NULL; 213 skb_set_owner_r(skb, sk); 214 215 /* Cache the SKB length before we tack it onto the receive 216 * queue. Once it is added it no longer belongs to us and 217 * may be freed by other threads of control pulling packets 218 * from the queue. 219 */ 220 skb_len = skb->len; 221 222 skb_queue_tail(&sk->sk_receive_queue, skb); 223 224 if (!sock_flag(sk, SOCK_DEAD)) 225 sk->sk_data_ready(sk, skb_len); 226 out: 227 return err; 228 } 229 EXPORT_SYMBOL(sock_queue_rcv_skb); 230 231 int sk_receive_skb(struct sock *sk, struct sk_buff *skb) 232 { 233 int rc = NET_RX_SUCCESS; 234 235 if (sk_filter(sk, skb, 0)) 236 goto discard_and_relse; 237 238 skb->dev = NULL; 239 240 bh_lock_sock(sk); 241 if (!sock_owned_by_user(sk)) 242 rc = sk->sk_backlog_rcv(sk, skb); 243 else 244 sk_add_backlog(sk, skb); 245 bh_unlock_sock(sk); 246 out: 247 sock_put(sk); 248 return rc; 249 discard_and_relse: 250 kfree_skb(skb); 251 goto out; 252 } 253 EXPORT_SYMBOL(sk_receive_skb); 254 255 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie) 256 { 257 struct dst_entry *dst = sk->sk_dst_cache; 258 259 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) { 260 sk->sk_dst_cache = NULL; 261 dst_release(dst); 262 return NULL; 263 } 264 265 return dst; 266 } 267 EXPORT_SYMBOL(__sk_dst_check); 268 269 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie) 270 { 271 struct dst_entry *dst = sk_dst_get(sk); 272 273 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) { 274 sk_dst_reset(sk); 275 dst_release(dst); 276 return NULL; 277 } 278 279 return dst; 280 } 281 EXPORT_SYMBOL(sk_dst_check); 282 283 /* 284 * This is meant for all protocols to use and covers goings on 285 * at the socket level. Everything here is generic. 286 */ 287 288 int sock_setsockopt(struct socket *sock, int level, int optname, 289 char __user *optval, int optlen) 290 { 291 struct sock *sk=sock->sk; 292 struct sk_filter *filter; 293 int val; 294 int valbool; 295 struct linger ling; 296 int ret = 0; 297 298 /* 299 * Options without arguments 300 */ 301 302 #ifdef SO_DONTLINGER /* Compatibility item... */ 303 if (optname == SO_DONTLINGER) { 304 lock_sock(sk); 305 sock_reset_flag(sk, SOCK_LINGER); 306 release_sock(sk); 307 return 0; 308 } 309 #endif 310 311 if(optlen<sizeof(int)) 312 return(-EINVAL); 313 314 if (get_user(val, (int __user *)optval)) 315 return -EFAULT; 316 317 valbool = val?1:0; 318 319 lock_sock(sk); 320 321 switch(optname) 322 { 323 case SO_DEBUG: 324 if(val && !capable(CAP_NET_ADMIN)) 325 { 326 ret = -EACCES; 327 } 328 else if (valbool) 329 sock_set_flag(sk, SOCK_DBG); 330 else 331 sock_reset_flag(sk, SOCK_DBG); 332 break; 333 case SO_REUSEADDR: 334 sk->sk_reuse = valbool; 335 break; 336 case SO_TYPE: 337 case SO_ERROR: 338 ret = -ENOPROTOOPT; 339 break; 340 case SO_DONTROUTE: 341 if (valbool) 342 sock_set_flag(sk, SOCK_LOCALROUTE); 343 else 344 sock_reset_flag(sk, SOCK_LOCALROUTE); 345 break; 346 case SO_BROADCAST: 347 sock_valbool_flag(sk, SOCK_BROADCAST, valbool); 348 break; 349 case SO_SNDBUF: 350 /* Don't error on this BSD doesn't and if you think 351 about it this is right. Otherwise apps have to 352 play 'guess the biggest size' games. RCVBUF/SNDBUF 353 are treated in BSD as hints */ 354 355 if (val > sysctl_wmem_max) 356 val = sysctl_wmem_max; 357 set_sndbuf: 358 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 359 if ((val * 2) < SOCK_MIN_SNDBUF) 360 sk->sk_sndbuf = SOCK_MIN_SNDBUF; 361 else 362 sk->sk_sndbuf = val * 2; 363 364 /* 365 * Wake up sending tasks if we 366 * upped the value. 367 */ 368 sk->sk_write_space(sk); 369 break; 370 371 case SO_SNDBUFFORCE: 372 if (!capable(CAP_NET_ADMIN)) { 373 ret = -EPERM; 374 break; 375 } 376 goto set_sndbuf; 377 378 case SO_RCVBUF: 379 /* Don't error on this BSD doesn't and if you think 380 about it this is right. Otherwise apps have to 381 play 'guess the biggest size' games. RCVBUF/SNDBUF 382 are treated in BSD as hints */ 383 384 if (val > sysctl_rmem_max) 385 val = sysctl_rmem_max; 386 set_rcvbuf: 387 sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 388 /* 389 * We double it on the way in to account for 390 * "struct sk_buff" etc. overhead. Applications 391 * assume that the SO_RCVBUF setting they make will 392 * allow that much actual data to be received on that 393 * socket. 394 * 395 * Applications are unaware that "struct sk_buff" and 396 * other overheads allocate from the receive buffer 397 * during socket buffer allocation. 398 * 399 * And after considering the possible alternatives, 400 * returning the value we actually used in getsockopt 401 * is the most desirable behavior. 402 */ 403 if ((val * 2) < SOCK_MIN_RCVBUF) 404 sk->sk_rcvbuf = SOCK_MIN_RCVBUF; 405 else 406 sk->sk_rcvbuf = val * 2; 407 break; 408 409 case SO_RCVBUFFORCE: 410 if (!capable(CAP_NET_ADMIN)) { 411 ret = -EPERM; 412 break; 413 } 414 goto set_rcvbuf; 415 416 case SO_KEEPALIVE: 417 #ifdef CONFIG_INET 418 if (sk->sk_protocol == IPPROTO_TCP) 419 tcp_set_keepalive(sk, valbool); 420 #endif 421 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool); 422 break; 423 424 case SO_OOBINLINE: 425 sock_valbool_flag(sk, SOCK_URGINLINE, valbool); 426 break; 427 428 case SO_NO_CHECK: 429 sk->sk_no_check = valbool; 430 break; 431 432 case SO_PRIORITY: 433 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN)) 434 sk->sk_priority = val; 435 else 436 ret = -EPERM; 437 break; 438 439 case SO_LINGER: 440 if(optlen<sizeof(ling)) { 441 ret = -EINVAL; /* 1003.1g */ 442 break; 443 } 444 if (copy_from_user(&ling,optval,sizeof(ling))) { 445 ret = -EFAULT; 446 break; 447 } 448 if (!ling.l_onoff) 449 sock_reset_flag(sk, SOCK_LINGER); 450 else { 451 #if (BITS_PER_LONG == 32) 452 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ) 453 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT; 454 else 455 #endif 456 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ; 457 sock_set_flag(sk, SOCK_LINGER); 458 } 459 break; 460 461 case SO_BSDCOMPAT: 462 sock_warn_obsolete_bsdism("setsockopt"); 463 break; 464 465 case SO_PASSCRED: 466 if (valbool) 467 set_bit(SOCK_PASSCRED, &sock->flags); 468 else 469 clear_bit(SOCK_PASSCRED, &sock->flags); 470 break; 471 472 case SO_TIMESTAMP: 473 if (valbool) { 474 sock_set_flag(sk, SOCK_RCVTSTAMP); 475 sock_enable_timestamp(sk); 476 } else 477 sock_reset_flag(sk, SOCK_RCVTSTAMP); 478 break; 479 480 case SO_RCVLOWAT: 481 if (val < 0) 482 val = INT_MAX; 483 sk->sk_rcvlowat = val ? : 1; 484 break; 485 486 case SO_RCVTIMEO: 487 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen); 488 break; 489 490 case SO_SNDTIMEO: 491 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen); 492 break; 493 494 #ifdef CONFIG_NETDEVICES 495 case SO_BINDTODEVICE: 496 { 497 char devname[IFNAMSIZ]; 498 499 /* Sorry... */ 500 if (!capable(CAP_NET_RAW)) { 501 ret = -EPERM; 502 break; 503 } 504 505 /* Bind this socket to a particular device like "eth0", 506 * as specified in the passed interface name. If the 507 * name is "" or the option length is zero the socket 508 * is not bound. 509 */ 510 511 if (!valbool) { 512 sk->sk_bound_dev_if = 0; 513 } else { 514 if (optlen > IFNAMSIZ - 1) 515 optlen = IFNAMSIZ - 1; 516 memset(devname, 0, sizeof(devname)); 517 if (copy_from_user(devname, optval, optlen)) { 518 ret = -EFAULT; 519 break; 520 } 521 522 /* Remove any cached route for this socket. */ 523 sk_dst_reset(sk); 524 525 if (devname[0] == '\0') { 526 sk->sk_bound_dev_if = 0; 527 } else { 528 struct net_device *dev = dev_get_by_name(devname); 529 if (!dev) { 530 ret = -ENODEV; 531 break; 532 } 533 sk->sk_bound_dev_if = dev->ifindex; 534 dev_put(dev); 535 } 536 } 537 break; 538 } 539 #endif 540 541 542 case SO_ATTACH_FILTER: 543 ret = -EINVAL; 544 if (optlen == sizeof(struct sock_fprog)) { 545 struct sock_fprog fprog; 546 547 ret = -EFAULT; 548 if (copy_from_user(&fprog, optval, sizeof(fprog))) 549 break; 550 551 ret = sk_attach_filter(&fprog, sk); 552 } 553 break; 554 555 case SO_DETACH_FILTER: 556 spin_lock_bh(&sk->sk_lock.slock); 557 filter = sk->sk_filter; 558 if (filter) { 559 sk->sk_filter = NULL; 560 spin_unlock_bh(&sk->sk_lock.slock); 561 sk_filter_release(sk, filter); 562 break; 563 } 564 spin_unlock_bh(&sk->sk_lock.slock); 565 ret = -ENONET; 566 break; 567 568 case SO_PASSSEC: 569 if (valbool) 570 set_bit(SOCK_PASSSEC, &sock->flags); 571 else 572 clear_bit(SOCK_PASSSEC, &sock->flags); 573 break; 574 575 /* We implement the SO_SNDLOWAT etc to 576 not be settable (1003.1g 5.3) */ 577 default: 578 ret = -ENOPROTOOPT; 579 break; 580 } 581 release_sock(sk); 582 return ret; 583 } 584 585 586 int sock_getsockopt(struct socket *sock, int level, int optname, 587 char __user *optval, int __user *optlen) 588 { 589 struct sock *sk = sock->sk; 590 591 union 592 { 593 int val; 594 struct linger ling; 595 struct timeval tm; 596 } v; 597 598 unsigned int lv = sizeof(int); 599 int len; 600 601 if(get_user(len,optlen)) 602 return -EFAULT; 603 if(len < 0) 604 return -EINVAL; 605 606 switch(optname) 607 { 608 case SO_DEBUG: 609 v.val = sock_flag(sk, SOCK_DBG); 610 break; 611 612 case SO_DONTROUTE: 613 v.val = sock_flag(sk, SOCK_LOCALROUTE); 614 break; 615 616 case SO_BROADCAST: 617 v.val = !!sock_flag(sk, SOCK_BROADCAST); 618 break; 619 620 case SO_SNDBUF: 621 v.val = sk->sk_sndbuf; 622 break; 623 624 case SO_RCVBUF: 625 v.val = sk->sk_rcvbuf; 626 break; 627 628 case SO_REUSEADDR: 629 v.val = sk->sk_reuse; 630 break; 631 632 case SO_KEEPALIVE: 633 v.val = !!sock_flag(sk, SOCK_KEEPOPEN); 634 break; 635 636 case SO_TYPE: 637 v.val = sk->sk_type; 638 break; 639 640 case SO_ERROR: 641 v.val = -sock_error(sk); 642 if(v.val==0) 643 v.val = xchg(&sk->sk_err_soft, 0); 644 break; 645 646 case SO_OOBINLINE: 647 v.val = !!sock_flag(sk, SOCK_URGINLINE); 648 break; 649 650 case SO_NO_CHECK: 651 v.val = sk->sk_no_check; 652 break; 653 654 case SO_PRIORITY: 655 v.val = sk->sk_priority; 656 break; 657 658 case SO_LINGER: 659 lv = sizeof(v.ling); 660 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER); 661 v.ling.l_linger = sk->sk_lingertime / HZ; 662 break; 663 664 case SO_BSDCOMPAT: 665 sock_warn_obsolete_bsdism("getsockopt"); 666 break; 667 668 case SO_TIMESTAMP: 669 v.val = sock_flag(sk, SOCK_RCVTSTAMP); 670 break; 671 672 case SO_RCVTIMEO: 673 lv=sizeof(struct timeval); 674 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) { 675 v.tm.tv_sec = 0; 676 v.tm.tv_usec = 0; 677 } else { 678 v.tm.tv_sec = sk->sk_rcvtimeo / HZ; 679 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ; 680 } 681 break; 682 683 case SO_SNDTIMEO: 684 lv=sizeof(struct timeval); 685 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) { 686 v.tm.tv_sec = 0; 687 v.tm.tv_usec = 0; 688 } else { 689 v.tm.tv_sec = sk->sk_sndtimeo / HZ; 690 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ; 691 } 692 break; 693 694 case SO_RCVLOWAT: 695 v.val = sk->sk_rcvlowat; 696 break; 697 698 case SO_SNDLOWAT: 699 v.val=1; 700 break; 701 702 case SO_PASSCRED: 703 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0; 704 break; 705 706 case SO_PEERCRED: 707 if (len > sizeof(sk->sk_peercred)) 708 len = sizeof(sk->sk_peercred); 709 if (copy_to_user(optval, &sk->sk_peercred, len)) 710 return -EFAULT; 711 goto lenout; 712 713 case SO_PEERNAME: 714 { 715 char address[128]; 716 717 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2)) 718 return -ENOTCONN; 719 if (lv < len) 720 return -EINVAL; 721 if (copy_to_user(optval, address, len)) 722 return -EFAULT; 723 goto lenout; 724 } 725 726 /* Dubious BSD thing... Probably nobody even uses it, but 727 * the UNIX standard wants it for whatever reason... -DaveM 728 */ 729 case SO_ACCEPTCONN: 730 v.val = sk->sk_state == TCP_LISTEN; 731 break; 732 733 case SO_PASSSEC: 734 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0; 735 break; 736 737 case SO_PEERSEC: 738 return security_socket_getpeersec_stream(sock, optval, optlen, len); 739 740 default: 741 return(-ENOPROTOOPT); 742 } 743 if (len > lv) 744 len = lv; 745 if (copy_to_user(optval, &v, len)) 746 return -EFAULT; 747 lenout: 748 if (put_user(len, optlen)) 749 return -EFAULT; 750 return 0; 751 } 752 753 /** 754 * sk_alloc - All socket objects are allocated here 755 * @family: protocol family 756 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc) 757 * @prot: struct proto associated with this new sock instance 758 * @zero_it: if we should zero the newly allocated sock 759 */ 760 struct sock *sk_alloc(int family, gfp_t priority, 761 struct proto *prot, int zero_it) 762 { 763 struct sock *sk = NULL; 764 kmem_cache_t *slab = prot->slab; 765 766 if (slab != NULL) 767 sk = kmem_cache_alloc(slab, priority); 768 else 769 sk = kmalloc(prot->obj_size, priority); 770 771 if (sk) { 772 if (zero_it) { 773 memset(sk, 0, prot->obj_size); 774 sk->sk_family = family; 775 /* 776 * See comment in struct sock definition to understand 777 * why we need sk_prot_creator -acme 778 */ 779 sk->sk_prot = sk->sk_prot_creator = prot; 780 sock_lock_init(sk); 781 } 782 783 if (security_sk_alloc(sk, family, priority)) 784 goto out_free; 785 786 if (!try_module_get(prot->owner)) 787 goto out_free; 788 } 789 return sk; 790 791 out_free: 792 if (slab != NULL) 793 kmem_cache_free(slab, sk); 794 else 795 kfree(sk); 796 return NULL; 797 } 798 799 void sk_free(struct sock *sk) 800 { 801 struct sk_filter *filter; 802 struct module *owner = sk->sk_prot_creator->owner; 803 804 if (sk->sk_destruct) 805 sk->sk_destruct(sk); 806 807 filter = sk->sk_filter; 808 if (filter) { 809 sk_filter_release(sk, filter); 810 sk->sk_filter = NULL; 811 } 812 813 sock_disable_timestamp(sk); 814 815 if (atomic_read(&sk->sk_omem_alloc)) 816 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n", 817 __FUNCTION__, atomic_read(&sk->sk_omem_alloc)); 818 819 security_sk_free(sk); 820 if (sk->sk_prot_creator->slab != NULL) 821 kmem_cache_free(sk->sk_prot_creator->slab, sk); 822 else 823 kfree(sk); 824 module_put(owner); 825 } 826 827 struct sock *sk_clone(const struct sock *sk, const gfp_t priority) 828 { 829 struct sock *newsk = sk_alloc(sk->sk_family, priority, sk->sk_prot, 0); 830 831 if (newsk != NULL) { 832 struct sk_filter *filter; 833 834 memcpy(newsk, sk, sk->sk_prot->obj_size); 835 836 /* SANITY */ 837 sk_node_init(&newsk->sk_node); 838 sock_lock_init(newsk); 839 bh_lock_sock(newsk); 840 841 atomic_set(&newsk->sk_rmem_alloc, 0); 842 atomic_set(&newsk->sk_wmem_alloc, 0); 843 atomic_set(&newsk->sk_omem_alloc, 0); 844 skb_queue_head_init(&newsk->sk_receive_queue); 845 skb_queue_head_init(&newsk->sk_write_queue); 846 #ifdef CONFIG_NET_DMA 847 skb_queue_head_init(&newsk->sk_async_wait_queue); 848 #endif 849 850 rwlock_init(&newsk->sk_dst_lock); 851 rwlock_init(&newsk->sk_callback_lock); 852 853 newsk->sk_dst_cache = NULL; 854 newsk->sk_wmem_queued = 0; 855 newsk->sk_forward_alloc = 0; 856 newsk->sk_send_head = NULL; 857 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL; 858 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK; 859 860 sock_reset_flag(newsk, SOCK_DONE); 861 skb_queue_head_init(&newsk->sk_error_queue); 862 863 filter = newsk->sk_filter; 864 if (filter != NULL) 865 sk_filter_charge(newsk, filter); 866 867 if (unlikely(xfrm_sk_clone_policy(newsk))) { 868 /* It is still raw copy of parent, so invalidate 869 * destructor and make plain sk_free() */ 870 newsk->sk_destruct = NULL; 871 sk_free(newsk); 872 newsk = NULL; 873 goto out; 874 } 875 876 newsk->sk_err = 0; 877 newsk->sk_priority = 0; 878 atomic_set(&newsk->sk_refcnt, 2); 879 880 /* 881 * Increment the counter in the same struct proto as the master 882 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that 883 * is the same as sk->sk_prot->socks, as this field was copied 884 * with memcpy). 885 * 886 * This _changes_ the previous behaviour, where 887 * tcp_create_openreq_child always was incrementing the 888 * equivalent to tcp_prot->socks (inet_sock_nr), so this have 889 * to be taken into account in all callers. -acme 890 */ 891 sk_refcnt_debug_inc(newsk); 892 newsk->sk_socket = NULL; 893 newsk->sk_sleep = NULL; 894 895 if (newsk->sk_prot->sockets_allocated) 896 atomic_inc(newsk->sk_prot->sockets_allocated); 897 } 898 out: 899 return newsk; 900 } 901 902 EXPORT_SYMBOL_GPL(sk_clone); 903 904 void __init sk_init(void) 905 { 906 if (num_physpages <= 4096) { 907 sysctl_wmem_max = 32767; 908 sysctl_rmem_max = 32767; 909 sysctl_wmem_default = 32767; 910 sysctl_rmem_default = 32767; 911 } else if (num_physpages >= 131072) { 912 sysctl_wmem_max = 131071; 913 sysctl_rmem_max = 131071; 914 } 915 } 916 917 /* 918 * Simple resource managers for sockets. 919 */ 920 921 922 /* 923 * Write buffer destructor automatically called from kfree_skb. 924 */ 925 void sock_wfree(struct sk_buff *skb) 926 { 927 struct sock *sk = skb->sk; 928 929 /* In case it might be waiting for more memory. */ 930 atomic_sub(skb->truesize, &sk->sk_wmem_alloc); 931 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) 932 sk->sk_write_space(sk); 933 sock_put(sk); 934 } 935 936 /* 937 * Read buffer destructor automatically called from kfree_skb. 938 */ 939 void sock_rfree(struct sk_buff *skb) 940 { 941 struct sock *sk = skb->sk; 942 943 atomic_sub(skb->truesize, &sk->sk_rmem_alloc); 944 } 945 946 947 int sock_i_uid(struct sock *sk) 948 { 949 int uid; 950 951 read_lock(&sk->sk_callback_lock); 952 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0; 953 read_unlock(&sk->sk_callback_lock); 954 return uid; 955 } 956 957 unsigned long sock_i_ino(struct sock *sk) 958 { 959 unsigned long ino; 960 961 read_lock(&sk->sk_callback_lock); 962 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0; 963 read_unlock(&sk->sk_callback_lock); 964 return ino; 965 } 966 967 /* 968 * Allocate a skb from the socket's send buffer. 969 */ 970 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, 971 gfp_t priority) 972 { 973 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) { 974 struct sk_buff * skb = alloc_skb(size, priority); 975 if (skb) { 976 skb_set_owner_w(skb, sk); 977 return skb; 978 } 979 } 980 return NULL; 981 } 982 983 /* 984 * Allocate a skb from the socket's receive buffer. 985 */ 986 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, 987 gfp_t priority) 988 { 989 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) { 990 struct sk_buff *skb = alloc_skb(size, priority); 991 if (skb) { 992 skb_set_owner_r(skb, sk); 993 return skb; 994 } 995 } 996 return NULL; 997 } 998 999 /* 1000 * Allocate a memory block from the socket's option memory buffer. 1001 */ 1002 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority) 1003 { 1004 if ((unsigned)size <= sysctl_optmem_max && 1005 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) { 1006 void *mem; 1007 /* First do the add, to avoid the race if kmalloc 1008 * might sleep. 1009 */ 1010 atomic_add(size, &sk->sk_omem_alloc); 1011 mem = kmalloc(size, priority); 1012 if (mem) 1013 return mem; 1014 atomic_sub(size, &sk->sk_omem_alloc); 1015 } 1016 return NULL; 1017 } 1018 1019 /* 1020 * Free an option memory block. 1021 */ 1022 void sock_kfree_s(struct sock *sk, void *mem, int size) 1023 { 1024 kfree(mem); 1025 atomic_sub(size, &sk->sk_omem_alloc); 1026 } 1027 1028 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock. 1029 I think, these locks should be removed for datagram sockets. 1030 */ 1031 static long sock_wait_for_wmem(struct sock * sk, long timeo) 1032 { 1033 DEFINE_WAIT(wait); 1034 1035 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 1036 for (;;) { 1037 if (!timeo) 1038 break; 1039 if (signal_pending(current)) 1040 break; 1041 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 1042 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 1043 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) 1044 break; 1045 if (sk->sk_shutdown & SEND_SHUTDOWN) 1046 break; 1047 if (sk->sk_err) 1048 break; 1049 timeo = schedule_timeout(timeo); 1050 } 1051 finish_wait(sk->sk_sleep, &wait); 1052 return timeo; 1053 } 1054 1055 1056 /* 1057 * Generic send/receive buffer handlers 1058 */ 1059 1060 static struct sk_buff *sock_alloc_send_pskb(struct sock *sk, 1061 unsigned long header_len, 1062 unsigned long data_len, 1063 int noblock, int *errcode) 1064 { 1065 struct sk_buff *skb; 1066 gfp_t gfp_mask; 1067 long timeo; 1068 int err; 1069 1070 gfp_mask = sk->sk_allocation; 1071 if (gfp_mask & __GFP_WAIT) 1072 gfp_mask |= __GFP_REPEAT; 1073 1074 timeo = sock_sndtimeo(sk, noblock); 1075 while (1) { 1076 err = sock_error(sk); 1077 if (err != 0) 1078 goto failure; 1079 1080 err = -EPIPE; 1081 if (sk->sk_shutdown & SEND_SHUTDOWN) 1082 goto failure; 1083 1084 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) { 1085 skb = alloc_skb(header_len, sk->sk_allocation); 1086 if (skb) { 1087 int npages; 1088 int i; 1089 1090 /* No pages, we're done... */ 1091 if (!data_len) 1092 break; 1093 1094 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT; 1095 skb->truesize += data_len; 1096 skb_shinfo(skb)->nr_frags = npages; 1097 for (i = 0; i < npages; i++) { 1098 struct page *page; 1099 skb_frag_t *frag; 1100 1101 page = alloc_pages(sk->sk_allocation, 0); 1102 if (!page) { 1103 err = -ENOBUFS; 1104 skb_shinfo(skb)->nr_frags = i; 1105 kfree_skb(skb); 1106 goto failure; 1107 } 1108 1109 frag = &skb_shinfo(skb)->frags[i]; 1110 frag->page = page; 1111 frag->page_offset = 0; 1112 frag->size = (data_len >= PAGE_SIZE ? 1113 PAGE_SIZE : 1114 data_len); 1115 data_len -= PAGE_SIZE; 1116 } 1117 1118 /* Full success... */ 1119 break; 1120 } 1121 err = -ENOBUFS; 1122 goto failure; 1123 } 1124 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 1125 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 1126 err = -EAGAIN; 1127 if (!timeo) 1128 goto failure; 1129 if (signal_pending(current)) 1130 goto interrupted; 1131 timeo = sock_wait_for_wmem(sk, timeo); 1132 } 1133 1134 skb_set_owner_w(skb, sk); 1135 return skb; 1136 1137 interrupted: 1138 err = sock_intr_errno(timeo); 1139 failure: 1140 *errcode = err; 1141 return NULL; 1142 } 1143 1144 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, 1145 int noblock, int *errcode) 1146 { 1147 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode); 1148 } 1149 1150 static void __lock_sock(struct sock *sk) 1151 { 1152 DEFINE_WAIT(wait); 1153 1154 for(;;) { 1155 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait, 1156 TASK_UNINTERRUPTIBLE); 1157 spin_unlock_bh(&sk->sk_lock.slock); 1158 schedule(); 1159 spin_lock_bh(&sk->sk_lock.slock); 1160 if(!sock_owned_by_user(sk)) 1161 break; 1162 } 1163 finish_wait(&sk->sk_lock.wq, &wait); 1164 } 1165 1166 static void __release_sock(struct sock *sk) 1167 { 1168 struct sk_buff *skb = sk->sk_backlog.head; 1169 1170 do { 1171 sk->sk_backlog.head = sk->sk_backlog.tail = NULL; 1172 bh_unlock_sock(sk); 1173 1174 do { 1175 struct sk_buff *next = skb->next; 1176 1177 skb->next = NULL; 1178 sk->sk_backlog_rcv(sk, skb); 1179 1180 /* 1181 * We are in process context here with softirqs 1182 * disabled, use cond_resched_softirq() to preempt. 1183 * This is safe to do because we've taken the backlog 1184 * queue private: 1185 */ 1186 cond_resched_softirq(); 1187 1188 skb = next; 1189 } while (skb != NULL); 1190 1191 bh_lock_sock(sk); 1192 } while((skb = sk->sk_backlog.head) != NULL); 1193 } 1194 1195 /** 1196 * sk_wait_data - wait for data to arrive at sk_receive_queue 1197 * @sk: sock to wait on 1198 * @timeo: for how long 1199 * 1200 * Now socket state including sk->sk_err is changed only under lock, 1201 * hence we may omit checks after joining wait queue. 1202 * We check receive queue before schedule() only as optimization; 1203 * it is very likely that release_sock() added new data. 1204 */ 1205 int sk_wait_data(struct sock *sk, long *timeo) 1206 { 1207 int rc; 1208 DEFINE_WAIT(wait); 1209 1210 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 1211 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1212 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue)); 1213 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1214 finish_wait(sk->sk_sleep, &wait); 1215 return rc; 1216 } 1217 1218 EXPORT_SYMBOL(sk_wait_data); 1219 1220 /* 1221 * Set of default routines for initialising struct proto_ops when 1222 * the protocol does not support a particular function. In certain 1223 * cases where it makes no sense for a protocol to have a "do nothing" 1224 * function, some default processing is provided. 1225 */ 1226 1227 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len) 1228 { 1229 return -EOPNOTSUPP; 1230 } 1231 1232 int sock_no_connect(struct socket *sock, struct sockaddr *saddr, 1233 int len, int flags) 1234 { 1235 return -EOPNOTSUPP; 1236 } 1237 1238 int sock_no_socketpair(struct socket *sock1, struct socket *sock2) 1239 { 1240 return -EOPNOTSUPP; 1241 } 1242 1243 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags) 1244 { 1245 return -EOPNOTSUPP; 1246 } 1247 1248 int sock_no_getname(struct socket *sock, struct sockaddr *saddr, 1249 int *len, int peer) 1250 { 1251 return -EOPNOTSUPP; 1252 } 1253 1254 unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt) 1255 { 1256 return 0; 1257 } 1258 1259 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1260 { 1261 return -EOPNOTSUPP; 1262 } 1263 1264 int sock_no_listen(struct socket *sock, int backlog) 1265 { 1266 return -EOPNOTSUPP; 1267 } 1268 1269 int sock_no_shutdown(struct socket *sock, int how) 1270 { 1271 return -EOPNOTSUPP; 1272 } 1273 1274 int sock_no_setsockopt(struct socket *sock, int level, int optname, 1275 char __user *optval, int optlen) 1276 { 1277 return -EOPNOTSUPP; 1278 } 1279 1280 int sock_no_getsockopt(struct socket *sock, int level, int optname, 1281 char __user *optval, int __user *optlen) 1282 { 1283 return -EOPNOTSUPP; 1284 } 1285 1286 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 1287 size_t len) 1288 { 1289 return -EOPNOTSUPP; 1290 } 1291 1292 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 1293 size_t len, int flags) 1294 { 1295 return -EOPNOTSUPP; 1296 } 1297 1298 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma) 1299 { 1300 /* Mirror missing mmap method error code */ 1301 return -ENODEV; 1302 } 1303 1304 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags) 1305 { 1306 ssize_t res; 1307 struct msghdr msg = {.msg_flags = flags}; 1308 struct kvec iov; 1309 char *kaddr = kmap(page); 1310 iov.iov_base = kaddr + offset; 1311 iov.iov_len = size; 1312 res = kernel_sendmsg(sock, &msg, &iov, 1, size); 1313 kunmap(page); 1314 return res; 1315 } 1316 1317 /* 1318 * Default Socket Callbacks 1319 */ 1320 1321 static void sock_def_wakeup(struct sock *sk) 1322 { 1323 read_lock(&sk->sk_callback_lock); 1324 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1325 wake_up_interruptible_all(sk->sk_sleep); 1326 read_unlock(&sk->sk_callback_lock); 1327 } 1328 1329 static void sock_def_error_report(struct sock *sk) 1330 { 1331 read_lock(&sk->sk_callback_lock); 1332 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1333 wake_up_interruptible(sk->sk_sleep); 1334 sk_wake_async(sk,0,POLL_ERR); 1335 read_unlock(&sk->sk_callback_lock); 1336 } 1337 1338 static void sock_def_readable(struct sock *sk, int len) 1339 { 1340 read_lock(&sk->sk_callback_lock); 1341 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1342 wake_up_interruptible(sk->sk_sleep); 1343 sk_wake_async(sk,1,POLL_IN); 1344 read_unlock(&sk->sk_callback_lock); 1345 } 1346 1347 static void sock_def_write_space(struct sock *sk) 1348 { 1349 read_lock(&sk->sk_callback_lock); 1350 1351 /* Do not wake up a writer until he can make "significant" 1352 * progress. --DaveM 1353 */ 1354 if((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) { 1355 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1356 wake_up_interruptible(sk->sk_sleep); 1357 1358 /* Should agree with poll, otherwise some programs break */ 1359 if (sock_writeable(sk)) 1360 sk_wake_async(sk, 2, POLL_OUT); 1361 } 1362 1363 read_unlock(&sk->sk_callback_lock); 1364 } 1365 1366 static void sock_def_destruct(struct sock *sk) 1367 { 1368 kfree(sk->sk_protinfo); 1369 } 1370 1371 void sk_send_sigurg(struct sock *sk) 1372 { 1373 if (sk->sk_socket && sk->sk_socket->file) 1374 if (send_sigurg(&sk->sk_socket->file->f_owner)) 1375 sk_wake_async(sk, 3, POLL_PRI); 1376 } 1377 1378 void sk_reset_timer(struct sock *sk, struct timer_list* timer, 1379 unsigned long expires) 1380 { 1381 if (!mod_timer(timer, expires)) 1382 sock_hold(sk); 1383 } 1384 1385 EXPORT_SYMBOL(sk_reset_timer); 1386 1387 void sk_stop_timer(struct sock *sk, struct timer_list* timer) 1388 { 1389 if (timer_pending(timer) && del_timer(timer)) 1390 __sock_put(sk); 1391 } 1392 1393 EXPORT_SYMBOL(sk_stop_timer); 1394 1395 void sock_init_data(struct socket *sock, struct sock *sk) 1396 { 1397 skb_queue_head_init(&sk->sk_receive_queue); 1398 skb_queue_head_init(&sk->sk_write_queue); 1399 skb_queue_head_init(&sk->sk_error_queue); 1400 #ifdef CONFIG_NET_DMA 1401 skb_queue_head_init(&sk->sk_async_wait_queue); 1402 #endif 1403 1404 sk->sk_send_head = NULL; 1405 1406 init_timer(&sk->sk_timer); 1407 1408 sk->sk_allocation = GFP_KERNEL; 1409 sk->sk_rcvbuf = sysctl_rmem_default; 1410 sk->sk_sndbuf = sysctl_wmem_default; 1411 sk->sk_state = TCP_CLOSE; 1412 sk->sk_socket = sock; 1413 1414 sock_set_flag(sk, SOCK_ZAPPED); 1415 1416 if(sock) 1417 { 1418 sk->sk_type = sock->type; 1419 sk->sk_sleep = &sock->wait; 1420 sock->sk = sk; 1421 } else 1422 sk->sk_sleep = NULL; 1423 1424 rwlock_init(&sk->sk_dst_lock); 1425 rwlock_init(&sk->sk_callback_lock); 1426 1427 sk->sk_state_change = sock_def_wakeup; 1428 sk->sk_data_ready = sock_def_readable; 1429 sk->sk_write_space = sock_def_write_space; 1430 sk->sk_error_report = sock_def_error_report; 1431 sk->sk_destruct = sock_def_destruct; 1432 1433 sk->sk_sndmsg_page = NULL; 1434 sk->sk_sndmsg_off = 0; 1435 1436 sk->sk_peercred.pid = 0; 1437 sk->sk_peercred.uid = -1; 1438 sk->sk_peercred.gid = -1; 1439 sk->sk_write_pending = 0; 1440 sk->sk_rcvlowat = 1; 1441 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1442 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT; 1443 1444 sk->sk_stamp.tv_sec = -1L; 1445 sk->sk_stamp.tv_usec = -1L; 1446 1447 atomic_set(&sk->sk_refcnt, 1); 1448 } 1449 1450 void fastcall lock_sock(struct sock *sk) 1451 { 1452 might_sleep(); 1453 spin_lock_bh(&(sk->sk_lock.slock)); 1454 if (sk->sk_lock.owner) 1455 __lock_sock(sk); 1456 sk->sk_lock.owner = (void *)1; 1457 spin_unlock_bh(&(sk->sk_lock.slock)); 1458 } 1459 1460 EXPORT_SYMBOL(lock_sock); 1461 1462 void fastcall release_sock(struct sock *sk) 1463 { 1464 spin_lock_bh(&(sk->sk_lock.slock)); 1465 if (sk->sk_backlog.tail) 1466 __release_sock(sk); 1467 sk->sk_lock.owner = NULL; 1468 if (waitqueue_active(&(sk->sk_lock.wq))) 1469 wake_up(&(sk->sk_lock.wq)); 1470 spin_unlock_bh(&(sk->sk_lock.slock)); 1471 } 1472 EXPORT_SYMBOL(release_sock); 1473 1474 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp) 1475 { 1476 if (!sock_flag(sk, SOCK_TIMESTAMP)) 1477 sock_enable_timestamp(sk); 1478 if (sk->sk_stamp.tv_sec == -1) 1479 return -ENOENT; 1480 if (sk->sk_stamp.tv_sec == 0) 1481 do_gettimeofday(&sk->sk_stamp); 1482 return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ? 1483 -EFAULT : 0; 1484 } 1485 EXPORT_SYMBOL(sock_get_timestamp); 1486 1487 void sock_enable_timestamp(struct sock *sk) 1488 { 1489 if (!sock_flag(sk, SOCK_TIMESTAMP)) { 1490 sock_set_flag(sk, SOCK_TIMESTAMP); 1491 net_enable_timestamp(); 1492 } 1493 } 1494 EXPORT_SYMBOL(sock_enable_timestamp); 1495 1496 /* 1497 * Get a socket option on an socket. 1498 * 1499 * FIX: POSIX 1003.1g is very ambiguous here. It states that 1500 * asynchronous errors should be reported by getsockopt. We assume 1501 * this means if you specify SO_ERROR (otherwise whats the point of it). 1502 */ 1503 int sock_common_getsockopt(struct socket *sock, int level, int optname, 1504 char __user *optval, int __user *optlen) 1505 { 1506 struct sock *sk = sock->sk; 1507 1508 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen); 1509 } 1510 1511 EXPORT_SYMBOL(sock_common_getsockopt); 1512 1513 #ifdef CONFIG_COMPAT 1514 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname, 1515 char __user *optval, int __user *optlen) 1516 { 1517 struct sock *sk = sock->sk; 1518 1519 if (sk->sk_prot->compat_setsockopt != NULL) 1520 return sk->sk_prot->compat_getsockopt(sk, level, optname, 1521 optval, optlen); 1522 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen); 1523 } 1524 EXPORT_SYMBOL(compat_sock_common_getsockopt); 1525 #endif 1526 1527 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock, 1528 struct msghdr *msg, size_t size, int flags) 1529 { 1530 struct sock *sk = sock->sk; 1531 int addr_len = 0; 1532 int err; 1533 1534 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT, 1535 flags & ~MSG_DONTWAIT, &addr_len); 1536 if (err >= 0) 1537 msg->msg_namelen = addr_len; 1538 return err; 1539 } 1540 1541 EXPORT_SYMBOL(sock_common_recvmsg); 1542 1543 /* 1544 * Set socket options on an inet socket. 1545 */ 1546 int sock_common_setsockopt(struct socket *sock, int level, int optname, 1547 char __user *optval, int optlen) 1548 { 1549 struct sock *sk = sock->sk; 1550 1551 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen); 1552 } 1553 1554 EXPORT_SYMBOL(sock_common_setsockopt); 1555 1556 #ifdef CONFIG_COMPAT 1557 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname, 1558 char __user *optval, int optlen) 1559 { 1560 struct sock *sk = sock->sk; 1561 1562 if (sk->sk_prot->compat_setsockopt != NULL) 1563 return sk->sk_prot->compat_setsockopt(sk, level, optname, 1564 optval, optlen); 1565 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen); 1566 } 1567 EXPORT_SYMBOL(compat_sock_common_setsockopt); 1568 #endif 1569 1570 void sk_common_release(struct sock *sk) 1571 { 1572 if (sk->sk_prot->destroy) 1573 sk->sk_prot->destroy(sk); 1574 1575 /* 1576 * Observation: when sock_common_release is called, processes have 1577 * no access to socket. But net still has. 1578 * Step one, detach it from networking: 1579 * 1580 * A. Remove from hash tables. 1581 */ 1582 1583 sk->sk_prot->unhash(sk); 1584 1585 /* 1586 * In this point socket cannot receive new packets, but it is possible 1587 * that some packets are in flight because some CPU runs receiver and 1588 * did hash table lookup before we unhashed socket. They will achieve 1589 * receive queue and will be purged by socket destructor. 1590 * 1591 * Also we still have packets pending on receive queue and probably, 1592 * our own packets waiting in device queues. sock_destroy will drain 1593 * receive queue, but transmitted packets will delay socket destruction 1594 * until the last reference will be released. 1595 */ 1596 1597 sock_orphan(sk); 1598 1599 xfrm_sk_free_policy(sk); 1600 1601 sk_refcnt_debug_release(sk); 1602 sock_put(sk); 1603 } 1604 1605 EXPORT_SYMBOL(sk_common_release); 1606 1607 static DEFINE_RWLOCK(proto_list_lock); 1608 static LIST_HEAD(proto_list); 1609 1610 int proto_register(struct proto *prot, int alloc_slab) 1611 { 1612 char *request_sock_slab_name = NULL; 1613 char *timewait_sock_slab_name; 1614 int rc = -ENOBUFS; 1615 1616 if (alloc_slab) { 1617 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0, 1618 SLAB_HWCACHE_ALIGN, NULL, NULL); 1619 1620 if (prot->slab == NULL) { 1621 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n", 1622 prot->name); 1623 goto out; 1624 } 1625 1626 if (prot->rsk_prot != NULL) { 1627 static const char mask[] = "request_sock_%s"; 1628 1629 request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); 1630 if (request_sock_slab_name == NULL) 1631 goto out_free_sock_slab; 1632 1633 sprintf(request_sock_slab_name, mask, prot->name); 1634 prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name, 1635 prot->rsk_prot->obj_size, 0, 1636 SLAB_HWCACHE_ALIGN, NULL, NULL); 1637 1638 if (prot->rsk_prot->slab == NULL) { 1639 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n", 1640 prot->name); 1641 goto out_free_request_sock_slab_name; 1642 } 1643 } 1644 1645 if (prot->twsk_prot != NULL) { 1646 static const char mask[] = "tw_sock_%s"; 1647 1648 timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); 1649 1650 if (timewait_sock_slab_name == NULL) 1651 goto out_free_request_sock_slab; 1652 1653 sprintf(timewait_sock_slab_name, mask, prot->name); 1654 prot->twsk_prot->twsk_slab = 1655 kmem_cache_create(timewait_sock_slab_name, 1656 prot->twsk_prot->twsk_obj_size, 1657 0, SLAB_HWCACHE_ALIGN, 1658 NULL, NULL); 1659 if (prot->twsk_prot->twsk_slab == NULL) 1660 goto out_free_timewait_sock_slab_name; 1661 } 1662 } 1663 1664 write_lock(&proto_list_lock); 1665 list_add(&prot->node, &proto_list); 1666 write_unlock(&proto_list_lock); 1667 rc = 0; 1668 out: 1669 return rc; 1670 out_free_timewait_sock_slab_name: 1671 kfree(timewait_sock_slab_name); 1672 out_free_request_sock_slab: 1673 if (prot->rsk_prot && prot->rsk_prot->slab) { 1674 kmem_cache_destroy(prot->rsk_prot->slab); 1675 prot->rsk_prot->slab = NULL; 1676 } 1677 out_free_request_sock_slab_name: 1678 kfree(request_sock_slab_name); 1679 out_free_sock_slab: 1680 kmem_cache_destroy(prot->slab); 1681 prot->slab = NULL; 1682 goto out; 1683 } 1684 1685 EXPORT_SYMBOL(proto_register); 1686 1687 void proto_unregister(struct proto *prot) 1688 { 1689 write_lock(&proto_list_lock); 1690 list_del(&prot->node); 1691 write_unlock(&proto_list_lock); 1692 1693 if (prot->slab != NULL) { 1694 kmem_cache_destroy(prot->slab); 1695 prot->slab = NULL; 1696 } 1697 1698 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) { 1699 const char *name = kmem_cache_name(prot->rsk_prot->slab); 1700 1701 kmem_cache_destroy(prot->rsk_prot->slab); 1702 kfree(name); 1703 prot->rsk_prot->slab = NULL; 1704 } 1705 1706 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) { 1707 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab); 1708 1709 kmem_cache_destroy(prot->twsk_prot->twsk_slab); 1710 kfree(name); 1711 prot->twsk_prot->twsk_slab = NULL; 1712 } 1713 } 1714 1715 EXPORT_SYMBOL(proto_unregister); 1716 1717 #ifdef CONFIG_PROC_FS 1718 static inline struct proto *__proto_head(void) 1719 { 1720 return list_entry(proto_list.next, struct proto, node); 1721 } 1722 1723 static inline struct proto *proto_head(void) 1724 { 1725 return list_empty(&proto_list) ? NULL : __proto_head(); 1726 } 1727 1728 static inline struct proto *proto_next(struct proto *proto) 1729 { 1730 return proto->node.next == &proto_list ? NULL : 1731 list_entry(proto->node.next, struct proto, node); 1732 } 1733 1734 static inline struct proto *proto_get_idx(loff_t pos) 1735 { 1736 struct proto *proto; 1737 loff_t i = 0; 1738 1739 list_for_each_entry(proto, &proto_list, node) 1740 if (i++ == pos) 1741 goto out; 1742 1743 proto = NULL; 1744 out: 1745 return proto; 1746 } 1747 1748 static void *proto_seq_start(struct seq_file *seq, loff_t *pos) 1749 { 1750 read_lock(&proto_list_lock); 1751 return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN; 1752 } 1753 1754 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1755 { 1756 ++*pos; 1757 return v == SEQ_START_TOKEN ? proto_head() : proto_next(v); 1758 } 1759 1760 static void proto_seq_stop(struct seq_file *seq, void *v) 1761 { 1762 read_unlock(&proto_list_lock); 1763 } 1764 1765 static char proto_method_implemented(const void *method) 1766 { 1767 return method == NULL ? 'n' : 'y'; 1768 } 1769 1770 static void proto_seq_printf(struct seq_file *seq, struct proto *proto) 1771 { 1772 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s " 1773 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n", 1774 proto->name, 1775 proto->obj_size, 1776 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1, 1777 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1, 1778 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI", 1779 proto->max_header, 1780 proto->slab == NULL ? "no" : "yes", 1781 module_name(proto->owner), 1782 proto_method_implemented(proto->close), 1783 proto_method_implemented(proto->connect), 1784 proto_method_implemented(proto->disconnect), 1785 proto_method_implemented(proto->accept), 1786 proto_method_implemented(proto->ioctl), 1787 proto_method_implemented(proto->init), 1788 proto_method_implemented(proto->destroy), 1789 proto_method_implemented(proto->shutdown), 1790 proto_method_implemented(proto->setsockopt), 1791 proto_method_implemented(proto->getsockopt), 1792 proto_method_implemented(proto->sendmsg), 1793 proto_method_implemented(proto->recvmsg), 1794 proto_method_implemented(proto->sendpage), 1795 proto_method_implemented(proto->bind), 1796 proto_method_implemented(proto->backlog_rcv), 1797 proto_method_implemented(proto->hash), 1798 proto_method_implemented(proto->unhash), 1799 proto_method_implemented(proto->get_port), 1800 proto_method_implemented(proto->enter_memory_pressure)); 1801 } 1802 1803 static int proto_seq_show(struct seq_file *seq, void *v) 1804 { 1805 if (v == SEQ_START_TOKEN) 1806 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s", 1807 "protocol", 1808 "size", 1809 "sockets", 1810 "memory", 1811 "press", 1812 "maxhdr", 1813 "slab", 1814 "module", 1815 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n"); 1816 else 1817 proto_seq_printf(seq, v); 1818 return 0; 1819 } 1820 1821 static struct seq_operations proto_seq_ops = { 1822 .start = proto_seq_start, 1823 .next = proto_seq_next, 1824 .stop = proto_seq_stop, 1825 .show = proto_seq_show, 1826 }; 1827 1828 static int proto_seq_open(struct inode *inode, struct file *file) 1829 { 1830 return seq_open(file, &proto_seq_ops); 1831 } 1832 1833 static struct file_operations proto_seq_fops = { 1834 .owner = THIS_MODULE, 1835 .open = proto_seq_open, 1836 .read = seq_read, 1837 .llseek = seq_lseek, 1838 .release = seq_release, 1839 }; 1840 1841 static int __init proto_init(void) 1842 { 1843 /* register /proc/net/protocols */ 1844 return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0; 1845 } 1846 1847 subsys_initcall(proto_init); 1848 1849 #endif /* PROC_FS */ 1850 1851 EXPORT_SYMBOL(sk_alloc); 1852 EXPORT_SYMBOL(sk_free); 1853 EXPORT_SYMBOL(sk_send_sigurg); 1854 EXPORT_SYMBOL(sock_alloc_send_skb); 1855 EXPORT_SYMBOL(sock_init_data); 1856 EXPORT_SYMBOL(sock_kfree_s); 1857 EXPORT_SYMBOL(sock_kmalloc); 1858 EXPORT_SYMBOL(sock_no_accept); 1859 EXPORT_SYMBOL(sock_no_bind); 1860 EXPORT_SYMBOL(sock_no_connect); 1861 EXPORT_SYMBOL(sock_no_getname); 1862 EXPORT_SYMBOL(sock_no_getsockopt); 1863 EXPORT_SYMBOL(sock_no_ioctl); 1864 EXPORT_SYMBOL(sock_no_listen); 1865 EXPORT_SYMBOL(sock_no_mmap); 1866 EXPORT_SYMBOL(sock_no_poll); 1867 EXPORT_SYMBOL(sock_no_recvmsg); 1868 EXPORT_SYMBOL(sock_no_sendmsg); 1869 EXPORT_SYMBOL(sock_no_sendpage); 1870 EXPORT_SYMBOL(sock_no_setsockopt); 1871 EXPORT_SYMBOL(sock_no_shutdown); 1872 EXPORT_SYMBOL(sock_no_socketpair); 1873 EXPORT_SYMBOL(sock_rfree); 1874 EXPORT_SYMBOL(sock_setsockopt); 1875 EXPORT_SYMBOL(sock_wfree); 1876 EXPORT_SYMBOL(sock_wmalloc); 1877 EXPORT_SYMBOL(sock_i_uid); 1878 EXPORT_SYMBOL(sock_i_ino); 1879 EXPORT_SYMBOL(sysctl_optmem_max); 1880 #ifdef CONFIG_SYSCTL 1881 EXPORT_SYMBOL(sysctl_rmem_max); 1882 EXPORT_SYMBOL(sysctl_wmem_max); 1883 #endif 1884