Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r849ed54 r14f1db0  
    6969#include <adt/module_map.h>
    7070#include <packet/packet_client.h>
     71#include <packet_remote.h>
    7172#include <nil_messages.h>
    7273#include <il_messages.h>
     74#include <il_local.h>
     75#include <ip_local.h>
    7376
    7477#include "ip.h"
    … …  
    7982/** IP module name.
    8083 */
    81 #define NAME    "IP protocol"
     84#define NAME  "ip"
    8285
    8386/** IP version 4.
    … …  
    424427}
    425428
    426 int ip_device_req(int il_phone, device_id_t device_id, services_t netif){
     429int ip_device_req_local(int il_phone, device_id_t device_id, services_t netif){
    427430        ERROR_DECLARE;
    428431
    … …  
    430433        ip_route_ref route;
    431434        int index;
    432         char * data;
    433435
    434436        ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
    … …  
    454456        }
    455457        // print the settings
    456         printf("New device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d\n", ip_netif->device_id, ip_netif->phone, ip_netif->ipv);
    457         printf("\tconfiguration\t= %s\n", ip_netif->dhcp ? "dhcp" : "static");
     458        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
     459            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
     460            ip_netif->dhcp ? "dhcp" : "static");
     461       
    458462        // TODO ipv6 addresses
    459         data = (char *) malloc(INET_ADDRSTRLEN);
    460         if(data){
    461                 for(index = 0; index < ip_routes_count(&ip_netif->routes); ++ index){
    462                         route = ip_routes_get_index(&ip_netif->routes, index);
    463                         if(route){
    464                                 printf("\tRouting %d:\n", index);
    465                                 inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr, data, INET_ADDRSTRLEN);
    466                                 printf("\t\taddress\t= %s\n", data);
    467                                 inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr, data, INET_ADDRSTRLEN);
    468                                 printf("\t\tnetmask\t= %s\n", data);
    469                                 inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr, data, INET_ADDRSTRLEN);
    470                                 printf("\t\tgateway\t= %s\n", data);
    471                         }
    472                 }
    473                 inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, data, INET_ADDRSTRLEN);
    474                 printf("\t\tbroadcast\t= %s\n", data);
    475                 free(data);
    476         }
     463       
     464        char address[INET_ADDRSTRLEN];
     465        char netmask[INET_ADDRSTRLEN];
     466        char gateway[INET_ADDRSTRLEN];
     467       
     468        for (index = 0; index < ip_routes_count(&ip_netif->routes); ++ index){
     469                route = ip_routes_get_index(&ip_netif->routes, index);
     470                if (route) {
     471                        inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr, address, INET_ADDRSTRLEN);
     472                        inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr, netmask, INET_ADDRSTRLEN);
     473                        inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr, gateway, INET_ADDRSTRLEN);
     474                        printf("%s: Route %d (address: %s, netmask: %s, gateway: %s)\n",
     475                            NAME, index, address, netmask, gateway);
     476                }
     477        }
     478       
     479        inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, address, INET_ADDRSTRLEN);
     480        printf("%s: Broadcast (%s)\n", NAME, address);
     481       
    477482        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    478483        return EOK;
    … …  
    595600        }
    596601        netif->packet_dimension.content = mtu;
    597         printf("ip - device %d changed mtu to %d\n\n", device_id, mtu);
     602        printf("%s: Device %d changed MTU to %d\n", NAME, device_id, mtu);
    598603        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    599604        return EOK;
    … …  
    611616        }
    612617        netif->state = state;
    613         printf("ip - device %d changed state to %d\n\n", device_id, state);
     618        printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
    614619        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    615620        return EOK;
    … …  
    646651                return index;
    647652        }
    648         printf("New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone);
     653       
     654        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
     655            NAME, proto->protocol, proto->phone);
     656       
    649657        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
    650658        return EOK;
    651659}
    652660
    653 int ip_send_msg(int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error){
     661int ip_send_msg_local(int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error){
    654662        ERROR_DECLARE;
    655663
    … …  
    777785//                      sleep(1);
    778786//                      ERROR_PROPAGATE(arp_translate_req(netif->arp->phone, netif->device_id, SERVICE_IP, &destination, &translation, &data));
    779                         pq_release(ip_globals.net_phone, packet_get_id(packet));
     787                        pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    780788                        return ERROR_CODE;
    781789                }
    … …  
    794802        }else translation = NULL;
    795803        if(ERROR_OCCURRED(ip_prepare_packet(src, dest, packet, translation))){
    796                 pq_release(ip_globals.net_phone, packet_get_id(packet));
     804                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    797805        }else{
    798806                packet = ip_split_packet(packet, netif->packet_dimension.prefix, netif->packet_dimension.content, netif->packet_dimension.suffix, netif->packet_dimension.addr_len, error);
    … …  
    886894}
    887895
    888 int ip_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     896int ip_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     897    ipc_call_t *answer, int * answer_count)
     898{
    889899        ERROR_DECLARE;
    890 
     900       
    891901        packet_t packet;
    892         struct sockaddr * addr;
     902        struct sockaddr *addr;
    893903        size_t addrlen;
    894904        size_t prefix;
    895905        size_t suffix;
    896906        size_t content;
    897         ip_pseudo_header_ref header;
     907        void *header;
    898908        size_t headerlen;
    899909        device_id_t device_id;
    900 
     910       
    901911        *answer_count = 0;
    902         switch(IPC_GET_METHOD(*call)){
     912        switch (IPC_GET_METHOD(*call)) {
    903913                case IPC_M_PHONE_HUNGUP:
    904914                        return EOK;
    905915                case NET_IL_DEVICE:
    906                         return ip_device_req(0, IPC_GET_DEVICE(call), IPC_GET_SERVICE(call));
     916                        return ip_device_req_local(0, IPC_GET_DEVICE(call),
     917                            IPC_GET_SERVICE(call));
    907918                case IPC_M_CONNECT_TO_ME:
    908                         return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call), IPC_GET_PHONE(call), NULL);
     919                        return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call),
     920                            IPC_GET_PHONE(call), NULL);
    909921                case NET_IL_SEND:
    910                         ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
    911                         return ip_send_msg(0, IPC_GET_DEVICE(call), packet, 0, IPC_GET_ERROR(call));
     922                        ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone, &packet,
     923                            IPC_GET_PACKET(call)));
     924                        return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
     925                            IPC_GET_ERROR(call));
    912926                case NET_IL_DEVICE_STATE:
    913                         return ip_device_state_message(IPC_GET_DEVICE(call), IPC_GET_STATE(call));
     927                        return ip_device_state_message(IPC_GET_DEVICE(call),
     928                            IPC_GET_STATE(call));
    914929                case NET_IL_RECEIVED:
    915                         ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
     930                        ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone, &packet,
     931                            IPC_GET_PACKET(call)));
    916932                        return ip_receive_message(IPC_GET_DEVICE(call), packet);
    917933                case NET_IP_RECEIVED_ERROR:
    918                         ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
    919                         return ip_received_error_msg(0, IPC_GET_DEVICE(call), packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
     934                        ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone, &packet,
     935                            IPC_GET_PACKET(call)));
     936                        return ip_received_error_msg_local(0, IPC_GET_DEVICE(call), packet,
     937                            IPC_GET_TARGET(call), IPC_GET_ERROR(call));
    920938                case NET_IP_ADD_ROUTE:
    921                         return ip_add_route_req(0, IPC_GET_DEVICE(call), IP_GET_ADDRESS(call), IP_GET_NETMASK(call), IP_GET_GATEWAY(call));
     939                        return ip_add_route_req_local(0, IPC_GET_DEVICE(call),
     940                            IP_GET_ADDRESS(call), IP_GET_NETMASK(call), IP_GET_GATEWAY(call));
    922941                case NET_IP_SET_GATEWAY:
    923                         return ip_set_gateway_req(0, IPC_GET_DEVICE(call), IP_GET_GATEWAY(call));
     942                        return ip_set_gateway_req_local(0, IPC_GET_DEVICE(call),
     943                            IP_GET_GATEWAY(call));
    924944                case NET_IP_GET_ROUTE:
    925945                        ERROR_PROPAGATE(data_receive((void **) &addr, &addrlen));
    926                         ERROR_PROPAGATE(ip_get_route_req(0, IP_GET_PROTOCOL(call), addr, (socklen_t) addrlen,
    927                             &device_id, &header, &headerlen));
     946                        ERROR_PROPAGATE(ip_get_route_req_local(0, IP_GET_PROTOCOL(call),
     947                            addr, (socklen_t) addrlen, &device_id, &header, &headerlen));
    928948                        IPC_SET_DEVICE(answer, device_id);
    929949                        IP_SET_HEADERLEN(answer, headerlen);
     950                       
    930951                        *answer_count = 2;
    931                         if(! ERROR_OCCURRED(data_reply(&headerlen, sizeof(headerlen)))){
     952                       
     953                        if (!ERROR_OCCURRED(data_reply(&headerlen, sizeof(headerlen))))
    932954                                ERROR_CODE = data_reply(header, headerlen);
    933                         }
     955                       
    934956                        free(header);
    935957                        return ERROR_CODE;
    936958                case NET_IL_PACKET_SPACE:
    937                         ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen, &prefix, &content, &suffix));
     959                        ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call),
     960                            &addrlen, &prefix, &content, &suffix));
    938961                        IPC_SET_ADDR(answer, addrlen);
    939962                        IPC_SET_PREFIX(answer, prefix);
    … …  
    943966                        return EOK;
    944967                case NET_IL_MTU_CHANGED:
    945                         return ip_mtu_changed_message(IPC_GET_DEVICE(call), IPC_GET_MTU(call));
    946         }
     968                        return ip_mtu_changed_message(IPC_GET_DEVICE(call),
     969                            IPC_GET_MTU(call));
     970        }
     971       
    947972        return ENOTSUP;
    948973}
    949974
    950 int ip_packet_size_req(int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension){
    951         if(! packet_dimension){
     975int ip_packet_size_req_local(int ip_phone, device_id_t device_id,
     976    packet_dimension_ref packet_dimension)
     977{
     978        if (!packet_dimension)
    952979                return EBADMEM;
    953         }
    954         return ip_packet_size_message(device_id, &packet_dimension->addr_len, &packet_dimension->prefix, &packet_dimension->content, &packet_dimension->suffix);
     980       
     981        return ip_packet_size_message(device_id, &packet_dimension->addr_len,
     982            &packet_dimension->prefix, &packet_dimension->content,
     983            &packet_dimension->suffix);
    955984}
    956985
    … …  
    9981027}
    9991028
    1000 int ip_add_route_req(int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway){
     1029int ip_add_route_req_local(int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway){
    10011030        ip_route_ref route;
    10021031        ip_netif_ref netif;
    … …  
    10621091}
    10631092
    1064 int ip_set_gateway_req(int ip_phone, device_id_t device_id, in_addr_t gateway){
     1093int ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
     1094{
    10651095        ip_netif_ref netif;
    10661096
    … …  
    11071137                                        }
    11081138                                }else{
    1109                                         pq_release(ip_globals.net_phone, packet_get_id(next));
     1139                                        pq_release_remote(ip_globals.net_phone, packet_get_id(next));
    11101140                                }
    11111141                                next = new_packet;
    … …  
    11481178        }
    11491179        // create the last fragment
    1150         new_packet = packet_get_4(ip_globals.net_phone, prefix, length, suffix, ((addrlen > addr_len) ? addrlen : addr_len));
     1180        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length, suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    11511181        if(! new_packet){
    11521182                return ENOMEM;
    … …  
    11721202        // create middle framgents
    11731203        while(IP_TOTAL_LENGTH(header) > length){
    1174                 new_packet = packet_get_4(ip_globals.net_phone, prefix, length, suffix, ((addrlen >= addr_len) ? addrlen : addr_len));
     1204                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length, suffix, ((addrlen >= addr_len) ? addrlen : addr_len));
    11751205                if(! new_packet){
    11761206                        return ENOMEM;
    … …  
    13521382}
    13531383
    1354 int ip_received_error_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error){
     1384/** Notify the IP module about the received error notification packet.
     1385 *
     1386 * @param[in] ip_phone  The IP module phone used for (semi)remote calls.
     1387 * @param[in] device_id The device identifier.
     1388 * @param[in] packet    The received packet or the received packet queue.
     1389 * @param[in] target    The target internetwork module service to be
     1390 *                      delivered to.
     1391 * @param[in] error     The packet error reporting service. Prefixes the
     1392 *                      received packet.
     1393 *
     1394 * @return EOK on success.
     1395 *
     1396 */
     1397int ip_received_error_msg_local(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error){
    13551398        uint8_t * data;
    13561399        int offset;
    … …  
    14871530        next = pq_detach(packet);
    14881531        if(next){
    1489                 pq_release(ip_globals.net_phone, packet_get_id(next));
     1532                pq_release_remote(ip_globals.net_phone, packet_get_id(next));
    14901533        }
    14911534        if(! header){
    … …  
    15511594
    15521595int ip_release_and_return(packet_t packet, int result){
    1553         pq_release(ip_globals.net_phone, packet_get_id(packet));
     1596        pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    15541597        return result;
    15551598}
    15561599
    1557 int ip_get_route_req(int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen){
     1600int ip_get_route_req_local(int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, void **header, size_t * headerlen){
    15581601        struct sockaddr_in * address_in;
    15591602//      struct sockaddr_in6 *   address_in6;
    … …  
    16191662        header_in->protocol = protocol;
    16201663        header_in->data_length = 0;
    1621         *header = (ip_pseudo_header_ref) header_in;
     1664        *header = header_in;
    16221665        return EOK;
    16231666}
    1624 
    1625 #ifdef CONFIG_NETWORKING_modular
    1626 
    1627 #include <il_standalone.h>
    16281667
    16291668/** Default thread for new connections.
    … …  
    16531692               
    16541693                /* Process the message */
    1655                 int res = il_module_message(callid, &call, &answer, &answer_count);
     1694                int res = il_module_message_standalone(callid, &call, &answer,
     1695                    &answer_count);
    16561696               
    16571697                /* End if said to either by the message or the processing result */
    … …  
    16771717        ERROR_DECLARE;
    16781718       
    1679         /* Print the module label */
    1680         printf("Task %d - %s\n", task_get_id(), NAME);
    1681        
    16821719        /* Start the module */
    1683         if (ERROR_OCCURRED(il_module_start(il_client_connection))) {
    1684                 printf(" - ERROR %i\n", ERROR_CODE);
     1720        if (ERROR_OCCURRED(il_module_start_standalone(il_client_connection)))
    16851721                return ERROR_CODE;
    1686         }
    16871722       
    16881723        return EOK;
    16891724}
    16901725
    1691 #endif /* CONFIG_NETWORKING_modular */
    1692 
    16931726/** @}
    16941727 */
Note: See TracChangeset for help on using the changeset viewer.