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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since c6533a7 was 26ec91c, checked in by Jiri Svoboda <jiri@…>, 14 years ago

Add more debugging messages to netecho.
  • Property mode set to 100644
File size: 12.0 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 if (verbose)
244 printf("accept()\n");
245 socket_id = accept(listening_id, (void *) address_buf, &addrlen);
246 if (socket_id <= 0) {
247 socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
248 } else {
249 if (verbose)
250 printf("Socket %d accepted\n", socket_id);
251 }
252
253 assert((size_t) addrlen <= sizeof(address_buf));
254 } else {
255 socket_id = listening_id;
256 }
257
258 /* if the datagram socket is used or the stream socked was accepted */
259 if (socket_id > 0) {
260
261 /* Receive a message to echo */
262 if (verbose)
263 printf("recvfrom()\n");
264 rcv_size = recvfrom(socket_id, data, size, 0, address,
265 &addrlen);
266 if (rcv_size < 0) {
267 socket_print_error(stderr, rcv_size, "Socket receive: ", "\n");
268 } else {
269 length = (size_t) rcv_size;
270 if (verbose) {
271 /* Print the header */
272
273 /* Get the source port and prepare the address buffer */
274 address_start = NULL;
275 switch (address->sa_family) {
276 case AF_INET:
277 port = ntohs(address_in->sin_port);
278 address_start = (uint8_t *) &address_in->sin_addr.s_addr;
279 break;
280 case AF_INET6:
281 port = ntohs(address_in6->sin6_port);
282 address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
283 break;
284 default:
285 fprintf(stderr, "Address family %u (%#x) is not supported.\n",
286 address->sa_family, address->sa_family);
287 }
288
289 /* Parse source address */
290 if (address_start) {
291 rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
292 if (rc != EOK) {
293 fprintf(stderr, "Received address error %d\n", rc);
294 } else {
295 data[length] = '\0';
296 printf("Socket %d received %zu bytes from %s:%d\n%s\n",
297 socket_id, length, address_string, port, data);
298 }
299 }
300 }
301
302 /* Answer the request either with the static reply or the original data */
303 if (type == SOCK_STREAM) {
304 if (verbose)
305 printf("send()\n");
306 rc = send(socket_id, reply ? reply : data, reply ? reply_length : length, 0);
307 if (rc != EOK)
308 socket_print_error(stderr, rc, "Socket send: ", "\n");
309 } else {
310 if (verbose)
311 printf("sendto()\n");
312 rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
313 if (rc != EOK)
314 socket_print_error(stderr, rc, "Socket send: ", "\n");
315 }
316 }
317
318 /* Close accepted stream socket */
319 if (type == SOCK_STREAM) {
320 rc = closesocket(socket_id);
321 if (rc != EOK)
322 socket_print_error(stderr, rc, "Close socket: ", "\n");
323 }
324
325 }
326
327 return EOK;
328}
329
330
331int main(int argc, char *argv[])
332{
333 struct sockaddr *address;;
334 struct sockaddr_in address_in;
335 struct sockaddr_in6 address_in6;
336 socklen_t addrlen;
337
338 int listening_id;
339 int index;
340 int rc;
341
342 /* Parse command line arguments */
343 for (index = 1; index < argc; ++index) {
344 if (argv[index][0] == '-') {
345 rc = netecho_parse_option(argc, argv, &index);
346 if (rc != EOK)
347 return rc;
348 } else {
349 echo_print_help();
350 return EINVAL;
351 }
352 }
353
354 /* Check buffer size */
355 if (size <= 0) {
356 fprintf(stderr, "Receive size too small (%zu). Using 1024 bytes instead.\n", size);
357 size = 1024;
358 }
359
360 /* size plus the terminating null character. */
361 data = (char *) malloc(size + 1);
362 if (!data) {
363 fprintf(stderr, "Failed to allocate receive buffer.\n");
364 return ENOMEM;
365 }
366
367 /* Set the reply size if set */
368 reply_length = reply ? str_length(reply) : 0;
369
370 /* Prepare the address buffer */
371 switch (family) {
372 case PF_INET:
373 address_in.sin_family = AF_INET;
374 address_in.sin_port = htons(port);
375 address = (struct sockaddr *) &address_in;
376 addrlen = sizeof(address_in);
377 break;
378 case PF_INET6:
379 address_in6.sin6_family = AF_INET6;
380 address_in6.sin6_port = htons(port);
381 address = (struct sockaddr *) &address_in6;
382 addrlen = sizeof(address_in6);
383 break;
384 default:
385 fprintf(stderr, "Protocol family is not supported\n");
386 return EAFNOSUPPORT;
387 }
388
389 /* Get a listening socket */
390 listening_id = socket(family, type, 0);
391 if (listening_id < 0) {
392 socket_print_error(stderr, listening_id, "Socket create: ", "\n");
393 return listening_id;
394 }
395
396 /* if the stream socket is used */
397 if (type == SOCK_STREAM) {
398 /* Check backlog size */
399 if (backlog <= 0) {
400 fprintf(stderr, "Accepted sockets queue size too small (%zu). Using 3 instead.\n", size);
401 backlog = 3;
402 }
403
404 /* Set the backlog */
405 rc = listen(listening_id, backlog);
406 if (rc != EOK) {
407 socket_print_error(stderr, rc, "Socket listen: ", "\n");
408 return rc;
409 }
410 }
411
412 /* Bind the listening socket */
413 rc = bind(listening_id, address, addrlen);
414 if (rc != EOK) {
415 socket_print_error(stderr, rc, "Socket bind: ", "\n");
416 return rc;
417 }
418
419 if (verbose)
420 printf("Socket %d listenning at %d\n", listening_id, port);
421
422 /*
423 * do count times
424 * or indefinitely if set to a negative value
425 */
426 while (count) {
427 rc = netecho_socket_process_message(listening_id);
428 if (rc != EOK)
429 break;
430
431 /* Decrease count if positive */
432 if (count > 0) {
433 count--;
434 if (verbose)
435 printf("Waiting for next %d message(s)\n", count);
436 }
437 }
438
439 if (verbose)
440 printf("Closing the socket\n");
441
442 /* Close listenning socket */
443 rc = closesocket(listening_id);
444 if (rc != EOK) {
445 socket_print_error(stderr, rc, "Close socket: ", "\n");
446 return rc;
447 }
448
449 if (verbose)
450 printf("Exiting\n");
451
452 return EOK;
453}
454
455/** @}
456 */
Note: See TracBrowser for help on using the repository browser.