Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/tl/icmp/icmp.c

    r46d4d9f r8e3a65c  
    2828
    2929/** @addtogroup icmp
    30  * @{
     30 *  @{
    3131 */
    3232
    3333/** @file
    34  * ICMP module implementation.
    35  * @see icmp.h
    36  */
    37 
    38 #include "icmp.h"
    39 #include "icmp_module.h"
     34 *  ICMP module implementation.
     35 *  @see icmp.h
     36 */
    4037
    4138#include <async.h>
     
    5451#include <byteorder.h>
    5552#include <errno.h>
     53#include <err.h>
    5654
    5755#include <net/socket_codes.h>
    5856#include <net/ip_protocols.h>
    5957#include <net/inet.h>
     58
    6059#include <net/modules.h>
    61 #include <net/icmp_api.h>
    62 #include <net/icmp_codes.h>
    63 #include <net/icmp_common.h>
    64 
    6560#include <packet_client.h>
    6661#include <packet_remote.h>
    6762#include <net_checksum.h>
     63#include <net/icmp_api.h>
    6864#include <icmp_client.h>
     65#include <net/icmp_codes.h>
     66#include <net/icmp_common.h>
    6967#include <icmp_interface.h>
    7068#include <il_interface.h>
     
    7674#include <icmp_header.h>
    7775
    78 /** ICMP module name. */
     76#include "icmp.h"
     77#include "icmp_module.h"
     78
     79/** ICMP module name.
     80 */
    7981#define NAME    "ICMP protocol"
    8082
    81 /** Default ICMP error reporting. */
     83/** Default ICMP error reporting.
     84 */
    8285#define NET_DEFAULT_ICMP_ERROR_REPORTING        true
    8386
    84 /** Default ICMP echo replying. */
     87/** Default ICMP echo replying.
     88 */
    8589#define NET_DEFAULT_ICMP_ECHO_REPLYING          true
    8690
    87 /** Original datagram length in bytes transfered to the error notification
    88  * message.
     91/** Original datagram length in bytes transfered to the error notification message.
    8992 */
    9093#define ICMP_KEEP_LENGTH        8
    9194
    92 /** Free identifier numbers pool start. */
     95/** Free identifier numbers pool start.
     96 */
    9397#define ICMP_FREE_IDS_START     1
    9498
    95 /** Free identifier numbers pool end. */
     99/** Free identifier numbers pool end.
     100 */
    96101#define ICMP_FREE_IDS_END       UINT16_MAX
    97102
    98103/** Computes the ICMP datagram checksum.
    99  *
    100  * @param[in,out] header The ICMP datagram header.
    101  * @param[in] length    The total datagram length.
    102  * @return              The computed checksum.
    103  */
    104 #define ICMP_CHECKSUM(header, length) \
    105         htons(ip_checksum((uint8_t *) (header), (length)))
    106 
    107 /** An echo request datagrams pattern. */
    108 #define ICMP_ECHO_TEXT          "Hello from HelenOS."
     104 *  @param[in,out] header The ICMP datagram header.
     105 *  @param[in] length The total datagram length.
     106 *  @returns The computed checksum.
     107 */
     108#define ICMP_CHECKSUM(header, length)           htons(ip_checksum((uint8_t *) (header), (length)))
     109
     110/** An echo request datagrams pattern.
     111 */
     112#define ICMP_ECHO_TEXT                                  "Hello from HelenOS."
    109113
    110114/** Computes an ICMP reply data key.
    111  *
    112  * @param[in] id        The message identifier.
    113  * @param[in] sequence  The message sequence number.
    114  * @return              The computed ICMP reply data key.
    115  */
    116 #define ICMP_GET_REPLY_KEY(id, sequence) \
    117         (((id) << 16) | (sequence & 0xFFFF))
    118 
    119 
    120 /** ICMP global data. */
     115 *  @param[in] id The message identifier.
     116 *  @param[in] sequence The message sequence number.
     117 *  @returns The computed ICMP reply data key.
     118 */
     119#define ICMP_GET_REPLY_KEY(id, sequence)        (((id) << 16) | (sequence &0xFFFF))
     120
     121/** Processes the received ICMP packet.
     122 *  Is used as an entry point from the underlying IP module.
     123 *  Releases the packet on error.
     124 *  @param device_id The device identifier. Ignored parameter.
     125 *  @param[in,out] packet The received packet.
     126 *  @param receiver The target service. Ignored parameter.
     127 *  @param[in] error The packet error reporting service. Prefixes the received packet.
     128 *  @returns EOK on success.
     129 *  @returns Other error codes as defined for the icmp_process_packet() function.
     130 */
     131int icmp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, services_t error);
     132
     133/** Processes the received ICMP packet.
     134 *  Notifies the destination socket application.
     135 *  @param[in,out] packet The received packet.
     136 *  @param[in] error The packet error reporting service. Prefixes the received packet.
     137 *  @returns EOK on success.
     138 *  @returns EINVAL if the packet is not valid.
     139 *  @returns EINVAL if the stored packet address is not the an_addr_t.
     140 *  @returns EINVAL if the packet does not contain any data.
     141 *  @returns NO_DATA if the packet content is shorter than the user datagram header.
     142 *  @returns ENOMEM if there is not enough memory left.
     143 *  @returns EADDRNOTAVAIL if the destination socket does not exist.
     144 *  @returns Other error codes as defined for the ip_client_process_packet() function.
     145 */
     146int icmp_process_packet(packet_t packet, services_t error);
     147
     148/** Processes the client messages.
     149 *  Remembers the assigned identifier and sequence numbers.
     150 *  Runs until the client module disconnects.
     151 *  @param[in] callid The message identifier.
     152 *  @param[in] call The message parameters.
     153 *  @returns EOK.
     154 *  @see icmp_interface.h
     155 *  @see icmp_api.h
     156 */
     157int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call);
     158
     159/** Processes the generic client messages.
     160 *  @param[in] call The message parameters.
     161 *  @returns EOK on success.
     162 *  @returns ENOTSUP if the message is not known.
     163 *  @returns Other error codes as defined for the packet_translate() function.
     164 *  @returns Other error codes as defined for the icmp_destination_unreachable_msg() function.
     165 *  @returns Other error codes as defined for the icmp_source_quench_msg() function.
     166 *  @returns Other error codes as defined for the icmp_time_exceeded_msg() function.
     167 *  @returns Other error codes as defined for the icmp_parameter_problem_msg() function.
     168 *  @see icmp_interface.h
     169 */
     170int icmp_process_message(ipc_call_t * call);
     171
     172/** Releases the packet and returns the result.
     173 *  @param[in] packet The packet queue to be released.
     174 *  @param[in] result The result to be returned.
     175 *  @returns The result parameter.
     176 */
     177int icmp_release_and_return(packet_t packet, int result);
     178
     179/** Requests an echo message.
     180 *  Sends a packet with specified parameters to the target host and waits for the reply upto the given timeout.
     181 *  Blocks the caller until the reply or the timeout occurs.
     182 *  @param[in] id The message identifier.
     183 *  @param[in] sequence The message sequence parameter.
     184 *  @param[in] size The message data length in bytes.
     185 *  @param[in] timeout The timeout in miliseconds.
     186 *  @param[in] ttl The time to live.
     187 *  @param[in] tos The type of service.
     188 *  @param[in] dont_fragment The value indicating whether the datagram must not be fragmented. Is used as a MTU discovery.
     189 *  @param[in] addr The target host address.
     190 *  @param[in] addrlen The torget host address length.
     191 *  @returns ICMP_ECHO on success.
     192 *  @returns ETIMEOUT if the reply has not arrived before the timeout.
     193 *  @returns ICMP type of the received error notification.
     194 *  @returns EINVAL if the addrlen parameter is less or equal to zero (<=0).
     195 *  @returns ENOMEM if there is not enough memory left.
     196 *  @returns EPARTY if there was an internal error.
     197 */
     198int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size, mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, const struct sockaddr * addr, socklen_t addrlen);
     199
     200/** Prepares the ICMP error packet.
     201 *  Truncates the original packet if longer than ICMP_KEEP_LENGTH bytes.
     202 *  Prefixes and returns the ICMP header.
     203 *  @param[in,out] packet The original packet.
     204 *  @returns The prefixed ICMP header.
     205 *  @returns NULL on errors.
     206 */
     207icmp_header_ref icmp_prepare_packet(packet_t packet);
     208
     209/** Sends the ICMP message.
     210 *  Sets the message type and code and computes the checksum.
     211 *  Error messages are sent only if allowed in the configuration.
     212 *  Releases the packet on errors.
     213 *  @param[in] type The message type.
     214 *  @param[in] code The message code.
     215 *  @param[in] packet The message packet to be sent.
     216 *  @param[in] header The ICMP header.
     217 *  @param[in] error The error service to be announced. Should be SERVICE_ICMP or zero (0).
     218 *  @param[in] ttl The time to live.
     219 *  @param[in] tos The type of service.
     220 *  @param[in] dont_fragment The value indicating whether the datagram must not be fragmented. Is used as a MTU discovery.
     221 *  @returns EOK on success.
     222 *  @returns EPERM if the error message is not allowed.
     223 */
     224int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet, icmp_header_ref header, services_t error, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment);
     225
     226/** Tries to set the pending reply result as the received message type.
     227 *  If the reply data is not present, the reply timed out and the other fibril
     228 *  is already awake.
     229 *  Releases the packet.
     230 *  @param[in] packet The received reply message.
     231 *  @param[in] header The ICMP message header.
     232 *  @param[in] type The received reply message type.
     233 *  @param[in] code The received reply message code.
     234 *  @returns EOK.
     235 */
     236int icmp_process_echo_reply(packet_t packet, icmp_header_ref header, icmp_type_t type, icmp_code_t code);
     237
     238/** Assigns a new identifier for the connection.
     239 *  Fills the echo data parameter with the assigned values.
     240 *  @param[in,out] echo_data The echo data to be bound.
     241 *  @returns Index of the inserted echo data.
     242 *  @returns EBADMEM if the echo_data parameter is NULL.
     243 *  @returns ENOTCONN if no free identifier have been found.
     244 */
     245int icmp_bind_free_id(icmp_echo_ref echo_data);
     246
     247/** ICMP global data.
     248 */
    121249icmp_globals_t  icmp_globals;
    122250
    123251INT_MAP_IMPLEMENT(icmp_replies, icmp_reply_t);
     252
    124253INT_MAP_IMPLEMENT(icmp_echo_data, icmp_echo_t);
    125254
    126 /** Releases the packet and returns the result.
    127  *
    128  * @param[in] packet    The packet queue to be released.
    129  * @param[in] result    The result to be returned.
    130  * @return              The result parameter.
    131  */
    132 static int icmp_release_and_return(packet_t *packet, int result)
    133 {
    134         pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
     255int icmp_echo_msg(int icmp_phone, size_t size, mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, const struct sockaddr * addr, socklen_t addrlen){
     256        icmp_echo_ref echo_data;
     257        int res;
     258
     259        fibril_rwlock_write_lock(&icmp_globals.lock);
     260        // use the phone as the echo data index
     261        echo_data = icmp_echo_data_find(&icmp_globals.echo_data, icmp_phone);
     262        if(! echo_data){
     263                res = ENOENT;
     264        }else{
     265                res = icmp_echo(echo_data->identifier, echo_data->sequence_number, size, timeout, ttl, tos, dont_fragment, addr, addrlen);
     266                if(echo_data->sequence_number < UINT16_MAX){
     267                        ++ echo_data->sequence_number;
     268                }else{
     269                        echo_data->sequence_number = 0;
     270                }
     271        }
     272        fibril_rwlock_write_unlock(&icmp_globals.lock);
     273        return res;
     274}
     275
     276int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size, mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, const struct sockaddr * addr, socklen_t addrlen){
     277        ERROR_DECLARE;
     278
     279        icmp_header_ref header;
     280        packet_t packet;
     281        size_t length;
     282        uint8_t * data;
     283        icmp_reply_ref reply;
     284        int reply_key;
     285        int result;
     286        int index;
     287
     288        if(addrlen <= 0){
     289                return EINVAL;
     290        }
     291        length = (size_t) addrlen;
     292        // TODO do not ask all the time
     293        ERROR_PROPAGATE(ip_packet_size_req(icmp_globals.ip_phone, -1, &icmp_globals.packet_dimension));
     294        packet = packet_get_4_remote(icmp_globals.net_phone, size, icmp_globals.packet_dimension.addr_len, ICMP_HEADER_SIZE + icmp_globals.packet_dimension.prefix, icmp_globals.packet_dimension.suffix);
     295        if(! packet){
     296                return ENOMEM;
     297        }
     298
     299        // prepare the requesting packet
     300        // set the destination address
     301        if(ERROR_OCCURRED(packet_set_addr(packet, NULL, (const uint8_t *) addr, length))){
     302                return icmp_release_and_return(packet, ERROR_CODE);
     303        }
     304        // allocate space in the packet
     305        data = (uint8_t *) packet_suffix(packet, size);
     306        if(! data){
     307                return icmp_release_and_return(packet, ENOMEM);
     308        }
     309        // fill the data
     310        length = 0;
     311        while(size > length + sizeof(ICMP_ECHO_TEXT)){
     312                memcpy(data + length, ICMP_ECHO_TEXT, sizeof(ICMP_ECHO_TEXT));
     313                length += sizeof(ICMP_ECHO_TEXT);
     314        }
     315        memcpy(data + length, ICMP_ECHO_TEXT, size - length);
     316        // prefix the header
     317        header = PACKET_PREFIX(packet, icmp_header_t);
     318        if(! header){
     319                return icmp_release_and_return(packet, ENOMEM);
     320        }
     321        bzero(header, sizeof(*header));
     322        header->un.echo.identifier = id;
     323        header->un.echo.sequence_number = sequence;
     324
     325        // prepare the reply structure
     326        reply = malloc(sizeof(*reply));
     327        if(! reply){
     328                return icmp_release_and_return(packet, ENOMEM);
     329        }
     330        fibril_mutex_initialize(&reply->mutex);
     331        fibril_mutex_lock(&reply->mutex);
     332        fibril_condvar_initialize(&reply->condvar);
     333        reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier, header->un.echo.sequence_number);
     334        index = icmp_replies_add(&icmp_globals.replies, reply_key, reply);
     335        if(index < 0){
     336                free(reply);
     337                return icmp_release_and_return(packet, index);
     338        }
     339
     340        // unlock the globals so that we can wait for the reply
     341        fibril_rwlock_write_unlock(&icmp_globals.lock);
     342
     343        // send the request
     344        icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos, dont_fragment);
     345
     346        // wait for the reply
     347        // timeout in microseconds
     348        if(ERROR_OCCURRED(fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex, timeout * 1000))){
     349                result = ERROR_CODE;
     350        }else{
     351                // read the result
     352                result = reply->result;
     353        }
     354
     355        // drop the reply mutex before locking the globals again
     356        fibril_mutex_unlock(&reply->mutex);
     357        fibril_rwlock_write_lock(&icmp_globals.lock);
     358
     359        // destroy the reply structure
     360        icmp_replies_exclude_index(&icmp_globals.replies, index);
    135361        return result;
    136362}
    137363
    138 /** Sends the ICMP message.
    139  *
    140  * Sets the message type and code and computes the checksum.
    141  * Error messages are sent only if allowed in the configuration.
    142  * Releases the packet on errors.
    143  *
    144  * @param[in] type      The message type.
    145  * @param[in] code      The message code.
    146  * @param[in] packet    The message packet to be sent.
    147  * @param[in] header    The ICMP header.
    148  * @param[in] error     The error service to be announced. Should be
    149  *                      SERVICE_ICMP or zero.
    150  * @param[in] ttl       The time to live.
    151  * @param[in] tos       The type of service.
    152  * @param[in] dont_fragment The value indicating whether the datagram must not
    153  *                      be fragmented. Is used as a MTU discovery.
    154  * @return              EOK on success.
    155  * @return              EPERM if the error message is not allowed.
    156  */
    157 static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t *packet,
    158     icmp_header_t *header, services_t error, ip_ttl_t ttl, ip_tos_t tos,
    159     int dont_fragment)
    160 {
    161         int rc;
    162 
    163         /* Do not send an error if disabled */
    164         if (error && !icmp_globals.error_reporting)
     364int icmp_destination_unreachable_msg(int icmp_phone, icmp_code_t code, icmp_param_t mtu, packet_t packet){
     365        icmp_header_ref header;
     366
     367        header = icmp_prepare_packet(packet);
     368        if(! header){
     369                return icmp_release_and_return(packet, ENOMEM);
     370        }
     371        if(mtu){
     372                header->un.frag.mtu = mtu;
     373        }
     374        return icmp_send_packet(ICMP_DEST_UNREACH, code, packet, header, SERVICE_ICMP, 0, 0, 0);
     375}
     376
     377int icmp_source_quench_msg(int icmp_phone, packet_t packet){
     378        icmp_header_ref header;
     379
     380        header = icmp_prepare_packet(packet);
     381        if(! header){
     382                return icmp_release_and_return(packet, ENOMEM);
     383        }
     384        return icmp_send_packet(ICMP_SOURCE_QUENCH, 0, packet, header, SERVICE_ICMP, 0, 0, 0);
     385}
     386
     387int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t packet){
     388        icmp_header_ref header;
     389
     390        header = icmp_prepare_packet(packet);
     391        if(! header){
     392                return icmp_release_and_return(packet, ENOMEM);
     393        }
     394        return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header, SERVICE_ICMP, 0, 0, 0);
     395}
     396
     397int icmp_parameter_problem_msg(int icmp_phone, icmp_code_t code, icmp_param_t pointer, packet_t packet){
     398        icmp_header_ref header;
     399
     400        header = icmp_prepare_packet(packet);
     401        if(! header){
     402                return icmp_release_and_return(packet, ENOMEM);
     403        }
     404        header->un.param.pointer = pointer;
     405        return icmp_send_packet(ICMP_PARAMETERPROB, code, packet, header, SERVICE_ICMP, 0, 0, 0);
     406}
     407
     408icmp_header_ref icmp_prepare_packet(packet_t packet){
     409        icmp_header_ref header;
     410        size_t header_length;
     411        size_t total_length;
     412
     413        total_length = packet_get_data_length(packet);
     414        if(total_length <= 0){
     415                return NULL;
     416        }
     417        header_length = ip_client_header_length(packet);
     418        if(header_length <= 0){
     419                return NULL;
     420        }
     421        // truncate if longer than 64 bits (without the IP header)
     422        if((total_length > header_length + ICMP_KEEP_LENGTH)
     423                && (packet_trim(packet, 0, total_length - header_length - ICMP_KEEP_LENGTH) != EOK)){
     424                return NULL;
     425        }
     426        header = PACKET_PREFIX(packet, icmp_header_t);
     427        if(! header){
     428                return NULL;
     429        }
     430        bzero(header, sizeof(*header));
     431        return header;
     432}
     433
     434int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet, icmp_header_ref header, services_t error, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment){
     435        ERROR_DECLARE;
     436
     437        // do not send an error if disabled
     438        if(error && (! icmp_globals.error_reporting)){
    165439                return icmp_release_and_return(packet, EPERM);
    166 
     440        }
    167441        header->type = type;
    168442        header->code = code;
    169443        header->checksum = 0;
    170         header->checksum = ICMP_CHECKSUM(header,
    171             packet_get_data_length(packet));
    172        
    173         rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,
    174             dont_fragment, 0);
    175         if (rc != EOK)
    176                 return icmp_release_and_return(packet, rc);
    177 
    178         return ip_send_msg(icmp_globals.ip_phone, -1, packet, SERVICE_ICMP,
    179             error);
    180 }
    181 
    182 /** Prepares the ICMP error packet.
    183  *
    184  * Truncates the original packet if longer than ICMP_KEEP_LENGTH bytes.
    185  * Prefixes and returns the ICMP header.
    186  *
    187  * @param[in,out] packet The original packet.
    188  * @return The prefixed ICMP header.
    189  * @return NULL on errors.
    190  */
    191 static icmp_header_t *icmp_prepare_packet(packet_t *packet)
    192 {
    193         icmp_header_t *header;
    194         size_t header_length;
    195         size_t total_length;
    196 
    197         total_length = packet_get_data_length(packet);
    198         if (total_length <= 0)
    199                 return NULL;
    200 
    201         header_length = ip_client_header_length(packet);
    202         if (header_length <= 0)
    203                 return NULL;
    204 
    205         /* Truncate if longer than 64 bits (without the IP header) */
    206         if ((total_length > header_length + ICMP_KEEP_LENGTH) &&
    207             (packet_trim(packet, 0,
    208             total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) {
    209                 return NULL;
    210         }
    211 
    212         header = PACKET_PREFIX(packet, icmp_header_t);
    213         if (!header)
    214                 return NULL;
    215 
    216         bzero(header, sizeof(*header));
    217         return header;
    218 }
    219 
    220 /** Requests an echo message.
    221  *
    222  * Sends a packet with specified parameters to the target host and waits for
    223  * the reply upto the given timeout.
    224  * Blocks the caller until the reply or the timeout occurs.
    225  *
    226  * @param[in] id        The message identifier.
    227  * @param[in] sequence  The message sequence parameter.
    228  * @param[in] size      The message data length in bytes.
    229  * @param[in] timeout   The timeout in miliseconds.
    230  * @param[in] ttl       The time to live.
    231  * @param[in] tos       The type of service.
    232  * @param[in] dont_fragment The value indicating whether the datagram must not
    233  *                      be fragmented. Is used as a MTU discovery.
    234  * @param[in] addr      The target host address.
    235  * @param[in] addrlen   The torget host address length.
    236  * @return              ICMP_ECHO on success.
    237  * @return              ETIMEOUT if the reply has not arrived before the
    238  *                      timeout.
    239  * @return              ICMP type of the received error notification.
    240  * @return              EINVAL if the addrlen parameter is less or equal to
    241  *                      zero.
    242  * @return              ENOMEM if there is not enough memory left.
    243  * @return              EPARTY if there was an internal error.
    244  */
    245 static int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
    246     mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment,
    247     const struct sockaddr * addr, socklen_t addrlen)
    248 {
    249         icmp_header_t *header;
    250         packet_t *packet;
    251         size_t length;
    252         uint8_t *data;
    253         icmp_reply_t *reply;
    254         int reply_key;
    255         int index;
    256         int rc;
    257 
    258         if (addrlen <= 0)
    259                 return EINVAL;
    260 
    261         length = (size_t) addrlen;
    262         /* TODO do not ask all the time */
    263         rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
    264             &icmp_globals.packet_dimension);
    265         if (rc != EOK)
    266                 return rc;
    267 
    268         packet = packet_get_4_remote(icmp_globals.net_phone, size,
    269             icmp_globals.packet_dimension.addr_len,
    270             ICMP_HEADER_SIZE + icmp_globals.packet_dimension.prefix,
    271             icmp_globals.packet_dimension.suffix);
    272         if (!packet)
    273                 return ENOMEM;
    274 
    275         /* Prepare the requesting packet, set the destination address. */
    276         rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
    277         if (rc != EOK)
    278                 return icmp_release_and_return(packet, rc);
    279 
    280         /* Allocate space in the packet */
    281         data = (uint8_t *) packet_suffix(packet, size);
    282         if (!data)
    283                 return icmp_release_and_return(packet, ENOMEM);
    284 
    285         /* Fill the data */
    286         length = 0;
    287         while (size > length + sizeof(ICMP_ECHO_TEXT)) {
    288                 memcpy(data + length, ICMP_ECHO_TEXT, sizeof(ICMP_ECHO_TEXT));
    289                 length += sizeof(ICMP_ECHO_TEXT);
    290         }
    291         memcpy(data + length, ICMP_ECHO_TEXT, size - length);
    292 
    293         /* Prefix the header */
    294         header = PACKET_PREFIX(packet, icmp_header_t);
    295         if (!header)
    296                 return icmp_release_and_return(packet, ENOMEM);
    297 
    298         bzero(header, sizeof(*header));
    299         header->un.echo.identifier = id;
    300         header->un.echo.sequence_number = sequence;
    301 
    302         /* Prepare the reply structure */
    303         reply = malloc(sizeof(*reply));
    304         if (!reply)
    305                 return icmp_release_and_return(packet, ENOMEM);
    306 
    307         fibril_mutex_initialize(&reply->mutex);
    308         fibril_mutex_lock(&reply->mutex);
    309         fibril_condvar_initialize(&reply->condvar);
    310         reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
    311             header->un.echo.sequence_number);
    312         index = icmp_replies_add(&icmp_globals.replies, reply_key, reply);
    313         if (index < 0) {
    314                 free(reply);
    315                 return icmp_release_and_return(packet, index);
    316         }
    317 
    318         /* Unlock the globals so that we can wait for the reply */
    319         fibril_rwlock_write_unlock(&icmp_globals.lock);
    320 
    321         /* Send the request */
    322         icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos,
    323             dont_fragment);
    324 
    325         /* Wait for the reply. Timeout in microseconds. */
    326         rc = fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex,
    327             timeout * 1000);
    328         if (rc == EOK)
    329                 rc = reply->result;
    330 
    331         /* Drop the reply mutex before locking the globals again */
    332         fibril_mutex_unlock(&reply->mutex);
    333         fibril_rwlock_write_lock(&icmp_globals.lock);
    334 
    335         /* Destroy the reply structure */
    336         icmp_replies_exclude_index(&icmp_globals.replies, index);
    337 
    338         return rc;
    339 }
    340 
    341 static int icmp_destination_unreachable_msg_local(int icmp_phone,
    342     icmp_code_t code, icmp_param_t mtu, packet_t *packet)
    343 {
    344         icmp_header_t *header;
    345 
    346         header = icmp_prepare_packet(packet);
    347         if (!header)
    348                 return icmp_release_and_return(packet, ENOMEM);
    349 
    350         if (mtu)
    351                 header->un.frag.mtu = mtu;
    352 
    353         return icmp_send_packet(ICMP_DEST_UNREACH, code, packet, header,
    354             SERVICE_ICMP, 0, 0, 0);
    355 }
    356 
    357 static int icmp_source_quench_msg_local(int icmp_phone, packet_t *packet)
    358 {
    359         icmp_header_t *header;
    360 
    361         header = icmp_prepare_packet(packet);
    362         if (!header)
    363                 return icmp_release_and_return(packet, ENOMEM);
    364 
    365         return icmp_send_packet(ICMP_SOURCE_QUENCH, 0, packet, header,
    366             SERVICE_ICMP, 0, 0, 0);
    367 }
    368 
    369 static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code,
    370     packet_t *packet)
    371 {
    372         icmp_header_t *header;
    373 
    374         header = icmp_prepare_packet(packet);
    375         if (!header)
    376                 return icmp_release_and_return(packet, ENOMEM);
    377 
    378         return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header,
    379             SERVICE_ICMP, 0, 0, 0);
    380 }
    381 
    382 static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
    383     icmp_param_t pointer, packet_t *packet)
    384 {
    385         icmp_header_t *header;
    386 
    387         header = icmp_prepare_packet(packet);
    388         if (!header)
    389                 return icmp_release_and_return(packet, ENOMEM);
    390 
    391         header->un.param.pointer = pointer;
    392         return icmp_send_packet(ICMP_PARAMETERPROB, code, packet, header,
    393             SERVICE_ICMP, 0, 0, 0);
    394 }
    395 
    396 /** Initializes the ICMP module.
    397  *
    398  * @param[in] client_connection The client connection processing function. The
    399  *                      module skeleton propagates its own one.
    400  * @return              EOK on success.
    401  * @return              ENOMEM if there is not enough memory left.
    402  */
    403 int icmp_initialize(async_client_conn_t client_connection)
    404 {
    405         measured_string_t names[] = {
    406                 {
    407                         (char *) "ICMP_ERROR_REPORTING",
    408                         20
    409                 },
    410                 {
    411                         (char *) "ICMP_ECHO_REPLYING",
    412                         18
    413                 }
    414         };
    415         measured_string_t *configuration;
     444        header->checksum = ICMP_CHECKSUM(header, packet_get_data_length(packet));
     445        if(ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos, dont_fragment, 0))){
     446                return icmp_release_and_return(packet, ERROR_CODE);
     447        }
     448        return ip_send_msg(icmp_globals.ip_phone, -1, packet, SERVICE_ICMP, error);
     449}
     450
     451int icmp_initialize(async_client_conn_t client_connection){
     452        ERROR_DECLARE;
     453
     454        measured_string_t names[] = {{str_dup("ICMP_ERROR_REPORTING"), 20}, {str_dup("ICMP_ECHO_REPLYING"), 18}};
     455        measured_string_ref configuration;
    416456        size_t count = sizeof(names) / sizeof(measured_string_t);
    417         char *data;
    418         int rc;
     457        char * data;
    419458
    420459        fibril_rwlock_initialize(&icmp_globals.lock);
     
    422461        icmp_replies_initialize(&icmp_globals.replies);
    423462        icmp_echo_data_initialize(&icmp_globals.echo_data);
    424        
    425         icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP,
    426             SERVICE_ICMP, client_connection);
    427         if (icmp_globals.ip_phone < 0) {
    428                 fibril_rwlock_write_unlock(&icmp_globals.lock);
     463        icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP, client_connection);
     464        if(icmp_globals.ip_phone < 0){
    429465                return icmp_globals.ip_phone;
    430466        }
    431        
    432         rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
    433             &icmp_globals.packet_dimension);
    434         if (rc != EOK) {
    435                 fibril_rwlock_write_unlock(&icmp_globals.lock);
    436                 return rc;
    437         }
    438 
     467        ERROR_PROPAGATE(ip_packet_size_req(icmp_globals.ip_phone, -1, &icmp_globals.packet_dimension));
    439468        icmp_globals.packet_dimension.prefix += ICMP_HEADER_SIZE;
    440469        icmp_globals.packet_dimension.content -= ICMP_HEADER_SIZE;
    441 
     470        // get configuration
    442471        icmp_globals.error_reporting = NET_DEFAULT_ICMP_ERROR_REPORTING;
    443472        icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING;
    444 
    445         /* Get configuration */
    446473        configuration = &names[0];
    447         rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count,
    448             &data);
    449         if (rc != EOK) {
    450                 fibril_rwlock_write_unlock(&icmp_globals.lock);
    451                 return rc;
    452         }
    453        
    454         if (configuration) {
    455                 if (configuration[0].value) {
    456                         icmp_globals.error_reporting =
    457                             (configuration[0].value[0] == 'y');
     474        ERROR_PROPAGATE(net_get_conf_req(icmp_globals.net_phone, &configuration, count, &data));
     475        if(configuration){
     476                if(configuration[0].value){
     477                        icmp_globals.error_reporting = (configuration[0].value[0] == 'y');
    458478                }
    459                 if (configuration[1].value) {
    460                         icmp_globals.echo_replying =
    461                             (configuration[1].value[0] == 'y');
     479                if(configuration[1].value){
     480                        icmp_globals.echo_replying = (configuration[1].value[0] == 'y');
    462481                }
    463482                net_free_settings(configuration, data);
    464483        }
    465 
    466484        fibril_rwlock_write_unlock(&icmp_globals.lock);
    467485        return EOK;
    468486}
    469487
    470 /** Tries to set the pending reply result as the received message type.
    471  *
    472  * If the reply data is not present, the reply timed out and the other fibril
    473  * is already awake.
    474  * Releases the packet.
    475  *
    476  * @param[in] packet    The received reply message.
    477  * @param[in] header    The ICMP message header.
    478  * @param[in] type      The received reply message type.
    479  * @param[in] code      The received reply message code.
    480  */
    481 static void  icmp_process_echo_reply(packet_t *packet, icmp_header_t *header,
    482     icmp_type_t type, icmp_code_t code)
    483 {
    484         int reply_key;
    485         icmp_reply_t *reply;
    486 
    487         /* Compute the reply key */
    488         reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
    489             header->un.echo.sequence_number);
    490         pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
    491 
    492         /* Find the pending reply */
    493         fibril_rwlock_write_lock(&icmp_globals.lock);
    494         reply = icmp_replies_find(&icmp_globals.replies, reply_key);
    495         if (reply) {
    496                 reply->result = type;
    497                 fibril_condvar_signal(&reply->condvar);
    498         }
    499         fibril_rwlock_write_unlock(&icmp_globals.lock);
    500 }
    501 
    502 /** Processes the received ICMP packet.
    503  *
    504  * Notifies the destination socket application.
    505  *
    506  * @param[in,out] packet The received packet.
    507  * @param[in] error     The packet error reporting service. Prefixes the
    508  *                      received packet.
    509  * @return              EOK on success.
    510  * @return              EINVAL if the packet is not valid.
    511  * @return              EINVAL if the stored packet address is not the an_addr_t.
    512  * @return              EINVAL if the packet does not contain any data.
    513  * @return              NO_DATA if the packet content is shorter than the user
    514  *                      datagram header.
    515  * @return              ENOMEM if there is not enough memory left.
    516  * @return              EADDRNOTAVAIL if the destination socket does not exist.
    517  * @return              Other error codes as defined for the
    518  *                      ip_client_process_packet() function.
    519  */
    520 static int icmp_process_packet(packet_t *packet, services_t error)
    521 {
     488int icmp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, services_t error){
     489        ERROR_DECLARE;
     490
     491        if(ERROR_OCCURRED(icmp_process_packet(packet, error))){
     492                return icmp_release_and_return(packet, ERROR_CODE);
     493        }
     494
     495        return EOK;
     496}
     497
     498int icmp_process_packet(packet_t packet, services_t error){
     499        ERROR_DECLARE;
     500
    522501        size_t length;
    523         uint8_t *src;
     502        uint8_t * src;
    524503        int addrlen;
    525504        int result;
    526         void *data;
    527         icmp_header_t *header;
     505        void * data;
     506        icmp_header_ref header;
    528507        icmp_type_t type;
    529508        icmp_code_t code;
    530         int rc;
    531 
    532         switch (error) {
    533         case SERVICE_NONE:
    534                 break;
    535         case SERVICE_ICMP:
    536                 /* Process error */
    537                 result = icmp_client_process_packet(packet, &type, &code, NULL,
    538                     NULL);
    539                 if (result < 0)
    540                         return result;
    541                 length = (size_t) result;
    542                 /* Remove the error header */
    543                 rc = packet_trim(packet, length, 0);
    544                 if (rc != EOK)
    545                         return rc;
    546                 break;
    547         default:
    548                 return ENOTSUP;
    549         }
    550 
    551         /* Get rid of the IP header */
     509
     510        if(error){
     511                switch(error){
     512                        case SERVICE_ICMP:
     513                                // process error
     514                                result = icmp_client_process_packet(packet, &type, &code, NULL, NULL);
     515                                if(result < 0){
     516                                        return result;
     517                                }
     518                                length = (size_t) result;
     519                                // remove the error header
     520                                ERROR_PROPAGATE(packet_trim(packet, length, 0));
     521                                break;
     522                        default:
     523                                return ENOTSUP;
     524                }
     525        }
     526        // get rid of the ip header
    552527        length = ip_client_header_length(packet);
    553         rc = packet_trim(packet, length, 0);
    554         if (rc != EOK)
    555                 return rc;
     528        ERROR_PROPAGATE(packet_trim(packet, length, 0));
    556529
    557530        length = packet_get_data_length(packet);
    558         if (length <= 0)
     531        if(length <= 0){
    559532                return EINVAL;
    560 
    561         if (length < ICMP_HEADER_SIZE)
     533        }
     534        if(length < ICMP_HEADER_SIZE){
    562535                return EINVAL;
    563 
     536        }
    564537        data = packet_get_data(packet);
    565         if (!data)
     538        if(! data){
    566539                return EINVAL;
    567 
    568         /* Get ICMP header */
    569         header = (icmp_header_t *) data;
    570 
    571         if (header->checksum) {
    572                 while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) {
    573                         /*
    574                          * Set the original message type on error notification.
    575                          * Type swap observed in Qemu.
    576                          */
    577                         if (error) {
    578                                 switch (header->type) {
    579                                 case ICMP_ECHOREPLY:
    580                                         header->type = ICMP_ECHO;
    581                                         continue;
     540        }
     541        // get icmp header
     542        header = (icmp_header_ref) data;
     543        // checksum
     544        if(header->checksum){
     545                while(ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO){
     546                        // set the original message type on error notification
     547                        // type swap observed in Qemu
     548                        if(error){
     549                                switch(header->type){
     550                                        case ICMP_ECHOREPLY:
     551                                                header->type = ICMP_ECHO;
     552                                                continue;
    582553                                }
    583554                        }
     
    585556                }
    586557        }
    587 
    588         switch (header->type) {
    589         case ICMP_ECHOREPLY:
    590                 if (error)
    591                         icmp_process_echo_reply(packet, header, type, code);
    592                 else
    593                         icmp_process_echo_reply(packet, header, ICMP_ECHO, 0);
    594 
    595                 return EOK;
    596 
    597         case ICMP_ECHO:
    598                 if (error) {
    599                         icmp_process_echo_reply(packet, header, type, code);
     558        switch(header->type){
     559                case ICMP_ECHOREPLY:
     560                        if(error){
     561                                return icmp_process_echo_reply(packet, header, type, code);
     562                        }else{
     563                                return icmp_process_echo_reply(packet, header, ICMP_ECHO, 0);
     564                        }
     565                case ICMP_ECHO:
     566                        if(error){
     567                                return icmp_process_echo_reply(packet, header, type, code);
     568                        // do not send a reply if disabled
     569                        }else if(icmp_globals.echo_replying){
     570                                addrlen = packet_get_addr(packet, &src, NULL);
     571                                if((addrlen > 0)
     572                                // set both addresses to the source one (avoids the source address deletion before setting the destination one)
     573                                        && (packet_set_addr(packet, src, src, (size_t) addrlen) == EOK)){
     574                                        // send the reply
     575                                        icmp_send_packet(ICMP_ECHOREPLY, 0, packet, header, 0, 0, 0, 0);
     576                                        return EOK;
     577                                }else{
     578                                        return EINVAL;
     579                                }
     580                        }else{
     581                                return EPERM;
     582                        }
     583                case ICMP_DEST_UNREACH:
     584                case ICMP_SOURCE_QUENCH:
     585                case ICMP_REDIRECT:
     586                case ICMP_ALTERNATE_ADDR:
     587                case ICMP_ROUTER_ADV:
     588                case ICMP_ROUTER_SOL:
     589                case ICMP_TIME_EXCEEDED:
     590                case ICMP_PARAMETERPROB:
     591                case ICMP_CONVERSION_ERROR:
     592                case ICMP_REDIRECT_MOBILE:
     593                case ICMP_SKIP:
     594                case ICMP_PHOTURIS:
     595                        ip_received_error_msg(icmp_globals.ip_phone, -1, packet, SERVICE_IP, SERVICE_ICMP);
    600596                        return EOK;
    601                 }
    602                
    603                 /* Do not send a reply if disabled */
    604                 if (icmp_globals.echo_replying) {
    605                         addrlen = packet_get_addr(packet, &src, NULL);
    606 
    607                         /*
    608                          * Set both addresses to the source one (avoids the
    609                          * source address deletion before setting the
    610                          * destination one).
    611                          */
    612                         if ((addrlen > 0) && (packet_set_addr(packet, src, src,
    613                             (size_t) addrlen) == EOK)) {
    614                                 /* Send the reply */
    615                                 icmp_send_packet(ICMP_ECHOREPLY, 0, packet,
    616                                     header, 0, 0, 0, 0);
    617                                 return EOK;
     597                default:
     598                        return ENOTSUP;
     599        }
     600}
     601
     602int icmp_process_echo_reply(packet_t packet, icmp_header_ref header, icmp_type_t type, icmp_code_t code){
     603        int reply_key;
     604        icmp_reply_ref reply;
     605
     606        // compute the reply key
     607        reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier, header->un.echo.sequence_number);
     608        pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
     609        // lock the globals
     610        fibril_rwlock_write_lock(&icmp_globals.lock);
     611        // find the pending reply
     612        reply = icmp_replies_find(&icmp_globals.replies, reply_key);
     613        if(reply){
     614                // set the result
     615                reply->result = type;
     616                // notify the waiting fibril
     617                fibril_condvar_signal(&reply->condvar);
     618        }
     619        fibril_rwlock_write_unlock(&icmp_globals.lock);
     620        return EOK;
     621}
     622
     623int icmp_message_standalone(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     624        ERROR_DECLARE;
     625
     626        packet_t packet;
     627
     628        *answer_count = 0;
     629        switch(IPC_GET_METHOD(*call)){
     630                case NET_TL_RECEIVED:
     631                        if(! ERROR_OCCURRED(packet_translate_remote(icmp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
     632                                ERROR_CODE = icmp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_ICMP, IPC_GET_ERROR(call));
    618633                        }
    619 
    620                         return EINVAL;
    621                 }
    622 
    623                 return EPERM;
    624 
    625         case ICMP_DEST_UNREACH:
    626         case ICMP_SOURCE_QUENCH:
    627         case ICMP_REDIRECT:
    628         case ICMP_ALTERNATE_ADDR:
    629         case ICMP_ROUTER_ADV:
    630         case ICMP_ROUTER_SOL:
    631         case ICMP_TIME_EXCEEDED:
    632         case ICMP_PARAMETERPROB:
    633         case ICMP_CONVERSION_ERROR:
    634         case ICMP_REDIRECT_MOBILE:
    635         case ICMP_SKIP:
    636         case ICMP_PHOTURIS:
    637                 ip_received_error_msg(icmp_globals.ip_phone, -1, packet,
    638                     SERVICE_IP, SERVICE_ICMP);
    639                 return EOK;
    640 
    641         default:
    642                 return ENOTSUP;
    643         }
    644 }
    645 
    646 /** Processes the received ICMP packet.
    647  *
    648  * Is used as an entry point from the underlying IP module.
    649  * Releases the packet on error.
    650  *
    651  * @param device_id     The device identifier. Ignored parameter.
    652  * @param[in,out] packet The received packet.
    653  * @param receiver      The target service. Ignored parameter.
    654  * @param[in] error     The packet error reporting service. Prefixes the
    655  *                      received packet.
    656  * @return              EOK on success.
    657  * @return              Other error codes as defined for the
    658  *                      icmp_process_packet() function.
    659  */
    660 static int icmp_received_msg_local(device_id_t device_id, packet_t *packet,
    661     services_t receiver, services_t error)
    662 {
    663         int rc;
    664 
    665         rc = icmp_process_packet(packet, error);
    666         if (rc != EOK)
    667                 return icmp_release_and_return(packet, rc);
    668 
    669         return EOK;
    670 }
    671 
    672 /** Processes the generic client messages.
    673  *
    674  * @param[in] call      The message parameters.
    675  * @return              EOK on success.
    676  * @return              ENOTSUP if the message is not known.
    677  * @return              Other error codes as defined for the packet_translate()
    678  *                      function.
    679  * @return              Other error codes as defined for the
    680  *                      icmp_destination_unreachable_msg_local() function.
    681  * @return              Other error codes as defined for the
    682  *                      icmp_source_quench_msg_local() function.
    683  * @return              Other error codes as defined for the
    684  *                      icmp_time_exceeded_msg_local() function.
    685  * @return              Other error codes as defined for the
    686  *                      icmp_parameter_problem_msg_local() function.
    687  *
    688  * @see icmp_interface.h
    689  */
    690 static int icmp_process_message(ipc_call_t *call)
    691 {
    692         packet_t *packet;
    693         int rc;
    694 
    695         switch (IPC_GET_METHOD(*call)) {
    696         case NET_ICMP_DEST_UNREACH:
    697                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    698                     IPC_GET_PACKET(call));
    699                 if (rc != EOK)
    700                         return rc;
    701                 return icmp_destination_unreachable_msg_local(0,
    702                     ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
    703         case NET_ICMP_SOURCE_QUENCH:
    704                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    705                     IPC_GET_PACKET(call));
    706                 if (rc != EOK)
    707                         return rc;
    708                 return icmp_source_quench_msg_local(0, packet);
    709         case NET_ICMP_TIME_EXCEEDED:
    710                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    711                     IPC_GET_PACKET(call));
    712                 if (rc != EOK)
    713                         return rc;
    714                 return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(call),
    715                     packet);
    716         case NET_ICMP_PARAMETERPROB:
    717                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    718                     IPC_GET_PACKET(call));
    719                 if (rc != EOK)
    720                         return rc;
    721                 return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(call),
    722                     ICMP_GET_POINTER(call), packet);
    723         default:
    724                 return ENOTSUP;
    725         }
    726 }
    727 
    728 /** Assigns a new identifier for the connection.
    729  *
    730  * Fills the echo data parameter with the assigned values.
    731  *
    732  * @param[in,out] echo_data The echo data to be bound.
    733  * @return              Index of the inserted echo data.
    734  * @return              EBADMEM if the echo_data parameter is NULL.
    735  * @return              ENOTCONN if no free identifier have been found.
    736  */
    737 static int icmp_bind_free_id(icmp_echo_t *echo_data)
    738 {
    739         icmp_param_t index;
    740 
    741         if (!echo_data)
    742                 return EBADMEM;
    743 
    744         /* From the last used one */
    745         index = icmp_globals.last_used_id;
    746         do {
    747                 index++;
    748                 /* til the range end */
    749                 if (index >= ICMP_FREE_IDS_END) {
    750                         /* start from the range beginning */
    751                         index = ICMP_FREE_IDS_START - 1;
    752                         do {
    753                                 index++;
    754                                 /* til the last used one */
    755                                 if (index >= icmp_globals.last_used_id) {
    756                                         /* none found */
    757                                         return ENOTCONN;
    758                                 }
    759                         } while(icmp_echo_data_find(&icmp_globals.echo_data,
    760                             index) != NULL);
    761 
    762                         /* Found, break immediately */
    763                         break;
    764                 }
    765         } while (icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
    766 
    767         echo_data->identifier = index;
    768         echo_data->sequence_number = 0;
    769 
    770         return icmp_echo_data_add(&icmp_globals.echo_data, index, echo_data);
    771 }
    772 
    773 /** Processes the client messages.
    774  *
    775  * Remembers the assigned identifier and sequence numbers.
    776  * Runs until the client module disconnects.
    777  *
    778  * @param[in] callid    The message identifier.
    779  * @param[in] call      The message parameters.
    780  * @return EOK.
    781  *
    782  * @see icmp_interface.h
    783  * @see icmp_api.h
    784  */
    785 static int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
    786 {
     634                        return ERROR_CODE;
     635                case NET_ICMP_INIT:
     636                        return icmp_process_client_messages(callid, * call);
     637                default:
     638                        return icmp_process_message(call);
     639        }
     640        return ENOTSUP;
     641}
     642
     643int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call){
     644        ERROR_DECLARE;
     645
    787646        bool keep_on_going = true;
     647//      fibril_rwlock_t                 lock;
    788648        ipc_call_t answer;
    789649        int answer_count;
    790650        size_t length;
    791         struct sockaddr *addr;
     651        struct sockaddr * addr;
    792652        ipc_callid_t data_callid;
    793         icmp_echo_t *echo_data;
    794         int rc = EOK;
     653        icmp_echo_ref echo_data;
     654        int res;
    795655
    796656        /*
     
    798658         *  - Answer the first NET_ICMP_INIT call.
    799659         */
     660        res = EOK;
    800661        answer_count = 0;
    801662
    802         echo_data = (icmp_echo_t *) malloc(sizeof(*echo_data));
    803         if (!echo_data)
     663//      fibril_rwlock_initialize(&lock);
     664
     665        echo_data = (icmp_echo_ref) malloc(sizeof(*echo_data));
     666        if(! echo_data){
    804667                return ENOMEM;
    805 
    806         /* Assign a new identifier */
     668        }
     669
     670        // assign a new identifier
    807671        fibril_rwlock_write_lock(&icmp_globals.lock);
    808         rc = icmp_bind_free_id(echo_data);
     672        res = icmp_bind_free_id(echo_data);
    809673        fibril_rwlock_write_unlock(&icmp_globals.lock);
    810         if (rc < 0) {
     674        if(res < 0){
    811675                free(echo_data);
    812                 return rc;
    813         }
    814 
    815         while (keep_on_going) {
    816                 /* Answer the call */
    817                 answer_call(callid, rc, &answer, answer_count);
    818 
    819                 /* Refresh data */
     676                return res;
     677        }
     678
     679        while(keep_on_going){
     680
     681                // answer the call
     682                answer_call(callid, res, &answer, answer_count);
     683
     684                // refresh data
    820685                refresh_answer(&answer, &answer_count);
    821686
    822                 /* Get the next call */
     687                // get the next call
    823688                callid = async_get_call(&call);
    824689
    825                 /* Process the call */
    826                 switch (IPC_GET_METHOD(call)) {
    827                 case IPC_M_PHONE_HUNGUP:
    828                         keep_on_going = false;
    829                         rc = EHANGUP;
    830                         break;
    831                
    832                 case NET_ICMP_ECHO:
    833                         if (!async_data_write_receive(&data_callid, &length)) {
    834                                 rc = EINVAL;
     690                // process the call
     691                switch(IPC_GET_METHOD(call)){
     692                        case IPC_M_PHONE_HUNGUP:
     693                                keep_on_going = false;
     694                                res = EHANGUP;
    835695                                break;
    836                         }
    837                        
    838                         addr = malloc(length);
    839                         if (!addr) {
    840                                 rc = ENOMEM;
     696                        case NET_ICMP_ECHO:
     697//                              fibril_rwlock_write_lock(&lock);
     698                                if(! async_data_write_receive(&data_callid, &length)){
     699                                        res = EINVAL;
     700                                }else{
     701                                        addr = malloc(length);
     702                                        if(! addr){
     703                                                res = ENOMEM;
     704                                        }else{
     705                                                if(! ERROR_OCCURRED(async_data_write_finalize(data_callid, addr, length))){
     706                                                        fibril_rwlock_write_lock(&icmp_globals.lock);
     707                                                        res = icmp_echo(echo_data->identifier, echo_data->sequence_number, ICMP_GET_SIZE(call), ICMP_GET_TIMEOUT(call), ICMP_GET_TTL(call), ICMP_GET_TOS(call), ICMP_GET_DONT_FRAGMENT(call), addr, (socklen_t) length);
     708                                                        fibril_rwlock_write_unlock(&icmp_globals.lock);
     709                                                        free(addr);
     710                                                        if(echo_data->sequence_number < UINT16_MAX){
     711                                                                ++ echo_data->sequence_number;
     712                                                        }else{
     713                                                                echo_data->sequence_number = 0;
     714                                                        }
     715                                                }else{
     716                                                        res = ERROR_CODE;
     717                                                }
     718                                        }
     719                                }
     720//                              fibril_rwlock_write_unlock(&lock);
    841721                                break;
    842                         }
    843                        
    844                         rc = async_data_write_finalize(data_callid, addr,
    845                             length);
    846                         if (rc != EOK) {
    847                                 free(addr);
    848                                 break;
    849                         }
    850 
    851                         fibril_rwlock_write_lock(&icmp_globals.lock);
    852                         rc = icmp_echo(echo_data->identifier,
    853                             echo_data->sequence_number, ICMP_GET_SIZE(call),
    854                             ICMP_GET_TIMEOUT(call), ICMP_GET_TTL(call),
    855                             ICMP_GET_TOS(call), ICMP_GET_DONT_FRAGMENT(call),
    856                             addr, (socklen_t) length);
    857                         fibril_rwlock_write_unlock(&icmp_globals.lock);
    858 
    859                         free(addr);
    860 
    861                         if (echo_data->sequence_number < UINT16_MAX)
    862                                 echo_data->sequence_number++;
    863                         else
    864                                 echo_data->sequence_number = 0;
    865 
    866                         break;
    867 
    868                 default:
    869                         rc = icmp_process_message(&call);
     722                        default:
     723                                res = icmp_process_message(&call);
    870724                }
    871 
    872         }
    873 
    874         /* Release the identifier */
     725        }
     726
     727        // release the identifier
    875728        fibril_rwlock_write_lock(&icmp_globals.lock);
    876729        icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier);
    877730        fibril_rwlock_write_unlock(&icmp_globals.lock);
    878 
    879         return rc;
    880 }
    881 
    882 /** Processes the ICMP message.
    883  *
    884  * @param[in] callid    The message identifier.
    885  * @param[in] call      The message parameters.
    886  * @param[out] answer   The message answer parameters.
    887  * @param[out] answer_count The last parameter for the actual answer in the
    888  *                      answer parameter.
    889  * @return              EOK on success.
    890  * @return              ENOTSUP if the message is not known.
    891  *
    892  * @see icmp_interface.h
    893  * @see IS_NET_ICMP_MESSAGE()
    894  */
    895 int icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    896     ipc_call_t *answer, int *answer_count)
    897 {
    898         packet_t *packet;
    899         int rc;
    900 
    901         *answer_count = 0;
    902         switch (IPC_GET_METHOD(*call)) {
    903         case NET_TL_RECEIVED:
    904                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    905                     IPC_GET_PACKET(call));
    906                 if (rc != EOK)
    907                         return rc;
    908                 return icmp_received_msg_local(IPC_GET_DEVICE(call), packet,
    909                     SERVICE_ICMP, IPC_GET_ERROR(call));
    910        
    911         case NET_ICMP_INIT:
    912                 return icmp_process_client_messages(callid, * call);
    913        
    914         default:
    915                 return icmp_process_message(call);
    916         }
    917 
    918         return ENOTSUP;
    919 }
    920 
     731        return res;
     732}
     733
     734int icmp_process_message(ipc_call_t * call){
     735        ERROR_DECLARE;
     736
     737        packet_t packet;
     738
     739        switch(IPC_GET_METHOD(*call)){
     740                case NET_ICMP_DEST_UNREACH:
     741                        if(! ERROR_OCCURRED(packet_translate_remote(icmp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
     742                                ERROR_CODE = icmp_destination_unreachable_msg(0, ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
     743                        }
     744                        return ERROR_CODE;
     745                case NET_ICMP_SOURCE_QUENCH:
     746                        if(! ERROR_OCCURRED(packet_translate_remote(icmp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
     747                                ERROR_CODE = icmp_source_quench_msg(0, packet);
     748                        }
     749                        return ERROR_CODE;
     750                case NET_ICMP_TIME_EXCEEDED:
     751                        if(! ERROR_OCCURRED(packet_translate_remote(icmp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
     752                                ERROR_CODE = icmp_time_exceeded_msg(0, ICMP_GET_CODE(call), packet);
     753                        }
     754                        return ERROR_CODE;
     755                case NET_ICMP_PARAMETERPROB:
     756                        if(! ERROR_OCCURRED(packet_translate_remote(icmp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
     757                                ERROR_CODE = icmp_parameter_problem_msg(0, ICMP_GET_CODE(call), ICMP_GET_POINTER(call), packet);
     758                        }
     759                        return ERROR_CODE;
     760                default:
     761                        return ENOTSUP;
     762        }
     763}
     764
     765int icmp_release_and_return(packet_t packet, int result){
     766        pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
     767        return result;
     768}
     769
     770int icmp_bind_free_id(icmp_echo_ref echo_data){
     771        icmp_param_t index;
     772
     773        if(! echo_data){
     774                return EBADMEM;
     775        }
     776        // from the last used one
     777        index = icmp_globals.last_used_id;
     778        do{
     779                ++ index;
     780                // til the range end
     781                if(index >= ICMP_FREE_IDS_END){
     782                        // start from the range beginning
     783                        index = ICMP_FREE_IDS_START - 1;
     784                        do{
     785                                ++ index;
     786                                // til the last used one
     787                                if(index >= icmp_globals.last_used_id){
     788                                        // none found
     789                                        return ENOTCONN;
     790                                }
     791                        }while(icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
     792                        // found, break immediately
     793                        break;
     794                }
     795        }while(icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
     796        echo_data->identifier = index;
     797        echo_data->sequence_number = 0;
     798        return icmp_echo_data_add(&icmp_globals.echo_data, index, echo_data);
     799}
    921800
    922801/** Default thread for new connections.
    923802 *
    924  * @param[in] iid The initial message identifier.
    925  * @param[in] icall The initial message call structure.
     803 *  @param[in] iid The initial message identifier.
     804 *  @param[in] icall The initial message call structure.
    926805 *
    927806 */
    928 static void tl_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     807static void tl_client_connection(ipc_callid_t iid, ipc_call_t * icall)
    929808{
    930809        /*
     
    934813        ipc_answer_0(iid, EOK);
    935814       
    936         while (true) {
     815        while(true) {
    937816                ipc_call_t answer;
    938817                int answer_count;
     
    949828                    &answer_count);
    950829               
    951                 /*
    952                  * End if told to either by the message or the processing
    953                  * result.
    954                  */
    955                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
    956                     (res == EHANGUP))
     830                /* End if said to either by the message or the processing result */
     831                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
    957832                        return;
    958833               
     
    964839/** Starts the module.
    965840 *
    966  * @return              EOK on success.
    967  * @return              Other error codes as defined for each specific module
    968  *                      start function.
     841 *  @param argc The count of the command line arguments. Ignored parameter.
     842 *  @param argv The command line parameters. Ignored parameter.
     843 *
     844 *  @returns EOK on success.
     845 *  @returns Other error codes as defined for each specific module start function.
     846 *
    969847 */
    970848int main(int argc, char *argv[])
    971849{
    972         int rc;
     850        ERROR_DECLARE;
    973851       
    974852        /* Start the module */
    975         rc = tl_module_start_standalone(tl_client_connection);
    976         return rc;
     853        if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection)))
     854                return ERROR_CODE;
     855       
     856        return EOK;
    977857}
    978858
    979859/** @}
    980860 */
    981 
Note: See TracChangeset for help on using the changeset viewer.