net/l2tpv3.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  * Copyright (c) 2012-2014 Cisco Systems
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include <linux/ip.h>
  27 #include <netdb.h>
  28 #include "config-host.h"
  29 #include "net/net.h"
  30 #include "clients.h"
  31 #include "monitor/monitor.h"
  32 #include "qemu-common.h"
  33 #include "qemu/error-report.h"
  34 #include "qemu/option.h"
  35 #include "qemu/sockets.h"
  36 #include "qemu/iov.h"
  37 #include "qemu/main-loop.h"
  38
  39
  40 /* The buffer size needs to be investigated for optimum numbers and
  41  * optimum means of paging in on different systems. This size is
  42  * chosen to be sufficient to accommodate one packet with some headers
  43  */
  44
  45 #define BUFFER_ALIGN sysconf(_SC_PAGESIZE)
  46 #define BUFFER_SIZE 2048
  47 #define IOVSIZE 2
  48 #define MAX_L2TPV3_MSGCNT 64
  49 #define MAX_L2TPV3_IOVCNT (MAX_L2TPV3_MSGCNT * IOVSIZE)
  50
  51 /* Header set to 0x30000 signifies a data packet */
  52
  53 #define L2TPV3_DATA_PACKET 0x30000
  54
  55 /* IANA-assigned IP protocol ID for L2TPv3 */
  56
  57 #ifndef IPPROTO_L2TP
  58 #define IPPROTO_L2TP 0x73
  59 #endif
  60
  61 typedef struct NetL2TPV3State {
  62     NetClientState nc;
  63     int fd;
  64
  65     /*
  66      * these are used for xmit - that happens packet a time
  67      * and for first sign of life packet (easier to parse that once)
  68      */
  69
  70     uint8_t *header_buf;
  71     struct iovec *vec;
  72
  73     /*
  74      * these are used for receive - try to "eat" up to 32 packets at a time
  75      */
  76
  77     struct mmsghdr *msgvec;
  78
  79     /*
  80      * peer address
  81      */
  82
  83     struct sockaddr_storage *dgram_dst;
  84     uint32_t dst_size;
  85
  86     /*
  87      * L2TPv3 parameters
  88      */
  89
  90     uint64_t rx_cookie;
  91     uint64_t tx_cookie;
  92     uint32_t rx_session;
  93     uint32_t tx_session;
  94     uint32_t header_size;
  95     uint32_t counter;
  96
  97     /*
  98     * DOS avoidance in error handling
  99     */
 100
 101     bool header_mismatch;
 102
 103     /*
 104      * Ring buffer handling
 105      */
 106
 107     int queue_head;
 108     int queue_tail;
 109     int queue_depth;
 110
 111     /*
 112      * Precomputed offsets
 113      */
 114
 115     uint32_t offset;
 116     uint32_t cookie_offset;
 117     uint32_t counter_offset;
 118     uint32_t session_offset;
 119
 120     /* Poll Control */
 121
 122     bool read_poll;
 123     bool write_poll;
 124
 125     /* Flags */
 126
 127     bool ipv6;
 128     bool udp;
 129     bool has_counter;
 130     bool pin_counter;
 131     bool cookie;
 132     bool cookie_is_64;
 133
 134 } NetL2TPV3State;
 135
 136 static void net_l2tpv3_send(void *opaque);
 137 static void l2tpv3_writable(void *opaque);
 138
 139 static void l2tpv3_update_fd_handler(NetL2TPV3State *s)
 140 {
 141     qemu_set_fd_handler(s->fd,
 142                         s->read_poll ? net_l2tpv3_send : NULL,
 143                         s->write_poll ? l2tpv3_writable : NULL,
 144                         s);
 145 }
 146
 147 static void l2tpv3_read_poll(NetL2TPV3State *s, bool enable)
 148 {
 149     if (s->read_poll != enable) {
 150         s->read_poll = enable;
 151         l2tpv3_update_fd_handler(s);
 152     }
 153 }
 154
 155 static void l2tpv3_write_poll(NetL2TPV3State *s, bool enable)
 156 {
 157     if (s->write_poll != enable) {
 158         s->write_poll = enable;
 159         l2tpv3_update_fd_handler(s);
 160     }
 161 }
 162
 163 static void l2tpv3_writable(void *opaque)
 164 {
 165     NetL2TPV3State *s = opaque;
 166     l2tpv3_write_poll(s, false);
 167     qemu_flush_queued_packets(&s->nc);
 168 }
 169
 170 static void l2tpv3_send_completed(NetClientState *nc, ssize_t len)
 171 {
 172     NetL2TPV3State *s = DO_UPCAST(NetL2TPV3State, nc, nc);
 173     l2tpv3_read_poll(s, true);
 174 }
 175
 176 static void l2tpv3_poll(NetClientState *nc, bool enable)
 177 {
 178     NetL2TPV3State *s = DO_UPCAST(NetL2TPV3State, nc, nc);
 179     l2tpv3_write_poll(s, enable);
 180     l2tpv3_read_poll(s, enable);
 181 }
 182
 183 static void l2tpv3_form_header(NetL2TPV3State *s)
 184 {
 185     uint32_t *counter;
 186
 187     if (s->udp) {
 188         stl_be_p((uint32_t *) s->header_buf, L2TPV3_DATA_PACKET);
 189     }
 190     stl_be_p(
 191             (uint32_t *) (s->header_buf + s->session_offset),
 192             s->tx_session
 193         );
 194     if (s->cookie) {
 195         if (s->cookie_is_64) {
 196             stq_be_p(
 197                 (uint64_t *)(s->header_buf + s->cookie_offset),
 198                 s->tx_cookie
 199             );
 200         } else {
 201             stl_be_p(
 202                 (uint32_t *) (s->header_buf + s->cookie_offset),
 203                 s->tx_cookie
 204             );
 205         }
 206     }
 207     if (s->has_counter) {
 208         counter = (uint32_t *)(s->header_buf + s->counter_offset);
 209         if (s->pin_counter) {
 210             *counter = 0;
 211         } else {
 212             stl_be_p(counter, ++s->counter);
 213         }
 214     }
 215 }
 216
 217 static ssize_t net_l2tpv3_receive_dgram_iov(NetClientState *nc,
 218                     const struct iovec *iov,
 219                     int iovcnt)
 220 {
 221     NetL2TPV3State *s = DO_UPCAST(NetL2TPV3State, nc, nc);
 222
 223     struct msghdr message;
 224     int ret;
 225
 226     if (iovcnt > MAX_L2TPV3_IOVCNT - 1) {
 227         error_report(
 228             "iovec too long %d > %d, change l2tpv3.h",
 229             iovcnt, MAX_L2TPV3_IOVCNT
 230         );
 231         return -1;
 232     }
 233     l2tpv3_form_header(s);
 234     memcpy(s->vec + 1, iov, iovcnt * sizeof(struct iovec));
 235     s->vec->iov_base = s->header_buf;
 236     s->vec->iov_len = s->offset;
 237     message.msg_name = s->dgram_dst;
 238     message.msg_namelen = s->dst_size;
 239     message.msg_iov = s->vec;
 240     message.msg_iovlen = iovcnt + 1;
 241     message.msg_control = NULL;
 242     message.msg_controllen = 0;
 243     message.msg_flags = 0;
 244     do {
 245         ret = sendmsg(s->fd, &message, 0);
 246     } while ((ret == -1) && (errno == EINTR));
 247     if (ret > 0) {
 248         ret -= s->offset;
 249     } else if (ret == 0) {
 250         /* belt and braces - should not occur on DGRAM
 251         * we should get an error and never a 0 send
 252         */
 253         ret = iov_size(iov, iovcnt);
 254     } else {
 255         /* signal upper layer that socket buffer is full */
 256         ret = -errno;
 257         if (ret == -EAGAIN || ret == -ENOBUFS) {
 258             l2tpv3_write_poll(s, true);
 259             ret = 0;
 260         }
 261     }
 262     return ret;
 263 }
 264
 265 static ssize_t net_l2tpv3_receive_dgram(NetClientState *nc,
 266                     const uint8_t *buf,
 267                     size_t size)
 268 {
 269     NetL2TPV3State *s = DO_UPCAST(NetL2TPV3State, nc, nc);
 270
 271     struct iovec *vec;
 272     struct msghdr message;
 273     ssize_t ret = 0;
 274
 275     l2tpv3_form_header(s);
 276     vec = s->vec;
 277     vec->iov_base = s->header_buf;
 278     vec->iov_len = s->offset;
 279     vec++;
 280     vec->iov_base = (void *) buf;
 281     vec->iov_len = size;
 282     message.msg_name = s->dgram_dst;
 283     message.msg_namelen = s->dst_size;
 284     message.msg_iov = s->vec;
 285     message.msg_iovlen = 2;
 286     message.msg_control = NULL;
 287     message.msg_controllen = 0;
 288     message.msg_flags = 0;
 289     do {
 290         ret = sendmsg(s->fd, &message, 0);
 291     } while ((ret == -1) && (errno == EINTR));
 292     if (ret > 0) {
 293         ret -= s->offset;
 294     } else if (ret == 0) {
 295         /* belt and braces - should not occur on DGRAM
 296         * we should get an error and never a 0 send
 297         */
 298         ret = size;
 299     } else {
 300         ret = -errno;
 301         if (ret == -EAGAIN || ret == -ENOBUFS) {
 302             /* signal upper layer that socket buffer is full */
 303             l2tpv3_write_poll(s, true);
 304             ret = 0;
 305         }
 306     }
 307     return ret;
 308 }
 309
 310 static int l2tpv3_verify_header(NetL2TPV3State *s, uint8_t *buf)
 311 {
 312
 313     uint32_t *session;
 314     uint64_t cookie;
 315
 316     if ((!s->udp) && (!s->ipv6)) {
 317         buf += sizeof(struct iphdr) /* fix for ipv4 raw */;
 318     }
 319
 320     /* we do not do a strict check for "data" packets as per
 321     * the RFC spec because the pure IP spec does not have
 322     * that anyway.
 323     */
 324
 325     if (s->cookie) {
 326         if (s->cookie_is_64) {
 327             cookie = ldq_be_p(buf + s->cookie_offset);
 328         } else {
 329             cookie = ldl_be_p(buf + s->cookie_offset);
 330         }
 331         if (cookie != s->rx_cookie) {
 332             if (!s->header_mismatch) {
 333                 error_report("unknown cookie id");
 334             }
 335             return -1;
 336         }
 337     }
 338     session = (uint32_t *) (buf + s->session_offset);
 339     if (ldl_be_p(session) != s->rx_session) {
 340         if (!s->header_mismatch) {
 341             error_report("session mismatch");
 342         }
 343         return -1;
 344     }
 345     return 0;
 346 }
 347
 348 static void net_l2tpv3_process_queue(NetL2TPV3State *s)
 349 {
 350     int size = 0;
 351     struct iovec *vec;
 352     bool bad_read;
 353     int data_size;
 354     struct mmsghdr *msgvec;
 355
 356     /* go into ring mode only if there is a "pending" tail */
 357     if (s->queue_depth > 0) {
 358         do {
 359             msgvec = s->msgvec + s->queue_tail;
 360             if (msgvec->msg_len > 0) {
 361                 data_size = msgvec->msg_len - s->header_size;
 362                 vec = msgvec->msg_hdr.msg_iov;
 363                 if ((data_size > 0) &&
 364                     (l2tpv3_verify_header(s, vec->iov_base) == 0)) {
 365                     vec++;
 366                     /* Use the legacy delivery for now, we will
 367                      * switch to using our own ring as a queueing mechanism
 368                      * at a later date
 369                      */
 370                     size = qemu_send_packet_async(
 371                             &s->nc,
 372                             vec->iov_base,
 373                             data_size,
 374                             l2tpv3_send_completed
 375                         );
 376                     if (size == 0) {
 377                         l2tpv3_read_poll(s, false);
 378                     }
 379                     bad_read = false;
 380                 } else {
 381                     bad_read = true;
 382                     if (!s->header_mismatch) {
 383                         /* report error only once */
 384                         error_report("l2tpv3 header verification failed");
 385                         s->header_mismatch = true;
 386                     }
 387                 }
 388             } else {
 389                 bad_read = true;
 390             }
 391             s->queue_tail = (s->queue_tail + 1) % MAX_L2TPV3_MSGCNT;
 392             s->queue_depth--;
 393         } while (
 394                 (s->queue_depth > 0) &&
 395                  qemu_can_send_packet(&s->nc) &&
 396                 ((size > 0) || bad_read)
 397             );
 398     }
 399 }
 400
 401 static void net_l2tpv3_send(void *opaque)
 402 {
 403     NetL2TPV3State *s = opaque;
 404     int target_count, count;
 405     struct mmsghdr *msgvec;
 406
 407     /* go into ring mode only if there is a "pending" tail */
 408
 409     if (s->queue_depth) {
 410
 411         /* The ring buffer we use has variable intake
 412          * count of how much we can read varies - adjust accordingly
 413          */
 414
 415         target_count = MAX_L2TPV3_MSGCNT - s->queue_depth;
 416
 417         /* Ensure we do not overrun the ring when we have
 418          * a lot of enqueued packets
 419          */
 420
 421         if (s->queue_head + target_count > MAX_L2TPV3_MSGCNT) {
 422             target_count = MAX_L2TPV3_MSGCNT - s->queue_head;
 423         }
 424     } else {
 425
 426         /* we do not have any pending packets - we can use
 427         * the whole message vector linearly instead of using
 428         * it as a ring
 429         */
 430
 431         s->queue_head = 0;
 432         s->queue_tail = 0;
 433         target_count = MAX_L2TPV3_MSGCNT;
 434     }
 435
 436     msgvec = s->msgvec + s->queue_head;
 437     if (target_count > 0) {
 438         do {
 439             count = recvmmsg(
 440                 s->fd,
 441                 msgvec,
 442                 target_count, MSG_DONTWAIT, NULL);
 443         } while ((count == -1) && (errno == EINTR));
 444         if (count < 0) {
 445             /* Recv error - we still need to flush packets here,
 446              * (re)set queue head to current position
 447              */
 448             count = 0;
 449         }
 450         s->queue_head = (s->queue_head + count) % MAX_L2TPV3_MSGCNT;
 451         s->queue_depth += count;
 452     }
 453     net_l2tpv3_process_queue(s);
 454 }
 455
 456 static void destroy_vector(struct mmsghdr *msgvec, int count, int iovcount)
 457 {
 458     int i, j;
 459     struct iovec *iov;
 460     struct mmsghdr *cleanup = msgvec;
 461     if (cleanup) {
 462         for (i = 0; i < count; i++) {
 463             if (cleanup->msg_hdr.msg_iov) {
 464                 iov = cleanup->msg_hdr.msg_iov;
 465                 for (j = 0; j < iovcount; j++) {
 466                     g_free(iov->iov_base);
 467                     iov++;
 468                 }
 469                 g_free(cleanup->msg_hdr.msg_iov);
 470             }
 471             cleanup++;
 472         }
 473         g_free(msgvec);
 474     }
 475 }
 476
 477 static struct mmsghdr *build_l2tpv3_vector(NetL2TPV3State *s, int count)
 478 {
 479     int i;
 480     struct iovec *iov;
 481     struct mmsghdr *msgvec, *result;
 482
 483     msgvec = g_new(struct mmsghdr, count);
 484     result = msgvec;
 485     for (i = 0; i < count ; i++) {
 486         msgvec->msg_hdr.msg_name = NULL;
 487         msgvec->msg_hdr.msg_namelen = 0;
 488         iov =  g_new(struct iovec, IOVSIZE);
 489         msgvec->msg_hdr.msg_iov = iov;
 490         iov->iov_base = g_malloc(s->header_size);
 491         iov->iov_len = s->header_size;
 492         iov++ ;
 493         iov->iov_base = qemu_memalign(BUFFER_ALIGN, BUFFER_SIZE);
 494         iov->iov_len = BUFFER_SIZE;
 495         msgvec->msg_hdr.msg_iovlen = 2;
 496         msgvec->msg_hdr.msg_control = NULL;
 497         msgvec->msg_hdr.msg_controllen = 0;
 498         msgvec->msg_hdr.msg_flags = 0;
 499         msgvec++;
 500     }
 501     return result;
 502 }
 503
 504 static void net_l2tpv3_cleanup(NetClientState *nc)
 505 {
 506     NetL2TPV3State *s = DO_UPCAST(NetL2TPV3State, nc, nc);
 507     qemu_purge_queued_packets(nc);
 508     l2tpv3_read_poll(s, false);
 509     l2tpv3_write_poll(s, false);
 510     if (s->fd >= 0) {
 511         close(s->fd);
 512     }
 513     destroy_vector(s->msgvec, MAX_L2TPV3_MSGCNT, IOVSIZE);
 514     g_free(s->vec);
 515     g_free(s->header_buf);
 516     g_free(s->dgram_dst);
 517 }
 518
 519 static NetClientInfo net_l2tpv3_info = {
 520     .type = NET_CLIENT_OPTIONS_KIND_L2TPV3,
 521     .size = sizeof(NetL2TPV3State),
 522     .receive = net_l2tpv3_receive_dgram,
 523     .receive_iov = net_l2tpv3_receive_dgram_iov,
 524     .poll = l2tpv3_poll,
 525     .cleanup = net_l2tpv3_cleanup,
 526 };
 527
 528 int net_init_l2tpv3(const NetClientOptions *opts,
 529                     const char *name,
 530                     NetClientState *peer, Error **errp)
 531 {
 532     /* FIXME error_setg(errp, ...) on failure */
 533     const NetdevL2TPv3Options *l2tpv3;
 534     NetL2TPV3State *s;
 535     NetClientState *nc;
 536     int fd = -1, gairet;
 537     struct addrinfo hints;
 538     struct addrinfo *result = NULL;
 539     char *srcport, *dstport;
 540
 541     nc = qemu_new_net_client(&net_l2tpv3_info, peer, "l2tpv3", name);
 542
 543     s = DO_UPCAST(NetL2TPV3State, nc, nc);
 544
 545     s->queue_head = 0;
 546     s->queue_tail = 0;
 547     s->header_mismatch = false;
 548
 549     assert(opts->kind == NET_CLIENT_OPTIONS_KIND_L2TPV3);
 550     l2tpv3 = opts->l2tpv3;
 551
 552     if (l2tpv3->has_ipv6 && l2tpv3->ipv6) {
 553         s->ipv6 = l2tpv3->ipv6;
 554     } else {
 555         s->ipv6 = false;
 556     }
 557
 558     if ((l2tpv3->has_offset) && (l2tpv3->offset > 256)) {
 559         error_report("l2tpv3_open : offset must be less than 256 bytes");
 560         goto outerr;
 561     }
 562
 563     if (l2tpv3->has_rxcookie || l2tpv3->has_txcookie) {
 564         if (l2tpv3->has_rxcookie && l2tpv3->has_txcookie) {
 565             s->cookie = true;
 566         } else {
 567             goto outerr;
 568         }
 569     } else {
 570         s->cookie = false;
 571     }
 572
 573     if (l2tpv3->has_cookie64 || l2tpv3->cookie64) {
 574         s->cookie_is_64  = true;
 575     } else {
 576         s->cookie_is_64  = false;
 577     }
 578
 579     if (l2tpv3->has_udp && l2tpv3->udp) {
 580         s->udp = true;
 581         if (!(l2tpv3->has_srcport && l2tpv3->has_dstport)) {
 582             error_report("l2tpv3_open : need both src and dst port for udp");
 583             goto outerr;
 584         } else {
 585             srcport = l2tpv3->srcport;
 586             dstport = l2tpv3->dstport;
 587         }
 588     } else {
 589         s->udp = false;
 590         srcport = NULL;
 591         dstport = NULL;
 592     }
 593
 594
 595     s->offset = 4;
 596     s->session_offset = 0;
 597     s->cookie_offset = 4;
 598     s->counter_offset = 4;
 599
 600     s->tx_session = l2tpv3->txsession;
 601     if (l2tpv3->has_rxsession) {
 602         s->rx_session = l2tpv3->rxsession;
 603     } else {
 604         s->rx_session = s->tx_session;
 605     }
 606
 607     if (s->cookie) {
 608         s->rx_cookie = l2tpv3->rxcookie;
 609         s->tx_cookie = l2tpv3->txcookie;
 610         if (s->cookie_is_64 == true) {
 611             /* 64 bit cookie */
 612             s->offset += 8;
 613             s->counter_offset += 8;
 614         } else {
 615             /* 32 bit cookie */
 616             s->offset += 4;
 617             s->counter_offset += 4;
 618         }
 619     }
 620
 621     memset(&hints, 0, sizeof(hints));
 622
 623     if (s->ipv6) {
 624         hints.ai_family = AF_INET6;
 625     } else {
 626         hints.ai_family = AF_INET;
 627     }
 628     if (s->udp) {
 629         hints.ai_socktype = SOCK_DGRAM;
 630         hints.ai_protocol = 0;
 631         s->offset += 4;
 632         s->counter_offset += 4;
 633         s->session_offset += 4;
 634         s->cookie_offset += 4;
 635     } else {
 636         hints.ai_socktype = SOCK_RAW;
 637         hints.ai_protocol = IPPROTO_L2TP;
 638     }
 639
 640     gairet = getaddrinfo(l2tpv3->src, srcport, &hints, &result);
 641
 642     if ((gairet != 0) || (result == NULL)) {
 643         error_report(
 644             "l2tpv3_open : could not resolve src, errno = %s",
 645             gai_strerror(gairet)
 646         );
 647         goto outerr;
 648     }
 649     fd = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
 650     if (fd == -1) {
 651         fd = -errno;
 652         error_report("l2tpv3_open : socket creation failed, errno = %d", -fd);
 653         goto outerr;
 654     }
 655     if (bind(fd, (struct sockaddr *) result->ai_addr, result->ai_addrlen)) {
 656         error_report("l2tpv3_open :  could not bind socket err=%i", errno);
 657         goto outerr;
 658     }
 659     if (result) {
 660         freeaddrinfo(result);
 661     }
 662
 663     memset(&hints, 0, sizeof(hints));
 664
 665     if (s->ipv6) {
 666         hints.ai_family = AF_INET6;
 667     } else {
 668         hints.ai_family = AF_INET;
 669     }
 670     if (s->udp) {
 671         hints.ai_socktype = SOCK_DGRAM;
 672         hints.ai_protocol = 0;
 673     } else {
 674         hints.ai_socktype = SOCK_RAW;
 675         hints.ai_protocol = IPPROTO_L2TP;
 676     }
 677
 678     result = NULL;
 679     gairet = getaddrinfo(l2tpv3->dst, dstport, &hints, &result);
 680     if ((gairet != 0) || (result == NULL)) {
 681         error_report(
 682             "l2tpv3_open : could not resolve dst, error = %s",
 683             gai_strerror(gairet)
 684         );
 685         goto outerr;
 686     }
 687
 688     s->dgram_dst = g_new0(struct sockaddr_storage, 1);
 689     memcpy(s->dgram_dst, result->ai_addr, result->ai_addrlen);
 690     s->dst_size = result->ai_addrlen;
 691
 692     if (result) {
 693         freeaddrinfo(result);
 694     }
 695
 696     if (l2tpv3->has_counter && l2tpv3->counter) {
 697         s->has_counter = true;
 698         s->offset += 4;
 699     } else {
 700         s->has_counter = false;
 701     }
 702
 703     if (l2tpv3->has_pincounter && l2tpv3->pincounter) {
 704         s->has_counter = true;  /* pin counter implies that there is counter */
 705         s->pin_counter = true;
 706     } else {
 707         s->pin_counter = false;
 708     }
 709
 710     if (l2tpv3->has_offset) {
 711         /* extra offset */
 712         s->offset += l2tpv3->offset;
 713     }
 714
 715     if ((s->ipv6) || (s->udp)) {
 716         s->header_size = s->offset;
 717     } else {
 718         s->header_size = s->offset + sizeof(struct iphdr);
 719     }
 720
 721     s->msgvec = build_l2tpv3_vector(s, MAX_L2TPV3_MSGCNT);
 722     s->vec = g_new(struct iovec, MAX_L2TPV3_IOVCNT);
 723     s->header_buf = g_malloc(s->header_size);
 724
 725     qemu_set_nonblock(fd);
 726
 727     s->fd = fd;
 728     s->counter = 0;
 729
 730     l2tpv3_read_poll(s, true);
 731
 732     snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 733              "l2tpv3: connected");
 734     return 0;
 735 outerr:
 736     qemu_del_net_client(nc);
 737     if (fd >= 0) {
 738         close(fd);
 739     }
 740     if (result) {
 741         freeaddrinfo(result);
 742     }
 743     return -1;
 744 }
 745