Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/il/ip/ip.c

    r774e6d1a r7880d58  
    275275        if (rc != EOK)
    276276                goto out;
    277         rc = add_module(NULL, &ip_globals.modules, (uint8_t *) ARP_NAME,
    278             (uint8_t *) ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module);
     277        rc = add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME,
     278            SERVICE_ARP, 0, arp_connect_module);
    279279
    280280out:
     
    312312        measured_string_t names[] = {
    313313                {
    314                         (uint8_t *) "IPV",
     314                        (char *) "IPV",
    315315                        3
    316316                },
    317317                {
    318                         (uint8_t *) "IP_CONFIG",
     318                        (char *) "IP_CONFIG",
    319319                        9
    320320                },
    321321                {
    322                         (uint8_t *) "IP_ADDR",
     322                        (char *) "IP_ADDR",
    323323                        7
    324324                },
    325325                {
    326                         (uint8_t *) "IP_NETMASK",
     326                        (char *) "IP_NETMASK",
    327327                        10
    328328                },
    329329                {
    330                         (uint8_t *) "IP_GATEWAY",
     330                        (char *) "IP_GATEWAY",
    331331                        10
    332332                },
    333333                {
    334                         (uint8_t *) "IP_BROADCAST",
     334                        (char *) "IP_BROADCAST",
    335335                        12
    336336                },
    337337                {
    338                         (uint8_t *) "ARP",
     338                        (char *) "ARP",
    339339                        3
    340340                },
    341341                {
    342                         (uint8_t *) "IP_ROUTING",
     342                        (char *) "IP_ROUTING",
    343343                        10
    344344                }
     
    346346        measured_string_t *configuration;
    347347        size_t count = sizeof(names) / sizeof(measured_string_t);
    348         uint8_t *data;
     348        char *data;
    349349        measured_string_t address;
    350350        ip_route_t *route;
     
    368368        if (configuration) {
    369369                if (configuration[0].value)
    370                         ip_netif->ipv = strtol((char *) configuration[0].value, NULL, 0);
    371                
    372                 ip_netif->dhcp = !str_lcmp((char *) configuration[1].value, "dhcp",
     370                        ip_netif->ipv = strtol(configuration[0].value, NULL, 0);
     371
     372                ip_netif->dhcp = !str_lcmp(configuration[1].value, "dhcp",
    373373                    configuration[1].length);
    374374               
     
    394394                        }
    395395                       
    396                         if ((inet_pton(AF_INET, (char *) configuration[2].value,
     396                        if ((inet_pton(AF_INET, configuration[2].value,
    397397                            (uint8_t *) &route->address.s_addr) != EOK) ||
    398                             (inet_pton(AF_INET, (char *) configuration[3].value,
     398                            (inet_pton(AF_INET, configuration[3].value,
    399399                            (uint8_t *) &route->netmask.s_addr) != EOK) ||
    400                             (inet_pton(AF_INET, (char *) configuration[4].value,
     400                            (inet_pton(AF_INET, configuration[4].value,
    401401                            (uint8_t *) &gateway.s_addr) == EINVAL) ||
    402                             (inet_pton(AF_INET, (char *) configuration[5].value,
     402                            (inet_pton(AF_INET, configuration[5].value,
    403403                            (uint8_t *) &ip_netif->broadcast.s_addr) == EINVAL))
    404404                            {
     
    441441        if (ip_netif->arp) {
    442442                if (route) {
    443                         address.value = (uint8_t *) &route->address.s_addr;
     443                        address.value = (char *) &route->address.s_addr;
    444444                        address.length = sizeof(in_addr_t);
    445445                       
     
    477477                ip_globals.gateway.gateway.s_addr = gateway.s_addr;
    478478                ip_globals.gateway.netif = ip_netif;
    479                
    480                 char defgateway[INET_ADDRSTRLEN];
    481                 inet_ntop(AF_INET, (uint8_t *) &gateway.s_addr,
    482                     defgateway, INET_ADDRSTRLEN);
    483                 printf("%s: Default gateway (%s)\n", NAME, defgateway);
    484479        }
    485480
     
    1002997        measured_string_t destination;
    1003998        measured_string_t *translation;
    1004         uint8_t *data;
     999        char *data;
    10051000        int phone;
    10061001        int rc;
     
    10091004        if (netif->arp && (route->address.s_addr != dest.s_addr)) {
    10101005                destination.value = route->gateway.s_addr ?
    1011                     (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr;
     1006                    (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
    10121007                destination.length = sizeof(dest.s_addr);
    10131008
     
    10741069        int index;
    10751070        ip_route_t *route;
    1076        
     1071
    10771072        if (!netif)
    10781073                return NULL;
    1079        
    1080         /* Start with the first one (the direct route) */
     1074
     1075        // start with the first one - the direct route
    10811076        for (index = 0; index < ip_routes_count(&netif->routes); index++) {
    10821077                route = ip_routes_get_index(&netif->routes, index);
    1083                 if ((route) &&
     1078                if (route &&
    10841079                    ((route->address.s_addr & route->netmask.s_addr) ==
    1085                     (destination.s_addr & route->netmask.s_addr)))
     1080                    (destination.s_addr & route->netmask.s_addr))) {
    10861081                        return route;
     1082                }
    10871083        }
    10881084
     
    12921288        if (device_id > 0) {
    12931289                netif = ip_netifs_find(&ip_globals.netifs, device_id);
    1294                 route = ip_netif_find_route(netif, *dest);
     1290                route = ip_netif_find_route(netif, * dest);
    12951291                if (netif && !route && (ip_globals.gateway.netif == netif))
    12961292                        route = &ip_globals.gateway;
     
    13221318                }
    13231319        }
    1324        
     1320
    13251321        // if the local host is the destination
    13261322        if ((route->address.s_addr == dest->s_addr) &&
     
    15661562        socklen_t addrlen;
    15671563        int rc;
    1568        
     1564
    15691565        header = (ip_header_t *) packet_get_data(packet);
    15701566        if (!header)
     
    15921588                return EINVAL;
    15931589        }
    1594        
     1590
    15951591        // process ipopt and get destination
    15961592        dest = ip_get_destination(header);
     
    16131609        if (rc != EOK)
    16141610                return rc;
    1615        
     1611
    16161612        route = ip_find_route(dest);
    16171613        if (!route) {
     
    17601756                    (header->destination_address & route->netmask.s_addr))) {
    17611757                        // clear the ARP mapping if any
    1762                         address.value = (uint8_t *) &header->destination_address;
     1758                        address.value = (char *) &header->destination_address;
    17631759                        address.length = sizeof(header->destination_address);
    17641760                        arp_clear_address_req(netif->arp->phone,
     
    18901886int
    18911887ip_message_standalone(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
    1892     size_t *answer_count)
     1888    int *answer_count)
    18931889{
    18941890        packet_t *packet;
     
    19091905       
    19101906        case IPC_M_CONNECT_TO_ME:
    1911                 return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
    1912                     IPC_GET_PHONE(*call), NULL);
     1907                return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call),
     1908                    IPC_GET_PHONE(call), NULL);
    19131909       
    19141910        case NET_IL_DEVICE:
    1915                 return ip_device_req_local(0, IPC_GET_DEVICE(*call),
    1916                     IPC_GET_SERVICE(*call));
     1911                return ip_device_req_local(0, IPC_GET_DEVICE(call),
     1912                    IPC_GET_SERVICE(call));
    19171913       
    19181914        case NET_IL_SEND:
    19191915                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    1920                     IPC_GET_PACKET(*call));
     1916                    IPC_GET_PACKET(call));
    19211917                if (rc != EOK)
    19221918                        return rc;
    1923                 return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
    1924                     IPC_GET_ERROR(*call));
     1919                return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
     1920                    IPC_GET_ERROR(call));
    19251921       
    19261922        case NET_IL_DEVICE_STATE:
    1927                 return ip_device_state_message(IPC_GET_DEVICE(*call),
    1928                     IPC_GET_STATE(*call));
     1923                return ip_device_state_message(IPC_GET_DEVICE(call),
     1924                    IPC_GET_STATE(call));
    19291925       
    19301926        case NET_IL_RECEIVED:
    19311927                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    1932                     IPC_GET_PACKET(*call));
     1928                    IPC_GET_PACKET(call));
    19331929                if (rc != EOK)
    19341930                        return rc;
    1935                 return ip_receive_message(IPC_GET_DEVICE(*call), packet);
     1931                return ip_receive_message(IPC_GET_DEVICE(call), packet);
    19361932       
    19371933        case NET_IP_RECEIVED_ERROR:
    19381934                rc = packet_translate_remote(ip_globals.net_phone, &packet,
    1939                     IPC_GET_PACKET(*call));
     1935                    IPC_GET_PACKET(call));
    19401936                if (rc != EOK)
    19411937                        return rc;
    1942                 return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
    1943                     packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call));
     1938                return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
     1939                    packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
    19441940       
    19451941        case NET_IP_ADD_ROUTE:
    1946                 return ip_add_route_req_local(0, IPC_GET_DEVICE(*call),
    1947                     IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call),
    1948                     IP_GET_GATEWAY(*call));
     1942                return ip_add_route_req_local(0, IPC_GET_DEVICE(call),
     1943                    IP_GET_ADDRESS(call), IP_GET_NETMASK(call),
     1944                    IP_GET_GATEWAY(call));
    19491945
    19501946        case NET_IP_SET_GATEWAY:
    1951                 return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call),
    1952                     IP_GET_GATEWAY(*call));
     1947                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(call),
     1948                    IP_GET_GATEWAY(call));
    19531949
    19541950        case NET_IP_GET_ROUTE:
     
    19581954                        return rc;
    19591955               
    1960                 rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
     1956                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(call), addr,
    19611957                    (socklen_t) addrlen, &device_id, &header, &headerlen);
    19621958                if (rc != EOK)
    19631959                        return rc;
    19641960               
    1965                 IPC_SET_DEVICE(*answer, device_id);
    1966                 IP_SET_HEADERLEN(*answer, headerlen);
     1961                IPC_SET_DEVICE(answer, device_id);
     1962                IP_SET_HEADERLEN(answer, headerlen);
    19671963               
    19681964                *answer_count = 2;
     
    19761972       
    19771973        case NET_IL_PACKET_SPACE:
    1978                 rc = ip_packet_size_message(IPC_GET_DEVICE(*call), &addrlen,
     1974                rc = ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen,
    19791975                    &prefix, &content, &suffix);
    19801976                if (rc != EOK)
    19811977                        return rc;
    19821978               
    1983                 IPC_SET_ADDR(*answer, addrlen);
    1984                 IPC_SET_PREFIX(*answer, prefix);
    1985                 IPC_SET_CONTENT(*answer, content);
    1986                 IPC_SET_SUFFIX(*answer, suffix);
     1979                IPC_SET_ADDR(answer, addrlen);
     1980                IPC_SET_PREFIX(answer, prefix);
     1981                IPC_SET_CONTENT(answer, content);
     1982                IPC_SET_SUFFIX(answer, suffix);
    19871983                *answer_count = 4;
    19881984                return EOK;
    19891985       
    19901986        case NET_IL_MTU_CHANGED:
    1991                 return ip_mtu_changed_message(IPC_GET_DEVICE(*call),
    1992                     IPC_GET_MTU(*call));
     1987                return ip_mtu_changed_message(IPC_GET_DEVICE(call),
     1988                    IPC_GET_MTU(call));
    19931989        }
    19941990       
     
    20112007        while (true) {
    20122008                ipc_call_t answer;
    2013                 size_t count;
     2009                int answer_count;
    20142010               
    20152011                /* Clear the answer structure */
    2016                 refresh_answer(&answer, &count);
     2012                refresh_answer(&answer, &answer_count);
    20172013               
    20182014                /* Fetch the next message */
     
    20222018                /* Process the message */
    20232019                int res = il_module_message_standalone(callid, &call, &answer,
    2024                     &count);
     2020                    &answer_count);
    20252021               
    20262022                /*
     
    20342030               
    20352031                /* Answer the message */
    2036                 answer_call(callid, res, &answer, count);
     2032                answer_call(callid, res, &answer, answer_count);
    20372033        }
    20382034}
Note: See TracChangeset for help on using the changeset viewer.