blob: 2f0ab3a121943ef67d7e318e01ddbfb212ebf858 [file] [log] [blame]
aliguori63a01ef2008-10-31 19:10:00 +00001/*
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 */
blueswir1d40cdb12009-03-07 16:52:02 +000024#include "config-host.h"
25
Paolo Bonzini1422e322012-10-24 08:43:34 +020026#include "net/net.h"
Paolo Bonzinifd9400b2012-10-24 11:27:28 +020027#include "clients.h"
28#include "hub.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020029#include "net/slirp.h"
Paolo Bonzinifd9400b2012-10-24 11:27:28 +020030#include "util.h"
Paolo Bonzinia245fc12012-09-17 18:43:51 +020031
Paolo Bonzini83c90892012-12-17 18:19:49 +010032#include "monitor/monitor.h"
Mark McLoughlin1df49e02009-11-25 18:48:58 +000033#include "qemu-common.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010034#include "qemu/sockets.h"
35#include "qemu/config-file.h"
Luiz Capitulino4b371562011-11-23 13:11:55 -020036#include "qmp-commands.h"
Amit Shah75422b02010-02-25 17:24:43 +053037#include "hw/qdev.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010038#include "qemu/iov.h"
Laszlo Ersek6687b792012-07-17 16:17:13 +020039#include "qapi-visit.h"
40#include "qapi/opts-visitor.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010041#include "qapi/dealloc-visitor.h"
blueswir1511d2b12009-03-07 15:32:56 +000042
Stefan Weil2944e4e2012-02-04 09:24:46 +010043/* Net bridge is currently not supported for W32. */
44#if !defined(_WIN32)
45# define CONFIG_NET_BRIDGE
46#endif
47
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +010048static QTAILQ_HEAD(, NetClientState) net_clients;
aliguori63a01ef2008-10-31 19:10:00 +000049
Gerd Hoffmanncb4522c2009-12-08 13:11:47 +010050int default_net = 1;
51
aliguori63a01ef2008-10-31 19:10:00 +000052/***********************************************************/
53/* network device redirectors */
54
Mark McLoughlin68ac40d2009-11-25 18:48:54 +000055#if defined(DEBUG_NET)
aliguori63a01ef2008-10-31 19:10:00 +000056static void hex_dump(FILE *f, const uint8_t *buf, int size)
57{
58 int len, i, j, c;
59
60 for(i=0;i<size;i+=16) {
61 len = size - i;
62 if (len > 16)
63 len = 16;
64 fprintf(f, "%08x ", i);
65 for(j=0;j<16;j++) {
66 if (j < len)
67 fprintf(f, " %02x", buf[i+j]);
68 else
69 fprintf(f, " ");
70 }
71 fprintf(f, " ");
72 for(j=0;j<len;j++) {
73 c = buf[i+j];
74 if (c < ' ' || c > '~')
75 c = '.';
76 fprintf(f, "%c", c);
77 }
78 fprintf(f, "\n");
79 }
80}
81#endif
82
aliguori63a01ef2008-10-31 19:10:00 +000083static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
84{
85 const char *p, *p1;
86 int len;
87 p = *pp;
88 p1 = strchr(p, sep);
89 if (!p1)
90 return -1;
91 len = p1 - p;
92 p1++;
93 if (buf_size > 0) {
94 if (len > buf_size - 1)
95 len = buf_size - 1;
96 memcpy(buf, p, len);
97 buf[len] = '\0';
98 }
99 *pp = p1;
100 return 0;
101}
102
aliguori63a01ef2008-10-31 19:10:00 +0000103int parse_host_port(struct sockaddr_in *saddr, const char *str)
104{
105 char buf[512];
106 struct hostent *he;
107 const char *p, *r;
108 int port;
109
110 p = str;
111 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
112 return -1;
113 saddr->sin_family = AF_INET;
114 if (buf[0] == '\0') {
115 saddr->sin_addr.s_addr = 0;
116 } else {
blueswir1cd390082008-11-16 13:53:32 +0000117 if (qemu_isdigit(buf[0])) {
aliguori63a01ef2008-10-31 19:10:00 +0000118 if (!inet_aton(buf, &saddr->sin_addr))
119 return -1;
120 } else {
121 if ((he = gethostbyname(buf)) == NULL)
122 return - 1;
123 saddr->sin_addr = *(struct in_addr *)he->h_addr;
124 }
125 }
126 port = strtol(p, (char **)&r, 0);
127 if (r == p)
128 return -1;
129 saddr->sin_port = htons(port);
130 return 0;
131}
132
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100133void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
aliguori7cb7434b2009-01-07 17:46:21 +0000134{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100135 snprintf(nc->info_str, sizeof(nc->info_str),
aliguori4dda4062009-01-08 19:01:37 +0000136 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100137 nc->model,
aliguori7cb7434b2009-01-07 17:46:21 +0000138 macaddr[0], macaddr[1], macaddr[2],
139 macaddr[3], macaddr[4], macaddr[5]);
140}
141
Gerd Hoffmann76d32cb2009-10-21 15:25:22 +0200142void qemu_macaddr_default_if_unset(MACAddr *macaddr)
143{
144 static int index = 0;
145 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
146
147 if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
148 return;
149 macaddr->a[0] = 0x52;
150 macaddr->a[1] = 0x54;
151 macaddr->a[2] = 0x00;
152 macaddr->a[3] = 0x12;
153 macaddr->a[4] = 0x34;
154 macaddr->a[5] = 0x56 + index++;
155}
156
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100157/**
158 * Generate a name for net client
159 *
160 * Only net clients created with the legacy -net option need this. Naming is
161 * mandatory for net clients created with -netdev.
162 */
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100163static char *assign_name(NetClientState *nc1, const char *model)
aliguori676cff22009-01-07 17:43:44 +0000164{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100165 NetClientState *nc;
aliguori676cff22009-01-07 17:43:44 +0000166 char buf[256];
167 int id = 0;
168
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100169 QTAILQ_FOREACH(nc, &net_clients, next) {
170 if (nc == nc1) {
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100171 continue;
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100172 }
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100173 /* For compatibility only bump id for net clients on a vlan */
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100174 if (strcmp(nc->model, model) == 0 &&
175 net_hub_id_for_client(nc, NULL) == 0) {
Markus Armbruster53e51d82011-06-16 18:45:36 +0200176 id++;
177 }
178 }
179
aliguori676cff22009-01-07 17:43:44 +0000180 snprintf(buf, sizeof(buf), "%s.%d", model, id);
181
Anthony Liguori7267c092011-08-20 22:09:37 -0500182 return g_strdup(buf);
aliguori676cff22009-01-07 17:43:44 +0000183}
184
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100185NetClientState *qemu_new_net_client(NetClientInfo *info,
186 NetClientState *peer,
187 const char *model,
188 const char *name)
aliguori63a01ef2008-10-31 19:10:00 +0000189{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100190 NetClientState *nc;
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100191
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100192 assert(info->size >= sizeof(NetClientState));
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100193
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100194 nc = g_malloc0(info->size);
Mark McLoughlin45460d12009-11-25 18:49:02 +0000195
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100196 nc->info = info;
197 nc->model = g_strdup(model);
Mark McLoughlin45460d12009-11-25 18:49:02 +0000198 if (name) {
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100199 nc->name = g_strdup(name);
Mark McLoughlin45460d12009-11-25 18:49:02 +0000200 } else {
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100201 nc->name = assign_name(nc, model);
Mark McLoughlin45460d12009-11-25 18:49:02 +0000202 }
aliguori63a01ef2008-10-31 19:10:00 +0000203
Stefan Hajnocziab5f3f82012-07-24 16:35:08 +0100204 if (peer) {
205 assert(!peer->peer);
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100206 nc->peer = peer;
207 peer->peer = nc;
Mark McLoughlind80b9fc2009-10-08 19:58:24 +0100208 }
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100209 QTAILQ_INSERT_TAIL(&net_clients, nc, next);
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100210
Zhi Yong Wu86a77c32012-07-24 16:35:17 +0100211 nc->send_queue = qemu_new_net_queue(nc);
aliguori63a01ef2008-10-31 19:10:00 +0000212
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100213 return nc;
aliguori63a01ef2008-10-31 19:10:00 +0000214}
215
Mark McLoughlinebef2c02009-11-25 18:49:10 +0000216NICState *qemu_new_nic(NetClientInfo *info,
217 NICConf *conf,
218 const char *model,
219 const char *name,
220 void *opaque)
221{
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100222 NetClientState *nc;
Mark McLoughlinebef2c02009-11-25 18:49:10 +0000223 NICState *nic;
224
Laszlo Ersek2be64a62012-07-17 16:17:12 +0200225 assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
Mark McLoughlinebef2c02009-11-25 18:49:10 +0000226 assert(info->size >= sizeof(NICState));
227
Stefan Hajnocziab5f3f82012-07-24 16:35:08 +0100228 nc = qemu_new_net_client(info, conf->peer, model, name);
Mark McLoughlinebef2c02009-11-25 18:49:10 +0000229
230 nic = DO_UPCAST(NICState, nc, nc);
231 nic->conf = conf;
232 nic->opaque = opaque;
233
234 return nic;
235}
236
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100237static void qemu_cleanup_net_client(NetClientState *nc)
aliguori63a01ef2008-10-31 19:10:00 +0000238{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100239 QTAILQ_REMOVE(&net_clients, nc, next);
aliguori63a01ef2008-10-31 19:10:00 +0000240
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100241 if (nc->info->cleanup) {
242 nc->info->cleanup(nc);
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100243 }
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200244}
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100245
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100246static void qemu_free_net_client(NetClientState *nc)
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200247{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100248 if (nc->send_queue) {
249 qemu_del_net_queue(nc->send_queue);
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200250 }
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100251 if (nc->peer) {
252 nc->peer->peer = NULL;
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100253 }
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100254 g_free(nc->name);
255 g_free(nc->model);
256 g_free(nc);
aliguori63a01ef2008-10-31 19:10:00 +0000257}
258
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100259void qemu_del_net_client(NetClientState *nc)
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200260{
261 /* If there is a peer NIC, delete and cleanup client, but do not free. */
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100262 if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
263 NICState *nic = DO_UPCAST(NICState, nc, nc->peer);
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200264 if (nic->peer_deleted) {
265 return;
266 }
267 nic->peer_deleted = true;
268 /* Let NIC know peer is gone. */
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100269 nc->peer->link_down = true;
270 if (nc->peer->info->link_status_changed) {
271 nc->peer->info->link_status_changed(nc->peer);
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200272 }
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100273 qemu_cleanup_net_client(nc);
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200274 return;
275 }
276
277 /* If this is a peer NIC and peer has already been deleted, free it now. */
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100278 if (nc->peer && nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
279 NICState *nic = DO_UPCAST(NICState, nc, nc);
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200280 if (nic->peer_deleted) {
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100281 qemu_free_net_client(nc->peer);
Michael S. Tsirkina083a892010-09-20 18:08:41 +0200282 }
283 }
284
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100285 qemu_cleanup_net_client(nc);
286 qemu_free_net_client(nc);
Jan Kiszka1a609522009-06-24 14:42:31 +0200287}
288
Mark McLoughlin57f9ef12009-11-25 18:49:31 +0000289void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
290{
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100291 NetClientState *nc;
Mark McLoughlin57f9ef12009-11-25 18:49:31 +0000292
Stefan Hajnoczi94878992012-07-24 16:35:12 +0100293 QTAILQ_FOREACH(nc, &net_clients, next) {
Laszlo Ersek2be64a62012-07-17 16:17:12 +0200294 if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
Mark McLoughlin57f9ef12009-11-25 18:49:31 +0000295 func(DO_UPCAST(NICState, nc, nc), opaque);
296 }
297 }
Mark McLoughlin57f9ef12009-11-25 18:49:31 +0000298}
299
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100300int qemu_can_send_packet(NetClientState *sender)
aliguori63a01ef2008-10-31 19:10:00 +0000301{
Stefan Hajnoczia005d072012-07-24 16:35:11 +0100302 if (!sender->peer) {
Mark McLoughlind80b9fc2009-10-08 19:58:24 +0100303 return 1;
304 }
305
Stefan Hajnoczia005d072012-07-24 16:35:11 +0100306 if (sender->peer->receive_disabled) {
307 return 0;
308 } else if (sender->peer->info->can_receive &&
309 !sender->peer->info->can_receive(sender->peer)) {
310 return 0;
aliguori63a01ef2008-10-31 19:10:00 +0000311 }
Vincent Palatin60c07d92011-03-02 17:25:02 -0500312 return 1;
aliguori63a01ef2008-10-31 19:10:00 +0000313}
314
Zhi Yong Wu86a77c32012-07-24 16:35:17 +0100315ssize_t qemu_deliver_packet(NetClientState *sender,
316 unsigned flags,
317 const uint8_t *data,
318 size_t size,
319 void *opaque)
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100320{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100321 NetClientState *nc = opaque;
Mark McLoughlin893379e2009-10-27 18:16:36 +0000322 ssize_t ret;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100323
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100324 if (nc->link_down) {
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100325 return size;
326 }
327
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100328 if (nc->receive_disabled) {
Mark McLoughlin893379e2009-10-27 18:16:36 +0000329 return 0;
330 }
331
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100332 if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
333 ret = nc->info->receive_raw(nc, data, size);
Mark McLoughlin893379e2009-10-27 18:16:36 +0000334 } else {
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100335 ret = nc->info->receive(nc, data, size);
Mark McLoughlin893379e2009-10-27 18:16:36 +0000336 }
337
338 if (ret == 0) {
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100339 nc->receive_disabled = 1;
Mark McLoughlin893379e2009-10-27 18:16:36 +0000340 };
341
342 return ret;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100343}
344
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100345void qemu_purge_queued_packets(NetClientState *nc)
aliguori63a01ef2008-10-31 19:10:00 +0000346{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100347 if (!nc->peer) {
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100348 return;
349 }
350
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100351 qemu_net_queue_purge(nc->peer->send_queue, nc);
Mark McLoughlin8cad5512009-06-18 18:21:29 +0100352}
353
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100354void qemu_flush_queued_packets(NetClientState *nc)
Mark McLoughline94667b2009-04-29 11:48:12 +0100355{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100356 nc->receive_disabled = 0;
Mark McLoughlind80b9fc2009-10-08 19:58:24 +0100357
Paolo Bonzini987a9b42012-08-09 16:45:55 +0200358 if (qemu_net_queue_flush(nc->send_queue)) {
359 /* We emptied the queue successfully, signal to the IO thread to repoll
360 * the file descriptor (for tap, for example).
361 */
362 qemu_notify_event();
363 }
Mark McLoughline94667b2009-04-29 11:48:12 +0100364}
365
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100366static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
Mark McLoughlinca77d172009-10-22 17:43:41 +0100367 unsigned flags,
368 const uint8_t *buf, int size,
369 NetPacketSent *sent_cb)
aliguori764a4d12009-04-21 19:56:41 +0000370{
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100371 NetQueue *queue;
Mark McLoughline94667b2009-04-29 11:48:12 +0100372
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100373#ifdef DEBUG_NET
Mark McLoughlind80b9fc2009-10-08 19:58:24 +0100374 printf("qemu_send_packet_async:\n");
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100375 hex_dump(stdout, buf, size);
376#endif
377
Stefan Hajnoczia005d072012-07-24 16:35:11 +0100378 if (sender->link_down || !sender->peer) {
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100379 return size;
380 }
381
Stefan Hajnoczia005d072012-07-24 16:35:11 +0100382 queue = sender->peer->send_queue;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100383
Mark McLoughlinca77d172009-10-22 17:43:41 +0100384 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
385}
386
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100387ssize_t qemu_send_packet_async(NetClientState *sender,
Mark McLoughlinca77d172009-10-22 17:43:41 +0100388 const uint8_t *buf, int size,
389 NetPacketSent *sent_cb)
390{
391 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
392 buf, size, sent_cb);
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100393}
394
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100395void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100396{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100397 qemu_send_packet_async(nc, buf, size, NULL);
aliguori63a01ef2008-10-31 19:10:00 +0000398}
399
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100400ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
Mark McLoughlinca77d172009-10-22 17:43:41 +0100401{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100402 return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
Mark McLoughlinca77d172009-10-22 17:43:41 +0100403 buf, size, NULL);
404}
405
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100406static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
aliguorifbe78f42008-12-17 19:13:11 +0000407 int iovcnt)
408{
409 uint8_t buffer[4096];
Benjamin Poirierce053662011-02-23 19:57:21 -0500410 size_t offset;
aliguorifbe78f42008-12-17 19:13:11 +0000411
Michael Tokarevdcf6f5e2012-03-11 18:05:12 +0400412 offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
aliguorifbe78f42008-12-17 19:13:11 +0000413
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100414 return nc->info->receive(nc, buffer, offset);
aliguorifbe78f42008-12-17 19:13:11 +0000415}
416
Zhi Yong Wu86a77c32012-07-24 16:35:17 +0100417ssize_t qemu_deliver_packet_iov(NetClientState *sender,
418 unsigned flags,
419 const struct iovec *iov,
420 int iovcnt,
421 void *opaque)
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100422{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100423 NetClientState *nc = opaque;
Stefan Hajnoczic67f5dc2012-08-17 21:16:42 +0100424 int ret;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100425
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100426 if (nc->link_down) {
Benjamin Poirierce053662011-02-23 19:57:21 -0500427 return iov_size(iov, iovcnt);
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100428 }
429
Stefan Hajnoczic67f5dc2012-08-17 21:16:42 +0100430 if (nc->receive_disabled) {
431 return 0;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100432 }
Stefan Hajnoczic67f5dc2012-08-17 21:16:42 +0100433
434 if (nc->info->receive_iov) {
435 ret = nc->info->receive_iov(nc, iov, iovcnt);
436 } else {
437 ret = nc_sendv_compat(nc, iov, iovcnt);
438 }
439
440 if (ret == 0) {
441 nc->receive_disabled = 1;
442 }
443
444 return ret;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100445}
446
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100447ssize_t qemu_sendv_packet_async(NetClientState *sender,
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100448 const struct iovec *iov, int iovcnt,
449 NetPacketSent *sent_cb)
aliguorifbe78f42008-12-17 19:13:11 +0000450{
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100451 NetQueue *queue;
452
Stefan Hajnoczia005d072012-07-24 16:35:11 +0100453 if (sender->link_down || !sender->peer) {
Benjamin Poirierce053662011-02-23 19:57:21 -0500454 return iov_size(iov, iovcnt);
aliguorifbe78f42008-12-17 19:13:11 +0000455 }
456
Stefan Hajnoczia005d072012-07-24 16:35:11 +0100457 queue = sender->peer->send_queue;
Mark McLoughlin9a6ecb32009-10-08 19:58:32 +0100458
Mark McLoughlinc0b8e492009-10-22 17:43:40 +0100459 return qemu_net_queue_send_iov(queue, sender,
460 QEMU_NET_PACKET_FLAG_NONE,
461 iov, iovcnt, sent_cb);
aliguorifbe78f42008-12-17 19:13:11 +0000462}
463
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100464ssize_t
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100465qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100466{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100467 return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
Mark McLoughlinf3b6c7f2009-04-29 12:15:26 +0100468}
469
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100470NetClientState *qemu_find_netdev(const char *id)
aliguori63a01ef2008-10-31 19:10:00 +0000471{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100472 NetClientState *nc;
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100473
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100474 QTAILQ_FOREACH(nc, &net_clients, next) {
475 if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
Markus Armbruster85dde9a2011-06-16 18:45:37 +0200476 continue;
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100477 if (!strcmp(nc->name, id)) {
478 return nc;
Mark McLoughlin5869c4d2009-10-08 19:58:29 +0100479 }
480 }
481
482 return NULL;
483}
484
aliguori76970792009-02-11 15:20:03 +0000485static int nic_get_free_idx(void)
486{
487 int index;
488
489 for (index = 0; index < MAX_NICS; index++)
490 if (!nd_table[index].used)
491 return index;
492 return -1;
493}
494
Markus Armbruster07caea32009-09-25 03:53:51 +0200495int qemu_show_nic_models(const char *arg, const char *const *models)
496{
497 int i;
498
Peter Maydellc8057f92012-08-02 13:45:54 +0100499 if (!arg || !is_help_option(arg)) {
Markus Armbruster07caea32009-09-25 03:53:51 +0200500 return 0;
Peter Maydellc8057f92012-08-02 13:45:54 +0100501 }
Markus Armbruster07caea32009-09-25 03:53:51 +0200502
503 fprintf(stderr, "qemu: Supported NIC models: ");
504 for (i = 0 ; models[i]; i++)
505 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
506 return 1;
507}
508
aliguorid07f22c2009-01-13 19:03:57 +0000509void qemu_check_nic_model(NICInfo *nd, const char *model)
510{
511 const char *models[2];
512
513 models[0] = model;
514 models[1] = NULL;
515
Markus Armbruster07caea32009-09-25 03:53:51 +0200516 if (qemu_show_nic_models(nd->model, models))
517 exit(0);
518 if (qemu_find_nic_model(nd, models, model) < 0)
519 exit(1);
aliguorid07f22c2009-01-13 19:03:57 +0000520}
521
Markus Armbruster07caea32009-09-25 03:53:51 +0200522int qemu_find_nic_model(NICInfo *nd, const char * const *models,
523 const char *default_model)
aliguorid07f22c2009-01-13 19:03:57 +0000524{
Markus Armbruster07caea32009-09-25 03:53:51 +0200525 int i;
aliguorid07f22c2009-01-13 19:03:57 +0000526
527 if (!nd->model)
Anthony Liguori7267c092011-08-20 22:09:37 -0500528 nd->model = g_strdup(default_model);
aliguorid07f22c2009-01-13 19:03:57 +0000529
Markus Armbruster07caea32009-09-25 03:53:51 +0200530 for (i = 0 ; models[i]; i++) {
531 if (strcmp(nd->model, models[i]) == 0)
532 return i;
aliguorid07f22c2009-01-13 19:03:57 +0000533 }
534
Markus Armbruster6daf1942011-06-22 14:03:54 +0200535 error_report("Unsupported NIC model: %s", nd->model);
Markus Armbruster07caea32009-09-25 03:53:51 +0200536 return -1;
aliguorid07f22c2009-01-13 19:03:57 +0000537}
538
Laszlo Ersek1a0c0952012-07-17 16:17:21 +0200539static int net_init_nic(const NetClientOptions *opts, const char *name,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100540 NetClientState *peer)
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100541{
542 int idx;
543 NICInfo *nd;
Laszlo Ersek2456f362012-07-17 16:17:14 +0200544 const NetLegacyNicOptions *nic;
545
546 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
547 nic = opts->nic;
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100548
549 idx = nic_get_free_idx();
550 if (idx == -1 || nb_nics >= MAX_NICS) {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100551 error_report("Too Many NICs");
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100552 return -1;
553 }
554
555 nd = &nd_table[idx];
556
557 memset(nd, 0, sizeof(*nd));
558
Laszlo Ersek2456f362012-07-17 16:17:14 +0200559 if (nic->has_netdev) {
560 nd->netdev = qemu_find_netdev(nic->netdev);
Mark McLoughlin5869c4d2009-10-08 19:58:29 +0100561 if (!nd->netdev) {
Laszlo Ersek2456f362012-07-17 16:17:14 +0200562 error_report("netdev '%s' not found", nic->netdev);
Mark McLoughlin5869c4d2009-10-08 19:58:29 +0100563 return -1;
564 }
565 } else {
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100566 assert(peer);
567 nd->netdev = peer;
Mark McLoughlin5869c4d2009-10-08 19:58:29 +0100568 }
Markus Armbrusterc64f50d2013-01-22 11:07:57 +0100569 nd->name = g_strdup(name);
Laszlo Ersek2456f362012-07-17 16:17:14 +0200570 if (nic->has_model) {
571 nd->model = g_strdup(nic->model);
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100572 }
Laszlo Ersek2456f362012-07-17 16:17:14 +0200573 if (nic->has_addr) {
574 nd->devaddr = g_strdup(nic->addr);
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100575 }
576
Laszlo Ersek2456f362012-07-17 16:17:14 +0200577 if (nic->has_macaddr &&
578 net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100579 error_report("invalid syntax for ethernet address");
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100580 return -1;
581 }
Jan Kiszka6eed1852011-07-20 12:20:22 +0200582 qemu_macaddr_default_if_unset(&nd->macaddr);
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100583
Laszlo Ersek2456f362012-07-17 16:17:14 +0200584 if (nic->has_vectors) {
585 if (nic->vectors > 0x7ffffff) {
586 error_report("invalid # of vectors: %"PRIu32, nic->vectors);
587 return -1;
588 }
589 nd->nvectors = nic->vectors;
590 } else {
591 nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100592 }
593
594 nd->used = 1;
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100595 nb_nics++;
596
597 return idx;
598}
599
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100600
Laszlo Ersek6687b792012-07-17 16:17:13 +0200601static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
Laszlo Ersek1a0c0952012-07-17 16:17:21 +0200602 const NetClientOptions *opts,
Laszlo Ersek6687b792012-07-17 16:17:13 +0200603 const char *name,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100604 NetClientState *peer) = {
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100605 [NET_CLIENT_OPTIONS_KIND_NIC] = net_init_nic,
Mark McLoughlinec302ff2009-10-06 12:17:07 +0100606#ifdef CONFIG_SLIRP
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100607 [NET_CLIENT_OPTIONS_KIND_USER] = net_init_slirp,
Mark McLoughlinec302ff2009-10-06 12:17:07 +0100608#endif
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100609 [NET_CLIENT_OPTIONS_KIND_TAP] = net_init_tap,
610 [NET_CLIENT_OPTIONS_KIND_SOCKET] = net_init_socket,
Mark McLoughlindd510582009-10-06 12:17:10 +0100611#ifdef CONFIG_VDE
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100612 [NET_CLIENT_OPTIONS_KIND_VDE] = net_init_vde,
Mark McLoughlindd510582009-10-06 12:17:10 +0100613#endif
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100614 [NET_CLIENT_OPTIONS_KIND_DUMP] = net_init_dump,
Stefan Weil2944e4e2012-02-04 09:24:46 +0100615#ifdef CONFIG_NET_BRIDGE
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100616 [NET_CLIENT_OPTIONS_KIND_BRIDGE] = net_init_bridge,
Laszlo Ersek6687b792012-07-17 16:17:13 +0200617#endif
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100618 [NET_CLIENT_OPTIONS_KIND_HUBPORT] = net_init_hubport,
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100619};
620
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100621
Laszlo Ersek1a0c0952012-07-17 16:17:21 +0200622static int net_client_init1(const void *object, int is_netdev, Error **errp)
Laszlo Ersek6687b792012-07-17 16:17:13 +0200623{
624 union {
625 const Netdev *netdev;
626 const NetLegacy *net;
627 } u;
628 const NetClientOptions *opts;
629 const char *name;
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100630
Markus Armbruster5294e2c2010-03-25 17:22:38 +0100631 if (is_netdev) {
Laszlo Ersek6687b792012-07-17 16:17:13 +0200632 u.netdev = object;
633 opts = u.netdev->opts;
634 name = u.netdev->id;
635
636 switch (opts->kind) {
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100637#ifdef CONFIG_SLIRP
Laszlo Ersek6687b792012-07-17 16:17:13 +0200638 case NET_CLIENT_OPTIONS_KIND_USER:
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100639#endif
Laszlo Ersek6687b792012-07-17 16:17:13 +0200640 case NET_CLIENT_OPTIONS_KIND_TAP:
641 case NET_CLIENT_OPTIONS_KIND_SOCKET:
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100642#ifdef CONFIG_VDE
Laszlo Ersek6687b792012-07-17 16:17:13 +0200643 case NET_CLIENT_OPTIONS_KIND_VDE:
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100644#endif
Laszlo Ersek6687b792012-07-17 16:17:13 +0200645#ifdef CONFIG_NET_BRIDGE
646 case NET_CLIENT_OPTIONS_KIND_BRIDGE:
647#endif
Stefan Hajnoczif6c874e2012-07-24 16:35:04 +0100648 case NET_CLIENT_OPTIONS_KIND_HUBPORT:
Laszlo Ersek6687b792012-07-17 16:17:13 +0200649 break;
650
651 default:
Luiz Capitulino4559a1d2012-04-20 16:50:25 -0300652 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
653 "a netdev backend type");
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100654 return -1;
655 }
Laszlo Ersek6687b792012-07-17 16:17:13 +0200656 } else {
657 u.net = object;
658 opts = u.net->opts;
659 /* missing optional values have been initialized to "all bits zero" */
660 name = u.net->has_id ? u.net->id : u.net->name;
661 }
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100662
Laszlo Ersek6687b792012-07-17 16:17:13 +0200663 if (net_client_init_fun[opts->kind]) {
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100664 NetClientState *peer = NULL;
Laszlo Ersek6687b792012-07-17 16:17:13 +0200665
666 /* Do not add to a vlan if it's a -netdev or a nic with a netdev=
667 * parameter. */
668 if (!is_netdev &&
669 (opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
670 !opts->nic->has_netdev)) {
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100671 peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100672 }
Laszlo Ersek6687b792012-07-17 16:17:13 +0200673
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100674 if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
Laszlo Ersek6687b792012-07-17 16:17:13 +0200675 /* TODO push error reporting into init() methods */
676 error_set(errp, QERR_DEVICE_INIT_FAILED,
677 NetClientOptionsKind_lookup[opts->kind]);
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100678 return -1;
679 }
680 }
Laszlo Ersek6687b792012-07-17 16:17:13 +0200681 return 0;
Mark McLoughlinf83c6e12009-10-06 12:17:06 +0100682}
683
Laszlo Ersek6687b792012-07-17 16:17:13 +0200684
685static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
686{
687 if (is_netdev) {
688 visit_type_Netdev(v, (Netdev **)object, NULL, errp);
689 } else {
690 visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
691 }
692}
693
694
695int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
696{
697 void *object = NULL;
698 Error *err = NULL;
699 int ret = -1;
700
701 {
702 OptsVisitor *ov = opts_visitor_new(opts);
703
704 net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
705 opts_visitor_cleanup(ov);
706 }
707
708 if (!err) {
Laszlo Ersek1a0c0952012-07-17 16:17:21 +0200709 ret = net_client_init1(object, is_netdev, &err);
Laszlo Ersek6687b792012-07-17 16:17:13 +0200710 }
711
712 if (object) {
713 QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
714
715 net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
716 qapi_dealloc_visitor_cleanup(dv);
717 }
718
719 error_propagate(errp, err);
720 return ret;
721}
722
723
aliguori6f338c32009-02-11 15:21:54 +0000724static int net_host_check_device(const char *device)
725{
726 int i;
aliguoribb9ea792009-04-21 19:56:28 +0000727 const char *valid_param_list[] = { "tap", "socket", "dump"
Stefan Weil2944e4e2012-02-04 09:24:46 +0100728#ifdef CONFIG_NET_BRIDGE
729 , "bridge"
730#endif
aliguori6f338c32009-02-11 15:21:54 +0000731#ifdef CONFIG_SLIRP
732 ,"user"
733#endif
734#ifdef CONFIG_VDE
735 ,"vde"
736#endif
737 };
738 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
739 if (!strncmp(valid_param_list[i], device,
740 strlen(valid_param_list[i])))
741 return 1;
742 }
743
744 return 0;
745}
746
Luiz Capitulinof18c16d2009-08-28 15:27:14 -0300747void net_host_device_add(Monitor *mon, const QDict *qdict)
aliguori6f338c32009-02-11 15:21:54 +0000748{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -0300749 const char *device = qdict_get_str(qdict, "device");
Mark McLoughlin7f1c9d22009-10-06 12:17:13 +0100750 const char *opts_str = qdict_get_try_str(qdict, "opts");
Luiz Capitulino4559a1d2012-04-20 16:50:25 -0300751 Error *local_err = NULL;
Mark McLoughlin7f1c9d22009-10-06 12:17:13 +0100752 QemuOpts *opts;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -0300753
aliguori6f338c32009-02-11 15:21:54 +0000754 if (!net_host_check_device(device)) {
aliguori376253e2009-03-05 23:01:23 +0000755 monitor_printf(mon, "invalid host network device %s\n", device);
aliguori6f338c32009-02-11 15:21:54 +0000756 return;
757 }
Mark McLoughlin7f1c9d22009-10-06 12:17:13 +0100758
Gerd Hoffmann3329f072010-08-20 13:52:01 +0200759 opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
Mark McLoughlin7f1c9d22009-10-06 12:17:13 +0100760 if (!opts) {
Mark McLoughlin7f1c9d22009-10-06 12:17:13 +0100761 return;
762 }
763
764 qemu_opt_set(opts, "type", device);
765
Luiz Capitulino4559a1d2012-04-20 16:50:25 -0300766 net_client_init(opts, 0, &local_err);
767 if (error_is_set(&local_err)) {
768 qerror_report_err(local_err);
769 error_free(local_err);
aliguori5c8be672009-04-21 19:56:32 +0000770 monitor_printf(mon, "adding host network device %s failed\n", device);
771 }
aliguori6f338c32009-02-11 15:21:54 +0000772}
773
Luiz Capitulinof18c16d2009-08-28 15:27:14 -0300774void net_host_device_remove(Monitor *mon, const QDict *qdict)
aliguori6f338c32009-02-11 15:21:54 +0000775{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100776 NetClientState *nc;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -0300777 int vlan_id = qdict_get_int(qdict, "vlan_id");
778 const char *device = qdict_get_str(qdict, "device");
aliguori6f338c32009-02-11 15:21:54 +0000779
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100780 nc = net_hub_find_client_by_name(vlan_id, device);
781 if (!nc) {
aliguori6f338c32009-02-11 15:21:54 +0000782 return;
783 }
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100784 if (!net_host_check_device(nc->model)) {
aliguorie8f1f9d2009-04-21 19:56:08 +0000785 monitor_printf(mon, "invalid host network device %s\n", device);
786 return;
787 }
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100788 qemu_del_net_client(nc);
aliguori6f338c32009-02-11 15:21:54 +0000789}
790
Luiz Capitulino928059a2012-04-18 17:34:15 -0300791void netdev_add(QemuOpts *opts, Error **errp)
792{
793 net_client_init(opts, 1, errp);
794}
795
796int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
Markus Armbrusterae82d322010-03-25 17:22:40 +0100797{
Luiz Capitulino4e899782012-04-18 17:24:01 -0300798 Error *local_err = NULL;
Luiz Capitulino928059a2012-04-18 17:34:15 -0300799 QemuOptsList *opts_list;
Markus Armbrusterae82d322010-03-25 17:22:40 +0100800 QemuOpts *opts;
Markus Armbrusterae82d322010-03-25 17:22:40 +0100801
Luiz Capitulino928059a2012-04-18 17:34:15 -0300802 opts_list = qemu_find_opts_err("netdev", &local_err);
803 if (error_is_set(&local_err)) {
804 goto exit_err;
Markus Armbrusterae82d322010-03-25 17:22:40 +0100805 }
806
Luiz Capitulino928059a2012-04-18 17:34:15 -0300807 opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
808 if (error_is_set(&local_err)) {
809 goto exit_err;
810 }
811
812 netdev_add(opts, &local_err);
813 if (error_is_set(&local_err)) {
Yoshiaki Tamura410cbaf2010-06-21 10:41:36 +0900814 qemu_opts_del(opts);
Luiz Capitulino928059a2012-04-18 17:34:15 -0300815 goto exit_err;
Yoshiaki Tamura410cbaf2010-06-21 10:41:36 +0900816 }
817
Luiz Capitulino928059a2012-04-18 17:34:15 -0300818 return 0;
819
820exit_err:
821 qerror_report_err(local_err);
822 error_free(local_err);
823 return -1;
Markus Armbrusterae82d322010-03-25 17:22:40 +0100824}
825
Luiz Capitulino5f964152012-04-16 14:36:32 -0300826void qmp_netdev_del(const char *id, Error **errp)
Markus Armbrusterae82d322010-03-25 17:22:40 +0100827{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100828 NetClientState *nc;
Stefan Hajnoczi645c9492012-10-24 14:34:12 +0200829 QemuOpts *opts;
Markus Armbrusterae82d322010-03-25 17:22:40 +0100830
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100831 nc = qemu_find_netdev(id);
832 if (!nc) {
Luiz Capitulino5f964152012-04-16 14:36:32 -0300833 error_set(errp, QERR_DEVICE_NOT_FOUND, id);
834 return;
Markus Armbrusterae82d322010-03-25 17:22:40 +0100835 }
Luiz Capitulino5f964152012-04-16 14:36:32 -0300836
Stefan Hajnoczi645c9492012-10-24 14:34:12 +0200837 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), id);
838 if (!opts) {
839 error_setg(errp, "Device '%s' is not a netdev", id);
840 return;
841 }
842
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100843 qemu_del_net_client(nc);
Stefan Hajnoczi645c9492012-10-24 14:34:12 +0200844 qemu_opts_del(opts);
Markus Armbrusterae82d322010-03-25 17:22:40 +0100845}
846
Zhi Yong Wu1a859592012-07-24 16:35:16 +0100847void print_net_client(Monitor *mon, NetClientState *nc)
Jan Kiszka44e798d2011-07-20 12:20:21 +0200848{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100849 monitor_printf(mon, "%s: type=%s,%s\n", nc->name,
850 NetClientOptionsKind_lookup[nc->info->type], nc->info_str);
Jan Kiszka44e798d2011-07-20 12:20:21 +0200851}
852
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800853void do_info_network(Monitor *mon, const QDict *qdict)
aliguori63a01ef2008-10-31 19:10:00 +0000854{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100855 NetClientState *nc, *peer;
Laszlo Ersek2be64a62012-07-17 16:17:12 +0200856 NetClientOptionsKind type;
aliguori63a01ef2008-10-31 19:10:00 +0000857
Zhi Yong Wu1a859592012-07-24 16:35:16 +0100858 net_hub_info(mon);
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100859
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100860 QTAILQ_FOREACH(nc, &net_clients, next) {
861 peer = nc->peer;
862 type = nc->info->type;
Zhi Yong Wu1a859592012-07-24 16:35:16 +0100863
864 /* Skip if already printed in hub info */
865 if (net_hub_id_for_client(nc, NULL) == 0) {
866 continue;
Mark McLoughlin5610c3a2009-10-08 19:58:23 +0100867 }
Zhi Yong Wu1a859592012-07-24 16:35:16 +0100868
Laszlo Ersek2be64a62012-07-17 16:17:12 +0200869 if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100870 print_net_client(mon, nc);
Jan Kiszka19061e62011-07-20 12:20:19 +0200871 } /* else it's a netdev connected to a NIC, printed with the NIC */
Laszlo Ersek2be64a62012-07-17 16:17:12 +0200872 if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
Zhi Yong Wu1a859592012-07-24 16:35:16 +0100873 monitor_printf(mon, " \\ ");
Jan Kiszka44e798d2011-07-20 12:20:21 +0200874 print_net_client(mon, peer);
Markus Armbrustera0104e02010-02-11 14:45:01 +0100875 }
Markus Armbrustera0104e02010-02-11 14:45:01 +0100876 }
aliguori63a01ef2008-10-31 19:10:00 +0000877}
878
Luiz Capitulino4b371562011-11-23 13:11:55 -0200879void qmp_set_link(const char *name, bool up, Error **errp)
aliguori436e5e52009-01-08 19:44:06 +0000880{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100881 NetClientState *nc = NULL;
aliguori436e5e52009-01-08 19:44:06 +0000882
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100883 QTAILQ_FOREACH(nc, &net_clients, next) {
884 if (!strcmp(nc->name, name)) {
Markus Armbruster85dde9a2011-06-16 18:45:37 +0200885 goto done;
886 }
887 }
edgar_igldd5de372009-01-09 00:48:28 +0000888done:
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100889 if (!nc) {
Luiz Capitulino4b371562011-11-23 13:11:55 -0200890 error_set(errp, QERR_DEVICE_NOT_FOUND, name);
891 return;
aliguori436e5e52009-01-08 19:44:06 +0000892 }
893
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100894 nc->link_down = !up;
aliguori436e5e52009-01-08 19:44:06 +0000895
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100896 if (nc->info->link_status_changed) {
897 nc->info->link_status_changed(nc);
Mark McLoughlin665a3b02009-11-25 18:49:30 +0000898 }
Michael S. Tsirkinab1cbe12011-02-09 18:45:04 +0200899
900 /* Notify peer. Don't update peer link status: this makes it possible to
901 * disconnect from host network without notifying the guest.
902 * FIXME: is disconnected link status change operation useful?
903 *
904 * Current behaviour is compatible with qemu vlans where there could be
905 * multiple clients that can still communicate with each other in
906 * disconnected mode. For now maintain this compatibility. */
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100907 if (nc->peer && nc->peer->info->link_status_changed) {
908 nc->peer->info->link_status_changed(nc->peer);
Michael S. Tsirkinab1cbe12011-02-09 18:45:04 +0200909 }
aliguori436e5e52009-01-08 19:44:06 +0000910}
911
aliguori63a01ef2008-10-31 19:10:00 +0000912void net_cleanup(void)
913{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100914 NetClientState *nc, *next_vc;
aliguori63a01ef2008-10-31 19:10:00 +0000915
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100916 QTAILQ_FOREACH_SAFE(nc, &net_clients, next, next_vc) {
Stefan Hajnoczib20c6b92012-07-24 16:35:15 +0100917 qemu_del_net_client(nc);
Mark McLoughlin577c4af2009-10-08 19:58:28 +0100918 }
aliguori63a01ef2008-10-31 19:10:00 +0000919}
920
Markus Armbruster668680f2010-02-11 14:44:58 +0100921void net_check_clients(void)
aliguori63a01ef2008-10-31 19:10:00 +0000922{
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100923 NetClientState *nc;
Peter Maydell48e2faf2011-05-20 16:50:01 +0100924 int i;
aliguori63a01ef2008-10-31 19:10:00 +0000925
Peter Maydell641f6ea2011-05-20 16:50:00 +0100926 /* Don't warn about the default network setup that you get if
927 * no command line -net or -netdev options are specified. There
928 * are two cases that we would otherwise complain about:
929 * (1) board doesn't support a NIC but the implicit "-net nic"
930 * requested one
931 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
932 * sets up a nic that isn't connected to anything.
933 */
934 if (default_net) {
935 return;
936 }
937
Stefan Hajnoczi81017642012-07-24 16:35:07 +0100938 net_hub_check_clients();
Tristan Gingoldac60cc12011-03-15 14:20:54 +0100939
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100940 QTAILQ_FOREACH(nc, &net_clients, next) {
941 if (!nc->peer) {
Markus Armbrusterefe32fd2010-02-11 14:45:00 +0100942 fprintf(stderr, "Warning: %s %s has no peer\n",
Stefan Hajnoczi35277d12012-07-24 16:35:14 +0100943 nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ?
944 "nic" : "netdev", nc->name);
Markus Armbrusterefe32fd2010-02-11 14:45:00 +0100945 }
946 }
Peter Maydell48e2faf2011-05-20 16:50:01 +0100947
948 /* Check that all NICs requested via -net nic actually got created.
949 * NICs created via -device don't need to be checked here because
950 * they are always instantiated.
951 */
952 for (i = 0; i < MAX_NICS; i++) {
953 NICInfo *nd = &nd_table[i];
954 if (nd->used && !nd->instantiated) {
955 fprintf(stderr, "Warning: requested NIC (%s, model %s) "
956 "was not created (not supported by this machine?)\n",
957 nd->name ? nd->name : "anonymous",
958 nd->model ? nd->model : "unspecified");
959 }
960 }
aliguori63a01ef2008-10-31 19:10:00 +0000961}
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +0100962
963static int net_init_client(QemuOpts *opts, void *dummy)
964{
Luiz Capitulino4559a1d2012-04-20 16:50:25 -0300965 Error *local_err = NULL;
966
967 net_client_init(opts, 0, &local_err);
968 if (error_is_set(&local_err)) {
969 qerror_report_err(local_err);
970 error_free(local_err);
Mark McLoughlinc1671a02009-10-12 09:52:00 +0100971 return -1;
Luiz Capitulino4559a1d2012-04-20 16:50:25 -0300972 }
973
Mark McLoughlinc1671a02009-10-12 09:52:00 +0100974 return 0;
Mark McLoughlinf6b134a2009-10-08 19:58:27 +0100975}
976
977static int net_init_netdev(QemuOpts *opts, void *dummy)
978{
Luiz Capitulino4559a1d2012-04-20 16:50:25 -0300979 Error *local_err = NULL;
980 int ret;
981
982 ret = net_client_init(opts, 1, &local_err);
983 if (error_is_set(&local_err)) {
984 qerror_report_err(local_err);
985 error_free(local_err);
986 return -1;
987 }
988
989 return ret;
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +0100990}
991
992int net_init_clients(void)
993{
Gerd Hoffmann3329f072010-08-20 13:52:01 +0200994 QemuOptsList *net = qemu_find_opts("net");
995
Gerd Hoffmanncb4522c2009-12-08 13:11:47 +0100996 if (default_net) {
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +0100997 /* if no clients, we use a default config */
Gerd Hoffmann3329f072010-08-20 13:52:01 +0200998 qemu_opts_set(net, NULL, "type", "nic");
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +0100999#ifdef CONFIG_SLIRP
Gerd Hoffmann3329f072010-08-20 13:52:01 +02001000 qemu_opts_set(net, NULL, "type", "user");
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001001#endif
1002 }
1003
Stefan Hajnoczi94878992012-07-24 16:35:12 +01001004 QTAILQ_INIT(&net_clients);
Mark McLoughlin5610c3a2009-10-08 19:58:23 +01001005
Gerd Hoffmann3329f072010-08-20 13:52:01 +02001006 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
Mark McLoughlinf6b134a2009-10-08 19:58:27 +01001007 return -1;
1008
Gerd Hoffmann3329f072010-08-20 13:52:01 +02001009 if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001010 return -1;
1011 }
1012
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001013 return 0;
1014}
1015
Mark McLoughlin7f161aa2009-10-08 19:58:25 +01001016int net_client_parse(QemuOptsList *opts_list, const char *optarg)
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001017{
Juan Quintelaa3a766e2009-10-07 23:44:15 +02001018#if defined(CONFIG_SLIRP)
Mark McLoughlin68ac40d2009-11-25 18:48:54 +00001019 int ret;
1020 if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001021 return ret;
1022 }
Juan Quintelaa3a766e2009-10-07 23:44:15 +02001023#endif
Mark McLoughlin68ac40d2009-11-25 18:48:54 +00001024
Markus Armbruster8212c642010-02-10 19:52:18 +01001025 if (!qemu_opts_parse(opts_list, optarg, 1)) {
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001026 return -1;
1027 }
1028
Gerd Hoffmanncb4522c2009-12-08 13:11:47 +01001029 default_net = 0;
Mark McLoughlindc1c9fe2009-10-06 12:17:16 +01001030 return 0;
1031}
Jason Wang7fc8d912012-03-05 11:08:50 +08001032
1033/* From FreeBSD */
1034/* XXX: optimize */
1035unsigned compute_mcast_idx(const uint8_t *ep)
1036{
1037 uint32_t crc;
1038 int carry, i, j;
1039 uint8_t b;
1040
1041 crc = 0xffffffff;
1042 for (i = 0; i < 6; i++) {
1043 b = *ep++;
1044 for (j = 0; j < 8; j++) {
1045 carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1046 crc <<= 1;
1047 b >>= 1;
1048 if (carry) {
1049 crc = ((crc ^ POLYNOMIAL) | carry);
1050 }
1051 }
1052 }
1053 return crc >> 26;
1054}
Paolo Bonzini4d454572012-11-26 16:03:42 +01001055
1056QemuOptsList qemu_netdev_opts = {
1057 .name = "netdev",
1058 .implied_opt_name = "type",
1059 .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1060 .desc = {
1061 /*
1062 * no elements => accept any params
1063 * validation will happen later
1064 */
1065 { /* end of list */ }
1066 },
1067};
1068
1069QemuOptsList qemu_net_opts = {
1070 .name = "net",
1071 .implied_opt_name = "type",
1072 .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1073 .desc = {
1074 /*
1075 * no elements => accept any params
1076 * validation will happen later
1077 */
1078 { /* end of list */ }
1079 },
1080};