2 * Copyright (c) 1982, 1986, 1988, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#)tcp_subr.c 8.1 (Berkeley) 6/10/93
30 * tcp_subr.c,v 1.5 1994/10/08 22:39:58 phk Exp
34 * Changes and additions relating to SLiRP
35 * Copyright (c) 1995 Danny Gasparovski.
37 * Please read the file COPYRIGHT for the
38 * terms and conditions of the copyright.
43 /* patchable/settable parameters for tcp */
44 /* Don't do rfc1323 performance enhancements */
45 #define TCP_DO_RFC1323 0
53 tcp_iss
= 1; /* wrong */
54 tcb
.so_next
= tcb
.so_prev
= &tcb
;
58 * Create template to be used to send tcp packets on a connection.
59 * Call after host entry created, fills
60 * in a skeletal tcp/ip header, minimizing the amount of work
61 * necessary when the connection is used.
63 /* struct tcpiphdr * */
65 tcp_template(struct tcpcb
*tp
)
67 struct socket
*so
= tp
->t_socket
;
68 register struct tcpiphdr
*n
= &tp
->t_template
;
72 n
->ti_pr
= IPPROTO_TCP
;
73 n
->ti_len
= htons(sizeof (struct tcpiphdr
) - sizeof (struct ip
));
74 n
->ti_src
= so
->so_faddr
;
75 n
->ti_dst
= so
->so_laddr
;
76 n
->ti_sport
= so
->so_fport
;
77 n
->ti_dport
= so
->so_lport
;
90 * Send a single message to the TCP at address specified by
91 * the given TCP/IP header. If m == 0, then we make a copy
92 * of the tcpiphdr at ti and send directly to the addressed host.
93 * This is used to force keep alive messages out using the TCP
94 * template for a connection tp->t_template. If flags are given
95 * then we send a message back to the TCP which originated the
96 * segment ti, and discard the mbuf containing it and any other
99 * In any case the ack and sequence number of the transmitted
100 * segment are as specified by the parameters.
103 tcp_respond(struct tcpcb
*tp
, struct tcpiphdr
*ti
, struct mbuf
*m
,
104 tcp_seq ack
, tcp_seq seq
, int flags
)
109 DEBUG_CALL("tcp_respond");
110 DEBUG_ARG("tp = %lx", (long)tp
);
111 DEBUG_ARG("ti = %lx", (long)ti
);
112 DEBUG_ARG("m = %lx", (long)m
);
113 DEBUG_ARG("ack = %u", ack
);
114 DEBUG_ARG("seq = %u", seq
);
115 DEBUG_ARG("flags = %x", flags
);
118 win
= sbspace(&tp
->t_socket
->so_rcv
);
120 if ((m
= m_get()) == NULL
)
127 m
->m_data
+= IF_MAXLINKHDR
;
128 *mtod(m
, struct tcpiphdr
*) = *ti
;
129 ti
= mtod(m
, struct tcpiphdr
*);
133 * ti points into m so the next line is just making
134 * the mbuf point to ti
136 m
->m_data
= (caddr_t
)ti
;
138 m
->m_len
= sizeof (struct tcpiphdr
);
140 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
141 xchg(ti
->ti_dst
.s_addr
, ti
->ti_src
.s_addr
, u_int32_t
);
142 xchg(ti
->ti_dport
, ti
->ti_sport
, u_int16_t
);
145 ti
->ti_len
= htons((u_short
)(sizeof (struct tcphdr
) + tlen
));
146 tlen
+= sizeof (struct tcpiphdr
);
151 ti
->ti_seq
= htonl(seq
);
152 ti
->ti_ack
= htonl(ack
);
154 ti
->ti_off
= sizeof (struct tcphdr
) >> 2;
155 ti
->ti_flags
= flags
;
157 ti
->ti_win
= htons((u_int16_t
) (win
>> tp
->rcv_scale
));
159 ti
->ti_win
= htons((u_int16_t
)win
);
162 ti
->ti_sum
= cksum(m
, tlen
);
163 ((struct ip
*)ti
)->ip_len
= tlen
;
166 ((struct ip
*)ti
)->ip_ttl
= MAXTTL
;
168 ((struct ip
*)ti
)->ip_ttl
= IPDEFTTL
;
170 (void) ip_output((struct socket
*)0, m
);
174 * Create a new TCP control block, making an
175 * empty reassembly queue and hooking it to the argument
176 * protocol control block.
179 tcp_newtcpcb(struct socket
*so
)
181 register struct tcpcb
*tp
;
183 tp
= (struct tcpcb
*)malloc(sizeof(*tp
));
185 return ((struct tcpcb
*)0);
187 memset((char *) tp
, 0, sizeof(struct tcpcb
));
188 tp
->seg_next
= tp
->seg_prev
= (struct tcpiphdr
*)tp
;
189 tp
->t_maxseg
= TCP_MSS
;
191 tp
->t_flags
= TCP_DO_RFC1323
? (TF_REQ_SCALE
|TF_REQ_TSTMP
) : 0;
195 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
196 * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
197 * reasonable initial retransmit time.
199 tp
->t_srtt
= TCPTV_SRTTBASE
;
200 tp
->t_rttvar
= TCPTV_SRTTDFLT
<< 2;
201 tp
->t_rttmin
= TCPTV_MIN
;
203 TCPT_RANGESET(tp
->t_rxtcur
,
204 ((TCPTV_SRTTBASE
>> 2) + (TCPTV_SRTTDFLT
<< 2)) >> 1,
205 TCPTV_MIN
, TCPTV_REXMTMAX
);
207 tp
->snd_cwnd
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
208 tp
->snd_ssthresh
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
209 tp
->t_state
= TCPS_CLOSED
;
217 * Drop a TCP connection, reporting
218 * the specified error. If connection is synchronized,
219 * then send a RST to peer.
221 struct tcpcb
*tcp_drop(struct tcpcb
*tp
, int err
)
223 /* tcp_drop(tp, errno)
224 register struct tcpcb *tp;
229 DEBUG_CALL("tcp_drop");
230 DEBUG_ARG("tp = %lx", (long)tp
);
231 DEBUG_ARG("errno = %d", errno
);
233 if (TCPS_HAVERCVDSYN(tp
->t_state
)) {
234 tp
->t_state
= TCPS_CLOSED
;
235 (void) tcp_output(tp
);
236 STAT(tcpstat
.tcps_drops
++);
238 STAT(tcpstat
.tcps_conndrops
++);
239 /* if (errno == ETIMEDOUT && tp->t_softerror)
240 * errno = tp->t_softerror;
242 /* so->so_error = errno; */
243 return (tcp_close(tp
));
247 * Close a TCP control block:
248 * discard all space held by the tcp
249 * discard internet protocol block
250 * wake up any sleepers
253 tcp_close(struct tcpcb
*tp
)
255 register struct tcpiphdr
*t
;
256 struct socket
*so
= tp
->t_socket
;
257 register struct mbuf
*m
;
259 DEBUG_CALL("tcp_close");
260 DEBUG_ARG("tp = %lx", (long )tp
);
262 /* free the reassembly queue, if any */
263 t
= tcpfrag_list_first(tp
);
264 while (!tcpfrag_list_end(t
, tp
)) {
265 t
= tcpiphdr_next(t
);
266 m
= tcpiphdr_prev(t
)->ti_mbuf
;
267 remque(tcpiphdr2qlink(tcpiphdr_prev(t
)));
271 /* if (tp->t_template)
272 * (void) m_free(dtom(tp->t_template));
274 /* free(tp, M_PCB); */
277 soisfdisconnected(so
);
278 /* clobber input socket cache if we're closing the cached connection */
279 if (so
== tcp_last_so
)
285 STAT(tcpstat
.tcps_closed
++);
286 return ((struct tcpcb
*)0);
297 * When a source quench is received, close congestion window
298 * to one segment. We will gradually open it again as we proceed.
305 struct tcpcb
*tp
= intotcpcb(inp
);
308 tp
->snd_cwnd
= tp
->t_maxseg
;
314 * TCP protocol interface to socket abstraction.
318 * User issued close, and wish to trail through shutdown states:
319 * if never received SYN, just forget it. If got a SYN from peer,
320 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
321 * If already got a FIN from peer, then almost done; go to LAST_ACK
322 * state. In all other cases, have already sent FIN to peer (e.g.
323 * after PRU_SHUTDOWN), and just have to play tedious game waiting
324 * for peer to send FIN or not respond to keep-alives, etc.
325 * We can let the user exit from the close as soon as the FIN is acked.
328 tcp_sockclosed(struct tcpcb
*tp
)
331 DEBUG_CALL("tcp_sockclosed");
332 DEBUG_ARG("tp = %lx", (long)tp
);
334 switch (tp
->t_state
) {
339 tp
->t_state
= TCPS_CLOSED
;
343 case TCPS_SYN_RECEIVED
:
344 case TCPS_ESTABLISHED
:
345 tp
->t_state
= TCPS_FIN_WAIT_1
;
348 case TCPS_CLOSE_WAIT
:
349 tp
->t_state
= TCPS_LAST_ACK
;
352 /* soisfdisconnecting(tp->t_socket); */
353 if (tp
&& tp
->t_state
>= TCPS_FIN_WAIT_2
)
354 soisfdisconnected(tp
->t_socket
);
360 * Connect to a host on the Internet
361 * Called by tcp_input
362 * Only do a connect, the tcp fields will be set in tcp_input
363 * return 0 if there's a result of the connect,
364 * else return -1 means we're still connecting
365 * The return value is almost always -1 since the socket is
366 * nonblocking. Connect returns after the SYN is sent, and does
367 * not wait for ACK+SYN.
369 int tcp_fconnect(struct socket
*so
)
373 DEBUG_CALL("tcp_fconnect");
374 DEBUG_ARG("so = %lx", (long )so
);
376 if( (ret
=so
->s
=socket(AF_INET
,SOCK_STREAM
,0)) >= 0) {
378 struct sockaddr_in addr
;
382 setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(opt
));
384 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(opt
));
386 addr
.sin_family
= AF_INET
;
387 if ((so
->so_faddr
.s_addr
& vnetwork_mask
.s_addr
) == vnetwork_addr
.s_addr
) {
389 if (so
->so_faddr
.s_addr
== vnameserver_addr
.s_addr
) {
390 addr
.sin_addr
= dns_addr
;
392 addr
.sin_addr
= loopback_addr
;
395 addr
.sin_addr
= so
->so_faddr
;
396 addr
.sin_port
= so
->so_fport
;
398 DEBUG_MISC((dfd
, " connect()ing, addr.sin_port=%d, "
399 "addr.sin_addr.s_addr=%.16s\n",
400 ntohs(addr
.sin_port
), inet_ntoa(addr
.sin_addr
)));
401 /* We don't care what port we get */
402 ret
= connect(s
,(struct sockaddr
*)&addr
,sizeof (addr
));
405 * If it's not in progress, it failed, so we just return 0,
406 * without clearing SS_NOFDREF
415 * Accept the socket and connect to the local-host
417 * We have a problem. The correct thing to do would be
418 * to first connect to the local-host, and only if the
419 * connection is accepted, then do an accept() here.
420 * But, a) we need to know who's trying to connect
421 * to the socket to be able to SYN the local-host, and
422 * b) we are already connected to the foreign host by
423 * the time it gets to accept(), so... We simply accept
424 * here and SYN the local-host.
427 tcp_connect(struct socket
*inso
)
430 struct sockaddr_in addr
;
431 socklen_t addrlen
= sizeof(struct sockaddr_in
);
435 DEBUG_CALL("tcp_connect");
436 DEBUG_ARG("inso = %lx", (long)inso
);
439 * If it's an SS_ACCEPTONCE socket, no need to socreate()
440 * another socket, just use the accept() socket.
442 if (inso
->so_state
& SS_FACCEPTONCE
) {
443 /* FACCEPTONCE already have a tcpcb */
446 if ((so
= socreate()) == NULL
) {
447 /* If it failed, get rid of the pending connection */
448 closesocket(accept(inso
->s
,(struct sockaddr
*)&addr
,&addrlen
));
451 if (tcp_attach(so
) < 0) {
452 free(so
); /* NOT sofree */
455 so
->so_laddr
= inso
->so_laddr
;
456 so
->so_lport
= inso
->so_lport
;
459 (void) tcp_mss(sototcpcb(so
), 0);
461 if ((s
= accept(inso
->s
,(struct sockaddr
*)&addr
,&addrlen
)) < 0) {
462 tcp_close(sototcpcb(so
)); /* This will sofree() as well */
467 setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(int));
469 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(int));
471 setsockopt(s
,IPPROTO_TCP
,TCP_NODELAY
,(char *)&opt
,sizeof(int));
473 so
->so_fport
= addr
.sin_port
;
474 so
->so_faddr
= addr
.sin_addr
;
475 /* Translate connections from localhost to the real hostname */
476 if (so
->so_faddr
.s_addr
== 0 || so
->so_faddr
.s_addr
== loopback_addr
.s_addr
)
477 so
->so_faddr
= vhost_addr
;
479 /* Close the accept() socket, set right state */
480 if (inso
->so_state
& SS_FACCEPTONCE
) {
481 closesocket(so
->s
); /* If we only accept once, close the accept() socket */
482 so
->so_state
= SS_NOFDREF
; /* Don't select it yet, even though we have an FD */
483 /* if it's not FACCEPTONCE, it's already NOFDREF */
487 so
->so_iptos
= tcp_tos(so
);
492 /* Compute window scaling to request. */
493 /* while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
494 * (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
495 * tp->request_r_scale++;
498 /* soisconnecting(so); */ /* NOFDREF used instead */
499 STAT(tcpstat
.tcps_connattempt
++);
501 tp
->t_state
= TCPS_SYN_SENT
;
502 tp
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
;
504 tcp_iss
+= TCP_ISSINCR
/2;
510 * Attach a TCPCB to a socket.
513 tcp_attach(struct socket
*so
)
515 if ((so
->so_tcpcb
= tcp_newtcpcb(so
)) == NULL
)
524 * Set the socket's type of service field
526 static const struct tos_t tcptos
[] = {
527 {0, 20, IPTOS_THROUGHPUT
, 0}, /* ftp data */
528 {21, 21, IPTOS_LOWDELAY
, EMU_FTP
}, /* ftp control */
529 {0, 23, IPTOS_LOWDELAY
, 0}, /* telnet */
530 {0, 80, IPTOS_THROUGHPUT
, 0}, /* WWW */
531 {0, 513, IPTOS_LOWDELAY
, EMU_RLOGIN
|EMU_NOCONNECT
}, /* rlogin */
532 {0, 514, IPTOS_LOWDELAY
, EMU_RSH
|EMU_NOCONNECT
}, /* shell */
533 {0, 544, IPTOS_LOWDELAY
, EMU_KSH
}, /* kshell */
534 {0, 543, IPTOS_LOWDELAY
, 0}, /* klogin */
535 {0, 6667, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC */
536 {0, 6668, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC undernet */
537 {0, 7070, IPTOS_LOWDELAY
, EMU_REALAUDIO
}, /* RealAudio control */
538 {0, 113, IPTOS_LOWDELAY
, EMU_IDENT
}, /* identd protocol */
545 struct emu_t
*tcpemu
= NULL
;
548 * Return TOS according to the above table
551 tcp_tos(struct socket
*so
)
556 while(tcptos
[i
].tos
) {
557 if ((tcptos
[i
].fport
&& (ntohs(so
->so_fport
) == tcptos
[i
].fport
)) ||
558 (tcptos
[i
].lport
&& (ntohs(so
->so_lport
) == tcptos
[i
].lport
))) {
559 so
->so_emu
= tcptos
[i
].emu
;
560 return tcptos
[i
].tos
;
565 /* Nope, lets see if there's a user-added one */
566 for (emup
= tcpemu
; emup
; emup
= emup
->next
) {
567 if ((emup
->fport
&& (ntohs(so
->so_fport
) == emup
->fport
)) ||
568 (emup
->lport
&& (ntohs(so
->so_lport
) == emup
->lport
))) {
569 so
->so_emu
= emup
->emu
;
582 * Emulate programs that try and connect to us
583 * This includes ftp (the data connection is
584 * initiated by the server) and IRC (DCC CHAT and
587 * NOTE: It's possible to crash SLiRP by sending it
588 * unstandard strings to emulate... if this is a problem,
589 * more checks are needed here
591 * XXX Assumes the whole command came in one packet
593 * XXX Some ftp clients will have their TOS set to
594 * LOWDELAY and so Nagel will kick in. Because of this,
595 * we'll get the first letter, followed by the rest, so
596 * we simply scan for ORT instead of PORT...
597 * DCC doesn't have this problem because there's other stuff
598 * in the packet before the DCC command.
600 * Return 1 if the mbuf m is still valid and should be
603 * NOTE: if you return 0 you MUST m_free() the mbuf!
606 tcp_emu(struct socket
*so
, struct mbuf
*m
)
608 u_int n1
, n2
, n3
, n4
, n5
, n6
;
614 DEBUG_CALL("tcp_emu");
615 DEBUG_ARG("so = %lx", (long)so
);
616 DEBUG_ARG("m = %lx", (long)m
);
623 * Identification protocol as per rfc-1413
627 struct socket
*tmpso
;
628 struct sockaddr_in addr
;
629 socklen_t addrlen
= sizeof(struct sockaddr_in
);
630 struct sbuf
*so_rcv
= &so
->so_rcv
;
632 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
633 so_rcv
->sb_wptr
+= m
->m_len
;
634 so_rcv
->sb_rptr
+= m
->m_len
;
635 m
->m_data
[m
->m_len
] = 0; /* NULL terminate */
636 if (strchr(m
->m_data
, '\r') || strchr(m
->m_data
, '\n')) {
637 if (sscanf(so_rcv
->sb_data
, "%u%*[ ,]%u", &n1
, &n2
) == 2) {
640 /* n2 is the one on our host */
641 for (tmpso
= tcb
.so_next
; tmpso
!= &tcb
; tmpso
= tmpso
->so_next
) {
642 if (tmpso
->so_laddr
.s_addr
== so
->so_laddr
.s_addr
&&
643 tmpso
->so_lport
== n2
&&
644 tmpso
->so_faddr
.s_addr
== so
->so_faddr
.s_addr
&&
645 tmpso
->so_fport
== n1
) {
646 if (getsockname(tmpso
->s
,
647 (struct sockaddr
*)&addr
, &addrlen
) == 0)
648 n2
= ntohs(addr
.sin_port
);
653 so_rcv
->sb_cc
= snprintf(so_rcv
->sb_data
,
655 "%d,%d\r\n", n1
, n2
);
656 so_rcv
->sb_rptr
= so_rcv
->sb_data
;
657 so_rcv
->sb_wptr
= so_rcv
->sb_data
+ so_rcv
->sb_cc
;
667 * First we accumulate all the initial option negotiation,
668 * then fork_exec() rlogin according to the options
675 struct sbuf
*so_snd
= &so
->so_snd
;
676 struct sbuf
*so_rcv
= &so
->so_rcv
;
678 /* First check if they have a priveladged port, or too much data has arrived */
679 if (ntohs(so
->so_lport
) > 1023 || ntohs(so
->so_lport
) < 512 ||
680 (m
->m_len
+ so_rcv
->sb_wptr
) > (so_rcv
->sb_data
+ so_rcv
->sb_datalen
)) {
681 memcpy(so_snd
->sb_wptr
, "Permission denied\n", 18);
682 so_snd
->sb_wptr
+= 18;
684 tcp_sockclosed(sototcpcb(so
));
689 /* Append the current data */
690 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
691 so_rcv
->sb_wptr
+= m
->m_len
;
692 so_rcv
->sb_rptr
+= m
->m_len
;
696 * Check if we have all the initial options,
697 * and build argument list to rlogin while we're here
700 ptr
= so_rcv
->sb_data
;
703 while (ptr
< so_rcv
->sb_wptr
) {
707 sprintf(args
, "rlogin -l %s %s",
708 ptr
, inet_ntoa(so
->so_faddr
));
710 i2
= so_rcv
->sb_wptr
- ptr
;
711 for (i
= 0; i
< i2
; i
++) {
715 sprintf(term
, "%s", ptr
);
717 sprintf(term
, "TERM=%s", ptr
);
730 /* We have it, set our term variable and fork_exec() */
732 setenv("TERM", term
, 1);
736 fork_exec(so
, args
, 2);
740 /* And finally, send the client a 0 character */
741 so_snd
->sb_wptr
[0] = 0;
751 * First we accumulate all the initial option negotiation,
752 * then rsh_exec() rsh according to the options
759 struct sbuf
*so_snd
= &so
->so_snd
;
760 struct sbuf
*so_rcv
= &so
->so_rcv
;
762 /* First check if they have a priveladged port, or too much data has arrived */
763 if (ntohs(so
->so_lport
) > 1023 || ntohs(so
->so_lport
) < 512 ||
764 (m
->m_len
+ so_rcv
->sb_wptr
) > (so_rcv
->sb_data
+ so_rcv
->sb_datalen
)) {
765 memcpy(so_snd
->sb_wptr
, "Permission denied\n", 18);
766 so_snd
->sb_wptr
+= 18;
768 tcp_sockclosed(sototcpcb(so
));
773 /* Append the current data */
774 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
775 so_rcv
->sb_wptr
+= m
->m_len
;
776 so_rcv
->sb_rptr
+= m
->m_len
;
780 * Check if we have all the initial options,
781 * and build argument list to rlogin while we're here
784 ptr
= so_rcv
->sb_data
;
787 if (so
->extra
==NULL
) {
791 if (port
<= 0) return 0;
792 if (port
> 1023 || port
< 512) {
793 memcpy(so_snd
->sb_wptr
, "Permission denied\n", 18);
794 so_snd
->sb_wptr
+= 18;
796 tcp_sockclosed(sototcpcb(so
));
799 if ((ns
=socreate()) == NULL
)
801 if (tcp_attach(ns
)<0) {
806 ns
->so_laddr
=so
->so_laddr
;
807 ns
->so_lport
=htons(port
);
809 (void) tcp_mss(sototcpcb(ns
), 0);
811 ns
->so_faddr
=so
->so_faddr
;
812 ns
->so_fport
=htons(IPPORT_RESERVED
-1); /* Use a fake port. */
814 if (ns
->so_faddr
.s_addr
== 0 ||
815 ns
->so_faddr
.s_addr
== loopback_addr
.s_addr
)
816 ns
->so_faddr
= alias_addr
;
818 ns
->so_iptos
= tcp_tos(ns
);
823 /* Compute window scaling to request. */
824 /* while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
825 * (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
826 * tp->request_r_scale++;
829 /*soisfconnecting(ns);*/
831 STAT(tcpstat
.tcps_connattempt
++);
833 tp
->t_state
= TCPS_SYN_SENT
;
834 tp
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
;
836 tcp_iss
+= TCP_ISSINCR
/2;
841 while (ptr
< so_rcv
->sb_wptr
) {
855 rsh_exec(so
,so
->extra
, user
, inet_ntoa(so
->so_faddr
), args
);
859 /* And finally, send the client a 0 character */
860 so_snd
->sb_wptr
[0] = 0;
870 struct sbuf
*so_snd
= &so
->so_snd
;
871 struct sbuf
*so_rcv
= &so
->so_rcv
;
874 * If there is binary data here, we save it in so->so_m
879 rxdata
=mtod(m
, char *);
880 for (rxlen
=m
->m_len
; rxlen
; rxlen
--) {
881 if (*rxdata
++ & 0x80) {
886 } /* if(so->so_m==NULL) */
891 sbappendsb(so_rcv
, m
);
893 /* To avoid going over the edge of the buffer, we reset it */
894 if (so_snd
->sb_cc
== 0)
895 so_snd
->sb_wptr
= so_snd
->sb_rptr
= so_snd
->sb_data
;
899 * If the first packet we get here is 1 byte long, then it
900 * was done in telnet character mode, therefore we must echo
901 * the characters as they come. Otherwise, we echo nothing,
902 * because in linemode, the line is already echoed
903 * XXX two or more control connections won't work
906 if (m
->m_len
== 1) do_echo
= 1;
910 sbappendsb(so_snd
, m
);
912 tcp_output(sototcpcb(so
)); /* XXX */
917 while (num
< so
->so_rcv
.sb_cc
) {
918 if (*(so
->so_rcv
.sb_rptr
+ num
) == '\n' ||
919 *(so
->so_rcv
.sb_rptr
+ num
) == '\r') {
922 *(so_rcv
->sb_rptr
+ num
) = 0;
923 if (ctl_password
&& !ctl_password_ok
) {
924 /* Need a password */
925 if (sscanf(so_rcv
->sb_rptr
, "pass %256s", buff
) == 1) {
926 if (strcmp(buff
, ctl_password
) == 0) {
928 n
= sprintf(so_snd
->sb_wptr
,
933 n
= sprintf(so_snd
->sb_wptr
,
934 "Error: Password required, log on with \"pass PASSWORD\"\r\n");
938 n
= do_config(so_rcv
->sb_rptr
, so
, PRN_SPRINTF
);
940 /* Register the printed data */
943 so_snd
->sb_wptr
+= n
;
945 n
= sprintf(so_snd
->sb_wptr
, "Slirp> ");
947 so_snd
->sb_wptr
+= n
;
949 /* Drop so_rcv data */
951 so_rcv
->sb_wptr
= so_rcv
->sb_rptr
= so_rcv
->sb_data
;
952 tcp_output(sototcpcb(so
)); /* Send the reply */
959 case EMU_FTP
: /* ftp */
960 *(m
->m_data
+m
->m_len
) = 0; /* NUL terminate for strstr */
961 if ((bptr
= (char *)strstr(m
->m_data
, "ORT")) != NULL
) {
963 * Need to emulate the PORT command
965 x
= sscanf(bptr
, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
966 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
970 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
971 lport
= htons((n5
<< 8) | (n6
));
973 if ((so
= solisten(0, laddr
, lport
, SS_FACCEPTONCE
)) == NULL
)
976 n6
= ntohs(so
->so_fport
);
978 n5
= (n6
>> 8) & 0xff;
981 laddr
= ntohl(so
->so_faddr
.s_addr
);
983 n1
= ((laddr
>> 24) & 0xff);
984 n2
= ((laddr
>> 16) & 0xff);
985 n3
= ((laddr
>> 8) & 0xff);
988 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
989 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
- m
->m_len
,
990 "ORT %d,%d,%d,%d,%d,%d\r\n%s",
991 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
993 } else if ((bptr
= (char *)strstr(m
->m_data
, "27 Entering")) != NULL
) {
995 * Need to emulate the PASV response
997 x
= sscanf(bptr
, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
998 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
1002 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
1003 lport
= htons((n5
<< 8) | (n6
));
1005 if ((so
= solisten(0, laddr
, lport
, SS_FACCEPTONCE
)) == NULL
)
1008 n6
= ntohs(so
->so_fport
);
1010 n5
= (n6
>> 8) & 0xff;
1013 laddr
= ntohl(so
->so_faddr
.s_addr
);
1015 n1
= ((laddr
>> 24) & 0xff);
1016 n2
= ((laddr
>> 16) & 0xff);
1017 n3
= ((laddr
>> 8) & 0xff);
1018 n4
= (laddr
& 0xff);
1020 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1021 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
- m
->m_len
,
1022 "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
1023 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
1032 * The kshell (Kerberos rsh) and shell services both pass
1033 * a local port port number to carry signals to the server
1034 * and stderr to the client. It is passed at the beginning
1035 * of the connection as a NUL-terminated decimal ASCII string.
1038 for (lport
= 0, i
= 0; i
< m
->m_len
-1; ++i
) {
1039 if (m
->m_data
[i
] < '0' || m
->m_data
[i
] > '9')
1040 return 1; /* invalid number */
1042 lport
+= m
->m_data
[i
] - '0';
1044 if (m
->m_data
[m
->m_len
-1] == '\0' && lport
!= 0 &&
1045 (so
= solisten(0, so
->so_laddr
.s_addr
, htons(lport
), SS_FACCEPTONCE
)) != NULL
)
1046 m
->m_len
= snprintf(m
->m_data
, m
->m_hdr
.mh_size
, "%d",
1047 ntohs(so
->so_fport
)) + 1;
1052 * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
1054 *(m
->m_data
+m
->m_len
) = 0; /* NULL terminate the string for strstr */
1055 if ((bptr
= (char *)strstr(m
->m_data
, "DCC")) == NULL
)
1058 /* The %256s is for the broken mIRC */
1059 if (sscanf(bptr
, "DCC CHAT %256s %u %u", buff
, &laddr
, &lport
) == 3) {
1060 if ((so
= solisten(0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
1063 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1064 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
1065 "DCC CHAT chat %lu %u%c\n",
1066 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
1067 ntohs(so
->so_fport
), 1);
1068 } else if (sscanf(bptr
, "DCC SEND %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
1069 if ((so
= solisten(0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
1072 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1073 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
1074 "DCC SEND %s %lu %u %u%c\n", buff
,
1075 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
1076 ntohs(so
->so_fport
), n1
, 1);
1077 } else if (sscanf(bptr
, "DCC MOVE %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
1078 if ((so
= solisten(0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
1081 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1082 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
1083 "DCC MOVE %s %lu %u %u%c\n", buff
,
1084 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
1085 ntohs(so
->so_fport
), n1
, 1);
1091 * RealAudio emulation - JP. We must try to parse the incoming
1092 * data and try to find the two characters that contain the
1093 * port number. Then we redirect an udp port and replace the
1094 * number with the real port we got.
1096 * The 1.0 beta versions of the player are not supported
1099 * A typical packet for player version 1.0 (release version):
1101 * 0000:50 4E 41 00 05
1102 * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 .....×..gælÜc..P
1103 * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
1104 * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
1105 * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
1107 * Now the port number 0x1BD7 is found at offset 0x04 of the
1108 * Now the port number 0x1BD7 is found at offset 0x04 of the
1109 * second packet. This time we received five bytes first and
1110 * then the rest. You never know how many bytes you get.
1112 * A typical packet for player version 2.0 (beta):
1114 * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA...........Á.
1115 * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .guxõc..Win2.0.0
1116 * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
1117 * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
1118 * 0040:65 2E 72 61 79 53 00 00 06 36 42 e.rayS...6B
1120 * Port number 0x1BC1 is found at offset 0x0d.
1122 * This is just a horrible switch statement. Variable ra tells
1123 * us where we're going.
1127 while (bptr
< m
->m_data
+ m
->m_len
) {
1141 if (*bptr
++ != ra_tbl
[ra
]) {
1149 * We may get 0x50 several times, ignore them
1151 if (*bptr
== 0x50) {
1155 } else if (*bptr
++ != ra_tbl
[ra
]) {
1163 * skip version number
1170 * The difference between versions 1.0 and
1171 * 2.0 is here. For future versions of
1172 * the player this may need to be modified.
1174 if (*(bptr
+ 1) == 0x02)
1181 /* This is the field containing the port
1182 * number that RA-player is listening to.
1184 lport
= (((u_char
*)bptr
)[0] << 8)
1185 + ((u_char
*)bptr
)[1];
1187 lport
+= 256; /* don't know why */
1188 if (lport
< 6970 || lport
> 7170)
1189 return 1; /* failed */
1191 /* try to get udp port between 6970 - 7170 */
1192 for (p
= 6970; p
< 7071; p
++) {
1193 if (udp_listen( htons(p
),
1194 so
->so_laddr
.s_addr
,
1202 *(u_char
*)bptr
++ = (p
>> 8) & 0xff;
1203 *(u_char
*)bptr
++ = p
& 0xff;
1205 return 1; /* port redirected, we're done */
1216 /* Ooops, not emulated, won't call tcp_emu again */
1223 * Do misc. config of SLiRP while its running.
1224 * Return 0 if this connections is to be closed, 1 otherwise,
1225 * return 2 if this is a command-line connection
1227 int tcp_ctl(struct socket
*so
)
1229 struct sbuf
*sb
= &so
->so_snd
;
1230 struct ex_list
*ex_ptr
;
1233 DEBUG_CALL("tcp_ctl");
1234 DEBUG_ARG("so = %lx", (long )so
);
1236 if (so
->so_faddr
.s_addr
!= vhost_addr
.s_addr
) {
1237 /* Check if it's pty_exec */
1238 for (ex_ptr
= exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
1239 if (ex_ptr
->ex_fport
== so
->so_fport
&&
1240 so
->so_faddr
.s_addr
== ex_ptr
->ex_addr
.s_addr
) {
1241 if (ex_ptr
->ex_pty
== 3) {
1243 so
->extra
= (void *)ex_ptr
->ex_exec
;
1246 do_pty
= ex_ptr
->ex_pty
;
1247 DEBUG_MISC((dfd
, " executing %s \n",ex_ptr
->ex_exec
));
1248 return fork_exec(so
, ex_ptr
->ex_exec
, do_pty
);
1253 snprintf(sb
->sb_wptr
, sb
->sb_datalen
- (sb
->sb_wptr
- sb
->sb_data
),
1254 "Error: No application configured.\r\n");
1255 sb
->sb_wptr
+= sb
->sb_cc
;