source: mainline/uspace/srv/net/app/echo/echo.c@ a8a13d0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a8a13d0 was aadf01e, checked in by Lukas Mejdrech <lukasmejdrech@…>, 15 years ago

Coding style (no functional change)
  • Property mode set to 100644
File size: 11.7 KB
RevLine 
[21580dd]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 echo
30 * @{
31 */
32
33/** @file
34 * Echo application.
35 * Answers received packets.
36 */
37
38#include <malloc.h>
39#include <stdio.h>
40#include <string.h>
41#include <task.h>
42
43#include "../../include/in.h"
44#include "../../include/in6.h"
45#include "../../include/inet.h"
46#include "../../include/socket.h"
47
48#include "../../err.h"
49
50#include "../parse.h"
51#include "../print_error.h"
52
53/** Echo module name.
54 */
55#define NAME "Echo"
56
57/** Module entry point.
58 * Reads command line parameters and starts listenning.
59 * @param[in] argc The number of command line parameters.
60 * @param[in] argv The command line parameters.
61 * @returns EOK on success.
62 */
[aadf01e]63int main(int argc, char * argv[]);
[21580dd]64
65/** Prints the application help.
66 */
[aadf01e]67void echo_print_help(void);
[21580dd]68
69/** Translates the character string to the protocol family number.
70 * @param[in] name The protocol family name.
71 * @returns The corresponding protocol family number.
72 * @returns EPFNOSUPPORTED if the protocol family is not supported.
73 */
[aadf01e]74int echo_parse_protocol_family(const char * name);
[21580dd]75
76/** Translates the character string to the socket type number.
77 * @param[in] name The socket type name.
78 * @returns The corresponding socket type number.
79 * @returns ESOCKNOSUPPORTED if the socket type is not supported.
80 */
[aadf01e]81int echo_parse_socket_type(const char * name);
[21580dd]82
[aadf01e]83void echo_print_help(void){
[21580dd]84 printf(
85 "Network Echo aplication\n" \
86 "Usage: echo [options]\n" \
87 "Where options are:\n" \
88 "-b backlog | --backlog=size\n" \
89 "\tThe size of the accepted sockets queue. Only for SOCK_STREAM. The default is 3.\n" \
90 "\n" \
91 "-c count | --count=count\n" \
92 "\tThe number of received messages to handle. A negative number means infinity. The default is infinity.\n" \
93 "\n" \
94 "-f protocol_family | --family=protocol_family\n" \
95 "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
96 "\n" \
97 "-h | --help\n" \
98 "\tShow this application help.\n"
99 "\n" \
100 "-p port_number | --port=port_number\n" \
101 "\tThe port number the application should listen at. The default is 7.\n" \
102 "\n" \
103 "-r reply_string | --reply=reply_string\n" \
104 "\tThe constant reply string. The default is the original data received.\n" \
105 "\n" \
106 "-s receive_size | --size=receive_size\n" \
107 "\tThe maximum receive data size the application should accept. The default is 1024 bytes.\n" \
108 "\n" \
109 "-t socket_type | --type=socket_type\n" \
110 "\tThe listenning socket type. Only the SOCK_DGRAM and the SOCK_STREAM are supported.\n" \
111 "\n" \
112 "-v | --verbose\n" \
113 "\tShow all output messages.\n"
114 );
115}
116
[aadf01e]117int echo_parse_protocol_family(const char * name){
118 if(str_lcmp(name, "PF_INET", 7) == 0){
[21580dd]119 return PF_INET;
[aadf01e]120 }else if(str_lcmp(name, "PF_INET6", 8) == 0){
[21580dd]121 return PF_INET6;
122 }
123 return EPFNOSUPPORT;
124}
125
[aadf01e]126int echo_parse_socket_type(const char * name){
127 if(str_lcmp(name, "SOCK_DGRAM", 11) == 0){
[21580dd]128 return SOCK_DGRAM;
[aadf01e]129 }else if(str_lcmp(name, "SOCK_STREAM", 12) == 0){
[21580dd]130 return SOCK_STREAM;
131 }
132 return ESOCKTNOSUPPORT;
133}
134
[aadf01e]135int main(int argc, char * argv[]){
[21580dd]136 ERROR_DECLARE;
137
[aadf01e]138 size_t size = 1024;
139 int verbose = 0;
140 char * reply = NULL;
141 sock_type_t type = SOCK_DGRAM;
142 int count = -1;
143 int family = PF_INET;
144 uint16_t port = 7;
145 int backlog = 3;
146
147 socklen_t max_length = sizeof(struct sockaddr_in6);
148 uint8_t address_data[max_length];
149 struct sockaddr * address = (struct sockaddr *) address_data;
150 struct sockaddr_in * address_in = (struct sockaddr_in *) address;
151 struct sockaddr_in6 * address_in6 = (struct sockaddr_in6 *) address;
152 socklen_t addrlen;
153 char address_string[INET6_ADDRSTRLEN];
154 uint8_t * address_start;
155 int socket_id;
156 int listening_id;
[21580dd]157 char * data;
[aadf01e]158 size_t length;
159 int index;
160 size_t reply_length;
161 int value;
162
163 printf("Task %d - ", task_get_id());
164 printf("%s\n", NAME);
165
166 for(index = 1; index < argc; ++ index){
167 if(argv[index][0] == '-'){
168 switch(argv[index][1]){
169 case 'b':
170 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &backlog, "accepted sockets queue size", 0));
171 break;
172 case 'c':
173 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &count, "message count", 0));
174 break;
175 case 'f':
176 ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "protocol family", 0, echo_parse_protocol_family));
177 break;
178 case 'h':
179 echo_print_help();
180 return EOK;
181 break;
182 case 'p':
183 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "port number", 0));
184 port = (uint16_t) value;
185 break;
186 case 'r':
187 ERROR_PROPAGATE(parse_parameter_string(argc, argv, &index, &reply, "reply string", 0));
188 break;
189 case 's':
190 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "receive size", 0));
191 size = (value >= 0) ? (size_t) value : 0;
192 break;
193 case 't':
194 ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &value, "socket type", 0, echo_parse_socket_type));
195 type = (sock_type_t) value;
196 break;
197 case 'v':
198 verbose = 1;
199 break;
200 case '-':
201 if(str_lcmp(argv[index] + 2, "backlog=", 6) == 0){
202 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &backlog, "accepted sockets queue size", 8));
203 }else if(str_lcmp(argv[index] + 2, "count=", 6) == 0){
204 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &count, "message count", 8));
205 }else if(str_lcmp(argv[index] + 2, "family=", 7) == 0){
206 ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "protocol family", 9, echo_parse_protocol_family));
207 }else if(str_lcmp(argv[index] + 2, "help", 5) == 0){
208 echo_print_help();
209 return EOK;
210 }else if(str_lcmp(argv[index] + 2, "port=", 5) == 0){
211 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "port number", 7));
212 port = (uint16_t) value;
213 }else if(str_lcmp(argv[index] + 2, "reply=", 6) == 0){
214 ERROR_PROPAGATE(parse_parameter_string(argc, argv, &index, &reply, "reply string", 8));
215 }else if(str_lcmp(argv[index] + 2, "size=", 5) == 0){
216 ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "receive size", 7));
217 size = (value >= 0) ? (size_t) value : 0;
218 }else if(str_lcmp(argv[index] + 2, "type=", 5) == 0){
219 ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &value, "socket type", 7, echo_parse_socket_type));
220 type = (sock_type_t) value;
221 }else if(str_lcmp(argv[index] + 2, "verbose", 8) == 0){
222 verbose = 1;
223 }else{
224 print_unrecognized(index, argv[index] + 2);
225 echo_print_help();
226 return EINVAL;
227 }
228 break;
[21580dd]229 default:
[aadf01e]230 print_unrecognized(index, argv[index] + 1);
[21580dd]231 echo_print_help();
232 return EINVAL;
233 }
234 }else{
[aadf01e]235 print_unrecognized(index, argv[index]);
[21580dd]236 echo_print_help();
237 return EINVAL;
238 }
239 }
240
[aadf01e]241 if(size <= 0){
242 fprintf(stderr, "Receive size too small (%d). Using 1024 bytes instead.\n", size);
[21580dd]243 size = 1024;
244 }
245 // size plus terminating null (\0)
[aadf01e]246 data = (char *) malloc(size + 1);
247 if(! data){
248 fprintf(stderr, "Failed to allocate receive buffer.\n");
[21580dd]249 return ENOMEM;
250 }
251
[aadf01e]252 reply_length = reply ? str_length(reply) : 0;
[21580dd]253
[aadf01e]254 listening_id = socket(family, type, 0);
255 if(listening_id < 0){
256 socket_print_error(stderr, listening_id, "Socket create: ", "\n");
[21580dd]257 return listening_id;
258 }
259
[aadf01e]260 bzero(address_data, max_length);
261 switch(family){
[21580dd]262 case PF_INET:
263 address_in->sin_family = AF_INET;
[aadf01e]264 address_in->sin_port = htons(port);
265 addrlen = sizeof(struct sockaddr_in);
[21580dd]266 break;
267 case PF_INET6:
268 address_in6->sin6_family = AF_INET6;
[aadf01e]269 address_in6->sin6_port = htons(port);
270 addrlen = sizeof(struct sockaddr_in6);
[21580dd]271 break;
272 default:
[aadf01e]273 fprintf(stderr, "Protocol family is not supported\n");
[21580dd]274 return EAFNOSUPPORT;
275 }
276
[aadf01e]277 listening_id = socket(family, type, 0);
278 if(listening_id < 0){
279 socket_print_error(stderr, listening_id, "Socket create: ", "\n");
[21580dd]280 return listening_id;
281 }
282
[aadf01e]283 if(type == SOCK_STREAM){
284 if(backlog <= 0){
285 fprintf(stderr, "Accepted sockets queue size too small (%d). Using 3 instead.\n", size);
[21580dd]286 backlog = 3;
287 }
[aadf01e]288 if(ERROR_OCCURRED(listen(listening_id, backlog))){
289 socket_print_error(stderr, ERROR_CODE, "Socket listen: ", "\n");
[21580dd]290 return ERROR_CODE;
291 }
292 }
293
[aadf01e]294 if(ERROR_OCCURRED(bind(listening_id, address, addrlen))){
295 socket_print_error(stderr, ERROR_CODE, "Socket bind: ", "\n");
[21580dd]296 return ERROR_CODE;
297 }
298
[aadf01e]299 if(verbose){
300 printf("Socket %d listenning at %d\n", listening_id, port);
301 }
[2d68c72]302
303 socket_id = listening_id;
[21580dd]304
[aadf01e]305 while(count){
[21580dd]306 addrlen = max_length;
[aadf01e]307 if(type == SOCK_STREAM){
308 socket_id = accept(listening_id, address, &addrlen);
309 if(socket_id <= 0){
310 socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
[1b053ca2]311 }else{
[aadf01e]312 if(verbose){
313 printf("Socket %d accepted\n", socket_id);
314 }
[21580dd]315 }
316 }
[aadf01e]317 if(socket_id > 0){
318 value = recvfrom(socket_id, data, size, 0, address, &addrlen);
319 if(value < 0){
320 socket_print_error(stderr, value, "Socket receive: ", "\n");
[21580dd]321 }else{
[aadf01e]322 length = (size_t) value;
323 if(verbose){
[21580dd]324 address_start = NULL;
[aadf01e]325 switch(address->sa_family){
[21580dd]326 case AF_INET:
[aadf01e]327 port = ntohs(address_in->sin_port);
328 address_start = (uint8_t *) &address_in->sin_addr.s_addr;
[21580dd]329 break;
330 case AF_INET6:
[aadf01e]331 port = ntohs(address_in6->sin6_port);
332 address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
[21580dd]333 break;
334 default:
[aadf01e]335 fprintf(stderr, "Address family %d (0x%X) is not supported.\n", address->sa_family);
[21580dd]336 }
[aadf01e]337 if(address_start){
338 if(ERROR_OCCURRED(inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string)))){
339 fprintf(stderr, "Received address error %d\n", ERROR_CODE);
[21580dd]340 }else{
[aadf01e]341 data[length] = '\0';
342 printf("Socket %d received %d bytes from %s:%d\n%s\n", socket_id, length, address_string, port, data);
[21580dd]343 }
344 }
345 }
[aadf01e]346 if(ERROR_OCCURRED(sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen))){
347 socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
[21580dd]348 }
349 }
[aadf01e]350 if(type == SOCK_STREAM){
351 if(ERROR_OCCURRED(closesocket(socket_id))){
352 socket_print_error(stderr, ERROR_CODE, "Close socket: ", "\n");
[21580dd]353 }
354 }
355 }
[aadf01e]356 if(count > 0){
[21580dd]357 -- count;
[aadf01e]358 if(verbose){
359 printf("Waiting for next %d packet(s)\n", count);
360 }
[21580dd]361 }
362 }
363
[aadf01e]364 if(verbose){
365 printf("Closing the socket\n");
366 }
[21580dd]367
[aadf01e]368 if(ERROR_OCCURRED(closesocket(listening_id))){
369 socket_print_error(stderr, ERROR_CODE, "Close socket: ", "\n");
[21580dd]370 return ERROR_CODE;
371 }
372
[aadf01e]373 if(verbose){
374 printf("Exiting\n");
375 }
[21580dd]376
377 return EOK;
378}
379
380/** @}
381 */
Note: See TracBrowser for help on using the repository browser.