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 #include "qemu/osdep.h"
44 /* patchable/settable parameters for tcp */
45 /* Don't do rfc1323 performance enhancements */
46 #define TCP_DO_RFC1323 0
52 tcp_init(Slirp
*slirp
)
54 slirp
->tcp_iss
= 1; /* wrong */
55 slirp
->tcb
.so_next
= slirp
->tcb
.so_prev
= &slirp
->tcb
;
56 slirp
->tcp_last_so
= &slirp
->tcb
;
59 void tcp_cleanup(Slirp
*slirp
)
61 while (slirp
->tcb
.so_next
!= &slirp
->tcb
) {
62 tcp_close(sototcpcb(slirp
->tcb
.so_next
));
67 * Create template to be used to send tcp packets on a connection.
68 * Call after host entry created, fills
69 * in a skeletal tcp/ip header, minimizing the amount of work
70 * necessary when the connection is used.
73 tcp_template(struct tcpcb
*tp
)
75 struct socket
*so
= tp
->t_socket
;
76 register struct tcpiphdr
*n
= &tp
->t_template
;
79 memset(&n
->ti
, 0, sizeof(n
->ti
));
81 switch (so
->so_ffamily
) {
83 n
->ti_pr
= IPPROTO_TCP
;
84 n
->ti_len
= htons(sizeof(struct tcphdr
));
85 n
->ti_src
= so
->so_faddr
;
86 n
->ti_dst
= so
->so_laddr
;
87 n
->ti_sport
= so
->so_fport
;
88 n
->ti_dport
= so
->so_lport
;
92 g_assert_not_reached();
106 * Send a single message to the TCP at address specified by
107 * the given TCP/IP header. If m == 0, then we make a copy
108 * of the tcpiphdr at ti and send directly to the addressed host.
109 * This is used to force keep alive messages out using the TCP
110 * template for a connection tp->t_template. If flags are given
111 * then we send a message back to the TCP which originated the
112 * segment ti, and discard the mbuf containing it and any other
115 * In any case the ack and sequence number of the transmitted
116 * segment are as specified by the parameters.
119 tcp_respond(struct tcpcb
*tp
, struct tcpiphdr
*ti
, struct mbuf
*m
,
120 tcp_seq ack
, tcp_seq seq
, int flags
, unsigned short af
)
125 DEBUG_CALL("tcp_respond");
126 DEBUG_ARG("tp = %p", tp
);
127 DEBUG_ARG("ti = %p", ti
);
128 DEBUG_ARG("m = %p", m
);
129 DEBUG_ARG("ack = %u", ack
);
130 DEBUG_ARG("seq = %u", seq
);
131 DEBUG_ARG("flags = %x", flags
);
134 win
= sbspace(&tp
->t_socket
->so_rcv
);
136 if (!tp
|| (m
= m_get(tp
->t_socket
->slirp
)) == NULL
)
139 m
->m_data
+= IF_MAXLINKHDR
;
140 *mtod(m
, struct tcpiphdr
*) = *ti
;
141 ti
= mtod(m
, struct tcpiphdr
*);
142 memset(&ti
->ti
, 0, sizeof(ti
->ti
));
146 * ti points into m so the next line is just making
147 * the mbuf point to ti
149 m
->m_data
= (caddr_t
)ti
;
151 m
->m_len
= sizeof (struct tcpiphdr
);
153 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
156 xchg(ti
->ti_dst
.s_addr
, ti
->ti_src
.s_addr
, uint32_t);
157 xchg(ti
->ti_dport
, ti
->ti_sport
, uint16_t);
160 g_assert_not_reached();
164 ti
->ti_len
= htons((u_short
)(sizeof (struct tcphdr
) + tlen
));
165 tlen
+= sizeof (struct tcpiphdr
);
170 ti
->ti_seq
= htonl(seq
);
171 ti
->ti_ack
= htonl(ack
);
173 ti
->ti_off
= sizeof (struct tcphdr
) >> 2;
174 ti
->ti_flags
= flags
;
176 ti
->ti_win
= htons((uint16_t) (win
>> tp
->rcv_scale
));
178 ti
->ti_win
= htons((uint16_t)win
);
181 ti
->ti_sum
= cksum(m
, tlen
);
183 struct tcpiphdr tcpiph_save
= *(mtod(m
, struct tcpiphdr
*));
188 m
->m_data
+= sizeof(struct tcpiphdr
) - sizeof(struct tcphdr
)
190 m
->m_len
-= sizeof(struct tcpiphdr
) - sizeof(struct tcphdr
)
192 ip
= mtod(m
, struct ip
*);
194 ip
->ip_dst
= tcpiph_save
.ti_dst
;
195 ip
->ip_src
= tcpiph_save
.ti_src
;
196 ip
->ip_p
= tcpiph_save
.ti_pr
;
198 if (flags
& TH_RST
) {
201 ip
->ip_ttl
= IPDEFTTL
;
204 (void) ip_output((struct socket
*)0, m
);
208 g_assert_not_reached();
213 * Create a new TCP control block, making an
214 * empty reassembly queue and hooking it to the argument
215 * protocol control block.
218 tcp_newtcpcb(struct socket
*so
)
220 register struct tcpcb
*tp
;
222 tp
= (struct tcpcb
*)malloc(sizeof(*tp
));
224 return ((struct tcpcb
*)0);
226 memset((char *) tp
, 0, sizeof(struct tcpcb
));
227 tp
->seg_next
= tp
->seg_prev
= (struct tcpiphdr
*)tp
;
228 tp
->t_maxseg
= TCP_MSS
;
230 tp
->t_flags
= TCP_DO_RFC1323
? (TF_REQ_SCALE
|TF_REQ_TSTMP
) : 0;
234 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
235 * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
236 * reasonable initial retransmit time.
238 tp
->t_srtt
= TCPTV_SRTTBASE
;
239 tp
->t_rttvar
= TCPTV_SRTTDFLT
<< 2;
240 tp
->t_rttmin
= TCPTV_MIN
;
242 TCPT_RANGESET(tp
->t_rxtcur
,
243 ((TCPTV_SRTTBASE
>> 2) + (TCPTV_SRTTDFLT
<< 2)) >> 1,
244 TCPTV_MIN
, TCPTV_REXMTMAX
);
246 tp
->snd_cwnd
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
247 tp
->snd_ssthresh
= TCP_MAXWIN
<< TCP_MAX_WINSHIFT
;
248 tp
->t_state
= TCPS_CLOSED
;
256 * Drop a TCP connection, reporting
257 * the specified error. If connection is synchronized,
258 * then send a RST to peer.
260 struct tcpcb
*tcp_drop(struct tcpcb
*tp
, int err
)
262 DEBUG_CALL("tcp_drop");
263 DEBUG_ARG("tp = %p", tp
);
264 DEBUG_ARG("errno = %d", errno
);
266 if (TCPS_HAVERCVDSYN(tp
->t_state
)) {
267 tp
->t_state
= TCPS_CLOSED
;
268 (void) tcp_output(tp
);
270 return (tcp_close(tp
));
274 * Close a TCP control block:
275 * discard all space held by the tcp
276 * discard internet protocol block
277 * wake up any sleepers
280 tcp_close(struct tcpcb
*tp
)
282 register struct tcpiphdr
*t
;
283 struct socket
*so
= tp
->t_socket
;
284 Slirp
*slirp
= so
->slirp
;
285 register struct mbuf
*m
;
287 DEBUG_CALL("tcp_close");
288 DEBUG_ARG("tp = %p", tp
);
290 /* free the reassembly queue, if any */
291 t
= tcpfrag_list_first(tp
);
292 while (!tcpfrag_list_end(t
, tp
)) {
293 t
= tcpiphdr_next(t
);
294 m
= tcpiphdr_prev(t
)->ti_mbuf
;
295 remque(tcpiphdr2qlink(tcpiphdr_prev(t
)));
300 /* clobber input socket cache if we're closing the cached connection */
301 if (so
== slirp
->tcp_last_so
)
302 slirp
->tcp_last_so
= &slirp
->tcb
;
307 return ((struct tcpcb
*)0);
311 * TCP protocol interface to socket abstraction.
315 * User issued close, and wish to trail through shutdown states:
316 * if never received SYN, just forget it. If got a SYN from peer,
317 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
318 * If already got a FIN from peer, then almost done; go to LAST_ACK
319 * state. In all other cases, have already sent FIN to peer (e.g.
320 * after PRU_SHUTDOWN), and just have to play tedious game waiting
321 * for peer to send FIN or not respond to keep-alives, etc.
322 * We can let the user exit from the close as soon as the FIN is acked.
325 tcp_sockclosed(struct tcpcb
*tp
)
328 DEBUG_CALL("tcp_sockclosed");
329 DEBUG_ARG("tp = %p", tp
);
331 switch (tp
->t_state
) {
336 tp
->t_state
= TCPS_CLOSED
;
340 case TCPS_SYN_RECEIVED
:
341 case TCPS_ESTABLISHED
:
342 tp
->t_state
= TCPS_FIN_WAIT_1
;
345 case TCPS_CLOSE_WAIT
:
346 tp
->t_state
= TCPS_LAST_ACK
;
354 * Connect to a host on the Internet
355 * Called by tcp_input
356 * Only do a connect, the tcp fields will be set in tcp_input
357 * return 0 if there's a result of the connect,
358 * else return -1 means we're still connecting
359 * The return value is almost always -1 since the socket is
360 * nonblocking. Connect returns after the SYN is sent, and does
361 * not wait for ACK+SYN.
363 int tcp_fconnect(struct socket
*so
, unsigned short af
)
367 DEBUG_CALL("tcp_fconnect");
368 DEBUG_ARG("so = %p", so
);
370 ret
= so
->s
= qemu_socket(af
, SOCK_STREAM
, 0);
373 struct sockaddr_storage addr
;
375 qemu_set_nonblock(s
);
376 socket_set_fast_reuse(s
);
378 qemu_setsockopt(s
, SOL_SOCKET
, SO_OOBINLINE
, &opt
, sizeof(opt
));
381 DEBUG_CALL(" connect()ing")
382 sotranslate_out(so
, &addr
);
384 /* We don't care what port we get */
385 ret
= connect(s
,(struct sockaddr
*)&addr
,sizeof (addr
));
388 * If it's not in progress, it failed, so we just return 0,
389 * without clearing SS_NOFDREF
398 * Accept the socket and connect to the local-host
400 * We have a problem. The correct thing to do would be
401 * to first connect to the local-host, and only if the
402 * connection is accepted, then do an accept() here.
403 * But, a) we need to know who's trying to connect
404 * to the socket to be able to SYN the local-host, and
405 * b) we are already connected to the foreign host by
406 * the time it gets to accept(), so... We simply accept
407 * here and SYN the local-host.
409 void tcp_connect(struct socket
*inso
)
411 Slirp
*slirp
= inso
->slirp
;
413 struct sockaddr_storage addr
;
414 socklen_t addrlen
= sizeof(struct sockaddr_storage
);
418 DEBUG_CALL("tcp_connect");
419 DEBUG_ARG("inso = %p", inso
);
422 * If it's an SS_ACCEPTONCE socket, no need to socreate()
423 * another socket, just use the accept() socket.
425 if (inso
->so_state
& SS_FACCEPTONCE
) {
426 /* FACCEPTONCE already have a tcpcb */
429 so
= socreate(slirp
);
431 /* If it failed, get rid of the pending connection */
432 closesocket(accept(inso
->s
, (struct sockaddr
*)&addr
, &addrlen
));
435 if (tcp_attach(so
) < 0) {
436 free(so
); /* NOT sofree */
439 so
->lhost
= inso
->lhost
;
440 so
->so_ffamily
= inso
->so_ffamily
;
443 tcp_mss(sototcpcb(so
), 0);
445 s
= accept(inso
->s
, (struct sockaddr
*)&addr
, &addrlen
);
447 tcp_close(sototcpcb(so
)); /* This will sofree() as well */
450 qemu_set_nonblock(s
);
451 socket_set_fast_reuse(s
);
453 qemu_setsockopt(s
, SOL_SOCKET
, SO_OOBINLINE
, &opt
, sizeof(int));
454 socket_set_nodelay(s
);
457 sotranslate_accept(so
);
459 /* Close the accept() socket, set right state */
460 if (inso
->so_state
& SS_FACCEPTONCE
) {
461 /* If we only accept once, close the accept() socket */
464 /* Don't select it yet, even though we have an FD */
465 /* if it's not FACCEPTONCE, it's already NOFDREF */
466 so
->so_state
= SS_NOFDREF
;
469 so
->so_state
|= SS_INCOMING
;
471 so
->so_iptos
= tcp_tos(so
);
476 tp
->t_state
= TCPS_SYN_SENT
;
477 tp
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
;
478 tp
->iss
= slirp
->tcp_iss
;
479 slirp
->tcp_iss
+= TCP_ISSINCR
/2;
485 * Attach a TCPCB to a socket.
488 tcp_attach(struct socket
*so
)
490 if ((so
->so_tcpcb
= tcp_newtcpcb(so
)) == NULL
)
493 insque(so
, &so
->slirp
->tcb
);
499 * Set the socket's type of service field
501 static const struct tos_t tcptos
[] = {
502 {0, 20, IPTOS_THROUGHPUT
, 0}, /* ftp data */
503 {21, 21, IPTOS_LOWDELAY
, EMU_FTP
}, /* ftp control */
504 {0, 23, IPTOS_LOWDELAY
, 0}, /* telnet */
505 {0, 80, IPTOS_THROUGHPUT
, 0}, /* WWW */
506 {0, 513, IPTOS_LOWDELAY
, EMU_RLOGIN
|EMU_NOCONNECT
}, /* rlogin */
507 {0, 514, IPTOS_LOWDELAY
, EMU_RSH
|EMU_NOCONNECT
}, /* shell */
508 {0, 544, IPTOS_LOWDELAY
, EMU_KSH
}, /* kshell */
509 {0, 543, IPTOS_LOWDELAY
, 0}, /* klogin */
510 {0, 6667, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC */
511 {0, 6668, IPTOS_THROUGHPUT
, EMU_IRC
}, /* IRC undernet */
512 {0, 7070, IPTOS_LOWDELAY
, EMU_REALAUDIO
}, /* RealAudio control */
513 {0, 113, IPTOS_LOWDELAY
, EMU_IDENT
}, /* identd protocol */
517 static struct emu_t
*tcpemu
= NULL
;
520 * Return TOS according to the above table
523 tcp_tos(struct socket
*so
)
528 while(tcptos
[i
].tos
) {
529 if ((tcptos
[i
].fport
&& (ntohs(so
->so_fport
) == tcptos
[i
].fport
)) ||
530 (tcptos
[i
].lport
&& (ntohs(so
->so_lport
) == tcptos
[i
].lport
))) {
531 so
->so_emu
= tcptos
[i
].emu
;
532 return tcptos
[i
].tos
;
537 /* Nope, lets see if there's a user-added one */
538 for (emup
= tcpemu
; emup
; emup
= emup
->next
) {
539 if ((emup
->fport
&& (ntohs(so
->so_fport
) == emup
->fport
)) ||
540 (emup
->lport
&& (ntohs(so
->so_lport
) == emup
->lport
))) {
541 so
->so_emu
= emup
->emu
;
550 * Emulate programs that try and connect to us
551 * This includes ftp (the data connection is
552 * initiated by the server) and IRC (DCC CHAT and
555 * NOTE: It's possible to crash SLiRP by sending it
556 * unstandard strings to emulate... if this is a problem,
557 * more checks are needed here
559 * XXX Assumes the whole command came in one packet
561 * XXX Some ftp clients will have their TOS set to
562 * LOWDELAY and so Nagel will kick in. Because of this,
563 * we'll get the first letter, followed by the rest, so
564 * we simply scan for ORT instead of PORT...
565 * DCC doesn't have this problem because there's other stuff
566 * in the packet before the DCC command.
568 * Return 1 if the mbuf m is still valid and should be
571 * NOTE: if you return 0 you MUST m_free() the mbuf!
574 tcp_emu(struct socket
*so
, struct mbuf
*m
)
576 Slirp
*slirp
= so
->slirp
;
577 u_int n1
, n2
, n3
, n4
, n5
, n6
;
583 DEBUG_CALL("tcp_emu");
584 DEBUG_ARG("so = %p", so
);
585 DEBUG_ARG("m = %p", m
);
592 * Identification protocol as per rfc-1413
596 struct socket
*tmpso
;
597 struct sockaddr_in addr
;
598 socklen_t addrlen
= sizeof(struct sockaddr_in
);
599 struct sbuf
*so_rcv
= &so
->so_rcv
;
601 memcpy(so_rcv
->sb_wptr
, m
->m_data
, m
->m_len
);
602 so_rcv
->sb_wptr
+= m
->m_len
;
603 so_rcv
->sb_rptr
+= m
->m_len
;
604 m
->m_data
[m
->m_len
] = 0; /* NULL terminate */
605 if (strchr(m
->m_data
, '\r') || strchr(m
->m_data
, '\n')) {
606 if (sscanf(so_rcv
->sb_data
, "%u%*[ ,]%u", &n1
, &n2
) == 2) {
609 /* n2 is the one on our host */
610 for (tmpso
= slirp
->tcb
.so_next
;
611 tmpso
!= &slirp
->tcb
;
612 tmpso
= tmpso
->so_next
) {
613 if (tmpso
->so_laddr
.s_addr
== so
->so_laddr
.s_addr
&&
614 tmpso
->so_lport
== n2
&&
615 tmpso
->so_faddr
.s_addr
== so
->so_faddr
.s_addr
&&
616 tmpso
->so_fport
== n1
) {
617 if (getsockname(tmpso
->s
,
618 (struct sockaddr
*)&addr
, &addrlen
) == 0)
619 n2
= ntohs(addr
.sin_port
);
624 so_rcv
->sb_cc
= snprintf(so_rcv
->sb_data
,
626 "%d,%d\r\n", n1
, n2
);
627 so_rcv
->sb_rptr
= so_rcv
->sb_data
;
628 so_rcv
->sb_wptr
= so_rcv
->sb_data
+ so_rcv
->sb_cc
;
634 case EMU_FTP
: /* ftp */
635 *(m
->m_data
+m
->m_len
) = 0; /* NUL terminate for strstr */
636 if ((bptr
= (char *)strstr(m
->m_data
, "ORT")) != NULL
) {
638 * Need to emulate the PORT command
640 x
= sscanf(bptr
, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
641 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
645 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
646 lport
= htons((n5
<< 8) | (n6
));
648 if ((so
= tcp_listen(slirp
, INADDR_ANY
, 0, laddr
,
649 lport
, SS_FACCEPTONCE
)) == NULL
) {
652 n6
= ntohs(so
->so_fport
);
654 n5
= (n6
>> 8) & 0xff;
657 laddr
= ntohl(so
->so_faddr
.s_addr
);
659 n1
= ((laddr
>> 24) & 0xff);
660 n2
= ((laddr
>> 16) & 0xff);
661 n3
= ((laddr
>> 8) & 0xff);
664 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
665 m
->m_len
+= snprintf(bptr
, m
->m_size
- m
->m_len
,
666 "ORT %d,%d,%d,%d,%d,%d\r\n%s",
667 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
669 } else if ((bptr
= (char *)strstr(m
->m_data
, "27 Entering")) != NULL
) {
671 * Need to emulate the PASV response
673 x
= sscanf(bptr
, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
674 &n1
, &n2
, &n3
, &n4
, &n5
, &n6
, buff
);
678 laddr
= htonl((n1
<< 24) | (n2
<< 16) | (n3
<< 8) | (n4
));
679 lport
= htons((n5
<< 8) | (n6
));
681 if ((so
= tcp_listen(slirp
, INADDR_ANY
, 0, laddr
,
682 lport
, SS_FACCEPTONCE
)) == NULL
) {
685 n6
= ntohs(so
->so_fport
);
687 n5
= (n6
>> 8) & 0xff;
690 laddr
= ntohl(so
->so_faddr
.s_addr
);
692 n1
= ((laddr
>> 24) & 0xff);
693 n2
= ((laddr
>> 16) & 0xff);
694 n3
= ((laddr
>> 8) & 0xff);
697 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
698 m
->m_len
+= snprintf(bptr
, m
->m_size
- m
->m_len
,
699 "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
700 n1
, n2
, n3
, n4
, n5
, n6
, x
==7?buff
:"");
709 * The kshell (Kerberos rsh) and shell services both pass
710 * a local port port number to carry signals to the server
711 * and stderr to the client. It is passed at the beginning
712 * of the connection as a NUL-terminated decimal ASCII string.
715 for (lport
= 0, i
= 0; i
< m
->m_len
-1; ++i
) {
716 if (m
->m_data
[i
] < '0' || m
->m_data
[i
] > '9')
717 return 1; /* invalid number */
719 lport
+= m
->m_data
[i
] - '0';
721 if (m
->m_data
[m
->m_len
-1] == '\0' && lport
!= 0 &&
722 (so
= tcp_listen(slirp
, INADDR_ANY
, 0, so
->so_laddr
.s_addr
,
723 htons(lport
), SS_FACCEPTONCE
)) != NULL
)
724 m
->m_len
= snprintf(m
->m_data
, m
->m_size
, "%d",
725 ntohs(so
->so_fport
)) + 1;
730 * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
732 *(m
->m_data
+m
->m_len
) = 0; /* NULL terminate the string for strstr */
733 if ((bptr
= (char *)strstr(m
->m_data
, "DCC")) == NULL
)
736 /* The %256s is for the broken mIRC */
737 if (sscanf(bptr
, "DCC CHAT %256s %u %u", buff
, &laddr
, &lport
) == 3) {
738 if ((so
= tcp_listen(slirp
, INADDR_ANY
, 0,
739 htonl(laddr
), htons(lport
),
740 SS_FACCEPTONCE
)) == NULL
) {
743 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
744 m
->m_len
+= snprintf(bptr
, m
->m_size
,
745 "DCC CHAT chat %lu %u%c\n",
746 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
747 ntohs(so
->so_fport
), 1);
748 } else if (sscanf(bptr
, "DCC SEND %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
749 if ((so
= tcp_listen(slirp
, INADDR_ANY
, 0,
750 htonl(laddr
), htons(lport
),
751 SS_FACCEPTONCE
)) == NULL
) {
754 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
755 m
->m_len
+= snprintf(bptr
, m
->m_size
,
756 "DCC SEND %s %lu %u %u%c\n", buff
,
757 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
758 ntohs(so
->so_fport
), n1
, 1);
759 } else if (sscanf(bptr
, "DCC MOVE %256s %u %u %u", buff
, &laddr
, &lport
, &n1
) == 4) {
760 if ((so
= tcp_listen(slirp
, INADDR_ANY
, 0,
761 htonl(laddr
), htons(lport
),
762 SS_FACCEPTONCE
)) == NULL
) {
765 m
->m_len
= bptr
- m
->m_data
; /* Adjust length */
766 m
->m_len
+= snprintf(bptr
, m
->m_size
,
767 "DCC MOVE %s %lu %u %u%c\n", buff
,
768 (unsigned long)ntohl(so
->so_faddr
.s_addr
),
769 ntohs(so
->so_fport
), n1
, 1);
775 * RealAudio emulation - JP. We must try to parse the incoming
776 * data and try to find the two characters that contain the
777 * port number. Then we redirect an udp port and replace the
778 * number with the real port we got.
780 * The 1.0 beta versions of the player are not supported
783 * A typical packet for player version 1.0 (release version):
785 * 0000:50 4E 41 00 05
786 * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 ........g.l.c..P
787 * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
788 * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
789 * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
791 * Now the port number 0x1BD7 is found at offset 0x04 of the
792 * Now the port number 0x1BD7 is found at offset 0x04 of the
793 * second packet. This time we received five bytes first and
794 * then the rest. You never know how many bytes you get.
796 * A typical packet for player version 2.0 (beta):
798 * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA.............
799 * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .gux.c..Win2.0.0
800 * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
801 * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
802 * 0040:65 2E 72 61 79 53 00 00 06 36 42 e.rayS...6B
804 * Port number 0x1BC1 is found at offset 0x0d.
806 * This is just a horrible switch statement. Variable ra tells
807 * us where we're going.
811 while (bptr
< m
->m_data
+ m
->m_len
) {
825 if (*bptr
++ != ra_tbl
[ra
]) {
833 * We may get 0x50 several times, ignore them
839 } else if (*bptr
++ != ra_tbl
[ra
]) {
847 * skip version number
854 * The difference between versions 1.0 and
855 * 2.0 is here. For future versions of
856 * the player this may need to be modified.
858 if (*(bptr
+ 1) == 0x02)
865 /* This is the field containing the port
866 * number that RA-player is listening to.
868 lport
= (((u_char
*)bptr
)[0] << 8)
869 + ((u_char
*)bptr
)[1];
871 lport
+= 256; /* don't know why */
872 if (lport
< 6970 || lport
> 7170)
873 return 1; /* failed */
875 /* try to get udp port between 6970 - 7170 */
876 for (p
= 6970; p
< 7071; p
++) {
877 if (udp_listen(slirp
, INADDR_ANY
,
887 *(u_char
*)bptr
++ = (p
>> 8) & 0xff;
888 *(u_char
*)bptr
= p
& 0xff;
890 return 1; /* port redirected, we're done */
901 /* Ooops, not emulated, won't call tcp_emu again */
908 * Do misc. config of SLiRP while its running.
909 * Return 0 if this connections is to be closed, 1 otherwise,
910 * return 2 if this is a command-line connection
912 int tcp_ctl(struct socket
*so
)
914 Slirp
*slirp
= so
->slirp
;
915 struct sbuf
*sb
= &so
->so_snd
;
916 struct ex_list
*ex_ptr
;
919 DEBUG_CALL("tcp_ctl");
920 DEBUG_ARG("so = %p", so
);
922 if (so
->so_faddr
.s_addr
!= slirp
->vhost_addr
.s_addr
) {
923 /* Check if it's pty_exec */
924 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
925 if (ex_ptr
->ex_fport
== so
->so_fport
&&
926 so
->so_faddr
.s_addr
== ex_ptr
->ex_addr
.s_addr
) {
927 if (ex_ptr
->ex_pty
== 3) {
929 so
->extra
= (void *)ex_ptr
->ex_exec
;
932 do_pty
= ex_ptr
->ex_pty
;
933 DEBUG_MISC((dfd
, " executing %s\n", ex_ptr
->ex_exec
));
934 return fork_exec(so
, ex_ptr
->ex_exec
, do_pty
);
939 snprintf(sb
->sb_wptr
, sb
->sb_datalen
- (sb
->sb_wptr
- sb
->sb_data
),
940 "Error: No application configured.\r\n");
941 sb
->sb_wptr
+= sb
->sb_cc
;