Statistics
| Branch: | Revision:

root / net.c @ ab1cbe1c

History | View | Annotate | Download (38.3 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 "net.h"
25

    
26
#include "config-host.h"
27

    
28
#include "net/tap.h"
29
#include "net/socket.h"
30
#include "net/dump.h"
31
#include "net/slirp.h"
32
#include "net/vde.h"
33
#include "net/util.h"
34
#include "monitor.h"
35
#include "sysemu.h"
36
#include "qemu-common.h"
37
#include "qemu_socket.h"
38
#include "hw/qdev.h"
39

    
40
static QTAILQ_HEAD(, VLANState) vlans;
41
static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
42

    
43
int default_net = 1;
44

    
45
/***********************************************************/
46
/* network device redirectors */
47

    
48
#if defined(DEBUG_NET)
49
static void hex_dump(FILE *f, const uint8_t *buf, int size)
50
{
51
    int len, i, j, c;
52

    
53
    for(i=0;i<size;i+=16) {
54
        len = size - i;
55
        if (len > 16)
56
            len = 16;
57
        fprintf(f, "%08x ", i);
58
        for(j=0;j<16;j++) {
59
            if (j < len)
60
                fprintf(f, " %02x", buf[i+j]);
61
            else
62
                fprintf(f, "   ");
63
        }
64
        fprintf(f, " ");
65
        for(j=0;j<len;j++) {
66
            c = buf[i+j];
67
            if (c < ' ' || c > '~')
68
                c = '.';
69
            fprintf(f, "%c", c);
70
        }
71
        fprintf(f, "\n");
72
    }
73
}
74
#endif
75

    
76
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
77
{
78
    const char *p, *p1;
79
    int len;
80
    p = *pp;
81
    p1 = strchr(p, sep);
82
    if (!p1)
83
        return -1;
84
    len = p1 - p;
85
    p1++;
86
    if (buf_size > 0) {
87
        if (len > buf_size - 1)
88
            len = buf_size - 1;
89
        memcpy(buf, p, len);
90
        buf[len] = '\0';
91
    }
92
    *pp = p1;
93
    return 0;
94
}
95

    
96
int parse_host_src_port(struct sockaddr_in *haddr,
97
                        struct sockaddr_in *saddr,
98
                        const char *input_str)
99
{
100
    char *str = qemu_strdup(input_str);
101
    char *host_str = str;
102
    char *src_str;
103
    const char *src_str2;
104
    char *ptr;
105

    
106
    /*
107
     * Chop off any extra arguments at the end of the string which
108
     * would start with a comma, then fill in the src port information
109
     * if it was provided else use the "any address" and "any port".
110
     */
111
    if ((ptr = strchr(str,',')))
112
        *ptr = '\0';
113

    
114
    if ((src_str = strchr(input_str,'@'))) {
115
        *src_str = '\0';
116
        src_str++;
117
    }
118

    
119
    if (parse_host_port(haddr, host_str) < 0)
120
        goto fail;
121

    
122
    src_str2 = src_str;
123
    if (!src_str || *src_str == '\0')
124
        src_str2 = ":0";
125

    
126
    if (parse_host_port(saddr, src_str2) < 0)
127
        goto fail;
128

    
129
    free(str);
130
    return(0);
131

    
132
fail:
133
    free(str);
134
    return -1;
135
}
136

    
137
int parse_host_port(struct sockaddr_in *saddr, const char *str)
138
{
139
    char buf[512];
140
    struct hostent *he;
141
    const char *p, *r;
142
    int port;
143

    
144
    p = str;
145
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
146
        return -1;
147
    saddr->sin_family = AF_INET;
148
    if (buf[0] == '\0') {
149
        saddr->sin_addr.s_addr = 0;
150
    } else {
151
        if (qemu_isdigit(buf[0])) {
152
            if (!inet_aton(buf, &saddr->sin_addr))
153
                return -1;
154
        } else {
155
            if ((he = gethostbyname(buf)) == NULL)
156
                return - 1;
157
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
158
        }
159
    }
160
    port = strtol(p, (char **)&r, 0);
161
    if (r == p)
162
        return -1;
163
    saddr->sin_port = htons(port);
164
    return 0;
165
}
166

    
167
void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
168
{
169
    snprintf(vc->info_str, sizeof(vc->info_str),
170
             "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
171
             vc->model,
172
             macaddr[0], macaddr[1], macaddr[2],
173
             macaddr[3], macaddr[4], macaddr[5]);
174
}
175

    
176
void qemu_macaddr_default_if_unset(MACAddr *macaddr)
177
{
178
    static int index = 0;
179
    static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
180

    
181
    if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
182
        return;
183
    macaddr->a[0] = 0x52;
184
    macaddr->a[1] = 0x54;
185
    macaddr->a[2] = 0x00;
186
    macaddr->a[3] = 0x12;
187
    macaddr->a[4] = 0x34;
188
    macaddr->a[5] = 0x56 + index++;
189
}
190

    
191
static char *assign_name(VLANClientState *vc1, const char *model)
192
{
193
    VLANState *vlan;
194
    char buf[256];
195
    int id = 0;
196

    
197
    QTAILQ_FOREACH(vlan, &vlans, next) {
198
        VLANClientState *vc;
199

    
200
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
201
            if (vc != vc1 && strcmp(vc->model, model) == 0) {
202
                id++;
203
            }
204
        }
205
    }
206

    
207
    snprintf(buf, sizeof(buf), "%s.%d", model, id);
208

    
209
    return qemu_strdup(buf);
210
}
211

    
212
static ssize_t qemu_deliver_packet(VLANClientState *sender,
213
                                   unsigned flags,
214
                                   const uint8_t *data,
215
                                   size_t size,
216
                                   void *opaque);
217
static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
218
                                       unsigned flags,
219
                                       const struct iovec *iov,
220
                                       int iovcnt,
221
                                       void *opaque);
222

    
223
VLANClientState *qemu_new_net_client(NetClientInfo *info,
224
                                     VLANState *vlan,
225
                                     VLANClientState *peer,
226
                                     const char *model,
227
                                     const char *name)
228
{
229
    VLANClientState *vc;
230

    
231
    assert(info->size >= sizeof(VLANClientState));
232

    
233
    vc = qemu_mallocz(info->size);
234

    
235
    vc->info = info;
236
    vc->model = qemu_strdup(model);
237
    if (name) {
238
        vc->name = qemu_strdup(name);
239
    } else {
240
        vc->name = assign_name(vc, model);
241
    }
242

    
243
    if (vlan) {
244
        assert(!peer);
245
        vc->vlan = vlan;
246
        QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
247
    } else {
248
        if (peer) {
249
            assert(!peer->peer);
250
            vc->peer = peer;
251
            peer->peer = vc;
252
        }
253
        QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
254

    
255
        vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
256
                                            qemu_deliver_packet_iov,
257
                                            vc);
258
    }
259

    
260
    return vc;
261
}
262

    
263
NICState *qemu_new_nic(NetClientInfo *info,
264
                       NICConf *conf,
265
                       const char *model,
266
                       const char *name,
267
                       void *opaque)
268
{
269
    VLANClientState *nc;
270
    NICState *nic;
271

    
272
    assert(info->type == NET_CLIENT_TYPE_NIC);
273
    assert(info->size >= sizeof(NICState));
274

    
275
    nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
276

    
277
    nic = DO_UPCAST(NICState, nc, nc);
278
    nic->conf = conf;
279
    nic->opaque = opaque;
280

    
281
    return nic;
282
}
283

    
284
static void qemu_cleanup_vlan_client(VLANClientState *vc)
285
{
286
    if (vc->vlan) {
287
        QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
288
    } else {
289
        QTAILQ_REMOVE(&non_vlan_clients, vc, next);
290
    }
291

    
292
    if (vc->info->cleanup) {
293
        vc->info->cleanup(vc);
294
    }
295
}
296

    
297
static void qemu_free_vlan_client(VLANClientState *vc)
298
{
299
    if (!vc->vlan) {
300
        if (vc->send_queue) {
301
            qemu_del_net_queue(vc->send_queue);
302
        }
303
        if (vc->peer) {
304
            vc->peer->peer = NULL;
305
        }
306
    }
307
    qemu_free(vc->name);
308
    qemu_free(vc->model);
309
    qemu_free(vc);
310
}
311

    
312
void qemu_del_vlan_client(VLANClientState *vc)
313
{
314
    /* If there is a peer NIC, delete and cleanup client, but do not free. */
315
    if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
316
        NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
317
        if (nic->peer_deleted) {
318
            return;
319
        }
320
        nic->peer_deleted = true;
321
        /* Let NIC know peer is gone. */
322
        vc->peer->link_down = true;
323
        if (vc->peer->info->link_status_changed) {
324
            vc->peer->info->link_status_changed(vc->peer);
325
        }
326
        qemu_cleanup_vlan_client(vc);
327
        return;
328
    }
329

    
330
    /* If this is a peer NIC and peer has already been deleted, free it now. */
331
    if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
332
        NICState *nic = DO_UPCAST(NICState, nc, vc);
333
        if (nic->peer_deleted) {
334
            qemu_free_vlan_client(vc->peer);
335
        }
336
    }
337

    
338
    qemu_cleanup_vlan_client(vc);
339
    qemu_free_vlan_client(vc);
340
}
341

    
342
VLANClientState *
343
qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
344
                              const char *client_str)
345
{
346
    VLANState *vlan;
347
    VLANClientState *vc;
348

    
349
    vlan = qemu_find_vlan(vlan_id, 0);
350
    if (!vlan) {
351
        monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
352
        return NULL;
353
    }
354

    
355
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
356
        if (!strcmp(vc->name, client_str)) {
357
            break;
358
        }
359
    }
360
    if (!vc) {
361
        monitor_printf(mon, "can't find device %s on VLAN %d\n",
362
                       client_str, vlan_id);
363
    }
364

    
365
    return vc;
366
}
367

    
368
void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
369
{
370
    VLANClientState *nc;
371
    VLANState *vlan;
372

    
373
    QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
374
        if (nc->info->type == NET_CLIENT_TYPE_NIC) {
375
            func(DO_UPCAST(NICState, nc, nc), opaque);
376
        }
377
    }
378

    
379
    QTAILQ_FOREACH(vlan, &vlans, next) {
380
        QTAILQ_FOREACH(nc, &vlan->clients, next) {
381
            if (nc->info->type == NET_CLIENT_TYPE_NIC) {
382
                func(DO_UPCAST(NICState, nc, nc), opaque);
383
            }
384
        }
385
    }
386
}
387

    
388
int qemu_can_send_packet(VLANClientState *sender)
389
{
390
    VLANState *vlan = sender->vlan;
391
    VLANClientState *vc;
392

    
393
    if (sender->peer) {
394
        if (sender->peer->receive_disabled) {
395
            return 0;
396
        } else if (sender->peer->info->can_receive &&
397
                   !sender->peer->info->can_receive(sender->peer)) {
398
            return 0;
399
        } else {
400
            return 1;
401
        }
402
    }
403

    
404
    if (!sender->vlan) {
405
        return 1;
406
    }
407

    
408
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
409
        if (vc == sender) {
410
            continue;
411
        }
412

    
413
        /* no can_receive() handler, they can always receive */
414
        if (!vc->info->can_receive || vc->info->can_receive(vc)) {
415
            return 1;
416
        }
417
    }
418
    return 0;
419
}
420

    
421
static ssize_t qemu_deliver_packet(VLANClientState *sender,
422
                                   unsigned flags,
423
                                   const uint8_t *data,
424
                                   size_t size,
425
                                   void *opaque)
426
{
427
    VLANClientState *vc = opaque;
428
    ssize_t ret;
429

    
430
    if (vc->link_down) {
431
        return size;
432
    }
433

    
434
    if (vc->receive_disabled) {
435
        return 0;
436
    }
437

    
438
    if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
439
        ret = vc->info->receive_raw(vc, data, size);
440
    } else {
441
        ret = vc->info->receive(vc, data, size);
442
    }
443

    
444
    if (ret == 0) {
445
        vc->receive_disabled = 1;
446
    };
447

    
448
    return ret;
449
}
450

    
451
static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
452
                                        unsigned flags,
453
                                        const uint8_t *buf,
454
                                        size_t size,
455
                                        void *opaque)
456
{
457
    VLANState *vlan = opaque;
458
    VLANClientState *vc;
459
    ssize_t ret = -1;
460

    
461
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
462
        ssize_t len;
463

    
464
        if (vc == sender) {
465
            continue;
466
        }
467

    
468
        if (vc->link_down) {
469
            ret = size;
470
            continue;
471
        }
472

    
473
        if (vc->receive_disabled) {
474
            ret = 0;
475
            continue;
476
        }
477

    
478
        if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
479
            len = vc->info->receive_raw(vc, buf, size);
480
        } else {
481
            len = vc->info->receive(vc, buf, size);
482
        }
483

    
484
        if (len == 0) {
485
            vc->receive_disabled = 1;
486
        }
487

    
488
        ret = (ret >= 0) ? ret : len;
489

    
490
    }
491

    
492
    return ret;
493
}
494

    
495
void qemu_purge_queued_packets(VLANClientState *vc)
496
{
497
    NetQueue *queue;
498

    
499
    if (!vc->peer && !vc->vlan) {
500
        return;
501
    }
502

    
503
    if (vc->peer) {
504
        queue = vc->peer->send_queue;
505
    } else {
506
        queue = vc->vlan->send_queue;
507
    }
508

    
509
    qemu_net_queue_purge(queue, vc);
510
}
511

    
512
void qemu_flush_queued_packets(VLANClientState *vc)
513
{
514
    NetQueue *queue;
515

    
516
    vc->receive_disabled = 0;
517

    
518
    if (vc->vlan) {
519
        queue = vc->vlan->send_queue;
520
    } else {
521
        queue = vc->send_queue;
522
    }
523

    
524
    qemu_net_queue_flush(queue);
525
}
526

    
527
static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
528
                                                 unsigned flags,
529
                                                 const uint8_t *buf, int size,
530
                                                 NetPacketSent *sent_cb)
531
{
532
    NetQueue *queue;
533

    
534
#ifdef DEBUG_NET
535
    printf("qemu_send_packet_async:\n");
536
    hex_dump(stdout, buf, size);
537
#endif
538

    
539
    if (sender->link_down || (!sender->peer && !sender->vlan)) {
540
        return size;
541
    }
542

    
543
    if (sender->peer) {
544
        queue = sender->peer->send_queue;
545
    } else {
546
        queue = sender->vlan->send_queue;
547
    }
548

    
549
    return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
550
}
551

    
552
ssize_t qemu_send_packet_async(VLANClientState *sender,
553
                               const uint8_t *buf, int size,
554
                               NetPacketSent *sent_cb)
555
{
556
    return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
557
                                             buf, size, sent_cb);
558
}
559

    
560
void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
561
{
562
    qemu_send_packet_async(vc, buf, size, NULL);
563
}
564

    
565
ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
566
{
567
    return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
568
                                             buf, size, NULL);
569
}
570

    
571
static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
572
                               int iovcnt)
573
{
574
    uint8_t buffer[4096];
575
    size_t offset = 0;
576
    int i;
577

    
578
    for (i = 0; i < iovcnt; i++) {
579
        size_t len;
580

    
581
        len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
582
        memcpy(buffer + offset, iov[i].iov_base, len);
583
        offset += len;
584
    }
585

    
586
    return vc->info->receive(vc, buffer, offset);
587
}
588

    
589
static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
590
{
591
    size_t offset = 0;
592
    int i;
593

    
594
    for (i = 0; i < iovcnt; i++)
595
        offset += iov[i].iov_len;
596
    return offset;
597
}
598

    
599
static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
600
                                       unsigned flags,
601
                                       const struct iovec *iov,
602
                                       int iovcnt,
603
                                       void *opaque)
604
{
605
    VLANClientState *vc = opaque;
606

    
607
    if (vc->link_down) {
608
        return calc_iov_length(iov, iovcnt);
609
    }
610

    
611
    if (vc->info->receive_iov) {
612
        return vc->info->receive_iov(vc, iov, iovcnt);
613
    } else {
614
        return vc_sendv_compat(vc, iov, iovcnt);
615
    }
616
}
617

    
618
static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
619
                                            unsigned flags,
620
                                            const struct iovec *iov,
621
                                            int iovcnt,
622
                                            void *opaque)
623
{
624
    VLANState *vlan = opaque;
625
    VLANClientState *vc;
626
    ssize_t ret = -1;
627

    
628
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
629
        ssize_t len;
630

    
631
        if (vc == sender) {
632
            continue;
633
        }
634

    
635
        if (vc->link_down) {
636
            ret = calc_iov_length(iov, iovcnt);
637
            continue;
638
        }
639

    
640
        assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
641

    
642
        if (vc->info->receive_iov) {
643
            len = vc->info->receive_iov(vc, iov, iovcnt);
644
        } else {
645
            len = vc_sendv_compat(vc, iov, iovcnt);
646
        }
647

    
648
        ret = (ret >= 0) ? ret : len;
649
    }
650

    
651
    return ret;
652
}
653

    
654
ssize_t qemu_sendv_packet_async(VLANClientState *sender,
655
                                const struct iovec *iov, int iovcnt,
656
                                NetPacketSent *sent_cb)
657
{
658
    NetQueue *queue;
659

    
660
    if (sender->link_down || (!sender->peer && !sender->vlan)) {
661
        return calc_iov_length(iov, iovcnt);
662
    }
663

    
664
    if (sender->peer) {
665
        queue = sender->peer->send_queue;
666
    } else {
667
        queue = sender->vlan->send_queue;
668
    }
669

    
670
    return qemu_net_queue_send_iov(queue, sender,
671
                                   QEMU_NET_PACKET_FLAG_NONE,
672
                                   iov, iovcnt, sent_cb);
673
}
674

    
675
ssize_t
676
qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
677
{
678
    return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
679
}
680

    
681
/* find or alloc a new VLAN */
682
VLANState *qemu_find_vlan(int id, int allocate)
683
{
684
    VLANState *vlan;
685

    
686
    QTAILQ_FOREACH(vlan, &vlans, next) {
687
        if (vlan->id == id) {
688
            return vlan;
689
        }
690
    }
691

    
692
    if (!allocate) {
693
        return NULL;
694
    }
695

    
696
    vlan = qemu_mallocz(sizeof(VLANState));
697
    vlan->id = id;
698
    QTAILQ_INIT(&vlan->clients);
699

    
700
    vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
701
                                          qemu_vlan_deliver_packet_iov,
702
                                          vlan);
703

    
704
    QTAILQ_INSERT_TAIL(&vlans, vlan, next);
705

    
706
    return vlan;
707
}
708

    
709
VLANClientState *qemu_find_netdev(const char *id)
710
{
711
    VLANClientState *vc;
712

    
713
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
714
        if (!strcmp(vc->name, id)) {
715
            return vc;
716
        }
717
    }
718

    
719
    return NULL;
720
}
721

    
722
static int nic_get_free_idx(void)
723
{
724
    int index;
725

    
726
    for (index = 0; index < MAX_NICS; index++)
727
        if (!nd_table[index].used)
728
            return index;
729
    return -1;
730
}
731

    
732
int qemu_show_nic_models(const char *arg, const char *const *models)
733
{
734
    int i;
735

    
736
    if (!arg || strcmp(arg, "?"))
737
        return 0;
738

    
739
    fprintf(stderr, "qemu: Supported NIC models: ");
740
    for (i = 0 ; models[i]; i++)
741
        fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
742
    return 1;
743
}
744

    
745
void qemu_check_nic_model(NICInfo *nd, const char *model)
746
{
747
    const char *models[2];
748

    
749
    models[0] = model;
750
    models[1] = NULL;
751

    
752
    if (qemu_show_nic_models(nd->model, models))
753
        exit(0);
754
    if (qemu_find_nic_model(nd, models, model) < 0)
755
        exit(1);
756
}
757

    
758
int qemu_find_nic_model(NICInfo *nd, const char * const *models,
759
                        const char *default_model)
760
{
761
    int i;
762

    
763
    if (!nd->model)
764
        nd->model = qemu_strdup(default_model);
765

    
766
    for (i = 0 ; models[i]; i++) {
767
        if (strcmp(nd->model, models[i]) == 0)
768
            return i;
769
    }
770

    
771
    error_report("qemu: Unsupported NIC model: %s", nd->model);
772
    return -1;
773
}
774

    
775
int net_handle_fd_param(Monitor *mon, const char *param)
776
{
777
    int fd;
778

    
779
    if (!qemu_isdigit(param[0]) && mon) {
780

    
781
        fd = monitor_get_fd(mon, param);
782
        if (fd == -1) {
783
            error_report("No file descriptor named %s found", param);
784
            return -1;
785
        }
786
    } else {
787
        char *endptr = NULL;
788

    
789
        fd = strtol(param, &endptr, 10);
790
        if (*endptr || (fd == 0 && param == endptr)) {
791
            return -1;
792
        }
793
    }
794

    
795
    return fd;
796
}
797

    
798
static int net_init_nic(QemuOpts *opts,
799
                        Monitor *mon,
800
                        const char *name,
801
                        VLANState *vlan)
802
{
803
    int idx;
804
    NICInfo *nd;
805
    const char *netdev;
806

    
807
    idx = nic_get_free_idx();
808
    if (idx == -1 || nb_nics >= MAX_NICS) {
809
        error_report("Too Many NICs");
810
        return -1;
811
    }
812

    
813
    nd = &nd_table[idx];
814

    
815
    memset(nd, 0, sizeof(*nd));
816

    
817
    if ((netdev = qemu_opt_get(opts, "netdev"))) {
818
        nd->netdev = qemu_find_netdev(netdev);
819
        if (!nd->netdev) {
820
            error_report("netdev '%s' not found", netdev);
821
            return -1;
822
        }
823
    } else {
824
        assert(vlan);
825
        nd->vlan = vlan;
826
    }
827
    if (name) {
828
        nd->name = qemu_strdup(name);
829
    }
830
    if (qemu_opt_get(opts, "model")) {
831
        nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
832
    }
833
    if (qemu_opt_get(opts, "addr")) {
834
        nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
835
    }
836

    
837
    nd->macaddr[0] = 0x52;
838
    nd->macaddr[1] = 0x54;
839
    nd->macaddr[2] = 0x00;
840
    nd->macaddr[3] = 0x12;
841
    nd->macaddr[4] = 0x34;
842
    nd->macaddr[5] = 0x56 + idx;
843

    
844
    if (qemu_opt_get(opts, "macaddr") &&
845
        net_parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
846
        error_report("invalid syntax for ethernet address");
847
        return -1;
848
    }
849

    
850
    nd->nvectors = qemu_opt_get_number(opts, "vectors",
851
                                       DEV_NVECTORS_UNSPECIFIED);
852
    if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
853
        (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
854
        error_report("invalid # of vectors: %d", nd->nvectors);
855
        return -1;
856
    }
857

    
858
    nd->used = 1;
859
    nb_nics++;
860

    
861
    return idx;
862
}
863

    
864
#define NET_COMMON_PARAMS_DESC                     \
865
    {                                              \
866
        .name = "type",                            \
867
        .type = QEMU_OPT_STRING,                   \
868
        .help = "net client type (nic, tap etc.)", \
869
     }, {                                          \
870
        .name = "vlan",                            \
871
        .type = QEMU_OPT_NUMBER,                   \
872
        .help = "vlan number",                     \
873
     }, {                                          \
874
        .name = "name",                            \
875
        .type = QEMU_OPT_STRING,                   \
876
        .help = "identifier for monitor commands", \
877
     }
878

    
879
typedef int (*net_client_init_func)(QemuOpts *opts,
880
                                    Monitor *mon,
881
                                    const char *name,
882
                                    VLANState *vlan);
883

    
884
/* magic number, but compiler will warn if too small */
885
#define NET_MAX_DESC 20
886

    
887
static const struct {
888
    const char *type;
889
    net_client_init_func init;
890
    QemuOptDesc desc[NET_MAX_DESC];
891
} net_client_types[] = {
892
    {
893
        .type = "none",
894
        .desc = {
895
            NET_COMMON_PARAMS_DESC,
896
            { /* end of list */ }
897
        },
898
    }, {
899
        .type = "nic",
900
        .init = net_init_nic,
901
        .desc = {
902
            NET_COMMON_PARAMS_DESC,
903
            {
904
                .name = "netdev",
905
                .type = QEMU_OPT_STRING,
906
                .help = "id of -netdev to connect to",
907
            },
908
            {
909
                .name = "macaddr",
910
                .type = QEMU_OPT_STRING,
911
                .help = "MAC address",
912
            }, {
913
                .name = "model",
914
                .type = QEMU_OPT_STRING,
915
                .help = "device model (e1000, rtl8139, virtio etc.)",
916
            }, {
917
                .name = "addr",
918
                .type = QEMU_OPT_STRING,
919
                .help = "PCI device address",
920
            }, {
921
                .name = "vectors",
922
                .type = QEMU_OPT_NUMBER,
923
                .help = "number of MSI-x vectors, 0 to disable MSI-X",
924
            },
925
            { /* end of list */ }
926
        },
927
#ifdef CONFIG_SLIRP
928
    }, {
929
        .type = "user",
930
        .init = net_init_slirp,
931
        .desc = {
932
            NET_COMMON_PARAMS_DESC,
933
            {
934
                .name = "hostname",
935
                .type = QEMU_OPT_STRING,
936
                .help = "client hostname reported by the builtin DHCP server",
937
            }, {
938
                .name = "restrict",
939
                .type = QEMU_OPT_STRING,
940
                .help = "isolate the guest from the host (y|yes|n|no)",
941
            }, {
942
                .name = "ip",
943
                .type = QEMU_OPT_STRING,
944
                .help = "legacy parameter, use net= instead",
945
            }, {
946
                .name = "net",
947
                .type = QEMU_OPT_STRING,
948
                .help = "IP address and optional netmask",
949
            }, {
950
                .name = "host",
951
                .type = QEMU_OPT_STRING,
952
                .help = "guest-visible address of the host",
953
            }, {
954
                .name = "tftp",
955
                .type = QEMU_OPT_STRING,
956
                .help = "root directory of the built-in TFTP server",
957
            }, {
958
                .name = "bootfile",
959
                .type = QEMU_OPT_STRING,
960
                .help = "BOOTP filename, for use with tftp=",
961
            }, {
962
                .name = "dhcpstart",
963
                .type = QEMU_OPT_STRING,
964
                .help = "the first of the 16 IPs the built-in DHCP server can assign",
965
            }, {
966
                .name = "dns",
967
                .type = QEMU_OPT_STRING,
968
                .help = "guest-visible address of the virtual nameserver",
969
            }, {
970
                .name = "smb",
971
                .type = QEMU_OPT_STRING,
972
                .help = "root directory of the built-in SMB server",
973
            }, {
974
                .name = "smbserver",
975
                .type = QEMU_OPT_STRING,
976
                .help = "IP address of the built-in SMB server",
977
            }, {
978
                .name = "hostfwd",
979
                .type = QEMU_OPT_STRING,
980
                .help = "guest port number to forward incoming TCP or UDP connections",
981
            }, {
982
                .name = "guestfwd",
983
                .type = QEMU_OPT_STRING,
984
                .help = "IP address and port to forward guest TCP connections",
985
            },
986
            { /* end of list */ }
987
        },
988
#endif
989
    }, {
990
        .type = "tap",
991
        .init = net_init_tap,
992
        .desc = {
993
            NET_COMMON_PARAMS_DESC,
994
            {
995
                .name = "ifname",
996
                .type = QEMU_OPT_STRING,
997
                .help = "interface name",
998
            },
999
#ifndef _WIN32
1000
            {
1001
                .name = "fd",
1002
                .type = QEMU_OPT_STRING,
1003
                .help = "file descriptor of an already opened tap",
1004
            }, {
1005
                .name = "script",
1006
                .type = QEMU_OPT_STRING,
1007
                .help = "script to initialize the interface",
1008
            }, {
1009
                .name = "downscript",
1010
                .type = QEMU_OPT_STRING,
1011
                .help = "script to shut down the interface",
1012
            }, {
1013
                .name = "sndbuf",
1014
                .type = QEMU_OPT_SIZE,
1015
                .help = "send buffer limit"
1016
            }, {
1017
                .name = "vnet_hdr",
1018
                .type = QEMU_OPT_BOOL,
1019
                .help = "enable the IFF_VNET_HDR flag on the tap interface"
1020
            }, {
1021
                .name = "vhost",
1022
                .type = QEMU_OPT_BOOL,
1023
                .help = "enable vhost-net network accelerator",
1024
            }, {
1025
                .name = "vhostfd",
1026
                .type = QEMU_OPT_STRING,
1027
                .help = "file descriptor of an already opened vhost net device",
1028
            },
1029
#endif /* _WIN32 */
1030
            { /* end of list */ }
1031
        },
1032
    }, {
1033
        .type = "socket",
1034
        .init = net_init_socket,
1035
        .desc = {
1036
            NET_COMMON_PARAMS_DESC,
1037
            {
1038
                .name = "fd",
1039
                .type = QEMU_OPT_STRING,
1040
                .help = "file descriptor of an already opened socket",
1041
            }, {
1042
                .name = "listen",
1043
                .type = QEMU_OPT_STRING,
1044
                .help = "port number, and optional hostname, to listen on",
1045
            }, {
1046
                .name = "connect",
1047
                .type = QEMU_OPT_STRING,
1048
                .help = "port number, and optional hostname, to connect to",
1049
            }, {
1050
                .name = "mcast",
1051
                .type = QEMU_OPT_STRING,
1052
                .help = "UDP multicast address and port number",
1053
            }, {
1054
                .name = "localaddr",
1055
                .type = QEMU_OPT_STRING,
1056
                .help = "source address for multicast packets",
1057
            },
1058
            { /* end of list */ }
1059
        },
1060
#ifdef CONFIG_VDE
1061
    }, {
1062
        .type = "vde",
1063
        .init = net_init_vde,
1064
        .desc = {
1065
            NET_COMMON_PARAMS_DESC,
1066
            {
1067
                .name = "sock",
1068
                .type = QEMU_OPT_STRING,
1069
                .help = "socket path",
1070
            }, {
1071
                .name = "port",
1072
                .type = QEMU_OPT_NUMBER,
1073
                .help = "port number",
1074
            }, {
1075
                .name = "group",
1076
                .type = QEMU_OPT_STRING,
1077
                .help = "group owner of socket",
1078
            }, {
1079
                .name = "mode",
1080
                .type = QEMU_OPT_NUMBER,
1081
                .help = "permissions for socket",
1082
            },
1083
            { /* end of list */ }
1084
        },
1085
#endif
1086
    }, {
1087
        .type = "dump",
1088
        .init = net_init_dump,
1089
        .desc = {
1090
            NET_COMMON_PARAMS_DESC,
1091
            {
1092
                .name = "len",
1093
                .type = QEMU_OPT_SIZE,
1094
                .help = "per-packet size limit (64k default)",
1095
            }, {
1096
                .name = "file",
1097
                .type = QEMU_OPT_STRING,
1098
                .help = "dump file path (default is qemu-vlan0.pcap)",
1099
            },
1100
            { /* end of list */ }
1101
        },
1102
    },
1103
    { /* end of list */ }
1104
};
1105

    
1106
int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
1107
{
1108
    const char *name;
1109
    const char *type;
1110
    int i;
1111

    
1112
    type = qemu_opt_get(opts, "type");
1113
    if (!type) {
1114
        qerror_report(QERR_MISSING_PARAMETER, "type");
1115
        return -1;
1116
    }
1117

    
1118
    if (is_netdev) {
1119
        if (strcmp(type, "tap") != 0 &&
1120
#ifdef CONFIG_SLIRP
1121
            strcmp(type, "user") != 0 &&
1122
#endif
1123
#ifdef CONFIG_VDE
1124
            strcmp(type, "vde") != 0 &&
1125
#endif
1126
            strcmp(type, "socket") != 0) {
1127
            qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1128
                          "a netdev backend type");
1129
            return -1;
1130
        }
1131

    
1132
        if (qemu_opt_get(opts, "vlan")) {
1133
            qerror_report(QERR_INVALID_PARAMETER, "vlan");
1134
            return -1;
1135
        }
1136
        if (qemu_opt_get(opts, "name")) {
1137
            qerror_report(QERR_INVALID_PARAMETER, "name");
1138
            return -1;
1139
        }
1140
        if (!qemu_opts_id(opts)) {
1141
            qerror_report(QERR_MISSING_PARAMETER, "id");
1142
            return -1;
1143
        }
1144
    }
1145

    
1146
    name = qemu_opts_id(opts);
1147
    if (!name) {
1148
        name = qemu_opt_get(opts, "name");
1149
    }
1150

    
1151
    for (i = 0; net_client_types[i].type != NULL; i++) {
1152
        if (!strcmp(net_client_types[i].type, type)) {
1153
            VLANState *vlan = NULL;
1154
            int ret;
1155

    
1156
            if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
1157
                return -1;
1158
            }
1159

    
1160
            /* Do not add to a vlan if it's a -netdev or a nic with a
1161
             * netdev= parameter. */
1162
            if (!(is_netdev ||
1163
                  (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1164
                vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1165
            }
1166

    
1167
            ret = 0;
1168
            if (net_client_types[i].init) {
1169
                ret = net_client_types[i].init(opts, mon, name, vlan);
1170
                if (ret < 0) {
1171
                    /* TODO push error reporting into init() methods */
1172
                    qerror_report(QERR_DEVICE_INIT_FAILED, type);
1173
                    return -1;
1174
                }
1175
            }
1176
            return ret;
1177
        }
1178
    }
1179

    
1180
    qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1181
                  "a network client type");
1182
    return -1;
1183
}
1184

    
1185
static int net_host_check_device(const char *device)
1186
{
1187
    int i;
1188
    const char *valid_param_list[] = { "tap", "socket", "dump"
1189
#ifdef CONFIG_SLIRP
1190
                                       ,"user"
1191
#endif
1192
#ifdef CONFIG_VDE
1193
                                       ,"vde"
1194
#endif
1195
    };
1196
    for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1197
        if (!strncmp(valid_param_list[i], device,
1198
                     strlen(valid_param_list[i])))
1199
            return 1;
1200
    }
1201

    
1202
    return 0;
1203
}
1204

    
1205
void net_host_device_add(Monitor *mon, const QDict *qdict)
1206
{
1207
    const char *device = qdict_get_str(qdict, "device");
1208
    const char *opts_str = qdict_get_try_str(qdict, "opts");
1209
    QemuOpts *opts;
1210

    
1211
    if (!net_host_check_device(device)) {
1212
        monitor_printf(mon, "invalid host network device %s\n", device);
1213
        return;
1214
    }
1215

    
1216
    opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
1217
    if (!opts) {
1218
        return;
1219
    }
1220

    
1221
    qemu_opt_set(opts, "type", device);
1222

    
1223
    if (net_client_init(mon, opts, 0) < 0) {
1224
        monitor_printf(mon, "adding host network device %s failed\n", device);
1225
    }
1226
}
1227

    
1228
void net_host_device_remove(Monitor *mon, const QDict *qdict)
1229
{
1230
    VLANClientState *vc;
1231
    int vlan_id = qdict_get_int(qdict, "vlan_id");
1232
    const char *device = qdict_get_str(qdict, "device");
1233

    
1234
    vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1235
    if (!vc) {
1236
        return;
1237
    }
1238
    if (!net_host_check_device(vc->model)) {
1239
        monitor_printf(mon, "invalid host network device %s\n", device);
1240
        return;
1241
    }
1242
    qemu_del_vlan_client(vc);
1243
}
1244

    
1245
int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
1246
{
1247
    QemuOpts *opts;
1248
    int res;
1249

    
1250
    opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict);
1251
    if (!opts) {
1252
        return -1;
1253
    }
1254

    
1255
    res = net_client_init(mon, opts, 1);
1256
    if (res < 0) {
1257
        qemu_opts_del(opts);
1258
    }
1259

    
1260
    return res;
1261
}
1262

    
1263
int do_netdev_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1264
{
1265
    const char *id = qdict_get_str(qdict, "id");
1266
    VLANClientState *vc;
1267

    
1268
    vc = qemu_find_netdev(id);
1269
    if (!vc || vc->info->type == NET_CLIENT_TYPE_NIC) {
1270
        qerror_report(QERR_DEVICE_NOT_FOUND, id);
1271
        return -1;
1272
    }
1273
    qemu_del_vlan_client(vc);
1274
    qemu_opts_del(qemu_opts_find(qemu_find_opts("netdev"), id));
1275
    return 0;
1276
}
1277

    
1278
void do_info_network(Monitor *mon)
1279
{
1280
    VLANState *vlan;
1281
    VLANClientState *vc;
1282

    
1283
    QTAILQ_FOREACH(vlan, &vlans, next) {
1284
        monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1285

    
1286
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
1287
            monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
1288
        }
1289
    }
1290
    monitor_printf(mon, "Devices not on any VLAN:\n");
1291
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1292
        monitor_printf(mon, "  %s: %s", vc->name, vc->info_str);
1293
        if (vc->peer) {
1294
            monitor_printf(mon, " peer=%s", vc->peer->name);
1295
        }
1296
        monitor_printf(mon, "\n");
1297
    }
1298
}
1299

    
1300
int do_set_link(Monitor *mon, const QDict *qdict, QObject **ret_data)
1301
{
1302
    VLANState *vlan;
1303
    VLANClientState *vc = NULL;
1304
    const char *name = qdict_get_str(qdict, "name");
1305
    int up = qdict_get_bool(qdict, "up");
1306

    
1307
    QTAILQ_FOREACH(vlan, &vlans, next) {
1308
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
1309
            if (strcmp(vc->name, name) == 0) {
1310
                goto done;
1311
            }
1312
        }
1313
    }
1314
    vc = qemu_find_netdev(name);
1315
done:
1316

    
1317
    if (!vc) {
1318
        qerror_report(QERR_DEVICE_NOT_FOUND, name);
1319
        return -1;
1320
    }
1321

    
1322
    vc->link_down = !up;
1323

    
1324
    if (vc->info->link_status_changed) {
1325
        vc->info->link_status_changed(vc);
1326
    }
1327

    
1328
    /* Notify peer. Don't update peer link status: this makes it possible to
1329
     * disconnect from host network without notifying the guest.
1330
     * FIXME: is disconnected link status change operation useful?
1331
     *
1332
     * Current behaviour is compatible with qemu vlans where there could be
1333
     * multiple clients that can still communicate with each other in
1334
     * disconnected mode. For now maintain this compatibility. */
1335
    if (vc->peer && vc->peer->info->link_status_changed) {
1336
        vc->peer->info->link_status_changed(vc->peer);
1337
    }
1338
    return 0;
1339
}
1340

    
1341
void net_cleanup(void)
1342
{
1343
    VLANState *vlan;
1344
    VLANClientState *vc, *next_vc;
1345

    
1346
    QTAILQ_FOREACH(vlan, &vlans, next) {
1347
        QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1348
            qemu_del_vlan_client(vc);
1349
        }
1350
    }
1351

    
1352
    QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1353
        qemu_del_vlan_client(vc);
1354
    }
1355
}
1356

    
1357
void net_check_clients(void)
1358
{
1359
    VLANState *vlan;
1360
    VLANClientState *vc;
1361
    int has_nic = 0, has_host_dev = 0;
1362

    
1363
    QTAILQ_FOREACH(vlan, &vlans, next) {
1364
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
1365
            switch (vc->info->type) {
1366
            case NET_CLIENT_TYPE_NIC:
1367
                has_nic = 1;
1368
                break;
1369
            case NET_CLIENT_TYPE_SLIRP:
1370
            case NET_CLIENT_TYPE_TAP:
1371
            case NET_CLIENT_TYPE_SOCKET:
1372
            case NET_CLIENT_TYPE_VDE:
1373
                has_host_dev = 1;
1374
                break;
1375
            default: ;
1376
            }
1377
        }
1378
        if (has_host_dev && !has_nic)
1379
            fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1380
        if (has_nic && !has_host_dev)
1381
            fprintf(stderr,
1382
                    "Warning: vlan %d is not connected to host network\n",
1383
                    vlan->id);
1384
    }
1385
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1386
        if (!vc->peer) {
1387
            fprintf(stderr, "Warning: %s %s has no peer\n",
1388
                    vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1389
                    vc->name);
1390
        }
1391
    }
1392
}
1393

    
1394
static int net_init_client(QemuOpts *opts, void *dummy)
1395
{
1396
    if (net_client_init(NULL, opts, 0) < 0)
1397
        return -1;
1398
    return 0;
1399
}
1400

    
1401
static int net_init_netdev(QemuOpts *opts, void *dummy)
1402
{
1403
    return net_client_init(NULL, opts, 1);
1404
}
1405

    
1406
int net_init_clients(void)
1407
{
1408
    QemuOptsList *net = qemu_find_opts("net");
1409

    
1410
    if (default_net) {
1411
        /* if no clients, we use a default config */
1412
        qemu_opts_set(net, NULL, "type", "nic");
1413
#ifdef CONFIG_SLIRP
1414
        qemu_opts_set(net, NULL, "type", "user");
1415
#endif
1416
    }
1417

    
1418
    QTAILQ_INIT(&vlans);
1419
    QTAILQ_INIT(&non_vlan_clients);
1420

    
1421
    if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1422
        return -1;
1423

    
1424
    if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1425
        return -1;
1426
    }
1427

    
1428
    return 0;
1429
}
1430

    
1431
int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1432
{
1433
#if defined(CONFIG_SLIRP)
1434
    int ret;
1435
    if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1436
        return ret;
1437
    }
1438
#endif
1439

    
1440
    if (!qemu_opts_parse(opts_list, optarg, 1)) {
1441
        return -1;
1442
    }
1443

    
1444
    default_net = 0;
1445
    return 0;
1446
}