Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4719 → Rev 4720

/branches/network/uspace/srv/net/app/echo/echo.c
41,6 → 41,7
#include <task.h>
 
#include "../../include/in.h"
#include "../../include/in6.h"
#include "../../include/inet.h"
#include "../../include/socket.h"
 
47,6 → 48,7
#include "../../err.h"
 
#include "../parse.h"
#include "../print_error.h"
 
/** Echo module name.
*/
67,14 → 69,16
/** Translates the character string to the protocol family number.
* @param name The protocol family name. Input parameter.
* @returns The corresponding protocol family number.
* @returns EPFNOSUPPORTED if the protocol family is not supported.
*/
int parse_protocol_family( const char * name );
int parse_protocol_family( const char * name );
 
/** Translates the character string to the socket type number.
* @param name The socket type name. Input parameter.
* @returns The corresponding socket type number.
* @returns ESOCKNOSUPPORTED if the socket type is not supported.
*/
int parse_socket_type( const char * name );
int parse_socket_type( const char * name );
 
void print_help( void ){
printf(
85,7 → 89,7
"\tThe number of received messages to handle. A negative number means infinity. The default is infinity.\n" \
"\n" \
"-f protocol_family | --family=protocol_family\n" \
"\tThe listenning socket protocol family. Only the PF_INET is supported.\n"
"\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
"\n" \
"-h | --help\n" \
"\tShow this application help.\n"
110,8 → 114,10
int parse_protocol_family( const char * name ){
if( str_lcmp( name, "PF_INET", 7 ) == 0 ){
return PF_INET;
}else if( str_lcmp( name, "PF_INET6", 8 ) == 0 ){
return PF_INET6;
}
return ENOENT;
return EPFNOSUPPORT;
}
 
int parse_socket_type( const char * name ){
118,7 → 124,7
if( str_lcmp( name, "SOCK_DGRAM", 11 ) == 0 ){
return SOCK_DGRAM;
}
return ENOENT;
return ESOCKTNOSUPPORT;
}
 
int main( int argc, char * argv[] ){
129,12 → 135,18
char * reply = NULL;
sock_type_t type = SOCK_DGRAM;
int count = -1;
struct sockaddr_in address = { .sin_family = AF_INET, .sin_port = 7 };
int family = PF_INET;
uint16_t port = 7;
 
socklen_t max_length = sizeof( struct sockaddr_in6 );
uint8_t address_data[ max_length ];
struct sockaddr * address = ( struct sockaddr * ) address_data;
struct sockaddr_in * address_in = ( struct sockaddr_in * ) address;
struct sockaddr_in6 * address_in6 = ( struct sockaddr_in6 * ) address;
socklen_t addrlen;
char address_string[ INET6_ADDRSTRLEN ];
uint8_t * address_start;
int socket_id;
int address_length;
char address_string[ INET_ADDRSTRLEN ];
char * data;
size_t length;
int index;
149,21 → 161,13
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 ));
family = value;
switch( family ){
case PF_INET:
address.sin_family = AF_INET;
break;
default:
return ENOENT;
}
case 'f': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 0, parse_protocol_family ));
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 = ( uint16_t ) value;
port = ( uint16_t ) value;
break;
case 'r': ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 0 ));
break;
178,22 → 182,13
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 ));
family = value;
switch( family ){
case PF_INET:
address.sin_family = AF_INET;
break;
default:
return ENOENT;
}
break;
ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 9, parse_protocol_family ));
}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 = ( uint16_t ) value;
port = ( uint16_t ) 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 ){
239,31 → 234,62
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 );
 
bzero( address_data, max_length );
switch( family ){
case PF_INET:
address_in->sin_family = AF_INET;
address_in->sin_port = port;
addrlen = sizeof( struct sockaddr_in );
break;
case PF_INET6:
address_in6->sin6_family = AF_INET6;
address_in6->sin6_port = port;
addrlen = sizeof( struct sockaddr_in6 );
break;
default:
fprintf( stderr, "Protocol family is not supported\n" );
return EAFNOSUPPORT;
}
if( ERROR_OCCURRED( bind( socket_id, address, addrlen ))){
socket_print_error( stderr, ERROR_CODE, "Socket bind: ", "\n" );
return ERROR_CODE;
}
 
if( verbose ) printf( "Listenning at %d\n", address.sin_port );
if( verbose ) printf( "Listenning at %d\n", port );
 
while( count ){
address_length = sizeof( address );
value = recvfrom( socket_id, data, size, 0, ( struct sockaddr * ) & address, & address_length );
addrlen = max_length;
value = recvfrom( socket_id, data, size, 0, address, & addrlen );
if( value < 0 ){
fprintf( stderr, "Socket receive error %d\n", value );
socket_print_error( stderr, value, "Socket receive: ", "\n" );
}else{
length = ( size_t ) value;
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 );
address_start = NULL;
switch( address->sa_family ){
case AF_INET:
port = address_in->sin_port;
address_start = ( uint8_t * ) & address_in->sin_addr.s_addr;
break;
case AF_INET6:
port = address_in6->sin6_port;
address_start = ( uint8_t * ) & address_in6->sin6_addr.s6_addr;
break;
default:
fprintf( stderr, "Address family %d (0x%X) is not supported.\n", address->sa_family );
}
if( address_start ){
if( ERROR_OCCURRED( inet_ntop( address->sa_family, address_start, address_string, sizeof( address_string )))){
fprintf( stderr, "Received address error %d\n", ERROR_CODE );
}else{
data[ length ] = '\0';
printf( "Received from %s:%d\n%s\n", address_string, port, data );
}
}
}
if( ERROR_OCCURRED( sendto( socket_id, reply ? reply : data, reply ? reply_length : length, 0, ( struct sockaddr * ) & address, sizeof( address )))){
fprintf( stderr, "Socket send error %d\n", ERROR_CODE );
if( ERROR_OCCURRED( sendto( socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen ))){
socket_print_error( stderr, ERROR_CODE, "Socket send: ", "\n" );
}
}
if( count > 0 ){
275,7 → 301,7
if( verbose ) printf( "Closing the socket\n" );
 
if( ERROR_OCCURRED( closesocket( socket_id ))){
fprintf( stderr, "Close socket error %d\n", ERROR_CODE );
socket_print_error( stderr, ERROR_CODE, "Close socket: ", "\n" );
return ERROR_CODE;
}