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

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

嵌入式Linux

开发平台：

Unix_Linux

sock.h：源码内容
  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.  * Definitions for the AF_INET socket handler.
  7.  *
  8.  * Version: @(#)sock.h 1.0.4 05/13/93
  9.  *
  10.  * Authors: Ross Biro, <bir7@leland.Stanford.Edu>
  11.  * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12.  * Corey Minyard <wf-rch!minyard@relay.EU.net>
  13.  * Florian La Roche <flla@stud.uni-sb.de>
  14.  *
  15.  * Fixes:
  16.  * Alan Cox : Volatiles in skbuff pointers. See
  17.  * skbuff comments. May be overdone,
  18.  * better to prove they can be removed
  19.  * than the reverse.
  20.  * Alan Cox : Added a zapped field for tcp to note
  21.  * a socket is reset and must stay shut up
  22.  * Alan Cox : New fields for options
  23.  * Pauline Middelink : identd support
  24.  * Alan Cox : Eliminate low level recv/recvfrom
  25.  * David S. Miller : New socket lookup architecture.
  26.  *              Steve Whitehouse:       Default routines for sock_ops
  27.  *
  28.  * This program is free software; you can redistribute it and/or
  29.  * modify it under the terms of the GNU General Public License
  30.  * as published by the Free Software Foundation; either version
  31.  * 2 of the License, or (at your option) any later version.
  32.  */
  33. #ifndef _SOCK_H
  34. #define _SOCK_H
  36. #include <linux/config.h>
  37. #include <linux/timer.h>
  38. #include <linux/cache.h>
  39. #include <linux/in.h> /* struct sockaddr_in */
  41. #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
  42. #include <linux/in6.h> /* struct sockaddr_in6 */
  43. #include <linux/ipv6.h> /* dest_cache, inet6_options */
  44. #include <linux/icmpv6.h>
  45. #include <net/if_inet6.h> /* struct ipv6_mc_socklist */
  46. #endif
  48. #if defined(CONFIG_INET) || defined (CONFIG_INET_MODULE)
  49. #include <linux/icmp.h>
  50. #endif
  51. #include <linux/tcp.h> /* struct tcphdr */
  53. #include <linux/netdevice.h>
  54. #include <linux/skbuff.h> /* struct sk_buff */
  55. #include <net/protocol.h> /* struct inet_protocol */
  56. #if defined(CONFIG_X25) || defined(CONFIG_X25_MODULE)
  57. #include <net/x25.h>
  58. #endif
  59. #if defined(CONFIG_WAN_ROUTER) || defined(CONFIG_WAN_ROUTER_MODULE)
  60. #include <linux/if_wanpipe.h>
  61. #endif
  63. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  64. #include <net/ax25.h>
  65. #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
  66. #include <net/netrom.h>
  67. #endif
  68. #if defined(CONFIG_ROSE) || defined(CONFIG_ROSE_MODULE)
  69. #include <net/rose.h>
  70. #endif
  71. #endif
  73. #if defined(CONFIG_PPPOE) || defined(CONFIG_PPPOE_MODULE)
  74. #include <linux/if_pppox.h>
  75. #include <linux/ppp_channel.h>   /* struct ppp_channel */
  76. #endif
  78. #if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE)
  79. #if defined(CONFIG_SPX) || defined(CONFIG_SPX_MODULE)
  80. #include <net/spx.h>
  81. #else
  82. #include <net/ipx.h>
  83. #endif /* CONFIG_SPX */
  84. #endif /* CONFIG_IPX */
  86. #if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
  87. #include <linux/atalk.h>
  88. #endif
  90. #if defined(CONFIG_DECNET) || defined(CONFIG_DECNET_MODULE)
  91. #include <net/dn.h>
  92. #endif
  94. #if defined(CONFIG_IRDA) || defined(CONFIG_IRDA_MODULE)
  95. #include <net/irda/irda.h>
  96. #endif
  98. #if defined(CONFIG_ATM) || defined(CONFIG_ATM_MODULE)
  99. struct atm_vcc;
  100. #endif
  102. #ifdef CONFIG_FILTER
  103. #include <linux/filter.h>
  104. #endif
  106. #include <asm/atomic.h>
  107. #include <net/dst.h>
  110. /* The AF_UNIX specific socket options */
  111. struct unix_opt {
  112. struct unix_address *addr;
  113. struct dentry * dentry;
  114. struct vfsmount * mnt;
  115. struct semaphore readsem;
  116. struct sock * other;
  117. struct sock ** list;
  118. struct sock * gc_tree;
  119. atomic_t inflight;
  120. rwlock_t lock;
  121. wait_queue_head_t peer_wait;
  122. };
  125. /* Once the IPX ncpd patches are in these are going into protinfo. */
  126. #if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE)
  127. struct ipx_opt {
  128. ipx_address dest_addr;
  129. ipx_interface *intrfc;
  130. unsigned short port;
  131. #ifdef CONFIG_IPX_INTERN
  132. unsigned char           node[IPX_NODE_LEN];
  133. #endif
  134. unsigned short type;
  135. /* 
  136.  * To handle special ncp connection-handling sockets for mars_nwe,
  137.  * the connection number must be stored in the socket.
  138.  */
  139. unsigned short ipx_ncp_conn;
  140. };
  141. #endif
  143. #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
  144. struct ipv6_pinfo {
  145. struct in6_addr  saddr;
  146. struct in6_addr  rcv_saddr;
  147. struct in6_addr daddr;
  148. struct in6_addr *daddr_cache;
  150. __u32 flow_label;
  151. __u32 frag_size;
  152. int hop_limit;
  153. int mcast_hops;
  154. int mcast_oif;
  156. /* pktoption flags */
  157. union {
  158. struct {
  159. __u8 srcrt:2,
  160.         rxinfo:1,
  161. rxhlim:1,
  162. hopopts:1,
  163. dstopts:1,
  164.                                 authhdr:1,
  165.                                 rxflow:1;
  166. } bits;
  167. __u8 all;
  168. } rxopt;
  170. /* sockopt flags */
  171. __u8 mc_loop:1,
  172.                         recverr:1,
  173.                         sndflow:1,
  174.                         pmtudisc:2;
  176. struct ipv6_mc_socklist *ipv6_mc_list;
  177. struct ipv6_fl_socklist *ipv6_fl_list;
  178. __u32 dst_cookie;
  180. struct ipv6_txoptions *opt;
  181. struct sk_buff *pktoptions;
  182. };
  184. struct raw6_opt {
  185. __u32 checksum; /* perform checksum */
  186. __u32 offset; /* checksum offset  */
  188. struct icmp6_filter filter;
  189. };
  191. #endif /* IPV6 */
  193. #if defined(CONFIG_INET) || defined(CONFIG_INET_MODULE)
  194. struct raw_opt {
  195. struct icmp_filter filter;
  196. };
  197. #endif
  199. #if defined(CONFIG_INET) || defined (CONFIG_INET_MODULE)
  200. struct inet_opt
  201. {
  202. int ttl; /* TTL setting */
  203. int tos; /* TOS */
  204. unsigned     cmsg_flags;
  205. struct ip_options *opt;
  206. unsigned char hdrincl; /* Include headers ? */
  207. __u8 mc_ttl; /* Multicasting TTL */
  208. __u8 mc_loop; /* Loopback */
  209. unsigned recverr : 1,
  210. freebind : 1;
  211. __u16 id; /* ID counter for DF pkts */
  212. __u8 pmtudisc;
  213. int mc_index; /* Multicast device index */
  214. __u32 mc_addr;
  215. struct ip_mc_socklist *mc_list; /* Group array */
  216. };
  217. #endif
  219. #if defined(CONFIG_PPPOE) || defined (CONFIG_PPPOE_MODULE)
  220. struct pppoe_opt
  221. {
  222. struct net_device      *dev;   /* device associated with socket*/
  223. struct pppoe_addr pa;   /* what this socket is bound to*/
  224. struct sockaddr_pppox relay;   /* what socket data will be
  225.      relayed to (PPPoE relaying) */
  226. };
  228. struct pppox_opt
  229. {
  230. struct ppp_channel chan;
  231. struct sock *sk;
  232. struct pppox_opt *next;   /* for hash table */
  233. union {
  234. struct pppoe_opt pppoe;
  235. } proto;
  236. };
  237. #define pppoe_dev proto.pppoe.dev
  238. #define pppoe_pa proto.pppoe.pa
  239. #define pppoe_relay proto.pppoe.relay
  240. #endif
  242. /* This defines a selective acknowledgement block. */
  243. struct tcp_sack_block {
  244. __u32 start_seq;
  245. __u32 end_seq;
  246. };
  248. struct tcp_opt {
  249. int tcp_header_len; /* Bytes of tcp header to send */
  251. /*
  252.  * Header prediction flags
  253.  * 0x5?10 << 16 + snd_wnd in net byte order
  254.  */
  255. __u32 pred_flags;
  257. /*
  258.  * RFC793 variables by their proper names. This means you can
  259.  * read the code and the spec side by side (and laugh ...)
  260.  * See RFC793 and RFC1122. The RFC writes these in capitals.
  261.  */
  262.   __u32 rcv_nxt; /* What we want to receive next  */
  263.   __u32 snd_nxt; /* Next sequence we send */
  265.   __u32 snd_una; /* First byte we want an ack for */
  266.   __u32 snd_sml; /* Last byte of the most recently transmitted small packet */
  267. __u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */
  268. __u32 lsndtime; /* timestamp of last sent data packet (for restart window) */
  270. /* Delayed ACK control data */
  271. struct {
  272. __u8 pending; /* ACK is pending */
  273. __u8 quick; /* Scheduled number of quick acks */
  274. __u8 pingpong; /* The session is interactive */
  275. __u8 blocked; /* Delayed ACK was blocked by socket lock*/
  276. __u32 ato; /* Predicted tick of soft clock */
  277. unsigned long timeout; /* Currently scheduled timeout */
  278. __u32 lrcvtime; /* timestamp of last received data packet*/
  279. __u16 last_seg_size; /* Size of last incoming segment */
  280. __u16 rcv_mss; /* MSS used for delayed ACK decisions */ 
  281. } ack;
  283. /* Data for direct copy to user */
  284. struct {
  285. struct sk_buff_head prequeue;
  286. int memory;
  287. struct task_struct *task;
  288. struct iovec *iov;
  289. int len;
  290. } ucopy;
  292. __u32 snd_wl1; /* Sequence for window update */
  293. __u32 snd_wnd; /* The window we expect to receive */
  294. __u32 max_window; /* Maximal window ever seen from peer */
  295. __u32 pmtu_cookie; /* Last pmtu seen by socket */
  296. __u16 mss_cache; /* Cached effective mss, not including SACKS */
  297. __u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
  298. __u16 ext_header_len; /* Network protocol overhead (IP/IPv6 options) */
  299. __u8 ca_state; /* State of fast-retransmit machine  */
  300. __u8 retransmits; /* Number of unrecovered RTO timeouts. */
  302. __u8 reordering; /* Packet reordering metric. */
  303. __u8 queue_shrunk; /* Write queue has been shrunk recently.*/
  304. __u8 defer_accept; /* User waits for some data after accept() */
  306. /* RTT measurement */
  307. __u8 backoff; /* backoff */
  308. __u32 srtt; /* smothed round trip time << 3 */
  309. __u32 mdev; /* medium deviation */
  310. __u32 mdev_max; /* maximal mdev for the last rtt period */
  311. __u32 rttvar; /* smoothed mdev_max */
  312. __u32 rtt_seq; /* sequence number to update rttvar */
  313. __u32 rto; /* retransmit timeout */
  315. __u32 packets_out; /* Packets which are "in flight" */
  316. __u32 left_out; /* Packets which leaved network */
  317. __u32 retrans_out; /* Retransmitted packets out */
  320. /*
  321.  * Slow start and congestion control (see also Nagle, and Karn & Partridge)
  322.  */
  323.   __u32 snd_ssthresh; /* Slow start size threshold */
  324.   __u32 snd_cwnd; /* Sending congestion window */
  325.   __u16 snd_cwnd_cnt; /* Linear increase counter */
  326. __u16 snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */
  327. __u32 snd_cwnd_used;
  328. __u32 snd_cwnd_stamp;
  330. /* Two commonly used timers in both sender and receiver paths. */
  331. unsigned long timeout;
  332.   struct timer_list retransmit_timer; /* Resend (no ack) */
  333.   struct timer_list delack_timer; /* Ack delay  */
  335. struct sk_buff_head out_of_order_queue; /* Out of order segments go here */
  337. struct tcp_func *af_specific; /* Operations which are AF_INET{4,6} specific */
  338. struct sk_buff *send_head; /* Front of stuff to transmit */
  339. struct page *sndmsg_page; /* Cached page for sendmsg */
  340. u32 sndmsg_off; /* Cached offset for sendmsg */
  342.   __u32 rcv_wnd; /* Current receiver window */
  343. __u32 rcv_wup; /* rcv_nxt on last window update sent */
  344. __u32 write_seq; /* Tail(+1) of data held in tcp send buffer */
  345. __u32 pushed_seq; /* Last pushed seq, required to talk to windows */
  346. __u32 copied_seq; /* Head of yet unread data */
  347. /*
  348.  *      Options received (usually on last packet, some only on SYN packets).
  349.  */
  350. char tstamp_ok, /* TIMESTAMP seen on SYN packet */
  351. wscale_ok, /* Wscale seen on SYN packet */
  352. sack_ok; /* SACK seen on SYN packet */
  353. char saw_tstamp; /* Saw TIMESTAMP on last packet */
  354.         __u8 snd_wscale; /* Window scaling received from sender */
  355.         __u8 rcv_wscale; /* Window scaling to send to receiver */
  356. __u8 nonagle; /* Disable Nagle algorithm?             */
  357. __u8 keepalive_probes; /* num of allowed keep alive probes */
  359. /* PAWS/RTTM data */
  360.         __u32 rcv_tsval; /* Time stamp value              */
  361.         __u32 rcv_tsecr; /* Time stamp echo reply         */
  362.         __u32 ts_recent; /* Time stamp to echo next */
  363.         long ts_recent_stamp;/* Time we stored ts_recent (for aging) */
  365. /* SACKs data */
  366. __u16 user_mss;   /* mss requested by user in ioctl */
  367. __u8 dsack; /* D-SACK is scheduled */
  368. __u8 eff_sacks; /* Size of SACK array to send with next packet */
  369. struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
  370. struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
  372. __u32 window_clamp; /* Maximal window to advertise */
  373. __u32 rcv_ssthresh; /* Current window clamp */
  374. __u8 probes_out; /* unanswered 0 window probes */
  375. __u8 num_sacks; /* Number of SACK blocks */
  376. __u16 advmss; /* Advertised MSS */
  378. __u8 syn_retries; /* num of allowed syn retries */
  379. __u8 ecn_flags; /* ECN status bits. */
  380. __u16 prior_ssthresh; /* ssthresh saved at recovery start */
  381. __u32 lost_out; /* Lost packets */
  382. __u32 sacked_out; /* SACK'd packets */
  383. __u32 fackets_out; /* FACK'd packets */
  384. __u32 high_seq; /* snd_nxt at onset of congestion */
  386. __u32 retrans_stamp; /* Timestamp of the last retransmit,
  387.  * also used in SYN-SENT to remember stamp of
  388.  * the first SYN. */
  389. __u32 undo_marker; /* tracking retrans started here. */
  390. int undo_retrans; /* number of undoable retransmissions. */
  391. __u32 urg_seq; /* Seq of received urgent pointer */
  392. __u16 urg_data; /* Saved octet of OOB data and control flags */
  393. __u8 pending; /* Scheduled timer event */
  394. __u8 urg_mode; /* In urgent mode */
  395. __u32 snd_up; /* Urgent pointer */
  397. /* The syn_wait_lock is necessary only to avoid tcp_get_info having
  398.  * to grab the main lock sock while browsing the listening hash
  399.  * (otherwise it's deadlock prone).
  400.  * This lock is acquired in read mode only from tcp_get_info() and
  401.  * it's acquired in write mode _only_ from code that is actively
  402.  * changing the syn_wait_queue. All readers that are holding
  403.  * the master sock lock don't need to grab this lock in read mode
  404.  * too as the syn_wait_queue writes are always protected from
  405.  * the main sock lock.
  406.  */
  407. rwlock_t syn_wait_lock;
  408. struct tcp_listen_opt *listen_opt;
  410. /* FIFO of established children */
  411. struct open_request *accept_queue;
  412. struct open_request *accept_queue_tail;
  414. int write_pending; /* A write to socket waits to start. */
  416. unsigned int keepalive_time;   /* time before keep alive takes place */
  417. unsigned int keepalive_intvl;  /* time interval between keep alive probes */
  418. int linger2;
  420. unsigned long last_synq_overflow; 
  421. };
  423.  
  424. /*
  425.  * This structure really needs to be cleaned up.
  426.  * Most of it is for TCP, and not used by any of
  427.  * the other protocols.
  428.  */
  430. /*
  431.  * The idea is to start moving to a newer struct gradualy
  432.  * 
  433.  * IMHO the newer struct should have the following format:
  434.  * 
  435.  * struct sock {
  436.  * sockmem [mem, proto, callbacks]
  437.  *
  438.  * union or struct {
  439.  * ax25;
  440.  * } ll_pinfo;
  441.  *
  442.  * union {
  443.  * ipv4;
  444.  * ipv6;
  445.  * ipx;
  446.  * netrom;
  447.  * rose;
  448.  *  x25;
  449.  * } net_pinfo;
  450.  *
  451.  * union {
  452.  * tcp;
  453.  * udp;
  454.  * spx;
  455.  * netrom;
  456.  * } tp_pinfo;
  457.  *
  458.  * }
  459.  *
  460.  * The idea failed because IPv6 transition asssumes dual IP/IPv6 sockets.
  461.  * So, net_pinfo is IPv6 are really, and protinfo unifies all another
  462.  * private areas.
  463.  */
  465. /* Define this to get the sk->debug debugging facility. */
  466. #define SOCK_DEBUGGING
  467. #ifdef SOCK_DEBUGGING
  468. #define SOCK_DEBUG(sk, msg...) do { if((sk) && ((sk)->debug)) printk(KERN_DEBUG msg); } while (0)
  469. #else
  470. #define SOCK_DEBUG(sk, msg...) do { } while (0)
  471. #endif
  473. /* This is the per-socket lock.  The spinlock provides a synchronization
  474.  * between user contexts and software interrupt processing, whereas the
  475.  * mini-semaphore synchronizes multiple users amongst themselves.
  476.  */
  477. typedef struct {
  478. spinlock_t slock;
  479. unsigned int users;
  480. wait_queue_head_t wq;
  481. } socket_lock_t;
  483. #define sock_lock_init(__sk) 
  484. do { spin_lock_init(&((__sk)->lock.slock)); 
  485. (__sk)->lock.users = 0; 
  486. init_waitqueue_head(&((__sk)->lock.wq)); 
  487. } while(0);
  489. struct sock {
  490. /* Socket demultiplex comparisons on incoming packets. */
  491. __u32 daddr; /* Foreign IPv4 addr */
  492. __u32 rcv_saddr; /* Bound local IPv4 addr */
  493. __u16 dport; /* Destination port */
  494. unsigned short num; /* Local port */
  495. int bound_dev_if; /* Bound device index if != 0 */
  497. /* Main hash linkage for various protocol lookup tables. */
  498. struct sock *next;
  499. struct sock **pprev;
  500. struct sock *bind_next;
  501. struct sock **bind_pprev;
  503. volatile unsigned char state, /* Connection state */
  504. zapped; /* In ax25 & ipx means not linked */
  505. __u16 sport; /* Source port */
  507. unsigned short family; /* Address family */
  508. unsigned char reuse; /* SO_REUSEADDR setting */
  509. unsigned char shutdown;
  510. atomic_t refcnt; /* Reference count */
  512. socket_lock_t lock; /* Synchronizer... */
  513. int rcvbuf; /* Size of receive buffer in bytes */
  515. wait_queue_head_t *sleep; /* Sock wait queue */
  516. struct dst_entry *dst_cache; /* Destination cache */
  517. rwlock_t dst_lock;
  518. atomic_t rmem_alloc; /* Receive queue bytes committed */
  519. struct sk_buff_head receive_queue; /* Incoming packets */
  520. atomic_t wmem_alloc; /* Transmit queue bytes committed */
  521. struct sk_buff_head write_queue; /* Packet sending queue */
  522. atomic_t omem_alloc; /* "o" is "option" or "other" */
  523. int wmem_queued; /* Persistent queue size */
  524. int forward_alloc; /* Space allocated forward. */
  525. __u32 saddr; /* Sending source */
  526. unsigned int allocation; /* Allocation mode */
  527. int sndbuf; /* Size of send buffer in bytes */
  528. struct sock *prev;
  530. /* Not all are volatile, but some are, so we might as well say they all are.
  531.  * XXX Make this a flag word -DaveM
  532.  */
  533. volatile char dead,
  534. done,
  535. urginline,
  536. keepopen,
  537. linger,
  538. destroy,
  539. no_check,
  540. broadcast,
  541. bsdism;
  542. unsigned char debug;
  543. unsigned char rcvtstamp;
  544. unsigned char use_write_queue;
  545. unsigned char userlocks;
  546. /* Hole of 3 bytes. Try to pack. */
  547. int route_caps;
  548. int proc;
  549. unsigned long         lingertime;
  551. int hashent;
  552. struct sock *pair;
  554. /* The backlog queue is special, it is always used with
  555.  * the per-socket spinlock held and requires low latency
  556.  * access.  Therefore we special case it's implementation.
  557.  */
  558. struct {
  559. struct sk_buff *head;
  560. struct sk_buff *tail;
  561. } backlog;
  563. rwlock_t callback_lock;
  565. /* Error queue, rarely used. */
  566. struct sk_buff_head error_queue;
  568. struct proto *prot;
  570. #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
  571. union {
  572. struct ipv6_pinfo af_inet6;
  573. } net_pinfo;
  574. #endif
  576. union {
  577. struct tcp_opt af_tcp;
  578. #if defined(CONFIG_INET) || defined (CONFIG_INET_MODULE)
  579. struct raw_opt tp_raw4;
  580. #endif
  581. #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
  582. struct raw6_opt tp_raw;
  583. #endif /* CONFIG_IPV6 */
  584. #if defined(CONFIG_SPX) || defined (CONFIG_SPX_MODULE)
  585. struct spx_opt af_spx;
  586. #endif /* CONFIG_SPX */
  588. } tp_pinfo;
  590. int err, err_soft; /* Soft holds errors that don't
  591.    cause failure but are the cause
  592.    of a persistent failure not just
  593.    'timed out' */
  594. unsigned short ack_backlog;
  595. unsigned short max_ack_backlog;
  596. __u32 priority;
  597. unsigned short type;
  598. unsigned char localroute; /* Route locally only */
  599. unsigned char protocol;
  600. struct ucred peercred;
  601. int rcvlowat;
  602. long rcvtimeo;
  603. long sndtimeo;
  605. #ifdef CONFIG_FILTER
  606. /* Socket Filtering Instructions */
  607. struct sk_filter       *filter;
  608. #endif /* CONFIG_FILTER */
  610. /* This is where all the private (optional) areas that don't
  611.  * overlap will eventually live. 
  612.  */
  613. union {
  614. void *destruct_hook;
  615.    struct unix_opt af_unix;
  616. #if defined(CONFIG_INET) || defined (CONFIG_INET_MODULE)
  617. struct inet_opt af_inet;
  618. #endif
  619. #if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
  620. struct atalk_sock af_at;
  621. #endif
  622. #if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE)
  623. struct ipx_opt af_ipx;
  624. #endif
  625. #if defined (CONFIG_DECNET) || defined(CONFIG_DECNET_MODULE)
  626. struct dn_scp           dn;
  627. #endif
  628. #if defined (CONFIG_PACKET) || defined(CONFIG_PACKET_MODULE)
  629. struct packet_opt *af_packet;
  630. #endif
  631. #if defined(CONFIG_X25) || defined(CONFIG_X25_MODULE)
  632. x25_cb *x25;
  633. #endif
  634. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  635. ax25_cb *ax25;
  636. #endif
  637. #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
  638. nr_cb *nr;
  639. #endif
  640. #if defined(CONFIG_ROSE) || defined(CONFIG_ROSE_MODULE)
  641. rose_cb *rose;
  642. #endif
  643. #if defined(CONFIG_PPPOE) || defined(CONFIG_PPPOE_MODULE)
  644. struct pppox_opt *pppox;
  645. #endif
  646. struct netlink_opt *af_netlink;
  647. #if defined(CONFIG_ECONET) || defined(CONFIG_ECONET_MODULE)
  648. struct econet_opt *af_econet;
  649. #endif
  650. #if defined(CONFIG_ATM) || defined(CONFIG_ATM_MODULE)
  651. struct atm_vcc *af_atm;
  652. #endif
  653. #if defined(CONFIG_IRDA) || defined(CONFIG_IRDA_MODULE)
  654. struct irda_sock        *irda;
  655. #endif
  656. #if defined(CONFIG_WAN_ROUTER) || defined(CONFIG_WAN_ROUTER_MODULE)
  657.                struct wanpipe_opt      *af_wanpipe;
  658. #endif
  659. } protinfo;  
  662. /* This part is used for the timeout functions. */
  663. struct timer_list timer; /* This is the sock cleanup timer. */
  664. struct timeval stamp;
  666. /* Identd and reporting IO signals */
  667. struct socket *socket;
  669. /* RPC layer private data */
  670. void *user_data;
  671.   
  672. /* Callbacks */
  673. void (*state_change)(struct sock *sk);
  674. void (*data_ready)(struct sock *sk,int bytes);
  675. void (*write_space)(struct sock *sk);
  676. void (*error_report)(struct sock *sk);
  678.    int (*backlog_rcv) (struct sock *sk,
  679. struct sk_buff *skb);  
  680. void                    (*destruct)(struct sock *sk);
  681. };
  683. /* The per-socket spinlock must be held here. */
  684. #define sk_add_backlog(__sk, __skb)
  685. do { if((__sk)->backlog.tail == NULL) {
  686. (__sk)->backlog.head =
  687.      (__sk)->backlog.tail = (__skb);
  688. } else {
  689. ((__sk)->backlog.tail)->next = (__skb);
  690. (__sk)->backlog.tail = (__skb);
  691. }
  692. (__skb)->next = NULL;
  693. } while(0)
  695. /* IP protocol blocks we attach to sockets.
  696.  * socket layer -> transport layer interface
  697.  * transport -> network interface is defined by struct inet_proto
  698.  */
  699. struct proto {
  700. void (*close)(struct sock *sk, 
  701. long timeout);
  702. int (*connect)(struct sock *sk,
  703.         struct sockaddr *uaddr, 
  704. int addr_len);
  705. int (*disconnect)(struct sock *sk, int flags);
  707. struct sock * (*accept) (struct sock *sk, int flags, int *err);
  709. int (*ioctl)(struct sock *sk, int cmd,
  710.  unsigned long arg);
  711. int (*init)(struct sock *sk);
  712. int (*destroy)(struct sock *sk);
  713. void (*shutdown)(struct sock *sk, int how);
  714. int (*setsockopt)(struct sock *sk, int level, 
  715. int optname, char *optval, int optlen);
  716. int (*getsockopt)(struct sock *sk, int level, 
  717. int optname, char *optval, 
  718. int *option);    
  719. int (*sendmsg)(struct sock *sk, struct msghdr *msg,
  720.    int len);
  721. int (*recvmsg)(struct sock *sk, struct msghdr *msg,
  722. int len, int noblock, int flags, 
  723. int *addr_len);
  724. int (*bind)(struct sock *sk, 
  725. struct sockaddr *uaddr, int addr_len);
  727. int (*backlog_rcv) (struct sock *sk, 
  728. struct sk_buff *skb);
  730. /* Keeping track of sk's, looking them up, and port selection methods. */
  731. void (*hash)(struct sock *sk);
  732. void (*unhash)(struct sock *sk);
  733. int (*get_port)(struct sock *sk, unsigned short snum);
  735. char name[32];
  737. struct {
  738. int inuse;
  739. u8  __pad[SMP_CACHE_BYTES - sizeof(int)];
  740. } stats[NR_CPUS];
  741. };
  743. /* Called with local bh disabled */
  744. static __inline__ void sock_prot_inc_use(struct proto *prot)
  745. {
  746. prot->stats[smp_processor_id()].inuse++;
  747. }
  749. static __inline__ void sock_prot_dec_use(struct proto *prot)
  750. {
  751. prot->stats[smp_processor_id()].inuse--;
  752. }
  754. /* About 10 seconds */
  755. #define SOCK_DESTROY_TIME (10*HZ)
  757. /* Sockets 0-1023 can't be bound to unless you are superuser */
  758. #define PROT_SOCK 1024
  760. #define SHUTDOWN_MASK 3
  761. #define RCV_SHUTDOWN 1
  762. #define SEND_SHUTDOWN 2
  764. #define SOCK_SNDBUF_LOCK 1
  765. #define SOCK_RCVBUF_LOCK 2
  766. #define SOCK_BINDADDR_LOCK 4
  767. #define SOCK_BINDPORT_LOCK 8
  770. /* Used by processes to "lock" a socket state, so that
  771.  * interrupts and bottom half handlers won't change it
  772.  * from under us. It essentially blocks any incoming
  773.  * packets, so that we won't get any new data or any
  774.  * packets that change the state of the socket.
  775.  *
  776.  * While locked, BH processing will add new packets to
  777.  * the backlog queue.  This queue is processed by the
  778.  * owner of the socket lock right before it is released.
  779.  *
  780.  * Since ~2.3.5 it is also exclusive sleep lock serializing
  781.  * accesses from user process context.
  782.  */
  783. extern void __lock_sock(struct sock *sk);
  784. extern void __release_sock(struct sock *sk);
  785. #define lock_sock(__sk) 
  786. do { spin_lock_bh(&((__sk)->lock.slock)); 
  787. if ((__sk)->lock.users != 0) 
  788. __lock_sock(__sk); 
  789. (__sk)->lock.users = 1; 
  790. spin_unlock_bh(&((__sk)->lock.slock)); 
  791. } while(0)
  793. #define release_sock(__sk) 
  794. do { spin_lock_bh(&((__sk)->lock.slock)); 
  795. if ((__sk)->backlog.tail != NULL) 
  796. __release_sock(__sk); 
  797. (__sk)->lock.users = 0; 
  798.         if (waitqueue_active(&((__sk)->lock.wq))) wake_up(&((__sk)->lock.wq)); 
  799. spin_unlock_bh(&((__sk)->lock.slock)); 
  800. } while(0)
  802. /* BH context may only use the following locking interface. */
  803. #define bh_lock_sock(__sk) spin_lock(&((__sk)->lock.slock))
  804. #define bh_unlock_sock(__sk) spin_unlock(&((__sk)->lock.slock))
  806. extern struct sock * sk_alloc(int family, int priority, int zero_it);
  807. extern void sk_free(struct sock *sk);
  809. extern struct sk_buff *sock_wmalloc(struct sock *sk,
  810.       unsigned long size, int force,
  811.       int priority);
  812. extern struct sk_buff *sock_rmalloc(struct sock *sk,
  813.       unsigned long size, int force,
  814.       int priority);
  815. extern void sock_wfree(struct sk_buff *skb);
  816. extern void sock_rfree(struct sk_buff *skb);
  818. extern int sock_setsockopt(struct socket *sock, int level,
  819. int op, char *optval,
  820. int optlen);
  822. extern int sock_getsockopt(struct socket *sock, int level,
  823. int op, char *optval, 
  824. int *optlen);
  825. extern struct sk_buff  *sock_alloc_send_skb(struct sock *sk,
  826.      unsigned long size,
  827.      int noblock,
  828.      int *errcode);
  829. extern struct sk_buff  *sock_alloc_send_pskb(struct sock *sk,
  830.       unsigned long header_len,
  831.       unsigned long data_len,
  832.       int noblock,
  833.       int *errcode);
  834. extern void *sock_kmalloc(struct sock *sk, int size, int priority);
  835. extern void sock_kfree_s(struct sock *sk, void *mem, int size);
  837. /*
  838.  * Functions to fill in entries in struct proto_ops when a protocol
  839.  * does not implement a particular function.
  840.  */
  841. extern int                      sock_no_release(struct socket *);
  842. extern int                      sock_no_bind(struct socket *, 
  843.      struct sockaddr *, int);
  844. extern int                      sock_no_connect(struct socket *,
  845. struct sockaddr *, int, int);
  846. extern int                      sock_no_socketpair(struct socket *,
  847.    struct socket *);
  848. extern int                      sock_no_accept(struct socket *,
  849.        struct socket *, int);
  850. extern int                      sock_no_getname(struct socket *,
  851. struct sockaddr *, int *, int);
  852. extern unsigned int             sock_no_poll(struct file *, struct socket *,
  853.      struct poll_table_struct *);
  854. extern int                      sock_no_ioctl(struct socket *, unsigned int,
  855.       unsigned long);
  856. extern int sock_no_listen(struct socket *, int);
  857. extern int                      sock_no_shutdown(struct socket *, int);
  858. extern int sock_no_getsockopt(struct socket *, int , int,
  859.    char *, int *);
  860. extern int sock_no_setsockopt(struct socket *, int, int,
  861.    char *, int);
  862. extern int  sock_no_fcntl(struct socket *, 
  863.       unsigned int, unsigned long);
  864. extern int                      sock_no_sendmsg(struct socket *,
  865. struct msghdr *, int,
  866. struct scm_cookie *);
  867. extern int                      sock_no_recvmsg(struct socket *,
  868. struct msghdr *, int, int,
  869. struct scm_cookie *);
  870. extern int sock_no_mmap(struct file *file,
  871.      struct socket *sock,
  872.      struct vm_area_struct *vma);
  873. extern ssize_t sock_no_sendpage(struct socket *sock,
  874. struct page *page,
  875. int offset, size_t size, 
  876. int flags);
  878. /*
  879.  * Default socket callbacks and setup code
  880.  */
  881.  
  882. extern void sock_def_destruct(struct sock *);
  884. /* Initialise core socket variables */
  885. extern void sock_init_data(struct socket *sock, struct sock *sk);
  887. extern void sklist_remove_socket(struct sock **list, struct sock *sk);
  888. extern void sklist_insert_socket(struct sock **list, struct sock *sk);
  889. extern void sklist_destroy_socket(struct sock **list, struct sock *sk);
  891. #ifdef CONFIG_FILTER
  893. /**
  894.  * sk_filter - run a packet through a socket filter
  895.  * @skb: buffer to filter
  896.  * @filter: filter to apply
  897.  *
  898.  * Run the filter code and then cut skb->data to correct size returned by
  899.  * sk_run_filter. If pkt_len is 0 we toss packet. If skb->len is smaller
  900.  * than pkt_len we keep whole skb->data. This is the socket level
  901.  * wrapper to sk_run_filter. It returns 0 if the packet should
  902.  * be accepted or 1 if the packet should be tossed.
  903.  */
  904.  
  905. static inline int sk_filter(struct sk_buff *skb, struct sk_filter *filter)
  906. {
  907. int pkt_len;
  909.         pkt_len = sk_run_filter(skb, filter->insns, filter->len);
  910.         if(!pkt_len)
  911.                 return 1; /* Toss Packet */
  912.         else
  913.                 skb_trim(skb, pkt_len);
  915. return 0;
  916. }
  918. /**
  919.  * sk_filter_release: Release a socket filter
  920.  * @sk: socket
  921.  * @fp: filter to remove
  922.  *
  923.  * Remove a filter from a socket and release its resources.
  924.  */
  925.  
  926. static inline void sk_filter_release(struct sock *sk, struct sk_filter *fp)
  927. {
  928. unsigned int size = sk_filter_len(fp);
  930. atomic_sub(size, &sk->omem_alloc);
  932. if (atomic_dec_and_test(&fp->refcnt))
  933. kfree(fp);
  934. }
  936. static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
  937. {
  938. atomic_inc(&fp->refcnt);
  939. atomic_add(sk_filter_len(fp), &sk->omem_alloc);
  940. }
  942. #endif /* CONFIG_FILTER */
  944. /*
  945.  * Socket reference counting postulates.
  946.  *
  947.  * * Each user of socket SHOULD hold a reference count.
  948.  * * Each access point to socket (an hash table bucket, reference from a list,
  949.  *   running timer, skb in flight MUST hold a reference count.
  950.  * * When reference count hits 0, it means it will never increase back.
  951.  * * When reference count hits 0, it means that no references from
  952.  *   outside exist to this socket and current process on current CPU
  953.  *   is last user and may/should destroy this socket.
  954.  * * sk_free is called from any context: process, BH, IRQ. When
  955.  *   it is called, socket has no references from outside -> sk_free
  956.  *   may release descendant resources allocated by the socket, but
  957.  *   to the time when it is called, socket is NOT referenced by any
  958.  *   hash tables, lists etc.
  959.  * * Packets, delivered from outside (from network or from another process)
  960.  *   and enqueued on receive/error queues SHOULD NOT grab reference count,
  961.  *   when they sit in queue. Otherwise, packets will leak to hole, when
  962.  *   socket is looked up by one cpu and unhasing is made by another CPU.
  963.  *   It is true for udp/raw, netlink (leak to receive and error queues), tcp
  964.  *   (leak to backlog). Packet socket does all the processing inside
  965.  *   BR_NETPROTO_LOCK, so that it has not this race condition. UNIX sockets
  966.  *   use separate SMP lock, so that they are prone too.
  967.  */
  969. /* Grab socket reference count. This operation is valid only
  970.    when sk is ALREADY grabbed f.e. it is found in hash table
  971.    or a list and the lookup is made under lock preventing hash table
  972.    modifications.
  973.  */
  975. static inline void sock_hold(struct sock *sk)
  976. {
  977. atomic_inc(&sk->refcnt);
  978. }
  980. /* Ungrab socket in the context, which assumes that socket refcnt
  981.    cannot hit zero, f.e. it is true in context of any socketcall.
  982.  */
  983. static inline void __sock_put(struct sock *sk)
  984. {
  985. atomic_dec(&sk->refcnt);
  986. }
  988. /* Ungrab socket and destroy it, if it was the last reference. */
  989. static inline void sock_put(struct sock *sk)
  990. {
  991. if (atomic_dec_and_test(&sk->refcnt))
  992. sk_free(sk);
  993. }
  995. /* Detach socket from process context.
  996.  * Announce socket dead, detach it from wait queue and inode.
  997.  * Note that parent inode held reference count on this struct sock,
  998.  * we do not release it in this function, because protocol
  999.  * probably wants some additional cleanups or even continuing
  1000.  * to work with this socket (TCP).
  1001.  */
  1002. static inline void sock_orphan(struct sock *sk)
  1003. {
  1004. write_lock_bh(&sk->callback_lock);
  1005. sk->dead = 1;
  1006. sk->socket = NULL;
  1007. sk->sleep = NULL;
  1008. write_unlock_bh(&sk->callback_lock);
  1009. }
  1011. static inline void sock_graft(struct sock *sk, struct socket *parent)
  1012. {
  1013. write_lock_bh(&sk->callback_lock);
  1014. sk->sleep = &parent->wait;
  1015. parent->sk = sk;
  1016. sk->socket = parent;
  1017. write_unlock_bh(&sk->callback_lock);
  1018. }
  1020. static inline int sock_i_uid(struct sock *sk)
  1021. {
  1022. int uid;
  1024. read_lock(&sk->callback_lock);
  1025. uid = sk->socket ? sk->socket->inode->i_uid : 0;
  1026. read_unlock(&sk->callback_lock);
  1027. return uid;
  1028. }
  1030. static inline unsigned long sock_i_ino(struct sock *sk)
  1031. {
  1032. unsigned long ino;
  1034. read_lock(&sk->callback_lock);
  1035. ino = sk->socket ? sk->socket->inode->i_ino : 0;
  1036. read_unlock(&sk->callback_lock);
  1037. return ino;
  1038. }
  1040. static inline struct dst_entry *
  1041. __sk_dst_get(struct sock *sk)
  1042. {
  1043. return sk->dst_cache;
  1044. }
  1046. static inline struct dst_entry *
  1047. sk_dst_get(struct sock *sk)
  1048. {
  1049. struct dst_entry *dst;
  1051. read_lock(&sk->dst_lock);
  1052. dst = sk->dst_cache;
  1053. if (dst)
  1054. dst_hold(dst);
  1055. read_unlock(&sk->dst_lock);
  1056. return dst;
  1057. }
  1059. static inline void
  1060. __sk_dst_set(struct sock *sk, struct dst_entry *dst)
  1061. {
  1062. struct dst_entry *old_dst;
  1064. old_dst = sk->dst_cache;
  1065. sk->dst_cache = dst;
  1066. dst_release(old_dst);
  1067. }
  1069. static inline void
  1070. sk_dst_set(struct sock *sk, struct dst_entry *dst)
  1071. {
  1072. write_lock(&sk->dst_lock);
  1073. __sk_dst_set(sk, dst);
  1074. write_unlock(&sk->dst_lock);
  1075. }
  1077. static inline void
  1078. __sk_dst_reset(struct sock *sk)
  1079. {
  1080. struct dst_entry *old_dst;
  1082. old_dst = sk->dst_cache;
  1083. sk->dst_cache = NULL;
  1084. dst_release(old_dst);
  1085. }
  1087. static inline void
  1088. sk_dst_reset(struct sock *sk)
  1089. {
  1090. write_lock(&sk->dst_lock);
  1091. __sk_dst_reset(sk);
  1092. write_unlock(&sk->dst_lock);
  1093. }
  1095. static inline struct dst_entry *
  1096. __sk_dst_check(struct sock *sk, u32 cookie)
  1097. {
  1098. struct dst_entry *dst = sk->dst_cache;
  1100. if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
  1101. sk->dst_cache = NULL;
  1102. return NULL;
  1103. }
  1105. return dst;
  1106. }
  1108. static inline struct dst_entry *
  1109. sk_dst_check(struct sock *sk, u32 cookie)
  1110. {
  1111. struct dst_entry *dst = sk_dst_get(sk);
  1113. if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
  1114. sk_dst_reset(sk);
  1115. return NULL;
  1116. }
  1118. return dst;
  1119. }
  1122. /*
  1123.  *  Queue a received datagram if it will fit. Stream and sequenced
  1124.  * protocols can't normally use this as they need to fit buffers in
  1125.  * and play with them.
  1126.  *
  1127.  *  Inlined as it's very short and called for pretty much every
  1128.  * packet ever received.
  1129.  */
  1131. static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
  1132. {
  1133. sock_hold(sk);
  1134. skb->sk = sk;
  1135. skb->destructor = sock_wfree;
  1136. atomic_add(skb->truesize, &sk->wmem_alloc);
  1137. }
  1139. static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
  1140. {
  1141. skb->sk = sk;
  1142. skb->destructor = sock_rfree;
  1143. atomic_add(skb->truesize, &sk->rmem_alloc);
  1144. }
  1146. static inline int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  1147. {
  1148. /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
  1149.    number of warnings when compiling with -W --ANK
  1150.  */
  1151. if (atomic_read(&sk->rmem_alloc) + skb->truesize >= (unsigned)sk->rcvbuf)
  1152.                 return -ENOMEM;
  1154. #ifdef CONFIG_FILTER
  1155. if (sk->filter) {
  1156. int err = 0;
  1157. struct sk_filter *filter;
  1159. /* It would be deadlock, if sock_queue_rcv_skb is used
  1160.    with socket lock! We assume that users of this
  1161.    function are lock free.
  1162.  */
  1163. bh_lock_sock(sk);
  1164. if ((filter = sk->filter) != NULL && sk_filter(skb, filter))
  1165. err = -EPERM;
  1166. bh_unlock_sock(sk);
  1167. if (err)
  1168. return err; /* Toss packet */
  1169. }
  1170. #endif /* CONFIG_FILTER */
  1172. skb->dev = NULL;
  1173. skb_set_owner_r(skb, sk);
  1174. skb_queue_tail(&sk->receive_queue, skb);
  1175. if (!sk->dead)
  1176. sk->data_ready(sk,skb->len);
  1177. return 0;
  1178. }
  1180. static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
  1181. {
  1182. /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
  1183.    number of warnings when compiling with -W --ANK
  1184.  */
  1185. if (atomic_read(&sk->rmem_alloc) + skb->truesize >= (unsigned)sk->rcvbuf)
  1186. return -ENOMEM;
  1187. skb_set_owner_r(skb, sk);
  1188. skb_queue_tail(&sk->error_queue,skb);
  1189. if (!sk->dead)
  1190. sk->data_ready(sk,skb->len);
  1191. return 0;
  1192. }
  1194. /*
  1195.  * Recover an error report and clear atomically
  1196.  */
  1197.  
  1198. static inline int sock_error(struct sock *sk)
  1199. {
  1200. int err=xchg(&sk->err,0);
  1201. return -err;
  1202. }
  1204. static inline unsigned long sock_wspace(struct sock *sk)
  1205. {
  1206. int amt = 0;
  1208. if (!(sk->shutdown & SEND_SHUTDOWN)) {
  1209. amt = sk->sndbuf - atomic_read(&sk->wmem_alloc);
  1210. if (amt < 0) 
  1211. amt = 0;
  1212. }
  1213. return amt;
  1214. }
  1216. static inline void sk_wake_async(struct sock *sk, int how, int band)
  1217. {
  1218. if (sk->socket && sk->socket->fasync_list)
  1219. sock_wake_async(sk->socket, how, band);
  1220. }
  1222. #define SOCK_MIN_SNDBUF 2048
  1223. #define SOCK_MIN_RCVBUF 256
  1224. /* Must be less or equal SOCK_MIN_SNDBUF */
  1225. #define SOCK_MIN_WRITE_SPACE SOCK_MIN_SNDBUF
  1227. /*
  1228.  * Default write policy as shown to user space via poll/select/SIGIO
  1229.  * Kernel internally doesn't use the MIN_WRITE_SPACE threshold.
  1230.  */
  1231. static inline int sock_writeable(struct sock *sk) 
  1232. {
  1233. return sock_wspace(sk) >= SOCK_MIN_WRITE_SPACE;
  1234. }
  1236. static inline int gfp_any(void)
  1237. {
  1238. return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
  1239. }
  1241. static inline long sock_rcvtimeo(struct sock *sk, int noblock)
  1242. {
  1243. return noblock ? 0 : sk->rcvtimeo;
  1244. }
  1246. static inline long sock_sndtimeo(struct sock *sk, int noblock)
  1247. {
  1248. return noblock ? 0 : sk->sndtimeo;
  1249. }
  1251. static inline int sock_rcvlowat(struct sock *sk, int waitall, int len)
  1252. {
  1253. return (waitall ? len : min_t(int, sk->rcvlowat, len)) ? : 1;
  1254. }
  1256. /* Alas, with timeout socket operations are not restartable.
  1257.  * Compare this to poll().
  1258.  */
  1259. static inline int sock_intr_errno(long timeo)
  1260. {
  1261. return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
  1262. }
  1264. static __inline__ void
  1265. sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
  1266. {
  1267. if (sk->rcvtstamp)
  1268. put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP, sizeof(skb->stamp), &skb->stamp);
  1269. else
  1270. sk->stamp = skb->stamp;
  1271. }
  1273. /* 
  1274.  * Enable debug/info messages 
  1275.  */
  1277. #if 0
  1278. #define NETDEBUG(x) do { } while (0)
  1279. #else
  1280. #define NETDEBUG(x) do { x; } while (0)
  1281. #endif
  1283. /*
  1284.  * Macros for sleeping on a socket. Use them like this:
  1285.  *
  1286.  * SOCK_SLEEP_PRE(sk)
  1287.  * if (condition)
  1288.  *  schedule();
  1289.  * SOCK_SLEEP_POST(sk)
  1290.  *
  1291.  */
  1293. #define SOCK_SLEEP_PRE(sk)  { struct task_struct *tsk = current; 
  1294. DECLARE_WAITQUEUE(wait, tsk); 
  1295. tsk->state = TASK_INTERRUPTIBLE; 
  1296. add_wait_queue((sk)->sleep, &wait); 
  1297. release_sock(sk);
  1299. #define SOCK_SLEEP_POST(sk) tsk->state = TASK_RUNNING; 
  1300. remove_wait_queue((sk)->sleep, &wait); 
  1301. lock_sock(sk); 
  1302. }
  1304. extern __u32 sysctl_wmem_max;
  1305. extern __u32 sysctl_rmem_max;
  1307. #endif /* _SOCK_H */