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.
41 #define WANT_SYS_IOCTL_H
44 /* patchable/settable parameters for tcp */
45 /* Don't do rfc1323 performance enhancements */
46 #define TCP_DO_RFC1323 0
54 tcp_iss
= 1; /* wrong */
55 tcb
.so_next
= tcb
.so_prev
= &tcb
;
59 * Create template to be used to send tcp packets on a connection.
60 * Call after host entry created, fills
61 * in a skeletal tcp/ip header, minimizing the amount of work
62 * necessary when the connection is used.
64 /* struct tcpiphdr * */
66 tcp_template(struct tcpcb
*tp
)
68 struct socket
*so
= tp
->t_socket
;
69 register struct tcpiphdr
*n
= &tp
->t_template
;
73 n
->ti_pr
= IPPROTO_TCP
;
74 n
->ti_len
= htons(sizeof (struct tcpiphdr
) - sizeof (struct ip
));
75 n
->ti_src
= so
->so_faddr
;
76 n
->ti_dst
= so
->so_laddr
;
77 n
->ti_sport
= so
->so_fport
;
78 n
->ti_dport
= so
->so_lport
;
91 * Send a single message to the TCP at address specified by
92 * the given TCP/IP header. If m == 0, then we make a copy
93 * of the tcpiphdr at ti and send directly to the addressed host.
94 * This is used to force keep alive messages out using the TCP
95 * template for a connection tp->t_template. If flags are given
96 * then we send a message back to the TCP which originated the
97 * segment ti, and discard the mbuf containing it and any other
100 * In any case the ack and sequence number of the transmitted
101 * segment are as specified by the parameters.
104 tcp_respond(struct tcpcb
*tp
, struct tcpiphdr
*ti
, struct mbuf
*m
,
105 tcp_seq ack
, tcp_seq seq
, int flags
)
110 DEBUG_CALL("tcp_respond");
111 DEBUG_ARG("tp = %lx", (long)tp
);
112 DEBUG_ARG("ti = %lx", (long)ti
);
113 DEBUG_ARG("m = %lx", (long)m
);
114 DEBUG_ARG("ack = %u", ack
);
115 DEBUG_ARG("seq = %u", seq
);
116 DEBUG_ARG("flags = %x", flags
);
119 win
= sbspace(&tp
->t_socket
->so_rcv
);
121 if ((m
= m_get()) == NULL
)
128 m
->m_data
+= IF_MAXLINKHDR
;
129 *mtod(m
, struct tcpiphdr
*) = *ti
;
130 ti
= mtod(m
, struct tcpiphdr
*);
134 * ti points into m so the next line is just making
135 * the mbuf point to ti
137 m
->m_data
= (caddr_t
)ti
;
139 m
->m_len
= sizeof (struct tcpiphdr
);
141 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
142 xchg(ti
->ti_dst
.s_addr
, ti
->ti_src
.s_addr
, u_int32_t
);
143 xchg(ti
->ti_dport
, ti
->ti_sport
, u_int16_t
);
146 ti
->ti_len
= htons((u_short
)(sizeof (struct tcphdr
) + tlen
));
147 tlen
+= sizeof (struct tcpiphdr
);
152 ti
->ti_seq
= htonl(seq
);
153 ti
->ti_ack
= htonl(ack
);
155 ti
->ti_off
= sizeof (struct tcphdr
) >> 2;
156 ti
->ti_flags
= flags
;
158 ti
->ti_win
= htons((u_int16_t
) (win
>> tp
->rcv_scale
));
160 ti
->ti_win
= htons((u_int16_t
)win
);
163 ti
->ti_sum
= cksum(m
, tlen
);
164 ((struct ip
*)ti
)->ip_len
= tlen
;
167 ((struct ip
*)ti
)->ip_ttl
= MAXTTL
;
169 ((struct ip
*)ti
)->ip_ttl
= IPDEFTTL
;
171 (void) ip_output((struct socket
*)0, m
);
175 * Create a new TCP control block, making an
176 * empty reassembly queue and hooking it to the argument
177 * protocol control block.
180 tcp_newtcpcb(struct socket
*so
)
182 register struct tcpcb
*tp
;
184 tp
= (struct tcpcb
*)malloc(sizeof(*tp
));
186 return ((struct tcpcb
*)0);
188 memset((char *) tp
, 0, sizeof(struct tcpcb
));
189 tp
->seg_next
= tp
->seg_prev
= (struct tcpiphdr
*)tp
;
190 tp
->t_maxseg
= TCP_MSS
;
192 tp
->t_flags
= TCP_DO_RFC1323
? (TF_REQ_SCALE
|TF_REQ_TSTMP
) : 0;
196 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
197 * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
198 * reasonable initial retransmit time.
200 tp
->t_srtt
= TCPTV_SRTTBASE
;
201 tp
->t_rttvar
= TCPTV_SRTTDFLT
<< 2;
202 tp
->t_rttmin
= TCPTV_MIN
;
204 TCPT_RANGESET(tp
->t_rxtcur
,
205 ((TCPTV_SRTTBASE
>> 2) + (TCPTV_SRTTDFLT
<< 2)) >> 1,
206 TCPTV_MIN
, TCPTV_REXMTMAX
);
208 tp
->snd_cwnd
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
209 tp
->snd_ssthresh
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
210 tp
->t_state
= TCPS_CLOSED
;
218 * Drop a TCP connection, reporting
219 * the specified error. If connection is synchronized,
220 * then send a RST to peer.
222 struct tcpcb
*tcp_drop(struct tcpcb
*tp
, int err
)
224 /* tcp_drop(tp, errno)
225 register struct tcpcb *tp;
230 DEBUG_CALL("tcp_drop");
231 DEBUG_ARG("tp = %lx", (long)tp
);
232 DEBUG_ARG("errno = %d", errno
);
234 if (TCPS_HAVERCVDSYN(tp
->t_state
)) {
235 tp
->t_state
= TCPS_CLOSED
;
236 (void) tcp_output(tp
);
237 STAT(tcpstat
.tcps_drops
++);
239 STAT(tcpstat
.tcps_conndrops
++);
240 /* if (errno == ETIMEDOUT && tp->t_softerror)
241 * errno = tp->t_softerror;
243 /* so->so_error = errno; */
244 return (tcp_close(tp
));
248 * Close a TCP control block:
249 * discard all space held by the tcp
250 * discard internet protocol block
251 * wake up any sleepers
254 tcp_close(struct tcpcb
*tp
)
256 register struct tcpiphdr
*t
;
257 struct socket
*so
= tp
->t_socket
;
258 register struct mbuf
*m
;
260 DEBUG_CALL("tcp_close");
261 DEBUG_ARG("tp = %lx", (long )tp
);
263 /* free the reassembly queue, if any */
264 t
= tcpfrag_list_first(tp
);
265 while (!tcpfrag_list_end(t
, tp
)) {
266 t
= tcpiphdr_next(t
);
267 m
= tcpiphdr_prev(t
)->ti_mbuf
;
268 remque(tcpiphdr2qlink(tcpiphdr_prev(t
)));
272 /* if (tp->t_template)
273 * (void) m_free(dtom(tp->t_template));
275 /* free(tp, M_PCB); */
278 soisfdisconnected(so
);
279 /* clobber input socket cache if we're closing the cached connection */
280 if (so
== tcp_last_so
)
286 STAT(tcpstat
.tcps_closed
++);
287 return ((struct tcpcb
*)0);
298 * When a source quench is received, close congestion window
299 * to one segment. We will gradually open it again as we proceed.
306 struct tcpcb
*tp
= intotcpcb(inp
);
309 tp
->snd_cwnd
= tp
->t_maxseg
;
315 * TCP protocol interface to socket abstraction.
319 * User issued close, and wish to trail through shutdown states:
320 * if never received SYN, just forget it. If got a SYN from peer,
321 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
322 * If already got a FIN from peer, then almost done; go to LAST_ACK
323 * state. In all other cases, have already sent FIN to peer (e.g.
324 * after PRU_SHUTDOWN), and just have to play tedious game waiting
325 * for peer to send FIN or not respond to keep-alives, etc.
326 * We can let the user exit from the close as soon as the FIN is acked.
329 tcp_sockclosed(struct tcpcb
*tp
)
332 DEBUG_CALL("tcp_sockclosed");
333 DEBUG_ARG("tp = %lx", (long)tp
);
335 switch (tp
->t_state
) {
340 tp
->t_state
= TCPS_CLOSED
;
344 case TCPS_SYN_RECEIVED
:
345 case TCPS_ESTABLISHED
:
346 tp
->t_state
= TCPS_FIN_WAIT_1
;
349 case TCPS_CLOSE_WAIT
:
350 tp
->t_state
= TCPS_LAST_ACK
;
353 /* soisfdisconnecting(tp->t_socket); */
354 if (tp
&& tp
->t_state
>= TCPS_FIN_WAIT_2
)
355 soisfdisconnected(tp
->t_socket
);
361 * Connect to a host on the Internet
362 * Called by tcp_input
363 * Only do a connect, the tcp fields will be set in tcp_input
364 * return 0 if there's a result of the connect,
365 * else return -1 means we're still connecting
366 * The return value is almost always -1 since the socket is
367 * nonblocking. Connect returns after the SYN is sent, and does
368 * not wait for ACK+SYN.
370 int tcp_fconnect(struct socket
*so
)
374 DEBUG_CALL("tcp_fconnect");
375 DEBUG_ARG("so = %lx", (long )so
);
377 if( (ret
=so
->s
=socket(AF_INET
,SOCK_STREAM
,0)) >= 0) {
379 struct sockaddr_in addr
;
383 setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(opt
));
385 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(opt
));
387 addr
.sin_family
= AF_INET
;
388 if ((so
->so_faddr
.s_addr
& htonl(0xffffff00)) == special_addr
.s_addr
) {
390 switch(ntohl(so
->so_faddr
.s_addr
) & 0xff) {
392 addr
.sin_addr
= dns_addr
;
396 addr
.sin_addr
= loopback_addr
;
400 addr
.sin_addr
= so
->so_faddr
;
401 addr
.sin_port
= so
->so_fport
;
403 DEBUG_MISC((dfd
, " connect()ing, addr.sin_port=%d, "
404 "addr.sin_addr.s_addr=%.16s\n",
405 ntohs(addr
.sin_port
), inet_ntoa(addr
.sin_addr
)));
406 /* We don't care what port we get */
407 ret
= connect(s
,(struct sockaddr
*)&addr
,sizeof (addr
));
410 * If it's not in progress, it failed, so we just return 0,
411 * without clearing SS_NOFDREF
420 * Accept the socket and connect to the local-host
422 * We have a problem. The correct thing to do would be
423 * to first connect to the local-host, and only if the
424 * connection is accepted, then do an accept() here.
425 * But, a) we need to know who's trying to connect
426 * to the socket to be able to SYN the local-host, and
427 * b) we are already connected to the foreign host by
428 * the time it gets to accept(), so... We simply accept
429 * here and SYN the local-host.
432 tcp_connect(struct socket
*inso
)
435 struct sockaddr_in addr
;
436 socklen_t addrlen
= sizeof(struct sockaddr_in
);
440 DEBUG_CALL("tcp_connect");
441 DEBUG_ARG("inso = %lx", (long)inso
);
444 * If it's an SS_ACCEPTONCE socket, no need to socreate()
445 * another socket, just use the accept() socket.
447 if (inso
->so_state
& SS_FACCEPTONCE
) {
448 /* FACCEPTONCE already have a tcpcb */
451 if ((so
= socreate()) == NULL
) {
452 /* If it failed, get rid of the pending connection */
453 closesocket(accept(inso
->s
,(struct sockaddr
*)&addr
,&addrlen
));
456 if (tcp_attach(so
) < 0) {
457 free(so
); /* NOT sofree */
460 so
->so_laddr
= inso
->so_laddr
;
461 so
->so_lport
= inso
->so_lport
;
464 (void) tcp_mss(sototcpcb(so
), 0);
466 if ((s
= accept(inso
->s
,(struct sockaddr
*)&addr
,&addrlen
)) < 0) {
467 tcp_close(sototcpcb(so
)); /* This will sofree() as well */
472 setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(int));
474 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(int));
476 setsockopt(s
,IPPROTO_TCP
,TCP_NODELAY
,(char *)&opt
,sizeof(int));
478 so
->so_fport
= addr
.sin_port
;
479 so
->so_faddr
= addr
.sin_addr
;
480 /* Translate connections from localhost to the real hostname */
481 if (so
->so_faddr
.s_addr
== 0 || so
->so_faddr
.s_addr
== loopback_addr
.s_addr
)
482 so
->so_faddr
= alias_addr
;
484 /* Close the accept() socket, set right state */
485 if (inso
->so_state
& SS_FACCEPTONCE
) {
486 closesocket(so
->s
); /* If we only accept once, close the accept() socket */
487 so
->so_state
= SS_NOFDREF
; /* Don't select it yet, even though we have an FD */
488 /* if it's not FACCEPTONCE, it's already NOFDREF */
492 so
->so_iptos
= tcp_tos(so
);
497 /* Compute window scaling to request. */
498 /* while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
499 * (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
500 * tp->request_r_scale++;
503 /* soisconnecting(so); */ /* NOFDREF used instead */
504 STAT(tcpstat
.tcps_connattempt
++);
506 tp
->t_state
= TCPS_SYN_SENT
;
507 tp
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
;
509 tcp_iss
+= TCP_ISSINCR
/2;
515 * Attach a TCPCB to a socket.
518 tcp_attach(struct socket
*so
)
520 if ((so
->so_tcpcb
= tcp_newtcpcb(so
)) == NULL
)
529 * Set the socket's type of service field
531 static const struct tos_t tcptos
[] = {
532 {0, 20, IPTOS_THROUGHPUT
, 0}, /* ftp data */
533 {21, 21, IPTOS_LOWDELAY
, EMU_FTP
}, /* ftp control */
534 {0, 23, IPTOS_LOWDELAY
, 0}, /* telnet */
535 {0, 80, IPTOS_THROUGHPUT
, 0}, /* WWW */
536 {0, 513, IPTOS_LOWDELAY
, EMU_RLOGIN
|EMU_NOCONNECT
}, /* rlogin */
537 {0, 514, IPTOS_LOWDELAY
, EMU_RSH
|EMU_NOCONNECT
}, /* shell */
538 {0, 544, IPTOS_LOWDELAY
, EMU_KSH
}, /* kshell */
539 {0, 543, IPTOS_LOWDELAY
, 0}, /* klogin */
540 {0, 6667, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC */
541 {0, 6668, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC undernet */
542 {0, 7070, IPTOS_LOWDELAY
, EMU_REALAUDIO
}, /* RealAudio control */
543 {0, 113, IPTOS_LOWDELAY
, EMU_IDENT
}, /* identd protocol */
550 struct emu_t
*tcpemu
= NULL
;
553 * Return TOS according to the above table
556 tcp_tos(struct socket
*so
)
561 while(tcptos
[i
].tos
) {
562 if ((tcptos
[i
].fport
&& (ntohs(so
->so_fport
) == tcptos
[i
].fport
)) ||
563 (tcptos
[i
].lport
&& (ntohs(so
->so_lport
) == tcptos
[i
].lport
))) {
564 so
->so_emu
= tcptos
[i
].emu
;
565 return tcptos
[i
].tos
;
570 /* Nope, lets see if there's a user-added one */
571 for (emup
= tcpemu
; emup
; emup
= emup
->next
) {
572 if ((emup
->fport
&& (ntohs(so
->so_fport
) == emup
->fport
)) ||
573 (emup
->lport
&& (ntohs(so
->so_lport
) == emup
->lport
))) {
574 so
->so_emu
= emup
->emu
;
587 * Emulate programs that try and connect to us
588 * This includes ftp (the data connection is
589 * initiated by the server) and IRC (DCC CHAT and
592 * NOTE: It's possible to crash SLiRP by sending it
593 * unstandard strings to emulate... if this is a problem,
594 * more checks are needed here
596 * XXX Assumes the whole command came in one packet
598 * XXX Some ftp clients will have their TOS set to
599 * LOWDELAY and so Nagel will kick in. Because of this,
600 * we'll get the first letter, followed by the rest, so
601 * we simply scan for ORT instead of PORT...
602 * DCC doesn't have this problem because there's other stuff
603 * in the packet before the DCC command.
605 * Return 1 if the mbuf m is still valid and should be
608 * NOTE: if you return 0 you MUST m_free() the mbuf!
611 tcp_emu(struct socket
*so
, struct mbuf
*m
)
613 u_int n1
, n2
, n3
, n4
, n5
, n6
;
619 DEBUG_CALL("tcp_emu");
620 DEBUG_ARG("so = %lx", (long)so
);
621 DEBUG_ARG("m = %lx", (long)m
);
628 * Identification protocol as per rfc-1413
632 struct socket
*tmpso
;
633 struct sockaddr_in addr
;
634 socklen_t addrlen
= sizeof(struct sockaddr_in
);
635 struct sbuf
*so_rcv
= &so
->so_rcv
;
637 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
638 so_rcv
->sb_wptr
+= m
->m_len
;
639 so_rcv
->sb_rptr
+= m
->m_len
;
640 m
->m_data
[m
->m_len
] = 0; /* NULL terminate */
641 if (strchr(m
->m_data
, '\r') || strchr(m
->m_data
, '\n')) {
642 if (sscanf(so_rcv
->sb_data
, "%u%*[ ,]%u", &n1
, &n2
) == 2) {
645 /* n2 is the one on our host */
646 for (tmpso
= tcb
.so_next
; tmpso
!= &tcb
; tmpso
= tmpso
->so_next
) {
647 if (tmpso
->so_laddr
.s_addr
== so
->so_laddr
.s_addr
&&
648 tmpso
->so_lport
== n2
&&
649 tmpso
->so_faddr
.s_addr
== so
->so_faddr
.s_addr
&&
650 tmpso
->so_fport
== n1
) {
651 if (getsockname(tmpso
->s
,
652 (struct sockaddr
*)&addr
, &addrlen
) == 0)
653 n2
= ntohs(addr
.sin_port
);
658 so_rcv
->sb_cc
= snprintf(so_rcv
->sb_data
,
660 "%d,%d\r\n", n1
, n2
);
661 so_rcv
->sb_rptr
= so_rcv
->sb_data
;
662 so_rcv
->sb_wptr
= so_rcv
->sb_data
+ so_rcv
->sb_cc
;
672 * First we accumulate all the initial option negotiation,
673 * then fork_exec() rlogin according to the options
680 struct sbuf
*so_snd
= &so
->so_snd
;
681 struct sbuf
*so_rcv
= &so
->so_rcv
;
683 /* First check if they have a priveladged port, or too much data has arrived */
684 if (ntohs(so
->so_lport
) > 1023 || ntohs(so
->so_lport
) < 512 ||
685 (m
->m_len
+ so_rcv
->sb_wptr
) > (so_rcv
->sb_data
+ so_rcv
->sb_datalen
)) {
686 memcpy(so_snd
->sb_wptr
, "Permission denied\n", 18);
687 so_snd
->sb_wptr
+= 18;
689 tcp_sockclosed(sototcpcb(so
));
694 /* Append the current data */
695 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
696 so_rcv
->sb_wptr
+= m
->m_len
;
697 so_rcv
->sb_rptr
+= m
->m_len
;
701 * Check if we have all the initial options,
702 * and build argument list to rlogin while we're here
705 ptr
= so_rcv
->sb_data
;
708 while (ptr
< so_rcv
->sb_wptr
) {
712 sprintf(args
, "rlogin -l %s %s",
713 ptr
, inet_ntoa(so
->so_faddr
));
715 i2
= so_rcv
->sb_wptr
- ptr
;
716 for (i
= 0; i
< i2
; i
++) {
720 sprintf(term
, "%s", ptr
);
722 sprintf(term
, "TERM=%s", ptr
);
735 /* We have it, set our term variable and fork_exec() */
737 setenv("TERM", term
, 1);
741 fork_exec(so
, args
, 2);
745 /* And finally, send the client a 0 character */
746 so_snd
->sb_wptr
[0] = 0;
756 * First we accumulate all the initial option negotiation,
757 * then rsh_exec() rsh according to the options
764 struct sbuf
*so_snd
= &so
->so_snd
;
765 struct sbuf
*so_rcv
= &so
->so_rcv
;
767 /* First check if they have a priveladged port, or too much data has arrived */
768 if (ntohs(so
->so_lport
) > 1023 || ntohs(so
->so_lport
) < 512 ||
769 (m
->m_len
+ so_rcv
->sb_wptr
) > (so_rcv
->sb_data
+ so_rcv
->sb_datalen
)) {
770 memcpy(so_snd
->sb_wptr
, "Permission denied\n", 18);
771 so_snd
->sb_wptr
+= 18;
773 tcp_sockclosed(sototcpcb(so
));
778 /* Append the current data */
779 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
780 so_rcv
->sb_wptr
+= m
->m_len
;
781 so_rcv
->sb_rptr
+= m
->m_len
;
785 * Check if we have all the initial options,
786 * and build argument list to rlogin while we're here
789 ptr
= so_rcv
->sb_data
;
792 if (so
->extra
==NULL
) {
796 if (port
<= 0) return 0;
797 if (port
> 1023 || port
< 512) {
798 memcpy(so_snd
->sb_wptr
, "Permission denied\n", 18);
799 so_snd
->sb_wptr
+= 18;
801 tcp_sockclosed(sototcpcb(so
));
804 if ((ns
=socreate()) == NULL
)
806 if (tcp_attach(ns
)<0) {
811 ns
->so_laddr
=so
->so_laddr
;
812 ns
->so_lport
=htons(port
);
814 (void) tcp_mss(sototcpcb(ns
), 0);
816 ns
->so_faddr
=so
->so_faddr
;
817 ns
->so_fport
=htons(IPPORT_RESERVED
-1); /* Use a fake port. */
819 if (ns
->so_faddr
.s_addr
== 0 ||
820 ns
->so_faddr
.s_addr
== loopback_addr
.s_addr
)
821 ns
->so_faddr
= alias_addr
;
823 ns
->so_iptos
= tcp_tos(ns
);
828 /* Compute window scaling to request. */
829 /* while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
830 * (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
831 * tp->request_r_scale++;
834 /*soisfconnecting(ns);*/
836 STAT(tcpstat
.tcps_connattempt
++);
838 tp
->t_state
= TCPS_SYN_SENT
;
839 tp
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
;
841 tcp_iss
+= TCP_ISSINCR
/2;
846 while (ptr
< so_rcv
->sb_wptr
) {
860 rsh_exec(so
,so
->extra
, user
, inet_ntoa(so
->so_faddr
), args
);
864 /* And finally, send the client a 0 character */
865 so_snd
->sb_wptr
[0] = 0;
875 struct sbuf
*so_snd
= &so
->so_snd
;
876 struct sbuf
*so_rcv
= &so
->so_rcv
;
879 * If there is binary data here, we save it in so->so_m
884 rxdata
=mtod(m
, char *);
885 for (rxlen
=m
->m_len
; rxlen
; rxlen
--) {
886 if (*rxdata
++ & 0x80) {
891 } /* if(so->so_m==NULL) */
896 sbappendsb(so_rcv
, m
);
898 /* To avoid going over the edge of the buffer, we reset it */
899 if (so_snd
->sb_cc
== 0)
900 so_snd
->sb_wptr
= so_snd
->sb_rptr
= so_snd
->sb_data
;
904 * If the first packet we get here is 1 byte long, then it
905 * was done in telnet character mode, therefore we must echo
906 * the characters as they come. Otherwise, we echo nothing,
907 * because in linemode, the line is already echoed
908 * XXX two or more control connections won't work
911 if (m
->m_len
== 1) do_echo
= 1;
915 sbappendsb(so_snd
, m
);
917 tcp_output(sototcpcb(so
)); /* XXX */
922 while (num
< so
->so_rcv
.sb_cc
) {
923 if (*(so
->so_rcv
.sb_rptr
+ num
) == '\n' ||
924 *(so
->so_rcv
.sb_rptr
+ num
) == '\r') {
927 *(so_rcv
->sb_rptr
+ num
) = 0;
928 if (ctl_password
&& !ctl_password_ok
) {
929 /* Need a password */
930 if (sscanf(so_rcv
->sb_rptr
, "pass %256s", buff
) == 1) {
931 if (strcmp(buff
, ctl_password
) == 0) {
933 n
= sprintf(so_snd
->sb_wptr
,
938 n
= sprintf(so_snd
->sb_wptr
,
939 "Error: Password required, log on with \"pass PASSWORD\"\r\n");
943 n
= do_config(so_rcv
->sb_rptr
, so
, PRN_SPRINTF
);
945 /* Register the printed data */
948 so_snd
->sb_wptr
+= n
;
950 n
= sprintf(so_snd
->sb_wptr
, "Slirp> ");
952 so_snd
->sb_wptr
+= n
;
954 /* Drop so_rcv data */
956 so_rcv
->sb_wptr
= so_rcv
->sb_rptr
= so_rcv
->sb_data
;
957 tcp_output(sototcpcb(so
)); /* Send the reply */
964 case EMU_FTP
: /* ftp */
965 *(m
->m_data
+m
->m_len
) = 0; /* NUL terminate for strstr */
966 if ((bptr
= (char *)strstr(m
->m_data
, "ORT")) != NULL
) {
968 * Need to emulate the PORT command
970 x
= sscanf(bptr
, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
971 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
975 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
976 lport
= htons((n5
<< 8) | (n6
));
978 if ((so
= solisten(0, laddr
, lport
, SS_FACCEPTONCE
)) == NULL
)
981 n6
= ntohs(so
->so_fport
);
983 n5
= (n6
>> 8) & 0xff;
986 laddr
= ntohl(so
->so_faddr
.s_addr
);
988 n1
= ((laddr
>> 24) & 0xff);
989 n2
= ((laddr
>> 16) & 0xff);
990 n3
= ((laddr
>> 8) & 0xff);
993 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
994 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
- m
->m_len
,
995 "ORT %d,%d,%d,%d,%d,%d\r\n%s",
996 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
998 } else if ((bptr
= (char *)strstr(m
->m_data
, "27 Entering")) != NULL
) {
1000 * Need to emulate the PASV response
1002 x
= sscanf(bptr
, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
1003 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
1007 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
1008 lport
= htons((n5
<< 8) | (n6
));
1010 if ((so
= solisten(0, laddr
, lport
, SS_FACCEPTONCE
)) == NULL
)
1013 n6
= ntohs(so
->so_fport
);
1015 n5
= (n6
>> 8) & 0xff;
1018 laddr
= ntohl(so
->so_faddr
.s_addr
);
1020 n1
= ((laddr
>> 24) & 0xff);
1021 n2
= ((laddr
>> 16) & 0xff);
1022 n3
= ((laddr
>> 8) & 0xff);
1023 n4
= (laddr
& 0xff);
1025 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1026 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
- m
->m_len
,
1027 "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
1028 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
1037 * The kshell (Kerberos rsh) and shell services both pass
1038 * a local port port number to carry signals to the server
1039 * and stderr to the client. It is passed at the beginning
1040 * of the connection as a NUL-terminated decimal ASCII string.
1043 for (lport
= 0, i
= 0; i
< m
->m_len
-1; ++i
) {
1044 if (m
->m_data
[i
] < '0' || m
->m_data
[i
] > '9')
1045 return 1; /* invalid number */
1047 lport
+= m
->m_data
[i
] - '0';
1049 if (m
->m_data
[m
->m_len
-1] == '\0' && lport
!= 0 &&
1050 (so
= solisten(0, so
->so_laddr
.s_addr
, htons(lport
), SS_FACCEPTONCE
)) != NULL
)
1051 m
->m_len
= snprintf(m
->m_data
, m
->m_hdr
.mh_size
, "%d",
1052 ntohs(so
->so_fport
)) + 1;
1057 * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
1059 *(m
->m_data
+m
->m_len
) = 0; /* NULL terminate the string for strstr */
1060 if ((bptr
= (char *)strstr(m
->m_data
, "DCC")) == NULL
)
1063 /* The %256s is for the broken mIRC */
1064 if (sscanf(bptr
, "DCC CHAT %256s %u %u", buff
, &laddr
, &lport
) == 3) {
1065 if ((so
= solisten(0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
1068 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1069 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
1070 "DCC CHAT chat %lu %u%c\n",
1071 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
1072 ntohs(so
->so_fport
), 1);
1073 } else if (sscanf(bptr
, "DCC SEND %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
1074 if ((so
= solisten(0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
1077 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1078 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
1079 "DCC SEND %s %lu %u %u%c\n", buff
,
1080 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
1081 ntohs(so
->so_fport
), n1
, 1);
1082 } else if (sscanf(bptr
, "DCC MOVE %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
1083 if ((so
= solisten(0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
1086 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
1087 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
1088 "DCC MOVE %s %lu %u %u%c\n", buff
,
1089 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
1090 ntohs(so
->so_fport
), n1
, 1);
1096 * RealAudio emulation - JP. We must try to parse the incoming
1097 * data and try to find the two characters that contain the
1098 * port number. Then we redirect an udp port and replace the
1099 * number with the real port we got.
1101 * The 1.0 beta versions of the player are not supported
1104 * A typical packet for player version 1.0 (release version):
1106 * 0000:50 4E 41 00 05
1107 * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 .....×..gælÜc..P
1108 * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
1109 * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
1110 * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
1112 * Now the port number 0x1BD7 is found at offset 0x04 of the
1113 * Now the port number 0x1BD7 is found at offset 0x04 of the
1114 * second packet. This time we received five bytes first and
1115 * then the rest. You never know how many bytes you get.
1117 * A typical packet for player version 2.0 (beta):
1119 * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA...........Á.
1120 * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .guxõc..Win2.0.0
1121 * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
1122 * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
1123 * 0040:65 2E 72 61 79 53 00 00 06 36 42 e.rayS...6B
1125 * Port number 0x1BC1 is found at offset 0x0d.
1127 * This is just a horrible switch statement. Variable ra tells
1128 * us where we're going.
1132 while (bptr
< m
->m_data
+ m
->m_len
) {
1146 if (*bptr
++ != ra_tbl
[ra
]) {
1154 * We may get 0x50 several times, ignore them
1156 if (*bptr
== 0x50) {
1160 } else if (*bptr
++ != ra_tbl
[ra
]) {
1168 * skip version number
1175 * The difference between versions 1.0 and
1176 * 2.0 is here. For future versions of
1177 * the player this may need to be modified.
1179 if (*(bptr
+ 1) == 0x02)
1186 /* This is the field containing the port
1187 * number that RA-player is listening to.
1189 lport
= (((u_char
*)bptr
)[0] << 8)
1190 + ((u_char
*)bptr
)[1];
1192 lport
+= 256; /* don't know why */
1193 if (lport
< 6970 || lport
> 7170)
1194 return 1; /* failed */
1196 /* try to get udp port between 6970 - 7170 */
1197 for (p
= 6970; p
< 7071; p
++) {
1198 if (udp_listen( htons(p
),
1199 so
->so_laddr
.s_addr
,
1207 *(u_char
*)bptr
++ = (p
>> 8) & 0xff;
1208 *(u_char
*)bptr
++ = p
& 0xff;
1210 return 1; /* port redirected, we're done */
1221 /* Ooops, not emulated, won't call tcp_emu again */
1228 * Do misc. config of SLiRP while its running.
1229 * Return 0 if this connections is to be closed, 1 otherwise,
1230 * return 2 if this is a command-line connection
1233 tcp_ctl(struct socket
*so
)
1235 struct sbuf
*sb
= &so
->so_snd
;
1237 struct ex_list
*ex_ptr
;
1239 // struct socket *tmpso;
1241 DEBUG_CALL("tcp_ctl");
1242 DEBUG_ARG("so = %lx", (long )so
);
1246 * Check if they're authorised
1248 if (ctl_addr
.s_addr
&& (ctl_addr
.s_addr
== -1 || (so
->so_laddr
.s_addr
!= ctl_addr
.s_addr
))) {
1249 sb
->sb_cc
= sprintf(sb
->sb_wptr
,"Error: Permission denied.\r\n");
1250 sb
->sb_wptr
+= sb
->sb_cc
;
1254 command
= (ntohl(so
->so_faddr
.s_addr
) & 0xff);
1257 default: /* Check for exec's */
1260 * Check if it's pty_exec
1262 for (ex_ptr
= exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
1263 if (ex_ptr
->ex_fport
== so
->so_fport
&&
1264 command
== ex_ptr
->ex_addr
) {
1265 if (ex_ptr
->ex_pty
== 3) {
1267 so
->extra
= (void *)ex_ptr
->ex_exec
;
1270 do_pty
= ex_ptr
->ex_pty
;
1278 /* tcp_fconnect(so); */
1282 sb
->sb_cc
= snprintf(sb
->sb_wptr
, sb
->sb_datalen
- (sb
->sb_wptr
- sb
->sb_data
),
1283 "Error: No application configured.\r\n");
1284 sb
->sb_wptr
+= sb
->sb_cc
;
1288 DEBUG_MISC((dfd
, " executing %s \n",ex_ptr
->ex_exec
));
1289 return(fork_exec(so
, ex_ptr
->ex_exec
, do_pty
));
1293 for (tmpso
= tcb
.so_next
; tmpso
!= &tcb
; tmpso
= tmpso
->so_next
) {
1294 if (tmpso
->so_emu
== EMU_CTL
&&
1296 (tmpso
->so_tcpcb
->t_state
& (TCPS_TIME_WAIT
|TCPS_LAST_ACK
))
1298 /* Ooops, control connection already active */
1299 sb
->sb_cc
= sprintf(sb
->sb_wptr
,"Sorry, already connected.\r\n");
1300 sb
->sb_wptr
+= sb
->sb_cc
;
1304 so
->so_emu
= EMU_CTL
;
1305 ctl_password_ok
= 0;
1306 sb
->sb_cc
= sprintf(sb
->sb_wptr
, "Slirp command-line ready (type \"help\" for help).\r\nSlirp> ");
1307 sb
->sb_wptr
+= sb
->sb_cc
;