Statistics
| Branch: | Revision:

root / net.c @ f68b9d67

History | View | Annotate | Download (38.5 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
#include "iov.h"
40

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

    
44
int default_net = 1;
45

    
46
/***********************************************************/
47
/* network device redirectors */
48

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

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

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

    
97
int parse_host_port(struct sockaddr_in *saddr, const char *str)
98
{
99
    char buf[512];
100
    struct hostent *he;
101
    const char *p, *r;
102
    int port;
103

    
104
    p = str;
105
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
106
        return -1;
107
    saddr->sin_family = AF_INET;
108
    if (buf[0] == '\0') {
109
        saddr->sin_addr.s_addr = 0;
110
    } else {
111
        if (qemu_isdigit(buf[0])) {
112
            if (!inet_aton(buf, &saddr->sin_addr))
113
                return -1;
114
        } else {
115
            if ((he = gethostbyname(buf)) == NULL)
116
                return - 1;
117
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
118
        }
119
    }
120
    port = strtol(p, (char **)&r, 0);
121
    if (r == p)
122
        return -1;
123
    saddr->sin_port = htons(port);
124
    return 0;
125
}
126

    
127
void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
128
{
129
    snprintf(vc->info_str, sizeof(vc->info_str),
130
             "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
131
             vc->model,
132
             macaddr[0], macaddr[1], macaddr[2],
133
             macaddr[3], macaddr[4], macaddr[5]);
134
}
135

    
136
void qemu_macaddr_default_if_unset(MACAddr *macaddr)
137
{
138
    static int index = 0;
139
    static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
140

    
141
    if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
142
        return;
143
    macaddr->a[0] = 0x52;
144
    macaddr->a[1] = 0x54;
145
    macaddr->a[2] = 0x00;
146
    macaddr->a[3] = 0x12;
147
    macaddr->a[4] = 0x34;
148
    macaddr->a[5] = 0x56 + index++;
149
}
150

    
151
static char *assign_name(VLANClientState *vc1, const char *model)
152
{
153
    VLANState *vlan;
154
    char buf[256];
155
    int id = 0;
156

    
157
    QTAILQ_FOREACH(vlan, &vlans, next) {
158
        VLANClientState *vc;
159

    
160
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
161
            if (vc != vc1 && strcmp(vc->model, model) == 0) {
162
                id++;
163
            }
164
        }
165
    }
166

    
167
    snprintf(buf, sizeof(buf), "%s.%d", model, id);
168

    
169
    return qemu_strdup(buf);
170
}
171

    
172
static ssize_t qemu_deliver_packet(VLANClientState *sender,
173
                                   unsigned flags,
174
                                   const uint8_t *data,
175
                                   size_t size,
176
                                   void *opaque);
177
static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
178
                                       unsigned flags,
179
                                       const struct iovec *iov,
180
                                       int iovcnt,
181
                                       void *opaque);
182

    
183
VLANClientState *qemu_new_net_client(NetClientInfo *info,
184
                                     VLANState *vlan,
185
                                     VLANClientState *peer,
186
                                     const char *model,
187
                                     const char *name)
188
{
189
    VLANClientState *vc;
190

    
191
    assert(info->size >= sizeof(VLANClientState));
192

    
193
    vc = qemu_mallocz(info->size);
194

    
195
    vc->info = info;
196
    vc->model = qemu_strdup(model);
197
    if (name) {
198
        vc->name = qemu_strdup(name);
199
    } else {
200
        vc->name = assign_name(vc, model);
201
    }
202

    
203
    if (vlan) {
204
        assert(!peer);
205
        vc->vlan = vlan;
206
        QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
207
    } else {
208
        if (peer) {
209
            assert(!peer->peer);
210
            vc->peer = peer;
211
            peer->peer = vc;
212
        }
213
        QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
214

    
215
        vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
216
                                            qemu_deliver_packet_iov,
217
                                            vc);
218
    }
219

    
220
    return vc;
221
}
222

    
223
NICState *qemu_new_nic(NetClientInfo *info,
224
                       NICConf *conf,
225
                       const char *model,
226
                       const char *name,
227
                       void *opaque)
228
{
229
    VLANClientState *nc;
230
    NICState *nic;
231

    
232
    assert(info->type == NET_CLIENT_TYPE_NIC);
233
    assert(info->size >= sizeof(NICState));
234

    
235
    nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
236

    
237
    nic = DO_UPCAST(NICState, nc, nc);
238
    nic->conf = conf;
239
    nic->opaque = opaque;
240

    
241
    return nic;
242
}
243

    
244
static void qemu_cleanup_vlan_client(VLANClientState *vc)
245
{
246
    if (vc->vlan) {
247
        QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
248
    } else {
249
        QTAILQ_REMOVE(&non_vlan_clients, vc, next);
250
    }
251

    
252
    if (vc->info->cleanup) {
253
        vc->info->cleanup(vc);
254
    }
255
}
256

    
257
static void qemu_free_vlan_client(VLANClientState *vc)
258
{
259
    if (!vc->vlan) {
260
        if (vc->send_queue) {
261
            qemu_del_net_queue(vc->send_queue);
262
        }
263
        if (vc->peer) {
264
            vc->peer->peer = NULL;
265
        }
266
    }
267
    qemu_free(vc->name);
268
    qemu_free(vc->model);
269
    qemu_free(vc);
270
}
271

    
272
void qemu_del_vlan_client(VLANClientState *vc)
273
{
274
    /* If there is a peer NIC, delete and cleanup client, but do not free. */
275
    if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
276
        NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
277
        if (nic->peer_deleted) {
278
            return;
279
        }
280
        nic->peer_deleted = true;
281
        /* Let NIC know peer is gone. */
282
        vc->peer->link_down = true;
283
        if (vc->peer->info->link_status_changed) {
284
            vc->peer->info->link_status_changed(vc->peer);
285
        }
286
        qemu_cleanup_vlan_client(vc);
287
        return;
288
    }
289

    
290
    /* If this is a peer NIC and peer has already been deleted, free it now. */
291
    if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
292
        NICState *nic = DO_UPCAST(NICState, nc, vc);
293
        if (nic->peer_deleted) {
294
            qemu_free_vlan_client(vc->peer);
295
        }
296
    }
297

    
298
    qemu_cleanup_vlan_client(vc);
299
    qemu_free_vlan_client(vc);
300
}
301

    
302
VLANClientState *
303
qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
304
                              const char *client_str)
305
{
306
    VLANState *vlan;
307
    VLANClientState *vc;
308

    
309
    vlan = qemu_find_vlan(vlan_id, 0);
310
    if (!vlan) {
311
        monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
312
        return NULL;
313
    }
314

    
315
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
316
        if (!strcmp(vc->name, client_str)) {
317
            break;
318
        }
319
    }
320
    if (!vc) {
321
        monitor_printf(mon, "can't find device %s on VLAN %d\n",
322
                       client_str, vlan_id);
323
    }
324

    
325
    return vc;
326
}
327

    
328
void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
329
{
330
    VLANClientState *nc;
331
    VLANState *vlan;
332

    
333
    QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
334
        if (nc->info->type == NET_CLIENT_TYPE_NIC) {
335
            func(DO_UPCAST(NICState, nc, nc), opaque);
336
        }
337
    }
338

    
339
    QTAILQ_FOREACH(vlan, &vlans, next) {
340
        QTAILQ_FOREACH(nc, &vlan->clients, next) {
341
            if (nc->info->type == NET_CLIENT_TYPE_NIC) {
342
                func(DO_UPCAST(NICState, nc, nc), opaque);
343
            }
344
        }
345
    }
346
}
347

    
348
int qemu_can_send_packet(VLANClientState *sender)
349
{
350
    VLANState *vlan = sender->vlan;
351
    VLANClientState *vc;
352

    
353
    if (sender->peer) {
354
        if (sender->peer->receive_disabled) {
355
            return 0;
356
        } else if (sender->peer->info->can_receive &&
357
                   !sender->peer->info->can_receive(sender->peer)) {
358
            return 0;
359
        } else {
360
            return 1;
361
        }
362
    }
363

    
364
    if (!sender->vlan) {
365
        return 1;
366
    }
367

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

    
373
        /* no can_receive() handler, they can always receive */
374
        if (vc->info->can_receive && !vc->info->can_receive(vc)) {
375
            return 0;
376
        }
377
    }
378
    return 1;
379
}
380

    
381
static ssize_t qemu_deliver_packet(VLANClientState *sender,
382
                                   unsigned flags,
383
                                   const uint8_t *data,
384
                                   size_t size,
385
                                   void *opaque)
386
{
387
    VLANClientState *vc = opaque;
388
    ssize_t ret;
389

    
390
    if (vc->link_down) {
391
        return size;
392
    }
393

    
394
    if (vc->receive_disabled) {
395
        return 0;
396
    }
397

    
398
    if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
399
        ret = vc->info->receive_raw(vc, data, size);
400
    } else {
401
        ret = vc->info->receive(vc, data, size);
402
    }
403

    
404
    if (ret == 0) {
405
        vc->receive_disabled = 1;
406
    };
407

    
408
    return ret;
409
}
410

    
411
static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
412
                                        unsigned flags,
413
                                        const uint8_t *buf,
414
                                        size_t size,
415
                                        void *opaque)
416
{
417
    VLANState *vlan = opaque;
418
    VLANClientState *vc;
419
    ssize_t ret = -1;
420

    
421
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
422
        ssize_t len;
423

    
424
        if (vc == sender) {
425
            continue;
426
        }
427

    
428
        if (vc->link_down) {
429
            ret = size;
430
            continue;
431
        }
432

    
433
        if (vc->receive_disabled) {
434
            ret = 0;
435
            continue;
436
        }
437

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

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

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

    
450
    }
451

    
452
    return ret;
453
}
454

    
455
void qemu_purge_queued_packets(VLANClientState *vc)
456
{
457
    NetQueue *queue;
458

    
459
    if (!vc->peer && !vc->vlan) {
460
        return;
461
    }
462

    
463
    if (vc->peer) {
464
        queue = vc->peer->send_queue;
465
    } else {
466
        queue = vc->vlan->send_queue;
467
    }
468

    
469
    qemu_net_queue_purge(queue, vc);
470
}
471

    
472
void qemu_flush_queued_packets(VLANClientState *vc)
473
{
474
    NetQueue *queue;
475

    
476
    vc->receive_disabled = 0;
477

    
478
    if (vc->vlan) {
479
        queue = vc->vlan->send_queue;
480
    } else {
481
        queue = vc->send_queue;
482
    }
483

    
484
    qemu_net_queue_flush(queue);
485
}
486

    
487
static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
488
                                                 unsigned flags,
489
                                                 const uint8_t *buf, int size,
490
                                                 NetPacketSent *sent_cb)
491
{
492
    NetQueue *queue;
493

    
494
#ifdef DEBUG_NET
495
    printf("qemu_send_packet_async:\n");
496
    hex_dump(stdout, buf, size);
497
#endif
498

    
499
    if (sender->link_down || (!sender->peer && !sender->vlan)) {
500
        return size;
501
    }
502

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

    
509
    return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
510
}
511

    
512
ssize_t qemu_send_packet_async(VLANClientState *sender,
513
                               const uint8_t *buf, int size,
514
                               NetPacketSent *sent_cb)
515
{
516
    return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
517
                                             buf, size, sent_cb);
518
}
519

    
520
void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
521
{
522
    qemu_send_packet_async(vc, buf, size, NULL);
523
}
524

    
525
ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
526
{
527
    return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
528
                                             buf, size, NULL);
529
}
530

    
531
static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
532
                               int iovcnt)
533
{
534
    uint8_t buffer[4096];
535
    size_t offset;
536

    
537
    offset = iov_to_buf(iov, iovcnt, buffer, 0, sizeof(buffer));
538

    
539
    return vc->info->receive(vc, buffer, offset);
540
}
541

    
542
static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
543
                                       unsigned flags,
544
                                       const struct iovec *iov,
545
                                       int iovcnt,
546
                                       void *opaque)
547
{
548
    VLANClientState *vc = opaque;
549

    
550
    if (vc->link_down) {
551
        return iov_size(iov, iovcnt);
552
    }
553

    
554
    if (vc->info->receive_iov) {
555
        return vc->info->receive_iov(vc, iov, iovcnt);
556
    } else {
557
        return vc_sendv_compat(vc, iov, iovcnt);
558
    }
559
}
560

    
561
static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
562
                                            unsigned flags,
563
                                            const struct iovec *iov,
564
                                            int iovcnt,
565
                                            void *opaque)
566
{
567
    VLANState *vlan = opaque;
568
    VLANClientState *vc;
569
    ssize_t ret = -1;
570

    
571
    QTAILQ_FOREACH(vc, &vlan->clients, next) {
572
        ssize_t len;
573

    
574
        if (vc == sender) {
575
            continue;
576
        }
577

    
578
        if (vc->link_down) {
579
            ret = iov_size(iov, iovcnt);
580
            continue;
581
        }
582

    
583
        assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
584

    
585
        if (vc->info->receive_iov) {
586
            len = vc->info->receive_iov(vc, iov, iovcnt);
587
        } else {
588
            len = vc_sendv_compat(vc, iov, iovcnt);
589
        }
590

    
591
        ret = (ret >= 0) ? ret : len;
592
    }
593

    
594
    return ret;
595
}
596

    
597
ssize_t qemu_sendv_packet_async(VLANClientState *sender,
598
                                const struct iovec *iov, int iovcnt,
599
                                NetPacketSent *sent_cb)
600
{
601
    NetQueue *queue;
602

    
603
    if (sender->link_down || (!sender->peer && !sender->vlan)) {
604
        return iov_size(iov, iovcnt);
605
    }
606

    
607
    if (sender->peer) {
608
        queue = sender->peer->send_queue;
609
    } else {
610
        queue = sender->vlan->send_queue;
611
    }
612

    
613
    return qemu_net_queue_send_iov(queue, sender,
614
                                   QEMU_NET_PACKET_FLAG_NONE,
615
                                   iov, iovcnt, sent_cb);
616
}
617

    
618
ssize_t
619
qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
620
{
621
    return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
622
}
623

    
624
/* find or alloc a new VLAN */
625
VLANState *qemu_find_vlan(int id, int allocate)
626
{
627
    VLANState *vlan;
628

    
629
    QTAILQ_FOREACH(vlan, &vlans, next) {
630
        if (vlan->id == id) {
631
            return vlan;
632
        }
633
    }
634

    
635
    if (!allocate) {
636
        return NULL;
637
    }
638

    
639
    vlan = qemu_mallocz(sizeof(VLANState));
640
    vlan->id = id;
641
    QTAILQ_INIT(&vlan->clients);
642

    
643
    vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
644
                                          qemu_vlan_deliver_packet_iov,
645
                                          vlan);
646

    
647
    QTAILQ_INSERT_TAIL(&vlans, vlan, next);
648

    
649
    return vlan;
650
}
651

    
652
VLANClientState *qemu_find_netdev(const char *id)
653
{
654
    VLANClientState *vc;
655

    
656
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
657
        if (!strcmp(vc->name, id)) {
658
            return vc;
659
        }
660
    }
661

    
662
    return NULL;
663
}
664

    
665
static int nic_get_free_idx(void)
666
{
667
    int index;
668

    
669
    for (index = 0; index < MAX_NICS; index++)
670
        if (!nd_table[index].used)
671
            return index;
672
    return -1;
673
}
674

    
675
int qemu_show_nic_models(const char *arg, const char *const *models)
676
{
677
    int i;
678

    
679
    if (!arg || strcmp(arg, "?"))
680
        return 0;
681

    
682
    fprintf(stderr, "qemu: Supported NIC models: ");
683
    for (i = 0 ; models[i]; i++)
684
        fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
685
    return 1;
686
}
687

    
688
void qemu_check_nic_model(NICInfo *nd, const char *model)
689
{
690
    const char *models[2];
691

    
692
    models[0] = model;
693
    models[1] = NULL;
694

    
695
    if (qemu_show_nic_models(nd->model, models))
696
        exit(0);
697
    if (qemu_find_nic_model(nd, models, model) < 0)
698
        exit(1);
699
}
700

    
701
int qemu_find_nic_model(NICInfo *nd, const char * const *models,
702
                        const char *default_model)
703
{
704
    int i;
705

    
706
    if (!nd->model)
707
        nd->model = qemu_strdup(default_model);
708

    
709
    for (i = 0 ; models[i]; i++) {
710
        if (strcmp(nd->model, models[i]) == 0)
711
            return i;
712
    }
713

    
714
    error_report("qemu: Unsupported NIC model: %s", nd->model);
715
    return -1;
716
}
717

    
718
int net_handle_fd_param(Monitor *mon, const char *param)
719
{
720
    int fd;
721

    
722
    if (!qemu_isdigit(param[0]) && mon) {
723

    
724
        fd = monitor_get_fd(mon, param);
725
        if (fd == -1) {
726
            error_report("No file descriptor named %s found", param);
727
            return -1;
728
        }
729
    } else {
730
        char *endptr = NULL;
731

    
732
        fd = strtol(param, &endptr, 10);
733
        if (*endptr || (fd == 0 && param == endptr)) {
734
            return -1;
735
        }
736
    }
737

    
738
    return fd;
739
}
740

    
741
static int net_init_nic(QemuOpts *opts,
742
                        Monitor *mon,
743
                        const char *name,
744
                        VLANState *vlan)
745
{
746
    int idx;
747
    NICInfo *nd;
748
    const char *netdev;
749

    
750
    idx = nic_get_free_idx();
751
    if (idx == -1 || nb_nics >= MAX_NICS) {
752
        error_report("Too Many NICs");
753
        return -1;
754
    }
755

    
756
    nd = &nd_table[idx];
757

    
758
    memset(nd, 0, sizeof(*nd));
759

    
760
    if ((netdev = qemu_opt_get(opts, "netdev"))) {
761
        nd->netdev = qemu_find_netdev(netdev);
762
        if (!nd->netdev) {
763
            error_report("netdev '%s' not found", netdev);
764
            return -1;
765
        }
766
    } else {
767
        assert(vlan);
768
        nd->vlan = vlan;
769
    }
770
    if (name) {
771
        nd->name = qemu_strdup(name);
772
    }
773
    if (qemu_opt_get(opts, "model")) {
774
        nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
775
    }
776
    if (qemu_opt_get(opts, "addr")) {
777
        nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
778
    }
779

    
780
    nd->macaddr[0] = 0x52;
781
    nd->macaddr[1] = 0x54;
782
    nd->macaddr[2] = 0x00;
783
    nd->macaddr[3] = 0x12;
784
    nd->macaddr[4] = 0x34;
785
    nd->macaddr[5] = 0x56 + idx;
786

    
787
    if (qemu_opt_get(opts, "macaddr") &&
788
        net_parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
789
        error_report("invalid syntax for ethernet address");
790
        return -1;
791
    }
792

    
793
    nd->nvectors = qemu_opt_get_number(opts, "vectors",
794
                                       DEV_NVECTORS_UNSPECIFIED);
795
    if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
796
        (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
797
        error_report("invalid # of vectors: %d", nd->nvectors);
798
        return -1;
799
    }
800

    
801
    nd->used = 1;
802
    nb_nics++;
803

    
804
    return idx;
805
}
806

    
807
#define NET_COMMON_PARAMS_DESC                     \
808
    {                                              \
809
        .name = "type",                            \
810
        .type = QEMU_OPT_STRING,                   \
811
        .help = "net client type (nic, tap etc.)", \
812
     }, {                                          \
813
        .name = "vlan",                            \
814
        .type = QEMU_OPT_NUMBER,                   \
815
        .help = "vlan number",                     \
816
     }, {                                          \
817
        .name = "name",                            \
818
        .type = QEMU_OPT_STRING,                   \
819
        .help = "identifier for monitor commands", \
820
     }
821

    
822
typedef int (*net_client_init_func)(QemuOpts *opts,
823
                                    Monitor *mon,
824
                                    const char *name,
825
                                    VLANState *vlan);
826

    
827
/* magic number, but compiler will warn if too small */
828
#define NET_MAX_DESC 20
829

    
830
static const struct {
831
    const char *type;
832
    net_client_init_func init;
833
    QemuOptDesc desc[NET_MAX_DESC];
834
} net_client_types[] = {
835
    {
836
        .type = "none",
837
        .desc = {
838
            NET_COMMON_PARAMS_DESC,
839
            { /* end of list */ }
840
        },
841
    }, {
842
        .type = "nic",
843
        .init = net_init_nic,
844
        .desc = {
845
            NET_COMMON_PARAMS_DESC,
846
            {
847
                .name = "netdev",
848
                .type = QEMU_OPT_STRING,
849
                .help = "id of -netdev to connect to",
850
            },
851
            {
852
                .name = "macaddr",
853
                .type = QEMU_OPT_STRING,
854
                .help = "MAC address",
855
            }, {
856
                .name = "model",
857
                .type = QEMU_OPT_STRING,
858
                .help = "device model (e1000, rtl8139, virtio etc.)",
859
            }, {
860
                .name = "addr",
861
                .type = QEMU_OPT_STRING,
862
                .help = "PCI device address",
863
            }, {
864
                .name = "vectors",
865
                .type = QEMU_OPT_NUMBER,
866
                .help = "number of MSI-x vectors, 0 to disable MSI-X",
867
            },
868
            { /* end of list */ }
869
        },
870
#ifdef CONFIG_SLIRP
871
    }, {
872
        .type = "user",
873
        .init = net_init_slirp,
874
        .desc = {
875
            NET_COMMON_PARAMS_DESC,
876
            {
877
                .name = "hostname",
878
                .type = QEMU_OPT_STRING,
879
                .help = "client hostname reported by the builtin DHCP server",
880
            }, {
881
                .name = "restrict",
882
                .type = QEMU_OPT_STRING,
883
                .help = "isolate the guest from the host (y|yes|n|no)",
884
            }, {
885
                .name = "ip",
886
                .type = QEMU_OPT_STRING,
887
                .help = "legacy parameter, use net= instead",
888
            }, {
889
                .name = "net",
890
                .type = QEMU_OPT_STRING,
891
                .help = "IP address and optional netmask",
892
            }, {
893
                .name = "host",
894
                .type = QEMU_OPT_STRING,
895
                .help = "guest-visible address of the host",
896
            }, {
897
                .name = "tftp",
898
                .type = QEMU_OPT_STRING,
899
                .help = "root directory of the built-in TFTP server",
900
            }, {
901
                .name = "bootfile",
902
                .type = QEMU_OPT_STRING,
903
                .help = "BOOTP filename, for use with tftp=",
904
            }, {
905
                .name = "dhcpstart",
906
                .type = QEMU_OPT_STRING,
907
                .help = "the first of the 16 IPs the built-in DHCP server can assign",
908
            }, {
909
                .name = "dns",
910
                .type = QEMU_OPT_STRING,
911
                .help = "guest-visible address of the virtual nameserver",
912
            }, {
913
                .name = "smb",
914
                .type = QEMU_OPT_STRING,
915
                .help = "root directory of the built-in SMB server",
916
            }, {
917
                .name = "smbserver",
918
                .type = QEMU_OPT_STRING,
919
                .help = "IP address of the built-in SMB server",
920
            }, {
921
                .name = "hostfwd",
922
                .type = QEMU_OPT_STRING,
923
                .help = "guest port number to forward incoming TCP or UDP connections",
924
            }, {
925
                .name = "guestfwd",
926
                .type = QEMU_OPT_STRING,
927
                .help = "IP address and port to forward guest TCP connections",
928
            },
929
            { /* end of list */ }
930
        },
931
#endif
932
    }, {
933
        .type = "tap",
934
        .init = net_init_tap,
935
        .desc = {
936
            NET_COMMON_PARAMS_DESC,
937
            {
938
                .name = "ifname",
939
                .type = QEMU_OPT_STRING,
940
                .help = "interface name",
941
            },
942
#ifndef _WIN32
943
            {
944
                .name = "fd",
945
                .type = QEMU_OPT_STRING,
946
                .help = "file descriptor of an already opened tap",
947
            }, {
948
                .name = "script",
949
                .type = QEMU_OPT_STRING,
950
                .help = "script to initialize the interface",
951
            }, {
952
                .name = "downscript",
953
                .type = QEMU_OPT_STRING,
954
                .help = "script to shut down the interface",
955
            }, {
956
                .name = "sndbuf",
957
                .type = QEMU_OPT_SIZE,
958
                .help = "send buffer limit"
959
            }, {
960
                .name = "vnet_hdr",
961
                .type = QEMU_OPT_BOOL,
962
                .help = "enable the IFF_VNET_HDR flag on the tap interface"
963
            }, {
964
                .name = "vhost",
965
                .type = QEMU_OPT_BOOL,
966
                .help = "enable vhost-net network accelerator",
967
            }, {
968
                .name = "vhostfd",
969
                .type = QEMU_OPT_STRING,
970
                .help = "file descriptor of an already opened vhost net device",
971
            }, {
972
                .name = "vhostforce",
973
                .type = QEMU_OPT_BOOL,
974
                .help = "force vhost on for non-MSIX virtio guests",
975
        },
976
#endif /* _WIN32 */
977
            { /* end of list */ }
978
        },
979
    }, {
980
        .type = "socket",
981
        .init = net_init_socket,
982
        .desc = {
983
            NET_COMMON_PARAMS_DESC,
984
            {
985
                .name = "fd",
986
                .type = QEMU_OPT_STRING,
987
                .help = "file descriptor of an already opened socket",
988
            }, {
989
                .name = "listen",
990
                .type = QEMU_OPT_STRING,
991
                .help = "port number, and optional hostname, to listen on",
992
            }, {
993
                .name = "connect",
994
                .type = QEMU_OPT_STRING,
995
                .help = "port number, and optional hostname, to connect to",
996
            }, {
997
                .name = "mcast",
998
                .type = QEMU_OPT_STRING,
999
                .help = "UDP multicast address and port number",
1000
            }, {
1001
                .name = "localaddr",
1002
                .type = QEMU_OPT_STRING,
1003
                .help = "source address for multicast packets",
1004
            },
1005
            { /* end of list */ }
1006
        },
1007
#ifdef CONFIG_VDE
1008
    }, {
1009
        .type = "vde",
1010
        .init = net_init_vde,
1011
        .desc = {
1012
            NET_COMMON_PARAMS_DESC,
1013
            {
1014
                .name = "sock",
1015
                .type = QEMU_OPT_STRING,
1016
                .help = "socket path",
1017
            }, {
1018
                .name = "port",
1019
                .type = QEMU_OPT_NUMBER,
1020
                .help = "port number",
1021
            }, {
1022
                .name = "group",
1023
                .type = QEMU_OPT_STRING,
1024
                .help = "group owner of socket",
1025
            }, {
1026
                .name = "mode",
1027
                .type = QEMU_OPT_NUMBER,
1028
                .help = "permissions for socket",
1029
            },
1030
            { /* end of list */ }
1031
        },
1032
#endif
1033
    }, {
1034
        .type = "dump",
1035
        .init = net_init_dump,
1036
        .desc = {
1037
            NET_COMMON_PARAMS_DESC,
1038
            {
1039
                .name = "len",
1040
                .type = QEMU_OPT_SIZE,
1041
                .help = "per-packet size limit (64k default)",
1042
            }, {
1043
                .name = "file",
1044
                .type = QEMU_OPT_STRING,
1045
                .help = "dump file path (default is qemu-vlan0.pcap)",
1046
            },
1047
            { /* end of list */ }
1048
        },
1049
    },
1050
    { /* end of list */ }
1051
};
1052

    
1053
int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
1054
{
1055
    const char *name;
1056
    const char *type;
1057
    int i;
1058

    
1059
    type = qemu_opt_get(opts, "type");
1060
    if (!type) {
1061
        qerror_report(QERR_MISSING_PARAMETER, "type");
1062
        return -1;
1063
    }
1064

    
1065
    if (is_netdev) {
1066
        if (strcmp(type, "tap") != 0 &&
1067
#ifdef CONFIG_SLIRP
1068
            strcmp(type, "user") != 0 &&
1069
#endif
1070
#ifdef CONFIG_VDE
1071
            strcmp(type, "vde") != 0 &&
1072
#endif
1073
            strcmp(type, "socket") != 0) {
1074
            qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1075
                          "a netdev backend type");
1076
            return -1;
1077
        }
1078

    
1079
        if (qemu_opt_get(opts, "vlan")) {
1080
            qerror_report(QERR_INVALID_PARAMETER, "vlan");
1081
            return -1;
1082
        }
1083
        if (qemu_opt_get(opts, "name")) {
1084
            qerror_report(QERR_INVALID_PARAMETER, "name");
1085
            return -1;
1086
        }
1087
        if (!qemu_opts_id(opts)) {
1088
            qerror_report(QERR_MISSING_PARAMETER, "id");
1089
            return -1;
1090
        }
1091
    }
1092

    
1093
    name = qemu_opts_id(opts);
1094
    if (!name) {
1095
        name = qemu_opt_get(opts, "name");
1096
    }
1097

    
1098
    for (i = 0; net_client_types[i].type != NULL; i++) {
1099
        if (!strcmp(net_client_types[i].type, type)) {
1100
            VLANState *vlan = NULL;
1101
            int ret;
1102

    
1103
            if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
1104
                return -1;
1105
            }
1106

    
1107
            /* Do not add to a vlan if it's a -netdev or a nic with a
1108
             * netdev= parameter. */
1109
            if (!(is_netdev ||
1110
                  (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1111
                vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1112
            }
1113

    
1114
            ret = 0;
1115
            if (net_client_types[i].init) {
1116
                ret = net_client_types[i].init(opts, mon, name, vlan);
1117
                if (ret < 0) {
1118
                    /* TODO push error reporting into init() methods */
1119
                    qerror_report(QERR_DEVICE_INIT_FAILED, type);
1120
                    return -1;
1121
                }
1122
            }
1123
            return ret;
1124
        }
1125
    }
1126

    
1127
    qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1128
                  "a network client type");
1129
    return -1;
1130
}
1131

    
1132
static int net_host_check_device(const char *device)
1133
{
1134
    int i;
1135
    const char *valid_param_list[] = { "tap", "socket", "dump"
1136
#ifdef CONFIG_SLIRP
1137
                                       ,"user"
1138
#endif
1139
#ifdef CONFIG_VDE
1140
                                       ,"vde"
1141
#endif
1142
    };
1143
    for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1144
        if (!strncmp(valid_param_list[i], device,
1145
                     strlen(valid_param_list[i])))
1146
            return 1;
1147
    }
1148

    
1149
    return 0;
1150
}
1151

    
1152
void net_host_device_add(Monitor *mon, const QDict *qdict)
1153
{
1154
    const char *device = qdict_get_str(qdict, "device");
1155
    const char *opts_str = qdict_get_try_str(qdict, "opts");
1156
    QemuOpts *opts;
1157

    
1158
    if (!net_host_check_device(device)) {
1159
        monitor_printf(mon, "invalid host network device %s\n", device);
1160
        return;
1161
    }
1162

    
1163
    opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
1164
    if (!opts) {
1165
        return;
1166
    }
1167

    
1168
    qemu_opt_set(opts, "type", device);
1169

    
1170
    if (net_client_init(mon, opts, 0) < 0) {
1171
        monitor_printf(mon, "adding host network device %s failed\n", device);
1172
    }
1173
}
1174

    
1175
void net_host_device_remove(Monitor *mon, const QDict *qdict)
1176
{
1177
    VLANClientState *vc;
1178
    int vlan_id = qdict_get_int(qdict, "vlan_id");
1179
    const char *device = qdict_get_str(qdict, "device");
1180

    
1181
    vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1182
    if (!vc) {
1183
        return;
1184
    }
1185
    if (!net_host_check_device(vc->model)) {
1186
        monitor_printf(mon, "invalid host network device %s\n", device);
1187
        return;
1188
    }
1189
    qemu_del_vlan_client(vc);
1190
}
1191

    
1192
int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
1193
{
1194
    QemuOpts *opts;
1195
    int res;
1196

    
1197
    opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict);
1198
    if (!opts) {
1199
        return -1;
1200
    }
1201

    
1202
    res = net_client_init(mon, opts, 1);
1203
    if (res < 0) {
1204
        qemu_opts_del(opts);
1205
    }
1206

    
1207
    return res;
1208
}
1209

    
1210
int do_netdev_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1211
{
1212
    const char *id = qdict_get_str(qdict, "id");
1213
    VLANClientState *vc;
1214

    
1215
    vc = qemu_find_netdev(id);
1216
    if (!vc || vc->info->type == NET_CLIENT_TYPE_NIC) {
1217
        qerror_report(QERR_DEVICE_NOT_FOUND, id);
1218
        return -1;
1219
    }
1220
    qemu_del_vlan_client(vc);
1221
    qemu_opts_del(qemu_opts_find(qemu_find_opts("netdev"), id));
1222
    return 0;
1223
}
1224

    
1225
void do_info_network(Monitor *mon)
1226
{
1227
    VLANState *vlan;
1228
    VLANClientState *vc;
1229

    
1230
    QTAILQ_FOREACH(vlan, &vlans, next) {
1231
        monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1232

    
1233
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
1234
            monitor_printf(mon, "  %s: %s\n", vc->name, vc->info_str);
1235
        }
1236
    }
1237
    monitor_printf(mon, "Devices not on any VLAN:\n");
1238
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1239
        monitor_printf(mon, "  %s: %s", vc->name, vc->info_str);
1240
        if (vc->peer) {
1241
            monitor_printf(mon, " peer=%s", vc->peer->name);
1242
        }
1243
        monitor_printf(mon, "\n");
1244
    }
1245
}
1246

    
1247
int do_set_link(Monitor *mon, const QDict *qdict, QObject **ret_data)
1248
{
1249
    VLANState *vlan;
1250
    VLANClientState *vc = NULL;
1251
    const char *name = qdict_get_str(qdict, "name");
1252
    int up = qdict_get_bool(qdict, "up");
1253

    
1254
    QTAILQ_FOREACH(vlan, &vlans, next) {
1255
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
1256
            if (strcmp(vc->name, name) == 0) {
1257
                goto done;
1258
            }
1259
        }
1260
    }
1261
    vc = qemu_find_netdev(name);
1262
done:
1263

    
1264
    if (!vc) {
1265
        qerror_report(QERR_DEVICE_NOT_FOUND, name);
1266
        return -1;
1267
    }
1268

    
1269
    vc->link_down = !up;
1270

    
1271
    if (vc->info->link_status_changed) {
1272
        vc->info->link_status_changed(vc);
1273
    }
1274

    
1275
    /* Notify peer. Don't update peer link status: this makes it possible to
1276
     * disconnect from host network without notifying the guest.
1277
     * FIXME: is disconnected link status change operation useful?
1278
     *
1279
     * Current behaviour is compatible with qemu vlans where there could be
1280
     * multiple clients that can still communicate with each other in
1281
     * disconnected mode. For now maintain this compatibility. */
1282
    if (vc->peer && vc->peer->info->link_status_changed) {
1283
        vc->peer->info->link_status_changed(vc->peer);
1284
    }
1285
    return 0;
1286
}
1287

    
1288
void net_cleanup(void)
1289
{
1290
    VLANState *vlan;
1291
    VLANClientState *vc, *next_vc;
1292

    
1293
    QTAILQ_FOREACH(vlan, &vlans, next) {
1294
        QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1295
            qemu_del_vlan_client(vc);
1296
        }
1297
    }
1298

    
1299
    QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1300
        qemu_del_vlan_client(vc);
1301
    }
1302
}
1303

    
1304
void net_check_clients(void)
1305
{
1306
    VLANState *vlan;
1307
    VLANClientState *vc;
1308
    int seen_nics = 0;
1309

    
1310
    /* Don't warn about the default network setup that you get if
1311
     * no command line -net options are specified. There are two
1312
     * cases that we would otherwise complain about:
1313
     * (1) board doesn't support a NIC but the implicit "-net nic"
1314
     * requested one; we'd otherwise complain about more NICs being
1315
     * specified than we support, and also that the vlan set up by
1316
     * the implicit "-net user" didn't have any NICs connected to it
1317
     * (2) CONFIG_SLIRP not set: we'd otherwise complain about the
1318
     * implicit "-net nic" setting up a nic that wasn't connected to
1319
     * anything.
1320
     */
1321
    if (default_net) {
1322
        return;
1323
    }
1324

    
1325
    QTAILQ_FOREACH(vlan, &vlans, next) {
1326
        int has_nic = 0, has_host_dev = 0;
1327

    
1328
        QTAILQ_FOREACH(vc, &vlan->clients, next) {
1329
            switch (vc->info->type) {
1330
            case NET_CLIENT_TYPE_NIC:
1331
                seen_nics++;
1332
                has_nic = 1;
1333
                break;
1334
            case NET_CLIENT_TYPE_SLIRP:
1335
            case NET_CLIENT_TYPE_TAP:
1336
            case NET_CLIENT_TYPE_SOCKET:
1337
            case NET_CLIENT_TYPE_VDE:
1338
                has_host_dev = 1;
1339
                break;
1340
            default: ;
1341
            }
1342
        }
1343
        if (has_host_dev && !has_nic)
1344
            fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1345
        if (has_nic && !has_host_dev)
1346
            fprintf(stderr,
1347
                    "Warning: vlan %d is not connected to host network\n",
1348
                    vlan->id);
1349
    }
1350
    QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1351
        if (vc->info->type == NET_CLIENT_TYPE_NIC) {
1352
            seen_nics++;
1353
        }
1354
        if (!vc->peer) {
1355
            fprintf(stderr, "Warning: %s %s has no peer\n",
1356
                    vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1357
                    vc->name);
1358
        }
1359
    }
1360
    if (seen_nics != nb_nics) {
1361
        /* Number of NICs requested by user on command line doesn't match
1362
         * the number the model actually registered with us.
1363
         * This will generally only happen for models of embedded boards
1364
         * with no PCI bus or similar. PCI based machines can instantiate
1365
         * all requested NICs as PCI devices but usually embedded boards
1366
         * only have a single NIC.
1367
         */
1368
        fprintf(stderr, "Warning: more nics requested than this machine "
1369
                "supports; some have been ignored\n");
1370
    }
1371
}
1372

    
1373
static int net_init_client(QemuOpts *opts, void *dummy)
1374
{
1375
    if (net_client_init(NULL, opts, 0) < 0)
1376
        return -1;
1377
    return 0;
1378
}
1379

    
1380
static int net_init_netdev(QemuOpts *opts, void *dummy)
1381
{
1382
    return net_client_init(NULL, opts, 1);
1383
}
1384

    
1385
int net_init_clients(void)
1386
{
1387
    QemuOptsList *net = qemu_find_opts("net");
1388

    
1389
    if (default_net) {
1390
        /* if no clients, we use a default config */
1391
        qemu_opts_set(net, NULL, "type", "nic");
1392
#ifdef CONFIG_SLIRP
1393
        qemu_opts_set(net, NULL, "type", "user");
1394
#endif
1395
    }
1396

    
1397
    QTAILQ_INIT(&vlans);
1398
    QTAILQ_INIT(&non_vlan_clients);
1399

    
1400
    if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1401
        return -1;
1402

    
1403
    if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1404
        return -1;
1405
    }
1406

    
1407
    return 0;
1408
}
1409

    
1410
int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1411
{
1412
#if defined(CONFIG_SLIRP)
1413
    int ret;
1414
    if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1415
        return ret;
1416
    }
1417
#endif
1418

    
1419
    if (!qemu_opts_parse(opts_list, optarg, 1)) {
1420
        return -1;
1421
    }
1422

    
1423
    default_net = 0;
1424
    return 0;
1425
}