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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1b053ca2 was 1b053ca2, checked in by Lukas Mejdrech <lukasmejdrech@…>, 16 years ago
  • echo accepted message if verbose fix
  • Property mode set to 100644
File size: 12.1 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 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 */
63int main( int argc, char * argv[] );
64
65/** Prints the application help.
66 */
67void echo_print_help( void );
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 */
74int echo_parse_protocol_family( const char * name );
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 */
81int echo_parse_socket_type( const char * name );
82
83void echo_print_help( void ){
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
117int echo_parse_protocol_family( const char * name ){
118 if( str_lcmp( name, "PF_INET", 7 ) == 0 ){
119 return PF_INET;
120 }else if( str_lcmp( name, "PF_INET6", 8 ) == 0 ){
121 return PF_INET6;
122 }
123 return EPFNOSUPPORT;
124}
125
126int echo_parse_socket_type( const char * name ){
127 if( str_lcmp( name, "SOCK_DGRAM", 11 ) == 0 ){
128 return SOCK_DGRAM;
129 }else if( str_lcmp( name, "SOCK_STREAM", 12 ) == 0 ){
130 return SOCK_STREAM;
131 }
132 return ESOCKTNOSUPPORT;
133}
134
135int main( int argc, char * argv[] ){
136 ERROR_DECLARE;
137
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;
157 char * data;
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': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & backlog, "accepted sockets queue size", 0 ));
170 break;
171 case 'c': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "message count", 0 ));
172 break;
173 case 'f': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 0, echo_parse_protocol_family ));
174 break;
175 case 'h': echo_print_help();
176 return EOK;
177 break;
178 case 'p': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 0 ));
179 port = ( uint16_t ) value;
180 break;
181 case 'r': ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 0 ));
182 break;
183 case 's': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "receive size", 0 ));
184 size = (value >= 0 ) ? ( size_t ) value : 0;
185 break;
186 case 't': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket type", 0, echo_parse_socket_type ));
187 type = ( sock_type_t ) value;
188 break;
189 case 'v': verbose = 1;
190 break;
191 case '-': if( str_lcmp( argv[ index ] + 2, "backlog=", 6 ) == 0 ){
192 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & backlog, "accepted sockets queue size", 8 ));
193 }else if( str_lcmp( argv[ index ] + 2, "count=", 6 ) == 0 ){
194 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "message count", 8 ));
195 }else if( str_lcmp( argv[ index ] + 2, "family=", 7 ) == 0 ){
196 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 9, echo_parse_protocol_family ));
197 }else if( str_lcmp( argv[ index ] + 2, "help", 5 ) == 0 ){
198 echo_print_help();
199 return EOK;
200 }else if( str_lcmp( argv[ index ] + 2, "port=", 5 ) == 0 ){
201 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 7 ));
202 port = ( uint16_t ) value;
203 }else if( str_lcmp( argv[ index ] + 2, "reply=", 6 ) == 0 ){
204 ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 8 ));
205 }else if( str_lcmp( argv[ index ] + 2, "size=", 5 ) == 0 ){
206 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "receive size", 7 ));
207 size = (value >= 0 ) ? ( size_t ) value : 0;
208 }else if( str_lcmp( argv[ index ] + 2, "type=", 5 ) == 0 ){
209 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket type", 7, echo_parse_socket_type ));
210 type = ( sock_type_t ) value;
211 }else if( str_lcmp( argv[ index ] + 2, "verbose", 8 ) == 0 ){
212 verbose = 1;
213 }else{
214 print_unrecognized( index, argv[ index ] + 2 );
215 echo_print_help();
216 return EINVAL;
217 }
218 break;
219 default:
220 print_unrecognized( index, argv[ index ] + 1 );
221 echo_print_help();
222 return EINVAL;
223 }
224 }else{
225 print_unrecognized( index, argv[ index ] );
226 echo_print_help();
227 return EINVAL;
228 }
229 }
230
231 if( size <= 0 ){
232 fprintf( stderr, "Receive size too small (%d). Using 1024 bytes instead.\n", size );
233 size = 1024;
234 }
235 // size plus terminating null (\0)
236 data = ( char * ) malloc( size + 1 );
237 if( ! data ){
238 fprintf( stderr, "Failed to allocate receive buffer.\n" );
239 return ENOMEM;
240 }
241
242 reply_length = reply ? str_length( reply ) : 0;
243
244 listening_id = socket( family, type, 0 );
245 if( listening_id < 0 ){
246 socket_print_error( stderr, listening_id, "Socket create: ", "\n" );
247 return listening_id;
248 }
249
250 bzero( address_data, max_length );
251 switch( family ){
252 case PF_INET:
253 address_in->sin_family = AF_INET;
254 address_in->sin_port = htons( port );
255 addrlen = sizeof( struct sockaddr_in );
256 break;
257 case PF_INET6:
258 address_in6->sin6_family = AF_INET6;
259 address_in6->sin6_port = htons( port );
260 addrlen = sizeof( struct sockaddr_in6 );
261 break;
262 default:
263 fprintf( stderr, "Protocol family is not supported\n" );
264 return EAFNOSUPPORT;
265 }
266
267 listening_id = socket( family, type, 0 );
268 if( listening_id < 0 ){
269 socket_print_error( stderr, listening_id, "Socket create: ", "\n" );
270 return listening_id;
271 }
272
273 if( type == SOCK_STREAM ){
274 if( backlog <= 0 ){
275 fprintf( stderr, "Accepted sockets queue size too small (%d). Using 3 instead.\n", size );
276 backlog = 3;
277 }
278 if( ERROR_OCCURRED( listen( listening_id, backlog ))){
279 socket_print_error( stderr, ERROR_CODE, "Socket listen: ", "\n" );
280 return ERROR_CODE;
281 }
282 }
283
284 if( ERROR_OCCURRED( bind( listening_id, address, addrlen ))){
285 socket_print_error( stderr, ERROR_CODE, "Socket bind: ", "\n" );
286 return ERROR_CODE;
287 }
288
289 if( verbose ) printf( "Socket %d listenning at %d\n", listening_id, port );
290
291 socket_id = listening_id;
292
293 while( count ){
294 addrlen = max_length;
295 if( type == SOCK_STREAM ){
296 socket_id = accept( listening_id, address, & addrlen );
297 if( socket_id <= 0 ){
298 socket_print_error( stderr, socket_id, "Socket accept: ", "\n" );
299 }else{
300 if( verbose ) printf( "Socket %d accepted\n", socket_id );
301 }
302 }
303 if( socket_id > 0 ){
304 value = recvfrom( socket_id, data, size, 0, address, & addrlen );
305 if( value < 0 ){
306 socket_print_error( stderr, value, "Socket receive: ", "\n" );
307 }else{
308 length = ( size_t ) value;
309 if( verbose ){
310 address_start = NULL;
311 switch( address->sa_family ){
312 case AF_INET:
313 port = ntohs( address_in->sin_port );
314 address_start = ( uint8_t * ) & address_in->sin_addr.s_addr;
315 break;
316 case AF_INET6:
317 port = ntohs( address_in6->sin6_port );
318 address_start = ( uint8_t * ) & address_in6->sin6_addr.s6_addr;
319 break;
320 default:
321 fprintf( stderr, "Address family %d (0x%X) is not supported.\n", address->sa_family );
322 }
323 if( address_start ){
324 if( ERROR_OCCURRED( inet_ntop( address->sa_family, address_start, address_string, sizeof( address_string )))){
325 fprintf( stderr, "Received address error %d\n", ERROR_CODE );
326 }else{
327 data[ length ] = '\0';
328 printf( "Socket %d received %d bytes from %s:%d\n%s\n", socket_id, length, address_string, port, data );
329 }
330 }
331 }
332 if( ERROR_OCCURRED( sendto( socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen ))){
333 socket_print_error( stderr, ERROR_CODE, "Socket send: ", "\n" );
334 }
335 }
336 if( type == SOCK_STREAM ){
337 if( ERROR_OCCURRED( closesocket( socket_id ))){
338 socket_print_error( stderr, ERROR_CODE, "Close socket: ", "\n" );
339 }
340 }
341 }
342 if( count > 0 ){
343 -- count;
344 if( verbose ) printf( "Waiting for next %d packet(s)\n", count );
345 }
346 }
347
348 if( verbose ) printf( "Closing the socket\n" );
349
350 if( ERROR_OCCURRED( closesocket( listening_id ))){
351 socket_print_error( stderr, ERROR_CODE, "Close socket: ", "\n" );
352 return ERROR_CODE;
353 }
354
355 if( verbose ) printf( "Exiting\n" );
356
357 return EOK;
358}
359
360/** @}
361 */
Note: See TracBrowser for help on using the repository browser.