66/*
67 * TCP protocol interface to socket abstraction.
68 */
69extern char *tcpstates[]; /* XXX ??? */
70
71static int tcp_attach __P((struct socket *, struct proc *));
72static int tcp_connect __P((struct tcpcb *, struct sockaddr *,
73 struct proc *));
74static struct tcpcb *
75 tcp_disconnect __P((struct tcpcb *));
76static struct tcpcb *
77 tcp_usrclosed __P((struct tcpcb *));
78
79#ifdef TCPDEBUG
80#define TCPDEBUG0 int ostate
81#define TCPDEBUG1() ostate = tp ? tp->t_state : 0
82#define TCPDEBUG2(req) if (tp && (so->so_options & SO_DEBUG)) \
83 tcp_trace(TA_USER, ostate, tp, 0, req)
84#else
85#define TCPDEBUG0
86#define TCPDEBUG1()
87#define TCPDEBUG2(req)
88#endif
89
90/*
91 * TCP attaches to socket via pru_attach(), reserving space,
92 * and an internet control block.
93 */
94static int
95tcp_usr_attach(struct socket *so, int proto, struct proc *p)
96{
97 int s = splnet();
98 int error;
99 struct inpcb *inp = sotoinpcb(so);
100 struct tcpcb *tp = 0;
101 TCPDEBUG0;
102
103 TCPDEBUG1();
104 if (inp) {
105 error = EISCONN;
106 goto out;
107 }
108
109 error = tcp_attach(so, p);
110 if (error)
111 goto out;
112
113 if ((so->so_options & SO_LINGER) && so->so_linger == 0)
114 so->so_linger = TCP_LINGERTIME;
115 tp = sototcpcb(so);
116out:
117 TCPDEBUG2(PRU_ATTACH);
118 splx(s);
119 return error;
120}
121
122/*
123 * pru_detach() detaches the TCP protocol from the socket.
124 * If the protocol state is non-embryonic, then can't
125 * do this directly: have to initiate a pru_disconnect(),
126 * which may finish later; embryonic TCB's can just
127 * be discarded here.
128 */
129static int
130tcp_usr_detach(struct socket *so)
131{
132 int s = splnet();
133 int error = 0;
134 struct inpcb *inp = sotoinpcb(so);
135 struct tcpcb *tp;
136 TCPDEBUG0;
137
138 if (inp == 0) {
139 splx(s);
140 return EINVAL; /* XXX */
141 }
142 tp = intotcpcb(inp);
143 TCPDEBUG1();
144 tp = tcp_disconnect(tp);
145
146 TCPDEBUG2(PRU_DETACH);
147 splx(s);
148 return error;
149}
150
151#define COMMON_START() TCPDEBUG0; \
152 do { \
153 if (inp == 0) { \
154 splx(s); \
155 return EINVAL; \
156 } \
157 tp = intotcpcb(inp); \
158 TCPDEBUG1(); \
159 } while(0)
160
161#define COMMON_END(req) out: TCPDEBUG2(req); splx(s); return error; goto out
162
163
164/*
165 * Give the socket an address.
166 */
167static int
168tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
169{
170 int s = splnet();
171 int error = 0;
172 struct inpcb *inp = sotoinpcb(so);
173 struct tcpcb *tp;
174 struct sockaddr_in *sinp;
175
176 COMMON_START();
177
178 /*
179 * Must check for multicast addresses and disallow binding
180 * to them.
181 */
182 sinp = (struct sockaddr_in *)nam;
183 if (sinp->sin_family == AF_INET &&
184 IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
185 error = EAFNOSUPPORT;
186 goto out;
187 }
188 error = in_pcbbind(inp, nam, p);
189 if (error)
190 goto out;
191 COMMON_END(PRU_BIND);
192
193}
194
195/*
196 * Prepare to accept connections.
197 */
198static int
199tcp_usr_listen(struct socket *so, struct proc *p)
200{
201 int s = splnet();
202 int error = 0;
203 struct inpcb *inp = sotoinpcb(so);
204 struct tcpcb *tp;
205
206 COMMON_START();
207 if (inp->inp_lport == 0)
208 error = in_pcbbind(inp, (struct sockaddr *)0, p);
209 if (error == 0)
210 tp->t_state = TCPS_LISTEN;
211 COMMON_END(PRU_LISTEN);
212}
213
214/*
215 * Initiate connection to peer.
216 * Create a template for use in transmissions on this connection.
217 * Enter SYN_SENT state, and mark socket as connecting.
218 * Start keep-alive timer, and seed output sequence space.
219 * Send initial segment on connection.
220 */
221static int
222tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
223{
224 int s = splnet();
225 int error = 0;
226 struct inpcb *inp = sotoinpcb(so);
227 struct tcpcb *tp;
228 struct sockaddr_in *sinp;
229
230 COMMON_START();
231
232 /*
233 * Must disallow TCP ``connections'' to multicast addresses.
234 */
235 sinp = (struct sockaddr_in *)nam;
236 if (sinp->sin_family == AF_INET
237 && IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
238 error = EAFNOSUPPORT;
239 goto out;
240 }
241
242 prison_remote_ip(p, 0, &sinp->sin_addr.s_addr);
243
244 if ((error = tcp_connect(tp, nam, p)) != 0)
245 goto out;
246 error = tcp_output(tp);
247 COMMON_END(PRU_CONNECT);
248}
249
250/*
251 * Initiate disconnect from peer.
252 * If connection never passed embryonic stage, just drop;
253 * else if don't need to let data drain, then can just drop anyways,
254 * else have to begin TCP shutdown process: mark socket disconnecting,
255 * drain unread data, state switch to reflect user close, and
256 * send segment (e.g. FIN) to peer. Socket will be really disconnected
257 * when peer sends FIN and acks ours.
258 *
259 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
260 */
261static int
262tcp_usr_disconnect(struct socket *so)
263{
264 int s = splnet();
265 int error = 0;
266 struct inpcb *inp = sotoinpcb(so);
267 struct tcpcb *tp;
268
269 COMMON_START();
270 tp = tcp_disconnect(tp);
271 COMMON_END(PRU_DISCONNECT);
272}
273
274/*
275 * Accept a connection. Essentially all the work is
276 * done at higher levels; just return the address
277 * of the peer, storing through addr.
278 */
279static int
280tcp_usr_accept(struct socket *so, struct sockaddr **nam)
281{
282 int s = splnet();
283 int error = 0;
284 struct inpcb *inp = sotoinpcb(so);
285 struct tcpcb *tp;
286
287 COMMON_START();
288 in_setpeeraddr(so, nam);
289 COMMON_END(PRU_ACCEPT);
290}
291
292/*
293 * Mark the connection as being incapable of further output.
294 */
295static int
296tcp_usr_shutdown(struct socket *so)
297{
298 int s = splnet();
299 int error = 0;
300 struct inpcb *inp = sotoinpcb(so);
301 struct tcpcb *tp;
302
303 COMMON_START();
304 socantsendmore(so);
305 tp = tcp_usrclosed(tp);
306 if (tp)
307 error = tcp_output(tp);
308 COMMON_END(PRU_SHUTDOWN);
309}
310
311/*
312 * After a receive, possibly send window update to peer.
313 */
314static int
315tcp_usr_rcvd(struct socket *so, int flags)
316{
317 int s = splnet();
318 int error = 0;
319 struct inpcb *inp = sotoinpcb(so);
320 struct tcpcb *tp;
321
322 COMMON_START();
323 tcp_output(tp);
324 COMMON_END(PRU_RCVD);
325}
326
327/*
328 * Do a send by putting data in output queue and updating urgent
329 * marker if URG set. Possibly send more data. Unlike the other
330 * pru_*() routines, the mbuf chains are our responsibility. We
331 * must either enqueue them or free them. The other pru_* routines
332 * generally are caller-frees.
333 */
334static int
335tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
336 struct sockaddr *nam, struct mbuf *control, struct proc *p)
337{
338 int s = splnet();
339 int error = 0;
340 struct inpcb *inp = sotoinpcb(so);
341 struct tcpcb *tp;
342 TCPDEBUG0;
343
344 if (inp == NULL) {
345 /*
346 * OOPS! we lost a race, the TCP session got reset after
347 * we checked SS_CANTSENDMORE, eg: while doing uiomove or a
348 * network interrupt in the non-splnet() section of sosend().
349 */
350 if (m)
351 m_freem(m);
352 if (control)
353 m_freem(control);
354 error = ECONNRESET; /* XXX EPIPE? */
355 tp = NULL;
356 TCPDEBUG1();
357 goto out;
358 }
359 tp = intotcpcb(inp);
360 TCPDEBUG1();
361 if (control) {
362 /* TCP doesn't do control messages (rights, creds, etc) */
363 if (control->m_len) {
364 m_freem(control);
365 if (m)
366 m_freem(m);
367 error = EINVAL;
368 goto out;
369 }
370 m_freem(control); /* empty control, just free it */
371 }
372 if(!(flags & PRUS_OOB)) {
373 sbappend(&so->so_snd, m);
374 if (nam && tp->t_state < TCPS_SYN_SENT) {
375 /*
376 * Do implied connect if not yet connected,
377 * initialize window to default value, and
378 * initialize maxseg/maxopd using peer's cached
379 * MSS.
380 */
381 error = tcp_connect(tp, nam, p);
382 if (error)
383 goto out;
384 tp->snd_wnd = TTCP_CLIENT_SND_WND;
385 tcp_mss(tp, -1);
386 }
387
388 if (flags & PRUS_EOF) {
389 /*
390 * Close the send side of the connection after
391 * the data is sent.
392 */
393 socantsendmore(so);
394 tp = tcp_usrclosed(tp);
395 }
396 if (tp != NULL) {
397 if (flags & PRUS_MORETOCOME)
398 tp->t_flags |= TF_MORETOCOME;
399 error = tcp_output(tp);
400 if (flags & PRUS_MORETOCOME)
401 tp->t_flags &= ~TF_MORETOCOME;
402 }
403 } else {
404 if (sbspace(&so->so_snd) < -512) {
405 m_freem(m);
406 error = ENOBUFS;
407 goto out;
408 }
409 /*
410 * According to RFC961 (Assigned Protocols),
411 * the urgent pointer points to the last octet
412 * of urgent data. We continue, however,
413 * to consider it to indicate the first octet
414 * of data past the urgent section.
415 * Otherwise, snd_up should be one lower.
416 */
417 sbappend(&so->so_snd, m);
418 if (nam && tp->t_state < TCPS_SYN_SENT) {
419 /*
420 * Do implied connect if not yet connected,
421 * initialize window to default value, and
422 * initialize maxseg/maxopd using peer's cached
423 * MSS.
424 */
425 error = tcp_connect(tp, nam, p);
426 if (error)
427 goto out;
428 tp->snd_wnd = TTCP_CLIENT_SND_WND;
429 tcp_mss(tp, -1);
430 }
431 tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
432 tp->t_force = 1;
433 error = tcp_output(tp);
434 tp->t_force = 0;
435 }
436 COMMON_END((flags & PRUS_OOB) ? PRU_SENDOOB :
437 ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
438}
439
440/*
441 * Abort the TCP.
442 */
443static int
444tcp_usr_abort(struct socket *so)
445{
446 int s = splnet();
447 int error = 0;
448 struct inpcb *inp = sotoinpcb(so);
449 struct tcpcb *tp;
450
451 COMMON_START();
452 tp = tcp_drop(tp, ECONNABORTED);
453 COMMON_END(PRU_ABORT);
454}
455
456/*
457 * Receive out-of-band data.
458 */
459static int
460tcp_usr_rcvoob(struct socket *so, struct mbuf *m, int flags)
461{
462 int s = splnet();
463 int error = 0;
464 struct inpcb *inp = sotoinpcb(so);
465 struct tcpcb *tp;
466
467 COMMON_START();
468 if ((so->so_oobmark == 0 &&
469 (so->so_state & SS_RCVATMARK) == 0) ||
470 so->so_options & SO_OOBINLINE ||
471 tp->t_oobflags & TCPOOB_HADDATA) {
472 error = EINVAL;
473 goto out;
474 }
475 if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
476 error = EWOULDBLOCK;
477 goto out;
478 }
479 m->m_len = 1;
480 *mtod(m, caddr_t) = tp->t_iobc;
481 if ((flags & MSG_PEEK) == 0)
482 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
483 COMMON_END(PRU_RCVOOB);
484}
485
486/* xxx - should be const */
487struct pr_usrreqs tcp_usrreqs = {
488 tcp_usr_abort, tcp_usr_accept, tcp_usr_attach, tcp_usr_bind,
489 tcp_usr_connect, pru_connect2_notsupp, in_control, tcp_usr_detach,
490 tcp_usr_disconnect, tcp_usr_listen, in_setpeeraddr, tcp_usr_rcvd,
491 tcp_usr_rcvoob, tcp_usr_send, pru_sense_null, tcp_usr_shutdown,
492 in_setsockaddr, sosend, soreceive, sopoll
493};
494
495/*
496 * Common subroutine to open a TCP connection to remote host specified
497 * by struct sockaddr_in in mbuf *nam. Call in_pcbbind to assign a local
498 * port number if needed. Call in_pcbladdr to do the routing and to choose
499 * a local host address (interface). If there is an existing incarnation
500 * of the same connection in TIME-WAIT state and if the remote host was
501 * sending CC options and if the connection duration was < MSL, then
502 * truncate the previous TIME-WAIT state and proceed.
503 * Initialize connection parameters and enter SYN-SENT state.
504 */
505static int
506tcp_connect(tp, nam, p)
507 register struct tcpcb *tp;
508 struct sockaddr *nam;
509 struct proc *p;
510{
511 struct inpcb *inp = tp->t_inpcb, *oinp;
512 struct socket *so = inp->inp_socket;
513 struct tcpcb *otp;
514 struct sockaddr_in *sin = (struct sockaddr_in *)nam;
515 struct sockaddr_in *ifaddr;
516 struct rmxp_tao *taop;
517 struct rmxp_tao tao_noncached;
518 int error;
519
520 if (inp->inp_lport == 0) {
521 error = in_pcbbind(inp, (struct sockaddr *)0, p);
522 if (error)
523 return error;
524 }
525
526 /*
527 * Cannot simply call in_pcbconnect, because there might be an
528 * earlier incarnation of this same connection still in
529 * TIME_WAIT state, creating an ADDRINUSE error.
530 */
531 error = in_pcbladdr(inp, nam, &ifaddr);
532 if (error)
533 return error;
534 oinp = in_pcblookup_hash(inp->inp_pcbinfo,
535 sin->sin_addr, sin->sin_port,
536 inp->inp_laddr.s_addr != INADDR_ANY ? inp->inp_laddr
537 : ifaddr->sin_addr,
538 inp->inp_lport, 0, NULL);
539 if (oinp) {
540 if (oinp != inp && (otp = intotcpcb(oinp)) != NULL &&
541 otp->t_state == TCPS_TIME_WAIT &&
542 (ticks - otp->t_starttime) < tcp_msl &&
543 (otp->t_flags & TF_RCVD_CC))
544 otp = tcp_close(otp);
545 else
546 return EADDRINUSE;
547 }
548 if (inp->inp_laddr.s_addr == INADDR_ANY)
549 inp->inp_laddr = ifaddr->sin_addr;
550 inp->inp_faddr = sin->sin_addr;
551 inp->inp_fport = sin->sin_port;
552 in_pcbrehash(inp);
553
554 tp->t_template = tcp_template(tp);
555 if (tp->t_template == 0) {
556 in_pcbdisconnect(inp);
557 return ENOBUFS;
558 }
559
560 /* Compute window scaling to request. */
561 while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
562 (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
563 tp->request_r_scale++;
564
565 soisconnecting(so);
566 tcpstat.tcps_connattempt++;
567 tp->t_state = TCPS_SYN_SENT;
568 callout_reset(tp->tt_keep, tcp_keepinit, tcp_timer_keep, tp);
569 tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
570 tcp_sendseqinit(tp);
571
572 /*
573 * Generate a CC value for this connection and
574 * check whether CC or CCnew should be used.
575 */
576 if ((taop = tcp_gettaocache(tp->t_inpcb)) == NULL) {
577 taop = &tao_noncached;
578 bzero(taop, sizeof(*taop));
579 }
580
581 tp->cc_send = CC_INC(tcp_ccgen);
582 if (taop->tao_ccsent != 0 &&
583 CC_GEQ(tp->cc_send, taop->tao_ccsent)) {
584 taop->tao_ccsent = tp->cc_send;
585 } else {
586 taop->tao_ccsent = 0;
587 tp->t_flags |= TF_SENDCCNEW;
588 }
589
590 return 0;
591}
592
593/*
594 * The new sockopt interface makes it possible for us to block in the
595 * copyin/out step (if we take a page fault). Taking a page fault at
596 * splnet() is probably a Bad Thing. (Since sockets and pcbs both now
597 * use TSM, there probably isn't any need for this function to run at
598 * splnet() any more. This needs more examination.)
599 */
600int
601tcp_ctloutput(so, sopt)
602 struct socket *so;
603 struct sockopt *sopt;
604{
605 int error, opt, optval, s;
606 struct inpcb *inp;
607 struct tcpcb *tp;
608
609 error = 0;
610 s = splnet(); /* XXX */
611 inp = sotoinpcb(so);
612 if (inp == NULL) {
613 splx(s);
614 return (ECONNRESET);
615 }
616 if (sopt->sopt_level != IPPROTO_TCP) {
617 error = ip_ctloutput(so, sopt);
618 splx(s);
619 return (error);
620 }
621 tp = intotcpcb(inp);
622
623 switch (sopt->sopt_dir) {
624 case SOPT_SET:
625 switch (sopt->sopt_name) {
626 case TCP_NODELAY:
627 case TCP_NOOPT:
628 case TCP_NOPUSH:
629 error = sooptcopyin(sopt, &optval, sizeof optval,
630 sizeof optval);
631 if (error)
632 break;
633
634 switch (sopt->sopt_name) {
635 case TCP_NODELAY:
636 opt = TF_NODELAY;
637 break;
638 case TCP_NOOPT:
639 opt = TF_NOOPT;
640 break;
641 case TCP_NOPUSH:
642 opt = TF_NOPUSH;
643 break;
644 default:
645 opt = 0; /* dead code to fool gcc */
646 break;
647 }
648
649 if (optval)
650 tp->t_flags |= opt;
651 else
652 tp->t_flags &= ~opt;
653 break;
654
655 case TCP_MAXSEG:
656 error = sooptcopyin(sopt, &optval, sizeof optval,
657 sizeof optval);
658 if (error)
659 break;
660
661 if (optval > 0 && optval <= tp->t_maxseg)
662 tp->t_maxseg = optval;
663 else
664 error = EINVAL;
665 break;
666
667 default:
668 error = ENOPROTOOPT;
669 break;
670 }
671 break;
672
673 case SOPT_GET:
674 switch (sopt->sopt_name) {
675 case TCP_NODELAY:
676 optval = tp->t_flags & TF_NODELAY;
677 break;
678 case TCP_MAXSEG:
679 optval = tp->t_maxseg;
680 break;
681 case TCP_NOOPT:
682 optval = tp->t_flags & TF_NOOPT;
683 break;
684 case TCP_NOPUSH:
685 optval = tp->t_flags & TF_NOPUSH;
686 break;
687 default:
688 error = ENOPROTOOPT;
689 break;
690 }
691 if (error == 0)
692 error = sooptcopyout(sopt, &optval, sizeof optval);
693 break;
694 }
695 splx(s);
696 return (error);
697}
698
699/*
700 * tcp_sendspace and tcp_recvspace are the default send and receive window
701 * sizes, respectively. These are obsolescent (this information should
702 * be set by the route).
703 */
704u_long tcp_sendspace = 1024*16;
705SYSCTL_INT(_net_inet_tcp, TCPCTL_SENDSPACE, sendspace, CTLFLAG_RW,
706 &tcp_sendspace , 0, "Maximum outgoing TCP datagram size");
707u_long tcp_recvspace = 1024*16;
708SYSCTL_INT(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLFLAG_RW,
709 &tcp_recvspace , 0, "Maximum incoming TCP datagram size");
710
711/*
712 * Attach TCP protocol to socket, allocating
713 * internet protocol control block, tcp control block,
714 * bufer space, and entering LISTEN state if to accept connections.
715 */
716static int
717tcp_attach(so, p)
718 struct socket *so;
719 struct proc *p;
720{
721 register struct tcpcb *tp;
722 struct inpcb *inp;
723 int error;
724
725 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
726 error = soreserve(so, tcp_sendspace, tcp_recvspace);
727 if (error)
728 return (error);
729 }
730 error = in_pcballoc(so, &tcbinfo, p);
731 if (error)
732 return (error);
733 inp = sotoinpcb(so);
| 71/*
72 * TCP protocol interface to socket abstraction.
73 */
74extern char *tcpstates[]; /* XXX ??? */
75
76static int tcp_attach __P((struct socket *, struct proc *));
77static int tcp_connect __P((struct tcpcb *, struct sockaddr *,
78 struct proc *));
79static struct tcpcb *
80 tcp_disconnect __P((struct tcpcb *));
81static struct tcpcb *
82 tcp_usrclosed __P((struct tcpcb *));
83
84#ifdef TCPDEBUG
85#define TCPDEBUG0 int ostate
86#define TCPDEBUG1() ostate = tp ? tp->t_state : 0
87#define TCPDEBUG2(req) if (tp && (so->so_options & SO_DEBUG)) \
88 tcp_trace(TA_USER, ostate, tp, 0, req)
89#else
90#define TCPDEBUG0
91#define TCPDEBUG1()
92#define TCPDEBUG2(req)
93#endif
94
95/*
96 * TCP attaches to socket via pru_attach(), reserving space,
97 * and an internet control block.
98 */
99static int
100tcp_usr_attach(struct socket *so, int proto, struct proc *p)
101{
102 int s = splnet();
103 int error;
104 struct inpcb *inp = sotoinpcb(so);
105 struct tcpcb *tp = 0;
106 TCPDEBUG0;
107
108 TCPDEBUG1();
109 if (inp) {
110 error = EISCONN;
111 goto out;
112 }
113
114 error = tcp_attach(so, p);
115 if (error)
116 goto out;
117
118 if ((so->so_options & SO_LINGER) && so->so_linger == 0)
119 so->so_linger = TCP_LINGERTIME;
120 tp = sototcpcb(so);
121out:
122 TCPDEBUG2(PRU_ATTACH);
123 splx(s);
124 return error;
125}
126
127/*
128 * pru_detach() detaches the TCP protocol from the socket.
129 * If the protocol state is non-embryonic, then can't
130 * do this directly: have to initiate a pru_disconnect(),
131 * which may finish later; embryonic TCB's can just
132 * be discarded here.
133 */
134static int
135tcp_usr_detach(struct socket *so)
136{
137 int s = splnet();
138 int error = 0;
139 struct inpcb *inp = sotoinpcb(so);
140 struct tcpcb *tp;
141 TCPDEBUG0;
142
143 if (inp == 0) {
144 splx(s);
145 return EINVAL; /* XXX */
146 }
147 tp = intotcpcb(inp);
148 TCPDEBUG1();
149 tp = tcp_disconnect(tp);
150
151 TCPDEBUG2(PRU_DETACH);
152 splx(s);
153 return error;
154}
155
156#define COMMON_START() TCPDEBUG0; \
157 do { \
158 if (inp == 0) { \
159 splx(s); \
160 return EINVAL; \
161 } \
162 tp = intotcpcb(inp); \
163 TCPDEBUG1(); \
164 } while(0)
165
166#define COMMON_END(req) out: TCPDEBUG2(req); splx(s); return error; goto out
167
168
169/*
170 * Give the socket an address.
171 */
172static int
173tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
174{
175 int s = splnet();
176 int error = 0;
177 struct inpcb *inp = sotoinpcb(so);
178 struct tcpcb *tp;
179 struct sockaddr_in *sinp;
180
181 COMMON_START();
182
183 /*
184 * Must check for multicast addresses and disallow binding
185 * to them.
186 */
187 sinp = (struct sockaddr_in *)nam;
188 if (sinp->sin_family == AF_INET &&
189 IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
190 error = EAFNOSUPPORT;
191 goto out;
192 }
193 error = in_pcbbind(inp, nam, p);
194 if (error)
195 goto out;
196 COMMON_END(PRU_BIND);
197
198}
199
200/*
201 * Prepare to accept connections.
202 */
203static int
204tcp_usr_listen(struct socket *so, struct proc *p)
205{
206 int s = splnet();
207 int error = 0;
208 struct inpcb *inp = sotoinpcb(so);
209 struct tcpcb *tp;
210
211 COMMON_START();
212 if (inp->inp_lport == 0)
213 error = in_pcbbind(inp, (struct sockaddr *)0, p);
214 if (error == 0)
215 tp->t_state = TCPS_LISTEN;
216 COMMON_END(PRU_LISTEN);
217}
218
219/*
220 * Initiate connection to peer.
221 * Create a template for use in transmissions on this connection.
222 * Enter SYN_SENT state, and mark socket as connecting.
223 * Start keep-alive timer, and seed output sequence space.
224 * Send initial segment on connection.
225 */
226static int
227tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
228{
229 int s = splnet();
230 int error = 0;
231 struct inpcb *inp = sotoinpcb(so);
232 struct tcpcb *tp;
233 struct sockaddr_in *sinp;
234
235 COMMON_START();
236
237 /*
238 * Must disallow TCP ``connections'' to multicast addresses.
239 */
240 sinp = (struct sockaddr_in *)nam;
241 if (sinp->sin_family == AF_INET
242 && IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
243 error = EAFNOSUPPORT;
244 goto out;
245 }
246
247 prison_remote_ip(p, 0, &sinp->sin_addr.s_addr);
248
249 if ((error = tcp_connect(tp, nam, p)) != 0)
250 goto out;
251 error = tcp_output(tp);
252 COMMON_END(PRU_CONNECT);
253}
254
255/*
256 * Initiate disconnect from peer.
257 * If connection never passed embryonic stage, just drop;
258 * else if don't need to let data drain, then can just drop anyways,
259 * else have to begin TCP shutdown process: mark socket disconnecting,
260 * drain unread data, state switch to reflect user close, and
261 * send segment (e.g. FIN) to peer. Socket will be really disconnected
262 * when peer sends FIN and acks ours.
263 *
264 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
265 */
266static int
267tcp_usr_disconnect(struct socket *so)
268{
269 int s = splnet();
270 int error = 0;
271 struct inpcb *inp = sotoinpcb(so);
272 struct tcpcb *tp;
273
274 COMMON_START();
275 tp = tcp_disconnect(tp);
276 COMMON_END(PRU_DISCONNECT);
277}
278
279/*
280 * Accept a connection. Essentially all the work is
281 * done at higher levels; just return the address
282 * of the peer, storing through addr.
283 */
284static int
285tcp_usr_accept(struct socket *so, struct sockaddr **nam)
286{
287 int s = splnet();
288 int error = 0;
289 struct inpcb *inp = sotoinpcb(so);
290 struct tcpcb *tp;
291
292 COMMON_START();
293 in_setpeeraddr(so, nam);
294 COMMON_END(PRU_ACCEPT);
295}
296
297/*
298 * Mark the connection as being incapable of further output.
299 */
300static int
301tcp_usr_shutdown(struct socket *so)
302{
303 int s = splnet();
304 int error = 0;
305 struct inpcb *inp = sotoinpcb(so);
306 struct tcpcb *tp;
307
308 COMMON_START();
309 socantsendmore(so);
310 tp = tcp_usrclosed(tp);
311 if (tp)
312 error = tcp_output(tp);
313 COMMON_END(PRU_SHUTDOWN);
314}
315
316/*
317 * After a receive, possibly send window update to peer.
318 */
319static int
320tcp_usr_rcvd(struct socket *so, int flags)
321{
322 int s = splnet();
323 int error = 0;
324 struct inpcb *inp = sotoinpcb(so);
325 struct tcpcb *tp;
326
327 COMMON_START();
328 tcp_output(tp);
329 COMMON_END(PRU_RCVD);
330}
331
332/*
333 * Do a send by putting data in output queue and updating urgent
334 * marker if URG set. Possibly send more data. Unlike the other
335 * pru_*() routines, the mbuf chains are our responsibility. We
336 * must either enqueue them or free them. The other pru_* routines
337 * generally are caller-frees.
338 */
339static int
340tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
341 struct sockaddr *nam, struct mbuf *control, struct proc *p)
342{
343 int s = splnet();
344 int error = 0;
345 struct inpcb *inp = sotoinpcb(so);
346 struct tcpcb *tp;
347 TCPDEBUG0;
348
349 if (inp == NULL) {
350 /*
351 * OOPS! we lost a race, the TCP session got reset after
352 * we checked SS_CANTSENDMORE, eg: while doing uiomove or a
353 * network interrupt in the non-splnet() section of sosend().
354 */
355 if (m)
356 m_freem(m);
357 if (control)
358 m_freem(control);
359 error = ECONNRESET; /* XXX EPIPE? */
360 tp = NULL;
361 TCPDEBUG1();
362 goto out;
363 }
364 tp = intotcpcb(inp);
365 TCPDEBUG1();
366 if (control) {
367 /* TCP doesn't do control messages (rights, creds, etc) */
368 if (control->m_len) {
369 m_freem(control);
370 if (m)
371 m_freem(m);
372 error = EINVAL;
373 goto out;
374 }
375 m_freem(control); /* empty control, just free it */
376 }
377 if(!(flags & PRUS_OOB)) {
378 sbappend(&so->so_snd, m);
379 if (nam && tp->t_state < TCPS_SYN_SENT) {
380 /*
381 * Do implied connect if not yet connected,
382 * initialize window to default value, and
383 * initialize maxseg/maxopd using peer's cached
384 * MSS.
385 */
386 error = tcp_connect(tp, nam, p);
387 if (error)
388 goto out;
389 tp->snd_wnd = TTCP_CLIENT_SND_WND;
390 tcp_mss(tp, -1);
391 }
392
393 if (flags & PRUS_EOF) {
394 /*
395 * Close the send side of the connection after
396 * the data is sent.
397 */
398 socantsendmore(so);
399 tp = tcp_usrclosed(tp);
400 }
401 if (tp != NULL) {
402 if (flags & PRUS_MORETOCOME)
403 tp->t_flags |= TF_MORETOCOME;
404 error = tcp_output(tp);
405 if (flags & PRUS_MORETOCOME)
406 tp->t_flags &= ~TF_MORETOCOME;
407 }
408 } else {
409 if (sbspace(&so->so_snd) < -512) {
410 m_freem(m);
411 error = ENOBUFS;
412 goto out;
413 }
414 /*
415 * According to RFC961 (Assigned Protocols),
416 * the urgent pointer points to the last octet
417 * of urgent data. We continue, however,
418 * to consider it to indicate the first octet
419 * of data past the urgent section.
420 * Otherwise, snd_up should be one lower.
421 */
422 sbappend(&so->so_snd, m);
423 if (nam && tp->t_state < TCPS_SYN_SENT) {
424 /*
425 * Do implied connect if not yet connected,
426 * initialize window to default value, and
427 * initialize maxseg/maxopd using peer's cached
428 * MSS.
429 */
430 error = tcp_connect(tp, nam, p);
431 if (error)
432 goto out;
433 tp->snd_wnd = TTCP_CLIENT_SND_WND;
434 tcp_mss(tp, -1);
435 }
436 tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
437 tp->t_force = 1;
438 error = tcp_output(tp);
439 tp->t_force = 0;
440 }
441 COMMON_END((flags & PRUS_OOB) ? PRU_SENDOOB :
442 ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
443}
444
445/*
446 * Abort the TCP.
447 */
448static int
449tcp_usr_abort(struct socket *so)
450{
451 int s = splnet();
452 int error = 0;
453 struct inpcb *inp = sotoinpcb(so);
454 struct tcpcb *tp;
455
456 COMMON_START();
457 tp = tcp_drop(tp, ECONNABORTED);
458 COMMON_END(PRU_ABORT);
459}
460
461/*
462 * Receive out-of-band data.
463 */
464static int
465tcp_usr_rcvoob(struct socket *so, struct mbuf *m, int flags)
466{
467 int s = splnet();
468 int error = 0;
469 struct inpcb *inp = sotoinpcb(so);
470 struct tcpcb *tp;
471
472 COMMON_START();
473 if ((so->so_oobmark == 0 &&
474 (so->so_state & SS_RCVATMARK) == 0) ||
475 so->so_options & SO_OOBINLINE ||
476 tp->t_oobflags & TCPOOB_HADDATA) {
477 error = EINVAL;
478 goto out;
479 }
480 if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
481 error = EWOULDBLOCK;
482 goto out;
483 }
484 m->m_len = 1;
485 *mtod(m, caddr_t) = tp->t_iobc;
486 if ((flags & MSG_PEEK) == 0)
487 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
488 COMMON_END(PRU_RCVOOB);
489}
490
491/* xxx - should be const */
492struct pr_usrreqs tcp_usrreqs = {
493 tcp_usr_abort, tcp_usr_accept, tcp_usr_attach, tcp_usr_bind,
494 tcp_usr_connect, pru_connect2_notsupp, in_control, tcp_usr_detach,
495 tcp_usr_disconnect, tcp_usr_listen, in_setpeeraddr, tcp_usr_rcvd,
496 tcp_usr_rcvoob, tcp_usr_send, pru_sense_null, tcp_usr_shutdown,
497 in_setsockaddr, sosend, soreceive, sopoll
498};
499
500/*
501 * Common subroutine to open a TCP connection to remote host specified
502 * by struct sockaddr_in in mbuf *nam. Call in_pcbbind to assign a local
503 * port number if needed. Call in_pcbladdr to do the routing and to choose
504 * a local host address (interface). If there is an existing incarnation
505 * of the same connection in TIME-WAIT state and if the remote host was
506 * sending CC options and if the connection duration was < MSL, then
507 * truncate the previous TIME-WAIT state and proceed.
508 * Initialize connection parameters and enter SYN-SENT state.
509 */
510static int
511tcp_connect(tp, nam, p)
512 register struct tcpcb *tp;
513 struct sockaddr *nam;
514 struct proc *p;
515{
516 struct inpcb *inp = tp->t_inpcb, *oinp;
517 struct socket *so = inp->inp_socket;
518 struct tcpcb *otp;
519 struct sockaddr_in *sin = (struct sockaddr_in *)nam;
520 struct sockaddr_in *ifaddr;
521 struct rmxp_tao *taop;
522 struct rmxp_tao tao_noncached;
523 int error;
524
525 if (inp->inp_lport == 0) {
526 error = in_pcbbind(inp, (struct sockaddr *)0, p);
527 if (error)
528 return error;
529 }
530
531 /*
532 * Cannot simply call in_pcbconnect, because there might be an
533 * earlier incarnation of this same connection still in
534 * TIME_WAIT state, creating an ADDRINUSE error.
535 */
536 error = in_pcbladdr(inp, nam, &ifaddr);
537 if (error)
538 return error;
539 oinp = in_pcblookup_hash(inp->inp_pcbinfo,
540 sin->sin_addr, sin->sin_port,
541 inp->inp_laddr.s_addr != INADDR_ANY ? inp->inp_laddr
542 : ifaddr->sin_addr,
543 inp->inp_lport, 0, NULL);
544 if (oinp) {
545 if (oinp != inp && (otp = intotcpcb(oinp)) != NULL &&
546 otp->t_state == TCPS_TIME_WAIT &&
547 (ticks - otp->t_starttime) < tcp_msl &&
548 (otp->t_flags & TF_RCVD_CC))
549 otp = tcp_close(otp);
550 else
551 return EADDRINUSE;
552 }
553 if (inp->inp_laddr.s_addr == INADDR_ANY)
554 inp->inp_laddr = ifaddr->sin_addr;
555 inp->inp_faddr = sin->sin_addr;
556 inp->inp_fport = sin->sin_port;
557 in_pcbrehash(inp);
558
559 tp->t_template = tcp_template(tp);
560 if (tp->t_template == 0) {
561 in_pcbdisconnect(inp);
562 return ENOBUFS;
563 }
564
565 /* Compute window scaling to request. */
566 while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
567 (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
568 tp->request_r_scale++;
569
570 soisconnecting(so);
571 tcpstat.tcps_connattempt++;
572 tp->t_state = TCPS_SYN_SENT;
573 callout_reset(tp->tt_keep, tcp_keepinit, tcp_timer_keep, tp);
574 tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
575 tcp_sendseqinit(tp);
576
577 /*
578 * Generate a CC value for this connection and
579 * check whether CC or CCnew should be used.
580 */
581 if ((taop = tcp_gettaocache(tp->t_inpcb)) == NULL) {
582 taop = &tao_noncached;
583 bzero(taop, sizeof(*taop));
584 }
585
586 tp->cc_send = CC_INC(tcp_ccgen);
587 if (taop->tao_ccsent != 0 &&
588 CC_GEQ(tp->cc_send, taop->tao_ccsent)) {
589 taop->tao_ccsent = tp->cc_send;
590 } else {
591 taop->tao_ccsent = 0;
592 tp->t_flags |= TF_SENDCCNEW;
593 }
594
595 return 0;
596}
597
598/*
599 * The new sockopt interface makes it possible for us to block in the
600 * copyin/out step (if we take a page fault). Taking a page fault at
601 * splnet() is probably a Bad Thing. (Since sockets and pcbs both now
602 * use TSM, there probably isn't any need for this function to run at
603 * splnet() any more. This needs more examination.)
604 */
605int
606tcp_ctloutput(so, sopt)
607 struct socket *so;
608 struct sockopt *sopt;
609{
610 int error, opt, optval, s;
611 struct inpcb *inp;
612 struct tcpcb *tp;
613
614 error = 0;
615 s = splnet(); /* XXX */
616 inp = sotoinpcb(so);
617 if (inp == NULL) {
618 splx(s);
619 return (ECONNRESET);
620 }
621 if (sopt->sopt_level != IPPROTO_TCP) {
622 error = ip_ctloutput(so, sopt);
623 splx(s);
624 return (error);
625 }
626 tp = intotcpcb(inp);
627
628 switch (sopt->sopt_dir) {
629 case SOPT_SET:
630 switch (sopt->sopt_name) {
631 case TCP_NODELAY:
632 case TCP_NOOPT:
633 case TCP_NOPUSH:
634 error = sooptcopyin(sopt, &optval, sizeof optval,
635 sizeof optval);
636 if (error)
637 break;
638
639 switch (sopt->sopt_name) {
640 case TCP_NODELAY:
641 opt = TF_NODELAY;
642 break;
643 case TCP_NOOPT:
644 opt = TF_NOOPT;
645 break;
646 case TCP_NOPUSH:
647 opt = TF_NOPUSH;
648 break;
649 default:
650 opt = 0; /* dead code to fool gcc */
651 break;
652 }
653
654 if (optval)
655 tp->t_flags |= opt;
656 else
657 tp->t_flags &= ~opt;
658 break;
659
660 case TCP_MAXSEG:
661 error = sooptcopyin(sopt, &optval, sizeof optval,
662 sizeof optval);
663 if (error)
664 break;
665
666 if (optval > 0 && optval <= tp->t_maxseg)
667 tp->t_maxseg = optval;
668 else
669 error = EINVAL;
670 break;
671
672 default:
673 error = ENOPROTOOPT;
674 break;
675 }
676 break;
677
678 case SOPT_GET:
679 switch (sopt->sopt_name) {
680 case TCP_NODELAY:
681 optval = tp->t_flags & TF_NODELAY;
682 break;
683 case TCP_MAXSEG:
684 optval = tp->t_maxseg;
685 break;
686 case TCP_NOOPT:
687 optval = tp->t_flags & TF_NOOPT;
688 break;
689 case TCP_NOPUSH:
690 optval = tp->t_flags & TF_NOPUSH;
691 break;
692 default:
693 error = ENOPROTOOPT;
694 break;
695 }
696 if (error == 0)
697 error = sooptcopyout(sopt, &optval, sizeof optval);
698 break;
699 }
700 splx(s);
701 return (error);
702}
703
704/*
705 * tcp_sendspace and tcp_recvspace are the default send and receive window
706 * sizes, respectively. These are obsolescent (this information should
707 * be set by the route).
708 */
709u_long tcp_sendspace = 1024*16;
710SYSCTL_INT(_net_inet_tcp, TCPCTL_SENDSPACE, sendspace, CTLFLAG_RW,
711 &tcp_sendspace , 0, "Maximum outgoing TCP datagram size");
712u_long tcp_recvspace = 1024*16;
713SYSCTL_INT(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLFLAG_RW,
714 &tcp_recvspace , 0, "Maximum incoming TCP datagram size");
715
716/*
717 * Attach TCP protocol to socket, allocating
718 * internet protocol control block, tcp control block,
719 * bufer space, and entering LISTEN state if to accept connections.
720 */
721static int
722tcp_attach(so, p)
723 struct socket *so;
724 struct proc *p;
725{
726 register struct tcpcb *tp;
727 struct inpcb *inp;
728 int error;
729
730 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
731 error = soreserve(so, tcp_sendspace, tcp_recvspace);
732 if (error)
733 return (error);
734 }
735 error = in_pcballoc(so, &tcbinfo, p);
736 if (error)
737 return (error);
738 inp = sotoinpcb(so);
|