Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/tl/icmp/icmp.c

    r014dd57b rffa2c8ef  
    3333/** @file
    3434 * ICMP module implementation.
    35  * @see icmp.h
    3635 */
    3736
    … …  
    4241#include <stdint.h>
    4342#include <str.h>
    44 #include <ipc/ipc.h>
    4543#include <ipc/services.h>
    4644#include <ipc/net.h>
    … …  
    5149#include <byteorder.h>
    5250#include <errno.h>
     51#include <adt/hash_table.h>
    5352
    5453#include <net/socket_codes.h>
    … …  
    6463#include <net_checksum.h>
    6564#include <icmp_client.h>
    66 #include <icmp_interface.h>
     65#include <icmp_remote.h>
    6766#include <il_remote.h>
    6867#include <ip_client.h>
    … …  
    7372#include <icmp_header.h>
    7473
    75 #include "icmp.h"
    76 
    77 /** ICMP module name. */
     74/** ICMP module name */
    7875#define NAME  "icmp"
    7976
    80 /** Default ICMP error reporting. */
    81 #define NET_DEFAULT_ICMP_ERROR_REPORTING        true
    82 
    83 /** Default ICMP echo replying. */
    84 #define NET_DEFAULT_ICMP_ECHO_REPLYING          true
    85 
    86 /** Original datagram length in bytes transfered to the error notification
    87  * message.
    88  */
    89 #define ICMP_KEEP_LENGTH        8
    90 
    91 /** Free identifier numbers pool start. */
    92 #define ICMP_FREE_IDS_START     1
    93 
    94 /** Free identifier numbers pool end. */
    95 #define ICMP_FREE_IDS_END       UINT16_MAX
    96 
    97 /** Computes the ICMP datagram checksum.
    98  *
    99  * @param[in,out] header The ICMP datagram header.
    100  * @param[in] length    The total datagram length.
    101  * @return              The computed checksum.
     77/** Number of replies hash table keys */
     78#define REPLY_KEYS  2
     79
     80/** Number of replies hash table buckets */
     81#define REPLY_BUCKETS  1024
     82
     83/**
     84 * Original datagram length in bytes transfered to the error
     85 * notification message.
     86 */
     87#define ICMP_KEEP_LENGTH  8
     88
     89/** Compute the ICMP datagram checksum.
     90 *
     91 * @param[in,out] header ICMP datagram header.
     92 * @param[in]     length Total datagram length.
     93 *
     94 * @return Computed checksum.
     95 *
    10296 */
    10397#define ICMP_CHECKSUM(header, length) \
    … …  
    10599
    106100/** An echo request datagrams pattern. */
    107 #define ICMP_ECHO_TEXT          "Hello from HelenOS."
    108 
    109 /** Computes an ICMP reply data key.
    110  *
    111  * @param[in] id        The message identifier.
    112  * @param[in] sequence  The message sequence number.
    113  * @return              The computed ICMP reply data key.
    114  */
    115 #define ICMP_GET_REPLY_KEY(id, sequence) \
    116         (((id) << 16) | (sequence & 0xFFFF))
    117 
    118 
    119 /** ICMP global data. */
    120 icmp_globals_t  icmp_globals;
    121 
    122 INT_MAP_IMPLEMENT(icmp_replies, icmp_reply_t);
    123 INT_MAP_IMPLEMENT(icmp_echo_data, icmp_echo_t);
    124 
    125 /** Releases the packet and returns the result.
    126  *
    127  * @param[in] packet    The packet queue to be released.
    128  * @param[in] result    The result to be returned.
    129  * @return              The result parameter.
    130  */
    131 static int icmp_release_and_return(packet_t *packet, int result)
    132 {
    133         pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
    134         return result;
    135 }
    136 
    137 /** Sends the ICMP message.
    138  *
    139  * Sets the message type and code and computes the checksum.
     101#define ICMP_ECHO_TEXT  "ICMP hello from HelenOS."
     102
     103/** ICMP reply data. */
     104typedef struct {
     105        /** Hash table link */
     106        link_t link;
     107       
     108        /** Reply identification and sequence */
     109        icmp_param_t id;
     110        icmp_param_t sequence;
     111       
     112        /** Reply signaling */
     113        fibril_condvar_t condvar;
     114       
     115        /** Reply result */
     116        int result;
     117} icmp_reply_t;
     118
     119/** Global data */
     120static int phone_net = -1;
     121static int phone_ip = -1;
     122static bool error_reporting = true;
     123static bool echo_replying = true;
     124static packet_dimension_t icmp_dimension;
     125
     126/** ICMP client identification counter */
     127static atomic_t icmp_client;
     128
     129/** ICMP identifier and sequence number (client-specific) */
     130static fibril_local icmp_param_t icmp_id;
     131static fibril_local icmp_param_t icmp_seq;
     132
     133/** Reply hash table */
     134static fibril_mutex_t reply_lock;
     135static hash_table_t replies;
     136
     137static hash_index_t replies_hash(unsigned long key[])
     138{
     139        /*
     140         * ICMP identifier and sequence numbers
     141         * are 16-bit values.
     142         */
     143        hash_index_t index = ((key[0] & 0xffff) << 16) | (key[1] & 0xffff);
     144        return (index % REPLY_BUCKETS);
     145}
     146
     147static int replies_compare(unsigned long key[], hash_count_t keys, link_t *item)
     148{
     149        icmp_reply_t *reply =
     150            hash_table_get_instance(item, icmp_reply_t, link);
     151       
     152        if (keys == 1)
     153                return (reply->id == key[0]);
     154        else
     155                return ((reply->id == key[0]) && (reply->sequence == key[1]));
     156}
     157
     158static void replies_remove_callback(link_t *item)
     159{
     160}
     161
     162static hash_table_operations_t reply_ops = {
     163        .hash = replies_hash,
     164        .compare = replies_compare,
     165        .remove_callback = replies_remove_callback
     166};
     167
     168/** Release the packet and return the result.
     169 *
     170 * @param[in] packet Packet queue to be released.
     171 *
     172 */
     173static void icmp_release(packet_t *packet)
     174{
     175        pq_release_remote(phone_net, packet_get_id(packet));
     176}
     177
     178/** Send the ICMP message.
     179 *
     180 * Set the message type and code and compute the checksum.
    140181 * Error messages are sent only if allowed in the configuration.
    141  * Releases the packet on errors.
    142  *
    143  * @param[in] type      The message type.
    144  * @param[in] code      The message code.
    145  * @param[in] packet    The message packet to be sent.
    146  * @param[in] header    The ICMP header.
    147  * @param[in] error     The error service to be announced. Should be
    148  *                      SERVICE_ICMP or zero.
    149  * @param[in] ttl       The time to live.
    150  * @param[in] tos       The type of service.
    151  * @param[in] dont_fragment The value indicating whether the datagram must not
    152  *                      be fragmented. Is used as a MTU discovery.
    153  * @return              EOK on success.
    154  * @return              EPERM if the error message is not allowed.
    155  */
    156 static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t *packet,
    157     icmp_header_t *header, services_t error, ip_ttl_t ttl, ip_tos_t tos,
    158     int dont_fragment)
    159 {
    160         int rc;
    161 
     182 * Release the packet on errors.
     183 *
     184 * @param[in] type          Message type.
     185 * @param[in] code          Message code.
     186 * @param[in] packet        Message packet to be sent.
     187 * @param[in] header        ICMP header.
     188 * @param[in] error         Error service to be announced. Should be
     189 *                          SERVICE_ICMP or zero.
     190 * @param[in] ttl           Time to live.
     191 * @param[in] tos           Type of service.
     192 * @param[in] dont_fragment Disable fragmentation.
     193 *
     194 * @return EOK on success.
     195 * @return EPERM if the error message is not allowed.
     196 *
     197 */
     198static int icmp_send_packet(icmp_type_t type, icmp_code_t code,
     199    packet_t *packet, icmp_header_t *header, services_t error, ip_ttl_t ttl,
     200    ip_tos_t tos, bool dont_fragment)
     201{
    162202        /* Do not send an error if disabled */
    163         if (error && !icmp_globals.error_reporting)
    164                 return icmp_release_and_return(packet, EPERM);
    165 
     203        if ((error) && (!error_reporting)) {
     204                icmp_release(packet);
     205                return EPERM;
     206        }
     207       
    166208        header->type = type;
    167209        header->code = code;
     210       
     211        /*
     212         * The checksum needs to be calculated
     213         * with a virtual checksum field set to
     214         * zero.
     215         */
    168216        header->checksum = 0;
    169217        header->checksum = ICMP_CHECKSUM(header,
    170218            packet_get_data_length(packet));
    171219       
    172         rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,
     220        int rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,
    173221            dont_fragment, 0);
    174         if (rc != EOK)
    175                 return icmp_release_and_return(packet, rc);
    176 
    177         return ip_send_msg(icmp_globals.ip_phone, -1, packet, SERVICE_ICMP,
    178             error);
    179 }
    180 
    181 /** Prepares the ICMP error packet.
    182  *
    183  * Truncates the original packet if longer than ICMP_KEEP_LENGTH bytes.
    184  * Prefixes and returns the ICMP header.
    185  *
    186  * @param[in,out] packet The original packet.
     222        if (rc != EOK) {
     223                icmp_release(packet);
     224                return rc;
     225        }
     226       
     227        return ip_send_msg(phone_ip, -1, packet, SERVICE_ICMP, error);
     228}
     229
     230/** Prepare the ICMP error packet.
     231 *
     232 * Truncate the original packet if longer than ICMP_KEEP_LENGTH bytes.
     233 * Prefix and return the ICMP header.
     234 *
     235 * @param[in,out] packet Original packet.
     236 *
    187237 * @return The prefixed ICMP header.
    188238 * @return NULL on errors.
     239 *
    189240 */
    190241static icmp_header_t *icmp_prepare_packet(packet_t *packet)
    191242{
    192         icmp_header_t *header;
    193         size_t header_length;
    194         size_t total_length;
    195 
    196         total_length = packet_get_data_length(packet);
     243        size_t total_length = packet_get_data_length(packet);
    197244        if (total_length <= 0)
    198245                return NULL;
    199 
    200         header_length = ip_client_header_length(packet);
     246       
     247        size_t header_length = ip_client_header_length(packet);
    201248        if (header_length <= 0)
    202249                return NULL;
    203 
     250       
    204251        /* Truncate if longer than 64 bits (without the IP header) */
    205252        if ((total_length > header_length + ICMP_KEEP_LENGTH) &&
    206253            (packet_trim(packet, 0,
    207             total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) {
     254            total_length - header_length - ICMP_KEEP_LENGTH) != EOK))
    208255                return NULL;
    209         }
    210 
    211         header = PACKET_PREFIX(packet, icmp_header_t);
     256       
     257        icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t);
    212258        if (!header)
    213259                return NULL;
    214 
     260       
    215261        bzero(header, sizeof(*header));
    216262        return header;
    217263}
    218264
    219 /** Requests an echo message.
    220  *
    221  * Sends a packet with specified parameters to the target host and waits for
    222  * the reply upto the given timeout.
    223  * Blocks the caller until the reply or the timeout occurs.
    224  *
    225  * @param[in] id        The message identifier.
    226  * @param[in] sequence  The message sequence parameter.
    227  * @param[in] size      The message data length in bytes.
    228  * @param[in] timeout   The timeout in miliseconds.
    229  * @param[in] ttl       The time to live.
    230  * @param[in] tos       The type of service.
    231  * @param[in] dont_fragment The value indicating whether the datagram must not
    232  *                      be fragmented. Is used as a MTU discovery.
    233  * @param[in] addr      The target host address.
    234  * @param[in] addrlen   The torget host address length.
    235  * @return              ICMP_ECHO on success.
    236  * @return              ETIMEOUT if the reply has not arrived before the
    237  *                      timeout.
    238  * @return              ICMP type of the received error notification.
    239  * @return              EINVAL if the addrlen parameter is less or equal to
    240  *                      zero.
    241  * @return              ENOMEM if there is not enough memory left.
    242  * @return              EPARTY if there was an internal error.
     265/** Request an echo message.
     266 *
     267 * Send a packet with specified parameters to the target host
     268 * and wait for the reply upto the given timeout.
     269 * Block the caller until the reply or the timeout occurs.
     270 *
     271 * @param[in] id            Message identifier.
     272 * @param[in] sequence      Message sequence parameter.
     273 * @param[in] size          Message data length in bytes.
     274 * @param[in] timeout       Timeout in miliseconds.
     275 * @param[in] ttl           Time to live.
     276 * @param[in] tos           Type of service.
     277 * @param[in] dont_fragment Disable fragmentation.
     278 * @param[in] addr          Target host address.
     279 * @param[in] addrlen       Torget host address length.
     280 *
     281 * @return ICMP_ECHO on success.
     282 * @return ETIMEOUT if the reply has not arrived before the
     283 *         timeout.
     284 * @return ICMP type of the received error notification.
     285 * @return EINVAL if the addrlen parameter is less or equal to
     286 *         zero.
     287 * @return ENOMEM if there is not enough memory left.
     288 *
    243289 */
    244290static int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
    245     mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment,
    246     const struct sockaddr * addr, socklen_t addrlen)
    247 {
    248         icmp_header_t *header;
    249         packet_t *packet;
    250         size_t length;
    251         uint8_t *data;
    252         icmp_reply_t *reply;
    253         int reply_key;
    254         int index;
    255         int rc;
    256 
     291    mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, bool dont_fragment,
     292    const struct sockaddr *addr, socklen_t addrlen)
     293{
    257294        if (addrlen <= 0)
    258295                return EINVAL;
    259 
    260         length = (size_t) addrlen;
    261         /* TODO do not ask all the time */
    262         rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
    263             &icmp_globals.packet_dimension);
    264         if (rc != EOK)
    265                 return rc;
    266 
    267         packet = packet_get_4_remote(icmp_globals.net_phone, size,
    268             icmp_globals.packet_dimension.addr_len,
    269             ICMP_HEADER_SIZE + icmp_globals.packet_dimension.prefix,
    270             icmp_globals.packet_dimension.suffix);
     296       
     297        size_t length = (size_t) addrlen;
     298       
     299        packet_t *packet = packet_get_4_remote(phone_net, size,
     300            icmp_dimension.addr_len, ICMP_HEADER_SIZE + icmp_dimension.prefix,
     301            icmp_dimension.suffix);
    271302        if (!packet)
    272303                return ENOMEM;
    273 
     304       
    274305        /* Prepare the requesting packet, set the destination address. */
    275         rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
    276         if (rc != EOK)
    277                 return icmp_release_and_return(packet, rc);
    278 
     306        int rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
     307        if (rc != EOK) {
     308                icmp_release(packet);
     309                return rc;
     310        }
     311       
    279312        /* Allocate space in the packet */
    280         data = (uint8_t *) packet_suffix(packet, size);
    281         if (!data)
    282                 return icmp_release_and_return(packet, ENOMEM);
    283 
     313        uint8_t *data = (uint8_t *) packet_suffix(packet, size);
     314        if (!data) {
     315                icmp_release(packet);
     316                return ENOMEM;
     317        }
     318       
    284319        /* Fill the data */
    285320        length = 0;
    … …  
    289324        }
    290325        memcpy(data + length, ICMP_ECHO_TEXT, size - length);
    291 
     326       
    292327        /* Prefix the header */
    293         header = PACKET_PREFIX(packet, icmp_header_t);
    294         if (!header)
    295                 return icmp_release_and_return(packet, ENOMEM);
    296 
    297         bzero(header, sizeof(*header));
     328        icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t);
     329        if (!header) {
     330                icmp_release(packet);
     331                return ENOMEM;
     332        }
     333       
     334        bzero(header, sizeof(icmp_header_t));
    298335        header->un.echo.identifier = id;
    299336        header->un.echo.sequence_number = sequence;
    300 
     337       
    301338        /* Prepare the reply structure */
    302         reply = malloc(sizeof(*reply));
    303         if (!reply)
    304                 return icmp_release_and_return(packet, ENOMEM);
    305 
    306         fibril_mutex_initialize(&reply->mutex);
    307         fibril_mutex_lock(&reply->mutex);
     339        icmp_reply_t *reply = malloc(sizeof(icmp_reply_t));
     340        if (!reply) {
     341                icmp_release(packet);
     342                return ENOMEM;
     343        }
     344       
     345        reply->id = id;
     346        reply->sequence = sequence;
    308347        fibril_condvar_initialize(&reply->condvar);
    309         reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
    310             header->un.echo.sequence_number);
    311         index = icmp_replies_add(&icmp_globals.replies, reply_key, reply);
    312         if (index < 0) {
    313                 free(reply);
    314                 return icmp_release_and_return(packet, index);
    315         }
    316 
    317         /* Unlock the globals so that we can wait for the reply */
    318         fibril_rwlock_write_unlock(&icmp_globals.lock);
    319 
     348       
     349        /* Add the reply to the replies hash table */
     350        fibril_mutex_lock(&reply_lock);
     351       
     352        unsigned long key[REPLY_KEYS] = {id, sequence};
     353        hash_table_insert(&replies, key, &reply->link);
     354       
    320355        /* Send the request */
    321356        icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos,
    322357            dont_fragment);
    323 
     358       
    324359        /* Wait for the reply. Timeout in microseconds. */
    325         rc = fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex,
     360        rc = fibril_condvar_wait_timeout(&reply->condvar, &reply_lock,
    326361            timeout * 1000);
    327362        if (rc == EOK)
    328363                rc = reply->result;
    329 
    330         /* Drop the reply mutex before locking the globals again */
    331         fibril_mutex_unlock(&reply->mutex);
    332         fibril_rwlock_write_lock(&icmp_globals.lock);
    333 
    334         /* Destroy the reply structure */
    335         icmp_replies_exclude_index(&icmp_globals.replies, index);
    336 
     364       
     365        /* Remove the reply from the replies hash table */
     366        hash_table_remove(&replies, key, REPLY_KEYS);
     367       
     368        fibril_mutex_unlock(&reply_lock);
     369       
     370        free(reply);
     371       
    337372        return rc;
    338373}
    339374
    340 static int icmp_destination_unreachable_msg_local(int icmp_phone,
    341     icmp_code_t code, icmp_param_t mtu, packet_t *packet)
    342 {
    343         icmp_header_t *header;
    344 
    345         header = icmp_prepare_packet(packet);
    346         if (!header)
    347                 return icmp_release_and_return(packet, ENOMEM);
    348 
     375static int icmp_destination_unreachable(icmp_code_t code, icmp_param_t mtu,
     376    packet_t *packet)
     377{
     378        icmp_header_t *header = icmp_prepare_packet(packet);
     379        if (!header) {
     380                icmp_release(packet);
     381                return ENOMEM;
     382        }
     383       
    349384        if (mtu)
    350385                header->un.frag.mtu = mtu;
    351 
     386       
    352387        return icmp_send_packet(ICMP_DEST_UNREACH, code, packet, header,
    353             SERVICE_ICMP, 0, 0, 0);
    354 }
    355 
    356 static int icmp_source_quench_msg_local(int icmp_phone, packet_t *packet)
    357 {
    358         icmp_header_t *header;
    359 
    360         header = icmp_prepare_packet(packet);
    361         if (!header)
    362                 return icmp_release_and_return(packet, ENOMEM);
    363 
     388            SERVICE_ICMP, 0, 0, false);
     389}
     390
     391static int icmp_source_quench(packet_t *packet)
     392{
     393        icmp_header_t *header = icmp_prepare_packet(packet);
     394        if (!header) {
     395                icmp_release(packet);
     396                return ENOMEM;
     397        }
     398       
    364399        return icmp_send_packet(ICMP_SOURCE_QUENCH, 0, packet, header,
    365             SERVICE_ICMP, 0, 0, 0);
    366 }
    367 
    368 static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code,
     400            SERVICE_ICMP, 0, 0, false);
     401}
     402
     403static int icmp_time_exceeded(icmp_code_t code, packet_t *packet)
     404{
     405        icmp_header_t *header = icmp_prepare_packet(packet);
     406        if (!header) {
     407                icmp_release(packet);
     408                return ENOMEM;
     409        }
     410       
     411        return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header,
     412            SERVICE_ICMP, 0, 0, false);
     413}
     414
     415static int icmp_parameter_problem(icmp_code_t code, icmp_param_t pointer,
    369416    packet_t *packet)
    370417{
    371         icmp_header_t *header;
    372 
    373         header = icmp_prepare_packet(packet);
    374         if (!header)
    375                 return icmp_release_and_return(packet, ENOMEM);
    376 
    377         return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header,
    378             SERVICE_ICMP, 0, 0, 0);
    379 }
    380 
    381 static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
    382     icmp_param_t pointer, packet_t *packet)
    383 {
    384         icmp_header_t *header;
    385 
    386         header = icmp_prepare_packet(packet);
    387         if (!header)
    388                 return icmp_release_and_return(packet, ENOMEM);
    389 
     418        icmp_header_t *header = icmp_prepare_packet(packet);
     419        if (!header) {
     420                icmp_release(packet);
     421                return ENOMEM;
     422        }
     423       
    390424        header->un.param.pointer = pointer;
    391425        return icmp_send_packet(ICMP_PARAMETERPROB, code, packet, header,
    392             SERVICE_ICMP, 0, 0, 0);
    393 }
    394 
    395 /** Tries to set the pending reply result as the received message type.
     426            SERVICE_ICMP, 0, 0, false);
     427}
     428
     429/** Try to set the pending reply result as the received message type.
    396430 *
    397431 * If the reply data is not present, the reply timed out and the other fibril
    398  * is already awake.
    399  * Releases the packet.
    400  *
    401  * @param[in] packet    The received reply message.
    402  * @param[in] header    The ICMP message header.
    403  * @param[in] type      The received reply message type.
    404  * @param[in] code      The received reply message code.
    405  */
    406 static void  icmp_process_echo_reply(packet_t *packet, icmp_header_t *header,
     432 * is already awake. The packet is released.
     433 *
     434 * @param[in] packet The received reply message.
     435 * @param[in] header The ICMP message header.
     436 * @param[in] type   The received reply message type.
     437 * @param[in] code   The received reply message code.
     438 *
     439 */
     440static void icmp_process_echo_reply(packet_t *packet, icmp_header_t *header,
    407441    icmp_type_t type, icmp_code_t code)
    408442{
    409         int reply_key;
    410         icmp_reply_t *reply;
    411 
    412         /* Compute the reply key */
    413         reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
    414             header->un.echo.sequence_number);
    415         pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
    416 
     443        unsigned long key[REPLY_KEYS] =
     444            {header->un.echo.identifier, header->un.echo.sequence_number};
     445       
     446        /* The packet is no longer needed */
     447        icmp_release(packet);
     448       
    417449        /* Find the pending reply */
    418         fibril_rwlock_write_lock(&icmp_globals.lock);
    419         reply = icmp_replies_find(&icmp_globals.replies, reply_key);
    420         if (reply) {
     450        fibril_mutex_lock(&reply_lock);
     451       
     452        link_t *link = hash_table_find(&replies, key);
     453        if (link != NULL) {
     454                icmp_reply_t *reply =
     455                   hash_table_get_instance(link, icmp_reply_t, link);
     456               
    421457                reply->result = type;
    422458                fibril_condvar_signal(&reply->condvar);
    423459        }
    424         fibril_rwlock_write_unlock(&icmp_globals.lock);
    425 }
    426 
    427 /** Processes the received ICMP packet.
    428  *
    429  * Notifies the destination socket application.
    430  *
    431  * @param[in,out] packet The received packet.
    432  * @param[in] error     The packet error reporting service. Prefixes the
    433  *                      received packet.
    434  * @return              EOK on success.
    435  * @return              EINVAL if the packet is not valid.
    436  * @return              EINVAL if the stored packet address is not the an_addr_t.
    437  * @return              EINVAL if the packet does not contain any data.
    438  * @return              NO_DATA if the packet content is shorter than the user
    439  *                      datagram header.
    440  * @return              ENOMEM if there is not enough memory left.
    441  * @return              EADDRNOTAVAIL if the destination socket does not exist.
    442  * @return              Other error codes as defined for the
    443  *                      ip_client_process_packet() function.
     460       
     461        fibril_mutex_unlock(&reply_lock);
     462}
     463
     464/** Process the received ICMP packet.
     465 *
     466 * Notify the destination socket application.
     467 *
     468 * @param[in,out] packet Received packet.
     469 * @param[in]     error  Packet error reporting service to prefix
     470 *                       the received packet.
     471 *
     472 * @return EOK on success.
     473 * @return EINVAL if the packet is not valid.
     474 * @return EINVAL if the stored packet address is not the an_addr_t.
     475 * @return EINVAL if the packet does not contain any data.
     476 * @return NO_DATA if the packet content is shorter than the user
     477 *         datagram header.
     478 * @return ENOMEM if there is not enough memory left.
     479 * @return EADDRNOTAVAIL if the destination socket does not exist.
     480 * @return Other error codes as defined for the
     481 *         ip_client_process_packet() function.
     482 *
    444483 */
    445484static int icmp_process_packet(packet_t *packet, services_t error)
    446485{
    447         size_t length;
    448         uint8_t *src;
    449         int addrlen;
    450         int result;
    451         void *data;
    452         icmp_header_t *header;
    453486        icmp_type_t type;
    454487        icmp_code_t code;
    … …  
    460493        case SERVICE_ICMP:
    461494                /* Process error */
    462                 result = icmp_client_process_packet(packet, &type, &code, NULL,
    463                     NULL);
    464                 if (result < 0)
    465                         return result;
    466                 length = (size_t) result;
     495                rc = icmp_client_process_packet(packet, &type, &code, NULL, NULL);
     496                if (rc < 0)
     497                        return rc;
     498               
    467499                /* Remove the error header */
    468                 rc = packet_trim(packet, length, 0);
     500                rc = packet_trim(packet, (size_t) rc, 0);
    469501                if (rc != EOK)
    470502                        return rc;
     503               
    471504                break;
    472505        default:
    473506                return ENOTSUP;
    474507        }
    475 
     508       
    476509        /* Get rid of the IP header */
    477         length = ip_client_header_length(packet);
     510        size_t length = ip_client_header_length(packet);
    478511        rc = packet_trim(packet, length, 0);
    479512        if (rc != EOK)
    480513                return rc;
    481 
     514       
    482515        length = packet_get_data_length(packet);
    483516        if (length <= 0)
    484517                return EINVAL;
    485 
     518       
    486519        if (length < ICMP_HEADER_SIZE)
    487520                return EINVAL;
    488 
    489         data = packet_get_data(packet);
     521       
     522        void *data = packet_get_data(packet);
    490523        if (!data)
    491524                return EINVAL;
    492 
     525       
    493526        /* Get ICMP header */
    494         header = (icmp_header_t *) data;
    495 
     527        icmp_header_t *header = (icmp_header_t *) data;
     528       
    496529        if (header->checksum) {
    497530                while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) {
    … …  
    507540                                }
    508541                        }
     542                       
    509543                        return EINVAL;
    510544                }
    511545        }
    512 
     546       
    513547        switch (header->type) {
    514548        case ICMP_ECHOREPLY:
    … …  
    517551                else
    518552                        icmp_process_echo_reply(packet, header, ICMP_ECHO, 0);
    519 
     553               
    520554                return EOK;
    521 
     555       
    522556        case ICMP_ECHO:
    523557                if (error) {
    … …  
    527561               
    528562                /* Do not send a reply if disabled */
    529                 if (icmp_globals.echo_replying) {
    530                         addrlen = packet_get_addr(packet, &src, NULL);
    531 
     563                if (echo_replying) {
     564                        uint8_t *src;
     565                        int addrlen = packet_get_addr(packet, &src, NULL);
     566                       
    532567                        /*
    533                          * Set both addresses to the source one (avoids the
     568                         * Set both addresses to the source one (avoid the
    534569                         * source address deletion before setting the
    535570                         * destination one).
    … …  
    542577                                return EOK;
    543578                        }
    544 
     579                       
    545580                        return EINVAL;
    546581                }
    547 
     582               
    548583                return EPERM;
    549 
     584       
    550585        case ICMP_DEST_UNREACH:
    551586        case ICMP_SOURCE_QUENCH:
    … …  
    560595        case ICMP_SKIP:
    561596        case ICMP_PHOTURIS:
    562                 ip_received_error_msg(icmp_globals.ip_phone, -1, packet,
     597                ip_received_error_msg(phone_ip, -1, packet,
    563598                    SERVICE_IP, SERVICE_ICMP);
    564599                return EOK;
    565 
     600       
    566601        default:
    567602                return ENOTSUP;
    … …  
    569604}
    570605
    571 /** Processes the received ICMP packet.
    572  *
    573  * Is used as an entry point from the underlying IP module.
    574  * Releases the packet on error.
    575  *
    576  * @param device_id     The device identifier. Ignored parameter.
    577  * @param[in,out] packet The received packet.
    578  * @param receiver      The target service. Ignored parameter.
    579  * @param[in] error     The packet error reporting service. Prefixes the
    580  *                      received packet.
    581  * @return              EOK on success.
    582  * @return              Other error codes as defined for the
    583  *                      icmp_process_packet() function.
    584  */
    585 static int icmp_received_msg_local(device_id_t device_id, packet_t *packet,
    586     services_t receiver, services_t error)
    587 {
    588         int rc;
    589 
    590         rc = icmp_process_packet(packet, error);
    591         if (rc != EOK)
    592                 return icmp_release_and_return(packet, rc);
    593 
    594         return EOK;
    595 }
    596 
    597606/** Process IPC messages from the IP module
    598607 *
    … …  
    603612static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall)
    604613{
     614        bool loop = true;
    605615        packet_t *packet;
    606616        int rc;
    607617       
    608         while (true) {
     618        while (loop) {
    609619                switch (IPC_GET_IMETHOD(*icall)) {
    610620                case NET_TL_RECEIVED:
    611                         rc = packet_translate_remote(icmp_globals.net_phone, &packet,
     621                        rc = packet_translate_remote(phone_net, &packet,
    612622                            IPC_GET_PACKET(*icall));
    613                         if (rc == EOK)
    614                                 rc = icmp_received_msg_local(IPC_GET_DEVICE(*icall), packet,
    615                                     SERVICE_ICMP, IPC_GET_ERROR(*icall));
     623                        if (rc == EOK) {
     624                                rc = icmp_process_packet(packet, IPC_GET_ERROR(*icall));
     625                                if (rc != EOK)
     626                                        icmp_release(packet);
     627                        }
    616628                       
    617                         ipc_answer_0(iid, (sysarg_t) rc);
     629                        async_answer_0(iid, (sysarg_t) rc);
    618630                        break;
     631                case IPC_M_PHONE_HUNGUP:
     632                        loop = false;
     633                        continue;
    619634                default:
    620                         ipc_answer_0(iid, (sysarg_t) ENOTSUP);
     635                        async_answer_0(iid, (sysarg_t) ENOTSUP);
    621636                }
    622637               
    … …  
    649664        uint8_t *data;
    650665       
    651         fibril_rwlock_initialize(&icmp_globals.lock);
    652         fibril_rwlock_write_lock(&icmp_globals.lock);
    653         icmp_replies_initialize(&icmp_globals.replies);
    654         icmp_echo_data_initialize(&icmp_globals.echo_data);
    655        
    656         icmp_globals.net_phone = net_phone;
    657        
    658         icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP,
    659             SERVICE_ICMP, icmp_receiver);
    660         if (icmp_globals.ip_phone < 0) {
    661                 fibril_rwlock_write_unlock(&icmp_globals.lock);
    662                 return icmp_globals.ip_phone;
    663         }
    664        
    665         int rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
    666             &icmp_globals.packet_dimension);
    667         if (rc != EOK) {
    668                 fibril_rwlock_write_unlock(&icmp_globals.lock);
     666        if (!hash_table_create(&replies, REPLY_BUCKETS, REPLY_KEYS, &reply_ops))
     667                return ENOMEM;
     668       
     669        fibril_mutex_initialize(&reply_lock);
     670        atomic_set(&icmp_client, 0);
     671       
     672        phone_net = net_phone;
     673        phone_ip = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP,
     674            icmp_receiver);
     675        if (phone_ip < 0)
     676                return phone_ip;
     677       
     678        int rc = ip_packet_size_req(phone_ip, -1, &icmp_dimension);
     679        if (rc != EOK)
    669680                return rc;
    670         }
    671        
    672         icmp_globals.packet_dimension.prefix += ICMP_HEADER_SIZE;
    673         icmp_globals.packet_dimension.content -= ICMP_HEADER_SIZE;
    674        
    675         icmp_globals.error_reporting = NET_DEFAULT_ICMP_ERROR_REPORTING;
    676         icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING;
     681       
     682        icmp_dimension.prefix += ICMP_HEADER_SIZE;
     683        icmp_dimension.content -= ICMP_HEADER_SIZE;
    677684       
    678685        /* Get configuration */
    679686        configuration = &names[0];
    680         rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count,
    681             &data);
    682         if (rc != EOK) {
    683                 fibril_rwlock_write_unlock(&icmp_globals.lock);
     687        rc = net_get_conf_req(phone_net, &configuration, count, &data);
     688        if (rc != EOK)
    684689                return rc;
    685         }
    686690       
    687691        if (configuration) {
    688                 if (configuration[0].value) {
    689                         icmp_globals.error_reporting =
    690                             (configuration[0].value[0] == 'y');
    691                 }
    692                 if (configuration[1].value) {
    693                         icmp_globals.echo_replying =
    694                             (configuration[1].value[0] == 'y');
    695                 }
     692                if (configuration[0].value)
     693                        error_reporting = (configuration[0].value[0] == 'y');
     694               
     695                if (configuration[1].value)
     696                        echo_replying = (configuration[1].value[0] == 'y');
     697               
    696698                net_free_settings(configuration, data);
    697699        }
    698700       
    699         fibril_rwlock_write_unlock(&icmp_globals.lock);
    700701        return EOK;
    701702}
    702703
    703 /** Processes the generic client messages.
    704  *
    705  * @param[in] call      The message parameters.
    706  * @return              EOK on success.
    707  * @return              ENOTSUP if the message is not known.
    708  * @return              Other error codes as defined for the packet_translate()
    709  *                      function.
    710  * @return              Other error codes as defined for the
    711  *                      icmp_destination_unreachable_msg_local() function.
    712  * @return              Other error codes as defined for the
    713  *                      icmp_source_quench_msg_local() function.
    714  * @return              Other error codes as defined for the
    715  *                      icmp_time_exceeded_msg_local() function.
    716  * @return              Other error codes as defined for the
    717  *                      icmp_parameter_problem_msg_local() function.
    718  *
    719  * @see icmp_interface.h
    720  */
    721 static int icmp_process_message(ipc_call_t *call)
    722 {
     704/** Per-connection initialization
     705 *
     706 * Initialize client-specific global variables.
     707 *
     708 */
     709void tl_connection(void)
     710{
     711        icmp_id = (icmp_param_t) atomic_postinc(&icmp_client);
     712        icmp_seq = 1;
     713}
     714
     715/** Process the ICMP message.
     716 *
     717 * @param[in]  callid Message identifier.
     718 * @param[in]  call   Message parameters.
     719 * @param[out] answer Answer.
     720 * @param[out] count  Number of arguments of the answer.
     721 *
     722 * @return EOK on success.
     723 * @return ENOTSUP if the message is not known.
     724 * @return Other error codes as defined for the packet_translate()
     725 *         function.
     726 * @return Other error codes as defined for the
     727 *         icmp_destination_unreachable() function.
     728 * @return Other error codes as defined for the
     729 *         icmp_source_quench() function.
     730 * @return Other error codes as defined for the
     731 *         icmp_time_exceeded() function.
     732 * @return Other error codes as defined for the
     733 *         icmp_parameter_problem() function.
     734 *
     735 * @see icmp_remote.h
     736 * @see IS_NET_ICMP_MESSAGE()
     737 *
     738 */
     739int tl_message(ipc_callid_t callid, ipc_call_t *call,
     740    ipc_call_t *answer, size_t *count)
     741{
     742        struct sockaddr *addr;
     743        size_t size;
    723744        packet_t *packet;
    724745        int rc;
    725 
     746       
     747        *count = 0;
     748       
    726749        switch (IPC_GET_IMETHOD(*call)) {
     750        case NET_ICMP_ECHO:
     751                rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &size);
     752                if (rc != EOK)
     753                        return rc;
     754               
     755                rc = icmp_echo(icmp_id, icmp_seq, ICMP_GET_SIZE(*call),
     756                    ICMP_GET_TIMEOUT(*call), ICMP_GET_TTL(*call),
     757                    ICMP_GET_TOS(*call), ICMP_GET_DONT_FRAGMENT(*call),
     758                    addr, (socklen_t) size);
     759               
     760                free(addr);
     761                icmp_seq++;
     762                return rc;
     763       
    727764        case NET_ICMP_DEST_UNREACH:
    728                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
     765                rc = packet_translate_remote(phone_net, &packet,
    729766                    IPC_GET_PACKET(*call));
    730767                if (rc != EOK)
    731768                        return rc;
    732                 return icmp_destination_unreachable_msg_local(0,
    733                     ICMP_GET_CODE(*call), ICMP_GET_MTU(*call), packet);
     769               
     770                return icmp_destination_unreachable(ICMP_GET_CODE(*call),
     771                    ICMP_GET_MTU(*call), packet);
     772       
    734773        case NET_ICMP_SOURCE_QUENCH:
    735                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
     774                rc = packet_translate_remote(phone_net, &packet,
    736775                    IPC_GET_PACKET(*call));
    737776                if (rc != EOK)
    738777                        return rc;
    739                 return icmp_source_quench_msg_local(0, packet);
     778               
     779                return icmp_source_quench(packet);
     780       
    740781        case NET_ICMP_TIME_EXCEEDED:
    741                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
     782                rc = packet_translate_remote(phone_net, &packet,
    742783                    IPC_GET_PACKET(*call));
    743784                if (rc != EOK)
    744785                        return rc;
    745                 return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(*call),
    746                     packet);
     786               
     787                return icmp_time_exceeded(ICMP_GET_CODE(*call), packet);
     788       
    747789        case NET_ICMP_PARAMETERPROB:
    748                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
     790                rc = packet_translate_remote(phone_net, &packet,
    749791                    IPC_GET_PACKET(*call));
    750792                if (rc != EOK)
    751793                        return rc;
    752                 return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(*call),
     794               
     795                return icmp_parameter_problem(ICMP_GET_CODE(*call),
    753796                    ICMP_GET_POINTER(*call), packet);
    754         default:
    755                 return ENOTSUP;
    756         }
    757 }
    758 
    759 /** Assigns a new identifier for the connection.
    760  *
    761  * Fills the echo data parameter with the assigned values.
    762  *
    763  * @param[in,out] echo_data The echo data to be bound.
    764  * @return              Index of the inserted echo data.
    765  * @return              EBADMEM if the echo_data parameter is NULL.
    766  * @return              ENOTCONN if no free identifier have been found.
    767  */
    768 static int icmp_bind_free_id(icmp_echo_t *echo_data)
    769 {
    770         icmp_param_t index;
    771 
    772         if (!echo_data)
    773                 return EBADMEM;
    774 
    775         /* From the last used one */
    776         index = icmp_globals.last_used_id;
    777         do {
    778                 index++;
    779                 /* til the range end */
    780                 if (index >= ICMP_FREE_IDS_END) {
    781                         /* start from the range beginning */
    782                         index = ICMP_FREE_IDS_START - 1;
    783                         do {
    784                                 index++;
    785                                 /* til the last used one */
    786                                 if (index >= icmp_globals.last_used_id) {
    787                                         /* none found */
    788                                         return ENOTCONN;
    789                                 }
    790                         } while(icmp_echo_data_find(&icmp_globals.echo_data,
    791                             index) != NULL);
    792 
    793                         /* Found, break immediately */
    794                         break;
    795                 }
    796         } while (icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
    797 
    798         echo_data->identifier = index;
    799         echo_data->sequence_number = 0;
    800 
    801         return icmp_echo_data_add(&icmp_globals.echo_data, index, echo_data);
    802 }
    803 
    804 /** Processes the client messages.
    805  *
    806  * Remembers the assigned identifier and sequence numbers.
    807  * Runs until the client module disconnects.
    808  *
    809  * @param[in] callid    The message identifier.
    810  * @param[in] call      The message parameters.
    811  * @return EOK.
    812  *
    813  * @see icmp_interface.h
    814  * @see icmp_api.h
    815  */
    816 static int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
    817 {
    818         bool keep_on_going = true;
    819         ipc_call_t answer;
    820         size_t answer_count;
    821         size_t length;
    822         struct sockaddr *addr;
    823         ipc_callid_t data_callid;
    824         icmp_echo_t *echo_data;
    825         int rc = EOK;
    826 
    827         /*
    828          * Accept the connection
    829          *  - Answer the first NET_ICMP_INIT call.
    830          */
    831         answer_count = 0;
    832 
    833         echo_data = (icmp_echo_t *) malloc(sizeof(*echo_data));
    834         if (!echo_data)
    835                 return ENOMEM;
    836 
    837         /* Assign a new identifier */
    838         fibril_rwlock_write_lock(&icmp_globals.lock);
    839         rc = icmp_bind_free_id(echo_data);
    840         fibril_rwlock_write_unlock(&icmp_globals.lock);
    841         if (rc < 0) {
    842                 free(echo_data);
    843                 return rc;
    844         }
    845 
    846         while (keep_on_going) {
    847                 /* Answer the call */
    848                 answer_call(callid, rc, &answer, answer_count);
    849 
    850                 /* Refresh data */
    851                 refresh_answer(&answer, &answer_count);
    852 
    853                 /* Get the next call */
    854                 callid = async_get_call(&call);
    855 
    856                 /* Process the call */
    857                 switch (IPC_GET_IMETHOD(call)) {
    858                 case IPC_M_PHONE_HUNGUP:
    859                         keep_on_going = false;
    860                         rc = EHANGUP;
    861                         break;
    862                
    863                 case NET_ICMP_ECHO:
    864                         if (!async_data_write_receive(&data_callid, &length)) {
    865                                 rc = EINVAL;
    866                                 break;
    867                         }
    868                        
    869                         addr = malloc(length);
    870                         if (!addr) {
    871                                 rc = ENOMEM;
    872                                 break;
    873                         }
    874                        
    875                         rc = async_data_write_finalize(data_callid, addr,
    876                             length);
    877                         if (rc != EOK) {
    878                                 free(addr);
    879                                 break;
    880                         }
    881 
    882                         fibril_rwlock_write_lock(&icmp_globals.lock);
    883                         rc = icmp_echo(echo_data->identifier,
    884                             echo_data->sequence_number, ICMP_GET_SIZE(call),
    885                             ICMP_GET_TIMEOUT(call), ICMP_GET_TTL(call),
    886                             ICMP_GET_TOS(call), ICMP_GET_DONT_FRAGMENT(call),
    887                             addr, (socklen_t) length);
    888                         fibril_rwlock_write_unlock(&icmp_globals.lock);
    889 
    890                         free(addr);
    891 
    892                         if (echo_data->sequence_number < UINT16_MAX)
    893                                 echo_data->sequence_number++;
    894                         else
    895                                 echo_data->sequence_number = 0;
    896 
    897                         break;
    898 
    899                 default:
    900                         rc = icmp_process_message(&call);
    901                 }
    902 
    903         }
    904 
    905         /* Release the identifier */
    906         fibril_rwlock_write_lock(&icmp_globals.lock);
    907         icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier);
    908         fibril_rwlock_write_unlock(&icmp_globals.lock);
    909 
    910         return rc;
    911 }
    912 
    913 /** Processes the ICMP message.
    914  *
    915  * @param[in] callid    The message identifier.
    916  * @param[in] call      The message parameters.
    917  * @param[out] answer   The message answer parameters.
    918  * @param[out] answer_count The last parameter for the actual answer in the
    919  *                      answer parameter.
    920  * @return              EOK on success.
    921  * @return              ENOTSUP if the message is not known.
    922  *
    923  * @see icmp_interface.h
    924  * @see IS_NET_ICMP_MESSAGE()
    925  */
    926 int tl_module_message   (ipc_callid_t callid, ipc_call_t *call,
    927     ipc_call_t *answer, size_t *answer_count)
    928 {
    929         *answer_count = 0;
    930         switch (IPC_GET_IMETHOD(*call)) {
    931         case NET_ICMP_INIT:
    932                 return icmp_process_client_messages(callid, *call);
    933         default:
    934                 return icmp_process_message(call);
    935797        }
    936798       
Note: See TracChangeset for help on using the changeset viewer.