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