Changes in uspace/srv/net/tl/icmp/icmp.c [61bfc370:ffa2c8ef] in mainline
- File:
-
- 1 edited
-
uspace/srv/net/tl/icmp/icmp.c (modified) (7 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/net/tl/icmp/icmp.c
r61bfc370 rffa2c8ef 33 33 /** @file 34 34 * ICMP module implementation. 35 * @see icmp.h 36 */ 37 38 #include "icmp.h" 39 #include "icmp_module.h" 35 */ 40 36 41 37 #include <async.h> … … 45 41 #include <stdint.h> 46 42 #include <str.h> 47 #include <ipc/ipc.h>48 43 #include <ipc/services.h> 49 44 #include <ipc/net.h> … … 54 49 #include <byteorder.h> 55 50 #include <errno.h> 51 #include <adt/hash_table.h> 56 52 57 53 #include <net/socket_codes.h> … … 67 63 #include <net_checksum.h> 68 64 #include <icmp_client.h> 69 #include <icmp_ interface.h>70 #include <il_ interface.h>65 #include <icmp_remote.h> 66 #include <il_remote.h> 71 67 #include <ip_client.h> 72 68 #include <ip_interface.h> 73 69 #include <net_interface.h> 74 #include <tl_ interface.h>75 #include <tl_ local.h>70 #include <tl_remote.h> 71 #include <tl_skel.h> 76 72 #include <icmp_header.h> 77 73 78 /** ICMP module name. */ 79 #define NAME "ICMP protocol" 80 81 /** Default ICMP error reporting. */ 82 #define NET_DEFAULT_ICMP_ERROR_REPORTING true 83 84 /** Default ICMP echo replying. */ 85 #define NET_DEFAULT_ICMP_ECHO_REPLYING true 86 87 /** Original datagram length in bytes transfered to the error notification 88 * message. 89 */ 90 #define ICMP_KEEP_LENGTH 8 91 92 /** Free identifier numbers pool start. */ 93 #define ICMP_FREE_IDS_START 1 94 95 /** Free identifier numbers pool end. */ 96 #define ICMP_FREE_IDS_END UINT16_MAX 97 98 /** 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. 74 /** ICMP module name */ 75 #define NAME "icmp" 76 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 * 103 96 */ 104 97 #define ICMP_CHECKSUM(header, length) \ … … 106 99 107 100 /** An echo request datagrams pattern. */ 108 #define ICMP_ECHO_TEXT "Hello from HelenOS." 109 110 /** 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. */ 121 icmp_globals_t icmp_globals; 122 123 INT_MAP_IMPLEMENT(icmp_replies, icmp_reply_t); 124 INT_MAP_IMPLEMENT(icmp_echo_data, icmp_echo_t); 125 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)); 135 return result; 136 } 137 138 /** Sends the ICMP message. 139 * 140 * Sets the message type and code and computes the checksum. 101 #define ICMP_ECHO_TEXT "ICMP hello from HelenOS." 102 103 /** ICMP reply data. */ 104 typedef 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 */ 120 static int phone_net = -1; 121 static int phone_ip = -1; 122 static bool error_reporting = true; 123 static bool echo_replying = true; 124 static packet_dimension_t icmp_dimension; 125 126 /** ICMP client identification counter */ 127 static atomic_t icmp_client; 128 129 /** ICMP identifier and sequence number (client-specific) */ 130 static fibril_local icmp_param_t icmp_id; 131 static fibril_local icmp_param_t icmp_seq; 132 133 /** Reply hash table */ 134 static fibril_mutex_t reply_lock; 135 static hash_table_t replies; 136 137 static 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 147 static 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 158 static void replies_remove_callback(link_t *item) 159 { 160 } 161 162 static 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 */ 173 static 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. 141 181 * 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 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 */ 198 static 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 { 163 202 /* Do not send an error if disabled */ 164 if (error && !icmp_globals.error_reporting) 165 return icmp_release_and_return(packet, EPERM); 166 203 if ((error) && (!error_reporting)) { 204 icmp_release(packet); 205 return EPERM; 206 } 207 167 208 header->type = type; 168 209 header->code = code; 210 211 /* 212 * The checksum needs to be calculated 213 * with a virtual checksum field set to 214 * zero. 215 */ 169 216 header->checksum = 0; 170 217 header->checksum = ICMP_CHECKSUM(header, 171 218 packet_get_data_length(packet)); 172 219 173 rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,220 int rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos, 174 221 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. 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 * 188 237 * @return The prefixed ICMP header. 189 238 * @return NULL on errors. 239 * 190 240 */ 191 241 static icmp_header_t *icmp_prepare_packet(packet_t *packet) 192 242 { 193 icmp_header_t *header; 194 size_t header_length; 195 size_t total_length; 196 197 total_length = packet_get_data_length(packet); 243 size_t total_length = packet_get_data_length(packet); 198 244 if (total_length <= 0) 199 245 return NULL; 200 201 header_length = ip_client_header_length(packet);246 247 size_t header_length = ip_client_header_length(packet); 202 248 if (header_length <= 0) 203 249 return NULL; 204 250 205 251 /* Truncate if longer than 64 bits (without the IP header) */ 206 252 if ((total_length > header_length + ICMP_KEEP_LENGTH) && 207 253 (packet_trim(packet, 0, 208 total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) {254 total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) 209 255 return NULL; 210 } 211 212 header = PACKET_PREFIX(packet, icmp_header_t); 256 257 icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t); 213 258 if (!header) 214 259 return NULL; 215 260 216 261 bzero(header, sizeof(*header)); 217 262 return header; 218 263 } 219 264 220 /** Request san echo message.221 * 222 * Send s a packet with specified parameters to the target host and waits for223 * the reply upto the given timeout.224 * Block sthe 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 not233 * 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 237 * @return 238 * 239 * @return 240 * @return 241 * 242 * @return 243 * @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 * 244 289 */ 245 290 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 291 mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, bool dont_fragment, 292 const struct sockaddr *addr, socklen_t addrlen) 293 { 258 294 if (addrlen <= 0) 259 295 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); 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); 272 302 if (!packet) 273 303 return ENOMEM; 274 304 275 305 /* 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 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 280 312 /* 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 313 uint8_t *data = (uint8_t *) packet_suffix(packet, size); 314 if (!data) { 315 icmp_release(packet); 316 return ENOMEM; 317 } 318 285 319 /* Fill the data */ 286 320 length = 0; … … 290 324 } 291 325 memcpy(data + length, ICMP_ECHO_TEXT, size - length); 292 326 293 327 /* 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)); 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)); 299 335 header->un.echo.identifier = id; 300 336 header->un.echo.sequence_number = sequence; 301 337 302 338 /* 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); 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; 309 347 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 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 321 355 /* Send the request */ 322 356 icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos, 323 357 dont_fragment); 324 358 325 359 /* Wait for the reply. Timeout in microseconds. */ 326 rc = fibril_condvar_wait_timeout(&reply->condvar, &reply ->mutex,360 rc = fibril_condvar_wait_timeout(&reply->condvar, &reply_lock, 327 361 timeout * 1000); 328 362 if (rc == EOK) 329 363 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 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 338 372 return rc; 339 373 } 340 374 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 375 static 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 350 384 if (mtu) 351 385 header->un.frag.mtu = mtu; 352 386 353 387 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 388 SERVICE_ICMP, 0, 0, false); 389 } 390 391 static 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 365 399 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, 400 SERVICE_ICMP, 0, 0, false); 401 } 402 403 static 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 415 static int icmp_parameter_problem(icmp_code_t code, icmp_param_t pointer, 370 416 packet_t *packet) 371 417 { 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 418 icmp_header_t *header = icmp_prepare_packet(packet); 419 if (!header) { 420 icmp_release(packet); 421 return ENOMEM; 422 } 423 391 424 header->un.param.pointer = pointer; 392 425 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) 426 SERVICE_ICMP, 0, 0, false); 427 } 428 429 /** Try to set the pending reply result as the received message type. 430 * 431 * If the reply data is not present, the reply timed out and the other fibril 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 */ 440 static void icmp_process_echo_reply(packet_t *packet, icmp_header_t *header, 441 icmp_type_t type, icmp_code_t code) 442 { 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 449 /* Find the pending 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 457 reply->result = type; 458 fibril_condvar_signal(&reply->condvar); 459 } 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 * 483 */ 484 static int icmp_process_packet(packet_t *packet, services_t error) 485 { 486 icmp_type_t type; 487 icmp_code_t code; 488 int rc; 489 490 switch (error) { 491 case SERVICE_NONE: 492 break; 493 case SERVICE_ICMP: 494 /* Process error */ 495 rc = icmp_client_process_packet(packet, &type, &code, NULL, NULL); 496 if (rc < 0) 497 return rc; 498 499 /* Remove the error header */ 500 rc = packet_trim(packet, (size_t) rc, 0); 501 if (rc != EOK) 502 return rc; 503 504 break; 505 default: 506 return ENOTSUP; 507 } 508 509 /* Get rid of the IP header */ 510 size_t length = ip_client_header_length(packet); 511 rc = packet_trim(packet, length, 0); 512 if (rc != EOK) 513 return rc; 514 515 length = packet_get_data_length(packet); 516 if (length <= 0) 517 return EINVAL; 518 519 if (length < ICMP_HEADER_SIZE) 520 return EINVAL; 521 522 void *data = packet_get_data(packet); 523 if (!data) 524 return EINVAL; 525 526 /* Get ICMP header */ 527 icmp_header_t *header = (icmp_header_t *) data; 528 529 if (header->checksum) { 530 while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) { 531 /* 532 * Set the original message type on error notification. 533 * Type swap observed in Qemu. 534 */ 535 if (error) { 536 switch (header->type) { 537 case ICMP_ECHOREPLY: 538 header->type = ICMP_ECHO; 539 continue; 540 } 541 } 542 543 return EINVAL; 544 } 545 } 546 547 switch (header->type) { 548 case ICMP_ECHOREPLY: 549 if (error) 550 icmp_process_echo_reply(packet, header, type, code); 551 else 552 icmp_process_echo_reply(packet, header, ICMP_ECHO, 0); 553 554 return EOK; 555 556 case ICMP_ECHO: 557 if (error) { 558 icmp_process_echo_reply(packet, header, type, code); 559 return EOK; 560 } 561 562 /* Do not send a reply if disabled */ 563 if (echo_replying) { 564 uint8_t *src; 565 int addrlen = packet_get_addr(packet, &src, NULL); 566 567 /* 568 * Set both addresses to the source one (avoid the 569 * source address deletion before setting the 570 * destination one). 571 */ 572 if ((addrlen > 0) && (packet_set_addr(packet, src, src, 573 (size_t) addrlen) == EOK)) { 574 /* Send the reply */ 575 icmp_send_packet(ICMP_ECHOREPLY, 0, packet, 576 header, 0, 0, 0, 0); 577 return EOK; 578 } 579 580 return EINVAL; 581 } 582 583 return EPERM; 584 585 case ICMP_DEST_UNREACH: 586 case ICMP_SOURCE_QUENCH: 587 case ICMP_REDIRECT: 588 case ICMP_ALTERNATE_ADDR: 589 case ICMP_ROUTER_ADV: 590 case ICMP_ROUTER_SOL: 591 case ICMP_TIME_EXCEEDED: 592 case ICMP_PARAMETERPROB: 593 case ICMP_CONVERSION_ERROR: 594 case ICMP_REDIRECT_MOBILE: 595 case ICMP_SKIP: 596 case ICMP_PHOTURIS: 597 ip_received_error_msg(phone_ip, -1, packet, 598 SERVICE_IP, SERVICE_ICMP); 599 return EOK; 600 601 default: 602 return ENOTSUP; 603 } 604 } 605 606 /** Process IPC messages from the IP module 607 * 608 * @param[in] iid Message identifier. 609 * @param[in,out] icall Message parameters. 610 * 611 */ 612 static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall) 613 { 614 bool loop = true; 615 packet_t *packet; 616 int rc; 617 618 while (loop) { 619 switch (IPC_GET_IMETHOD(*icall)) { 620 case NET_TL_RECEIVED: 621 rc = packet_translate_remote(phone_net, &packet, 622 IPC_GET_PACKET(*icall)); 623 if (rc == EOK) { 624 rc = icmp_process_packet(packet, IPC_GET_ERROR(*icall)); 625 if (rc != EOK) 626 icmp_release(packet); 627 } 628 629 async_answer_0(iid, (sysarg_t) rc); 630 break; 631 case IPC_M_PHONE_HUNGUP: 632 loop = false; 633 continue; 634 default: 635 async_answer_0(iid, (sysarg_t) ENOTSUP); 636 } 637 638 iid = async_get_call(icall); 639 } 640 } 641 642 /** Initialize the ICMP module. 643 * 644 * @param[in] net_phone Network module phone. 645 * 646 * @return EOK on success. 647 * @return ENOMEM if there is not enough memory left. 648 * 649 */ 650 int tl_initialize(int net_phone) 404 651 { 405 652 measured_string_t names[] = { … … 416 663 size_t count = sizeof(names) / sizeof(measured_string_t); 417 664 uint8_t *data; 418 int rc; 419 420 fibril_rwlock_initialize(&icmp_globals.lock); 421 fibril_rwlock_write_lock(&icmp_globals.lock); 422 icmp_replies_initialize(&icmp_globals.replies); 423 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); 429 return icmp_globals.ip_phone; 430 } 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); 665 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) 436 680 return rc; 437 } 438 439 icmp_globals.packet_dimension.prefix += ICMP_HEADER_SIZE; 440 icmp_globals.packet_dimension.content -= ICMP_HEADER_SIZE; 441 442 icmp_globals.error_reporting = NET_DEFAULT_ICMP_ERROR_REPORTING; 443 icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING; 444 681 682 icmp_dimension.prefix += ICMP_HEADER_SIZE; 683 icmp_dimension.content -= ICMP_HEADER_SIZE; 684 445 685 /* Get configuration */ 446 686 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); 687 rc = net_get_conf_req(phone_net, &configuration, count, &data); 688 if (rc != EOK) 451 689 return rc; 452 }453 690 454 691 if (configuration) { 455 if (configuration[0].value) { 456 icmp_globals.error_reporting = 457 (configuration[0].value[0] == 'y'); 458 } 459 if (configuration[1].value) { 460 icmp_globals.echo_replying = 461 (configuration[1].value[0] == 'y'); 462 } 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 463 698 net_free_settings(configuration, data); 464 699 } 465 466 fibril_rwlock_write_unlock(&icmp_globals.lock); 700 467 701 return EOK; 468 702 } 469 703 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 { 522 size_t length; 523 uint8_t *src; 524 int addrlen; 525 int result; 526 void *data; 527 icmp_header_t *header; 528 icmp_type_t type; 529 icmp_code_t code; 704 /** Per-connection initialization 705 * 706 * Initialize client-specific global variables. 707 * 708 */ 709 void 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 */ 739 int 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; 744 packet_t *packet; 530 745 int rc; 531 746 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); 747 *count = 0; 748 749 switch (IPC_GET_IMETHOD(*call)) { 750 case NET_ICMP_ECHO: 751 rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &size); 544 752 if (rc != EOK) 545 753 return rc; 546 break; 547 default: 548 return ENOTSUP; 549 } 550 551 /* Get rid of the IP header */ 552 length = ip_client_header_length(packet); 553 rc = packet_trim(packet, length, 0); 554 if (rc != EOK) 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++; 555 762 return rc; 556 557 length = packet_get_data_length(packet); 558 if (length <= 0) 559 return EINVAL; 560 561 if (length < ICMP_HEADER_SIZE) 562 return EINVAL; 563 564 data = packet_get_data(packet); 565 if (!data) 566 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; 582 } 583 } 584 return EINVAL; 585 } 586 } 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); 600 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; 618 } 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_IMETHOD(*call)) { 763 696 764 case NET_ICMP_DEST_UNREACH: 697 rc = packet_translate_remote( icmp_globals.net_phone, &packet,698 IPC_GET_PACKET( call));765 rc = packet_translate_remote(phone_net, &packet, 766 IPC_GET_PACKET(*call)); 699 767 if (rc != EOK) 700 768 return rc; 701 return icmp_destination_unreachable_msg_local(0, 702 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 703 773 case NET_ICMP_SOURCE_QUENCH: 704 rc = packet_translate_remote( icmp_globals.net_phone, &packet,705 IPC_GET_PACKET( call));774 rc = packet_translate_remote(phone_net, &packet, 775 IPC_GET_PACKET(*call)); 706 776 if (rc != EOK) 707 777 return rc; 708 return icmp_source_quench_msg_local(0, packet); 778 779 return icmp_source_quench(packet); 780 709 781 case NET_ICMP_TIME_EXCEEDED: 710 rc = packet_translate_remote( icmp_globals.net_phone, &packet,711 IPC_GET_PACKET( call));782 rc = packet_translate_remote(phone_net, &packet, 783 IPC_GET_PACKET(*call)); 712 784 if (rc != EOK) 713 785 return rc; 714 return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(call), 715 packet); 786 787 return icmp_time_exceeded(ICMP_GET_CODE(*call), packet); 788 716 789 case NET_ICMP_PARAMETERPROB: 717 rc = packet_translate_remote( icmp_globals.net_phone, &packet,718 IPC_GET_PACKET( call));790 rc = packet_translate_remote(phone_net, &packet, 791 IPC_GET_PACKET(*call)); 719 792 if (rc != EOK) 720 793 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 { 787 bool keep_on_going = true; 788 ipc_call_t answer; 789 int answer_count; 790 size_t length; 791 struct sockaddr *addr; 792 ipc_callid_t data_callid; 793 icmp_echo_t *echo_data; 794 int rc = EOK; 795 796 /* 797 * Accept the connection 798 * - Answer the first NET_ICMP_INIT call. 799 */ 800 answer_count = 0; 801 802 echo_data = (icmp_echo_t *) malloc(sizeof(*echo_data)); 803 if (!echo_data) 804 return ENOMEM; 805 806 /* Assign a new identifier */ 807 fibril_rwlock_write_lock(&icmp_globals.lock); 808 rc = icmp_bind_free_id(echo_data); 809 fibril_rwlock_write_unlock(&icmp_globals.lock); 810 if (rc < 0) { 811 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 */ 820 refresh_answer(&answer, &answer_count); 821 822 /* Get the next call */ 823 callid = async_get_call(&call); 824 825 /* Process the call */ 826 switch (IPC_GET_IMETHOD(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; 835 break; 836 } 837 838 addr = malloc(length); 839 if (!addr) { 840 rc = ENOMEM; 841 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); 870 } 871 872 } 873 874 /* Release the identifier */ 875 fibril_rwlock_write_lock(&icmp_globals.lock); 876 icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier); 877 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_IMETHOD(*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 794 795 return icmp_parameter_problem(ICMP_GET_CODE(*call), 796 ICMP_GET_POINTER(*call), packet); 797 } 798 918 799 return ENOTSUP; 919 800 } 920 801 921 922 /** Default thread for new connections.923 *924 * @param[in] iid The initial message identifier.925 * @param[in] icall The initial message call structure.926 *927 */928 static void tl_client_connection(ipc_callid_t iid, ipc_call_t *icall)929 {930 /*931 * Accept the connection932 * - Answer the first IPC_M_CONNECT_ME_TO call.933 */934 ipc_answer_0(iid, EOK);935 936 while (true) {937 ipc_call_t answer;938 int answer_count;939 940 /* Clear the answer structure */941 refresh_answer(&answer, &answer_count);942 943 /* Fetch the next message */944 ipc_call_t call;945 ipc_callid_t callid = async_get_call(&call);946 947 /* Process the message */948 int res = tl_module_message_standalone(callid, &call, &answer,949 &answer_count);950 951 /*952 * End if told to either by the message or the processing953 * result.954 */955 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||956 (res == EHANGUP))957 return;958 959 /* Answer the message */960 answer_call(callid, res, &answer, answer_count);961 }962 }963 964 /** Starts the module.965 *966 * @return EOK on success.967 * @return Other error codes as defined for each specific module968 * start function.969 */970 802 int main(int argc, char *argv[]) 971 803 { 972 int rc;973 974 804 /* Start the module */ 975 rc = tl_module_start_standalone(tl_client_connection); 976 return rc; 805 return tl_module_start(SERVICE_ICMP); 977 806 } 978 807 979 808 /** @} 980 809 */ 981
Note:
See TracChangeset
for help on using the changeset viewer.
