Statistics
| Branch: | Revision:

root / net.c @ 283c7c63

History | View | Annotate | Download (87.2 kB)

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
 */
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

    
32
/* Needed early for CONFIG_BSD etc. */
33
#include "config-host.h"
34

    
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>
41
#include <sys/resource.h>
42
#include <sys/socket.h>
43
#include <netinet/in.h>
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>
52
#include <dirent.h>
53
#include <netdb.h>
54
#include <sys/select.h>
55
#ifdef CONFIG_BSD
56
#include <sys/stat.h>
57
#if defined(__FreeBSD__) || defined(__DragonFly__)
58
#include <libutil.h>
59
#else
60
#include <util.h>
61
#endif
62
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
63
#include <freebsd/stdlib.h>
64
#else
65
#ifdef __linux__
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

    
96
#if defined(__OpenBSD__)
97
#include <util.h>
98
#endif
99

    
100
#if defined(CONFIG_VDE)
101
#include <libvdeplug.h>
102
#endif
103

    
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"
112
#include "qemu-log.h"
113
#include "qemu-config.h"
114

    
115
#include "slirp/libslirp.h"
116

    
117
static QTAILQ_HEAD(, VLANState) vlans;
118
static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
119

    
120
/***********************************************************/
121
/* network device redirectors */
122

    
123
#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
124
static void hex_dump(FILE *f, const uint8_t *buf, int size)
125
{
126
    int len, i, j, c;
127

    
128
    for(i=0;i<size;i+=16) {
129
        len = size - i;
130
        if (len > 16)
131
            len = 16;
132
        fprintf(f, "%08x ", i);
133
        for(j=0;j<16;j++) {
134
            if (j < len)
135
                fprintf(f, " %02x", buf[i+j]);
136
            else
137
                fprintf(f, "   ");
138
        }
139
        fprintf(f, " ");
140
        for(j=0;j<len;j++) {
141
            c = buf[i+j];
142
            if (c < ' ' || c > '~')
143
                c = '.';
144
            fprintf(f, "%c", c);
145
        }
146
        fprintf(f, "\n");
147
    }
148
}
149
#endif
150

    
151
static int parse_macaddr(uint8_t *macaddr, const char *p)
152
{
153
    int i;
154
    char *last_char;
155
    long int offset;
156

    
157
    errno = 0;
158
    offset = strtol(p, &last_char, 0);    
159
    if (0 == errno && '\0' == *last_char &&
160
            offset >= 0 && offset <= 0xFFFFFF) {
161
        macaddr[3] = (offset & 0xFF0000) >> 16;
162
        macaddr[4] = (offset & 0xFF00) >> 8;
163
        macaddr[5] = offset & 0xFF;
164
        return 0;
165
    } else {
166
        for(i = 0; i < 6; i++) {
167
            macaddr[i] = strtol(p, (char **)&p, 16);
168
            if (i == 5) {
169
                if (*p != '\0')
170
                    return -1;
171
            } else {
172
                if (*p != ':' && *p != '-')
173
                    return -1;
174
                p++;
175
            }
176
        }
177
        return 0;    
178
    }
179

    
180
    return -1;
181
}
182

    
183
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
184
{
185
    const char *p, *p1;
186
    int len;
187
    p = *pp;
188
    p1 = strchr(p, sep);
189
    if (!p1)
190
        return -1;
191
    len = p1 - p;
192
    p1++;
193
    if (buf_size > 0) {
194
        if (len > buf_size - 1)
195
            len = buf_size - 1;
196
        memcpy(buf, p, len);
197
        buf[len] = '\0';
198
    }
199
    *pp = p1;
200
    return 0;
201
}
202

    
203
int parse_host_src_port(struct sockaddr_in *haddr,
204
                        struct sockaddr_in *saddr,
205
                        const char *input_str)
206
{
207
    char *str = strdup(input_str);
208
    char *host_str = str;
209
    char *src_str;
210
    const char *src_str2;
211
    char *ptr;
212

    
213
    /*
214
     * Chop off any extra arguments at the end of the string which
215
     * would start with a comma, then fill in the src port information
216
     * if it was provided else use the "any address" and "any port".
217
     */
218
    if ((ptr = strchr(str,',')))
219
        *ptr = '\0';
220

    
221
    if ((src_str = strchr(input_str,'@'))) {
222
        *src_str = '\0';
223
        src_str++;
224
    }
225

    
226
    if (parse_host_port(haddr, host_str) < 0)
227
        goto fail;
228

    
229
    src_str2 = src_str;
230
    if (!src_str || *src_str == '\0')
231
        src_str2 = ":0";
232

    
233
    if (parse_host_port(saddr, src_str2) < 0)
234
        goto fail;
235

    
236
    free(str);
237
    return(0);
238

    
239
fail:
240
    free(str);
241
    return -1;
242
}
243

    
244
int parse_host_port(struct sockaddr_in *saddr, const char *str)
245
{
246
    char buf[512];
247
    struct hostent *he;
248
    const char *p, *r;
249
    int port;
250

    
251
    p = str;
252
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
253
        return -1;
254
    saddr->sin_family = AF_INET;
255
    if (buf[0] == '\0') {
256
        saddr->sin_addr.s_addr = 0;
257
    } else {
258
        if (qemu_isdigit(buf[0])) {
259
            if (!inet_aton(buf, &saddr->sin_addr))
260
                return -1;
261
        } else {
262
            if ((he = gethostbyname(buf)) == NULL)
263
                return - 1;
264
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
265
        }
266
    }
267
    port = strtol(p, (char **)&r, 0);
268
    if (r == p)
269
        return -1;
270
    saddr->sin_port = htons(port);
271
    return 0;
272
}
273

    
274
void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
275
{
276
    snprintf(vc->info_str, sizeof(vc->info_str),
277
             "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
278
             vc->model,
279
             macaddr[0], macaddr[1], macaddr[2],
280
             macaddr[3], macaddr[4], macaddr[5]);
281
}
282

    
283
static char *assign_name(VLANClientState *vc1, const char *model)
284
{
285
    VLANState *vlan;
286
    char buf[256];
287
    int id = 0;
288

    
289
    QTAILQ_FOREACH(vlan, &vlans, next) {
290
        VLANClientState *vc;
291

    
292
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
293
            if (vc != vc1 && strcmp(vc->model, model) == 0) {
294
                id++;
295
            }
296
        }
297
    }
298

    
299
    snprintf(buf, sizeof(buf), "%s.%d", model, id);
300

    
301
    return qemu_strdup(buf);
302
}
303

    
304
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
305
                                      VLANClientState *peer,
306
                                      const char *model,
307
                                      const char *name,
308
                                      NetCanReceive *can_receive,
309
                                      NetReceive *receive,
310
                                      NetReceiveIOV *receive_iov,
311
                                      NetCleanup *cleanup,
312
                                      void *opaque)
313
{
314
    VLANClientState *vc;
315

    
316
    vc = qemu_mallocz(sizeof(VLANClientState));
317

    
318
    vc->model = qemu_strdup(model);
319
    if (name)
320
        vc->name = qemu_strdup(name);
321
    else
322
        vc->name = assign_name(vc, model);
323
    vc->can_receive = can_receive;
324
    vc->receive = receive;
325
    vc->receive_iov = receive_iov;
326
    vc->cleanup = cleanup;
327
    vc->opaque = opaque;
328

    
329
    if (vlan) {
330
        assert(!peer);
331
        vc->vlan = vlan;
332
        QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
333
    } else {
334
        if (peer) {
335
            vc->peer = peer;
336
            peer->peer = vc;
337
        }
338
        QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
339
    }
340

    
341
    return vc;
342
}
343

    
344
void qemu_del_vlan_client(VLANClientState *vc)
345
{
346
    if (vc->vlan) {
347
        QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
348
    } else {
349
        QTAILQ_REMOVE(&non_vlan_clients, vc, next);
350
        if (vc->peer) {
351
            vc->peer->peer = NULL;
352
        }
353
    }
354

    
355
    if (vc->cleanup) {
356
        vc->cleanup(vc);
357
    }
358

    
359
    qemu_free(vc->name);
360
    qemu_free(vc->model);
361
    qemu_free(vc);
362
}
363

    
364
VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
365
{
366
    VLANClientState *vc;
367

    
368
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
369
        if (vc->opaque == opaque) {
370
            return vc;
371
        }
372
    }
373

    
374
    return NULL;
375
}
376

    
377
static VLANClientState *
378
qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
379
                              const char *client_str)
380
{
381
    VLANState *vlan;
382
    VLANClientState *vc;
383

    
384
    vlan = qemu_find_vlan(vlan_id, 0);
385
    if (!vlan) {
386
        monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
387
        return NULL;
388
    }
389

    
390
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
391
        if (!strcmp(vc->name, client_str)) {
392
            break;
393
        }
394
    }
395
    if (!vc) {
396
        monitor_printf(mon, "can't find device %s on VLAN %d\n",
397
                       client_str, vlan_id);
398
    }
399

    
400
    return vc;
401
}
402

    
403
int qemu_can_send_packet(VLANClientState *sender)
404
{
405
    VLANState *vlan = sender->vlan;
406
    VLANClientState *vc;
407

    
408
    if (!sender->vlan) {
409
        return 1;
410
    }
411

    
412
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
413
        if (vc == sender) {
414
            continue;
415
        }
416

    
417
        /* no can_receive() handler, they can always receive */
418
        if (!vc->can_receive || vc->can_receive(vc)) {
419
            return 1;
420
        }
421
    }
422
    return 0;
423
}
424

    
425
static int
426
qemu_deliver_packet(VLANClientState *sender, const uint8_t *buf, int size)
427
{
428
    VLANClientState *vc;
429
    int ret = -1;
430

    
431
    sender->vlan->delivering = 1;
432

    
433
    QTAILQ_FOREACH(vc, &sender->vlan->clients, next) {
434
        ssize_t len;
435

    
436
        if (vc == sender) {
437
            continue;
438
        }
439

    
440
        if (vc->link_down) {
441
            ret = size;
442
            continue;
443
        }
444

    
445
        len = vc->receive(vc, buf, size);
446

    
447
        ret = (ret >= 0) ? ret : len;
448
    }
449

    
450
    sender->vlan->delivering = 0;
451

    
452
    return ret;
453
}
454

    
455
void qemu_purge_queued_packets(VLANClientState *vc)
456
{
457
    VLANPacket *packet, *next;
458

    
459
    if (!vc->vlan)
460
        return;
461

    
462
    QTAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) {
463
        if (packet->sender == vc) {
464
            QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
465
            qemu_free(packet);
466
        }
467
    }
468
}
469

    
470
void qemu_flush_queued_packets(VLANClientState *vc)
471
{
472
    if (!vc->vlan)
473
        return;
474

    
475
    while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) {
476
        VLANPacket *packet;
477
        int ret;
478

    
479
        packet = QTAILQ_FIRST(&vc->vlan->send_queue);
480
        QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
481

    
482
        ret = qemu_deliver_packet(packet->sender, packet->data, packet->size);
483
        if (ret == 0 && packet->sent_cb != NULL) {
484
            QTAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry);
485
            break;
486
        }
487

    
488
        if (packet->sent_cb)
489
            packet->sent_cb(packet->sender, ret);
490

    
491
        qemu_free(packet);
492
    }
493
}
494

    
495
static void qemu_enqueue_packet(VLANClientState *sender,
496
                                const uint8_t *buf, int size,
497
                                NetPacketSent *sent_cb)
498
{
499
    VLANPacket *packet;
500

    
501
    packet = qemu_malloc(sizeof(VLANPacket) + size);
502
    packet->sender = sender;
503
    packet->size = size;
504
    packet->sent_cb = sent_cb;
505
    memcpy(packet->data, buf, size);
506

    
507
    QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
508
}
509

    
510
ssize_t qemu_send_packet_async(VLANClientState *sender,
511
                               const uint8_t *buf, int size,
512
                               NetPacketSent *sent_cb)
513
{
514
    int ret;
515

    
516
    if (sender->link_down || !sender->vlan) {
517
        return size;
518
    }
519

    
520
#ifdef DEBUG_NET
521
    printf("qemu_send_packet_async:\n");
522
    hex_dump(stdout, buf, size);
523
#endif
524

    
525
    if (sender->vlan->delivering) {
526
        qemu_enqueue_packet(sender, buf, size, NULL);
527
        return size;
528
    }
529

    
530
    ret = qemu_deliver_packet(sender, buf, size);
531
    if (ret == 0 && sent_cb != NULL) {
532
        qemu_enqueue_packet(sender, buf, size, sent_cb);
533
        return 0;
534
    }
535

    
536
    qemu_flush_queued_packets(sender);
537

    
538
    return ret;
539
}
540

    
541
void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
542
{
543
    qemu_send_packet_async(vc, buf, size, NULL);
544
}
545

    
546
static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
547
                               int iovcnt)
548
{
549
    uint8_t buffer[4096];
550
    size_t offset = 0;
551
    int i;
552

    
553
    for (i = 0; i < iovcnt; i++) {
554
        size_t len;
555

    
556
        len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
557
        memcpy(buffer + offset, iov[i].iov_base, len);
558
        offset += len;
559
    }
560

    
561
    return vc->receive(vc, buffer, offset);
562
}
563

    
564
static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
565
{
566
    size_t offset = 0;
567
    int i;
568

    
569
    for (i = 0; i < iovcnt; i++)
570
        offset += iov[i].iov_len;
571
    return offset;
572
}
573

    
574
static int qemu_deliver_packet_iov(VLANClientState *sender,
575
                                   const struct iovec *iov, int iovcnt)
576
{
577
    VLANClientState *vc;
578
    int ret = -1;
579

    
580
    sender->vlan->delivering = 1;
581

    
582
    QTAILQ_FOREACH(vc, &sender->vlan->clients, next) {
583
        ssize_t len;
584

    
585
        if (vc == sender) {
586
            continue;
587
        }
588

    
589
        if (vc->link_down) {
590
            ret = calc_iov_length(iov, iovcnt);
591
            continue;
592
        }
593

    
594
        if (vc->receive_iov) {
595
            len = vc->receive_iov(vc, iov, iovcnt);
596
        } else {
597
            len = vc_sendv_compat(vc, iov, iovcnt);
598
        }
599

    
600
        ret = (ret >= 0) ? ret : len;
601
    }
602

    
603
    sender->vlan->delivering = 0;
604

    
605
    return ret;
606
}
607

    
608
static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender,
609
                                       const struct iovec *iov, int iovcnt,
610
                                       NetPacketSent *sent_cb)
611
{
612
    VLANPacket *packet;
613
    size_t max_len = 0;
614
    int i;
615

    
616
    max_len = calc_iov_length(iov, iovcnt);
617

    
618
    packet = qemu_malloc(sizeof(VLANPacket) + max_len);
619
    packet->sender = sender;
620
    packet->sent_cb = sent_cb;
621
    packet->size = 0;
622

    
623
    for (i = 0; i < iovcnt; i++) {
624
        size_t len = iov[i].iov_len;
625

    
626
        memcpy(packet->data + packet->size, iov[i].iov_base, len);
627
        packet->size += len;
628
    }
629

    
630
    QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
631

    
632
    return packet->size;
633
}
634

    
635
ssize_t qemu_sendv_packet_async(VLANClientState *sender,
636
                                const struct iovec *iov, int iovcnt,
637
                                NetPacketSent *sent_cb)
638
{
639
    int ret;
640

    
641
    if (sender->link_down || !sender->vlan) {
642
        return calc_iov_length(iov, iovcnt);
643
    }
644

    
645
    if (sender->vlan->delivering) {
646
        return qemu_enqueue_packet_iov(sender, iov, iovcnt, NULL);
647
    }
648

    
649
    ret = qemu_deliver_packet_iov(sender, iov, iovcnt);
650
    if (ret == 0 && sent_cb != NULL) {
651
        qemu_enqueue_packet_iov(sender, iov, iovcnt, sent_cb);
652
        return 0;
653
    }
654

    
655
    qemu_flush_queued_packets(sender);
656

    
657
    return ret;
658
}
659

    
660
ssize_t
661
qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
662
{
663
    return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
664
}
665

    
666
#if defined(CONFIG_SLIRP)
667

    
668
/* slirp network adapter */
669

    
670
#define SLIRP_CFG_HOSTFWD 1
671
#define SLIRP_CFG_LEGACY  2
672

    
673
struct slirp_config_str {
674
    struct slirp_config_str *next;
675
    int flags;
676
    char str[1024];
677
    int legacy_format;
678
};
679

    
680
typedef struct SlirpState {
681
    QTAILQ_ENTRY(SlirpState) entry;
682
    VLANClientState *vc;
683
    Slirp *slirp;
684
#ifndef _WIN32
685
    char smb_dir[128];
686
#endif
687
} SlirpState;
688

    
689
static struct slirp_config_str *slirp_configs;
690
const char *legacy_tftp_prefix;
691
const char *legacy_bootp_filename;
692
static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
693
    QTAILQ_HEAD_INITIALIZER(slirp_stacks);
694

    
695
static int slirp_hostfwd(SlirpState *s, const char *redir_str,
696
                         int legacy_format);
697
static int slirp_guestfwd(SlirpState *s, const char *config_str,
698
                          int legacy_format);
699

    
700
#ifndef _WIN32
701
static const char *legacy_smb_export;
702

    
703
static int slirp_smb(SlirpState *s, const char *exported_dir,
704
                     struct in_addr vserver_addr);
705
static void slirp_smb_cleanup(SlirpState *s);
706
#else
707
static inline void slirp_smb_cleanup(SlirpState *s) { }
708
#endif
709

    
710
int slirp_can_output(void *opaque)
711
{
712
    SlirpState *s = opaque;
713

    
714
    return qemu_can_send_packet(s->vc);
715
}
716

    
717
void slirp_output(void *opaque, const uint8_t *pkt, int pkt_len)
718
{
719
    SlirpState *s = opaque;
720

    
721
#ifdef DEBUG_SLIRP
722
    printf("slirp output:\n");
723
    hex_dump(stdout, pkt, pkt_len);
724
#endif
725
    qemu_send_packet(s->vc, pkt, pkt_len);
726
}
727

    
728
static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
729
{
730
    SlirpState *s = vc->opaque;
731

    
732
#ifdef DEBUG_SLIRP
733
    printf("slirp input:\n");
734
    hex_dump(stdout, buf, size);
735
#endif
736
    slirp_input(s->slirp, buf, size);
737
    return size;
738
}
739

    
740
static void net_slirp_cleanup(VLANClientState *vc)
741
{
742
    SlirpState *s = vc->opaque;
743

    
744
    slirp_cleanup(s->slirp);
745
    slirp_smb_cleanup(s);
746
    QTAILQ_REMOVE(&slirp_stacks, s, entry);
747
    qemu_free(s);
748
}
749

    
750
static int net_slirp_init(VLANState *vlan, const char *model,
751
                          const char *name, int restricted,
752
                          const char *vnetwork, const char *vhost,
753
                          const char *vhostname, const char *tftp_export,
754
                          const char *bootfile, const char *vdhcp_start,
755
                          const char *vnameserver, const char *smb_export,
756
                          const char *vsmbserver)
757
{
758
    /* default settings according to historic slirp */
759
    struct in_addr net  = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
760
    struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
761
    struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
762
    struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
763
    struct in_addr dns  = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
764
#ifndef _WIN32
765
    struct in_addr smbsrv = { .s_addr = 0 };
766
#endif
767
    SlirpState *s;
768
    char buf[20];
769
    uint32_t addr;
770
    int shift;
771
    char *end;
772
    struct slirp_config_str *config;
773

    
774
    if (!tftp_export) {
775
        tftp_export = legacy_tftp_prefix;
776
    }
777
    if (!bootfile) {
778
        bootfile = legacy_bootp_filename;
779
    }
780

    
781
    if (vnetwork) {
782
        if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
783
            if (!inet_aton(vnetwork, &net)) {
784
                return -1;
785
            }
786
            addr = ntohl(net.s_addr);
787
            if (!(addr & 0x80000000)) {
788
                mask.s_addr = htonl(0xff000000); /* class A */
789
            } else if ((addr & 0xfff00000) == 0xac100000) {
790
                mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
791
            } else if ((addr & 0xc0000000) == 0x80000000) {
792
                mask.s_addr = htonl(0xffff0000); /* class B */
793
            } else if ((addr & 0xffff0000) == 0xc0a80000) {
794
                mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
795
            } else if ((addr & 0xffff0000) == 0xc6120000) {
796
                mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
797
            } else if ((addr & 0xe0000000) == 0xe0000000) {
798
                mask.s_addr = htonl(0xffffff00); /* class C */
799
            } else {
800
                mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
801
            }
802
        } else {
803
            if (!inet_aton(buf, &net)) {
804
                return -1;
805
            }
806
            shift = strtol(vnetwork, &end, 10);
807
            if (*end != '\0') {
808
                if (!inet_aton(vnetwork, &mask)) {
809
                    return -1;
810
                }
811
            } else if (shift < 4 || shift > 32) {
812
                return -1;
813
            } else {
814
                mask.s_addr = htonl(0xffffffff << (32 - shift));
815
            }
816
        }
817
        net.s_addr &= mask.s_addr;
818
        host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
819
        dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
820
        dns.s_addr  = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
821
    }
822

    
823
    if (vhost && !inet_aton(vhost, &host)) {
824
        return -1;
825
    }
826
    if ((host.s_addr & mask.s_addr) != net.s_addr) {
827
        return -1;
828
    }
829

    
830
    if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
831
        return -1;
832
    }
833
    if ((dhcp.s_addr & mask.s_addr) != net.s_addr ||
834
        dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
835
        return -1;
836
    }
837

    
838
    if (vnameserver && !inet_aton(vnameserver, &dns)) {
839
        return -1;
840
    }
841
    if ((dns.s_addr & mask.s_addr) != net.s_addr ||
842
        dns.s_addr == host.s_addr) {
843
        return -1;
844
    }
845

    
846
#ifndef _WIN32
847
    if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
848
        return -1;
849
    }
850
#endif
851

    
852
    s = qemu_mallocz(sizeof(SlirpState));
853
    s->slirp = slirp_init(restricted, net, mask, host, vhostname,
854
                          tftp_export, bootfile, dhcp, dns, s);
855
    QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
856

    
857
    for (config = slirp_configs; config; config = config->next) {
858
        if (config->flags & SLIRP_CFG_HOSTFWD) {
859
            if (slirp_hostfwd(s, config->str,
860
                              config->flags & SLIRP_CFG_LEGACY) < 0)
861
                return -1;
862
        } else {
863
            if (slirp_guestfwd(s, config->str,
864
                               config->flags & SLIRP_CFG_LEGACY) < 0)
865
                return -1;
866
        }
867
    }
868
#ifndef _WIN32
869
    if (!smb_export) {
870
        smb_export = legacy_smb_export;
871
    }
872
    if (smb_export) {
873
        if (slirp_smb(s, smb_export, smbsrv) < 0)
874
            return -1;
875
    }
876
#endif
877

    
878
    s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
879
                                 slirp_receive, NULL,
880
                                 net_slirp_cleanup, s);
881
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
882
             "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');
883
    return 0;
884
}
885

    
886
static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
887
                                const char *stack)
888
{
889
    VLANClientState *vc;
890

    
891
    if (vlan) {
892
        vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
893
        if (!vc) {
894
            return NULL;
895
        }
896
        if (strcmp(vc->model, "user")) {
897
            monitor_printf(mon, "invalid device specified\n");
898
            return NULL;
899
        }
900
        return vc->opaque;
901
    } else {
902
        if (QTAILQ_EMPTY(&slirp_stacks)) {
903
            monitor_printf(mon, "user mode network stack not in use\n");
904
            return NULL;
905
        }
906
        return QTAILQ_FIRST(&slirp_stacks);
907
    }
908
}
909

    
910
void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
911
{
912
    struct in_addr host_addr = { .s_addr = INADDR_ANY };
913
    int host_port;
914
    char buf[256] = "";
915
    const char *src_str, *p;
916
    SlirpState *s;
917
    int is_udp = 0;
918
    int err;
919
    const char *arg1 = qdict_get_str(qdict, "arg1");
920
    const char *arg2 = qdict_get_try_str(qdict, "arg2");
921
    const char *arg3 = qdict_get_try_str(qdict, "arg3");
922

    
923
    if (arg2) {
924
        s = slirp_lookup(mon, arg1, arg2);
925
        src_str = arg3;
926
    } else {
927
        s = slirp_lookup(mon, NULL, NULL);
928
        src_str = arg1;
929
    }
930
    if (!s) {
931
        return;
932
    }
933

    
934
    if (!src_str || !src_str[0])
935
        goto fail_syntax;
936

    
937
    p = src_str;
938
    get_str_sep(buf, sizeof(buf), &p, ':');
939

    
940
    if (!strcmp(buf, "tcp") || buf[0] == '\0') {
941
        is_udp = 0;
942
    } else if (!strcmp(buf, "udp")) {
943
        is_udp = 1;
944
    } else {
945
        goto fail_syntax;
946
    }
947

    
948
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
949
        goto fail_syntax;
950
    }
951
    if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
952
        goto fail_syntax;
953
    }
954

    
955
    host_port = atoi(p);
956

    
957
    err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
958
                               host_addr, host_port);
959

    
960
    monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
961
                   err ? "removed" : "not found");
962
    return;
963

    
964
 fail_syntax:
965
    monitor_printf(mon, "invalid format\n");
966
}
967

    
968
static int slirp_hostfwd(SlirpState *s, const char *redir_str,
969
                         int legacy_format)
970
{
971
    struct in_addr host_addr = { .s_addr = INADDR_ANY };
972
    struct in_addr guest_addr = { .s_addr = 0 };
973
    int host_port, guest_port;
974
    const char *p;
975
    char buf[256];
976
    int is_udp;
977
    char *end;
978

    
979
    p = redir_str;
980
    if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
981
        goto fail_syntax;
982
    }
983
    if (!strcmp(buf, "tcp") || buf[0] == '\0') {
984
        is_udp = 0;
985
    } else if (!strcmp(buf, "udp")) {
986
        is_udp = 1;
987
    } else {
988
        goto fail_syntax;
989
    }
990

    
991
    if (!legacy_format) {
992
        if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
993
            goto fail_syntax;
994
        }
995
        if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
996
            goto fail_syntax;
997
        }
998
    }
999

    
1000
    if (get_str_sep(buf, sizeof(buf), &p, legacy_format ? ':' : '-') < 0) {
1001
        goto fail_syntax;
1002
    }
1003
    host_port = strtol(buf, &end, 0);
1004
    if (*end != '\0' || host_port < 1 || host_port > 65535) {
1005
        goto fail_syntax;
1006
    }
1007

    
1008
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1009
        goto fail_syntax;
1010
    }
1011
    if (buf[0] != '\0' && !inet_aton(buf, &guest_addr)) {
1012
        goto fail_syntax;
1013
    }
1014

    
1015
    guest_port = strtol(p, &end, 0);
1016
    if (*end != '\0' || guest_port < 1 || guest_port > 65535) {
1017
        goto fail_syntax;
1018
    }
1019

    
1020
    if (slirp_add_hostfwd(s->slirp, is_udp, host_addr, host_port, guest_addr,
1021
                          guest_port) < 0) {
1022
        qemu_error("could not set up host forwarding rule '%s'\n",
1023
                   redir_str);
1024
        return -1;
1025
    }
1026
    return 0;
1027

    
1028
 fail_syntax:
1029
    qemu_error("invalid host forwarding rule '%s'\n", redir_str);
1030
    return -1;
1031
}
1032

    
1033
void net_slirp_hostfwd_add(Monitor *mon, const QDict *qdict)
1034
{
1035
    const char *redir_str;
1036
    SlirpState *s;
1037
    const char *arg1 = qdict_get_str(qdict, "arg1");
1038
    const char *arg2 = qdict_get_try_str(qdict, "arg2");
1039
    const char *arg3 = qdict_get_try_str(qdict, "arg3");
1040

    
1041
    if (arg2) {
1042
        s = slirp_lookup(mon, arg1, arg2);
1043
        redir_str = arg3;
1044
    } else {
1045
        s = slirp_lookup(mon, NULL, NULL);
1046
        redir_str = arg1;
1047
    }
1048
    if (s) {
1049
        slirp_hostfwd(s, redir_str, 0);
1050
    }
1051

    
1052
}
1053

    
1054
int net_slirp_redir(const char *redir_str)
1055
{
1056
    struct slirp_config_str *config;
1057

    
1058
    if (QTAILQ_EMPTY(&slirp_stacks)) {
1059
        config = qemu_malloc(sizeof(*config));
1060
        pstrcpy(config->str, sizeof(config->str), redir_str);
1061
        config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
1062
        config->next = slirp_configs;
1063
        slirp_configs = config;
1064
        return 0;
1065
    }
1066

    
1067
    return slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), redir_str, 1);
1068
}
1069

    
1070
#ifndef _WIN32
1071

    
1072
/* automatic user mode samba server configuration */
1073
static void slirp_smb_cleanup(SlirpState *s)
1074
{
1075
    char cmd[128];
1076

    
1077
    if (s->smb_dir[0] != '\0') {
1078
        snprintf(cmd, sizeof(cmd), "rm -rf %s", s->smb_dir);
1079
        system(cmd);
1080
        s->smb_dir[0] = '\0';
1081
    }
1082
}
1083

    
1084
static int slirp_smb(SlirpState* s, const char *exported_dir,
1085
                     struct in_addr vserver_addr)
1086
{
1087
    static int instance;
1088
    char smb_conf[128];
1089
    char smb_cmdline[128];
1090
    FILE *f;
1091

    
1092
    snprintf(s->smb_dir, sizeof(s->smb_dir), "/tmp/qemu-smb.%ld-%d",
1093
             (long)getpid(), instance++);
1094
    if (mkdir(s->smb_dir, 0700) < 0) {
1095
        qemu_error("could not create samba server dir '%s'\n", s->smb_dir);
1096
        return -1;
1097
    }
1098
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", s->smb_dir, "smb.conf");
1099

    
1100
    f = fopen(smb_conf, "w");
1101
    if (!f) {
1102
        slirp_smb_cleanup(s);
1103
        qemu_error("could not create samba server configuration file '%s'\n",
1104
                   smb_conf);
1105
        return -1;
1106
    }
1107
    fprintf(f,
1108
            "[global]\n"
1109
            "private dir=%s\n"
1110
            "smb ports=0\n"
1111
            "socket address=127.0.0.1\n"
1112
            "pid directory=%s\n"
1113
            "lock directory=%s\n"
1114
            "log file=%s/log.smbd\n"
1115
            "smb passwd file=%s/smbpasswd\n"
1116
            "security = share\n"
1117
            "[qemu]\n"
1118
            "path=%s\n"
1119
            "read only=no\n"
1120
            "guest ok=yes\n",
1121
            s->smb_dir,
1122
            s->smb_dir,
1123
            s->smb_dir,
1124
            s->smb_dir,
1125
            s->smb_dir,
1126
            exported_dir
1127
            );
1128
    fclose(f);
1129

    
1130
    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
1131
             SMBD_COMMAND, smb_conf);
1132

    
1133
    if (slirp_add_exec(s->slirp, 0, smb_cmdline, &vserver_addr, 139) < 0) {
1134
        slirp_smb_cleanup(s);
1135
        qemu_error("conflicting/invalid smbserver address\n");
1136
        return -1;
1137
    }
1138
    return 0;
1139
}
1140

    
1141
/* automatic user mode samba server configuration (legacy interface) */
1142
int net_slirp_smb(const char *exported_dir)
1143
{
1144
    struct in_addr vserver_addr = { .s_addr = 0 };
1145

    
1146
    if (legacy_smb_export) {
1147
        fprintf(stderr, "-smb given twice\n");
1148
        return -1;
1149
    }
1150
    legacy_smb_export = exported_dir;
1151
    if (!QTAILQ_EMPTY(&slirp_stacks)) {
1152
        return slirp_smb(QTAILQ_FIRST(&slirp_stacks), exported_dir,
1153
                         vserver_addr);
1154
    }
1155
    return 0;
1156
}
1157

    
1158
#endif /* !defined(_WIN32) */
1159

    
1160
struct GuestFwd {
1161
    CharDriverState *hd;
1162
    struct in_addr server;
1163
    int port;
1164
    Slirp *slirp;
1165
};
1166

    
1167
static int guestfwd_can_read(void *opaque)
1168
{
1169
    struct GuestFwd *fwd = opaque;
1170
    return slirp_socket_can_recv(fwd->slirp, fwd->server, fwd->port);
1171
}
1172

    
1173
static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
1174
{
1175
    struct GuestFwd *fwd = opaque;
1176
    slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
1177
}
1178

    
1179
static int slirp_guestfwd(SlirpState *s, const char *config_str,
1180
                          int legacy_format)
1181
{
1182
    struct in_addr server = { .s_addr = 0 };
1183
    struct GuestFwd *fwd;
1184
    const char *p;
1185
    char buf[128];
1186
    char *end;
1187
    int port;
1188

    
1189
    p = config_str;
1190
    if (legacy_format) {
1191
        if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1192
            goto fail_syntax;
1193
        }
1194
    } else {
1195
        if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1196
            goto fail_syntax;
1197
        }
1198
        if (strcmp(buf, "tcp") && buf[0] != '\0') {
1199
            goto fail_syntax;
1200
        }
1201
        if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1202
            goto fail_syntax;
1203
        }
1204
        if (buf[0] != '\0' && !inet_aton(buf, &server)) {
1205
            goto fail_syntax;
1206
        }
1207
        if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
1208
            goto fail_syntax;
1209
        }
1210
    }
1211
    port = strtol(buf, &end, 10);
1212
    if (*end != '\0' || port < 1 || port > 65535) {
1213
        goto fail_syntax;
1214
    }
1215

    
1216
    fwd = qemu_malloc(sizeof(struct GuestFwd));
1217
    snprintf(buf, sizeof(buf), "guestfwd.tcp:%d", port);
1218
    fwd->hd = qemu_chr_open(buf, p, NULL);
1219
    if (!fwd->hd) {
1220
        qemu_error("could not open guest forwarding device '%s'\n", buf);
1221
        qemu_free(fwd);
1222
        return -1;
1223
    }
1224

    
1225
    if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) {
1226
        qemu_error("conflicting/invalid host:port in guest forwarding "
1227
                   "rule '%s'\n", config_str);
1228
        qemu_free(fwd);
1229
        return -1;
1230
    }
1231
    fwd->server = server;
1232
    fwd->port = port;
1233
    fwd->slirp = s->slirp;
1234

    
1235
    qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
1236
                          NULL, fwd);
1237
    return 0;
1238

    
1239
 fail_syntax:
1240
    qemu_error("invalid guest forwarding rule '%s'\n", config_str);
1241
    return -1;
1242
}
1243

    
1244
void do_info_usernet(Monitor *mon)
1245
{
1246
    SlirpState *s;
1247

    
1248
    QTAILQ_FOREACH(s, &slirp_stacks, entry) {
1249
        monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
1250
        slirp_connection_info(s->slirp, mon);
1251
    }
1252
}
1253

    
1254
#endif /* CONFIG_SLIRP */
1255

    
1256
#if !defined(_WIN32)
1257

    
1258
typedef struct TAPState {
1259
    VLANClientState *vc;
1260
    int fd;
1261
    char down_script[1024];
1262
    char down_script_arg[128];
1263
    uint8_t buf[4096];
1264
    unsigned int read_poll : 1;
1265
    unsigned int write_poll : 1;
1266
} TAPState;
1267

    
1268
static int launch_script(const char *setup_script, const char *ifname, int fd);
1269

    
1270
static int tap_can_send(void *opaque);
1271
static void tap_send(void *opaque);
1272
static void tap_writable(void *opaque);
1273

    
1274
static void tap_update_fd_handler(TAPState *s)
1275
{
1276
    qemu_set_fd_handler2(s->fd,
1277
                         s->read_poll  ? tap_can_send : NULL,
1278
                         s->read_poll  ? tap_send     : NULL,
1279
                         s->write_poll ? tap_writable : NULL,
1280
                         s);
1281
}
1282

    
1283
static void tap_read_poll(TAPState *s, int enable)
1284
{
1285
    s->read_poll = !!enable;
1286
    tap_update_fd_handler(s);
1287
}
1288

    
1289
static void tap_write_poll(TAPState *s, int enable)
1290
{
1291
    s->write_poll = !!enable;
1292
    tap_update_fd_handler(s);
1293
}
1294

    
1295
static void tap_writable(void *opaque)
1296
{
1297
    TAPState *s = opaque;
1298

    
1299
    tap_write_poll(s, 0);
1300

    
1301
    qemu_flush_queued_packets(s->vc);
1302
}
1303

    
1304
static ssize_t tap_receive_iov(VLANClientState *vc, const struct iovec *iov,
1305
                               int iovcnt)
1306
{
1307
    TAPState *s = vc->opaque;
1308
    ssize_t len;
1309

    
1310
    do {
1311
        len = writev(s->fd, iov, iovcnt);
1312
    } while (len == -1 && errno == EINTR);
1313

    
1314
    if (len == -1 && errno == EAGAIN) {
1315
        tap_write_poll(s, 1);
1316
        return 0;
1317
    }
1318

    
1319
    return len;
1320
}
1321

    
1322
static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1323
{
1324
    TAPState *s = vc->opaque;
1325
    ssize_t len;
1326

    
1327
    do {
1328
        len = write(s->fd, buf, size);
1329
    } while (len == -1 && (errno == EINTR || errno == EAGAIN));
1330

    
1331
    return len;
1332
}
1333

    
1334
static int tap_can_send(void *opaque)
1335
{
1336
    TAPState *s = opaque;
1337

    
1338
    return qemu_can_send_packet(s->vc);
1339
}
1340

    
1341
#ifdef __sun__
1342
static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1343
{
1344
    struct strbuf sbuf;
1345
    int f = 0;
1346

    
1347
    sbuf.maxlen = maxlen;
1348
    sbuf.buf = (char *)buf;
1349

    
1350
    return getmsg(tapfd, NULL, &sbuf, &f) >= 0 ? sbuf.len : -1;
1351
}
1352
#else
1353
static ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
1354
{
1355
    return read(tapfd, buf, maxlen);
1356
}
1357
#endif
1358

    
1359
static void tap_send_completed(VLANClientState *vc, ssize_t len)
1360
{
1361
    TAPState *s = vc->opaque;
1362
    tap_read_poll(s, 1);
1363
}
1364

    
1365
static void tap_send(void *opaque)
1366
{
1367
    TAPState *s = opaque;
1368
    int size;
1369

    
1370
    do {
1371
        size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
1372
        if (size <= 0) {
1373
            break;
1374
        }
1375

    
1376
        size = qemu_send_packet_async(s->vc, s->buf, size, tap_send_completed);
1377
        if (size == 0) {
1378
            tap_read_poll(s, 0);
1379
        }
1380
    } while (size > 0);
1381
}
1382

    
1383
#ifdef TUNSETSNDBUF
1384
/* sndbuf should be set to a value lower than the tx queue
1385
 * capacity of any destination network interface.
1386
 * Ethernet NICs generally have txqueuelen=1000, so 1Mb is
1387
 * a good default, given a 1500 byte MTU.
1388
 */
1389
#define TAP_DEFAULT_SNDBUF 1024*1024
1390

    
1391
static int tap_set_sndbuf(TAPState *s, QemuOpts *opts)
1392
{
1393
    int sndbuf;
1394

    
1395
    sndbuf = qemu_opt_get_size(opts, "sndbuf", TAP_DEFAULT_SNDBUF);
1396
    if (!sndbuf) {
1397
        sndbuf = INT_MAX;
1398
    }
1399

    
1400
    if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1 && qemu_opt_get(opts, "sndbuf")) {
1401
        qemu_error("TUNSETSNDBUF ioctl failed: %s\n", strerror(errno));
1402
        return -1;
1403
    }
1404
    return 0;
1405
}
1406
#else
1407
static int tap_set_sndbuf(TAPState *s, QemuOpts *opts)
1408
{
1409
    return 0;
1410
}
1411
#endif /* TUNSETSNDBUF */
1412

    
1413
static void tap_cleanup(VLANClientState *vc)
1414
{
1415
    TAPState *s = vc->opaque;
1416

    
1417
    qemu_purge_queued_packets(vc);
1418

    
1419
    if (s->down_script[0])
1420
        launch_script(s->down_script, s->down_script_arg, s->fd);
1421

    
1422
    tap_read_poll(s, 0);
1423
    tap_write_poll(s, 0);
1424
    close(s->fd);
1425
    qemu_free(s);
1426
}
1427

    
1428
/* fd support */
1429

    
1430
static TAPState *net_tap_fd_init(VLANState *vlan,
1431
                                 const char *model,
1432
                                 const char *name,
1433
                                 int fd)
1434
{
1435
    TAPState *s;
1436

    
1437
    s = qemu_mallocz(sizeof(TAPState));
1438
    s->fd = fd;
1439
    s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
1440
                                 tap_receive, tap_receive_iov,
1441
                                 tap_cleanup, s);
1442
    tap_read_poll(s, 1);
1443
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
1444
    return s;
1445
}
1446

    
1447
#if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__)
1448
static int tap_open(char *ifname, int ifname_size)
1449
{
1450
    int fd;
1451
    char *dev;
1452
    struct stat s;
1453

    
1454
    TFR(fd = open("/dev/tap", O_RDWR));
1455
    if (fd < 0) {
1456
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1457
        return -1;
1458
    }
1459

    
1460
    fstat(fd, &s);
1461
    dev = devname(s.st_rdev, S_IFCHR);
1462
    pstrcpy(ifname, ifname_size, dev);
1463

    
1464
    fcntl(fd, F_SETFL, O_NONBLOCK);
1465
    return fd;
1466
}
1467
#elif defined(__sun__)
1468
#define TUNNEWPPA       (('T'<<16) | 0x0001)
1469
/*
1470
 * Allocate TAP device, returns opened fd.
1471
 * Stores dev name in the first arg(must be large enough).
1472
 */
1473
static int tap_alloc(char *dev, size_t dev_size)
1474
{
1475
    int tap_fd, if_fd, ppa = -1;
1476
    static int ip_fd = 0;
1477
    char *ptr;
1478

    
1479
    static int arp_fd = 0;
1480
    int ip_muxid, arp_muxid;
1481
    struct strioctl  strioc_if, strioc_ppa;
1482
    int link_type = I_PLINK;;
1483
    struct lifreq ifr;
1484
    char actual_name[32] = "";
1485

    
1486
    memset(&ifr, 0x0, sizeof(ifr));
1487

    
1488
    if( *dev ){
1489
       ptr = dev;
1490
       while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
1491
       ppa = atoi(ptr);
1492
    }
1493

    
1494
    /* Check if IP device was opened */
1495
    if( ip_fd )
1496
       close(ip_fd);
1497

    
1498
    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
1499
    if (ip_fd < 0) {
1500
       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
1501
       return -1;
1502
    }
1503

    
1504
    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
1505
    if (tap_fd < 0) {
1506
       syslog(LOG_ERR, "Can't open /dev/tap");
1507
       return -1;
1508
    }
1509

    
1510
    /* Assign a new PPA and get its unit number. */
1511
    strioc_ppa.ic_cmd = TUNNEWPPA;
1512
    strioc_ppa.ic_timout = 0;
1513
    strioc_ppa.ic_len = sizeof(ppa);
1514
    strioc_ppa.ic_dp = (char *)&ppa;
1515
    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
1516
       syslog (LOG_ERR, "Can't assign new interface");
1517

    
1518
    TFR(if_fd = open("/dev/tap", O_RDWR, 0));
1519
    if (if_fd < 0) {
1520
       syslog(LOG_ERR, "Can't open /dev/tap (2)");
1521
       return -1;
1522
    }
1523
    if(ioctl(if_fd, I_PUSH, "ip") < 0){
1524
       syslog(LOG_ERR, "Can't push IP module");
1525
       return -1;
1526
    }
1527

    
1528
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
1529
        syslog(LOG_ERR, "Can't get flags\n");
1530

    
1531
    snprintf (actual_name, 32, "tap%d", ppa);
1532
    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1533

    
1534
    ifr.lifr_ppa = ppa;
1535
    /* Assign ppa according to the unit number returned by tun device */
1536

    
1537
    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
1538
        syslog (LOG_ERR, "Can't set PPA %d", ppa);
1539
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
1540
        syslog (LOG_ERR, "Can't get flags\n");
1541
    /* Push arp module to if_fd */
1542
    if (ioctl (if_fd, I_PUSH, "arp") < 0)
1543
        syslog (LOG_ERR, "Can't push ARP module (2)");
1544

    
1545
    /* Push arp module to ip_fd */
1546
    if (ioctl (ip_fd, I_POP, NULL) < 0)
1547
        syslog (LOG_ERR, "I_POP failed\n");
1548
    if (ioctl (ip_fd, I_PUSH, "arp") < 0)
1549
        syslog (LOG_ERR, "Can't push ARP module (3)\n");
1550
    /* Open arp_fd */
1551
    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
1552
    if (arp_fd < 0)
1553
       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
1554

    
1555
    /* Set ifname to arp */
1556
    strioc_if.ic_cmd = SIOCSLIFNAME;
1557
    strioc_if.ic_timout = 0;
1558
    strioc_if.ic_len = sizeof(ifr);
1559
    strioc_if.ic_dp = (char *)&ifr;
1560
    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
1561
        syslog (LOG_ERR, "Can't set ifname to arp\n");
1562
    }
1563

    
1564
    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
1565
       syslog(LOG_ERR, "Can't link TAP device to IP");
1566
       return -1;
1567
    }
1568

    
1569
    if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
1570
        syslog (LOG_ERR, "Can't link TAP device to ARP");
1571

    
1572
    close (if_fd);
1573

    
1574
    memset(&ifr, 0x0, sizeof(ifr));
1575
    pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
1576
    ifr.lifr_ip_muxid  = ip_muxid;
1577
    ifr.lifr_arp_muxid = arp_muxid;
1578

    
1579
    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
1580
    {
1581
      ioctl (ip_fd, I_PUNLINK , arp_muxid);
1582
      ioctl (ip_fd, I_PUNLINK, ip_muxid);
1583
      syslog (LOG_ERR, "Can't set multiplexor id");
1584
    }
1585

    
1586
    snprintf(dev, dev_size, "tap%d", ppa);
1587
    return tap_fd;
1588
}
1589

    
1590
static int tap_open(char *ifname, int ifname_size)
1591
{
1592
    char  dev[10]="";
1593
    int fd;
1594
    if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
1595
       fprintf(stderr, "Cannot allocate TAP device\n");
1596
       return -1;
1597
    }
1598
    pstrcpy(ifname, ifname_size, dev);
1599
    fcntl(fd, F_SETFL, O_NONBLOCK);
1600
    return fd;
1601
}
1602
#elif defined (_AIX)
1603
static int tap_open(char *ifname, int ifname_size)
1604
{
1605
    fprintf (stderr, "no tap on AIX\n");
1606
    return -1;
1607
}
1608
#else
1609
static int tap_open(char *ifname, int ifname_size)
1610
{
1611
    struct ifreq ifr;
1612
    int fd, ret;
1613

    
1614
    TFR(fd = open("/dev/net/tun", O_RDWR));
1615
    if (fd < 0) {
1616
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1617
        return -1;
1618
    }
1619
    memset(&ifr, 0, sizeof(ifr));
1620
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1621
    if (ifname[0] != '\0')
1622
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
1623
    else
1624
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
1625
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1626
    if (ret != 0) {
1627
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1628
        close(fd);
1629
        return -1;
1630
    }
1631
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
1632
    fcntl(fd, F_SETFL, O_NONBLOCK);
1633
    return fd;
1634
}
1635
#endif
1636

    
1637
static int launch_script(const char *setup_script, const char *ifname, int fd)
1638
{
1639
    sigset_t oldmask, mask;
1640
    int pid, status;
1641
    char *args[3];
1642
    char **parg;
1643

    
1644
    sigemptyset(&mask);
1645
    sigaddset(&mask, SIGCHLD);
1646
    sigprocmask(SIG_BLOCK, &mask, &oldmask);
1647

    
1648
    /* try to launch network script */
1649
    pid = fork();
1650
    if (pid == 0) {
1651
        int open_max = sysconf(_SC_OPEN_MAX), i;
1652

    
1653
        for (i = 0; i < open_max; i++) {
1654
            if (i != STDIN_FILENO &&
1655
                i != STDOUT_FILENO &&
1656
                i != STDERR_FILENO &&
1657
                i != fd) {
1658
                close(i);
1659
            }
1660
        }
1661
        parg = args;
1662
        *parg++ = (char *)setup_script;
1663
        *parg++ = (char *)ifname;
1664
        *parg++ = NULL;
1665
        execv(setup_script, args);
1666
        _exit(1);
1667
    } else if (pid > 0) {
1668
        while (waitpid(pid, &status, 0) != pid) {
1669
            /* loop */
1670
        }
1671
        sigprocmask(SIG_SETMASK, &oldmask, NULL);
1672

    
1673
        if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
1674
            return 0;
1675
        }
1676
    }
1677
    fprintf(stderr, "%s: could not launch network script\n", setup_script);
1678
    return -1;
1679
}
1680

    
1681
static TAPState *net_tap_init(VLANState *vlan, const char *model,
1682
                              const char *name, const char *ifname1,
1683
                              const char *setup_script, const char *down_script)
1684
{
1685
    TAPState *s;
1686
    int fd;
1687
    char ifname[128];
1688

    
1689
    if (ifname1 != NULL)
1690
        pstrcpy(ifname, sizeof(ifname), ifname1);
1691
    else
1692
        ifname[0] = '\0';
1693
    TFR(fd = tap_open(ifname, sizeof(ifname)));
1694
    if (fd < 0)
1695
        return NULL;
1696

    
1697
    if (!setup_script || !strcmp(setup_script, "no"))
1698
        setup_script = "";
1699
    if (setup_script[0] != '\0' &&
1700
        launch_script(setup_script, ifname, fd)) {
1701
        return NULL;
1702
    }
1703
    s = net_tap_fd_init(vlan, model, name, fd);
1704
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1705
             "ifname=%s,script=%s,downscript=%s",
1706
             ifname, setup_script, down_script);
1707
    if (down_script && strcmp(down_script, "no")) {
1708
        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
1709
        snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
1710
    }
1711
    return s;
1712
}
1713

    
1714
#endif /* !_WIN32 */
1715

    
1716
#if defined(CONFIG_VDE)
1717
typedef struct VDEState {
1718
    VLANClientState *vc;
1719
    VDECONN *vde;
1720
} VDEState;
1721

    
1722
static void vde_to_qemu(void *opaque)
1723
{
1724
    VDEState *s = opaque;
1725
    uint8_t buf[4096];
1726
    int size;
1727

    
1728
    size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
1729
    if (size > 0) {
1730
        qemu_send_packet(s->vc, buf, size);
1731
    }
1732
}
1733

    
1734
static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1735
{
1736
    VDEState *s = vc->opaque;
1737
    ssize_t ret;
1738

    
1739
    do {
1740
      ret = vde_send(s->vde, (const char *)buf, size, 0);
1741
    } while (ret < 0 && errno == EINTR);
1742

    
1743
    return ret;
1744
}
1745

    
1746
static void vde_cleanup(VLANClientState *vc)
1747
{
1748
    VDEState *s = vc->opaque;
1749
    qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
1750
    vde_close(s->vde);
1751
    qemu_free(s);
1752
}
1753

    
1754
static int net_vde_init(VLANState *vlan, const char *model,
1755
                        const char *name, const char *sock,
1756
                        int port, const char *group, int mode)
1757
{
1758
    VDEState *s;
1759
    char *init_group = (char *)group;
1760
    char *init_sock = (char *)sock;
1761

    
1762
    struct vde_open_args args = {
1763
        .port = port,
1764
        .group = init_group,
1765
        .mode = mode,
1766
    };
1767

    
1768
    s = qemu_mallocz(sizeof(VDEState));
1769
    s->vde = vde_open(init_sock, (char *)"QEMU", &args);
1770
    if (!s->vde){
1771
        free(s);
1772
        return -1;
1773
    }
1774
    s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
1775
                                 vde_receive, NULL,
1776
                                 vde_cleanup, s);
1777
    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
1778
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
1779
             sock, vde_datafd(s->vde));
1780
    return 0;
1781
}
1782
#endif
1783

    
1784
/* network connection */
1785
typedef struct NetSocketState {
1786
    VLANClientState *vc;
1787
    int fd;
1788
    int state; /* 0 = getting length, 1 = getting data */
1789
    unsigned int index;
1790
    unsigned int packet_len;
1791
    uint8_t buf[4096];
1792
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1793
} NetSocketState;
1794

    
1795
typedef struct NetSocketListenState {
1796
    VLANState *vlan;
1797
    char *model;
1798
    char *name;
1799
    int fd;
1800
} NetSocketListenState;
1801

    
1802
/* XXX: we consider we can send the whole packet without blocking */
1803
static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
1804
{
1805
    NetSocketState *s = vc->opaque;
1806
    uint32_t len;
1807
    len = htonl(size);
1808

    
1809
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
1810
    return send_all(s->fd, buf, size);
1811
}
1812

    
1813
static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
1814
{
1815
    NetSocketState *s = vc->opaque;
1816

    
1817
    return sendto(s->fd, (const void *)buf, size, 0,
1818
                  (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
1819
}
1820

    
1821
static void net_socket_send(void *opaque)
1822
{
1823
    NetSocketState *s = opaque;
1824
    int size, err;
1825
    unsigned l;
1826
    uint8_t buf1[4096];
1827
    const uint8_t *buf;
1828

    
1829
    size = recv(s->fd, (void *)buf1, sizeof(buf1), 0);
1830
    if (size < 0) {
1831
        err = socket_error();
1832
        if (err != EWOULDBLOCK)
1833
            goto eoc;
1834
    } else if (size == 0) {
1835
        /* end of connection */
1836
    eoc:
1837
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1838
        closesocket(s->fd);
1839
        return;
1840
    }
1841
    buf = buf1;
1842
    while (size > 0) {
1843
        /* reassemble a packet from the network */
1844
        switch(s->state) {
1845
        case 0:
1846
            l = 4 - s->index;
1847
            if (l > size)
1848
                l = size;
1849
            memcpy(s->buf + s->index, buf, l);
1850
            buf += l;
1851
            size -= l;
1852
            s->index += l;
1853
            if (s->index == 4) {
1854
                /* got length */
1855
                s->packet_len = ntohl(*(uint32_t *)s->buf);
1856
                s->index = 0;
1857
                s->state = 1;
1858
            }
1859
            break;
1860
        case 1:
1861
            l = s->packet_len - s->index;
1862
            if (l > size)
1863
                l = size;
1864
            if (s->index + l <= sizeof(s->buf)) {
1865
                memcpy(s->buf + s->index, buf, l);
1866
            } else {
1867
                fprintf(stderr, "serious error: oversized packet received,"
1868
                    "connection terminated.\n");
1869
                s->state = 0;
1870
                goto eoc;
1871
            }
1872

    
1873
            s->index += l;
1874
            buf += l;
1875
            size -= l;
1876
            if (s->index >= s->packet_len) {
1877
                qemu_send_packet(s->vc, s->buf, s->packet_len);
1878
                s->index = 0;
1879
                s->state = 0;
1880
            }
1881
            break;
1882
        }
1883
    }
1884
}
1885

    
1886
static void net_socket_send_dgram(void *opaque)
1887
{
1888
    NetSocketState *s = opaque;
1889
    int size;
1890

    
1891
    size = recv(s->fd, (void *)s->buf, sizeof(s->buf), 0);
1892
    if (size < 0)
1893
        return;
1894
    if (size == 0) {
1895
        /* end of connection */
1896
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1897
        return;
1898
    }
1899
    qemu_send_packet(s->vc, s->buf, size);
1900
}
1901

    
1902
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1903
{
1904
    struct ip_mreq imr;
1905
    int fd;
1906
    int val, ret;
1907
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1908
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1909
                inet_ntoa(mcastaddr->sin_addr),
1910
                (int)ntohl(mcastaddr->sin_addr.s_addr));
1911
        return -1;
1912

    
1913
    }
1914
    fd = socket(PF_INET, SOCK_DGRAM, 0);
1915
    if (fd < 0) {
1916
        perror("socket(PF_INET, SOCK_DGRAM)");
1917
        return -1;
1918
    }
1919

    
1920
    val = 1;
1921
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1922
                   (const char *)&val, sizeof(val));
1923
    if (ret < 0) {
1924
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1925
        goto fail;
1926
    }
1927

    
1928
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1929
    if (ret < 0) {
1930
        perror("bind");
1931
        goto fail;
1932
    }
1933

    
1934
    /* Add host to multicast group */
1935
    imr.imr_multiaddr = mcastaddr->sin_addr;
1936
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
1937

    
1938
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1939
                     (const char *)&imr, sizeof(struct ip_mreq));
1940
    if (ret < 0) {
1941
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
1942
        goto fail;
1943
    }
1944

    
1945
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1946
    val = 1;
1947
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1948
                   (const char *)&val, sizeof(val));
1949
    if (ret < 0) {
1950
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1951
        goto fail;
1952
    }
1953

    
1954
    socket_set_nonblock(fd);
1955
    return fd;
1956
fail:
1957
    if (fd >= 0)
1958
        closesocket(fd);
1959
    return -1;
1960
}
1961

    
1962
static void net_socket_cleanup(VLANClientState *vc)
1963
{
1964
    NetSocketState *s = vc->opaque;
1965
    qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1966
    close(s->fd);
1967
    qemu_free(s);
1968
}
1969

    
1970
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
1971
                                                const char *model,
1972
                                                const char *name,
1973
                                                int fd, int is_connected)
1974
{
1975
    struct sockaddr_in saddr;
1976
    int newfd;
1977
    socklen_t saddr_len;
1978
    NetSocketState *s;
1979

    
1980
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1981
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1982
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
1983
     */
1984

    
1985
    if (is_connected) {
1986
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1987
            /* must be bound */
1988
            if (saddr.sin_addr.s_addr==0) {
1989
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1990
                        fd);
1991
                return NULL;
1992
            }
1993
            /* clone dgram socket */
1994
            newfd = net_socket_mcast_create(&saddr);
1995
            if (newfd < 0) {
1996
                /* error already reported by net_socket_mcast_create() */
1997
                close(fd);
1998
                return NULL;
1999
            }
2000
            /* clone newfd to fd, close newfd */
2001
            dup2(newfd, fd);
2002
            close(newfd);
2003

    
2004
        } else {
2005
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
2006
                    fd, strerror(errno));
2007
            return NULL;
2008
        }
2009
    }
2010

    
2011
    s = qemu_mallocz(sizeof(NetSocketState));
2012
    s->fd = fd;
2013

    
2014
    s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
2015
                                 net_socket_receive_dgram, NULL,
2016
                                 net_socket_cleanup, s);
2017
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2018

    
2019
    /* mcast: save bound address as dst */
2020
    if (is_connected) s->dgram_dst=saddr;
2021

    
2022
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2023
            "socket: fd=%d (%s mcast=%s:%d)",
2024
            fd, is_connected? "cloned" : "",
2025
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2026
    return s;
2027
}
2028

    
2029
static void net_socket_connect(void *opaque)
2030
{
2031
    NetSocketState *s = opaque;
2032
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2033
}
2034

    
2035
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
2036
                                                 const char *model,
2037
                                                 const char *name,
2038
                                                 int fd, int is_connected)
2039
{
2040
    NetSocketState *s;
2041
    s = qemu_mallocz(sizeof(NetSocketState));
2042
    s->fd = fd;
2043
    s->vc = qemu_new_vlan_client(vlan, NULL, model, name, NULL,
2044
                                 net_socket_receive, NULL,
2045
                                 net_socket_cleanup, s);
2046
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2047
             "socket: fd=%d", fd);
2048
    if (is_connected) {
2049
        net_socket_connect(s);
2050
    } else {
2051
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2052
    }
2053
    return s;
2054
}
2055

    
2056
static NetSocketState *net_socket_fd_init(VLANState *vlan,
2057
                                          const char *model, const char *name,
2058
                                          int fd, int is_connected)
2059
{
2060
    int so_type = -1, optlen=sizeof(so_type);
2061

    
2062
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
2063
        (socklen_t *)&optlen)< 0) {
2064
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
2065
        return NULL;
2066
    }
2067
    switch(so_type) {
2068
    case SOCK_DGRAM:
2069
        return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
2070
    case SOCK_STREAM:
2071
        return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
2072
    default:
2073
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2074
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
2075
        return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
2076
    }
2077
    return NULL;
2078
}
2079

    
2080
static void net_socket_accept(void *opaque)
2081
{
2082
    NetSocketListenState *s = opaque;
2083
    NetSocketState *s1;
2084
    struct sockaddr_in saddr;
2085
    socklen_t len;
2086
    int fd;
2087

    
2088
    for(;;) {
2089
        len = sizeof(saddr);
2090
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2091
        if (fd < 0 && errno != EINTR) {
2092
            return;
2093
        } else if (fd >= 0) {
2094
            break;
2095
        }
2096
    }
2097
    s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
2098
    if (!s1) {
2099
        closesocket(fd);
2100
    } else {
2101
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2102
                 "socket: connection from %s:%d",
2103
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2104
    }
2105
}
2106

    
2107
static int net_socket_listen_init(VLANState *vlan,
2108
                                  const char *model,
2109
                                  const char *name,
2110
                                  const char *host_str)
2111
{
2112
    NetSocketListenState *s;
2113
    int fd, val, ret;
2114
    struct sockaddr_in saddr;
2115

    
2116
    if (parse_host_port(&saddr, host_str) < 0)
2117
        return -1;
2118

    
2119
    s = qemu_mallocz(sizeof(NetSocketListenState));
2120

    
2121
    fd = socket(PF_INET, SOCK_STREAM, 0);
2122
    if (fd < 0) {
2123
        perror("socket");
2124
        return -1;
2125
    }
2126
    socket_set_nonblock(fd);
2127

    
2128
    /* allow fast reuse */
2129
    val = 1;
2130
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2131

    
2132
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2133
    if (ret < 0) {
2134
        perror("bind");
2135
        return -1;
2136
    }
2137
    ret = listen(fd, 0);
2138
    if (ret < 0) {
2139
        perror("listen");
2140
        return -1;
2141
    }
2142
    s->vlan = vlan;
2143
    s->model = qemu_strdup(model);
2144
    s->name = name ? qemu_strdup(name) : NULL;
2145
    s->fd = fd;
2146
    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2147
    return 0;
2148
}
2149

    
2150
static int net_socket_connect_init(VLANState *vlan,
2151
                                   const char *model,
2152
                                   const char *name,
2153
                                   const char *host_str)
2154
{
2155
    NetSocketState *s;
2156
    int fd, connected, ret, err;
2157
    struct sockaddr_in saddr;
2158

    
2159
    if (parse_host_port(&saddr, host_str) < 0)
2160
        return -1;
2161

    
2162
    fd = socket(PF_INET, SOCK_STREAM, 0);
2163
    if (fd < 0) {
2164
        perror("socket");
2165
        return -1;
2166
    }
2167
    socket_set_nonblock(fd);
2168

    
2169
    connected = 0;
2170
    for(;;) {
2171
        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2172
        if (ret < 0) {
2173
            err = socket_error();
2174
            if (err == EINTR || err == EWOULDBLOCK) {
2175
            } else if (err == EINPROGRESS) {
2176
                break;
2177
#ifdef _WIN32
2178
            } else if (err == WSAEALREADY) {
2179
                break;
2180
#endif
2181
            } else {
2182
                perror("connect");
2183
                closesocket(fd);
2184
                return -1;
2185
            }
2186
        } else {
2187
            connected = 1;
2188
            break;
2189
        }
2190
    }
2191
    s = net_socket_fd_init(vlan, model, name, fd, connected);
2192
    if (!s)
2193
        return -1;
2194
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2195
             "socket: connect to %s:%d",
2196
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2197
    return 0;
2198
}
2199

    
2200
static int net_socket_mcast_init(VLANState *vlan,
2201
                                 const char *model,
2202
                                 const char *name,
2203
                                 const char *host_str)
2204
{
2205
    NetSocketState *s;
2206
    int fd;
2207
    struct sockaddr_in saddr;
2208

    
2209
    if (parse_host_port(&saddr, host_str) < 0)
2210
        return -1;
2211

    
2212

    
2213
    fd = net_socket_mcast_create(&saddr);
2214
    if (fd < 0)
2215
        return -1;
2216

    
2217
    s = net_socket_fd_init(vlan, model, name, fd, 0);
2218
    if (!s)
2219
        return -1;
2220

    
2221
    s->dgram_dst = saddr;
2222

    
2223
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2224
             "socket: mcast=%s:%d",
2225
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2226
    return 0;
2227

    
2228
}
2229

    
2230
typedef struct DumpState {
2231
    VLANClientState *pcap_vc;
2232
    int fd;
2233
    int pcap_caplen;
2234
} DumpState;
2235

    
2236
#define PCAP_MAGIC 0xa1b2c3d4
2237

    
2238
struct pcap_file_hdr {
2239
    uint32_t magic;
2240
    uint16_t version_major;
2241
    uint16_t version_minor;
2242
    int32_t thiszone;
2243
    uint32_t sigfigs;
2244
    uint32_t snaplen;
2245
    uint32_t linktype;
2246
};
2247

    
2248
struct pcap_sf_pkthdr {
2249
    struct {
2250
        int32_t tv_sec;
2251
        int32_t tv_usec;
2252
    } ts;
2253
    uint32_t caplen;
2254
    uint32_t len;
2255
};
2256

    
2257
static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
2258
{
2259
    DumpState *s = vc->opaque;
2260
    struct pcap_sf_pkthdr hdr;
2261
    int64_t ts;
2262
    int caplen;
2263

    
2264
    /* Early return in case of previous error. */
2265
    if (s->fd < 0) {
2266
        return size;
2267
    }
2268

    
2269
    ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
2270
    caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
2271

    
2272
    hdr.ts.tv_sec = ts / 1000000;
2273
    hdr.ts.tv_usec = ts % 1000000;
2274
    hdr.caplen = caplen;
2275
    hdr.len = size;
2276
    if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
2277
        write(s->fd, buf, caplen) != caplen) {
2278
        qemu_log("-net dump write error - stop dump\n");
2279
        close(s->fd);
2280
        s->fd = -1;
2281
    }
2282

    
2283
    return size;
2284
}
2285

    
2286
static void net_dump_cleanup(VLANClientState *vc)
2287
{
2288
    DumpState *s = vc->opaque;
2289

    
2290
    close(s->fd);
2291
    qemu_free(s);
2292
}
2293

    
2294
static int net_dump_init(VLANState *vlan, const char *device,
2295
                         const char *name, const char *filename, int len)
2296
{
2297
    struct pcap_file_hdr hdr;
2298
    DumpState *s;
2299

    
2300
    s = qemu_malloc(sizeof(DumpState));
2301

    
2302
    s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
2303
    if (s->fd < 0) {
2304
        qemu_error("-net dump: can't open %s\n", filename);
2305
        return -1;
2306
    }
2307

    
2308
    s->pcap_caplen = len;
2309

    
2310
    hdr.magic = PCAP_MAGIC;
2311
    hdr.version_major = 2;
2312
    hdr.version_minor = 4;
2313
    hdr.thiszone = 0;
2314
    hdr.sigfigs = 0;
2315
    hdr.snaplen = s->pcap_caplen;
2316
    hdr.linktype = 1;
2317

    
2318
    if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
2319
        qemu_error("-net dump write error: %s\n", strerror(errno));
2320
        close(s->fd);
2321
        qemu_free(s);
2322
        return -1;
2323
    }
2324

    
2325
    s->pcap_vc = qemu_new_vlan_client(vlan, NULL, device, name, NULL,
2326
                                      dump_receive, NULL,
2327
                                      net_dump_cleanup, s);
2328
    snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str),
2329
             "dump to %s (len=%d)", filename, len);
2330
    return 0;
2331
}
2332

    
2333
/* find or alloc a new VLAN */
2334
VLANState *qemu_find_vlan(int id, int allocate)
2335
{
2336
    VLANState *vlan;
2337

    
2338
    QTAILQ_FOREACH(vlan, &vlans, next) {
2339
        if (vlan->id == id) {
2340
            return vlan;
2341
        }
2342
    }
2343

    
2344
    if (!allocate) {
2345
        return NULL;
2346
    }
2347

    
2348
    vlan = qemu_mallocz(sizeof(VLANState));
2349
    vlan->id = id;
2350
    QTAILQ_INIT(&vlan->clients);
2351
    QTAILQ_INIT(&vlan->send_queue);
2352

    
2353
    QTAILQ_INSERT_TAIL(&vlans, vlan, next);
2354

    
2355
    return vlan;
2356
}
2357

    
2358
static VLANClientState *qemu_find_netdev(const char *id)
2359
{
2360
    VLANClientState *vc;
2361

    
2362
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
2363
        if (!strcmp(vc->name, id)) {
2364
            return vc;
2365
        }
2366
    }
2367

    
2368
    return NULL;
2369
}
2370

    
2371
static int nic_get_free_idx(void)
2372
{
2373
    int index;
2374

    
2375
    for (index = 0; index < MAX_NICS; index++)
2376
        if (!nd_table[index].used)
2377
            return index;
2378
    return -1;
2379
}
2380

    
2381
int qemu_show_nic_models(const char *arg, const char *const *models)
2382
{
2383
    int i;
2384

    
2385
    if (!arg || strcmp(arg, "?"))
2386
        return 0;
2387

    
2388
    fprintf(stderr, "qemu: Supported NIC models: ");
2389
    for (i = 0 ; models[i]; i++)
2390
        fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
2391
    return 1;
2392
}
2393

    
2394
void qemu_check_nic_model(NICInfo *nd, const char *model)
2395
{
2396
    const char *models[2];
2397

    
2398
    models[0] = model;
2399
    models[1] = NULL;
2400

    
2401
    if (qemu_show_nic_models(nd->model, models))
2402
        exit(0);
2403
    if (qemu_find_nic_model(nd, models, model) < 0)
2404
        exit(1);
2405
}
2406

    
2407
int qemu_find_nic_model(NICInfo *nd, const char * const *models,
2408
                        const char *default_model)
2409
{
2410
    int i;
2411

    
2412
    if (!nd->model)
2413
        nd->model = qemu_strdup(default_model);
2414

    
2415
    for (i = 0 ; models[i]; i++) {
2416
        if (strcmp(nd->model, models[i]) == 0)
2417
            return i;
2418
    }
2419

    
2420
    qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
2421
    return -1;
2422
}
2423

    
2424
static int net_handle_fd_param(Monitor *mon, const char *param)
2425
{
2426
    if (!qemu_isdigit(param[0])) {
2427
        int fd;
2428

    
2429
        fd = monitor_get_fd(mon, param);
2430
        if (fd == -1) {
2431
            qemu_error("No file descriptor named %s found", param);
2432
            return -1;
2433
        }
2434

    
2435
        return fd;
2436
    } else {
2437
        return strtol(param, NULL, 0);
2438
    }
2439
}
2440

    
2441
static int net_init_nic(QemuOpts *opts,
2442
                        Monitor *mon,
2443
                        const char *name,
2444
                        VLANState *vlan)
2445
{
2446
    int idx;
2447
    NICInfo *nd;
2448
    const char *netdev;
2449

    
2450
    idx = nic_get_free_idx();
2451
    if (idx == -1 || nb_nics >= MAX_NICS) {
2452
        qemu_error("Too Many NICs\n");
2453
        return -1;
2454
    }
2455

    
2456
    nd = &nd_table[idx];
2457

    
2458
    memset(nd, 0, sizeof(*nd));
2459

    
2460
    if ((netdev = qemu_opt_get(opts, "netdev"))) {
2461
        nd->netdev = qemu_find_netdev(netdev);
2462
        if (!nd->netdev) {
2463
            qemu_error("netdev '%s' not found\n", netdev);
2464
            return -1;
2465
        }
2466
    } else {
2467
        assert(vlan);
2468
        nd->vlan = vlan;
2469
    }
2470
    if (name) {
2471
        nd->name = qemu_strdup(name);
2472
    }
2473
    if (qemu_opt_get(opts, "model")) {
2474
        nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
2475
    }
2476
    if (qemu_opt_get(opts, "addr")) {
2477
        nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
2478
    }
2479

    
2480
    nd->macaddr[0] = 0x52;
2481
    nd->macaddr[1] = 0x54;
2482
    nd->macaddr[2] = 0x00;
2483
    nd->macaddr[3] = 0x12;
2484
    nd->macaddr[4] = 0x34;
2485
    nd->macaddr[5] = 0x56 + idx;
2486

    
2487
    if (qemu_opt_get(opts, "macaddr") &&
2488
        parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
2489
        qemu_error("invalid syntax for ethernet address\n");
2490
        return -1;
2491
    }
2492

    
2493
    nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
2494
    if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
2495
        (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
2496
        qemu_error("invalid # of vectors: %d\n", nd->nvectors);
2497
        return -1;
2498
    }
2499

    
2500
    nd->used = 1;
2501
    if (vlan) {
2502
        nd->vlan->nb_guest_devs++;
2503
    }
2504
    nb_nics++;
2505

    
2506
    return idx;
2507
}
2508

    
2509
#if defined(CONFIG_SLIRP)
2510
static int net_init_slirp_configs(const char *name, const char *value, void *opaque)
2511
{
2512
    struct slirp_config_str *config;
2513

    
2514
    if (strcmp(name, "hostfwd") != 0 && strcmp(name, "guestfwd") != 0) {
2515
        return 0;
2516
    }
2517

    
2518
    config = qemu_mallocz(sizeof(*config));
2519

    
2520
    pstrcpy(config->str, sizeof(config->str), value);
2521

    
2522
    if (!strcmp(name, "hostfwd")) {
2523
        config->flags = SLIRP_CFG_HOSTFWD;
2524
    }
2525

    
2526
    config->next = slirp_configs;
2527
    slirp_configs = config;
2528

    
2529
    return 0;
2530
}
2531

    
2532
static int net_init_slirp(QemuOpts *opts,
2533
                          Monitor *mon,
2534
                          const char *name,
2535
                          VLANState *vlan)
2536
{
2537
    struct slirp_config_str *config;
2538
    const char *vhost;
2539
    const char *vhostname;
2540
    const char *vdhcp_start;
2541
    const char *vnamesrv;
2542
    const char *tftp_export;
2543
    const char *bootfile;
2544
    const char *smb_export;
2545
    const char *vsmbsrv;
2546
    char *vnet = NULL;
2547
    int restricted = 0;
2548
    int ret;
2549

    
2550
    vhost       = qemu_opt_get(opts, "host");
2551
    vhostname   = qemu_opt_get(opts, "hostname");
2552
    vdhcp_start = qemu_opt_get(opts, "dhcpstart");
2553
    vnamesrv    = qemu_opt_get(opts, "dns");
2554
    tftp_export = qemu_opt_get(opts, "tftp");
2555
    bootfile    = qemu_opt_get(opts, "bootfile");
2556
    smb_export  = qemu_opt_get(opts, "smb");
2557
    vsmbsrv     = qemu_opt_get(opts, "smbserver");
2558

    
2559
    if (qemu_opt_get(opts, "ip")) {
2560
        const char *ip = qemu_opt_get(opts, "ip");
2561
        int l = strlen(ip) + strlen("/24") + 1;
2562

    
2563
        vnet = qemu_malloc(l);
2564

    
2565
        /* emulate legacy ip= parameter */
2566
        pstrcpy(vnet, l, ip);
2567
        pstrcat(vnet, l, "/24");
2568
    }
2569

    
2570
    if (qemu_opt_get(opts, "net")) {
2571
        if (vnet) {
2572
            qemu_free(vnet);
2573
        }
2574
        vnet = qemu_strdup(qemu_opt_get(opts, "net"));
2575
    }
2576

    
2577
    if (qemu_opt_get(opts, "restrict") &&
2578
        qemu_opt_get(opts, "restrict")[0] == 'y') {
2579
        restricted = 1;
2580
    }
2581

    
2582
    qemu_opt_foreach(opts, net_init_slirp_configs, NULL, 0);
2583

    
2584
    ret = net_slirp_init(vlan, "user", name, restricted, vnet, vhost,
2585
                         vhostname, tftp_export, bootfile, vdhcp_start,
2586
                         vnamesrv, smb_export, vsmbsrv);
2587

    
2588
    while (slirp_configs) {
2589
        config = slirp_configs;
2590
        slirp_configs = config->next;
2591
        qemu_free(config);
2592
    }
2593

    
2594
    if (ret != -1 && vlan) {
2595
        vlan->nb_host_devs++;
2596
    }
2597

    
2598
    qemu_free(vnet);
2599

    
2600
    return ret;
2601
}
2602
#endif /* CONFIG_SLIRP */
2603

    
2604
#ifdef _WIN32
2605
static int net_init_tap_win32(QemuOpts *opts,
2606
                              Monitor *mon,
2607
                              const char *name,
2608
                              VLANState *vlan)
2609
{
2610
    const char *ifname;
2611

    
2612
    ifname = qemu_opt_get(opts, "ifname");
2613

    
2614
    if (!ifname) {
2615
        qemu_error("tap: no interface name\n");
2616
        return -1;
2617
    }
2618

    
2619
    if (tap_win32_init(vlan, "tap", name, ifname) == -1) {
2620
        return -1;
2621
    }
2622

    
2623
    if (vlan) {
2624
        vlan->nb_host_devs++;
2625
    }
2626

    
2627
    return 0;
2628
}
2629
#elif !defined(_AIX)
2630
static int net_init_tap(QemuOpts *opts,
2631
                        Monitor *mon,
2632
                        const char *name,
2633
                        VLANState *vlan)
2634
{
2635
    TAPState *s;
2636

    
2637
    if (qemu_opt_get(opts, "fd")) {
2638
        int fd;
2639

    
2640
        if (qemu_opt_get(opts, "ifname") ||
2641
            qemu_opt_get(opts, "script") ||
2642
            qemu_opt_get(opts, "downscript")) {
2643
            qemu_error("ifname=, script= and downscript= is invalid with fd=\n");
2644
            return -1;
2645
        }
2646

    
2647
        fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2648
        if (fd == -1) {
2649
            return -1;
2650
        }
2651

    
2652
        fcntl(fd, F_SETFL, O_NONBLOCK);
2653

    
2654
        s = net_tap_fd_init(vlan, "tap", name, fd);
2655
        if (!s) {
2656
            close(fd);
2657
        }
2658
    } else {
2659
        const char *ifname, *script, *downscript;
2660

    
2661
        ifname     = qemu_opt_get(opts, "ifname");
2662
        script     = qemu_opt_get(opts, "script");
2663
        downscript = qemu_opt_get(opts, "downscript");
2664

    
2665
        if (!script) {
2666
            script = DEFAULT_NETWORK_SCRIPT;
2667
        }
2668
        if (!downscript) {
2669
            downscript = DEFAULT_NETWORK_DOWN_SCRIPT;
2670
        }
2671

    
2672
        s = net_tap_init(vlan, "tap", name, ifname, script, downscript);
2673
    }
2674

    
2675
    if (!s) {
2676
        return -1;
2677
    }
2678

    
2679
    if (tap_set_sndbuf(s, opts) < 0) {
2680
        return -1;
2681
    }
2682

    
2683
    if (vlan) {
2684
        vlan->nb_host_devs++;
2685
    }
2686

    
2687
    return 0;
2688
}
2689
#endif
2690

    
2691
static int net_init_socket(QemuOpts *opts,
2692
                           Monitor *mon,
2693
                           const char *name,
2694
                           VLANState *vlan)
2695
{
2696
    if (qemu_opt_get(opts, "fd")) {
2697
        int fd;
2698

    
2699
        if (qemu_opt_get(opts, "listen") ||
2700
            qemu_opt_get(opts, "connect") ||
2701
            qemu_opt_get(opts, "mcast")) {
2702
            qemu_error("listen=, connect= and mcast= is invalid with fd=\n");
2703
            return -1;
2704
        }
2705

    
2706
        fd = net_handle_fd_param(mon, qemu_opt_get(opts, "fd"));
2707
        if (fd == -1) {
2708
            return -1;
2709
        }
2710

    
2711
        if (!net_socket_fd_init(vlan, "socket", name, fd, 1)) {
2712
            close(fd);
2713
            return -1;
2714
        }
2715
    } else if (qemu_opt_get(opts, "listen")) {
2716
        const char *listen;
2717

    
2718
        if (qemu_opt_get(opts, "fd") ||
2719
            qemu_opt_get(opts, "connect") ||
2720
            qemu_opt_get(opts, "mcast")) {
2721
            qemu_error("fd=, connect= and mcast= is invalid with listen=\n");
2722
            return -1;
2723
        }
2724

    
2725
        listen = qemu_opt_get(opts, "listen");
2726

    
2727
        if (net_socket_listen_init(vlan, "socket", name, listen) == -1) {
2728
            return -1;
2729
        }
2730
    } else if (qemu_opt_get(opts, "connect")) {
2731
        const char *connect;
2732

    
2733
        if (qemu_opt_get(opts, "fd") ||
2734
            qemu_opt_get(opts, "listen") ||
2735
            qemu_opt_get(opts, "mcast")) {
2736
            qemu_error("fd=, listen= and mcast= is invalid with connect=\n");
2737
            return -1;
2738
        }
2739

    
2740
        connect = qemu_opt_get(opts, "connect");
2741

    
2742
        if (net_socket_connect_init(vlan, "socket", name, connect) == -1) {
2743
            return -1;
2744
        }
2745
    } else if (qemu_opt_get(opts, "mcast")) {
2746
        const char *mcast;
2747

    
2748
        if (qemu_opt_get(opts, "fd") ||
2749
            qemu_opt_get(opts, "connect") ||
2750
            qemu_opt_get(opts, "listen")) {
2751
            qemu_error("fd=, connect= and listen= is invalid with mcast=\n");
2752
            return -1;
2753
        }
2754

    
2755
        mcast = qemu_opt_get(opts, "mcast");
2756

    
2757
        if (net_socket_mcast_init(vlan, "socket", name, mcast) == -1) {
2758
            return -1;
2759
        }
2760
    } else {
2761
        qemu_error("-socket requires fd=, listen=, connect= or mcast=\n");
2762
        return -1;
2763
    }
2764

    
2765
    if (vlan) {
2766
        vlan->nb_host_devs++;
2767
    }
2768

    
2769
    return 0;
2770
}
2771

    
2772
#ifdef CONFIG_VDE
2773
static int net_init_vde(QemuOpts *opts,
2774
                        Monitor *mon,
2775
                        const char *name,
2776
                        VLANState *vlan)
2777
{
2778
    const char *sock;
2779
    const char *group;
2780
    int port, mode;
2781

    
2782
    sock  = qemu_opt_get(opts, "sock");
2783
    group = qemu_opt_get(opts, "group");
2784

    
2785
    port = qemu_opt_get_number(opts, "port", 0);
2786
    mode = qemu_opt_get_number(opts, "mode", 0700);
2787

    
2788
    if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
2789
        return -1;
2790
    }
2791

    
2792
    if (vlan) {
2793
        vlan->nb_host_devs++;
2794
    }
2795

    
2796
    return 0;
2797
}
2798
#endif
2799

    
2800
static int net_init_dump(QemuOpts *opts,
2801
                         Monitor *mon,
2802
                         const char *name,
2803
                         VLANState *vlan)
2804
{
2805
    int len;
2806
    const char *file;
2807
    char def_file[128];
2808

    
2809
    assert(vlan);
2810

    
2811
    file = qemu_opt_get(opts, "file");
2812
    if (!file) {
2813
        snprintf(def_file, sizeof(def_file), "qemu-vlan%d.pcap", vlan->id);
2814
        file = def_file;
2815
    }
2816

    
2817
    len = qemu_opt_get_size(opts, "len", 65536);
2818

    
2819
    return net_dump_init(vlan, "dump", name, file, len);
2820
}
2821

    
2822
#define NET_COMMON_PARAMS_DESC                     \
2823
    {                                              \
2824
        .name = "type",                            \
2825
        .type = QEMU_OPT_STRING,                   \
2826
        .help = "net client type (nic, tap etc.)", \
2827
     }, {                                          \
2828
        .name = "vlan",                            \
2829
        .type = QEMU_OPT_NUMBER,                   \
2830
        .help = "vlan number",                     \
2831
     }, {                                          \
2832
        .name = "name",                            \
2833
        .type = QEMU_OPT_STRING,                   \
2834
        .help = "identifier for monitor commands", \
2835
     }
2836

    
2837
typedef int (*net_client_init_func)(QemuOpts *opts,
2838
                                    Monitor *mon,
2839
                                    const char *name,
2840
                                    VLANState *vlan);
2841

    
2842
/* magic number, but compiler will warn if too small */
2843
#define NET_MAX_DESC 20
2844

    
2845
static struct {
2846
    const char *type;
2847
    net_client_init_func init;
2848
    QemuOptDesc desc[NET_MAX_DESC];
2849
} net_client_types[] = {
2850
    {
2851
        .type = "none",
2852
        .desc = {
2853
            NET_COMMON_PARAMS_DESC,
2854
            { /* end of list */ }
2855
        },
2856
    }, {
2857
        .type = "nic",
2858
        .init = net_init_nic,
2859
        .desc = {
2860
            NET_COMMON_PARAMS_DESC,
2861
            {
2862
                .name = "netdev",
2863
                .type = QEMU_OPT_STRING,
2864
                .help = "id of -netdev to connect to",
2865
            },
2866
            {
2867
                .name = "macaddr",
2868
                .type = QEMU_OPT_STRING,
2869
                .help = "MAC address",
2870
            }, {
2871
                .name = "model",
2872
                .type = QEMU_OPT_STRING,
2873
                .help = "device model (e1000, rtl8139, virtio etc.)",
2874
            }, {
2875
                .name = "addr",
2876
                .type = QEMU_OPT_STRING,
2877
                .help = "PCI device address",
2878
            }, {
2879
                .name = "vectors",
2880
                .type = QEMU_OPT_NUMBER,
2881
                .help = "number of MSI-x vectors, 0 to disable MSI-X",
2882
            },
2883
            { /* end of list */ }
2884
        },
2885
#ifdef CONFIG_SLIRP
2886
    }, {
2887
        .type = "user",
2888
        .init = net_init_slirp,
2889
        .desc = {
2890
            NET_COMMON_PARAMS_DESC,
2891
            {
2892
                .name = "hostname",
2893
                .type = QEMU_OPT_STRING,
2894
                .help = "client hostname reported by the builtin DHCP server",
2895
            }, {
2896
                .name = "restrict",
2897
                .type = QEMU_OPT_STRING,
2898
                .help = "isolate the guest from the host (y|yes|n|no)",
2899
            }, {
2900
                .name = "ip",
2901
                .type = QEMU_OPT_STRING,
2902
                .help = "legacy parameter, use net= instead",
2903
            }, {
2904
                .name = "net",
2905
                .type = QEMU_OPT_STRING,
2906
                .help = "IP address and optional netmask",
2907
            }, {
2908
                .name = "host",
2909
                .type = QEMU_OPT_STRING,
2910
                .help = "guest-visible address of the host",
2911
            }, {
2912
                .name = "tftp",
2913
                .type = QEMU_OPT_STRING,
2914
                .help = "root directory of the built-in TFTP server",
2915
            }, {
2916
                .name = "bootfile",
2917
                .type = QEMU_OPT_STRING,
2918
                .help = "BOOTP filename, for use with tftp=",
2919
            }, {
2920
                .name = "dhcpstart",
2921
                .type = QEMU_OPT_STRING,
2922
                .help = "the first of the 16 IPs the built-in DHCP server can assign",
2923
            }, {
2924
                .name = "dns",
2925
                .type = QEMU_OPT_STRING,
2926
                .help = "guest-visible address of the virtual nameserver",
2927
            }, {
2928
                .name = "smb",
2929
                .type = QEMU_OPT_STRING,
2930
                .help = "root directory of the built-in SMB server",
2931
            }, {
2932
                .name = "smbserver",
2933
                .type = QEMU_OPT_STRING,
2934
                .help = "IP address of the built-in SMB server",
2935
            }, {
2936
                .name = "hostfwd",
2937
                .type = QEMU_OPT_STRING,
2938
                .help = "guest port number to forward incoming TCP or UDP connections",
2939
            }, {
2940
                .name = "guestfwd",
2941
                .type = QEMU_OPT_STRING,
2942
                .help = "IP address and port to forward guest TCP connections",
2943
            },
2944
            { /* end of list */ }
2945
        },
2946
#endif
2947
#ifdef _WIN32
2948
    }, {
2949
        .type = "tap",
2950
        .init = net_init_tap_win32,
2951
        .desc = {
2952
            NET_COMMON_PARAMS_DESC,
2953
            {
2954
                .name = "ifname",
2955
                .type = QEMU_OPT_STRING,
2956
                .help = "interface name",
2957
            },
2958
            { /* end of list */ }
2959
        },
2960
#elif !defined(_AIX)
2961
    }, {
2962
        .type = "tap",
2963
        .init = net_init_tap,
2964
        .desc = {
2965
            NET_COMMON_PARAMS_DESC,
2966
            {
2967
                .name = "fd",
2968
                .type = QEMU_OPT_STRING,
2969
                .help = "file descriptor of an already opened tap",
2970
            }, {
2971
                .name = "ifname",
2972
                .type = QEMU_OPT_STRING,
2973
                .help = "interface name",
2974
            }, {
2975
                .name = "script",
2976
                .type = QEMU_OPT_STRING,
2977
                .help = "script to initialize the interface",
2978
            }, {
2979
                .name = "downscript",
2980
                .type = QEMU_OPT_STRING,
2981
                .help = "script to shut down the interface",
2982
#ifdef TUNSETSNDBUF
2983
            }, {
2984
                .name = "sndbuf",
2985
                .type = QEMU_OPT_SIZE,
2986
                .help = "send buffer limit"
2987
#endif
2988
            },
2989
            { /* end of list */ }
2990
        },
2991
#endif
2992
    }, {
2993
        .type = "socket",
2994
        .init = net_init_socket,
2995
        .desc = {
2996
            NET_COMMON_PARAMS_DESC,
2997
            {
2998
                .name = "fd",
2999
                .type = QEMU_OPT_STRING,
3000
                .help = "file descriptor of an already opened socket",
3001
            }, {
3002
                .name = "listen",
3003
                .type = QEMU_OPT_STRING,
3004
                .help = "port number, and optional hostname, to listen on",
3005
            }, {
3006
                .name = "connect",
3007
                .type = QEMU_OPT_STRING,
3008
                .help = "port number, and optional hostname, to connect to",
3009
            }, {
3010
                .name = "mcast",
3011
                .type = QEMU_OPT_STRING,
3012
                .help = "UDP multicast address and port number",
3013
            },
3014
            { /* end of list */ }
3015
        },
3016
#ifdef CONFIG_VDE
3017
    }, {
3018
        .type = "vde",
3019
        .init = net_init_vde,
3020
        .desc = {
3021
            NET_COMMON_PARAMS_DESC,
3022
            {
3023
                .name = "sock",
3024
                .type = QEMU_OPT_STRING,
3025
                .help = "socket path",
3026
            }, {
3027
                .name = "port",
3028
                .type = QEMU_OPT_NUMBER,
3029
                .help = "port number",
3030
            }, {
3031
                .name = "group",
3032
                .type = QEMU_OPT_STRING,
3033
                .help = "group owner of socket",
3034
            }, {
3035
                .name = "mode",
3036
                .type = QEMU_OPT_NUMBER,
3037
                .help = "permissions for socket",
3038
            },
3039
            { /* end of list */ }
3040
        },
3041
#endif
3042
    }, {
3043
        .type = "dump",
3044
        .init = net_init_dump,
3045
        .desc = {
3046
            NET_COMMON_PARAMS_DESC,
3047
            {
3048
                .name = "len",
3049
                .type = QEMU_OPT_SIZE,
3050
                .help = "per-packet size limit (64k default)",
3051
            }, {
3052
                .name = "file",
3053
                .type = QEMU_OPT_STRING,
3054
                .help = "dump file path (default is qemu-vlan0.pcap)",
3055
            },
3056
            { /* end of list */ }
3057
        },
3058
    },
3059
    { /* end of list */ }
3060
};
3061

    
3062
int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
3063
{
3064
    const char *name;
3065
    const char *type;
3066
    int i;
3067

    
3068
    type = qemu_opt_get(opts, "type");
3069
    if (!type) {
3070
        qemu_error("No type specified for -net\n");
3071
        return -1;
3072
    }
3073

    
3074
    if (is_netdev) {
3075
        if (strcmp(type, "tap") != 0 &&
3076
#ifdef CONFIG_SLIRP
3077
            strcmp(type, "user") != 0 &&
3078
#endif
3079
#ifdef CONFIG_VDE
3080
            strcmp(type, "vde") != 0 &&
3081
#endif
3082
            strcmp(type, "socket") != 0) {
3083
            qemu_error("The '%s' network backend type is not valid with -netdev\n",
3084
                       type);
3085
            return -1;
3086
        }
3087

    
3088
        if (qemu_opt_get(opts, "vlan")) {
3089
            qemu_error("The 'vlan' parameter is not valid with -netdev\n");
3090
            return -1;
3091
        }
3092
        if (qemu_opt_get(opts, "name")) {
3093
            qemu_error("The 'name' parameter is not valid with -netdev\n");
3094
            return -1;
3095
        }
3096
        if (!qemu_opts_id(opts)) {
3097
            qemu_error("The id= parameter is required with -netdev\n");
3098
            return -1;
3099
        }
3100
    }
3101

    
3102
    name = qemu_opts_id(opts);
3103
    if (!name) {
3104
        name = qemu_opt_get(opts, "name");
3105
    }
3106

    
3107
    for (i = 0; net_client_types[i].type != NULL; i++) {
3108
        if (!strcmp(net_client_types[i].type, type)) {
3109
            VLANState *vlan = NULL;
3110

    
3111
            if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
3112
                return -1;
3113
            }
3114

    
3115
            /* Do not add to a vlan if it's a -netdev or a nic with a
3116
             * netdev= parameter. */
3117
            if (!(is_netdev ||
3118
                  (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
3119
                vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
3120
            }
3121

    
3122
            if (net_client_types[i].init) {
3123
                return net_client_types[i].init(opts, mon, name, vlan);
3124
            } else {
3125
                return 0;
3126
            }
3127
        }
3128
    }
3129

    
3130
    qemu_error("Invalid -net type '%s'\n", type);
3131
    return -1;
3132
}
3133

    
3134
void net_client_uninit(NICInfo *nd)
3135
{
3136
    if (nd->vlan) {
3137
        nd->vlan->nb_guest_devs--;
3138
    }
3139
    nb_nics--;
3140

    
3141
    qemu_free(nd->model);
3142
    qemu_free(nd->name);
3143
    qemu_free(nd->devaddr);
3144

    
3145
    nd->used = 0;
3146
}
3147

    
3148
static int net_host_check_device(const char *device)
3149
{
3150
    int i;
3151
    const char *valid_param_list[] = { "tap", "socket", "dump"
3152
#ifdef CONFIG_SLIRP
3153
                                       ,"user"
3154
#endif
3155
#ifdef CONFIG_VDE
3156
                                       ,"vde"
3157
#endif
3158
    };
3159
    for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
3160
        if (!strncmp(valid_param_list[i], device,
3161
                     strlen(valid_param_list[i])))
3162
            return 1;
3163
    }
3164

    
3165
    return 0;
3166
}
3167

    
3168
void net_host_device_add(Monitor *mon, const QDict *qdict)
3169
{
3170
    const char *device = qdict_get_str(qdict, "device");
3171
    const char *opts_str = qdict_get_try_str(qdict, "opts");
3172
    QemuOpts *opts;
3173

    
3174
    if (!net_host_check_device(device)) {
3175
        monitor_printf(mon, "invalid host network device %s\n", device);
3176
        return;
3177
    }
3178

    
3179
    opts = qemu_opts_parse(&qemu_net_opts, opts_str ? opts_str : "", NULL);
3180
    if (!opts) {
3181
        monitor_printf(mon, "parsing network options '%s' failed\n",
3182
                       opts_str ? opts_str : "");
3183
        return;
3184
    }
3185

    
3186
    qemu_opt_set(opts, "type", device);
3187

    
3188
    if (net_client_init(mon, opts, 0) < 0) {
3189
        monitor_printf(mon, "adding host network device %s failed\n", device);
3190
    }
3191
}
3192

    
3193
void net_host_device_remove(Monitor *mon, const QDict *qdict)
3194
{
3195
    VLANClientState *vc;
3196
    int vlan_id = qdict_get_int(qdict, "vlan_id");
3197
    const char *device = qdict_get_str(qdict, "device");
3198

    
3199
    vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
3200
    if (!vc) {
3201
        return;
3202
    }
3203
    if (!net_host_check_device(vc->model)) {
3204
        monitor_printf(mon, "invalid host network device %s\n", device);
3205
        return;
3206
    }
3207
    qemu_del_vlan_client(vc);
3208
}
3209

    
3210
void net_set_boot_mask(int net_boot_mask)
3211
{
3212
    int i;
3213

    
3214
    /* Only the first four NICs may be bootable */
3215
    net_boot_mask = net_boot_mask & 0xF;
3216

    
3217
    for (i = 0; i < nb_nics; i++) {
3218
        if (net_boot_mask & (1 << i)) {
3219
            nd_table[i].bootable = 1;
3220
            net_boot_mask &= ~(1 << i);
3221
        }
3222
    }
3223

    
3224
    if (net_boot_mask) {
3225
        fprintf(stderr, "Cannot boot from non-existent NIC\n");
3226
        exit(1);
3227
    }
3228
}
3229

    
3230
void do_info_network(Monitor *mon)
3231
{
3232
    VLANState *vlan;
3233

    
3234
    QTAILQ_FOREACH(vlan, &vlans, next) {
3235
        VLANClientState *vc;
3236

    
3237
        monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
3238

    
3239
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
3240
            monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
3241
        }
3242
    }
3243
}
3244

    
3245
void do_set_link(Monitor *mon, const QDict *qdict)
3246
{
3247
    VLANState *vlan;
3248
    VLANClientState *vc = NULL;
3249
    const char *name = qdict_get_str(qdict, "name");
3250
    const char *up_or_down = qdict_get_str(qdict, "up_or_down");
3251

    
3252
    QTAILQ_FOREACH(vlan, &vlans, next) {
3253
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
3254
            if (strcmp(vc->name, name) == 0) {
3255
                goto done;
3256
            }
3257
        }
3258
    }
3259
done:
3260

    
3261
    if (!vc) {
3262
        monitor_printf(mon, "could not find network device '%s'\n", name);
3263
        return;
3264
    }
3265

    
3266
    if (strcmp(up_or_down, "up") == 0)
3267
        vc->link_down = 0;
3268
    else if (strcmp(up_or_down, "down") == 0)
3269
        vc->link_down = 1;
3270
    else
3271
        monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
3272
                       "valid\n", up_or_down);
3273

    
3274
    if (vc->link_status_changed)
3275
        vc->link_status_changed(vc);
3276
}
3277

    
3278
void net_cleanup(void)
3279
{
3280
    VLANState *vlan;
3281
    VLANClientState *vc, *next_vc;
3282

    
3283
    QTAILQ_FOREACH(vlan, &vlans, next) {
3284
        QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
3285
            qemu_del_vlan_client(vc);
3286
        }
3287
    }
3288

    
3289
    QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
3290
        qemu_del_vlan_client(vc);
3291
    }
3292
}
3293

    
3294
static void net_check_clients(void)
3295
{
3296
    VLANState *vlan;
3297

    
3298
    QTAILQ_FOREACH(vlan, &vlans, next) {
3299
        if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
3300
            continue;
3301
        if (vlan->nb_guest_devs == 0)
3302
            fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
3303
        if (vlan->nb_host_devs == 0)
3304
            fprintf(stderr,
3305
                    "Warning: vlan %d is not connected to host network\n",
3306
                    vlan->id);
3307
    }
3308
}
3309

    
3310
static int net_init_client(QemuOpts *opts, void *dummy)
3311
{
3312
    return net_client_init(NULL, opts, 0);
3313
}
3314

    
3315
static int net_init_netdev(QemuOpts *opts, void *dummy)
3316
{
3317
    return net_client_init(NULL, opts, 1);
3318
}
3319

    
3320
int net_init_clients(void)
3321
{
3322
    if (QTAILQ_EMPTY(&qemu_net_opts.head)) {
3323
        /* if no clients, we use a default config */
3324
        qemu_opts_set(&qemu_net_opts, NULL, "type", "nic");
3325
#ifdef CONFIG_SLIRP
3326
        qemu_opts_set(&qemu_net_opts, NULL, "type", "user");
3327
#endif
3328
    }
3329

    
3330
    QTAILQ_INIT(&vlans);
3331
    QTAILQ_INIT(&non_vlan_clients);
3332

    
3333
    if (qemu_opts_foreach(&qemu_netdev_opts, net_init_netdev, NULL, 1) == -1)
3334
        return -1;
3335

    
3336
    if (qemu_opts_foreach(&qemu_net_opts, net_init_client, NULL, 1) == -1) {
3337
        return -1;
3338
    }
3339

    
3340
    net_check_clients();
3341

    
3342
    return 0;
3343
}
3344

    
3345
int net_client_parse(QemuOptsList *opts_list, const char *optarg)
3346
{
3347
#if defined(CONFIG_SLIRP)
3348
    /* handle legacy -net channel,port:chr */
3349
    if (!strcmp(opts_list->name, "net") &&
3350
        !strncmp(optarg, "channel,", strlen("channel,"))) {
3351
        int ret;
3352

    
3353
        optarg += strlen("channel,");
3354

    
3355
        if (QTAILQ_EMPTY(&slirp_stacks)) {
3356
            struct slirp_config_str *config;
3357

    
3358
            config = qemu_malloc(sizeof(*config));
3359
            pstrcpy(config->str, sizeof(config->str), optarg);
3360
            config->flags = SLIRP_CFG_LEGACY;
3361
            config->next = slirp_configs;
3362
            slirp_configs = config;
3363
            ret = 0;
3364
        } else {
3365
            ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), optarg, 1);
3366
        }
3367

    
3368
        return ret;
3369
    }
3370
#endif
3371
    if (!qemu_opts_parse(opts_list, optarg, "type")) {
3372
        return -1;
3373
    }
3374

    
3375
    return 0;
3376
}