]> Git Repo - qemu.git/blame - net.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Make it obvious that pci_nic_init() can't fail
[qemu.git] / net.c
CommitLineData
63a01ef8
AL		 1/*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
63a01ef8
AL		 24#include <unistd.h>
25#include <fcntl.h>
26#include <signal.h>
27#include <time.h>
28#include <errno.h>
29#include <sys/time.h>
30#include <zlib.h>
31
71e72a19 32/* Needed early for CONFIG_BSD etc. */
d40cdb10
BS		 33#include "config-host.h"
34
63a01ef8
AL		 35#ifndef _WIN32
36#include <sys/times.h>
37#include <sys/wait.h>
38#include <termios.h>
39#include <sys/mman.h>
40#include <sys/ioctl.h>
24646c7e 41#include <sys/resource.h>
63a01ef8
AL		 42#include <sys/socket.h>
43#include <netinet/in.h>
24646c7e
BS		 44#include <net/if.h>
45#ifdef __NetBSD__
46#include <net/if_tap.h>
47#endif
48#ifdef __linux__
49#include <linux/if_tun.h>
50#endif
51#include <arpa/inet.h>
63a01ef8
AL		 52#include <dirent.h>
53#include <netdb.h>
54#include <sys/select.h>
71e72a19 55#ifdef CONFIG_BSD
63a01ef8 56#include <sys/stat.h>
c5e97233 57#if defined(__FreeBSD__) || defined(__DragonFly__)
63a01ef8 58#include <libutil.h>
24646c7e
BS		 59#else
60#include <util.h>
63a01ef8
AL		 61#endif
62#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
63#include <freebsd/stdlib.h>
64#else
65#ifdef __linux__
63a01ef8
AL		 66#include <pty.h>
67#include <malloc.h>
68#include <linux/rtc.h>
69
70/* For the benefit of older linux systems which don't supply it,
71 we use a local copy of hpet.h. */
72/* #include <linux/hpet.h> */
73#include "hpet.h"
74
75#include <linux/ppdev.h>
76#include <linux/parport.h>
77#endif
78#ifdef __sun__
79#include <sys/stat.h>
80#include <sys/ethernet.h>
81#include <sys/sockio.h>
82#include <netinet/arp.h>
83#include <netinet/in.h>
84#include <netinet/in_systm.h>
85#include <netinet/ip.h>
86#include <netinet/ip_icmp.h> // must come after ip.h
87#include <netinet/udp.h>
88#include <netinet/tcp.h>
89#include <net/if.h>
90#include <syslog.h>
91#include <stropts.h>
92#endif
93#endif
94#endif
95
63a01ef8
AL		 96#if defined(__OpenBSD__)
97#include <util.h>
98#endif
99
100#if defined(CONFIG_VDE)
101#include <libvdeplug.h>
102#endif
103
511d2b14
BS		 104#include "qemu-common.h"
105#include "net.h"
106#include "monitor.h"
107#include "sysemu.h"
108#include "qemu-timer.h"
109#include "qemu-char.h"
110#include "audio/audio.h"
111#include "qemu_socket.h"
bb9ea79e 112#include "qemu-log.h"
511d2b14 113
d918f23e 114#include "slirp/libslirp.h"
72cf2d4f 115#include "qemu-queue.h"
511d2b14
BS		 116
117
63a01ef8
AL		 118static VLANState *first_vlan;
119
120/***********************************************************/
121/* network device redirectors */
122
123#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
124static void hex_dump(FILE *f, const uint8_t *buf, int size)
125{
126 int len, i, j, c;
127
128 for(i=0;i<size;i+=16) {
129 len = size - i;
130 if (len > 16)
131 len = 16;
132 fprintf(f, "%08x ", i);
133 for(j=0;j<16;j++) {
134 if (j < len)
135 fprintf(f, " %02x", buf[i+j]);
136 else
137 fprintf(f, " ");
138 }
139 fprintf(f, " ");
140 for(j=0;j<len;j++) {
141 c = buf[i+j];
142 if (c < ' ' || c > '~')
143 c = '.';
144 fprintf(f, "%c", c);
145 }
146 fprintf(f, "\n");
147 }
148}
149#endif
150
151static int parse_macaddr(uint8_t *macaddr, const char *p)
152{
153 int i;
154 char *last_char;
155 long int offset;
156
157 errno = 0;
158 offset = strtol(p, &last_char, 0);
159 if (0 == errno && '\0' == *last_char &&
160 offset >= 0 && offset <= 0xFFFFFF) {
161 macaddr[3] = (offset & 0xFF0000) >> 16;
162 macaddr[4] = (offset & 0xFF00) >> 8;
163 macaddr[5] = offset & 0xFF;
164 return 0;
165 } else {
166 for(i = 0; i < 6; i++) {
167 macaddr[i] = strtol(p, (char **)&p, 16);
168 if (i == 5) {
169 if (*p != '\0')
170 return -1;
171 } else {
172 if (*p != ':' && *p != '-')
173 return -1;
174 p++;
175 }
176 }
177 return 0;
178 }
179
180 return -1;
181}
182
183static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
184{
185 const char *p, *p1;
186 int len;
187 p = *pp;
188 p1 = strchr(p, sep);
189 if (!p1)
190 return -1;
191 len = p1 - p;
192 p1++;
193 if (buf_size > 0) {
194 if (len > buf_size - 1)
195 len = buf_size - 1;
196 memcpy(buf, p, len);
197 buf[len] = '\0';
198 }
199 *pp = p1;
200 return 0;
201}
202
203int parse_host_src_port(struct sockaddr_in *haddr,
204 struct sockaddr_in *saddr,
205 const char *input_str)
206{
207 char *str = strdup(input_str);
208 char *host_str = str;
209 char *src_str;
210 const char *src_str2;
211 char *ptr;
212
213 /*
214 * Chop off any extra arguments at the end of the string which
215 * would start with a comma, then fill in the src port information
216 * if it was provided else use the "any address" and "any port".
217 */
218 if ((ptr = strchr(str,',')))
219 *ptr = '\0';
220
221 if ((src_str = strchr(input_str,'@'))) {
222 *src_str = '\0';
223 src_str++;
224 }
225
226 if (parse_host_port(haddr, host_str) < 0)
227 goto fail;
228
229 src_str2 = src_str;
230 if (!src_str || *src_str == '\0')
231 src_str2 = ":0";
232
233 if (parse_host_port(saddr, src_str2) < 0)
234 goto fail;
235
236 free(str);
237 return(0);
238
239fail:
240 free(str);
241 return -1;
242}
243
244int parse_host_port(struct sockaddr_in *saddr, const char *str)
245{
246 char buf[512];
247 struct hostent *he;
248 const char *p, *r;
249 int port;
250
251 p = str;
252 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
253 return -1;
254 saddr->sin_family = AF_INET;
255 if (buf[0] == '\0') {
256 saddr->sin_addr.s_addr = 0;
257 } else {
cd390083 258 if (qemu_isdigit(buf[0])) {
63a01ef8
AL		 259 if (!inet_aton(buf, &saddr->sin_addr))
260 return -1;
261 } else {
262 if ((he = gethostbyname(buf)) == NULL)
263 return - 1;
264 saddr->sin_addr = *(struct in_addr *)he->h_addr;
265 }
266 }
267 port = strtol(p, (char **)&r, 0);
268 if (r == p)
269 return -1;
270 saddr->sin_port = htons(port);
271 return 0;
272}
273
7cb7434b
AL		 274void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
275{
276 snprintf(vc->info_str, sizeof(vc->info_str),
4dda4063
AL		 277 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
278 vc->model,
7cb7434b
AL		 279 macaddr[0], macaddr[1], macaddr[2],
280 macaddr[3], macaddr[4], macaddr[5]);
281}
282
676cff29
AL		 283static char *assign_name(VLANClientState *vc1, const char *model)
284{
285 VLANState *vlan;
286 char buf[256];
287 int id = 0;
288
289 for (vlan = first_vlan; vlan; vlan = vlan->next) {
290 VLANClientState *vc;
291
292 for (vc = vlan->first_client; vc; vc = vc->next)
293 if (vc != vc1 && strcmp(vc->model, model) == 0)
294 id++;
295 }
296
297 snprintf(buf, sizeof(buf), "%s.%d", model, id);
298
299 return strdup(buf);
300}
301
63a01ef8 302VLANClientState *qemu_new_vlan_client(VLANState *vlan,
bf38c1a0 303 const char *model,
7a9f6e4a 304 const char *name,
cda9046b
MM		 305 NetCanReceive *can_receive,
306 NetReceive *receive,
307 NetReceiveIOV *receive_iov,
b946a153 308 NetCleanup *cleanup,
63a01ef8
AL		 309 void *opaque)
310{
311 VLANClientState *vc, **pvc;
312 vc = qemu_mallocz(sizeof(VLANClientState));
bf38c1a0 313 vc->model = strdup(model);
7a9f6e4a
AL		 314 if (name)
315 vc->name = strdup(name);
316 else
317 vc->name = assign_name(vc, model);
cda9046b
MM		 318 vc->can_receive = can_receive;
319 vc->receive = receive;
320 vc->receive_iov = receive_iov;
b946a153 321 vc->cleanup = cleanup;
63a01ef8
AL		 322 vc->opaque = opaque;
323 vc->vlan = vlan;
324
325 vc->next = NULL;
326 pvc = &vlan->first_client;
327 while (*pvc != NULL)
328 pvc = &(*pvc)->next;
329 *pvc = vc;
330 return vc;
331}
332
333void qemu_del_vlan_client(VLANClientState *vc)
334{
335 VLANClientState **pvc = &vc->vlan->first_client;
336
337 while (*pvc != NULL)
338 if (*pvc == vc) {
339 *pvc = vc->next;
b946a153
AL		 340 if (vc->cleanup) {
341 vc->cleanup(vc);
342 }
676cff29 343 free(vc->name);
bf38c1a0 344 free(vc->model);
dad35419 345 qemu_free(vc);
63a01ef8
AL		 346 break;
347 } else
348 pvc = &(*pvc)->next;
349}
350
8b13c4a7
AL		 351VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
352{
353 VLANClientState **pvc = &vlan->first_client;
354
355 while (*pvc != NULL)
356 if ((*pvc)->opaque == opaque)
357 return *pvc;
358 else
359 pvc = &(*pvc)->next;
360
361 return NULL;
362}
363
1a609520
JK		 364static VLANClientState *
365qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
366 const char *client_str)
367{
368 VLANState *vlan;
369 VLANClientState *vc;
370
371 vlan = qemu_find_vlan(vlan_id, 0);
372 if (!vlan) {
373 monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
374 return NULL;
375 }
376
377 for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
378 if (!strcmp(vc->name, client_str)) {
379 break;
380 }
381 }
382 if (!vc) {
383 monitor_printf(mon, "can't find device %s on VLAN %d\n",
384 client_str, vlan_id);
385 }
386
387 return vc;
388}
389
2e1e0641 390int qemu_can_send_packet(VLANClientState *sender)
63a01ef8 391{
2e1e0641 392 VLANState *vlan = sender->vlan;
63a01ef8
AL		 393 VLANClientState *vc;
394
2e1e0641
MM		 395 for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
396 if (vc == sender) {
397 continue;
398 }
399
cda9046b 400 /* no can_receive() handler, they can always receive */
e3f5ec2b 401 if (!vc->can_receive || vc->can_receive(vc)) {
2e1e0641 402 return 1;
63a01ef8
AL		 403 }
404 }
405 return 0;
406}
407
3e021d40 408static int
764a4d1d 409qemu_deliver_packet(VLANClientState *sender, const uint8_t *buf, int size)
63a01ef8 410{
63a01ef8 411 VLANClientState *vc;
3e021d40 412 int ret = -1;
63a01ef8 413
e94667b9
MM		 414 sender->vlan->delivering = 1;
415
764a4d1d 416 for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) {
3e021d40
MM		 417 ssize_t len;
418
419 if (vc == sender) {
420 continue;
764a4d1d 421 }
3e021d40
MM		 422
423 if (vc->link_down) {
424 ret = size;
425 continue;
426 }
427
428 len = vc->receive(vc, buf, size);
429
430 ret = (ret >= 0) ? ret : len;
764a4d1d 431 }
3e021d40 432
e94667b9
MM		 433 sender->vlan->delivering = 0;
434
3e021d40 435 return ret;
764a4d1d
AL		 436}
437
8cad5516
MM		 438void qemu_purge_queued_packets(VLANClientState *vc)
439{
9da43187 440 VLANPacket *packet, *next;
8cad5516 441
72cf2d4f 442 QTAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) {
8cad5516 443 if (packet->sender == vc) {
72cf2d4f 444 QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
8cad5516 445 qemu_free(packet);
8cad5516
MM		 446 }
447 }
448}
449
f3b6c7fc 450void qemu_flush_queued_packets(VLANClientState *vc)
e94667b9 451{
72cf2d4f 452 while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) {
9da43187 453 VLANPacket *packet;
f3b6c7fc
MM		 454 int ret;
455
72cf2d4f
BS		 456 packet = QTAILQ_FIRST(&vc->vlan->send_queue);
457 QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
f3b6c7fc
MM		 458
459 ret = qemu_deliver_packet(packet->sender, packet->data, packet->size);
460 if (ret == 0 && packet->sent_cb != NULL) {
72cf2d4f 461 QTAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry);
f3b6c7fc
MM		 462 break;
463 }
464
465 if (packet->sent_cb)
783527a9 466 packet->sent_cb(packet->sender, ret);
f3b6c7fc 467
e94667b9
MM		 468 qemu_free(packet);
469 }
470}
471
f3b6c7fc
MM		 472static void qemu_enqueue_packet(VLANClientState *sender,
473 const uint8_t *buf, int size,
474 NetPacketSent *sent_cb)
e94667b9
MM		 475{
476 VLANPacket *packet;
477
478 packet = qemu_malloc(sizeof(VLANPacket) + size);
e94667b9
MM		 479 packet->sender = sender;
480 packet->size = size;
f3b6c7fc 481 packet->sent_cb = sent_cb;
e94667b9 482 memcpy(packet->data, buf, size);
9da43187 483
72cf2d4f 484 QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
e94667b9
MM		 485}
486
f3b6c7fc
MM		 487ssize_t qemu_send_packet_async(VLANClientState *sender,
488 const uint8_t *buf, int size,
489 NetPacketSent *sent_cb)
764a4d1d 490{
f3b6c7fc 491 int ret;
764a4d1d 492
f3b6c7fc
MM		 493 if (sender->link_down) {
494 return size;
495 }
436e5e53 496
63a01ef8 497#ifdef DEBUG_NET
f3b6c7fc 498 printf("vlan %d send:\n", sender->vlan->id);
63a01ef8
AL		 499 hex_dump(stdout, buf, size);
500#endif
f3b6c7fc
MM		 501
502 if (sender->vlan->delivering) {
503 qemu_enqueue_packet(sender, buf, size, NULL);
504 return size;
505 }
506
507 ret = qemu_deliver_packet(sender, buf, size);
508 if (ret == 0 && sent_cb != NULL) {
509 qemu_enqueue_packet(sender, buf, size, sent_cb);
510 return 0;
63a01ef8 511 }
e94667b9 512
f3b6c7fc
MM		 513 qemu_flush_queued_packets(sender);
514
515 return ret;
516}
517
518void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
519{
520 qemu_send_packet_async(vc, buf, size, NULL);
63a01ef8
AL		 521}
522
fbe78f4f
AL		 523static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
524 int iovcnt)
525{
526 uint8_t buffer[4096];
527 size_t offset = 0;
528 int i;
529
530 for (i = 0; i < iovcnt; i++) {
531 size_t len;
532
533 len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
534 memcpy(buffer + offset, iov[i].iov_base, len);
535 offset += len;
536 }
537
f3b6c7fc 538 return vc->receive(vc, buffer, offset);
fbe78f4f
AL		 539}
540
e0e7877a
AL		 541static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
542{
543 size_t offset = 0;
544 int i;
545
546 for (i = 0; i < iovcnt; i++)
547 offset += iov[i].iov_len;
548 return offset;
549}
550
e94667b9
MM		 551static int qemu_deliver_packet_iov(VLANClientState *sender,
552 const struct iovec *iov, int iovcnt)
fbe78f4f 553{
fbe78f4f 554 VLANClientState *vc;
e94667b9
MM		 555 int ret = -1;
556
557 sender->vlan->delivering = 1;
558
559 for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) {
560 ssize_t len;
561
562 if (vc == sender) {
563 continue;
564 }
565
566 if (vc->link_down) {
567 ret = calc_iov_length(iov, iovcnt);
568 continue;
569 }
570
571 if (vc->receive_iov) {
572 len = vc->receive_iov(vc, iov, iovcnt);
573 } else {
574 len = vc_sendv_compat(vc, iov, iovcnt);
575 }
576
577 ret = (ret >= 0) ? ret : len;
578 }
579
580 sender->vlan->delivering = 0;
581
582 return ret;
583}
584
585static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender,
f3b6c7fc
MM		 586 const struct iovec *iov, int iovcnt,
587 NetPacketSent *sent_cb)
e94667b9 588{
c27ff608 589 VLANPacket *packet;
e94667b9 590 size_t max_len = 0;
c27ff608 591 int i;
fbe78f4f 592
e94667b9 593 max_len = calc_iov_length(iov, iovcnt);
e0e7877a 594
e94667b9 595 packet = qemu_malloc(sizeof(VLANPacket) + max_len);
e94667b9 596 packet->sender = sender;
f3b6c7fc 597 packet->sent_cb = sent_cb;
e94667b9 598 packet->size = 0;
c27ff608 599
e94667b9
MM		 600 for (i = 0; i < iovcnt; i++) {
601 size_t len = iov[i].iov_len;
c27ff608 602
e94667b9
MM		 603 memcpy(packet->data + packet->size, iov[i].iov_base, len);
604 packet->size += len;
605 }
fbe78f4f 606
72cf2d4f 607 QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
fbe78f4f 608
e94667b9
MM		 609 return packet->size;
610}
fbe78f4f 611
f3b6c7fc
MM		 612ssize_t qemu_sendv_packet_async(VLANClientState *sender,
613 const struct iovec *iov, int iovcnt,
614 NetPacketSent *sent_cb)
e94667b9
MM		 615{
616 int ret;
617
618 if (sender->link_down) {
619 return calc_iov_length(iov, iovcnt);
620 }
621
622 if (sender->vlan->delivering) {
f3b6c7fc 623 return qemu_enqueue_packet_iov(sender, iov, iovcnt, NULL);
fbe78f4f
AL		 624 }
625
e94667b9 626 ret = qemu_deliver_packet_iov(sender, iov, iovcnt);
f3b6c7fc
MM		 627 if (ret == 0 && sent_cb != NULL) {
628 qemu_enqueue_packet_iov(sender, iov, iovcnt, sent_cb);
629 return 0;
630 }
e94667b9
MM		 631
632 qemu_flush_queued_packets(sender);
633
634 return ret;
fbe78f4f
AL		 635}
636
f3b6c7fc
MM		 637ssize_t
638qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
639{
640 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
641}
642
10ae5a7a
JK		 643static void config_error(Monitor *mon, const char *fmt, ...)
644{
645 va_list ap;
646
647 va_start(ap, fmt);
648 if (mon) {
649 monitor_vprintf(mon, fmt, ap);
650 } else {
651 fprintf(stderr, "qemu: ");
652 vfprintf(stderr, fmt, ap);
653 exit(1);
654 }
655 va_end(ap);
656}
657
63a01ef8
AL		 658#if defined(CONFIG_SLIRP)
659
660/* slirp network adapter */
661
c92ef6a2
JK		 662#define SLIRP_CFG_HOSTFWD 1
663#define SLIRP_CFG_LEGACY 2
ad196a9d 664
b8e8af38
JK		 665struct slirp_config_str {
666 struct slirp_config_str *next;
ad196a9d
JK		 667 int flags;
668 char str[1024];
c92ef6a2 669 int legacy_format;
b8e8af38
JK		 670};
671
9f8bd042 672typedef struct SlirpState {
72cf2d4f 673 QTAILQ_ENTRY(SlirpState) entry;
9f8bd042
JK		 674 VLANClientState *vc;
675 Slirp *slirp;
28432466
JK		 676#ifndef _WIN32
677 char smb_dir[128];
678#endif
9f8bd042
JK		 679} SlirpState;
680
ad196a9d
JK		 681static struct slirp_config_str *slirp_configs;
682const char *legacy_tftp_prefix;
683const char *legacy_bootp_filename;
72cf2d4f
BS		 684static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
685 QTAILQ_HEAD_INITIALIZER(slirp_stacks);
63a01ef8 686
9f8bd042 687static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str,
3c6a0580 688 int legacy_format);
9f8bd042 689static void slirp_guestfwd(SlirpState *s, Monitor *mon, const char *config_str,
c92ef6a2 690 int legacy_format);
ad196a9d 691
c5b76b38 692#ifndef _WIN32
ad196a9d
JK		 693static const char *legacy_smb_export;
694
492efabd 695static void slirp_smb(SlirpState *s, Monitor *mon, const char *exported_dir,
9f8bd042 696 struct in_addr vserver_addr);
28432466
JK		 697static void slirp_smb_cleanup(SlirpState *s);
698#else
699static inline void slirp_smb_cleanup(SlirpState *s) { }
c5b76b38 700#endif
b8e8af38 701
9f8bd042 702int slirp_can_output(void *opaque)
63a01ef8 703{
9f8bd042
JK		 704 SlirpState *s = opaque;
705
706 return qemu_can_send_packet(s->vc);
63a01ef8
AL		 707}
708
9f8bd042 709void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
63a01ef8 710{
9f8bd042
JK		 711 SlirpState *s = opaque;
712
63a01ef8
AL		 713#ifdef DEBUG_SLIRP
714 printf("slirp output:\n");
715 hex_dump(stdout, pkt, pkt_len);
716#endif
9f8bd042 717 qemu_send_packet(s->vc, pkt, pkt_len);
63a01ef8
AL		 718}
719
4f1c942b 720static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 721{
9f8bd042
JK		 722 SlirpState *s = vc->opaque;
723
63a01ef8
AL		 724#ifdef DEBUG_SLIRP
725 printf("slirp input:\n");
726 hex_dump(stdout, buf, size);
727#endif
9f8bd042 728 slirp_input(s->slirp, buf, size);
4f1c942b 729 return size;
63a01ef8
AL		 730}
731
8d6249a7
AL		 732static void net_slirp_cleanup(VLANClientState *vc)
733{
ad0d8c4c
JK		 734 SlirpState *s = vc->opaque;
735
736 slirp_cleanup(s->slirp);
28432466 737 slirp_smb_cleanup(s);
72cf2d4f 738 QTAILQ_REMOVE(&slirp_stacks, s, entry);
ad0d8c4c 739 qemu_free(s);
8d6249a7
AL		 740}
741
ad196a9d 742static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model,
c92ef6a2
JK		 743 const char *name, int restricted,
744 const char *vnetwork, const char *vhost,
745 const char *vhostname, const char *tftp_export,
746 const char *bootfile, const char *vdhcp_start,
747 const char *vnameserver, const char *smb_export,
748 const char *vsmbserver)
63a01ef8 749{
ad0d8c4c 750 /* default settings according to historic slirp */
8389e7f4
AL		 751 struct in_addr net = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
752 struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
ad0d8c4c
JK		 753 struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
754 struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
755 struct in_addr dns = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
c92ef6a2 756#ifndef _WIN32
ad0d8c4c 757 struct in_addr smbsrv = { .s_addr = 0 };
c92ef6a2 758#endif
ad0d8c4c
JK		 759 SlirpState *s;
760 char buf[20];
761 uint32_t addr;
762 int shift;
763 char *end;
764
765 if (!tftp_export) {
766 tftp_export = legacy_tftp_prefix;
767 }
768 if (!bootfile) {
769 bootfile = legacy_bootp_filename;
770 }
c92ef6a2 771
ad0d8c4c
JK		 772 if (vnetwork) {
773 if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
774 if (!inet_aton(vnetwork, &net)) {
775 return -1;
776 }
777 addr = ntohl(net.s_addr);
778 if (!(addr & 0x80000000)) {
779 mask.s_addr = htonl(0xff000000); /* class A */
780 } else if ((addr & 0xfff00000) == 0xac100000) {
781 mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
782 } else if ((addr & 0xc0000000) == 0x80000000) {
783 mask.s_addr = htonl(0xffff0000); /* class B */
784 } else if ((addr & 0xffff0000) == 0xc0a80000) {
785 mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
786 } else if ((addr & 0xffff0000) == 0xc6120000) {
787 mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
788 } else if ((addr & 0xe0000000) == 0xe0000000) {
789 mask.s_addr = htonl(0xffffff00); /* class C */
c92ef6a2 790 } else {
ad0d8c4c
JK		 791 mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
792 }
793 } else {
794 if (!inet_aton(buf, &net)) {
795 return -1;
796 }
797 shift = strtol(vnetwork, &end, 10);
798 if (*end != '\0') {
799 if (!inet_aton(vnetwork, &mask)) {
c92ef6a2 800 return -1;
c92ef6a2 801 }
ad0d8c4c
JK		 802 } else if (shift < 4 || shift > 32) {
803 return -1;
804 } else {
805 mask.s_addr = htonl(0xffffffff << (32 - shift));
c92ef6a2 806 }
c92ef6a2 807 }
ad0d8c4c
JK		 808 net.s_addr &= mask.s_addr;
809 host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
810 dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
811 dns.s_addr = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
812 }
c92ef6a2 813
ad0d8c4c
JK		 814 if (vhost && !inet_aton(vhost, &host)) {
815 return -1;
816 }
817 if ((host.s_addr & mask.s_addr) != net.s_addr) {
818 return -1;
819 }
c92ef6a2 820
ad0d8c4c
JK		 821 if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
822 return -1;
823 }
824 if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||
825 dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
826 return -1;
827 }
c92ef6a2 828
ad0d8c4c
JK		 829 if (vnameserver && !inet_aton(vnameserver, &dns)) {
830 return -1;
831 }
832 if ((dns.s_addr & mask.s_addr) != net.s_addr ||
833 dns.s_addr == host.s_addr) {
834 return -1;
835 }
c92ef6a2
JK		 836
837#ifndef _WIN32
ad0d8c4c
JK		 838 if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
839 return -1;
840 }
c92ef6a2
JK		 841#endif
842
ad0d8c4c
JK		 843 s = qemu_mallocz(sizeof(SlirpState));
844 s->slirp = slirp_init(restricted, net, mask, host, vhostname,
845 tftp_export, bootfile, dhcp, dns, s);
72cf2d4f 846 QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
b8e8af38 847
ad0d8c4c
JK		 848 while (slirp_configs) {
849 struct slirp_config_str *config = slirp_configs;
b8e8af38 850
ad0d8c4c
JK		 851 if (config->flags & SLIRP_CFG_HOSTFWD) {
852 slirp_hostfwd(s, mon, config->str,
853 config->flags & SLIRP_CFG_LEGACY);
854 } else {
855 slirp_guestfwd(s, mon, config->str,
856 config->flags & SLIRP_CFG_LEGACY);
b8e8af38 857 }
ad0d8c4c
JK		 858 slirp_configs = config->next;
859 qemu_free(config);
860 }
b8e8af38 861#ifndef _WIN32
ad0d8c4c
JK		 862 if (!smb_export) {
863 smb_export = legacy_smb_export;
864 }
865 if (smb_export) {
492efabd 866 slirp_smb(s, mon, smb_export, smbsrv);
63a01ef8 867 }
ad0d8c4c 868#endif
b8e8af38 869
9f8bd042
JK		 870 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, slirp_receive, NULL,
871 net_slirp_cleanup, s);
fc57bc57
JK		 872 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
873 "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');
63a01ef8
AL		 874 return 0;
875}
876
f13b572c
JK		 877static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
878 const char *stack)
879{
880 VLANClientState *vc;
881
882 if (vlan) {
883 vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
884 if (!vc) {
885 return NULL;
886 }
887 if (strcmp(vc->model, "user")) {
888 monitor_printf(mon, "invalid device specified\n");
889 return NULL;
890 }
891 return vc->opaque;
892 } else {
72cf2d4f 893 if (QTAILQ_EMPTY(&slirp_stacks)) {
f13b572c
JK		 894 monitor_printf(mon, "user mode network stack not in use\n");
895 return NULL;
896 }
72cf2d4f 897 return QTAILQ_FIRST(&slirp_stacks);
f13b572c
JK		 898 }
899}
900
1d4daa91 901void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
c1261d8d 902{
3c6a0580 903 struct in_addr host_addr = { .s_addr = INADDR_ANY };
c1261d8d
AG		 904 int host_port;
905 char buf[256] = "";
f13b572c
JK		 906 const char *src_str, *p;
907 SlirpState *s;
c1261d8d 908 int is_udp = 0;
9c12a6f2 909 int err;
1d4daa91
LC		 910 const char *arg1 = qdict_get_str(qdict, "arg1");
911 const char *arg2 = qdict_get_try_str(qdict, "arg2");
912 const char *arg3 = qdict_get_try_str(qdict, "arg3");
c1261d8d 913
f13b572c
JK		 914 if (arg2) {
915 s = slirp_lookup(mon, arg1, arg2);
916 src_str = arg3;
917 } else {
918 s = slirp_lookup(mon, NULL, NULL);
919 src_str = arg1;
920 }
921 if (!s) {
c1261d8d 922 return;
f3546deb 923 }
c1261d8d 924
3c6a0580 925 if (!src_str || !src_str[0])
c1261d8d
AG		 926 goto fail_syntax;
927
f13b572c 928 p = src_str;
c1261d8d
AG		 929 get_str_sep(buf, sizeof(buf), &p, ':');
930
931 if (!strcmp(buf, "tcp") || buf[0] == '\0') {
932 is_udp = 0;
933 } else if (!strcmp(buf, "udp")) {
934 is_udp = 1;
935 } else {
936 goto fail_syntax;
937 }
938
3c6a0580
JK		 939 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
940 goto fail_syntax;
941 }
942 if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
943 goto fail_syntax;
944 }
945
c1261d8d
AG		 946 host_port = atoi(p);
947
72cf2d4f 948 err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
9f8bd042 949 host_addr, host_port);
c1261d8d 950
9c12a6f2
JK		 951 monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
952 err ? "removed" : "not found");
c1261d8d
AG		 953 return;
954
955 fail_syntax:
956 monitor_printf(mon, "invalid format\n");
957}
958
9f8bd042 959static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str,
3c6a0580 960 int legacy_format)
63a01ef8 961{
3c6a0580 962 struct in_addr host_addr = { .s_addr = INADDR_ANY };
c92ef6a2 963 struct in_addr guest_addr = { .s_addr = 0 };
63a01ef8 964 int host_port, guest_port;
b8e8af38 965 const char *p;
c92ef6a2 966 char buf[256];
b8e8af38 967 int is_udp;
c92ef6a2 968 char *end;
1c6ed9f3 969
63a01ef8 970 p = redir_str;
f13b572c 971 if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
d4ebe193 972 goto fail_syntax;
b8e8af38 973 }
d4ebe193 974 if (!strcmp(buf, "tcp") || buf[0] == '\0') {
63a01ef8
AL		 975 is_udp = 0;
976 } else if (!strcmp(buf, "udp")) {
977 is_udp = 1;
978 } else {
d4ebe193 979 goto fail_syntax;
63a01ef8
AL		 980 }
981
3c6a0580
JK		 982 if (!legacy_format) {
983 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
984 goto fail_syntax;
985 }
986 if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
987 goto fail_syntax;
988 }
989 }
990
991 if (get_str_sep(buf, sizeof(buf), &p, legacy_format ? ':' : '-') < 0) {
d4ebe193 992 goto fail_syntax;
b8e8af38 993 }
c92ef6a2
JK		 994 host_port = strtol(buf, &end, 0);
995 if (*end != '\0' || host_port < 1 || host_port > 65535) {
d4ebe193 996 goto fail_syntax;
b8e8af38 997 }
63a01ef8 998
b8e8af38 999 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
d4ebe193 1000 goto fail_syntax;
b8e8af38 1001 }
c92ef6a2 1002 if (buf[0] != '\0' && !inet_aton(buf, &guest_addr)) {
d4ebe193 1003 goto fail_syntax;
b8e8af38 1004 }
63a01ef8 1005
c92ef6a2
JK		 1006 guest_port = strtol(p, &end, 0);
1007 if (*end != '\0' || guest_port < 1 || guest_port > 65535) {
d4ebe193 1008 goto fail_syntax;
b8e8af38 1009 }
63a01ef8 1010
9f8bd042
JK		 1011 if (slirp_add_hostfwd(s->slirp, is_udp, host_addr, host_port, guest_addr,
1012 guest_port) < 0) {
c92ef6a2
JK		 1013 config_error(mon, "could not set up host forwarding rule '%s'\n",
1014 redir_str);
63a01ef8
AL		 1015 }
1016 return;
d4ebe193
AL		 1017
1018 fail_syntax:
c92ef6a2 1019 config_error(mon, "invalid host forwarding rule '%s'\n", redir_str);
63a01ef8
AL		 1020}
1021
1d4daa91 1022void net_slirp_hostfwd_add(Monitor *mon, const QDict *qdict)
b8e8af38 1023{
f13b572c
JK		 1024 const char *redir_str;
1025 SlirpState *s;
1d4daa91
LC		 1026 const char *arg1 = qdict_get_str(qdict, "arg1");
1027 const char *arg2 = qdict_get_try_str(qdict, "arg2");
1028 const char *arg3 = qdict_get_try_str(qdict, "arg3");
f13b572c
JK		 1029
1030 if (arg2) {
1031 s = slirp_lookup(mon, arg1, arg2);
1032 redir_str = arg3;
1033 } else {
1034 s = slirp_lookup(mon, NULL, NULL);
1035 redir_str = arg1;
1036 }
1037 if (s) {
1038 slirp_hostfwd(s, mon, redir_str, 0);
b8e8af38
JK		 1039 }
1040
f3546deb
JK		 1041}
1042
1043void net_slirp_redir(const char *redir_str)
1044{
1045 struct slirp_config_str *config;
1046
72cf2d4f 1047 if (QTAILQ_EMPTY(&slirp_stacks)) {
f3546deb
JK		 1048 config = qemu_malloc(sizeof(*config));
1049 pstrcpy(config->str, sizeof(config->str), redir_str);
3c6a0580 1050 config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
f3546deb
JK		 1051 config->next = slirp_configs;
1052 slirp_configs = config;
b8e8af38
JK		 1053 return;
1054 }
1055
72cf2d4f 1056 slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1);
b8e8af38
JK		 1057}
1058
63a01ef8
AL		 1059#ifndef _WIN32
1060
63a01ef8 1061/* automatic user mode samba server configuration */
28432466 1062static void slirp_smb_cleanup(SlirpState *s)
63a01ef8 1063{
28432466 1064 char cmd[128];
09c18925 1065
28432466
JK		 1066 if (s->smb_dir[0] != '\0') {
1067 snprintf(cmd, sizeof(cmd), "rm -rf %s", s->smb_dir);
1068 system(cmd);
1069 s->smb_dir[0] = '\0';
1070 }
63a01ef8
AL		 1071}
1072
492efabd 1073static void slirp_smb(SlirpState* s, Monitor *mon, const char *exported_dir,
9f8bd042 1074 struct in_addr vserver_addr)
63a01ef8 1075{
28432466
JK		 1076 static int instance;
1077 char smb_conf[128];
1078 char smb_cmdline[128];
63a01ef8
AL		 1079 FILE *f;
1080
28432466
JK		 1081 snprintf(s->smb_dir, sizeof(s->smb_dir), "/tmp/qemu-smb.%ld-%d",
1082 (long)getpid(), instance++);
1083 if (mkdir(s->smb_dir, 0700) < 0) {
1084 config_error(mon, "could not create samba server dir '%s'\n",
1085 s->smb_dir);
492efabd 1086 return;
63a01ef8 1087 }
28432466 1088 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", s->smb_dir, "smb.conf");
63a01ef8
AL		 1089
1090 f = fopen(smb_conf, "w");
1091 if (!f) {
28432466 1092 slirp_smb_cleanup(s);
492efabd
JK		 1093 config_error(mon, "could not create samba server "
1094 "configuration file '%s'\n", smb_conf);
1095 return;
63a01ef8
AL		 1096 }
1097 fprintf(f,
1098 "[global]\n"
1099 "private dir=%s\n"
1100 "smb ports=0\n"
1101 "socket address=127.0.0.1\n"
1102 "pid directory=%s\n"
1103 "lock directory=%s\n"
1104 "log file=%s/log.smbd\n"
1105 "smb passwd file=%s/smbpasswd\n"
1106 "security = share\n"
1107 "[qemu]\n"
1108 "path=%s\n"
1109 "read only=no\n"
1110 "guest ok=yes\n",
28432466
JK		 1111 s->smb_dir,
1112 s->smb_dir,
1113 s->smb_dir,
1114 s->smb_dir,
1115 s->smb_dir,
63a01ef8
AL		 1116 exported_dir
1117 );
1118 fclose(f);
63a01ef8
AL		 1119
1120 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
1121 SMBD_COMMAND, smb_conf);
1122
bb53fc53 1123 if (slirp_add_exec(s->slirp, 0, smb_cmdline, &vserver_addr, 139) < 0) {
28432466 1124 slirp_smb_cleanup(s);
492efabd 1125 config_error(mon, "conflicting/invalid smbserver address\n");
c92ef6a2 1126 }
63a01ef8
AL		 1127}
1128
ad196a9d 1129/* automatic user mode samba server configuration (legacy interface) */
b8e8af38
JK		 1130void net_slirp_smb(const char *exported_dir)
1131{
c92ef6a2
JK		 1132 struct in_addr vserver_addr = { .s_addr = 0 };
1133
ad196a9d 1134 if (legacy_smb_export) {
b8e8af38
JK		 1135 fprintf(stderr, "-smb given twice\n");
1136 exit(1);
1137 }
ad196a9d 1138 legacy_smb_export = exported_dir;
72cf2d4f
BS		 1139 if (!QTAILQ_EMPTY(&slirp_stacks)) {
1140 slirp_smb(QTAILQ_FIRST(&slirp_stacks), NULL, exported_dir,
492efabd 1141 vserver_addr);
b8e8af38
JK		 1142 }
1143}
1144
63a01ef8 1145#endif /* !defined(_WIN32) */
b8e8af38 1146
c92ef6a2 1147struct GuestFwd {
8ca9217d 1148 CharDriverState *hd;
c92ef6a2 1149 struct in_addr server;
8ca9217d 1150 int port;
9f8bd042 1151 Slirp *slirp;
511d2b14 1152};
8ca9217d 1153
c92ef6a2 1154static int guestfwd_can_read(void *opaque)
8ca9217d 1155{
c92ef6a2 1156 struct GuestFwd *fwd = opaque;
9f8bd042 1157 return slirp_socket_can_recv(fwd->slirp, fwd->server, fwd->port);
8ca9217d
AL		 1158}
1159
c92ef6a2 1160static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
8ca9217d 1161{
c92ef6a2 1162 struct GuestFwd *fwd = opaque;
9f8bd042 1163 slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
8ca9217d
AL		 1164}
1165
9f8bd042 1166static void slirp_guestfwd(SlirpState *s, Monitor *mon, const char *config_str,
c92ef6a2 1167 int legacy_format)
ad196a9d 1168{
c92ef6a2
JK		 1169 struct in_addr server = { .s_addr = 0 };
1170 struct GuestFwd *fwd;
1171 const char *p;
1172 char buf[128];
1173 char *end;
ad196a9d
JK		 1174 int port;
1175
c92ef6a2
JK		 1176 p = config_str;
1177 if (legacy_format) {
1178 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1179 goto fail_syntax;
1180 }
1181 } else {
1182 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1183 goto fail_syntax;
1184 }
1185 if (strcmp(buf, "tcp") && buf[0] != '\0') {
1186 goto fail_syntax;
1187 }
1188 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1189 goto fail_syntax;
1190 }
1191 if (buf[0] != '\0' && !inet_aton(buf, &server)) {
1192 goto fail_syntax;
1193 }
1194 if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
1195 goto fail_syntax;
1196 }
1197 }
1198 port = strtol(buf, &end, 10);
1199 if (*end != '\0' || port < 1 || port > 65535) {
1200 goto fail_syntax;
ad196a9d 1201 }
ad196a9d 1202
c92ef6a2
JK		 1203 fwd = qemu_malloc(sizeof(struct GuestFwd));
1204 snprintf(buf, sizeof(buf), "guestfwd.tcp:%d", port);
1205 fwd->hd = qemu_chr_open(buf, p, NULL);
1206 if (!fwd->hd) {
1207 config_error(mon, "could not open guest forwarding device '%s'\n",
1208 buf);
1209 qemu_free(fwd);
ad196a9d
JK		 1210 return;
1211 }
ad196a9d 1212
bb53fc53 1213 if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) {
c92ef6a2
JK		 1214 config_error(mon, "conflicting/invalid host:port in guest forwarding "
1215 "rule '%s'\n", config_str);
1216 qemu_free(fwd);
1217 return;
1218 }
bb53fc53
JK		 1219 fwd->server = server;
1220 fwd->port = port;
1221 fwd->slirp = s->slirp;
1222
c92ef6a2
JK		 1223 qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
1224 NULL, fwd);
ad196a9d 1225 return;
c92ef6a2
JK		 1226
1227 fail_syntax:
1228 config_error(mon, "invalid guest forwarding rule '%s'\n", config_str);
ad196a9d
JK		 1229}
1230
6dbe553f
JK		 1231void do_info_usernet(Monitor *mon)
1232{
b1c99fcd 1233 SlirpState *s;
9f8bd042 1234
72cf2d4f 1235 QTAILQ_FOREACH(s, &slirp_stacks, entry) {
b1c99fcd
JK		 1236 monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
1237 slirp_connection_info(s->slirp, mon);
9f8bd042 1238 }
6dbe553f
JK		 1239}
1240
63a01ef8
AL		 1241#endif /* CONFIG_SLIRP */
1242
1243#if !defined(_WIN32)
1244
1245typedef struct TAPState {
1246 VLANClientState *vc;
1247 int fd;
1248 char down_script[1024];
973cbd37 1249 char down_script_arg[128];
5b01e886 1250 uint8_t buf[4096];
b664e367 1251 unsigned int read_poll : 1;
1f7babf6 1252 unsigned int write_poll : 1;
63a01ef8
AL		 1253} TAPState;
1254
b946a153
AL		 1255static int launch_script(const char *setup_script, const char *ifname, int fd);
1256
b664e367
MM		 1257static int tap_can_send(void *opaque);
1258static void tap_send(void *opaque);
1f7babf6 1259static void tap_writable(void *opaque);
b664e367
MM		 1260
1261static void tap_update_fd_handler(TAPState *s)
1262{
1263 qemu_set_fd_handler2(s->fd,
1264 s->read_poll ? tap_can_send : NULL,
1265 s->read_poll ? tap_send : NULL,
1f7babf6 1266 s->write_poll ? tap_writable : NULL,
b664e367
MM		 1267 s);
1268}
1269
1270static void tap_read_poll(TAPState *s, int enable)
1271{
1272 s->read_poll = !!enable;
1273 tap_update_fd_handler(s);
1274}
1275
1f7babf6
MM		 1276static void tap_write_poll(TAPState *s, int enable)
1277{
1278 s->write_poll = !!enable;
1279 tap_update_fd_handler(s);
1280}
1281
1282static void tap_writable(void *opaque)
1283{
1284 TAPState *s = opaque;
1285
1286 tap_write_poll(s, 0);
1287
1288 qemu_flush_queued_packets(s->vc);
1289}
1290
e3f5ec2b 1291static ssize_t tap_receive_iov(VLANClientState *vc, const struct iovec *iov,
b535b7b2
AL		 1292 int iovcnt)
1293{
e3f5ec2b 1294 TAPState *s = vc->opaque;
b535b7b2
AL		 1295 ssize_t len;
1296
1297 do {
1298 len = writev(s->fd, iov, iovcnt);
1f7babf6
MM		 1299 } while (len == -1 && errno == EINTR);
1300
1301 if (len == -1 && errno == EAGAIN) {
1302 tap_write_poll(s, 1);
1303 return 0;
1304 }
b535b7b2
AL		 1305
1306 return len;
1307}
b535b7b2 1308
4f1c942b 1309static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1310{
e3f5ec2b 1311 TAPState *s = vc->opaque;
4f1c942b
MM		 1312 ssize_t len;
1313
1314 do {
1315 len = write(s->fd, buf, size);
1316 } while (len == -1 && (errno == EINTR || errno == EAGAIN));
1317
1318 return len;
63a01ef8
AL		 1319}
1320
3471b757
MM		 1321static int tap_can_send(void *opaque)
1322{
1323 TAPState *s = opaque;
1324
1325 return qemu_can_send_packet(s->vc);
1326}
1327
63a01ef8 1328#ifdef __sun__
5a6d8815
MM		 1329static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1330{
63a01ef8
AL		 1331 struct strbuf sbuf;
1332 int f = 0;
5a6d8815
MM		 1333
1334 sbuf.maxlen = maxlen;
3f4cb3d3 1335 sbuf.buf = (char *)buf;
5a6d8815
MM		 1336
1337 return getmsg(tapfd, NULL, &sbuf, &f) >= 0 ? sbuf.len : -1;
1338}
63a01ef8 1339#else
5a6d8815
MM		 1340static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1341{
1342 return read(tapfd, buf, maxlen);
1343}
63a01ef8 1344#endif
5a6d8815 1345
783527a9 1346static void tap_send_completed(VLANClientState *vc, ssize_t len)
e19eb224
MM		 1347{
1348 TAPState *s = vc->opaque;
b664e367 1349 tap_read_poll(s, 1);
e19eb224
MM		 1350}
1351
5a6d8815
MM		 1352static void tap_send(void *opaque)
1353{
1354 TAPState *s = opaque;
5a6d8815
MM		 1355 int size;
1356
e19eb224
MM		 1357 do {
1358 size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
1359 if (size <= 0) {
1360 break;
1361 }
1362
1363 size = qemu_send_packet_async(s->vc, s->buf, size, tap_send_completed);
1364 if (size == 0) {
b664e367 1365 tap_read_poll(s, 0);
e19eb224
MM		 1366 }
1367 } while (size > 0);
63a01ef8
AL		 1368}
1369
0df0ff6d 1370#ifdef TUNSETSNDBUF
fc5b81d1
MM		 1371/* sndbuf should be set to a value lower than the tx queue
1372 * capacity of any destination network interface.
1373 * Ethernet NICs generally have txqueuelen=1000, so 1Mb is
1374 * a good default, given a 1500 byte MTU.
1375 */
1376#define TAP_DEFAULT_SNDBUF 1024*1024
1377
1378static void tap_set_sndbuf(TAPState *s, const char *sndbuf_str, Monitor *mon)
1379{
1380 int sndbuf = TAP_DEFAULT_SNDBUF;
1381
1382 if (sndbuf_str) {
1383 sndbuf = atoi(sndbuf_str);
1384 }
1385
1386 if (!sndbuf) {
1387 sndbuf = INT_MAX;
1388 }
1389
d026fb6d 1390 if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1 && sndbuf_str) {
0df0ff6d
MM		 1391 config_error(mon, "TUNSETSNDBUF ioctl failed: %s\n",
1392 strerror(errno));
1393 }
fc5b81d1 1394}
0df0ff6d 1395#else
fc5b81d1
MM		 1396static void tap_set_sndbuf(TAPState *s, const char *sndbuf_str, Monitor *mon)
1397{
1398 if (sndbuf_str) {
1399 config_error(mon, "No '-net tap,sndbuf=<nbytes>' support available\n");
1400 }
0df0ff6d 1401}
fc5b81d1 1402#endif /* TUNSETSNDBUF */
0df0ff6d 1403
b946a153
AL		 1404static void tap_cleanup(VLANClientState *vc)
1405{
1406 TAPState *s = vc->opaque;
1407
b9adce2c
MM		 1408 qemu_purge_queued_packets(vc);
1409
b946a153
AL		 1410 if (s->down_script[0])
1411 launch_script(s->down_script, s->down_script_arg, s->fd);
1412
b664e367 1413 tap_read_poll(s, 0);
1f7babf6 1414 tap_write_poll(s, 0);
b946a153
AL		 1415 close(s->fd);
1416 qemu_free(s);
1417}
1418
63a01ef8
AL		 1419/* fd support */
1420
7a9f6e4a
AL		 1421static TAPState *net_tap_fd_init(VLANState *vlan,
1422 const char *model,
1423 const char *name,
1424 int fd)
63a01ef8
AL		 1425{
1426 TAPState *s;
1427
1428 s = qemu_mallocz(sizeof(TAPState));
63a01ef8 1429 s->fd = fd;
463af534
MM		 1430 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, tap_receive,
1431 tap_receive_iov, tap_cleanup, s);
b664e367 1432 tap_read_poll(s, 1);
7cb7434b 1433 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
63a01ef8
AL		 1434 return s;
1435}
1436
71e72a19 1437#if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__)
63a01ef8
AL		 1438static int tap_open(char *ifname, int ifname_size)
1439{
1440 int fd;
1441 char *dev;
1442 struct stat s;
1443
1444 TFR(fd = open("/dev/tap", O_RDWR));
1445 if (fd < 0) {
1446 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1447 return -1;
1448 }
1449
1450 fstat(fd, &s);
1451 dev = devname(s.st_rdev, S_IFCHR);
1452 pstrcpy(ifname, ifname_size, dev);
1453
1454 fcntl(fd, F_SETFL, O_NONBLOCK);
1455 return fd;
1456}
1457#elif defined(__sun__)
1458#define TUNNEWPPA (('T'<<16) | 0x0001)
1459/*
1460 * Allocate TAP device, returns opened fd.
1461 * Stores dev name in the first arg(must be large enough).
1462 */
3f4cb3d3 1463static int tap_alloc(char *dev, size_t dev_size)
63a01ef8
AL		 1464{
1465 int tap_fd, if_fd, ppa = -1;
1466 static int ip_fd = 0;
1467 char *ptr;
1468
1469 static int arp_fd = 0;
1470 int ip_muxid, arp_muxid;
1471 struct strioctl strioc_if, strioc_ppa;
1472 int link_type = I_PLINK;;
1473 struct lifreq ifr;
1474 char actual_name[32] = "";
1475
1476 memset(&ifr, 0x0, sizeof(ifr));
1477
1478 if( *dev ){
1479 ptr = dev;
47398b9c 1480 while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
63a01ef8
AL		 1481 ppa = atoi(ptr);
1482 }
1483
1484 /* Check if IP device was opened */
1485 if( ip_fd )
1486 close(ip_fd);
1487
1488 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
1489 if (ip_fd < 0) {
1490 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
1491 return -1;
1492 }
1493
1494 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
1495 if (tap_fd < 0) {
1496 syslog(LOG_ERR, "Can't open /dev/tap");
1497 return -1;
1498 }
1499
1500 /* Assign a new PPA and get its unit number. */
1501 strioc_ppa.ic_cmd = TUNNEWPPA;
1502 strioc_ppa.ic_timout = 0;
1503 strioc_ppa.ic_len = sizeof(ppa);
1504 strioc_ppa.ic_dp = (char *)&ppa;
1505 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
1506 syslog (LOG_ERR, "Can't assign new interface");
1507
1508 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
1509 if (if_fd < 0) {
1510 syslog(LOG_ERR, "Can't open /dev/tap (2)");
1511 return -1;
1512 }
1513 if(ioctl(if_fd, I_PUSH, "ip") < 0){
1514 syslog(LOG_ERR, "Can't push IP module");
1515 return -1;
1516 }
1517
1518 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
1519 syslog(LOG_ERR, "Can't get flags\n");
1520
1521 snprintf (actual_name, 32, "tap%d", ppa);
1522 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1523
1524 ifr.lifr_ppa = ppa;
1525 /* Assign ppa according to the unit number returned by tun device */
1526
1527 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
1528 syslog (LOG_ERR, "Can't set PPA %d", ppa);
1529 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
1530 syslog (LOG_ERR, "Can't get flags\n");
1531 /* Push arp module to if_fd */
1532 if (ioctl (if_fd, I_PUSH, "arp") < 0)
1533 syslog (LOG_ERR, "Can't push ARP module (2)");
1534
1535 /* Push arp module to ip_fd */
1536 if (ioctl (ip_fd, I_POP, NULL) < 0)
1537 syslog (LOG_ERR, "I_POP failed\n");
1538 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
1539 syslog (LOG_ERR, "Can't push ARP module (3)\n");
1540 /* Open arp_fd */
1541 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
1542 if (arp_fd < 0)
1543 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
1544
1545 /* Set ifname to arp */
1546 strioc_if.ic_cmd = SIOCSLIFNAME;
1547 strioc_if.ic_timout = 0;
1548 strioc_if.ic_len = sizeof(ifr);
1549 strioc_if.ic_dp = (char *)&ifr;
1550 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
1551 syslog (LOG_ERR, "Can't set ifname to arp\n");
1552 }
1553
1554 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
1555 syslog(LOG_ERR, "Can't link TAP device to IP");
1556 return -1;
1557 }
1558
1559 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
1560 syslog (LOG_ERR, "Can't link TAP device to ARP");
1561
1562 close (if_fd);
1563
1564 memset(&ifr, 0x0, sizeof(ifr));
1565 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1566 ifr.lifr_ip_muxid = ip_muxid;
1567 ifr.lifr_arp_muxid = arp_muxid;
1568
1569 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
1570 {
1571 ioctl (ip_fd, I_PUNLINK , arp_muxid);
1572 ioctl (ip_fd, I_PUNLINK, ip_muxid);
1573 syslog (LOG_ERR, "Can't set multiplexor id");
1574 }
1575
1576 snprintf(dev, dev_size, "tap%d", ppa);
1577 return tap_fd;
1578}
1579
1580static int tap_open(char *ifname, int ifname_size)
1581{
1582 char dev[10]="";
1583 int fd;
1584 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
1585 fprintf(stderr, "Cannot allocate TAP device\n");
1586 return -1;
1587 }
1588 pstrcpy(ifname, ifname_size, dev);
1589 fcntl(fd, F_SETFL, O_NONBLOCK);
1590 return fd;
1591}
b29fe3ed 1592#elif defined (_AIX)
1593static int tap_open(char *ifname, int ifname_size)
1594{
1595 fprintf (stderr, "no tap on AIX\n");
1596 return -1;
1597}
63a01ef8
AL		 1598#else
1599static int tap_open(char *ifname, int ifname_size)
1600{
1601 struct ifreq ifr;
1602 int fd, ret;
1603
1604 TFR(fd = open("/dev/net/tun", O_RDWR));
1605 if (fd < 0) {
1606 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1607 return -1;
1608 }
1609 memset(&ifr, 0, sizeof(ifr));
1610 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1611 if (ifname[0] != '\0')
1612 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
1613 else
1614 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
1615 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1616 if (ret != 0) {
1617 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1618 close(fd);
1619 return -1;
1620 }
1621 pstrcpy(ifname, ifname_size, ifr.ifr_name);
1622 fcntl(fd, F_SETFL, O_NONBLOCK);
1623 return fd;
1624}
1625#endif
1626
1627static int launch_script(const char *setup_script, const char *ifname, int fd)
1628{
7c3370d4 1629 sigset_t oldmask, mask;
63a01ef8
AL		 1630 int pid, status;
1631 char *args[3];
1632 char **parg;
1633
7c3370d4
JK		 1634 sigemptyset(&mask);
1635 sigaddset(&mask, SIGCHLD);
1636 sigprocmask(SIG_BLOCK, &mask, &oldmask);
1637
1638 /* try to launch network script */
1639 pid = fork();
1640 if (pid == 0) {
1641 int open_max = sysconf(_SC_OPEN_MAX), i;
1642
1643 for (i = 0; i < open_max; i++) {
1644 if (i != STDIN_FILENO &&
1645 i != STDOUT_FILENO &&
1646 i != STDERR_FILENO &&
1647 i != fd) {
1648 close(i);
63a01ef8
AL		 1649 }
1650 }
7c3370d4
JK		 1651 parg = args;
1652 *parg++ = (char *)setup_script;
1653 *parg++ = (char *)ifname;
1654 *parg++ = NULL;
1655 execv(setup_script, args);
1656 _exit(1);
1657 } else if (pid > 0) {
1658 while (waitpid(pid, &status, 0) != pid) {
1659 /* loop */
1660 }
1661 sigprocmask(SIG_SETMASK, &oldmask, NULL);
1662
1663 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
1664 return 0;
1665 }
1666 }
1667 fprintf(stderr, "%s: could not launch network script\n", setup_script);
1668 return -1;
63a01ef8
AL		 1669}
1670
4a77b25e
MM		 1671static TAPState *net_tap_init(VLANState *vlan, const char *model,
1672 const char *name, const char *ifname1,
1673 const char *setup_script, const char *down_script)
63a01ef8
AL		 1674{
1675 TAPState *s;
1676 int fd;
1677 char ifname[128];
1678
1679 if (ifname1 != NULL)
1680 pstrcpy(ifname, sizeof(ifname), ifname1);
1681 else
1682 ifname[0] = '\0';
1683 TFR(fd = tap_open(ifname, sizeof(ifname)));
1684 if (fd < 0)
4a77b25e 1685 return NULL;
63a01ef8
AL		 1686
1687 if (!setup_script || !strcmp(setup_script, "no"))
1688 setup_script = "";
4a77b25e
MM		 1689 if (setup_script[0] != '\0' &&
1690 launch_script(setup_script, ifname, fd)) {
1691 return NULL;
63a01ef8 1692 }
7a9f6e4a 1693 s = net_tap_fd_init(vlan, model, name, fd);
63a01ef8 1694 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
7cb7434b
AL		 1695 "ifname=%s,script=%s,downscript=%s",
1696 ifname, setup_script, down_script);
973cbd37 1697 if (down_script && strcmp(down_script, "no")) {
63a01ef8 1698 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
973cbd37
AL		 1699 snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
1700 }
4a77b25e 1701 return s;
63a01ef8
AL		 1702}
1703
1704#endif /* !_WIN32 */
1705
1706#if defined(CONFIG_VDE)
1707typedef struct VDEState {
1708 VLANClientState *vc;
1709 VDECONN *vde;
1710} VDEState;
1711
1712static void vde_to_qemu(void *opaque)
1713{
1714 VDEState *s = opaque;
1715 uint8_t buf[4096];
1716 int size;
1717
cc63bb0f 1718 size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
63a01ef8
AL		 1719 if (size > 0) {
1720 qemu_send_packet(s->vc, buf, size);
1721 }
1722}
1723
4f1c942b 1724static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1725{
e3f5ec2b 1726 VDEState *s = vc->opaque;
068daedd 1727 ssize_t ret;
4f1c942b
MM		 1728
1729 do {
1730 ret = vde_send(s->vde, (const char *)buf, size, 0);
1731 } while (ret < 0 && errno == EINTR);
1732
1733 return ret;
63a01ef8
AL		 1734}
1735
b946a153
AL		 1736static void vde_cleanup(VLANClientState *vc)
1737{
1738 VDEState *s = vc->opaque;
1739 qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
1740 vde_close(s->vde);
1741 qemu_free(s);
1742}
1743
7a9f6e4a
AL		 1744static int net_vde_init(VLANState *vlan, const char *model,
1745 const char *name, const char *sock,
bf38c1a0 1746 int port, const char *group, int mode)
63a01ef8
AL		 1747{
1748 VDEState *s;
1749 char *init_group = strlen(group) ? (char *)group : NULL;
1750 char *init_sock = strlen(sock) ? (char *)sock : NULL;
1751
1752 struct vde_open_args args = {
1753 .port = port,
1754 .group = init_group,
1755 .mode = mode,
1756 };
1757
1758 s = qemu_mallocz(sizeof(VDEState));
cc63bb0f 1759 s->vde = vde_open(init_sock, (char *)"QEMU", &args);
63a01ef8
AL		 1760 if (!s->vde){
1761 free(s);
1762 return -1;
1763 }
e3f5ec2b 1764 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, vde_receive,
b946a153 1765 NULL, vde_cleanup, s);
63a01ef8 1766 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
7cb7434b 1767 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
63a01ef8
AL		 1768 sock, vde_datafd(s->vde));
1769 return 0;
1770}
1771#endif
1772
1773/* network connection */
1774typedef struct NetSocketState {
1775 VLANClientState *vc;
1776 int fd;
1777 int state; /* 0 = getting length, 1 = getting data */
abcd2baa
AL		 1778 unsigned int index;
1779 unsigned int packet_len;
63a01ef8
AL		 1780 uint8_t buf[4096];
1781 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1782} NetSocketState;
1783
1784typedef struct NetSocketListenState {
1785 VLANState *vlan;
bf38c1a0 1786 char *model;
7a9f6e4a 1787 char *name;
63a01ef8
AL		 1788 int fd;
1789} NetSocketListenState;
1790
1791/* XXX: we consider we can send the whole packet without blocking */
4f1c942b 1792static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1793{
e3f5ec2b 1794 NetSocketState *s = vc->opaque;
63a01ef8
AL		 1795 uint32_t len;
1796 len = htonl(size);
1797
1798 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4f1c942b 1799 return send_all(s->fd, buf, size);
63a01ef8
AL		 1800}
1801
4f1c942b 1802static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1803{
e3f5ec2b 1804 NetSocketState *s = vc->opaque;
4f1c942b 1805
70503264 1806 return sendto(s->fd, (const void *)buf, size, 0,
4f1c942b 1807 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
63a01ef8
AL		 1808}
1809
1810static void net_socket_send(void *opaque)
1811{
1812 NetSocketState *s = opaque;
abcd2baa
AL		 1813 int size, err;
1814 unsigned l;
63a01ef8
AL		 1815 uint8_t buf1[4096];
1816 const uint8_t *buf;
1817
c5b76b38 1818 size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
63a01ef8
AL		 1819 if (size < 0) {
1820 err = socket_error();
1821 if (err != EWOULDBLOCK)
1822 goto eoc;
1823 } else if (size == 0) {
1824 /* end of connection */
1825 eoc:
1826 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1827 closesocket(s->fd);
1828 return;
1829 }
1830 buf = buf1;
1831 while (size > 0) {
1832 /* reassemble a packet from the network */
1833 switch(s->state) {
1834 case 0:
1835 l = 4 - s->index;
1836 if (l > size)
1837 l = size;
1838 memcpy(s->buf + s->index, buf, l);
1839 buf += l;
1840 size -= l;
1841 s->index += l;
1842 if (s->index == 4) {
1843 /* got length */
1844 s->packet_len = ntohl(*(uint32_t *)s->buf);
1845 s->index = 0;
1846 s->state = 1;
1847 }
1848 break;
1849 case 1:
1850 l = s->packet_len - s->index;
1851 if (l > size)
1852 l = size;
abcd2baa
AL		 1853 if (s->index + l <= sizeof(s->buf)) {
1854 memcpy(s->buf + s->index, buf, l);
1855 } else {
1856 fprintf(stderr, "serious error: oversized packet received,"
1857 "connection terminated.\n");
1858 s->state = 0;
1859 goto eoc;
1860 }
1861
63a01ef8
AL		 1862 s->index += l;
1863 buf += l;
1864 size -= l;
1865 if (s->index >= s->packet_len) {
1866 qemu_send_packet(s->vc, s->buf, s->packet_len);
1867 s->index = 0;
1868 s->state = 0;
1869 }
1870 break;
1871 }
1872 }
1873}
1874
1875static void net_socket_send_dgram(void *opaque)
1876{
1877 NetSocketState *s = opaque;
1878 int size;
1879
c5b76b38 1880 size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
63a01ef8
AL		 1881 if (size < 0)
1882 return;
1883 if (size == 0) {
1884 /* end of connection */
1885 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1886 return;
1887 }
1888 qemu_send_packet(s->vc, s->buf, size);
1889}
1890
1891static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1892{
1893 struct ip_mreq imr;
1894 int fd;
1895 int val, ret;
1896 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1897 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1898 inet_ntoa(mcastaddr->sin_addr),
1899 (int)ntohl(mcastaddr->sin_addr.s_addr));
1900 return -1;
1901
1902 }
1903 fd = socket(PF_INET, SOCK_DGRAM, 0);
1904 if (fd < 0) {
1905 perror("socket(PF_INET, SOCK_DGRAM)");
1906 return -1;
1907 }
1908
1909 val = 1;
1910 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1911 (const char *)&val, sizeof(val));
1912 if (ret < 0) {
1913 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1914 goto fail;
1915 }
1916
1917 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1918 if (ret < 0) {
1919 perror("bind");
1920 goto fail;
1921 }
1922
1923 /* Add host to multicast group */
1924 imr.imr_multiaddr = mcastaddr->sin_addr;
1925 imr.imr_interface.s_addr = htonl(INADDR_ANY);
1926
1927 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1928 (const char *)&imr, sizeof(struct ip_mreq));
1929 if (ret < 0) {
1930 perror("setsockopt(IP_ADD_MEMBERSHIP)");
1931 goto fail;
1932 }
1933
1934 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1935 val = 1;
1936 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1937 (const char *)&val, sizeof(val));
1938 if (ret < 0) {
1939 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1940 goto fail;
1941 }
1942
1943 socket_set_nonblock(fd);
1944 return fd;
1945fail:
1946 if (fd >= 0)
1947 closesocket(fd);
1948 return -1;
1949}
1950
b946a153
AL		 1951static void net_socket_cleanup(VLANClientState *vc)
1952{
1953 NetSocketState *s = vc->opaque;
1954 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1955 close(s->fd);
1956 qemu_free(s);
1957}
1958
7a9f6e4a
AL		 1959static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
1960 const char *model,
1961 const char *name,
bf38c1a0 1962 int fd, int is_connected)
63a01ef8
AL		 1963{
1964 struct sockaddr_in saddr;
1965 int newfd;
1966 socklen_t saddr_len;
1967 NetSocketState *s;
1968
1969 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1970 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1971 * by ONLY ONE process: we must "clone" this dgram socket --jjo
1972 */
1973
1974 if (is_connected) {
1975 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1976 /* must be bound */
1977 if (saddr.sin_addr.s_addr==0) {
1978 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1979 fd);
1980 return NULL;
1981 }
1982 /* clone dgram socket */
1983 newfd = net_socket_mcast_create(&saddr);
1984 if (newfd < 0) {
1985 /* error already reported by net_socket_mcast_create() */
1986 close(fd);
1987 return NULL;
1988 }
1989 /* clone newfd to fd, close newfd */
1990 dup2(newfd, fd);
1991 close(newfd);
1992
1993 } else {
1994 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1995 fd, strerror(errno));
1996 return NULL;
1997 }
1998 }
1999
2000 s = qemu_mallocz(sizeof(NetSocketState));
63a01ef8
AL		 2001 s->fd = fd;
2002
463af534 2003 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, net_socket_receive_dgram,
b946a153 2004 NULL, net_socket_cleanup, s);
63a01ef8
AL		 2005 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2006
2007 /* mcast: save bound address as dst */
2008 if (is_connected) s->dgram_dst=saddr;
2009
2010 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2011 "socket: fd=%d (%s mcast=%s:%d)",
2012 fd, is_connected? "cloned" : "",
2013 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2014 return s;
2015}
2016
2017static void net_socket_connect(void *opaque)
2018{
2019 NetSocketState *s = opaque;
2020 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2021}
2022
7a9f6e4a
AL		 2023static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
2024 const char *model,
2025 const char *name,
bf38c1a0 2026 int fd, int is_connected)
63a01ef8
AL		 2027{
2028 NetSocketState *s;
2029 s = qemu_mallocz(sizeof(NetSocketState));
63a01ef8 2030 s->fd = fd;
463af534 2031 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, net_socket_receive,
b946a153 2032 NULL, net_socket_cleanup, s);
63a01ef8
AL		 2033 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2034 "socket: fd=%d", fd);
2035 if (is_connected) {
2036 net_socket_connect(s);
2037 } else {
2038 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2039 }
2040 return s;
2041}
2042
7a9f6e4a
AL		 2043static NetSocketState *net_socket_fd_init(VLANState *vlan,
2044 const char *model, const char *name,
bf38c1a0 2045 int fd, int is_connected)
63a01ef8 2046{
acedcfbf 2047 int so_type = -1, optlen=sizeof(so_type);
63a01ef8
AL		 2048
2049 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
2050 (socklen_t *)&optlen)< 0) {
2051 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
2052 return NULL;
2053 }
2054 switch(so_type) {
2055 case SOCK_DGRAM:
7a9f6e4a 2056 return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
63a01ef8 2057 case SOCK_STREAM:
7a9f6e4a 2058 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
63a01ef8
AL		 2059 default:
2060 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2061 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
7a9f6e4a 2062 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
63a01ef8
AL		 2063 }
2064 return NULL;
2065}
2066
2067static void net_socket_accept(void *opaque)
2068{
2069 NetSocketListenState *s = opaque;
2070 NetSocketState *s1;
2071 struct sockaddr_in saddr;
2072 socklen_t len;
2073 int fd;
2074
2075 for(;;) {
2076 len = sizeof(saddr);
2077 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2078 if (fd < 0 && errno != EINTR) {
2079 return;
2080 } else if (fd >= 0) {
2081 break;
2082 }
2083 }
7a9f6e4a 2084 s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
63a01ef8
AL		 2085 if (!s1) {
2086 closesocket(fd);
2087 } else {
2088 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2089 "socket: connection from %s:%d",
2090 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2091 }
2092}
2093
7a9f6e4a
AL		 2094static int net_socket_listen_init(VLANState *vlan,
2095 const char *model,
2096 const char *name,
bf38c1a0 2097 const char *host_str)
63a01ef8
AL		 2098{
2099 NetSocketListenState *s;
2100 int fd, val, ret;
2101 struct sockaddr_in saddr;
2102
2103 if (parse_host_port(&saddr, host_str) < 0)
2104 return -1;
2105
2106 s = qemu_mallocz(sizeof(NetSocketListenState));
63a01ef8
AL		 2107
2108 fd = socket(PF_INET, SOCK_STREAM, 0);
2109 if (fd < 0) {
2110 perror("socket");
2111 return -1;
2112 }
2113 socket_set_nonblock(fd);
2114
2115 /* allow fast reuse */
2116 val = 1;
2117 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2118
2119 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2120 if (ret < 0) {
2121 perror("bind");
2122 return -1;
2123 }
2124 ret = listen(fd, 0);
2125 if (ret < 0) {
2126 perror("listen");
2127 return -1;
2128 }
2129 s->vlan = vlan;
bf38c1a0 2130 s->model = strdup(model);
ea053add 2131 s->name = name ? strdup(name) : NULL;
63a01ef8
AL		 2132 s->fd = fd;
2133 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2134 return 0;
2135}
2136
7a9f6e4a
AL		 2137static int net_socket_connect_init(VLANState *vlan,
2138 const char *model,
2139 const char *name,
bf38c1a0 2140 const char *host_str)
63a01ef8
AL		 2141{
2142 NetSocketState *s;
2143 int fd, connected, ret, err;
2144 struct sockaddr_in saddr;
2145
2146 if (parse_host_port(&saddr, host_str) < 0)
2147 return -1;
2148
2149 fd = socket(PF_INET, SOCK_STREAM, 0);
2150 if (fd < 0) {
2151 perror("socket");
2152 return -1;
2153 }
2154 socket_set_nonblock(fd);
2155
2156 connected = 0;
2157 for(;;) {
2158 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2159 if (ret < 0) {
2160 err = socket_error();
2161 if (err == EINTR || err == EWOULDBLOCK) {
2162 } else if (err == EINPROGRESS) {
2163 break;
2164#ifdef _WIN32
2165 } else if (err == WSAEALREADY) {
2166 break;
2167#endif
2168 } else {
2169 perror("connect");
2170 closesocket(fd);
2171 return -1;
2172 }
2173 } else {
2174 connected = 1;
2175 break;
2176 }
2177 }
7a9f6e4a 2178 s = net_socket_fd_init(vlan, model, name, fd, connected);
63a01ef8
AL		 2179 if (!s)
2180 return -1;
2181 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2182 "socket: connect to %s:%d",
2183 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2184 return 0;
2185}
2186
7a9f6e4a
AL		 2187static int net_socket_mcast_init(VLANState *vlan,
2188 const char *model,
2189 const char *name,
bf38c1a0 2190 const char *host_str)
63a01ef8
AL		 2191{
2192 NetSocketState *s;
2193 int fd;
2194 struct sockaddr_in saddr;
2195
2196 if (parse_host_port(&saddr, host_str) < 0)
2197 return -1;
2198
2199
2200 fd = net_socket_mcast_create(&saddr);
2201 if (fd < 0)
2202 return -1;
2203
7a9f6e4a 2204 s = net_socket_fd_init(vlan, model, name, fd, 0);
63a01ef8
AL		 2205 if (!s)
2206 return -1;
2207
2208 s->dgram_dst = saddr;
2209
2210 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2211 "socket: mcast=%s:%d",
2212 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2213 return 0;
2214
2215}
2216
bb9ea79e
AL		 2217typedef struct DumpState {
2218 VLANClientState *pcap_vc;
2219 int fd;
2220 int pcap_caplen;
2221} DumpState;
2222
2223#define PCAP_MAGIC 0xa1b2c3d4
2224
2225struct pcap_file_hdr {
2226 uint32_t magic;
2227 uint16_t version_major;
2228 uint16_t version_minor;
2229 int32_t thiszone;
2230 uint32_t sigfigs;
2231 uint32_t snaplen;
2232 uint32_t linktype;
2233};
2234
2235struct pcap_sf_pkthdr {
2236 struct {
2237 int32_t tv_sec;
2238 int32_t tv_usec;
2239 } ts;
2240 uint32_t caplen;
2241 uint32_t len;
2242};
2243
4f1c942b 2244static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
bb9ea79e 2245{
e3f5ec2b 2246 DumpState *s = vc->opaque;
bb9ea79e
AL		 2247 struct pcap_sf_pkthdr hdr;
2248 int64_t ts;
2249 int caplen;
2250
2251 /* Early return in case of previous error. */
2252 if (s->fd < 0) {
4f1c942b 2253 return size;
bb9ea79e
AL		 2254 }
2255
6ee093c9 2256 ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
bb9ea79e
AL		 2257 caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
2258
37cb6fc3 2259 hdr.ts.tv_sec = ts / 1000000;
bb9ea79e
AL		 2260 hdr.ts.tv_usec = ts % 1000000;
2261 hdr.caplen = caplen;
2262 hdr.len = size;
2263 if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
2264 write(s->fd, buf, caplen) != caplen) {
2265 qemu_log("-net dump write error - stop dump\n");
2266 close(s->fd);
2267 s->fd = -1;
2268 }
4f1c942b
MM		 2269
2270 return size;
bb9ea79e
AL		 2271}
2272
2273static void net_dump_cleanup(VLANClientState *vc)
2274{
2275 DumpState *s = vc->opaque;
2276
2277 close(s->fd);
2278 qemu_free(s);
2279}
2280
10ae5a7a 2281static int net_dump_init(Monitor *mon, VLANState *vlan, const char *device,
bb9ea79e
AL		 2282 const char *name, const char *filename, int len)
2283{
2284 struct pcap_file_hdr hdr;
2285 DumpState *s;
2286
2287 s = qemu_malloc(sizeof(DumpState));
2288
024431b3 2289 s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
bb9ea79e 2290 if (s->fd < 0) {
10ae5a7a 2291 config_error(mon, "-net dump: can't open %s\n", filename);
bb9ea79e
AL		 2292 return -1;
2293 }
2294
2295 s->pcap_caplen = len;
2296
2297 hdr.magic = PCAP_MAGIC;
2298 hdr.version_major = 2;
2299 hdr.version_minor = 4;
2300 hdr.thiszone = 0;
2301 hdr.sigfigs = 0;
2302 hdr.snaplen = s->pcap_caplen;
2303 hdr.linktype = 1;
2304
2305 if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
10ae5a7a 2306 config_error(mon, "-net dump write error: %s\n", strerror(errno));
bb9ea79e
AL		 2307 close(s->fd);
2308 qemu_free(s);
2309 return -1;
2310 }
2311
463af534 2312 s->pcap_vc = qemu_new_vlan_client(vlan, device, name, NULL, dump_receive, NULL,
bb9ea79e
AL		 2313 net_dump_cleanup, s);
2314 snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str),
2315 "dump to %s (len=%d)", filename, len);
2316 return 0;
2317}
2318
63a01ef8 2319/* find or alloc a new VLAN */
1a609520 2320VLANState *qemu_find_vlan(int id, int allocate)
63a01ef8
AL		 2321{
2322 VLANState **pvlan, *vlan;
2323 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2324 if (vlan->id == id)
2325 return vlan;
2326 }
1a609520
JK		 2327 if (!allocate) {
2328 return NULL;
2329 }
63a01ef8 2330 vlan = qemu_mallocz(sizeof(VLANState));
63a01ef8 2331 vlan->id = id;
72cf2d4f 2332 QTAILQ_INIT(&vlan->send_queue);
63a01ef8
AL		 2333 vlan->next = NULL;
2334 pvlan = &first_vlan;
2335 while (*pvlan != NULL)
2336 pvlan = &(*pvlan)->next;
2337 *pvlan = vlan;
2338 return vlan;
2339}
2340
7697079b
AL		 2341static int nic_get_free_idx(void)
2342{
2343 int index;
2344
2345 for (index = 0; index < MAX_NICS; index++)
2346 if (!nd_table[index].used)
2347 return index;
2348 return -1;
2349}
2350
d07f22c5
AL		 2351void qemu_check_nic_model(NICInfo *nd, const char *model)
2352{
2353 const char *models[2];
2354
2355 models[0] = model;
2356 models[1] = NULL;
2357
2358 qemu_check_nic_model_list(nd, models, model);
2359}
2360
9ee05825
MA		 2361int qemu_check_nic_model_list(NICInfo *nd, const char * const *models,
2362 const char *default_model)
d07f22c5
AL		 2363{
2364 int i, exit_status = 0;
2365
2366 if (!nd->model)
2367 nd->model = strdup(default_model);
2368
2369 if (strcmp(nd->model, "?") != 0) {
2370 for (i = 0 ; models[i]; i++)
2371 if (strcmp(nd->model, models[i]) == 0)
9ee05825 2372 return i;
d07f22c5
AL		 2373
2374 fprintf(stderr, "qemu: Unsupported NIC model: %s\n", nd->model);
2375 exit_status = 1;
2376 }
2377
2378 fprintf(stderr, "qemu: Supported NIC models: ");
2379 for (i = 0 ; models[i]; i++)
2380 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
2381
2382 exit(exit_status);
2383}
2384
c1d6eed7
MM		 2385static int net_handle_fd_param(Monitor *mon, const char *param)
2386{
2387 if (!qemu_isdigit(param[0])) {
2388 int fd;
2389
2390 fd = monitor_get_fd(mon, param);
2391 if (fd == -1) {
2392 config_error(mon, "No file descriptor named %s found", param);
2393 return -1;
2394 }
2395
2396 return fd;
2397 } else {
2398 return strtol(param, NULL, 0);
2399 }
2400}
2401
10ae5a7a 2402int net_client_init(Monitor *mon, const char *device, const char *p)
63a01ef8
AL		 2403{
2404 char buf[1024];
2405 int vlan_id, ret;
2406 VLANState *vlan;
7a9f6e4a 2407 char *name = NULL;
63a01ef8
AL		 2408
2409 vlan_id = 0;
2410 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
2411 vlan_id = strtol(buf, NULL, 0);
2412 }
1a609520 2413 vlan = qemu_find_vlan(vlan_id, 1);
9036de1a 2414
7a9f6e4a 2415 if (get_param_value(buf, sizeof(buf), "name", p)) {
10ae5a7a 2416 name = qemu_strdup(buf);
7a9f6e4a 2417 }
63a01ef8 2418 if (!strcmp(device, "nic")) {
8e4416af 2419 static const char * const nic_params[] = {
eb54b6dc 2420 "vlan", "name", "macaddr", "model", "addr", "id", "vectors", NULL
8e4416af 2421 };
63a01ef8
AL		 2422 NICInfo *nd;
2423 uint8_t *macaddr;
7697079b 2424 int idx = nic_get_free_idx();
63a01ef8 2425
0aa7a205 2426 if (check_params(buf, sizeof(buf), nic_params, p) < 0) {
10ae5a7a
JK		 2427 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
2428 ret = -1;
2429 goto out;
8e4416af 2430 }
7697079b 2431 if (idx == -1 || nb_nics >= MAX_NICS) {
10ae5a7a 2432 config_error(mon, "Too Many NICs\n");
771f1339
AL		 2433 ret = -1;
2434 goto out;
63a01ef8 2435 }
7697079b 2436 nd = &nd_table[idx];
63a01ef8
AL		 2437 macaddr = nd->macaddr;
2438 macaddr[0] = 0x52;
2439 macaddr[1] = 0x54;
2440 macaddr[2] = 0x00;
2441 macaddr[3] = 0x12;
2442 macaddr[4] = 0x34;
7697079b 2443 macaddr[5] = 0x56 + idx;
63a01ef8
AL		 2444
2445 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
2446 if (parse_macaddr(macaddr, buf) < 0) {
10ae5a7a 2447 config_error(mon, "invalid syntax for ethernet address\n");
771f1339
AL		 2448 ret = -1;
2449 goto out;
63a01ef8
AL		 2450 }
2451 }
2452 if (get_param_value(buf, sizeof(buf), "model", p)) {
2453 nd->model = strdup(buf);
2454 }
5607c388
MA		 2455 if (get_param_value(buf, sizeof(buf), "addr", p)) {
2456 nd->devaddr = strdup(buf);
2457 }
eb54b6dc
GH		 2458 if (get_param_value(buf, sizeof(buf), "id", p)) {
2459 nd->id = strdup(buf);
2460 }
ffe6370c
MT		 2461 nd->nvectors = NIC_NVECTORS_UNSPECIFIED;
2462 if (get_param_value(buf, sizeof(buf), "vectors", p)) {
2463 char *endptr;
2464 long vectors = strtol(buf, &endptr, 0);
2465 if (*endptr) {
2466 config_error(mon, "invalid syntax for # of vectors\n");
2467 ret = -1;
2468 goto out;
2469 }
2470 if (vectors < 0 || vectors > 0x7ffffff) {
2471 config_error(mon, "invalid # of vectors\n");
2472 ret = -1;
2473 goto out;
2474 }
2475 nd->nvectors = vectors;
2476 }
63a01ef8 2477 nd->vlan = vlan;
7a9f6e4a 2478 nd->name = name;
7697079b 2479 nd->used = 1;
7a9f6e4a 2480 name = NULL;
63a01ef8
AL		 2481 nb_nics++;
2482 vlan->nb_guest_devs++;
4d73cd3b 2483 ret = idx;
63a01ef8
AL		 2484 } else
2485 if (!strcmp(device, "none")) {
8e4416af 2486 if (*p != '\0') {
10ae5a7a
JK		 2487 config_error(mon, "'none' takes no parameters\n");
2488 ret = -1;
2489 goto out;
8e4416af 2490 }
63a01ef8
AL		 2491 /* does nothing. It is needed to signal that no network cards
2492 are wanted */
2493 ret = 0;
2494 } else
2495#ifdef CONFIG_SLIRP
2496 if (!strcmp(device, "user")) {
8e4416af 2497 static const char * const slirp_params[] = {
c92ef6a2
JK		 2498 "vlan", "name", "hostname", "restrict", "ip", "net", "host",
2499 "tftp", "bootfile", "dhcpstart", "dns", "smb", "smbserver",
2500 "hostfwd", "guestfwd", NULL
8e4416af 2501 };
ad196a9d 2502 struct slirp_config_str *config;
c92ef6a2
JK		 2503 int restricted = 0;
2504 char *vnet = NULL;
2505 char *vhost = NULL;
2506 char *vhostname = NULL;
ad196a9d
JK		 2507 char *tftp_export = NULL;
2508 char *bootfile = NULL;
c92ef6a2
JK		 2509 char *vdhcp_start = NULL;
2510 char *vnamesrv = NULL;
ad196a9d 2511 char *smb_export = NULL;
c92ef6a2 2512 char *vsmbsrv = NULL;
ad196a9d 2513 const char *q;
b8e8af38 2514
0aa7a205 2515 if (check_params(buf, sizeof(buf), slirp_params, p) < 0) {
10ae5a7a
JK		 2516 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
2517 ret = -1;
2518 goto out;
8e4416af 2519 }
c92ef6a2 2520 if (get_param_value(buf, sizeof(buf), "ip", p)) {
3da6abd4 2521 int vnet_buflen = strlen(buf) + strlen("/24") + 1;
c92ef6a2 2522 /* emulate legacy parameter */
3da6abd4
BS		 2523 vnet = qemu_malloc(vnet_buflen);
2524 pstrcpy(vnet, vnet_buflen, buf);
2525 pstrcat(vnet, vnet_buflen, "/24");
c92ef6a2
JK		 2526 }
2527 if (get_param_value(buf, sizeof(buf), "net", p)) {
2528 vnet = qemu_strdup(buf);
2529 }
2530 if (get_param_value(buf, sizeof(buf), "host", p)) {
2531 vhost = qemu_strdup(buf);
2532 }
63a01ef8 2533 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
c92ef6a2 2534 vhostname = qemu_strdup(buf);
63a01ef8 2535 }
49ec9b40 2536 if (get_param_value(buf, sizeof(buf), "restrict", p)) {
b8e8af38 2537 restricted = (buf[0] == 'y') ? 1 : 0;
49ec9b40 2538 }
c92ef6a2
JK		 2539 if (get_param_value(buf, sizeof(buf), "dhcpstart", p)) {
2540 vdhcp_start = qemu_strdup(buf);
2541 }
2542 if (get_param_value(buf, sizeof(buf), "dns", p)) {
2543 vnamesrv = qemu_strdup(buf);
49ec9b40 2544 }
ad196a9d
JK		 2545 if (get_param_value(buf, sizeof(buf), "tftp", p)) {
2546 tftp_export = qemu_strdup(buf);
2547 }
2548 if (get_param_value(buf, sizeof(buf), "bootfile", p)) {
2549 bootfile = qemu_strdup(buf);
2550 }
2551 if (get_param_value(buf, sizeof(buf), "smb", p)) {
2552 smb_export = qemu_strdup(buf);
c92ef6a2
JK		 2553 if (get_param_value(buf, sizeof(buf), "smbserver", p)) {
2554 vsmbsrv = qemu_strdup(buf);
2555 }
ad196a9d
JK		 2556 }
2557 q = p;
2558 while (1) {
2559 config = qemu_malloc(sizeof(*config));
2560 if (!get_next_param_value(config->str, sizeof(config->str),
c92ef6a2 2561 "hostfwd", &q)) {
ad196a9d
JK		 2562 break;
2563 }
c92ef6a2 2564 config->flags = SLIRP_CFG_HOSTFWD;
ad196a9d
JK		 2565 config->next = slirp_configs;
2566 slirp_configs = config;
2567 config = NULL;
2568 }
2569 q = p;
2570 while (1) {
2571 config = qemu_malloc(sizeof(*config));
2572 if (!get_next_param_value(config->str, sizeof(config->str),
c92ef6a2 2573 "guestfwd", &q)) {
ad196a9d
JK		 2574 break;
2575 }
2576 config->flags = 0;
2577 config->next = slirp_configs;
2578 slirp_configs = config;
2579 config = NULL;
2580 }
2581 qemu_free(config);
63a01ef8 2582 vlan->nb_host_devs++;
c92ef6a2
JK		 2583 ret = net_slirp_init(mon, vlan, device, name, restricted, vnet, vhost,
2584 vhostname, tftp_export, bootfile, vdhcp_start,
2585 vnamesrv, smb_export, vsmbsrv);
2586 qemu_free(vnet);
2587 qemu_free(vhost);
2588 qemu_free(vhostname);
ad196a9d
JK		 2589 qemu_free(tftp_export);
2590 qemu_free(bootfile);
c92ef6a2
JK		 2591 qemu_free(vdhcp_start);
2592 qemu_free(vnamesrv);
ad196a9d 2593 qemu_free(smb_export);
c92ef6a2 2594 qemu_free(vsmbsrv);
8ca9217d 2595 } else if (!strcmp(device, "channel")) {
72cf2d4f 2596 if (QTAILQ_EMPTY(&slirp_stacks)) {
ad196a9d
JK		 2597 struct slirp_config_str *config;
2598
2599 config = qemu_malloc(sizeof(*config));
2600 pstrcpy(config->str, sizeof(config->str), p);
c92ef6a2 2601 config->flags = SLIRP_CFG_LEGACY;
ad196a9d
JK		 2602 config->next = slirp_configs;
2603 slirp_configs = config;
2604 } else {
72cf2d4f 2605 slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), mon, p, 1);
8ca9217d 2606 }
8ca9217d 2607 ret = 0;
63a01ef8
AL		 2608 } else
2609#endif
2610#ifdef _WIN32
2611 if (!strcmp(device, "tap")) {
8e4416af
AL		 2612 static const char * const tap_params[] = {
2613 "vlan", "name", "ifname", NULL
2614 };
63a01ef8 2615 char ifname[64];
8e4416af 2616
0aa7a205 2617 if (check_params(buf, sizeof(buf), tap_params, p) < 0) {
10ae5a7a
JK		 2618 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
2619 ret = -1;
2620 goto out;
8e4416af 2621 }
63a01ef8 2622 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
10ae5a7a 2623 config_error(mon, "tap: no interface name\n");
771f1339
AL		 2624 ret = -1;
2625 goto out;
63a01ef8
AL		 2626 }
2627 vlan->nb_host_devs++;
7a9f6e4a 2628 ret = tap_win32_init(vlan, device, name, ifname);
63a01ef8 2629 } else
b29fe3ed 2630#elif defined (_AIX)
63a01ef8
AL		 2631#else
2632 if (!strcmp(device, "tap")) {
0aa7a205 2633 char ifname[64], chkbuf[64];
63a01ef8 2634 char setup_script[1024], down_script[1024];
4a77b25e 2635 TAPState *s;
63a01ef8
AL		 2636 int fd;
2637 vlan->nb_host_devs++;
2638 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
0df0ff6d
MM		 2639 static const char * const fd_params[] = {
2640 "vlan", "name", "fd", "sndbuf", NULL
2641 };
c1d6eed7 2642 ret = -1;
0aa7a205 2643 if (check_params(chkbuf, sizeof(chkbuf), fd_params, p) < 0) {
10ae5a7a 2644 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
10ae5a7a 2645 goto out;
8e4416af 2646 }
c1d6eed7
MM		 2647 fd = net_handle_fd_param(mon, buf);
2648 if (fd == -1) {
2649 goto out;
2650 }
63a01ef8 2651 fcntl(fd, F_SETFL, O_NONBLOCK);
4a77b25e 2652 s = net_tap_fd_init(vlan, device, name, fd);
c1d6eed7
MM		 2653 if (!s) {
2654 close(fd);
2655 }
63a01ef8 2656 } else {
8e4416af 2657 static const char * const tap_params[] = {
0df0ff6d 2658 "vlan", "name", "ifname", "script", "downscript", "sndbuf", NULL
8e4416af 2659 };
0aa7a205 2660 if (check_params(chkbuf, sizeof(chkbuf), tap_params, p) < 0) {
10ae5a7a
JK		 2661 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
2662 ret = -1;
2663 goto out;
8e4416af 2664 }
63a01ef8
AL		 2665 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
2666 ifname[0] = '\0';
2667 }
2668 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
2669 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
2670 }
2671 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
2672 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
2673 }
4a77b25e
MM		 2674 s = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
2675 }
2676 if (s != NULL) {
fc5b81d1 2677 const char *sndbuf_str = NULL;
0df0ff6d 2678 if (get_param_value(buf, sizeof(buf), "sndbuf", p)) {
fc5b81d1 2679 sndbuf_str = buf;
0df0ff6d 2680 }
fc5b81d1 2681 tap_set_sndbuf(s, sndbuf_str, mon);
4a77b25e
MM		 2682 ret = 0;
2683 } else {
2684 ret = -1;
63a01ef8
AL		 2685 }
2686 } else
2687#endif
2688 if (!strcmp(device, "socket")) {
0aa7a205 2689 char chkbuf[64];
63a01ef8 2690 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
0df0ff6d
MM		 2691 static const char * const fd_params[] = {
2692 "vlan", "name", "fd", NULL
2693 };
63a01ef8 2694 int fd;
c1d6eed7 2695 ret = -1;
0aa7a205 2696 if (check_params(chkbuf, sizeof(chkbuf), fd_params, p) < 0) {
10ae5a7a 2697 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
10ae5a7a 2698 goto out;
8e4416af 2699 }
c1d6eed7
MM		 2700 fd = net_handle_fd_param(mon, buf);
2701 if (fd == -1) {
2702 goto out;
2703 }
2704 if (!net_socket_fd_init(vlan, device, name, fd, 1)) {
2705 close(fd);
2706 goto out;
2707 }
2708 ret = 0;
63a01ef8 2709 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
8e4416af
AL		 2710 static const char * const listen_params[] = {
2711 "vlan", "name", "listen", NULL
2712 };
0aa7a205 2713 if (check_params(chkbuf, sizeof(chkbuf), listen_params, p) < 0) {
10ae5a7a
JK		 2714 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
2715 ret = -1;
2716 goto out;
8e4416af 2717 }
7a9f6e4a 2718 ret = net_socket_listen_init(vlan, device, name, buf);
63a01ef8 2719 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
8e4416af
AL		 2720 static const char * const connect_params[] = {
2721 "vlan", "name", "connect", NULL
2722 };
0aa7a205 2723 if (check_params(chkbuf, sizeof(chkbuf), connect_params, p) < 0) {
10ae5a7a
JK		 2724 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
2725 ret = -1;
2726 goto out;
8e4416af 2727 }
7a9f6e4a 2728 ret = net_socket_connect_init(vlan, device, name, buf);
63a01ef8 2729 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
8e4416af
AL		 2730 static const char * const mcast_params[] = {
2731 "vlan", "name", "mcast", NULL
2732 };
0aa7a205 2733 if (check_params(chkbuf, sizeof(chkbuf), mcast_params, p) < 0) {
10ae5a7a
JK		 2734 config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
2735 ret = -1;
2736 goto out;
8e4416af 2737 }
7a9f6e4a 2738 ret = net_socket_mcast_init(vlan, device, name, buf);
63a01ef8 2739 } else {
10ae5a7a 2740 config_error(mon, "Unknown socket options: %s\n", p);
771f1339
AL		 2741 ret = -1;
2742 goto out;
63a01ef8
AL		 2743 }
2744 vlan->nb_host_devs++;
2745 } else
2746#ifdef CONFIG_VDE
2747 if (!strcmp(device, "vde")) {
8e4416af
AL		 2748 static const char * const vde_params[] = {
2749 "vlan", "name", "sock", "port", "group", "mode", NULL
2750 };
63a01ef8
AL		 2751 char vde_sock[1024], vde_group[512];
2752 int vde_port, vde_mode;
8e4416af 2753
0aa7a205 2754 if (check_params(buf, sizeof(buf), vde_params, p) < 0) {
10ae5a7a
JK		 2755 config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
2756 ret = -1;
2757 goto out;
8e4416af 2758 }
63a01ef8
AL		 2759 vlan->nb_host_devs++;
2760 if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
2761 vde_sock[0] = '\0';
2762 }
2763 if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
2764 vde_port = strtol(buf, NULL, 10);
2765 } else {
2766 vde_port = 0;
2767 }
2768 if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
2769 vde_group[0] = '\0';
2770 }
2771 if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
2772 vde_mode = strtol(buf, NULL, 8);
2773 } else {
2774 vde_mode = 0700;
2775 }
7a9f6e4a 2776 ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode);
63a01ef8
AL		 2777 } else
2778#endif
bb9ea79e
AL		 2779 if (!strcmp(device, "dump")) {
2780 int len = 65536;
2781
2782 if (get_param_value(buf, sizeof(buf), "len", p) > 0) {
2783 len = strtol(buf, NULL, 0);
2784 }
2785 if (!get_param_value(buf, sizeof(buf), "file", p)) {
2786 snprintf(buf, sizeof(buf), "qemu-vlan%d.pcap", vlan_id);
2787 }
10ae5a7a 2788 ret = net_dump_init(mon, vlan, device, name, buf, len);
bb9ea79e 2789 } else {
10ae5a7a 2790 config_error(mon, "Unknown network device: %s\n", device);
771f1339
AL		 2791 ret = -1;
2792 goto out;
63a01ef8
AL		 2793 }
2794 if (ret < 0) {
10ae5a7a 2795 config_error(mon, "Could not initialize device '%s'\n", device);
63a01ef8 2796 }
771f1339 2797out:
10ae5a7a 2798 qemu_free(name);
63a01ef8
AL		 2799 return ret;
2800}
2801
8b13c4a7
AL		 2802void net_client_uninit(NICInfo *nd)
2803{
2804 nd->vlan->nb_guest_devs--;
2805 nb_nics--;
a9796703
GC		 2806
2807 qemu_free((void *)nd->model);
2808 qemu_free((void *)nd->name);
2809 qemu_free((void *)nd->devaddr);
2810 qemu_free((void *)nd->id);
2811
2812 memset(nd, 0, sizeof(*nd));
8b13c4a7
AL		 2813}
2814
6f338c34
AL		 2815static int net_host_check_device(const char *device)
2816{
2817 int i;
bb9ea79e 2818 const char *valid_param_list[] = { "tap", "socket", "dump"
6f338c34
AL		 2819#ifdef CONFIG_SLIRP
2820 ,"user"
2821#endif
2822#ifdef CONFIG_VDE
2823 ,"vde"
2824#endif
2825 };
2826 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
2827 if (!strncmp(valid_param_list[i], device,
2828 strlen(valid_param_list[i])))
2829 return 1;
2830 }
2831
2832 return 0;
2833}
2834
f18c16de 2835void net_host_device_add(Monitor *mon, const QDict *qdict)
6f338c34 2836{
f18c16de
LC		 2837 const char *device = qdict_get_str(qdict, "device");
2838 const char *opts = qdict_get_try_str(qdict, "opts");
2839
6f338c34 2840 if (!net_host_check_device(device)) {
376253ec 2841 monitor_printf(mon, "invalid host network device %s\n", device);
6f338c34
AL		 2842 return;
2843 }
10ae5a7a 2844 if (net_client_init(mon, device, opts ? opts : "") < 0) {
5c8be678
AL		 2845 monitor_printf(mon, "adding host network device %s failed\n", device);
2846 }
6f338c34
AL		 2847}
2848
f18c16de 2849void net_host_device_remove(Monitor *mon, const QDict *qdict)
6f338c34 2850{
6f338c34 2851 VLANClientState *vc;
f18c16de
LC		 2852 int vlan_id = qdict_get_int(qdict, "vlan_id");
2853 const char *device = qdict_get_str(qdict, "device");
6f338c34 2854
1a609520 2855 vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
6f338c34 2856 if (!vc) {
6f338c34
AL		 2857 return;
2858 }
e8f1f9db
AL		 2859 if (!net_host_check_device(vc->model)) {
2860 monitor_printf(mon, "invalid host network device %s\n", device);
2861 return;
2862 }
6f338c34
AL		 2863 qemu_del_vlan_client(vc);
2864}
2865
63a01ef8
AL		 2866int net_client_parse(const char *str)
2867{
2868 const char *p;
2869 char *q;
2870 char device[64];
2871
2872 p = str;
2873 q = device;
2874 while (*p != '\0' && *p != ',') {
2875 if ((q - device) < sizeof(device) - 1)
2876 *q++ = *p;
2877 p++;
2878 }
2879 *q = '\0';
2880 if (*p == ',')
2881 p++;
2882
10ae5a7a 2883 return net_client_init(NULL, device, p);
63a01ef8
AL		 2884}
2885
406c8df3
GC		 2886void net_set_boot_mask(int net_boot_mask)
2887{
2888 int i;
2889
2890 /* Only the first four NICs may be bootable */
2891 net_boot_mask = net_boot_mask & 0xF;
2892
2893 for (i = 0; i < nb_nics; i++) {
2894 if (net_boot_mask & (1 << i)) {
2895 nd_table[i].bootable = 1;
2896 net_boot_mask &= ~(1 << i);
2897 }
2898 }
2899
2900 if (net_boot_mask) {
2901 fprintf(stderr, "Cannot boot from non-existent NIC\n");
2902 exit(1);
2903 }
2904}
2905
376253ec 2906void do_info_network(Monitor *mon)
63a01ef8
AL		 2907{
2908 VLANState *vlan;
2909 VLANClientState *vc;
2910
2911 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
376253ec 2912 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
63a01ef8 2913 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
376253ec 2914 monitor_printf(mon, " %s: %s\n", vc->name, vc->info_str);
63a01ef8
AL		 2915 }
2916}
2917
f18c16de 2918void do_set_link(Monitor *mon, const QDict *qdict)
436e5e53
AL		 2919{
2920 VLANState *vlan;
2921 VLANClientState *vc = NULL;
f18c16de
LC		 2922 const char *name = qdict_get_str(qdict, "name");
2923 const char *up_or_down = qdict_get_str(qdict, "up_or_down");
436e5e53
AL		 2924
2925 for (vlan = first_vlan; vlan != NULL; vlan = vlan->next)
2926 for (vc = vlan->first_client; vc != NULL; vc = vc->next)
2927 if (strcmp(vc->name, name) == 0)
dd5de373
EI		 2928 goto done;
2929done:
436e5e53
AL		 2930
2931 if (!vc) {
7dc3fa09 2932 monitor_printf(mon, "could not find network device '%s'\n", name);
c3cf0d3f 2933 return;
436e5e53
AL		 2934 }
2935
2936 if (strcmp(up_or_down, "up") == 0)
2937 vc->link_down = 0;
2938 else if (strcmp(up_or_down, "down") == 0)
2939 vc->link_down = 1;
2940 else
376253ec
AL		 2941 monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
2942 "valid\n", up_or_down);
436e5e53 2943
34b25ca7
AL		 2944 if (vc->link_status_changed)
2945 vc->link_status_changed(vc);
436e5e53
AL		 2946}
2947
63a01ef8
AL		 2948void net_cleanup(void)
2949{
2950 VLANState *vlan;
2951
63a01ef8
AL		 2952 /* close network clients */
2953 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
b946a153 2954 VLANClientState *vc = vlan->first_client;
63a01ef8 2955
b946a153
AL		 2956 while (vc) {
2957 VLANClientState *next = vc->next;
63a01ef8 2958
b946a153
AL		 2959 qemu_del_vlan_client(vc);
2960
2961 vc = next;
63a01ef8
AL		 2962 }
2963 }
63a01ef8
AL		 2964}
2965
2966void net_client_check(void)
2967{
2968 VLANState *vlan;
2969
2970 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2971 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
2972 continue;
2973 if (vlan->nb_guest_devs == 0)
2974 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
2975 if (vlan->nb_host_devs == 0)
2976 fprintf(stderr,
2977 "Warning: vlan %d is not connected to host network\n",
2978 vlan->id);
2979 }
2980}
Empty description
This page took 0.588738 seconds and 4 git commands to generate.