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