0,0 → 1,357 |
/* |
* Copyright (c) 2009 Lukas Mejdrech |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
|
/** @addtogroup echo |
* @{ |
*/ |
|
/** @file |
*/ |
|
#include <malloc.h> |
#include <stdio.h> |
#include <string.h> |
#include <task.h> |
|
#include "../../include/in.h" |
#include "../../include/inet.h" |
#include "../../include/socket.h" |
|
#include "../../err.h" |
|
/** Echo module name. |
*/ |
#define NAME "Echo" |
|
/** Module entry point. |
* Reads command line parameters and starts listenning. |
* @param argc The number of command line parameters. Input parameter. |
* @param argv The command line parameters. Input parameter. |
* @returns EOK on success. |
*/ |
int main( int argc, char * argv[] ); |
|
/** Prints the application help. |
*/ |
void print_help( void ); |
|
/** Prints the parameter unrecognized message and the application help. |
* @param index The index of the parameter. Input parameter. |
* @param parameter The parameter name. Input parameter. |
*/ |
void print_unrecognized( int index, const char * parameter ); |
|
/** Parses the next parameter as an integral number. |
* Uses the offseted actual parameter if the offset is set or the next one if not. |
* @param argc The total number of the parameters. Input parameter. |
* @param argv The parameters. Input parameter. |
* @param index The actual parameter index. Input/output parameter. |
* @param value The parsed parameter value. Output parameter. |
* @param name The parameter name to be printed on errors. Input parameter. |
* @param offset The value offset in the actual parameter. If not set, the next parameter is parsed instead. Input parameter. |
* @returns EOK on success. |
* @returns EINVAL if the parameter is missing. |
* @returns EINVAL if the parameter is in wrong format. |
*/ |
int parse_parameter_int( int argc, char ** argv, int * index, int * value, const char * name, int offset ); |
|
/** Parses the next parameter as a character string. |
* Uses the offseted actual parameter if the offset is set or the next one if not. |
* @param argc The total number of the parameters. Input parameter. |
* @param argv The parameters. Input parameter. |
* @param index The actual parameter index. Input/output parameter. |
* @param value The parsed parameter value. Output parameter. |
* @param name The parameter name to be printed on errors. Input parameter. |
* @param offset The value offset in the actual parameter. If not set, the next parameter is parsed instead. Input parameter. |
* @returns EOK on success. |
* @returns EINVAL if the parameter is missing. |
*/ |
int parse_parameter_string( int argc, char ** argv, int * index, char ** value, const char * name, int offset ); |
|
/** Parses the next named parameter as an integral number. |
* Uses the offseted actual parameter if the offset is set or the next one if not. |
* Translates the parameter using the parse_value function. |
* @param argc The total number of the parameters. Input parameter. |
* @param argv The parameters. Input parameter. |
* @param index The actual parameter index. Input/output parameter. |
* @param value The parsed parameter value. Output parameter. |
* @param name The parameter name to be printed on errors. Input parameter. |
* @param offset The value offset in the actual parameter. If not set, the next parameter is parsed instead. Input parameter. |
* @param parse_value The translation function to parse the named value. |
* @returns EOK on success. |
* @returns EINVAL if the parameter is missing. |
* @returns ENOENT if the parameter name has not been found. |
*/ |
int parse_parameter_name_int( int argc, char ** argv, int * index, int * value, const char * name, int offset, int ( * parse_value )( const char * value )); |
|
/** Translates the character string to the protocol family number. |
* @param The protocol family name. Input parameter. |
* @returns The corresponding protocol family number. |
*/ |
int parse_protocol_family( const char * name ); |
|
/** Translates the character string to the socket type number. |
* @param The socket type name. Input parameter. |
* @returns The corresponding socket type number. |
*/ |
int parse_socket_type( const char * name ); |
|
void print_help( void ){ |
printf( |
"Network Echo aplication\n" \ |
"Usage: echo [options]\n" \ |
"Where options are:\n" \ |
"-p port_number | --port=port_number\n" \ |
"\tThe port number the application should listen at. The default is 7.\n" \ |
"\n" \ |
"-s receive_size | --size=receive_size\n" \ |
"\tThe maximum receive data size the application should accept. The default is 1024 bytes.\n" \ |
"\n" \ |
"-c count | --count\n" \ |
"\tThe number of received messages to handle. A negative number means infinity. The default is infinity.\n" \ |
"\n" \ |
"-r reply_string | --reply=reply_string\n" \ |
"\tThe constant reply string. The default is the original data received.\n" \ |
"\n" \ |
"-f protocol_family | --family=protocol_family\n" \ |
"\tThe listenning socket protocol family. Only the PF_INET is supported.\n" |
"\n" \ |
"-h | --help\n" \ |
"\tShow this application help.\n" |
"\n" \ |
"-t socket_type | --type=socket_type\n" \ |
"\tThe listenning socket type. Only the SOCK_DGRAM is supported.\n" \ |
"\n" \ |
"-v | --verbose\n" \ |
"\tShow all output messages.\n" |
); |
} |
|
int parse_parameter_int( int argc, char ** argv, int * index, int * value, const char * name, int offset ){ |
char * rest; |
|
if( offset ){ |
* value = strtol( argv[ * index ] + offset, & rest, 10 ); |
}else if(( * index ) + 1 < argc ){ |
++ ( * index ); |
* value = strtol( argv[ * index ], & rest, 10 ); |
}else{ |
fprintf( stderr, "Command line error: missing %s\n", name ); |
return EINVAL; |
} |
if( rest && ( * rest )){ |
fprintf( stderr, "Command line error: %s unrecognized (%d: %s)\n", name, * index, argv[ * index ] ); |
return EINVAL; |
} |
return EOK; |
} |
|
int parse_parameter_string( int argc, char ** argv, int * index, char ** value, const char * name, int offset ){ |
if( offset ){ |
* value = argv[ * index ] + offset; |
}else if(( * index ) + 1 < argc ){ |
++ ( * index ); |
* value = argv[ * index ]; |
}else{ |
fprintf( stderr, "Command line error: missing %s\n", name ); |
return EINVAL; |
} |
return EOK; |
} |
|
int parse_parameter_name_int( int argc, char ** argv, int * index, int * value, const char * name, int offset, int ( * parse_value )( const char * value )){ |
ERROR_DECLARE; |
|
char * parameter; |
|
ERROR_PROPAGATE( parse_parameter_string( argc, argv, index, & parameter, name, offset )); |
* value = ( * parse_value )( parameter ); |
if(( * value ) == ENOENT ){ |
fprintf( stderr, "Command line error: unrecognized %s value (%d: %s)\n", name, * index, parameter ); |
return ENOENT; |
} |
return EOK; |
} |
|
int parse_protocol_family( const char * name ){ |
if( str_lcmp( name, "PF_INET", 7 ) == 0 ){ |
return PF_INET; |
} |
return ENOENT; |
} |
|
int parse_socket_type( const char * name ){ |
if( str_lcmp( name, "SOCK_DGRAM", 11 ) == 0 ){ |
return SOCK_DGRAM; |
} |
return ENOENT; |
} |
|
void print_unrecognized( int index, const char * parameter ){ |
fprintf( stderr, "Command line error - unrecognized parameter (%d: %s)\n", index, parameter ); |
print_help(); |
} |
|
int main( int argc, char * argv[] ){ |
ERROR_DECLARE; |
|
int size = 1024; |
int verbose = 0; |
char * reply = NULL; |
sock_type_t type = SOCK_DGRAM; |
int count = -1; |
struct sockaddr_in address = { .sin_family = PF_INET, .sin_port = 7 }; |
|
int socket_id; |
int address_length; |
char address_string[ INET_ADDRSTRLEN ]; |
char * data; |
int length; |
int index; |
size_t reply_length; |
int value; |
|
printf( "Task %d - ", task_get_id()); |
printf( "%s\n", NAME ); |
|
for( index = 1; index < argc; ++ index ){ |
if( argv[ index ][ 0 ] == '-' ){ |
switch( argv[ index ][ 1 ] ){ |
case 'c': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "count", 0 )); |
break; |
case 'f': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "protocol family", 0, parse_protocol_family )); |
address.sin_family = ( uint16_t ) value; |
break; |
case 'h': print_help(); |
return EOK; |
break; |
case 'p': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 0 )); |
address.sin_port = value; |
break; |
case 'r': ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 0 )); |
break; |
case 's': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & size, "receive size", 0 )); |
break; |
case 't': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, ( int * ) & type, "socket_type", 0, parse_socket_type )); |
break; |
case 'v': verbose = 1; |
break; |
case '-': if( str_lcmp( argv[ index ] + 2, "count=", 6 ) == 0 ){ |
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "received count", 8 )) |
}else if( str_lcmp( argv[ index ] + 2, "family=", 7 ) == 0 ){ |
ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "protocol family", 9, parse_protocol_family )); |
address.sin_family = value; |
}else if( str_lcmp( argv[ index ] + 2, "help", 5 ) == 0 ){ |
print_help(); |
return EOK; |
}else if( str_lcmp( argv[ index ] + 2, "port=", 5 ) == 0 ){ |
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 7 )); |
address.sin_port = value; |
}else if( str_lcmp( argv[ index ] + 2, "reply=", 6 ) == 0 ){ |
ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 8 )); |
}else if( str_lcmp( argv[ index ] + 2, "size=", 5 ) == 0 ){ |
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & size, "receive size", 7 )); |
}else if( str_lcmp( argv[ index ] + 2, "type=", 5 ) == 0 ){ |
ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, ( int * ) & type, "socket_type", 7, parse_socket_type )); |
}else if( str_lcmp( argv[ index ] + 2, "verbose", 8 ) == 0 ){ |
verbose = 1; |
}else{ |
print_unrecognized( index, argv[ index ] + 2 ); |
return EINVAL; |
} |
break; |
default: |
print_unrecognized( index, argv[ index ] + 1 ); |
return EINVAL; |
} |
}else{ |
print_unrecognized( index, argv[ index ] ); |
return EINVAL; |
} |
} |
|
if( size <= 0 ){ |
fprintf( stderr, "Receive size too small (%d). Using 1024 bytes instead.\n", size ); |
size = 1024; |
} |
data = ( char * ) malloc( size + 1 ); |
if( ! data ){ |
fprintf( stderr, "Failed to allocate receive buffer.\n" ); |
return ENOMEM; |
} |
|
reply_length = reply ? str_length( reply ) : 0; |
|
socket_id = socket( address.sin_family, type, 0 ); |
if( socket_id < 0 ){ |
fprintf( stderr, "Socket create error %d\n", socket_id ); |
return socket_id; |
} |
if( ERROR_OCCURRED( bind( socket_id, ( struct sockaddr * ) & address, sizeof( address )))){ |
fprintf( stderr, "Socket bind error %d\n", ERROR_CODE ); |
return ERROR_CODE; |
} |
|
if( verbose ) printf( "Listenning at %d\n", address.sin_port ); |
|
while( count ){ |
address_length = sizeof( address ); |
length = recvfrom( socket_id, data, size, 0, ( struct sockaddr * ) & address, & address_length ); |
if( length < 0 ){ |
fprintf( stderr, "Socket receive error %d\n", length ); |
}else{ |
if( verbose ){ |
if( ERROR_OCCURRED( inet_ntop( address.sin_family, ( uint8_t * ) & address.sin_addr.s_addr, address_string, sizeof( address_string )))){ |
fprintf( stderr, "Received address error %d\n", ERROR_CODE ); |
continue; |
}else{ |
data[ length ] = '\0'; |
printf( "Received from %s:%d\n%s\n", address_string, address.sin_port, data ); |
} |
} |
if( ERROR_OCCURRED( sendto( socket_id, reply ? reply : data, reply ? reply_length : ( size_t ) length, 0, ( struct sockaddr * ) & address, sizeof( address )))){ |
fprintf( stderr, "Socket send error %d\n", ERROR_CODE ); |
} |
} |
if( count > 0 ) -- count; |
} |
|
if( verbose ) printf( "Closing the socket\n" ); |
|
if( ERROR_OCCURRED( closesocket( socket_id ))){ |
fprintf( stderr, "Close socket error %d\n", ERROR_CODE ); |
return ERROR_CODE; |
} |
|
if( verbose ) printf( "Exiting\n" ); |
|
return EOK; |
} |
|
/** @} |
*/ |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |