]>
Commit | Line | Data |
---|---|---|
f0cbd3ec FB |
1 | /* |
2 | * Copyright (c) 1995 Danny Gasparovski. | |
5fafdf24 TS |
3 | * |
4 | * Please read the file COPYRIGHT for the | |
f0cbd3ec FB |
5 | * terms and conditions of the copyright. |
6 | */ | |
7 | ||
7df7482b | 8 | #include "qemu/osdep.h" |
e1c5a2b3 | 9 | #include "qemu-common.h" |
a9c94277 | 10 | #include "slirp.h" |
f0cbd3ec | 11 | #include "ip_icmp.h" |
ec530c81 FB |
12 | #ifdef __sun__ |
13 | #include <sys/filio.h> | |
14 | #endif | |
f0cbd3ec | 15 | |
9634d903 BS |
16 | static void sofcantrcvmore(struct socket *so); |
17 | static void sofcantsendmore(struct socket *so); | |
18 | ||
8a87f121 GS |
19 | struct socket *solookup(struct socket **last, struct socket *head, |
20 | struct sockaddr_storage *lhost, struct sockaddr_storage *fhost) | |
f0cbd3ec | 21 | { |
a5fd24aa | 22 | struct socket *so = *last; |
5fafdf24 | 23 | |
a5fd24aa | 24 | /* Optimisation */ |
8a87f121 GS |
25 | if (so != head && sockaddr_equal(&(so->lhost.ss), lhost) |
26 | && (!fhost || sockaddr_equal(&so->fhost.ss, fhost))) { | |
a5fd24aa GS |
27 | return so; |
28 | } | |
5fafdf24 | 29 | |
a5fd24aa | 30 | for (so = head->so_next; so != head; so = so->so_next) { |
8a87f121 GS |
31 | if (sockaddr_equal(&(so->lhost.ss), lhost) |
32 | && (!fhost || sockaddr_equal(&so->fhost.ss, fhost))) { | |
a5fd24aa GS |
33 | *last = so; |
34 | return so; | |
35 | } | |
36 | } | |
5fafdf24 | 37 | |
a5fd24aa | 38 | return (struct socket *)NULL; |
f0cbd3ec FB |
39 | } |
40 | ||
41 | /* | |
42 | * Create a new socket, initialise the fields | |
43 | * It is the responsibility of the caller to | |
44 | * insque() it into the correct linked-list | |
45 | */ | |
46 | struct socket * | |
460fec67 | 47 | socreate(Slirp *slirp) |
f0cbd3ec FB |
48 | { |
49 | struct socket *so; | |
5fafdf24 | 50 | |
f0cbd3ec FB |
51 | so = (struct socket *)malloc(sizeof(struct socket)); |
52 | if(so) { | |
53 | memset(so, 0, sizeof(struct socket)); | |
54 | so->so_state = SS_NOFDREF; | |
55 | so->s = -1; | |
460fec67 | 56 | so->slirp = slirp; |
7bd43ec2 | 57 | so->pollfds_idx = -1; |
f0cbd3ec FB |
58 | } |
59 | return(so); | |
60 | } | |
61 | ||
62 | /* | |
63 | * remque and free a socket, clobber cache | |
64 | */ | |
65 | void | |
511d2b14 | 66 | sofree(struct socket *so) |
f0cbd3ec | 67 | { |
460fec67 | 68 | Slirp *slirp = so->slirp; |
ea64d5f0 ST |
69 | struct mbuf *ifm; |
70 | ||
71 | for (ifm = (struct mbuf *) slirp->if_fastq.qh_link; | |
72 | (struct quehead *) ifm != &slirp->if_fastq; | |
73 | ifm = ifm->ifq_next) { | |
74 | if (ifm->ifq_so == so) { | |
75 | ifm->ifq_so = NULL; | |
76 | } | |
77 | } | |
78 | ||
79 | for (ifm = (struct mbuf *) slirp->if_batchq.qh_link; | |
80 | (struct quehead *) ifm != &slirp->if_batchq; | |
81 | ifm = ifm->ifq_next) { | |
82 | if (ifm->ifq_so == so) { | |
83 | ifm->ifq_so = NULL; | |
84 | } | |
85 | } | |
460fec67 | 86 | |
f0cbd3ec FB |
87 | if (so->so_emu==EMU_RSH && so->extra) { |
88 | sofree(so->extra); | |
89 | so->extra=NULL; | |
90 | } | |
460fec67 JK |
91 | if (so == slirp->tcp_last_so) { |
92 | slirp->tcp_last_so = &slirp->tcb; | |
93 | } else if (so == slirp->udp_last_so) { | |
94 | slirp->udp_last_so = &slirp->udb; | |
e6d43cfb JK |
95 | } else if (so == slirp->icmp_last_so) { |
96 | slirp->icmp_last_so = &slirp->icmp; | |
460fec67 | 97 | } |
f0cbd3ec | 98 | m_free(so->so_m); |
5fafdf24 TS |
99 | |
100 | if(so->so_next && so->so_prev) | |
f0cbd3ec FB |
101 | remque(so); /* crashes if so is not in a queue */ |
102 | ||
7d824696 MAL |
103 | if (so->so_tcpcb) { |
104 | free(so->so_tcpcb); | |
105 | } | |
f0cbd3ec FB |
106 | free(so); |
107 | } | |
108 | ||
e1c5a2b3 | 109 | size_t sopreprbuf(struct socket *so, struct iovec *iov, int *np) |
f0cbd3ec | 110 | { |
e1c5a2b3 | 111 | int n, lss, total; |
f0cbd3ec FB |
112 | struct sbuf *sb = &so->so_snd; |
113 | int len = sb->sb_datalen - sb->sb_cc; | |
f0cbd3ec | 114 | int mss = so->so_tcpcb->t_maxseg; |
5fafdf24 | 115 | |
e1c5a2b3 | 116 | DEBUG_CALL("sopreprbuf"); |
ecc804ca | 117 | DEBUG_ARG("so = %p", so); |
5fafdf24 | 118 | |
e1c5a2b3 AL |
119 | if (len <= 0) |
120 | return 0; | |
121 | ||
f0cbd3ec | 122 | iov[0].iov_base = sb->sb_wptr; |
66029f6a BS |
123 | iov[1].iov_base = NULL; |
124 | iov[1].iov_len = 0; | |
f0cbd3ec FB |
125 | if (sb->sb_wptr < sb->sb_rptr) { |
126 | iov[0].iov_len = sb->sb_rptr - sb->sb_wptr; | |
127 | /* Should never succeed, but... */ | |
128 | if (iov[0].iov_len > len) | |
129 | iov[0].iov_len = len; | |
130 | if (iov[0].iov_len > mss) | |
131 | iov[0].iov_len -= iov[0].iov_len%mss; | |
132 | n = 1; | |
133 | } else { | |
134 | iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_wptr; | |
135 | /* Should never succeed, but... */ | |
136 | if (iov[0].iov_len > len) iov[0].iov_len = len; | |
137 | len -= iov[0].iov_len; | |
138 | if (len) { | |
139 | iov[1].iov_base = sb->sb_data; | |
140 | iov[1].iov_len = sb->sb_rptr - sb->sb_data; | |
141 | if(iov[1].iov_len > len) | |
142 | iov[1].iov_len = len; | |
143 | total = iov[0].iov_len + iov[1].iov_len; | |
144 | if (total > mss) { | |
145 | lss = total%mss; | |
146 | if (iov[1].iov_len > lss) { | |
147 | iov[1].iov_len -= lss; | |
148 | n = 2; | |
149 | } else { | |
150 | lss -= iov[1].iov_len; | |
151 | iov[0].iov_len -= lss; | |
152 | n = 1; | |
153 | } | |
154 | } else | |
155 | n = 2; | |
156 | } else { | |
157 | if (iov[0].iov_len > mss) | |
158 | iov[0].iov_len -= iov[0].iov_len%mss; | |
159 | n = 1; | |
160 | } | |
161 | } | |
e1c5a2b3 AL |
162 | if (np) |
163 | *np = n; | |
164 | ||
165 | return iov[0].iov_len + (n - 1) * iov[1].iov_len; | |
166 | } | |
167 | ||
168 | /* | |
169 | * Read from so's socket into sb_snd, updating all relevant sbuf fields | |
170 | * NOTE: This will only be called if it is select()ed for reading, so | |
171 | * a read() of 0 (or less) means it's disconnected | |
172 | */ | |
173 | int | |
511d2b14 | 174 | soread(struct socket *so) |
e1c5a2b3 AL |
175 | { |
176 | int n, nn; | |
177 | struct sbuf *sb = &so->so_snd; | |
178 | struct iovec iov[2]; | |
179 | ||
180 | DEBUG_CALL("soread"); | |
ecc804ca | 181 | DEBUG_ARG("so = %p", so); |
e1c5a2b3 AL |
182 | |
183 | /* | |
184 | * No need to check if there's enough room to read. | |
185 | * soread wouldn't have been called if there weren't | |
186 | */ | |
187 | sopreprbuf(so, iov, &n); | |
5fafdf24 | 188 | |
f0cbd3ec FB |
189 | #ifdef HAVE_READV |
190 | nn = readv(so->s, (struct iovec *)iov, n); | |
191 | DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn)); | |
192 | #else | |
00aa0040 | 193 | nn = qemu_recv(so->s, iov[0].iov_base, iov[0].iov_len,0); |
5fafdf24 | 194 | #endif |
f0cbd3ec FB |
195 | if (nn <= 0) { |
196 | if (nn < 0 && (errno == EINTR || errno == EAGAIN)) | |
197 | return 0; | |
198 | else { | |
27d92ebc EI |
199 | int err; |
200 | socklen_t slen = sizeof err; | |
201 | ||
202 | err = errno; | |
203 | if (nn == 0) { | |
204 | getsockopt(so->s, SOL_SOCKET, SO_ERROR, | |
205 | &err, &slen); | |
206 | } | |
207 | ||
f0cbd3ec FB |
208 | DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno))); |
209 | sofcantrcvmore(so); | |
27d92ebc | 210 | |
6625d83a | 211 | if (err == ECONNRESET || err == ECONNREFUSED |
27d92ebc EI |
212 | || err == ENOTCONN || err == EPIPE) { |
213 | tcp_drop(sototcpcb(so), err); | |
214 | } else { | |
215 | tcp_sockclosed(sototcpcb(so)); | |
216 | } | |
f0cbd3ec FB |
217 | return -1; |
218 | } | |
219 | } | |
5fafdf24 | 220 | |
f0cbd3ec FB |
221 | #ifndef HAVE_READV |
222 | /* | |
223 | * If there was no error, try and read the second time round | |
224 | * We read again if n = 2 (ie, there's another part of the buffer) | |
225 | * and we read as much as we could in the first read | |
226 | * We don't test for <= 0 this time, because there legitimately | |
227 | * might not be any more data (since the socket is non-blocking), | |
228 | * a close will be detected on next iteration. | |
cb8d4c8f | 229 | * A return of -1 won't (shouldn't) happen, since it didn't happen above |
f0cbd3ec | 230 | */ |
17444c9c FB |
231 | if (n == 2 && nn == iov[0].iov_len) { |
232 | int ret; | |
00aa0040 | 233 | ret = qemu_recv(so->s, iov[1].iov_base, iov[1].iov_len,0); |
17444c9c FB |
234 | if (ret > 0) |
235 | nn += ret; | |
236 | } | |
5fafdf24 | 237 | |
f0cbd3ec FB |
238 | DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn)); |
239 | #endif | |
5fafdf24 | 240 | |
f0cbd3ec FB |
241 | /* Update fields */ |
242 | sb->sb_cc += nn; | |
243 | sb->sb_wptr += nn; | |
244 | if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen)) | |
245 | sb->sb_wptr -= sb->sb_datalen; | |
246 | return nn; | |
247 | } | |
5fafdf24 | 248 | |
e1c5a2b3 AL |
249 | int soreadbuf(struct socket *so, const char *buf, int size) |
250 | { | |
251 | int n, nn, copy = size; | |
252 | struct sbuf *sb = &so->so_snd; | |
253 | struct iovec iov[2]; | |
254 | ||
255 | DEBUG_CALL("soreadbuf"); | |
ecc804ca | 256 | DEBUG_ARG("so = %p", so); |
e1c5a2b3 AL |
257 | |
258 | /* | |
259 | * No need to check if there's enough room to read. | |
260 | * soread wouldn't have been called if there weren't | |
261 | */ | |
262 | if (sopreprbuf(so, iov, &n) < size) | |
263 | goto err; | |
264 | ||
265 | nn = MIN(iov[0].iov_len, copy); | |
266 | memcpy(iov[0].iov_base, buf, nn); | |
267 | ||
268 | copy -= nn; | |
269 | buf += nn; | |
270 | ||
271 | if (copy == 0) | |
272 | goto done; | |
273 | ||
274 | memcpy(iov[1].iov_base, buf, copy); | |
275 | ||
276 | done: | |
277 | /* Update fields */ | |
278 | sb->sb_cc += size; | |
279 | sb->sb_wptr += size; | |
280 | if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen)) | |
281 | sb->sb_wptr -= sb->sb_datalen; | |
282 | return size; | |
283 | err: | |
284 | ||
285 | sofcantrcvmore(so); | |
286 | tcp_sockclosed(sototcpcb(so)); | |
287 | fprintf(stderr, "soreadbuf buffer to small"); | |
288 | return -1; | |
289 | } | |
290 | ||
f0cbd3ec FB |
291 | /* |
292 | * Get urgent data | |
5fafdf24 | 293 | * |
f0cbd3ec FB |
294 | * When the socket is created, we set it SO_OOBINLINE, |
295 | * so when OOB data arrives, we soread() it and everything | |
296 | * in the send buffer is sent as urgent data | |
297 | */ | |
bfb1ac14 | 298 | int |
511d2b14 | 299 | sorecvoob(struct socket *so) |
f0cbd3ec FB |
300 | { |
301 | struct tcpcb *tp = sototcpcb(so); | |
bfb1ac14 | 302 | int ret; |
f0cbd3ec FB |
303 | |
304 | DEBUG_CALL("sorecvoob"); | |
ecc804ca | 305 | DEBUG_ARG("so = %p", so); |
5fafdf24 | 306 | |
f0cbd3ec FB |
307 | /* |
308 | * We take a guess at how much urgent data has arrived. | |
309 | * In most situations, when urgent data arrives, the next | |
310 | * read() should get all the urgent data. This guess will | |
311 | * be wrong however if more data arrives just after the | |
5fafdf24 | 312 | * urgent data, or the read() doesn't return all the |
f0cbd3ec FB |
313 | * urgent data. |
314 | */ | |
bfb1ac14 SL |
315 | ret = soread(so); |
316 | if (ret > 0) { | |
317 | tp->snd_up = tp->snd_una + so->so_snd.sb_cc; | |
318 | tp->t_force = 1; | |
319 | tcp_output(tp); | |
320 | tp->t_force = 0; | |
321 | } | |
322 | ||
323 | return ret; | |
f0cbd3ec FB |
324 | } |
325 | ||
326 | /* | |
327 | * Send urgent data | |
328 | * There's a lot duplicated code here, but... | |
329 | */ | |
330 | int | |
511d2b14 | 331 | sosendoob(struct socket *so) |
f0cbd3ec FB |
332 | { |
333 | struct sbuf *sb = &so->so_rcv; | |
334 | char buff[2048]; /* XXX Shouldn't be sending more oob data than this */ | |
5fafdf24 | 335 | |
f0cbd3ec | 336 | int n, len; |
5fafdf24 | 337 | |
f0cbd3ec | 338 | DEBUG_CALL("sosendoob"); |
ecc804ca | 339 | DEBUG_ARG("so = %p", so); |
f0cbd3ec | 340 | DEBUG_ARG("sb->sb_cc = %d", sb->sb_cc); |
5fafdf24 | 341 | |
f0cbd3ec FB |
342 | if (so->so_urgc > 2048) |
343 | so->so_urgc = 2048; /* XXXX */ | |
5fafdf24 | 344 | |
f0cbd3ec FB |
345 | if (sb->sb_rptr < sb->sb_wptr) { |
346 | /* We can send it directly */ | |
e1c5a2b3 | 347 | n = slirp_send(so, sb->sb_rptr, so->so_urgc, (MSG_OOB)); /* |MSG_DONTWAIT)); */ |
f0cbd3ec | 348 | } else { |
5fafdf24 | 349 | /* |
f0cbd3ec FB |
350 | * Since there's no sendv or sendtov like writev, |
351 | * we must copy all data to a linear buffer then | |
352 | * send it all | |
353 | */ | |
0b466065 | 354 | uint32_t urgc = so->so_urgc; |
f0cbd3ec | 355 | len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr; |
0b466065 PM |
356 | if (len > urgc) { |
357 | len = urgc; | |
358 | } | |
f0cbd3ec | 359 | memcpy(buff, sb->sb_rptr, len); |
0b466065 PM |
360 | urgc -= len; |
361 | if (urgc) { | |
f0cbd3ec | 362 | n = sb->sb_wptr - sb->sb_data; |
0b466065 PM |
363 | if (n > urgc) { |
364 | n = urgc; | |
365 | } | |
f0cbd3ec | 366 | memcpy((buff + len), sb->sb_data, n); |
f0cbd3ec FB |
367 | len += n; |
368 | } | |
e1c5a2b3 | 369 | n = slirp_send(so, buff, len, (MSG_OOB)); /* |MSG_DONTWAIT)); */ |
0b466065 PM |
370 | } |
371 | ||
f0cbd3ec | 372 | #ifdef DEBUG |
0b466065 PM |
373 | if (n != len) { |
374 | DEBUG_ERROR((dfd, "Didn't send all data urgently XXXXX\n")); | |
375 | } | |
3b46e624 | 376 | #endif |
0b466065 PM |
377 | if (n < 0) { |
378 | return n; | |
f0cbd3ec | 379 | } |
0b466065 PM |
380 | so->so_urgc -= n; |
381 | DEBUG_MISC((dfd, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc)); | |
5fafdf24 | 382 | |
f0cbd3ec FB |
383 | sb->sb_cc -= n; |
384 | sb->sb_rptr += n; | |
385 | if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen)) | |
386 | sb->sb_rptr -= sb->sb_datalen; | |
5fafdf24 | 387 | |
f0cbd3ec FB |
388 | return n; |
389 | } | |
390 | ||
391 | /* | |
5fafdf24 | 392 | * Write data from so_rcv to so's socket, |
f0cbd3ec FB |
393 | * updating all sbuf field as necessary |
394 | */ | |
395 | int | |
511d2b14 | 396 | sowrite(struct socket *so) |
f0cbd3ec FB |
397 | { |
398 | int n,nn; | |
399 | struct sbuf *sb = &so->so_rcv; | |
400 | int len = sb->sb_cc; | |
401 | struct iovec iov[2]; | |
5fafdf24 | 402 | |
f0cbd3ec | 403 | DEBUG_CALL("sowrite"); |
ecc804ca | 404 | DEBUG_ARG("so = %p", so); |
5fafdf24 | 405 | |
f0cbd3ec FB |
406 | if (so->so_urgc) { |
407 | sosendoob(so); | |
408 | if (sb->sb_cc == 0) | |
409 | return 0; | |
410 | } | |
411 | ||
412 | /* | |
413 | * No need to check if there's something to write, | |
414 | * sowrite wouldn't have been called otherwise | |
415 | */ | |
5fafdf24 | 416 | |
f0cbd3ec | 417 | iov[0].iov_base = sb->sb_rptr; |
66029f6a BS |
418 | iov[1].iov_base = NULL; |
419 | iov[1].iov_len = 0; | |
f0cbd3ec FB |
420 | if (sb->sb_rptr < sb->sb_wptr) { |
421 | iov[0].iov_len = sb->sb_wptr - sb->sb_rptr; | |
422 | /* Should never succeed, but... */ | |
423 | if (iov[0].iov_len > len) iov[0].iov_len = len; | |
424 | n = 1; | |
425 | } else { | |
426 | iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr; | |
427 | if (iov[0].iov_len > len) iov[0].iov_len = len; | |
428 | len -= iov[0].iov_len; | |
429 | if (len) { | |
430 | iov[1].iov_base = sb->sb_data; | |
431 | iov[1].iov_len = sb->sb_wptr - sb->sb_data; | |
432 | if (iov[1].iov_len > len) iov[1].iov_len = len; | |
433 | n = 2; | |
434 | } else | |
435 | n = 1; | |
436 | } | |
437 | /* Check if there's urgent data to send, and if so, send it */ | |
438 | ||
439 | #ifdef HAVE_READV | |
440 | nn = writev(so->s, (const struct iovec *)iov, n); | |
5fafdf24 | 441 | |
f0cbd3ec FB |
442 | DEBUG_MISC((dfd, " ... wrote nn = %d bytes\n", nn)); |
443 | #else | |
e1c5a2b3 | 444 | nn = slirp_send(so, iov[0].iov_base, iov[0].iov_len,0); |
f0cbd3ec FB |
445 | #endif |
446 | /* This should never happen, but people tell me it does *shrug* */ | |
447 | if (nn < 0 && (errno == EAGAIN || errno == EINTR)) | |
448 | return 0; | |
5fafdf24 | 449 | |
f0cbd3ec FB |
450 | if (nn <= 0) { |
451 | DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n", | |
452 | so->so_state, errno)); | |
453 | sofcantsendmore(so); | |
454 | tcp_sockclosed(sototcpcb(so)); | |
455 | return -1; | |
456 | } | |
5fafdf24 | 457 | |
f0cbd3ec | 458 | #ifndef HAVE_READV |
3bc2175d FB |
459 | if (n == 2 && nn == iov[0].iov_len) { |
460 | int ret; | |
e1c5a2b3 | 461 | ret = slirp_send(so, iov[1].iov_base, iov[1].iov_len,0); |
3bc2175d FB |
462 | if (ret > 0) |
463 | nn += ret; | |
464 | } | |
f0cbd3ec FB |
465 | DEBUG_MISC((dfd, " ... wrote nn = %d bytes\n", nn)); |
466 | #endif | |
5fafdf24 | 467 | |
f0cbd3ec FB |
468 | /* Update sbuf */ |
469 | sb->sb_cc -= nn; | |
470 | sb->sb_rptr += nn; | |
471 | if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen)) | |
472 | sb->sb_rptr -= sb->sb_datalen; | |
5fafdf24 | 473 | |
f0cbd3ec FB |
474 | /* |
475 | * If in DRAIN mode, and there's no more data, set | |
476 | * it CANTSENDMORE | |
477 | */ | |
478 | if ((so->so_state & SS_FWDRAIN) && sb->sb_cc == 0) | |
479 | sofcantsendmore(so); | |
5fafdf24 | 480 | |
f0cbd3ec FB |
481 | return nn; |
482 | } | |
483 | ||
484 | /* | |
485 | * recvfrom() a UDP socket | |
486 | */ | |
487 | void | |
511d2b14 | 488 | sorecvfrom(struct socket *so) |
f0cbd3ec | 489 | { |
eae303ff | 490 | struct sockaddr_storage addr; |
5379229a | 491 | struct sockaddr_storage saddr, daddr; |
eae303ff | 492 | socklen_t addrlen = sizeof(struct sockaddr_storage); |
5fafdf24 | 493 | |
f0cbd3ec | 494 | DEBUG_CALL("sorecvfrom"); |
ecc804ca | 495 | DEBUG_ARG("so = %p", so); |
5fafdf24 | 496 | |
f0cbd3ec FB |
497 | if (so->so_type == IPPROTO_ICMP) { /* This is a "ping" reply */ |
498 | char buff[256]; | |
499 | int len; | |
3b46e624 | 500 | |
5fafdf24 | 501 | len = recvfrom(so->s, buff, 256, 0, |
f0cbd3ec FB |
502 | (struct sockaddr *)&addr, &addrlen); |
503 | /* XXX Check if reply is "correct"? */ | |
3b46e624 | 504 | |
f0cbd3ec FB |
505 | if(len == -1 || len == 0) { |
506 | u_char code=ICMP_UNREACH_PORT; | |
507 | ||
508 | if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST; | |
509 | else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET; | |
3b46e624 | 510 | |
f0cbd3ec FB |
511 | DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n", |
512 | errno,strerror(errno))); | |
de40abfe | 513 | icmp_send_error(so->so_m, ICMP_UNREACH, code, 0, strerror(errno)); |
f0cbd3ec FB |
514 | } else { |
515 | icmp_reflect(so->so_m); | |
511d2b14 | 516 | so->so_m = NULL; /* Don't m_free() it again! */ |
f0cbd3ec FB |
517 | } |
518 | /* No need for this socket anymore, udp_detach it */ | |
519 | udp_detach(so); | |
520 | } else { /* A "normal" UDP packet */ | |
521 | struct mbuf *m; | |
c5b76b38 BS |
522 | int len; |
523 | #ifdef _WIN32 | |
524 | unsigned long n; | |
525 | #else | |
526 | int n; | |
527 | #endif | |
f0cbd3ec | 528 | |
460fec67 JK |
529 | m = m_get(so->slirp); |
530 | if (!m) { | |
531 | return; | |
532 | } | |
98c63057 GS |
533 | switch (so->so_ffamily) { |
534 | case AF_INET: | |
535 | m->m_data += IF_MAXLINKHDR + sizeof(struct udpiphdr); | |
536 | break; | |
537 | case AF_INET6: | |
538 | m->m_data += IF_MAXLINKHDR + sizeof(struct ip6) | |
539 | + sizeof(struct udphdr); | |
540 | break; | |
541 | default: | |
542 | g_assert_not_reached(); | |
543 | break; | |
544 | } | |
3b46e624 | 545 | |
5fafdf24 | 546 | /* |
f0cbd3ec FB |
547 | * XXX Shouldn't FIONREAD packets destined for port 53, |
548 | * but I don't know the max packet size for DNS lookups | |
549 | */ | |
550 | len = M_FREEROOM(m); | |
551 | /* if (so->so_fport != htons(53)) { */ | |
379ff53d | 552 | ioctlsocket(so->s, FIONREAD, &n); |
3b46e624 | 553 | |
f0cbd3ec FB |
554 | if (n > len) { |
555 | n = (m->m_data - m->m_dat) + m->m_len + n + 1; | |
556 | m_inc(m, n); | |
557 | len = M_FREEROOM(m); | |
558 | } | |
559 | /* } */ | |
3b46e624 | 560 | |
f0cbd3ec FB |
561 | m->m_len = recvfrom(so->s, m->m_data, len, 0, |
562 | (struct sockaddr *)&addr, &addrlen); | |
5fafdf24 | 563 | DEBUG_MISC((dfd, " did recvfrom %d, errno = %d-%s\n", |
f0cbd3ec FB |
564 | m->m_len, errno,strerror(errno))); |
565 | if(m->m_len<0) { | |
15d62af4 GS |
566 | /* Report error as ICMP */ |
567 | switch (so->so_lfamily) { | |
568 | uint8_t code; | |
569 | case AF_INET: | |
570 | code = ICMP_UNREACH_PORT; | |
571 | ||
572 | if (errno == EHOSTUNREACH) { | |
573 | code = ICMP_UNREACH_HOST; | |
574 | } else if (errno == ENETUNREACH) { | |
575 | code = ICMP_UNREACH_NET; | |
576 | } | |
577 | ||
578 | DEBUG_MISC((dfd, " rx error, tx icmp ICMP_UNREACH:%i\n", code)); | |
579 | icmp_send_error(so->so_m, ICMP_UNREACH, code, 0, strerror(errno)); | |
580 | break; | |
581 | case AF_INET6: | |
582 | code = ICMP6_UNREACH_PORT; | |
583 | ||
584 | if (errno == EHOSTUNREACH) { | |
585 | code = ICMP6_UNREACH_ADDRESS; | |
586 | } else if (errno == ENETUNREACH) { | |
587 | code = ICMP6_UNREACH_NO_ROUTE; | |
588 | } | |
589 | ||
590 | DEBUG_MISC((dfd, " rx error, tx icmp6 ICMP_UNREACH:%i\n", code)); | |
591 | icmp6_send_error(so->so_m, ICMP6_UNREACH, code); | |
592 | break; | |
593 | default: | |
594 | g_assert_not_reached(); | |
595 | break; | |
596 | } | |
f0cbd3ec FB |
597 | m_free(m); |
598 | } else { | |
599 | /* | |
600 | * Hack: domain name lookup will be used the most for UDP, | |
601 | * and since they'll only be used once there's no need | |
602 | * for the 4 minute (or whatever) timeout... So we time them | |
603 | * out much quicker (10 seconds for now...) | |
604 | */ | |
605 | if (so->so_expire) { | |
606 | if (so->so_fport == htons(53)) | |
607 | so->so_expire = curtime + SO_EXPIREFAST; | |
608 | else | |
609 | so->so_expire = curtime + SO_EXPIRE; | |
610 | } | |
611 | ||
5fafdf24 | 612 | /* |
f0cbd3ec | 613 | * If this packet was destined for CTL_ADDR, |
5379229a | 614 | * make it look like that's where it came from |
f0cbd3ec | 615 | */ |
5379229a GS |
616 | saddr = addr; |
617 | sotranslate_in(so, &saddr); | |
618 | daddr = so->lhost.ss; | |
619 | ||
eae303ff GS |
620 | switch (so->so_ffamily) { |
621 | case AF_INET: | |
5379229a GS |
622 | udp_output(so, m, (struct sockaddr_in *) &saddr, |
623 | (struct sockaddr_in *) &daddr, | |
624 | so->so_iptos); | |
eae303ff | 625 | break; |
15d62af4 GS |
626 | case AF_INET6: |
627 | udp6_output(so, m, (struct sockaddr_in6 *) &saddr, | |
628 | (struct sockaddr_in6 *) &daddr); | |
629 | break; | |
eae303ff | 630 | default: |
15d62af4 | 631 | g_assert_not_reached(); |
eae303ff GS |
632 | break; |
633 | } | |
f0cbd3ec FB |
634 | } /* rx error */ |
635 | } /* if ping packet */ | |
636 | } | |
637 | ||
638 | /* | |
639 | * sendto() a socket | |
640 | */ | |
641 | int | |
511d2b14 | 642 | sosendto(struct socket *so, struct mbuf *m) |
f0cbd3ec FB |
643 | { |
644 | int ret; | |
5379229a | 645 | struct sockaddr_storage addr; |
f0cbd3ec FB |
646 | |
647 | DEBUG_CALL("sosendto"); | |
ecc804ca SW |
648 | DEBUG_ARG("so = %p", so); |
649 | DEBUG_ARG("m = %p", m); | |
5fafdf24 | 650 | |
5379229a GS |
651 | addr = so->fhost.ss; |
652 | DEBUG_CALL(" sendto()ing)"); | |
653 | sotranslate_out(so, &addr); | |
5fafdf24 | 654 | |
f0cbd3ec FB |
655 | /* Don't care what port we get */ |
656 | ret = sendto(so->s, m->m_data, m->m_len, 0, | |
0d48dfed | 657 | (struct sockaddr *)&addr, sockaddr_size(&addr)); |
f0cbd3ec FB |
658 | if (ret < 0) |
659 | return -1; | |
5fafdf24 | 660 | |
f0cbd3ec FB |
661 | /* |
662 | * Kill the socket if there's no reply in 4 minutes, | |
663 | * but only if it's an expirable socket | |
664 | */ | |
665 | if (so->so_expire) | |
666 | so->so_expire = curtime + SO_EXPIRE; | |
f932b6ce JK |
667 | so->so_state &= SS_PERSISTENT_MASK; |
668 | so->so_state |= SS_ISFCONNECTED; /* So that it gets select()ed */ | |
f0cbd3ec FB |
669 | return 0; |
670 | } | |
671 | ||
672 | /* | |
3c6a0580 | 673 | * Listen for incoming TCP connections |
f0cbd3ec FB |
674 | */ |
675 | struct socket * | |
b6dce92e | 676 | tcp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr, |
460fec67 | 677 | u_int lport, int flags) |
f0cbd3ec FB |
678 | { |
679 | struct sockaddr_in addr; | |
680 | struct socket *so; | |
242acf3a AZ |
681 | int s, opt = 1; |
682 | socklen_t addrlen = sizeof(addr); | |
ab07b980 | 683 | memset(&addr, 0, addrlen); |
f0cbd3ec | 684 | |
3c6a0580 | 685 | DEBUG_CALL("tcp_listen"); |
9f349498 JK |
686 | DEBUG_ARG("haddr = %x", haddr); |
687 | DEBUG_ARG("hport = %d", hport); | |
f0cbd3ec FB |
688 | DEBUG_ARG("laddr = %x", laddr); |
689 | DEBUG_ARG("lport = %d", lport); | |
690 | DEBUG_ARG("flags = %x", flags); | |
5fafdf24 | 691 | |
460fec67 JK |
692 | so = socreate(slirp); |
693 | if (!so) { | |
f0cbd3ec FB |
694 | return NULL; |
695 | } | |
5fafdf24 | 696 | |
f0cbd3ec FB |
697 | /* Don't tcp_attach... we don't need so_snd nor so_rcv */ |
698 | if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) { | |
699 | free(so); | |
700 | return NULL; | |
701 | } | |
460fec67 | 702 | insque(so, &slirp->tcb); |
5fafdf24 TS |
703 | |
704 | /* | |
f0cbd3ec FB |
705 | * SS_FACCEPTONCE sockets must time out. |
706 | */ | |
707 | if (flags & SS_FACCEPTONCE) | |
708 | so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2; | |
5fafdf24 | 709 | |
f932b6ce JK |
710 | so->so_state &= SS_PERSISTENT_MASK; |
711 | so->so_state |= (SS_FACCEPTCONN | flags); | |
eae303ff | 712 | so->so_lfamily = AF_INET; |
f0cbd3ec FB |
713 | so->so_lport = lport; /* Kept in network format */ |
714 | so->so_laddr.s_addr = laddr; /* Ditto */ | |
5fafdf24 | 715 | |
f0cbd3ec | 716 | addr.sin_family = AF_INET; |
3c6a0580 JK |
717 | addr.sin_addr.s_addr = haddr; |
718 | addr.sin_port = hport; | |
5fafdf24 | 719 | |
40ff6d7e | 720 | if (((s = qemu_socket(AF_INET,SOCK_STREAM,0)) < 0) || |
aad1239a | 721 | (socket_set_fast_reuse(s) < 0) || |
f0cbd3ec FB |
722 | (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) || |
723 | (listen(s,1) < 0)) { | |
724 | int tmperrno = errno; /* Don't clobber the real reason we failed */ | |
3b46e624 | 725 | |
bd5d2353 PM |
726 | if (s >= 0) { |
727 | closesocket(s); | |
728 | } | |
f0cbd3ec FB |
729 | sofree(so); |
730 | /* Restore the real errno */ | |
02d2c54c FB |
731 | #ifdef _WIN32 |
732 | WSASetLastError(tmperrno); | |
733 | #else | |
f0cbd3ec | 734 | errno = tmperrno; |
02d2c54c | 735 | #endif |
f0cbd3ec FB |
736 | return NULL; |
737 | } | |
9957fc7f | 738 | qemu_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(int)); |
5fafdf24 | 739 | |
f0cbd3ec | 740 | getsockname(s,(struct sockaddr *)&addr,&addrlen); |
eae303ff | 741 | so->so_ffamily = AF_INET; |
f0cbd3ec FB |
742 | so->so_fport = addr.sin_port; |
743 | if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr) | |
460fec67 | 744 | so->so_faddr = slirp->vhost_addr; |
f0cbd3ec FB |
745 | else |
746 | so->so_faddr = addr.sin_addr; | |
747 | ||
748 | so->s = s; | |
749 | return so; | |
750 | } | |
751 | ||
f0cbd3ec FB |
752 | /* |
753 | * Various session state calls | |
754 | * XXX Should be #define's | |
755 | * The socket state stuff needs work, these often get call 2 or 3 | |
756 | * times each when only 1 was needed | |
757 | */ | |
758 | void | |
511d2b14 | 759 | soisfconnecting(struct socket *so) |
f0cbd3ec FB |
760 | { |
761 | so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE| | |
762 | SS_FCANTSENDMORE|SS_FWDRAIN); | |
763 | so->so_state |= SS_ISFCONNECTING; /* Clobber other states */ | |
764 | } | |
765 | ||
766 | void | |
511d2b14 | 767 | soisfconnected(struct socket *so) |
f0cbd3ec FB |
768 | { |
769 | so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF); | |
770 | so->so_state |= SS_ISFCONNECTED; /* Clobber other states */ | |
771 | } | |
772 | ||
9634d903 BS |
773 | static void |
774 | sofcantrcvmore(struct socket *so) | |
f0cbd3ec FB |
775 | { |
776 | if ((so->so_state & SS_NOFDREF) == 0) { | |
777 | shutdown(so->s,0); | |
f0cbd3ec FB |
778 | } |
779 | so->so_state &= ~(SS_ISFCONNECTING); | |
f932b6ce JK |
780 | if (so->so_state & SS_FCANTSENDMORE) { |
781 | so->so_state &= SS_PERSISTENT_MASK; | |
782 | so->so_state |= SS_NOFDREF; /* Don't select it */ | |
783 | } else { | |
f0cbd3ec | 784 | so->so_state |= SS_FCANTRCVMORE; |
f932b6ce | 785 | } |
f0cbd3ec FB |
786 | } |
787 | ||
9634d903 BS |
788 | static void |
789 | sofcantsendmore(struct socket *so) | |
f0cbd3ec FB |
790 | { |
791 | if ((so->so_state & SS_NOFDREF) == 0) { | |
02d2c54c | 792 | shutdown(so->s,1); /* send FIN to fhost */ |
f0cbd3ec FB |
793 | } |
794 | so->so_state &= ~(SS_ISFCONNECTING); | |
f932b6ce JK |
795 | if (so->so_state & SS_FCANTRCVMORE) { |
796 | so->so_state &= SS_PERSISTENT_MASK; | |
797 | so->so_state |= SS_NOFDREF; /* as above */ | |
798 | } else { | |
f0cbd3ec | 799 | so->so_state |= SS_FCANTSENDMORE; |
f932b6ce | 800 | } |
f0cbd3ec FB |
801 | } |
802 | ||
f0cbd3ec FB |
803 | /* |
804 | * Set write drain mode | |
805 | * Set CANTSENDMORE once all data has been write()n | |
806 | */ | |
807 | void | |
511d2b14 | 808 | sofwdrain(struct socket *so) |
f0cbd3ec FB |
809 | { |
810 | if (so->so_rcv.sb_cc) | |
811 | so->so_state |= SS_FWDRAIN; | |
812 | else | |
813 | sofcantsendmore(so); | |
814 | } | |
5379229a GS |
815 | |
816 | /* | |
817 | * Translate addr in host addr when it is a virtual address | |
818 | */ | |
819 | void sotranslate_out(struct socket *so, struct sockaddr_storage *addr) | |
820 | { | |
821 | Slirp *slirp = so->slirp; | |
822 | struct sockaddr_in *sin = (struct sockaddr_in *)addr; | |
05061d85 | 823 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr; |
5379229a GS |
824 | |
825 | switch (addr->ss_family) { | |
826 | case AF_INET: | |
827 | if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) == | |
828 | slirp->vnetwork_addr.s_addr) { | |
829 | /* It's an alias */ | |
830 | if (so->so_faddr.s_addr == slirp->vnameserver_addr.s_addr) { | |
831 | if (get_dns_addr(&sin->sin_addr) < 0) { | |
832 | sin->sin_addr = loopback_addr; | |
833 | } | |
834 | } else { | |
835 | sin->sin_addr = loopback_addr; | |
836 | } | |
837 | } | |
838 | ||
839 | DEBUG_MISC((dfd, " addr.sin_port=%d, " | |
840 | "addr.sin_addr.s_addr=%.16s\n", | |
841 | ntohs(sin->sin_port), inet_ntoa(sin->sin_addr))); | |
842 | break; | |
843 | ||
05061d85 GS |
844 | case AF_INET6: |
845 | if (in6_equal_net(&so->so_faddr6, &slirp->vprefix_addr6, | |
846 | slirp->vprefix_len)) { | |
847 | if (in6_equal(&so->so_faddr6, &slirp->vnameserver_addr6)) { | |
ef763fa4 ST |
848 | uint32_t scope_id; |
849 | if (get_dns6_addr(&sin6->sin6_addr, &scope_id) >= 0) { | |
850 | sin6->sin6_scope_id = scope_id; | |
851 | } else { | |
05061d85 | 852 | sin6->sin6_addr = in6addr_loopback; |
1d17654e | 853 | } |
05061d85 GS |
854 | } else { |
855 | sin6->sin6_addr = in6addr_loopback; | |
856 | } | |
857 | } | |
858 | break; | |
859 | ||
5379229a GS |
860 | default: |
861 | break; | |
862 | } | |
863 | } | |
864 | ||
865 | void sotranslate_in(struct socket *so, struct sockaddr_storage *addr) | |
866 | { | |
867 | Slirp *slirp = so->slirp; | |
868 | struct sockaddr_in *sin = (struct sockaddr_in *)addr; | |
05061d85 | 869 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr; |
5379229a GS |
870 | |
871 | switch (addr->ss_family) { | |
872 | case AF_INET: | |
873 | if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) == | |
874 | slirp->vnetwork_addr.s_addr) { | |
875 | uint32_t inv_mask = ~slirp->vnetwork_mask.s_addr; | |
876 | ||
877 | if ((so->so_faddr.s_addr & inv_mask) == inv_mask) { | |
878 | sin->sin_addr = slirp->vhost_addr; | |
879 | } else if (sin->sin_addr.s_addr == loopback_addr.s_addr || | |
880 | so->so_faddr.s_addr != slirp->vhost_addr.s_addr) { | |
881 | sin->sin_addr = so->so_faddr; | |
882 | } | |
883 | } | |
884 | break; | |
885 | ||
05061d85 GS |
886 | case AF_INET6: |
887 | if (in6_equal_net(&so->so_faddr6, &slirp->vprefix_addr6, | |
888 | slirp->vprefix_len)) { | |
889 | if (in6_equal(&sin6->sin6_addr, &in6addr_loopback) | |
890 | || !in6_equal(&so->so_faddr6, &slirp->vhost_addr6)) { | |
891 | sin6->sin6_addr = so->so_faddr6; | |
892 | } | |
893 | } | |
894 | break; | |
895 | ||
5379229a GS |
896 | default: |
897 | break; | |
898 | } | |
899 | } | |
900 | ||
901 | /* | |
902 | * Translate connections from localhost to the real hostname | |
903 | */ | |
904 | void sotranslate_accept(struct socket *so) | |
905 | { | |
906 | Slirp *slirp = so->slirp; | |
907 | ||
908 | switch (so->so_ffamily) { | |
909 | case AF_INET: | |
910 | if (so->so_faddr.s_addr == INADDR_ANY || | |
911 | (so->so_faddr.s_addr & loopback_mask) == | |
912 | (loopback_addr.s_addr & loopback_mask)) { | |
913 | so->so_faddr = slirp->vhost_addr; | |
914 | } | |
915 | break; | |
916 | ||
05061d85 GS |
917 | case AF_INET6: |
918 | if (in6_equal(&so->so_faddr6, &in6addr_any) || | |
919 | in6_equal(&so->so_faddr6, &in6addr_loopback)) { | |
920 | so->so_faddr6 = slirp->vhost_addr6; | |
921 | } | |
922 | break; | |
923 | ||
5379229a GS |
924 | default: |
925 | break; | |
926 | } | |
927 | } |