![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to socket.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / slirp|
Return to socket.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / slirp |
1.1 root 1: /*
2: * Copyright (c) 1995 Danny Gasparovski.
3: *
4: * Please read the file COPYRIGHT for the
5: * terms and conditions of the copyright.
6: */
7:
8: #define WANT_SYS_IOCTL_H
9: #include <stdlib.h>
10: #include <slirp.h>
11: #include "ip_icmp.h"
12: #include "main.h"
13: #ifdef __sun__
14: #include <sys/filio.h>
15: #endif
16:
17: #ifdef _WIN32
18: #define IS_EAGAIN(e) ((e) == WSAEINTR || (e) == EAGAIN)
19: #else
20: #define IS_EAGAIN(e) ((e) == EAGAIN)
21: #endif
22:
23: void
24: so_init()
25: {
26: /* Nothing yet */
27: }
28:
29:
30: struct socket *
31: solookup(head, laddr, lport, faddr, fport)
32: struct socket *head;
33: struct in_addr laddr;
34: u_int lport;
35: struct in_addr faddr;
36: u_int fport;
37: {
38: struct socket *so;
39:
40: for (so = head->so_next; so != head; so = so->so_next) {
41: if (so->so_lport == lport &&
42: so->so_laddr.s_addr == laddr.s_addr &&
43: so->so_faddr.s_addr == faddr.s_addr &&
44: so->so_fport == fport)
45: break;
46: }
47:
48: if (so == head)
49: return (struct socket *)NULL;
50: return so;
51:
52: }
53:
54: /*
55: * Create a new socket, initialise the fields
56: * It is the responsibility of the caller to
57: * insque() it into the correct linked-list
58: */
59: struct socket *
60: socreate()
61: {
62: struct socket *so;
63:
64: so = (struct socket *)malloc(sizeof(struct socket));
65: if(so) {
66: memset(so, 0, sizeof(struct socket));
67: so->so_state = SS_NOFDREF;
68: so->s = -1;
69: }
70: return(so);
71: }
72:
73: /*
74: * remque and free a socket, clobber cache
75: */
76: void
77: sofree(so)
78: struct socket *so;
79: {
80: if (so->so_emu==EMU_RSH && so->extra) {
81: sofree(so->extra);
82: so->extra=NULL;
83: }
84: if (so == tcp_last_so)
85: tcp_last_so = &tcb;
86: else if (so == udp_last_so)
87: udp_last_so = &udb;
88:
89: m_free(so->so_m);
90:
91: if(so->so_next && so->so_prev)
92: remque(so); /* crashes if so is not in a queue */
93:
94: free(so);
95: }
96:
97: /*
98: * Read from so's socket into sb_snd, updating all relevant sbuf fields
99: * NOTE: This will only be called if it is select()ed for reading, so
100: * a read() of 0 (or less) means it's disconnected
101: */
102: int
103: soread(so)
104: struct socket *so;
105: {
106: int n, nn;
107: u_int lss, total;
108: struct sbuf *sb = &so->so_snd;
109: u_int len = sb->sb_datalen - sb->sb_cc;
110: struct iovec iov[2];
111: u_int mss = so->so_tcpcb->t_maxseg;
112:
113: DEBUG_CALL("soread");
114: DEBUG_ARG("so = %lx", (long )so);
115:
116: /*
117: * No need to check if there's enough room to read.
118: * soread wouldn't have been called if there weren't
119: */
120:
121: len = sb->sb_datalen - sb->sb_cc;
122:
123: iov[0].iov_base = sb->sb_wptr;
124: if (sb->sb_wptr < sb->sb_rptr) {
125: iov[0].iov_len = sb->sb_rptr - sb->sb_wptr;
126: /* Should never succeed, but... */
127: if (iov[0].iov_len > len)
128: iov[0].iov_len = len;
129: if (iov[0].iov_len > mss)
130: iov[0].iov_len -= iov[0].iov_len%mss;
131: n = 1;
132: } else {
133: iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_wptr;
134: /* Should never succeed, but... */
135: if (iov[0].iov_len > len) iov[0].iov_len = len;
136: len -= iov[0].iov_len;
137: if (len) {
138: iov[1].iov_base = sb->sb_data;
139: iov[1].iov_len = sb->sb_rptr - sb->sb_data;
140: if(iov[1].iov_len > len)
141: iov[1].iov_len = len;
142: total = iov[0].iov_len + iov[1].iov_len;
143: if (total > mss) {
144: lss = total%mss;
145: if (iov[1].iov_len > lss) {
146: iov[1].iov_len -= lss;
147: n = 2;
148: } else {
149: lss -= iov[1].iov_len;
150: iov[0].iov_len -= lss;
151: n = 1;
152: }
153: } else
154: n = 2;
155: } else {
156: if (iov[0].iov_len > mss)
157: iov[0].iov_len -= iov[0].iov_len%mss;
158: n = 1;
159: }
160: }
161:
162: #ifdef HAVE_READV
163: nn = readv(so->s, (struct iovec *)iov, n);
164: DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
165: #else
166: nn = recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
167: #endif
168: if (nn <= 0) {
169: int error = WSAGetLastError();
170: if (nn < 0 && IS_EAGAIN(error))
171: return 0;
172: else {
173: DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
174: sofcantrcvmore(so);
175: tcp_sockclosed(sototcpcb(so));
176: return -1;
177: }
178: }
179:
180: #ifndef HAVE_READV
181: /*
182: * If there was no error, try and read the second time round
183: * We read again if n = 2 (ie, there's another part of the buffer)
184: * and we read as much as we could in the first read
185: * We don't test for <= 0 this time, because there legitimately
186: * might not be any more data (since the socket is non-blocking),
187: * a close will be detected on next iteration.
188: * A return of -1 wont (shouldn't) happen, since it didn't happen above
189: */
190: if (n == 2 && nn == iov[0].iov_len) {
191: int ret;
192: ret = recv(so->s, iov[1].iov_base, iov[1].iov_len,0);
193: if (ret > 0)
194: nn += ret;
195: }
196:
197: DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
198: #endif
199:
200: /* Update fields */
201: sb->sb_cc += nn;
202: sb->sb_wptr += nn;
203: if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
204: sb->sb_wptr -= sb->sb_datalen;
205: return nn;
206: }
207:
208: /*
209: * Get urgent data
210: *
211: * When the socket is created, we set it SO_OOBINLINE,
212: * so when OOB data arrives, we soread() it and everything
213: * in the send buffer is sent as urgent data
214: */
215: void
216: sorecvoob(so)
217: struct socket *so;
218: {
219: struct tcpcb *tp = sototcpcb(so);
220:
221: DEBUG_CALL("sorecvoob");
222: DEBUG_ARG("so = %lx", (long)so);
223:
224: /*
225: * We take a guess at how much urgent data has arrived.
226: * In most situations, when urgent data arrives, the next
227: * read() should get all the urgent data. This guess will
228: * be wrong however if more data arrives just after the
229: * urgent data, or the read() doesn't return all the
230: * urgent data.
231: */
232: soread(so);
233: tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
234: tp->t_force = 1;
235: tcp_output(tp);
236: tp->t_force = 0;
237: }
238:
239: /*
240: * Send urgent data
241: * There's a lot duplicated code here, but...
242: */
243: int
244: sosendoob(so)
245: struct socket *so;
246: {
247: struct sbuf *sb = &so->so_rcv;
248: char buff[2048]; /* XXX Shouldn't be sending more oob data than this */
249:
250: int n, len;
251:
252: DEBUG_CALL("sosendoob");
253: DEBUG_ARG("so = %lx", (long)so);
254: DEBUG_ARG("sb->sb_cc = %d", sb->sb_cc);
255:
256: if (so->so_urgc > 2048)
257: so->so_urgc = 2048; /* XXXX */
258:
259: if (sb->sb_rptr < sb->sb_wptr) {
260: /* We can send it directly */
261: n = send(so->s, sb->sb_rptr, so->so_urgc, (MSG_OOB)); /* |MSG_DONTWAIT)); */
262: so->so_urgc -= n;
263:
264: DEBUG_MISC((dfd, " --- sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
265: } else {
266: /*
267: * Since there's no sendv or sendtov like writev,
268: * we must copy all data to a linear buffer then
269: * send it all
270: */
271: len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
272: if (len > so->so_urgc) len = so->so_urgc;
273: memcpy(buff, sb->sb_rptr, len);
274: so->so_urgc -= len;
275: if (so->so_urgc) {
276: n = sb->sb_wptr - sb->sb_data;
277: if (n > so->so_urgc) n = so->so_urgc;
278: memcpy((buff + len), sb->sb_data, n);
279: so->so_urgc -= n;
280: len += n;
281: }
282: n = send(so->s, buff, len, (MSG_OOB)); /* |MSG_DONTWAIT)); */
283: #ifdef DEBUG
284: if (n != len)
285: DEBUG_ERROR((dfd, "Didn't send all data urgently XXXXX\n"));
286: #endif
287: DEBUG_MISC((dfd, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
288: }
289:
290: sb->sb_cc -= n;
291: sb->sb_rptr += n;
292: if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
293: sb->sb_rptr -= sb->sb_datalen;
294:
295: return n;
296: }
297:
298: /*
299: * Write data from so_rcv to so's socket,
300: * updating all sbuf field as necessary
301: */
302: int
303: sowrite(so)
304: struct socket *so;
305: {
306: int n,nn;
307: struct sbuf *sb = &so->so_rcv;
308: u_int len = sb->sb_cc;
309: struct iovec iov[2];
310:
311: DEBUG_CALL("sowrite");
312: DEBUG_ARG("so = %lx", (long)so);
313:
314: if (so->so_urgc) {
315: sosendoob(so);
316: if (sb->sb_cc == 0)
317: return 0;
318: }
319:
320: /*
321: * No need to check if there's something to write,
322: * sowrite wouldn't have been called otherwise
323: */
324:
325: len = sb->sb_cc;
326:
327: iov[0].iov_base = sb->sb_rptr;
328: if (sb->sb_rptr < sb->sb_wptr) {
329: iov[0].iov_len = sb->sb_wptr - sb->sb_rptr;
330: /* Should never succeed, but... */
331: if (iov[0].iov_len > len) iov[0].iov_len = len;
332: n = 1;
333: } else {
334: iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
335: if (iov[0].iov_len > len) iov[0].iov_len = len;
336: len -= iov[0].iov_len;
337: if (len) {
338: iov[1].iov_base = sb->sb_data;
339: iov[1].iov_len = sb->sb_wptr - sb->sb_data;
340: if (iov[1].iov_len > len) iov[1].iov_len = len;
341: n = 2;
342: } else
343: n = 1;
344: }
345: /* Check if there's urgent data to send, and if so, send it */
346:
347: #ifdef HAVE_READV
348: nn = writev(so->s, (const struct iovec *)iov, n);
349:
350: DEBUG_MISC((dfd, " ... wrote nn = %d bytes\n", nn));
351: #else
352: nn = send(so->s, iov[0].iov_base, iov[0].iov_len,0);
353: #endif
354: /* This should never happen, but people tell me it does *shrug* */
355: if (nn < 0) {
356: int error = WSAGetLastError();
357: if (IS_EAGAIN(error))
358: return 0;
359: }
360:
361: if (nn <= 0) {
362: DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
363: so->so_state, errno));
364: sofcantsendmore(so);
365: tcp_sockclosed(sototcpcb(so));
366: return -1;
367: }
368:
369: #ifndef HAVE_READV
370: if (n == 2 && nn == iov[0].iov_len) {
371: int ret;
372: ret = send(so->s, iov[1].iov_base, iov[1].iov_len,0);
373: if (ret > 0)
374: nn += ret;
375: }
376: DEBUG_MISC((dfd, " ... wrote nn = %d bytes\n", nn));
377: #endif
378:
379: /* Update sbuf */
380: sb->sb_cc -= nn;
381: sb->sb_rptr += nn;
382: if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
383: sb->sb_rptr -= sb->sb_datalen;
384:
385: /*
386: * If in DRAIN mode, and there's no more data, set
387: * it CANTSENDMORE
388: */
389: if ((so->so_state & SS_FWDRAIN) && sb->sb_cc == 0)
390: sofcantsendmore(so);
391:
392: return nn;
393: }
394:
395: /*
396: * recvfrom() a UDP socket
397: */
398: void
399: sorecvfrom(so)
400: struct socket *so;
401: {
402: struct sockaddr_in addr;
403: socklen_t addrlen = sizeof(struct sockaddr_in);
404:
405: DEBUG_CALL("sorecvfrom");
406: DEBUG_ARG("so = %lx", (long)so);
407:
408: if (so->so_type == IPPROTO_ICMP) { /* This is a "ping" reply */
409: char buff[256];
410: int len;
411:
412: len = recvfrom(so->s, buff, 256, 0,
413: (struct sockaddr *)&addr, &addrlen);
414: /* XXX Check if reply is "correct"? */
415:
416: if(len == -1 || len == 0) {
417: u_char code=ICMP_UNREACH_PORT;
418:
419: int error = WSAGetLastError();
420: if(error == WSAEHOSTUNREACH) code=ICMP_UNREACH_HOST;
421: else if(error == WSAENETUNREACH) code=ICMP_UNREACH_NET;
422:
423: DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
424: errno,strerror(errno)));
425: icmp_error(so->so_m, ICMP_UNREACH,code, 0,strerror(errno));
426: } else {
427: icmp_reflect(so->so_m);
428: so->so_m = 0; /* Don't m_free() it again! */
429: }
430: /* No need for this socket anymore, udp_detach it */
431: udp_detach(so);
432: } else { /* A "normal" UDP packet */
433: struct mbuf *m;
434: u_int len;
435: ioctlsockopt_t n;
436:
437: if (!(m = m_get())) return;
438: m->m_data += if_maxlinkhdr;
439:
440: /*
441: * XXX Shouldn't FIONREAD packets destined for port 53,
442: * but I don't know the max packet size for DNS lookups
443: */
444: len = M_FREEROOM(m);
445: /* if (so->so_fport != htons(53)) { */
446: ioctlsocket(so->s, FIONREAD, &n);
447:
448: if (n > len) {
449: n = (m->m_data - m->m_dat) + m->m_len + n + 1;
450: m_inc(m, n);
451: len = M_FREEROOM(m);
452: }
453: /* } */
454:
455: m->m_len = recvfrom(so->s, m->m_data, len, 0,
456: (struct sockaddr *)&addr, &addrlen);
457: DEBUG_MISC((dfd, " did recvfrom %zu, errno = %d-%s\n",
458: m->m_len, errno,strerror(errno)));
459: if((int)m->m_len<0) {
460: u_char code=ICMP_UNREACH_PORT;
461:
462: int error = WSAGetLastError();
463: if(error == WSAEHOSTUNREACH) code=ICMP_UNREACH_HOST;
464: else if(error == WSAENETUNREACH) code=ICMP_UNREACH_NET;
465:
466: DEBUG_MISC((dfd," rx error, tx icmp ICMP_UNREACH:%i\n", code));
467: icmp_error(so->so_m, ICMP_UNREACH,code, 0,strerror(errno));
468: m_free(m);
469: } else {
470: /*
471: * Hack: domain name lookup will be used the most for UDP,
472: * and since they'll only be used once there's no need
473: * for the 4 minute (or whatever) timeout... So we time them
474: * out much quicker (10 seconds for now...)
475: */
476: if (so->so_expire) {
477: if (so->so_fport == htons(53))
478: so->so_expire = curtime + SO_EXPIREFAST;
479: else
480: so->so_expire = curtime + SO_EXPIRE;
481: }
482:
483: /* if (m->m_len == len) {
484: * m_inc(m, MINCSIZE);
485: * m->m_len = 0;
486: * }
487: */
488:
489: /*
490: * If this packet was destined for CTL_ADDR,
491: * make it look like that's where it came from, done by udp_output
492: */
493: udp_output(so, m, &addr);
494: } /* rx error */
495: } /* if ping packet */
496: }
497:
498: /*
499: * sendto() a socket
500: */
501: int
502: sosendto(so, m)
503: struct socket *so;
504: struct mbuf *m;
505: {
506: int ret;
507: struct sockaddr_in addr;
508:
509: DEBUG_CALL("sosendto");
510: DEBUG_ARG("so = %lx", (long)so);
511: DEBUG_ARG("m = %lx", (long)m);
512:
513: addr.sin_family = AF_INET;
514: if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) {
515: /* It's an alias */
516: switch(ntohl(so->so_faddr.s_addr) & 0xff) {
517: case CTL_DNS:
518: addr.sin_addr = dns_addr;
519: break;
520: case CTL_ALIAS:
521: default:
522: addr.sin_addr = loopback_addr;
523: break;
524: }
525: } else
526: addr.sin_addr = so->so_faddr;
527: addr.sin_port = so->so_fport;
528:
529: char addrstr[INET_ADDRSTRLEN];
530: DEBUG_MISC((dfd, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n",
531: ntohs(addr.sin_port), inet_ntop(AF_INET, &addr.sin_addr, addrstr, sizeof(addrstr))));
532:
533: /* Don't care what port we get */
534: ret = sendto(so->s, m->m_data, m->m_len, 0,
535: (struct sockaddr *)&addr, sizeof (struct sockaddr));
536: if (ret < 0)
537: return -1;
538:
539: /*
540: * Kill the socket if there's no reply in 4 minutes,
541: * but only if it's an expirable socket
542: */
543: if (so->so_expire)
544: so->so_expire = curtime + SO_EXPIRE;
545: so->so_state = SS_ISFCONNECTED; /* So that it gets select()ed */
546: return 0;
547: }
548:
549: /*
550: * XXX This should really be tcp_listen
551: */
552: struct socket *
553: solisten(port, laddr, lport, flags)
554: u_int port;
555: u_int32_t laddr;
556: u_int lport;
557: int flags;
558: {
559: struct sockaddr_in addr;
560: struct socket *so;
561: int s;
562: socklen_t addrlen = sizeof(addr);
563: int opt = 1;
564:
565: DEBUG_CALL("solisten");
566: DEBUG_ARG("port = %d", port);
567: DEBUG_ARG("laddr = %x", laddr);
568: DEBUG_ARG("lport = %d", lport);
569: DEBUG_ARG("flags = %x", flags);
570:
571: if ((so = socreate()) == NULL) {
572: /* free(so); Not sofree() ??? free(NULL) == NOP */
573: return NULL;
574: }
575:
576: /* Don't tcp_attach... we don't need so_snd nor so_rcv */
577: if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {
578: free(so);
579: return NULL;
580: }
581: insque(so,&tcb);
582:
583: /*
584: * SS_FACCEPTONCE sockets must time out.
585: */
586: if (flags & SS_FACCEPTONCE)
587: so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;
588:
589: so->so_state = (SS_FACCEPTCONN|flags);
590: so->so_lport = lport; /* Kept in network format */
591: so->so_laddr.s_addr = laddr; /* Ditto */
592:
593: memset(&addr, 0, sizeof(struct sockaddr_in));
594: addr.sin_family = AF_INET;
595: addr.sin_addr.s_addr = INADDR_ANY;
596: addr.sin_port = port;
597:
598: if (((s = socket(AF_INET,SOCK_STREAM,0)) < 0) ||
599: (setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)) < 0) ||
600: (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) ||
601: (listen(s,1) < 0)) {
602: int error = WSAGetLastError(); /* Don't clobber the real reason we failed */
603:
604: close(s);
605: sofree(so);
606: /* Restore the real errno */
607: WSASetLastError(error);
608: return NULL;
609: }
610: setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
611:
612: getsockname(s,(struct sockaddr *)&addr,&addrlen);
613: so->so_fport = addr.sin_port;
614: if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)
615: so->so_faddr = alias_addr;
616: else
617: so->so_faddr = addr.sin_addr;
618:
619: so->s = s;
620: return so;
621: }
622:
623: /*
624: * Data is available in so_rcv
625: * Just write() the data to the socket
626: * XXX not yet...
627: */
628: void
629: sorwakeup(so)
630: struct socket *so;
631: {
632: /* sowrite(so); */
633: /* FD_CLR(so->s,&writefds); */
634: }
635:
636: /*
637: * Data has been freed in so_snd
638: * We have room for a read() if we want to
639: * For now, don't read, it'll be done in the main loop
640: */
641: void
642: sowwakeup(so)
643: struct socket *so;
644: {
645: /* Nothing, yet */
646: }
647:
648: /*
649: * Various session state calls
650: * XXX Should be #define's
651: * The socket state stuff needs work, these often get call 2 or 3
652: * times each when only 1 was needed
653: */
654: void
655: soisfconnecting(so)
656: register struct socket *so;
657: {
658: so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
659: SS_FCANTSENDMORE|SS_FWDRAIN);
660: so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
661: }
662:
663: void
664: soisfconnected(so)
665: register struct socket *so;
666: {
667: so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
668: so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
669: }
670:
671: void
672: sofcantrcvmore(so)
673: struct socket *so;
674: {
675: if ((so->so_state & SS_NOFDREF) == 0) {
676: shutdown(so->s,0);
677: if(global_writefds) {
678: FD_CLR(so->s,global_writefds);
679: }
680: }
681: so->so_state &= ~(SS_ISFCONNECTING);
682: if (so->so_state & SS_FCANTSENDMORE)
683: so->so_state = SS_NOFDREF; /* Don't select it */ /* XXX close() here as well? */
684: else
685: so->so_state |= SS_FCANTRCVMORE;
686: }
687:
688: void
689: sofcantsendmore(so)
690: struct socket *so;
691: {
692: if ((so->so_state & SS_NOFDREF) == 0) {
693: shutdown(so->s,1); /* send FIN to fhost */
694: if (global_readfds) {
695: FD_CLR(so->s,global_readfds);
696: }
697: if (global_xfds) {
698: FD_CLR(so->s,global_xfds);
699: }
700: }
701: so->so_state &= ~(SS_ISFCONNECTING);
702: if (so->so_state & SS_FCANTRCVMORE)
703: so->so_state = SS_NOFDREF; /* as above */
704: else
705: so->so_state |= SS_FCANTSENDMORE;
706: }
707:
708: void
709: soisfdisconnected(so)
710: struct socket *so;
711: {
712: /* so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */
713: /* close(so->s); */
714: /* so->so_state = SS_ISFDISCONNECTED; */
715: /*
716: * XXX Do nothing ... ?
717: */
718: }
719:
720: /*
721: * Set write drain mode
722: * Set CANTSENDMORE once all data has been write()n
723: */
724: void
725: sofwdrain(so)
726: struct socket *so;
727: {
728: if (so->so_rcv.sb_cc)
729: so->so_state |= SS_FWDRAIN;
730: else
731: sofcantsendmore(so);
732: }
733:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.