]> git.proxmox.com Git - mirror_qemu.git/blame - net.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: add -net nic,netdev= option
[mirror_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
63a01ef8 304VLANClientState *qemu_new_vlan_client(VLANState *vlan,
bf38c1a0 305 const char *model,
7a9f6e4a 306 const char *name,
cda9046b
MM		 307 NetCanReceive *can_receive,
308 NetReceive *receive,
309 NetReceiveIOV *receive_iov,
b946a153 310 NetCleanup *cleanup,
63a01ef8
AL		 311 void *opaque)
312{
5610c3aa
MM		 313 VLANClientState *vc;
314
63a01ef8 315 vc = qemu_mallocz(sizeof(VLANClientState));
5610c3aa 316
02374aa0 317 vc->model = qemu_strdup(model);
7a9f6e4a 318 if (name)
02374aa0 319 vc->name = qemu_strdup(name);
7a9f6e4a
AL		 320 else
321 vc->name = assign_name(vc, model);
cda9046b
MM		 322 vc->can_receive = can_receive;
323 vc->receive = receive;
324 vc->receive_iov = receive_iov;
b946a153 325 vc->cleanup = cleanup;
63a01ef8 326 vc->opaque = opaque;
5610c3aa 327
d80b9fc6
MM		 328 if (vlan) {
329 vc->vlan = vlan;
330 QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
577c4af9
MM		 331 } else {
332 QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
d80b9fc6 333 }
63a01ef8 334
63a01ef8
AL		 335 return vc;
336}
337
338void qemu_del_vlan_client(VLANClientState *vc)
339{
d80b9fc6
MM		 340 if (vc->vlan) {
341 QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
577c4af9
MM		 342 } else {
343 QTAILQ_REMOVE(&non_vlan_clients, vc, next);
d80b9fc6 344 }
63a01ef8 345
5610c3aa
MM		 346 if (vc->cleanup) {
347 vc->cleanup(vc);
348 }
349
350 qemu_free(vc->name);
351 qemu_free(vc->model);
352 qemu_free(vc);
63a01ef8
AL		 353}
354
8b13c4a7
AL		 355VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
356{
5610c3aa 357 VLANClientState *vc;
8b13c4a7 358
5610c3aa
MM		 359 QTAILQ_FOREACH(vc, &vlan->clients, next) {
360 if (vc->opaque == opaque) {
361 return vc;
362 }
363 }
8b13c4a7
AL		 364
365 return NULL;
366}
367
1a609520
JK		 368static VLANClientState *
369qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
370 const char *client_str)
371{
372 VLANState *vlan;
373 VLANClientState *vc;
374
375 vlan = qemu_find_vlan(vlan_id, 0);
376 if (!vlan) {
377 monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
378 return NULL;
379 }
380
5610c3aa 381 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1a609520
JK		 382 if (!strcmp(vc->name, client_str)) {
383 break;
384 }
385 }
386 if (!vc) {
387 monitor_printf(mon, "can't find device %s on VLAN %d\n",
388 client_str, vlan_id);
389 }
390
391 return vc;
392}
393
2e1e0641 394int qemu_can_send_packet(VLANClientState *sender)
63a01ef8 395{
2e1e0641 396 VLANState *vlan = sender->vlan;
63a01ef8
AL		 397 VLANClientState *vc;
398
d80b9fc6
MM		 399 if (!sender->vlan) {
400 return 1;
401 }
402
5610c3aa 403 QTAILQ_FOREACH(vc, &vlan->clients, next) {
2e1e0641
MM		 404 if (vc == sender) {
405 continue;
406 }
407
cda9046b 408 /* no can_receive() handler, they can always receive */
e3f5ec2b 409 if (!vc->can_receive || vc->can_receive(vc)) {
2e1e0641 410 return 1;
63a01ef8
AL		 411 }
412 }
413 return 0;
414}
415
3e021d40 416static int
764a4d1d 417qemu_deliver_packet(VLANClientState *sender, const uint8_t *buf, int size)
63a01ef8 418{
63a01ef8 419 VLANClientState *vc;
3e021d40 420 int ret = -1;
63a01ef8 421
e94667b9
MM		 422 sender->vlan->delivering = 1;
423
5610c3aa 424 QTAILQ_FOREACH(vc, &sender->vlan->clients, next) {
3e021d40
MM		 425 ssize_t len;
426
427 if (vc == sender) {
428 continue;
764a4d1d 429 }
3e021d40
MM		 430
431 if (vc->link_down) {
432 ret = size;
433 continue;
434 }
435
436 len = vc->receive(vc, buf, size);
437
438 ret = (ret >= 0) ? ret : len;
764a4d1d 439 }
3e021d40 440
e94667b9
MM		 441 sender->vlan->delivering = 0;
442
3e021d40 443 return ret;
764a4d1d
AL		 444}
445
8cad5516
MM		 446void qemu_purge_queued_packets(VLANClientState *vc)
447{
9da43187 448 VLANPacket *packet, *next;
8cad5516 449
d80b9fc6
MM		 450 if (!vc->vlan)
451 return;
452
72cf2d4f 453 QTAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) {
8cad5516 454 if (packet->sender == vc) {
72cf2d4f 455 QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
8cad5516 456 qemu_free(packet);
8cad5516
MM		 457 }
458 }
459}
460
f3b6c7fc 461void qemu_flush_queued_packets(VLANClientState *vc)
e94667b9 462{
d80b9fc6
MM		 463 if (!vc->vlan)
464 return;
465
72cf2d4f 466 while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) {
9da43187 467 VLANPacket *packet;
f3b6c7fc
MM		 468 int ret;
469
72cf2d4f
BS		 470 packet = QTAILQ_FIRST(&vc->vlan->send_queue);
471 QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
f3b6c7fc
MM		 472
473 ret = qemu_deliver_packet(packet->sender, packet->data, packet->size);
474 if (ret == 0 && packet->sent_cb != NULL) {
72cf2d4f 475 QTAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry);
f3b6c7fc
MM		 476 break;
477 }
478
479 if (packet->sent_cb)
783527a9 480 packet->sent_cb(packet->sender, ret);
f3b6c7fc 481
e94667b9
MM		 482 qemu_free(packet);
483 }
484}
485
f3b6c7fc
MM		 486static void qemu_enqueue_packet(VLANClientState *sender,
487 const uint8_t *buf, int size,
488 NetPacketSent *sent_cb)
e94667b9
MM		 489{
490 VLANPacket *packet;
491
492 packet = qemu_malloc(sizeof(VLANPacket) + size);
e94667b9
MM		 493 packet->sender = sender;
494 packet->size = size;
f3b6c7fc 495 packet->sent_cb = sent_cb;
e94667b9 496 memcpy(packet->data, buf, size);
9da43187 497
72cf2d4f 498 QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
e94667b9
MM		 499}
500
f3b6c7fc
MM		 501ssize_t qemu_send_packet_async(VLANClientState *sender,
502 const uint8_t *buf, int size,
503 NetPacketSent *sent_cb)
764a4d1d 504{
f3b6c7fc 505 int ret;
764a4d1d 506
d80b9fc6 507 if (sender->link_down || !sender->vlan) {
f3b6c7fc
MM		 508 return size;
509 }
436e5e53 510
63a01ef8 511#ifdef DEBUG_NET
d80b9fc6 512 printf("qemu_send_packet_async:\n");
63a01ef8
AL		 513 hex_dump(stdout, buf, size);
514#endif
f3b6c7fc
MM		 515
516 if (sender->vlan->delivering) {
517 qemu_enqueue_packet(sender, buf, size, NULL);
518 return size;
519 }
520
521 ret = qemu_deliver_packet(sender, buf, size);
522 if (ret == 0 && sent_cb != NULL) {
523 qemu_enqueue_packet(sender, buf, size, sent_cb);
524 return 0;
63a01ef8 525 }
e94667b9 526
f3b6c7fc
MM		 527 qemu_flush_queued_packets(sender);
528
529 return ret;
530}
531
532void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
533{
534 qemu_send_packet_async(vc, buf, size, NULL);
63a01ef8
AL		 535}
536
fbe78f4f
AL		 537static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
538 int iovcnt)
539{
540 uint8_t buffer[4096];
541 size_t offset = 0;
542 int i;
543
544 for (i = 0; i < iovcnt; i++) {
545 size_t len;
546
547 len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
548 memcpy(buffer + offset, iov[i].iov_base, len);
549 offset += len;
550 }
551
f3b6c7fc 552 return vc->receive(vc, buffer, offset);
fbe78f4f
AL		 553}
554
e0e7877a
AL		 555static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
556{
557 size_t offset = 0;
558 int i;
559
560 for (i = 0; i < iovcnt; i++)
561 offset += iov[i].iov_len;
562 return offset;
563}
564
e94667b9
MM		 565static int qemu_deliver_packet_iov(VLANClientState *sender,
566 const struct iovec *iov, int iovcnt)
fbe78f4f 567{
fbe78f4f 568 VLANClientState *vc;
e94667b9
MM		 569 int ret = -1;
570
571 sender->vlan->delivering = 1;
572
5610c3aa 573 QTAILQ_FOREACH(vc, &sender->vlan->clients, next) {
e94667b9
MM		 574 ssize_t len;
575
576 if (vc == sender) {
577 continue;
578 }
579
580 if (vc->link_down) {
581 ret = calc_iov_length(iov, iovcnt);
582 continue;
583 }
584
585 if (vc->receive_iov) {
586 len = vc->receive_iov(vc, iov, iovcnt);
587 } else {
588 len = vc_sendv_compat(vc, iov, iovcnt);
589 }
590
591 ret = (ret >= 0) ? ret : len;
592 }
593
594 sender->vlan->delivering = 0;
595
596 return ret;
597}
598
599static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender,
f3b6c7fc
MM		 600 const struct iovec *iov, int iovcnt,
601 NetPacketSent *sent_cb)
e94667b9 602{
c27ff608 603 VLANPacket *packet;
e94667b9 604 size_t max_len = 0;
c27ff608 605 int i;
fbe78f4f 606
e94667b9 607 max_len = calc_iov_length(iov, iovcnt);
e0e7877a 608
e94667b9 609 packet = qemu_malloc(sizeof(VLANPacket) + max_len);
e94667b9 610 packet->sender = sender;
f3b6c7fc 611 packet->sent_cb = sent_cb;
e94667b9 612 packet->size = 0;
c27ff608 613
e94667b9
MM		 614 for (i = 0; i < iovcnt; i++) {
615 size_t len = iov[i].iov_len;
c27ff608 616
e94667b9
MM		 617 memcpy(packet->data + packet->size, iov[i].iov_base, len);
618 packet->size += len;
619 }
fbe78f4f 620
72cf2d4f 621 QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
fbe78f4f 622
e94667b9
MM		 623 return packet->size;
624}
fbe78f4f 625
f3b6c7fc
MM		 626ssize_t qemu_sendv_packet_async(VLANClientState *sender,
627 const struct iovec *iov, int iovcnt,
628 NetPacketSent *sent_cb)
e94667b9
MM		 629{
630 int ret;
631
d80b9fc6 632 if (sender->link_down || !sender->vlan) {
e94667b9
MM		 633 return calc_iov_length(iov, iovcnt);
634 }
635
636 if (sender->vlan->delivering) {
f3b6c7fc 637 return qemu_enqueue_packet_iov(sender, iov, iovcnt, NULL);
fbe78f4f
AL		 638 }
639
e94667b9 640 ret = qemu_deliver_packet_iov(sender, iov, iovcnt);
f3b6c7fc
MM		 641 if (ret == 0 && sent_cb != NULL) {
642 qemu_enqueue_packet_iov(sender, iov, iovcnt, sent_cb);
643 return 0;
644 }
e94667b9
MM		 645
646 qemu_flush_queued_packets(sender);
647
648 return ret;
fbe78f4f
AL		 649}
650
f3b6c7fc
MM		 651ssize_t
652qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
653{
654 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
655}
656
63a01ef8
AL		 657#if defined(CONFIG_SLIRP)
658
659/* slirp network adapter */
660
c92ef6a2
JK		 661#define SLIRP_CFG_HOSTFWD 1
662#define SLIRP_CFG_LEGACY 2
ad196a9d 663
b8e8af38
JK		 664struct slirp_config_str {
665 struct slirp_config_str *next;
ad196a9d
JK		 666 int flags;
667 char str[1024];
c92ef6a2 668 int legacy_format;
b8e8af38
JK		 669};
670
9f8bd042 671typedef struct SlirpState {
72cf2d4f 672 QTAILQ_ENTRY(SlirpState) entry;
9f8bd042
JK		 673 VLANClientState *vc;
674 Slirp *slirp;
28432466
JK		 675#ifndef _WIN32
676 char smb_dir[128];
677#endif
9f8bd042
JK		 678} SlirpState;
679
ad196a9d
JK		 680static struct slirp_config_str *slirp_configs;
681const char *legacy_tftp_prefix;
682const char *legacy_bootp_filename;
72cf2d4f
BS		 683static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
684 QTAILQ_HEAD_INITIALIZER(slirp_stacks);
63a01ef8 685
fb12577c 686static int slirp_hostfwd(SlirpState *s, const char *redir_str,
0752706d 687 int legacy_format);
fb12577c 688static int slirp_guestfwd(SlirpState *s, const char *config_str,
3c6a0580 689 int legacy_format);
ad196a9d 690
c5b76b38 691#ifndef _WIN32
ad196a9d
JK		 692static const char *legacy_smb_export;
693
fb12577c 694static int slirp_smb(SlirpState *s, const char *exported_dir,
0752706d 695 struct in_addr vserver_addr);
28432466
JK		 696static void slirp_smb_cleanup(SlirpState *s);
697#else
698static inline void slirp_smb_cleanup(SlirpState *s) { }
c5b76b38 699#endif
b8e8af38 700
9f8bd042 701int slirp_can_output(void *opaque)
63a01ef8 702{
9f8bd042
JK		 703 SlirpState *s = opaque;
704
705 return qemu_can_send_packet(s->vc);
63a01ef8
AL		 706}
707
9f8bd042 708void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
63a01ef8 709{
9f8bd042
JK		 710 SlirpState *s = opaque;
711
63a01ef8
AL		 712#ifdef DEBUG_SLIRP
713 printf("slirp output:\n");
714 hex_dump(stdout, pkt, pkt_len);
715#endif
9f8bd042 716 qemu_send_packet(s->vc, pkt, pkt_len);
63a01ef8
AL		 717}
718
4f1c942b 719static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 720{
9f8bd042
JK		 721 SlirpState *s = vc->opaque;
722
63a01ef8
AL		 723#ifdef DEBUG_SLIRP
724 printf("slirp input:\n");
725 hex_dump(stdout, buf, size);
726#endif
9f8bd042 727 slirp_input(s->slirp, buf, size);
4f1c942b 728 return size;
63a01ef8
AL		 729}
730
8d6249a7
AL		 731static void net_slirp_cleanup(VLANClientState *vc)
732{
ad0d8c4c
JK		 733 SlirpState *s = vc->opaque;
734
735 slirp_cleanup(s->slirp);
28432466 736 slirp_smb_cleanup(s);
72cf2d4f 737 QTAILQ_REMOVE(&slirp_stacks, s, entry);
ad0d8c4c 738 qemu_free(s);
8d6249a7
AL		 739}
740
fb12577c 741static int net_slirp_init(VLANState *vlan, const char *model,
c92ef6a2
JK		 742 const char *name, int restricted,
743 const char *vnetwork, const char *vhost,
744 const char *vhostname, const char *tftp_export,
745 const char *bootfile, const char *vdhcp_start,
746 const char *vnameserver, const char *smb_export,
747 const char *vsmbserver)
63a01ef8 748{
ad0d8c4c 749 /* default settings according to historic slirp */
8389e7f4
AL		 750 struct in_addr net = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
751 struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
ad0d8c4c
JK		 752 struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
753 struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
754 struct in_addr dns = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
c92ef6a2 755#ifndef _WIN32
ad0d8c4c 756 struct in_addr smbsrv = { .s_addr = 0 };
c92ef6a2 757#endif
ad0d8c4c
JK		 758 SlirpState *s;
759 char buf[20];
760 uint32_t addr;
761 int shift;
762 char *end;
3a179c66 763 struct slirp_config_str *config;
ad0d8c4c
JK		 764
765 if (!tftp_export) {
766 tftp_export = legacy_tftp_prefix;
767 }
768 if (!bootfile) {
769 bootfile = legacy_bootp_filename;
770 }
c92ef6a2 771
ad0d8c4c
JK		 772 if (vnetwork) {
773 if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
774 if (!inet_aton(vnetwork, &net)) {
775 return -1;
776 }
777 addr = ntohl(net.s_addr);
778 if (!(addr & 0x80000000)) {
779 mask.s_addr = htonl(0xff000000); /* class A */
780 } else if ((addr & 0xfff00000) == 0xac100000) {
781 mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
782 } else if ((addr & 0xc0000000) == 0x80000000) {
783 mask.s_addr = htonl(0xffff0000); /* class B */
784 } else if ((addr & 0xffff0000) == 0xc0a80000) {
785 mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
786 } else if ((addr & 0xffff0000) == 0xc6120000) {
787 mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
788 } else if ((addr & 0xe0000000) == 0xe0000000) {
789 mask.s_addr = htonl(0xffffff00); /* class C */
c92ef6a2 790 } else {
ad0d8c4c
JK		 791 mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
792 }
793 } else {
794 if (!inet_aton(buf, &net)) {
795 return -1;
796 }
797 shift = strtol(vnetwork, &end, 10);
798 if (*end != '\0') {
799 if (!inet_aton(vnetwork, &mask)) {
c92ef6a2 800 return -1;
c92ef6a2 801 }
ad0d8c4c
JK		 802 } else if (shift < 4 || shift > 32) {
803 return -1;
804 } else {
805 mask.s_addr = htonl(0xffffffff << (32 - shift));
c92ef6a2 806 }
c92ef6a2 807 }
ad0d8c4c
JK		 808 net.s_addr &= mask.s_addr;
809 host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
810 dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
811 dns.s_addr = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
812 }
c92ef6a2 813
ad0d8c4c
JK		 814 if (vhost && !inet_aton(vhost, &host)) {
815 return -1;
816 }
817 if ((host.s_addr & mask.s_addr) != net.s_addr) {
818 return -1;
819 }
c92ef6a2 820
ad0d8c4c
JK		 821 if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
822 return -1;
823 }
824 if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||
825 dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
826 return -1;
827 }
c92ef6a2 828
ad0d8c4c
JK		 829 if (vnameserver && !inet_aton(vnameserver, &dns)) {
830 return -1;
831 }
832 if ((dns.s_addr & mask.s_addr) != net.s_addr ||
833 dns.s_addr == host.s_addr) {
834 return -1;
835 }
c92ef6a2
JK		 836
837#ifndef _WIN32
ad0d8c4c
JK		 838 if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
839 return -1;
840 }
c92ef6a2
JK		 841#endif
842
ad0d8c4c
JK		 843 s = qemu_mallocz(sizeof(SlirpState));
844 s->slirp = slirp_init(restricted, net, mask, host, vhostname,
845 tftp_export, bootfile, dhcp, dns, s);
72cf2d4f 846 QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
b8e8af38 847
3a179c66 848 for (config = slirp_configs; config; config = config->next) {
ad0d8c4c 849 if (config->flags & SLIRP_CFG_HOSTFWD) {
fb12577c 850 if (slirp_hostfwd(s, config->str,
0752706d
MA		 851 config->flags & SLIRP_CFG_LEGACY) < 0)
852 return -1;
ad0d8c4c 853 } else {
fb12577c 854 if (slirp_guestfwd(s, config->str,
0752706d
MA		 855 config->flags & SLIRP_CFG_LEGACY) < 0)
856 return -1;
b8e8af38 857 }
ad0d8c4c 858 }
b8e8af38 859#ifndef _WIN32
ad0d8c4c
JK		 860 if (!smb_export) {
861 smb_export = legacy_smb_export;
862 }
863 if (smb_export) {
fb12577c 864 if (slirp_smb(s, smb_export, smbsrv) < 0)
0752706d 865 return -1;
63a01ef8 866 }
ad0d8c4c 867#endif
b8e8af38 868
9f8bd042
JK		 869 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, slirp_receive, NULL,
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;
463af534
MM		 1429 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, tap_receive,
1430 tap_receive_iov, tap_cleanup, s);
b664e367 1431 tap_read_poll(s, 1);
7cb7434b 1432 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
63a01ef8
AL		 1433 return s;
1434}
1435
71e72a19 1436#if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__)
63a01ef8
AL		 1437static int tap_open(char *ifname, int ifname_size)
1438{
1439 int fd;
1440 char *dev;
1441 struct stat s;
1442
1443 TFR(fd = open("/dev/tap", O_RDWR));
1444 if (fd < 0) {
1445 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1446 return -1;
1447 }
1448
1449 fstat(fd, &s);
1450 dev = devname(s.st_rdev, S_IFCHR);
1451 pstrcpy(ifname, ifname_size, dev);
1452
1453 fcntl(fd, F_SETFL, O_NONBLOCK);
1454 return fd;
1455}
1456#elif defined(__sun__)
1457#define TUNNEWPPA (('T'<<16) | 0x0001)
1458/*
1459 * Allocate TAP device, returns opened fd.
1460 * Stores dev name in the first arg(must be large enough).
1461 */
3f4cb3d3 1462static int tap_alloc(char *dev, size_t dev_size)
63a01ef8
AL		 1463{
1464 int tap_fd, if_fd, ppa = -1;
1465 static int ip_fd = 0;
1466 char *ptr;
1467
1468 static int arp_fd = 0;
1469 int ip_muxid, arp_muxid;
1470 struct strioctl strioc_if, strioc_ppa;
1471 int link_type = I_PLINK;;
1472 struct lifreq ifr;
1473 char actual_name[32] = "";
1474
1475 memset(&ifr, 0x0, sizeof(ifr));
1476
1477 if( *dev ){
1478 ptr = dev;
47398b9c 1479 while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
63a01ef8
AL		 1480 ppa = atoi(ptr);
1481 }
1482
1483 /* Check if IP device was opened */
1484 if( ip_fd )
1485 close(ip_fd);
1486
1487 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
1488 if (ip_fd < 0) {
1489 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
1490 return -1;
1491 }
1492
1493 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
1494 if (tap_fd < 0) {
1495 syslog(LOG_ERR, "Can't open /dev/tap");
1496 return -1;
1497 }
1498
1499 /* Assign a new PPA and get its unit number. */
1500 strioc_ppa.ic_cmd = TUNNEWPPA;
1501 strioc_ppa.ic_timout = 0;
1502 strioc_ppa.ic_len = sizeof(ppa);
1503 strioc_ppa.ic_dp = (char *)&ppa;
1504 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
1505 syslog (LOG_ERR, "Can't assign new interface");
1506
1507 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
1508 if (if_fd < 0) {
1509 syslog(LOG_ERR, "Can't open /dev/tap (2)");
1510 return -1;
1511 }
1512 if(ioctl(if_fd, I_PUSH, "ip") < 0){
1513 syslog(LOG_ERR, "Can't push IP module");
1514 return -1;
1515 }
1516
1517 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
1518 syslog(LOG_ERR, "Can't get flags\n");
1519
1520 snprintf (actual_name, 32, "tap%d", ppa);
1521 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1522
1523 ifr.lifr_ppa = ppa;
1524 /* Assign ppa according to the unit number returned by tun device */
1525
1526 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
1527 syslog (LOG_ERR, "Can't set PPA %d", ppa);
1528 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
1529 syslog (LOG_ERR, "Can't get flags\n");
1530 /* Push arp module to if_fd */
1531 if (ioctl (if_fd, I_PUSH, "arp") < 0)
1532 syslog (LOG_ERR, "Can't push ARP module (2)");
1533
1534 /* Push arp module to ip_fd */
1535 if (ioctl (ip_fd, I_POP, NULL) < 0)
1536 syslog (LOG_ERR, "I_POP failed\n");
1537 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
1538 syslog (LOG_ERR, "Can't push ARP module (3)\n");
1539 /* Open arp_fd */
1540 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
1541 if (arp_fd < 0)
1542 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
1543
1544 /* Set ifname to arp */
1545 strioc_if.ic_cmd = SIOCSLIFNAME;
1546 strioc_if.ic_timout = 0;
1547 strioc_if.ic_len = sizeof(ifr);
1548 strioc_if.ic_dp = (char *)&ifr;
1549 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
1550 syslog (LOG_ERR, "Can't set ifname to arp\n");
1551 }
1552
1553 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
1554 syslog(LOG_ERR, "Can't link TAP device to IP");
1555 return -1;
1556 }
1557
1558 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
1559 syslog (LOG_ERR, "Can't link TAP device to ARP");
1560
1561 close (if_fd);
1562
1563 memset(&ifr, 0x0, sizeof(ifr));
1564 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1565 ifr.lifr_ip_muxid = ip_muxid;
1566 ifr.lifr_arp_muxid = arp_muxid;
1567
1568 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
1569 {
1570 ioctl (ip_fd, I_PUNLINK , arp_muxid);
1571 ioctl (ip_fd, I_PUNLINK, ip_muxid);
1572 syslog (LOG_ERR, "Can't set multiplexor id");
1573 }
1574
1575 snprintf(dev, dev_size, "tap%d", ppa);
1576 return tap_fd;
1577}
1578
1579static int tap_open(char *ifname, int ifname_size)
1580{
1581 char dev[10]="";
1582 int fd;
1583 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
1584 fprintf(stderr, "Cannot allocate TAP device\n");
1585 return -1;
1586 }
1587 pstrcpy(ifname, ifname_size, dev);
1588 fcntl(fd, F_SETFL, O_NONBLOCK);
1589 return fd;
1590}
b29fe3ed 1591#elif defined (_AIX)
1592static int tap_open(char *ifname, int ifname_size)
1593{
1594 fprintf (stderr, "no tap on AIX\n");
1595 return -1;
1596}
63a01ef8
AL		 1597#else
1598static int tap_open(char *ifname, int ifname_size)
1599{
1600 struct ifreq ifr;
1601 int fd, ret;
1602
1603 TFR(fd = open("/dev/net/tun", O_RDWR));
1604 if (fd < 0) {
1605 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1606 return -1;
1607 }
1608 memset(&ifr, 0, sizeof(ifr));
1609 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1610 if (ifname[0] != '\0')
1611 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
1612 else
1613 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
1614 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1615 if (ret != 0) {
1616 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1617 close(fd);
1618 return -1;
1619 }
1620 pstrcpy(ifname, ifname_size, ifr.ifr_name);
1621 fcntl(fd, F_SETFL, O_NONBLOCK);
1622 return fd;
1623}
1624#endif
1625
1626static int launch_script(const char *setup_script, const char *ifname, int fd)
1627{
7c3370d4 1628 sigset_t oldmask, mask;
63a01ef8
AL		 1629 int pid, status;
1630 char *args[3];
1631 char **parg;
1632
7c3370d4
JK		 1633 sigemptyset(&mask);
1634 sigaddset(&mask, SIGCHLD);
1635 sigprocmask(SIG_BLOCK, &mask, &oldmask);
1636
1637 /* try to launch network script */
1638 pid = fork();
1639 if (pid == 0) {
1640 int open_max = sysconf(_SC_OPEN_MAX), i;
1641
1642 for (i = 0; i < open_max; i++) {
1643 if (i != STDIN_FILENO &&
1644 i != STDOUT_FILENO &&
1645 i != STDERR_FILENO &&
1646 i != fd) {
1647 close(i);
63a01ef8
AL		 1648 }
1649 }
7c3370d4
JK		 1650 parg = args;
1651 *parg++ = (char *)setup_script;
1652 *parg++ = (char *)ifname;
1653 *parg++ = NULL;
1654 execv(setup_script, args);
1655 _exit(1);
1656 } else if (pid > 0) {
1657 while (waitpid(pid, &status, 0) != pid) {
1658 /* loop */
1659 }
1660 sigprocmask(SIG_SETMASK, &oldmask, NULL);
1661
1662 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
1663 return 0;
1664 }
1665 }
1666 fprintf(stderr, "%s: could not launch network script\n", setup_script);
1667 return -1;
63a01ef8
AL		 1668}
1669
4a77b25e
MM		 1670static TAPState *net_tap_init(VLANState *vlan, const char *model,
1671 const char *name, const char *ifname1,
1672 const char *setup_script, const char *down_script)
63a01ef8
AL		 1673{
1674 TAPState *s;
1675 int fd;
1676 char ifname[128];
1677
1678 if (ifname1 != NULL)
1679 pstrcpy(ifname, sizeof(ifname), ifname1);
1680 else
1681 ifname[0] = '\0';
1682 TFR(fd = tap_open(ifname, sizeof(ifname)));
1683 if (fd < 0)
4a77b25e 1684 return NULL;
63a01ef8
AL		 1685
1686 if (!setup_script || !strcmp(setup_script, "no"))
1687 setup_script = "";
4a77b25e
MM		 1688 if (setup_script[0] != '\0' &&
1689 launch_script(setup_script, ifname, fd)) {
1690 return NULL;
63a01ef8 1691 }
7a9f6e4a 1692 s = net_tap_fd_init(vlan, model, name, fd);
63a01ef8 1693 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
7cb7434b
AL		 1694 "ifname=%s,script=%s,downscript=%s",
1695 ifname, setup_script, down_script);
973cbd37 1696 if (down_script && strcmp(down_script, "no")) {
63a01ef8 1697 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
973cbd37
AL		 1698 snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
1699 }
4a77b25e 1700 return s;
63a01ef8
AL		 1701}
1702
1703#endif /* !_WIN32 */
1704
1705#if defined(CONFIG_VDE)
1706typedef struct VDEState {
1707 VLANClientState *vc;
1708 VDECONN *vde;
1709} VDEState;
1710
1711static void vde_to_qemu(void *opaque)
1712{
1713 VDEState *s = opaque;
1714 uint8_t buf[4096];
1715 int size;
1716
cc63bb0f 1717 size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
63a01ef8
AL		 1718 if (size > 0) {
1719 qemu_send_packet(s->vc, buf, size);
1720 }
1721}
1722
4f1c942b 1723static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1724{
e3f5ec2b 1725 VDEState *s = vc->opaque;
068daedd 1726 ssize_t ret;
4f1c942b
MM		 1727
1728 do {
1729 ret = vde_send(s->vde, (const char *)buf, size, 0);
1730 } while (ret < 0 && errno == EINTR);
1731
1732 return ret;
63a01ef8
AL		 1733}
1734
b946a153
AL		 1735static void vde_cleanup(VLANClientState *vc)
1736{
1737 VDEState *s = vc->opaque;
1738 qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
1739 vde_close(s->vde);
1740 qemu_free(s);
1741}
1742
7a9f6e4a
AL		 1743static int net_vde_init(VLANState *vlan, const char *model,
1744 const char *name, const char *sock,
bf38c1a0 1745 int port, const char *group, int mode)
63a01ef8
AL		 1746{
1747 VDEState *s;
dd51058d
MM		 1748 char *init_group = (char *)group;
1749 char *init_sock = (char *)sock;
63a01ef8
AL		 1750
1751 struct vde_open_args args = {
1752 .port = port,
1753 .group = init_group,
1754 .mode = mode,
1755 };
1756
1757 s = qemu_mallocz(sizeof(VDEState));
cc63bb0f 1758 s->vde = vde_open(init_sock, (char *)"QEMU", &args);
63a01ef8
AL		 1759 if (!s->vde){
1760 free(s);
1761 return -1;
1762 }
e3f5ec2b 1763 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, vde_receive,
b946a153 1764 NULL, vde_cleanup, s);
63a01ef8 1765 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
7cb7434b 1766 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
63a01ef8
AL		 1767 sock, vde_datafd(s->vde));
1768 return 0;
1769}
1770#endif
1771
1772/* network connection */
1773typedef struct NetSocketState {
1774 VLANClientState *vc;
1775 int fd;
1776 int state; /* 0 = getting length, 1 = getting data */
abcd2baa
AL		 1777 unsigned int index;
1778 unsigned int packet_len;
63a01ef8
AL		 1779 uint8_t buf[4096];
1780 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1781} NetSocketState;
1782
1783typedef struct NetSocketListenState {
1784 VLANState *vlan;
bf38c1a0 1785 char *model;
7a9f6e4a 1786 char *name;
63a01ef8
AL		 1787 int fd;
1788} NetSocketListenState;
1789
1790/* XXX: we consider we can send the whole packet without blocking */
4f1c942b 1791static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1792{
e3f5ec2b 1793 NetSocketState *s = vc->opaque;
63a01ef8
AL		 1794 uint32_t len;
1795 len = htonl(size);
1796
1797 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4f1c942b 1798 return send_all(s->fd, buf, size);
63a01ef8
AL		 1799}
1800
4f1c942b 1801static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
63a01ef8 1802{
e3f5ec2b 1803 NetSocketState *s = vc->opaque;
4f1c942b 1804
70503264 1805 return sendto(s->fd, (const void *)buf, size, 0,
4f1c942b 1806 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
63a01ef8
AL		 1807}
1808
1809static void net_socket_send(void *opaque)
1810{
1811 NetSocketState *s = opaque;
abcd2baa
AL		 1812 int size, err;
1813 unsigned l;
63a01ef8
AL		 1814 uint8_t buf1[4096];
1815 const uint8_t *buf;
1816
c5b76b38 1817 size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
63a01ef8
AL		 1818 if (size < 0) {
1819 err = socket_error();
1820 if (err != EWOULDBLOCK)
1821 goto eoc;
1822 } else if (size == 0) {
1823 /* end of connection */
1824 eoc:
1825 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1826 closesocket(s->fd);
1827 return;
1828 }
1829 buf = buf1;
1830 while (size > 0) {
1831 /* reassemble a packet from the network */
1832 switch(s->state) {
1833 case 0:
1834 l = 4 - s->index;
1835 if (l > size)
1836 l = size;
1837 memcpy(s->buf + s->index, buf, l);
1838 buf += l;
1839 size -= l;
1840 s->index += l;
1841 if (s->index == 4) {
1842 /* got length */
1843 s->packet_len = ntohl(*(uint32_t *)s->buf);
1844 s->index = 0;
1845 s->state = 1;
1846 }
1847 break;
1848 case 1:
1849 l = s->packet_len - s->index;
1850 if (l > size)
1851 l = size;
abcd2baa
AL		 1852 if (s->index + l <= sizeof(s->buf)) {
1853 memcpy(s->buf + s->index, buf, l);
1854 } else {
1855 fprintf(stderr, "serious error: oversized packet received,"
1856 "connection terminated.\n");
1857 s->state = 0;
1858 goto eoc;
1859 }
1860
63a01ef8
AL		 1861 s->index += l;
1862 buf += l;
1863 size -= l;
1864 if (s->index >= s->packet_len) {
1865 qemu_send_packet(s->vc, s->buf, s->packet_len);
1866 s->index = 0;
1867 s->state = 0;
1868 }
1869 break;
1870 }
1871 }
1872}
1873
1874static void net_socket_send_dgram(void *opaque)
1875{
1876 NetSocketState *s = opaque;
1877 int size;
1878
c5b76b38 1879 size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
63a01ef8
AL		 1880 if (size < 0)
1881 return;
1882 if (size == 0) {
1883 /* end of connection */
1884 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1885 return;
1886 }
1887 qemu_send_packet(s->vc, s->buf, size);
1888}
1889
1890static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1891{
1892 struct ip_mreq imr;
1893 int fd;
1894 int val, ret;
1895 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1896 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1897 inet_ntoa(mcastaddr->sin_addr),
1898 (int)ntohl(mcastaddr->sin_addr.s_addr));
1899 return -1;
1900
1901 }
1902 fd = socket(PF_INET, SOCK_DGRAM, 0);
1903 if (fd < 0) {
1904 perror("socket(PF_INET, SOCK_DGRAM)");
1905 return -1;
1906 }
1907
1908 val = 1;
1909 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1910 (const char *)&val, sizeof(val));
1911 if (ret < 0) {
1912 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1913 goto fail;
1914 }
1915
1916 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1917 if (ret < 0) {
1918 perror("bind");
1919 goto fail;
1920 }
1921
1922 /* Add host to multicast group */
1923 imr.imr_multiaddr = mcastaddr->sin_addr;
1924 imr.imr_interface.s_addr = htonl(INADDR_ANY);
1925
1926 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1927 (const char *)&imr, sizeof(struct ip_mreq));
1928 if (ret < 0) {
1929 perror("setsockopt(IP_ADD_MEMBERSHIP)");
1930 goto fail;
1931 }
1932
1933 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1934 val = 1;
1935 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1936 (const char *)&val, sizeof(val));
1937 if (ret < 0) {
1938 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1939 goto fail;
1940 }
1941
1942 socket_set_nonblock(fd);
1943 return fd;
1944fail:
1945 if (fd >= 0)
1946 closesocket(fd);
1947 return -1;
1948}
1949
b946a153
AL		 1950static void net_socket_cleanup(VLANClientState *vc)
1951{
1952 NetSocketState *s = vc->opaque;
1953 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1954 close(s->fd);
1955 qemu_free(s);
1956}
1957
7a9f6e4a
AL		 1958static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
1959 const char *model,
1960 const char *name,
bf38c1a0 1961 int fd, int is_connected)
63a01ef8
AL		 1962{
1963 struct sockaddr_in saddr;
1964 int newfd;
1965 socklen_t saddr_len;
1966 NetSocketState *s;
1967
1968 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1969 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1970 * by ONLY ONE process: we must "clone" this dgram socket --jjo
1971 */
1972
1973 if (is_connected) {
1974 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1975 /* must be bound */
1976 if (saddr.sin_addr.s_addr==0) {
1977 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1978 fd);
1979 return NULL;
1980 }
1981 /* clone dgram socket */
1982 newfd = net_socket_mcast_create(&saddr);
1983 if (newfd < 0) {
1984 /* error already reported by net_socket_mcast_create() */
1985 close(fd);
1986 return NULL;
1987 }
1988 /* clone newfd to fd, close newfd */
1989 dup2(newfd, fd);
1990 close(newfd);
1991
1992 } else {
1993 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1994 fd, strerror(errno));
1995 return NULL;
1996 }
1997 }
1998
1999 s = qemu_mallocz(sizeof(NetSocketState));
63a01ef8
AL		 2000 s->fd = fd;
2001
463af534 2002 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, net_socket_receive_dgram,
b946a153 2003 NULL, net_socket_cleanup, s);
63a01ef8
AL		 2004 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2005
2006 /* mcast: save bound address as dst */
2007 if (is_connected) s->dgram_dst=saddr;
2008
2009 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2010 "socket: fd=%d (%s mcast=%s:%d)",
2011 fd, is_connected? "cloned" : "",
2012 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2013 return s;
2014}
2015
2016static void net_socket_connect(void *opaque)
2017{
2018 NetSocketState *s = opaque;
2019 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2020}
2021
7a9f6e4a
AL		 2022static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
2023 const char *model,
2024 const char *name,
bf38c1a0 2025 int fd, int is_connected)
63a01ef8
AL		 2026{
2027 NetSocketState *s;
2028 s = qemu_mallocz(sizeof(NetSocketState));
63a01ef8 2029 s->fd = fd;
463af534 2030 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, net_socket_receive,
b946a153 2031 NULL, net_socket_cleanup, s);
63a01ef8
AL		 2032 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2033 "socket: fd=%d", fd);
2034 if (is_connected) {
2035 net_socket_connect(s);
2036 } else {
2037 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2038 }
2039 return s;
2040}
2041
7a9f6e4a
AL		 2042static NetSocketState *net_socket_fd_init(VLANState *vlan,
2043 const char *model, const char *name,
bf38c1a0 2044 int fd, int is_connected)
63a01ef8 2045{
acedcfbf 2046 int so_type = -1, optlen=sizeof(so_type);
63a01ef8
AL		 2047
2048 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
2049 (socklen_t *)&optlen)< 0) {
2050 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
2051 return NULL;
2052 }
2053 switch(so_type) {
2054 case SOCK_DGRAM:
7a9f6e4a 2055 return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
63a01ef8 2056 case SOCK_STREAM:
7a9f6e4a 2057 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
63a01ef8
AL		 2058 default:
2059 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2060 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
7a9f6e4a 2061 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
63a01ef8
AL		 2062 }
2063 return NULL;
2064}
2065
2066static void net_socket_accept(void *opaque)
2067{
2068 NetSocketListenState *s = opaque;
2069 NetSocketState *s1;
2070 struct sockaddr_in saddr;
2071 socklen_t len;
2072 int fd;
2073
2074 for(;;) {
2075 len = sizeof(saddr);
2076 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2077 if (fd < 0 && errno != EINTR) {
2078 return;
2079 } else if (fd >= 0) {
2080 break;
2081 }
2082 }
7a9f6e4a 2083 s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
63a01ef8
AL		 2084 if (!s1) {
2085 closesocket(fd);
2086 } else {
2087 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2088 "socket: connection from %s:%d",
2089 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2090 }
2091}
2092
7a9f6e4a
AL		 2093static int net_socket_listen_init(VLANState *vlan,
2094 const char *model,
2095 const char *name,
bf38c1a0 2096 const char *host_str)
63a01ef8
AL		 2097{
2098 NetSocketListenState *s;
2099 int fd, val, ret;
2100 struct sockaddr_in saddr;
2101
2102 if (parse_host_port(&saddr, host_str) < 0)
2103 return -1;
2104
2105 s = qemu_mallocz(sizeof(NetSocketListenState));
63a01ef8
AL		 2106
2107 fd = socket(PF_INET, SOCK_STREAM, 0);
2108 if (fd < 0) {
2109 perror("socket");
2110 return -1;
2111 }
2112 socket_set_nonblock(fd);
2113
2114 /* allow fast reuse */
2115 val = 1;
2116 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2117
2118 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2119 if (ret < 0) {
2120 perror("bind");
2121 return -1;
2122 }
2123 ret = listen(fd, 0);
2124 if (ret < 0) {
2125 perror("listen");
2126 return -1;
2127 }
2128 s->vlan = vlan;
02374aa0
MM		 2129 s->model = qemu_strdup(model);
2130 s->name = name ? qemu_strdup(name) : NULL;
63a01ef8
AL		 2131 s->fd = fd;
2132 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2133 return 0;
2134}
2135
7a9f6e4a
AL		 2136static int net_socket_connect_init(VLANState *vlan,
2137 const char *model,
2138 const char *name,
bf38c1a0 2139 const char *host_str)
63a01ef8
AL		 2140{
2141 NetSocketState *s;
2142 int fd, connected, ret, err;
2143 struct sockaddr_in saddr;
2144
2145 if (parse_host_port(&saddr, host_str) < 0)
2146 return -1;
2147
2148 fd = socket(PF_INET, SOCK_STREAM, 0);
2149 if (fd < 0) {
2150 perror("socket");
2151 return -1;
2152 }
2153 socket_set_nonblock(fd);
2154
2155 connected = 0;
2156 for(;;) {
2157 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2158 if (ret < 0) {
2159 err = socket_error();
2160 if (err == EINTR || err == EWOULDBLOCK) {
2161 } else if (err == EINPROGRESS) {
2162 break;
2163#ifdef _WIN32
2164 } else if (err == WSAEALREADY) {
2165 break;
2166#endif
2167 } else {
2168 perror("connect");
2169 closesocket(fd);
2170 return -1;
2171 }
2172 } else {
2173 connected = 1;
2174 break;
2175 }
2176 }
7a9f6e4a 2177 s = net_socket_fd_init(vlan, model, name, fd, connected);
63a01ef8
AL		 2178 if (!s)
2179 return -1;
2180 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2181 "socket: connect to %s:%d",
2182 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2183 return 0;
2184}
2185
7a9f6e4a
AL		 2186static int net_socket_mcast_init(VLANState *vlan,
2187 const char *model,
2188 const char *name,
bf38c1a0 2189 const char *host_str)
63a01ef8
AL		 2190{
2191 NetSocketState *s;
2192 int fd;
2193 struct sockaddr_in saddr;
2194
2195 if (parse_host_port(&saddr, host_str) < 0)
2196 return -1;
2197
2198
2199 fd = net_socket_mcast_create(&saddr);
2200 if (fd < 0)
2201 return -1;
2202
7a9f6e4a 2203 s = net_socket_fd_init(vlan, model, name, fd, 0);
63a01ef8
AL		 2204 if (!s)
2205 return -1;
2206
2207 s->dgram_dst = saddr;
2208
2209 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2210 "socket: mcast=%s:%d",
2211 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2212 return 0;
2213
2214}
2215
bb9ea79e
AL		 2216typedef struct DumpState {
2217 VLANClientState *pcap_vc;
2218 int fd;
2219 int pcap_caplen;
2220} DumpState;
2221
2222#define PCAP_MAGIC 0xa1b2c3d4
2223
2224struct pcap_file_hdr {
2225 uint32_t magic;
2226 uint16_t version_major;
2227 uint16_t version_minor;
2228 int32_t thiszone;
2229 uint32_t sigfigs;
2230 uint32_t snaplen;
2231 uint32_t linktype;
2232};
2233
2234struct pcap_sf_pkthdr {
2235 struct {
2236 int32_t tv_sec;
2237 int32_t tv_usec;
2238 } ts;
2239 uint32_t caplen;
2240 uint32_t len;
2241};
2242
4f1c942b 2243static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
bb9ea79e 2244{
e3f5ec2b 2245 DumpState *s = vc->opaque;
bb9ea79e
AL		 2246 struct pcap_sf_pkthdr hdr;
2247 int64_t ts;
2248 int caplen;
2249
2250 /* Early return in case of previous error. */
2251 if (s->fd < 0) {
4f1c942b 2252 return size;
bb9ea79e
AL		 2253 }
2254
6ee093c9 2255 ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
bb9ea79e
AL		 2256 caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
2257
37cb6fc3 2258 hdr.ts.tv_sec = ts / 1000000;
bb9ea79e
AL		 2259 hdr.ts.tv_usec = ts % 1000000;
2260 hdr.caplen = caplen;
2261 hdr.len = size;
2262 if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
2263 write(s->fd, buf, caplen) != caplen) {
2264 qemu_log("-net dump write error - stop dump\n");
2265 close(s->fd);
2266 s->fd = -1;
2267 }
4f1c942b
MM		 2268
2269 return size;
bb9ea79e
AL		 2270}
2271
2272static void net_dump_cleanup(VLANClientState *vc)
2273{
2274 DumpState *s = vc->opaque;
2275
2276 close(s->fd);
2277 qemu_free(s);
2278}
2279
fb12577c 2280static int net_dump_init(VLANState *vlan, const char *device,
bb9ea79e
AL		 2281 const char *name, const char *filename, int len)
2282{
2283 struct pcap_file_hdr hdr;
2284 DumpState *s;
2285
2286 s = qemu_malloc(sizeof(DumpState));
2287
024431b3 2288 s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
bb9ea79e 2289 if (s->fd < 0) {
fb12577c 2290 qemu_error("-net dump: can't open %s\n", filename);
bb9ea79e
AL		 2291 return -1;
2292 }
2293
2294 s->pcap_caplen = len;
2295
2296 hdr.magic = PCAP_MAGIC;
2297 hdr.version_major = 2;
2298 hdr.version_minor = 4;
2299 hdr.thiszone = 0;
2300 hdr.sigfigs = 0;
2301 hdr.snaplen = s->pcap_caplen;
2302 hdr.linktype = 1;
2303
2304 if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
fb12577c 2305 qemu_error("-net dump write error: %s\n", strerror(errno));
bb9ea79e
AL		 2306 close(s->fd);
2307 qemu_free(s);
2308 return -1;
2309 }
2310
463af534 2311 s->pcap_vc = qemu_new_vlan_client(vlan, device, name, NULL, dump_receive, NULL,
bb9ea79e
AL		 2312 net_dump_cleanup, s);
2313 snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str),
2314 "dump to %s (len=%d)", filename, len);
2315 return 0;
2316}
2317
63a01ef8 2318/* find or alloc a new VLAN */
1a609520 2319VLANState *qemu_find_vlan(int id, int allocate)
63a01ef8 2320{
5610c3aa
MM		 2321 VLANState *vlan;
2322
2323 QTAILQ_FOREACH(vlan, &vlans, next) {
2324 if (vlan->id == id) {
63a01ef8 2325 return vlan;
5610c3aa 2326 }
63a01ef8 2327 }
5610c3aa 2328
1a609520
JK		 2329 if (!allocate) {
2330 return NULL;
2331 }
5610c3aa 2332
63a01ef8 2333 vlan = qemu_mallocz(sizeof(VLANState));
63a01ef8 2334 vlan->id = id;
5610c3aa 2335 QTAILQ_INIT(&vlan->clients);
72cf2d4f 2336 QTAILQ_INIT(&vlan->send_queue);
5610c3aa
MM		 2337
2338 QTAILQ_INSERT_TAIL(&vlans, vlan, next);
2339
63a01ef8
AL		 2340 return vlan;
2341}
2342
5869c4d5
MM		 2343static VLANClientState *qemu_find_netdev(const char *id)
2344{
2345 VLANClientState *vc;
2346
2347 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
2348 if (!strcmp(vc->name, id)) {
2349 return vc;
2350 }
2351 }
2352
2353 return NULL;
2354}
2355
7697079b
AL		 2356static int nic_get_free_idx(void)
2357{
2358 int index;
2359
2360 for (index = 0; index < MAX_NICS; index++)
2361 if (!nd_table[index].used)
2362 return index;
2363 return -1;
2364}
2365
07caea31
MA		 2366int qemu_show_nic_models(const char *arg, const char *const *models)
2367{
2368 int i;
2369
2370 if (!arg || strcmp(arg, "?"))
2371 return 0;
2372
2373 fprintf(stderr, "qemu: Supported NIC models: ");
2374 for (i = 0 ; models[i]; i++)
2375 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
2376 return 1;
2377}
2378
d07f22c5
AL		 2379void qemu_check_nic_model(NICInfo *nd, const char *model)
2380{
2381 const char *models[2];
2382
2383 models[0] = model;
2384 models[1] = NULL;
2385
07caea31
MA		 2386 if (qemu_show_nic_models(nd->model, models))
2387 exit(0);
2388 if (qemu_find_nic_model(nd, models, model) < 0)
2389 exit(1);
d07f22c5
AL		 2390}
2391
07caea31
MA		 2392int qemu_find_nic_model(NICInfo *nd, const char * const *models,
2393 const char *default_model)
d07f22c5 2394{
07caea31 2395 int i;
d07f22c5
AL		 2396
2397 if (!nd->model)
32a8e14a 2398 nd->model = qemu_strdup(default_model);
d07f22c5 2399
07caea31
MA		 2400 for (i = 0 ; models[i]; i++) {
2401 if (strcmp(nd->model, models[i]) == 0)
2402 return i;
d07f22c5
AL		 2403 }
2404
07caea31
MA		 2405 qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
2406 return -1;
d07f22c5
AL		 2407}
2408
c1d6eed7
MM		 2409static int net_handle_fd_param(Monitor *mon, const char *param)
2410{
2411 if (!qemu_isdigit(param[0])) {
2412 int fd;
2413
2414 fd = monitor_get_fd(mon, param);
2415 if (fd == -1) {
fb12577c 2416 qemu_error("No file descriptor named %s found", param);
c1d6eed7
MM		 2417 return -1;
2418 }
2419
2420 return fd;
2421 } else {
2422 return strtol(param, NULL, 0);
2423 }
2424}
2425
f6b134ac
MM		 2426static int net_init_nic(QemuOpts *opts,
2427 Monitor *mon,
2428 const char *name,
2429 VLANState *vlan)
f83c6e10
MM		 2430{
2431 int idx;
2432 NICInfo *nd;
5869c4d5 2433 const char *netdev;
f83c6e10
MM		 2434
2435 idx = nic_get_free_idx();
2436 if (idx == -1 || nb_nics >= MAX_NICS) {
2437 qemu_error("Too Many NICs\n");
2438 return -1;
2439 }
2440
2441 nd = &nd_table[idx];
2442
2443 memset(nd, 0, sizeof(*nd));
2444
5869c4d5
MM		 2445 if ((netdev = qemu_opt_get(opts, "netdev"))) {
2446 nd->netdev = qemu_find_netdev(netdev);
2447 if (!nd->netdev) {
2448 qemu_error("netdev '%s' not found\n", netdev);
2449 return -1;
2450 }
2451 } else {
2452 assert(vlan);
2453 nd->vlan = vlan;
2454 }
6d952ebe
MM		 2455 if (name) {
2456 nd->name = qemu_strdup(name);
2457 }
f83c6e10
MM		 2458 if (qemu_opt_get(opts, "model")) {
2459 nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
2460 }
2461 if (qemu_opt_get(opts, "addr")) {
2462 nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
2463 }
2464
2465 nd->macaddr[0] = 0x52;
2466 nd->macaddr[1] = 0x54;
2467 nd->macaddr[2] = 0x00;
2468 nd->macaddr[3] = 0x12;
2469 nd->macaddr[4] = 0x34;
2470 nd->macaddr[5] = 0x56 + idx;
2471
2472 if (qemu_opt_get(opts, "macaddr") &&
2473 parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
2474 qemu_error("invalid syntax for ethernet address\n");
2475 return -1;
2476 }
2477
2478 nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
2479 if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
2480 (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
2481 qemu_error("invalid # of vectors: %d\n", nd->nvectors);
2482 return -1;
2483 }
2484
2485 nd->used = 1;
5869c4d5
MM		 2486 if (vlan) {
2487 nd->vlan->nb_guest_devs++;
2488 }
f83c6e10
MM		 2489 nb_nics++;
2490
2491 return idx;
2492}
2493
a3a766e7 2494#if defined(CONFIG_SLIRP)
ec302ffd
MM		 2495static int net_init_slirp_configs(const char *name, const char *value, void *opaque)
2496{
2497 struct slirp_config_str *config;
2498
2499 if (strcmp(name, "hostfwd") != 0 && strcmp(name, "guestfwd") != 0) {
2500 return 0;
2501 }
2502
2503 config = qemu_mallocz(sizeof(*config));
2504
2505 pstrcpy(config->str, sizeof(config->str), value);
2506
2507 if (!strcmp(name, "hostfwd")) {
2508 config->flags = SLIRP_CFG_HOSTFWD;
2509 }
2510
2511 config->next = slirp_configs;
2512 slirp_configs = config;
2513
2514 return 0;
2515}
2516
f6b134ac
MM		 2517static int net_init_slirp(QemuOpts *opts,
2518 Monitor *mon,
2519 const char *name,
2520 VLANState *vlan)
ec302ffd 2521{
ec302ffd 2522 struct slirp_config_str *config;
ec302ffd
MM		 2523 const char *vhost;
2524 const char *vhostname;
2525 const char *vdhcp_start;
2526 const char *vnamesrv;
2527 const char *tftp_export;
2528 const char *bootfile;
2529 const char *smb_export;
2530 const char *vsmbsrv;
2531 char *vnet = NULL;
2532 int restricted = 0;
2533 int ret;
2534
ec302ffd
MM		 2535 vhost = qemu_opt_get(opts, "host");
2536 vhostname = qemu_opt_get(opts, "hostname");
2537 vdhcp_start = qemu_opt_get(opts, "dhcpstart");
2538 vnamesrv = qemu_opt_get(opts, "dns");
2539 tftp_export = qemu_opt_get(opts, "tftp");
2540 bootfile = qemu_opt_get(opts, "bootfile");
2541 smb_export = qemu_opt_get(opts, "smb");
2542 vsmbsrv = qemu_opt_get(opts, "smbserver");
2543
2544 if (qemu_opt_get(opts, "ip")) {
2545 const char *ip = qemu_opt_get(opts, "ip");
2546 int l = strlen(ip) + strlen("/24") + 1;
2547
2548 vnet = qemu_malloc(l);
2549
2550 /* emulate legacy ip= parameter */
2551 pstrcpy(vnet, l, ip);
2552 pstrcat(vnet, l, "/24");
2553 }
2554
2555 if (qemu_opt_get(opts, "net")) {
2556 if (vnet) {
2557 qemu_free(vnet);
2558 }
2559 vnet = qemu_strdup(qemu_opt_get(opts, "net"));
2560 }
2561
2562 if (qemu_opt_get(opts, "restrict") &&
2563 qemu_opt_get(opts, "restrict")[0] == 'y') {
2564 restricted = 1;
2565 }
2566
2567 qemu_opt_foreach(opts, net_init_slirp_configs, NULL, 0);
2568
2569 ret = net_slirp_init(vlan, "user", name, restricted, vnet, vhost,
2570 vhostname, tftp_export, bootfile, vdhcp_start,
2571 vnamesrv, smb_export, vsmbsrv);
2572
2573 while (slirp_configs) {
2574 config = slirp_configs;
2575 slirp_configs = config->next;
2576 qemu_free(config);
2577 }
2578
f6b134ac 2579 if (ret != -1 && vlan) {
ec302ffd
MM		 2580 vlan->nb_host_devs++;
2581 }
2582
2583 qemu_free(vnet);
2584
2585 return ret;
2586}
a3a766e7 2587#endif /* CONFIG_SLIRP */
ec302ffd 2588
8a1c5235 2589#ifdef _WIN32
f6b134ac
MM		 2590static int net_init_tap_win32(QemuOpts *opts,
2591 Monitor *mon,
2592 const char *name,
2593 VLANState *vlan)
8a1c5235 2594{
8a1c5235
MM		 2595 const char *ifname;
2596
8a1c5235
MM		 2597 ifname = qemu_opt_get(opts, "ifname");
2598
2599 if (!ifname) {
2600 qemu_error("tap: no interface name\n");
2601 return -1;
2602 }
2603
2604 if (tap_win32_init(vlan, "tap", name, ifname) == -1) {
2605 return -1;
2606 }
2607
f6b134ac
MM		 2608 if (vlan) {
2609 vlan->nb_host_devs++;
2610 }
8a1c5235
MM		 2611
2612 return 0;
2613}
2614#elif !defined(_AIX)
f6b134ac
MM		 2615static int net_init_tap(QemuOpts *opts,
2616 Monitor *mon,
2617 const char *name,
2618 VLANState *vlan)
8a1c5235 2619{
8a1c5235
MM		 2620 TAPState *s;
2621
8a1c5235
MM		 2622 if (qemu_opt_get(opts, "fd")) {
2623 int fd;
2624
2625 if (qemu_opt_get(opts, "ifname") ||
2626 qemu_opt_get(opts, "script") ||
2627 qemu_opt_get(opts, "downscript")) {
2628 qemu_error("ifname=, script= and downscript= is invalid with fd=\n");
2629 return -1;
2630 }
2631
2632 fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2633 if (fd == -1) {
2634 return -1;
2635 }
2636
2637 fcntl(fd, F_SETFL, O_NONBLOCK);
2638
2639 s = net_tap_fd_init(vlan, "tap", name, fd);
2640 if (!s) {
2641 close(fd);
2642 }
2643 } else {
2644 const char *ifname, *script, *downscript;
2645
2646 ifname = qemu_opt_get(opts, "ifname");
2647 script = qemu_opt_get(opts, "script");
2648 downscript = qemu_opt_get(opts, "downscript");
2649
2650 if (!script) {
2651 script = DEFAULT_NETWORK_SCRIPT;
2652 }
2653 if (!downscript) {
2654 downscript = DEFAULT_NETWORK_DOWN_SCRIPT;
2655 }
2656
2657 s = net_tap_init(vlan, "tap", name, ifname, script, downscript);
2658 }
2659
2660 if (!s) {
2661 return -1;
2662 }
2663
2664 if (tap_set_sndbuf(s, opts) < 0) {
2665 return -1;
2666 }
2667
f6b134ac
MM		 2668 if (vlan) {
2669 vlan->nb_host_devs++;
2670 }
8a1c5235
MM		 2671
2672 return 0;
2673}
2674#endif
2675
f6b134ac
MM		 2676static int net_init_socket(QemuOpts *opts,
2677 Monitor *mon,
2678 const char *name,
2679 VLANState *vlan)
88ce16ca 2680{
88ce16ca
MM		 2681 if (qemu_opt_get(opts, "fd")) {
2682 int fd;
2683
2684 if (qemu_opt_get(opts, "listen") ||
2685 qemu_opt_get(opts, "connect") ||
2686 qemu_opt_get(opts, "mcast")) {
2687 qemu_error("listen=, connect= and mcast= is invalid with fd=\n");
2688 return -1;
2689 }
2690
2691 fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2692 if (fd == -1) {
2693 return -1;
2694 }
2695
2696 if (!net_socket_fd_init(vlan, "socket", name, fd, 1)) {
2697 close(fd);
2698 return -1;
2699 }
2700 } else if (qemu_opt_get(opts, "listen")) {
2701 const char *listen;
2702
2703 if (qemu_opt_get(opts, "fd") ||
2704 qemu_opt_get(opts, "connect") ||
2705 qemu_opt_get(opts, "mcast")) {
2706 qemu_error("fd=, connect= and mcast= is invalid with listen=\n");
2707 return -1;
2708 }
2709
2710 listen = qemu_opt_get(opts, "listen");
2711
2712 if (net_socket_listen_init(vlan, "socket", name, listen) == -1) {
2713 return -1;
2714 }
2715 } else if (qemu_opt_get(opts, "connect")) {
2716 const char *connect;
2717
2718 if (qemu_opt_get(opts, "fd") ||
2719 qemu_opt_get(opts, "listen") ||
2720 qemu_opt_get(opts, "mcast")) {
2721 qemu_error("fd=, listen= and mcast= is invalid with connect=\n");
2722 return -1;
2723 }
2724
2725 connect = qemu_opt_get(opts, "connect");
2726
2727 if (net_socket_connect_init(vlan, "socket", name, connect) == -1) {
2728 return -1;
2729 }
2730 } else if (qemu_opt_get(opts, "mcast")) {
2731 const char *mcast;
2732
2733 if (qemu_opt_get(opts, "fd") ||
2734 qemu_opt_get(opts, "connect") ||
2735 qemu_opt_get(opts, "listen")) {
2736 qemu_error("fd=, connect= and listen= is invalid with mcast=\n");
2737 return -1;
2738 }
2739
2740 mcast = qemu_opt_get(opts, "mcast");
2741
2742 if (net_socket_mcast_init(vlan, "socket", name, mcast) == -1) {
2743 return -1;
2744 }
2745 } else {
2746 qemu_error("-socket requires fd=, listen=, connect= or mcast=\n");
2747 return -1;
2748 }
2749
f6b134ac
MM		 2750 if (vlan) {
2751 vlan->nb_host_devs++;
2752 }
88ce16ca
MM		 2753
2754 return 0;
2755}
2756
dd51058d 2757#ifdef CONFIG_VDE
f6b134ac
MM		 2758static int net_init_vde(QemuOpts *opts,
2759 Monitor *mon,
2760 const char *name,
2761 VLANState *vlan)
dd51058d 2762{
dd51058d
MM		 2763 const char *sock;
2764 const char *group;
2765 int port, mode;
2766
dd51058d
MM		 2767 sock = qemu_opt_get(opts, "sock");
2768 group = qemu_opt_get(opts, "group");
2769
2770 port = qemu_opt_get_number(opts, "port", 0);
2771 mode = qemu_opt_get_number(opts, "mode", 0700);
2772
2773 if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
2774 return -1;
2775 }
2776
f6b134ac
MM		 2777 if (vlan) {
2778 vlan->nb_host_devs++;
2779 }
dd51058d
MM		 2780
2781 return 0;
2782}
2783#endif
2784
f6b134ac
MM		 2785static int net_init_dump(QemuOpts *opts,
2786 Monitor *mon,
2787 const char *name,
2788 VLANState *vlan)
ed2955c2 2789{
ed2955c2
MM		 2790 int len;
2791 const char *file;
ed2955c2
MM		 2792 char def_file[128];
2793
f6b134ac 2794 assert(vlan);
ed2955c2 2795
ed2955c2
MM		 2796 file = qemu_opt_get(opts, "file");
2797 if (!file) {
2798 snprintf(def_file, sizeof(def_file), "qemu-vlan%d.pcap", vlan->id);
2799 file = def_file;
2800 }
2801
2802 len = qemu_opt_get_size(opts, "len", 65536);
2803
2804 return net_dump_init(vlan, "dump", name, file, len);
2805}
2806
f83c6e10
MM		 2807#define NET_COMMON_PARAMS_DESC \
2808 { \
2809 .name = "type", \
2810 .type = QEMU_OPT_STRING, \
2811 .help = "net client type (nic, tap etc.)", \
2812 }, { \
2813 .name = "vlan", \
2814 .type = QEMU_OPT_NUMBER, \
2815 .help = "vlan number", \
2816 }, { \
2817 .name = "name", \
2818 .type = QEMU_OPT_STRING, \
2819 .help = "identifier for monitor commands", \
2820 }
2821
6d952ebe
MM		 2822typedef int (*net_client_init_func)(QemuOpts *opts,
2823 Monitor *mon,
f6b134ac
MM		 2824 const char *name,
2825 VLANState *vlan);
f83c6e10
MM		 2826
2827/* magic number, but compiler will warn if too small */
2828#define NET_MAX_DESC 20
2829
2830static struct {
2831 const char *type;
2832 net_client_init_func init;
2833 QemuOptDesc desc[NET_MAX_DESC];
2834} net_client_types[] = {
2835 {
2836 .type = "none",
2837 .desc = {
2838 NET_COMMON_PARAMS_DESC,
2839 { /* end of list */ }
2840 },
2841 }, {
2842 .type = "nic",
2843 .init = net_init_nic,
2844 .desc = {
2845 NET_COMMON_PARAMS_DESC,
5869c4d5
MM		 2846 {
2847 .name = "netdev",
2848 .type = QEMU_OPT_STRING,
2849 .help = "id of -netdev to connect to",
2850 },
f83c6e10
MM		 2851 {
2852 .name = "macaddr",
2853 .type = QEMU_OPT_STRING,
2854 .help = "MAC address",
2855 }, {
2856 .name = "model",
2857 .type = QEMU_OPT_STRING,
2858 .help = "device model (e1000, rtl8139, virtio etc.)",
2859 }, {
2860 .name = "addr",
2861 .type = QEMU_OPT_STRING,
2862 .help = "PCI device address",
2863 }, {
2864 .name = "vectors",
2865 .type = QEMU_OPT_NUMBER,
2866 .help = "number of MSI-x vectors, 0 to disable MSI-X",
2867 },
2868 { /* end of list */ }
2869 },
ec302ffd
MM		 2870#ifdef CONFIG_SLIRP
2871 }, {
2872 .type = "user",
2873 .init = net_init_slirp,
2874 .desc = {
2875 NET_COMMON_PARAMS_DESC,
2876 {
2877 .name = "hostname",
2878 .type = QEMU_OPT_STRING,
2879 .help = "client hostname reported by the builtin DHCP server",
2880 }, {
2881 .name = "restrict",
2882 .type = QEMU_OPT_STRING,
2883 .help = "isolate the guest from the host (y|yes|n|no)",
2884 }, {
2885 .name = "ip",
2886 .type = QEMU_OPT_STRING,
2887 .help = "legacy parameter, use net= instead",
2888 }, {
2889 .name = "net",
2890 .type = QEMU_OPT_STRING,
2891 .help = "IP address and optional netmask",
2892 }, {
2893 .name = "host",
2894 .type = QEMU_OPT_STRING,
2895 .help = "guest-visible address of the host",
2896 }, {
2897 .name = "tftp",
2898 .type = QEMU_OPT_STRING,
2899 .help = "root directory of the built-in TFTP server",
2900 }, {
2901 .name = "bootfile",
2902 .type = QEMU_OPT_STRING,
2903 .help = "BOOTP filename, for use with tftp=",
2904 }, {
2905 .name = "dhcpstart",
2906 .type = QEMU_OPT_STRING,
2907 .help = "the first of the 16 IPs the built-in DHCP server can assign",
2908 }, {
2909 .name = "dns",
2910 .type = QEMU_OPT_STRING,
2911 .help = "guest-visible address of the virtual nameserver",
2912 }, {
2913 .name = "smb",
2914 .type = QEMU_OPT_STRING,
2915 .help = "root directory of the built-in SMB server",
2916 }, {
2917 .name = "smbserver",
2918 .type = QEMU_OPT_STRING,
2919 .help = "IP address of the built-in SMB server",
2920 }, {
2921 .name = "hostfwd",
2922 .type = QEMU_OPT_STRING,
2923 .help = "guest port number to forward incoming TCP or UDP connections",
2924 }, {
2925 .name = "guestfwd",
2926 .type = QEMU_OPT_STRING,
2927 .help = "IP address and port to forward guest TCP connections",
2928 },
2929 { /* end of list */ }
2930 },
8a1c5235
MM		 2931#endif
2932#ifdef _WIN32
2933 }, {
2934 .type = "tap",
2935 .init = net_init_tap_win32,
2936 .desc = {
2937 NET_COMMON_PARAMS_DESC,
2938 {
2939 .name = "ifname",
2940 .type = QEMU_OPT_STRING,
2941 .help = "interface name",
2942 },
2943 { /* end of list */ }
2944 },
2945#elif !defined(_AIX)
2946 }, {
2947 .type = "tap",
2948 .init = net_init_tap,
2949 .desc = {
2950 NET_COMMON_PARAMS_DESC,
2951 {
2952 .name = "fd",
2953 .type = QEMU_OPT_STRING,
2954 .help = "file descriptor of an already opened tap",
2955 }, {
2956 .name = "ifname",
2957 .type = QEMU_OPT_STRING,
2958 .help = "interface name",
2959 }, {
2960 .name = "script",
2961 .type = QEMU_OPT_STRING,
2962 .help = "script to initialize the interface",
2963 }, {
2964 .name = "downscript",
2965 .type = QEMU_OPT_STRING,
2966 .help = "script to shut down the interface",
2967#ifdef TUNSETSNDBUF
2968 }, {
2969 .name = "sndbuf",
2970 .type = QEMU_OPT_SIZE,
2971 .help = "send buffer limit"
2972#endif
2973 },
2974 { /* end of list */ }
2975 },
ec302ffd 2976#endif
88ce16ca
MM		 2977 }, {
2978 .type = "socket",
2979 .init = net_init_socket,
2980 .desc = {
2981 NET_COMMON_PARAMS_DESC,
2982 {
2983 .name = "fd",
2984 .type = QEMU_OPT_STRING,
2985 .help = "file descriptor of an already opened socket",
2986 }, {
2987 .name = "listen",
2988 .type = QEMU_OPT_STRING,
2989 .help = "port number, and optional hostname, to listen on",
2990 }, {
2991 .name = "connect",
2992 .type = QEMU_OPT_STRING,
2993 .help = "port number, and optional hostname, to connect to",
2994 }, {
2995 .name = "mcast",
2996 .type = QEMU_OPT_STRING,
2997 .help = "UDP multicast address and port number",
2998 },
2999 { /* end of list */ }
3000 },
dd51058d
MM		 3001#ifdef CONFIG_VDE
3002 }, {
3003 .type = "vde",
3004 .init = net_init_vde,
3005 .desc = {
3006 NET_COMMON_PARAMS_DESC,
3007 {
3008 .name = "sock",
3009 .type = QEMU_OPT_STRING,
3010 .help = "socket path",
3011 }, {
3012 .name = "port",
3013 .type = QEMU_OPT_NUMBER,
3014 .help = "port number",
3015 }, {
3016 .name = "group",
3017 .type = QEMU_OPT_STRING,
3018 .help = "group owner of socket",
3019 }, {
3020 .name = "mode",
3021 .type = QEMU_OPT_NUMBER,
3022 .help = "permissions for socket",
3023 },
3024 { /* end of list */ }
3025 },
3026#endif
ed2955c2
MM		 3027 }, {
3028 .type = "dump",
3029 .init = net_init_dump,
3030 .desc = {
3031 NET_COMMON_PARAMS_DESC,
3032 {
3033 .name = "len",
3034 .type = QEMU_OPT_SIZE,
3035 .help = "per-packet size limit (64k default)",
3036 }, {
3037 .name = "file",
3038 .type = QEMU_OPT_STRING,
3039 .help = "dump file path (default is qemu-vlan0.pcap)",
3040 },
3041 { /* end of list */ }
3042 },
f83c6e10
MM		 3043 },
3044 { /* end of list */ }
3045};
3046
f6b134ac 3047int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
f83c6e10 3048{
6d952ebe 3049 const char *name;
f83c6e10
MM		 3050 const char *type;
3051 int i;
3052
3053 type = qemu_opt_get(opts, "type");
3054 if (!type) {
3055 qemu_error("No type specified for -net\n");
3056 return -1;
3057 }
3058
f6b134ac
MM		 3059 if (is_netdev) {
3060 if (strcmp(type, "tap") != 0 &&
3061#ifdef CONFIG_SLIRP
3062 strcmp(type, "user") != 0 &&
3063#endif
3064#ifdef CONFIG_VDE
3065 strcmp(type, "vde") != 0 &&
3066#endif
3067 strcmp(type, "socket") != 0) {
3068 qemu_error("The '%s' network backend type is not valid with -netdev\n",
3069 type);
3070 return -1;
3071 }
3072
3073 if (qemu_opt_get(opts, "vlan")) {
3074 qemu_error("The 'vlan' parameter is not valid with -netdev\n");
3075 return -1;
3076 }
3077 if (qemu_opt_get(opts, "name")) {
3078 qemu_error("The 'name' parameter is not valid with -netdev\n");
3079 return -1;
3080 }
3081 if (!qemu_opts_id(opts)) {
3082 qemu_error("The id= parameter is required with -netdev\n");
3083 return -1;
3084 }
3085 }
3086
6d952ebe
MM		 3087 name = qemu_opts_id(opts);
3088 if (!name) {
3089 name = qemu_opt_get(opts, "name");
3090 }
3091
f83c6e10
MM		 3092 for (i = 0; net_client_types[i].type != NULL; i++) {
3093 if (!strcmp(net_client_types[i].type, type)) {
f6b134ac
MM		 3094 VLANState *vlan = NULL;
3095
f83c6e10
MM		 3096 if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
3097 return -1;
3098 }
3099
5869c4d5
MM		 3100 /* Do not add to a vlan if it's a -netdev or a nic with a
3101 * netdev= parameter. */
3102 if (!(is_netdev ||
3103 (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
f6b134ac
MM		 3104 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
3105 }
3106
f83c6e10 3107 if (net_client_types[i].init) {
f6b134ac 3108 return net_client_types[i].init(opts, mon, name, vlan);
f83c6e10
MM		 3109 } else {
3110 return 0;
3111 }
3112 }
3113 }
3114
3115 qemu_error("Invalid -net type '%s'\n", type);
3116 return -1;
3117}
3118
8b13c4a7
AL		 3119void net_client_uninit(NICInfo *nd)
3120{
d80b9fc6
MM		 3121 if (nd->vlan) {
3122 nd->vlan->nb_guest_devs--;
3123 }
8b13c4a7 3124 nb_nics--;
a9796703 3125
9203f520
MM		 3126 qemu_free(nd->model);
3127 qemu_free(nd->name);
3128 qemu_free(nd->devaddr);
a9796703 3129
d2cffe30 3130 nd->used = 0;
8b13c4a7
AL		 3131}
3132
6f338c34
AL		 3133static int net_host_check_device(const char *device)
3134{
3135 int i;
bb9ea79e 3136 const char *valid_param_list[] = { "tap", "socket", "dump"
6f338c34
AL		 3137#ifdef CONFIG_SLIRP
3138 ,"user"
3139#endif
3140#ifdef CONFIG_VDE
3141 ,"vde"
3142#endif
3143 };
3144 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
3145 if (!strncmp(valid_param_list[i], device,
3146 strlen(valid_param_list[i])))
3147 return 1;
3148 }
3149
3150 return 0;
3151}
3152
f18c16de 3153void net_host_device_add(Monitor *mon, const QDict *qdict)
6f338c34 3154{
f18c16de 3155 const char *device = qdict_get_str(qdict, "device");
7f1c9d20
MM		 3156 const char *opts_str = qdict_get_try_str(qdict, "opts");
3157 QemuOpts *opts;
f18c16de 3158
6f338c34 3159 if (!net_host_check_device(device)) {
376253ec 3160 monitor_printf(mon, "invalid host network device %s\n", device);
6f338c34
AL		 3161 return;
3162 }
7f1c9d20
MM		 3163
3164 opts = qemu_opts_parse(&qemu_net_opts, opts_str ? opts_str : "", NULL);
3165 if (!opts) {
3166 monitor_printf(mon, "parsing network options '%s' failed\n",
3167 opts_str ? opts_str : "");
3168 return;
3169 }
3170
3171 qemu_opt_set(opts, "type", device);
3172
f6b134ac 3173 if (net_client_init(mon, opts, 0) < 0) {
5c8be678
AL		 3174 monitor_printf(mon, "adding host network device %s failed\n", device);
3175 }
6f338c34
AL		 3176}
3177
f18c16de 3178void net_host_device_remove(Monitor *mon, const QDict *qdict)
6f338c34 3179{
6f338c34 3180 VLANClientState *vc;
f18c16de
LC		 3181 int vlan_id = qdict_get_int(qdict, "vlan_id");
3182 const char *device = qdict_get_str(qdict, "device");
6f338c34 3183
1a609520 3184 vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
6f338c34 3185 if (!vc) {
6f338c34
AL		 3186 return;
3187 }
e8f1f9db
AL		 3188 if (!net_host_check_device(vc->model)) {
3189 monitor_printf(mon, "invalid host network device %s\n", device);
3190 return;
3191 }
6f338c34
AL		 3192 qemu_del_vlan_client(vc);
3193}
3194
406c8df3
GC		 3195void net_set_boot_mask(int net_boot_mask)
3196{
3197 int i;
3198
3199 /* Only the first four NICs may be bootable */
3200 net_boot_mask = net_boot_mask & 0xF;
3201
3202 for (i = 0; i < nb_nics; i++) {
3203 if (net_boot_mask & (1 << i)) {
3204 nd_table[i].bootable = 1;
3205 net_boot_mask &= ~(1 << i);
3206 }
3207 }
3208
3209 if (net_boot_mask) {
3210 fprintf(stderr, "Cannot boot from non-existent NIC\n");
3211 exit(1);
3212 }
3213}
3214
376253ec 3215void do_info_network(Monitor *mon)
63a01ef8
AL		 3216{
3217 VLANState *vlan;
63a01ef8 3218
5610c3aa
MM		 3219 QTAILQ_FOREACH(vlan, &vlans, next) {
3220 VLANClientState *vc;
3221
376253ec 3222 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
5610c3aa
MM		 3223
3224 QTAILQ_FOREACH(vc, &vlan->clients, next) {
376253ec 3225 monitor_printf(mon, " %s: %s\n", vc->name, vc->info_str);
5610c3aa 3226 }
63a01ef8
AL		 3227 }
3228}
3229
f18c16de 3230void do_set_link(Monitor *mon, const QDict *qdict)
436e5e53
AL		 3231{
3232 VLANState *vlan;
3233 VLANClientState *vc = NULL;
f18c16de
LC		 3234 const char *name = qdict_get_str(qdict, "name");
3235 const char *up_or_down = qdict_get_str(qdict, "up_or_down");
436e5e53 3236
5610c3aa
MM		 3237 QTAILQ_FOREACH(vlan, &vlans, next) {
3238 QTAILQ_FOREACH(vc, &vlan->clients, next) {
3239 if (strcmp(vc->name, name) == 0) {
dd5de373 3240 goto done;
5610c3aa
MM		 3241 }
3242 }
3243 }
dd5de373 3244done:
436e5e53
AL		 3245
3246 if (!vc) {
7dc3fa09 3247 monitor_printf(mon, "could not find network device '%s'\n", name);
c3cf0d3f 3248 return;
436e5e53
AL		 3249 }
3250
3251 if (strcmp(up_or_down, "up") == 0)
3252 vc->link_down = 0;
3253 else if (strcmp(up_or_down, "down") == 0)
3254 vc->link_down = 1;
3255 else
376253ec
AL		 3256 monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
3257 "valid\n", up_or_down);
436e5e53 3258
34b25ca7
AL		 3259 if (vc->link_status_changed)
3260 vc->link_status_changed(vc);
436e5e53
AL		 3261}
3262
63a01ef8
AL		 3263void net_cleanup(void)
3264{
3265 VLANState *vlan;
577c4af9 3266 VLANClientState *vc, *next_vc;
63a01ef8 3267
5610c3aa 3268 QTAILQ_FOREACH(vlan, &vlans, next) {
5610c3aa 3269 QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
b946a153 3270 qemu_del_vlan_client(vc);
63a01ef8
AL		 3271 }
3272 }
577c4af9
MM		 3273
3274 QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
3275 qemu_del_vlan_client(vc);
3276 }
63a01ef8
AL		 3277}
3278
dc1c9fe8 3279static void net_check_clients(void)
63a01ef8
AL		 3280{
3281 VLANState *vlan;
3282
5610c3aa 3283 QTAILQ_FOREACH(vlan, &vlans, next) {
63a01ef8
AL		 3284 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
3285 continue;
3286 if (vlan->nb_guest_devs == 0)
3287 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
3288 if (vlan->nb_host_devs == 0)
3289 fprintf(stderr,
3290 "Warning: vlan %d is not connected to host network\n",
3291 vlan->id);
3292 }
3293}
dc1c9fe8
MM		 3294
3295static int net_init_client(QemuOpts *opts, void *dummy)
3296{
f6b134ac
MM		 3297 return net_client_init(NULL, opts, 0);
3298}
3299
3300static int net_init_netdev(QemuOpts *opts, void *dummy)
3301{
3302 return net_client_init(NULL, opts, 1);
dc1c9fe8
MM		 3303}
3304
3305int net_init_clients(void)
3306{
3307 if (QTAILQ_EMPTY(&qemu_net_opts.head)) {
3308 /* if no clients, we use a default config */
3309 qemu_opts_set(&qemu_net_opts, NULL, "type", "nic");
3310#ifdef CONFIG_SLIRP
3311 qemu_opts_set(&qemu_net_opts, NULL, "type", "user");
3312#endif
3313 }
3314
5610c3aa 3315 QTAILQ_INIT(&vlans);
577c4af9 3316 QTAILQ_INIT(&non_vlan_clients);
5610c3aa 3317
f6b134ac
MM		 3318 if (qemu_opts_foreach(&qemu_netdev_opts, net_init_netdev, NULL, 1) == -1)
3319 return -1;
3320
dc1c9fe8
MM		 3321 if (qemu_opts_foreach(&qemu_net_opts, net_init_client, NULL, 1) == -1) {
3322 return -1;
3323 }
3324
3325 net_check_clients();
3326
3327 return 0;
3328}
3329
7f161aae 3330int net_client_parse(QemuOptsList *opts_list, const char *optarg)
dc1c9fe8 3331{
a3a766e7 3332#if defined(CONFIG_SLIRP)
dc1c9fe8 3333 /* handle legacy -net channel,port:chr */
7f161aae
MM		 3334 if (!strcmp(opts_list->name, "net") &&
3335 !strncmp(optarg, "channel,", strlen("channel,"))) {
dc1c9fe8
MM		 3336 int ret;
3337
3338 optarg += strlen("channel,");
3339
3340 if (QTAILQ_EMPTY(&slirp_stacks)) {
3341 struct slirp_config_str *config;
3342
3343 config = qemu_malloc(sizeof(*config));
3344 pstrcpy(config->str, sizeof(config->str), optarg);
3345 config->flags = SLIRP_CFG_LEGACY;
3346 config->next = slirp_configs;
3347 slirp_configs = config;
3348 ret = 0;
3349 } else {
3350 ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), optarg, 1);
3351 }
3352
3353 return ret;
3354 }
a3a766e7 3355#endif
7f161aae 3356 if (!qemu_opts_parse(opts_list, optarg, "type")) {
dc1c9fe8
MM		 3357 return -1;
3358 }
3359
3360 return 0;
3361}
QEMU mirror