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.
64 tcp_template(struct tcpcb
*tp
)
66 struct socket
*so
= tp
->t_socket
;
67 register struct tcpiphdr
*n
= &tp
->t_template
;
71 n
->ti_pr
= IPPROTO_TCP
;
72 n
->ti_len
= htons(sizeof (struct tcpiphdr
) - sizeof (struct ip
));
73 n
->ti_src
= so
->so_faddr
;
74 n
->ti_dst
= so
->so_laddr
;
75 n
->ti_sport
= so
->so_fport
;
76 n
->ti_dport
= so
->so_lport
;
89 * Send a single message to the TCP at address specified by
90 * the given TCP/IP header. If m == 0, then we make a copy
91 * of the tcpiphdr at ti and send directly to the addressed host.
92 * This is used to force keep alive messages out using the TCP
93 * template for a connection tp->t_template. If flags are given
94 * then we send a message back to the TCP which originated the
95 * segment ti, and discard the mbuf containing it and any other
98 * In any case the ack and sequence number of the transmitted
99 * segment are as specified by the parameters.
102 tcp_respond(struct tcpcb
*tp
, struct tcpiphdr
*ti
, struct mbuf
*m
,
103 tcp_seq ack
, tcp_seq seq
, int flags
)
108 DEBUG_CALL("tcp_respond");
109 DEBUG_ARG("tp = %lx", (long)tp
);
110 DEBUG_ARG("ti = %lx", (long)ti
);
111 DEBUG_ARG("m = %lx", (long)m
);
112 DEBUG_ARG("ack = %u", ack
);
113 DEBUG_ARG("seq = %u", seq
);
114 DEBUG_ARG("flags = %x", flags
);
117 win
= sbspace(&tp
->t_socket
->so_rcv
);
119 if ((m
= m_get()) == NULL
)
122 m
->m_data
+= IF_MAXLINKHDR
;
123 *mtod(m
, struct tcpiphdr
*) = *ti
;
124 ti
= mtod(m
, struct tcpiphdr
*);
128 * ti points into m so the next line is just making
129 * the mbuf point to ti
131 m
->m_data
= (caddr_t
)ti
;
133 m
->m_len
= sizeof (struct tcpiphdr
);
135 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
136 xchg(ti
->ti_dst
.s_addr
, ti
->ti_src
.s_addr
, u_int32_t
);
137 xchg(ti
->ti_dport
, ti
->ti_sport
, u_int16_t
);
140 ti
->ti_len
= htons((u_short
)(sizeof (struct tcphdr
) + tlen
));
141 tlen
+= sizeof (struct tcpiphdr
);
146 ti
->ti_seq
= htonl(seq
);
147 ti
->ti_ack
= htonl(ack
);
149 ti
->ti_off
= sizeof (struct tcphdr
) >> 2;
150 ti
->ti_flags
= flags
;
152 ti
->ti_win
= htons((u_int16_t
) (win
>> tp
->rcv_scale
));
154 ti
->ti_win
= htons((u_int16_t
)win
);
157 ti
->ti_sum
= cksum(m
, tlen
);
158 ((struct ip
*)ti
)->ip_len
= tlen
;
161 ((struct ip
*)ti
)->ip_ttl
= MAXTTL
;
163 ((struct ip
*)ti
)->ip_ttl
= IPDEFTTL
;
165 (void) ip_output((struct socket
*)0, m
);
169 * Create a new TCP control block, making an
170 * empty reassembly queue and hooking it to the argument
171 * protocol control block.
174 tcp_newtcpcb(struct socket
*so
)
176 register struct tcpcb
*tp
;
178 tp
= (struct tcpcb
*)malloc(sizeof(*tp
));
180 return ((struct tcpcb
*)0);
182 memset((char *) tp
, 0, sizeof(struct tcpcb
));
183 tp
->seg_next
= tp
->seg_prev
= (struct tcpiphdr
*)tp
;
184 tp
->t_maxseg
= TCP_MSS
;
186 tp
->t_flags
= TCP_DO_RFC1323
? (TF_REQ_SCALE
|TF_REQ_TSTMP
) : 0;
190 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
191 * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
192 * reasonable initial retransmit time.
194 tp
->t_srtt
= TCPTV_SRTTBASE
;
195 tp
->t_rttvar
= TCPTV_SRTTDFLT
<< 2;
196 tp
->t_rttmin
= TCPTV_MIN
;
198 TCPT_RANGESET(tp
->t_rxtcur
,
199 ((TCPTV_SRTTBASE
>> 2) + (TCPTV_SRTTDFLT
<< 2)) >> 1,
200 TCPTV_MIN
, TCPTV_REXMTMAX
);
202 tp
->snd_cwnd
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
203 tp
->snd_ssthresh
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
204 tp
->t_state
= TCPS_CLOSED
;
212 * Drop a TCP connection, reporting
213 * the specified error. If connection is synchronized,
214 * then send a RST to peer.
216 struct tcpcb
*tcp_drop(struct tcpcb
*tp
, int err
)
218 DEBUG_CALL("tcp_drop");
219 DEBUG_ARG("tp = %lx", (long)tp
);
220 DEBUG_ARG("errno = %d", errno
);
222 if (TCPS_HAVERCVDSYN(tp
->t_state
)) {
223 tp
->t_state
= TCPS_CLOSED
;
224 (void) tcp_output(tp
);
226 return (tcp_close(tp
));
230 * Close a TCP control block:
231 * discard all space held by the tcp
232 * discard internet protocol block
233 * wake up any sleepers
236 tcp_close(struct tcpcb
*tp
)
238 register struct tcpiphdr
*t
;
239 struct socket
*so
= tp
->t_socket
;
240 register struct mbuf
*m
;
242 DEBUG_CALL("tcp_close");
243 DEBUG_ARG("tp = %lx", (long )tp
);
245 /* free the reassembly queue, if any */
246 t
= tcpfrag_list_first(tp
);
247 while (!tcpfrag_list_end(t
, tp
)) {
248 t
= tcpiphdr_next(t
);
249 m
= tcpiphdr_prev(t
)->ti_mbuf
;
250 remque(tcpiphdr2qlink(tcpiphdr_prev(t
)));
255 /* clobber input socket cache if we're closing the cached connection */
256 if (so
== tcp_last_so
)
262 return ((struct tcpcb
*)0);
266 * TCP protocol interface to socket abstraction.
270 * User issued close, and wish to trail through shutdown states:
271 * if never received SYN, just forget it. If got a SYN from peer,
272 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
273 * If already got a FIN from peer, then almost done; go to LAST_ACK
274 * state. In all other cases, have already sent FIN to peer (e.g.
275 * after PRU_SHUTDOWN), and just have to play tedious game waiting
276 * for peer to send FIN or not respond to keep-alives, etc.
277 * We can let the user exit from the close as soon as the FIN is acked.
280 tcp_sockclosed(struct tcpcb
*tp
)
283 DEBUG_CALL("tcp_sockclosed");
284 DEBUG_ARG("tp = %lx", (long)tp
);
286 switch (tp
->t_state
) {
291 tp
->t_state
= TCPS_CLOSED
;
295 case TCPS_SYN_RECEIVED
:
296 case TCPS_ESTABLISHED
:
297 tp
->t_state
= TCPS_FIN_WAIT_1
;
300 case TCPS_CLOSE_WAIT
:
301 tp
->t_state
= TCPS_LAST_ACK
;
309 * Connect to a host on the Internet
310 * Called by tcp_input
311 * Only do a connect, the tcp fields will be set in tcp_input
312 * return 0 if there's a result of the connect,
313 * else return -1 means we're still connecting
314 * The return value is almost always -1 since the socket is
315 * nonblocking. Connect returns after the SYN is sent, and does
316 * not wait for ACK+SYN.
318 int tcp_fconnect(struct socket
*so
)
322 DEBUG_CALL("tcp_fconnect");
323 DEBUG_ARG("so = %lx", (long )so
);
325 if( (ret
=so
->s
=socket(AF_INET
,SOCK_STREAM
,0)) >= 0) {
327 struct sockaddr_in addr
;
331 setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(opt
));
333 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(opt
));
335 addr
.sin_family
= AF_INET
;
336 if ((so
->so_faddr
.s_addr
& vnetwork_mask
.s_addr
) == vnetwork_addr
.s_addr
) {
338 if (so
->so_faddr
.s_addr
== vnameserver_addr
.s_addr
) {
339 addr
.sin_addr
= dns_addr
;
341 addr
.sin_addr
= loopback_addr
;
344 addr
.sin_addr
= so
->so_faddr
;
345 addr
.sin_port
= so
->so_fport
;
347 DEBUG_MISC((dfd
, " connect()ing, addr.sin_port=%d, "
348 "addr.sin_addr.s_addr=%.16s\n",
349 ntohs(addr
.sin_port
), inet_ntoa(addr
.sin_addr
)));
350 /* We don't care what port we get */
351 ret
= connect(s
,(struct sockaddr
*)&addr
,sizeof (addr
));
354 * If it's not in progress, it failed, so we just return 0,
355 * without clearing SS_NOFDREF
364 * Accept the socket and connect to the local-host
366 * We have a problem. The correct thing to do would be
367 * to first connect to the local-host, and only if the
368 * connection is accepted, then do an accept() here.
369 * But, a) we need to know who's trying to connect
370 * to the socket to be able to SYN the local-host, and
371 * b) we are already connected to the foreign host by
372 * the time it gets to accept(), so... We simply accept
373 * here and SYN the local-host.
376 tcp_connect(struct socket
*inso
)
379 struct sockaddr_in addr
;
380 socklen_t addrlen
= sizeof(struct sockaddr_in
);
384 DEBUG_CALL("tcp_connect");
385 DEBUG_ARG("inso = %lx", (long)inso
);
388 * If it's an SS_ACCEPTONCE socket, no need to socreate()
389 * another socket, just use the accept() socket.
391 if (inso
->so_state
& SS_FACCEPTONCE
) {
392 /* FACCEPTONCE already have a tcpcb */
395 if ((so
= socreate()) == NULL
) {
396 /* If it failed, get rid of the pending connection */
397 closesocket(accept(inso
->s
,(struct sockaddr
*)&addr
,&addrlen
));
400 if (tcp_attach(so
) < 0) {
401 free(so
); /* NOT sofree */
404 so
->so_laddr
= inso
->so_laddr
;
405 so
->so_lport
= inso
->so_lport
;
408 (void) tcp_mss(sototcpcb(so
), 0);
410 if ((s
= accept(inso
->s
,(struct sockaddr
*)&addr
,&addrlen
)) < 0) {
411 tcp_close(sototcpcb(so
)); /* This will sofree() as well */
416 setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(int));
418 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(int));
420 setsockopt(s
,IPPROTO_TCP
,TCP_NODELAY
,(char *)&opt
,sizeof(int));
422 so
->so_fport
= addr
.sin_port
;
423 so
->so_faddr
= addr
.sin_addr
;
424 /* Translate connections from localhost to the real hostname */
425 if (so
->so_faddr
.s_addr
== 0 || so
->so_faddr
.s_addr
== loopback_addr
.s_addr
)
426 so
->so_faddr
= vhost_addr
;
428 /* Close the accept() socket, set right state */
429 if (inso
->so_state
& SS_FACCEPTONCE
) {
430 closesocket(so
->s
); /* If we only accept once, close the accept() socket */
431 so
->so_state
= SS_NOFDREF
; /* Don't select it yet, even though we have an FD */
432 /* if it's not FACCEPTONCE, it's already NOFDREF */
435 so
->so_state
|= SS_INCOMING
;
437 so
->so_iptos
= tcp_tos(so
);
442 tp
->t_state
= TCPS_SYN_SENT
;
443 tp
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
;
445 tcp_iss
+= TCP_ISSINCR
/2;
451 * Attach a TCPCB to a socket.
454 tcp_attach(struct socket
*so
)
456 if ((so
->so_tcpcb
= tcp_newtcpcb(so
)) == NULL
)
465 * Set the socket's type of service field
467 static const struct tos_t tcptos
[] = {
468 {0, 20, IPTOS_THROUGHPUT
, 0}, /* ftp data */
469 {21, 21, IPTOS_LOWDELAY
, EMU_FTP
}, /* ftp control */
470 {0, 23, IPTOS_LOWDELAY
, 0}, /* telnet */
471 {0, 80, IPTOS_THROUGHPUT
, 0}, /* WWW */
472 {0, 513, IPTOS_LOWDELAY
, EMU_RLOGIN
|EMU_NOCONNECT
}, /* rlogin */
473 {0, 514, IPTOS_LOWDELAY
, EMU_RSH
|EMU_NOCONNECT
}, /* shell */
474 {0, 544, IPTOS_LOWDELAY
, EMU_KSH
}, /* kshell */
475 {0, 543, IPTOS_LOWDELAY
, 0}, /* klogin */
476 {0, 6667, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC */
477 {0, 6668, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC undernet */
478 {0, 7070, IPTOS_LOWDELAY
, EMU_REALAUDIO
}, /* RealAudio control */
479 {0, 113, IPTOS_LOWDELAY
, EMU_IDENT
}, /* identd protocol */
483 static struct emu_t
*tcpemu
= NULL
;
486 * Return TOS according to the above table
489 tcp_tos(struct socket
*so
)
494 while(tcptos
[i
].tos
) {
495 if ((tcptos
[i
].fport
&& (ntohs(so
->so_fport
) == tcptos
[i
].fport
)) ||
496 (tcptos
[i
].lport
&& (ntohs(so
->so_lport
) == tcptos
[i
].lport
))) {
497 so
->so_emu
= tcptos
[i
].emu
;
498 return tcptos
[i
].tos
;
503 /* Nope, lets see if there's a user-added one */
504 for (emup
= tcpemu
; emup
; emup
= emup
->next
) {
505 if ((emup
->fport
&& (ntohs(so
->so_fport
) == emup
->fport
)) ||
506 (emup
->lport
&& (ntohs(so
->so_lport
) == emup
->lport
))) {
507 so
->so_emu
= emup
->emu
;
516 * Emulate programs that try and connect to us
517 * This includes ftp (the data connection is
518 * initiated by the server) and IRC (DCC CHAT and
521 * NOTE: It's possible to crash SLiRP by sending it
522 * unstandard strings to emulate... if this is a problem,
523 * more checks are needed here
525 * XXX Assumes the whole command came in one packet
527 * XXX Some ftp clients will have their TOS set to
528 * LOWDELAY and so Nagel will kick in. Because of this,
529 * we'll get the first letter, followed by the rest, so
530 * we simply scan for ORT instead of PORT...
531 * DCC doesn't have this problem because there's other stuff
532 * in the packet before the DCC command.
534 * Return 1 if the mbuf m is still valid and should be
537 * NOTE: if you return 0 you MUST m_free() the mbuf!
540 tcp_emu(struct socket
*so
, struct mbuf
*m
)
542 u_int n1
, n2
, n3
, n4
, n5
, n6
;
548 DEBUG_CALL("tcp_emu");
549 DEBUG_ARG("so = %lx", (long)so
);
550 DEBUG_ARG("m = %lx", (long)m
);
557 * Identification protocol as per rfc-1413
561 struct socket
*tmpso
;
562 struct sockaddr_in addr
;
563 socklen_t addrlen
= sizeof(struct sockaddr_in
);
564 struct sbuf
*so_rcv
= &so
->so_rcv
;
566 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
567 so_rcv
->sb_wptr
+= m
->m_len
;
568 so_rcv
->sb_rptr
+= m
->m_len
;
569 m
->m_data
[m
->m_len
] = 0; /* NULL terminate */
570 if (strchr(m
->m_data
, '\r') || strchr(m
->m_data
, '\n')) {
571 if (sscanf(so_rcv
->sb_data
, "%u%*[ ,]%u", &n1
, &n2
) == 2) {
574 /* n2 is the one on our host */
575 for (tmpso
= tcb
.so_next
; tmpso
!= &tcb
; tmpso
= tmpso
->so_next
) {
576 if (tmpso
->so_laddr
.s_addr
== so
->so_laddr
.s_addr
&&
577 tmpso
->so_lport
== n2
&&
578 tmpso
->so_faddr
.s_addr
== so
->so_faddr
.s_addr
&&
579 tmpso
->so_fport
== n1
) {
580 if (getsockname(tmpso
->s
,
581 (struct sockaddr
*)&addr
, &addrlen
) == 0)
582 n2
= ntohs(addr
.sin_port
);
587 so_rcv
->sb_cc
= snprintf(so_rcv
->sb_data
,
589 "%d,%d\r\n", n1
, n2
);
590 so_rcv
->sb_rptr
= so_rcv
->sb_data
;
591 so_rcv
->sb_wptr
= so_rcv
->sb_data
+ so_rcv
->sb_cc
;
597 case EMU_FTP
: /* ftp */
598 *(m
->m_data
+m
->m_len
) = 0; /* NUL terminate for strstr */
599 if ((bptr
= (char *)strstr(m
->m_data
, "ORT")) != NULL
) {
601 * Need to emulate the PORT command
603 x
= sscanf(bptr
, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
604 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
608 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
609 lport
= htons((n5
<< 8) | (n6
));
611 if ((so
= tcp_listen(INADDR_ANY
, 0, laddr
, lport
, SS_FACCEPTONCE
)) == NULL
)
614 n6
= ntohs(so
->so_fport
);
616 n5
= (n6
>> 8) & 0xff;
619 laddr
= ntohl(so
->so_faddr
.s_addr
);
621 n1
= ((laddr
>> 24) & 0xff);
622 n2
= ((laddr
>> 16) & 0xff);
623 n3
= ((laddr
>> 8) & 0xff);
626 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
627 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
- m
->m_len
,
628 "ORT %d,%d,%d,%d,%d,%d\r\n%s",
629 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
631 } else if ((bptr
= (char *)strstr(m
->m_data
, "27 Entering")) != NULL
) {
633 * Need to emulate the PASV response
635 x
= sscanf(bptr
, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
636 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
640 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
641 lport
= htons((n5
<< 8) | (n6
));
643 if ((so
= tcp_listen(INADDR_ANY
, 0, laddr
, lport
, SS_FACCEPTONCE
)) == NULL
)
646 n6
= ntohs(so
->so_fport
);
648 n5
= (n6
>> 8) & 0xff;
651 laddr
= ntohl(so
->so_faddr
.s_addr
);
653 n1
= ((laddr
>> 24) & 0xff);
654 n2
= ((laddr
>> 16) & 0xff);
655 n3
= ((laddr
>> 8) & 0xff);
658 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
659 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
- m
->m_len
,
660 "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
661 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
670 * The kshell (Kerberos rsh) and shell services both pass
671 * a local port port number to carry signals to the server
672 * and stderr to the client. It is passed at the beginning
673 * of the connection as a NUL-terminated decimal ASCII string.
676 for (lport
= 0, i
= 0; i
< m
->m_len
-1; ++i
) {
677 if (m
->m_data
[i
] < '0' || m
->m_data
[i
] > '9')
678 return 1; /* invalid number */
680 lport
+= m
->m_data
[i
] - '0';
682 if (m
->m_data
[m
->m_len
-1] == '\0' && lport
!= 0 &&
683 (so
= tcp_listen(INADDR_ANY
, 0, so
->so_laddr
.s_addr
, htons(lport
), SS_FACCEPTONCE
)) != NULL
)
684 m
->m_len
= snprintf(m
->m_data
, m
->m_hdr
.mh_size
, "%d",
685 ntohs(so
->so_fport
)) + 1;
690 * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
692 *(m
->m_data
+m
->m_len
) = 0; /* NULL terminate the string for strstr */
693 if ((bptr
= (char *)strstr(m
->m_data
, "DCC")) == NULL
)
696 /* The %256s is for the broken mIRC */
697 if (sscanf(bptr
, "DCC CHAT %256s %u %u", buff
, &laddr
, &lport
) == 3) {
698 if ((so
= tcp_listen(INADDR_ANY
, 0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
701 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
702 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
703 "DCC CHAT chat %lu %u%c\n",
704 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
705 ntohs(so
->so_fport
), 1);
706 } else if (sscanf(bptr
, "DCC SEND %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
707 if ((so
= tcp_listen(INADDR_ANY
, 0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
710 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
711 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
712 "DCC SEND %s %lu %u %u%c\n", buff
,
713 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
714 ntohs(so
->so_fport
), n1
, 1);
715 } else if (sscanf(bptr
, "DCC MOVE %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
716 if ((so
= tcp_listen(INADDR_ANY
, 0, htonl(laddr
), htons(lport
), SS_FACCEPTONCE
)) == NULL
)
719 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
720 m
->m_len
+= snprintf(bptr
, m
->m_hdr
.mh_size
,
721 "DCC MOVE %s %lu %u %u%c\n", buff
,
722 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
723 ntohs(so
->so_fport
), n1
, 1);
729 * RealAudio emulation - JP. We must try to parse the incoming
730 * data and try to find the two characters that contain the
731 * port number. Then we redirect an udp port and replace the
732 * number with the real port we got.
734 * The 1.0 beta versions of the player are not supported
737 * A typical packet for player version 1.0 (release version):
739 * 0000:50 4E 41 00 05
740 * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 ........g.l.c..P
741 * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
742 * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
743 * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
745 * Now the port number 0x1BD7 is found at offset 0x04 of the
746 * Now the port number 0x1BD7 is found at offset 0x04 of the
747 * second packet. This time we received five bytes first and
748 * then the rest. You never know how many bytes you get.
750 * A typical packet for player version 2.0 (beta):
752 * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA.............
753 * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .gux.c..Win2.0.0
754 * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
755 * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
756 * 0040:65 2E 72 61 79 53 00 00 06 36 42 e.rayS...6B
758 * Port number 0x1BC1 is found at offset 0x0d.
760 * This is just a horrible switch statement. Variable ra tells
761 * us where we're going.
765 while (bptr
< m
->m_data
+ m
->m_len
) {
779 if (*bptr
++ != ra_tbl
[ra
]) {
787 * We may get 0x50 several times, ignore them
793 } else if (*bptr
++ != ra_tbl
[ra
]) {
801 * skip version number
808 * The difference between versions 1.0 and
809 * 2.0 is here. For future versions of
810 * the player this may need to be modified.
812 if (*(bptr
+ 1) == 0x02)
819 /* This is the field containing the port
820 * number that RA-player is listening to.
822 lport
= (((u_char
*)bptr
)[0] << 8)
823 + ((u_char
*)bptr
)[1];
825 lport
+= 256; /* don't know why */
826 if (lport
< 6970 || lport
> 7170)
827 return 1; /* failed */
829 /* try to get udp port between 6970 - 7170 */
830 for (p
= 6970; p
< 7071; p
++) {
831 if (udp_listen(INADDR_ANY
,
841 *(u_char
*)bptr
++ = (p
>> 8) & 0xff;
842 *(u_char
*)bptr
++ = p
& 0xff;
844 return 1; /* port redirected, we're done */
855 /* Ooops, not emulated, won't call tcp_emu again */
862 * Do misc. config of SLiRP while its running.
863 * Return 0 if this connections is to be closed, 1 otherwise,
864 * return 2 if this is a command-line connection
866 int tcp_ctl(struct socket
*so
)
868 struct sbuf
*sb
= &so
->so_snd
;
869 struct ex_list
*ex_ptr
;
872 DEBUG_CALL("tcp_ctl");
873 DEBUG_ARG("so = %lx", (long )so
);
875 if (so
->so_faddr
.s_addr
!= vhost_addr
.s_addr
) {
876 /* Check if it's pty_exec */
877 for (ex_ptr
= exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
878 if (ex_ptr
->ex_fport
== so
->so_fport
&&
879 so
->so_faddr
.s_addr
== ex_ptr
->ex_addr
.s_addr
) {
880 if (ex_ptr
->ex_pty
== 3) {
882 so
->extra
= (void *)ex_ptr
->ex_exec
;
885 do_pty
= ex_ptr
->ex_pty
;
886 DEBUG_MISC((dfd
, " executing %s \n",ex_ptr
->ex_exec
));
887 return fork_exec(so
, ex_ptr
->ex_exec
, do_pty
);
892 snprintf(sb
->sb_wptr
, sb
->sb_datalen
- (sb
->sb_wptr
- sb
->sb_data
),
893 "Error: No application configured.\r\n");
894 sb
->sb_wptr
+= sb
->sb_cc
;