Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rccca251 r014dd57b  
    4141#include <stdio.h>
    4242#include <str.h>
     43#include <ipc/ipc.h>
    4344#include <ipc/services.h>
    4445#include <ipc/net.h>
    … …  
    6667#include <net_checksum.h>
    6768#include <icmp_client.h>
    68 #include <icmp_remote.h>
     69#include <icmp_interface.h>
    6970#include <ip_client.h>
    7071#include <ip_interface.h>
    … …  
    176177        socklen_t addrlen;
    177178
    178         /* Detach the first packet and release the others */
     179        // detach the first packet and release the others
    179180        next = pq_detach(packet);
    180181        if (next)
    … …  
    185186                        return ENOMEM;
    186187
    187                 /* Get header */
     188                // get header
    188189                header = (ip_header_t *) packet_get_data(packet);
    189190                if (!header)
    … …  
    192193        }
    193194
    194         /* Only for the first fragment */
     195        // only for the first fragment
    195196        if (IP_FRAGMENT_OFFSET(header))
    196197                return EINVAL;
    197198
    198         /* Not for the ICMP protocol */
     199        // not for the ICMP protocol
    199200        if (header->protocol == IPPROTO_ICMP)
    200201                return EPERM;
    201202
    202         /* Set the destination address */
     203        // set the destination address
    203204        switch (header->version) {
    204205        case IPVERSION:
    … …  
    351352        configuration = &names[0];
    352353
    353         /* Get configuration */
     354        // get configuration
    354355        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
    355356            &configuration, count, &data);
    … …  
    419420        }
    420421
    421         /* Bind netif service which also initializes the device */
     422        // binds the netif service which also initializes the device
    422423        ip_netif->phone = nil_bind_service(ip_netif->service,
    423424            (sysarg_t) ip_netif->device_id, SERVICE_IP,
    … …  
    429430        }
    430431
    431         /* Has to be after the device netif module initialization */
     432        // has to be after the device netif module initialization
    432433        if (ip_netif->arp) {
    433434                if (route) {
    … …  
    445446        }
    446447
    447         /* Get packet dimensions */
     448        // get packet dimensions
    448449        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
    449450            &ip_netif->packet_dimension);
    … …  
    463464       
    464465        if (gateway.s_addr) {
    465                 /* The default gateway */
     466                // the default gateway
    466467                ip_globals.gateway.address.s_addr = 0;
    467468                ip_globals.gateway.netmask.s_addr = 0;
    … …  
    505506        if (rc != EOK) {
    506507                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    507                 ip_routes_destroy(&ip_netif->routes, free);
     508                ip_routes_destroy(&ip_netif->routes);
    508509                free(ip_netif);
    509510                return rc;
    … …  
    512513                ip_netif->arp->usage++;
    513514
    514         /* Print the settings */
     515        // print the settings
    515516        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
    516517            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
    … …  
    587588        ip_netif_t *netif;
    588589
    589         /* Start with the last netif - the newest one */
     590        // start with the last netif - the newest one
    590591        index = ip_netifs_count(&ip_globals.netifs) - 1;
    591592        while (index >= 0) {
    … …  
    629630        size_t length;
    630631
    631         /* Copy first itself */
     632        // copy first itself
    632633        memcpy(last, first, sizeof(ip_header_t));
    633634        length = sizeof(ip_header_t);
    634635        next = sizeof(ip_header_t);
    635636
    636         /* Process all IP options */
     637        // process all ip options
    637638        while (next < first->header_length) {
    638639                option = (ip_option_t *) (((uint8_t *) first) + next);
    639                 /* Skip end or noop */
     640                // skip end or noop
    640641                if ((option->type == IPOPT_END) ||
    641642                    (option->type == IPOPT_NOOP)) {
    642643                        next++;
    643644                } else {
    644                         /* Copy if told so or skip */
     645                        // copy if told so or skip
    645646                        if (IPOPT_COPIED(option->type)) {
    646647                                memcpy(((uint8_t *) last) + length,
    … …  
    648649                                length += option->length;
    649650                        }
    650                         /* Next option */
     651                        // next option
    651652                        next += option->length;
    652653                }
    653654        }
    654655
    655         /* Align 4 byte boundary */
     656        // align 4 byte boundary
    656657        if (length % 4) {
    657658                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    … …  
    789790
    790791        header->total_length = htons(length);
    791         /* Unnecessary for all protocols */
     792        // unnecessary for all protocols
    792793        header->header_checksum = IP_HEADER_CHECKSUM(header);
    793794
    … …  
    916917                return ENOMEM;
    917918
    918         /* Get header */
     919        // get header
    919920        header = (ip_header_t *) packet_get_data(packet);
    920921        if (!header)
    921922                return EINVAL;
    922923
    923         /* Fragmentation forbidden? */
     924        // fragmentation forbidden?
    924925        if(header->flags & IPFLAG_DONT_FRAGMENT)
    925926                return EPERM;
    926927
    927         /* Create the last fragment */
     928        // create the last fragment
    928929        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
    929930            suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    … …  
    931932                return ENOMEM;
    932933
    933         /* Allocate as much as originally */
     934        // allocate as much as originally
    934935        last_header = (ip_header_t *) packet_suffix(new_packet,
    935936            IP_HEADER_LENGTH(header));
    … …  
    939940        ip_create_last_header(last_header, header);
    940941
    941         /* Trim the unused space */
     942        // trim the unused space
    942943        rc = packet_trim(new_packet, 0,
    943944            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
    … …  
    945946                return ip_release_and_return(packet, rc);
    946947
    947         /* Greatest multiple of 8 lower than content */
     948        // biggest multiple of 8 lower than content
    948949        // TODO even fragmentation?
    949950        length = length & ~0x7;
    … …  
    957958                return ip_release_and_return(packet, rc);
    958959
    959         /* Mark the first as fragmented */
     960        // mark the first as fragmented
    960961        header->flags |= IPFLAG_MORE_FRAGMENTS;
    961962
    962         /* Create middle fragments */
     963        // create middle framgents
    963964        while (IP_TOTAL_LENGTH(header) > length) {
    964965                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
    … …  
    981982        }
    982983
    983         /* Finish the first fragment */
     984        // finish the first fragment
    984985        header->header_checksum = IP_HEADER_CHECKSUM(header);
    985986
    … …  
    10121013
    10131014        next = packet;
    1014         /* Check all packets */
     1015        // check all packets
    10151016        while (next) {
    10161017                length = packet_get_data_length(next);
    … …  
    10211022                }
    10221023
    1023                 /* Too long */
     1024                // too long
    10241025                result = ip_fragment_packet(next, content, prefix,
    10251026                    suffix, addr_len);
    … …  
    10271028                        new_packet = pq_detach(next);
    10281029                        if (next == packet) {
    1029                                 /* The new first packet of the queue */
     1030                                // the new first packet of the queue
    10301031                                packet = new_packet;
    10311032                        }
    1032                         /* Fragmentation needed? */
     1033                        // fragmentation needed?
    10331034                        if (result == EPERM) {
    10341035                                phone = ip_prepare_icmp_and_get_phone(
    10351036                                    error, next, NULL);
    10361037                                if (phone >= 0) {
    1037                                         /* Fragmentation necessary ICMP */
     1038                                        // fragmentation necessary ICMP
    10381039                                        icmp_destination_unreachable_msg(phone,
    10391040                                            ICMP_FRAG_NEEDED, content, next);
    … …  
    10801081        int rc;
    10811082
    1082         /* Get destination hardware address */
     1083        // get destination hardware address
    10831084        if (netif->arp && (route->address.s_addr != dest.s_addr)) {
    10841085                destination.value = route->gateway.s_addr ?
    … …  
    11021103                            NULL);
    11031104                        if (phone >= 0) {
    1104                                 /* Unreachable ICMP if no routing */
     1105                                // unreachable ICMP if no routing
    11051106                                icmp_destination_unreachable_msg(phone,
    11061107                                    ICMP_HOST_UNREACH, 0, packet);
    … …  
    11481149        int rc;
    11491150
    1150         /*
    1151          * Addresses in the host byte order
    1152          * Should be the next hop address or the target destination address
    1153          */
     1151        // addresses in the host byte order
     1152        // should be the next hop address or the target destination address
    11541153        addrlen = packet_get_addr(packet, NULL, (uint8_t **) &addr);
    11551154        if (addrlen < 0)
    … …  
    11761175        fibril_rwlock_read_lock(&ip_globals.netifs_lock);
    11771176
    1178         /* Device specified? */
     1177        // device specified?
    11791178        if (device_id > 0) {
    11801179                netif = ip_netifs_find(&ip_globals.netifs, device_id);
    … …  
    11921191                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
    11931192                if (phone >= 0) {
    1194                         /* Unreachable ICMP if no routing */
     1193                        // unreachable ICMP if no routing
    11951194                        icmp_destination_unreachable_msg(phone,
    11961195                            ICMP_NET_UNREACH, 0, packet);
    … …  
    12001199
    12011200        if (error) {
    1202                 /*
    1203                  * Do not send for broadcast, anycast packets or network
    1204                  * broadcast.
    1205                  */
     1201                // do not send for broadcast, anycast packets or network
     1202                // broadcast
    12061203                if (!dest->s_addr || !(~dest->s_addr) ||
    12071204                    !(~((dest->s_addr & ~route->netmask.s_addr) |
    … …  
    12121209        }
    12131210       
    1214         /* If the local host is the destination */
     1211        // if the local host is the destination
    12151212        if ((route->address.s_addr == dest->s_addr) &&
    12161213            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    1217                 /* Find the loopback device to deliver */
     1214                // find the loopback device to deliver
    12181215                dest->s_addr = IPV4_LOCALHOST_ADDRESS;
    12191216                route = ip_find_route(*dest);
    … …  
    12241221                            NULL);
    12251222                        if (phone >= 0) {
    1226                                 /* Unreachable ICMP if no routing */
     1223                                // unreachable ICMP if no routing
    12271224                                icmp_destination_unreachable_msg(phone,
    12281225                                    ICMP_HOST_UNREACH, 0, packet);
    … …  
    12561253
    12571254        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    1258         /* Find the device */
     1255        // find the device
    12591256        netif = ip_netifs_find(&ip_globals.netifs, device_id);
    12601257        if (!netif) {
    … …  
    13481345                return ip_release_and_return(packet, rc);
    13491346
    1350         /* Trim padding if present */
     1347        // trim padding if present
    13511348        if (!error &&
    13521349            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
    … …  
    13641361                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
    13651362                if (phone >= 0) {
    1366                         /* Unreachable ICMP */
     1363                        // unreachable ICMP
    13671364                        icmp_destination_unreachable_msg(phone,
    13681365                            ICMP_PROT_UNREACH, 0, packet);
    … …  
    14211418                return ip_release_and_return(packet, ENOMEM);
    14221419
    1423         /* Checksum */
     1420        // checksum
    14241421        if ((header->header_checksum) &&
    14251422            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
    14261423                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14271424                if (phone >= 0) {
    1428                         /* Checksum error ICMP */
     1425                        // checksum error ICMP
    14291426                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
    14301427                            ((size_t) ((void *) &header->header_checksum)) -
    … …  
    14371434                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14381435                if (phone >= 0) {
    1439                         /* TTL exceeded ICMP */
     1436                        // ttl exceeded ICMP
    14401437                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14411438                }
    … …  
    14431440        }
    14441441       
    1445         /* Process ipopt and get destination */
     1442        // process ipopt and get destination
    14461443        dest = ip_get_destination(header);
    14471444
    1448         /* Set the destination address */
     1445        // set the addrination address
    14491446        switch (header->version) {
    14501447        case IPVERSION:
    … …  
    14681465                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14691466                if (phone >= 0) {
    1470                         /* Unreachable ICMP */
     1467                        // unreachable ICMP
    14711468                        icmp_destination_unreachable_msg(phone,
    14721469                            ICMP_HOST_UNREACH, 0, packet);
    … …  
    14761473
    14771474        if (route->address.s_addr == dest.s_addr) {
    1478                 /* Local delivery */
     1475                // local delivery
    14791476                return ip_deliver_local(device_id, packet, header, 0);
    14801477        }
    … …  
    14881485        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14891486        if (phone >= 0) {
    1490                 /* Unreachable ICMP if no routing */
     1487                // unreachable ICMP if no routing
    14911488                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
    14921489                    packet);
    … …  
    15991596                        rc = ip_device_state_message(IPC_GET_DEVICE(*icall),
    16001597                            IPC_GET_STATE(*icall));
    1601                         async_answer_0(iid, (sysarg_t) rc);
     1598                        ipc_answer_0(iid, (sysarg_t) rc);
    16021599                        break;
    16031600               
    … …  
    16131610                        }
    16141611                       
    1615                         async_answer_0(iid, (sysarg_t) rc);
     1612                        ipc_answer_0(iid, (sysarg_t) rc);
    16161613                        break;
    16171614               
    … …  
    16191616                        rc = ip_mtu_changed_message(IPC_GET_DEVICE(*icall),
    16201617                            IPC_GET_MTU(*icall));
    1621                         async_answer_0(iid, (sysarg_t) rc);
     1618                        ipc_answer_0(iid, (sysarg_t) rc);
    16221619                        break;
    16231620               
    16241621                default:
    1625                         async_answer_0(iid, (sysarg_t) ENOTSUP);
     1622                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
    16261623                }
    16271624               
    … …  
    17741771                header = (ip_header_t *)(data + offset);
    17751772
    1776                 /* Destination host unreachable? */
     1773                // destination host unreachable?
    17771774                if ((type != ICMP_DEST_UNREACH) ||
    17781775                    (code != ICMP_HOST_UNREACH)) {
    1779                         /* No, something else */
     1776                        // no, something else
    17801777                        break;
    17811778                }
    … …  
    17911788                route = ip_routes_get_index(&netif->routes, 0);
    17921789
    1793                 /* From the same network? */
     1790                // from the same network?
    17941791                if (route && ((route->address.s_addr & route->netmask.s_addr) ==
    17951792                    (header->destination_address & route->netmask.s_addr))) {
    1796                         /* Clear the ARP mapping if any */
     1793                        // clear the ARP mapping if any
    17971794                        address.value = (uint8_t *) &header->destination_address;
    17981795                        address.length = sizeof(header->destination_address);
    … …  
    18481845        fibril_rwlock_read_lock(&ip_globals.lock);
    18491846        route = ip_find_route(*dest);
    1850         /* If the local host is the destination */
     1847        // if the local host is the destination
    18511848        if (route && (route->address.s_addr == dest->s_addr) &&
    18521849            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    1853                 /* Find the loopback device to deliver */
     1850                // find the loopback device to deliver
    18541851                dest->s_addr = IPV4_LOCALHOST_ADDRESS;
    18551852                route = ip_find_route(*dest);
Note: See TracChangeset for help on using the changeset viewer.