![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to socketvar.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / sys|
Return to socketvar.h CVS log | Up to [Apple XNU] / XNU / bsd / sys |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
23: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
24: /*-
25: * Copyright (c) 1982, 1986, 1990, 1993
26: * The Regents of the University of California. All rights reserved.
27: *
28: * Redistribution and use in source and binary forms, with or without
29: * modification, are permitted provided that the following conditions
30: * are met:
31: * 1. Redistributions of source code must retain the above copyright
32: * notice, this list of conditions and the following disclaimer.
33: * 2. Redistributions in binary form must reproduce the above copyright
34: * notice, this list of conditions and the following disclaimer in the
35: * documentation and/or other materials provided with the distribution.
36: * 3. All advertising materials mentioning features or use of this software
37: * must display the following acknowledgement:
38: * This product includes software developed by the University of
39: * California, Berkeley and its contributors.
40: * 4. Neither the name of the University nor the names of its contributors
41: * may be used to endorse or promote products derived from this software
42: * without specific prior written permission.
43: *
44: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54: * SUCH DAMAGE.
55: *
56: * @(#)socketvar.h 8.1 (Berkeley) 6/2/93
57: */
58:
59: #ifndef _SYS_SOCKETVAR_H_
60: #define _SYS_SOCKETVAR_H_
61:
62: #include <sys/select.h> /* for struct selinfo */
63: #include <sys/queue.h>
64: #include <net/kext_net.h>
65: #include <sys/ev.h>
66: /*
67: * Hacks to get around compiler complaints
68: */
69: struct mbuf;
70: struct socket;
71: struct uio;
72: struct sockbuf;
73: struct sockaddr;
74: struct kextcb;
75: struct protosw;
76: struct sockif;
77: struct sockutil;
78:
79: /* strings for sleep message: */
80: extern char netio[], netcon[], netcls[];
81: #define SOCKET_CACHE_ON
82: #define SO_CACHE_FLUSH_INTERVAL 1 /* Seconds */
83: #define SO_CACHE_TIME_LIMIT (120/SO_CACHE_FLUSH_INTERVAL) /* Seconds */
84: #define SO_CACHE_MAX_FREE_BATCH 50
85: #define MAX_CACHED_SOCKETS 60000
86: #define TEMPDEBUG 0
87:
88: /*
89: * Kernel structure per socket.
90: * Contains send and receive buffer queues,
91: * handle on protocol and pointer to protocol
92: * private data and error information.
93: */
94: typedef u_quad_t so_gen_t;
95:
96: struct socket {
97: int so_zone; /* zone we were allocated from */
98: short so_type; /* generic type, see socket.h */
99: short so_options; /* from socket call, see socket.h */
100: short so_linger; /* time to linger while closing */
101: short so_state; /* internal state flags SS_*, below */
102: caddr_t so_pcb; /* protocol control block */
103: struct protosw *so_proto; /* protocol handle */
104: /*
105: * Variables for connection queueing.
106: * Socket where accepts occur is so_head in all subsidiary sockets.
107: * If so_head is 0, socket is not related to an accept.
108: * For head socket so_q0 queues partially completed connections,
109: * while so_q is a queue of connections ready to be accepted.
110: * If a connection is aborted and it has so_head set, then
111: * it has to be pulled out of either so_q0 or so_q.
112: * We allow connections to queue up based on current queue lengths
113: * and limit on number of queued connections for this socket.
114: */
115: struct socket *so_head; /* back pointer to accept socket */
116: TAILQ_HEAD(, socket) so_incomp; /* queue of partial unaccepted connections */
117: TAILQ_HEAD(, socket) so_comp; /* queue of complete unaccepted connections */
118: TAILQ_ENTRY(socket) so_list; /* list of unaccepted connections */
119: short so_qlen; /* number of unaccepted connections */
120: short so_incqlen; /* number of unaccepted incomplete
121: connections */
122: short so_qlimit; /* max number queued connections */
123: short so_timeo; /* connection timeout */
124: u_short so_error; /* error affecting connection */
125: pid_t so_pgid; /* pgid for signals */
126: u_long so_oobmark; /* chars to oob mark */
127: /*
128: * Variables for socket buffering.
129: */
130: struct sockbuf {
131: u_long sb_cc; /* actual chars in buffer */
132: u_long sb_hiwat; /* max actual char count */
133: u_long sb_mbcnt; /* chars of mbufs used */
134: u_long sb_mbmax; /* max chars of mbufs to use */
135: long sb_lowat; /* low water mark */
136: struct mbuf *sb_mb; /* the mbuf chain */
137: struct socket *sb_so; /* socket back ptr */
138: struct selinfo sb_sel; /* process selecting read/write */
139: short sb_flags; /* flags, see below */
140: short sb_timeo; /* timeout for read/write */
141: } so_rcv, so_snd;
142: #define SB_MAX (256*1024) /* default for max chars in sockbuf */
143: #define SB_LOCK 0x01 /* lock on data queue */
144: #define SB_WANT 0x02 /* someone is waiting to lock */
145: #define SB_WAIT 0x04 /* someone is waiting for data/space */
146: #define SB_SEL 0x08 /* someone is selecting */
147: #define SB_ASYNC 0x10 /* ASYNC I/O, need signals */
148: #define SB_NOTIFY (SB_WAIT|SB_SEL|SB_ASYNC)
149: #define SB_UPCALL 0x20 /* someone wants an upcall */
150: #define SB_NOINTR 0x40 /* operations not interruptible */
151: #define SB_RECV 0x8000 /* this is rcv sb */
152:
153: caddr_t so_tpcb; /* Wisc. protocol control block XXX */
154: void (*so_upcall) __P((struct socket *so, caddr_t arg, int waitf));
155: caddr_t so_upcallarg; /* Arg for above */
156: uid_t so_uid; /* who opened the socket */
157: /* NB: generation count must not be first; easiest to make it last. */
158: so_gen_t so_gencnt; /* generation count */
159: TAILQ_HEAD(,eventqelt) so_evlist;
160: int cached_in_sock_layer; /* Is socket bundled with pcb/pcb.inp_ppcb? */
161: struct socket *cache_next;
162: struct socket *cache_prev;
163: u_long cache_timestamp;
164: caddr_t so_saved_pcb; /* Saved pcb when cacheing */
165: struct mbuf *so_temp; /* Holding area for outbound frags */
166: /* Plug-in support - make the socket interface overridable */
167: struct mbuf *so_tail;
168: struct kextcb *so_ext; /* NKE hook */
169: };
170:
171: /*
172: * Socket state bits.
173: */
174: #define SS_NOFDREF 0x001 /* no file table ref any more */
175: #define SS_ISCONNECTED 0x002 /* socket connected to a peer */
176: #define SS_ISCONNECTING 0x004 /* in process of connecting to peer */
177: #define SS_ISDISCONNECTING 0x008 /* in process of disconnecting */
178: #define SS_CANTSENDMORE 0x010 /* can't send more data to peer */
179: #define SS_CANTRCVMORE 0x020 /* can't receive more data from peer */
180: #define SS_RCVATMARK 0x040 /* at mark on input */
181:
182: #define SS_PRIV 0x080 /* privileged for broadcast, raw... */
183: #define SS_NBIO 0x100 /* non-blocking ops */
184: #define SS_ASYNC 0x200 /* async i/o notify */
185: #define SS_ISCONFIRMING 0x400 /* deciding to accept connection req */
186: #define SS_INCOMP 0x800 /* Unaccepted, incomplete connection */
187: #define SS_COMP 0x1000 /* unaccepted, complete connection */
188:
189: /*
190: * Externalized form of struct socket used by the sysctl(3) interface.
191: */
192: struct xsocket {
193: size_t xso_len; /* length of this structure */
194: struct socket *xso_so; /* makes a convenient handle sometimes */
195: short so_type;
196: short so_options;
197: short so_linger;
198: short so_state;
199: caddr_t so_pcb; /* another convenient handle */
200: int xso_protocol;
201: int xso_family;
202: short so_qlen;
203: short so_incqlen;
204: short so_qlimit;
205: short so_timeo;
206: u_short so_error;
207: pid_t so_pgid;
208: u_long so_oobmark;
209: struct xsockbuf {
210: u_long sb_cc;
211: u_long sb_hiwat;
212: u_long sb_mbcnt;
213: u_long sb_mbmax;
214: long sb_lowat;
215: short sb_flags;
216: short sb_timeo;
217: } so_rcv, so_snd;
218: uid_t so_uid; /* XXX */
219: };
220:
221: /*
222: * Macros for sockets and socket buffering.
223: */
224: #define sbtoso(sb) (sb->sb_so)
225:
226: /*
227: * Do we need to notify the other side when I/O is possible?
228: */
229: #define sb_notify(sb) (((sb)->sb_flags & (SB_WAIT|SB_SEL|SB_ASYNC|SB_UPCALL)) != 0)
230:
231: /*
232: * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
233: * This is problematical if the fields are unsigned, as the space might
234: * still be negative (cc > hiwat or mbcnt > mbmax). Should detect
235: * overflow and return 0. Should use "lmin" but it doesn't exist now.
236: */
237: #define sbspace(sb) \
238: ((long) imin((int)((sb)->sb_hiwat - (sb)->sb_cc), \
239: (int)((sb)->sb_mbmax - (sb)->sb_mbcnt)))
240:
241: /* do we have to send all at once on a socket? */
242: #define sosendallatonce(so) \
243: ((so)->so_proto->pr_flags & PR_ATOMIC)
244:
245: /* can we read something from so? */
246: #define soreadable(so) \
247: ((so)->so_rcv.sb_cc >= (so)->so_rcv.sb_lowat || \
248: ((so)->so_state & SS_CANTRCVMORE) || \
249: (so)->so_comp.tqh_first || (so)->so_error)
250:
251: /* can we write something to so? */
252: #define sowriteable(so) \
253: ((sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && \
254: (((so)->so_state&SS_ISCONNECTED) || \
255: ((so)->so_proto->pr_flags&PR_CONNREQUIRED)==0)) || \
256: ((so)->so_state & SS_CANTSENDMORE) || \
257: (so)->so_error)
258:
259: /* adjust counters in sb reflecting allocation of m */
260: #define sballoc(sb, m) { \
261: (sb)->sb_cc += (m)->m_len; \
262: (sb)->sb_mbcnt += MSIZE; \
263: if ((m)->m_flags & M_EXT) \
264: (sb)->sb_mbcnt += (m)->m_ext.ext_size; \
265: }
266:
267: /* adjust counters in sb reflecting freeing of m */
268: #define sbfree(sb, m) { \
269: (sb)->sb_cc -= (m)->m_len; \
270: (sb)->sb_mbcnt -= MSIZE; \
271: if ((m)->m_flags & M_EXT) \
272: (sb)->sb_mbcnt -= (m)->m_ext.ext_size; \
273: }
274:
275: /*
276: * Set lock on sockbuf sb; sleep if lock is already held.
277: * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
278: * Returns error without lock if sleep is interrupted.
279: */
280: #define sblock(sb, wf) ((sb)->sb_flags & SB_LOCK ? \
281: (((wf) == M_WAIT) ? sb_lock(sb) : EWOULDBLOCK) : \
282: ((sb)->sb_flags |= SB_LOCK), 0)
283:
284: /* release lock on sockbuf sb */
285: #define sbunlock(sb) { \
286: (sb)->sb_flags &= ~SB_LOCK; \
287: if ((sb)->sb_flags & SB_WANT) { \
288: (sb)->sb_flags &= ~SB_WANT; \
289: wakeup((caddr_t)&(sb)->sb_flags); \
290: } \
291: }
292:
293: #define sorwakeup(so) do { \
294: if (sb_notify(&(so)->so_rcv)) \
295: sowakeup((so), &(so)->so_rcv); \
296: } while (0)
297:
298: #define sowwakeup(so) do { \
299: if (sb_notify(&(so)->so_snd)) \
300: sowakeup((so), &(so)->so_snd); \
301: } while (0)
302:
303:
304: /*
305: * Socket extension mechanism: control block hooks:
306: * This is the "head" of any control block for an extenstion
307: * Note: we separate intercept function dispatch vectors from
308: * the NFDescriptor to permit selective replacement during
309: * operation, e.g., to disable some functions.
310: */
311: struct kextcb
312: { struct kextcb *e_next; /* Next kext control block */
313: void *e_fcb; /* Real filter control block */
314: struct NFDescriptor *e_nfd; /* NKE Descriptor */
315: /* Plug-in support - intercept functions */
316: struct sockif *e_soif; /* Socket functions */
317: struct sockutil *e_sout; /* Sockbuf utility functions */
318: };
319: #define EXT_NULL 0x0 /* STATE: Not in use */
320: #define sotokextcb(so) (so ? so->so_ext : 0)
321:
322: #ifdef KERNEL
323: /*
324: * Argument structure for sosetopt et seq. This is in the KERNEL
325: * section because it will never be visible to user code.
326: */
327: enum sopt_dir { SOPT_GET, SOPT_SET };
328: struct sockopt {
329: enum sopt_dir sopt_dir; /* is this a get or a set? */
330: int sopt_level; /* second arg of [gs]etsockopt */
331: int sopt_name; /* third arg of [gs]etsockopt */
332: void *sopt_val; /* fourth arg of [gs]etsockopt */
333: size_t sopt_valsize; /* (almost) fifth arg of [gs]etsockopt */
334: struct proc *sopt_p; /* calling process or null if kernel */
335: };
336:
337: #if SENDFILE
338:
339: struct sf_buf {
340: SLIST_ENTRY(sf_buf) free_list; /* list of free buffer slots */
341: int refcnt; /* reference count */
342: struct vm_page *m; /* currently mapped page */
343: vm_offset_t kva; /* va of mapping */
344: };
345:
346: #endif
347:
348: #ifdef MALLOC_DECLARE
349: MALLOC_DECLARE(M_PCB);
350: MALLOC_DECLARE(M_SONAME);
351: #endif
352:
353: extern int maxsockets;
354: extern u_long sb_max;
355: extern int socket_zone;
356: extern so_gen_t so_gencnt;
357:
358: struct file;
359: struct filedesc;
360: struct mbuf;
361: struct sockaddr;
362: struct stat;
363: struct ucred;
364: struct uio;
365:
366: /*
367: * File operations on sockets.
368: */
369: int soo_read __P((struct file *fp, struct uio *uio, struct ucred *cred));
370: int soo_write __P((struct file *fp, struct uio *uio, struct ucred *cred));
371: int soo_ioctl __P((struct file *fp, u_long cmd, caddr_t data,
372: struct proc *p));
373: int soo_select __P((struct file *fp, int which, struct proc *p));
374: int soo_stat __P((struct socket *so, struct stat *ub));
375:
376: int soo_close __P((struct file *fp, struct proc *p));
377:
378:
379: /*
380: * From uipc_socket and friends
381: */
382: struct sockaddr *dup_sockaddr __P((struct sockaddr *sa, int canwait));
383: int getsock __P((struct filedesc *fdp, int fd, struct file **fpp));
384: int sockargs __P((struct mbuf **mp, caddr_t buf, int buflen, int type));
385: int getsockaddr __P((struct sockaddr **namp, caddr_t uaddr, size_t len));
386: void sbappend __P((struct sockbuf *sb, struct mbuf *m));
387: int sbappendaddr __P((struct sockbuf *sb, struct sockaddr *asa,
388: struct mbuf *m0, struct mbuf *control));
389: int sbappendcontrol __P((struct sockbuf *sb, struct mbuf *m0,
390: struct mbuf *control));
391: void sbappendrecord __P((struct sockbuf *sb, struct mbuf *m0));
392: void sbcheck __P((struct sockbuf *sb));
393: void sbcompress __P((struct sockbuf *sb, struct mbuf *m, struct mbuf *n));
394: struct mbuf *
395: sbcreatecontrol __P((caddr_t p, int size, int type, int level));
396: void sbdrop __P((struct sockbuf *sb, int len));
397: void sbdroprecord __P((struct sockbuf *sb));
398: void sbflush __P((struct sockbuf *sb));
399: void sbinsertoob __P((struct sockbuf *sb, struct mbuf *m0));
400: void sbrelease __P((struct sockbuf *sb));
401: int sbreserve __P((struct sockbuf *sb, u_long cc));
402: void sbtoxsockbuf __P((struct sockbuf *sb, struct xsockbuf *xsb));
403: int sbwait __P((struct sockbuf *sb));
404: int sb_lock __P((struct sockbuf *sb));
405: int soabort __P((struct socket *so));
406: int soaccept __P((struct socket *so, struct sockaddr **nam));
407: struct socket *soalloc __P((int waitok));
408: int sobind __P((struct socket *so, struct sockaddr *nam));
409: void socantrcvmore __P((struct socket *so));
410: void socantsendmore __P((struct socket *so));
411: int soclose __P((struct socket *so));
412: int soconnect __P((struct socket *so, struct sockaddr *nam));
413: int soconnect2 __P((struct socket *so1, struct socket *so2));
414: int socreate __P((int dom, struct socket **aso, int type, int proto));
415: void sodealloc __P((struct socket *so));
416: int sodisconnect __P((struct socket *so));
417: void sofree __P((struct socket *so));
418: int sogetopt __P((struct socket *so, struct sockopt *sopt));
419: void sohasoutofband __P((struct socket *so));
420: void soisconnected __P((struct socket *so));
421: void soisconnecting __P((struct socket *so));
422: void soisdisconnected __P((struct socket *so));
423: void soisdisconnecting __P((struct socket *so));
424: int solisten __P((struct socket *so, int backlog));
425: struct socket *
426: sodropablereq __P((struct socket *head));
427: struct socket *
428: sonewconn __P((struct socket *head, int connstatus));
429: int sooptcopyin __P((struct sockopt *sopt, void *buf, size_t len,
430: size_t minlen));
431: int sooptcopyout __P((struct sockopt *sopt, void *buf, size_t len));
432: int sopoll __P((struct socket *so, int events, struct ucred *cred));
433: int soreceive __P((struct socket *so, struct sockaddr **paddr,
434: struct uio *uio, struct mbuf **mp0,
435: struct mbuf **controlp, int *flagsp));
436: int soreserve __P((struct socket *so, u_long sndcc, u_long rcvcc));
437: void sorflush __P((struct socket *so));
438: int sosend __P((struct socket *so, struct sockaddr *addr, struct uio *uio,
439: struct mbuf *top, struct mbuf *control, int flags));
440:
441: int sosetopt __P((struct socket *so, struct sockopt *sopt));
442:
443:
444: int soshutdown __P((struct socket *so, int how));
445: void sotoxsocket __P((struct socket *so, struct xsocket *xso));
446: void sowakeup __P((struct socket *so, struct sockbuf *sb));
447:
448:
449: #endif /* KERNEL */
450: #endif /* !_SYS_SOCKETVAR_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.