FD.io VPP  v18.07-rc0-415-g6c78436
Vector Packet Processing
sockclnt_vlib.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * sockclnt_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 <unistd.h>
23 #include <netinet/in.h>
24 #include <sys/ioctl.h>
25 #include <vppinfra/byte_order.h>
26 #include <netdb.h>
27 
28 #include <fcntl.h>
29 #include <sys/stat.h>
30 
31 #include <vlibmemory/api.h>
32 
33 
35 
36 #define vl_typedefs /* define message structures */
38 #undef vl_typedefs
39 
40 /* instantiate all the print functions we know about */
41 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
42 #define vl_printfun
44 #undef vl_printfun
45 
46 /* instantiate all the endian swap functions we know about */
47 #define vl_endianfun
49 #undef vl_endianfun
50 
51 static void
53 {
55 
56  rp->server_handle = mp->handle;
57  rp->server_index = mp->index;
58 }
59 
60 static void
62 {
66 
67  clib_file_del (fm, uf);
69 }
70 
71 u32
72 sockclnt_open_index (char *client_name, char *hostname, int port)
73 {
76  clib_file_t template = { 0 };
77  int sockfd;
78  int one = 1;
79  int rv;
80  struct sockaddr_in serv_addr;
81  struct hostent *server;
83  char my_hostname[64];
84 
85  server = gethostbyname (hostname);
86  if (server == NULL)
87  {
88  clib_warning ("Couldn't translate server name %s", hostname);
89  return ~0;
90  }
91 
92  /* Set up non-blocking server socket on CLIENT_API_SERVER_PORT */
93  sockfd = socket (AF_INET, SOCK_STREAM, 0);
94 
95  if (sockfd < 0)
96  {
97  clib_unix_warning ("socket");
98  return ~0;
99  }
100 
101  bzero ((char *) &serv_addr, sizeof (serv_addr));
102  serv_addr.sin_family = AF_INET;
103  bcopy ((char *) server->h_addr,
104  (char *) &serv_addr.sin_addr.s_addr, server->h_length);
105  serv_addr.sin_port = htons (port);
106 
107  if (connect (sockfd, (const void *) &serv_addr, sizeof (serv_addr)) < 0)
108  {
109  clib_unix_warning ("Connect failure to (%s, %d)", hostname, port);
110  close (sockfd);
111  return ~0;
112  }
113 
114  rv = ioctl (sockfd, FIONBIO, &one);
115  if (rv < 0)
116  {
117  clib_unix_warning ("FIONBIO");
118  close (sockfd);
119  return ~0;
120  }
121 
123  memset (rp, 0, sizeof (*rp));
126 
127  template.read_function = vl_socket_read_ready;
128  template.write_function = vl_socket_write_ready;
129  template.file_descriptor = sockfd;
130  template.private_data = rp - socket_main.registration_pool;
131 
132  rp->clib_file_index = clib_file_add (fm, &template);
133  rp->name = format (0, "%s:%d", hostname, port);
134 
135  mp = vl_msg_api_alloc (sizeof (*mp));
136  mp->_vl_msg_id = ntohs (VL_API_SOCKCLNT_CREATE);
138 
139  if (gethostname (my_hostname, sizeof (my_hostname)) < 0)
140  {
141  clib_unix_warning ("gethostname");
142  strncpy (my_hostname, "unknown!", sizeof (my_hostname) - 1);
143  }
144  strncpy ((char *) mp->name, my_hostname, sizeof (mp->name) - 1);
145 
146  vl_api_send_msg (rp, (u8 *) mp);
147  return rp - socket_main.registration_pool;
148 }
149 
150 void
152 {
155 
156  /* Don't crash / assert if fed garbage */
158  {
159  clib_warning ("registration_pool index %d already free", index);
160  return;
161  }
163 
164  mp = vl_msg_api_alloc (sizeof (*mp));
165  mp->_vl_msg_id = ntohs (VL_API_SOCKCLNT_DELETE);
166  mp->handle = rp->server_handle;
167  mp->index = rp->server_index;
168  vl_api_send_msg (rp, (u8 *) mp);
169 }
170 
173 {
175 }
176 
177 /*
178  * Both rx and tx msgs MUST be initialized, or we'll have
179  * precisely no idea how many bytes to write into the API trace...
180  */
181 #define foreach_sockclnt_api_msg \
182 _(SOCKCLNT_CREATE_REPLY, sockclnt_create_reply) \
183 _(SOCKCLNT_DELETE_REPLY, sockclnt_delete_reply)
184 
185 
186 static clib_error_t *
188 {
189 #define _(N,n) \
190  vl_msg_api_set_handlers(VL_API_##N, #n, \
191  vl_api_##n##_t_handler, \
192  vl_noop_handler, \
193  vl_api_##n##_t_endian, \
194  vl_api_##n##_t_print, \
195  sizeof(vl_api_##n##_t), 1);
197 #undef _
198  return 0;
199 }
200 
202 
203 /*
204  * fd.io coding-style-patch-verification: ON
205  *
206  * Local Variables:
207  * eval: (c-set-style "gnu")
208  * End:
209  */
static void vl_api_sockclnt_delete_reply_t_handler(vl_api_sockclnt_delete_reply_t *mp)
Definition: sockclnt_vlib.c:61
static void clib_file_del(clib_file_main_t *um, clib_file_t *f)
Definition: file.h:109
static void vl_api_sockclnt_create_reply_t_handler(vl_api_sockclnt_create_reply_t *mp)
Definition: sockclnt_vlib.c:52
u8 * name
Client name.
Definition: api_common.h:51
vl_api_registration_t * registration_pool
Definition: socket_api.h:46
VLIB_API_INIT_FUNCTION(sockclnt_vlib_api_init)
#define foreach_sockclnt_api_msg
#define NULL
Definition: clib.h:55
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:34
clib_file_t * current_uf
Definition: socket_api.h:53
socket_main_t socket_main
Definition: socket_api.c:48
void sockclnt_close_index(u32 index)
u32 server_index
Socket client only: server index.
Definition: api_common.h:72
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
clib_error_t * vl_socket_write_ready(clib_file_t *uf)
Definition: socket_api.c:311
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:227
void * vl_msg_api_alloc(int nbytes)
unsigned char u8
Definition: types.h:56
u32 clib_file_index
Socket only: file index.
Definition: api_common.h:64
clib_file_main_t file_main
Definition: main.c:63
unsigned int u32
Definition: types.h:88
vl_registration_type_t registration_type
type
Definition: api_common.h:46
static clib_error_t * sockclnt_vlib_api_init(vlib_main_t *vm)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:461
vl_api_registration_t * sockclnt_get_registration(u32 index)
clib_error_t * vl_socket_read_ready(clib_file_t *uf)
Definition: socket_api.c:158
An API client registration, only in vpp/vlib.
Definition: api_common.h:44
vlib_main_t * vm
Definition: buffer.c:294
#define clib_warning(format, args...)
Definition: error.h:59
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:270
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
Definition: file.h:96
vl_api_registration_t * current_rp
Definition: socket_api.h:52
void vl_socket_free_registration_index(u32 pool_index)
Definition: socket_api.c:120
u32 sockclnt_open_index(char *client_name, char *hostname, int port)
Definition: sockclnt_vlib.c:72
#define clib_unix_warning(format, args...)
Definition: error.h:68
u32 vl_api_registration_pool_index
Index in VLIB&#39;s brain (not shared memory).
Definition: api_common.h:49
u32 server_handle
Socket client only: server handle.
Definition: api_common.h:71
Definition: file.h:51