Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rccca251 r5fe7692  
    176176        socklen_t addrlen;
    177177
    178         /* Detach the first packet and release the others */
     178        // detach the first packet and release the others
    179179        next = pq_detach(packet);
    180180        if (next)
    … …  
    185185                        return ENOMEM;
    186186
    187                 /* Get header */
     187                // get header
    188188                header = (ip_header_t *) packet_get_data(packet);
    189189                if (!header)
    … …  
    192192        }
    193193
    194         /* Only for the first fragment */
     194        // only for the first fragment
    195195        if (IP_FRAGMENT_OFFSET(header))
    196196                return EINVAL;
    197197
    198         /* Not for the ICMP protocol */
     198        // not for the ICMP protocol
    199199        if (header->protocol == IPPROTO_ICMP)
    200200                return EPERM;
    201201
    202         /* Set the destination address */
     202        // set the destination address
    203203        switch (header->version) {
    204204        case IPVERSION:
    … …  
    351351        configuration = &names[0];
    352352
    353         /* Get configuration */
     353        // get configuration
    354354        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
    355355            &configuration, count, &data);
    … …  
    419419        }
    420420
    421         /* Bind netif service which also initializes the device */
     421        // binds the netif service which also initializes the device
    422422        ip_netif->phone = nil_bind_service(ip_netif->service,
    423423            (sysarg_t) ip_netif->device_id, SERVICE_IP,
    … …  
    429429        }
    430430
    431         /* Has to be after the device netif module initialization */
     431        // has to be after the device netif module initialization
    432432        if (ip_netif->arp) {
    433433                if (route) {
    … …  
    445445        }
    446446
    447         /* Get packet dimensions */
     447        // get packet dimensions
    448448        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
    449449            &ip_netif->packet_dimension);
    … …  
    463463       
    464464        if (gateway.s_addr) {
    465                 /* The default gateway */
     465                // the default gateway
    466466                ip_globals.gateway.address.s_addr = 0;
    467467                ip_globals.gateway.netmask.s_addr = 0;
    … …  
    512512                ip_netif->arp->usage++;
    513513
    514         /* Print the settings */
     514        // print the settings
    515515        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
    516516            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
    … …  
    587587        ip_netif_t *netif;
    588588
    589         /* Start with the last netif - the newest one */
     589        // start with the last netif - the newest one
    590590        index = ip_netifs_count(&ip_globals.netifs) - 1;
    591591        while (index >= 0) {
    … …  
    629629        size_t length;
    630630
    631         /* Copy first itself */
     631        // copy first itself
    632632        memcpy(last, first, sizeof(ip_header_t));
    633633        length = sizeof(ip_header_t);
    634634        next = sizeof(ip_header_t);
    635635
    636         /* Process all IP options */
     636        // process all ip options
    637637        while (next < first->header_length) {
    638638                option = (ip_option_t *) (((uint8_t *) first) + next);
    639                 /* Skip end or noop */
     639                // skip end or noop
    640640                if ((option->type == IPOPT_END) ||
    641641                    (option->type == IPOPT_NOOP)) {
    642642                        next++;
    643643                } else {
    644                         /* Copy if told so or skip */
     644                        // copy if told so or skip
    645645                        if (IPOPT_COPIED(option->type)) {
    646646                                memcpy(((uint8_t *) last) + length,
    … …  
    648648                                length += option->length;
    649649                        }
    650                         /* Next option */
     650                        // next option
    651651                        next += option->length;
    652652                }
    653653        }
    654654
    655         /* Align 4 byte boundary */
     655        // align 4 byte boundary
    656656        if (length % 4) {
    657657                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    … …  
    789789
    790790        header->total_length = htons(length);
    791         /* Unnecessary for all protocols */
     791        // unnecessary for all protocols
    792792        header->header_checksum = IP_HEADER_CHECKSUM(header);
    793793
    … …  
    916916                return ENOMEM;
    917917
    918         /* Get header */
     918        // get header
    919919        header = (ip_header_t *) packet_get_data(packet);
    920920        if (!header)
    921921                return EINVAL;
    922922
    923         /* Fragmentation forbidden? */
     923        // fragmentation forbidden?
    924924        if(header->flags & IPFLAG_DONT_FRAGMENT)
    925925                return EPERM;
    926926
    927         /* Create the last fragment */
     927        // create the last fragment
    928928        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
    929929            suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    … …  
    931931                return ENOMEM;
    932932
    933         /* Allocate as much as originally */
     933        // allocate as much as originally
    934934        last_header = (ip_header_t *) packet_suffix(new_packet,
    935935            IP_HEADER_LENGTH(header));
    … …  
    939939        ip_create_last_header(last_header, header);
    940940
    941         /* Trim the unused space */
     941        // trim the unused space
    942942        rc = packet_trim(new_packet, 0,
    943943            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
    … …  
    945945                return ip_release_and_return(packet, rc);
    946946
    947         /* Greatest multiple of 8 lower than content */
     947        // biggest multiple of 8 lower than content
    948948        // TODO even fragmentation?
    949949        length = length & ~0x7;
    … …  
    957957                return ip_release_and_return(packet, rc);
    958958
    959         /* Mark the first as fragmented */
     959        // mark the first as fragmented
    960960        header->flags |= IPFLAG_MORE_FRAGMENTS;
    961961
    962         /* Create middle fragments */
     962        // create middle framgents
    963963        while (IP_TOTAL_LENGTH(header) > length) {
    964964                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
    … …  
    981981        }
    982982
    983         /* Finish the first fragment */
     983        // finish the first fragment
    984984        header->header_checksum = IP_HEADER_CHECKSUM(header);
    985985
    … …  
    10121012
    10131013        next = packet;
    1014         /* Check all packets */
     1014        // check all packets
    10151015        while (next) {
    10161016                length = packet_get_data_length(next);
    … …  
    10211021                }
    10221022
    1023                 /* Too long */
     1023                // too long
    10241024                result = ip_fragment_packet(next, content, prefix,
    10251025                    suffix, addr_len);
    … …  
    10271027                        new_packet = pq_detach(next);
    10281028                        if (next == packet) {
    1029                                 /* The new first packet of the queue */
     1029                                // the new first packet of the queue
    10301030                                packet = new_packet;
    10311031                        }
    1032                         /* Fragmentation needed? */
     1032                        // fragmentation needed?
    10331033                        if (result == EPERM) {
    10341034                                phone = ip_prepare_icmp_and_get_phone(
    10351035                                    error, next, NULL);
    10361036                                if (phone >= 0) {
    1037                                         /* Fragmentation necessary ICMP */
     1037                                        // fragmentation necessary ICMP
    10381038                                        icmp_destination_unreachable_msg(phone,
    10391039                                            ICMP_FRAG_NEEDED, content, next);
    … …  
    10801080        int rc;
    10811081
    1082         /* Get destination hardware address */
     1082        // get destination hardware address
    10831083        if (netif->arp && (route->address.s_addr != dest.s_addr)) {
    10841084                destination.value = route->gateway.s_addr ?
    … …  
    11021102                            NULL);
    11031103                        if (phone >= 0) {
    1104                                 /* Unreachable ICMP if no routing */
     1104                                // unreachable ICMP if no routing
    11051105                                icmp_destination_unreachable_msg(phone,
    11061106                                    ICMP_HOST_UNREACH, 0, packet);
    … …  
    11481148        int rc;
    11491149
    1150         /*
    1151          * Addresses in the host byte order
    1152          * Should be the next hop address or the target destination address
    1153          */
     1150        // addresses in the host byte order
     1151        // should be the next hop address or the target destination address
    11541152        addrlen = packet_get_addr(packet, NULL, (uint8_t **) &addr);
    11551153        if (addrlen < 0)
    … …  
    11761174        fibril_rwlock_read_lock(&ip_globals.netifs_lock);
    11771175
    1178         /* Device specified? */
     1176        // device specified?
    11791177        if (device_id > 0) {
    11801178                netif = ip_netifs_find(&ip_globals.netifs, device_id);
    … …  
    11921190                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
    11931191                if (phone >= 0) {
    1194                         /* Unreachable ICMP if no routing */
     1192                        // unreachable ICMP if no routing
    11951193                        icmp_destination_unreachable_msg(phone,
    11961194                            ICMP_NET_UNREACH, 0, packet);
    … …  
    12001198
    12011199        if (error) {
    1202                 /*
    1203                  * Do not send for broadcast, anycast packets or network
    1204                  * broadcast.
    1205                  */
     1200                // do not send for broadcast, anycast packets or network
     1201                // broadcast
    12061202                if (!dest->s_addr || !(~dest->s_addr) ||
    12071203                    !(~((dest->s_addr & ~route->netmask.s_addr) |
    … …  
    12121208        }
    12131209       
    1214         /* If the local host is the destination */
     1210        // if the local host is the destination
    12151211        if ((route->address.s_addr == dest->s_addr) &&
    12161212            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    1217                 /* Find the loopback device to deliver */
     1213                // find the loopback device to deliver
    12181214                dest->s_addr = IPV4_LOCALHOST_ADDRESS;
    12191215                route = ip_find_route(*dest);
    … …  
    12241220                            NULL);
    12251221                        if (phone >= 0) {
    1226                                 /* Unreachable ICMP if no routing */
     1222                                // unreachable ICMP if no routing
    12271223                                icmp_destination_unreachable_msg(phone,
    12281224                                    ICMP_HOST_UNREACH, 0, packet);
    … …  
    12561252
    12571253        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    1258         /* Find the device */
     1254        // find the device
    12591255        netif = ip_netifs_find(&ip_globals.netifs, device_id);
    12601256        if (!netif) {
    … …  
    13481344                return ip_release_and_return(packet, rc);
    13491345
    1350         /* Trim padding if present */
     1346        // trim padding if present
    13511347        if (!error &&
    13521348            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
    … …  
    13641360                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
    13651361                if (phone >= 0) {
    1366                         /* Unreachable ICMP */
     1362                        // unreachable ICMP
    13671363                        icmp_destination_unreachable_msg(phone,
    13681364                            ICMP_PROT_UNREACH, 0, packet);
    … …  
    14211417                return ip_release_and_return(packet, ENOMEM);
    14221418
    1423         /* Checksum */
     1419        // checksum
    14241420        if ((header->header_checksum) &&
    14251421            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
    14261422                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14271423                if (phone >= 0) {
    1428                         /* Checksum error ICMP */
     1424                        // checksum error ICMP
    14291425                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
    14301426                            ((size_t) ((void *) &header->header_checksum)) -
    … …  
    14371433                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14381434                if (phone >= 0) {
    1439                         /* TTL exceeded ICMP */
     1435                        // ttl exceeded ICMP
    14401436                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14411437                }
    … …  
    14431439        }
    14441440       
    1445         /* Process ipopt and get destination */
     1441        // process ipopt and get destination
    14461442        dest = ip_get_destination(header);
    14471443
    1448         /* Set the destination address */
     1444        // set the addrination address
    14491445        switch (header->version) {
    14501446        case IPVERSION:
    … …  
    14681464                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14691465                if (phone >= 0) {
    1470                         /* Unreachable ICMP */
     1466                        // unreachable ICMP
    14711467                        icmp_destination_unreachable_msg(phone,
    14721468                            ICMP_HOST_UNREACH, 0, packet);
    … …  
    14761472
    14771473        if (route->address.s_addr == dest.s_addr) {
    1478                 /* Local delivery */
     1474                // local delivery
    14791475                return ip_deliver_local(device_id, packet, header, 0);
    14801476        }
    … …  
    14881484        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14891485        if (phone >= 0) {
    1490                 /* Unreachable ICMP if no routing */
     1486                // unreachable ICMP if no routing
    14911487                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
    14921488                    packet);
    … …  
    17741770                header = (ip_header_t *)(data + offset);
    17751771
    1776                 /* Destination host unreachable? */
     1772                // destination host unreachable?
    17771773                if ((type != ICMP_DEST_UNREACH) ||
    17781774                    (code != ICMP_HOST_UNREACH)) {
    1779                         /* No, something else */
     1775                        // no, something else
    17801776                        break;
    17811777                }
    … …  
    17911787                route = ip_routes_get_index(&netif->routes, 0);
    17921788
    1793                 /* From the same network? */
     1789                // from the same network?
    17941790                if (route && ((route->address.s_addr & route->netmask.s_addr) ==
    17951791                    (header->destination_address & route->netmask.s_addr))) {
    1796                         /* Clear the ARP mapping if any */
     1792                        // clear the ARP mapping if any
    17971793                        address.value = (uint8_t *) &header->destination_address;
    17981794                        address.length = sizeof(header->destination_address);
    … …  
    18481844        fibril_rwlock_read_lock(&ip_globals.lock);
    18491845        route = ip_find_route(*dest);
    1850         /* If the local host is the destination */
     1846        // if the local host is the destination
    18511847        if (route && (route->address.s_addr == dest->s_addr) &&
    18521848            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    1853                 /* Find the loopback device to deliver */
     1849                // find the loopback device to deliver
    18541850                dest->s_addr = IPV4_LOCALHOST_ADDRESS;
    18551851                route = ip_find_route(*dest);
Note: See TracChangeset for help on using the changeset viewer.