Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r14f1db0 r849ed54  
    6969#include <adt/module_map.h>
    7070#include <packet/packet_client.h>
    71 #include <packet_remote.h>
    7271#include <nil_messages.h>
    7372#include <il_messages.h>
    74 #include <il_local.h>
    75 #include <ip_local.h>
    7673
    7774#include "ip.h"
    … …  
    8279/** IP module name.
    8380 */
    84 #define NAME  "ip"
     81#define NAME    "IP protocol"
    8582
    8683/** IP version 4.
    … …  
    427424}
    428425
    429 int ip_device_req_local(int il_phone, device_id_t device_id, services_t netif){
     426int ip_device_req(int il_phone, device_id_t device_id, services_t netif){
    430427        ERROR_DECLARE;
    431428
    … …  
    433430        ip_route_ref route;
    434431        int index;
     432        char * data;
    435433
    436434        ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
    … …  
    456454        }
    457455        // print the settings
    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        
     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");
    462458        // TODO ipv6 addresses
    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        
     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        }
    482477        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    483478        return EOK;
    … …  
    600595        }
    601596        netif->packet_dimension.content = mtu;
    602         printf("%s: Device %d changed MTU to %d\n", NAME, device_id, mtu);
     597        printf("ip - device %d changed mtu to %d\n\n", device_id, mtu);
    603598        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    604599        return EOK;
    … …  
    616611        }
    617612        netif->state = state;
    618         printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
     613        printf("ip - device %d changed state to %d\n\n", device_id, state);
    619614        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    620615        return EOK;
    … …  
    651646                return index;
    652647        }
    653        
    654         printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
    655             NAME, proto->protocol, proto->phone);
    656        
     648        printf("New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone);
    657649        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
    658650        return EOK;
    659651}
    660652
    661 int ip_send_msg_local(int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error){
     653int ip_send_msg(int il_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error){
    662654        ERROR_DECLARE;
    663655
    … …  
    785777//                      sleep(1);
    786778//                      ERROR_PROPAGATE(arp_translate_req(netif->arp->phone, netif->device_id, SERVICE_IP, &destination, &translation, &data));
    787                         pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
     779                        pq_release(ip_globals.net_phone, packet_get_id(packet));
    788780                        return ERROR_CODE;
    789781                }
    … …  
    802794        }else translation = NULL;
    803795        if(ERROR_OCCURRED(ip_prepare_packet(src, dest, packet, translation))){
    804                 pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
     796                pq_release(ip_globals.net_phone, packet_get_id(packet));
    805797        }else{
    806798                packet = ip_split_packet(packet, netif->packet_dimension.prefix, netif->packet_dimension.content, netif->packet_dimension.suffix, netif->packet_dimension.addr_len, error);
    … …  
    894886}
    895887
    896 int ip_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    897     ipc_call_t *answer, int * answer_count)
    898 {
     888int ip_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    899889        ERROR_DECLARE;
    900        
     890
    901891        packet_t packet;
    902         struct sockaddr *addr;
     892        struct sockaddr * addr;
    903893        size_t addrlen;
    904894        size_t prefix;
    905895        size_t suffix;
    906896        size_t content;
    907         void *header;
     897        ip_pseudo_header_ref header;
    908898        size_t headerlen;
    909899        device_id_t device_id;
    910        
     900
    911901        *answer_count = 0;
    912         switch (IPC_GET_METHOD(*call)) {
     902        switch(IPC_GET_METHOD(*call)){
    913903                case IPC_M_PHONE_HUNGUP:
    914904                        return EOK;
    915905                case NET_IL_DEVICE:
    916                         return ip_device_req_local(0, IPC_GET_DEVICE(call),
    917                             IPC_GET_SERVICE(call));
     906                        return ip_device_req(0, IPC_GET_DEVICE(call), IPC_GET_SERVICE(call));
    918907                case IPC_M_CONNECT_TO_ME:
    919                         return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call),
    920                             IPC_GET_PHONE(call), NULL);
     908                        return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call), IPC_GET_PHONE(call), NULL);
    921909                case NET_IL_SEND:
    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));
     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));
    926912                case NET_IL_DEVICE_STATE:
    927                         return ip_device_state_message(IPC_GET_DEVICE(call),
    928                             IPC_GET_STATE(call));
     913                        return ip_device_state_message(IPC_GET_DEVICE(call), IPC_GET_STATE(call));
    929914                case NET_IL_RECEIVED:
    930                         ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone, &packet,
    931                             IPC_GET_PACKET(call)));
     915                        ERROR_PROPAGATE(packet_translate(ip_globals.net_phone, &packet, IPC_GET_PACKET(call)));
    932916                        return ip_receive_message(IPC_GET_DEVICE(call), packet);
    933917                case NET_IP_RECEIVED_ERROR:
    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));
     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));
    938920                case NET_IP_ADD_ROUTE:
    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));
     921                        return ip_add_route_req(0, IPC_GET_DEVICE(call), IP_GET_ADDRESS(call), IP_GET_NETMASK(call), IP_GET_GATEWAY(call));
    941922                case NET_IP_SET_GATEWAY:
    942                         return ip_set_gateway_req_local(0, IPC_GET_DEVICE(call),
    943                             IP_GET_GATEWAY(call));
     923                        return ip_set_gateway_req(0, IPC_GET_DEVICE(call), IP_GET_GATEWAY(call));
    944924                case NET_IP_GET_ROUTE:
    945925                        ERROR_PROPAGATE(data_receive((void **) &addr, &addrlen));
    946                         ERROR_PROPAGATE(ip_get_route_req_local(0, IP_GET_PROTOCOL(call),
    947                             addr, (socklen_t) addrlen, &device_id, &header, &headerlen));
     926                        ERROR_PROPAGATE(ip_get_route_req(0, IP_GET_PROTOCOL(call), addr, (socklen_t) addrlen,
     927                            &device_id, &header, &headerlen));
    948928                        IPC_SET_DEVICE(answer, device_id);
    949929                        IP_SET_HEADERLEN(answer, headerlen);
    950                        
    951930                        *answer_count = 2;
    952                        
    953                         if (!ERROR_OCCURRED(data_reply(&headerlen, sizeof(headerlen))))
     931                        if(! ERROR_OCCURRED(data_reply(&headerlen, sizeof(headerlen)))){
    954932                                ERROR_CODE = data_reply(header, headerlen);
    955                        
     933                        }
    956934                        free(header);
    957935                        return ERROR_CODE;
    958936                case NET_IL_PACKET_SPACE:
    959                         ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call),
    960                             &addrlen, &prefix, &content, &suffix));
     937                        ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen, &prefix, &content, &suffix));
    961938                        IPC_SET_ADDR(answer, addrlen);
    962939                        IPC_SET_PREFIX(answer, prefix);
    … …  
    966943                        return EOK;
    967944                case NET_IL_MTU_CHANGED:
    968                         return ip_mtu_changed_message(IPC_GET_DEVICE(call),
    969                             IPC_GET_MTU(call));
    970         }
    971        
     945                        return ip_mtu_changed_message(IPC_GET_DEVICE(call), IPC_GET_MTU(call));
     946        }
    972947        return ENOTSUP;
    973948}
    974949
    975 int ip_packet_size_req_local(int ip_phone, device_id_t device_id,
    976     packet_dimension_ref packet_dimension)
    977 {
    978         if (!packet_dimension)
     950int ip_packet_size_req(int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension){
     951        if(! packet_dimension){
    979952                return EBADMEM;
    980        
    981         return ip_packet_size_message(device_id, &packet_dimension->addr_len,
    982             &packet_dimension->prefix, &packet_dimension->content,
    983             &packet_dimension->suffix);
     953        }
     954        return ip_packet_size_message(device_id, &packet_dimension->addr_len, &packet_dimension->prefix, &packet_dimension->content, &packet_dimension->suffix);
    984955}
    985956
    … …  
    1027998}
    1028999
    1029 int 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){
     1000int ip_add_route_req(int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway){
    10301001        ip_route_ref route;
    10311002        ip_netif_ref netif;
    … …  
    10911062}
    10921063
    1093 int ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
    1094 {
     1064int ip_set_gateway_req(int ip_phone, device_id_t device_id, in_addr_t gateway){
    10951065        ip_netif_ref netif;
    10961066
    … …  
    11371107                                        }
    11381108                                }else{
    1139                                         pq_release_remote(ip_globals.net_phone, packet_get_id(next));
     1109                                        pq_release(ip_globals.net_phone, packet_get_id(next));
    11401110                                }
    11411111                                next = new_packet;
    … …  
    11781148        }
    11791149        // create the last fragment
    1180         new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length, suffix, ((addrlen > addr_len) ? addrlen : addr_len));
     1150        new_packet = packet_get_4(ip_globals.net_phone, prefix, length, suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    11811151        if(! new_packet){
    11821152                return ENOMEM;
    … …  
    12021172        // create middle framgents
    12031173        while(IP_TOTAL_LENGTH(header) > length){
    1204                 new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length, suffix, ((addrlen >= addr_len) ? addrlen : addr_len));
     1174                new_packet = packet_get_4(ip_globals.net_phone, prefix, length, suffix, ((addrlen >= addr_len) ? addrlen : addr_len));
    12051175                if(! new_packet){
    12061176                        return ENOMEM;
    … …  
    13821352}
    13831353
    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  */
    1397 int ip_received_error_msg_local(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error){
     1354int ip_received_error_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error){
    13981355        uint8_t * data;
    13991356        int offset;
    … …  
    15301487        next = pq_detach(packet);
    15311488        if(next){
    1532                 pq_release_remote(ip_globals.net_phone, packet_get_id(next));
     1489                pq_release(ip_globals.net_phone, packet_get_id(next));
    15331490        }
    15341491        if(! header){
    … …  
    15941551
    15951552int ip_release_and_return(packet_t packet, int result){
    1596         pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
     1553        pq_release(ip_globals.net_phone, packet_get_id(packet));
    15971554        return result;
    15981555}
    15991556
    1600 int 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){
     1557int 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){
    16011558        struct sockaddr_in * address_in;
    16021559//      struct sockaddr_in6 *   address_in6;
    … …  
    16621619        header_in->protocol = protocol;
    16631620        header_in->data_length = 0;
    1664         *header = header_in;
     1621        *header = (ip_pseudo_header_ref) header_in;
    16651622        return EOK;
    16661623}
     1624
     1625#ifdef CONFIG_NETWORKING_modular
     1626
     1627#include <il_standalone.h>
    16671628
    16681629/** Default thread for new connections.
    … …  
    16921653               
    16931654                /* Process the message */
    1694                 int res = il_module_message_standalone(callid, &call, &answer,
    1695                     &answer_count);
     1655                int res = il_module_message(callid, &call, &answer, &answer_count);
    16961656               
    16971657                /* End if said to either by the message or the processing result */
    … …  
    17171677        ERROR_DECLARE;
    17181678       
     1679        /* Print the module label */
     1680        printf("Task %d - %s\n", task_get_id(), NAME);
     1681       
    17191682        /* Start the module */
    1720         if (ERROR_OCCURRED(il_module_start_standalone(il_client_connection)))
     1683        if (ERROR_OCCURRED(il_module_start(il_client_connection))) {
     1684                printf(" - ERROR %i\n", ERROR_CODE);
    17211685                return ERROR_CODE;
     1686        }
    17221687       
    17231688        return EOK;
    17241689}
    17251690
     1691#endif /* CONFIG_NETWORKING_modular */
     1692
    17261693/** @}
    17271694 */
Note: See TracChangeset for help on using the changeset viewer.