Annotation of qemu/slirp/tcp_subr.c, revision 1.1.1.7
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1988, 1990, 1993
3: * The Regents of the University of California. All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
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.
1.1.1.5 root 13: * 3. Neither the name of the University nor the names of its contributors
1.1 root 14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
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
27: * SUCH DAMAGE.
28: *
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
31: */
32:
33: /*
34: * Changes and additions relating to SLiRP
35: * Copyright (c) 1995 Danny Gasparovski.
1.1.1.4 root 36: *
37: * Please read the file COPYRIGHT for the
1.1 root 38: * terms and conditions of the copyright.
39: */
40:
41: #include <slirp.h>
42:
43: /* patchable/settable parameters for tcp */
1.1.1.4 root 44: /* Don't do rfc1323 performance enhancements */
45: #define TCP_DO_RFC1323 0
1.1 root 46:
47: /*
48: * Tcp initialization
49: */
50: void
1.1.1.6 root 51: tcp_init(Slirp *slirp)
1.1 root 52: {
1.1.1.6 root 53: slirp->tcp_iss = 1; /* wrong */
54: slirp->tcb.so_next = slirp->tcb.so_prev = &slirp->tcb;
55: slirp->tcp_last_so = &slirp->tcb;
1.1 root 56: }
57:
58: /*
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.
63: */
64: void
1.1.1.6 root 65: tcp_template(struct tcpcb *tp)
1.1 root 66: {
67: struct socket *so = tp->t_socket;
68: register struct tcpiphdr *n = &tp->t_template;
69:
1.1.1.5 root 70: n->ti_mbuf = NULL;
1.1 root 71: n->ti_x1 = 0;
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;
1.1.1.4 root 78:
1.1 root 79: n->ti_seq = 0;
80: n->ti_ack = 0;
81: n->ti_x2 = 0;
82: n->ti_off = 5;
83: n->ti_flags = 0;
84: n->ti_win = 0;
85: n->ti_sum = 0;
86: n->ti_urp = 0;
87: }
88:
89: /*
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
97: * attached mbufs.
98: *
99: * In any case the ack and sequence number of the transmitted
100: * segment are as specified by the parameters.
101: */
102: void
1.1.1.6 root 103: tcp_respond(struct tcpcb *tp, struct tcpiphdr *ti, struct mbuf *m,
104: tcp_seq ack, tcp_seq seq, int flags)
1.1 root 105: {
106: register int tlen;
107: int win = 0;
108:
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);
1.1.1.4 root 116:
1.1 root 117: if (tp)
118: win = sbspace(&tp->t_socket->so_rcv);
1.1.1.6 root 119: if (m == NULL) {
120: if ((m = m_get(tp->t_socket->slirp)) == NULL)
1.1 root 121: return;
122: tlen = 0;
1.1.1.4 root 123: m->m_data += IF_MAXLINKHDR;
1.1 root 124: *mtod(m, struct tcpiphdr *) = *ti;
125: ti = mtod(m, struct tcpiphdr *);
126: flags = TH_ACK;
127: } else {
1.1.1.4 root 128: /*
1.1 root 129: * ti points into m so the next line is just making
130: * the mbuf point to ti
131: */
132: m->m_data = (caddr_t)ti;
1.1.1.4 root 133:
1.1 root 134: m->m_len = sizeof (struct tcpiphdr);
135: tlen = 0;
136: #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
137: xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_int32_t);
138: xchg(ti->ti_dport, ti->ti_sport, u_int16_t);
139: #undef xchg
140: }
141: ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
142: tlen += sizeof (struct tcpiphdr);
143: m->m_len = tlen;
144:
1.1.1.6 root 145: ti->ti_mbuf = NULL;
1.1 root 146: ti->ti_x1 = 0;
147: ti->ti_seq = htonl(seq);
148: ti->ti_ack = htonl(ack);
149: ti->ti_x2 = 0;
150: ti->ti_off = sizeof (struct tcphdr) >> 2;
151: ti->ti_flags = flags;
152: if (tp)
153: ti->ti_win = htons((u_int16_t) (win >> tp->rcv_scale));
154: else
155: ti->ti_win = htons((u_int16_t)win);
156: ti->ti_urp = 0;
157: ti->ti_sum = 0;
158: ti->ti_sum = cksum(m, tlen);
159: ((struct ip *)ti)->ip_len = tlen;
160:
1.1.1.4 root 161: if(flags & TH_RST)
1.1 root 162: ((struct ip *)ti)->ip_ttl = MAXTTL;
1.1.1.4 root 163: else
164: ((struct ip *)ti)->ip_ttl = IPDEFTTL;
165:
1.1 root 166: (void) ip_output((struct socket *)0, m);
167: }
168:
169: /*
170: * Create a new TCP control block, making an
171: * empty reassembly queue and hooking it to the argument
172: * protocol control block.
173: */
174: struct tcpcb *
1.1.1.6 root 175: tcp_newtcpcb(struct socket *so)
1.1 root 176: {
177: register struct tcpcb *tp;
1.1.1.4 root 178:
1.1 root 179: tp = (struct tcpcb *)malloc(sizeof(*tp));
180: if (tp == NULL)
181: return ((struct tcpcb *)0);
1.1.1.4 root 182:
1.1 root 183: memset((char *) tp, 0, sizeof(struct tcpcb));
1.1.1.5 root 184: tp->seg_next = tp->seg_prev = (struct tcpiphdr*)tp;
1.1.1.4 root 185: tp->t_maxseg = TCP_MSS;
186:
187: tp->t_flags = TCP_DO_RFC1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
1.1 root 188: tp->t_socket = so;
1.1.1.4 root 189:
1.1 root 190: /*
191: * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
192: * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
193: * reasonable initial retransmit time.
194: */
195: tp->t_srtt = TCPTV_SRTTBASE;
1.1.1.4 root 196: tp->t_rttvar = TCPTV_SRTTDFLT << 2;
1.1 root 197: tp->t_rttmin = TCPTV_MIN;
198:
1.1.1.4 root 199: TCPT_RANGESET(tp->t_rxtcur,
1.1 root 200: ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
201: TCPTV_MIN, TCPTV_REXMTMAX);
202:
203: tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
204: tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
205: tp->t_state = TCPS_CLOSED;
1.1.1.4 root 206:
1.1 root 207: so->so_tcpcb = tp;
208:
209: return (tp);
210: }
211:
212: /*
213: * Drop a TCP connection, reporting
214: * the specified error. If connection is synchronized,
215: * then send a RST to peer.
216: */
1.1.1.4 root 217: struct tcpcb *tcp_drop(struct tcpcb *tp, int err)
1.1 root 218: {
219: DEBUG_CALL("tcp_drop");
220: DEBUG_ARG("tp = %lx", (long)tp);
221: DEBUG_ARG("errno = %d", errno);
1.1.1.4 root 222:
1.1 root 223: if (TCPS_HAVERCVDSYN(tp->t_state)) {
224: tp->t_state = TCPS_CLOSED;
225: (void) tcp_output(tp);
1.1.1.6 root 226: }
1.1 root 227: return (tcp_close(tp));
228: }
229:
230: /*
231: * Close a TCP control block:
232: * discard all space held by the tcp
233: * discard internet protocol block
234: * wake up any sleepers
235: */
236: struct tcpcb *
1.1.1.6 root 237: tcp_close(struct tcpcb *tp)
1.1 root 238: {
239: register struct tcpiphdr *t;
240: struct socket *so = tp->t_socket;
1.1.1.6 root 241: Slirp *slirp = so->slirp;
1.1 root 242: register struct mbuf *m;
243:
244: DEBUG_CALL("tcp_close");
245: DEBUG_ARG("tp = %lx", (long )tp);
1.1.1.4 root 246:
1.1 root 247: /* free the reassembly queue, if any */
1.1.1.5 root 248: t = tcpfrag_list_first(tp);
249: while (!tcpfrag_list_end(t, tp)) {
250: t = tcpiphdr_next(t);
251: m = tcpiphdr_prev(t)->ti_mbuf;
252: remque(tcpiphdr2qlink(tcpiphdr_prev(t)));
1.1 root 253: m_freem(m);
254: }
255: free(tp);
1.1.1.6 root 256: so->so_tcpcb = NULL;
1.1 root 257: /* clobber input socket cache if we're closing the cached connection */
1.1.1.6 root 258: if (so == slirp->tcp_last_so)
259: slirp->tcp_last_so = &slirp->tcb;
1.1 root 260: closesocket(so->s);
261: sbfree(&so->so_rcv);
262: sbfree(&so->so_snd);
263: sofree(so);
264: return ((struct tcpcb *)0);
265: }
266:
267: /*
268: * TCP protocol interface to socket abstraction.
269: */
270:
271: /*
272: * User issued close, and wish to trail through shutdown states:
273: * if never received SYN, just forget it. If got a SYN from peer,
274: * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
275: * If already got a FIN from peer, then almost done; go to LAST_ACK
276: * state. In all other cases, have already sent FIN to peer (e.g.
277: * after PRU_SHUTDOWN), and just have to play tedious game waiting
278: * for peer to send FIN or not respond to keep-alives, etc.
279: * We can let the user exit from the close as soon as the FIN is acked.
280: */
281: void
1.1.1.6 root 282: tcp_sockclosed(struct tcpcb *tp)
1.1 root 283: {
284:
285: DEBUG_CALL("tcp_sockclosed");
286: DEBUG_ARG("tp = %lx", (long)tp);
1.1.1.4 root 287:
1.1 root 288: switch (tp->t_state) {
289:
290: case TCPS_CLOSED:
291: case TCPS_LISTEN:
292: case TCPS_SYN_SENT:
293: tp->t_state = TCPS_CLOSED;
294: tp = tcp_close(tp);
295: break;
296:
297: case TCPS_SYN_RECEIVED:
298: case TCPS_ESTABLISHED:
299: tp->t_state = TCPS_FIN_WAIT_1;
300: break;
301:
302: case TCPS_CLOSE_WAIT:
303: tp->t_state = TCPS_LAST_ACK;
304: break;
305: }
306: if (tp)
307: tcp_output(tp);
308: }
309:
1.1.1.4 root 310: /*
1.1 root 311: * Connect to a host on the Internet
312: * Called by tcp_input
313: * Only do a connect, the tcp fields will be set in tcp_input
314: * return 0 if there's a result of the connect,
315: * else return -1 means we're still connecting
316: * The return value is almost always -1 since the socket is
1.1.1.4 root 317: * nonblocking. Connect returns after the SYN is sent, and does
1.1 root 318: * not wait for ACK+SYN.
319: */
1.1.1.6 root 320: int tcp_fconnect(struct socket *so)
1.1 root 321: {
1.1.1.6 root 322: Slirp *slirp = so->slirp;
1.1 root 323: int ret=0;
1.1.1.4 root 324:
1.1 root 325: DEBUG_CALL("tcp_fconnect");
326: DEBUG_ARG("so = %lx", (long )so);
327:
1.1.1.7 ! root 328: if( (ret = so->s = qemu_socket(AF_INET,SOCK_STREAM,0)) >= 0) {
1.1 root 329: int opt, s=so->s;
330: struct sockaddr_in addr;
331:
332: fd_nonblock(s);
333: opt = 1;
334: setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(opt ));
335: opt = 1;
336: setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(opt ));
1.1.1.4 root 337:
1.1 root 338: addr.sin_family = AF_INET;
1.1.1.6 root 339: if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) ==
340: slirp->vnetwork_addr.s_addr) {
1.1 root 341: /* It's an alias */
1.1.1.6 root 342: if (so->so_faddr.s_addr == slirp->vnameserver_addr.s_addr) {
1.1.1.7 ! root 343: if (get_dns_addr(&addr.sin_addr) < 0)
! 344: addr.sin_addr = loopback_addr;
1.1.1.6 root 345: } else {
1.1 root 346: addr.sin_addr = loopback_addr;
347: }
348: } else
349: addr.sin_addr = so->so_faddr;
350: addr.sin_port = so->so_fport;
1.1.1.4 root 351:
1.1 root 352: DEBUG_MISC((dfd, " connect()ing, addr.sin_port=%d, "
1.1.1.4 root 353: "addr.sin_addr.s_addr=%.16s\n",
1.1 root 354: ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));
355: /* We don't care what port we get */
356: ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));
1.1.1.4 root 357:
1.1 root 358: /*
359: * If it's not in progress, it failed, so we just return 0,
360: * without clearing SS_NOFDREF
361: */
362: soisfconnecting(so);
363: }
364:
365: return(ret);
366: }
367:
368: /*
369: * Accept the socket and connect to the local-host
1.1.1.4 root 370: *
1.1 root 371: * We have a problem. The correct thing to do would be
372: * to first connect to the local-host, and only if the
373: * connection is accepted, then do an accept() here.
1.1.1.4 root 374: * But, a) we need to know who's trying to connect
1.1 root 375: * to the socket to be able to SYN the local-host, and
376: * b) we are already connected to the foreign host by
377: * the time it gets to accept(), so... We simply accept
378: * here and SYN the local-host.
1.1.1.4 root 379: */
1.1 root 380: void
1.1.1.6 root 381: tcp_connect(struct socket *inso)
1.1 root 382: {
1.1.1.6 root 383: Slirp *slirp = inso->slirp;
1.1 root 384: struct socket *so;
385: struct sockaddr_in addr;
1.1.1.5 root 386: socklen_t addrlen = sizeof(struct sockaddr_in);
1.1 root 387: struct tcpcb *tp;
388: int s, opt;
389:
390: DEBUG_CALL("tcp_connect");
391: DEBUG_ARG("inso = %lx", (long)inso);
1.1.1.4 root 392:
1.1 root 393: /*
394: * If it's an SS_ACCEPTONCE socket, no need to socreate()
395: * another socket, just use the accept() socket.
396: */
397: if (inso->so_state & SS_FACCEPTONCE) {
398: /* FACCEPTONCE already have a tcpcb */
399: so = inso;
400: } else {
1.1.1.6 root 401: if ((so = socreate(slirp)) == NULL) {
1.1 root 402: /* If it failed, get rid of the pending connection */
403: closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
404: return;
405: }
406: if (tcp_attach(so) < 0) {
407: free(so); /* NOT sofree */
408: return;
409: }
410: so->so_laddr = inso->so_laddr;
411: so->so_lport = inso->so_lport;
412: }
1.1.1.4 root 413:
1.1 root 414: (void) tcp_mss(sototcpcb(so), 0);
415:
416: if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
417: tcp_close(sototcpcb(so)); /* This will sofree() as well */
418: return;
419: }
420: fd_nonblock(s);
421: opt = 1;
422: setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
423: opt = 1;
424: setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
1.1.1.3 root 425: opt = 1;
426: setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char *)&opt,sizeof(int));
1.1.1.4 root 427:
1.1 root 428: so->so_fport = addr.sin_port;
429: so->so_faddr = addr.sin_addr;
430: /* Translate connections from localhost to the real hostname */
431: if (so->so_faddr.s_addr == 0 || so->so_faddr.s_addr == loopback_addr.s_addr)
1.1.1.6 root 432: so->so_faddr = slirp->vhost_addr;
1.1.1.4 root 433:
1.1 root 434: /* Close the accept() socket, set right state */
435: if (inso->so_state & SS_FACCEPTONCE) {
436: closesocket(so->s); /* If we only accept once, close the accept() socket */
437: so->so_state = SS_NOFDREF; /* Don't select it yet, even though we have an FD */
438: /* if it's not FACCEPTONCE, it's already NOFDREF */
439: }
440: so->s = s;
1.1.1.6 root 441: so->so_state |= SS_INCOMING;
1.1.1.4 root 442:
1.1 root 443: so->so_iptos = tcp_tos(so);
444: tp = sototcpcb(so);
445:
446: tcp_template(tp);
1.1.1.4 root 447:
1.1 root 448: tp->t_state = TCPS_SYN_SENT;
449: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
1.1.1.6 root 450: tp->iss = slirp->tcp_iss;
451: slirp->tcp_iss += TCP_ISSINCR/2;
1.1 root 452: tcp_sendseqinit(tp);
453: tcp_output(tp);
454: }
455:
456: /*
457: * Attach a TCPCB to a socket.
458: */
459: int
1.1.1.6 root 460: tcp_attach(struct socket *so)
1.1 root 461: {
462: if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL)
463: return -1;
1.1.1.4 root 464:
1.1.1.6 root 465: insque(so, &so->slirp->tcb);
1.1 root 466:
467: return 0;
468: }
469:
470: /*
471: * Set the socket's type of service field
472: */
1.1.1.4 root 473: static const struct tos_t tcptos[] = {
1.1 root 474: {0, 20, IPTOS_THROUGHPUT, 0}, /* ftp data */
475: {21, 21, IPTOS_LOWDELAY, EMU_FTP}, /* ftp control */
476: {0, 23, IPTOS_LOWDELAY, 0}, /* telnet */
477: {0, 80, IPTOS_THROUGHPUT, 0}, /* WWW */
478: {0, 513, IPTOS_LOWDELAY, EMU_RLOGIN|EMU_NOCONNECT}, /* rlogin */
479: {0, 514, IPTOS_LOWDELAY, EMU_RSH|EMU_NOCONNECT}, /* shell */
480: {0, 544, IPTOS_LOWDELAY, EMU_KSH}, /* kshell */
481: {0, 543, IPTOS_LOWDELAY, 0}, /* klogin */
482: {0, 6667, IPTOS_THROUGHPUT, EMU_IRC}, /* IRC */
483: {0, 6668, IPTOS_THROUGHPUT, EMU_IRC}, /* IRC undernet */
484: {0, 7070, IPTOS_LOWDELAY, EMU_REALAUDIO }, /* RealAudio control */
485: {0, 113, IPTOS_LOWDELAY, EMU_IDENT }, /* identd protocol */
486: {0, 0, 0, 0}
487: };
488:
1.1.1.6 root 489: static struct emu_t *tcpemu = NULL;
1.1.1.4 root 490:
1.1 root 491: /*
492: * Return TOS according to the above table
493: */
494: u_int8_t
1.1.1.6 root 495: tcp_tos(struct socket *so)
1.1 root 496: {
497: int i = 0;
498: struct emu_t *emup;
1.1.1.4 root 499:
1.1 root 500: while(tcptos[i].tos) {
501: if ((tcptos[i].fport && (ntohs(so->so_fport) == tcptos[i].fport)) ||
502: (tcptos[i].lport && (ntohs(so->so_lport) == tcptos[i].lport))) {
503: so->so_emu = tcptos[i].emu;
504: return tcptos[i].tos;
505: }
506: i++;
507: }
1.1.1.4 root 508:
1.1 root 509: /* Nope, lets see if there's a user-added one */
510: for (emup = tcpemu; emup; emup = emup->next) {
511: if ((emup->fport && (ntohs(so->so_fport) == emup->fport)) ||
512: (emup->lport && (ntohs(so->so_lport) == emup->lport))) {
513: so->so_emu = emup->emu;
514: return emup->tos;
515: }
516: }
1.1.1.4 root 517:
1.1 root 518: return 0;
519: }
520:
521: /*
522: * Emulate programs that try and connect to us
523: * This includes ftp (the data connection is
524: * initiated by the server) and IRC (DCC CHAT and
525: * DCC SEND) for now
1.1.1.4 root 526: *
1.1 root 527: * NOTE: It's possible to crash SLiRP by sending it
528: * unstandard strings to emulate... if this is a problem,
529: * more checks are needed here
530: *
531: * XXX Assumes the whole command came in one packet
1.1.1.4 root 532: *
1.1 root 533: * XXX Some ftp clients will have their TOS set to
534: * LOWDELAY and so Nagel will kick in. Because of this,
535: * we'll get the first letter, followed by the rest, so
536: * we simply scan for ORT instead of PORT...
537: * DCC doesn't have this problem because there's other stuff
538: * in the packet before the DCC command.
1.1.1.4 root 539: *
540: * Return 1 if the mbuf m is still valid and should be
1.1 root 541: * sbappend()ed
1.1.1.4 root 542: *
1.1 root 543: * NOTE: if you return 0 you MUST m_free() the mbuf!
544: */
545: int
1.1.1.6 root 546: tcp_emu(struct socket *so, struct mbuf *m)
1.1 root 547: {
1.1.1.6 root 548: Slirp *slirp = so->slirp;
1.1 root 549: u_int n1, n2, n3, n4, n5, n6;
1.1.1.5 root 550: char buff[257];
1.1 root 551: u_int32_t laddr;
552: u_int lport;
553: char *bptr;
1.1.1.4 root 554:
1.1 root 555: DEBUG_CALL("tcp_emu");
556: DEBUG_ARG("so = %lx", (long)so);
557: DEBUG_ARG("m = %lx", (long)m);
1.1.1.4 root 558:
1.1 root 559: switch(so->so_emu) {
560: int x, i;
1.1.1.4 root 561:
1.1 root 562: case EMU_IDENT:
563: /*
564: * Identification protocol as per rfc-1413
565: */
1.1.1.4 root 566:
1.1 root 567: {
568: struct socket *tmpso;
569: struct sockaddr_in addr;
1.1.1.5 root 570: socklen_t addrlen = sizeof(struct sockaddr_in);
1.1 root 571: struct sbuf *so_rcv = &so->so_rcv;
1.1.1.4 root 572:
1.1 root 573: memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
574: so_rcv->sb_wptr += m->m_len;
575: so_rcv->sb_rptr += m->m_len;
576: m->m_data[m->m_len] = 0; /* NULL terminate */
577: if (strchr(m->m_data, '\r') || strchr(m->m_data, '\n')) {
1.1.1.4 root 578: if (sscanf(so_rcv->sb_data, "%u%*[ ,]%u", &n1, &n2) == 2) {
1.1 root 579: HTONS(n1);
580: HTONS(n2);
581: /* n2 is the one on our host */
1.1.1.6 root 582: for (tmpso = slirp->tcb.so_next;
583: tmpso != &slirp->tcb;
584: tmpso = tmpso->so_next) {
1.1 root 585: if (tmpso->so_laddr.s_addr == so->so_laddr.s_addr &&
586: tmpso->so_lport == n2 &&
587: tmpso->so_faddr.s_addr == so->so_faddr.s_addr &&
588: tmpso->so_fport == n1) {
589: if (getsockname(tmpso->s,
590: (struct sockaddr *)&addr, &addrlen) == 0)
591: n2 = ntohs(addr.sin_port);
592: break;
593: }
594: }
595: }
1.1.1.5 root 596: so_rcv->sb_cc = snprintf(so_rcv->sb_data,
597: so_rcv->sb_datalen,
598: "%d,%d\r\n", n1, n2);
1.1 root 599: so_rcv->sb_rptr = so_rcv->sb_data;
600: so_rcv->sb_wptr = so_rcv->sb_data + so_rcv->sb_cc;
601: }
602: m_free(m);
603: return 0;
604: }
1.1.1.4 root 605:
1.1 root 606: case EMU_FTP: /* ftp */
1.1.1.6 root 607: *(m->m_data+m->m_len) = 0; /* NUL terminate for strstr */
1.1 root 608: if ((bptr = (char *)strstr(m->m_data, "ORT")) != NULL) {
609: /*
610: * Need to emulate the PORT command
1.1.1.4 root 611: */
612: x = sscanf(bptr, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]",
1.1 root 613: &n1, &n2, &n3, &n4, &n5, &n6, buff);
614: if (x < 6)
615: return 1;
1.1.1.4 root 616:
1.1 root 617: laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4));
618: lport = htons((n5 << 8) | (n6));
1.1.1.4 root 619:
1.1.1.6 root 620: if ((so = tcp_listen(slirp, INADDR_ANY, 0, laddr,
621: lport, SS_FACCEPTONCE)) == NULL) {
1.1 root 622: return 1;
1.1.1.6 root 623: }
1.1 root 624: n6 = ntohs(so->so_fport);
1.1.1.4 root 625:
1.1 root 626: n5 = (n6 >> 8) & 0xff;
627: n6 &= 0xff;
1.1.1.4 root 628:
1.1 root 629: laddr = ntohl(so->so_faddr.s_addr);
1.1.1.4 root 630:
1.1 root 631: n1 = ((laddr >> 24) & 0xff);
632: n2 = ((laddr >> 16) & 0xff);
633: n3 = ((laddr >> 8) & 0xff);
634: n4 = (laddr & 0xff);
1.1.1.4 root 635:
1.1 root 636: m->m_len = bptr - m->m_data; /* Adjust length */
1.1.1.5 root 637: m->m_len += snprintf(bptr, m->m_hdr.mh_size - m->m_len,
638: "ORT %d,%d,%d,%d,%d,%d\r\n%s",
639: n1, n2, n3, n4, n5, n6, x==7?buff:"");
1.1 root 640: return 1;
641: } else if ((bptr = (char *)strstr(m->m_data, "27 Entering")) != NULL) {
642: /*
643: * Need to emulate the PASV response
644: */
1.1.1.4 root 645: x = sscanf(bptr, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]",
1.1 root 646: &n1, &n2, &n3, &n4, &n5, &n6, buff);
647: if (x < 6)
648: return 1;
1.1.1.4 root 649:
1.1 root 650: laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4));
651: lport = htons((n5 << 8) | (n6));
1.1.1.4 root 652:
1.1.1.6 root 653: if ((so = tcp_listen(slirp, INADDR_ANY, 0, laddr,
654: lport, SS_FACCEPTONCE)) == NULL) {
1.1 root 655: return 1;
1.1.1.6 root 656: }
1.1 root 657: n6 = ntohs(so->so_fport);
1.1.1.4 root 658:
1.1 root 659: n5 = (n6 >> 8) & 0xff;
660: n6 &= 0xff;
1.1.1.4 root 661:
1.1 root 662: laddr = ntohl(so->so_faddr.s_addr);
1.1.1.4 root 663:
1.1 root 664: n1 = ((laddr >> 24) & 0xff);
665: n2 = ((laddr >> 16) & 0xff);
666: n3 = ((laddr >> 8) & 0xff);
667: n4 = (laddr & 0xff);
1.1.1.4 root 668:
1.1 root 669: m->m_len = bptr - m->m_data; /* Adjust length */
1.1.1.5 root 670: m->m_len += snprintf(bptr, m->m_hdr.mh_size - m->m_len,
671: "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s",
672: n1, n2, n3, n4, n5, n6, x==7?buff:"");
1.1.1.4 root 673:
1.1 root 674: return 1;
675: }
1.1.1.4 root 676:
1.1 root 677: return 1;
1.1.1.4 root 678:
1.1 root 679: case EMU_KSH:
680: /*
681: * The kshell (Kerberos rsh) and shell services both pass
682: * a local port port number to carry signals to the server
683: * and stderr to the client. It is passed at the beginning
684: * of the connection as a NUL-terminated decimal ASCII string.
685: */
686: so->so_emu = 0;
687: for (lport = 0, i = 0; i < m->m_len-1; ++i) {
688: if (m->m_data[i] < '0' || m->m_data[i] > '9')
689: return 1; /* invalid number */
690: lport *= 10;
691: lport += m->m_data[i] - '0';
692: }
693: if (m->m_data[m->m_len-1] == '\0' && lport != 0 &&
1.1.1.6 root 694: (so = tcp_listen(slirp, INADDR_ANY, 0, so->so_laddr.s_addr,
695: htons(lport), SS_FACCEPTONCE)) != NULL)
1.1.1.5 root 696: m->m_len = snprintf(m->m_data, m->m_hdr.mh_size, "%d",
697: ntohs(so->so_fport)) + 1;
1.1 root 698: return 1;
1.1.1.4 root 699:
1.1 root 700: case EMU_IRC:
701: /*
702: * Need to emulate DCC CHAT, DCC SEND and DCC MOVE
703: */
704: *(m->m_data+m->m_len) = 0; /* NULL terminate the string for strstr */
705: if ((bptr = (char *)strstr(m->m_data, "DCC")) == NULL)
706: return 1;
1.1.1.4 root 707:
1.1 root 708: /* The %256s is for the broken mIRC */
709: if (sscanf(bptr, "DCC CHAT %256s %u %u", buff, &laddr, &lport) == 3) {
1.1.1.6 root 710: if ((so = tcp_listen(slirp, INADDR_ANY, 0,
711: htonl(laddr), htons(lport),
712: SS_FACCEPTONCE)) == NULL) {
1.1 root 713: return 1;
1.1.1.6 root 714: }
1.1 root 715: m->m_len = bptr - m->m_data; /* Adjust length */
1.1.1.5 root 716: m->m_len += snprintf(bptr, m->m_hdr.mh_size,
717: "DCC CHAT chat %lu %u%c\n",
718: (unsigned long)ntohl(so->so_faddr.s_addr),
719: ntohs(so->so_fport), 1);
1.1 root 720: } else if (sscanf(bptr, "DCC SEND %256s %u %u %u", buff, &laddr, &lport, &n1) == 4) {
1.1.1.6 root 721: if ((so = tcp_listen(slirp, INADDR_ANY, 0,
722: htonl(laddr), htons(lport),
723: SS_FACCEPTONCE)) == NULL) {
1.1 root 724: return 1;
1.1.1.6 root 725: }
1.1 root 726: m->m_len = bptr - m->m_data; /* Adjust length */
1.1.1.5 root 727: m->m_len += snprintf(bptr, m->m_hdr.mh_size,
728: "DCC SEND %s %lu %u %u%c\n", buff,
729: (unsigned long)ntohl(so->so_faddr.s_addr),
730: ntohs(so->so_fport), n1, 1);
1.1 root 731: } else if (sscanf(bptr, "DCC MOVE %256s %u %u %u", buff, &laddr, &lport, &n1) == 4) {
1.1.1.6 root 732: if ((so = tcp_listen(slirp, INADDR_ANY, 0,
733: htonl(laddr), htons(lport),
734: SS_FACCEPTONCE)) == NULL) {
1.1 root 735: return 1;
1.1.1.6 root 736: }
1.1 root 737: m->m_len = bptr - m->m_data; /* Adjust length */
1.1.1.5 root 738: m->m_len += snprintf(bptr, m->m_hdr.mh_size,
739: "DCC MOVE %s %lu %u %u%c\n", buff,
740: (unsigned long)ntohl(so->so_faddr.s_addr),
741: ntohs(so->so_fport), n1, 1);
1.1 root 742: }
743: return 1;
744:
745: case EMU_REALAUDIO:
1.1.1.4 root 746: /*
1.1 root 747: * RealAudio emulation - JP. We must try to parse the incoming
748: * data and try to find the two characters that contain the
749: * port number. Then we redirect an udp port and replace the
750: * number with the real port we got.
751: *
752: * The 1.0 beta versions of the player are not supported
753: * any more.
1.1.1.4 root 754: *
1.1 root 755: * A typical packet for player version 1.0 (release version):
1.1.1.4 root 756: *
757: * 0000:50 4E 41 00 05
1.1.1.6 root 758: * 0000:00 01 00 02 1B D7 00 00 67 E6 6C DC 63 00 12 50 ........g.l.c..P
1.1 root 759: * 0010:4E 43 4C 49 45 4E 54 20 31 30 31 20 41 4C 50 48 NCLIENT 101 ALPH
760: * 0020:41 6C 00 00 52 00 17 72 61 66 69 6C 65 73 2F 76 Al..R..rafiles/v
761: * 0030:6F 61 2F 65 6E 67 6C 69 73 68 5F 2E 72 61 79 42 oa/english_.rayB
1.1.1.4 root 762: *
1.1 root 763: * Now the port number 0x1BD7 is found at offset 0x04 of the
764: * Now the port number 0x1BD7 is found at offset 0x04 of the
765: * second packet. This time we received five bytes first and
766: * then the rest. You never know how many bytes you get.
767: *
768: * A typical packet for player version 2.0 (beta):
1.1.1.4 root 769: *
1.1.1.6 root 770: * 0000:50 4E 41 00 06 00 02 00 00 00 01 00 02 1B C1 00 PNA.............
771: * 0010:00 67 75 78 F5 63 00 0A 57 69 6E 32 2E 30 2E 30 .gux.c..Win2.0.0
1.1 root 772: * 0020:2E 35 6C 00 00 52 00 1C 72 61 66 69 6C 65 73 2F .5l..R..rafiles/
773: * 0030:77 65 62 73 69 74 65 2F 32 30 72 65 6C 65 61 73 website/20releas
774: * 0040:65 2E 72 61 79 53 00 00 06 36 42 e.rayS...6B
1.1.1.4 root 775: *
1.1 root 776: * Port number 0x1BC1 is found at offset 0x0d.
1.1.1.4 root 777: *
1.1 root 778: * This is just a horrible switch statement. Variable ra tells
779: * us where we're going.
780: */
1.1.1.4 root 781:
1.1 root 782: bptr = m->m_data;
783: while (bptr < m->m_data + m->m_len) {
784: u_short p;
785: static int ra = 0;
1.1.1.4 root 786: char ra_tbl[4];
787:
1.1 root 788: ra_tbl[0] = 0x50;
789: ra_tbl[1] = 0x4e;
790: ra_tbl[2] = 0x41;
791: ra_tbl[3] = 0;
1.1.1.4 root 792:
1.1 root 793: switch (ra) {
794: case 0:
795: case 2:
796: case 3:
797: if (*bptr++ != ra_tbl[ra]) {
798: ra = 0;
799: continue;
800: }
801: break;
1.1.1.4 root 802:
1.1 root 803: case 1:
804: /*
805: * We may get 0x50 several times, ignore them
806: */
807: if (*bptr == 0x50) {
808: ra = 1;
809: bptr++;
810: continue;
811: } else if (*bptr++ != ra_tbl[ra]) {
812: ra = 0;
813: continue;
814: }
815: break;
1.1.1.4 root 816:
817: case 4:
818: /*
1.1 root 819: * skip version number
820: */
821: bptr++;
822: break;
1.1.1.4 root 823:
824: case 5:
1.1 root 825: /*
826: * The difference between versions 1.0 and
827: * 2.0 is here. For future versions of
828: * the player this may need to be modified.
829: */
830: if (*(bptr + 1) == 0x02)
831: bptr += 8;
832: else
833: bptr += 4;
1.1.1.4 root 834: break;
835:
1.1 root 836: case 6:
837: /* This is the field containing the port
838: * number that RA-player is listening to.
839: */
1.1.1.4 root 840: lport = (((u_char*)bptr)[0] << 8)
1.1 root 841: + ((u_char *)bptr)[1];
1.1.1.4 root 842: if (lport < 6970)
1.1 root 843: lport += 256; /* don't know why */
844: if (lport < 6970 || lport > 7170)
845: return 1; /* failed */
1.1.1.4 root 846:
1.1 root 847: /* try to get udp port between 6970 - 7170 */
848: for (p = 6970; p < 7071; p++) {
1.1.1.6 root 849: if (udp_listen(slirp, INADDR_ANY,
850: htons(p),
1.1 root 851: so->so_laddr.s_addr,
852: htons(lport),
853: SS_FACCEPTONCE)) {
854: break;
855: }
856: }
857: if (p == 7071)
858: p = 0;
859: *(u_char *)bptr++ = (p >> 8) & 0xff;
860: *(u_char *)bptr++ = p & 0xff;
1.1.1.4 root 861: ra = 0;
1.1 root 862: return 1; /* port redirected, we're done */
1.1.1.4 root 863: break;
864:
1.1 root 865: default:
1.1.1.4 root 866: ra = 0;
1.1 root 867: }
868: ra++;
869: }
1.1.1.4 root 870: return 1;
871:
1.1 root 872: default:
873: /* Ooops, not emulated, won't call tcp_emu again */
874: so->so_emu = 0;
875: return 1;
876: }
877: }
878:
879: /*
880: * Do misc. config of SLiRP while its running.
881: * Return 0 if this connections is to be closed, 1 otherwise,
882: * return 2 if this is a command-line connection
883: */
1.1.1.6 root 884: int tcp_ctl(struct socket *so)
1.1 root 885: {
1.1.1.6 root 886: Slirp *slirp = so->slirp;
887: struct sbuf *sb = &so->so_snd;
888: struct ex_list *ex_ptr;
889: int do_pty;
890:
891: DEBUG_CALL("tcp_ctl");
892: DEBUG_ARG("so = %lx", (long )so);
893:
894: if (so->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
895: /* Check if it's pty_exec */
896: for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
897: if (ex_ptr->ex_fport == so->so_fport &&
898: so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr) {
899: if (ex_ptr->ex_pty == 3) {
900: so->s = -1;
901: so->extra = (void *)ex_ptr->ex_exec;
902: return 1;
903: }
904: do_pty = ex_ptr->ex_pty;
905: DEBUG_MISC((dfd, " executing %s \n",ex_ptr->ex_exec));
906: return fork_exec(so, ex_ptr->ex_exec, do_pty);
907: }
908: }
909: }
910: sb->sb_cc =
911: snprintf(sb->sb_wptr, sb->sb_datalen - (sb->sb_wptr - sb->sb_data),
912: "Error: No application configured.\r\n");
913: sb->sb_wptr += sb->sb_cc;
914: return 0;
1.1 root 915: }
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / slirp