Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 2e99277 in mainline


Ignore:
Timestamp:
2010-02-23T22:51:49Z (12 years ago)
Author:
Lukas Mejdrech <lukasmejdrech@…>
Branches:
lfn, master
Children:
aa85487
Parents:
8edacbc
Message:
  • inner message processing fixed
Location:
uspace/srv/net
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/module.c

    r8edacbc r2e99277  
    110110                res = module_message( callid, & call, & answer, & answer_count );
    111111
    112                 if( IPC_GET_METHOD( call ) == IPC_M_PHONE_HUNGUP ) return;
     112                if(( IPC_GET_METHOD( call ) == IPC_M_PHONE_HUNGUP ) || ( res == EHANGUP )){
     113                        return;
     114                }
    113115
    114116                answer_call( callid, res, & answer, answer_count );
  • uspace/srv/net/tl/icmp/icmp.c

    r8edacbc r2e99277  
    658658        ipc_callid_t                    data_callid;
    659659        icmp_echo_ref                   echo_data;
     660        int                                             res;
    660661
    661662        /*
     
    663664         *  - Answer the first NET_ICMP_INIT call.
    664665         */
    665         ipc_answer_0( callid, EOK );
     666        res = EOK;
     667        answer_count = 0;
    666668
    667669//      fibril_rwlock_initialize( & lock );
     
    669671        echo_data = ( icmp_echo_ref ) malloc( sizeof( * echo_data ));
    670672        if( ! echo_data ) return ENOMEM;
     673
    671674        // assign a new identifier
    672675        fibril_rwlock_write_lock( & icmp_globals.lock );
    673         ERROR_CODE = icmp_bind_free_id( echo_data );
     676        res = icmp_bind_free_id( echo_data );
    674677        fibril_rwlock_write_unlock( & icmp_globals.lock );
    675         if( ERROR_CODE < 0 ){
     678        if( res < 0 ){
    676679                free( echo_data );
    677                 return ERROR_CODE;
     680                return res;
    678681        }
    679682
    680683        while( keep_on_going ){
     684
     685                // answer the call
     686                answer_call( callid, res, & answer, answer_count );
     687
     688                // refresh data
    681689                refresh_answer( & answer, & answer_count );
    682690
     691                // get the next call
    683692                callid = async_get_call( & call );
    684693
     694                // process the call
    685695                switch( IPC_GET_METHOD( call )){
    686696                        case IPC_M_PHONE_HUNGUP:
    687697                                keep_on_going = false;
    688                                 ERROR_CODE = EOK;
     698                                res = EHANGUP;
    689699                                break;
    690700                        case NET_ICMP_ECHO:
    691701//                              fibril_rwlock_write_lock( & lock );
    692702                                if( ! async_data_write_receive( & data_callid, & length )){
    693                                         ERROR_CODE = EINVAL;
     703                                        res = EINVAL;
    694704                                }else{
    695705                                        addr = malloc( length );
    696706                                        if( ! addr ){
    697                                                 ERROR_CODE = ENOMEM;
     707                                                res = ENOMEM;
    698708                                        }else{
    699709                                                if( ! ERROR_OCCURRED( async_data_write_finalize( data_callid, addr, length ))){
    700710                                                        fibril_rwlock_write_lock( & icmp_globals.lock );
    701                                                         ERROR_CODE = icmp_echo( echo_data->identifier, echo_data->sequence_number, ICMP_GET_SIZE( call ), ICMP_GET_TIMEOUT( call ), ICMP_GET_TTL( call ), ICMP_GET_TOS( call ), ICMP_GET_DONT_FRAGMENT( call ), addr, ( socklen_t ) length );
     711                                                        res = icmp_echo( echo_data->identifier, echo_data->sequence_number, ICMP_GET_SIZE( call ), ICMP_GET_TIMEOUT( call ), ICMP_GET_TTL( call ), ICMP_GET_TOS( call ), ICMP_GET_DONT_FRAGMENT( call ), addr, ( socklen_t ) length );
    702712                                                        fibril_rwlock_write_unlock( & icmp_globals.lock );
    703713                                                        free( addr );
     
    707717                                                                echo_data->sequence_number = 0;
    708718                                                        }
     719                                                }else{
     720                                                        res = ERROR_CODE;
    709721                                                }
    710722                                        }
     
    713725                                break;
    714726                        default:
    715                                 ERROR_CODE = icmp_process_message( & call );
     727                                res = icmp_process_message( & call );
    716728                }
    717 
    718                 answer_call( callid, ERROR_CODE, & answer, answer_count );
    719729        }
    720730
     
    723733        icmp_echo_data_exclude( & icmp_globals.echo_data, echo_data->identifier );
    724734        fibril_rwlock_write_unlock( & icmp_globals.lock );
    725         return EOK;
     735        return res;
    726736}
    727737
  • uspace/srv/net/tl/tcp/tcp.c

    r8edacbc r2e99277  
    10701070         *  - Answer the first IPC_M_CONNECT_ME_TO call.
    10711071         */
    1072         ipc_answer_0( callid, EOK );
     1072        res = EOK;
     1073        answer_count = 0;
    10731074
    10741075        socket_cores_initialize( & local_sockets );
     
    10761077
    10771078        while( keep_on_going ){
     1079
     1080                // answer the call
     1081                answer_call( callid, res, & answer, answer_count );
     1082
    10781083                // refresh data
    10791084                refresh_answer( & answer, & answer_count );
    10801085
     1086                // get the next call
    10811087                callid = async_get_call( & call );
    1082 //              printf( "message %d\n", IPC_GET_METHOD( * call ));
    1083 
     1088
     1089                // process the call
    10841090                switch( IPC_GET_METHOD( call )){
    10851091                        case IPC_M_PHONE_HUNGUP:
    10861092                                keep_on_going = false;
    1087                                 res = EOK;
     1093                                res = EHANGUP;
    10881094                                break;
    10891095                        case NET_SOCKET:
     
    12311237                                break;
    12321238                }
    1233 
    1234 //              printf( "res = %d\n", res );
    1235 
    1236                 answer_call( callid, res, & answer, answer_count );
    12371239        }
    12381240
     
    12731275                                        // TODO release as connection lost
    12741276                                        //tcp_refresh_socket_data( socket_data );
    1275                                 }
    1276                                 // retransmit
    1277                                 // TODO enable retransmit
    1278                                 //tcp_retransmit_packet( socket, socket_data, timeout->sequence_number );
     1277                                }else{
     1278                                        // retransmit
     1279                                        tcp_retransmit_packet( socket, socket_data, timeout->sequence_number );
     1280                                }
    12791281                                fibril_rwlock_write_unlock( socket_data->local_lock );
    12801282                        }else{
  • uspace/srv/net/tl/udp/udp.c

    r8edacbc r2e99277  
    390390        fibril_rwlock_write_unlock( & udp_globals.lock );
    391391        async_msg_5( socket->phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) socket->socket_id, packet_dimension->content, 0, 0, ( ipcarg_t ) fragments );
    392 /*      fibril_rwlock_write_unlock( & udp_globals.lock );
    393         async_msg_5( socket->phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) socket->socket_id, 0, 0, 0, ( ipcarg_t ) fragments );
    394 */      return EOK;
     392        return EOK;
    395393}
    396394
     
    429427         *  - Answer the first IPC_M_CONNECT_TO_ME call.
    430428         */
    431         ipc_answer_0( callid, EOK );
     429        res = EOK;
     430        answer_count = 0;
    432431
    433432        // The client connection is only in one fibril and therefore no additional locks are needed.
     
    437436
    438437        while( keep_on_going ){
     438
     439                // answer the call
     440                answer_call( callid, res, & answer, answer_count );
     441
    439442                // refresh data
    440443                refresh_answer( & answer, & answer_count );
    441444
     445                // get the next call
    442446                callid = async_get_call( & call );
    443 //              printf( "message %d\n", IPC_GET_METHOD( * call ));
    444 
     447
     448                // process the call
    445449                switch( IPC_GET_METHOD( call )){
    446450                        case IPC_M_PHONE_HUNGUP:
    447451                                keep_on_going = false;
    448                                 res = EOK;
     452                                res = EHANGUP;
    449453                                break;
    450454                        case NET_SOCKET:
     
    514518                                break;
    515519                }
    516 
    517 //              printf( "res = %d\n", res );
    518 
    519                 answer_call( callid, res, & answer, answer_count );
    520520        }
    521521
     
    523523        socket_cores_release( udp_globals.net_phone, & local_sockets, & udp_globals.sockets, NULL );
    524524
    525         return EOK;
     525        return res;
    526526}
    527527
     
    618618        header->checksum = 0;
    619619        if( udp_globals.checksum_computing ){
    620 //              if( ERROR_OCCURRED( ip_get_route_req( udp_globals.ip_phone, IPPROTO_UDP, addr, addrlen, & device_id, & ip_header, & headerlen ))){
    621 //                      return udp_release_and_return( packet, ERROR_CODE );
    622 //              }
    623                 if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( ip_header, headerlen, total_length + UDP_HEADER_SIZE))){
     620                // update the pseudo header
     621                if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( ip_header, headerlen, total_length + UDP_HEADER_SIZE ))){
    624622                        free( ip_header );
    625623                        return udp_release_and_return( packet, ERROR_CODE );
    626624                }
     625                // finish the checksum computation
    627626                checksum = compute_checksum( checksum, ip_header, headerlen );
    628627                checksum = compute_checksum( checksum, ( uint8_t * ) header, sizeof( * header ));
Note: See TracChangeset for help on using the changeset viewer.