source: mainline/uspace/app/netecho/netecho.c@ a676574

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a676574 was cd22764, checked in by Martin Decky <martin@…>, 14 years ago

in case —help argument is used, exit and do not proceed to echoing network traffic
  • Property mode set to 100644
File size: 11.6 KB
Line 
1/*
2 * Copyright (c) 2009 Lukas Mejdrech
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup netecho
30 * @{
31 */
32
33/** @file
34 * Network echo server.
35 *
36 * Sockets-based server that echoes incomming messages. If stream mode
37 * is selected, accepts incoming connections.
38 */
39
40#include <assert.h>
41#include <stdio.h>
42#include <stdlib.h>
43#include <str.h>
44#include <task.h>
45#include <arg_parse.h>
46
47#include <net/in.h>
48#include <net/in6.h>
49#include <net/inet.h>
50#include <net/socket.h>
51#include <net/socket_parse.h>
52
53#include "print_error.h"
54
55#define NAME "netecho"
56
57static int count = -1;
58static int family = PF_INET;
59static sock_type_t type = SOCK_DGRAM;
60static uint16_t port = 7;
61static int backlog = 3;
62static size_t size = 1024;
63static int verbose = 0;
64
65static char *reply = NULL;
66static size_t reply_length;
67
68static char *data;
69
70static void echo_print_help(void)
71{
72 printf(
73 "Network echo server\n"
74 "Usage: " NAME " [options]\n"
75 "Where options are:\n"
76 "-b backlog | --backlog=size\n"
77 "\tThe size of the accepted sockets queue. Only for SOCK_STREAM. "
78 "The default is 3.\n"
79 "\n"
80 "-c count | --count=count\n"
81 "\tThe number of received messages to handle. A negative number "
82 "means infinity. The default is infinity.\n"
83 "\n"
84 "-f protocol_family | --family=protocol_family\n"
85 "\tThe listenning socket protocol family. Only the PF_INET and "
86 "PF_INET6 are supported.\n"
87 "\n"
88 "-h | --help\n"
89 "\tShow this application help.\n"
90 "\n"
91 "-p port_number | --port=port_number\n"
92 "\tThe port number the application should listen at. The default "
93 "is 7.\n"
94 "\n"
95 "-r reply_string | --reply=reply_string\n"
96 "\tThe constant reply string. The default is the original data "
97 "received.\n"
98 "\n"
99 "-s receive_size | --size=receive_size\n"
100 "\tThe maximum receive data size the application should accept. "
101 "The default is 1024 bytes.\n"
102 "\n"
103 "-t socket_type | --type=socket_type\n"
104 "\tThe listenning socket type. Only the SOCK_DGRAM and the "
105 "SOCK_STREAM are supported.\n"
106 "\n"
107 "-v | --verbose\n"
108 "\tShow all output messages.\n"
109 );
110}
111
112static int netecho_parse_option(int argc, char *argv[], int *index)
113{
114 int value;
115 int rc;
116
117 switch (argv[*index][1]) {
118 case 'b':
119 rc = arg_parse_int(argc, argv, index, &backlog, 0);
120 if (rc != EOK)
121 return rc;
122 break;
123 case 'c':
124 rc = arg_parse_int(argc, argv, index, &count, 0);
125 if (rc != EOK)
126 return rc;
127 break;
128 case 'f':
129 rc = arg_parse_name_int(argc, argv, index, &family, 0,
130 socket_parse_protocol_family);
131 if (rc != EOK)
132 return rc;
133 break;
134 case 'h':
135 echo_print_help();
136 exit(0);
137 break;
138 case 'p':
139 rc = arg_parse_int(argc, argv, index, &value, 0);
140 if (rc != EOK)
141 return rc;
142 port = (uint16_t) value;
143 break;
144 case 'r':
145 rc = arg_parse_string(argc, argv, index, &reply, 0);
146 if (rc != EOK)
147 return rc;
148 break;
149 case 's':
150 rc = arg_parse_int(argc, argv, index, &value, 0);
151 if (rc != EOK)
152 return rc;
153 size = (value >= 0) ? (size_t) value : 0;
154 break;
155 case 't':
156 rc = arg_parse_name_int(argc, argv, index, &value, 0,
157 socket_parse_socket_type);
158 if (rc != EOK)
159 return rc;
160 type = (sock_type_t) value;
161 break;
162 case 'v':
163 verbose = 1;
164 break;
165 /* Long options with double dash */
166 case '-':
167 if (str_lcmp(argv[*index] + 2, "backlog=", 6) == 0) {
168 rc = arg_parse_int(argc, argv, index, &backlog, 8);
169 if (rc != EOK)
170 return rc;
171 } else if (str_lcmp(argv[*index] + 2, "count=", 6) == 0) {
172 rc = arg_parse_int(argc, argv, index, &count, 8);
173 if (rc != EOK)
174 return rc;
175 } else if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
176 rc = arg_parse_name_int(argc, argv, index, &family, 9,
177 socket_parse_protocol_family);
178 if (rc != EOK)
179 return rc;
180 } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
181 echo_print_help();
182 exit(0);
183 } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
184 rc = arg_parse_int(argc, argv, index, &value, 7);
185 if (rc != EOK)
186 return rc;
187 port = (uint16_t) value;
188 } else if (str_lcmp(argv[*index] + 2, "reply=", 6) == 0) {
189 rc = arg_parse_string(argc, argv, index, &reply, 8);
190 if (rc != EOK)
191 return rc;
192 } else if (str_lcmp(argv[*index] + 2, "size=", 5) == 0) {
193 rc = arg_parse_int(argc, argv, index, &value, 7);
194 if (rc != EOK)
195 return rc;
196 size = (value >= 0) ? (size_t) value : 0;
197 } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
198 rc = arg_parse_name_int(argc, argv, index, &value, 7,
199 socket_parse_socket_type);
200 if (rc != EOK)
201 return rc;
202 type = (sock_type_t) value;
203 } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
204 verbose = 1;
205 } else {
206 echo_print_help();
207 return EINVAL;
208 }
209 break;
210 default:
211 echo_print_help();
212 return EINVAL;
213 }
214
215 return EOK;
216}
217
218/** Echo one message (accept one connection and echo message).
219 *
220 * @param listening_id Listening socket.
221 * @return EOK on success or negative error code.
222 */
223static int netecho_socket_process_message(int listening_id)
224{
225 uint8_t address_buf[sizeof(struct sockaddr_in6)];
226
227 socklen_t addrlen;
228 int socket_id;
229 ssize_t rcv_size;
230 size_t length;
231 uint8_t *address_start;
232
233 char address_string[INET6_ADDRSTRLEN];
234 struct sockaddr_in *address_in = (struct sockaddr_in *) address_buf;
235 struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address_buf;
236 struct sockaddr *address = (struct sockaddr *) address_buf;
237
238 int rc;
239
240 if (type == SOCK_STREAM) {
241 /* Accept a socket if a stream socket is used */
242 addrlen = sizeof(address_buf);
243 socket_id = accept(listening_id, (void *) address_buf, &addrlen);
244 if (socket_id <= 0) {
245 socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
246 } else {
247 if (verbose)
248 printf("Socket %d accepted\n", socket_id);
249 }
250
251 assert((size_t) addrlen <= sizeof(address_buf));
252 } else {
253 socket_id = listening_id;
254 }
255
256 /* if the datagram socket is used or the stream socked was accepted */
257 if (socket_id > 0) {
258
259 /* Receive a message to echo */
260 rcv_size = recvfrom(socket_id, data, size, 0, address,
261 &addrlen);
262 if (rcv_size < 0) {
263 socket_print_error(stderr, rcv_size, "Socket receive: ", "\n");
264 } else {
265 length = (size_t) rcv_size;
266 if (verbose) {
267 /* Print the header */
268
269 /* Get the source port and prepare the address buffer */
270 address_start = NULL;
271 switch (address->sa_family) {
272 case AF_INET:
273 port = ntohs(address_in->sin_port);
274 address_start = (uint8_t *) &address_in->sin_addr.s_addr;
275 break;
276 case AF_INET6:
277 port = ntohs(address_in6->sin6_port);
278 address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
279 break;
280 default:
281 fprintf(stderr, "Address family %u (%#x) is not supported.\n",
282 address->sa_family, address->sa_family);
283 }
284
285 /* Parse source address */
286 if (address_start) {
287 rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
288 if (rc != EOK) {
289 fprintf(stderr, "Received address error %d\n", rc);
290 } else {
291 data[length] = '\0';
292 printf("Socket %d received %zu bytes from %s:%d\n%s\n",
293 socket_id, length, address_string, port, data);
294 }
295 }
296 }
297
298 /* Answer the request either with the static reply or the original data */
299 rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
300 if (rc != EOK)
301 socket_print_error(stderr, rc, "Socket send: ", "\n");
302 }
303
304 /* Close accepted stream socket */
305 if (type == SOCK_STREAM) {
306 rc = closesocket(socket_id);
307 if (rc != EOK)
308 socket_print_error(stderr, rc, "Close socket: ", "\n");
309 }
310
311 }
312
313 return EOK;
314}
315
316
317int main(int argc, char *argv[])
318{
319 struct sockaddr *address;;
320 struct sockaddr_in address_in;
321 struct sockaddr_in6 address_in6;
322 socklen_t addrlen;
323
324 int listening_id;
325 int index;
326 int rc;
327
328 /* Parse command line arguments */
329 for (index = 1; index < argc; ++index) {
330 if (argv[index][0] == '-') {
331 rc = netecho_parse_option(argc, argv, &index);
332 if (rc != EOK)
333 return rc;
334 } else {
335 echo_print_help();
336 return EINVAL;
337 }
338 }
339
340 /* Check buffer size */
341 if (size <= 0) {
342 fprintf(stderr, "Receive size too small (%zu). Using 1024 bytes instead.\n", size);
343 size = 1024;
344 }
345
346 /* size plus the terminating null character. */
347 data = (char *) malloc(size + 1);
348 if (!data) {
349 fprintf(stderr, "Failed to allocate receive buffer.\n");
350 return ENOMEM;
351 }
352
353 /* Set the reply size if set */
354 reply_length = reply ? str_length(reply) : 0;
355
356 /* Prepare the address buffer */
357 switch (family) {
358 case PF_INET:
359 address_in.sin_family = AF_INET;
360 address_in.sin_port = htons(port);
361 address = (struct sockaddr *) &address_in;
362 addrlen = sizeof(address_in);
363 break;
364 case PF_INET6:
365 address_in6.sin6_family = AF_INET6;
366 address_in6.sin6_port = htons(port);
367 address = (struct sockaddr *) &address_in6;
368 addrlen = sizeof(address_in6);
369 break;
370 default:
371 fprintf(stderr, "Protocol family is not supported\n");
372 return EAFNOSUPPORT;
373 }
374
375 /* Get a listening socket */
376 listening_id = socket(family, type, 0);
377 if (listening_id < 0) {
378 socket_print_error(stderr, listening_id, "Socket create: ", "\n");
379 return listening_id;
380 }
381
382 /* if the stream socket is used */
383 if (type == SOCK_STREAM) {
384 /* Check backlog size */
385 if (backlog <= 0) {
386 fprintf(stderr, "Accepted sockets queue size too small (%zu). Using 3 instead.\n", size);
387 backlog = 3;
388 }
389
390 /* Set the backlog */
391 rc = listen(listening_id, backlog);
392 if (rc != EOK) {
393 socket_print_error(stderr, rc, "Socket listen: ", "\n");
394 return rc;
395 }
396 }
397
398 /* Bind the listening socket */
399 rc = bind(listening_id, address, addrlen);
400 if (rc != EOK) {
401 socket_print_error(stderr, rc, "Socket bind: ", "\n");
402 return rc;
403 }
404
405 if (verbose)
406 printf("Socket %d listenning at %d\n", listening_id, port);
407
408 /*
409 * do count times
410 * or indefinitely if set to a negative value
411 */
412 while (count) {
413 rc = netecho_socket_process_message(listening_id);
414 if (rc != EOK)
415 break;
416
417 /* Decrease count if positive */
418 if (count > 0) {
419 count--;
420 if (verbose)
421 printf("Waiting for next %d message(s)\n", count);
422 }
423 }
424
425 if (verbose)
426 printf("Closing the socket\n");
427
428 /* Close listenning socket */
429 rc = closesocket(listening_id);
430 if (rc != EOK) {
431 socket_print_error(stderr, rc, "Close socket: ", "\n");
432 return rc;
433 }
434
435 if (verbose)
436 printf("Exiting\n");
437
438 return EOK;
439}
440
441/** @}
442 */
Note: See TracBrowser for help on using the repository browser.