FD.io VPP  v17.01-9-ge7dcee4
Vector Packet Processing
socksvr_vlib.c
Go to the documentation of this file.
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 */
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
42 #undef vl_printfun
43 
44 /* instantiate all the endian swap functions we know about */
45 #define vl_endianfun
47 #undef vl_endianfun
48 
50 
51 void
53 {
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* */
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
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 
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 
105  + socket_main.registration_pool,
106  (u8 *) & tmp, sizeof (tmp));
110  + socket_main.registration_pool,
111  elem, msg_length);
112  vl_msg_api_free ((void *) elem);
113 }
114 
115 void
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 
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 
145  + socket_main.registration_pool,
146  (u8 *) & tmp, sizeof (tmp));
150  + socket_main.registration_pool,
151  elem, msg_length);
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
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 
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 
187  + socket_main.registration_pool,
188  (u8 *) & tmp, sizeof (tmp));
192  + socket_main.registration_pool,
193  elem, msg_length);
194  if (free)
195  vl_msg_api_free ((void *) elem);
196 }
197 
198 void
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
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
216 {
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 
226  vec_free (rp->name);
228  vec_free (rp->output_vector);
230  pool_put (socket_main.registration_pool, rp);
231 }
232 
233 static inline void
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 *
247 {
248  unix_main_t *um = &unix_main;
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;
268  }
269  else
270  {
271  clib_warning ("client index %d already free?",
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
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);
366  if (!skip_update)
368  }
369 }
370 
371 static void
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);
382  if (!skip_update)
384  }
385 }
386 
387 clib_error_t *
389 {
390  unix_main_t *um = &unix_main;
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 
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 *
419 {
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);
426 
427  return 0;
428 }
429 
430 void
432 {
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 
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 *
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 *
477 {
478  clib_warning ("why am I here?");
479  return 0;
480 }
481 
482 /*
483  * vl_api_sockclnt_create_t_handler
484  */
485 void
487 {
488  vl_api_registration_t *regp;
490  int rv = 1;
491 
492  regp = socket_main.current_rp;
493 
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;
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
513 {
514  vl_api_registration_t *regp;
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 
529 
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 *
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;
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);
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 
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 *
634 {
635  unix_main_t *um = &unix_main;
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 
655 
656 static clib_error_t *
658 {
659  int portno;
660 
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 
677 
678 /* argument in host byte order */
679 void
681 {
682  socket_main.portno = port;
683 }
684 
685 /* argument in host byte order */
686 void
688 {
689  socket_main.bind_address = bind_address;
690 }
691 
692 clib_error_t *
694 {
695  return 0;
696 }
697 
699 
700 /*
701  * fd.io coding-style-patch-verification: ON
702  *
703  * Local Variables:
704  * eval: (c-set-style "gnu")
705  * End:
706  */
u32 unix_file_index
Definition: api.h:56
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
unix_file_t * file_pool
Definition: unix.h:89
void dump_socket_clients(vlib_main_t *vm, api_main_t *am)
Definition: socksvr_vlib.c:52
static clib_error_t * socksvr_config(vlib_main_t *vm, unformat_input_t *input)
Definition: socksvr_vlib.c:657
u32 flags
Definition: unix.h:54
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
clib_error_t * vl_socket_error_ready(unix_file_t *uf)
Definition: socksvr_vlib.c:418
static clib_error_t * socksvr_bogus_write(unix_file_t *uf)
Definition: socksvr_vlib.c:476
clib_error_t * vl_socket_write_ready(unix_file_t *uf)
Definition: socksvr_vlib.c:388
void vl_socket_add_pending_output(unix_file_t *uf, vl_api_registration_t *rp, u8 *buffer, uword buffer_bytes)
Definition: socksvr_vlib.c:355
vl_api_registration_t * registration_pool
Definition: api.h:37
void vl_socket_api_send_with_data(vl_api_registration_t *rp, u8 *elem, u8 *data_vector)
Definition: socksvr_vlib.c:116
static clib_error_t * socket_exit(vlib_main_t *vm)
Definition: socksvr_vlib.c:633
int size
Definition: api.h:71
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
vl_api_registration_t * current_rp
Definition: api.h:43
void socksvr_file_add(unix_main_t *um, int fd)
Definition: socksvr_vlib.c:431
void socksvr_set_port(u16 port)
Definition: socksvr_vlib.c:680
#define SOCKSVR_DEFAULT_PORT
Definition: api.h:55
#define pool_is_free(P, E)
Use free bitmap to query whether given element is free.
Definition: pool.h:203
socket_main_t socket_main
Definition: socksvr_vlib.c:49
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:200
static void socket_process_msg(unix_file_t *uf, vl_api_registration_t *rp, i8 *input_v)
Definition: socksvr_vlib.c:234
clib_error_t * vl_socket_read_ready(unix_file_t *uf)
Definition: socksvr_vlib.c:246
trace_cfg_t * api_trace_cfg
Definition: api.h:131
static uword unix_file_add(unix_main_t *um, unix_file_t *template)
Definition: unix.h:136
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:559
api_main_t api_main
Definition: api_shared.c:39
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:348
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
void vl_msg_api_free(void *)
char i8
Definition: types.h:45
void vl_free_socket_registration_index(u32 pool_index)
Definition: socksvr_vlib.c:215
#define clib_warning(format, args...)
Definition: error.h:59
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:201
void vl_socket_api_send(vl_api_registration_t *rp, u8 *elem)
Definition: socksvr_vlib.c:81
static void socket_del_pending_output(unix_file_t *uf, vl_api_registration_t *rp, uword n_bytes)
Definition: socksvr_vlib.c:372
vl_registration_type_t registration_type
Definition: api.h:40
static void unix_file_del(unix_main_t *um, unix_file_t *f)
Definition: unix.h:146
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
u32 file_descriptor
Definition: unix.h:52
uword private_data
Definition: unix.h:59
u32 bind_address
Definition: api.h:31
#define clib_error_return_unix(e, args...)
Definition: error.h:114
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:214
#define VLIB_CONFIG_FUNCTION(x, n,...)
Definition: init.h:118
u32 unprocessed_msg_length
Definition: api.h:58
unix_file_t * current_uf
Definition: api.h:44
void vl_socket_api_send_with_length_no_free(vl_api_registration_t *rp, u8 *elem, u32 msg_length)
Definition: socksvr_vlib.c:207
static clib_error_t * socksvr_api_init(vlib_main_t *vm)
Definition: socksvr_vlib.c:543
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:576
void * vl_msg_api_alloc(int nbytes)
void socksvr_set_bind_address(u32 bind_address)
Definition: socksvr_vlib.c:687
void vl_api_sockclnt_create_t_handler(vl_api_sockclnt_create_t *mp)
Definition: socksvr_vlib.c:486
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
#define foreach_vlib_api_msg
Definition: socksvr_vlib.c:538
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
Definition: init.h:115
clib_error_t * vlibsocket_init(vlib_main_t *vm)
Definition: socksvr_vlib.c:693
#define clib_memcpy(a, b, c)
Definition: string.h:69
u8 * output_vector
Definition: api.h:59
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:211
static clib_error_t * socksvr_accept_ready(unix_file_t *uf)
Definition: socksvr_vlib.c:451
int portno
Definition: api.h:28
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:745
#define vec_append(v1, v2)
Append v2 after v1.
Definition: vec.h:779
i8 * unprocessed_input
Definition: api.h:57
unix_main_t unix_main
Definition: main.c:57
void vl_msg_api_send(vl_api_registration_t *rp, u8 *elem)
Definition: memory_vlib.c:91
void vl_socket_api_send_with_length(vl_api_registration_t *rp, u8 *elem, u32 msg_length)
Definition: socksvr_vlib.c:199
u64 uword
Definition: types.h:112
void(* file_update)(unix_file_t *file, unix_file_update_type_t update_type)
Definition: unix.h:94
unsigned short u16
Definition: types.h:57
void vl_msg_api_socket_handler(void *the_msg)
Definition: api_shared.c:639
#define UNIX_FILE_DATA_AVAILABLE_TO_WRITE
Definition: unix.h:55
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
Definition: unix.h:49
u32 vl_api_registration_pool_index
Definition: api.h:43
i8 * input_buffer
Definition: api.h:46
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
#define clib_error_return(e, args...)
Definition: error.h:111
struct _unformat_input_t unformat_input_t
static void vl_socket_api_send_with_length_internal(vl_api_registration_t *rp, u8 *elem, u32 msg_length, int free)
Definition: socksvr_vlib.c:161
void vl_api_sockclnt_delete_t_handler(vl_api_sockclnt_delete_t *mp)
Definition: socksvr_vlib.c:512
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:109