Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6b82009 r7bf12387  
    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) {
    … …  
    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       
    … …  
    932929
    933930        /* Create the last fragment */
    934         new_packet = packet_get_4_remote(ip_globals.net_sess, prefix, length,
     931        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
    935932            suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    936933        if (!new_packet)
    … …  
    969966        /* Create middle fragments */
    970967        while (IP_TOTAL_LENGTH(header) > length) {
    971                 new_packet = packet_get_4_remote(ip_globals.net_sess, prefix,
     968                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
    972969                    length, suffix,
    973970                    ((addrlen >= addr_len) ? addrlen : addr_len));
    … …  
    994991}
    995992
    996 /** Check the packet queue lengths and fragments the packets if needed.
     993/** Checks the packet queue lengths and fragments the packets if needed.
    997994 *
    998995 * The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to
    999996 * be fragmented and the fragmentation is not allowed.
    1000997 *
    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)
     998 * @param[in,out] packet The packet or the packet queue to be checked.
     999 * @param[in] prefix    The minimum prefix size.
     1000 * @param[in] content   The maximum content size.
     1001 * @param[in] suffix    The minimum suffix size.
     1002 * @param[in] addr_len  The minimum address length.
     1003 * @param[in] error     The error module service.
     1004 * @return              The packet or the packet queue of the allowed length.
     1005 * @return              NULL if there are no packets left.
     1006 */
     1007static packet_t *
     1008ip_split_packet(packet_t *packet, size_t prefix, size_t content, size_t suffix,
     1009    socklen_t addr_len, services_t error)
    10141010{
    10151011        size_t length;
    … …  
    10171013        packet_t *new_packet;
    10181014        int result;
    1019         async_sess_t *sess;
    1020        
     1015        int phone;
     1016
    10211017        next = packet;
    10221018        /* Check all packets */
    … …  
    10401036                        /* Fragmentation needed? */
    10411037                        if (result == EPERM) {
    1042                                 sess = ip_prepare_icmp_and_get_session(error, next, NULL);
    1043                                 if (sess) {
     1038                                phone = ip_prepare_icmp_and_get_phone(
     1039                                    error, next, NULL);
     1040                                if (phone >= 0) {
    10441041                                        /* Fragmentation necessary ICMP */
    1045                                         icmp_destination_unreachable_msg(sess,
     1042                                        icmp_destination_unreachable_msg(phone,
    10461043                                            ICMP_FRAG_NEEDED, content, next);
    10471044                                }
    10481045                        } else {
    1049                                 pq_release_remote(ip_globals.net_sess,
     1046                                pq_release_remote(ip_globals.net_phone,
    10501047                                    packet_get_id(next));
    10511048                        }
    … …  
    10611058}
    10621059
    1063 /** Send the packet or the packet queue via the specified route.
     1060/** Sends the packet or the packet queue via the specified route.
    10641061 *
    10651062 * The ICMP_HOST_UNREACH error notification may be sent if route hardware
    10661063 * destination address is found.
    10671064 *
    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  *
     1065 * @param[in,out] packet The packet to be sent.
     1066 * @param[in] netif     The target network interface.
     1067 * @param[in] route     The target route.
     1068 * @param[in] src       The source address.
     1069 * @param[in] dest      The destination address.
     1070 * @param[in] error     The error module service.
     1071 * @return              EOK on success.
     1072 * @return              Other error codes as defined for the arp_translate_req()
     1073 *                      function.
     1074 * @return              Other error codes as defined for the ip_prepare_packet()
     1075 *                      function.
    10791076 */
    10801077static int ip_send_route(packet_t *packet, ip_netif_t *netif,
    … …  
    10841081        measured_string_t *translation;
    10851082        uint8_t *data;
    1086         async_sess_t *sess;
     1083        int phone;
    10871084        int rc;
    10881085
    … …  
    10931090                destination.length = sizeof(dest.s_addr);
    10941091
    1095                 rc = arp_translate_req(netif->arp->sess, netif->device_id,
     1092                rc = arp_translate_req(netif->arp->phone, netif->device_id,
    10961093                    SERVICE_IP, &destination, &translation, &data);
    10971094                if (rc != EOK) {
    1098                         pq_release_remote(ip_globals.net_sess,
     1095                        pq_release_remote(ip_globals.net_phone,
    10991096                            packet_get_id(packet));
    11001097                        return rc;
    … …  
    11061103                                free(data);
    11071104                        }
    1108                         sess = ip_prepare_icmp_and_get_session(error, packet,
     1105                        phone = ip_prepare_icmp_and_get_phone(error, packet,
    11091106                            NULL);
    1110                         if (sess) {
     1107                        if (phone >= 0) {
    11111108                                /* Unreachable ICMP if no routing */
    1112                                 icmp_destination_unreachable_msg(sess,
     1109                                icmp_destination_unreachable_msg(phone,
    11131110                                    ICMP_HOST_UNREACH, 0, packet);
    11141111                        }
    … …  
    11221119        rc = ip_prepare_packet(src, dest, packet, translation);
    11231120        if (rc != EOK) {
    1124                 pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
     1121                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    11251122        } else {
    11261123                packet = ip_split_packet(packet, netif->packet_dimension.prefix,
    … …  
    11291126                    netif->packet_dimension.addr_len, error);
    11301127                if (packet) {
    1131                         nil_send_msg(netif->sess, netif->device_id, packet,
     1128                        nil_send_msg(netif->phone, netif->device_id, packet,
    11321129                            SERVICE_IP);
    11331130                }
    … …  
    11421139}
    11431140
    1144 static int ip_send_msg_local(device_id_t device_id, packet_t *packet,
    1145     services_t sender, services_t error)
     1141static int ip_send_msg_local(int il_phone, device_id_t device_id,
     1142    packet_t *packet, services_t sender, services_t error)
    11461143{
    11471144        int addrlen;
    … …  
    11521149        in_addr_t *dest;
    11531150        in_addr_t *src;
    1154         async_sess_t *sess;
     1151        int phone;
    11551152        int rc;
    11561153
    … …  
    11971194        if (!netif || !route) {
    11981195                fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    1199                 sess = ip_prepare_icmp_and_get_session(error, packet, NULL);
    1200                 if (sess) {
     1196                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
     1197                if (phone >= 0) {
    12011198                        /* Unreachable ICMP if no routing */
    1202                         icmp_destination_unreachable_msg(sess,
     1199                        icmp_destination_unreachable_msg(phone,
    12031200                            ICMP_NET_UNREACH, 0, packet);
    12041201                }
    … …  
    12281225                if (!netif || !route) {
    12291226                        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    1230                         sess = ip_prepare_icmp_and_get_session(error, packet,
     1227                        phone = ip_prepare_icmp_and_get_phone(error, packet,
    12311228                            NULL);
    1232                         if (sess) {
     1229                        if (phone >= 0) {
    12331230                                /* Unreachable ICMP if no routing */
    1234                                 icmp_destination_unreachable_msg(sess,
     1231                                icmp_destination_unreachable_msg(phone,
    12351232                                    ICMP_HOST_UNREACH, 0, packet);
    12361233                        }
    … …  
    13161313{
    13171314        ip_proto_t *proto;
    1318         async_sess_t *sess;
     1315        int phone;
    13191316        services_t service;
    13201317        tl_received_msg_t received_msg;
    … …  
    13691366        if (!proto) {
    13701367                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    1371                 sess = ip_prepare_icmp_and_get_session(error, packet, header);
    1372                 if (sess) {
     1368                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
     1369                if (phone >= 0) {
    13731370                        /* Unreachable ICMP */
    1374                         icmp_destination_unreachable_msg(sess,
     1371                        icmp_destination_unreachable_msg(phone,
    13751372                            ICMP_PROT_UNREACH, 0, packet);
    13761373                }
    … …  
    13841381                rc = received_msg(device_id, packet, service, error);
    13851382        } else {
    1386                 rc = tl_received_msg(proto->sess, device_id, packet,
     1383                rc = tl_received_msg(proto->phone, device_id, packet,
    13871384                    proto->service, error);
    13881385                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    … …  
    14181415        in_addr_t dest;
    14191416        ip_route_t *route;
    1420         async_sess_t *sess;
     1417        int phone;
    14211418        struct sockaddr *addr;
    14221419        struct sockaddr_in addr_in;
    … …  
    14311428        if ((header->header_checksum) &&
    14321429            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
    1433                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1434                 if (sess) {
     1430                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1431                if (phone >= 0) {
    14351432                        /* Checksum error ICMP */
    1436                         icmp_parameter_problem_msg(sess, ICMP_PARAM_POINTER,
     1433                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
    14371434                            ((size_t) ((void *) &header->header_checksum)) -
    14381435                            ((size_t) ((void *) header)), packet);
    … …  
    14421439
    14431440        if (header->ttl <= 1) {
    1444                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1445                 if (sess) {
     1441                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1442                if (phone >= 0) {
    14461443                        /* TTL exceeded ICMP */
    1447                         icmp_time_exceeded_msg(sess, ICMP_EXC_TTL, packet);
     1444                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14481445                }
    14491446                return EINVAL;
    … …  
    14731470        route = ip_find_route(dest);
    14741471        if (!route) {
    1475                 sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1476                 if (sess) {
     1472                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1473                if (phone >= 0) {
    14771474                        /* Unreachable ICMP */
    1478                         icmp_destination_unreachable_msg(sess,
     1475                        icmp_destination_unreachable_msg(phone,
    14791476                            ICMP_HOST_UNREACH, 0, packet);
    14801477                }
    … …  
    14931490        }
    14941491
    1495         sess = ip_prepare_icmp_and_get_session(0, packet, header);
    1496         if (sess) {
     1492        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
     1493        if (phone >= 0) {
    14971494                /* Unreachable ICMP if no routing */
    1498                 icmp_destination_unreachable_msg(sess, ICMP_HOST_UNREACH, 0,
     1495                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
    14991496                    packet);
    15001497        }
    … …  
    15031500}
    15041501
    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  *
     1502/** Returns the device packet dimensions for sending.
     1503 *
     1504 * @param[in] phone     The service module phone.
     1505 * @param[in] message   The service specific message.
     1506 * @param[in] device_id The device identifier.
     1507 * @param[out] addr_len The minimum reserved address length.
     1508 * @param[out] prefix   The minimum reserved prefix size.
     1509 * @param[out] content  The maximum content size.
     1510 * @param[out] suffix   The minimum reserved suffix size.
     1511 * @return              EOK on success.
    15151512 */
    15161513static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
    … …  
    15941591 * @param[in]     iid   Message identifier.
    15951592 * @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)
     1593 *
     1594 */
     1595static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall)
    16001596{
    16011597        packet_t *packet;
    … …  
    16111607               
    16121608                case NET_IL_RECEIVED:
    1613                         rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1609                        rc = packet_translate_remote(ip_globals.net_phone, &packet,
    16141610                            IPC_GET_PACKET(*icall));
    16151611                        if (rc == EOK) {
    … …  
    16381634}
    16391635
    1640 /** Register the transport layer protocol.
     1636/** Registers the transport layer protocol.
    16411637 *
    16421638 * The traffic of this protocol will be supplied using either the receive
    16431639 * function or IPC message.
    16441640 *
    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,
     1641 * @param[in] protocol  The transport layer module protocol.
     1642 * @param[in] service   The transport layer module service.
     1643 * @param[in] phone     The transport layer module phone.
     1644 * @param[in] received_msg The receiving function.
     1645 * @return              EOK on success.
     1646 * @return              EINVAL if the protocol parameter and/or the service
     1647 *                      parameter is zero.
     1648 * @return              EINVAL if the phone parameter is not a positive number
     1649 *                      and the tl_receive_msg is NULL.
     1650 * @return              ENOMEM if there is not enough memory left.
     1651 */
     1652static int
     1653ip_register(int protocol, services_t service, int phone,
    16591654    tl_received_msg_t received_msg)
    16601655{
    … …  
    16621657        int index;
    16631658
    1664         if ((!protocol) || (!service) || ((!sess) && (!received_msg)))
     1659        if (!protocol || !service || ((phone < 0) && !received_msg))
    16651660                return EINVAL;
    1666        
     1661
    16671662        proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
    16681663        if (!proto)
    … …  
    16711666        proto->protocol = protocol;
    16721667        proto->service = service;
    1673         proto->sess = sess;
     1668        proto->phone = phone;
    16741669        proto->received_msg = received_msg;
    16751670
    … …  
    16831678        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
    16841679
    1685         printf("%s: Protocol registered (protocol: %d)\n",
    1686             NAME, proto->protocol);
     1680        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
     1681            NAME, proto->protocol, proto->phone);
    16871682
    16881683        return EOK;
    16891684}
    16901685
    1691 static int ip_add_route_req_local(device_id_t device_id, in_addr_t address,
     1686
     1687static int
     1688ip_add_route_req_local(int ip_phone, device_id_t device_id, in_addr_t address,
    16921689    in_addr_t netmask, in_addr_t gateway)
    16931690{
    … …  
    17231720}
    17241721
    1725 static int ip_set_gateway_req_local(device_id_t device_id, in_addr_t gateway)
     1722static int
     1723ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
    17261724{
    17271725        ip_netif_t *netif;
    … …  
    17471745/** Notify the IP module about the received error notification packet.
    17481746 *
    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,
     1747 * @param[in] ip_phone  The IP module phone used for (semi)remote calls.
     1748 * @param[in] device_id The device identifier.
     1749 * @param[in] packet    The received packet or the received packet queue.
     1750 * @param[in] target    The target internetwork module service to be
     1751 *                      delivered to.
     1752 * @param[in] error     The packet error reporting service. Prefixes the
     1753 *                      received packet.
     1754 * @return              EOK on success.
     1755 *
     1756 */
     1757static int
     1758ip_received_error_msg_local(int ip_phone, device_id_t device_id,
    17601759    packet_t *packet, services_t target, services_t error)
    17611760{
    … …  
    18021801                        address.value = (uint8_t *) &header->destination_address;
    18031802                        address.length = sizeof(header->destination_address);
    1804                         arp_clear_address_req(netif->arp->sess,
     1803                        arp_clear_address_req(netif->arp->phone,
    18051804                            netif->device_id, SERVICE_IP, &address);
    18061805                }
    … …  
    18161815}
    18171816
    1818 static int ip_get_route_req_local(ip_protocol_t protocol,
     1817static int
     1818ip_get_route_req_local(int ip_phone, ip_protocol_t protocol,
    18191819    const struct sockaddr *destination, socklen_t addrlen,
    18201820    device_id_t *device_id, void **header, size_t *headerlen)
    … …  
    19131913       
    19141914        *answer_count = 0;
    1915        
    1916         if (!IPC_GET_IMETHOD(*call))
     1915        switch (IPC_GET_IMETHOD(*call)) {
     1916        case IPC_M_PHONE_HUNGUP:
    19171917                return EOK;
    19181918       
    1919         async_sess_t *callback =
    1920             async_callback_receive_start(EXCHANGE_SERIALIZE, call);
    1921         if (callback)
     1919        case IPC_M_CONNECT_TO_ME:
    19221920                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
    1923                     callback, NULL);
    1924        
    1925         switch (IPC_GET_IMETHOD(*call)) {
     1921                    IPC_GET_PHONE(*call), NULL);
     1922       
    19261923        case NET_IP_DEVICE:
    1927                 return ip_device_req_local(IPC_GET_DEVICE(*call),
     1924                return ip_device_req_local(0, IPC_GET_DEVICE(*call),
    19281925                    IPC_GET_SERVICE(*call));
    19291926       
    19301927        case NET_IP_RECEIVED_ERROR:
    1931                 rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1928                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    19321929                    IPC_GET_PACKET(*call));
    19331930                if (rc != EOK)
    19341931                        return rc;
    1935                 return ip_received_error_msg_local(IPC_GET_DEVICE(*call),
     1932                return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
    19361933                    packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call));
    19371934       
    19381935        case NET_IP_ADD_ROUTE:
    1939                 return ip_add_route_req_local(IPC_GET_DEVICE(*call),
     1936                return ip_add_route_req_local(0, IPC_GET_DEVICE(*call),
    19401937                    IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call),
    19411938                    IP_GET_GATEWAY(*call));
    19421939
    19431940        case NET_IP_SET_GATEWAY:
    1944                 return ip_set_gateway_req_local(IPC_GET_DEVICE(*call),
     1941                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call),
    19451942                    IP_GET_GATEWAY(*call));
    19461943
    … …  
    19511948                        return rc;
    19521949               
    1953                 rc = ip_get_route_req_local(IP_GET_PROTOCOL(*call), addr,
     1950                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
    19541951                    (socklen_t) addrlen, &device_id, &header, &headerlen);
    19551952                if (rc != EOK)
    … …  
    19821979       
    19831980        case NET_IP_SEND:
    1984                 rc = packet_translate_remote(ip_globals.net_sess, &packet,
     1981                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    19851982                    IPC_GET_PACKET(*call));
    19861983                if (rc != EOK)
    19871984                        return rc;
    19881985               
    1989                 return ip_send_msg_local(IPC_GET_DEVICE(*call), packet, 0,
     1986                return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
    19901987                    IPC_GET_ERROR(*call));
    19911988        }
Note: See TracChangeset for help on using the changeset viewer.