vlib-api/vlibsocket/socksvr_vlib.c

   1 /*
   2  *------------------------------------------------------------------
   3  * socksvr_vlib.c
   4  *
   5  * Copyright (c) 2009 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <sys/ioctl.h>
  24 #include <vppinfra/byte_order.h>
  25
  26 #include <fcntl.h>
  27 #include <sys/stat.h>
  28
  29 #include <vlibsocket/api.h>
  30 #include <vlibmemory/api.h>
  31
  32 #include <vlibsocket/vl_socket_msg_enum.h>      /* enumerate all vlib messages */
  33
  34 #define vl_typedefs             /* define message structures */
  35 #include <vlibsocket/vl_socket_api_h.h>
  36 #undef vl_typedefs
  37
  38 /* instantiate all the print functions we know about */
  39 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  40 #define vl_printfun
  41 #include <vlibsocket/vl_socket_api_h.h>
  42 #undef vl_printfun
  43
  44 /* instantiate all the endian swap functions we know about */
  45 #define vl_endianfun
  46 #include <vlibsocket/vl_socket_api_h.h>
  47 #undef vl_endianfun
  48
  49 socket_main_t socket_main;
  50
  51 void
  52 dump_socket_clients (vlib_main_t * vm, api_main_t * am)
  53 {
  54   vl_api_registration_t *reg;
  55   socket_main_t *sm = &socket_main;
  56   unix_main_t *um = &unix_main;
  57   unix_file_t *f;
  58
  59   /*
  60    * Must have at least one active client, not counting the
  61    * REGISTRATION_TYPE_SOCKET_LISTEN bind/accept socket
  62    */
  63   if (pool_elts (sm->registration_pool) < 2)
  64     return;
  65
  66   vlib_cli_output (vm, "TCP socket clients");
  67   vlib_cli_output (vm, "%16s %8s", "Name", "Fildesc");
  68     /* *INDENT-OFF* */
  69     pool_foreach (reg, sm->registration_pool,
  70     ({
  71         if (reg->registration_type == REGISTRATION_TYPE_SOCKET_SERVER) {
  72             f = pool_elt_at_index (um->file_pool, reg->unix_file_index);
  73             vlib_cli_output (vm, "%16s %8d",
  74                              reg->name, f->file_descriptor);
  75         }
  76     }));
  77 /* *INDENT-ON* */
  78 }
  79
  80 void
  81 vl_socket_api_send (vl_api_registration_t * rp, u8 * elem)
  82 {
  83   u32 nbytes = 4;               /* for the length... */
  84   u16 msg_id = ntohs (*(u16 *) elem);
  85   u32 msg_length;
  86   u32 tmp;
  87   api_main_t *am = &api_main;
  88
  89   ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM);
  90
  91   if (msg_id >= vec_len (am->api_trace_cfg))
  92     {
  93       clib_warning ("id out of range: %d", msg_id);
  94       vl_msg_api_free ((void *) elem);
  95       return;
  96     }
  97
  98   msg_length = am->api_trace_cfg[msg_id].size;
  99   nbytes += msg_length;
 100   tmp = clib_host_to_net_u32 (nbytes);
 101
 102   vl_socket_add_pending_output (rp->unix_file_index
 103                                 + unix_main.file_pool,
 104                                 rp->vl_api_registration_pool_index
 105                                 + socket_main.registration_pool,
 106                                 (u8 *) & tmp, sizeof (tmp));
 107   vl_socket_add_pending_output (rp->unix_file_index
 108                                 + unix_main.file_pool,
 109                                 rp->vl_api_registration_pool_index
 110                                 + socket_main.registration_pool,
 111                                 elem, msg_length);
 112   vl_msg_api_free ((void *) elem);
 113 }
 114
 115 void
 116 vl_socket_api_send_with_data (vl_api_registration_t * rp,
 117                               u8 * elem, u8 * data_vector)
 118 {
 119   u32 nbytes = 4;               /* for the length... */
 120   u16 msg_id = ntohs (*(u16 *) elem);
 121   u32 msg_length;
 122   u32 tmp;
 123   api_main_t *am = &api_main;
 124
 125   ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM);
 126
 127   if (msg_id >= vec_len (am->api_trace_cfg))
 128     {
 129       clib_warning ("id out of range: %d", msg_id);
 130       vec_free (data_vector);
 131       vl_msg_api_free ((void *) elem);
 132       return;
 133     }
 134
 135   msg_length = am->api_trace_cfg[msg_id].size;
 136   nbytes += msg_length;
 137   nbytes += vec_len (data_vector);
 138
 139   /* Length in network byte order */
 140   tmp = clib_host_to_net_u32 (nbytes);
 141
 142   vl_socket_add_pending_output (rp->unix_file_index
 143                                 + unix_main.file_pool,
 144                                 rp->vl_api_registration_pool_index
 145                                 + socket_main.registration_pool,
 146                                 (u8 *) & tmp, sizeof (tmp));
 147   vl_socket_add_pending_output (rp->unix_file_index
 148                                 + unix_main.file_pool,
 149                                 rp->vl_api_registration_pool_index
 150                                 + socket_main.registration_pool,
 151                                 elem, msg_length);
 152   vl_socket_add_pending_output (rp->unix_file_index
 153                                 + unix_main.file_pool,
 154                                 rp->vl_api_registration_pool_index
 155                                 + socket_main.registration_pool,
 156                                 data_vector, vec_len (data_vector));
 157   vl_msg_api_free ((void *) elem);
 158 }
 159
 160 static inline void
 161 vl_socket_api_send_with_length_internal (vl_api_registration_t * rp,
 162                                          u8 * elem, u32 msg_length, int free)
 163 {
 164   u32 nbytes = 4;               /* for the length... */
 165   u16 msg_id = ntohs (*(u16 *) elem);
 166   u32 tmp;
 167   api_main_t *am = &api_main;
 168
 169   ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM);
 170
 171   if (msg_id >= vec_len (am->api_trace_cfg))
 172     {
 173       clib_warning ("id out of range: %d", msg_id);
 174       if (free)
 175         vl_msg_api_free ((void *) elem);
 176       return;
 177     }
 178
 179   nbytes += msg_length;
 180
 181   /* Length in network byte order */
 182   tmp = clib_host_to_net_u32 (nbytes);
 183
 184   vl_socket_add_pending_output (rp->unix_file_index
 185                                 + unix_main.file_pool,
 186                                 rp->vl_api_registration_pool_index
 187                                 + socket_main.registration_pool,
 188                                 (u8 *) & tmp, sizeof (tmp));
 189   vl_socket_add_pending_output (rp->unix_file_index
 190                                 + unix_main.file_pool,
 191                                 rp->vl_api_registration_pool_index
 192                                 + socket_main.registration_pool,
 193                                 elem, msg_length);
 194   if (free)
 195     vl_msg_api_free ((void *) elem);
 196 }
 197
 198 void
 199 vl_socket_api_send_with_length (vl_api_registration_t * rp,
 200                                 u8 * elem, u32 msg_length)
 201 {
 202   vl_socket_api_send_with_length_internal (rp, elem, msg_length,
 203                                            1 /* free */ );
 204 }
 205
 206 void
 207 vl_socket_api_send_with_length_no_free (vl_api_registration_t * rp,
 208                                         u8 * elem, u32 msg_length)
 209 {
 210   vl_socket_api_send_with_length_internal (rp, elem, msg_length,
 211                                            0 /* free */ );
 212 }
 213
 214 void
 215 vl_free_socket_registration_index (u32 pool_index)
 216 {
 217   vl_api_registration_t *rp;
 218   if (pool_is_free_index (socket_main.registration_pool, pool_index))
 219     {
 220       clib_warning ("main pool index %d already free", pool_index);
 221       return;
 222     }
 223   rp = pool_elt_at_index (socket_main.registration_pool, pool_index);
 224
 225   ASSERT (rp->registration_type != REGISTRATION_TYPE_FREE);
 226   vec_free (rp->name);
 227   vec_free (rp->unprocessed_input);
 228   vec_free (rp->output_vector);
 229   rp->registration_type = REGISTRATION_TYPE_FREE;
 230   pool_put (socket_main.registration_pool, rp);
 231 }
 232
 233 static inline void
 234 socket_process_msg (unix_file_t * uf, vl_api_registration_t * rp,
 235                     i8 * input_v)
 236 {
 237   u8 *the_msg = (u8 *) (input_v + sizeof (u32));
 238   socket_main.current_uf = uf;
 239   socket_main.current_rp = rp;
 240   vl_msg_api_socket_handler (the_msg);
 241   socket_main.current_uf = 0;
 242   socket_main.current_rp = 0;
 243 }
 244
 245 clib_error_t *
 246 vl_socket_read_ready (unix_file_t * uf)
 247 {
 248   unix_main_t *um = &unix_main;
 249   vl_api_registration_t *rp;
 250   int n;
 251   i8 *msg_buffer = 0;
 252   u32 msg_len;
 253   u32 save_input_buffer_length = vec_len (socket_main.input_buffer);
 254
 255   rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
 256
 257   n = read (uf->file_descriptor, socket_main.input_buffer,
 258             vec_len (socket_main.input_buffer));
 259
 260   if (n <= 0 && errno != EAGAIN)
 261     {
 262       unix_file_del (um, uf);
 263
 264       if (!pool_is_free (socket_main.registration_pool, rp))
 265         {
 266           u32 index = rp - socket_main.registration_pool;
 267           vl_free_socket_registration_index (index);
 268         }
 269       else
 270         {
 271           clib_warning ("client index %d already free?",
 272                         rp->vl_api_registration_pool_index);
 273         }
 274       return 0;
 275     }
 276
 277   _vec_len (socket_main.input_buffer) = n;
 278
 279   /*
 280    * Look for bugs here. This code is tricky because
 281    * data read from a stream socket does honor message
 282    * boundaries. In the case of a long message (>4K bytes)
 283    * we have to do (at least) 2 reads, etc.
 284    */
 285   do
 286     {
 287       if (vec_len (rp->unprocessed_input))
 288         {
 289           vec_append (rp->unprocessed_input, socket_main.input_buffer);
 290           msg_buffer = rp->unprocessed_input;
 291           msg_len = rp->unprocessed_msg_length;
 292         }
 293       else
 294         {
 295           msg_buffer = socket_main.input_buffer;
 296           msg_len = 0;
 297         }
 298
 299       if (msg_len == 0)
 300         {
 301           /* Length may be split across two reads */
 302           if (vec_len (msg_buffer) < sizeof (u32))
 303             goto save_and_split;
 304
 305           /* total length, including msg_len itself, in network byte order */
 306           msg_len = clib_net_to_host_u32 (*((u32 *) msg_buffer));
 307         }
 308
 309       /* Happens if the client sent msg_len == 0 */
 310       if (msg_len == 0)
 311         {
 312           clib_warning ("msg_len == 0");
 313           goto turf_it;
 314         }
 315
 316       /* We don't have the entire message yet. */
 317       if (msg_len > vec_len (msg_buffer))
 318         {
 319         save_and_split:
 320           /*
 321            * if we were using the shared input buffer,
 322            * save the fragment.
 323            */
 324           if (msg_buffer == socket_main.input_buffer)
 325             {
 326               ASSERT (vec_len (rp->unprocessed_input) == 0);
 327               vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1);
 328               clib_memcpy (rp->unprocessed_input, msg_buffer,
 329                            vec_len (msg_buffer));
 330               _vec_len (rp->unprocessed_input) = vec_len (msg_buffer);
 331             }
 332           _vec_len (socket_main.input_buffer) = save_input_buffer_length;
 333           rp->unprocessed_msg_length = msg_len;
 334           return 0;
 335         }
 336
 337       socket_process_msg (uf, rp, msg_buffer);
 338       if (n > msg_len)
 339         vec_delete (msg_buffer, msg_len, 0);
 340       else
 341         _vec_len (msg_buffer) = 0;
 342       n -= msg_len;
 343       msg_len = 0;
 344       rp->unprocessed_msg_length = 0;
 345     }
 346   while (n > 0);
 347
 348 turf_it:
 349   _vec_len (socket_main.input_buffer) = save_input_buffer_length;
 350
 351   return 0;
 352 }
 353
 354 void
 355 vl_socket_add_pending_output (unix_file_t * uf,
 356                               vl_api_registration_t * rp,
 357                               u8 * buffer, uword buffer_bytes)
 358 {
 359   unix_main_t *um = &unix_main;
 360
 361   vec_add (rp->output_vector, buffer, buffer_bytes);
 362   if (vec_len (rp->output_vector) > 0)
 363     {
 364       int skip_update = 0 != (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE);
 365       uf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
 366       if (!skip_update)
 367         um->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
 368     }
 369 }
 370
 371 static void
 372 socket_del_pending_output (unix_file_t * uf,
 373                            vl_api_registration_t * rp, uword n_bytes)
 374 {
 375   unix_main_t *um = &unix_main;
 376
 377   vec_delete (rp->output_vector, n_bytes, 0);
 378   if (vec_len (rp->output_vector) <= 0)
 379     {
 380       int skip_update = 0 == (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE);
 381       uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
 382       if (!skip_update)
 383         um->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
 384     }
 385 }
 386
 387 clib_error_t *
 388 vl_socket_write_ready (unix_file_t * uf)
 389 {
 390   unix_main_t *um = &unix_main;
 391   vl_api_registration_t *rp;
 392   int n;
 393
 394   rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
 395
 396   /* Flush output vector. */
 397   n = write (uf->file_descriptor,
 398              rp->output_vector, vec_len (rp->output_vector));
 399
 400   if (n < 0)
 401     {
 402 #if DEBUG > 2
 403       clib_warning ("write error, close the file...\n");
 404 #endif
 405       unix_file_del (um, uf);
 406
 407       vl_free_socket_registration_index (rp - socket_main.registration_pool);
 408       return 0;
 409     }
 410
 411   else if (n > 0)
 412     socket_del_pending_output (uf, rp, n);
 413
 414   return 0;
 415 }
 416
 417 clib_error_t *
 418 vl_socket_error_ready (unix_file_t * uf)
 419 {
 420   vl_api_registration_t *rp;
 421   unix_main_t *um = &unix_main;
 422
 423   rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data);
 424   unix_file_del (um, uf);
 425   vl_free_socket_registration_index (rp - socket_main.registration_pool);
 426
 427   return 0;
 428 }
 429
 430 void
 431 socksvr_file_add (unix_main_t * um, int fd)
 432 {
 433   vl_api_registration_t *rp;
 434   unix_file_t template = { 0 };
 435
 436   pool_get (socket_main.registration_pool, rp);
 437   memset (rp, 0, sizeof (*rp));
 438
 439   template.read_function = vl_socket_read_ready;
 440   template.write_function = vl_socket_write_ready;
 441   template.error_function = vl_socket_error_ready;
 442   template.file_descriptor = fd;
 443   template.private_data = rp - socket_main.registration_pool;
 444
 445   rp->registration_type = REGISTRATION_TYPE_SOCKET_SERVER;
 446   rp->vl_api_registration_pool_index = rp - socket_main.registration_pool;
 447   rp->unix_file_index = unix_file_add (um, &template);
 448 }
 449
 450 static clib_error_t *
 451 socksvr_accept_ready (unix_file_t * uf)
 452 {
 453   unix_main_t *um = &unix_main;
 454   struct sockaddr_in client_addr;
 455   int client_fd;
 456   int client_len;
 457
 458   client_len = sizeof (client_addr);
 459
 460   /*
 461    * Supposedly acquires the non-blocking attrib from the
 462    * server socket.
 463    */
 464   client_fd = accept (uf->file_descriptor,
 465                       (struct sockaddr *) &client_addr,
 466                       (socklen_t *) & client_len);
 467
 468   if (client_fd < 0)
 469     return clib_error_return_unix (0, "socksvr_accept_ready: accept");
 470
 471   socksvr_file_add (um, client_fd);
 472   return 0;
 473 }
 474
 475 static clib_error_t *
 476 socksvr_bogus_write (unix_file_t * uf)
 477 {
 478   clib_warning ("why am I here?");
 479   return 0;
 480 }
 481
 482 /*
 483  * vl_api_sockclnt_create_t_handler
 484  */
 485 void
 486 vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp)
 487 {
 488   vl_api_registration_t *regp;
 489   vl_api_sockclnt_create_reply_t *rp;
 490   int rv = 1;
 491
 492   regp = socket_main.current_rp;
 493
 494   ASSERT (regp->registration_type == REGISTRATION_TYPE_SOCKET_SERVER);
 495
 496   regp->name = format (0, "%s%c", mp->name, 0);
 497
 498   rp = vl_msg_api_alloc (sizeof (*rp));
 499   rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY);
 500   rp->handle = (uword) regp;
 501   rp->index = (uword) regp->vl_api_registration_pool_index;
 502   rp->context = mp->context;
 503   rp->response = htonl (rv);
 504
 505   vl_msg_api_send (regp, (u8 *) rp);
 506 }
 507
 508 /*
 509  * vl_api_sockclnt_delete_t_handler
 510  */
 511 void
 512 vl_api_sockclnt_delete_t_handler (vl_api_sockclnt_delete_t * mp)
 513 {
 514   vl_api_registration_t *regp;
 515   vl_api_sockclnt_delete_reply_t *rp;
 516
 517   if (!pool_is_free_index (socket_main.registration_pool, mp->index))
 518     {
 519       regp = pool_elt_at_index (socket_main.registration_pool, mp->index);
 520
 521       rp = vl_msg_api_alloc (sizeof (*rp));
 522       rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY);
 523       rp->handle = mp->handle;
 524       rp->response = htonl (1);
 525
 526       vl_msg_api_send (regp, (u8 *) rp);
 527
 528       unix_file_del (&unix_main, unix_main.file_pool + regp->unix_file_index);
 529
 530       vl_free_socket_registration_index (mp->index);
 531     }
 532   else
 533     {
 534       clib_warning ("unknown client ID %d", mp->index);
 535     }
 536 }
 537
 538 #define foreach_vlib_api_msg                    \
 539 _(SOCKCLNT_CREATE, sockclnt_create)             \
 540 _(SOCKCLNT_DELETE, sockclnt_delete)
 541
 542 static clib_error_t *
 543 socksvr_api_init (vlib_main_t * vm)
 544 {
 545   unix_main_t *um = &unix_main;
 546   unix_file_t template = { 0 };
 547   int sockfd;
 548   int one = 1;
 549   int rv;
 550   struct sockaddr_in serv_addr;
 551   vl_api_registration_t *rp;
 552   u16 portno;
 553   u32 bind_address;
 554
 555 #define _(N,n)                                                  \
 556     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 557                            vl_api_##n##_t_handler,              \
 558                            vl_noop_handler,                     \
 559                            vl_api_##n##_t_endian,               \
 560                            vl_api_##n##_t_print,                \
 561                            sizeof(vl_api_##n##_t), 1);
 562   foreach_vlib_api_msg;
 563 #undef _
 564
 565   vec_resize (socket_main.input_buffer, 4096);
 566
 567   /* Set up non-blocking server socket on CLIENT_API_SERVER_PORT */
 568   sockfd = socket (AF_INET, SOCK_STREAM, 0);
 569
 570   if (sockfd < 0)
 571     {
 572       return clib_error_return_unix (0, "socket");
 573     }
 574
 575   rv = ioctl (sockfd, FIONBIO, &one);
 576   if (rv < 0)
 577     {
 578       close (sockfd);
 579       return clib_error_return_unix (0, "FIONBIO");
 580     }
 581
 582   rv = setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof (one));
 583   if (rv < 0)
 584     {
 585       close (sockfd);
 586       return clib_error_return_unix (0, "SO_REUSEADDR");
 587     }
 588
 589   bzero ((char *) &serv_addr, sizeof (serv_addr));
 590   serv_addr.sin_family = AF_INET;
 591
 592   if (socket_main.bind_address)
 593     bind_address = socket_main.bind_address;
 594   else
 595     bind_address = INADDR_LOOPBACK;
 596
 597   if (socket_main.portno)
 598     portno = socket_main.portno;
 599   else
 600     portno = SOCKSVR_DEFAULT_PORT;
 601
 602   serv_addr.sin_port = clib_host_to_net_u16 (portno);
 603   serv_addr.sin_addr.s_addr = clib_host_to_net_u32 (bind_address);
 604
 605   if (bind (sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0)
 606     {
 607       close (sockfd);
 608       return clib_error_return_unix (0, "bind");
 609     }
 610
 611   rv = listen (sockfd, 5);
 612   if (rv < 0)
 613     {
 614       close (sockfd);
 615       return clib_error_return_unix (0, "listen");
 616     }
 617
 618   pool_get (socket_main.registration_pool, rp);
 619   memset (rp, 0, sizeof (*rp));
 620
 621   rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN;
 622
 623   template.read_function = socksvr_accept_ready;
 624   template.write_function = socksvr_bogus_write;
 625   template.file_descriptor = sockfd;
 626   template.private_data = rp - socket_main.registration_pool;
 627
 628   rp->unix_file_index = unix_file_add (um, &template);
 629   return 0;
 630 }
 631
 632 static clib_error_t *
 633 socket_exit (vlib_main_t * vm)
 634 {
 635   unix_main_t *um = &unix_main;
 636   vl_api_registration_t *rp;
 637
 638   /* Defensive driving in case something wipes out early */
 639   if (socket_main.registration_pool)
 640     {
 641       u32 index;
 642         /* *INDENT-OFF* */
 643         pool_foreach (rp, socket_main.registration_pool, ({
 644             unix_file_del (um, um->file_pool + rp->unix_file_index);
 645             index = rp->vl_api_registration_pool_index;
 646             vl_free_socket_registration_index (index);
 647         }));
 648 /* *INDENT-ON* */
 649     }
 650
 651   return 0;
 652 }
 653
 654 VLIB_MAIN_LOOP_EXIT_FUNCTION (socket_exit);
 655
 656 static clib_error_t *
 657 socksvr_config (vlib_main_t * vm, unformat_input_t * input)
 658 {
 659   int portno;
 660
 661   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 662     {
 663       if (unformat (input, "port %d", &portno))
 664         {
 665           socket_main.portno = portno;
 666         }
 667       else
 668         {
 669           return clib_error_return (0, "unknown input '%U'",
 670                                     format_unformat_error, input);
 671         }
 672     }
 673   return socksvr_api_init (vm);
 674 }
 675
 676 VLIB_CONFIG_FUNCTION (socksvr_config, "socksvr");
 677
 678 /* argument in host byte order */
 679 void
 680 socksvr_set_port (u16 port)
 681 {
 682   socket_main.portno = port;
 683 }
 684
 685 /* argument in host byte order */
 686 void
 687 socksvr_set_bind_address (u32 bind_address)
 688 {
 689   socket_main.bind_address = bind_address;
 690 }
 691
 692 clib_error_t *
 693 vlibsocket_init (vlib_main_t * vm)
 694 {
 695   return 0;
 696 }
 697
 698 VLIB_INIT_FUNCTION (vlibsocket_init);
 699
 700 /*
 701  * fd.io coding-style-patch-verification: ON
 702  *
 703  * Local Variables:
 704  * eval: (c-set-style "gnu")
 705  * End:
 706  */