]> git.proxmox.com Git - qemu.git/blame - net.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Send a RARP packet after migration.
[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"
f83c6e10 113#include "qemu-config.h"
511d2b14 114
d918f23e 115#include "slirp/libslirp.h"
511d2b14 116
5610c3aa 117static QTAILQ_HEAD(, VLANState) vlans;
577c4af9 118static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
63a01ef8
AL		 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
5610c3aa 289 QTAILQ_FOREACH(vlan, &vlans, next) {
676cff29
AL		 290 VLANClientState *vc;
291
5610c3aa
MM		 292 QTAILQ_FOREACH(vc, &vlan->clients, next) {
293 if (vc != vc1 && strcmp(vc->model, model) == 0) {
676cff29 294 id++;
5610c3aa
MM		 295 }
296 }
676cff29
AL		 297 }
298
299 snprintf(buf, sizeof(buf), "%s.%d", model, id);
300
02374aa0 301 return qemu_strdup(buf);
676cff29
AL		 302}
303
9a6ecb30
MM		 304static ssize_t qemu_deliver_packet(VLANClientState *sender,
305 const uint8_t *data,
306 size_t size,
307 void *opaque);
308static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
309 const struct iovec *iov,
310 int iovcnt,
311 void *opaque);
312
63a01ef8 313VLANClientState *qemu_new_vlan_client(VLANState *vlan,
283c7c63 314 VLANClientState *peer,
bf38c1a0 315 const char *model,
7a9f6e4a 316 const char *name,
cda9046b
MM		 317 NetCanReceive *can_receive,
318 NetReceive *receive,
319 NetReceiveIOV *receive_iov,
b946a153 320 NetCleanup *cleanup,
63a01ef8
AL		 321 void *opaque)
322{
5610c3aa
MM		 323 VLANClientState *vc;
324
63a01ef8 325 vc = qemu_mallocz(sizeof(VLANClientState));
5610c3aa 326
02374aa0 327 vc->model = qemu_strdup(model);
7a9f6e4a 328 if (name)
02374aa0 329 vc->name = qemu_strdup(name);
7a9f6e4a
AL		 330 else
331 vc->name = assign_name(vc, model);
cda9046b
MM		 332 vc->can_receive = can_receive;
333 vc->receive = receive;
334 vc->receive_iov = receive_iov;
b946a153 335 vc->cleanup = cleanup;
63a01ef8 336 vc->opaque = opaque;
5610c3aa 337
d80b9fc6 338 if (vlan) {
283c7c63 339 assert(!peer);
d80b9fc6
MM		 340 vc->vlan = vlan;
341 QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
577c4af9 342 } else {
283c7c63
MM		 343 if (peer) {
344 vc->peer = peer;
345 peer->peer = vc;
346 }
577c4af9 347 QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
9a6ecb30
MM		 348
349 vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
350 qemu_deliver_packet_iov,
351 vc);
d80b9fc6 352 }
63a01ef8 353
63a01ef8
AL		 354 return vc;
355}
356
357void qemu_del_vlan_client(VLANClientState *vc)
358{
d80b9fc6
MM		 359 if (vc->vlan) {
360 QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
577c4af9 361 } else {
9a6ecb30
MM		 362 if (vc->send_queue) {
363 qemu_del_net_queue(vc->send_queue);
364 }
577c4af9 365 QTAILQ_REMOVE(&non_vlan_clients, vc, next);
283c7c63
MM		 366 if (vc->peer) {
367 vc->peer->peer = NULL;
368 }
d80b9fc6 369 }
63a01ef8 370
5610c3aa
MM		 371 if (vc->cleanup) {
372 vc->cleanup(vc);
373 }
374
375 qemu_free(vc->name);
376 qemu_free(vc->model);
377 qemu_free(vc);
63a01ef8
AL		 378}
379
8b13c4a7
AL		 380VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
381{
5610c3aa 382 VLANClientState *vc;
8b13c4a7 383
5610c3aa
MM		 384 QTAILQ_FOREACH(vc, &vlan->clients, next) {
385 if (vc->opaque == opaque) {
386 return vc;
387 }
388 }
8b13c4a7
AL		 389
390 return NULL;
391}
392
1a609520
JK		 393static VLANClientState *
394qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
395 const char *client_str)
396{
397 VLANState *vlan;
398 VLANClientState *vc;
399
400 vlan = qemu_find_vlan(vlan_id, 0);
401 if (!vlan) {
402 monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
403 return NULL;
404 }
405
5610c3aa 406 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1a609520
JK		 407 if (!strcmp(vc->name, client_str)) {
408 break;
409 }
410 }
411 if (!vc) {
412 monitor_printf(mon, "can't find device %s on VLAN %d\n",
413 client_str, vlan_id);
414 }
415
416 return vc;
417}
418
2e1e0641 419int qemu_can_send_packet(VLANClientState *sender)
63a01ef8 420{
2e1e0641 421 VLANState *vlan = sender->vlan;
63a01ef8
AL		 422 VLANClientState *vc;
423
9a6ecb30
MM		 424 if (sender->peer) {
425 if (!sender->peer->can_receive ||
426 sender->peer->can_receive(sender->peer)) {
427 return 1;
428 } else {
429 return 0;
430 }
431 }
432
d80b9fc6
MM		 433 if (!sender->vlan) {
434 return 1;
435 }
436
5610c3aa 437 QTAILQ_FOREACH(vc, &vlan->clients, next) {
2e1e0641
MM		 438 if (vc == sender) {
439 continue;
440 }
441
cda9046b 442 /* no can_receive() handler, they can always receive */
e3f5ec2b 443 if (!vc->can_receive || vc->can_receive(vc)) {
2e1e0641 444 return 1;
63a01ef8
AL		 445 }
446 }
447 return 0;
448}
449
9a6ecb30
MM		 450static ssize_t qemu_deliver_packet(VLANClientState *sender,
451 const uint8_t *data,
452 size_t size,
453 void *opaque)
454{
455 VLANClientState *vc = opaque;
456
457 if (vc->link_down) {
458 return size;
459 }
460
461 return vc->receive(vc, data, size);
462}
463
f7105843
MM		 464static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
465 const uint8_t *buf,
466 size_t size,
467 void *opaque)
63a01ef8 468{
f7105843 469 VLANState *vlan = opaque;
63a01ef8 470 VLANClientState *vc;
3e021d40 471 int ret = -1;
63a01ef8 472
f7105843 473 QTAILQ_FOREACH(vc, &vlan->clients, next) {
3e021d40
MM		 474 ssize_t len;
475
476 if (vc == sender) {
477 continue;
764a4d1d 478 }
3e021d40
MM		 479
480 if (vc->link_down) {
481 ret = size;
482 continue;
483 }
484
485 len = vc->receive(vc, buf, size);
486
487 ret = (ret >= 0) ? ret : len;
764a4d1d 488 }
3e021d40
MM		 489
490 return ret;
764a4d1d
AL		 491}
492
8cad5516
MM		 493void qemu_purge_queued_packets(VLANClientState *vc)
494{
9a6ecb30
MM		 495 NetQueue *queue;
496
497 if (!vc->peer && !vc->vlan) {
d80b9fc6 498 return;
9a6ecb30 499 }
d80b9fc6 500
9a6ecb30
MM		 501 if (vc->peer) {
502 queue = vc->peer->send_queue;
503 } else {
504 queue = vc->vlan->send_queue;
505 }
506
507 qemu_net_queue_purge(queue, vc);
8cad5516
MM		 508}
509
f3b6c7fc 510void qemu_flush_queued_packets(VLANClientState *vc)
e94667b9 511{
9a6ecb30
MM		 512 NetQueue *queue;
513
514 if (vc->vlan) {
515 queue = vc->vlan->send_queue;
516 } else {
517 queue = vc->send_queue;
518 }
d80b9fc6 519
9a6ecb30 520 qemu_net_queue_flush(queue);
e94667b9
MM		 521}
522
f3b6c7fc
MM		 523ssize_t qemu_send_packet_async(VLANClientState *sender,
524 const uint8_t *buf, int size,
525 NetPacketSent *sent_cb)
764a4d1d 526{
9a6ecb30 527 NetQueue *queue;
436e5e53 528
63a01ef8 529#ifdef DEBUG_NET
d80b9fc6 530 printf("qemu_send_packet_async:\n");
63a01ef8
AL		 531 hex_dump(stdout, buf, size);
532#endif
f3b6c7fc 533
9a6ecb30
MM		 534 if (sender->link_down || (!sender->peer && !sender->vlan)) {
535 return size;
536 }
537
538 if (sender->peer) {
539 queue = sender->peer->send_queue;
540 } else {
541 queue = sender->vlan->send_queue;
542 }
543
544 return qemu_net_queue_send(queue, sender, buf, size, sent_cb);
f3b6c7fc
MM		 545}
546
547void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
548{
549 qemu_send_packet_async(vc, buf, size, NULL);
63a01ef8
AL		 550}
551
fbe78f4f
AL		 552static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
553 int iovcnt)
554{
555 uint8_t buffer[4096];
556 size_t offset = 0;
557 int i;
558
559 for (i = 0; i < iovcnt; i++) {
560 size_t len;
561
562 len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
563 memcpy(buffer + offset, iov[i].iov_base, len);
564 offset += len;
565 }
566
f3b6c7fc 567 return vc->receive(vc, buffer, offset);
fbe78f4f
AL		 568}
569
e0e7877a
AL		 570static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
571{
572 size_t offset = 0;
573 int i;
574
575 for (i = 0; i < iovcnt; i++)
576 offset += iov[i].iov_len;
577 return offset;
578}
579
9a6ecb30
MM		 580static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
581 const struct iovec *iov,
582 int iovcnt,
583 void *opaque)
584{
585 VLANClientState *vc = opaque;
586
587 if (vc->link_down) {
588 return calc_iov_length(iov, iovcnt);
589 }
590
591 if (vc->receive_iov) {
592 return vc->receive_iov(vc, iov, iovcnt);
593 } else {
594 return vc_sendv_compat(vc, iov, iovcnt);
595 }
596}
597
f7105843
MM		 598static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
599 const struct iovec *iov,
600 int iovcnt,
601 void *opaque)
fbe78f4f 602{
f7105843 603 VLANState *vlan = opaque;
fbe78f4f 604 VLANClientState *vc;
f7105843 605 ssize_t ret = -1;
e94667b9 606
f7105843 607 QTAILQ_FOREACH(vc, &vlan->clients, next) {
e94667b9
MM		 608 ssize_t len;
609
610 if (vc == sender) {
611 continue;
612 }
613
614 if (vc->link_down) {
615 ret = calc_iov_length(iov, iovcnt);
616 continue;
617 }
618
619 if (vc->receive_iov) {
620 len = vc->receive_iov(vc, iov, iovcnt);
621 } else {
622 len = vc_sendv_compat(vc, iov, iovcnt);
623 }
624
625 ret = (ret >= 0) ? ret : len;
626 }
627
e94667b9
MM		 628 return ret;
629}
630
f3b6c7fc
MM		 631ssize_t qemu_sendv_packet_async(VLANClientState *sender,
632 const struct iovec *iov, int iovcnt,
633 NetPacketSent *sent_cb)
e94667b9 634{
9a6ecb30
MM		 635 NetQueue *queue;
636
637 if (sender->link_down || (!sender->peer && !sender->vlan)) {
e94667b9
MM		 638 return calc_iov_length(iov, iovcnt);
639 }
640
9a6ecb30
MM		 641 if (sender->peer) {
642 queue = sender->peer->send_queue;
643 } else {
644 queue = sender->vlan->send_queue;
645 }
646
647 return qemu_net_queue_send_iov(queue, sender, iov, iovcnt, sent_cb);
fbe78f4f
AL		 648}
649
f3b6c7fc
MM		 650ssize_t
651qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
652{
653 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
654}
655
63a01ef8
AL		 656#if defined(CONFIG_SLIRP)
657
658/* slirp network adapter */
659
c92ef6a2
JK		 660#define SLIRP_CFG_HOSTFWD 1
661#define SLIRP_CFG_LEGACY 2
ad196a9d 662
b8e8af38
JK		 663struct slirp_config_str {
664 struct slirp_config_str *next;
ad196a9d
JK		 665 int flags;
666 char str[1024];
c92ef6a2 667 int legacy_format;
b8e8af38
JK		 668};
669
9f8bd042 670typedef struct SlirpState {
72cf2d4f 671 QTAILQ_ENTRY(SlirpState) entry;
9f8bd042
JK		 672 VLANClientState *vc;
673 Slirp *slirp;
28432466
JK		 674#ifndef _WIN32
675 char smb_dir[128];
676#endif
9f8bd042
JK		 677} SlirpState;
678
ad196a9d
JK		 679static struct slirp_config_str *slirp_configs;
680const char *legacy_tftp_prefix;
681const char *legacy_bootp_filename;
72cf2d4f
BS		 682static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
683 QTAILQ_HEAD_INITIALIZER(slirp_stacks);
63a01ef8 684
fb12577c 685static int slirp_hostfwd(SlirpState *s, const char *redir_str,
0752706d 686 int legacy_format);
fb12577c 687static int slirp_guestfwd(SlirpState *s, const char *config_str,
3c6a0580 688 int legacy_format);
ad196a9d 689
c5b76b38 690#ifndef _WIN32
ad196a9d
JK		 691static const char *legacy_smb_export;
692
fb12577c 693static int slirp_smb(SlirpState *s, const char *exported_dir,
0752706d 694 struct in_addr vserver_addr);
28432466
JK		 695static void slirp_smb_cleanup(SlirpState *s);
696#else
697static inline void slirp_smb_cleanup(SlirpState *s) { }
c5b76b38 698#endif
b8e8af38 699
9f8bd042 700int slirp_can_output(void *opaque)
63a01ef8 701{
9f8bd042
JK		 702 SlirpState *s = opaque;
703
704 return qemu_can_send_packet(s->vc);
63a01ef8
AL		 705}
706
9f8bd042 707void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
63a01ef8 708{
9f8bd042
JK		 709 SlirpState *s = opaque;
710
63a01ef8
AL		 711#ifdef DEBUG_SLIRP
712 printf("slirp output:\n");
713 hex_dump(stdout, pkt, pkt_len);
714#endif
9f8bd042 715 qemu_send_packet(s->vc, pkt, pkt_len);
63a01ef8
AL		 716}
717
4f1c942b 718static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 719{
9f8bd042
JK		 720 SlirpState *s = vc->opaque;
721
63a01ef8
AL		 722#ifdef DEBUG_SLIRP
723 printf("slirp input:\n");
724 hex_dump(stdout, buf, size);
725#endif
9f8bd042 726 slirp_input(s->slirp, buf, size);
4f1c942b 727 return size;
63a01ef8
AL		 728}
729
8d6249a7
AL		 730static void net_slirp_cleanup(VLANClientState *vc)
731{
ad0d8c4c
JK		 732 SlirpState *s = vc->opaque;
733
734 slirp_cleanup(s->slirp);
28432466 735 slirp_smb_cleanup(s);
72cf2d4f 736 QTAILQ_REMOVE(&slirp_stacks, s, entry);
ad0d8c4c 737 qemu_free(s);
8d6249a7
AL		 738}
739
fb12577c 740static int net_slirp_init(VLANState *vlan, const char *model,
c92ef6a2
JK		 741 const char *name, int restricted,
742 const char *vnetwork, const char *vhost,
743 const char *vhostname, const char *tftp_export,
744 const char *bootfile, const char *vdhcp_start,
745 const char *vnameserver, const char *smb_export,
746 const char *vsmbserver)
63a01ef8 747{
ad0d8c4c 748 /* default settings according to historic slirp */
8389e7f4
AL		 749 struct in_addr net = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
750 struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
ad0d8c4c
JK		 751 struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
752 struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
753 struct in_addr dns = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
c92ef6a2 754#ifndef _WIN32
ad0d8c4c 755 struct in_addr smbsrv = { .s_addr = 0 };
c92ef6a2 756#endif
ad0d8c4c
JK		 757 SlirpState *s;
758 char buf[20];
759 uint32_t addr;
760 int shift;
761 char *end;
3a179c66 762 struct slirp_config_str *config;
ad0d8c4c
JK		 763
764 if (!tftp_export) {
765 tftp_export = legacy_tftp_prefix;
766 }
767 if (!bootfile) {
768 bootfile = legacy_bootp_filename;
769 }
c92ef6a2 770
ad0d8c4c
JK		 771 if (vnetwork) {
772 if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
773 if (!inet_aton(vnetwork, &net)) {
774 return -1;
775 }
776 addr = ntohl(net.s_addr);
777 if (!(addr & 0x80000000)) {
778 mask.s_addr = htonl(0xff000000); /* class A */
779 } else if ((addr & 0xfff00000) == 0xac100000) {
780 mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
781 } else if ((addr & 0xc0000000) == 0x80000000) {
782 mask.s_addr = htonl(0xffff0000); /* class B */
783 } else if ((addr & 0xffff0000) == 0xc0a80000) {
784 mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
785 } else if ((addr & 0xffff0000) == 0xc6120000) {
786 mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
787 } else if ((addr & 0xe0000000) == 0xe0000000) {
788 mask.s_addr = htonl(0xffffff00); /* class C */
c92ef6a2 789 } else {
ad0d8c4c
JK		 790 mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
791 }
792 } else {
793 if (!inet_aton(buf, &net)) {
794 return -1;
795 }
796 shift = strtol(vnetwork, &end, 10);
797 if (*end != '\0') {
798 if (!inet_aton(vnetwork, &mask)) {
c92ef6a2 799 return -1;
c92ef6a2 800 }
ad0d8c4c
JK		 801 } else if (shift < 4 || shift > 32) {
802 return -1;
803 } else {
804 mask.s_addr = htonl(0xffffffff << (32 - shift));
c92ef6a2 805 }
c92ef6a2 806 }
ad0d8c4c
JK		 807 net.s_addr &= mask.s_addr;
808 host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
809 dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
810 dns.s_addr = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
811 }
c92ef6a2 812
ad0d8c4c
JK		 813 if (vhost && !inet_aton(vhost, &host)) {
814 return -1;
815 }
816 if ((host.s_addr & mask.s_addr) != net.s_addr) {
817 return -1;
818 }
c92ef6a2 819
ad0d8c4c
JK		 820 if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
821 return -1;
822 }
823 if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||
824 dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
825 return -1;
826 }
c92ef6a2 827
ad0d8c4c
JK		 828 if (vnameserver && !inet_aton(vnameserver, &dns)) {
829 return -1;
830 }
831 if ((dns.s_addr & mask.s_addr) != net.s_addr ||
832 dns.s_addr == host.s_addr) {
833 return -1;
834 }
c92ef6a2
JK		 835
836#ifndef _WIN32
ad0d8c4c
JK		 837 if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
838 return -1;
839 }
c92ef6a2
JK		 840#endif
841
ad0d8c4c
JK		 842 s = qemu_mallocz(sizeof(SlirpState));
843 s->slirp = slirp_init(restricted, net, mask, host, vhostname,
844 tftp_export, bootfile, dhcp, dns, s);
72cf2d4f 845 QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
b8e8af38 846
3a179c66 847 for (config = slirp_configs; config; config = config->next) {
ad0d8c4c 848 if (config->flags & SLIRP_CFG_HOSTFWD) {
fb12577c 849 if (slirp_hostfwd(s, config->str,
0752706d
MA		 850 config->flags & SLIRP_CFG_LEGACY) < 0)
851 return -1;
ad0d8c4c 852 } else {
fb12577c 853 if (slirp_guestfwd(s, config->str,
0752706d
MA		 854 config->flags & SLIRP_CFG_LEGACY) < 0)
855 return -1;
b8e8af38 856 }
ad0d8c4c 857 }
b8e8af38 858#ifndef _WIN32
ad0d8c4c
JK		 859 if (!smb_export) {
860 smb_export = legacy_smb_export;
861 }
862 if (smb_export) {
fb12577c 863 if (slirp_smb(s, smb_export, smbsrv) < 0)
0752706d 864 return -1;
63a01ef8 865 }
ad0d8c4c 866#endif
b8e8af38 867
283c7c63
MM		 868 s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
869 slirp_receive, NULL,
9f8bd042 870 net_slirp_cleanup, s);
fc57bc57
JK		 871 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
872 "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');
63a01ef8
AL		 873 return 0;
874}
875
f13b572c
JK		 876static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
877 const char *stack)
878{
879 VLANClientState *vc;
880
881 if (vlan) {
882 vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
883 if (!vc) {
884 return NULL;
885 }
886 if (strcmp(vc->model, "user")) {
887 monitor_printf(mon, "invalid device specified\n");
888 return NULL;
889 }
890 return vc->opaque;
891 } else {
72cf2d4f 892 if (QTAILQ_EMPTY(&slirp_stacks)) {
f13b572c
JK		 893 monitor_printf(mon, "user mode network stack not in use\n");
894 return NULL;
895 }
72cf2d4f 896 return QTAILQ_FIRST(&slirp_stacks);
f13b572c
JK		 897 }
898}
899
1d4daa91 900void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
c1261d8d 901{
3c6a0580 902 struct in_addr host_addr = { .s_addr = INADDR_ANY };
c1261d8d
AG		 903 int host_port;
904 char buf[256] = "";
f13b572c
JK		 905 const char *src_str, *p;
906 SlirpState *s;
c1261d8d 907 int is_udp = 0;
9c12a6f2 908 int err;
1d4daa91
LC		 909 const char *arg1 = qdict_get_str(qdict, "arg1");
910 const char *arg2 = qdict_get_try_str(qdict, "arg2");
911 const char *arg3 = qdict_get_try_str(qdict, "arg3");
c1261d8d 912
f13b572c
JK		 913 if (arg2) {
914 s = slirp_lookup(mon, arg1, arg2);
915 src_str = arg3;
916 } else {
917 s = slirp_lookup(mon, NULL, NULL);
918 src_str = arg1;
919 }
920 if (!s) {
c1261d8d 921 return;
f3546deb 922 }
c1261d8d 923
3c6a0580 924 if (!src_str || !src_str[0])
c1261d8d
AG		 925 goto fail_syntax;
926
f13b572c 927 p = src_str;
c1261d8d
AG		 928 get_str_sep(buf, sizeof(buf), &p, ':');
929
930 if (!strcmp(buf, "tcp") || buf[0] == '\0') {
931 is_udp = 0;
932 } else if (!strcmp(buf, "udp")) {
933 is_udp = 1;
934 } else {
935 goto fail_syntax;
936 }
937
3c6a0580
JK		 938 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
939 goto fail_syntax;
940 }
941 if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
942 goto fail_syntax;
943 }
944
c1261d8d
AG		 945 host_port = atoi(p);
946
72cf2d4f 947 err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
9f8bd042 948 host_addr, host_port);
c1261d8d 949
9c12a6f2
JK		 950 monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
951 err ? "removed" : "not found");
c1261d8d
AG		 952 return;
953
954 fail_syntax:
955 monitor_printf(mon, "invalid format\n");
956}
957
fb12577c 958static int slirp_hostfwd(SlirpState *s, const char *redir_str,
0752706d 959 int legacy_format)
63a01ef8 960{
3c6a0580 961 struct in_addr host_addr = { .s_addr = INADDR_ANY };
c92ef6a2 962 struct in_addr guest_addr = { .s_addr = 0 };
63a01ef8 963 int host_port, guest_port;
b8e8af38 964 const char *p;
c92ef6a2 965 char buf[256];
b8e8af38 966 int is_udp;
c92ef6a2 967 char *end;
1c6ed9f3 968
63a01ef8 969 p = redir_str;
f13b572c 970 if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
d4ebe193 971 goto fail_syntax;
b8e8af38 972 }
d4ebe193 973 if (!strcmp(buf, "tcp") || buf[0] == '\0') {
63a01ef8
AL		 974 is_udp = 0;
975 } else if (!strcmp(buf, "udp")) {
976 is_udp = 1;
977 } else {
d4ebe193 978 goto fail_syntax;
63a01ef8
AL		 979 }
980
3c6a0580
JK		 981 if (!legacy_format) {
982 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
983 goto fail_syntax;
984 }
985 if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
986 goto fail_syntax;
987 }
988 }
989
990 if (get_str_sep(buf, sizeof(buf), &p, legacy_format ? ':' : '-') < 0) {
d4ebe193 991 goto fail_syntax;
b8e8af38 992 }
c92ef6a2
JK		 993 host_port = strtol(buf, &end, 0);
994 if (*end != '\0' || host_port < 1 || host_port > 65535) {
d4ebe193 995 goto fail_syntax;
b8e8af38 996 }
63a01ef8 997
b8e8af38 998 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
d4ebe193 999 goto fail_syntax;
b8e8af38 1000 }
c92ef6a2 1001 if (buf[0] != '\0' && !inet_aton(buf, &guest_addr)) {
d4ebe193 1002 goto fail_syntax;
b8e8af38 1003 }
63a01ef8 1004
c92ef6a2
JK		 1005 guest_port = strtol(p, &end, 0);
1006 if (*end != '\0' || guest_port < 1 || guest_port > 65535) {
d4ebe193 1007 goto fail_syntax;
b8e8af38 1008 }
63a01ef8 1009
9f8bd042
JK		 1010 if (slirp_add_hostfwd(s->slirp, is_udp, host_addr, host_port, guest_addr,
1011 guest_port) < 0) {
fb12577c
MA		 1012 qemu_error("could not set up host forwarding rule '%s'\n",
1013 redir_str);
0752706d 1014 return -1;
63a01ef8 1015 }
0752706d 1016 return 0;
d4ebe193
AL		 1017
1018 fail_syntax:
fb12577c 1019 qemu_error("invalid host forwarding rule '%s'\n", redir_str);
0752706d 1020 return -1;
63a01ef8
AL		 1021}
1022
1d4daa91 1023void net_slirp_hostfwd_add(Monitor *mon, const QDict *qdict)
b8e8af38 1024{
f13b572c
JK		 1025 const char *redir_str;
1026 SlirpState *s;
1d4daa91
LC		 1027 const char *arg1 = qdict_get_str(qdict, "arg1");
1028 const char *arg2 = qdict_get_try_str(qdict, "arg2");
1029 const char *arg3 = qdict_get_try_str(qdict, "arg3");
f13b572c
JK		 1030
1031 if (arg2) {
1032 s = slirp_lookup(mon, arg1, arg2);
1033 redir_str = arg3;
1034 } else {
1035 s = slirp_lookup(mon, NULL, NULL);
1036 redir_str = arg1;
1037 }
1038 if (s) {
fb12577c 1039 slirp_hostfwd(s, redir_str, 0);
b8e8af38
JK		 1040 }
1041
f3546deb
JK		 1042}
1043
0752706d 1044int net_slirp_redir(const char *redir_str)
f3546deb
JK		 1045{
1046 struct slirp_config_str *config;
1047
72cf2d4f 1048 if (QTAILQ_EMPTY(&slirp_stacks)) {
f3546deb
JK		 1049 config = qemu_malloc(sizeof(*config));
1050 pstrcpy(config->str, sizeof(config->str), redir_str);
3c6a0580 1051 config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
f3546deb
JK		 1052 config->next = slirp_configs;
1053 slirp_configs = config;
0752706d 1054 return 0;
b8e8af38
JK		 1055 }
1056
fb12577c 1057 return slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), redir_str, 1);
b8e8af38
JK		 1058}
1059
63a01ef8
AL		 1060#ifndef _WIN32
1061
63a01ef8 1062/* automatic user mode samba server configuration */
28432466 1063static void slirp_smb_cleanup(SlirpState *s)
63a01ef8 1064{
28432466 1065 char cmd[128];
09c18925 1066
28432466
JK		 1067 if (s->smb_dir[0] != '\0') {
1068 snprintf(cmd, sizeof(cmd), "rm -rf %s", s->smb_dir);
1069 system(cmd);
1070 s->smb_dir[0] = '\0';
1071 }
63a01ef8
AL		 1072}
1073
fb12577c 1074static int slirp_smb(SlirpState* s, const char *exported_dir,
0752706d 1075 struct in_addr vserver_addr)
63a01ef8 1076{
28432466
JK		 1077 static int instance;
1078 char smb_conf[128];
1079 char smb_cmdline[128];
63a01ef8
AL		 1080 FILE *f;
1081
28432466
JK		 1082 snprintf(s->smb_dir, sizeof(s->smb_dir), "/tmp/qemu-smb.%ld-%d",
1083 (long)getpid(), instance++);
1084 if (mkdir(s->smb_dir, 0700) < 0) {
fb12577c 1085 qemu_error("could not create samba server dir '%s'\n", s->smb_dir);
0752706d 1086 return -1;
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);
fb12577c
MA		 1093 qemu_error("could not create samba server configuration file '%s'\n",
1094 smb_conf);
0752706d 1095 return -1;
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);
fb12577c 1125 qemu_error("conflicting/invalid smbserver address\n");
0752706d 1126 return -1;
c92ef6a2 1127 }
0752706d 1128 return 0;
63a01ef8
AL		 1129}
1130
ad196a9d 1131/* automatic user mode samba server configuration (legacy interface) */
0752706d 1132int net_slirp_smb(const char *exported_dir)
b8e8af38 1133{
c92ef6a2
JK		 1134 struct in_addr vserver_addr = { .s_addr = 0 };
1135
ad196a9d 1136 if (legacy_smb_export) {
b8e8af38 1137 fprintf(stderr, "-smb given twice\n");
0752706d 1138 return -1;
b8e8af38 1139 }
ad196a9d 1140 legacy_smb_export = exported_dir;
72cf2d4f 1141 if (!QTAILQ_EMPTY(&slirp_stacks)) {
fb12577c 1142 return slirp_smb(QTAILQ_FIRST(&slirp_stacks), exported_dir,
0752706d 1143 vserver_addr);
b8e8af38 1144 }
0752706d 1145 return 0;
b8e8af38
JK		 1146}
1147
63a01ef8 1148#endif /* !defined(_WIN32) */
b8e8af38 1149
c92ef6a2 1150struct GuestFwd {
8ca9217d 1151 CharDriverState *hd;
c92ef6a2 1152 struct in_addr server;
8ca9217d 1153 int port;
9f8bd042 1154 Slirp *slirp;
511d2b14 1155};
8ca9217d 1156
c92ef6a2 1157static int guestfwd_can_read(void *opaque)
8ca9217d 1158{
c92ef6a2 1159 struct GuestFwd *fwd = opaque;
9f8bd042 1160 return slirp_socket_can_recv(fwd->slirp, fwd->server, fwd->port);
8ca9217d
AL		 1161}
1162
c92ef6a2 1163static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
8ca9217d 1164{
c92ef6a2 1165 struct GuestFwd *fwd = opaque;
9f8bd042 1166 slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
8ca9217d
AL		 1167}
1168
fb12577c 1169static int slirp_guestfwd(SlirpState *s, const char *config_str,
0752706d 1170 int legacy_format)
ad196a9d 1171{
c92ef6a2
JK		 1172 struct in_addr server = { .s_addr = 0 };
1173 struct GuestFwd *fwd;
1174 const char *p;
1175 char buf[128];
1176 char *end;
ad196a9d
JK		 1177 int port;
1178
c92ef6a2
JK		 1179 p = config_str;
1180 if (legacy_format) {
1181 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1182 goto fail_syntax;
1183 }
1184 } else {
1185 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1186 goto fail_syntax;
1187 }
1188 if (strcmp(buf, "tcp") && buf[0] != '\0') {
1189 goto fail_syntax;
1190 }
1191 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1192 goto fail_syntax;
1193 }
1194 if (buf[0] != '\0' && !inet_aton(buf, &server)) {
1195 goto fail_syntax;
1196 }
1197 if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
1198 goto fail_syntax;
1199 }
1200 }
1201 port = strtol(buf, &end, 10);
1202 if (*end != '\0' || port < 1 || port > 65535) {
1203 goto fail_syntax;
ad196a9d 1204 }
ad196a9d 1205
c92ef6a2
JK		 1206 fwd = qemu_malloc(sizeof(struct GuestFwd));
1207 snprintf(buf, sizeof(buf), "guestfwd.tcp:%d", port);
1208 fwd->hd = qemu_chr_open(buf, p, NULL);
1209 if (!fwd->hd) {
fb12577c 1210 qemu_error("could not open guest forwarding device '%s'\n", buf);
c92ef6a2 1211 qemu_free(fwd);
0752706d 1212 return -1;
ad196a9d 1213 }
ad196a9d 1214
bb53fc53 1215 if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) {
fb12577c
MA		 1216 qemu_error("conflicting/invalid host:port in guest forwarding "
1217 "rule '%s'\n", config_str);
c92ef6a2 1218 qemu_free(fwd);
0752706d 1219 return -1;
c92ef6a2 1220 }
bb53fc53
JK		 1221 fwd->server = server;
1222 fwd->port = port;
1223 fwd->slirp = s->slirp;
1224
c92ef6a2
JK		 1225 qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
1226 NULL, fwd);
0752706d 1227 return 0;
c92ef6a2
JK		 1228
1229 fail_syntax:
fb12577c 1230 qemu_error("invalid guest forwarding rule '%s'\n", config_str);
0752706d 1231 return -1;
ad196a9d
JK		 1232}
1233
6dbe553f
JK		 1234void do_info_usernet(Monitor *mon)
1235{
b1c99fcd 1236 SlirpState *s;
9f8bd042 1237
72cf2d4f 1238 QTAILQ_FOREACH(s, &slirp_stacks, entry) {
b1c99fcd
JK		 1239 monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
1240 slirp_connection_info(s->slirp, mon);
9f8bd042 1241 }
6dbe553f
JK		 1242}
1243
63a01ef8
AL		 1244#endif /* CONFIG_SLIRP */
1245
1246#if !defined(_WIN32)
1247
1248typedef struct TAPState {
1249 VLANClientState *vc;
1250 int fd;
1251 char down_script[1024];
973cbd37 1252 char down_script_arg[128];
5b01e886 1253 uint8_t buf[4096];
b664e367 1254 unsigned int read_poll : 1;
1f7babf6 1255 unsigned int write_poll : 1;
63a01ef8
AL		 1256} TAPState;
1257
b946a153
AL		 1258static int launch_script(const char *setup_script, const char *ifname, int fd);
1259
b664e367
MM		 1260static int tap_can_send(void *opaque);
1261static void tap_send(void *opaque);
1f7babf6 1262static void tap_writable(void *opaque);
b664e367
MM		 1263
1264static void tap_update_fd_handler(TAPState *s)
1265{
1266 qemu_set_fd_handler2(s->fd,
1267 s->read_poll ? tap_can_send : NULL,
1268 s->read_poll ? tap_send : NULL,
1f7babf6 1269 s->write_poll ? tap_writable : NULL,
b664e367
MM		 1270 s);
1271}
1272
1273static void tap_read_poll(TAPState *s, int enable)
1274{
1275 s->read_poll = !!enable;
1276 tap_update_fd_handler(s);
1277}
1278
1f7babf6
MM		 1279static void tap_write_poll(TAPState *s, int enable)
1280{
1281 s->write_poll = !!enable;
1282 tap_update_fd_handler(s);
1283}
1284
1285static void tap_writable(void *opaque)
1286{
1287 TAPState *s = opaque;
1288
1289 tap_write_poll(s, 0);
1290
1291 qemu_flush_queued_packets(s->vc);
1292}
1293
e3f5ec2b 1294static ssize_t tap_receive_iov(VLANClientState *vc, const struct iovec *iov,
b535b7b2
AL		 1295 int iovcnt)
1296{
e3f5ec2b 1297 TAPState *s = vc->opaque;
b535b7b2
AL		 1298 ssize_t len;
1299
1300 do {
1301 len = writev(s->fd, iov, iovcnt);
1f7babf6
MM		 1302 } while (len == -1 && errno == EINTR);
1303
1304 if (len == -1 && errno == EAGAIN) {
1305 tap_write_poll(s, 1);
1306 return 0;
1307 }
b535b7b2
AL		 1308
1309 return len;
1310}
b535b7b2 1311
4f1c942b 1312static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1313{
e3f5ec2b 1314 TAPState *s = vc->opaque;
4f1c942b
MM		 1315 ssize_t len;
1316
1317 do {
1318 len = write(s->fd, buf, size);
1319 } while (len == -1 && (errno == EINTR || errno == EAGAIN));
1320
1321 return len;
63a01ef8
AL		 1322}
1323
3471b757
MM		 1324static int tap_can_send(void *opaque)
1325{
1326 TAPState *s = opaque;
1327
1328 return qemu_can_send_packet(s->vc);
1329}
1330
63a01ef8 1331#ifdef __sun__
5a6d8815
MM		 1332static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1333{
63a01ef8
AL		 1334 struct strbuf sbuf;
1335 int f = 0;
5a6d8815
MM		 1336
1337 sbuf.maxlen = maxlen;
3f4cb3d3 1338 sbuf.buf = (char *)buf;
5a6d8815
MM		 1339
1340 return getmsg(tapfd, NULL, &sbuf, &f) >= 0 ? sbuf.len : -1;
1341}
63a01ef8 1342#else
5a6d8815
MM		 1343static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1344{
1345 return read(tapfd, buf, maxlen);
1346}
63a01ef8 1347#endif
5a6d8815 1348
783527a9 1349static void tap_send_completed(VLANClientState *vc, ssize_t len)
e19eb224
MM		 1350{
1351 TAPState *s = vc->opaque;
b664e367 1352 tap_read_poll(s, 1);
e19eb224
MM		 1353}
1354
5a6d8815
MM		 1355static void tap_send(void *opaque)
1356{
1357 TAPState *s = opaque;
5a6d8815
MM		 1358 int size;
1359
e19eb224
MM		 1360 do {
1361 size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
1362 if (size <= 0) {
1363 break;
1364 }
1365
1366 size = qemu_send_packet_async(s->vc, s->buf, size, tap_send_completed);
1367 if (size == 0) {
b664e367 1368 tap_read_poll(s, 0);
e19eb224
MM		 1369 }
1370 } while (size > 0);
63a01ef8
AL		 1371}
1372
0df0ff6d 1373#ifdef TUNSETSNDBUF
fc5b81d1
MM		 1374/* sndbuf should be set to a value lower than the tx queue
1375 * capacity of any destination network interface.
1376 * Ethernet NICs generally have txqueuelen=1000, so 1Mb is
1377 * a good default, given a 1500 byte MTU.
1378 */
1379#define TAP_DEFAULT_SNDBUF 1024*1024
1380
8a1c5235 1381static int tap_set_sndbuf(TAPState *s, QemuOpts *opts)
fc5b81d1 1382{
8a1c5235 1383 int sndbuf;
fc5b81d1 1384
8a1c5235 1385 sndbuf = qemu_opt_get_size(opts, "sndbuf", TAP_DEFAULT_SNDBUF);
fc5b81d1
MM		 1386 if (!sndbuf) {
1387 sndbuf = INT_MAX;
1388 }
1389
8a1c5235 1390 if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1 && qemu_opt_get(opts, "sndbuf")) {
fb12577c 1391 qemu_error("TUNSETSNDBUF ioctl failed: %s\n", strerror(errno));
0752706d 1392 return -1;
0df0ff6d 1393 }
0752706d 1394 return 0;
fc5b81d1 1395}
0df0ff6d 1396#else
8a1c5235 1397static int tap_set_sndbuf(TAPState *s, QemuOpts *opts)
fc5b81d1 1398{
0752706d 1399 return 0;
0df0ff6d 1400}
fc5b81d1 1401#endif /* TUNSETSNDBUF */
0df0ff6d 1402
b946a153
AL		 1403static void tap_cleanup(VLANClientState *vc)
1404{
1405 TAPState *s = vc->opaque;
1406
b9adce2c
MM		 1407 qemu_purge_queued_packets(vc);
1408
b946a153
AL		 1409 if (s->down_script[0])
1410 launch_script(s->down_script, s->down_script_arg, s->fd);
1411
b664e367 1412 tap_read_poll(s, 0);
1f7babf6 1413 tap_write_poll(s, 0);
b946a153
AL		 1414 close(s->fd);
1415 qemu_free(s);
1416}
1417
63a01ef8
AL		 1418/* fd support */
1419
7a9f6e4a
AL		 1420static TAPState *net_tap_fd_init(VLANState *vlan,
1421 const char *model,
1422 const char *name,
1423 int fd)
63a01ef8
AL		 1424{
1425 TAPState *s;
1426
1427 s = qemu_mallocz(sizeof(TAPState));
63a01ef8 1428 s->fd = fd;
283c7c63
MM		 1429 s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
1430 tap_receive, tap_receive_iov,
1431 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;
dd51058d
MM		 1749 char *init_group = (char *)group;
1750 char *init_sock = (char *)sock;
63a01ef8
AL		 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 }
283c7c63
MM		 1764 s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
1765 vde_receive, NULL,
1766 vde_cleanup, s);
63a01ef8 1767 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
7cb7434b 1768 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
63a01ef8
AL		 1769 sock, vde_datafd(s->vde));
1770 return 0;
1771}
1772#endif
1773
1774/* network connection */
1775typedef struct NetSocketState {
1776 VLANClientState *vc;
1777 int fd;
1778 int state; /* 0 = getting length, 1 = getting data */
abcd2baa
AL		 1779 unsigned int index;
1780 unsigned int packet_len;
63a01ef8
AL		 1781 uint8_t buf[4096];
1782 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1783} NetSocketState;
1784
1785typedef struct NetSocketListenState {
1786 VLANState *vlan;
bf38c1a0 1787 char *model;
7a9f6e4a 1788 char *name;
63a01ef8
AL		 1789 int fd;
1790} NetSocketListenState;
1791
1792/* XXX: we consider we can send the whole packet without blocking */
4f1c942b 1793static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1794{
e3f5ec2b 1795 NetSocketState *s = vc->opaque;
63a01ef8
AL		 1796 uint32_t len;
1797 len = htonl(size);
1798
1799 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4f1c942b 1800 return send_all(s->fd, buf, size);
63a01ef8
AL		 1801}
1802
4f1c942b 1803static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1804{
e3f5ec2b 1805 NetSocketState *s = vc->opaque;
4f1c942b 1806
70503264 1807 return sendto(s->fd, (const void *)buf, size, 0,
4f1c942b 1808 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
63a01ef8
AL		 1809}
1810
1811static void net_socket_send(void *opaque)
1812{
1813 NetSocketState *s = opaque;
abcd2baa
AL		 1814 int size, err;
1815 unsigned l;
63a01ef8
AL		 1816 uint8_t buf1[4096];
1817 const uint8_t *buf;
1818
c5b76b38 1819 size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
63a01ef8
AL		 1820 if (size < 0) {
1821 err = socket_error();
1822 if (err != EWOULDBLOCK)
1823 goto eoc;
1824 } else if (size == 0) {
1825 /* end of connection */
1826 eoc:
1827 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1828 closesocket(s->fd);
1829 return;
1830 }
1831 buf = buf1;
1832 while (size > 0) {
1833 /* reassemble a packet from the network */
1834 switch(s->state) {
1835 case 0:
1836 l = 4 - s->index;
1837 if (l > size)
1838 l = size;
1839 memcpy(s->buf + s->index, buf, l);
1840 buf += l;
1841 size -= l;
1842 s->index += l;
1843 if (s->index == 4) {
1844 /* got length */
1845 s->packet_len = ntohl(*(uint32_t *)s->buf);
1846 s->index = 0;
1847 s->state = 1;
1848 }
1849 break;
1850 case 1:
1851 l = s->packet_len - s->index;
1852 if (l > size)
1853 l = size;
abcd2baa
AL		 1854 if (s->index + l <= sizeof(s->buf)) {
1855 memcpy(s->buf + s->index, buf, l);
1856 } else {
1857 fprintf(stderr, "serious error: oversized packet received,"
1858 "connection terminated.\n");
1859 s->state = 0;
1860 goto eoc;
1861 }
1862
63a01ef8
AL		 1863 s->index += l;
1864 buf += l;
1865 size -= l;
1866 if (s->index >= s->packet_len) {
1867 qemu_send_packet(s->vc, s->buf, s->packet_len);
1868 s->index = 0;
1869 s->state = 0;
1870 }
1871 break;
1872 }
1873 }
1874}
1875
1876static void net_socket_send_dgram(void *opaque)
1877{
1878 NetSocketState *s = opaque;
1879 int size;
1880
c5b76b38 1881 size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
63a01ef8
AL		 1882 if (size < 0)
1883 return;
1884 if (size == 0) {
1885 /* end of connection */
1886 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1887 return;
1888 }
1889 qemu_send_packet(s->vc, s->buf, size);
1890}
1891
1892static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1893{
1894 struct ip_mreq imr;
1895 int fd;
1896 int val, ret;
1897 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1898 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1899 inet_ntoa(mcastaddr->sin_addr),
1900 (int)ntohl(mcastaddr->sin_addr.s_addr));
1901 return -1;
1902
1903 }
1904 fd = socket(PF_INET, SOCK_DGRAM, 0);
1905 if (fd < 0) {
1906 perror("socket(PF_INET, SOCK_DGRAM)");
1907 return -1;
1908 }
1909
1910 val = 1;
1911 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1912 (const char *)&val, sizeof(val));
1913 if (ret < 0) {
1914 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1915 goto fail;
1916 }
1917
1918 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1919 if (ret < 0) {
1920 perror("bind");
1921 goto fail;
1922 }
1923
1924 /* Add host to multicast group */
1925 imr.imr_multiaddr = mcastaddr->sin_addr;
1926 imr.imr_interface.s_addr = htonl(INADDR_ANY);
1927
1928 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1929 (const char *)&imr, sizeof(struct ip_mreq));
1930 if (ret < 0) {
1931 perror("setsockopt(IP_ADD_MEMBERSHIP)");
1932 goto fail;
1933 }
1934
1935 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1936 val = 1;
1937 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1938 (const char *)&val, sizeof(val));
1939 if (ret < 0) {
1940 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1941 goto fail;
1942 }
1943
1944 socket_set_nonblock(fd);
1945 return fd;
1946fail:
1947 if (fd >= 0)
1948 closesocket(fd);
1949 return -1;
1950}
1951
b946a153
AL		 1952static void net_socket_cleanup(VLANClientState *vc)
1953{
1954 NetSocketState *s = vc->opaque;
1955 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1956 close(s->fd);
1957 qemu_free(s);
1958}
1959
7a9f6e4a
AL		 1960static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
1961 const char *model,
1962 const char *name,
bf38c1a0 1963 int fd, int is_connected)
63a01ef8
AL		 1964{
1965 struct sockaddr_in saddr;
1966 int newfd;
1967 socklen_t saddr_len;
1968 NetSocketState *s;
1969
1970 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1971 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1972 * by ONLY ONE process: we must "clone" this dgram socket --jjo
1973 */
1974
1975 if (is_connected) {
1976 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1977 /* must be bound */
1978 if (saddr.sin_addr.s_addr==0) {
1979 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1980 fd);
1981 return NULL;
1982 }
1983 /* clone dgram socket */
1984 newfd = net_socket_mcast_create(&saddr);
1985 if (newfd < 0) {
1986 /* error already reported by net_socket_mcast_create() */
1987 close(fd);
1988 return NULL;
1989 }
1990 /* clone newfd to fd, close newfd */
1991 dup2(newfd, fd);
1992 close(newfd);
1993
1994 } else {
1995 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1996 fd, strerror(errno));
1997 return NULL;
1998 }
1999 }
2000
2001 s = qemu_mallocz(sizeof(NetSocketState));
63a01ef8
AL		 2002 s->fd = fd;
2003
283c7c63
MM		 2004 s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
2005 net_socket_receive_dgram, NULL,
2006 net_socket_cleanup, s);
63a01ef8
AL		 2007 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2008
2009 /* mcast: save bound address as dst */
2010 if (is_connected) s->dgram_dst=saddr;
2011
2012 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2013 "socket: fd=%d (%s mcast=%s:%d)",
2014 fd, is_connected? "cloned" : "",
2015 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2016 return s;
2017}
2018
2019static void net_socket_connect(void *opaque)
2020{
2021 NetSocketState *s = opaque;
2022 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2023}
2024
7a9f6e4a
AL		 2025static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
2026 const char *model,
2027 const char *name,
bf38c1a0 2028 int fd, int is_connected)
63a01ef8
AL		 2029{
2030 NetSocketState *s;
2031 s = qemu_mallocz(sizeof(NetSocketState));
63a01ef8 2032 s->fd = fd;
283c7c63
MM		 2033 s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
2034 net_socket_receive, NULL,
2035 net_socket_cleanup, s);
63a01ef8
AL		 2036 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2037 "socket: fd=%d", fd);
2038 if (is_connected) {
2039 net_socket_connect(s);
2040 } else {
2041 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2042 }
2043 return s;
2044}
2045
7a9f6e4a
AL		 2046static NetSocketState *net_socket_fd_init(VLANState *vlan,
2047 const char *model, const char *name,
bf38c1a0 2048 int fd, int is_connected)
63a01ef8 2049{
acedcfbf 2050 int so_type = -1, optlen=sizeof(so_type);
63a01ef8
AL		 2051
2052 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
2053 (socklen_t *)&optlen)< 0) {
2054 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
2055 return NULL;
2056 }
2057 switch(so_type) {
2058 case SOCK_DGRAM:
7a9f6e4a 2059 return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
63a01ef8 2060 case SOCK_STREAM:
7a9f6e4a 2061 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
63a01ef8
AL		 2062 default:
2063 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2064 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
7a9f6e4a 2065 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
63a01ef8
AL		 2066 }
2067 return NULL;
2068}
2069
2070static void net_socket_accept(void *opaque)
2071{
2072 NetSocketListenState *s = opaque;
2073 NetSocketState *s1;
2074 struct sockaddr_in saddr;
2075 socklen_t len;
2076 int fd;
2077
2078 for(;;) {
2079 len = sizeof(saddr);
2080 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2081 if (fd < 0 && errno != EINTR) {
2082 return;
2083 } else if (fd >= 0) {
2084 break;
2085 }
2086 }
7a9f6e4a 2087 s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
63a01ef8
AL		 2088 if (!s1) {
2089 closesocket(fd);
2090 } else {
2091 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2092 "socket: connection from %s:%d",
2093 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2094 }
2095}
2096
7a9f6e4a
AL		 2097static int net_socket_listen_init(VLANState *vlan,
2098 const char *model,
2099 const char *name,
bf38c1a0 2100 const char *host_str)
63a01ef8
AL		 2101{
2102 NetSocketListenState *s;
2103 int fd, val, ret;
2104 struct sockaddr_in saddr;
2105
2106 if (parse_host_port(&saddr, host_str) < 0)
2107 return -1;
2108
2109 s = qemu_mallocz(sizeof(NetSocketListenState));
63a01ef8
AL		 2110
2111 fd = socket(PF_INET, SOCK_STREAM, 0);
2112 if (fd < 0) {
2113 perror("socket");
2114 return -1;
2115 }
2116 socket_set_nonblock(fd);
2117
2118 /* allow fast reuse */
2119 val = 1;
2120 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2121
2122 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2123 if (ret < 0) {
2124 perror("bind");
2125 return -1;
2126 }
2127 ret = listen(fd, 0);
2128 if (ret < 0) {
2129 perror("listen");
2130 return -1;
2131 }
2132 s->vlan = vlan;
02374aa0
MM		 2133 s->model = qemu_strdup(model);
2134 s->name = name ? qemu_strdup(name) : NULL;
63a01ef8
AL		 2135 s->fd = fd;
2136 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2137 return 0;
2138}
2139
7a9f6e4a
AL		 2140static int net_socket_connect_init(VLANState *vlan,
2141 const char *model,
2142 const char *name,
bf38c1a0 2143 const char *host_str)
63a01ef8
AL		 2144{
2145 NetSocketState *s;
2146 int fd, connected, ret, err;
2147 struct sockaddr_in saddr;
2148
2149 if (parse_host_port(&saddr, host_str) < 0)
2150 return -1;
2151
2152 fd = socket(PF_INET, SOCK_STREAM, 0);
2153 if (fd < 0) {
2154 perror("socket");
2155 return -1;
2156 }
2157 socket_set_nonblock(fd);
2158
2159 connected = 0;
2160 for(;;) {
2161 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2162 if (ret < 0) {
2163 err = socket_error();
2164 if (err == EINTR || err == EWOULDBLOCK) {
2165 } else if (err == EINPROGRESS) {
2166 break;
2167#ifdef _WIN32
2168 } else if (err == WSAEALREADY) {
2169 break;
2170#endif
2171 } else {
2172 perror("connect");
2173 closesocket(fd);
2174 return -1;
2175 }
2176 } else {
2177 connected = 1;
2178 break;
2179 }
2180 }
7a9f6e4a 2181 s = net_socket_fd_init(vlan, model, name, fd, connected);
63a01ef8
AL		 2182 if (!s)
2183 return -1;
2184 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2185 "socket: connect to %s:%d",
2186 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2187 return 0;
2188}
2189
7a9f6e4a
AL		 2190static int net_socket_mcast_init(VLANState *vlan,
2191 const char *model,
2192 const char *name,
bf38c1a0 2193 const char *host_str)
63a01ef8
AL		 2194{
2195 NetSocketState *s;
2196 int fd;
2197 struct sockaddr_in saddr;
2198
2199 if (parse_host_port(&saddr, host_str) < 0)
2200 return -1;
2201
2202
2203 fd = net_socket_mcast_create(&saddr);
2204 if (fd < 0)
2205 return -1;
2206
7a9f6e4a 2207 s = net_socket_fd_init(vlan, model, name, fd, 0);
63a01ef8
AL		 2208 if (!s)
2209 return -1;
2210
2211 s->dgram_dst = saddr;
2212
2213 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2214 "socket: mcast=%s:%d",
2215 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2216 return 0;
2217
2218}
2219
bb9ea79e
AL		 2220typedef struct DumpState {
2221 VLANClientState *pcap_vc;
2222 int fd;
2223 int pcap_caplen;
2224} DumpState;
2225
2226#define PCAP_MAGIC 0xa1b2c3d4
2227
2228struct pcap_file_hdr {
2229 uint32_t magic;
2230 uint16_t version_major;
2231 uint16_t version_minor;
2232 int32_t thiszone;
2233 uint32_t sigfigs;
2234 uint32_t snaplen;
2235 uint32_t linktype;
2236};
2237
2238struct pcap_sf_pkthdr {
2239 struct {
2240 int32_t tv_sec;
2241 int32_t tv_usec;
2242 } ts;
2243 uint32_t caplen;
2244 uint32_t len;
2245};
2246
4f1c942b 2247static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
bb9ea79e 2248{
e3f5ec2b 2249 DumpState *s = vc->opaque;
bb9ea79e
AL		 2250 struct pcap_sf_pkthdr hdr;
2251 int64_t ts;
2252 int caplen;
2253
2254 /* Early return in case of previous error. */
2255 if (s->fd < 0) {
4f1c942b 2256 return size;
bb9ea79e
AL		 2257 }
2258
6ee093c9 2259 ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
bb9ea79e
AL		 2260 caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
2261
37cb6fc3 2262 hdr.ts.tv_sec = ts / 1000000;
bb9ea79e
AL		 2263 hdr.ts.tv_usec = ts % 1000000;
2264 hdr.caplen = caplen;
2265 hdr.len = size;
2266 if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
2267 write(s->fd, buf, caplen) != caplen) {
2268 qemu_log("-net dump write error - stop dump\n");
2269 close(s->fd);
2270 s->fd = -1;
2271 }
4f1c942b
MM		 2272
2273 return size;
bb9ea79e
AL		 2274}
2275
2276static void net_dump_cleanup(VLANClientState *vc)
2277{
2278 DumpState *s = vc->opaque;
2279
2280 close(s->fd);
2281 qemu_free(s);
2282}
2283
fb12577c 2284static int net_dump_init(VLANState *vlan, const char *device,
bb9ea79e
AL		 2285 const char *name, const char *filename, int len)
2286{
2287 struct pcap_file_hdr hdr;
2288 DumpState *s;
2289
2290 s = qemu_malloc(sizeof(DumpState));
2291
024431b3 2292 s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
bb9ea79e 2293 if (s->fd < 0) {
fb12577c 2294 qemu_error("-net dump: can't open %s\n", filename);
bb9ea79e
AL		 2295 return -1;
2296 }
2297
2298 s->pcap_caplen = len;
2299
2300 hdr.magic = PCAP_MAGIC;
2301 hdr.version_major = 2;
2302 hdr.version_minor = 4;
2303 hdr.thiszone = 0;
2304 hdr.sigfigs = 0;
2305 hdr.snaplen = s->pcap_caplen;
2306 hdr.linktype = 1;
2307
2308 if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
fb12577c 2309 qemu_error("-net dump write error: %s\n", strerror(errno));
bb9ea79e
AL		 2310 close(s->fd);
2311 qemu_free(s);
2312 return -1;
2313 }
2314
283c7c63
MM		 2315 s->pcap_vc = qemu_new_vlan_client(vlan, NULL, device, name, NULL,
2316 dump_receive, NULL,
bb9ea79e
AL		 2317 net_dump_cleanup, s);
2318 snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str),
2319 "dump to %s (len=%d)", filename, len);
2320 return 0;
2321}
2322
63a01ef8 2323/* find or alloc a new VLAN */
1a609520 2324VLANState *qemu_find_vlan(int id, int allocate)
63a01ef8 2325{
5610c3aa
MM		 2326 VLANState *vlan;
2327
2328 QTAILQ_FOREACH(vlan, &vlans, next) {
2329 if (vlan->id == id) {
63a01ef8 2330 return vlan;
5610c3aa 2331 }
63a01ef8 2332 }
5610c3aa 2333
1a609520
JK		 2334 if (!allocate) {
2335 return NULL;
2336 }
5610c3aa 2337
63a01ef8 2338 vlan = qemu_mallocz(sizeof(VLANState));
63a01ef8 2339 vlan->id = id;
5610c3aa 2340 QTAILQ_INIT(&vlan->clients);
f7105843
MM		 2341
2342 vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
2343 qemu_vlan_deliver_packet_iov,
2344 vlan);
5610c3aa
MM		 2345
2346 QTAILQ_INSERT_TAIL(&vlans, vlan, next);
2347
63a01ef8
AL		 2348 return vlan;
2349}
2350
5869c4d5
MM		 2351static VLANClientState *qemu_find_netdev(const char *id)
2352{
2353 VLANClientState *vc;
2354
2355 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
2356 if (!strcmp(vc->name, id)) {
2357 return vc;
2358 }
2359 }
2360
2361 return NULL;
2362}
2363
7697079b
AL		 2364static int nic_get_free_idx(void)
2365{
2366 int index;
2367
2368 for (index = 0; index < MAX_NICS; index++)
2369 if (!nd_table[index].used)
2370 return index;
2371 return -1;
2372}
2373
07caea31
MA		 2374int qemu_show_nic_models(const char *arg, const char *const *models)
2375{
2376 int i;
2377
2378 if (!arg || strcmp(arg, "?"))
2379 return 0;
2380
2381 fprintf(stderr, "qemu: Supported NIC models: ");
2382 for (i = 0 ; models[i]; i++)
2383 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
2384 return 1;
2385}
2386
d07f22c5
AL		 2387void qemu_check_nic_model(NICInfo *nd, const char *model)
2388{
2389 const char *models[2];
2390
2391 models[0] = model;
2392 models[1] = NULL;
2393
07caea31
MA		 2394 if (qemu_show_nic_models(nd->model, models))
2395 exit(0);
2396 if (qemu_find_nic_model(nd, models, model) < 0)
2397 exit(1);
d07f22c5
AL		 2398}
2399
07caea31
MA		 2400int qemu_find_nic_model(NICInfo *nd, const char * const *models,
2401 const char *default_model)
d07f22c5 2402{
07caea31 2403 int i;
d07f22c5
AL		 2404
2405 if (!nd->model)
32a8e14a 2406 nd->model = qemu_strdup(default_model);
d07f22c5 2407
07caea31
MA		 2408 for (i = 0 ; models[i]; i++) {
2409 if (strcmp(nd->model, models[i]) == 0)
2410 return i;
d07f22c5
AL		 2411 }
2412
07caea31
MA		 2413 qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
2414 return -1;
d07f22c5
AL		 2415}
2416
c1d6eed7
MM		 2417static int net_handle_fd_param(Monitor *mon, const char *param)
2418{
2419 if (!qemu_isdigit(param[0])) {
2420 int fd;
2421
2422 fd = monitor_get_fd(mon, param);
2423 if (fd == -1) {
fb12577c 2424 qemu_error("No file descriptor named %s found", param);
c1d6eed7
MM		 2425 return -1;
2426 }
2427
2428 return fd;
2429 } else {
2430 return strtol(param, NULL, 0);
2431 }
2432}
2433
f6b134ac
MM		 2434static int net_init_nic(QemuOpts *opts,
2435 Monitor *mon,
2436 const char *name,
2437 VLANState *vlan)
f83c6e10
MM		 2438{
2439 int idx;
2440 NICInfo *nd;
5869c4d5 2441 const char *netdev;
f83c6e10
MM		 2442
2443 idx = nic_get_free_idx();
2444 if (idx == -1 || nb_nics >= MAX_NICS) {
2445 qemu_error("Too Many NICs\n");
2446 return -1;
2447 }
2448
2449 nd = &nd_table[idx];
2450
2451 memset(nd, 0, sizeof(*nd));
2452
5869c4d5
MM		 2453 if ((netdev = qemu_opt_get(opts, "netdev"))) {
2454 nd->netdev = qemu_find_netdev(netdev);
2455 if (!nd->netdev) {
2456 qemu_error("netdev '%s' not found\n", netdev);
2457 return -1;
2458 }
2459 } else {
2460 assert(vlan);
2461 nd->vlan = vlan;
2462 }
6d952ebe
MM		 2463 if (name) {
2464 nd->name = qemu_strdup(name);
2465 }
f83c6e10
MM		 2466 if (qemu_opt_get(opts, "model")) {
2467 nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
2468 }
2469 if (qemu_opt_get(opts, "addr")) {
2470 nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
2471 }
2472
2473 nd->macaddr[0] = 0x52;
2474 nd->macaddr[1] = 0x54;
2475 nd->macaddr[2] = 0x00;
2476 nd->macaddr[3] = 0x12;
2477 nd->macaddr[4] = 0x34;
2478 nd->macaddr[5] = 0x56 + idx;
2479
2480 if (qemu_opt_get(opts, "macaddr") &&
2481 parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
2482 qemu_error("invalid syntax for ethernet address\n");
2483 return -1;
2484 }
2485
2486 nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
2487 if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
2488 (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
2489 qemu_error("invalid # of vectors: %d\n", nd->nvectors);
2490 return -1;
2491 }
2492
2493 nd->used = 1;
5869c4d5
MM		 2494 if (vlan) {
2495 nd->vlan->nb_guest_devs++;
2496 }
f83c6e10
MM		 2497 nb_nics++;
2498
2499 return idx;
2500}
2501
a3a766e7 2502#if defined(CONFIG_SLIRP)
ec302ffd
MM		 2503static int net_init_slirp_configs(const char *name, const char *value, void *opaque)
2504{
2505 struct slirp_config_str *config;
2506
2507 if (strcmp(name, "hostfwd") != 0 && strcmp(name, "guestfwd") != 0) {
2508 return 0;
2509 }
2510
2511 config = qemu_mallocz(sizeof(*config));
2512
2513 pstrcpy(config->str, sizeof(config->str), value);
2514
2515 if (!strcmp(name, "hostfwd")) {
2516 config->flags = SLIRP_CFG_HOSTFWD;
2517 }
2518
2519 config->next = slirp_configs;
2520 slirp_configs = config;
2521
2522 return 0;
2523}
2524
f6b134ac
MM		 2525static int net_init_slirp(QemuOpts *opts,
2526 Monitor *mon,
2527 const char *name,
2528 VLANState *vlan)
ec302ffd 2529{
ec302ffd 2530 struct slirp_config_str *config;
ec302ffd
MM		 2531 const char *vhost;
2532 const char *vhostname;
2533 const char *vdhcp_start;
2534 const char *vnamesrv;
2535 const char *tftp_export;
2536 const char *bootfile;
2537 const char *smb_export;
2538 const char *vsmbsrv;
2539 char *vnet = NULL;
2540 int restricted = 0;
2541 int ret;
2542
ec302ffd
MM		 2543 vhost = qemu_opt_get(opts, "host");
2544 vhostname = qemu_opt_get(opts, "hostname");
2545 vdhcp_start = qemu_opt_get(opts, "dhcpstart");
2546 vnamesrv = qemu_opt_get(opts, "dns");
2547 tftp_export = qemu_opt_get(opts, "tftp");
2548 bootfile = qemu_opt_get(opts, "bootfile");
2549 smb_export = qemu_opt_get(opts, "smb");
2550 vsmbsrv = qemu_opt_get(opts, "smbserver");
2551
2552 if (qemu_opt_get(opts, "ip")) {
2553 const char *ip = qemu_opt_get(opts, "ip");
2554 int l = strlen(ip) + strlen("/24") + 1;
2555
2556 vnet = qemu_malloc(l);
2557
2558 /* emulate legacy ip= parameter */
2559 pstrcpy(vnet, l, ip);
2560 pstrcat(vnet, l, "/24");
2561 }
2562
2563 if (qemu_opt_get(opts, "net")) {
2564 if (vnet) {
2565 qemu_free(vnet);
2566 }
2567 vnet = qemu_strdup(qemu_opt_get(opts, "net"));
2568 }
2569
2570 if (qemu_opt_get(opts, "restrict") &&
2571 qemu_opt_get(opts, "restrict")[0] == 'y') {
2572 restricted = 1;
2573 }
2574
2575 qemu_opt_foreach(opts, net_init_slirp_configs, NULL, 0);
2576
2577 ret = net_slirp_init(vlan, "user", name, restricted, vnet, vhost,
2578 vhostname, tftp_export, bootfile, vdhcp_start,
2579 vnamesrv, smb_export, vsmbsrv);
2580
2581 while (slirp_configs) {
2582 config = slirp_configs;
2583 slirp_configs = config->next;
2584 qemu_free(config);
2585 }
2586
f6b134ac 2587 if (ret != -1 && vlan) {
ec302ffd
MM		 2588 vlan->nb_host_devs++;
2589 }
2590
2591 qemu_free(vnet);
2592
2593 return ret;
2594}
a3a766e7 2595#endif /* CONFIG_SLIRP */
ec302ffd 2596
8a1c5235 2597#ifdef _WIN32
f6b134ac
MM		 2598static int net_init_tap_win32(QemuOpts *opts,
2599 Monitor *mon,
2600 const char *name,
2601 VLANState *vlan)
8a1c5235 2602{
8a1c5235
MM		 2603 const char *ifname;
2604
8a1c5235
MM		 2605 ifname = qemu_opt_get(opts, "ifname");
2606
2607 if (!ifname) {
2608 qemu_error("tap: no interface name\n");
2609 return -1;
2610 }
2611
2612 if (tap_win32_init(vlan, "tap", name, ifname) == -1) {
2613 return -1;
2614 }
2615
f6b134ac
MM		 2616 if (vlan) {
2617 vlan->nb_host_devs++;
2618 }
8a1c5235
MM		 2619
2620 return 0;
2621}
2622#elif !defined(_AIX)
f6b134ac
MM		 2623static int net_init_tap(QemuOpts *opts,
2624 Monitor *mon,
2625 const char *name,
2626 VLANState *vlan)
8a1c5235 2627{
8a1c5235
MM		 2628 TAPState *s;
2629
8a1c5235
MM		 2630 if (qemu_opt_get(opts, "fd")) {
2631 int fd;
2632
2633 if (qemu_opt_get(opts, "ifname") ||
2634 qemu_opt_get(opts, "script") ||
2635 qemu_opt_get(opts, "downscript")) {
2636 qemu_error("ifname=, script= and downscript= is invalid with fd=\n");
2637 return -1;
2638 }
2639
2640 fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2641 if (fd == -1) {
2642 return -1;
2643 }
2644
2645 fcntl(fd, F_SETFL, O_NONBLOCK);
2646
2647 s = net_tap_fd_init(vlan, "tap", name, fd);
2648 if (!s) {
2649 close(fd);
2650 }
2651 } else {
2652 const char *ifname, *script, *downscript;
2653
2654 ifname = qemu_opt_get(opts, "ifname");
2655 script = qemu_opt_get(opts, "script");
2656 downscript = qemu_opt_get(opts, "downscript");
2657
2658 if (!script) {
2659 script = DEFAULT_NETWORK_SCRIPT;
2660 }
2661 if (!downscript) {
2662 downscript = DEFAULT_NETWORK_DOWN_SCRIPT;
2663 }
2664
2665 s = net_tap_init(vlan, "tap", name, ifname, script, downscript);
2666 }
2667
2668 if (!s) {
2669 return -1;
2670 }
2671
2672 if (tap_set_sndbuf(s, opts) < 0) {
2673 return -1;
2674 }
2675
f6b134ac
MM		 2676 if (vlan) {
2677 vlan->nb_host_devs++;
2678 }
8a1c5235
MM		 2679
2680 return 0;
2681}
2682#endif
2683
f6b134ac
MM		 2684static int net_init_socket(QemuOpts *opts,
2685 Monitor *mon,
2686 const char *name,
2687 VLANState *vlan)
88ce16ca 2688{
88ce16ca
MM		 2689 if (qemu_opt_get(opts, "fd")) {
2690 int fd;
2691
2692 if (qemu_opt_get(opts, "listen") ||
2693 qemu_opt_get(opts, "connect") ||
2694 qemu_opt_get(opts, "mcast")) {
2695 qemu_error("listen=, connect= and mcast= is invalid with fd=\n");
2696 return -1;
2697 }
2698
2699 fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2700 if (fd == -1) {
2701 return -1;
2702 }
2703
2704 if (!net_socket_fd_init(vlan, "socket", name, fd, 1)) {
2705 close(fd);
2706 return -1;
2707 }
2708 } else if (qemu_opt_get(opts, "listen")) {
2709 const char *listen;
2710
2711 if (qemu_opt_get(opts, "fd") ||
2712 qemu_opt_get(opts, "connect") ||
2713 qemu_opt_get(opts, "mcast")) {
2714 qemu_error("fd=, connect= and mcast= is invalid with listen=\n");
2715 return -1;
2716 }
2717
2718 listen = qemu_opt_get(opts, "listen");
2719
2720 if (net_socket_listen_init(vlan, "socket", name, listen) == -1) {
2721 return -1;
2722 }
2723 } else if (qemu_opt_get(opts, "connect")) {
2724 const char *connect;
2725
2726 if (qemu_opt_get(opts, "fd") ||
2727 qemu_opt_get(opts, "listen") ||
2728 qemu_opt_get(opts, "mcast")) {
2729 qemu_error("fd=, listen= and mcast= is invalid with connect=\n");
2730 return -1;
2731 }
2732
2733 connect = qemu_opt_get(opts, "connect");
2734
2735 if (net_socket_connect_init(vlan, "socket", name, connect) == -1) {
2736 return -1;
2737 }
2738 } else if (qemu_opt_get(opts, "mcast")) {
2739 const char *mcast;
2740
2741 if (qemu_opt_get(opts, "fd") ||
2742 qemu_opt_get(opts, "connect") ||
2743 qemu_opt_get(opts, "listen")) {
2744 qemu_error("fd=, connect= and listen= is invalid with mcast=\n");
2745 return -1;
2746 }
2747
2748 mcast = qemu_opt_get(opts, "mcast");
2749
2750 if (net_socket_mcast_init(vlan, "socket", name, mcast) == -1) {
2751 return -1;
2752 }
2753 } else {
2754 qemu_error("-socket requires fd=, listen=, connect= or mcast=\n");
2755 return -1;
2756 }
2757
f6b134ac
MM		 2758 if (vlan) {
2759 vlan->nb_host_devs++;
2760 }
88ce16ca
MM		 2761
2762 return 0;
2763}
2764
dd51058d 2765#ifdef CONFIG_VDE
f6b134ac
MM		 2766static int net_init_vde(QemuOpts *opts,
2767 Monitor *mon,
2768 const char *name,
2769 VLANState *vlan)
dd51058d 2770{
dd51058d
MM		 2771 const char *sock;
2772 const char *group;
2773 int port, mode;
2774
dd51058d
MM		 2775 sock = qemu_opt_get(opts, "sock");
2776 group = qemu_opt_get(opts, "group");
2777
2778 port = qemu_opt_get_number(opts, "port", 0);
2779 mode = qemu_opt_get_number(opts, "mode", 0700);
2780
2781 if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
2782 return -1;
2783 }
2784
f6b134ac
MM		 2785 if (vlan) {
2786 vlan->nb_host_devs++;
2787 }
dd51058d
MM		 2788
2789 return 0;
2790}
2791#endif
2792
f6b134ac
MM		 2793static int net_init_dump(QemuOpts *opts,
2794 Monitor *mon,
2795 const char *name,
2796 VLANState *vlan)
ed2955c2 2797{
ed2955c2
MM		 2798 int len;
2799 const char *file;
ed2955c2
MM		 2800 char def_file[128];
2801
f6b134ac 2802 assert(vlan);
ed2955c2 2803
ed2955c2
MM		 2804 file = qemu_opt_get(opts, "file");
2805 if (!file) {
2806 snprintf(def_file, sizeof(def_file), "qemu-vlan%d.pcap", vlan->id);
2807 file = def_file;
2808 }
2809
2810 len = qemu_opt_get_size(opts, "len", 65536);
2811
2812 return net_dump_init(vlan, "dump", name, file, len);
2813}
2814
f83c6e10
MM		 2815#define NET_COMMON_PARAMS_DESC \
2816 { \
2817 .name = "type", \
2818 .type = QEMU_OPT_STRING, \
2819 .help = "net client type (nic, tap etc.)", \
2820 }, { \
2821 .name = "vlan", \
2822 .type = QEMU_OPT_NUMBER, \
2823 .help = "vlan number", \
2824 }, { \
2825 .name = "name", \
2826 .type = QEMU_OPT_STRING, \
2827 .help = "identifier for monitor commands", \
2828 }
2829
6d952ebe
MM		 2830typedef int (*net_client_init_func)(QemuOpts *opts,
2831 Monitor *mon,
f6b134ac
MM		 2832 const char *name,
2833 VLANState *vlan);
f83c6e10
MM		 2834
2835/* magic number, but compiler will warn if too small */
2836#define NET_MAX_DESC 20
2837
2838static struct {
2839 const char *type;
2840 net_client_init_func init;
2841 QemuOptDesc desc[NET_MAX_DESC];
2842} net_client_types[] = {
2843 {
2844 .type = "none",
2845 .desc = {
2846 NET_COMMON_PARAMS_DESC,
2847 { /* end of list */ }
2848 },
2849 }, {
2850 .type = "nic",
2851 .init = net_init_nic,
2852 .desc = {
2853 NET_COMMON_PARAMS_DESC,
5869c4d5
MM		 2854 {
2855 .name = "netdev",
2856 .type = QEMU_OPT_STRING,
2857 .help = "id of -netdev to connect to",
2858 },
f83c6e10
MM		 2859 {
2860 .name = "macaddr",
2861 .type = QEMU_OPT_STRING,
2862 .help = "MAC address",
2863 }, {
2864 .name = "model",
2865 .type = QEMU_OPT_STRING,
2866 .help = "device model (e1000, rtl8139, virtio etc.)",
2867 }, {
2868 .name = "addr",
2869 .type = QEMU_OPT_STRING,
2870 .help = "PCI device address",
2871 }, {
2872 .name = "vectors",
2873 .type = QEMU_OPT_NUMBER,
2874 .help = "number of MSI-x vectors, 0 to disable MSI-X",
2875 },
2876 { /* end of list */ }
2877 },
ec302ffd
MM		 2878#ifdef CONFIG_SLIRP
2879 }, {
2880 .type = "user",
2881 .init = net_init_slirp,
2882 .desc = {
2883 NET_COMMON_PARAMS_DESC,
2884 {
2885 .name = "hostname",
2886 .type = QEMU_OPT_STRING,
2887 .help = "client hostname reported by the builtin DHCP server",
2888 }, {
2889 .name = "restrict",
2890 .type = QEMU_OPT_STRING,
2891 .help = "isolate the guest from the host (y|yes|n|no)",
2892 }, {
2893 .name = "ip",
2894 .type = QEMU_OPT_STRING,
2895 .help = "legacy parameter, use net= instead",
2896 }, {
2897 .name = "net",
2898 .type = QEMU_OPT_STRING,
2899 .help = "IP address and optional netmask",
2900 }, {
2901 .name = "host",
2902 .type = QEMU_OPT_STRING,
2903 .help = "guest-visible address of the host",
2904 }, {
2905 .name = "tftp",
2906 .type = QEMU_OPT_STRING,
2907 .help = "root directory of the built-in TFTP server",
2908 }, {
2909 .name = "bootfile",
2910 .type = QEMU_OPT_STRING,
2911 .help = "BOOTP filename, for use with tftp=",
2912 }, {
2913 .name = "dhcpstart",
2914 .type = QEMU_OPT_STRING,
2915 .help = "the first of the 16 IPs the built-in DHCP server can assign",
2916 }, {
2917 .name = "dns",
2918 .type = QEMU_OPT_STRING,
2919 .help = "guest-visible address of the virtual nameserver",
2920 }, {
2921 .name = "smb",
2922 .type = QEMU_OPT_STRING,
2923 .help = "root directory of the built-in SMB server",
2924 }, {
2925 .name = "smbserver",
2926 .type = QEMU_OPT_STRING,
2927 .help = "IP address of the built-in SMB server",
2928 }, {
2929 .name = "hostfwd",
2930 .type = QEMU_OPT_STRING,
2931 .help = "guest port number to forward incoming TCP or UDP connections",
2932 }, {
2933 .name = "guestfwd",
2934 .type = QEMU_OPT_STRING,
2935 .help = "IP address and port to forward guest TCP connections",
2936 },
2937 { /* end of list */ }
2938 },
8a1c5235
MM		 2939#endif
2940#ifdef _WIN32
2941 }, {
2942 .type = "tap",
2943 .init = net_init_tap_win32,
2944 .desc = {
2945 NET_COMMON_PARAMS_DESC,
2946 {
2947 .name = "ifname",
2948 .type = QEMU_OPT_STRING,
2949 .help = "interface name",
2950 },
2951 { /* end of list */ }
2952 },
2953#elif !defined(_AIX)
2954 }, {
2955 .type = "tap",
2956 .init = net_init_tap,
2957 .desc = {
2958 NET_COMMON_PARAMS_DESC,
2959 {
2960 .name = "fd",
2961 .type = QEMU_OPT_STRING,
2962 .help = "file descriptor of an already opened tap",
2963 }, {
2964 .name = "ifname",
2965 .type = QEMU_OPT_STRING,
2966 .help = "interface name",
2967 }, {
2968 .name = "script",
2969 .type = QEMU_OPT_STRING,
2970 .help = "script to initialize the interface",
2971 }, {
2972 .name = "downscript",
2973 .type = QEMU_OPT_STRING,
2974 .help = "script to shut down the interface",
2975#ifdef TUNSETSNDBUF
2976 }, {
2977 .name = "sndbuf",
2978 .type = QEMU_OPT_SIZE,
2979 .help = "send buffer limit"
2980#endif
2981 },
2982 { /* end of list */ }
2983 },
ec302ffd 2984#endif
88ce16ca
MM		 2985 }, {
2986 .type = "socket",
2987 .init = net_init_socket,
2988 .desc = {
2989 NET_COMMON_PARAMS_DESC,
2990 {
2991 .name = "fd",
2992 .type = QEMU_OPT_STRING,
2993 .help = "file descriptor of an already opened socket",
2994 }, {
2995 .name = "listen",
2996 .type = QEMU_OPT_STRING,
2997 .help = "port number, and optional hostname, to listen on",
2998 }, {
2999 .name = "connect",
3000 .type = QEMU_OPT_STRING,
3001 .help = "port number, and optional hostname, to connect to",
3002 }, {
3003 .name = "mcast",
3004 .type = QEMU_OPT_STRING,
3005 .help = "UDP multicast address and port number",
3006 },
3007 { /* end of list */ }
3008 },
dd51058d
MM		 3009#ifdef CONFIG_VDE
3010 }, {
3011 .type = "vde",
3012 .init = net_init_vde,
3013 .desc = {
3014 NET_COMMON_PARAMS_DESC,
3015 {
3016 .name = "sock",
3017 .type = QEMU_OPT_STRING,
3018 .help = "socket path",
3019 }, {
3020 .name = "port",
3021 .type = QEMU_OPT_NUMBER,
3022 .help = "port number",
3023 }, {
3024 .name = "group",
3025 .type = QEMU_OPT_STRING,
3026 .help = "group owner of socket",
3027 }, {
3028 .name = "mode",
3029 .type = QEMU_OPT_NUMBER,
3030 .help = "permissions for socket",
3031 },
3032 { /* end of list */ }
3033 },
3034#endif
ed2955c2
MM		 3035 }, {
3036 .type = "dump",
3037 .init = net_init_dump,
3038 .desc = {
3039 NET_COMMON_PARAMS_DESC,
3040 {
3041 .name = "len",
3042 .type = QEMU_OPT_SIZE,
3043 .help = "per-packet size limit (64k default)",
3044 }, {
3045 .name = "file",
3046 .type = QEMU_OPT_STRING,
3047 .help = "dump file path (default is qemu-vlan0.pcap)",
3048 },
3049 { /* end of list */ }
3050 },
f83c6e10
MM		 3051 },
3052 { /* end of list */ }
3053};
3054
f6b134ac 3055int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
f83c6e10 3056{
6d952ebe 3057 const char *name;
f83c6e10
MM		 3058 const char *type;
3059 int i;
3060
3061 type = qemu_opt_get(opts, "type");
3062 if (!type) {
3063 qemu_error("No type specified for -net\n");
3064 return -1;
3065 }
3066
f6b134ac
MM		 3067 if (is_netdev) {
3068 if (strcmp(type, "tap") != 0 &&
3069#ifdef CONFIG_SLIRP
3070 strcmp(type, "user") != 0 &&
3071#endif
3072#ifdef CONFIG_VDE
3073 strcmp(type, "vde") != 0 &&
3074#endif
3075 strcmp(type, "socket") != 0) {
3076 qemu_error("The '%s' network backend type is not valid with -netdev\n",
3077 type);
3078 return -1;
3079 }
3080
3081 if (qemu_opt_get(opts, "vlan")) {
3082 qemu_error("The 'vlan' parameter is not valid with -netdev\n");
3083 return -1;
3084 }
3085 if (qemu_opt_get(opts, "name")) {
3086 qemu_error("The 'name' parameter is not valid with -netdev\n");
3087 return -1;
3088 }
3089 if (!qemu_opts_id(opts)) {
3090 qemu_error("The id= parameter is required with -netdev\n");
3091 return -1;
3092 }
3093 }
3094
6d952ebe
MM		 3095 name = qemu_opts_id(opts);
3096 if (!name) {
3097 name = qemu_opt_get(opts, "name");
3098 }
3099
f83c6e10
MM		 3100 for (i = 0; net_client_types[i].type != NULL; i++) {
3101 if (!strcmp(net_client_types[i].type, type)) {
f6b134ac
MM		 3102 VLANState *vlan = NULL;
3103
f83c6e10
MM		 3104 if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
3105 return -1;
3106 }
3107
5869c4d5
MM		 3108 /* Do not add to a vlan if it's a -netdev or a nic with a
3109 * netdev= parameter. */
3110 if (!(is_netdev ||
3111 (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
f6b134ac
MM		 3112 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
3113 }
3114
f83c6e10 3115 if (net_client_types[i].init) {
f6b134ac 3116 return net_client_types[i].init(opts, mon, name, vlan);
f83c6e10
MM		 3117 } else {
3118 return 0;
3119 }
3120 }
3121 }
3122
3123 qemu_error("Invalid -net type '%s'\n", type);
3124 return -1;
3125}
3126
8b13c4a7
AL		 3127void net_client_uninit(NICInfo *nd)
3128{
d80b9fc6
MM		 3129 if (nd->vlan) {
3130 nd->vlan->nb_guest_devs--;
3131 }
8b13c4a7 3132 nb_nics--;
a9796703 3133
9203f520
MM		 3134 qemu_free(nd->model);
3135 qemu_free(nd->name);
3136 qemu_free(nd->devaddr);
a9796703 3137
d2cffe30 3138 nd->used = 0;
8b13c4a7
AL		 3139}
3140
6f338c34
AL		 3141static int net_host_check_device(const char *device)
3142{
3143 int i;
bb9ea79e 3144 const char *valid_param_list[] = { "tap", "socket", "dump"
6f338c34
AL		 3145#ifdef CONFIG_SLIRP
3146 ,"user"
3147#endif
3148#ifdef CONFIG_VDE
3149 ,"vde"
3150#endif
3151 };
3152 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
3153 if (!strncmp(valid_param_list[i], device,
3154 strlen(valid_param_list[i])))
3155 return 1;
3156 }
3157
3158 return 0;
3159}
3160
f18c16de 3161void net_host_device_add(Monitor *mon, const QDict *qdict)
6f338c34 3162{
f18c16de 3163 const char *device = qdict_get_str(qdict, "device");
7f1c9d20
MM		 3164 const char *opts_str = qdict_get_try_str(qdict, "opts");
3165 QemuOpts *opts;
f18c16de 3166
6f338c34 3167 if (!net_host_check_device(device)) {
376253ec 3168 monitor_printf(mon, "invalid host network device %s\n", device);
6f338c34
AL		 3169 return;
3170 }
7f1c9d20
MM		 3171
3172 opts = qemu_opts_parse(&qemu_net_opts, opts_str ? opts_str : "", NULL);
3173 if (!opts) {
3174 monitor_printf(mon, "parsing network options '%s' failed\n",
3175 opts_str ? opts_str : "");
3176 return;
3177 }
3178
3179 qemu_opt_set(opts, "type", device);
3180
f6b134ac 3181 if (net_client_init(mon, opts, 0) < 0) {
5c8be678
AL		 3182 monitor_printf(mon, "adding host network device %s failed\n", device);
3183 }
6f338c34
AL		 3184}
3185
f18c16de 3186void net_host_device_remove(Monitor *mon, const QDict *qdict)
6f338c34 3187{
6f338c34 3188 VLANClientState *vc;
f18c16de
LC		 3189 int vlan_id = qdict_get_int(qdict, "vlan_id");
3190 const char *device = qdict_get_str(qdict, "device");
6f338c34 3191
1a609520 3192 vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
6f338c34 3193 if (!vc) {
6f338c34
AL		 3194 return;
3195 }
e8f1f9db
AL		 3196 if (!net_host_check_device(vc->model)) {
3197 monitor_printf(mon, "invalid host network device %s\n", device);
3198 return;
3199 }
6f338c34
AL		 3200 qemu_del_vlan_client(vc);
3201}
3202
406c8df3
GC		 3203void net_set_boot_mask(int net_boot_mask)
3204{
3205 int i;
3206
3207 /* Only the first four NICs may be bootable */
3208 net_boot_mask = net_boot_mask & 0xF;
3209
3210 for (i = 0; i < nb_nics; i++) {
3211 if (net_boot_mask & (1 << i)) {
3212 nd_table[i].bootable = 1;
3213 net_boot_mask &= ~(1 << i);
3214 }
3215 }
3216
3217 if (net_boot_mask) {
3218 fprintf(stderr, "Cannot boot from non-existent NIC\n");
3219 exit(1);
3220 }
3221}
3222
376253ec 3223void do_info_network(Monitor *mon)
63a01ef8
AL		 3224{
3225 VLANState *vlan;
63a01ef8 3226
5610c3aa
MM		 3227 QTAILQ_FOREACH(vlan, &vlans, next) {
3228 VLANClientState *vc;
3229
376253ec 3230 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
5610c3aa
MM		 3231
3232 QTAILQ_FOREACH(vc, &vlan->clients, next) {
376253ec 3233 monitor_printf(mon, " %s: %s\n", vc->name, vc->info_str);
5610c3aa 3234 }
63a01ef8
AL		 3235 }
3236}
3237
f18c16de 3238void do_set_link(Monitor *mon, const QDict *qdict)
436e5e53
AL		 3239{
3240 VLANState *vlan;
3241 VLANClientState *vc = NULL;
f18c16de
LC		 3242 const char *name = qdict_get_str(qdict, "name");
3243 const char *up_or_down = qdict_get_str(qdict, "up_or_down");
436e5e53 3244
5610c3aa
MM		 3245 QTAILQ_FOREACH(vlan, &vlans, next) {
3246 QTAILQ_FOREACH(vc, &vlan->clients, next) {
3247 if (strcmp(vc->name, name) == 0) {
dd5de373 3248 goto done;
5610c3aa
MM		 3249 }
3250 }
3251 }
dd5de373 3252done:
436e5e53
AL		 3253
3254 if (!vc) {
7dc3fa09 3255 monitor_printf(mon, "could not find network device '%s'\n", name);
c3cf0d3f 3256 return;
436e5e53
AL		 3257 }
3258
3259 if (strcmp(up_or_down, "up") == 0)
3260 vc->link_down = 0;
3261 else if (strcmp(up_or_down, "down") == 0)
3262 vc->link_down = 1;
3263 else
376253ec
AL		 3264 monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
3265 "valid\n", up_or_down);
436e5e53 3266
34b25ca7
AL		 3267 if (vc->link_status_changed)
3268 vc->link_status_changed(vc);
436e5e53
AL		 3269}
3270
63a01ef8
AL		 3271void net_cleanup(void)
3272{
3273 VLANState *vlan;
577c4af9 3274 VLANClientState *vc, *next_vc;
63a01ef8 3275
5610c3aa 3276 QTAILQ_FOREACH(vlan, &vlans, next) {
5610c3aa 3277 QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
b946a153 3278 qemu_del_vlan_client(vc);
63a01ef8
AL		 3279 }
3280 }
577c4af9
MM		 3281
3282 QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
3283 qemu_del_vlan_client(vc);
3284 }
63a01ef8
AL		 3285}
3286
dc1c9fe8 3287static void net_check_clients(void)
63a01ef8
AL		 3288{
3289 VLANState *vlan;
3290
5610c3aa 3291 QTAILQ_FOREACH(vlan, &vlans, next) {
63a01ef8
AL		 3292 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
3293 continue;
3294 if (vlan->nb_guest_devs == 0)
3295 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
3296 if (vlan->nb_host_devs == 0)
3297 fprintf(stderr,
3298 "Warning: vlan %d is not connected to host network\n",
3299 vlan->id);
3300 }
3301}
dc1c9fe8
MM		 3302
3303static int net_init_client(QemuOpts *opts, void *dummy)
3304{
c1671a08
MM		 3305 if (net_client_init(NULL, opts, 0) < 0)
3306 return -1;
3307 return 0;
f6b134ac
MM		 3308}
3309
3310static int net_init_netdev(QemuOpts *opts, void *dummy)
3311{
3312 return net_client_init(NULL, opts, 1);
dc1c9fe8
MM		 3313}
3314
3315int net_init_clients(void)
3316{
3317 if (QTAILQ_EMPTY(&qemu_net_opts.head)) {
3318 /* if no clients, we use a default config */
3319 qemu_opts_set(&qemu_net_opts, NULL, "type", "nic");
3320#ifdef CONFIG_SLIRP
3321 qemu_opts_set(&qemu_net_opts, NULL, "type", "user");
3322#endif
3323 }
3324
5610c3aa 3325 QTAILQ_INIT(&vlans);
577c4af9 3326 QTAILQ_INIT(&non_vlan_clients);
5610c3aa 3327
f6b134ac
MM		 3328 if (qemu_opts_foreach(&qemu_netdev_opts, net_init_netdev, NULL, 1) == -1)
3329 return -1;
3330
dc1c9fe8
MM		 3331 if (qemu_opts_foreach(&qemu_net_opts, net_init_client, NULL, 1) == -1) {
3332 return -1;
3333 }
3334
3335 net_check_clients();
3336
3337 return 0;
3338}
3339
7f161aae 3340int net_client_parse(QemuOptsList *opts_list, const char *optarg)
dc1c9fe8 3341{
a3a766e7 3342#if defined(CONFIG_SLIRP)
dc1c9fe8 3343 /* handle legacy -net channel,port:chr */
7f161aae
MM		 3344 if (!strcmp(opts_list->name, "net") &&
3345 !strncmp(optarg, "channel,", strlen("channel,"))) {
dc1c9fe8
MM		 3346 int ret;
3347
3348 optarg += strlen("channel,");
3349
3350 if (QTAILQ_EMPTY(&slirp_stacks)) {
3351 struct slirp_config_str *config;
3352
3353 config = qemu_malloc(sizeof(*config));
3354 pstrcpy(config->str, sizeof(config->str), optarg);
3355 config->flags = SLIRP_CFG_LEGACY;
3356 config->next = slirp_configs;
3357 slirp_configs = config;
3358 ret = 0;
3359 } else {
3360 ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), optarg, 1);
3361 }
3362
3363 return ret;
3364 }
a3a766e7 3365#endif
7f161aae 3366 if (!qemu_opts_parse(opts_list, optarg, "type")) {
dc1c9fe8
MM		 3367 return -1;
3368 }
3369
3370 return 0;
3371}
Qemu copy for testing