]>
Commit | Line | Data |
---|---|---|
f0cbd3ec FB |
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. | |
2f5f8996 | 13 | * 3. Neither the name of the University nor the names of its contributors |
f0cbd3ec FB |
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. | |
5fafdf24 TS |
36 | * |
37 | * Please read the file COPYRIGHT for the | |
f0cbd3ec FB |
38 | * terms and conditions of the copyright. |
39 | */ | |
40 | ||
f0cbd3ec FB |
41 | #include <slirp.h> |
42 | ||
43 | /* patchable/settable parameters for tcp */ | |
9634d903 BS |
44 | /* Don't do rfc1323 performance enhancements */ |
45 | #define TCP_DO_RFC1323 0 | |
f0cbd3ec FB |
46 | |
47 | /* | |
48 | * Tcp initialization | |
49 | */ | |
50 | void | |
511d2b14 | 51 | tcp_init(void) |
f0cbd3ec FB |
52 | { |
53 | tcp_iss = 1; /* wrong */ | |
54 | tcb.so_next = tcb.so_prev = &tcb; | |
f0cbd3ec FB |
55 | } |
56 | ||
57 | /* | |
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. | |
62 | */ | |
63 | /* struct tcpiphdr * */ | |
64 | void | |
511d2b14 | 65 | tcp_template(struct tcpcb *tp) |
f0cbd3ec FB |
66 | { |
67 | struct socket *so = tp->t_socket; | |
68 | register struct tcpiphdr *n = &tp->t_template; | |
69 | ||
429d0a3d | 70 | n->ti_mbuf = NULL; |
f0cbd3ec FB |
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; | |
5fafdf24 | 78 | |
f0cbd3ec FB |
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 | |
511d2b14 BS |
103 | tcp_respond(struct tcpcb *tp, struct tcpiphdr *ti, struct mbuf *m, |
104 | tcp_seq ack, tcp_seq seq, int flags) | |
f0cbd3ec FB |
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); | |
5fafdf24 | 116 | |
f0cbd3ec FB |
117 | if (tp) |
118 | win = sbspace(&tp->t_socket->so_rcv); | |
511d2b14 | 119 | if (m == NULL) { |
f0cbd3ec FB |
120 | if ((m = m_get()) == NULL) |
121 | return; | |
122 | #ifdef TCP_COMPAT_42 | |
123 | tlen = 1; | |
124 | #else | |
125 | tlen = 0; | |
126 | #endif | |
9634d903 | 127 | m->m_data += IF_MAXLINKHDR; |
f0cbd3ec FB |
128 | *mtod(m, struct tcpiphdr *) = *ti; |
129 | ti = mtod(m, struct tcpiphdr *); | |
130 | flags = TH_ACK; | |
131 | } else { | |
5fafdf24 | 132 | /* |
f0cbd3ec FB |
133 | * ti points into m so the next line is just making |
134 | * the mbuf point to ti | |
135 | */ | |
136 | m->m_data = (caddr_t)ti; | |
3b46e624 | 137 | |
f0cbd3ec FB |
138 | m->m_len = sizeof (struct tcpiphdr); |
139 | tlen = 0; | |
140 | #define xchg(a,b,type) { type t; t=a; a=b; b=t; } | |
141 | xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_int32_t); | |
142 | xchg(ti->ti_dport, ti->ti_sport, u_int16_t); | |
143 | #undef xchg | |
144 | } | |
145 | ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen)); | |
146 | tlen += sizeof (struct tcpiphdr); | |
147 | m->m_len = tlen; | |
148 | ||
511d2b14 | 149 | ti->ti_mbuf = NULL; |
f0cbd3ec FB |
150 | ti->ti_x1 = 0; |
151 | ti->ti_seq = htonl(seq); | |
152 | ti->ti_ack = htonl(ack); | |
153 | ti->ti_x2 = 0; | |
154 | ti->ti_off = sizeof (struct tcphdr) >> 2; | |
155 | ti->ti_flags = flags; | |
156 | if (tp) | |
157 | ti->ti_win = htons((u_int16_t) (win >> tp->rcv_scale)); | |
158 | else | |
159 | ti->ti_win = htons((u_int16_t)win); | |
160 | ti->ti_urp = 0; | |
161 | ti->ti_sum = 0; | |
162 | ti->ti_sum = cksum(m, tlen); | |
163 | ((struct ip *)ti)->ip_len = tlen; | |
164 | ||
5fafdf24 | 165 | if(flags & TH_RST) |
f0cbd3ec | 166 | ((struct ip *)ti)->ip_ttl = MAXTTL; |
5fafdf24 | 167 | else |
9634d903 | 168 | ((struct ip *)ti)->ip_ttl = IPDEFTTL; |
5fafdf24 | 169 | |
f0cbd3ec FB |
170 | (void) ip_output((struct socket *)0, m); |
171 | } | |
172 | ||
173 | /* | |
174 | * Create a new TCP control block, making an | |
175 | * empty reassembly queue and hooking it to the argument | |
176 | * protocol control block. | |
177 | */ | |
178 | struct tcpcb * | |
511d2b14 | 179 | tcp_newtcpcb(struct socket *so) |
f0cbd3ec FB |
180 | { |
181 | register struct tcpcb *tp; | |
5fafdf24 | 182 | |
f0cbd3ec FB |
183 | tp = (struct tcpcb *)malloc(sizeof(*tp)); |
184 | if (tp == NULL) | |
185 | return ((struct tcpcb *)0); | |
5fafdf24 | 186 | |
f0cbd3ec | 187 | memset((char *) tp, 0, sizeof(struct tcpcb)); |
429d0a3d | 188 | tp->seg_next = tp->seg_prev = (struct tcpiphdr*)tp; |
9634d903 | 189 | tp->t_maxseg = TCP_MSS; |
5fafdf24 | 190 | |
9634d903 | 191 | tp->t_flags = TCP_DO_RFC1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0; |
f0cbd3ec | 192 | tp->t_socket = so; |
5fafdf24 | 193 | |
f0cbd3ec FB |
194 | /* |
195 | * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no | |
196 | * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives | |
197 | * reasonable initial retransmit time. | |
198 | */ | |
199 | tp->t_srtt = TCPTV_SRTTBASE; | |
9634d903 | 200 | tp->t_rttvar = TCPTV_SRTTDFLT << 2; |
f0cbd3ec FB |
201 | tp->t_rttmin = TCPTV_MIN; |
202 | ||
5fafdf24 | 203 | TCPT_RANGESET(tp->t_rxtcur, |
f0cbd3ec FB |
204 | ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1, |
205 | TCPTV_MIN, TCPTV_REXMTMAX); | |
206 | ||
207 | tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT; | |
208 | tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT; | |
209 | tp->t_state = TCPS_CLOSED; | |
5fafdf24 | 210 | |
f0cbd3ec FB |
211 | so->so_tcpcb = tp; |
212 | ||
213 | return (tp); | |
214 | } | |
215 | ||
216 | /* | |
217 | * Drop a TCP connection, reporting | |
218 | * the specified error. If connection is synchronized, | |
219 | * then send a RST to peer. | |
220 | */ | |
5fafdf24 | 221 | struct tcpcb *tcp_drop(struct tcpcb *tp, int err) |
f0cbd3ec FB |
222 | { |
223 | /* tcp_drop(tp, errno) | |
224 | register struct tcpcb *tp; | |
225 | int errno; | |
226 | { | |
227 | */ | |
228 | ||
229 | DEBUG_CALL("tcp_drop"); | |
230 | DEBUG_ARG("tp = %lx", (long)tp); | |
231 | DEBUG_ARG("errno = %d", errno); | |
5fafdf24 | 232 | |
f0cbd3ec FB |
233 | if (TCPS_HAVERCVDSYN(tp->t_state)) { |
234 | tp->t_state = TCPS_CLOSED; | |
235 | (void) tcp_output(tp); | |
31a60e22 | 236 | STAT(tcpstat.tcps_drops++); |
f0cbd3ec | 237 | } else |
31a60e22 | 238 | STAT(tcpstat.tcps_conndrops++); |
f0cbd3ec FB |
239 | /* if (errno == ETIMEDOUT && tp->t_softerror) |
240 | * errno = tp->t_softerror; | |
241 | */ | |
242 | /* so->so_error = errno; */ | |
243 | return (tcp_close(tp)); | |
244 | } | |
245 | ||
246 | /* | |
247 | * Close a TCP control block: | |
248 | * discard all space held by the tcp | |
249 | * discard internet protocol block | |
250 | * wake up any sleepers | |
251 | */ | |
252 | struct tcpcb * | |
511d2b14 | 253 | tcp_close(struct tcpcb *tp) |
f0cbd3ec FB |
254 | { |
255 | register struct tcpiphdr *t; | |
256 | struct socket *so = tp->t_socket; | |
257 | register struct mbuf *m; | |
258 | ||
259 | DEBUG_CALL("tcp_close"); | |
260 | DEBUG_ARG("tp = %lx", (long )tp); | |
5fafdf24 | 261 | |
f0cbd3ec | 262 | /* free the reassembly queue, if any */ |
429d0a3d BS |
263 | t = tcpfrag_list_first(tp); |
264 | while (!tcpfrag_list_end(t, tp)) { | |
265 | t = tcpiphdr_next(t); | |
266 | m = tcpiphdr_prev(t)->ti_mbuf; | |
267 | remque(tcpiphdr2qlink(tcpiphdr_prev(t))); | |
f0cbd3ec FB |
268 | m_freem(m); |
269 | } | |
270 | /* It's static */ | |
271 | /* if (tp->t_template) | |
272 | * (void) m_free(dtom(tp->t_template)); | |
273 | */ | |
274 | /* free(tp, M_PCB); */ | |
275 | free(tp); | |
511d2b14 | 276 | so->so_tcpcb = NULL; |
f0cbd3ec FB |
277 | soisfdisconnected(so); |
278 | /* clobber input socket cache if we're closing the cached connection */ | |
279 | if (so == tcp_last_so) | |
280 | tcp_last_so = &tcb; | |
379ff53d | 281 | closesocket(so->s); |
f0cbd3ec FB |
282 | sbfree(&so->so_rcv); |
283 | sbfree(&so->so_snd); | |
284 | sofree(so); | |
31a60e22 | 285 | STAT(tcpstat.tcps_closed++); |
f0cbd3ec FB |
286 | return ((struct tcpcb *)0); |
287 | } | |
288 | ||
9634d903 | 289 | #ifdef notdef |
f0cbd3ec FB |
290 | void |
291 | tcp_drain() | |
292 | { | |
293 | /* XXX */ | |
294 | } | |
295 | ||
296 | /* | |
297 | * When a source quench is received, close congestion window | |
298 | * to one segment. We will gradually open it again as we proceed. | |
299 | */ | |
f0cbd3ec FB |
300 | void |
301 | tcp_quench(i, errno) | |
302 | ||
303 | int errno; | |
304 | { | |
305 | struct tcpcb *tp = intotcpcb(inp); | |
306 | ||
307 | if (tp) | |
308 | tp->snd_cwnd = tp->t_maxseg; | |
309 | } | |
310 | ||
311 | #endif /* notdef */ | |
312 | ||
313 | /* | |
314 | * TCP protocol interface to socket abstraction. | |
315 | */ | |
316 | ||
317 | /* | |
318 | * User issued close, and wish to trail through shutdown states: | |
319 | * if never received SYN, just forget it. If got a SYN from peer, | |
320 | * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN. | |
321 | * If already got a FIN from peer, then almost done; go to LAST_ACK | |
322 | * state. In all other cases, have already sent FIN to peer (e.g. | |
323 | * after PRU_SHUTDOWN), and just have to play tedious game waiting | |
324 | * for peer to send FIN or not respond to keep-alives, etc. | |
325 | * We can let the user exit from the close as soon as the FIN is acked. | |
326 | */ | |
327 | void | |
511d2b14 | 328 | tcp_sockclosed(struct tcpcb *tp) |
f0cbd3ec FB |
329 | { |
330 | ||
331 | DEBUG_CALL("tcp_sockclosed"); | |
332 | DEBUG_ARG("tp = %lx", (long)tp); | |
5fafdf24 | 333 | |
f0cbd3ec FB |
334 | switch (tp->t_state) { |
335 | ||
336 | case TCPS_CLOSED: | |
337 | case TCPS_LISTEN: | |
338 | case TCPS_SYN_SENT: | |
339 | tp->t_state = TCPS_CLOSED; | |
340 | tp = tcp_close(tp); | |
341 | break; | |
342 | ||
343 | case TCPS_SYN_RECEIVED: | |
344 | case TCPS_ESTABLISHED: | |
345 | tp->t_state = TCPS_FIN_WAIT_1; | |
346 | break; | |
347 | ||
348 | case TCPS_CLOSE_WAIT: | |
349 | tp->t_state = TCPS_LAST_ACK; | |
350 | break; | |
351 | } | |
352 | /* soisfdisconnecting(tp->t_socket); */ | |
353 | if (tp && tp->t_state >= TCPS_FIN_WAIT_2) | |
354 | soisfdisconnected(tp->t_socket); | |
355 | if (tp) | |
356 | tcp_output(tp); | |
357 | } | |
358 | ||
5fafdf24 | 359 | /* |
f0cbd3ec FB |
360 | * Connect to a host on the Internet |
361 | * Called by tcp_input | |
362 | * Only do a connect, the tcp fields will be set in tcp_input | |
363 | * return 0 if there's a result of the connect, | |
364 | * else return -1 means we're still connecting | |
365 | * The return value is almost always -1 since the socket is | |
5fafdf24 | 366 | * nonblocking. Connect returns after the SYN is sent, and does |
f0cbd3ec FB |
367 | * not wait for ACK+SYN. |
368 | */ | |
511d2b14 | 369 | int tcp_fconnect(struct socket *so) |
f0cbd3ec FB |
370 | { |
371 | int ret=0; | |
3b46e624 | 372 | |
f0cbd3ec FB |
373 | DEBUG_CALL("tcp_fconnect"); |
374 | DEBUG_ARG("so = %lx", (long )so); | |
375 | ||
376 | if( (ret=so->s=socket(AF_INET,SOCK_STREAM,0)) >= 0) { | |
377 | int opt, s=so->s; | |
378 | struct sockaddr_in addr; | |
379 | ||
380 | fd_nonblock(s); | |
381 | opt = 1; | |
382 | setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(opt )); | |
383 | opt = 1; | |
384 | setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(opt )); | |
3b46e624 | 385 | |
f0cbd3ec | 386 | addr.sin_family = AF_INET; |
a13a4126 | 387 | if ((so->so_faddr.s_addr & vnetwork_mask.s_addr) == vnetwork_addr.s_addr) { |
f0cbd3ec | 388 | /* It's an alias */ |
a13a4126 | 389 | if (so->so_faddr.s_addr == vnameserver_addr.s_addr) { |
f0cbd3ec | 390 | addr.sin_addr = dns_addr; |
a13a4126 | 391 | } else { |
f0cbd3ec | 392 | addr.sin_addr = loopback_addr; |
f0cbd3ec FB |
393 | } |
394 | } else | |
395 | addr.sin_addr = so->so_faddr; | |
396 | addr.sin_port = so->so_fport; | |
3b46e624 | 397 | |
f0cbd3ec | 398 | DEBUG_MISC((dfd, " connect()ing, addr.sin_port=%d, " |
5fafdf24 | 399 | "addr.sin_addr.s_addr=%.16s\n", |
f0cbd3ec FB |
400 | ntohs(addr.sin_port), inet_ntoa(addr.sin_addr))); |
401 | /* We don't care what port we get */ | |
402 | ret = connect(s,(struct sockaddr *)&addr,sizeof (addr)); | |
3b46e624 | 403 | |
f0cbd3ec FB |
404 | /* |
405 | * If it's not in progress, it failed, so we just return 0, | |
406 | * without clearing SS_NOFDREF | |
407 | */ | |
408 | soisfconnecting(so); | |
409 | } | |
410 | ||
411 | return(ret); | |
412 | } | |
413 | ||
414 | /* | |
415 | * Accept the socket and connect to the local-host | |
5fafdf24 | 416 | * |
f0cbd3ec FB |
417 | * We have a problem. The correct thing to do would be |
418 | * to first connect to the local-host, and only if the | |
419 | * connection is accepted, then do an accept() here. | |
5fafdf24 | 420 | * But, a) we need to know who's trying to connect |
f0cbd3ec FB |
421 | * to the socket to be able to SYN the local-host, and |
422 | * b) we are already connected to the foreign host by | |
423 | * the time it gets to accept(), so... We simply accept | |
424 | * here and SYN the local-host. | |
5fafdf24 | 425 | */ |
f0cbd3ec | 426 | void |
511d2b14 | 427 | tcp_connect(struct socket *inso) |
f0cbd3ec FB |
428 | { |
429 | struct socket *so; | |
430 | struct sockaddr_in addr; | |
b55266b5 | 431 | socklen_t addrlen = sizeof(struct sockaddr_in); |
f0cbd3ec FB |
432 | struct tcpcb *tp; |
433 | int s, opt; | |
434 | ||
435 | DEBUG_CALL("tcp_connect"); | |
436 | DEBUG_ARG("inso = %lx", (long)inso); | |
5fafdf24 | 437 | |
f0cbd3ec FB |
438 | /* |
439 | * If it's an SS_ACCEPTONCE socket, no need to socreate() | |
440 | * another socket, just use the accept() socket. | |
441 | */ | |
442 | if (inso->so_state & SS_FACCEPTONCE) { | |
443 | /* FACCEPTONCE already have a tcpcb */ | |
444 | so = inso; | |
445 | } else { | |
446 | if ((so = socreate()) == NULL) { | |
447 | /* If it failed, get rid of the pending connection */ | |
379ff53d | 448 | closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen)); |
f0cbd3ec FB |
449 | return; |
450 | } | |
451 | if (tcp_attach(so) < 0) { | |
452 | free(so); /* NOT sofree */ | |
453 | return; | |
454 | } | |
455 | so->so_laddr = inso->so_laddr; | |
456 | so->so_lport = inso->so_lport; | |
457 | } | |
5fafdf24 | 458 | |
f0cbd3ec FB |
459 | (void) tcp_mss(sototcpcb(so), 0); |
460 | ||
461 | if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) { | |
462 | tcp_close(sototcpcb(so)); /* This will sofree() as well */ | |
463 | return; | |
464 | } | |
465 | fd_nonblock(s); | |
466 | opt = 1; | |
467 | setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)); | |
468 | opt = 1; | |
469 | setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int)); | |
eaf7e70b TS |
470 | opt = 1; |
471 | setsockopt(s,IPPROTO_TCP,TCP_NODELAY,(char *)&opt,sizeof(int)); | |
5fafdf24 | 472 | |
f0cbd3ec FB |
473 | so->so_fport = addr.sin_port; |
474 | so->so_faddr = addr.sin_addr; | |
475 | /* Translate connections from localhost to the real hostname */ | |
476 | if (so->so_faddr.s_addr == 0 || so->so_faddr.s_addr == loopback_addr.s_addr) | |
a13a4126 | 477 | so->so_faddr = vhost_addr; |
5fafdf24 | 478 | |
f0cbd3ec FB |
479 | /* Close the accept() socket, set right state */ |
480 | if (inso->so_state & SS_FACCEPTONCE) { | |
379ff53d | 481 | closesocket(so->s); /* If we only accept once, close the accept() socket */ |
f0cbd3ec FB |
482 | so->so_state = SS_NOFDREF; /* Don't select it yet, even though we have an FD */ |
483 | /* if it's not FACCEPTONCE, it's already NOFDREF */ | |
484 | } | |
485 | so->s = s; | |
5fafdf24 | 486 | |
f0cbd3ec FB |
487 | so->so_iptos = tcp_tos(so); |
488 | tp = sototcpcb(so); | |
489 | ||
490 | tcp_template(tp); | |
5fafdf24 | 491 | |
f0cbd3ec FB |
492 | /* Compute window scaling to request. */ |
493 | /* while (tp->request_r_scale < TCP_MAX_WINSHIFT && | |
494 | * (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat) | |
495 | * tp->request_r_scale++; | |
496 | */ | |
497 | ||
498 | /* soisconnecting(so); */ /* NOFDREF used instead */ | |
31a60e22 | 499 | STAT(tcpstat.tcps_connattempt++); |
5fafdf24 | 500 | |
f0cbd3ec FB |
501 | tp->t_state = TCPS_SYN_SENT; |
502 | tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT; | |
5fafdf24 | 503 | tp->iss = tcp_iss; |
f0cbd3ec FB |
504 | tcp_iss += TCP_ISSINCR/2; |
505 | tcp_sendseqinit(tp); | |
506 | tcp_output(tp); | |
507 | } | |
508 | ||
509 | /* | |
510 | * Attach a TCPCB to a socket. | |
511 | */ | |
512 | int | |
511d2b14 | 513 | tcp_attach(struct socket *so) |
f0cbd3ec FB |
514 | { |
515 | if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) | |
516 | return -1; | |
5fafdf24 | 517 | |
f0cbd3ec FB |
518 | insque(so, &tcb); |
519 | ||
520 | return 0; | |
521 | } | |
522 | ||
523 | /* | |
524 | * Set the socket's type of service field | |
525 | */ | |
9634d903 | 526 | static const struct tos_t tcptos[] = { |
f0cbd3ec FB |
527 | {0, 20, IPTOS_THROUGHPUT, 0}, /* ftp data */ |
528 | {21, 21, IPTOS_LOWDELAY, EMU_FTP}, /* ftp control */ | |
529 | {0, 23, IPTOS_LOWDELAY, 0}, /* telnet */ | |
530 | {0, 80, IPTOS_THROUGHPUT, 0}, /* WWW */ | |
531 | {0, 513, IPTOS_LOWDELAY, EMU_RLOGIN|EMU_NOCONNECT}, /* rlogin */ | |
532 | {0, 514, IPTOS_LOWDELAY, EMU_RSH|EMU_NOCONNECT}, /* shell */ | |
533 | {0, 544, IPTOS_LOWDELAY, EMU_KSH}, /* kshell */ | |
534 | {0, 543, IPTOS_LOWDELAY, 0}, /* klogin */ | |
535 | {0, 6667, IPTOS_THROUGHPUT, EMU_IRC}, /* IRC */ | |
536 | {0, 6668, IPTOS_THROUGHPUT, EMU_IRC}, /* IRC undernet */ | |
537 | {0, 7070, IPTOS_LOWDELAY, EMU_REALAUDIO }, /* RealAudio control */ | |
538 | {0, 113, IPTOS_LOWDELAY, EMU_IDENT }, /* identd protocol */ | |
539 | {0, 0, 0, 0} | |
540 | }; | |
541 | ||
7c829863 BS |
542 | #ifdef CONFIG_QEMU |
543 | static | |
544 | #endif | |
511d2b14 | 545 | struct emu_t *tcpemu = NULL; |
3b46e624 | 546 | |
f0cbd3ec FB |
547 | /* |
548 | * Return TOS according to the above table | |
549 | */ | |
550 | u_int8_t | |
511d2b14 | 551 | tcp_tos(struct socket *so) |
f0cbd3ec FB |
552 | { |
553 | int i = 0; | |
554 | struct emu_t *emup; | |
5fafdf24 | 555 | |
f0cbd3ec FB |
556 | while(tcptos[i].tos) { |
557 | if ((tcptos[i].fport && (ntohs(so->so_fport) == tcptos[i].fport)) || | |
558 | (tcptos[i].lport && (ntohs(so->so_lport) == tcptos[i].lport))) { | |
559 | so->so_emu = tcptos[i].emu; | |
560 | return tcptos[i].tos; | |
561 | } | |
562 | i++; | |
563 | } | |
5fafdf24 | 564 | |
f0cbd3ec FB |
565 | /* Nope, lets see if there's a user-added one */ |
566 | for (emup = tcpemu; emup; emup = emup->next) { | |
567 | if ((emup->fport && (ntohs(so->so_fport) == emup->fport)) || | |
568 | (emup->lport && (ntohs(so->so_lport) == emup->lport))) { | |
569 | so->so_emu = emup->emu; | |
570 | return emup->tos; | |
571 | } | |
572 | } | |
5fafdf24 | 573 | |
f0cbd3ec FB |
574 | return 0; |
575 | } | |
576 | ||
7878ff6b | 577 | #if 0 |
f0cbd3ec | 578 | int do_echo = -1; |
7878ff6b | 579 | #endif |
f0cbd3ec FB |
580 | |
581 | /* | |
582 | * Emulate programs that try and connect to us | |
583 | * This includes ftp (the data connection is | |
584 | * initiated by the server) and IRC (DCC CHAT and | |
585 | * DCC SEND) for now | |
5fafdf24 | 586 | * |
f0cbd3ec FB |
587 | * NOTE: It's possible to crash SLiRP by sending it |
588 | * unstandard strings to emulate... if this is a problem, | |
589 | * more checks are needed here | |
590 | * | |
591 | * XXX Assumes the whole command came in one packet | |
3b46e624 | 592 | * |
f0cbd3ec FB |
593 | * XXX Some ftp clients will have their TOS set to |
594 | * LOWDELAY and so Nagel will kick in. Because of this, | |
595 | * we'll get the first letter, followed by the rest, so | |
596 | * we simply scan for ORT instead of PORT... | |
597 | * DCC doesn't have this problem because there's other stuff | |
598 | * in the packet before the DCC command. | |
5fafdf24 TS |
599 | * |
600 | * Return 1 if the mbuf m is still valid and should be | |
f0cbd3ec | 601 | * sbappend()ed |
5fafdf24 | 602 | * |
f0cbd3ec FB |
603 | * NOTE: if you return 0 you MUST m_free() the mbuf! |
604 | */ | |
605 | int | |
511d2b14 | 606 | tcp_emu(struct socket *so, struct mbuf *m) |
f0cbd3ec FB |
607 | { |
608 | u_int n1, n2, n3, n4, n5, n6; | |
363a37d5 | 609 | char buff[257]; |
f0cbd3ec FB |
610 | u_int32_t laddr; |
611 | u_int lport; | |
612 | char *bptr; | |
5fafdf24 | 613 | |
f0cbd3ec FB |
614 | DEBUG_CALL("tcp_emu"); |
615 | DEBUG_ARG("so = %lx", (long)so); | |
616 | DEBUG_ARG("m = %lx", (long)m); | |
5fafdf24 | 617 | |
f0cbd3ec FB |
618 | switch(so->so_emu) { |
619 | int x, i; | |
3b46e624 | 620 | |
f0cbd3ec FB |
621 | case EMU_IDENT: |
622 | /* | |
623 | * Identification protocol as per rfc-1413 | |
624 | */ | |
3b46e624 | 625 | |
f0cbd3ec FB |
626 | { |
627 | struct socket *tmpso; | |
628 | struct sockaddr_in addr; | |
b55266b5 | 629 | socklen_t addrlen = sizeof(struct sockaddr_in); |
f0cbd3ec | 630 | struct sbuf *so_rcv = &so->so_rcv; |
3b46e624 | 631 | |
f0cbd3ec FB |
632 | memcpy(so_rcv->sb_wptr, m->m_data, m->m_len); |
633 | so_rcv->sb_wptr += m->m_len; | |
634 | so_rcv->sb_rptr += m->m_len; | |
635 | m->m_data[m->m_len] = 0; /* NULL terminate */ | |
636 | if (strchr(m->m_data, '\r') || strchr(m->m_data, '\n')) { | |
9634d903 | 637 | if (sscanf(so_rcv->sb_data, "%u%*[ ,]%u", &n1, &n2) == 2) { |
f0cbd3ec FB |
638 | HTONS(n1); |
639 | HTONS(n2); | |
640 | /* n2 is the one on our host */ | |
641 | for (tmpso = tcb.so_next; tmpso != &tcb; tmpso = tmpso->so_next) { | |
642 | if (tmpso->so_laddr.s_addr == so->so_laddr.s_addr && | |
643 | tmpso->so_lport == n2 && | |
644 | tmpso->so_faddr.s_addr == so->so_faddr.s_addr && | |
645 | tmpso->so_fport == n1) { | |
646 | if (getsockname(tmpso->s, | |
647 | (struct sockaddr *)&addr, &addrlen) == 0) | |
648 | n2 = ntohs(addr.sin_port); | |
649 | break; | |
650 | } | |
651 | } | |
652 | } | |
363a37d5 BS |
653 | so_rcv->sb_cc = snprintf(so_rcv->sb_data, |
654 | so_rcv->sb_datalen, | |
655 | "%d,%d\r\n", n1, n2); | |
f0cbd3ec FB |
656 | so_rcv->sb_rptr = so_rcv->sb_data; |
657 | so_rcv->sb_wptr = so_rcv->sb_data + so_rcv->sb_cc; | |
658 | } | |
659 | m_free(m); | |
660 | return 0; | |
661 | } | |
3b46e624 | 662 | |
f0cbd3ec FB |
663 | #if 0 |
664 | case EMU_RLOGIN: | |
665 | /* | |
666 | * Rlogin emulation | |
667 | * First we accumulate all the initial option negotiation, | |
668 | * then fork_exec() rlogin according to the options | |
669 | */ | |
670 | { | |
671 | int i, i2, n; | |
672 | char *ptr; | |
673 | char args[100]; | |
674 | char term[100]; | |
675 | struct sbuf *so_snd = &so->so_snd; | |
676 | struct sbuf *so_rcv = &so->so_rcv; | |
3b46e624 | 677 | |
f0cbd3ec FB |
678 | /* First check if they have a priveladged port, or too much data has arrived */ |
679 | if (ntohs(so->so_lport) > 1023 || ntohs(so->so_lport) < 512 || | |
680 | (m->m_len + so_rcv->sb_wptr) > (so_rcv->sb_data + so_rcv->sb_datalen)) { | |
681 | memcpy(so_snd->sb_wptr, "Permission denied\n", 18); | |
682 | so_snd->sb_wptr += 18; | |
683 | so_snd->sb_cc += 18; | |
684 | tcp_sockclosed(sototcpcb(so)); | |
685 | m_free(m); | |
686 | return 0; | |
687 | } | |
3b46e624 | 688 | |
f0cbd3ec FB |
689 | /* Append the current data */ |
690 | memcpy(so_rcv->sb_wptr, m->m_data, m->m_len); | |
691 | so_rcv->sb_wptr += m->m_len; | |
692 | so_rcv->sb_rptr += m->m_len; | |
693 | m_free(m); | |
3b46e624 | 694 | |
f0cbd3ec FB |
695 | /* |
696 | * Check if we have all the initial options, | |
697 | * and build argument list to rlogin while we're here | |
698 | */ | |
699 | n = 0; | |
700 | ptr = so_rcv->sb_data; | |
701 | args[0] = 0; | |
702 | term[0] = 0; | |
703 | while (ptr < so_rcv->sb_wptr) { | |
704 | if (*ptr++ == 0) { | |
705 | n++; | |
706 | if (n == 2) { | |
707 | sprintf(args, "rlogin -l %s %s", | |
708 | ptr, inet_ntoa(so->so_faddr)); | |
709 | } else if (n == 3) { | |
710 | i2 = so_rcv->sb_wptr - ptr; | |
711 | for (i = 0; i < i2; i++) { | |
712 | if (ptr[i] == '/') { | |
713 | ptr[i] = 0; | |
714 | #ifdef HAVE_SETENV | |
715 | sprintf(term, "%s", ptr); | |
716 | #else | |
717 | sprintf(term, "TERM=%s", ptr); | |
718 | #endif | |
719 | ptr[i] = '/'; | |
720 | break; | |
721 | } | |
722 | } | |
723 | } | |
724 | } | |
725 | } | |
3b46e624 | 726 | |
f0cbd3ec FB |
727 | if (n != 4) |
728 | return 0; | |
3b46e624 | 729 | |
f0cbd3ec FB |
730 | /* We have it, set our term variable and fork_exec() */ |
731 | #ifdef HAVE_SETENV | |
732 | setenv("TERM", term, 1); | |
733 | #else | |
734 | putenv(term); | |
735 | #endif | |
736 | fork_exec(so, args, 2); | |
737 | term[0] = 0; | |
738 | so->so_emu = 0; | |
3b46e624 | 739 | |
f0cbd3ec FB |
740 | /* And finally, send the client a 0 character */ |
741 | so_snd->sb_wptr[0] = 0; | |
742 | so_snd->sb_wptr++; | |
743 | so_snd->sb_cc++; | |
3b46e624 | 744 | |
f0cbd3ec FB |
745 | return 0; |
746 | } | |
3b46e624 | 747 | |
f0cbd3ec FB |
748 | case EMU_RSH: |
749 | /* | |
750 | * rsh emulation | |
751 | * First we accumulate all the initial option negotiation, | |
752 | * then rsh_exec() rsh according to the options | |
753 | */ | |
754 | { | |
755 | int n; | |
756 | char *ptr; | |
757 | char *user; | |
758 | char *args; | |
759 | struct sbuf *so_snd = &so->so_snd; | |
760 | struct sbuf *so_rcv = &so->so_rcv; | |
3b46e624 | 761 | |
f0cbd3ec FB |
762 | /* First check if they have a priveladged port, or too much data has arrived */ |
763 | if (ntohs(so->so_lport) > 1023 || ntohs(so->so_lport) < 512 || | |
764 | (m->m_len + so_rcv->sb_wptr) > (so_rcv->sb_data + so_rcv->sb_datalen)) { | |
765 | memcpy(so_snd->sb_wptr, "Permission denied\n", 18); | |
766 | so_snd->sb_wptr += 18; | |
767 | so_snd->sb_cc += 18; | |
768 | tcp_sockclosed(sototcpcb(so)); | |
769 | m_free(m); | |
770 | return 0; | |
771 | } | |
3b46e624 | 772 | |
f0cbd3ec FB |
773 | /* Append the current data */ |
774 | memcpy(so_rcv->sb_wptr, m->m_data, m->m_len); | |
775 | so_rcv->sb_wptr += m->m_len; | |
776 | so_rcv->sb_rptr += m->m_len; | |
777 | m_free(m); | |
3b46e624 | 778 | |
f0cbd3ec FB |
779 | /* |
780 | * Check if we have all the initial options, | |
781 | * and build argument list to rlogin while we're here | |
782 | */ | |
783 | n = 0; | |
784 | ptr = so_rcv->sb_data; | |
785 | user=""; | |
786 | args=""; | |
787 | if (so->extra==NULL) { | |
788 | struct socket *ns; | |
789 | struct tcpcb* tp; | |
790 | int port=atoi(ptr); | |
791 | if (port <= 0) return 0; | |
792 | if (port > 1023 || port < 512) { | |
793 | memcpy(so_snd->sb_wptr, "Permission denied\n", 18); | |
794 | so_snd->sb_wptr += 18; | |
795 | so_snd->sb_cc += 18; | |
796 | tcp_sockclosed(sototcpcb(so)); | |
797 | return 0; | |
798 | } | |
799 | if ((ns=socreate()) == NULL) | |
800 | return 0; | |
801 | if (tcp_attach(ns)<0) { | |
802 | free(ns); | |
803 | return 0; | |
804 | } | |
805 | ||
806 | ns->so_laddr=so->so_laddr; | |
807 | ns->so_lport=htons(port); | |
808 | ||
809 | (void) tcp_mss(sototcpcb(ns), 0); | |
810 | ||
811 | ns->so_faddr=so->so_faddr; | |
812 | ns->so_fport=htons(IPPORT_RESERVED-1); /* Use a fake port. */ | |
813 | ||
5fafdf24 | 814 | if (ns->so_faddr.s_addr == 0 || |
f0cbd3ec | 815 | ns->so_faddr.s_addr == loopback_addr.s_addr) |
8dbca8dd | 816 | ns->so_faddr = alias_addr; |
f0cbd3ec FB |
817 | |
818 | ns->so_iptos = tcp_tos(ns); | |
819 | tp = sototcpcb(ns); | |
3b46e624 | 820 | |
f0cbd3ec | 821 | tcp_template(tp); |
3b46e624 | 822 | |
f0cbd3ec FB |
823 | /* Compute window scaling to request. */ |
824 | /* while (tp->request_r_scale < TCP_MAX_WINSHIFT && | |
825 | * (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat) | |
826 | * tp->request_r_scale++; | |
827 | */ | |
828 | ||
829 | /*soisfconnecting(ns);*/ | |
830 | ||
31a60e22 | 831 | STAT(tcpstat.tcps_connattempt++); |
3b46e624 | 832 | |
f0cbd3ec FB |
833 | tp->t_state = TCPS_SYN_SENT; |
834 | tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT; | |
5fafdf24 | 835 | tp->iss = tcp_iss; |
f0cbd3ec FB |
836 | tcp_iss += TCP_ISSINCR/2; |
837 | tcp_sendseqinit(tp); | |
838 | tcp_output(tp); | |
839 | so->extra=ns; | |
840 | } | |
841 | while (ptr < so_rcv->sb_wptr) { | |
842 | if (*ptr++ == 0) { | |
843 | n++; | |
844 | if (n == 2) { | |
845 | user=ptr; | |
846 | } else if (n == 3) { | |
847 | args=ptr; | |
848 | } | |
849 | } | |
850 | } | |
3b46e624 | 851 | |
f0cbd3ec FB |
852 | if (n != 4) |
853 | return 0; | |
3b46e624 | 854 | |
f0cbd3ec FB |
855 | rsh_exec(so,so->extra, user, inet_ntoa(so->so_faddr), args); |
856 | so->so_emu = 0; | |
857 | so->extra=NULL; | |
3b46e624 | 858 | |
f0cbd3ec FB |
859 | /* And finally, send the client a 0 character */ |
860 | so_snd->sb_wptr[0] = 0; | |
861 | so_snd->sb_wptr++; | |
862 | so_snd->sb_cc++; | |
3b46e624 | 863 | |
f0cbd3ec FB |
864 | return 0; |
865 | } | |
866 | ||
867 | case EMU_CTL: | |
868 | { | |
869 | int num; | |
870 | struct sbuf *so_snd = &so->so_snd; | |
871 | struct sbuf *so_rcv = &so->so_rcv; | |
3b46e624 | 872 | |
f0cbd3ec FB |
873 | /* |
874 | * If there is binary data here, we save it in so->so_m | |
875 | */ | |
876 | if (!so->so_m) { | |
877 | int rxlen; | |
878 | char *rxdata; | |
879 | rxdata=mtod(m, char *); | |
880 | for (rxlen=m->m_len; rxlen; rxlen--) { | |
881 | if (*rxdata++ & 0x80) { | |
882 | so->so_m = m; | |
883 | return 0; | |
884 | } | |
885 | } | |
886 | } /* if(so->so_m==NULL) */ | |
3b46e624 | 887 | |
f0cbd3ec FB |
888 | /* |
889 | * Append the line | |
890 | */ | |
891 | sbappendsb(so_rcv, m); | |
3b46e624 | 892 | |
f0cbd3ec FB |
893 | /* To avoid going over the edge of the buffer, we reset it */ |
894 | if (so_snd->sb_cc == 0) | |
895 | so_snd->sb_wptr = so_snd->sb_rptr = so_snd->sb_data; | |
3b46e624 | 896 | |
f0cbd3ec FB |
897 | /* |
898 | * A bit of a hack: | |
899 | * If the first packet we get here is 1 byte long, then it | |
900 | * was done in telnet character mode, therefore we must echo | |
901 | * the characters as they come. Otherwise, we echo nothing, | |
902 | * because in linemode, the line is already echoed | |
903 | * XXX two or more control connections won't work | |
904 | */ | |
905 | if (do_echo == -1) { | |
906 | if (m->m_len == 1) do_echo = 1; | |
907 | else do_echo = 0; | |
908 | } | |
909 | if (do_echo) { | |
910 | sbappendsb(so_snd, m); | |
911 | m_free(m); | |
912 | tcp_output(sototcpcb(so)); /* XXX */ | |
913 | } else | |
914 | m_free(m); | |
3b46e624 | 915 | |
f0cbd3ec FB |
916 | num = 0; |
917 | while (num < so->so_rcv.sb_cc) { | |
918 | if (*(so->so_rcv.sb_rptr + num) == '\n' || | |
919 | *(so->so_rcv.sb_rptr + num) == '\r') { | |
920 | int n; | |
3b46e624 | 921 | |
f0cbd3ec FB |
922 | *(so_rcv->sb_rptr + num) = 0; |
923 | if (ctl_password && !ctl_password_ok) { | |
924 | /* Need a password */ | |
925 | if (sscanf(so_rcv->sb_rptr, "pass %256s", buff) == 1) { | |
926 | if (strcmp(buff, ctl_password) == 0) { | |
927 | ctl_password_ok = 1; | |
928 | n = sprintf(so_snd->sb_wptr, | |
929 | "Password OK.\r\n"); | |
930 | goto do_prompt; | |
931 | } | |
932 | } | |
933 | n = sprintf(so_snd->sb_wptr, | |
934 | "Error: Password required, log on with \"pass PASSWORD\"\r\n"); | |
935 | goto do_prompt; | |
936 | } | |
937 | cfg_quitting = 0; | |
938 | n = do_config(so_rcv->sb_rptr, so, PRN_SPRINTF); | |
939 | if (!cfg_quitting) { | |
940 | /* Register the printed data */ | |
941 | do_prompt: | |
942 | so_snd->sb_cc += n; | |
943 | so_snd->sb_wptr += n; | |
944 | /* Add prompt */ | |
945 | n = sprintf(so_snd->sb_wptr, "Slirp> "); | |
946 | so_snd->sb_cc += n; | |
947 | so_snd->sb_wptr += n; | |
948 | } | |
949 | /* Drop so_rcv data */ | |
950 | so_rcv->sb_cc = 0; | |
951 | so_rcv->sb_wptr = so_rcv->sb_rptr = so_rcv->sb_data; | |
952 | tcp_output(sototcpcb(so)); /* Send the reply */ | |
953 | } | |
954 | num++; | |
955 | } | |
956 | return 0; | |
957 | } | |
3b46e624 | 958 | #endif |
f0cbd3ec | 959 | case EMU_FTP: /* ftp */ |
511d2b14 | 960 | *(m->m_data+m->m_len) = 0; /* NUL terminate for strstr */ |
f0cbd3ec FB |
961 | if ((bptr = (char *)strstr(m->m_data, "ORT")) != NULL) { |
962 | /* | |
963 | * Need to emulate the PORT command | |
3b46e624 | 964 | */ |
9634d903 | 965 | x = sscanf(bptr, "ORT %u,%u,%u,%u,%u,%u\r\n%256[^\177]", |
f0cbd3ec FB |
966 | &n1, &n2, &n3, &n4, &n5, &n6, buff); |
967 | if (x < 6) | |
968 | return 1; | |
3b46e624 | 969 | |
f0cbd3ec FB |
970 | laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4)); |
971 | lport = htons((n5 << 8) | (n6)); | |
3b46e624 | 972 | |
3c6a0580 | 973 | if ((so = tcp_listen(INADDR_ANY, 0, laddr, lport, SS_FACCEPTONCE)) == NULL) |
f0cbd3ec | 974 | return 1; |
3b46e624 | 975 | |
f0cbd3ec | 976 | n6 = ntohs(so->so_fport); |
3b46e624 | 977 | |
f0cbd3ec FB |
978 | n5 = (n6 >> 8) & 0xff; |
979 | n6 &= 0xff; | |
3b46e624 | 980 | |
f0cbd3ec | 981 | laddr = ntohl(so->so_faddr.s_addr); |
3b46e624 | 982 | |
f0cbd3ec FB |
983 | n1 = ((laddr >> 24) & 0xff); |
984 | n2 = ((laddr >> 16) & 0xff); | |
985 | n3 = ((laddr >> 8) & 0xff); | |
986 | n4 = (laddr & 0xff); | |
3b46e624 | 987 | |
f0cbd3ec | 988 | m->m_len = bptr - m->m_data; /* Adjust length */ |
363a37d5 BS |
989 | m->m_len += snprintf(bptr, m->m_hdr.mh_size - m->m_len, |
990 | "ORT %d,%d,%d,%d,%d,%d\r\n%s", | |
991 | n1, n2, n3, n4, n5, n6, x==7?buff:""); | |
f0cbd3ec FB |
992 | return 1; |
993 | } else if ((bptr = (char *)strstr(m->m_data, "27 Entering")) != NULL) { | |
994 | /* | |
995 | * Need to emulate the PASV response | |
996 | */ | |
9634d903 | 997 | x = sscanf(bptr, "27 Entering Passive Mode (%u,%u,%u,%u,%u,%u)\r\n%256[^\177]", |
f0cbd3ec FB |
998 | &n1, &n2, &n3, &n4, &n5, &n6, buff); |
999 | if (x < 6) | |
1000 | return 1; | |
3b46e624 | 1001 | |
f0cbd3ec FB |
1002 | laddr = htonl((n1 << 24) | (n2 << 16) | (n3 << 8) | (n4)); |
1003 | lport = htons((n5 << 8) | (n6)); | |
3b46e624 | 1004 | |
3c6a0580 | 1005 | if ((so = tcp_listen(INADDR_ANY, 0, laddr, lport, SS_FACCEPTONCE)) == NULL) |
f0cbd3ec | 1006 | return 1; |
3b46e624 | 1007 | |
f0cbd3ec | 1008 | n6 = ntohs(so->so_fport); |
3b46e624 | 1009 | |
f0cbd3ec FB |
1010 | n5 = (n6 >> 8) & 0xff; |
1011 | n6 &= 0xff; | |
3b46e624 | 1012 | |
f0cbd3ec | 1013 | laddr = ntohl(so->so_faddr.s_addr); |
3b46e624 | 1014 | |
f0cbd3ec FB |
1015 | n1 = ((laddr >> 24) & 0xff); |
1016 | n2 = ((laddr >> 16) & 0xff); | |
1017 | n3 = ((laddr >> 8) & 0xff); | |
1018 | n4 = (laddr & 0xff); | |
3b46e624 | 1019 | |
f0cbd3ec | 1020 | m->m_len = bptr - m->m_data; /* Adjust length */ |
363a37d5 BS |
1021 | m->m_len += snprintf(bptr, m->m_hdr.mh_size - m->m_len, |
1022 | "27 Entering Passive Mode (%d,%d,%d,%d,%d,%d)\r\n%s", | |
1023 | n1, n2, n3, n4, n5, n6, x==7?buff:""); | |
3b46e624 | 1024 | |
f0cbd3ec FB |
1025 | return 1; |
1026 | } | |
3b46e624 | 1027 | |
f0cbd3ec | 1028 | return 1; |
3b46e624 | 1029 | |
f0cbd3ec FB |
1030 | case EMU_KSH: |
1031 | /* | |
1032 | * The kshell (Kerberos rsh) and shell services both pass | |
1033 | * a local port port number to carry signals to the server | |
1034 | * and stderr to the client. It is passed at the beginning | |
1035 | * of the connection as a NUL-terminated decimal ASCII string. | |
1036 | */ | |
1037 | so->so_emu = 0; | |
1038 | for (lport = 0, i = 0; i < m->m_len-1; ++i) { | |
1039 | if (m->m_data[i] < '0' || m->m_data[i] > '9') | |
1040 | return 1; /* invalid number */ | |
1041 | lport *= 10; | |
1042 | lport += m->m_data[i] - '0'; | |
1043 | } | |
1044 | if (m->m_data[m->m_len-1] == '\0' && lport != 0 && | |
3c6a0580 | 1045 | (so = tcp_listen(INADDR_ANY, 0, so->so_laddr.s_addr, htons(lport), SS_FACCEPTONCE)) != NULL) |
363a37d5 BS |
1046 | m->m_len = snprintf(m->m_data, m->m_hdr.mh_size, "%d", |
1047 | ntohs(so->so_fport)) + 1; | |
f0cbd3ec | 1048 | return 1; |
3b46e624 | 1049 | |
f0cbd3ec FB |
1050 | case EMU_IRC: |
1051 | /* | |
1052 | * Need to emulate DCC CHAT, DCC SEND and DCC MOVE | |
1053 | */ | |
1054 | *(m->m_data+m->m_len) = 0; /* NULL terminate the string for strstr */ | |
1055 | if ((bptr = (char *)strstr(m->m_data, "DCC")) == NULL) | |
1056 | return 1; | |
3b46e624 | 1057 | |
f0cbd3ec FB |
1058 | /* The %256s is for the broken mIRC */ |
1059 | if (sscanf(bptr, "DCC CHAT %256s %u %u", buff, &laddr, &lport) == 3) { | |
3c6a0580 | 1060 | if ((so = tcp_listen(INADDR_ANY, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL) |
f0cbd3ec | 1061 | return 1; |
3b46e624 | 1062 | |
f0cbd3ec | 1063 | m->m_len = bptr - m->m_data; /* Adjust length */ |
363a37d5 BS |
1064 | m->m_len += snprintf(bptr, m->m_hdr.mh_size, |
1065 | "DCC CHAT chat %lu %u%c\n", | |
1066 | (unsigned long)ntohl(so->so_faddr.s_addr), | |
1067 | ntohs(so->so_fport), 1); | |
f0cbd3ec | 1068 | } else if (sscanf(bptr, "DCC SEND %256s %u %u %u", buff, &laddr, &lport, &n1) == 4) { |
3c6a0580 | 1069 | if ((so = tcp_listen(INADDR_ANY, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL) |
f0cbd3ec | 1070 | return 1; |
3b46e624 | 1071 | |
f0cbd3ec | 1072 | m->m_len = bptr - m->m_data; /* Adjust length */ |
363a37d5 BS |
1073 | m->m_len += snprintf(bptr, m->m_hdr.mh_size, |
1074 | "DCC SEND %s %lu %u %u%c\n", buff, | |
1075 | (unsigned long)ntohl(so->so_faddr.s_addr), | |
1076 | ntohs(so->so_fport), n1, 1); | |
f0cbd3ec | 1077 | } else if (sscanf(bptr, "DCC MOVE %256s %u %u %u", buff, &laddr, &lport, &n1) == 4) { |
3c6a0580 | 1078 | if ((so = tcp_listen(INADDR_ANY, 0, htonl(laddr), htons(lport), SS_FACCEPTONCE)) == NULL) |
f0cbd3ec | 1079 | return 1; |
3b46e624 | 1080 | |
f0cbd3ec | 1081 | m->m_len = bptr - m->m_data; /* Adjust length */ |
363a37d5 BS |
1082 | m->m_len += snprintf(bptr, m->m_hdr.mh_size, |
1083 | "DCC MOVE %s %lu %u %u%c\n", buff, | |
1084 | (unsigned long)ntohl(so->so_faddr.s_addr), | |
1085 | ntohs(so->so_fport), n1, 1); | |
f0cbd3ec FB |
1086 | } |
1087 | return 1; | |
1088 | ||
1089 | case EMU_REALAUDIO: | |
5fafdf24 | 1090 | /* |
f0cbd3ec FB |
1091 | * RealAudio emulation - JP. We must try to parse the incoming |
1092 | * data and try to find the two characters that contain the | |
1093 | * port number. Then we redirect an udp port and replace the | |
1094 | * number with the real port we got. | |
1095 | * | |
1096 | * The 1.0 beta versions of the player are not supported | |
1097 | * any more. | |
5fafdf24 | 1098 | * |
f0cbd3ec | 1099 | * A typical packet for player version 1.0 (release version): |
3b46e624 | 1100 | * |
5fafdf24 | 1101 | * 0000:50 4E 41 00 05 |
f0cbd3ec FB |
1102 |