Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/il/ip/ip.c

    r00d7e1b rccca251  
    120120GENERIC_FIELD_IMPLEMENT(ip_routes, ip_route_t);
    121121
    122 static void ip_receiver(ipc_callid_t, ipc_call_t *, void *);
    123 
    124 /** Release the packet and returns the result.
    125  *
    126  * @param[in] packet Packet queue to be released.
    127  * @param[in] result Result to be returned.
    128  *
    129  * @return Result parameter.
    130  *
     122static void ip_receiver(ipc_callid_t, ipc_call_t *);
     123
     124/** Releases the packet and returns the result.
     125 *
     126 * @param[in] packet    The packet queue to be released.
     127 * @param[in] result    The result to be returned.
     128 * @return              The result parameter.
    131129 */
    132130static int ip_release_and_return(packet_t *packet, int result)
    133131{
    134         pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
     132        pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    135133        return result;
    136134}
    137135
    138 /** Return the ICMP session.
    139  *
    140  * Search the registered protocols.
    141  *
    142  * @return Found ICMP session.
    143  * @return NULL if the ICMP is not registered.
    144  *
    145  */
    146 static async_sess_t *ip_get_icmp_session(void)
    147 {
     136/** Returns the ICMP phone.
     137 *
     138 * Searches the registered protocols.
     139 *
     140 * @return              The found ICMP phone.
     141 * @return              ENOENT if the ICMP is not registered.
     142 */
     143static int ip_get_icmp_phone(void)
     144{
     145        ip_proto_t *proto;
     146        int phone;
     147
    148148        fibril_rwlock_read_lock(&ip_globals.protos_lock);
    149         ip_proto_t *proto = ip_protos_find(&ip_globals.protos, IPPROTO_ICMP);
    150         async_sess_t *sess = proto ? proto->sess : NULL;
     149        proto = ip_protos_find(&ip_globals.protos, IPPROTO_ICMP);
     150        phone = proto ? proto->phone : ENOENT;
    151151        fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    152        
    153         return sess;
     152        return phone;
    154153}
    155154
    … …  
    180179        next = pq_detach(packet);
    181180        if (next)
    182                 pq_release_remote(ip_globals.net_sess, packet_get_id(next));
     181                pq_release_remote(ip_globals.net_phone, packet_get_id(next));
    183182
    184183        if (!header) {
    … …  
    202201
    203202        /* Set the destination address */
    204         switch (GET_IP_HEADER_VERSION(header)) {
     203        switch (header->version) {
    205204        case IPVERSION:
    206205                addrlen = sizeof(dest_in);
    … …  
    219218}
    220219
    221 /** Prepare the ICMP notification packet.
    222  *
    223  * Release additional packets and keep only the first one.
     220/** Prepares the ICMP notification packet.
     221 *
     222 * Releases additional packets and keeps only the first one.
    224223 * All packets are released on error.
    225224 *
    226  * @param[in] error  Packet error service.
    227  * @param[in] packet Packet or the packet queue to be reported as faulty.
    228  * @param[in] header First packet IP header. May be NULL.
    229  *
    230  * @return Found ICMP session.
    231  * @return NULL if the error parameter is set.
    232  * @return NULL if the ICMP session is not found.
    233  * @return NULL if the ip_prepare_icmp() fails.
    234  *
    235  */
    236 static async_sess_t *ip_prepare_icmp_and_get_session(services_t error,
    237     packet_t *packet, ip_header_t *header)
    238 {
    239         async_sess_t *sess = ip_get_icmp_session();
    240        
    241         if ((error) || (!sess) || (ip_prepare_icmp(packet, header))) {
    242                 pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
    243                 return NULL;
    244         }
    245        
    246         return sess;
    247 }
    248 
    249 int il_initialize(async_sess_t *net_sess)
     225 * @param[in] error     The packet error service.
     226 * @param[in] packet    The packet or the packet queue to be reported as faulty.
     227 * @param[in] header    The first packet IP header. May be NULL.
     228 * @return              The found ICMP phone.
     229 * @return              EINVAL if the error parameter is set.
     230 * @return              EINVAL if the ICMP phone is not found.
     231 * @return              EINVAL if the ip_prepare_icmp() fails.
     232 */
     233static int
     234ip_prepare_icmp_and_get_phone(services_t error, packet_t *packet,
     235    ip_header_t *header)
     236{
     237        int phone;
     238
     239        phone = ip_get_icmp_phone();
     240        if (error || (phone < 0) || ip_prepare_icmp(packet, header))
     241                return ip_release_and_return(packet, EINVAL);
     242        return phone;
     243}
     244
     245int il_initialize(int net_phone)
    250246{
    251247        fibril_rwlock_initialize(&ip_globals.lock);
    … …  
    254250        fibril_rwlock_initialize(&ip_globals.netifs_lock);
    255251       
    256         ip_globals.net_sess = net_sess;
     252        ip_globals.net_phone = net_phone;
    257253        ip_globals.packet_counter = 0;
    258254        ip_globals.gateway.address.s_addr = 0;
    … …  
    354350        ip_netif->routing = NET_DEFAULT_IP_ROUTING;
    355351        configuration = &names[0];
    356        
     352
    357353        /* Get configuration */
    358         rc = net_get_device_conf_req(ip_globals.net_sess, ip_netif->device_id,
     354        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
    359355            &configuration, count, &data);
    360356        if (rc != EOK)
    … …  
    406402                        return ENOTSUP;
    407403                }
    408                
     404
    409405                if (configuration[6].value) {
    410406                        ip_netif->arp = get_running_module(&ip_globals.modules,
    … …  
    417413                        }
    418414                }
    419                
    420415                if (configuration[7].value)
    421416                        ip_netif->routing = (configuration[7].value[0] == 'y');
    422                
     417
    423418                net_free_settings(configuration, data);
    424419        }
    425        
     420
    426421        /* Bind netif service which also initializes the device */
    427         ip_netif->sess = nil_bind_service(ip_netif->service,
     422        ip_netif->phone = nil_bind_service(ip_netif->service,
    428423            (sysarg_t) ip_netif->device_id, SERVICE_IP,
    429424            ip_receiver);
    430         if (ip_netif->sess == NULL) {
     425        if (ip_netif->phone < 0) {
    431426                printf("Failed to contact the nil service %d\n",
    432427                    ip_netif->service);
    433                 return ENOENT;
    434         }
    435        
     428                return ip_netif->phone;
     429        }
     430
    436431        /* Has to be after the device netif module initialization */
    437432        if (ip_netif->arp) {
    … …  
    440435                        address.length = sizeof(in_addr_t);
    441436                       
    442                         rc = arp_device_req(ip_netif->arp->sess,
     437                        rc = arp_device_req(ip_netif->arp->phone,
    443438                            ip_netif->device_id, SERVICE_IP, ip_netif->service,
    444439                            &address);
    … …  
    449444                }
    450445        }
    451        
     446
    452447        /* Get packet dimensions */
    453         rc = nil_packet_size_req(ip_netif->sess, ip_netif->device_id,
     448        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
    454449            &ip_netif->packet_dimension);
    455450        if (rc != EOK)
    … …  
    462457                ip_netif->packet_dimension.content = IP_MIN_CONTENT;
    463458        }
    464        
     459
    465460        index = ip_netifs_add(&ip_globals.netifs, ip_netif->device_id, ip_netif);
    466461        if (index < 0)
    … …  
    479474                printf("%s: Default gateway (%s)\n", NAME, defgateway);
    480475        }
    481        
     476
    482477        return EOK;
    483478}
    484479
    485 static int ip_device_req_local(nic_device_id_t device_id, services_t netif)
     480static int ip_device_req_local(int il_phone, device_id_t device_id,
     481    services_t netif)
    486482{
    487483        ip_netif_t *ip_netif;
    … …  
    499495                return rc;
    500496        }
    501        
     497
    502498        ip_netif->device_id = device_id;
    503499        ip_netif->service = netif;
    504         ip_netif->state = NIC_STATE_STOPPED;
    505        
     500        ip_netif->state = NETIF_STOPPED;
     501
    506502        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    507503
    … …  
    517513
    518514        /* Print the settings */
    519         printf("%s: Device registered (id: %d, ipv: %d, conf: %s)\n",
    520             NAME, ip_netif->device_id, ip_netif->ipv,
     515        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
     516            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
    521517            ip_netif->dhcp ? "dhcp" : "static");
    522518       
    … …  
    595591        while (index >= 0) {
    596592                netif = ip_netifs_get_index(&ip_globals.netifs, index);
    597                 if (netif && (netif->state == NIC_STATE_ACTIVE)) {
     593                if (netif && (netif->state == NETIF_ACTIVE)) {
    598594                        route = ip_netif_find_route(netif, destination);
    599595                        if (route)
    … …  
    639635
    640636        /* Process all IP options */
    641         while (next < GET_IP_HEADER_LENGTH(first)) {
     637        while (next < first->header_length) {
    642638                option = (ip_option_t *) (((uint8_t *) first) + next);
    643639                /* Skip end or noop */
    … …  
    660656        if (length % 4) {
    661657                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    662                 SET_IP_HEADER_LENGTH(last, (length / 4 + 1));
     658                last->header_length = length / 4 + 1;
    663659        } else {
    664                 SET_IP_HEADER_LENGTH(last, (length / 4));
     660                last->header_length = length / 4;
    665661        }
    666662
    … …  
    710706                return rc;
    711707       
    712         SET_IP_HEADER_VERSION(header, IPV4);
    713         SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, 0);
     708        header->version = IPV4;
     709        header->fragment_offset_high = 0;
    714710        header->fragment_offset_low = 0;
    715711        header->header_checksum = 0;
    … …  
    739735                        memcpy(middle_header, last_header,
    740736                            IP_HEADER_LENGTH(last_header));
    741                         SET_IP_HEADER_FLAGS(header,
    742                             (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
     737                        header->flags |= IPFLAG_MORE_FRAGMENTS;
    743738                        middle_header->total_length =
    744739                            htons(packet_get_data_length(next));
    745                         SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
    746                             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
     740                        middle_header->fragment_offset_high =
     741                            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
    747742                        middle_header->fragment_offset_low =
    748743                            IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    773768                middle_header->total_length =
    774769                    htons(packet_get_data_length(next));
    775                 SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
    776                     IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
     770                middle_header->fragment_offset_high =
     771                    IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
    777772                middle_header->fragment_offset_low =
    778773                    IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    790785                length += packet_get_data_length(next);
    791786                free(last_header);
    792                 SET_IP_HEADER_FLAGS(header,
    793                     (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
     787                header->flags |= IPFLAG_MORE_FRAGMENTS;
    794788        }
    795789
    … …  
    840834        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
    841835        offset = IP_FRAGMENT_OFFSET(header) + IP_HEADER_DATA_LENGTH(header);
    842         SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(new_header,
    843             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset));
     836        new_header->fragment_offset_high =
     837            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset);
    844838        new_header->fragment_offset_low =
    845839            IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
    … …  
    871865                return NULL;
    872866        memcpy(middle, last, IP_HEADER_LENGTH(last));
    873         SET_IP_HEADER_FLAGS(middle,
    874             (GET_IP_HEADER_FLAGS(middle) | IPFLAG_MORE_FRAGMENTS));
     867        middle->flags |= IPFLAG_MORE_FRAGMENTS;
    875868        return middle;
    876869}
    … …  
    929922
    930923        /* Fragmentation forbidden? */
    931         if(GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT)
     924        if(header->flags & IPFLAG_DONT_FRAGMENT)
    932925                return EPERM;
    933926
    934927        /* Create the last fragment */
    935         new_packet = packet_get_4_remote(ip_globals.net_sess, prefix, length,
     928        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
    936929            suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    937930        if (!new_packet)
    … …  
    965958
    966959        /* Mark the first as fragmented */
    967         SET_IP_HEADER_FLAGS(header,
    968             (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
     960        header->flags |= IPFLAG_MORE_FRAGMENTS;
    969961
    970962        /* Create middle fragments */
    971963        while (IP_TOTAL_LENGTH(header) > length) {
    972                 new_packet = packet_get_4_remote(ip_globals.net_sess, prefix,
     964                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
    973965                    length, suffix,
    974966                    ((addrlen >= addr_len) ? addrlen : addr_len));
    … …  
    995987}
    996988
    997 /** Check the packet queue lengths and fragments the packets if needed.
     989/** Checks the packet queue lengths and fragments the packets if needed.
    998990 *
    999991 * The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to
    1000992 * be fragmented and the fragmentation is not allowed.
    1001993 *
    1002  * @param[in,out] packet   Packet or the packet queue to be checked.
    1003  * @param[in]     prefix   Minimum prefix size.
    1004  * @param[in]     content  Maximum content size.
    1005  * @param[in]     suffix   Minimum suffix size.
    1006  * @param[in]     addr_len Minimum address length.
    1007  * @param[in]     error    Error module service.
    1008  *
    1009  * @return The packet or the packet queue of the allowed length.
    1010  * @return NULL if there are no packets left.
    1011  *
    1012  */
    1013 static packet_t *ip_split_packet(packet_t *packet, size_t prefix, size_t content,
    1014     size_t suffix, socklen_t addr_len, services_t error)
     994 * @param[in,out] packet The packet or the packet queue to be checked.
     995 * @param[in] prefix    The minimum prefix size.
     996 * @param[in] content   The maximum content size.
     997 * @param[in] suffix    The minimum suffix size.
     998 * @param[in] addr_len  The minimum address length.
     999 * @param[in] error     The error module service.
     1000 * @return              The packet or the packet queue of the allowed length.
     1001 * @return              NULL if there are no packets left.
     1002 */
     1003static packet_t *
     1004ip_split_packet(packet_t *packet, size_t prefix, size_t content, size_t suffix,
     1005    socklen_t addr_len, services_t error)
    10151006{
    10161007        size_t length;
    … …  
    10181009        packet_t *new_packet;
    10191010        int result;
    1020         async_sess_t *sess;
    1021        
     1011        int phone;
     1012
    10221013        next = packet;
    10231014        /* Check all packets */
    … …  
    10411032                        /* Fragmentation needed? */
    10421033                        if (result == EPERM) {
    1043                                 sess = ip_prepare_icmp_and_get_session(error, next, NULL);
    1044                                 if (sess) {
     1034                                phone = ip_prepare_icmp_and_get_phone(
     1035                                    error, next, NULL);
     1036                                if (phone >= 0) {
    10451037                                        /* Fragmentation necessary ICMP */
    1046                                         icmp_destination_unreachable_msg(sess,
     1038                                        icmp_destination_unreachable_msg(phone,
    10471039                                            ICMP_FRAG_NEEDED, content, next);
    10481040                                }
    10491041                        } else {
    1050                                 pq_release_remote(ip_globals.net_sess,
     1042                                pq_release_remote(ip_globals.net_phone,
    10511043                                    packet_get_id(next));
    10521044                        }
    … …  
    10621054}
    10631055
    1064 /** Send the packet or the packet queue via the specified route.
     1056/** Sends the packet or the packet queue via the specified route.
    10651057 *
    10661058 * The ICMP_HOST_UNREACH error notification may be sent if route hardware
    10671059 * destination address is found.
    10681060 *
    1069  * @param[in,out] packet Packet to be sent.
    1070  * @param[in]     netif  Target network interface.
    1071  * @param[in]     route  Target route.
    1072  * @param[in]     src    Source address.
    1073  * @param[in]     dest   Destination address.
    1074  * @param[in]     error  Error module service.
    1075  *
    1076  * @return EOK on success.
    1077  * @return Other error codes as defined for arp_translate_req().
    1078  * @return Other error codes as defined for ip_prepare_packet().
    1079  *
     1061 * @param[in,out] packet The packet to be sent.
     1062 * @param[in] netif     The target network interface.
     1063 * @param[in] route     The target route.
     1064 * @param[in] src       The source address.
     1065 * @param[in] dest      The destination address.
     1066 * @param[in] error     The error module service.
     1067 * @return              EOK on success.
     1068 * @return              Other error codes as defined for the arp_translate_req()
     1069 *                      function.
     1070 * @return              Other error codes as defined for the ip_prepare_packet()
     1071 *                      function.
    10801072 */
    10811073static int ip_send_route(packet_t *packet, ip_netif_t *netif,
    … …  
    10851077        measured_string_t *translation;
    10861078        uint8_t *data;
    1087         async_sess_t *sess;
     1079        int phone;
    10881080        int rc;
    10891081
    … …  
    10941086                destination.length = sizeof(dest.s_addr);
    10951087
    1096                 rc = arp_translate_req(netif->arp->sess, netif->device_id,
     1088                rc = arp_translate_req(netif->arp->phone, netif->device_id,
    10971089                    SERVICE_IP, &destination, &translation, &data);
    10981090                if (rc != EOK) {
    1099                         pq_release_remote(ip_globals.net_sess,
     1091                        pq_release_remote(ip_globals.net_phone,
    11001092                            packet_get_id(packet));
    11011093                        return rc;
    … …  
    11071099                                free(data);
    11081100                        }
    1109                         sess = ip_prepare_icmp_and_get_session(error, packet,
     1101                        phone = ip_prepare_icmp_and_get_phone(error, packet,
    11101102                            NULL);
    1111                         if (sess) {
     1103                        if (phone >= 0) {
    11121104                                /* Unreachable ICMP if no routing */
    1113                                 icmp_destination_unreachable_msg(sess,
     1105                                icmp_destination_unreachable_msg(phone,
    11141106                                    ICMP_HOST_UNREACH, 0, packet);
    11151107                        }
    … …  
    11231115        rc = ip_prepare_packet(src, dest, packet, translation);
    11241116        if (rc != EOK) {
    1125                 pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
     1117                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    11261118        } else {
    11271119                packet = ip_split_packet(packet, netif->packet_dimension.prefix,
    … …  
    11301122                    netif->packet_dimension.addr_len, error);
    11311123                if (packet) {
    1132                         nil_send_msg(netif->sess, netif->device_id, packet,
     1124                        nil_send_msg(netif->phone, netif->device_id, packet,
    11331125                            SERVICE_IP);
    11341126                }
    … …  
    11431135}
    11441136
    1145 static int ip_send_msg_local(nic_device_id_t device_id, packet_t *packet,
    1146     services_t sender, services_t error)
     1137static int ip_send_msg_local(int il_phone, device_id_t device_id,
     1138    packet_t *packet, services_t sender, services_t error)
    11471139{
    11481140        int addrlen;
    … …  
    11531145        in_addr_t *dest;
    11541146        in_addr_t *src;
    1155         async_sess_t *sess;
     1147        int phone;
    11561148        int rc;
    11571149
    … …  
    11981190        if (!netif || !route) {
    11991191                fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    1200                 sess = ip_prepare_icmp_and_get_session(error, packet, NULL);
    1201                 if (sess) {
     1192                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
     1193                if (phone >= 0) {
    12021194                        /* Unreachable ICMP if no routing */
    1203                         icmp_destination_unreachable_msg(sess,
     1195                        icmp_destination_unreachable_msg(phone,
    12041196                            ICMP_NET_UNREACH, 0, packet);
    12051197                }
    … …  
    12291221                if (!netif || !route) {
    12301222                        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    1231                         sess = ip_prepare_icmp_and_get_session(error, packet,
     1223                        phone = ip_prepare_icmp_and_get_phone(error, packet,
    12321224                            NULL);
    1233                         if (sess) {
     1225                        if (phone >= 0) {
    12341226                                /* Unreachable ICMP if no routing */
    1235                                 icmp_destination_unreachable_msg(sess,
     1227                                icmp_destination_unreachable_msg(phone,
    12361228                                    ICMP_HOST_UNREACH, 0, packet);
    12371229                        }
    … …  
    12591251 * @return              ENOENT if device is not found.
    12601252 */
    1261 static int ip_device_state_message(nic_device_id_t device_id,
    1262     nic_device_state_t state)
     1253static int ip_device_state_message(device_id_t device_id, device_state_t state)
    12631254{
    12641255        ip_netif_t *netif;
    … …  
    12741265        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    12751266
    1276         printf("%s: Device %d changed state to '%s'\n", NAME, device_id,
    1277             nic_device_state_to_string(state));
     1267        printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
    12781268
    12791269        return EOK;
    … …  
    13151305 *                      tl_received_msg() function.
    13161306 */
    1317 static int ip_deliver_local(nic_device_id_t device_id, packet_t *packet,
     1307static int ip_deliver_local(device_id_t device_id, packet_t *packet,
    13181308    ip_header_t *header, services_t error)
    13191309{
    13201310        ip_proto_t *proto;
    1321         async_sess_t *sess;
     1311        int phone;
    13221312        services_t service;
    13231313        tl_received_msg_t received_msg;
    … …  
    13291319        int rc;
    13301320
    1331         if ((GET_IP_HEADER_FLAGS(header) & IPFLAG_MORE_FRAGMENTS) ||
     1321        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
    13321322            IP_FRAGMENT_OFFSET(header)) {
    13331323                // TODO fragmented
    … …  
    13351325        }
    13361326       
    1337         switch (GET_IP_HEADER_VERSION(header)) {
     1327        switch (header->version) {
    13381328        case IPVERSION:
    13391329                addrlen = sizeof(src_in);
    … …  
    13721362        if (!proto) {
    13731363                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    1374                 sess = ip_prepare_icmp_and_get_session(error, packet, header);
    1375                 if (sess) {
     1364                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
     1365                if (phone >= 0) {
    13761366                        /* Unreachable ICMP */
    1377                         icmp_destination_unreachable_msg(sess,
     1367                        icmp_destination_unreachable_msg(phone,
    13781368                            ICMP_PROT_UNREACH, 0, packet);
    13791369                }
    … …  
    13871377                rc = received_msg(device_id, packet, service, error);
    13881378        } else {
    1389                 rc = tl_received_msg(proto->sess, device_id, packet,
     1379                rc = tl_received_msg(proto->phone, device_id, packet,
    13901380                    proto->service, error);
    13911381                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    … …  
    14161406 *                      is disabled.
    14171407 */
    1418 static int ip_process_packet(nic_device_id_t device_id, packet_t *packet)
     1408static int ip_process_packet(device_id_t device_id, packet_t *packet)
    14191409{
    14201410        ip_header_t *header;
    14211411        in_addr_t dest;
    14221412        ip_route_t *route;
    1423         async_sess_t *sess;
     1413        int phone;
    14241414        struct sockaddr *addr;
    14251415        struct sockaddr_in addr_in;
    … …  
    14341424        if ((header->header_checksum) &&
    14351425            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
    1436                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1437                 if (sess) {
     1426                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1427                if (phone >= 0) {
    14381428                        /* Checksum error ICMP */
    1439                         icmp_parameter_problem_msg(sess, ICMP_PARAM_POINTER,
     1429                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
    14401430                            ((size_t) ((void *) &header->header_checksum)) -
    14411431                            ((size_t) ((void *) header)), packet);
    … …  
    14451435
    14461436        if (header->ttl <= 1) {
    1447                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1448                 if (sess) {
     1437                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1438                if (phone >= 0) {
    14491439                        /* TTL exceeded ICMP */
    1450                         icmp_time_exceeded_msg(sess, ICMP_EXC_TTL, packet);
     1440                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14511441                }
    14521442                return EINVAL;
    … …  
    14571447
    14581448        /* Set the destination address */
    1459         switch (GET_IP_HEADER_VERSION(header)) {
     1449        switch (header->version) {
    14601450        case IPVERSION:
    14611451                addrlen = sizeof(addr_in);
    … …  
    14761466        route = ip_find_route(dest);
    14771467        if (!route) {
    1478                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1479                 if (sess) {
     1468                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1469                if (phone >= 0) {
    14801470                        /* Unreachable ICMP */
    1481                         icmp_destination_unreachable_msg(sess,
     1471                        icmp_destination_unreachable_msg(phone,
    14821472                            ICMP_HOST_UNREACH, 0, packet);
    14831473                }
    … …  
    14961486        }
    14971487
    1498         sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1499         if (sess) {
     1488        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1489        if (phone >= 0) {
    15001490                /* Unreachable ICMP if no routing */
    1501                 icmp_destination_unreachable_msg(sess, ICMP_HOST_UNREACH, 0,
     1491                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
    15021492                    packet);
    15031493        }
    … …  
    15061496}
    15071497
    1508 /** Return the device packet dimensions for sending.
    1509  *
    1510  * @param[in]  device_id Device identifier.
    1511  * @param[out] addr_len  Minimum reserved address length.
    1512  * @param[out] prefix    Minimum reserved prefix size.
    1513  * @param[out] content   Maximum content size.
    1514  * @param[out] suffix    Minimum reserved suffix size.
    1515  *
    1516  * @return EOK on success.
    1517  *
    1518  */
    1519 static int ip_packet_size_message(nic_device_id_t device_id, size_t *addr_len,
     1498/** Returns the device packet dimensions for sending.
     1499 *
     1500 * @param[in] phone     The service module phone.
     1501 * @param[in] message   The service specific message.
     1502 * @param[in] device_id The device identifier.
     1503 * @param[out] addr_len The minimum reserved address length.
     1504 * @param[out] prefix   The minimum reserved prefix size.
     1505 * @param[out] content  The maximum content size.
     1506 * @param[out] suffix   The minimum reserved suffix size.
     1507 * @return              EOK on success.
     1508 */
     1509static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
    15201510    size_t *prefix, size_t *content, size_t *suffix)
    15211511{
    … …  
    15751565 * @return              ENOENT if device is not found.
    15761566 */
    1577 static int ip_mtu_changed_message(nic_device_id_t device_id, size_t mtu)
     1567static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
    15781568{
    15791569        ip_netif_t *netif;
    … …  
    15971587 * @param[in]     iid   Message identifier.
    15981588 * @param[in,out] icall Message parameters.
    1599  * @param[in]     arg   Local argument.
    1600  *
    1601  */
    1602 static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     1589 *
     1590 */
     1591static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall)
    16031592{
    16041593        packet_t *packet;
    … …  
    16141603               
    16151604                case NET_IL_RECEIVED:
    1616                         rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1605                        rc = packet_translate_remote(ip_globals.net_phone, &packet,
    16171606                            IPC_GET_PACKET(*icall));
    16181607                        if (rc == EOK) {
    … …  
    16321621                        async_answer_0(iid, (sysarg_t) rc);
    16331622                        break;
    1634                 case NET_IL_ADDR_CHANGED:
    1635                         async_answer_0(iid, (sysarg_t) EOK);
    1636                         break;
    1637 
     1623               
    16381624                default:
    16391625                        async_answer_0(iid, (sysarg_t) ENOTSUP);
    … …  
    16441630}
    16451631
    1646 /** Register the transport layer protocol.
     1632/** Registers the transport layer protocol.
    16471633 *
    16481634 * The traffic of this protocol will be supplied using either the receive
    16491635 * function or IPC message.
    16501636 *
    1651  * @param[in] protocol     Transport layer module protocol.
    1652  * @param[in] service      Transport layer module service.
    1653  * @param[in] sess         Transport layer module session.
    1654  * @param[in] received_msg Receiving function.
    1655  *
    1656  * @return EOK on success.
    1657  * @return EINVAL if the protocol parameter and/or the service
    1658  *         parameter is zero.
    1659  * @return EINVAL if the phone parameter is not a positive number
    1660  *         and the tl_receive_msg is NULL.
    1661  * @return ENOMEM if there is not enough memory left.
    1662  *
    1663  */
    1664 static int ip_register(int protocol, services_t service, async_sess_t *sess,
     1637 * @param[in] protocol  The transport layer module protocol.
     1638 * @param[in] service   The transport layer module service.
     1639 * @param[in] phone     The transport layer module phone.
     1640 * @param[in] received_msg The receiving function.
     1641 * @return              EOK on success.
     1642 * @return              EINVAL if the protocol parameter and/or the service
     1643 *                      parameter is zero.
     1644 * @return              EINVAL if the phone parameter is not a positive number
     1645 *                      and the tl_receive_msg is NULL.
     1646 * @return              ENOMEM if there is not enough memory left.
     1647 */
     1648static int
     1649ip_register(int protocol, services_t service, int phone,
    16651650    tl_received_msg_t received_msg)
    16661651{
    … …  
    16681653        int index;
    16691654
    1670         if ((!protocol) || (!service) || ((!sess) && (!received_msg)))
     1655        if (!protocol || !service || ((phone < 0) && !received_msg))
    16711656                return EINVAL;
    1672        
     1657
    16731658        proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
    16741659        if (!proto)
    … …  
    16771662        proto->protocol = protocol;
    16781663        proto->service = service;
    1679         proto->sess = sess;
     1664        proto->phone = phone;
    16801665        proto->received_msg = received_msg;
    16811666
    … …  
    16891674        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
    16901675
    1691         printf("%s: Protocol registered (protocol: %d)\n",
    1692             NAME, proto->protocol);
     1676        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
     1677            NAME, proto->protocol, proto->phone);
    16931678
    16941679        return EOK;
    16951680}
    16961681
    1697 static int ip_add_route_req_local(nic_device_id_t device_id, in_addr_t address,
     1682
     1683static int
     1684ip_add_route_req_local(int ip_phone, device_id_t device_id, in_addr_t address,
    16981685    in_addr_t netmask, in_addr_t gateway)
    16991686{
    … …  
    17291716}
    17301717
    1731 static int ip_set_gateway_req_local(nic_device_id_t device_id,
    1732     in_addr_t gateway)
     1718static int
     1719ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
    17331720{
    17341721        ip_netif_t *netif;
    … …  
    17541741/** Notify the IP module about the received error notification packet.
    17551742 *
    1756  * @param[in] device_id Device identifier.
    1757  * @param[in] packet    Received packet or the received packet queue.
    1758  * @param[in] target    Target internetwork module service to be
    1759  *                      delivered to.
    1760  * @param[in] error     Packet error reporting service. Prefixes the
    1761  *                      received packet.
    1762  *
    1763  * @return EOK on success.
    1764  *
    1765  */
    1766 static int ip_received_error_msg_local(nic_device_id_t device_id,
     1743 * @param[in] ip_phone  The IP module phone used for (semi)remote calls.
     1744 * @param[in] device_id The device identifier.
     1745 * @param[in] packet    The received packet or the received packet queue.
     1746 * @param[in] target    The target internetwork module service to be
     1747 *                      delivered to.
     1748 * @param[in] error     The packet error reporting service. Prefixes the
     1749 *                      received packet.
     1750 * @return              EOK on success.
     1751 *
     1752 */
     1753static int
     1754ip_received_error_msg_local(int ip_phone, device_id_t device_id,
    17671755    packet_t *packet, services_t target, services_t error)
    17681756{
    … …  
    18091797                        address.value = (uint8_t *) &header->destination_address;
    18101798                        address.length = sizeof(header->destination_address);
    1811                         arp_clear_address_req(netif->arp->sess,
     1799                        arp_clear_address_req(netif->arp->phone,
    18121800                            netif->device_id, SERVICE_IP, &address);
    18131801                }
    … …  
    18231811}
    18241812
    1825 static int ip_get_route_req_local(ip_protocol_t protocol,
     1813static int
     1814ip_get_route_req_local(int ip_phone, ip_protocol_t protocol,
    18261815    const struct sockaddr *destination, socklen_t addrlen,
    1827     nic_device_id_t *device_id, void **header, size_t *headerlen)
     1816    device_id_t *device_id, void **header, size_t *headerlen)
    18281817{
    18291818        struct sockaddr_in *address_in;
    … …  
    19161905        size_t suffix;
    19171906        size_t content;
    1918         nic_device_id_t device_id;
     1907        device_id_t device_id;
    19191908        int rc;
    19201909       
    19211910        *answer_count = 0;
    1922        
    1923         if (!IPC_GET_IMETHOD(*call))
     1911        switch (IPC_GET_IMETHOD(*call)) {
     1912        case IPC_M_PHONE_HUNGUP:
    19241913                return EOK;
    19251914       
    1926         async_sess_t *callback =
    1927             async_callback_receive_start(EXCHANGE_SERIALIZE, call);
    1928         if (callback)
     1915        case IPC_M_CONNECT_TO_ME:
    19291916                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
    1930                     callback, NULL);
    1931        
    1932         switch (IPC_GET_IMETHOD(*call)) {
     1917                    IPC_GET_PHONE(*call), NULL);
     1918       
    19331919        case NET_IP_DEVICE:
    1934                 return ip_device_req_local(IPC_GET_DEVICE(*call),
     1920                return ip_device_req_local(0, IPC_GET_DEVICE(*call),
    19351921                    IPC_GET_SERVICE(*call));
    19361922       
    19371923        case NET_IP_RECEIVED_ERROR:
    1938                 rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1924                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    19391925                    IPC_GET_PACKET(*call));
    19401926                if (rc != EOK)
    19411927                        return rc;
    1942                 return ip_received_error_msg_local(IPC_GET_DEVICE(*call),
     1928                return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
    19431929                    packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call));
    19441930       
    19451931        case NET_IP_ADD_ROUTE:
    1946                 return ip_add_route_req_local(IPC_GET_DEVICE(*call),
     1932                return ip_add_route_req_local(0, IPC_GET_DEVICE(*call),
    19471933                    IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call),
    19481934                    IP_GET_GATEWAY(*call));
    19491935
    19501936        case NET_IP_SET_GATEWAY:
    1951                 return ip_set_gateway_req_local(IPC_GET_DEVICE(*call),
     1937                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call),
    19521938                    IP_GET_GATEWAY(*call));
    19531939
    … …  
    19581944                        return rc;
    19591945               
    1960                 rc = ip_get_route_req_local(IP_GET_PROTOCOL(*call), addr,
     1946                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
    19611947                    (socklen_t) addrlen, &device_id, &header, &headerlen);
    19621948                if (rc != EOK)
    … …  
    19891975       
    19901976        case NET_IP_SEND:
    1991                 rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1977                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    19921978                    IPC_GET_PACKET(*call));
    19931979                if (rc != EOK)
    19941980                        return rc;
    19951981               
    1996                 return ip_send_msg_local(IPC_GET_DEVICE(*call), packet, 0,
     1982                return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
    19971983                    IPC_GET_ERROR(*call));
    19981984        }
Note: See TracChangeset for help on using the changeset viewer.