Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6b82009 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;
    … …  
    356352
    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)
    … …  
    424420
    425421        /* Bind netif service which also initializes the device */
    426         ip_netif->sess = nil_bind_service(ip_netif->service,
     422        ip_netif->phone = nil_bind_service(ip_netif->service,
    427423            (sysarg_t) ip_netif->device_id, SERVICE_IP,
    428424            ip_receiver);
    429         if (ip_netif->sess == NULL) {
     425        if (ip_netif->phone < 0) {
    430426                printf("Failed to contact the nil service %d\n",
    431427                    ip_netif->service);
    432                 return ENOENT;
     428                return ip_netif->phone;
    433429        }
    434430
    … …  
    439435                        address.length = sizeof(in_addr_t);
    440436                       
    441                         rc = arp_device_req(ip_netif->arp->sess,
     437                        rc = arp_device_req(ip_netif->arp->phone,
    442438                            ip_netif->device_id, SERVICE_IP, ip_netif->service,
    443439                            &address);
    … …  
    450446
    451447        /* Get packet dimensions */
    452         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,
    453449            &ip_netif->packet_dimension);
    454450        if (rc != EOK)
    … …  
    482478}
    483479
    484 static int ip_device_req_local(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)
    485482{
    486483        ip_netif_t *ip_netif;
    … …  
    516513
    517514        /* Print the settings */
    518         printf("%s: Device registered (id: %d, ipv: %d, conf: %s)\n",
    519             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,
    520517            ip_netif->dhcp ? "dhcp" : "static");
    521518       
    … …  
    638635
    639636        /* Process all IP options */
    640         while (next < GET_IP_HEADER_LENGTH(first)) {
     637        while (next < first->header_length) {
    641638                option = (ip_option_t *) (((uint8_t *) first) + next);
    642639                /* Skip end or noop */
    … …  
    659656        if (length % 4) {
    660657                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    661                 SET_IP_HEADER_LENGTH(last, (length / 4 + 1));
     658                last->header_length = length / 4 + 1;
    662659        } else {
    663                 SET_IP_HEADER_LENGTH(last, (length / 4));
     660                last->header_length = length / 4;
    664661        }
    665662
    … …  
    709706                return rc;
    710707       
    711         SET_IP_HEADER_VERSION(header, IPV4);
    712         SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, 0);
     708        header->version = IPV4;
     709        header->fragment_offset_high = 0;
    713710        header->fragment_offset_low = 0;
    714711        header->header_checksum = 0;
    … …  
    738735                        memcpy(middle_header, last_header,
    739736                            IP_HEADER_LENGTH(last_header));
    740                         SET_IP_HEADER_FLAGS(header,
    741                             (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
     737                        header->flags |= IPFLAG_MORE_FRAGMENTS;
    742738                        middle_header->total_length =
    743739                            htons(packet_get_data_length(next));
    744                         SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
    745                             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
     740                        middle_header->fragment_offset_high =
     741                            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
    746742                        middle_header->fragment_offset_low =
    747743                            IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    772768                middle_header->total_length =
    773769                    htons(packet_get_data_length(next));
    774                 SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
    775                     IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
     770                middle_header->fragment_offset_high =
     771                    IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
    776772                middle_header->fragment_offset_low =
    777773                    IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    789785                length += packet_get_data_length(next);
    790786                free(last_header);
    791                 SET_IP_HEADER_FLAGS(header,
    792                     (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
     787                header->flags |= IPFLAG_MORE_FRAGMENTS;
    793788        }
    794789
    … …  
    839834        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
    840835        offset = IP_FRAGMENT_OFFSET(header) + IP_HEADER_DATA_LENGTH(header);
    841         SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(new_header,
    842             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset));
     836        new_header->fragment_offset_high =
     837            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset);
    843838        new_header->fragment_offset_low =
    844839            IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
    … …  
    870865                return NULL;
    871866        memcpy(middle, last, IP_HEADER_LENGTH(last));
    872         SET_IP_HEADER_FLAGS(middle,
    873             (GET_IP_HEADER_FLAGS(middle) | IPFLAG_MORE_FRAGMENTS));
     867        middle->flags |= IPFLAG_MORE_FRAGMENTS;
    874868        return middle;
    875869}
    … …  
    928922
    929923        /* Fragmentation forbidden? */
    930         if(GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT)
     924        if(header->flags & IPFLAG_DONT_FRAGMENT)
    931925                return EPERM;
    932926
    933927        /* Create the last fragment */
    934         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,
    935929            suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    936930        if (!new_packet)
    … …  
    964958
    965959        /* Mark the first as fragmented */
    966         SET_IP_HEADER_FLAGS(header,
    967             (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
     960        header->flags |= IPFLAG_MORE_FRAGMENTS;
    968961
    969962        /* Create middle fragments */
    970963        while (IP_TOTAL_LENGTH(header) > length) {
    971                 new_packet = packet_get_4_remote(ip_globals.net_sess, prefix,
     964                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
    972965                    length, suffix,
    973966                    ((addrlen >= addr_len) ? addrlen : addr_len));
    … …  
    994987}
    995988
    996 /** Check the packet queue lengths and fragments the packets if needed.
     989/** Checks the packet queue lengths and fragments the packets if needed.
    997990 *
    998991 * The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to
    999992 * be fragmented and the fragmentation is not allowed.
    1000993 *
    1001  * @param[in,out] packet   Packet or the packet queue to be checked.
    1002  * @param[in]     prefix   Minimum prefix size.
    1003  * @param[in]     content  Maximum content size.
    1004  * @param[in]     suffix   Minimum suffix size.
    1005  * @param[in]     addr_len Minimum address length.
    1006  * @param[in]     error    Error module service.
    1007  *
    1008  * @return The packet or the packet queue of the allowed length.
    1009  * @return NULL if there are no packets left.
    1010  *
    1011  */
    1012 static packet_t *ip_split_packet(packet_t *packet, size_t prefix, size_t content,
    1013     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)
    10141006{
    10151007        size_t length;
    … …  
    10171009        packet_t *new_packet;
    10181010        int result;
    1019         async_sess_t *sess;
    1020        
     1011        int phone;
     1012
    10211013        next = packet;
    10221014        /* Check all packets */
    … …  
    10401032                        /* Fragmentation needed? */
    10411033                        if (result == EPERM) {
    1042                                 sess = ip_prepare_icmp_and_get_session(error, next, NULL);
    1043                                 if (sess) {
     1034                                phone = ip_prepare_icmp_and_get_phone(
     1035                                    error, next, NULL);
     1036                                if (phone >= 0) {
    10441037                                        /* Fragmentation necessary ICMP */
    1045                                         icmp_destination_unreachable_msg(sess,
     1038                                        icmp_destination_unreachable_msg(phone,
    10461039                                            ICMP_FRAG_NEEDED, content, next);
    10471040                                }
    10481041                        } else {
    1049                                 pq_release_remote(ip_globals.net_sess,
     1042                                pq_release_remote(ip_globals.net_phone,
    10501043                                    packet_get_id(next));
    10511044                        }
    … …  
    10611054}
    10621055
    1063 /** Send the packet or the packet queue via the specified route.
     1056/** Sends the packet or the packet queue via the specified route.
    10641057 *
    10651058 * The ICMP_HOST_UNREACH error notification may be sent if route hardware
    10661059 * destination address is found.
    10671060 *
    1068  * @param[in,out] packet Packet to be sent.
    1069  * @param[in]     netif  Target network interface.
    1070  * @param[in]     route  Target route.
    1071  * @param[in]     src    Source address.
    1072  * @param[in]     dest   Destination address.
    1073  * @param[in]     error  Error module service.
    1074  *
    1075  * @return EOK on success.
    1076  * @return Other error codes as defined for arp_translate_req().
    1077  * @return Other error codes as defined for ip_prepare_packet().
    1078  *
     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.
    10791072 */
    10801073static int ip_send_route(packet_t *packet, ip_netif_t *netif,
    … …  
    10841077        measured_string_t *translation;
    10851078        uint8_t *data;
    1086         async_sess_t *sess;
     1079        int phone;
    10871080        int rc;
    10881081
    … …  
    10931086                destination.length = sizeof(dest.s_addr);
    10941087
    1095                 rc = arp_translate_req(netif->arp->sess, netif->device_id,
     1088                rc = arp_translate_req(netif->arp->phone, netif->device_id,
    10961089                    SERVICE_IP, &destination, &translation, &data);
    10971090                if (rc != EOK) {
    1098                         pq_release_remote(ip_globals.net_sess,
     1091                        pq_release_remote(ip_globals.net_phone,
    10991092                            packet_get_id(packet));
    11001093                        return rc;
    … …  
    11061099                                free(data);
    11071100                        }
    1108                         sess = ip_prepare_icmp_and_get_session(error, packet,
     1101                        phone = ip_prepare_icmp_and_get_phone(error, packet,
    11091102                            NULL);
    1110                         if (sess) {
     1103                        if (phone >= 0) {
    11111104                                /* Unreachable ICMP if no routing */
    1112                                 icmp_destination_unreachable_msg(sess,
     1105                                icmp_destination_unreachable_msg(phone,
    11131106                                    ICMP_HOST_UNREACH, 0, packet);
    11141107                        }
    … …  
    11221115        rc = ip_prepare_packet(src, dest, packet, translation);
    11231116        if (rc != EOK) {
    1124                 pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
     1117                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    11251118        } else {
    11261119                packet = ip_split_packet(packet, netif->packet_dimension.prefix,
    … …  
    11291122                    netif->packet_dimension.addr_len, error);
    11301123                if (packet) {
    1131                         nil_send_msg(netif->sess, netif->device_id, packet,
     1124                        nil_send_msg(netif->phone, netif->device_id, packet,
    11321125                            SERVICE_IP);
    11331126                }
    … …  
    11421135}
    11431136
    1144 static int ip_send_msg_local(device_id_t device_id, packet_t *packet,
    1145     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)
    11461139{
    11471140        int addrlen;
    … …  
    11521145        in_addr_t *dest;
    11531146        in_addr_t *src;
    1154         async_sess_t *sess;
     1147        int phone;
    11551148        int rc;
    11561149
    … …  
    11971190        if (!netif || !route) {
    11981191                fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    1199                 sess = ip_prepare_icmp_and_get_session(error, packet, NULL);
    1200                 if (sess) {
     1192                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
     1193                if (phone >= 0) {
    12011194                        /* Unreachable ICMP if no routing */
    1202                         icmp_destination_unreachable_msg(sess,
     1195                        icmp_destination_unreachable_msg(phone,
    12031196                            ICMP_NET_UNREACH, 0, packet);
    12041197                }
    … …  
    12281221                if (!netif || !route) {
    12291222                        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    1230                         sess = ip_prepare_icmp_and_get_session(error, packet,
     1223                        phone = ip_prepare_icmp_and_get_phone(error, packet,
    12311224                            NULL);
    1232                         if (sess) {
     1225                        if (phone >= 0) {
    12331226                                /* Unreachable ICMP if no routing */
    1234                                 icmp_destination_unreachable_msg(sess,
     1227                                icmp_destination_unreachable_msg(phone,
    12351228                                    ICMP_HOST_UNREACH, 0, packet);
    12361229                        }
    … …  
    13161309{
    13171310        ip_proto_t *proto;
    1318         async_sess_t *sess;
     1311        int phone;
    13191312        services_t service;
    13201313        tl_received_msg_t received_msg;
    … …  
    13261319        int rc;
    13271320
    1328         if ((GET_IP_HEADER_FLAGS(header) & IPFLAG_MORE_FRAGMENTS) ||
     1321        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
    13291322            IP_FRAGMENT_OFFSET(header)) {
    13301323                // TODO fragmented
    … …  
    13321325        }
    13331326       
    1334         switch (GET_IP_HEADER_VERSION(header)) {
     1327        switch (header->version) {
    13351328        case IPVERSION:
    13361329                addrlen = sizeof(src_in);
    … …  
    13691362        if (!proto) {
    13701363                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    1371                 sess = ip_prepare_icmp_and_get_session(error, packet, header);
    1372                 if (sess) {
     1364                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
     1365                if (phone >= 0) {
    13731366                        /* Unreachable ICMP */
    1374                         icmp_destination_unreachable_msg(sess,
     1367                        icmp_destination_unreachable_msg(phone,
    13751368                            ICMP_PROT_UNREACH, 0, packet);
    13761369                }
    … …  
    13841377                rc = received_msg(device_id, packet, service, error);
    13851378        } else {
    1386                 rc = tl_received_msg(proto->sess, device_id, packet,
     1379                rc = tl_received_msg(proto->phone, device_id, packet,
    13871380                    proto->service, error);
    13881381                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    … …  
    14181411        in_addr_t dest;
    14191412        ip_route_t *route;
    1420         async_sess_t *sess;
     1413        int phone;
    14211414        struct sockaddr *addr;
    14221415        struct sockaddr_in addr_in;
    … …  
    14311424        if ((header->header_checksum) &&
    14321425            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
    1433                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1434                 if (sess) {
     1426                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1427                if (phone >= 0) {
    14351428                        /* Checksum error ICMP */
    1436                         icmp_parameter_problem_msg(sess, ICMP_PARAM_POINTER,
     1429                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
    14371430                            ((size_t) ((void *) &header->header_checksum)) -
    14381431                            ((size_t) ((void *) header)), packet);
    … …  
    14421435
    14431436        if (header->ttl <= 1) {
    1444                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1445                 if (sess) {
     1437                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1438                if (phone >= 0) {
    14461439                        /* TTL exceeded ICMP */
    1447                         icmp_time_exceeded_msg(sess, ICMP_EXC_TTL, packet);
     1440                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14481441                }
    14491442                return EINVAL;
    … …  
    14541447
    14551448        /* Set the destination address */
    1456         switch (GET_IP_HEADER_VERSION(header)) {
     1449        switch (header->version) {
    14571450        case IPVERSION:
    14581451                addrlen = sizeof(addr_in);
    … …  
    14731466        route = ip_find_route(dest);
    14741467        if (!route) {
    1475                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1476                 if (sess) {
     1468                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1469                if (phone >= 0) {
    14771470                        /* Unreachable ICMP */
    1478                         icmp_destination_unreachable_msg(sess,
     1471                        icmp_destination_unreachable_msg(phone,
    14791472                            ICMP_HOST_UNREACH, 0, packet);
    14801473                }
    … …  
    14931486        }
    14941487
    1495         sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1496         if (sess) {
     1488        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1489        if (phone >= 0) {
    14971490                /* Unreachable ICMP if no routing */
    1498                 icmp_destination_unreachable_msg(sess, ICMP_HOST_UNREACH, 0,
     1491                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
    14991492                    packet);
    15001493        }
    … …  
    15031496}
    15041497
    1505 /** Return the device packet dimensions for sending.
    1506  *
    1507  * @param[in]  device_id Device identifier.
    1508  * @param[out] addr_len  Minimum reserved address length.
    1509  * @param[out] prefix    Minimum reserved prefix size.
    1510  * @param[out] content   Maximum content size.
    1511  * @param[out] suffix    Minimum reserved suffix size.
    1512  *
    1513  * @return EOK on success.
    1514  *
     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.
    15151508 */
    15161509static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
    … …  
    15941587 * @param[in]     iid   Message identifier.
    15951588 * @param[in,out] icall Message parameters.
    1596  * @param[in]     arg   Local argument.
    1597  *
    1598  */
    1599 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)
    16001592{
    16011593        packet_t *packet;
    … …  
    16111603               
    16121604                case NET_IL_RECEIVED:
    1613                         rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1605                        rc = packet_translate_remote(ip_globals.net_phone, &packet,
    16141606                            IPC_GET_PACKET(*icall));
    16151607                        if (rc == EOK) {
    … …  
    16381630}
    16391631
    1640 /** Register the transport layer protocol.
     1632/** Registers the transport layer protocol.
    16411633 *
    16421634 * The traffic of this protocol will be supplied using either the receive
    16431635 * function or IPC message.
    16441636 *
    1645  * @param[in] protocol     Transport layer module protocol.
    1646  * @param[in] service      Transport layer module service.
    1647  * @param[in] sess         Transport layer module session.
    1648  * @param[in] received_msg Receiving function.
    1649  *
    1650  * @return EOK on success.
    1651  * @return EINVAL if the protocol parameter and/or the service
    1652  *         parameter is zero.
    1653  * @return EINVAL if the phone parameter is not a positive number
    1654  *         and the tl_receive_msg is NULL.
    1655  * @return ENOMEM if there is not enough memory left.
    1656  *
    1657  */
    1658 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,
    16591650    tl_received_msg_t received_msg)
    16601651{
    … …  
    16621653        int index;
    16631654
    1664         if ((!protocol) || (!service) || ((!sess) && (!received_msg)))
     1655        if (!protocol || !service || ((phone < 0) && !received_msg))
    16651656                return EINVAL;
    1666        
     1657
    16671658        proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
    16681659        if (!proto)
    … …  
    16711662        proto->protocol = protocol;
    16721663        proto->service = service;
    1673         proto->sess = sess;
     1664        proto->phone = phone;
    16741665        proto->received_msg = received_msg;
    16751666
    … …  
    16831674        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
    16841675
    1685         printf("%s: Protocol registered (protocol: %d)\n",
    1686             NAME, proto->protocol);
     1676        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
     1677            NAME, proto->protocol, proto->phone);
    16871678
    16881679        return EOK;
    16891680}
    16901681
    1691 static int ip_add_route_req_local(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,
    16921685    in_addr_t netmask, in_addr_t gateway)
    16931686{
    … …  
    17231716}
    17241717
    1725 static int ip_set_gateway_req_local(device_id_t device_id, in_addr_t gateway)
     1718static int
     1719ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
    17261720{
    17271721        ip_netif_t *netif;
    … …  
    17471741/** Notify the IP module about the received error notification packet.
    17481742 *
    1749  * @param[in] device_id Device identifier.
    1750  * @param[in] packet    Received packet or the received packet queue.
    1751  * @param[in] target    Target internetwork module service to be
    1752  *                      delivered to.
    1753  * @param[in] error     Packet error reporting service. Prefixes the
    1754  *                      received packet.
    1755  *
    1756  * @return EOK on success.
    1757  *
    1758  */
    1759 static int ip_received_error_msg_local(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,
    17601755    packet_t *packet, services_t target, services_t error)
    17611756{
    … …  
    18021797                        address.value = (uint8_t *) &header->destination_address;
    18031798                        address.length = sizeof(header->destination_address);
    1804                         arp_clear_address_req(netif->arp->sess,
     1799                        arp_clear_address_req(netif->arp->phone,
    18051800                            netif->device_id, SERVICE_IP, &address);
    18061801                }
    … …  
    18161811}
    18171812
    1818 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,
    18191815    const struct sockaddr *destination, socklen_t addrlen,
    18201816    device_id_t *device_id, void **header, size_t *headerlen)
    … …  
    19131909       
    19141910        *answer_count = 0;
    1915        
    1916         if (!IPC_GET_IMETHOD(*call))
     1911        switch (IPC_GET_IMETHOD(*call)) {
     1912        case IPC_M_PHONE_HUNGUP:
    19171913                return EOK;
    19181914       
    1919         async_sess_t *callback =
    1920             async_callback_receive_start(EXCHANGE_SERIALIZE, call);
    1921         if (callback)
     1915        case IPC_M_CONNECT_TO_ME:
    19221916                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
    1923                     callback, NULL);
    1924        
    1925         switch (IPC_GET_IMETHOD(*call)) {
     1917                    IPC_GET_PHONE(*call), NULL);
     1918       
    19261919        case NET_IP_DEVICE:
    1927                 return ip_device_req_local(IPC_GET_DEVICE(*call),
     1920                return ip_device_req_local(0, IPC_GET_DEVICE(*call),
    19281921                    IPC_GET_SERVICE(*call));
    19291922       
    19301923        case NET_IP_RECEIVED_ERROR:
    1931                 rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1924                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    19321925                    IPC_GET_PACKET(*call));
    19331926                if (rc != EOK)
    19341927                        return rc;
    1935                 return ip_received_error_msg_local(IPC_GET_DEVICE(*call),
     1928                return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
    19361929                    packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call));
    19371930       
    19381931        case NET_IP_ADD_ROUTE:
    1939                 return ip_add_route_req_local(IPC_GET_DEVICE(*call),
     1932                return ip_add_route_req_local(0, IPC_GET_DEVICE(*call),
    19401933                    IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call),
    19411934                    IP_GET_GATEWAY(*call));
    19421935
    19431936        case NET_IP_SET_GATEWAY:
    1944                 return ip_set_gateway_req_local(IPC_GET_DEVICE(*call),
     1937                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call),
    19451938                    IP_GET_GATEWAY(*call));
    19461939
    … …  
    19511944                        return rc;
    19521945               
    1953                 rc = ip_get_route_req_local(IP_GET_PROTOCOL(*call), addr,
     1946                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
    19541947                    (socklen_t) addrlen, &device_id, &header, &headerlen);
    19551948                if (rc != EOK)
    … …  
    19821975       
    19831976        case NET_IP_SEND:
    1984                 rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1977                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    19851978                    IPC_GET_PACKET(*call));
    19861979                if (rc != EOK)
    19871980                        return rc;
    19881981               
    1989                 return ip_send_msg_local(IPC_GET_DEVICE(*call), packet, 0,
     1982                return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
    19901983                    IPC_GET_ERROR(*call));
    19911984        }
Note: See TracChangeset for help on using the changeset viewer.