power: fix frequency list buffer validation
[dpdk.git] / examples / ip_pipeline / conn.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2018 Intel Corporation
3  */
4
5 #include <string.h>
6 #include <stdlib.h>
7 #include <stdio.h>
8 #include <unistd.h>
9 #include <sys/types.h>
10
11 #include <sys/socket.h>
12
13 #include <sys/epoll.h>
14 #include <netinet/in.h>
15 #include <arpa/inet.h>
16 #include <errno.h>
17
18 #include "conn.h"
19
20 #define MSG_CMD_TOO_LONG "Command too long."
21
22 struct conn {
23         char *welcome;
24         char *prompt;
25         char *buf;
26         char *msg_in;
27         char *msg_out;
28         size_t buf_size;
29         size_t msg_in_len_max;
30         size_t msg_out_len_max;
31         size_t msg_in_len;
32         int fd_server;
33         int fd_client_group;
34         conn_msg_handle_t msg_handle;
35 };
36
37 struct conn *
38 conn_init(struct conn_params *p)
39 {
40         struct sockaddr_in server_address;
41         struct conn *conn;
42         int fd_server, fd_client_group, status;
43
44         memset(&server_address, 0, sizeof(server_address));
45
46         /* Check input arguments */
47         if ((p == NULL) ||
48                 (p->welcome == NULL) ||
49                 (p->prompt == NULL) ||
50                 (p->addr == NULL) ||
51                 (p->buf_size == 0) ||
52                 (p->msg_in_len_max == 0) ||
53                 (p->msg_out_len_max == 0) ||
54                 (p->msg_handle == NULL))
55                 return NULL;
56
57         status = inet_aton(p->addr, &server_address.sin_addr);
58         if (status == 0)
59                 return NULL;
60
61         /* Memory allocation */
62         conn = calloc(1, sizeof(struct conn));
63         if (conn == NULL)
64                 return NULL;
65
66         conn->welcome = calloc(1, CONN_WELCOME_LEN_MAX + 1);
67         conn->prompt = calloc(1, CONN_PROMPT_LEN_MAX + 1);
68         conn->buf = calloc(1, p->buf_size);
69         conn->msg_in = calloc(1, p->msg_in_len_max + 1);
70         conn->msg_out = calloc(1, p->msg_out_len_max + 1);
71
72         if ((conn->welcome == NULL) ||
73                 (conn->prompt == NULL) ||
74                 (conn->buf == NULL) ||
75                 (conn->msg_in == NULL) ||
76                 (conn->msg_out == NULL)) {
77                 conn_free(conn);
78                 return NULL;
79         }
80
81         /* Server socket */
82         server_address.sin_family = AF_INET;
83         server_address.sin_port = htons(p->port);
84
85         fd_server = socket(AF_INET,
86                 SOCK_STREAM | SOCK_NONBLOCK,
87                 0);
88         if (fd_server == -1) {
89                 conn_free(conn);
90                 return NULL;
91         }
92
93         status = bind(fd_server,
94                 (struct sockaddr *) &server_address,
95                 sizeof(server_address));
96         if (status == -1) {
97                 conn_free(conn);
98                 close(fd_server);
99                 return NULL;
100         }
101
102         status = listen(fd_server, 16);
103         if (status == -1) {
104                 conn_free(conn);
105                 close(fd_server);
106                 return NULL;
107         }
108
109         /* Client group */
110         fd_client_group = epoll_create(1);
111         if (fd_client_group == -1) {
112                 conn_free(conn);
113                 close(fd_server);
114                 return NULL;
115         }
116
117         /* Fill in */
118         strncpy(conn->welcome, p->welcome, CONN_WELCOME_LEN_MAX);
119         strncpy(conn->prompt, p->prompt, CONN_PROMPT_LEN_MAX);
120         conn->buf_size = p->buf_size;
121         conn->msg_in_len_max = p->msg_in_len_max;
122         conn->msg_out_len_max = p->msg_out_len_max;
123         conn->msg_in_len = 0;
124         conn->fd_server = fd_server;
125         conn->fd_client_group = fd_client_group;
126         conn->msg_handle = p->msg_handle;
127
128         return conn;
129 }
130
131 void
132 conn_free(struct conn *conn)
133 {
134         if (conn == NULL)
135                 return;
136
137         if (conn->fd_client_group)
138                 close(conn->fd_client_group);
139
140         if (conn->fd_server)
141                 close(conn->fd_server);
142
143         free(conn->msg_out);
144         free(conn->msg_in);
145         free(conn->prompt);
146         free(conn->welcome);
147         free(conn);
148 }
149
150 int
151 conn_poll_for_conn(struct conn *conn)
152 {
153         struct sockaddr_in client_address;
154         struct epoll_event event;
155         socklen_t client_address_length;
156         int fd_client, status;
157
158         /* Check input arguments */
159         if (conn == NULL)
160                 return -1;
161
162         /* Server socket */
163         client_address_length = sizeof(client_address);
164         fd_client = accept4(conn->fd_server,
165                 (struct sockaddr *) &client_address,
166                 &client_address_length,
167                 SOCK_NONBLOCK);
168         if (fd_client == -1) {
169                 if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
170                         return 0;
171
172                 return -1;
173         }
174
175         /* Client group */
176         event.events = EPOLLIN | EPOLLRDHUP | EPOLLHUP;
177         event.data.fd = fd_client;
178
179         status = epoll_ctl(conn->fd_client_group,
180                 EPOLL_CTL_ADD,
181                 fd_client,
182                 &event);
183         if (status == -1) {
184                 close(fd_client);
185                 return -1;
186         }
187
188         /* Client */
189         status = write(fd_client,
190                 conn->welcome,
191                 strlen(conn->welcome));
192         if (status == -1) {
193                 close(fd_client);
194                 return -1;
195         }
196
197         status = write(fd_client,
198                 conn->prompt,
199                 strlen(conn->prompt));
200         if (status == -1) {
201                 close(fd_client);
202                 return -1;
203         }
204
205         return 0;
206 }
207
208 static int
209 data_event_handle(struct conn *conn,
210         int fd_client)
211 {
212         ssize_t len, i, status;
213
214         /* Read input message */
215
216         len = read(fd_client,
217                 conn->buf,
218                 conn->buf_size);
219         if (len == -1) {
220                 if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
221                         return 0;
222
223                 return -1;
224         }
225         if (len == 0)
226                 return 0;
227
228         /* Handle input messages */
229         for (i = 0; i < len; i++) {
230                 if (conn->buf[i] == '\n') {
231                         size_t n;
232
233                         conn->msg_in[conn->msg_in_len] = 0;
234                         conn->msg_out[0] = 0;
235
236                         conn->msg_handle(conn->msg_in,
237                                 conn->msg_out,
238                                 conn->msg_out_len_max);
239
240                         n = strlen(conn->msg_out);
241                         if (n) {
242                                 status = write(fd_client,
243                                         conn->msg_out,
244                                         n);
245                                 if (status == -1)
246                                         return status;
247                         }
248
249                         conn->msg_in_len = 0;
250                 } else if (conn->msg_in_len < conn->msg_in_len_max) {
251                         conn->msg_in[conn->msg_in_len] = conn->buf[i];
252                         conn->msg_in_len++;
253                 } else {
254                         status = write(fd_client,
255                                 MSG_CMD_TOO_LONG,
256                                 strlen(MSG_CMD_TOO_LONG));
257                         if (status == -1)
258                                 return status;
259
260                         conn->msg_in_len = 0;
261                 }
262         }
263
264         /* Write prompt */
265         status = write(fd_client,
266                 conn->prompt,
267                 strlen(conn->prompt));
268         if (status == -1)
269                 return status;
270
271         return 0;
272 }
273
274 static int
275 control_event_handle(struct conn *conn,
276         int fd_client)
277 {
278         int status;
279
280         status = epoll_ctl(conn->fd_client_group,
281                 EPOLL_CTL_DEL,
282                 fd_client,
283                 NULL);
284         if (status == -1)
285                 return -1;
286
287         status = close(fd_client);
288         if (status == -1)
289                 return -1;
290
291         return 0;
292 }
293
294 int
295 conn_poll_for_msg(struct conn *conn)
296 {
297         struct epoll_event event;
298         int fd_client, status, status_data = 0, status_control = 0;
299
300         /* Check input arguments */
301         if (conn == NULL)
302                 return -1;
303
304         /* Client group */
305         status = epoll_wait(conn->fd_client_group,
306                 &event,
307                 1,
308                 0);
309         if (status == -1)
310                 return -1;
311         if (status == 0)
312                 return 0;
313
314         fd_client = event.data.fd;
315
316         /* Data available */
317         if (event.events & EPOLLIN)
318                 status_data = data_event_handle(conn, fd_client);
319
320         /* Control events */
321         if (event.events & (EPOLLRDHUP | EPOLLERR | EPOLLHUP))
322                 status_control = control_event_handle(conn, fd_client);
323
324         if (status_data || status_control)
325                 return -1;
326
327         return 0;
328 }