开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sock.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

sock.c：源码内容
  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.116 2001/11/08 04:20:06 davem Exp $
  11.  *
  12.  * Authors: Ross Biro, <bir7@leland.Stanford.Edu>
  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.  */
  94. #include <linux/config.h>
  95. #include <linux/errno.h>
  96. #include <linux/types.h>
  97. #include <linux/socket.h>
  98. #include <linux/in.h>
  99. #include <linux/kernel.h>
  100. #include <linux/major.h>
  101. #include <linux/sched.h>
  102. #include <linux/timer.h>
  103. #include <linux/string.h>
  104. #include <linux/sockios.h>
  105. #include <linux/net.h>
  106. #include <linux/fcntl.h>
  107. #include <linux/mm.h>
  108. #include <linux/slab.h>
  109. #include <linux/interrupt.h>
  110. #include <linux/poll.h>
  111. #include <linux/init.h>
  113. #include <asm/uaccess.h>
  114. #include <asm/system.h>
  116. #include <linux/netdevice.h>
  117. #include <net/protocol.h>
  118. #include <linux/skbuff.h>
  119. #include <net/sock.h>
  120. #include <linux/ipsec.h>
  122. #ifdef CONFIG_FILTER
  123. #include <linux/filter.h>
  124. #endif
  126. #ifdef CONFIG_INET
  127. #include <net/tcp.h>
  128. #endif
  130. /* Run time adjustable parameters. */
  131. __u32 sysctl_wmem_max = SK_WMEM_MAX;
  132. __u32 sysctl_rmem_max = SK_RMEM_MAX;
  133. __u32 sysctl_wmem_default = SK_WMEM_MAX;
  134. __u32 sysctl_rmem_default = SK_RMEM_MAX;
  136. /* Maximal space eaten by iovec or ancilliary data plus some space */
  137. int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512);
  139. static int sock_set_timeout(long *timeo_p, char *optval, int optlen)
  140. {
  141. struct timeval tv;
  143. if (optlen < sizeof(tv))
  144. return -EINVAL;
  145. if (copy_from_user(&tv, optval, sizeof(tv)))
  146. return -EFAULT;
  148. *timeo_p = MAX_SCHEDULE_TIMEOUT;
  149. if (tv.tv_sec == 0 && tv.tv_usec == 0)
  150. return 0;
  151. if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
  152. *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
  153. return 0;
  154. }
  156. /*
  157.  * This is meant for all protocols to use and covers goings on
  158.  * at the socket level. Everything here is generic.
  159.  */
  161. int sock_setsockopt(struct socket *sock, int level, int optname,
  162.     char *optval, int optlen)
  163. {
  164. struct sock *sk=sock->sk;
  165. #ifdef CONFIG_FILTER
  166. struct sk_filter *filter;
  167. #endif
  168. int val;
  169. int valbool;
  170. struct linger ling;
  171. int ret = 0;
  173. /*
  174.  * Options without arguments
  175.  */
  177. #ifdef SO_DONTLINGER /* Compatibility item... */
  178. switch(optname)
  179. {
  180. case SO_DONTLINGER:
  181. sk->linger=0;
  182. return 0;
  183. }
  184. #endif
  186.    if(optlen<sizeof(int))
  187.    return(-EINVAL);
  188.   
  189. if (get_user(val, (int *)optval))
  190. return -EFAULT;
  192.    valbool = val?1:0;
  194. lock_sock(sk);
  196.    switch(optname) 
  197.    {
  198. case SO_DEBUG:
  199. if(val && !capable(CAP_NET_ADMIN))
  200. {
  201. ret = -EACCES;
  202. }
  203. else
  204. sk->debug=valbool;
  205. break;
  206. case SO_REUSEADDR:
  207. sk->reuse = valbool;
  208. break;
  209. case SO_TYPE:
  210. case SO_ERROR:
  211. ret = -ENOPROTOOPT;
  212.    break;
  213. case SO_DONTROUTE:
  214. sk->localroute=valbool;
  215. break;
  216. case SO_BROADCAST:
  217. sk->broadcast=valbool;
  218. break;
  219. case SO_SNDBUF:
  220. /* Don't error on this BSD doesn't and if you think
  221.    about it this is right. Otherwise apps have to
  222.    play 'guess the biggest size' games. RCVBUF/SNDBUF
  223.    are treated in BSD as hints */
  224.    
  225. if (val > sysctl_wmem_max)
  226. val = sysctl_wmem_max;
  228. sk->userlocks |= SOCK_SNDBUF_LOCK;
  229. if ((val * 2) < SOCK_MIN_SNDBUF)
  230. sk->sndbuf = SOCK_MIN_SNDBUF;
  231. else
  232. sk->sndbuf = (val * 2);
  234. /*
  235.  * Wake up sending tasks if we
  236.  * upped the value.
  237.  */
  238. sk->write_space(sk);
  239. break;
  241. case SO_RCVBUF:
  242. /* Don't error on this BSD doesn't and if you think
  243.    about it this is right. Otherwise apps have to
  244.    play 'guess the biggest size' games. RCVBUF/SNDBUF
  245.    are treated in BSD as hints */
  246.   
  247. if (val > sysctl_rmem_max)
  248. val = sysctl_rmem_max;
  250. sk->userlocks |= SOCK_RCVBUF_LOCK;
  251. /* FIXME: is this lower bound the right one? */
  252. if ((val * 2) < SOCK_MIN_RCVBUF)
  253. sk->rcvbuf = SOCK_MIN_RCVBUF;
  254. else
  255. sk->rcvbuf = (val * 2);
  256. break;
  258. case SO_KEEPALIVE:
  259. #ifdef CONFIG_INET
  260. if (sk->protocol == IPPROTO_TCP)
  261. {
  262. tcp_set_keepalive(sk, valbool);
  263. }
  264. #endif
  265. sk->keepopen = valbool;
  266. break;
  268.   case SO_OOBINLINE:
  269. sk->urginline = valbool;
  270. break;
  272.   case SO_NO_CHECK:
  273. sk->no_check = valbool;
  274. break;
  276. case SO_PRIORITY:
  277. if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN)) 
  278. sk->priority = val;
  279. else
  280. ret = -EPERM;
  281. break;
  283. case SO_LINGER:
  284. if(optlen<sizeof(ling)) {
  285. ret = -EINVAL; /* 1003.1g */
  286. break;
  287. }
  288. if (copy_from_user(&ling,optval,sizeof(ling))) {
  289. ret = -EFAULT;
  290. break;
  291. }
  292. if(ling.l_onoff==0) {
  293. sk->linger=0;
  294. } else {
  295. #if (BITS_PER_LONG == 32)
  296. if (ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
  297. sk->lingertime=MAX_SCHEDULE_TIMEOUT;
  298. else
  299. #endif
  300. sk->lingertime=ling.l_linger*HZ;
  301. sk->linger=1;
  302. }
  303. break;
  305. case SO_BSDCOMPAT:
  306. sk->bsdism = valbool;
  307. break;
  309. case SO_PASSCRED:
  310. sock->passcred = valbool;
  311. break;
  313. case SO_TIMESTAMP:
  314. sk->rcvtstamp = valbool;
  315. break;
  317. case SO_RCVLOWAT:
  318. if (val < 0)
  319. val = INT_MAX;
  320. sk->rcvlowat = val ? : 1;
  321. break;
  323. case SO_RCVTIMEO:
  324. ret = sock_set_timeout(&sk->rcvtimeo, optval, optlen);
  325. break;
  327. case SO_SNDTIMEO:
  328. ret = sock_set_timeout(&sk->sndtimeo, optval, optlen);
  329. break;
  331. #ifdef CONFIG_NETDEVICES
  332. case SO_BINDTODEVICE:
  333. {
  334. char devname[IFNAMSIZ]; 
  336. /* Sorry... */ 
  337. if (!capable(CAP_NET_RAW)) {
  338. ret = -EPERM;
  339. break;
  340. }
  342. /* Bind this socket to a particular device like "eth0",
  343.  * as specified in the passed interface name. If the
  344.  * name is "" or the option length is zero the socket 
  345.  * is not bound. 
  346.  */ 
  348. if (!valbool) {
  349. sk->bound_dev_if = 0;
  350. } else {
  351. if (optlen > IFNAMSIZ) 
  352. optlen = IFNAMSIZ; 
  353. if (copy_from_user(devname, optval, optlen)) {
  354. ret = -EFAULT;
  355. break;
  356. }
  358. /* Remove any cached route for this socket. */
  359. sk_dst_reset(sk);
  361. if (devname[0] == '') {
  362. sk->bound_dev_if = 0;
  363. } else {
  364. struct net_device *dev = dev_get_by_name(devname);
  365. if (!dev) {
  366. ret = -ENODEV;
  367. break;
  368. }
  369. sk->bound_dev_if = dev->ifindex;
  370. dev_put(dev);
  371. }
  372. }
  373. break;
  374. }
  375. #endif
  378. #ifdef CONFIG_FILTER
  379. case SO_ATTACH_FILTER:
  380. ret = -EINVAL;
  381. if (optlen == sizeof(struct sock_fprog)) {
  382. struct sock_fprog fprog;
  384. ret = -EFAULT;
  385. if (copy_from_user(&fprog, optval, sizeof(fprog)))
  386. break;
  388. ret = sk_attach_filter(&fprog, sk);
  389. }
  390. break;
  392. case SO_DETACH_FILTER:
  393. spin_lock_bh(&sk->lock.slock);
  394. filter = sk->filter;
  395.                         if (filter) {
  396. sk->filter = NULL;
  397. spin_unlock_bh(&sk->lock.slock);
  398. sk_filter_release(sk, filter);
  399. break;
  400. }
  401. spin_unlock_bh(&sk->lock.slock);
  402. ret = -ENONET;
  403. break;
  404. #endif
  405. /* We implement the SO_SNDLOWAT etc to
  406.    not be settable (1003.1g 5.3) */
  407. default:
  408.    ret = -ENOPROTOOPT;
  409. break;
  410.    }
  411. release_sock(sk);
  412. return ret;
  413. }
  416. int sock_getsockopt(struct socket *sock, int level, int optname,
  417.     char *optval, int *optlen)
  418. {
  419. struct sock *sk = sock->sk;
  421. union
  422. {
  423.    int val;
  424.    struct linger ling;
  425. struct timeval tm;
  426. } v;
  428. unsigned int lv=sizeof(int),len;
  429.   
  430.    if(get_user(len,optlen))
  431.    return -EFAULT;
  432. if(len < 0)
  433. return -EINVAL;
  435.    switch(optname) 
  436.    {
  437. case SO_DEBUG:
  438. v.val = sk->debug;
  439. break;
  441. case SO_DONTROUTE:
  442. v.val = sk->localroute;
  443. break;
  445. case SO_BROADCAST:
  446. v.val= sk->broadcast;
  447. break;
  449. case SO_SNDBUF:
  450. v.val=sk->sndbuf;
  451. break;
  453. case SO_RCVBUF:
  454. v.val =sk->rcvbuf;
  455. break;
  457. case SO_REUSEADDR:
  458. v.val = sk->reuse;
  459. break;
  461. case SO_KEEPALIVE:
  462. v.val = sk->keepopen;
  463. break;
  465. case SO_TYPE:
  466. v.val = sk->type;   
  467. break;
  469. case SO_ERROR:
  470. v.val = -sock_error(sk);
  471. if(v.val==0)
  472. v.val=xchg(&sk->err_soft,0);
  473. break;
  475. case SO_OOBINLINE:
  476. v.val = sk->urginline;
  477. break;
  479. case SO_NO_CHECK:
  480. v.val = sk->no_check;
  481. break;
  483. case SO_PRIORITY:
  484. v.val = sk->priority;
  485. break;
  487. case SO_LINGER:
  488. lv=sizeof(v.ling);
  489. v.ling.l_onoff=sk->linger;
  490.   v.ling.l_linger=sk->lingertime/HZ;
  491. break;
  493. case SO_BSDCOMPAT:
  494. v.val = sk->bsdism;
  495. break;
  497. case SO_TIMESTAMP:
  498. v.val = sk->rcvtstamp;
  499. break;
  501. case SO_RCVTIMEO:
  502. lv=sizeof(struct timeval);
  503. if (sk->rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
  504. v.tm.tv_sec = 0;
  505. v.tm.tv_usec = 0;
  506. } else {
  507. v.tm.tv_sec = sk->rcvtimeo/HZ;
  508. v.tm.tv_usec = ((sk->rcvtimeo%HZ)*1000)/HZ;
  509. }
  510. break;
  512. case SO_SNDTIMEO:
  513. lv=sizeof(struct timeval);
  514. if (sk->sndtimeo == MAX_SCHEDULE_TIMEOUT) {
  515. v.tm.tv_sec = 0;
  516. v.tm.tv_usec = 0;
  517. } else {
  518. v.tm.tv_sec = sk->sndtimeo/HZ;
  519. v.tm.tv_usec = ((sk->sndtimeo%HZ)*1000)/HZ;
  520. }
  521. break;
  523. case SO_RCVLOWAT:
  524. v.val = sk->rcvlowat;
  525. break;
  527. case SO_SNDLOWAT:
  528. v.val=1;
  529. break; 
  531. case SO_PASSCRED:
  532. v.val = sock->passcred;
  533. break;
  535. case SO_PEERCRED:
  536. if (len > sizeof(sk->peercred))
  537. len = sizeof(sk->peercred);
  538. if (copy_to_user(optval, &sk->peercred, len))
  539. return -EFAULT;
  540. goto lenout;
  542. case SO_PEERNAME:
  543. {
  544. char address[128];
  546. if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
  547. return -ENOTCONN;
  548. if (lv < len)
  549. return -EINVAL;
  550. if(copy_to_user((void*)optval, address, len))
  551. return -EFAULT;
  552. goto lenout;
  553. }
  555. /* Dubious BSD thing... Probably nobody even uses it, but
  556.  * the UNIX standard wants it for whatever reason... -DaveM
  557.  */
  558. case SO_ACCEPTCONN:
  559. v.val = (sk->state == TCP_LISTEN);
  560. break;
  562. default:
  563. return(-ENOPROTOOPT);
  564. }
  565. if (len > lv)
  566. len = lv;
  567. if (copy_to_user(optval, &v, len))
  568. return -EFAULT;
  569. lenout:
  570.    if (put_user(len, optlen))
  571.    return -EFAULT;
  572.    return 0;
  573. }
  575. static kmem_cache_t *sk_cachep;
  577. /*
  578.  * All socket objects are allocated here. This is for future
  579.  * usage.
  580.  */
  581.  
  582. struct sock *sk_alloc(int family, int priority, int zero_it)
  583. {
  584. struct sock *sk = kmem_cache_alloc(sk_cachep, priority);
  586. if(sk && zero_it) {
  587. memset(sk, 0, sizeof(struct sock));
  588. sk->family = family;
  589. sock_lock_init(sk);
  590. }
  592. return sk;
  593. }
  595. void sk_free(struct sock *sk)
  596. {
  597. #ifdef CONFIG_FILTER
  598. struct sk_filter *filter;
  599. #endif
  601. if (sk->destruct)
  602. sk->destruct(sk);
  604. #ifdef CONFIG_FILTER
  605. filter = sk->filter;
  606. if (filter) {
  607. sk_filter_release(sk, filter);
  608. sk->filter = NULL;
  609. }
  610. #endif
  612. if (atomic_read(&sk->omem_alloc))
  613. printk(KERN_DEBUG "sk_free: optmem leakage (%d bytes) detected.n", atomic_read(&sk->omem_alloc));
  615. kmem_cache_free(sk_cachep, sk);
  616. }
  618. void __init sk_init(void)
  619. {
  620. sk_cachep = kmem_cache_create("sock", sizeof(struct sock), 0,
  621.       SLAB_HWCACHE_ALIGN, 0, 0);
  622. if (!sk_cachep)
  623. printk(KERN_CRIT "sk_init: Cannot create sock SLAB cache!");
  625. if (num_physpages <= 4096) {
  626. sysctl_wmem_max = 32767;
  627. sysctl_rmem_max = 32767;
  628. sysctl_wmem_default = 32767;
  629. sysctl_wmem_default = 32767;
  630. } else if (num_physpages >= 131072) {
  631. sysctl_wmem_max = 131071;
  632. sysctl_rmem_max = 131071;
  633. }
  634. }
  636. /*
  637.  * Simple resource managers for sockets.
  638.  */
  641. /* 
  642.  * Write buffer destructor automatically called from kfree_skb. 
  643.  */
  644. void sock_wfree(struct sk_buff *skb)
  645. {
  646. struct sock *sk = skb->sk;
  648. /* In case it might be waiting for more memory. */
  649. atomic_sub(skb->truesize, &sk->wmem_alloc);
  650. if (!sk->use_write_queue)
  651. sk->write_space(sk);
  652. sock_put(sk);
  653. }
  655. /* 
  656.  * Read buffer destructor automatically called from kfree_skb. 
  657.  */
  658. void sock_rfree(struct sk_buff *skb)
  659. {
  660. struct sock *sk = skb->sk;
  662. atomic_sub(skb->truesize, &sk->rmem_alloc);
  663. }
  665. /*
  666.  * Allocate a skb from the socket's send buffer.
  667.  */
  668. struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
  669. {
  670. if (force || atomic_read(&sk->wmem_alloc) < sk->sndbuf) {
  671. struct sk_buff * skb = alloc_skb(size, priority);
  672. if (skb) {
  673. skb_set_owner_w(skb, sk);
  674. return skb;
  675. }
  676. }
  677. return NULL;
  678. }
  680. /*
  681.  * Allocate a skb from the socket's receive buffer.
  682.  */ 
  683. struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
  684. {
  685. if (force || atomic_read(&sk->rmem_alloc) < sk->rcvbuf) {
  686. struct sk_buff *skb = alloc_skb(size, priority);
  687. if (skb) {
  688. skb_set_owner_r(skb, sk);
  689. return skb;
  690. }
  691. }
  692. return NULL;
  693. }
  695. /* 
  696.  * Allocate a memory block from the socket's option memory buffer.
  697.  */ 
  698. void *sock_kmalloc(struct sock *sk, int size, int priority)
  699. {
  700. if ((unsigned)size <= sysctl_optmem_max &&
  701.     atomic_read(&sk->omem_alloc)+size < sysctl_optmem_max) {
  702. void *mem;
  703. /* First do the add, to avoid the race if kmalloc
  704.    * might sleep.
  705.  */
  706. atomic_add(size, &sk->omem_alloc);
  707. mem = kmalloc(size, priority);
  708. if (mem)
  709. return mem;
  710. atomic_sub(size, &sk->omem_alloc);
  711. }
  712. return NULL;
  713. }
  715. /*
  716.  * Free an option memory block.
  717.  */
  718. void sock_kfree_s(struct sock *sk, void *mem, int size)
  719. {
  720. kfree(mem);
  721. atomic_sub(size, &sk->omem_alloc);
  722. }
  724. /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
  725.    I think, these locks should be removed for datagram sockets.
  726.  */
  727. static long sock_wait_for_wmem(struct sock * sk, long timeo)
  728. {
  729. DECLARE_WAITQUEUE(wait, current);
  731. clear_bit(SOCK_ASYNC_NOSPACE, &sk->socket->flags);
  732. add_wait_queue(sk->sleep, &wait);
  733. for (;;) {
  734. if (!timeo)
  735. break;
  736. if (signal_pending(current))
  737. break;
  738. set_bit(SOCK_NOSPACE, &sk->socket->flags);
  739. set_current_state(TASK_INTERRUPTIBLE);
  740. if (atomic_read(&sk->wmem_alloc) < sk->sndbuf)
  741. break;
  742. if (sk->shutdown & SEND_SHUTDOWN)
  743. break;
  744. if (sk->err)
  745. break;
  746. timeo = schedule_timeout(timeo);
  747. }
  748. __set_current_state(TASK_RUNNING);
  749. remove_wait_queue(sk->sleep, &wait);
  750. return timeo;
  751. }
  754. /*
  755.  * Generic send/receive buffer handlers
  756.  */
  758. struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
  759.      unsigned long data_len, int noblock, int *errcode)
  760. {
  761. struct sk_buff *skb;
  762. long timeo;
  763. int err;
  765. timeo = sock_sndtimeo(sk, noblock);
  766. while (1) {
  767. err = sock_error(sk);
  768. if (err != 0)
  769. goto failure;
  771. err = -EPIPE;
  772. if (sk->shutdown & SEND_SHUTDOWN)
  773. goto failure;
  775. if (atomic_read(&sk->wmem_alloc) < sk->sndbuf) {
  776. skb = alloc_skb(header_len, sk->allocation);
  777. if (skb) {
  778. int npages;
  779. int i;
  781. /* No pages, we're done... */
  782. if (!data_len)
  783. break;
  785. npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
  786. skb->truesize += data_len;
  787. skb_shinfo(skb)->nr_frags = npages;
  788. for (i = 0; i < npages; i++) {
  789. struct page *page;
  790. skb_frag_t *frag;
  792. page = alloc_pages(sk->allocation, 0);
  793. if (!page) {
  794. err = -ENOBUFS;
  795. kfree_skb(skb);
  796. goto failure;
  797. }
  799. frag = &skb_shinfo(skb)->frags[i];
  800. frag->page = page;
  801. frag->page_offset = 0;
  802. frag->size = (data_len >= PAGE_SIZE ?
  803.       PAGE_SIZE :
  804.       data_len);
  805. data_len -= PAGE_SIZE;
  806. }
  808. /* Full success... */
  809. break;
  810. }
  811. err = -ENOBUFS;
  812. goto failure;
  813. }
  814. set_bit(SOCK_ASYNC_NOSPACE, &sk->socket->flags);
  815. set_bit(SOCK_NOSPACE, &sk->socket->flags);
  816. err = -EAGAIN;
  817. if (!timeo)
  818. goto failure;
  819. if (signal_pending(current))
  820. goto interrupted;
  821. timeo = sock_wait_for_wmem(sk, timeo);
  822. }
  824. skb_set_owner_w(skb, sk);
  825. return skb;
  827. interrupted:
  828. err = sock_intr_errno(timeo);
  829. failure:
  830. *errcode = err;
  831. return NULL;
  832. }
  834. struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, 
  835.     int noblock, int *errcode)
  836. {
  837. return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
  838. }
  840. void __lock_sock(struct sock *sk)
  841. {
  842. DECLARE_WAITQUEUE(wait, current);
  844. add_wait_queue_exclusive(&sk->lock.wq, &wait);
  845. for(;;) {
  846. current->state = TASK_UNINTERRUPTIBLE;
  847. spin_unlock_bh(&sk->lock.slock);
  848. schedule();
  849. spin_lock_bh(&sk->lock.slock);
  850. if(!sk->lock.users)
  851. break;
  852. }
  853. current->state = TASK_RUNNING;
  854. remove_wait_queue(&sk->lock.wq, &wait);
  855. }
  857. void __release_sock(struct sock *sk)
  858. {
  859. struct sk_buff *skb = sk->backlog.head;
  861. do {
  862. sk->backlog.head = sk->backlog.tail = NULL;
  863. bh_unlock_sock(sk);
  865. do {
  866. struct sk_buff *next = skb->next;
  868. skb->next = NULL;
  869. sk->backlog_rcv(sk, skb);
  870. skb = next;
  871. } while (skb != NULL);
  873. bh_lock_sock(sk);
  874. } while((skb = sk->backlog.head) != NULL);
  875. }
  877. /*
  878.  * Generic socket manager library. Most simpler socket families
  879.  * use this to manage their socket lists. At some point we should
  880.  * hash these. By making this generic we get the lot hashed for free.
  881.  *
  882.  * It is broken by design. All the protocols using it must be fixed. --ANK
  883.  */
  885. rwlock_t net_big_sklist_lock = RW_LOCK_UNLOCKED;
  886.  
  887. void sklist_remove_socket(struct sock **list, struct sock *sk)
  888. {
  889. struct sock *s;
  891. write_lock_bh(&net_big_sklist_lock);
  893. while ((s = *list) != NULL) {
  894. if (s == sk) {
  895. *list = s->next;
  896. break;
  897. }
  898. list = &s->next;
  899. }
  901. write_unlock_bh(&net_big_sklist_lock);
  902. if (s)
  903. sock_put(s);
  904. }
  906. void sklist_insert_socket(struct sock **list, struct sock *sk)
  907. {
  908. write_lock_bh(&net_big_sklist_lock);
  909. sk->next= *list;
  910. *list=sk;
  911. sock_hold(sk);
  912. write_unlock_bh(&net_big_sklist_lock);
  913. }
  915. /*
  916.  * This is only called from user mode. Thus it protects itself against
  917.  * interrupt users but doesn't worry about being called during work.
  918.  * Once it is removed from the queue no interrupt or bottom half will
  919.  * touch it and we are (fairly 8-) ) safe.
  920.  */
  922. void sklist_destroy_socket(struct sock **list, struct sock *sk);
  924. /*
  925.  * Handler for deferred kills.
  926.  */
  928. static void sklist_destroy_timer(unsigned long data)
  929. {
  930. struct sock *sk=(struct sock *)data;
  931. sklist_destroy_socket(NULL,sk);
  932. }
  934. /*
  935.  * Destroy a socket. We pass NULL for a list if we know the
  936.  * socket is not on a list.
  937.  */
  938.  
  939. void sklist_destroy_socket(struct sock **list,struct sock *sk)
  940. {
  941. if(list)
  942. sklist_remove_socket(list, sk);
  944. skb_queue_purge(&sk->receive_queue);
  946. if(atomic_read(&sk->wmem_alloc) == 0 &&
  947.    atomic_read(&sk->rmem_alloc) == 0 &&
  948.    sk->dead)
  949. {
  950. sock_put(sk);
  951. }
  952. else
  953. {
  954. /*
  955.  * Someone is using our buffers still.. defer
  956.  */
  957. init_timer(&sk->timer);
  958. sk->timer.expires=jiffies+SOCK_DESTROY_TIME;
  959. sk->timer.function=sklist_destroy_timer;
  960. sk->timer.data = (unsigned long)sk;
  961. add_timer(&sk->timer);
  962. }
  963. }
  965. /*
  966.  * Set of default routines for initialising struct proto_ops when
  967.  * the protocol does not support a particular function. In certain
  968.  * cases where it makes no sense for a protocol to have a "do nothing"
  969.  * function, some default processing is provided.
  970.  */
  972. int sock_no_release(struct socket *sock)
  973. {
  974. return 0;
  975. }
  977. int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
  978. {
  979. return -EOPNOTSUPP;
  980. }
  982. int sock_no_connect(struct socket *sock, struct sockaddr *saddr, 
  983.     int len, int flags)
  984. {
  985. return -EOPNOTSUPP;
  986. }
  988. int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
  989. {
  990. return -EOPNOTSUPP;
  991. }
  993. int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
  994. {
  995. return -EOPNOTSUPP;
  996. }
  998. int sock_no_getname(struct socket *sock, struct sockaddr *saddr, 
  999.     int *len, int peer)
  1000. {
  1001. return -EOPNOTSUPP;
  1002. }
  1004. unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
  1005. {
  1006. return 0;
  1007. }
  1009. int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  1010. {
  1011. return -EOPNOTSUPP;
  1012. }
  1014. int sock_no_listen(struct socket *sock, int backlog)
  1015. {
  1016. return -EOPNOTSUPP;
  1017. }
  1019. int sock_no_shutdown(struct socket *sock, int how)
  1020. {
  1021. return -EOPNOTSUPP;
  1022. }
  1024. int sock_no_setsockopt(struct socket *sock, int level, int optname,
  1025.     char *optval, int optlen)
  1026. {
  1027. return -EOPNOTSUPP;
  1028. }
  1030. int sock_no_getsockopt(struct socket *sock, int level, int optname,
  1031.     char *optval, int *optlen)
  1032. {
  1033. return -EOPNOTSUPP;
  1034. }
  1036. /* 
  1037.  * Note: if you add something that sleeps here then change sock_fcntl()
  1038.  *       to do proper fd locking.
  1039.  */
  1040. int sock_no_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
  1041. {
  1042. struct sock *sk = sock->sk;
  1044. switch(cmd)
  1045. {
  1046. case F_SETOWN:
  1047. /*
  1048.  * This is a little restrictive, but it's the only
  1049.  * way to make sure that you can't send a sigurg to
  1050.  * another process.
  1051.  */
  1052. if (current->pgrp != -arg &&
  1053. current->pid != arg &&
  1054. !capable(CAP_KILL)) return(-EPERM);
  1055. sk->proc = arg;
  1056. return(0);
  1057. case F_GETOWN:
  1058. return(sk->proc);
  1059. default:
  1060. return(-EINVAL);
  1061. }
  1062. }
  1064. int sock_no_sendmsg(struct socket *sock, struct msghdr *m, int flags,
  1065.     struct scm_cookie *scm)
  1066. {
  1067. return -EOPNOTSUPP;
  1068. }
  1070. int sock_no_recvmsg(struct socket *sock, struct msghdr *m, int len, int flags,
  1071.     struct scm_cookie *scm)
  1072. {
  1073. return -EOPNOTSUPP;
  1074. }
  1076. int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
  1077. {
  1078. /* Mirror missing mmap method error code */
  1079. return -ENODEV;
  1080. }
  1082. ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
  1083. {
  1084. ssize_t res;
  1085. struct msghdr msg;
  1086. struct iovec iov;
  1087. mm_segment_t old_fs;
  1088. char *kaddr;
  1090. kaddr = kmap(page);
  1092. msg.msg_name = NULL;
  1093. msg.msg_namelen = 0;
  1094. msg.msg_iov = &iov;
  1095. msg.msg_iovlen = 1;
  1096. msg.msg_control = NULL;
  1097. msg.msg_controllen = 0;
  1098. msg.msg_flags = flags;
  1100. iov.iov_base = kaddr + offset;
  1101. iov.iov_len = size;
  1103. old_fs = get_fs();
  1104. set_fs(KERNEL_DS);
  1105. res = sock_sendmsg(sock, &msg, size);
  1106. set_fs(old_fs);
  1108. kunmap(page);
  1109. return res;
  1110. }
  1112. /*
  1113.  * Default Socket Callbacks
  1114.  */
  1116. void sock_def_wakeup(struct sock *sk)
  1117. {
  1118. read_lock(&sk->callback_lock);
  1119. if (sk->sleep && waitqueue_active(sk->sleep))
  1120. wake_up_interruptible_all(sk->sleep);
  1121. read_unlock(&sk->callback_lock);
  1122. }
  1124. void sock_def_error_report(struct sock *sk)
  1125. {
  1126. read_lock(&sk->callback_lock);
  1127. if (sk->sleep && waitqueue_active(sk->sleep))
  1128. wake_up_interruptible(sk->sleep);
  1129. sk_wake_async(sk,0,POLL_ERR); 
  1130. read_unlock(&sk->callback_lock);
  1131. }
  1133. void sock_def_readable(struct sock *sk, int len)
  1134. {
  1135. read_lock(&sk->callback_lock);
  1136. if (sk->sleep && waitqueue_active(sk->sleep))
  1137. wake_up_interruptible(sk->sleep);
  1138. sk_wake_async(sk,1,POLL_IN);
  1139. read_unlock(&sk->callback_lock);
  1140. }
  1142. void sock_def_write_space(struct sock *sk)
  1143. {
  1144. read_lock(&sk->callback_lock);
  1146. /* Do not wake up a writer until he can make "significant"
  1147.  * progress.  --DaveM
  1148.  */
  1149. if((atomic_read(&sk->wmem_alloc) << 1) <= sk->sndbuf) {
  1150. if (sk->sleep && waitqueue_active(sk->sleep))
  1151. wake_up_interruptible(sk->sleep);
  1153. /* Should agree with poll, otherwise some programs break */
  1154. if (sock_writeable(sk))
  1155. sk_wake_async(sk, 2, POLL_OUT);
  1156. }
  1158. read_unlock(&sk->callback_lock);
  1159. }
  1161. void sock_def_destruct(struct sock *sk)
  1162. {
  1163. if (sk->protinfo.destruct_hook)
  1164. kfree(sk->protinfo.destruct_hook);
  1165. }
  1167. void sock_init_data(struct socket *sock, struct sock *sk)
  1168. {
  1169. skb_queue_head_init(&sk->receive_queue);
  1170. skb_queue_head_init(&sk->write_queue);
  1171. skb_queue_head_init(&sk->error_queue);
  1173. init_timer(&sk->timer);
  1175. sk->allocation = GFP_KERNEL;
  1176. sk->rcvbuf = sysctl_rmem_default;
  1177. sk->sndbuf = sysctl_wmem_default;
  1178. sk->state  =  TCP_CLOSE;
  1179. sk->zapped = 1;
  1180. sk->socket = sock;
  1182. if(sock)
  1183. {
  1184. sk->type = sock->type;
  1185. sk->sleep = &sock->wait;
  1186. sock->sk = sk;
  1187. } else
  1188. sk->sleep = NULL;
  1190. sk->dst_lock = RW_LOCK_UNLOCKED;
  1191. sk->callback_lock = RW_LOCK_UNLOCKED;
  1193. sk->state_change = sock_def_wakeup;
  1194. sk->data_ready = sock_def_readable;
  1195. sk->write_space = sock_def_write_space;
  1196. sk->error_report = sock_def_error_report;
  1197. sk->destruct            =       sock_def_destruct;
  1199. sk->peercred.pid  = 0;
  1200. sk->peercred.uid = -1;
  1201. sk->peercred.gid = -1;
  1202. sk->rcvlowat = 1;
  1203. sk->rcvtimeo = MAX_SCHEDULE_TIMEOUT;
  1204. sk->sndtimeo = MAX_SCHEDULE_TIMEOUT;
  1206. atomic_set(&sk->refcnt, 1);
  1207. }