Changeset aadf01e in mainline for uspace/srv/net/app


Ignore:
Timestamp:
2010-03-07T15:13:28Z (16 years ago)
Author:
Lukas Mejdrech <lukasmejdrech@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
936835e
Parents:
aa85487
Message:

Coding style (no functional change)

Location:
uspace/srv/net/app
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/app/echo/echo.c

    raa85487 raadf01e  
    6161 *  @returns EOK on success.
    6262 */
    63 int             main( int argc, char * argv[] );
     63int main(int argc, char * argv[]);
    6464
    6565/** Prints the application help.
    6666 */
    67 void    echo_print_help( void );
     67void echo_print_help(void);
    6868
    6969/** Translates the character string to the protocol family number.
    … …  
    7272 *  @returns EPFNOSUPPORTED if the protocol family is not supported.
    7373 */
    74 int             echo_parse_protocol_family( const char * name );
     74int echo_parse_protocol_family(const char * name);
    7575
    7676/** Translates the character string to the socket type number.
    … …  
    7979 *  @returns ESOCKNOSUPPORTED if the socket type is not supported.
    8080 */
    81 int             echo_parse_socket_type( const char * name );
    82 
    83 void echo_print_help( void ){
     81int echo_parse_socket_type(const char * name);
     82
     83void echo_print_help(void){
    8484        printf(
    8585                "Network Echo aplication\n" \
    … …  
    115115}
    116116
    117 int echo_parse_protocol_family( const char * name ){
    118         if( str_lcmp( name, "PF_INET", 7 ) == 0 ){
     117int echo_parse_protocol_family(const char * name){
     118        if(str_lcmp(name, "PF_INET", 7) == 0){
    119119                return PF_INET;
    120         }else if( str_lcmp( name, "PF_INET6", 8 ) == 0 ){
     120        }else if(str_lcmp(name, "PF_INET6", 8) == 0){
    121121                return PF_INET6;
    122122        }
    … …  
    124124}
    125125
    126 int echo_parse_socket_type( const char * name ){
    127         if( str_lcmp( name, "SOCK_DGRAM", 11 ) == 0 ){
     126int echo_parse_socket_type(const char * name){
     127        if(str_lcmp(name, "SOCK_DGRAM", 11) == 0){
    128128                return SOCK_DGRAM;
    129         }else if( str_lcmp( name, "SOCK_STREAM", 12 ) == 0 ){
     129        }else if(str_lcmp(name, "SOCK_STREAM", 12) == 0){
    130130                return SOCK_STREAM;
    131131        }
    … …  
    133133}
    134134
    135 int main( int argc, char * argv[] ){
     135int main(int argc, char * argv[]){
    136136        ERROR_DECLARE;
    137137
    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;
     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;
    157157        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;
     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;
    219229                                default:
    220                                         print_unrecognized( index, argv[ index ] + 1 );
     230                                        print_unrecognized(index, argv[index] + 1);
    221231                                        echo_print_help();
    222232                                        return EINVAL;
    223233                        }
    224234                }else{
    225                         print_unrecognized( index, argv[ index ] );
     235                        print_unrecognized(index, argv[index]);
    226236                        echo_print_help();
    227237                        return EINVAL;
    … …  
    229239        }
    230240
    231         if( size <= 0 ){
    232                 fprintf( stderr, "Receive size too small (%d). Using 1024 bytes instead.\n", size );
     241        if(size <= 0){
     242                fprintf(stderr, "Receive size too small (%d). Using 1024 bytes instead.\n", size);
    233243                size = 1024;
    234244        }
    235245        // size plus terminating null (\0)
    236         data = ( char * ) malloc( size + 1 );
    237         if( ! data ){
    238                 fprintf( stderr, "Failed to allocate receive buffer.\n" );
     246        data = (char *) malloc(size + 1);
     247        if(! data){
     248                fprintf(stderr, "Failed to allocate receive buffer.\n");
    239249                return ENOMEM;
    240250        }
    241251
    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" );
     252        reply_length = reply ? str_length(reply) : 0;
     253
     254        listening_id = socket(family, type, 0);
     255        if(listening_id < 0){
     256                socket_print_error(stderr, listening_id, "Socket create: ", "\n");
    247257                return listening_id;
    248258        }
    249259
    250         bzero( address_data, max_length );
    251         switch( family ){
     260        bzero(address_data, max_length);
     261        switch(family){
    252262                case PF_INET:
    253263                        address_in->sin_family = AF_INET;
    254                         address_in->sin_port = htons( port );
    255                         addrlen = sizeof( struct sockaddr_in );
     264                        address_in->sin_port = htons(port);
     265                        addrlen = sizeof(struct sockaddr_in);
    256266                        break;
    257267                case PF_INET6:
    258268                        address_in6->sin6_family = AF_INET6;
    259                         address_in6->sin6_port = htons( port );
    260                         addrlen = sizeof( struct sockaddr_in6 );
     269                        address_in6->sin6_port = htons(port);
     270                        addrlen = sizeof(struct sockaddr_in6);
    261271                        break;
    262272                default:
    263                         fprintf( stderr, "Protocol family is not supported\n" );
     273                        fprintf(stderr, "Protocol family is not supported\n");
    264274                        return EAFNOSUPPORT;
    265275        }
    266276
    267         listening_id = socket( family, type, 0 );
    268         if( listening_id < 0 ){
    269                 socket_print_error( stderr, listening_id, "Socket create: ", "\n" );
     277        listening_id = socket(family, type, 0);
     278        if(listening_id < 0){
     279                socket_print_error(stderr, listening_id, "Socket create: ", "\n");
    270280                return listening_id;
    271281        }
    272282
    273         if( type == SOCK_STREAM ){
    274                 if( backlog <= 0 ){
    275                         fprintf( stderr, "Accepted sockets queue size too small (%d). Using 3 instead.\n", size );
     283        if(type == SOCK_STREAM){
     284                if(backlog <= 0){
     285                        fprintf(stderr, "Accepted sockets queue size too small (%d). Using 3 instead.\n", size);
    276286                        backlog = 3;
    277287                }
    278                 if( ERROR_OCCURRED( listen( listening_id, backlog ))){
    279                         socket_print_error( stderr, ERROR_CODE, "Socket listen: ", "\n" );
     288                if(ERROR_OCCURRED(listen(listening_id, backlog))){
     289                        socket_print_error(stderr, ERROR_CODE, "Socket listen: ", "\n");
    280290                        return ERROR_CODE;
    281291                }
    282292        }
    283293
    284         if( ERROR_OCCURRED( bind( listening_id, address, addrlen ))){
    285                 socket_print_error( stderr, ERROR_CODE, "Socket bind: ", "\n" );
     294        if(ERROR_OCCURRED(bind(listening_id, address, addrlen))){
     295                socket_print_error(stderr, ERROR_CODE, "Socket bind: ", "\n");
    286296                return ERROR_CODE;
    287297        }
    288298
    289         if( verbose ) printf( "Socket %d listenning at %d\n", listening_id, port );
     299        if(verbose){
     300                printf("Socket %d listenning at %d\n", listening_id, port);
     301        }
    290302
    291303        socket_id = listening_id;
    292304
    293         while( count ){
     305        while(count){
    294306                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" );
     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");
    299311                        }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" );
     312                                if(verbose){
     313                                        printf("Socket %d accepted\n", socket_id);
     314                                }
     315                        }
     316                }
     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");
    307321                        }else{
    308                                 length = ( size_t ) value;
    309                                 if( verbose ){
     322                                length = (size_t) value;
     323                                if(verbose){
    310324                                        address_start = NULL;
    311                                         switch( address->sa_family ){
     325                                        switch(address->sa_family){
    312326                                                case AF_INET:
    313                                                         port = ntohs( address_in->sin_port );
    314                                                         address_start = ( uint8_t * ) & address_in->sin_addr.s_addr;
     327                                                        port = ntohs(address_in->sin_port);
     328                                                        address_start = (uint8_t *) &address_in->sin_addr.s_addr;
    315329                                                        break;
    316330                                                case AF_INET6:
    317                                                         port = ntohs( address_in6->sin6_port );
    318                                                         address_start = ( uint8_t * ) & address_in6->sin6_addr.s6_addr;
     331                                                        port = ntohs(address_in6->sin6_port);
     332                                                        address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
    319333                                                        break;
    320334                                                default:
    321                                                         fprintf( stderr, "Address family %d (0x%X) is not supported.\n", address->sa_family );
     335                                                        fprintf(stderr, "Address family %d (0x%X) is not supported.\n", address->sa_family);
    322336                                        }
    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 );
     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);
    326340                                                }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 );
     341                                                        data[length] = '\0';
     342                                                        printf("Socket %d received %d bytes from %s:%d\n%s\n", socket_id, length, address_string, port, data);
    329343                                                }
    330344                                        }
    331345                                }
    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" );
     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");
    334348                                }
    335349                        }
    336                         if( type == SOCK_STREAM ){
    337                                 if( ERROR_OCCURRED( closesocket( socket_id ))){
    338                                         socket_print_error( stderr, ERROR_CODE, "Close socket: ", "\n" );
     350                        if(type == SOCK_STREAM){
     351                                if(ERROR_OCCURRED(closesocket(socket_id))){
     352                                        socket_print_error(stderr, ERROR_CODE, "Close socket: ", "\n");
    339353                                }
    340354                        }
    341355                }
    342                 if( count > 0 ){
     356                if(count > 0){
    343357                        -- 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" );
     358                        if(verbose){
     359                                printf("Waiting for next %d packet(s)\n", count);
     360                        }
     361                }
     362        }
     363
     364        if(verbose){
     365                printf("Closing the socket\n");
     366        }
     367
     368        if(ERROR_OCCURRED(closesocket(listening_id))){
     369                socket_print_error(stderr, ERROR_CODE, "Close socket: ", "\n");
    352370                return ERROR_CODE;
    353371        }
    354372
    355         if( verbose ) printf( "Exiting\n" );
     373        if(verbose){
     374                printf("Exiting\n");
     375        }
    356376
    357377        return EOK;

  • uspace/srv/net/app/nettest1/nettest1.c

    raa85487 raadf01e  
    6565 *  @returns EOK on success.
    6666 */
    67 int             main( int argc, char * argv[] );
     67int main(int argc, char * argv[]);
    6868
    6969/** Prints the application help.
    7070 */
    71 void    print_help( void );
     71void print_help(void);
    7272
    7373/** Translates the character string to the protocol family number.
    … …  
    7676 *  @returns EPFNOSUPPORTED if the protocol family is not supported.
    7777 */
    78 int             parse_protocol_family( const char * name );
     78int parse_protocol_family(const char * name);
    7979
    8080/** Translates the character string to the socket type number.
    … …  
    8383 *  @returns ESOCKNOSUPPORTED if the socket type is not supported.
    8484 */
    85 int             parse_socket_type( const char * name );
     85int parse_socket_type(const char * name);
    8686
    8787/** Refreshes the data.
    … …  
    9090 *  @param[in] size The data block size in bytes.
    9191 */
    92 void    refresh_data( char * data, size_t size );
     92void refresh_data(char * data, size_t size);
    9393
    9494/** Creates new sockets.
    … …  
    101101 *  @returns Other error codes as defined for the socket() function.
    102102 */
    103 int     sockets_create( int verbose, int * socket_ids, int sockets, int family, sock_type_t type );
     103int sockets_create(int verbose, int * socket_ids, int sockets, int family, sock_type_t type);
    104104
    105105/** Closes sockets.
    … …  
    110110 *  @returns Other error codes as defined for the closesocket() function.
    111111 */
    112 int     sockets_close( int verbose, int * socket_ids, int sockets );
     112int sockets_close(int verbose, int * socket_ids, int sockets);
    113113
    114114/** Connects sockets.
    … …  
    121121 *  @returns Other error codes as defined for the connect() function.
    122122 */
    123 int     sockets_connect( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen );
     123int sockets_connect(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen);
    124124
    125125/** Sends data via sockets.
    … …  
    135135 *  @returns Other error codes as defined for the sendto() function.
    136136 */
    137 int     sockets_sendto( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages );
     137int sockets_sendto(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages);
    138138
    139139/** Receives data via sockets.
    … …  
    149149 *  @returns Other error codes as defined for the recvfrom() function.
    150150 */
    151 int     sockets_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages );
     151int sockets_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages);
    152152
    153153/** Sends and receives data via sockets.
    … …  
    165165 *  @returns Other error codes as defined for the recvfrom() function.
    166166 */
    167 int     sockets_sendto_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages );
     167int sockets_sendto_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages);
    168168
    169169/** Prints a mark.
    … …  
    171171 *  @param[in] index The index of the mark to be printed.
    172172 */
    173 void    print_mark( int index );
    174 
    175 void print_help( void ){
     173void print_mark(int index);
     174
     175void print_help(void){
    176176        printf(
    177177                "Network Networking test 1 aplication - sockets\n" \
    … …  
    201201}
    202202
    203 int parse_protocol_family( const char * name ){
    204         if( str_lcmp( name, "PF_INET", 7 ) == 0 ){
     203int parse_protocol_family(const char * name){
     204        if(str_lcmp(name, "PF_INET", 7) == 0){
    205205                return PF_INET;
    206         }else if( str_lcmp( name, "PF_INET6", 8 ) == 0 ){
     206        }else if(str_lcmp(name, "PF_INET6", 8) == 0){
    207207                return PF_INET6;
    208208        }
    … …  
    210210}
    211211
    212 int parse_socket_type( const char * name ){
    213         if( str_lcmp( name, "SOCK_DGRAM", 11 ) == 0 ){
     212int parse_socket_type(const char * name){
     213        if(str_lcmp(name, "SOCK_DGRAM", 11) == 0){
    214214                return SOCK_DGRAM;
    215         }else if( str_lcmp( name, "SOCK_STREAM", 12 ) == 0 ){
     215        }else if(str_lcmp(name, "SOCK_STREAM", 12) == 0){
    216216                return SOCK_STREAM;
    217217        }
    … …  
    219219}
    220220
    221 void refresh_data( char * data, size_t size ){
    222         size_t  length;
     221void refresh_data(char * data, size_t size){
     222        size_t length;
    223223
    224224        // fill the data
    225225        length = 0;
    226         while( size > length + sizeof( NETTEST1_TEXT ) - 1 ){
    227                 memcpy( data + length, NETTEST1_TEXT, sizeof( NETTEST1_TEXT ) - 1 );
    228                 length += sizeof( NETTEST1_TEXT ) - 1;
    229         }
    230         memcpy( data + length, NETTEST1_TEXT, size - length );
    231         data[ size ] = '\0';
    232 }
    233 
    234 int sockets_create( int verbose, int * socket_ids, int sockets, int family, sock_type_t type ){
    235         int     index;
    236 
    237         if( verbose ) printf( "Create\t" );
    238         fflush( stdout );
    239         for( index = 0; index < sockets; ++ index ){
    240                 socket_ids[ index ] = socket( family, type, 0 );
    241                 if( socket_ids[ index ] < 0 ){
    242                         printf( "Socket %d (%d) error:\n", index, socket_ids[ index ] );
    243                         socket_print_error( stderr, socket_ids[ index ], "Socket create: ", "\n" );
    244                         return socket_ids[ index ];
    245                 }
    246                 if( verbose ){
    247                         print_mark( index );
     226        while(size > length + sizeof(NETTEST1_TEXT) - 1){
     227                memcpy(data + length, NETTEST1_TEXT, sizeof(NETTEST1_TEXT) - 1);
     228                length += sizeof(NETTEST1_TEXT) - 1;
     229        }
     230        memcpy(data + length, NETTEST1_TEXT, size - length);
     231        data[size] = '\0';
     232}
     233
     234int sockets_create(int verbose, int * socket_ids, int sockets, int family, sock_type_t type){
     235        int index;
     236
     237        if(verbose){
     238                printf("Create\t");
     239        }
     240        fflush(stdout);
     241        for(index = 0; index < sockets; ++ index){
     242                socket_ids[index] = socket(family, type, 0);
     243                if(socket_ids[index] < 0){
     244                        printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     245                        socket_print_error(stderr, socket_ids[index], "Socket create: ", "\n");
     246                        return socket_ids[index];
     247                }
     248                if(verbose){
     249                        print_mark(index);
    248250                }
    249251        }
    … …  
    251253}
    252254
    253 int sockets_close( int verbose, int * socket_ids, int sockets ){
     255int sockets_close(int verbose, int * socket_ids, int sockets){
    254256        ERROR_DECLARE;
    255257
    256         int     index;
    257 
    258         if( verbose ) printf( "\tClose\t" );
    259         fflush( stdout );
    260         for( index = 0; index < sockets; ++ index ){
    261                 if( ERROR_OCCURRED( closesocket( socket_ids[ index ] ))){
    262                         printf( "Socket %d (%d) error:\n", index, socket_ids[ index ] );
    263                         socket_print_error( stderr, ERROR_CODE, "Socket close: ", "\n" );
     258        int index;
     259
     260        if(verbose){
     261                printf("\tClose\t");
     262        }
     263        fflush(stdout);
     264        for(index = 0; index < sockets; ++ index){
     265                if(ERROR_OCCURRED(closesocket(socket_ids[index]))){
     266                        printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     267                        socket_print_error(stderr, ERROR_CODE, "Socket close: ", "\n");
    264268                        return ERROR_CODE;
    265269                }
    266                 if( verbose ) print_mark( index );
     270                if(verbose){
     271                        print_mark(index);
     272                }
    267273        }
    268274        return EOK;
    269275}
    270276
    271 int sockets_connect( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen ){
     277int sockets_connect(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen){
    272278        ERROR_DECLARE;
    273279
    274         int     index;
    275 
    276         if( verbose ) printf( "\tConnect\t" );
    277         fflush( stdout );
    278         for( index = 0; index < sockets; ++ index ){
    279                 if( ERROR_OCCURRED( connect( socket_ids[ index ], address, addrlen ))){
    280                         socket_print_error( stderr, ERROR_CODE, "Socket connect: ", "\n" );
     280        int index;
     281
     282        if(verbose){
     283                printf("\tConnect\t");
     284        }
     285        fflush(stdout);
     286        for(index = 0; index < sockets; ++ index){
     287                if(ERROR_OCCURRED(connect(socket_ids[index], address, addrlen))){
     288                        socket_print_error(stderr, ERROR_CODE, "Socket connect: ", "\n");
    281289                        return ERROR_CODE;
    282290                }
    283                 if( verbose ) print_mark( index );
     291                if(verbose){
     292                        print_mark(index);
     293                }
    284294        }
    285295        return EOK;
    286296}
    287297
    288 int sockets_sendto( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages ){
     298int sockets_sendto(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages){
    289299        ERROR_DECLARE;
    290300
    291         int     index;
    292         int     message;
    293 
    294         if( verbose ) printf( "\tSendto\t" );
    295         fflush( stdout );
    296         for( index = 0; index < sockets; ++ index ){
    297                 for( message = 0; message < messages; ++ message ){
    298                         if( ERROR_OCCURRED( sendto( socket_ids[ index ], data, size, 0, address, addrlen ))){
    299                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    300                                 socket_print_error( stderr, ERROR_CODE, "Socket send: ", "\n" );
     301        int index;
     302        int message;
     303
     304        if(verbose){
     305                printf("\tSendto\t");
     306        }
     307        fflush(stdout);
     308        for(index = 0; index < sockets; ++ index){
     309                for(message = 0; message < messages; ++ message){
     310                        if(ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, addrlen))){
     311                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     312                                socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    301313                                return ERROR_CODE;
    302314                        }
    303315                }
    304                 if( verbose ) print_mark( index );
     316                if(verbose){
     317                        print_mark(index);
     318                }
    305319        }
    306320        return EOK;
    307321}
    308322
    309 int sockets_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages ){
    310         int     value;
    311         int     index;
    312         int     message;
    313 
    314         if( verbose ) printf( "\tRecvfrom\t" );
    315         fflush( stdout );
    316         for( index = 0; index < sockets; ++ index ){
    317                 for( message = 0; message < messages; ++ message ){
    318                         value = recvfrom( socket_ids[ index ], data, size, 0, address, addrlen );
    319                         if( value < 0 ){
    320                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    321                                 socket_print_error( stderr, value, "Socket receive: ", "\n" );
     323int sockets_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages){
     324        int value;
     325        int index;
     326        int message;
     327
     328        if(verbose){
     329                printf("\tRecvfrom\t");
     330        }
     331        fflush(stdout);
     332        for(index = 0; index < sockets; ++ index){
     333                for(message = 0; message < messages; ++ message){
     334                        value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     335                        if(value < 0){
     336                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     337                                socket_print_error(stderr, value, "Socket receive: ", "\n");
    322338                                return value;
    323339                        }
    324340                }
    325                 if( verbose ) print_mark( index );
     341                if(verbose){
     342                        print_mark(index);
     343                }
    326344        }
    327345        return EOK;
    328346}
    329347
    330 int sockets_sendto_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages ){
     348int sockets_sendto_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages){
    331349        ERROR_DECLARE;
    332350
    333         int     value;
    334         int     index;
    335         int     message;
    336 
    337         if( verbose ) printf( "\tSendto and recvfrom\t" );
    338         fflush( stdout );
    339         for( index = 0; index < sockets; ++ index ){
    340                 for( message = 0; message < messages; ++ message ){
    341                         if( ERROR_OCCURRED( sendto( socket_ids[ index ], data, size, 0, address, * addrlen ))){
    342                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    343                                 socket_print_error( stderr, ERROR_CODE, "Socket send: ", "\n" );
     351        int value;
     352        int index;
     353        int message;
     354
     355        if(verbose){
     356                printf("\tSendto and recvfrom\t");
     357        }
     358        fflush(stdout);
     359        for(index = 0; index < sockets; ++ index){
     360                for(message = 0; message < messages; ++ message){
     361                        if(ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, * addrlen))){
     362                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     363                                socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    344364                                return ERROR_CODE;
    345365                        }
    346                         value = recvfrom( socket_ids[ index ], data, size, 0, address, addrlen );
    347                         if( value < 0 ){
    348                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    349                                 socket_print_error( stderr, value, "Socket receive: ", "\n" );
     366                        value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     367                        if(value < 0){
     368                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     369                                socket_print_error(stderr, value, "Socket receive: ", "\n");
    350370                                return value;
    351371                        }
    352372                }
    353                 if( verbose ) print_mark( index );
     373                if(verbose){
     374                        print_mark(index);
     375                }
    354376        }
    355377        return EOK;
    356378}
    357379
    358 void print_mark( int index ){
    359         if(( index + 1 ) % 10 ){
    360                 printf( "*" );
     380void print_mark(int index){
     381        if((index + 1) % 10){
     382                printf("*");
    361383        }else{
    362                 printf( "|" );
    363         }
    364         fflush( stdout );
    365 }
    366 
    367 int main( int argc, char * argv[] ){
     384                printf("|");
     385        }
     386        fflush(stdout);
     387}
     388
     389int main(int argc, char * argv[]){
    368390        ERROR_DECLARE;
    369391
    370         size_t                          size                    = 27;
    371         int                                     verbose                 = 0;
    372         sock_type_t                     type                    = SOCK_DGRAM;
    373         int                                     sockets                 = 10;
    374         int                                     messages                = 10;
    375         int                                     family                  = PF_INET;
    376         uint16_t                        port                    = 7;
    377 
    378         socklen_t                       max_length              = sizeof( struct sockaddr_in6 );
    379         uint8_t                         address_data[ max_length ];
    380         struct sockaddr *               address         = ( struct sockaddr * ) address_data;
    381         struct sockaddr_in *    address_in              = ( struct sockaddr_in * ) address;
    382         struct sockaddr_in6 *   address_in6     = ( struct sockaddr_in6 * ) address;
    383         socklen_t                       addrlen;
    384 //      char                            address_string[ INET6_ADDRSTRLEN ];
    385         uint8_t *                       address_start;
    386 
    387         int *                           socket_ids;
     392        size_t size                     = 27;
     393        int verbose                     = 0;
     394        sock_type_t type                        = SOCK_DGRAM;
     395        int sockets                     = 10;
     396        int messages            = 10;
     397        int family                      = PF_INET;
     398        uint16_t port                   = 7;
     399
     400        socklen_t max_length            = sizeof(struct sockaddr_in6);
     401        uint8_t address_data[max_length];
     402        struct sockaddr * address               = (struct sockaddr *) address_data;
     403        struct sockaddr_in * address_in         = (struct sockaddr_in *) address;
     404        struct sockaddr_in6 * address_in6       = (struct sockaddr_in6 *) address;
     405        socklen_t addrlen;
     406//      char                            address_string[INET6_ADDRSTRLEN];
     407        uint8_t * address_start;
     408
     409        int * socket_ids;
    388410        char *                          data;
    389         int                                     value;
    390         int                                     index;
    391         struct timeval          time_before;
    392         struct timeval          time_after;
    393 
    394         printf( "Task %d - ", task_get_id());
    395         printf( "%s\n", NAME );
    396 
    397         if( argc <= 1 ){
     411        int value;
     412        int index;
     413        struct timeval time_before;
     414        struct timeval time_after;
     415
     416        printf("Task %d - ", task_get_id());
     417        printf("%s\n", NAME);
     418
     419        if(argc <= 1){
    398420                print_help();
    399421                return EINVAL;
    400422        }
    401423
    402         for( index = 1; ( index < argc - 1 ) || (( index == argc ) && ( argv[ index ][ 0 ] == '-' )); ++ index ){
    403                 if( argv[ index ][ 0 ] == '-' ){
    404                         switch( argv[ index ][ 1 ] ){
    405                                 case 'f':       ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 0, parse_protocol_family ));
    406                                                         break;
    407                                 case 'h':       print_help();
    408                                                         return EOK;
    409                                                         break;
    410                                 case 'm':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & messages, "message count", 0 ));
    411                                                         break;
    412                                 case 'n':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & sockets, "socket count", 0 ));
    413                                                         break;
    414                                 case 'p':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 0 ));
    415                                                         port = ( uint16_t ) value;
    416                                                         break;
    417                                 case 's':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "packet size", 0 ));
    418                                                         size = (value >= 0 ) ? ( size_t ) value : 0;
    419                                                         break;
    420                                 case 't':       ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket type", 0, parse_socket_type ));
    421                                                         type = ( sock_type_t ) value;
    422                                                         break;
    423                                 case 'v':       verbose = 1;
    424                                                         break;
    425                                 case '-':       if( str_lcmp( argv[ index ] + 2, "family=", 7 ) == 0 ){
    426                                                                 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 9, parse_protocol_family ));
    427                                                         }else if( str_lcmp( argv[ index ] + 2, "help", 5 ) == 0 ){
    428                                                                 print_help();
    429                                                                 return EOK;
    430                                                         }else if( str_lcmp( argv[ index ] + 2, "messages=", 6 ) == 0 ){
    431                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & messages, "message count", 8 ));
    432                                                         }else if( str_lcmp( argv[ index ] + 2, "sockets=", 6 ) == 0 ){
    433                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & sockets, "socket count", 8 ));
    434                                                         }else if( str_lcmp( argv[ index ] + 2, "port=", 5 ) == 0 ){
    435                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 7 ));
    436                                                                 port = ( uint16_t ) value;
    437                                                         }else if( str_lcmp( argv[ index ] + 2, "type=", 5 ) == 0 ){
    438                                                                 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket type", 7, parse_socket_type ));
    439                                                                 type = ( sock_type_t ) value;
    440                                                         }else if( str_lcmp( argv[ index ] + 2, "verbose", 8 ) == 0 ){
    441                                                                 verbose = 1;
    442                                                         }else{
    443                                                                 print_unrecognized( index, argv[ index ] + 2 );
    444                                                                 print_help();
    445                                                                 return EINVAL;
    446                                                         }
    447                                                         break;
     424        for(index = 1; (index < argc - 1) || ((index == argc) && (argv[index][0] == '-')); ++ index){
     425                if(argv[index][0] == '-'){
     426                        switch(argv[index][1]){
     427                                case 'f':
     428                                        ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "protocol family", 0, parse_protocol_family));
     429                                        break;
     430                                case 'h':
     431                                        print_help();
     432                                        return EOK;
     433                                        break;
     434                                case 'm':
     435                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &messages, "message count", 0));
     436                                        break;
     437                                case 'n':
     438                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &sockets, "socket count", 0));
     439                                        break;
     440                                case 'p':
     441                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "port number", 0));
     442                                        port = (uint16_t) value;
     443                                        break;
     444                                case 's':
     445                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "packet size", 0));
     446                                        size = (value >= 0) ? (size_t) value : 0;
     447                                        break;
     448                                case 't':
     449                                        ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &value, "socket type", 0, parse_socket_type));
     450                                        type = (sock_type_t) value;
     451                                        break;
     452                                case 'v':
     453                                        verbose = 1;
     454                                        break;
     455                                case '-':
     456                                        if(str_lcmp(argv[index] + 2, "family=", 7) == 0){
     457                                                ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "protocol family", 9, parse_protocol_family));
     458                                        }else if(str_lcmp(argv[index] + 2, "help", 5) == 0){
     459                                                print_help();
     460                                                return EOK;
     461                                        }else if(str_lcmp(argv[index] + 2, "messages=", 6) == 0){
     462                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &messages, "message count", 8));
     463                                        }else if(str_lcmp(argv[index] + 2, "sockets=", 6) == 0){
     464                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &sockets, "socket count", 8));
     465                                        }else if(str_lcmp(argv[index] + 2, "port=", 5) == 0){
     466                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "port number", 7));
     467                                                port = (uint16_t) value;
     468                                        }else if(str_lcmp(argv[index] + 2, "type=", 5) == 0){
     469                                                ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &value, "socket type", 7, parse_socket_type));
     470                                                type = (sock_type_t) value;
     471                                        }else if(str_lcmp(argv[index] + 2, "verbose", 8) == 0){
     472                                                verbose = 1;
     473                                        }else{
     474                                                print_unrecognized(index, argv[index] + 2);
     475                                                print_help();
     476                                                return EINVAL;
     477                                        }
     478                                        break;
    448479                                default:
    449                                         print_unrecognized( index, argv[ index ] + 1 );
     480                                        print_unrecognized(index, argv[index] + 1);
    450481                                        print_help();
    451482                                        return EINVAL;
    452483                        }
    453484                }else{
    454                         print_unrecognized( index, argv[ index ] );
     485                        print_unrecognized(index, argv[index]);
    455486                        print_help();
    456487                        return EINVAL;
    … …  
    458489        }
    459490
    460         bzero( address_data, max_length );
    461         switch( family ){
     491        bzero(address_data, max_length);
     492        switch(family){
    462493                case PF_INET:
    463494                        address_in->sin_family = AF_INET;
    464                         address_in->sin_port = htons( port );
    465                         address_start = ( uint8_t * ) & address_in->sin_addr.s_addr;
    466                         addrlen = sizeof( struct sockaddr_in );
     495                        address_in->sin_port = htons(port);
     496                        address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     497                        addrlen = sizeof(struct sockaddr_in);
    467498                        break;
    468499                case PF_INET6:
    469500                        address_in6->sin6_family = AF_INET6;
    470                         address_in6->sin6_port = htons( port );
    471                         address_start = ( uint8_t * ) & address_in6->sin6_addr.s6_addr;
    472                         addrlen = sizeof( struct sockaddr_in6 );
     501                        address_in6->sin6_port = htons(port);
     502                        address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     503                        addrlen = sizeof(struct sockaddr_in6);
    473504                        break;
    474505                default:
    475                         fprintf( stderr, "Address family is not supported\n" );
     506                        fprintf(stderr, "Address family is not supported\n");
    476507                        return EAFNOSUPPORT;
    477508        }
    478509
    479         if( ERROR_OCCURRED( inet_pton( family, argv[ argc - 1 ], address_start ))){
    480                 fprintf( stderr, "Address parse error %d\n", ERROR_CODE );
     510        if(ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))){
     511                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
    481512                return ERROR_CODE;
    482513        }
    483514
    484         if( size <= 0 ){
    485                 fprintf( stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size );
     515        if(size <= 0){
     516                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    486517                size = 1024;
    487518        }
    488519        // size plus terminating null (\0)
    489         data = ( char * ) malloc( size + 1 );
    490         if( ! data ){
    491                 fprintf( stderr, "Failed to allocate data buffer.\n" );
     520        data = (char *) malloc(size + 1);
     521        if(! data){
     522                fprintf(stderr, "Failed to allocate data buffer.\n");
    492523                return ENOMEM;
    493524        }
    494         refresh_data( data, size );
    495 
    496         if( sockets <= 0 ){
    497                 fprintf( stderr, "Socket count too small (%d). Using 2 instead.\n", sockets );
     525        refresh_data(data, size);
     526
     527        if(sockets <= 0){
     528                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    498529                sockets = 2;
    499530        }
    500531        // count plus terminating null (\0)
    501         socket_ids = ( int * ) malloc( sizeof( int ) * ( sockets + 1 ));
    502         if( ! socket_ids ){
    503                 fprintf( stderr, "Failed to allocate receive buffer.\n" );
     532        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     533        if(! socket_ids){
     534                fprintf(stderr, "Failed to allocate receive buffer.\n");
    504535                return ENOMEM;
    505536        }
    506         socket_ids[ sockets ] = NULL;
    507 
    508         if( verbose ) printf( "Starting tests\n" );
    509 
    510         if( verbose ) printf( "1 socket, 1 message\n" );
    511 
    512         if( ERROR_OCCURRED( gettimeofday( & time_before, NULL ))){
    513                 fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     537        socket_ids[sockets] = NULL;
     538
     539        if(verbose){
     540                printf("Starting tests\n");
     541        }
     542
     543        if(verbose){
     544                printf("1 socket, 1 message\n");
     545        }
     546
     547        if(ERROR_OCCURRED(gettimeofday(&time_before, NULL))){
     548                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    514549                return ERROR_CODE;
    515550        }
    516551
    517         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, 1, family, type ));
    518         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, 1 ));
    519         if( verbose ) printf( "\tOK\n" );
    520 
    521         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, 1, family, type ));
    522         if( type == SOCK_STREAM ){
    523                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, 1, address, addrlen ));
    524         }
    525         ERROR_PROPAGATE( sockets_sendto_recvfrom( verbose, socket_ids, 1, address, & addrlen, data, size, 1 ));
    526         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, 1 ));
    527         if( verbose ) printf( "\tOK\n" );
    528 
    529         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, 1, family, type ));
    530         if( type == SOCK_STREAM ){
    531                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, 1, address, addrlen ));
    532         }
    533         ERROR_PROPAGATE( sockets_sendto( verbose, socket_ids, 1, address, addrlen, data, size, 1 ));
    534         ERROR_PROPAGATE( sockets_recvfrom( verbose, socket_ids, 1, address, & addrlen, data, size, 1 ));
    535         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, 1 ));
    536         if( verbose ) printf( "\tOK\n" );
    537 
    538         if( verbose ) printf( "1 socket, %d messages\n", messages );
    539 
    540         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, 1, family, type ));
    541         if( type == SOCK_STREAM ){
    542                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, 1, address, addrlen ));
    543         }
    544         ERROR_PROPAGATE( sockets_sendto_recvfrom( verbose, socket_ids, 1, address, & addrlen, data, size, messages ));
    545         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, 1 ));
    546         if( verbose ) printf( "\tOK\n" );
    547 
    548         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, 1, family, type ));
    549         if( type == SOCK_STREAM ){
    550                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, 1, address, addrlen ));
    551         }
    552         ERROR_PROPAGATE( sockets_sendto( verbose, socket_ids, 1, address, addrlen, data, size, messages ));
    553         ERROR_PROPAGATE( sockets_recvfrom( verbose, socket_ids, 1, address, & addrlen, data, size, messages ));
    554         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, 1 ));
    555         if( verbose ) printf( "\tOK\n" );
    556 
    557         if( verbose ) printf( "%d sockets, 1 message\n", sockets );
    558 
    559         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, sockets, family, type ));
    560         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, sockets ));
    561         if( verbose ) printf( "\tOK\n" );
    562 
    563         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, sockets, family, type ));
    564         if( type == SOCK_STREAM ){
    565                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, sockets, address, addrlen ));
    566         }
    567         ERROR_PROPAGATE( sockets_sendto_recvfrom( verbose, socket_ids, sockets, address, & addrlen, data, size, 1 ));
    568         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, sockets ));
    569         if( verbose ) printf( "\tOK\n" );
    570 
    571         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, sockets, family, type ));
    572         if( type == SOCK_STREAM ){
    573                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, sockets, address, addrlen ));
    574         }
    575         ERROR_PROPAGATE( sockets_sendto( verbose, socket_ids, sockets, address, addrlen, data, size, 1 ));
    576         ERROR_PROPAGATE( sockets_recvfrom( verbose, socket_ids, sockets, address, & addrlen, data, size, 1 ));
    577         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, sockets ));
    578         if( verbose ) printf( "\tOK\n" );
    579 
    580         if( verbose ) printf( "%d sockets, %d messages\n", sockets, messages );
    581 
    582         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, sockets, family, type ));
    583         if( type == SOCK_STREAM ){
    584                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, sockets, address, addrlen ));
    585         }
    586         ERROR_PROPAGATE( sockets_sendto_recvfrom( verbose, socket_ids, sockets, address, & addrlen, data, size, messages ));
    587         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, sockets ));
    588         if( verbose ) printf( "\tOK\n" );
    589 
    590         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, sockets, family, type ));
    591         if( type == SOCK_STREAM ){
    592                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, sockets, address, addrlen ));
    593         }
    594         ERROR_PROPAGATE( sockets_sendto( verbose, socket_ids, sockets, address, addrlen, data, size, messages ));
    595         ERROR_PROPAGATE( sockets_recvfrom( verbose, socket_ids, sockets, address, & addrlen, data, size, messages ));
    596         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, sockets ));
    597 
    598         if( ERROR_OCCURRED( gettimeofday( & time_after, NULL ))){
    599                 fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     552        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     553        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     554        if(verbose){
     555                printf("\tOK\n");
     556        }
     557
     558        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     559        if(type == SOCK_STREAM){
     560                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     561        }
     562        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, 1));
     563        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     564        if(verbose){
     565                printf("\tOK\n");
     566        }
     567
     568        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     569        if(type == SOCK_STREAM){
     570                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     571        }
     572        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, 1, address, addrlen, data, size, 1));
     573        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, 1));
     574        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     575        if(verbose){
     576                printf("\tOK\n");
     577        }
     578
     579        if(verbose){
     580                printf("1 socket, %d messages\n", messages);
     581        }
     582
     583        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     584        if(type == SOCK_STREAM){
     585                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     586        }
     587        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, messages));
     588        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     589        if(verbose){
     590                printf("\tOK\n");
     591        }
     592
     593        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     594        if(type == SOCK_STREAM){
     595                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     596        }
     597        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, 1, address, addrlen, data, size, messages));
     598        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, messages));
     599        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     600        if(verbose){
     601                printf("\tOK\n");
     602        }
     603
     604        if(verbose){
     605                printf("%d sockets, 1 message\n", sockets);
     606        }
     607
     608        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     609        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     610        if(verbose){
     611                printf("\tOK\n");
     612        }
     613
     614        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     615        if(type == SOCK_STREAM){
     616                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     617        }
     618        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, 1));
     619        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     620        if(verbose){
     621                printf("\tOK\n");
     622        }
     623
     624        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     625        if(type == SOCK_STREAM){
     626                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     627        }
     628        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, 1));
     629        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, 1));
     630        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     631        if(verbose){
     632                printf("\tOK\n");
     633        }
     634
     635        if(verbose){
     636                printf("%d sockets, %d messages\n", sockets, messages);
     637        }
     638
     639        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     640        if(type == SOCK_STREAM){
     641                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     642        }
     643        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     644        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     645        if(verbose){
     646                printf("\tOK\n");
     647        }
     648
     649        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     650        if(type == SOCK_STREAM){
     651                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     652        }
     653        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     654        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     655        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     656
     657        if(ERROR_OCCURRED(gettimeofday(&time_after, NULL))){
     658                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    600659                return ERROR_CODE;
    601660        }
    602661
    603         if( verbose ) printf( "\tOK\n" );
    604 
    605         printf( "Tested in %d microseconds\n", tv_sub( & time_after, & time_before ));
    606 
    607         if( verbose ) printf( "Exiting\n" );
     662        if(verbose){
     663                printf("\tOK\n");
     664        }
     665
     666        printf("Tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     667
     668        if(verbose){
     669                printf("Exiting\n");
     670        }
    608671
    609672        return EOK;

  • uspace/srv/net/app/nettest2/nettest2.c

    raa85487 raadf01e  
    6565 *  @returns EOK on success.
    6666 */
    67 int             main( int argc, char * argv[] );
     67int main(int argc, char * argv[]);
    6868
    6969/** Prints the application help.
    7070 */
    71 void    print_help( void );
     71void print_help(void);
    7272
    7373/** Translates the character string to the protocol family number.
    … …  
    7676 *  @returns EPFNOSUPPORTED if the protocol family is not supported.
    7777 */
    78 int             parse_protocol_family( const char * name );
     78int parse_protocol_family(const char * name);
    7979
    8080/** Translates the character string to the socket type number.
    … …  
    8383 *  @returns ESOCKNOSUPPORTED if the socket type is not supported.
    8484 */
    85 int             parse_socket_type( const char * name );
     85int parse_socket_type(const char * name);
    8686
    8787/** Refreshes the data.
    … …  
    9090 *  @param[in] size The data block size in bytes.
    9191 */
    92 void    refresh_data( char * data, size_t size );
     92void refresh_data(char * data, size_t size);
    9393
    9494/** Creates new sockets.
    … …  
    101101 *  @returns Other error codes as defined for the socket() function.
    102102 */
    103 int     sockets_create( int verbose, int * socket_ids, int sockets, int family, sock_type_t type );
     103int sockets_create(int verbose, int * socket_ids, int sockets, int family, sock_type_t type);
    104104
    105105/** Closes sockets.
    … …  
    110110 *  @returns Other error codes as defined for the closesocket() function.
    111111 */
    112 int     sockets_close( int verbose, int * socket_ids, int sockets );
     112int sockets_close(int verbose, int * socket_ids, int sockets);
    113113
    114114/** Connects sockets.
    … …  
    121121 *  @returns Other error codes as defined for the connect() function.
    122122 */
    123 int     sockets_connect( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen );
     123int sockets_connect(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen);
    124124
    125125/** Sends data via sockets.
    … …  
    135135 *  @returns Other error codes as defined for the sendto() function.
    136136 */
    137 int     sockets_sendto( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages );
     137int sockets_sendto(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages);
    138138
    139139/** Receives data via sockets.
    … …  
    149149 *  @returns Other error codes as defined for the recvfrom() function.
    150150 */
    151 int     sockets_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages );
     151int sockets_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages);
    152152
    153153/** Sends and receives data via sockets.
    … …  
    165165 *  @returns Other error codes as defined for the recvfrom() function.
    166166 */
    167 int     sockets_sendto_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages );
     167int sockets_sendto_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages);
    168168
    169169/** Prints a mark.
    … …  
    171171 *  @param[in] index The index of the mark to be printed.
    172172 */
    173 void    print_mark( int index );
    174 
    175 void print_help( void ){
     173void print_mark(int index);
     174
     175void print_help(void){
    176176        printf(
    177177                "Network Networking test 2 aplication - UDP transfer\n" \
    … …  
    201201}
    202202
    203 int parse_protocol_family( const char * name ){
    204         if( str_lcmp( name, "PF_INET", 7 ) == 0 ){
     203int parse_protocol_family(const char * name){
     204        if(str_lcmp(name, "PF_INET", 7) == 0){
    205205                return PF_INET;
    206         }else if( str_lcmp( name, "PF_INET6", 8 ) == 0 ){
     206        }else if(str_lcmp(name, "PF_INET6", 8) == 0){
    207207                return PF_INET6;
    208208        }
    … …  
    210210}
    211211
    212 int parse_socket_type( const char * name ){
    213         if( str_lcmp( name, "SOCK_DGRAM", 11 ) == 0 ){
     212int parse_socket_type(const char * name){
     213        if(str_lcmp(name, "SOCK_DGRAM", 11) == 0){
    214214                return SOCK_DGRAM;
    215         }else if( str_lcmp( name, "SOCK_STREAM", 12 ) == 0 ){
     215        }else if(str_lcmp(name, "SOCK_STREAM", 12) == 0){
    216216                return SOCK_STREAM;
    217217        }
    … …  
    219219}
    220220
    221 void refresh_data( char * data, size_t size ){
    222         size_t  length;
     221void refresh_data(char * data, size_t size){
     222        size_t length;
    223223
    224224        // fill the data
    225225        length = 0;
    226         while( size > length + sizeof( NETTEST2_TEXT ) - 1 ){
    227                 memcpy( data + length, NETTEST2_TEXT, sizeof( NETTEST2_TEXT ) - 1 );
    228                 length += sizeof( NETTEST2_TEXT ) - 1;
    229         }
    230         memcpy( data + length, NETTEST2_TEXT, size - length );
    231         data[ size ] = '\0';
    232 }
    233 
    234 int sockets_create( int verbose, int * socket_ids, int sockets, int family, sock_type_t type ){
    235         int     index;
    236 
    237         if( verbose ) printf( "Create\t" );
    238         fflush( stdout );
    239         for( index = 0; index < sockets; ++ index ){
    240                 socket_ids[ index ] = socket( family, type, 0 );
    241                 if( socket_ids[ index ] < 0 ){
    242                         printf( "Socket %d (%d) error:\n", index, socket_ids[ index ] );
    243                         socket_print_error( stderr, socket_ids[ index ], "Socket create: ", "\n" );
    244                         return socket_ids[ index ];
    245                 }
    246                 if( verbose ) print_mark( index );
     226        while(size > length + sizeof(NETTEST2_TEXT) - 1){
     227                memcpy(data + length, NETTEST2_TEXT, sizeof(NETTEST2_TEXT) - 1);
     228                length += sizeof(NETTEST2_TEXT) - 1;
     229        }
     230        memcpy(data + length, NETTEST2_TEXT, size - length);
     231        data[size] = '\0';
     232}
     233
     234int sockets_create(int verbose, int * socket_ids, int sockets, int family, sock_type_t type){
     235        int index;
     236
     237        if(verbose){
     238                printf("Create\t");
     239        }
     240        fflush(stdout);
     241        for(index = 0; index < sockets; ++ index){
     242                socket_ids[index] = socket(family, type, 0);
     243                if(socket_ids[index] < 0){
     244                        printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     245                        socket_print_error(stderr, socket_ids[index], "Socket create: ", "\n");
     246                        return socket_ids[index];
     247                }
     248                if(verbose){
     249                        print_mark(index);
     250                }
    247251        }
    248252        return EOK;
    249253}
    250254
    251 int sockets_close( int verbose, int * socket_ids, int sockets ){
     255int sockets_close(int verbose, int * socket_ids, int sockets){
    252256        ERROR_DECLARE;
    253257
    254         int     index;
    255 
    256         if( verbose ) printf( "\tClose\t" );
    257         fflush( stdout );
    258         for( index = 0; index < sockets; ++ index ){
    259                 if( ERROR_OCCURRED( closesocket( socket_ids[ index ] ))){
    260                         printf( "Socket %d (%d) error:\n", index, socket_ids[ index ] );
    261                         socket_print_error( stderr, ERROR_CODE, "Socket close: ", "\n" );
     258        int index;
     259
     260        if(verbose){
     261                printf("\tClose\t");
     262        }
     263        fflush(stdout);
     264        for(index = 0; index < sockets; ++ index){
     265                if(ERROR_OCCURRED(closesocket(socket_ids[index]))){
     266                        printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     267                        socket_print_error(stderr, ERROR_CODE, "Socket close: ", "\n");
    262268                        return ERROR_CODE;
    263269                }
    264                 if( verbose ) print_mark( index );
     270                if(verbose){
     271                        print_mark(index);
     272                }
    265273        }
    266274        return EOK;
    267275}
    268276
    269 int sockets_connect( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen ){
     277int sockets_connect(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen){
    270278        ERROR_DECLARE;
    271279
    272         int     index;
    273 
    274         if( verbose ) printf( "\tConnect\t" );
    275         fflush( stdout );
    276         for( index = 0; index < sockets; ++ index ){
    277                 if( ERROR_OCCURRED( connect( socket_ids[ index ], address, addrlen ))){
    278                         socket_print_error( stderr, ERROR_CODE, "Socket connect: ", "\n" );
     280        int index;
     281
     282        if(verbose){
     283                printf("\tConnect\t");
     284        }
     285        fflush(stdout);
     286        for(index = 0; index < sockets; ++ index){
     287                if(ERROR_OCCURRED(connect(socket_ids[index], address, addrlen))){
     288                        socket_print_error(stderr, ERROR_CODE, "Socket connect: ", "\n");
    279289                        return ERROR_CODE;
    280290                }
    281                 if( verbose ) print_mark( index );
     291                if(verbose){
     292                        print_mark(index);
     293                }
    282294        }
    283295        return EOK;
    284296}
    285297
    286 int sockets_sendto( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages ){
     298int sockets_sendto(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t addrlen, char * data, int size, int messages){
    287299        ERROR_DECLARE;
    288300
    289         int     index;
    290         int     message;
    291 
    292         if( verbose ) printf( "\tSendto\t" );
    293         fflush( stdout );
    294         for( index = 0; index < sockets; ++ index ){
    295                 for( message = 0; message < messages; ++ message ){
    296                         if( ERROR_OCCURRED( sendto( socket_ids[ index ], data, size, 0, address, addrlen ))){
    297                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    298                                 socket_print_error( stderr, ERROR_CODE, "Socket send: ", "\n" );
     301        int index;
     302        int message;
     303
     304        if(verbose){
     305                printf("\tSendto\t");
     306        }
     307        fflush(stdout);
     308        for(index = 0; index < sockets; ++ index){
     309                for(message = 0; message < messages; ++ message){
     310                        if(ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, addrlen))){
     311                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     312                                socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    299313                                return ERROR_CODE;
    300314                        }
    301315                }
    302                 if( verbose ) print_mark( index );
     316                if(verbose){
     317                        print_mark(index);
     318                }
    303319        }
    304320        return EOK;
    305321}
    306322
    307 int sockets_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages ){
    308         int     value;
    309         int     index;
    310         int     message;
    311 
    312         if( verbose ) printf( "\tRecvfrom\t" );
    313         fflush( stdout );
    314         for( index = 0; index < sockets; ++ index ){
    315                 for( message = 0; message < messages; ++ message ){
    316                         value = recvfrom( socket_ids[ index ], data, size, 0, address, addrlen );
    317                         if( value < 0 ){
    318                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    319                                 socket_print_error( stderr, value, "Socket receive: ", "\n" );
     323int sockets_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages){
     324        int value;
     325        int index;
     326        int message;
     327
     328        if(verbose){
     329                printf("\tRecvfrom\t");
     330        }
     331        fflush(stdout);
     332        for(index = 0; index < sockets; ++ index){
     333                for(message = 0; message < messages; ++ message){
     334                        value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     335                        if(value < 0){
     336                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     337                                socket_print_error(stderr, value, "Socket receive: ", "\n");
    320338                                return value;
    321339                        }
    322340                }
    323                 if( verbose ) print_mark( index );
     341                if(verbose){
     342                        print_mark(index);
     343                }
    324344        }
    325345        return EOK;
    326346}
    327347
    328 int sockets_sendto_recvfrom( int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages ){
     348int sockets_sendto_recvfrom(int verbose, int * socket_ids, int sockets, struct sockaddr * address, socklen_t * addrlen, char * data, int size, int messages){
    329349        ERROR_DECLARE;
    330350
    331         int     value;
    332         int     index;
    333         int     message;
    334 
    335         if( verbose ) printf( "\tSendto and recvfrom\t" );
    336         fflush( stdout );
    337         for( index = 0; index < sockets; ++ index ){
    338                 for( message = 0; message < messages; ++ message ){
    339                         if( ERROR_OCCURRED( sendto( socket_ids[ index ], data, size, 0, address, * addrlen ))){
    340                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    341                                 socket_print_error( stderr, ERROR_CODE, "Socket send: ", "\n" );
     351        int value;
     352        int index;
     353        int message;
     354
     355        if(verbose){
     356                printf("\tSendto and recvfrom\t");
     357        }
     358        fflush(stdout);
     359        for(index = 0; index < sockets; ++ index){
     360                for(message = 0; message < messages; ++ message){
     361                        if(ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, * addrlen))){
     362                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     363                                socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    342364                                return ERROR_CODE;
    343365                        }
    344                         value = recvfrom( socket_ids[ index ], data, size, 0, address, addrlen );
    345                         if( value < 0 ){
    346                                 printf( "Socket %d (%d), message %d error:\n", index, socket_ids[ index ], message );
    347                                 socket_print_error( stderr, value, "Socket receive: ", "\n" );
     366                        value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     367                        if(value < 0){
     368                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     369                                socket_print_error(stderr, value, "Socket receive: ", "\n");
    348370                                return value;
    349371                        }
    350372                }
    351                 if( verbose ) print_mark( index );
     373                if(verbose){
     374                        print_mark(index);
     375                }
    352376        }
    353377        return EOK;
    354378}
    355379
    356 void print_mark( int index ){
    357         if(( index + 1 ) % 10 ){
    358                 printf( "*" );
     380void print_mark(int index){
     381        if((index + 1) % 10){
     382                printf("*");
    359383        }else{
    360                 printf( "|" );
    361         }
    362         fflush( stdout );
    363 }
    364 
    365 int main( int argc, char * argv[] ){
     384                printf("|");
     385        }
     386        fflush(stdout);
     387}
     388
     389int main(int argc, char * argv[]){
    366390        ERROR_DECLARE;
    367391
    368         size_t                          size                    = 28;
    369         int                                     verbose                 = 0;
    370         sock_type_t                     type                    = SOCK_DGRAM;
    371         int                                     sockets                 = 10;
    372         int                                     messages                = 10;
    373         int                                     family                  = PF_INET;
    374         uint16_t                        port                    = 7;
    375 
    376         socklen_t                       max_length              = sizeof( struct sockaddr_in6 );
    377         uint8_t                         address_data[ max_length ];
    378         struct sockaddr *               address         = ( struct sockaddr * ) address_data;
    379         struct sockaddr_in *    address_in              = ( struct sockaddr_in * ) address;
    380         struct sockaddr_in6 *   address_in6     = ( struct sockaddr_in6 * ) address;
    381         socklen_t                       addrlen;
    382 //      char                            address_string[ INET6_ADDRSTRLEN ];
    383         uint8_t *                       address_start;
    384 
    385         int *                           socket_ids;
     392        size_t size                     = 28;
     393        int verbose                     = 0;
     394        sock_type_t type                        = SOCK_DGRAM;
     395        int sockets                     = 10;
     396        int messages            = 10;
     397        int family                      = PF_INET;
     398        uint16_t port                   = 7;
     399
     400        socklen_t max_length            = sizeof(struct sockaddr_in6);
     401        uint8_t address_data[max_length];
     402        struct sockaddr * address               = (struct sockaddr *) address_data;
     403        struct sockaddr_in * address_in         = (struct sockaddr_in *) address;
     404        struct sockaddr_in6 * address_in6       = (struct sockaddr_in6 *) address;
     405        socklen_t addrlen;
     406//      char                            address_string[INET6_ADDRSTRLEN];
     407        uint8_t * address_start;
     408
     409        int * socket_ids;
    386410        char *                          data;
    387         int                                     value;
    388         int                                     index;
    389         struct timeval          time_before;
    390         struct timeval          time_after;
    391 
    392         printf( "Task %d - ", task_get_id());
    393         printf( "%s\n", NAME );
    394 
    395         if( argc <= 1 ){
     411        int value;
     412        int index;
     413        struct timeval time_before;
     414        struct timeval time_after;
     415
     416        printf("Task %d - ", task_get_id());
     417        printf("%s\n", NAME);
     418
     419        if(argc <= 1){
    396420                print_help();
    397421                return EINVAL;
    398422        }
    399423
    400         for( index = 1; ( index < argc - 1 ) || (( index == argc ) && ( argv[ index ][ 0 ] == '-' )); ++ index ){
    401                 if( argv[ index ][ 0 ] == '-' ){
    402                         switch( argv[ index ][ 1 ] ){
    403                                 case 'f':       ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 0, parse_protocol_family ));
    404                                                         break;
    405                                 case 'h':       print_help();
    406                                                         return EOK;
    407                                                         break;
    408                                 case 'm':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & messages, "message count", 0 ));
    409                                                         break;
    410                                 case 'n':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & sockets, "socket count", 0 ));
    411                                                         break;
    412                                 case 'p':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 0 ));
    413                                                         port = ( uint16_t ) value;
    414                                                         break;
    415                                 case 's':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "packet size", 0 ));
    416                                                         size = (value >= 0 ) ? ( size_t ) value : 0;
    417                                                         break;
    418                                 case 't':       ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket type", 0, parse_socket_type ));
    419                                                         type = ( sock_type_t ) value;
    420                                                         break;
    421                                 case 'v':       verbose = 1;
    422                                                         break;
    423                                 case '-':       if( str_lcmp( argv[ index ] + 2, "family=", 7 ) == 0 ){
    424                                                                 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "protocol family", 9, parse_protocol_family ));
    425                                                         }else if( str_lcmp( argv[ index ] + 2, "help", 5 ) == 0 ){
    426                                                                 print_help();
    427                                                                 return EOK;
    428                                                         }else if( str_lcmp( argv[ index ] + 2, "messages=", 6 ) == 0 ){
    429                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & messages, "message count", 8 ));
    430                                                         }else if( str_lcmp( argv[ index ] + 2, "sockets=", 6 ) == 0 ){
    431                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & sockets, "socket count", 8 ));
    432                                                         }else if( str_lcmp( argv[ index ] + 2, "port=", 5 ) == 0 ){
    433                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 7 ));
    434                                                                 port = ( uint16_t ) value;
    435                                                         }else if( str_lcmp( argv[ index ] + 2, "type=", 5 ) == 0 ){
    436                                                                 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket type", 7, parse_socket_type ));
    437                                                                 type = ( sock_type_t ) value;
    438                                                         }else if( str_lcmp( argv[ index ] + 2, "verbose", 8 ) == 0 ){
    439                                                                 verbose = 1;
    440                                                         }else{
    441                                                                 print_unrecognized( index, argv[ index ] + 2 );
    442                                                                 print_help();
    443                                                                 return EINVAL;
    444                                                         }
    445                                                         break;
     424        for(index = 1; (index < argc - 1) || ((index == argc) && (argv[index][0] == '-')); ++ index){
     425                if(argv[index][0] == '-'){
     426                        switch(argv[index][1]){
     427                                case 'f':
     428                                        ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "protocol family", 0, parse_protocol_family));
     429                                        break;
     430                                case 'h':
     431                                        print_help();
     432                                        return EOK;
     433                                        break;
     434                                case 'm':
     435                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &messages, "message count", 0));
     436                                        break;
     437                                case 'n':
     438                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &sockets, "socket count", 0));
     439                                        break;
     440                                case 'p':
     441                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "port number", 0));
     442                                        port = (uint16_t) value;
     443                                        break;
     444                                case 's':
     445                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "packet size", 0));
     446                                        size = (value >= 0) ? (size_t) value : 0;
     447                                        break;
     448                                case 't':
     449                                        ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &value, "socket type", 0, parse_socket_type));
     450                                        type = (sock_type_t) value;
     451                                        break;
     452                                case 'v':
     453                                        verbose = 1;
     454                                        break;
     455                                case '-':
     456                                        if(str_lcmp(argv[index] + 2, "family=", 7) == 0){
     457                                                ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "protocol family", 9, parse_protocol_family));
     458                                        }else if(str_lcmp(argv[index] + 2, "help", 5) == 0){
     459                                                print_help();
     460                                                return EOK;
     461                                        }else if(str_lcmp(argv[index] + 2, "messages=", 6) == 0){
     462                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &messages, "message count", 8));
     463                                        }else if(str_lcmp(argv[index] + 2, "sockets=", 6) == 0){
     464                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &sockets, "socket count", 8));
     465                                        }else if(str_lcmp(argv[index] + 2, "port=", 5) == 0){
     466                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "port number", 7));
     467                                                port = (uint16_t) value;
     468                                        }else if(str_lcmp(argv[index] + 2, "type=", 5) == 0){
     469                                                ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &value, "socket type", 7, parse_socket_type));
     470                                                type = (sock_type_t) value;
     471                                        }else if(str_lcmp(argv[index] + 2, "verbose", 8) == 0){
     472                                                verbose = 1;
     473                                        }else{
     474                                                print_unrecognized(index, argv[index] + 2);
     475                                                print_help();
     476                                                return EINVAL;
     477                                        }
     478                                        break;
    446479                                default:
    447                                         print_unrecognized( index, argv[ index ] + 1 );
     480                                        print_unrecognized(index, argv[index] + 1);
    448481                                        print_help();
    449482                                        return EINVAL;
    450483                        }
    451484                }else{
    452                         print_unrecognized( index, argv[ index ] );
     485                        print_unrecognized(index, argv[index]);
    453486                        print_help();
    454487                        return EINVAL;
    … …  
    456489        }
    457490
    458         bzero( address_data, max_length );
    459         switch( family ){
     491        bzero(address_data, max_length);
     492        switch(family){
    460493                case PF_INET:
    461494                        address_in->sin_family = AF_INET;
    462                         address_in->sin_port = htons( port );
    463                         address_start = ( uint8_t * ) & address_in->sin_addr.s_addr;
    464                         addrlen = sizeof( struct sockaddr_in );
     495                        address_in->sin_port = htons(port);
     496                        address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     497                        addrlen = sizeof(struct sockaddr_in);
    465498                        break;
    466499                case PF_INET6:
    467500                        address_in6->sin6_family = AF_INET6;
    468                         address_in6->sin6_port = htons( port );
    469                         address_start = ( uint8_t * ) & address_in6->sin6_addr.s6_addr;
    470                         addrlen = sizeof( struct sockaddr_in6 );
     501                        address_in6->sin6_port = htons(port);
     502                        address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     503                        addrlen = sizeof(struct sockaddr_in6);
    471504                        break;
    472505                default:
    473                         fprintf( stderr, "Address family is not supported\n" );
     506                        fprintf(stderr, "Address family is not supported\n");
    474507                        return EAFNOSUPPORT;
    475508        }
    476509
    477         if( ERROR_OCCURRED( inet_pton( family, argv[ argc - 1 ], address_start ))){
    478                 fprintf( stderr, "Address parse error %d\n", ERROR_CODE );
     510        if(ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))){
     511                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
    479512                return ERROR_CODE;
    480513        }
    481514
    482         if( size <= 0 ){
    483                 fprintf( stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size );
     515        if(size <= 0){
     516                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    484517                size = 1024;
    485518        }
    486519        // size plus terminating null (\0)
    487         data = ( char * ) malloc( size + 1 );
    488         if( ! data ){
    489                 fprintf( stderr, "Failed to allocate data buffer.\n" );
     520        data = (char *) malloc(size + 1);
     521        if(! data){
     522                fprintf(stderr, "Failed to allocate data buffer.\n");
    490523                return ENOMEM;
    491524        }
    492         refresh_data( data, size );
    493 
    494         if( sockets <= 0 ){
    495                 fprintf( stderr, "Socket count too small (%d). Using 2 instead.\n", sockets );
     525        refresh_data(data, size);
     526
     527        if(sockets <= 0){
     528                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    496529                sockets = 2;
    497530        }
    498531        // count plus terminating null (\0)
    499         socket_ids = ( int * ) malloc( sizeof( int ) * ( sockets + 1 ));
    500         if( ! socket_ids ){
    501                 fprintf( stderr, "Failed to allocate receive buffer.\n" );
     532        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     533        if(! socket_ids){
     534                fprintf(stderr, "Failed to allocate receive buffer.\n");
    502535                return ENOMEM;
    503536        }
    504         socket_ids[ sockets ] = NULL;
    505 
    506         if( verbose ) printf( "Starting tests\n" );
    507 
    508         ERROR_PROPAGATE( sockets_create( verbose, socket_ids, sockets, family, type ));
    509 
    510         if( type == SOCK_STREAM ){
    511                 ERROR_PROPAGATE( sockets_connect( verbose, socket_ids, sockets, address, addrlen ));
    512         }
    513 
    514         if( verbose ) printf( "\n" );
    515 
    516         if( ERROR_OCCURRED( gettimeofday( & time_before, NULL ))){
    517                 fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     537        socket_ids[sockets] = NULL;
     538
     539        if(verbose){
     540                printf("Starting tests\n");
     541        }
     542
     543        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     544
     545        if(type == SOCK_STREAM){
     546                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     547        }
     548
     549        if(verbose){
     550                printf("\n");
     551        }
     552
     553        if(ERROR_OCCURRED(gettimeofday(&time_before, NULL))){
     554                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    518555                return ERROR_CODE;
    519556        }
    520557
    521         ERROR_PROPAGATE( sockets_sendto_recvfrom( verbose, socket_ids, sockets, address, & addrlen, data, size, messages ));
    522 
    523         if( ERROR_OCCURRED( gettimeofday( & time_after, NULL ))){
    524                 fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     558        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     559
     560        if(ERROR_OCCURRED(gettimeofday(&time_after, NULL))){
     561                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    525562                return ERROR_CODE;
    526563        }
    527564
    528         if( verbose ) printf( "\tOK\n" );
    529 
    530         printf( "sendto + recvfrom tested in %d microseconds\n", tv_sub( & time_after, & time_before ));
    531 
    532         if( ERROR_OCCURRED( gettimeofday( & time_before, NULL ))){
    533                 fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     565        if(verbose){
     566                printf("\tOK\n");
     567        }
     568
     569        printf("sendto + recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     570
     571        if(ERROR_OCCURRED(gettimeofday(&time_before, NULL))){
     572                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    534573                return ERROR_CODE;
    535574        }
    536575
    537         ERROR_PROPAGATE( sockets_sendto( verbose, socket_ids, sockets, address, addrlen, data, size, messages ));
    538         ERROR_PROPAGATE( sockets_recvfrom( verbose, socket_ids, sockets, address, & addrlen, data, size, messages ));
    539 
    540         if( ERROR_OCCURRED( gettimeofday( & time_after, NULL ))){
    541                 fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     576        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     577        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     578
     579        if(ERROR_OCCURRED(gettimeofday(&time_after, NULL))){
     580                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    542581                return ERROR_CODE;
    543582        }
    544583
    545         if( verbose ) printf( "\tOK\n" );
    546 
    547         printf( "sendto, recvfrom tested in %d microseconds\n", tv_sub( & time_after, & time_before ));
    548 
    549         ERROR_PROPAGATE( sockets_close( verbose, socket_ids, sockets ));
    550 
    551         if( verbose ) printf( "\nExiting\n" );
     584        if(verbose){
     585                printf("\tOK\n");
     586        }
     587
     588        printf("sendto, recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     589
     590        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     591
     592        if(verbose){
     593                printf("\nExiting\n");
     594        }
    552595
    553596        return EOK;

  • uspace/srv/net/app/parse.c

    raa85487 raadf01e  
    4242#include "parse.h"
    4343
    44 int parse_parameter_int( int argc, char ** argv, int * index, int * value, const char * name, int offset ){
    45         char *  rest;
     44int parse_parameter_int(int argc, char ** argv, int * index, int * value, const char * name, int offset){
     45        char * rest;
    4646
    47         if( offset ){
    48                 * value = strtol( argv[ * index ] + offset, & rest, 10 );
    49         }else if(( * index ) + 1 < argc ){
    50                 ++ ( * index );
    51                 * value = strtol( argv[ * index ], & rest, 10 );
     47        if(offset){
     48                *value = strtol(argv[*index] + offset, &rest, 10);
     49        }else if((*index) + 1 < argc){
     50                ++ (*index);
     51                *value = strtol(argv[*index], &rest, 10);
    5252        }else{
    53                 fprintf( stderr, "Command line error: missing %s\n", name );
     53                fprintf(stderr, "Command line error: missing %s\n", name);
    5454                return EINVAL;
    5555        }
    56         if( rest && ( * rest )){
    57                 fprintf( stderr, "Command line error: %s unrecognized (%d: %s)\n", name, * index, argv[ * index ] );
     56        if(rest && (*rest)){
     57                fprintf(stderr, "Command line error: %s unrecognized (%d: %s)\n", name, * index, argv[*index]);
    5858                return EINVAL;
    5959        }
    … …  
    6161}
    6262
    63 int parse_parameter_string( int argc, char ** argv, int * index, char ** value, const char * name, int offset ){
    64         if( offset ){
    65                 * value = argv[ * index ] + offset;
    66         }else if(( * index ) + 1 < argc ){
    67                 ++ ( * index );
    68                 * value = argv[ * index ];
     63int parse_parameter_string(int argc, char ** argv, int * index, char ** value, const char * name, int offset){
     64        if(offset){
     65                *value = argv[*index] + offset;
     66        }else if((*index) + 1 < argc){
     67                ++ (*index);
     68                *value = argv[*index];
    6969        }else{
    70                 fprintf( stderr, "Command line error: missing %s\n", name );
     70                fprintf(stderr, "Command line error: missing %s\n", name);
    7171                return EINVAL;
    7272        }
    … …  
    7474}
    7575
    76 int parse_parameter_name_int( int argc, char ** argv, int * index, int * value, const char * name, int offset, int ( * parse_value )( const char * value )){
     76int parse_parameter_name_int(int argc, char ** argv, int * index, int * value, const char * name, int offset, int (*parse_value)(const char * value)){
    7777        ERROR_DECLARE;
    7878
    79         char *  parameter;
     79        char * parameter;
    8080
    81         ERROR_PROPAGATE( parse_parameter_string( argc, argv, index, & parameter, name, offset ));
    82         * value = ( * parse_value )( parameter );
    83         if(( * value ) == ENOENT ){
    84                 fprintf( stderr, "Command line error: unrecognized %s value (%d: %s)\n", name, * index, parameter );
     81        ERROR_PROPAGATE(parse_parameter_string(argc, argv, index, &parameter, name, offset));
     82        *value = (*parse_value)(parameter);
     83        if((*value) == ENOENT){
     84                fprintf(stderr, "Command line error: unrecognized %s value (%d: %s)\n", name, * index, parameter);
    8585                return ENOENT;
    8686        }
    … …  
    8888}
    8989
    90 void print_unrecognized( int index, const char * parameter ){
    91         fprintf( stderr, "Command line error - unrecognized parameter (%d: %s)\n", index, parameter );
     90void print_unrecognized(int index, const char * parameter){
     91        fprintf(stderr, "Command line error - unrecognized parameter (%d: %s)\n", index, parameter);
    9292}
    9393

  • uspace/srv/net/app/parse.h

    raa85487 raadf01e  
    4242 *  @param[in] parameter The parameter name.
    4343 */
    44 void    print_unrecognized( int index, const char * parameter );
     44void print_unrecognized(int index, const char * parameter);
    4545
    4646/** Parses the next parameter as an integral number.
    … …  
    5757 *  @returns EINVAL if the parameter is in wrong format.
    5858 */
    59 int     parse_parameter_int( int argc, char ** argv, int * index, int * value, const char * name, int offset );
     59int parse_parameter_int(int argc, char ** argv, int * index, int * value, const char * name, int offset);
    6060
    6161/** Parses the next parameter as a character string.
    … …  
    7272 *  @returns EINVAL if the parameter is missing.
    7373 */
    74 int     parse_parameter_string( int argc, char ** argv, int * index, char ** value, const char * name, int offset );
     74int parse_parameter_string(int argc, char ** argv, int * index, char ** value, const char * name, int offset);
    7575
    7676/** Parses the next named parameter as an integral number.
    … …  
    9090 *  @returns ENOENT if the parameter name has not been found.
    9191 */
    92 int     parse_parameter_name_int( int argc, char ** argv, int * index, int * value, const char * name, int offset, int ( * parse_value )( const char * value ));
     92int parse_parameter_name_int(int argc, char ** argv, int * index, int * value, const char * name, int offset, int (*parse_value)(const char * value));
    9393
    9494#endif

  • uspace/srv/net/app/ping/ping.c

    raa85487 raadf01e  
    6363 *  @returns EOK on success.
    6464 */
    65 int             main( int argc, char * argv[] );
     65int main(int argc, char * argv[]);
    6666
    6767/** Prints the application help.
    6868 */
    69 void    print_help( void );
     69void print_help(void);
    7070
    7171/** Translates the character string to the address family number.
    … …  
    7474 *  @returns EAFNOSUPPORTED if the address family is not supported.
    7575 */
    76 int             parse_address_family( const char * name );
    77 
    78 void print_help( void ){
     76int parse_address_family(const char * name);
     77
     78void print_help(void){
    7979        printf(
    8080                "Network Ping aplication\n" \
    … …  
    111111}
    112112
    113 int parse_address_family( const char * name ){
    114         if( str_lcmp( name, "AF_INET", 7 ) == 0 ){
     113int parse_address_family(const char * name){
     114        if(str_lcmp(name, "AF_INET", 7) == 0){
    115115                return AF_INET;
    116         }else if( str_lcmp( name, "AF_INET6", 8 ) == 0 ){
     116        }else if(str_lcmp(name, "AF_INET6", 8) == 0){
    117117                return AF_INET6;
    118118        }
    … …  
    120120}
    121121
    122 int main( int argc, char * argv[] ){
     122int main(int argc, char * argv[]){
    123123        ERROR_DECLARE;
    124124
    125         size_t                          size                    = 38;
    126         int                                     verbose                 = 0;
    127         int                                     dont_fragment   = 0;
    128         ip_ttl_t                        ttl                             = 0;
    129         ip_tos_t                        tos                             = 0;
    130         int                                     count                   = 3;
    131         suseconds_t                     timeout                 = 3000;
    132         int                                     family                  = AF_INET;
    133 
    134         socklen_t                       max_length              = sizeof( struct sockaddr_in6 );
    135         uint8_t                         address_data[ max_length ];
    136         struct sockaddr *               address         = ( struct sockaddr * ) address_data;
    137         struct sockaddr_in *    address_in              = ( struct sockaddr_in * ) address;
    138         struct sockaddr_in6 *   address_in6     = ( struct sockaddr_in6 * ) address;
    139         socklen_t                       addrlen;
    140         char                            address_string[ INET6_ADDRSTRLEN ];
    141         uint8_t *                       address_start;
    142         int                                     icmp_phone;
    143         struct timeval          time_before;
    144         struct timeval          time_after;
    145         int                                     result;
    146         int                                     value;
    147         int                                     index;
    148 
    149         printf( "Task %d - ", task_get_id());
    150         printf( "%s\n", NAME );
    151 
    152         if( argc <= 1 ){
     125        size_t size                     = 38;
     126        int verbose                     = 0;
     127        int dont_fragment       = 0;
     128        ip_ttl_t ttl                            = 0;
     129        ip_tos_t tos                            = 0;
     130        int count                       = 3;
     131        suseconds_t timeout                     = 3000;
     132        int family                      = AF_INET;
     133
     134        socklen_t max_length            = sizeof(struct sockaddr_in6);
     135        uint8_t address_data[max_length];
     136        struct sockaddr * address               = (struct sockaddr *) address_data;
     137        struct sockaddr_in * address_in         = (struct sockaddr_in *) address;
     138        struct sockaddr_in6 * address_in6       = (struct sockaddr_in6 *) address;
     139        socklen_t addrlen;
     140        char address_string[INET6_ADDRSTRLEN];
     141        uint8_t * address_start;
     142        int icmp_phone;
     143        struct timeval time_before;
     144        struct timeval time_after;
     145        int result;
     146        int value;
     147        int index;
     148
     149        printf("Task %d - ", task_get_id());
     150        printf("%s\n", NAME);
     151
     152        if(argc <= 1){
    153153                print_help();
    154154                return EINVAL;
    155155        }
    156156
    157         for( index = 1; ( index < argc - 1 ) || (( index == argc ) && ( argv[ index ][ 0 ] == '-' )); ++ index ){
    158                 if( argv[ index ][ 0 ] == '-' ){
    159                         switch( argv[ index ][ 1 ] ){
    160                                 case 'c':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "count", 0 ));
    161                                                         break;
    162                                 case 'f':       ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "address family", 0, parse_address_family ));
    163                                                         break;
    164                                 case 'h':       print_help();
    165                                                         return EOK;
    166                                                         break;
    167                                 case 's':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "packet size", 0 ));
    168                                                         size = (value >= 0 ) ? ( size_t ) value : 0;
    169                                                         break;
    170                                 case 't':       ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "timeout", 0 ));
    171                                                         timeout = (value >= 0 ) ? ( suseconds_t ) value : 0;
    172                                                         break;
    173                                 case 'v':       verbose = 1;
    174                                                         break;
    175                                 case '-':       if( str_lcmp( argv[ index ] + 2, "count=", 6 ) == 0 ){
    176                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "received count", 8 ));
    177                                                         }else if( str_lcmp( argv[ index ] + 2, "dont_fragment", 13 ) == 0 ){
    178                                                                 dont_fragment = 1;
    179                                                         }else if( str_lcmp( argv[ index ] + 2, "family=", 7 ) == 0 ){
    180                                                                 ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & family, "address family", 9, parse_address_family ));
    181                                                         }else if( str_lcmp( argv[ index ] + 2, "help", 5 ) == 0 ){
    182                                                                 print_help();
    183                                                                 return EOK;
    184                                                         }else if( str_lcmp( argv[ index ] + 2, "size=", 5 ) == 0 ){
    185                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "packet size", 7 ));
    186                                                                 size = (value >= 0 ) ? ( size_t ) value : 0;
    187                                                         }else if( str_lcmp( argv[ index ] + 2, "timeout=", 8 ) == 0 ){
    188                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "timeout", 7 ));
    189                                                                 timeout = (value >= 0 ) ? ( suseconds_t ) value : 0;
    190                                                         }else if( str_lcmp( argv[ index ] + 2, "tos=", 4 ) == 0 ){
    191                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "type of service", 7 ));
    192                                                                 tos = (value >= 0 ) ? ( ip_tos_t ) value : 0;
    193                                                         }else if( str_lcmp( argv[ index ] + 2, "ttl=", 4 ) == 0 ){
    194                                                                 ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "time to live", 7 ));
    195                                                                 ttl = (value >= 0 ) ? ( ip_ttl_t ) value : 0;
    196                                                         }else if( str_lcmp( argv[ index ] + 2, "verbose", 8 ) == 0 ){
    197                                                                 verbose = 1;
    198                                                         }else{
    199                                                                 print_unrecognized( index, argv[ index ] + 2 );
    200                                                                 print_help();
    201                                                                 return EINVAL;
    202                                                         }
    203                                                         break;
     157        for(index = 1; (index < argc - 1) || ((index == argc) && (argv[index][0] == '-')); ++ index){
     158                if(argv[index][0] == '-'){
     159                        switch(argv[index][1]){
     160                                case 'c':
     161                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &count, "count", 0));
     162                                        break;
     163                                case 'f':
     164                                        ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "address family", 0, parse_address_family));
     165                                        break;
     166                                case 'h':
     167                                        print_help();
     168                                        return EOK;
     169                                        break;
     170                                case 's':
     171                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "packet size", 0));
     172                                        size = (value >= 0) ? (size_t) value : 0;
     173                                        break;
     174                                case 't':
     175                                        ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "timeout", 0));
     176                                        timeout = (value >= 0) ? (suseconds_t) value : 0;
     177                                        break;
     178                                case 'v':
     179                                        verbose = 1;
     180                                        break;
     181                                case '-':
     182                                        if(str_lcmp(argv[index] + 2, "count=", 6) == 0){
     183                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &count, "received count", 8));
     184                                        }else if(str_lcmp(argv[index] + 2, "dont_fragment", 13) == 0){
     185                                                dont_fragment = 1;
     186                                        }else if(str_lcmp(argv[index] + 2, "family=", 7) == 0){
     187                                                ERROR_PROPAGATE(parse_parameter_name_int(argc, argv, &index, &family, "address family", 9, parse_address_family));
     188                                        }else if(str_lcmp(argv[index] + 2, "help", 5) == 0){
     189                                                print_help();
     190                                                return EOK;
     191                                        }else if(str_lcmp(argv[index] + 2, "size=", 5) == 0){
     192                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "packet size", 7));
     193                                                size = (value >= 0) ? (size_t) value : 0;
     194                                        }else if(str_lcmp(argv[index] + 2, "timeout=", 8) == 0){
     195                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "timeout", 7));
     196                                                timeout = (value >= 0) ? (suseconds_t) value : 0;
     197                                        }else if(str_lcmp(argv[index] + 2, "tos=", 4) == 0){
     198                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "type of service", 7));
     199                                                tos = (value >= 0) ? (ip_tos_t) value : 0;
     200                                        }else if(str_lcmp(argv[index] + 2, "ttl=", 4) == 0){
     201                                                ERROR_PROPAGATE(parse_parameter_int(argc, argv, &index, &value, "time to live", 7));
     202                                                ttl = (value >= 0) ? (ip_ttl_t) value : 0;
     203                                        }else if(str_lcmp(argv[index] + 2, "verbose", 8) == 0){
     204                                                verbose = 1;
     205                                        }else{
     206                                                print_unrecognized(index, argv[index] + 2);
     207                                                print_help();
     208                                                return EINVAL;
     209                                        }
     210                                        break;
    204211                                default:
    205                                         print_unrecognized( index, argv[ index ] + 1 );
     212                                        print_unrecognized(index, argv[index] + 1);
    206213                                        print_help();
    207214                                        return EINVAL;
    208215                        }
    209216                }else{
    210                         print_unrecognized( index, argv[ index ] );
     217                        print_unrecognized(index, argv[index]);
    211218                        print_help();
    212219                        return EINVAL;
    … …  
    214221        }
    215222
    216         bzero( address_data, max_length );
    217         switch( family ){
     223        bzero(address_data, max_length);
     224        switch(family){
    218225                case AF_INET:
    219226                        address_in->sin_family = AF_INET;
    220                         address_start = ( uint8_t * ) & address_in->sin_addr.s_addr;
    221                         addrlen = sizeof( struct sockaddr_in );
     227                        address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     228                        addrlen = sizeof(struct sockaddr_in);
    222229                        break;
    223230                case AF_INET6:
    224231                        address_in6->sin6_family = AF_INET6;
    225                         address_start = ( uint8_t * ) & address_in6->sin6_addr.s6_addr;
    226                         addrlen = sizeof( struct sockaddr_in6 );
     232                        address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     233                        addrlen = sizeof(struct sockaddr_in6);
    227234                        break;
    228235                default:
    229                         fprintf( stderr, "Address family is not supported\n" );
     236                        fprintf(stderr, "Address family is not supported\n");
    230237                        return EAFNOSUPPORT;
    231238        }
    232239
    233         if( ERROR_OCCURRED( inet_pton( family, argv[ argc - 1 ], address_start ))){
    234                 fprintf( stderr, "Address parse error %d\n", ERROR_CODE );
     240        if(ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))){
     241                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
    235242                return ERROR_CODE;
    236243        }
    237244
    238         icmp_phone = icmp_connect_module( SERVICE_ICMP, ICMP_CONNECT_TIMEOUT );
    239         if( icmp_phone < 0 ){
    240                 fprintf( stderr, "ICMP connect error %d\n", icmp_phone );
     245        icmp_phone = icmp_connect_module(SERVICE_ICMP, ICMP_CONNECT_TIMEOUT);
     246        if(icmp_phone < 0){
     247                fprintf(stderr, "ICMP connect error %d\n", icmp_phone);
    241248                return icmp_phone;
    242249        }
    243250
    244         printf( "PING %d bytes of data\n", size );
    245         if( ERROR_OCCURRED( inet_ntop( address->sa_family, address_start, address_string, sizeof( address_string )))){
    246                 fprintf( stderr, "Address error %d\n", ERROR_CODE );
     251        printf("PING %d bytes of data\n", size);
     252        if(ERROR_OCCURRED(inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string)))){
     253                fprintf(stderr, "Address error %d\n", ERROR_CODE);
    247254        }else{
    248                 printf( "Address %s:\n", address_string );
    249         }
    250 
    251         while( count > 0 ){
    252                 if( ERROR_OCCURRED( gettimeofday( & time_before, NULL ))){
    253                         fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     255                printf("Address %s:\n", address_string);
     256        }
     257
     258        while(count > 0){
     259                if(ERROR_OCCURRED(gettimeofday(&time_before, NULL))){
     260                        fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    254261                        return ERROR_CODE;
    255262                }
    256                 result = icmp_echo_msg( icmp_phone, size, timeout, ttl, tos, dont_fragment, address, addrlen );
    257                 if( ERROR_OCCURRED( gettimeofday( & time_after, NULL ))){
    258                         fprintf( stderr, "Get time of day error %d\n", ERROR_CODE );
     263                result = icmp_echo_msg(icmp_phone, size, timeout, ttl, tos, dont_fragment, address, addrlen);
     264                if(ERROR_OCCURRED(gettimeofday(&time_after, NULL))){
     265                        fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
    259266                        return ERROR_CODE;
    260267                }
    261                 switch( result ){
     268                switch(result){
    262269                        case ICMP_ECHO:
    263                                 printf( "Ping round trip time %d miliseconds\n", tv_sub( & time_after, & time_before ) / 1000 );
     270                                printf("Ping round trip time %d miliseconds\n", tv_sub(&time_after, &time_before) / 1000);
    264271                                break;
    265272                        case ETIMEOUT:
    266                                 printf( "Timed out.\n" );
     273                                printf("Timed out.\n");
    267274                                break;
    268275                        default:
    269                                 print_error( stdout, result, NULL, "\n" );
     276                                print_error(stdout, result, NULL, "\n");
    270277                }
    271278                -- count;
    272279        }
    273280
    274         if( verbose ) printf( "Exiting\n" );
     281        if(verbose){
     282                printf("Exiting\n");
     283        }
    275284
    276285        return EOK;

  • uspace/srv/net/app/print_error.c

    raa85487 raadf01e  
    4242#include "print_error.h"
    4343
    44 void print_error( FILE * output, int error_code, const char * prefix, const char * suffix ){
    45         if( IS_ICMP_ERROR( error_code )){
    46                 icmp_print_error( output, error_code, prefix, suffix );
    47         }else if( IS_SOCKET_ERROR( error_code )){
    48                 socket_print_error( output, error_code, prefix, suffix );
     44void print_error(FILE * output, int error_code, const char * prefix, const char * suffix){
     45        if(IS_ICMP_ERROR(error_code)){
     46                icmp_print_error(output, error_code, prefix, suffix);
     47        }else if(IS_SOCKET_ERROR(error_code)){
     48                socket_print_error(output, error_code, prefix, suffix);
    4949        }
    5050}
    5151
    52 void icmp_print_error( FILE * output, int error_code, const char * prefix, const char * suffix ){
    53         if( output ){
    54                 if( prefix ){
    55                         fprintf( output, "%s", prefix );
     52void icmp_print_error(FILE * output, int error_code, const char * prefix, const char * suffix){
     53        if(output){
     54                if(prefix){
     55                        fprintf(output, "%s", prefix);
    5656                }
    57                 switch( error_code ){
     57                switch(error_code){
    5858                        case ICMP_DEST_UNREACH:
    59                                 fprintf( output, "ICMP Destination Unreachable (%d) error", error_code );
     59                                fprintf(output, "ICMP Destination Unreachable (%d) error", error_code);
    6060                                break;
    6161                        case ICMP_SOURCE_QUENCH:
    62                                 fprintf( output, "ICMP Source Quench (%d) error", error_code );
     62                                fprintf(output, "ICMP Source Quench (%d) error", error_code);
    6363                                break;
    6464                        case ICMP_REDIRECT:
    65                                 fprintf( output, "ICMP Redirect (%d) error", error_code );
     65                                fprintf(output, "ICMP Redirect (%d) error", error_code);
    6666                                break;
    6767                        case ICMP_ALTERNATE_ADDR:
    68                                 fprintf( output, "ICMP Alternate Host Address (%d) error", error_code );
     68                                fprintf(output, "ICMP Alternate Host Address (%d) error", error_code);
    6969                                break;
    7070                        case ICMP_ROUTER_ADV:
    71                                 fprintf( output, "ICMP Router Advertisement (%d) error", error_code );
     71                                fprintf(output, "ICMP Router Advertisement (%d) error", error_code);
    7272                                break;
    7373                        case ICMP_ROUTER_SOL:
    74                                 fprintf( output, "ICMP Router Solicitation (%d) error", error_code );
     74                                fprintf(output, "ICMP Router Solicitation (%d) error", error_code);
    7575                                break;
    7676                        case ICMP_TIME_EXCEEDED:
    77                                 fprintf( output, "ICMP Time Exceeded (%d) error", error_code );
     77                                fprintf(output, "ICMP Time Exceeded (%d) error", error_code);
    7878                                break;
    7979                        case ICMP_PARAMETERPROB:
    80                                 fprintf( output, "ICMP Paramenter Problem (%d) error", error_code );
     80                                fprintf(output, "ICMP Paramenter Problem (%d) error", error_code);
    8181                                break;
    8282                        case ICMP_CONVERSION_ERROR:
    83                                 fprintf( output, "ICMP Datagram Conversion Error (%d) error", error_code );
     83                                fprintf(output, "ICMP Datagram Conversion Error (%d) error", error_code);
    8484                                break;
    8585                        case ICMP_REDIRECT_MOBILE:
    86                                 fprintf( output, "ICMP Mobile Host Redirect (%d) error", error_code );
     86                                fprintf(output, "ICMP Mobile Host Redirect (%d) error", error_code);
    8787                                break;
    8888                        case ICMP_SKIP:
    89                                 fprintf( output, "ICMP SKIP (%d) error", error_code );
     89                                fprintf(output, "ICMP SKIP (%d) error", error_code);
    9090                                break;
    9191                        case ICMP_PHOTURIS:
    92                                 fprintf( output, "ICMP Photuris (%d) error", error_code );
     92                                fprintf(output, "ICMP Photuris (%d) error", error_code);
    9393                                break;
    9494                        default:
    95                                 fprintf( output, "Other (%d) error", error_code );
     95                                fprintf(output, "Other (%d) error", error_code);
    9696                }
    97                 if( suffix ){
    98                         fprintf( output, "%s", suffix );
     97                if(suffix){
     98                        fprintf(output, "%s", suffix);
    9999                }
    100100        }
    101101}
    102102
    103 void socket_print_error( FILE * output, int error_code, const char * prefix, const char * suffix ){
    104         if( output ){
    105                 if( prefix ){
    106                         fprintf( output, "%s", prefix );
     103void socket_print_error(FILE * output, int error_code, const char * prefix, const char * suffix){
     104        if(output){
     105                if(prefix){
     106                        fprintf(output, "%s", prefix);
    107107                }
    108                 switch( error_code ){
     108                switch(error_code){
    109109                        case ENOTSOCK:
    110                                 fprintf( output, "Not a socket (%d) error", error_code );
     110                                fprintf(output, "Not a socket (%d) error", error_code);
    111111                                break;
    112112                        case EPROTONOSUPPORT:
    113                                 fprintf( output, "Protocol not supported (%d) error", error_code );
     113                                fprintf(output, "Protocol not supported (%d) error", error_code);
    114114                                break;
    115115                        case ESOCKTNOSUPPORT:
    116                                 fprintf( output, "Socket type not supported (%d) error", error_code );
     116                                fprintf(output, "Socket type not supported (%d) error", error_code);
    117117                                break;
    118118                        case EPFNOSUPPORT:
    119                                 fprintf( output, "Protocol family not supported (%d) error", error_code );
     119                                fprintf(output, "Protocol family not supported (%d) error", error_code);
    120120                                break;
    121121                        case EAFNOSUPPORT:
    122                                 fprintf( output, "Address family not supported (%d) error", error_code );
     122                                fprintf(output, "Address family not supported (%d) error", error_code);
    123123                                break;
    124124                        case EADDRINUSE:
    125                                 fprintf( output, "Address already in use (%d) error", error_code );
     125                                fprintf(output, "Address already in use (%d) error", error_code);
    126126                                break;
    127127                        case ENOTCONN:
    128                                 fprintf( output, "Socket not connected (%d) error", error_code );
     128                                fprintf(output, "Socket not connected (%d) error", error_code);
    129129                                break;
    130130                        case NO_DATA:
    131                                 fprintf( output, "No data (%d) error", error_code );
     131                                fprintf(output, "No data (%d) error", error_code);
    132132                                break;
    133133                        case EINPROGRESS:
    134                                 fprintf( output, "Another operation in progress (%d) error", error_code );
     134                                fprintf(output, "Another operation in progress (%d) error", error_code);
    135135                                break;
    136136                        case EDESTADDRREQ:
    137                                 fprintf( output, "Destination address required (%d) error", error_code );
     137                                fprintf(output, "Destination address required (%d) error", error_code);
    138138                        case TRY_AGAIN:
    139                                 fprintf( output, "Try again (%d) error", error_code );
     139                                fprintf(output, "Try again (%d) error", error_code);
    140140                        default:
    141                                 fprintf( output, "Other (%d) error", error_code );
     141                                fprintf(output, "Other (%d) error", error_code);
    142142                }
    143                 if( suffix ){
    144                         fprintf( output, "%s", suffix );
     143                if(suffix){
     144                        fprintf(output, "%s", suffix);
    145145                }
    146146        }

  • uspace/srv/net/app/print_error.h

    raa85487 raadf01e  
    4242 *  @returns A value indicating whether the error code may be an ICMP error code.
    4343 */
    44 #define IS_ICMP_ERROR( error_code )             (( error_code ) > 0 )
     44#define IS_ICMP_ERROR(error_code)               ((error_code) > 0)
    4545
    4646/** Returns whether the error code may be socket error code.
    … …  
    4848 *  @returns A value indicating whether the error code may be a socket error code.
    4949 */
    50 #define IS_SOCKET_ERROR( error_code )   (( error_code ) < 0 )
     50#define IS_SOCKET_ERROR(error_code)     ((error_code) < 0)
    5151
    5252/** Prints the error description.
    … …  
    5757 *  @param[in] suffix The error description suffix. May be NULL.
    5858 */
    59 void print_error( FILE * output, int error_code, const char * prefix, const char * suffix );
     59void print_error(FILE * output, int error_code, const char * prefix, const char * suffix);
    6060
    6161/** Prints the specific ICMP error description.
    … …  
    6565 *  @param[in] suffix The error description suffix. May be NULL.
    6666 */
    67 void icmp_print_error( FILE * output, int error_code, const char * prefix, const char * suffix );
     67void icmp_print_error(FILE * output, int error_code, const char * prefix, const char * suffix);
    6868
    6969/** Prints the specific socket error description.
    … …  
    7373 *  @param[in] suffix The error description suffix. May be NULL.
    7474 */
    75 void socket_print_error( FILE * output, int error_code, const char * prefix, const char * suffix );
     75void socket_print_error(FILE * output, int error_code, const char * prefix, const char * suffix);
    7676
    7777#endif
Note: See TracChangeset for help on using the changeset viewer.