xref: /openbmc/qemu/net/net.c (revision 17ef2af6b67f29bb5c5c687f07216544830f167a)
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  
25  #include "qemu/osdep.h"
26  
27  #include "net/net.h"
28  #include "clients.h"
29  #include "hub.h"
30  #include "hw/qdev-properties.h"
31  #include "net/slirp.h"
32  #include "net/eth.h"
33  #include "util.h"
34  
35  #include "monitor/monitor.h"
36  #include "qemu/help_option.h"
37  #include "qapi/qapi-commands-net.h"
38  #include "qapi/qapi-visit-net.h"
39  #include "qapi/qmp/qdict.h"
40  #include "qapi/qmp/qerror.h"
41  #include "qemu/error-report.h"
42  #include "qemu/sockets.h"
43  #include "qemu/cutils.h"
44  #include "qemu/config-file.h"
45  #include "qemu/ctype.h"
46  #include "qemu/iov.h"
47  #include "qemu/main-loop.h"
48  #include "qemu/option.h"
49  #include "qapi/error.h"
50  #include "qapi/opts-visitor.h"
51  #include "sysemu/sysemu.h"
52  #include "sysemu/qtest.h"
53  #include "sysemu/runstate.h"
54  #include "sysemu/sysemu.h"
55  #include "net/filter.h"
56  #include "qapi/string-output-visitor.h"
57  
58  /* Net bridge is currently not supported for W32. */
59  #if !defined(_WIN32)
60  # define CONFIG_NET_BRIDGE
61  #endif
62  
63  static VMChangeStateEntry *net_change_state_entry;
64  static QTAILQ_HEAD(, NetClientState) net_clients;
65  
66  /***********************************************************/
67  /* network device redirectors */
68  
69  int parse_host_port(struct sockaddr_in *saddr, const char *str,
70                      Error **errp)
71  {
72      gchar **substrings;
73      struct hostent *he;
74      const char *addr, *p, *r;
75      int port, ret = 0;
76  
77      substrings = g_strsplit(str, ":", 2);
78      if (!substrings || !substrings[0] || !substrings[1]) {
79          error_setg(errp, "host address '%s' doesn't contain ':' "
80                     "separating host from port", str);
81          ret = -1;
82          goto out;
83      }
84  
85      addr = substrings[0];
86      p = substrings[1];
87  
88      saddr->sin_family = AF_INET;
89      if (addr[0] == '\0') {
90          saddr->sin_addr.s_addr = 0;
91      } else {
92          if (qemu_isdigit(addr[0])) {
93              if (!inet_aton(addr, &saddr->sin_addr)) {
94                  error_setg(errp, "host address '%s' is not a valid "
95                             "IPv4 address", addr);
96                  ret = -1;
97                  goto out;
98              }
99          } else {
100              he = gethostbyname(addr);
101              if (he == NULL) {
102                  error_setg(errp, "can't resolve host address '%s'", addr);
103                  ret = -1;
104                  goto out;
105              }
106              saddr->sin_addr = *(struct in_addr *)he->h_addr;
107          }
108      }
109      port = strtol(p, (char **)&r, 0);
110      if (r == p) {
111          error_setg(errp, "port number '%s' is invalid", p);
112          ret = -1;
113          goto out;
114      }
115      saddr->sin_port = htons(port);
116  
117  out:
118      g_strfreev(substrings);
119      return ret;
120  }
121  
122  char *qemu_mac_strdup_printf(const uint8_t *macaddr)
123  {
124      return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
125                             macaddr[0], macaddr[1], macaddr[2],
126                             macaddr[3], macaddr[4], macaddr[5]);
127  }
128  
129  void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
130  {
131      snprintf(nc->info_str, sizeof(nc->info_str),
132               "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
133               nc->model,
134               macaddr[0], macaddr[1], macaddr[2],
135               macaddr[3], macaddr[4], macaddr[5]);
136  }
137  
138  static int mac_table[256] = {0};
139  
140  static void qemu_macaddr_set_used(MACAddr *macaddr)
141  {
142      int index;
143  
144      for (index = 0x56; index < 0xFF; index++) {
145          if (macaddr->a[5] == index) {
146              mac_table[index]++;
147          }
148      }
149  }
150  
151  static void qemu_macaddr_set_free(MACAddr *macaddr)
152  {
153      int index;
154      static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
155  
156      if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
157          return;
158      }
159      for (index = 0x56; index < 0xFF; index++) {
160          if (macaddr->a[5] == index) {
161              mac_table[index]--;
162          }
163      }
164  }
165  
166  static int qemu_macaddr_get_free(void)
167  {
168      int index;
169  
170      for (index = 0x56; index < 0xFF; index++) {
171          if (mac_table[index] == 0) {
172              return index;
173          }
174      }
175  
176      return -1;
177  }
178  
179  void qemu_macaddr_default_if_unset(MACAddr *macaddr)
180  {
181      static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
182      static const MACAddr base = { .a = { 0x52, 0x54, 0x00, 0x12, 0x34, 0 } };
183  
184      if (memcmp(macaddr, &zero, sizeof(zero)) != 0) {
185          if (memcmp(macaddr->a, &base.a, (sizeof(base.a) - 1)) != 0) {
186              return;
187          } else {
188              qemu_macaddr_set_used(macaddr);
189              return;
190          }
191      }
192  
193      macaddr->a[0] = 0x52;
194      macaddr->a[1] = 0x54;
195      macaddr->a[2] = 0x00;
196      macaddr->a[3] = 0x12;
197      macaddr->a[4] = 0x34;
198      macaddr->a[5] = qemu_macaddr_get_free();
199      qemu_macaddr_set_used(macaddr);
200  }
201  
202  /**
203   * Generate a name for net client
204   *
205   * Only net clients created with the legacy -net option and NICs need this.
206   */
207  static char *assign_name(NetClientState *nc1, const char *model)
208  {
209      NetClientState *nc;
210      int id = 0;
211  
212      QTAILQ_FOREACH(nc, &net_clients, next) {
213          if (nc == nc1) {
214              continue;
215          }
216          if (strcmp(nc->model, model) == 0) {
217              id++;
218          }
219      }
220  
221      return g_strdup_printf("%s.%d", model, id);
222  }
223  
224  static void qemu_net_client_destructor(NetClientState *nc)
225  {
226      g_free(nc);
227  }
228  static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
229                                         unsigned flags,
230                                         const struct iovec *iov,
231                                         int iovcnt,
232                                         void *opaque);
233  
234  static void qemu_net_client_setup(NetClientState *nc,
235                                    NetClientInfo *info,
236                                    NetClientState *peer,
237                                    const char *model,
238                                    const char *name,
239                                    NetClientDestructor *destructor)
240  {
241      nc->info = info;
242      nc->model = g_strdup(model);
243      if (name) {
244          nc->name = g_strdup(name);
245      } else {
246          nc->name = assign_name(nc, model);
247      }
248  
249      if (peer) {
250          assert(!peer->peer);
251          nc->peer = peer;
252          peer->peer = nc;
253      }
254      QTAILQ_INSERT_TAIL(&net_clients, nc, next);
255  
256      nc->incoming_queue = qemu_new_net_queue(qemu_deliver_packet_iov, nc);
257      nc->destructor = destructor;
258      QTAILQ_INIT(&nc->filters);
259  }
260  
261  NetClientState *qemu_new_net_client(NetClientInfo *info,
262                                      NetClientState *peer,
263                                      const char *model,
264                                      const char *name)
265  {
266      NetClientState *nc;
267  
268      assert(info->size >= sizeof(NetClientState));
269  
270      nc = g_malloc0(info->size);
271      qemu_net_client_setup(nc, info, peer, model, name,
272                            qemu_net_client_destructor);
273  
274      return nc;
275  }
276  
277  NICState *qemu_new_nic(NetClientInfo *info,
278                         NICConf *conf,
279                         const char *model,
280                         const char *name,
281                         void *opaque)
282  {
283      NetClientState **peers = conf->peers.ncs;
284      NICState *nic;
285      int i, queues = MAX(1, conf->peers.queues);
286  
287      assert(info->type == NET_CLIENT_DRIVER_NIC);
288      assert(info->size >= sizeof(NICState));
289  
290      nic = g_malloc0(info->size + sizeof(NetClientState) * queues);
291      nic->ncs = (void *)nic + info->size;
292      nic->conf = conf;
293      nic->opaque = opaque;
294  
295      for (i = 0; i < queues; i++) {
296          qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, name,
297                                NULL);
298          nic->ncs[i].queue_index = i;
299      }
300  
301      return nic;
302  }
303  
304  NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
305  {
306      return nic->ncs + queue_index;
307  }
308  
309  NetClientState *qemu_get_queue(NICState *nic)
310  {
311      return qemu_get_subqueue(nic, 0);
312  }
313  
314  NICState *qemu_get_nic(NetClientState *nc)
315  {
316      NetClientState *nc0 = nc - nc->queue_index;
317  
318      return (NICState *)((void *)nc0 - nc->info->size);
319  }
320  
321  void *qemu_get_nic_opaque(NetClientState *nc)
322  {
323      NICState *nic = qemu_get_nic(nc);
324  
325      return nic->opaque;
326  }
327  
328  NetClientState *qemu_get_peer(NetClientState *nc, int queue_index)
329  {
330      assert(nc != NULL);
331      NetClientState *ncs = nc + queue_index;
332      return ncs->peer;
333  }
334  
335  static void qemu_cleanup_net_client(NetClientState *nc)
336  {
337      QTAILQ_REMOVE(&net_clients, nc, next);
338  
339      if (nc->info->cleanup) {
340          nc->info->cleanup(nc);
341      }
342  }
343  
344  static void qemu_free_net_client(NetClientState *nc)
345  {
346      if (nc->incoming_queue) {
347          qemu_del_net_queue(nc->incoming_queue);
348      }
349      if (nc->peer) {
350          nc->peer->peer = NULL;
351      }
352      g_free(nc->name);
353      g_free(nc->model);
354      if (nc->destructor) {
355          nc->destructor(nc);
356      }
357  }
358  
359  void qemu_del_net_client(NetClientState *nc)
360  {
361      NetClientState *ncs[MAX_QUEUE_NUM];
362      int queues, i;
363      NetFilterState *nf, *next;
364  
365      assert(nc->info->type != NET_CLIENT_DRIVER_NIC);
366  
367      /* If the NetClientState belongs to a multiqueue backend, we will change all
368       * other NetClientStates also.
369       */
370      queues = qemu_find_net_clients_except(nc->name, ncs,
371                                            NET_CLIENT_DRIVER_NIC,
372                                            MAX_QUEUE_NUM);
373      assert(queues != 0);
374  
375      QTAILQ_FOREACH_SAFE(nf, &nc->filters, next, next) {
376          object_unparent(OBJECT(nf));
377      }
378  
379      /* If there is a peer NIC, delete and cleanup client, but do not free. */
380      if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
381          NICState *nic = qemu_get_nic(nc->peer);
382          if (nic->peer_deleted) {
383              return;
384          }
385          nic->peer_deleted = true;
386  
387          for (i = 0; i < queues; i++) {
388              ncs[i]->peer->link_down = true;
389          }
390  
391          if (nc->peer->info->link_status_changed) {
392              nc->peer->info->link_status_changed(nc->peer);
393          }
394  
395          for (i = 0; i < queues; i++) {
396              qemu_cleanup_net_client(ncs[i]);
397          }
398  
399          return;
400      }
401  
402      for (i = 0; i < queues; i++) {
403          qemu_cleanup_net_client(ncs[i]);
404          qemu_free_net_client(ncs[i]);
405      }
406  }
407  
408  void qemu_del_nic(NICState *nic)
409  {
410      int i, queues = MAX(nic->conf->peers.queues, 1);
411  
412      qemu_macaddr_set_free(&nic->conf->macaddr);
413  
414      /* If this is a peer NIC and peer has already been deleted, free it now. */
415      if (nic->peer_deleted) {
416          for (i = 0; i < queues; i++) {
417              qemu_free_net_client(qemu_get_subqueue(nic, i)->peer);
418          }
419      }
420  
421      for (i = queues - 1; i >= 0; i--) {
422          NetClientState *nc = qemu_get_subqueue(nic, i);
423  
424          qemu_cleanup_net_client(nc);
425          qemu_free_net_client(nc);
426      }
427  
428      g_free(nic);
429  }
430  
431  void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
432  {
433      NetClientState *nc;
434  
435      QTAILQ_FOREACH(nc, &net_clients, next) {
436          if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
437              if (nc->queue_index == 0) {
438                  func(qemu_get_nic(nc), opaque);
439              }
440          }
441      }
442  }
443  
444  bool qemu_has_ufo(NetClientState *nc)
445  {
446      if (!nc || !nc->info->has_ufo) {
447          return false;
448      }
449  
450      return nc->info->has_ufo(nc);
451  }
452  
453  bool qemu_has_vnet_hdr(NetClientState *nc)
454  {
455      if (!nc || !nc->info->has_vnet_hdr) {
456          return false;
457      }
458  
459      return nc->info->has_vnet_hdr(nc);
460  }
461  
462  bool qemu_has_vnet_hdr_len(NetClientState *nc, int len)
463  {
464      if (!nc || !nc->info->has_vnet_hdr_len) {
465          return false;
466      }
467  
468      return nc->info->has_vnet_hdr_len(nc, len);
469  }
470  
471  void qemu_using_vnet_hdr(NetClientState *nc, bool enable)
472  {
473      if (!nc || !nc->info->using_vnet_hdr) {
474          return;
475      }
476  
477      nc->info->using_vnet_hdr(nc, enable);
478  }
479  
480  void qemu_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
481                            int ecn, int ufo)
482  {
483      if (!nc || !nc->info->set_offload) {
484          return;
485      }
486  
487      nc->info->set_offload(nc, csum, tso4, tso6, ecn, ufo);
488  }
489  
490  void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
491  {
492      if (!nc || !nc->info->set_vnet_hdr_len) {
493          return;
494      }
495  
496      nc->vnet_hdr_len = len;
497      nc->info->set_vnet_hdr_len(nc, len);
498  }
499  
500  int qemu_set_vnet_le(NetClientState *nc, bool is_le)
501  {
502  #ifdef HOST_WORDS_BIGENDIAN
503      if (!nc || !nc->info->set_vnet_le) {
504          return -ENOSYS;
505      }
506  
507      return nc->info->set_vnet_le(nc, is_le);
508  #else
509      return 0;
510  #endif
511  }
512  
513  int qemu_set_vnet_be(NetClientState *nc, bool is_be)
514  {
515  #ifdef HOST_WORDS_BIGENDIAN
516      return 0;
517  #else
518      if (!nc || !nc->info->set_vnet_be) {
519          return -ENOSYS;
520      }
521  
522      return nc->info->set_vnet_be(nc, is_be);
523  #endif
524  }
525  
526  int qemu_can_send_packet(NetClientState *sender)
527  {
528      int vm_running = runstate_is_running();
529  
530      if (!vm_running) {
531          return 0;
532      }
533  
534      if (!sender->peer) {
535          return 1;
536      }
537  
538      if (sender->peer->receive_disabled) {
539          return 0;
540      } else if (sender->peer->info->can_receive &&
541                 !sender->peer->info->can_receive(sender->peer)) {
542          return 0;
543      }
544      return 1;
545  }
546  
547  static ssize_t filter_receive_iov(NetClientState *nc,
548                                    NetFilterDirection direction,
549                                    NetClientState *sender,
550                                    unsigned flags,
551                                    const struct iovec *iov,
552                                    int iovcnt,
553                                    NetPacketSent *sent_cb)
554  {
555      ssize_t ret = 0;
556      NetFilterState *nf = NULL;
557  
558      if (direction == NET_FILTER_DIRECTION_TX) {
559          QTAILQ_FOREACH(nf, &nc->filters, next) {
560              ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
561                                           iovcnt, sent_cb);
562              if (ret) {
563                  return ret;
564              }
565          }
566      } else {
567          QTAILQ_FOREACH_REVERSE(nf, &nc->filters, next) {
568              ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
569                                           iovcnt, sent_cb);
570              if (ret) {
571                  return ret;
572              }
573          }
574      }
575  
576      return ret;
577  }
578  
579  static ssize_t filter_receive(NetClientState *nc,
580                                NetFilterDirection direction,
581                                NetClientState *sender,
582                                unsigned flags,
583                                const uint8_t *data,
584                                size_t size,
585                                NetPacketSent *sent_cb)
586  {
587      struct iovec iov = {
588          .iov_base = (void *)data,
589          .iov_len = size
590      };
591  
592      return filter_receive_iov(nc, direction, sender, flags, &iov, 1, sent_cb);
593  }
594  
595  void qemu_purge_queued_packets(NetClientState *nc)
596  {
597      if (!nc->peer) {
598          return;
599      }
600  
601      qemu_net_queue_purge(nc->peer->incoming_queue, nc);
602  }
603  
604  void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge)
605  {
606      nc->receive_disabled = 0;
607  
608      if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_HUBPORT) {
609          if (net_hub_flush(nc->peer)) {
610              qemu_notify_event();
611          }
612      }
613      if (qemu_net_queue_flush(nc->incoming_queue)) {
614          /* We emptied the queue successfully, signal to the IO thread to repoll
615           * the file descriptor (for tap, for example).
616           */
617          qemu_notify_event();
618      } else if (purge) {
619          /* Unable to empty the queue, purge remaining packets */
620          qemu_net_queue_purge(nc->incoming_queue, nc->peer);
621      }
622  }
623  
624  void qemu_flush_queued_packets(NetClientState *nc)
625  {
626      qemu_flush_or_purge_queued_packets(nc, false);
627  }
628  
629  static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
630                                                   unsigned flags,
631                                                   const uint8_t *buf, int size,
632                                                   NetPacketSent *sent_cb)
633  {
634      NetQueue *queue;
635      int ret;
636  
637  #ifdef DEBUG_NET
638      printf("qemu_send_packet_async:\n");
639      qemu_hexdump((const char *)buf, stdout, "net", size);
640  #endif
641  
642      if (sender->link_down || !sender->peer) {
643          return size;
644      }
645  
646      /* Let filters handle the packet first */
647      ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
648                           sender, flags, buf, size, sent_cb);
649      if (ret) {
650          return ret;
651      }
652  
653      ret = filter_receive(sender->peer, NET_FILTER_DIRECTION_RX,
654                           sender, flags, buf, size, sent_cb);
655      if (ret) {
656          return ret;
657      }
658  
659      queue = sender->peer->incoming_queue;
660  
661      return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
662  }
663  
664  ssize_t qemu_send_packet_async(NetClientState *sender,
665                                 const uint8_t *buf, int size,
666                                 NetPacketSent *sent_cb)
667  {
668      return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
669                                               buf, size, sent_cb);
670  }
671  
672  ssize_t qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
673  {
674      return qemu_send_packet_async(nc, buf, size, NULL);
675  }
676  
677  ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
678  {
679      return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
680                                               buf, size, NULL);
681  }
682  
683  static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
684                                 int iovcnt, unsigned flags)
685  {
686      uint8_t *buf = NULL;
687      uint8_t *buffer;
688      size_t offset;
689      ssize_t ret;
690  
691      if (iovcnt == 1) {
692          buffer = iov[0].iov_base;
693          offset = iov[0].iov_len;
694      } else {
695          offset = iov_size(iov, iovcnt);
696          if (offset > NET_BUFSIZE) {
697              return -1;
698          }
699          buf = g_malloc(offset);
700          buffer = buf;
701          offset = iov_to_buf(iov, iovcnt, 0, buf, offset);
702      }
703  
704      if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
705          ret = nc->info->receive_raw(nc, buffer, offset);
706      } else {
707          ret = nc->info->receive(nc, buffer, offset);
708      }
709  
710      g_free(buf);
711      return ret;
712  }
713  
714  static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
715                                         unsigned flags,
716                                         const struct iovec *iov,
717                                         int iovcnt,
718                                         void *opaque)
719  {
720      NetClientState *nc = opaque;
721      int ret;
722  
723  
724      if (nc->link_down) {
725          return iov_size(iov, iovcnt);
726      }
727  
728      if (nc->receive_disabled) {
729          return 0;
730      }
731  
732      if (nc->info->receive_iov && !(flags & QEMU_NET_PACKET_FLAG_RAW)) {
733          ret = nc->info->receive_iov(nc, iov, iovcnt);
734      } else {
735          ret = nc_sendv_compat(nc, iov, iovcnt, flags);
736      }
737  
738      if (ret == 0) {
739          nc->receive_disabled = 1;
740      }
741  
742      return ret;
743  }
744  
745  ssize_t qemu_sendv_packet_async(NetClientState *sender,
746                                  const struct iovec *iov, int iovcnt,
747                                  NetPacketSent *sent_cb)
748  {
749      NetQueue *queue;
750      size_t size = iov_size(iov, iovcnt);
751      int ret;
752  
753      if (size > NET_BUFSIZE) {
754          return size;
755      }
756  
757      if (sender->link_down || !sender->peer) {
758          return size;
759      }
760  
761      /* Let filters handle the packet first */
762      ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
763                               QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
764      if (ret) {
765          return ret;
766      }
767  
768      ret = filter_receive_iov(sender->peer, NET_FILTER_DIRECTION_RX, sender,
769                               QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
770      if (ret) {
771          return ret;
772      }
773  
774      queue = sender->peer->incoming_queue;
775  
776      return qemu_net_queue_send_iov(queue, sender,
777                                     QEMU_NET_PACKET_FLAG_NONE,
778                                     iov, iovcnt, sent_cb);
779  }
780  
781  ssize_t
782  qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
783  {
784      return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
785  }
786  
787  NetClientState *qemu_find_netdev(const char *id)
788  {
789      NetClientState *nc;
790  
791      QTAILQ_FOREACH(nc, &net_clients, next) {
792          if (nc->info->type == NET_CLIENT_DRIVER_NIC)
793              continue;
794          if (!strcmp(nc->name, id)) {
795              return nc;
796          }
797      }
798  
799      return NULL;
800  }
801  
802  int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
803                                   NetClientDriver type, int max)
804  {
805      NetClientState *nc;
806      int ret = 0;
807  
808      QTAILQ_FOREACH(nc, &net_clients, next) {
809          if (nc->info->type == type) {
810              continue;
811          }
812          if (!id || !strcmp(nc->name, id)) {
813              if (ret < max) {
814                  ncs[ret] = nc;
815              }
816              ret++;
817          }
818      }
819  
820      return ret;
821  }
822  
823  static int nic_get_free_idx(void)
824  {
825      int index;
826  
827      for (index = 0; index < MAX_NICS; index++)
828          if (!nd_table[index].used)
829              return index;
830      return -1;
831  }
832  
833  int qemu_show_nic_models(const char *arg, const char *const *models)
834  {
835      int i;
836  
837      if (!arg || !is_help_option(arg)) {
838          return 0;
839      }
840  
841      printf("Supported NIC models:\n");
842      for (i = 0 ; models[i]; i++) {
843          printf("%s\n", models[i]);
844      }
845      return 1;
846  }
847  
848  void qemu_check_nic_model(NICInfo *nd, const char *model)
849  {
850      const char *models[2];
851  
852      models[0] = model;
853      models[1] = NULL;
854  
855      if (qemu_show_nic_models(nd->model, models))
856          exit(0);
857      if (qemu_find_nic_model(nd, models, model) < 0)
858          exit(1);
859  }
860  
861  int qemu_find_nic_model(NICInfo *nd, const char * const *models,
862                          const char *default_model)
863  {
864      int i;
865  
866      if (!nd->model)
867          nd->model = g_strdup(default_model);
868  
869      for (i = 0 ; models[i]; i++) {
870          if (strcmp(nd->model, models[i]) == 0)
871              return i;
872      }
873  
874      error_report("Unsupported NIC model: %s", nd->model);
875      return -1;
876  }
877  
878  static int net_init_nic(const Netdev *netdev, const char *name,
879                          NetClientState *peer, Error **errp)
880  {
881      int idx;
882      NICInfo *nd;
883      const NetLegacyNicOptions *nic;
884  
885      assert(netdev->type == NET_CLIENT_DRIVER_NIC);
886      nic = &netdev->u.nic;
887  
888      idx = nic_get_free_idx();
889      if (idx == -1 || nb_nics >= MAX_NICS) {
890          error_setg(errp, "too many NICs");
891          return -1;
892      }
893  
894      nd = &nd_table[idx];
895  
896      memset(nd, 0, sizeof(*nd));
897  
898      if (nic->has_netdev) {
899          nd->netdev = qemu_find_netdev(nic->netdev);
900          if (!nd->netdev) {
901              error_setg(errp, "netdev '%s' not found", nic->netdev);
902              return -1;
903          }
904      } else {
905          assert(peer);
906          nd->netdev = peer;
907      }
908      nd->name = g_strdup(name);
909      if (nic->has_model) {
910          nd->model = g_strdup(nic->model);
911      }
912      if (nic->has_addr) {
913          nd->devaddr = g_strdup(nic->addr);
914      }
915  
916      if (nic->has_macaddr &&
917          net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
918          error_setg(errp, "invalid syntax for ethernet address");
919          return -1;
920      }
921      if (nic->has_macaddr &&
922          is_multicast_ether_addr(nd->macaddr.a)) {
923          error_setg(errp,
924                     "NIC cannot have multicast MAC address (odd 1st byte)");
925          return -1;
926      }
927      qemu_macaddr_default_if_unset(&nd->macaddr);
928  
929      if (nic->has_vectors) {
930          if (nic->vectors > 0x7ffffff) {
931              error_setg(errp, "invalid # of vectors: %"PRIu32, nic->vectors);
932              return -1;
933          }
934          nd->nvectors = nic->vectors;
935      } else {
936          nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
937      }
938  
939      nd->used = 1;
940      nb_nics++;
941  
942      return idx;
943  }
944  
945  
946  static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
947      const Netdev *netdev,
948      const char *name,
949      NetClientState *peer, Error **errp) = {
950          [NET_CLIENT_DRIVER_NIC]       = net_init_nic,
951  #ifdef CONFIG_SLIRP
952          [NET_CLIENT_DRIVER_USER]      = net_init_slirp,
953  #endif
954          [NET_CLIENT_DRIVER_TAP]       = net_init_tap,
955          [NET_CLIENT_DRIVER_SOCKET]    = net_init_socket,
956  #ifdef CONFIG_VDE
957          [NET_CLIENT_DRIVER_VDE]       = net_init_vde,
958  #endif
959  #ifdef CONFIG_NETMAP
960          [NET_CLIENT_DRIVER_NETMAP]    = net_init_netmap,
961  #endif
962  #ifdef CONFIG_NET_BRIDGE
963          [NET_CLIENT_DRIVER_BRIDGE]    = net_init_bridge,
964  #endif
965          [NET_CLIENT_DRIVER_HUBPORT]   = net_init_hubport,
966  #ifdef CONFIG_VHOST_NET_USER
967          [NET_CLIENT_DRIVER_VHOST_USER] = net_init_vhost_user,
968  #endif
969  #ifdef CONFIG_VHOST_NET_VDPA
970          [NET_CLIENT_DRIVER_VHOST_VDPA] = net_init_vhost_vdpa,
971  #endif
972  #ifdef CONFIG_L2TPV3
973          [NET_CLIENT_DRIVER_L2TPV3]    = net_init_l2tpv3,
974  #endif
975  };
976  
977  
978  static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
979  {
980      NetClientState *peer = NULL;
981  
982      if (is_netdev) {
983          if (netdev->type == NET_CLIENT_DRIVER_NIC ||
984              !net_client_init_fun[netdev->type]) {
985              error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
986                         "a netdev backend type");
987              return -1;
988          }
989      } else {
990          if (netdev->type == NET_CLIENT_DRIVER_NONE) {
991              return 0; /* nothing to do */
992          }
993          if (netdev->type == NET_CLIENT_DRIVER_HUBPORT ||
994              !net_client_init_fun[netdev->type]) {
995              error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
996                         "a net backend type (maybe it is not compiled "
997                         "into this binary)");
998              return -1;
999          }
1000  
1001          /* Do not add to a hub if it's a nic with a netdev= parameter. */
1002          if (netdev->type != NET_CLIENT_DRIVER_NIC ||
1003              !netdev->u.nic.has_netdev) {
1004              peer = net_hub_add_port(0, NULL, NULL);
1005          }
1006      }
1007  
1008      if (net_client_init_fun[netdev->type](netdev, netdev->id, peer, errp) < 0) {
1009          /* FIXME drop when all init functions store an Error */
1010          if (errp && !*errp) {
1011              error_setg(errp, QERR_DEVICE_INIT_FAILED,
1012                         NetClientDriver_str(netdev->type));
1013          }
1014          return -1;
1015      }
1016  
1017      if (is_netdev) {
1018          NetClientState *nc;
1019  
1020          nc = qemu_find_netdev(netdev->id);
1021          assert(nc);
1022          nc->is_netdev = true;
1023      }
1024  
1025      return 0;
1026  }
1027  
1028  static void show_netdevs(void)
1029  {
1030      int idx;
1031      const char *available_netdevs[] = {
1032          "socket",
1033          "hubport",
1034          "tap",
1035  #ifdef CONFIG_SLIRP
1036          "user",
1037  #endif
1038  #ifdef CONFIG_L2TPV3
1039          "l2tpv3",
1040  #endif
1041  #ifdef CONFIG_VDE
1042          "vde",
1043  #endif
1044  #ifdef CONFIG_NET_BRIDGE
1045          "bridge",
1046  #endif
1047  #ifdef CONFIG_NETMAP
1048          "netmap",
1049  #endif
1050  #ifdef CONFIG_POSIX
1051          "vhost-user",
1052  #endif
1053      };
1054  
1055      printf("Available netdev backend types:\n");
1056      for (idx = 0; idx < ARRAY_SIZE(available_netdevs); idx++) {
1057          puts(available_netdevs[idx]);
1058      }
1059  }
1060  
1061  static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)
1062  {
1063      gchar **substrings = NULL;
1064      Netdev *object = NULL;
1065      int ret = -1;
1066      Visitor *v = opts_visitor_new(opts);
1067  
1068      const char *type = qemu_opt_get(opts, "type");
1069  
1070      if (is_netdev && type && is_help_option(type)) {
1071          show_netdevs();
1072          exit(0);
1073      } else {
1074          /* Parse convenience option format ip6-net=fec0::0[/64] */
1075          const char *ip6_net = qemu_opt_get(opts, "ipv6-net");
1076  
1077          if (ip6_net) {
1078              char *prefix_addr;
1079              unsigned long prefix_len = 64; /* Default 64bit prefix length. */
1080  
1081              substrings = g_strsplit(ip6_net, "/", 2);
1082              if (!substrings || !substrings[0]) {
1083                  error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "ipv6-net",
1084                             "a valid IPv6 prefix");
1085                  goto out;
1086              }
1087  
1088              prefix_addr = substrings[0];
1089  
1090              /* Handle user-specified prefix length. */
1091              if (substrings[1] &&
1092                  qemu_strtoul(substrings[1], NULL, 10, &prefix_len))
1093              {
1094                  error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1095                             "ipv6-prefixlen", "a number");
1096                  goto out;
1097              }
1098  
1099              qemu_opt_set(opts, "ipv6-prefix", prefix_addr, &error_abort);
1100              qemu_opt_set_number(opts, "ipv6-prefixlen", prefix_len,
1101                                  &error_abort);
1102              qemu_opt_unset(opts, "ipv6-net");
1103          }
1104      }
1105  
1106      /* Create an ID for -net if the user did not specify one */
1107      if (!is_netdev && !qemu_opts_id(opts)) {
1108          static int idx;
1109          qemu_opts_set_id(opts, g_strdup_printf("__org.qemu.net%i", idx++));
1110      }
1111  
1112      if (visit_type_Netdev(v, NULL, &object, errp)) {
1113          ret = net_client_init1(object, is_netdev, errp);
1114      }
1115  
1116      qapi_free_Netdev(object);
1117  
1118  out:
1119      g_strfreev(substrings);
1120      visit_free(v);
1121      return ret;
1122  }
1123  
1124  void netdev_add(QemuOpts *opts, Error **errp)
1125  {
1126      net_client_init(opts, true, errp);
1127  }
1128  
1129  void qmp_netdev_add(Netdev *netdev, Error **errp)
1130  {
1131      net_client_init1(netdev, true, errp);
1132  }
1133  
1134  void qmp_netdev_del(const char *id, Error **errp)
1135  {
1136      NetClientState *nc;
1137  
1138      nc = qemu_find_netdev(id);
1139      if (!nc) {
1140          error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1141                    "Device '%s' not found", id);
1142          return;
1143      }
1144  
1145      if (!nc->is_netdev) {
1146          error_setg(errp, "Device '%s' is not a netdev", id);
1147          return;
1148      }
1149  
1150      qemu_del_net_client(nc);
1151  }
1152  
1153  static void netfilter_print_info(Monitor *mon, NetFilterState *nf)
1154  {
1155      char *str;
1156      ObjectProperty *prop;
1157      ObjectPropertyIterator iter;
1158      Visitor *v;
1159  
1160      /* generate info str */
1161      object_property_iter_init(&iter, OBJECT(nf));
1162      while ((prop = object_property_iter_next(&iter))) {
1163          if (!strcmp(prop->name, "type")) {
1164              continue;
1165          }
1166          v = string_output_visitor_new(false, &str);
1167          object_property_get(OBJECT(nf), prop->name, v, NULL);
1168          visit_complete(v, &str);
1169          visit_free(v);
1170          monitor_printf(mon, ",%s=%s", prop->name, str);
1171          g_free(str);
1172      }
1173      monitor_printf(mon, "\n");
1174  }
1175  
1176  void print_net_client(Monitor *mon, NetClientState *nc)
1177  {
1178      NetFilterState *nf;
1179  
1180      monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
1181                     nc->queue_index,
1182                     NetClientDriver_str(nc->info->type),
1183                     nc->info_str);
1184      if (!QTAILQ_EMPTY(&nc->filters)) {
1185          monitor_printf(mon, "filters:\n");
1186      }
1187      QTAILQ_FOREACH(nf, &nc->filters, next) {
1188          monitor_printf(mon, "  - %s: type=%s",
1189                         object_get_canonical_path_component(OBJECT(nf)),
1190                         object_get_typename(OBJECT(nf)));
1191          netfilter_print_info(mon, nf);
1192      }
1193  }
1194  
1195  RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
1196                                        Error **errp)
1197  {
1198      NetClientState *nc;
1199      RxFilterInfoList *filter_list = NULL, *last_entry = NULL;
1200  
1201      QTAILQ_FOREACH(nc, &net_clients, next) {
1202          RxFilterInfoList *entry;
1203          RxFilterInfo *info;
1204  
1205          if (has_name && strcmp(nc->name, name) != 0) {
1206              continue;
1207          }
1208  
1209          /* only query rx-filter information of NIC */
1210          if (nc->info->type != NET_CLIENT_DRIVER_NIC) {
1211              if (has_name) {
1212                  error_setg(errp, "net client(%s) isn't a NIC", name);
1213                  return NULL;
1214              }
1215              continue;
1216          }
1217  
1218          /* only query information on queue 0 since the info is per nic,
1219           * not per queue
1220           */
1221          if (nc->queue_index != 0)
1222              continue;
1223  
1224          if (nc->info->query_rx_filter) {
1225              info = nc->info->query_rx_filter(nc);
1226              entry = g_malloc0(sizeof(*entry));
1227              entry->value = info;
1228  
1229              if (!filter_list) {
1230                  filter_list = entry;
1231              } else {
1232                  last_entry->next = entry;
1233              }
1234              last_entry = entry;
1235          } else if (has_name) {
1236              error_setg(errp, "net client(%s) doesn't support"
1237                         " rx-filter querying", name);
1238              return NULL;
1239          }
1240  
1241          if (has_name) {
1242              break;
1243          }
1244      }
1245  
1246      if (filter_list == NULL && has_name) {
1247          error_setg(errp, "invalid net client name: %s", name);
1248      }
1249  
1250      return filter_list;
1251  }
1252  
1253  void hmp_info_network(Monitor *mon, const QDict *qdict)
1254  {
1255      NetClientState *nc, *peer;
1256      NetClientDriver type;
1257  
1258      net_hub_info(mon);
1259  
1260      QTAILQ_FOREACH(nc, &net_clients, next) {
1261          peer = nc->peer;
1262          type = nc->info->type;
1263  
1264          /* Skip if already printed in hub info */
1265          if (net_hub_id_for_client(nc, NULL) == 0) {
1266              continue;
1267          }
1268  
1269          if (!peer || type == NET_CLIENT_DRIVER_NIC) {
1270              print_net_client(mon, nc);
1271          } /* else it's a netdev connected to a NIC, printed with the NIC */
1272          if (peer && type == NET_CLIENT_DRIVER_NIC) {
1273              monitor_printf(mon, " \\ ");
1274              print_net_client(mon, peer);
1275          }
1276      }
1277  }
1278  
1279  void colo_notify_filters_event(int event, Error **errp)
1280  {
1281      NetClientState *nc;
1282      NetFilterState *nf;
1283      NetFilterClass *nfc = NULL;
1284      Error *local_err = NULL;
1285  
1286      QTAILQ_FOREACH(nc, &net_clients, next) {
1287          QTAILQ_FOREACH(nf, &nc->filters, next) {
1288              nfc = NETFILTER_GET_CLASS(OBJECT(nf));
1289              nfc->handle_event(nf, event, &local_err);
1290              if (local_err) {
1291                  error_propagate(errp, local_err);
1292                  return;
1293              }
1294          }
1295      }
1296  }
1297  
1298  void qmp_set_link(const char *name, bool up, Error **errp)
1299  {
1300      NetClientState *ncs[MAX_QUEUE_NUM];
1301      NetClientState *nc;
1302      int queues, i;
1303  
1304      queues = qemu_find_net_clients_except(name, ncs,
1305                                            NET_CLIENT_DRIVER__MAX,
1306                                            MAX_QUEUE_NUM);
1307  
1308      if (queues == 0) {
1309          error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1310                    "Device '%s' not found", name);
1311          return;
1312      }
1313      nc = ncs[0];
1314  
1315      for (i = 0; i < queues; i++) {
1316          ncs[i]->link_down = !up;
1317      }
1318  
1319      if (nc->info->link_status_changed) {
1320          nc->info->link_status_changed(nc);
1321      }
1322  
1323      if (nc->peer) {
1324          /* Change peer link only if the peer is NIC and then notify peer.
1325           * If the peer is a HUBPORT or a backend, we do not change the
1326           * link status.
1327           *
1328           * This behavior is compatible with qemu hubs where there could be
1329           * multiple clients that can still communicate with each other in
1330           * disconnected mode. For now maintain this compatibility.
1331           */
1332          if (nc->peer->info->type == NET_CLIENT_DRIVER_NIC) {
1333              for (i = 0; i < queues; i++) {
1334                  ncs[i]->peer->link_down = !up;
1335              }
1336          }
1337          if (nc->peer->info->link_status_changed) {
1338              nc->peer->info->link_status_changed(nc->peer);
1339          }
1340      }
1341  }
1342  
1343  static void net_vm_change_state_handler(void *opaque, int running,
1344                                          RunState state)
1345  {
1346      NetClientState *nc;
1347      NetClientState *tmp;
1348  
1349      QTAILQ_FOREACH_SAFE(nc, &net_clients, next, tmp) {
1350          if (running) {
1351              /* Flush queued packets and wake up backends. */
1352              if (nc->peer && qemu_can_send_packet(nc)) {
1353                  qemu_flush_queued_packets(nc->peer);
1354              }
1355          } else {
1356              /* Complete all queued packets, to guarantee we don't modify
1357               * state later when VM is not running.
1358               */
1359              qemu_flush_or_purge_queued_packets(nc, true);
1360          }
1361      }
1362  }
1363  
1364  void net_cleanup(void)
1365  {
1366      NetClientState *nc;
1367  
1368      /* We may del multiple entries during qemu_del_net_client(),
1369       * so QTAILQ_FOREACH_SAFE() is also not safe here.
1370       */
1371      while (!QTAILQ_EMPTY(&net_clients)) {
1372          nc = QTAILQ_FIRST(&net_clients);
1373          if (nc->info->type == NET_CLIENT_DRIVER_NIC) {
1374              qemu_del_nic(qemu_get_nic(nc));
1375          } else {
1376              qemu_del_net_client(nc);
1377          }
1378      }
1379  
1380      qemu_del_vm_change_state_handler(net_change_state_entry);
1381  }
1382  
1383  void net_check_clients(void)
1384  {
1385      NetClientState *nc;
1386      int i;
1387  
1388      net_hub_check_clients();
1389  
1390      QTAILQ_FOREACH(nc, &net_clients, next) {
1391          if (!nc->peer) {
1392              warn_report("%s %s has no peer",
1393                          nc->info->type == NET_CLIENT_DRIVER_NIC
1394                          ? "nic" : "netdev",
1395                          nc->name);
1396          }
1397      }
1398  
1399      /* Check that all NICs requested via -net nic actually got created.
1400       * NICs created via -device don't need to be checked here because
1401       * they are always instantiated.
1402       */
1403      for (i = 0; i < MAX_NICS; i++) {
1404          NICInfo *nd = &nd_table[i];
1405          if (nd->used && !nd->instantiated) {
1406              warn_report("requested NIC (%s, model %s) "
1407                          "was not created (not supported by this machine?)",
1408                          nd->name ? nd->name : "anonymous",
1409                          nd->model ? nd->model : "unspecified");
1410          }
1411      }
1412  }
1413  
1414  static int net_init_client(void *dummy, QemuOpts *opts, Error **errp)
1415  {
1416      return net_client_init(opts, false, errp);
1417  }
1418  
1419  static int net_init_netdev(void *dummy, QemuOpts *opts, Error **errp)
1420  {
1421      return net_client_init(opts, true, errp);
1422  }
1423  
1424  /* For the convenience "--nic" parameter */
1425  static int net_param_nic(void *dummy, QemuOpts *opts, Error **errp)
1426  {
1427      char *mac, *nd_id;
1428      int idx, ret;
1429      NICInfo *ni;
1430      const char *type;
1431  
1432      type = qemu_opt_get(opts, "type");
1433      if (type && g_str_equal(type, "none")) {
1434          return 0;    /* Nothing to do, default_net is cleared in vl.c */
1435      }
1436  
1437      idx = nic_get_free_idx();
1438      if (idx == -1 || nb_nics >= MAX_NICS) {
1439          error_setg(errp, "no more on-board/default NIC slots available");
1440          return -1;
1441      }
1442  
1443      if (!type) {
1444          qemu_opt_set(opts, "type", "user", &error_abort);
1445      }
1446  
1447      ni = &nd_table[idx];
1448      memset(ni, 0, sizeof(*ni));
1449      ni->model = qemu_opt_get_del(opts, "model");
1450  
1451      /* Create an ID if the user did not specify one */
1452      nd_id = g_strdup(qemu_opts_id(opts));
1453      if (!nd_id) {
1454          nd_id = g_strdup_printf("__org.qemu.nic%i", idx);
1455          qemu_opts_set_id(opts, nd_id);
1456      }
1457  
1458      /* Handle MAC address */
1459      mac = qemu_opt_get_del(opts, "mac");
1460      if (mac) {
1461          ret = net_parse_macaddr(ni->macaddr.a, mac);
1462          g_free(mac);
1463          if (ret) {
1464              error_setg(errp, "invalid syntax for ethernet address");
1465              goto out;
1466          }
1467          if (is_multicast_ether_addr(ni->macaddr.a)) {
1468              error_setg(errp, "NIC cannot have multicast MAC address");
1469              ret = -1;
1470              goto out;
1471          }
1472      }
1473      qemu_macaddr_default_if_unset(&ni->macaddr);
1474  
1475      ret = net_client_init(opts, true, errp);
1476      if (ret == 0) {
1477          ni->netdev = qemu_find_netdev(nd_id);
1478          ni->used = true;
1479          nb_nics++;
1480      }
1481  
1482  out:
1483      g_free(nd_id);
1484      return ret;
1485  }
1486  
1487  int net_init_clients(Error **errp)
1488  {
1489      net_change_state_entry =
1490          qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
1491  
1492      QTAILQ_INIT(&net_clients);
1493  
1494      if (qemu_opts_foreach(qemu_find_opts("netdev"),
1495                            net_init_netdev, NULL, errp)) {
1496          return -1;
1497      }
1498  
1499      if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL, errp)) {
1500          return -1;
1501      }
1502  
1503      if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL, errp)) {
1504          return -1;
1505      }
1506  
1507      return 0;
1508  }
1509  
1510  int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1511  {
1512      if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
1513          return -1;
1514      }
1515  
1516      return 0;
1517  }
1518  
1519  /* From FreeBSD */
1520  /* XXX: optimize */
1521  uint32_t net_crc32(const uint8_t *p, int len)
1522  {
1523      uint32_t crc;
1524      int carry, i, j;
1525      uint8_t b;
1526  
1527      crc = 0xffffffff;
1528      for (i = 0; i < len; i++) {
1529          b = *p++;
1530          for (j = 0; j < 8; j++) {
1531              carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
1532              crc <<= 1;
1533              b >>= 1;
1534              if (carry) {
1535                  crc = ((crc ^ POLYNOMIAL_BE) | carry);
1536              }
1537          }
1538      }
1539  
1540      return crc;
1541  }
1542  
1543  uint32_t net_crc32_le(const uint8_t *p, int len)
1544  {
1545      uint32_t crc;
1546      int carry, i, j;
1547      uint8_t b;
1548  
1549      crc = 0xffffffff;
1550      for (i = 0; i < len; i++) {
1551          b = *p++;
1552          for (j = 0; j < 8; j++) {
1553              carry = (crc & 0x1) ^ (b & 0x01);
1554              crc >>= 1;
1555              b >>= 1;
1556              if (carry) {
1557                  crc ^= POLYNOMIAL_LE;
1558              }
1559          }
1560      }
1561  
1562      return crc;
1563  }
1564  
1565  QemuOptsList qemu_netdev_opts = {
1566      .name = "netdev",
1567      .implied_opt_name = "type",
1568      .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
1569      .desc = {
1570          /*
1571           * no elements => accept any params
1572           * validation will happen later
1573           */
1574          { /* end of list */ }
1575      },
1576  };
1577  
1578  QemuOptsList qemu_nic_opts = {
1579      .name = "nic",
1580      .implied_opt_name = "type",
1581      .head = QTAILQ_HEAD_INITIALIZER(qemu_nic_opts.head),
1582      .desc = {
1583          /*
1584           * no elements => accept any params
1585           * validation will happen later
1586           */
1587          { /* end of list */ }
1588      },
1589  };
1590  
1591  QemuOptsList qemu_net_opts = {
1592      .name = "net",
1593      .implied_opt_name = "type",
1594      .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
1595      .desc = {
1596          /*
1597           * no elements => accept any params
1598           * validation will happen later
1599           */
1600          { /* end of list */ }
1601      },
1602  };
1603  
1604  void net_socket_rs_init(SocketReadState *rs,
1605                          SocketReadStateFinalize *finalize,
1606                          bool vnet_hdr)
1607  {
1608      rs->state = 0;
1609      rs->vnet_hdr = vnet_hdr;
1610      rs->index = 0;
1611      rs->packet_len = 0;
1612      rs->vnet_hdr_len = 0;
1613      memset(rs->buf, 0, sizeof(rs->buf));
1614      rs->finalize = finalize;
1615  }
1616  
1617  /*
1618   * Returns
1619   * 0: success
1620   * -1: error occurs
1621   */
1622  int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
1623  {
1624      unsigned int l;
1625  
1626      while (size > 0) {
1627          /* Reassemble a packet from the network.
1628           * 0 = getting length.
1629           * 1 = getting vnet header length.
1630           * 2 = getting data.
1631           */
1632          switch (rs->state) {
1633          case 0:
1634              l = 4 - rs->index;
1635              if (l > size) {
1636                  l = size;
1637              }
1638              memcpy(rs->buf + rs->index, buf, l);
1639              buf += l;
1640              size -= l;
1641              rs->index += l;
1642              if (rs->index == 4) {
1643                  /* got length */
1644                  rs->packet_len = ntohl(*(uint32_t *)rs->buf);
1645                  rs->index = 0;
1646                  if (rs->vnet_hdr) {
1647                      rs->state = 1;
1648                  } else {
1649                      rs->state = 2;
1650                      rs->vnet_hdr_len = 0;
1651                  }
1652              }
1653              break;
1654          case 1:
1655              l = 4 - rs->index;
1656              if (l > size) {
1657                  l = size;
1658              }
1659              memcpy(rs->buf + rs->index, buf, l);
1660              buf += l;
1661              size -= l;
1662              rs->index += l;
1663              if (rs->index == 4) {
1664                  /* got vnet header length */
1665                  rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
1666                  rs->index = 0;
1667                  rs->state = 2;
1668              }
1669              break;
1670          case 2:
1671              l = rs->packet_len - rs->index;
1672              if (l > size) {
1673                  l = size;
1674              }
1675              if (rs->index + l <= sizeof(rs->buf)) {
1676                  memcpy(rs->buf + rs->index, buf, l);
1677              } else {
1678                  fprintf(stderr, "serious error: oversized packet received,"
1679                      "connection terminated.\n");
1680                  rs->index = rs->state = 0;
1681                  return -1;
1682              }
1683  
1684              rs->index += l;
1685              buf += l;
1686              size -= l;
1687              if (rs->index >= rs->packet_len) {
1688                  rs->index = 0;
1689                  rs->state = 0;
1690                  assert(rs->finalize);
1691                  rs->finalize(rs);
1692              }
1693              break;
1694          }
1695      }
1696  
1697      assert(size == 0);
1698      return 0;
1699  }
1700