WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/tl/udp/udp.c

+}
 int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
     ERROR_DECLARE;
-    int             length;
+    size_t          length;
-    int             offset;
+    size_t          offset;
+    int             result;
     uint8_t *       data;
     udp_header_ref  header;
     socket_core_ref *   socket;
     packet_t        next_packet;
-    int             total_length;
+    size_t          total_length;
 //  uint16_t        checksum;
     int             fragments;
     packet_t        tmp_packet;
     icmp_type_t     type;
     icmp_code_t     code;
         switch( error ){
             case SERVICE_ICMP:
                 // process error
                 // TODO remove debug dump
                 // length = icmp_client_header_length( packet );
-                length = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
+                result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
-                if( length < 0 ){
+                if( result < 0 ){
-                    return release_and_return( packet, length );
+                    return release_and_return( packet, result );
+                }
                 printf( "ICMP error %d (%d) in packet %d\n", type, code, packet_get_id( packet ) );
+                length = ( size_t ) result;
                 if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
                     return release_and_return( packet, ERROR_CODE );
+                }
                 break;
             default:
                 return release_and_return( packet, ENOTSUP );
+        }
+    }
     // TODO process received ipopts?
-    offset = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
+    result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
-    if( offset < 0 ){
+    if( result < 0 ){
-        return release_and_return( packet, offset );
+        return release_and_return( packet, result );
+    }
+    offset = ( size_t ) result;
     length = packet_get_data_length( packet );
     if( length <= 0 ){
         return release_and_return( packet, EINVAL );
+    }
     fragments = 0;
     total_length = ntohs( header->len );
     do{
         ++ fragments;
         length = packet_get_data_length( packet );
-        if( ! length ){
+        if( length <= 0 ){
             return release_and_return( packet, NO_DATA );
+        }
         if( total_length < length ){
             // cut of the suffix if too long
             if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
     if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
         return release_and_return( packet, ERROR_CODE );
+    }
     // notify the destination socket
-    async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ** socket ).socket_id, fragments );
+    async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) ( ** socket ).socket_id, ( ipcarg_t ) fragments );
     return EOK;
+}
 int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
     ERROR_DECLARE;
+        }
 //      printf( "res = %d\n", res );
         switch( answer_count ){
-            case 0:     ipc_answer_0( callid, res );
+            case 0:     ipc_answer_0( callid, ( ipcarg_t ) res );
                     continue;
-            case 1:     ipc_answer_1( callid, res, IPC_GET_ARG1( answer ));
+            case 1:     ipc_answer_1( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ));
                     continue;
-            case 2:     ipc_answer_2( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ));
+            case 2:     ipc_answer_2( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ));
                     continue;
-            case 3:     ipc_answer_3( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ));
+            case 3:     ipc_answer_3( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ));
                     continue;
-            case 4:     ipc_answer_4( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ));
+            case 4:     ipc_answer_4( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ));
                     continue;
-            default:    ipc_answer_5( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ), IPC_GET_ARG5( answer ));
+            default:    ipc_answer_5( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ), IPC_GET_ARG5( answer ));
                     continue;
+        }
+    }
     socket_cores_destroy( & local_sockets );
     struct sockaddr_in *    address_in;
     packet_t                packet;
     packet_t                next_packet;
     udp_header_ref          header;
     int                     index;
-    int                     total_length;
+    size_t                  total_length;
-    int                     length;
+    int                     result;
     if( addrlen < sizeof( struct sockaddr )) return EINVAL;
     address = ( struct sockaddr * ) addr;
     switch( address->sa_family ){
         case AF_INET:
+            }
             // TODO do not ask all the time
             ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
             // read the first packet fragment
-            total_length = socket_read_packet_data( & packet, sizeof( udp_header_t ), address_in );
+            result = socket_read_packet_data( & packet, sizeof( udp_header_t ), address_in );
-            if( total_length < 0 ) return total_length;
+            if( result < 0 ) return result;
+            total_length = ( size_t ) result;
             // prefix the udp header
             header = PACKET_PREFIX( packet, udp_header_t );
             if( ! header ){
                 pq_release( udp_globals.net_phone, packet_get_id( packet ));
                 return ENOMEM;
+            }
             // read the rest of the packet fragments
             for( index = 1; index < fragments; ++ index ){
-                length = socket_read_packet_data( & next_packet, 0, address_in );
+                result = socket_read_packet_data( & next_packet, 0, address_in );
-                if( length < 0 ){
+                if( result < 0 ){
-                    pq_release( udp_globals.net_phone, packet_get_id( packet ));
+                    return release_and_return( packet, result );
-                    return length;
+                }
                 packet = pq_add( packet, next_packet, index, 0 );
-                total_length += length;
+                total_length += ( size_t ) result;
+            }
             // set the udp header
-            header->source = ( socket->port < 0 ) ? 0 : htons( socket->port );
+            header->source = htons( socket->port );
             header->dest = htons( address_in->sin_port );
             header->len = htons( total_length + sizeof( udp_header_t ));
             // TODO my ip address for the pseudo header checksum
             header->check = 0;
             // prepare the first packet fragment
                 return ERROR_CODE;
+            }
             // send the packet
             return ip_send_msg( udp_globals.ip_phone, socket->device_id, packet, SERVICE_UDP, 0 );
         // TODO IPv6
-        default:
-            return EAFNOSUPPORT;
+    }
-    return EOK;
+    return EAFNOSUPPORT;
+}
 int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags ){
     ERROR_DECLARE;
     socket_core_ref socket;
     int             packet_id;
     packet_t        packet;
     udp_header_ref  header;
     struct sockaddr_in      address;
-    int             length;
+    size_t          length;
     packet_t        next_packet;
-    void *          data;
+    uint8_t *       data;
-    int             fragments;
+    size_t          fragments;
-    int *           lengths;
+    size_t *        lengths;
+    int             result;
-    int             index;
+    size_t          index;
     uint8_t *       addr;
     // find the socket
     socket = socket_cores_find( local_sockets, socket_id );
     if( ! socket ) return ENOTSOCK;
+    }
     header = ( udp_header_ref ) data;
     // set the source address
     address.sin_family = PF_INET;
     address.sin_port = ntohs( header->source );
-    length = packet_get_addr( packet, & addr, NULL );
+    result = packet_get_addr( packet, & addr, NULL );
-    if( length != sizeof( address.sin_addr.s_addr )){
+    if( result != sizeof( address.sin_addr.s_addr )){
         pq_release( udp_globals.net_phone, packet_id );
         return EINVAL;
+    }
     address.sin_addr.s_addr = *(( uint32_t * ) addr );
     bzero( & address.sin_zero, sizeof( address.sin_zero ));
         next_packet = pq_next( packet );
         while(( next_packet = pq_next( next_packet ))){
             ++ fragments;
+        }
         // compute and store the fragment lengths
-        lengths = ( int * ) malloc( sizeof( int ) * ( fragments + 1 ));
+        lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
         if( ! lengths ) return ENOMEM;
         lengths[ 0 ] = packet_get_data_length( packet ) - sizeof( udp_header_t );
         lengths[ fragments ] = lengths[ 0 ];
         next_packet = pq_next( packet );
         for( index = 1; index < fragments; ++ index ){
+    }
     // release the packet
     dyn_fifo_pop( & socket->received );
     pq_release( udp_globals.net_phone, packet_get_id( packet ));
     // return the total length
-    return length;
+    return ( int ) length;
+}
 int socket_write_data( void * data, size_t data_length ){
     size_t          length;
     ipc_callid_t    callid;
     // set the packet destination address
     || ERROR_OCCURRED( packet_set_addr( * packet, NULL, ( uint8_t * ) & address_in->sin_addr.s_addr, sizeof( address_in->sin_addr.s_addr )))){
         pq_release( udp_globals.net_phone, packet_get_id( * packet ));
         return ERROR_CODE;
+    }
-    return length;
+    return ( int ) length;
+}
 static int  release_and_return( packet_t packet, int result ){
     pq_release( udp_globals.net_phone, packet_get_id( packet ));
     return result;
     length = packet_get_addr( packet, & src, NULL );
     if(( length > 0 )
     && ( ! error )
     && ( udp_globals.icmp_phone >= 0 )
     // set both addresses to the source one (avoids the source address deletion before setting the destination one)
-    && ( packet_set_addr( packet, src, src, length ) == EOK )){
+    && ( packet_set_addr( packet, src, src, ( size_t ) length ) == EOK )){
         icmp_destination_unreachable_msg( udp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
     }else{
-        return release_and_return( packet, EINVAL );
+        release_and_return( packet, EINVAL );
+    }
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/tl/udp/udp.c – Rev 4707 → 4708