Changeset 5d00e40 in mainline
- Timestamp:
- 2011-01-21T12:55:13Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 50c06df, 85d0cf8, aa9f0a4
- Parents:
- d08abdb7 (diff), 7e36c8d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Files:
-
- 1 deleted
- 15 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/adt/avl.c
rd08abdb7 r5d00e40 723 723 void avltree_walk(avltree_t *t, avltree_walker_t walker, void *arg) 724 724 { 725 _avltree_walk(t->root, walker, arg); 725 if (t->root) 726 _avltree_walk(t->root, walker, arg); 726 727 } 727 728 -
uspace/app/ping/ping.c
rd08abdb7 r5d00e40 340 340 config.dest_str, config.size, config.size); 341 341 342 int icmp_phone = icmp_connect_module( SERVICE_ICMP,ICMP_CONNECT_TIMEOUT);342 int icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT); 343 343 if (icmp_phone < 0) { 344 344 fprintf(stderr, "%s: Unable to connect to ICMP service (%s)\n", NAME, -
uspace/lib/c/generic/net/icmp_common.c
rd08abdb7 r5d00e40 27 27 */ 28 28 29 /** @addtogroup libc 29 /** @addtogroup libc 30 30 * @{ 31 31 */ … … 38 38 #include <net/modules.h> 39 39 #include <net/icmp_common.h> 40 41 40 #include <ipc/services.h> 42 41 #include <ipc/icmp.h> 43 44 42 #include <sys/time.h> 45 43 #include <async.h> 46 44 47 /** Connect sto the ICMP module.45 /** Connect to the ICMP module. 48 46 * 49 * @param service The ICMP module service. Ignored parameter. 50 * @param[in] timeout The connection timeout in microseconds. No timeout if 51 * set to zero. 52 * @return The ICMP module phone on success. 53 * @return ETIMEOUT if the connection timeouted. 47 * @param[in] timeout Connection timeout in microseconds, zero 48 * for no timeout. 49 * 50 * @return ICMP module phone on success. 51 * @return ETIMEOUT if the connection timeouted. 52 * 54 53 */ 55 int icmp_connect_module(s ervices_t service, suseconds_t timeout)54 int icmp_connect_module(suseconds_t timeout) 56 55 { 57 int phone; 58 59 phone = connect_to_service_timeout(SERVICE_ICMP, timeout); 60 if (phone >= 0) 61 async_req_0_0(phone, NET_ICMP_INIT); 62 63 return phone; 56 return connect_to_service_timeout(SERVICE_ICMP, timeout); 64 57 } 65 58 -
uspace/lib/c/include/adt/hash_table.h
rd08abdb7 r5d00e40 41 41 typedef unsigned long hash_count_t; 42 42 typedef unsigned long hash_index_t; 43 typedef struct hash_table hash_table_t; 44 typedef struct hash_table_operations hash_table_operations_t; 43 44 /** Set of operations for hash table. */ 45 typedef struct { 46 /** Hash function. 47 * 48 * @param key Array of keys needed to compute hash index. 49 * All keys must be passed. 50 * 51 * @return Index into hash table. 52 * 53 */ 54 hash_index_t (*hash)(unsigned long key[]); 55 56 /** Hash table item comparison function. 57 * 58 * @param key Array of keys that will be compared with item. It is 59 * not necessary to pass all keys. 60 * 61 * @return True if the keys match, false otherwise. 62 * 63 */ 64 int (*compare)(unsigned long key[], hash_count_t keys, link_t *item); 65 66 /** Hash table item removal callback. 67 * 68 * @param item Item that was removed from the hash table. 69 * 70 */ 71 void (*remove_callback)(link_t *item); 72 } hash_table_operations_t; 45 73 46 74 /** Hash table structure. */ 47 struct hash_table{75 typedef struct { 48 76 link_t *entry; 49 77 hash_count_t entries; 50 78 hash_count_t max_keys; 51 79 hash_table_operations_t *op; 52 }; 53 54 /** Set of operations for hash table. */ 55 struct hash_table_operations { 56 /** Hash function. 57 * 58 * @param key Array of keys needed to compute hash index. All keys 59 * must be passed. 60 * 61 * @return Index into hash table. 62 */ 63 hash_index_t (* hash)(unsigned long key[]); 64 65 /** Hash table item comparison function. 66 * 67 * @param key Array of keys that will be compared with item. It is 68 * not necessary to pass all keys. 69 * 70 * @return true if the keys match, false otherwise. 71 */ 72 int (*compare)(unsigned long key[], hash_count_t keys, link_t *item); 73 74 /** Hash table item removal callback. 75 * 76 * @param item Item that was removed from the hash table. 77 */ 78 void (*remove_callback)(link_t *item); 79 }; 80 } hash_table_t; 80 81 81 82 #define hash_table_get_instance(item, type, member) \ -
uspace/lib/c/include/ipc/icmp.h
rd08abdb7 r5d00e40 33 33 /** @file 34 34 * ICMP module messages. 35 * @see icmp_ interface.h35 * @see icmp_remote.h 36 36 */ 37 37 … … 48 48 /** ICMP module messages. */ 49 49 typedef enum { 50 /** Send secho request. @see icmp_echo() */50 /** Send echo request. @see icmp_echo() */ 51 51 NET_ICMP_ECHO = NET_ICMP_FIRST, 52 52 53 53 /** 54 * Send sdestination unreachable error message.54 * Send destination unreachable error message. 55 55 * @see icmp_destination_unreachable_msg() 56 56 */ … … 58 58 59 59 /** 60 * Send ssource quench error message.60 * Send source quench error message. 61 61 * @see icmp_source_quench_msg() 62 62 */ … … 64 64 65 65 /** 66 * Send stime exceeded error message.66 * Send time exceeded error message. 67 67 * @see icmp_time_exceeded_msg() 68 68 */ … … 70 70 71 71 /** 72 * Send sparameter problem error message.72 * Send parameter problem error message. 73 73 * @see icmp_parameter_problem_msg() 74 74 */ 75 NET_ICMP_PARAMETERPROB, 76 77 /** Initializes new connection. */ 78 NET_ICMP_INIT 79 } icmp_messages; 75 NET_ICMP_PARAMETERPROB 76 } icmp_messages_t; 80 77 81 78 /** @name ICMP specific message parameters definitions */ -
uspace/lib/c/include/net/icmp_common.h
rd08abdb7 r5d00e40 41 41 #include <sys/time.h> 42 42 43 /** Default timeout for incoming connections in microseconds . */44 #define ICMP_CONNECT_TIMEOUT (1 * 1000 * 1000)43 /** Default timeout for incoming connections in microseconds (1 sec). */ 44 #define ICMP_CONNECT_TIMEOUT 1000000 45 45 46 extern int icmp_connect_module(s ervices_t, suseconds_t);46 extern int icmp_connect_module(suseconds_t); 47 47 48 48 #endif -
uspace/lib/net/include/icmp_header.h
rd08abdb7 r5d00e40 45 45 46 46 /** ICMP header size in bytes. */ 47 #define ICMP_HEADER_SIZE sizeof(icmp_header_t) 48 49 /** Type definition of the echo specific data. 50 * @see icmp_echo 51 */ 52 typedef struct icmp_echo icmp_echo_t; 47 #define ICMP_HEADER_SIZE sizeof(icmp_header_t) 53 48 54 49 /** Echo specific data. */ 55 struct icmp_echo {50 typedef struct icmp_echo { 56 51 /** Message idintifier. */ 57 52 icmp_param_t identifier; 58 53 /** Message sequence number. */ 59 54 icmp_param_t sequence_number; 60 } __attribute__ ((packed)); 61 62 /** Type definition of the internet control message header. 63 * @see icmp_header 64 */ 65 typedef struct icmp_header icmp_header_t; 55 } __attribute__((packed)) icmp_echo_t; 66 56 67 57 /** Internet control message header. */ 68 struct icmp_header {58 typedef struct icmp_header { 69 59 /** The type of the message. */ 70 60 uint8_t type; … … 83 73 */ 84 74 uint16_t checksum; 85 75 86 76 /** Message specific data. */ 87 77 union { 88 78 /** Echo specific data. */ 89 icmp_echo_t 79 icmp_echo_t echo; 90 80 /** Proposed gateway value. */ 91 81 in_addr_t gateway; … … 107 97 } param; 108 98 } un; 109 } __attribute__ ((packed));99 } __attribute__((packed)) icmp_header_t; 110 100 111 101 #endif -
uspace/lib/net/include/icmp_remote.h
rd08abdb7 r5d00e40 27 27 */ 28 28 29 /** @addtogroup libnet 29 /** @addtogroup libnet 30 30 * @{ 31 31 */ 32 32 33 #ifndef LIBNET_ICMP_ INTERFACE_H_34 #define LIBNET_ICMP_ INTERFACE_H_33 #ifndef LIBNET_ICMP_REMOTE_H_ 34 #define LIBNET_ICMP_REMOTE_H_ 35 35 36 36 #include <net/socket_codes.h> … … 54 54 extern int icmp_source_quench_msg(int, packet_t *); 55 55 extern int icmp_time_exceeded_msg(int, icmp_code_t, packet_t *); 56 extern int icmp_parameter_problem_msg(int, icmp_code_t, icmp_param_t, packet_t *); 56 extern int icmp_parameter_problem_msg(int, icmp_code_t, icmp_param_t, 57 packet_t *); 57 58 58 59 /*@}*/ -
uspace/lib/net/include/tl_skel.h
rd08abdb7 r5d00e40 61 61 extern int tl_initialize(int net_phone); 62 62 63 /** Per-connection module initialization. 64 * 65 * This has to be implemented in user code. 66 * 67 */ 68 extern void tl_connection(void); 69 63 70 /** Process the transport layer module message. 64 71 * … … 74 81 * 75 82 */ 76 extern int tl_m odule_message(ipc_callid_t, ipc_call_t *,83 extern int tl_message(ipc_callid_t, ipc_call_t *, 77 84 ipc_call_t *, size_t *); 78 85 -
uspace/lib/net/tl/icmp_remote.c
rd08abdb7 r5d00e40 33 33 /** @file 34 34 * ICMP interface implementation for remote modules. 35 * @see icmp_ interface.h35 * @see icmp_remote.h 36 36 */ 37 37 38 #include <icmp_ interface.h>38 #include <icmp_remote.h> 39 39 #include <net/modules.h> 40 40 #include <packet_client.h> -
uspace/lib/net/tl/tl_common.c
rd08abdb7 r5d00e40 27 27 */ 28 28 29 /** @addtogroup libnet 29 /** @addtogroup libnet 30 30 * @{ 31 31 */ … … 39 39 #include <packet_client.h> 40 40 #include <packet_remote.h> 41 #include <icmp_ interface.h>41 #include <icmp_remote.h> 42 42 #include <ip_remote.h> 43 43 #include <ip_interface.h> -
uspace/lib/net/tl/tl_skel.c
rd08abdb7 r5d00e40 56 56 ipc_answer_0(iid, EOK); 57 57 58 /* Per-connection initialization */ 59 tl_connection(); 60 58 61 while (true) { 59 62 ipc_call_t answer; … … 68 71 69 72 /* Process the message */ 70 int res = tl_module_message(callid, &call, &answer, 71 &count); 73 int res = tl_message(callid, &call, &answer, &count); 72 74 73 75 /* -
uspace/srv/net/il/ip/ip.c
rd08abdb7 r5d00e40 67 67 #include <net_checksum.h> 68 68 #include <icmp_client.h> 69 #include <icmp_ interface.h>69 #include <icmp_remote.h> 70 70 #include <ip_client.h> 71 71 #include <ip_interface.h> -
uspace/srv/net/tl/icmp/icmp.c
rd08abdb7 r5d00e40 33 33 /** @file 34 34 * ICMP module implementation. 35 * @see icmp.h36 35 */ 37 36 … … 51 50 #include <byteorder.h> 52 51 #include <errno.h> 52 #include <adt/hash_table.h> 53 53 54 54 #include <net/socket_codes.h> … … 64 64 #include <net_checksum.h> 65 65 #include <icmp_client.h> 66 #include <icmp_ interface.h>66 #include <icmp_remote.h> 67 67 #include <il_remote.h> 68 68 #include <ip_client.h> … … 73 73 #include <icmp_header.h> 74 74 75 #include "icmp.h" 76 77 /** ICMP module name. */ 75 /** ICMP module name */ 78 76 #define NAME "icmp" 79 77 80 /** Default ICMP error reporting. */ 81 #define NET_DEFAULT_ICMP_ERROR_REPORTING true 82 83 /** Default ICMP echo replying. */ 84 #define NET_DEFAULT_ICMP_ECHO_REPLYING true 85 86 /** Original datagram length in bytes transfered to the error notification 87 * message. 88 */ 89 #define ICMP_KEEP_LENGTH 8 90 91 /** Free identifier numbers pool start. */ 92 #define ICMP_FREE_IDS_START 1 93 94 /** Free identifier numbers pool end. */ 95 #define ICMP_FREE_IDS_END UINT16_MAX 96 97 /** Computes the ICMP datagram checksum. 98 * 99 * @param[in,out] header The ICMP datagram header. 100 * @param[in] length The total datagram length. 101 * @return The computed checksum. 78 /** Number of replies hash table keys */ 79 #define REPLY_KEYS 2 80 81 /** Number of replies hash table buckets */ 82 #define REPLY_BUCKETS 1024 83 84 /** 85 * Original datagram length in bytes transfered to the error 86 * notification message. 87 */ 88 #define ICMP_KEEP_LENGTH 8 89 90 /** Compute the ICMP datagram checksum. 91 * 92 * @param[in,out] header ICMP datagram header. 93 * @param[in] length Total datagram length. 94 * 95 * @return Computed checksum. 96 * 102 97 */ 103 98 #define ICMP_CHECKSUM(header, length) \ … … 105 100 106 101 /** An echo request datagrams pattern. */ 107 #define ICMP_ECHO_TEXT "Hello from HelenOS." 108 109 /** Computes an ICMP reply data key. 110 * 111 * @param[in] id The message identifier. 112 * @param[in] sequence The message sequence number. 113 * @return The computed ICMP reply data key. 114 */ 115 #define ICMP_GET_REPLY_KEY(id, sequence) \ 116 (((id) << 16) | (sequence & 0xFFFF)) 117 118 119 /** ICMP global data. */ 120 icmp_globals_t icmp_globals; 121 122 INT_MAP_IMPLEMENT(icmp_replies, icmp_reply_t); 123 INT_MAP_IMPLEMENT(icmp_echo_data, icmp_echo_t); 124 125 /** Releases the packet and returns the result. 126 * 127 * @param[in] packet The packet queue to be released. 128 * @param[in] result The result to be returned. 129 * @return The result parameter. 130 */ 131 static int icmp_release_and_return(packet_t *packet, int result) 132 { 133 pq_release_remote(icmp_globals.net_phone, packet_get_id(packet)); 134 return result; 135 } 136 137 /** Sends the ICMP message. 138 * 139 * Sets the message type and code and computes the checksum. 102 #define ICMP_ECHO_TEXT "ICMP hello from HelenOS." 103 104 /** ICMP reply data. */ 105 typedef struct { 106 /** Hash table link */ 107 link_t link; 108 109 /** Reply identification and sequence */ 110 icmp_param_t id; 111 icmp_param_t sequence; 112 113 /** Reply signaling */ 114 fibril_condvar_t condvar; 115 116 /** Reply result */ 117 int result; 118 } icmp_reply_t; 119 120 /** Global data */ 121 static int phone_net = -1; 122 static int phone_ip = -1; 123 static bool error_reporting = true; 124 static bool echo_replying = true; 125 static packet_dimension_t icmp_dimension; 126 127 /** ICMP client identification counter */ 128 static atomic_t icmp_client; 129 130 /** ICMP identifier and sequence number (client-specific) */ 131 static fibril_local icmp_param_t icmp_id; 132 static fibril_local icmp_param_t icmp_seq; 133 134 /** Reply hash table */ 135 static fibril_mutex_t reply_lock; 136 static hash_table_t replies; 137 138 static hash_index_t replies_hash(unsigned long key[]) 139 { 140 /* 141 * ICMP identifier and sequence numbers 142 * are 16-bit values. 143 */ 144 hash_index_t index = ((key[0] & 0xffff) << 16) | (key[1] & 0xffff); 145 return (index % REPLY_BUCKETS); 146 } 147 148 static int replies_compare(unsigned long key[], hash_count_t keys, link_t *item) 149 { 150 icmp_reply_t *reply = 151 hash_table_get_instance(item, icmp_reply_t, link); 152 153 if (keys == 1) 154 return (reply->id == key[0]); 155 else 156 return ((reply->id == key[0]) && (reply->sequence == key[1])); 157 } 158 159 static void replies_remove_callback(link_t *item) 160 { 161 } 162 163 static hash_table_operations_t reply_ops = { 164 .hash = replies_hash, 165 .compare = replies_compare, 166 .remove_callback = replies_remove_callback 167 }; 168 169 /** Release the packet and return the result. 170 * 171 * @param[in] packet Packet queue to be released. 172 * 173 */ 174 static void icmp_release(packet_t *packet) 175 { 176 pq_release_remote(phone_net, packet_get_id(packet)); 177 } 178 179 /** Send the ICMP message. 180 * 181 * Set the message type and code and compute the checksum. 140 182 * Error messages are sent only if allowed in the configuration. 141 * Releases the packet on errors. 142 * 143 * @param[in] type The message type. 144 * @param[in] code The message code. 145 * @param[in] packet The message packet to be sent. 146 * @param[in] header The ICMP header. 147 * @param[in] error The error service to be announced. Should be 148 * SERVICE_ICMP or zero. 149 * @param[in] ttl The time to live. 150 * @param[in] tos The type of service. 151 * @param[in] dont_fragment The value indicating whether the datagram must not 152 * be fragmented. Is used as a MTU discovery. 153 * @return EOK on success. 154 * @return EPERM if the error message is not allowed. 155 */ 156 static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t *packet, 157 icmp_header_t *header, services_t error, ip_ttl_t ttl, ip_tos_t tos, 158 int dont_fragment) 159 { 160 int rc; 161 183 * Release the packet on errors. 184 * 185 * @param[in] type Message type. 186 * @param[in] code Message code. 187 * @param[in] packet Message packet to be sent. 188 * @param[in] header ICMP header. 189 * @param[in] error Error service to be announced. Should be 190 * SERVICE_ICMP or zero. 191 * @param[in] ttl Time to live. 192 * @param[in] tos Type of service. 193 * @param[in] dont_fragment Disable fragmentation. 194 * 195 * @return EOK on success. 196 * @return EPERM if the error message is not allowed. 197 * 198 */ 199 static int icmp_send_packet(icmp_type_t type, icmp_code_t code, 200 packet_t *packet, icmp_header_t *header, services_t error, ip_ttl_t ttl, 201 ip_tos_t tos, bool dont_fragment) 202 { 162 203 /* Do not send an error if disabled */ 163 if (error && !icmp_globals.error_reporting) 164 return icmp_release_and_return(packet, EPERM); 165 204 if ((error) && (!error_reporting)) { 205 icmp_release(packet); 206 return EPERM; 207 } 208 166 209 header->type = type; 167 210 header->code = code; 211 212 /* 213 * The checksum needs to be calculated 214 * with a virtual checksum field set to 215 * zero. 216 */ 168 217 header->checksum = 0; 169 218 header->checksum = ICMP_CHECKSUM(header, 170 219 packet_get_data_length(packet)); 171 220 172 rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,221 int rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos, 173 222 dont_fragment, 0); 174 if (rc != EOK) 175 return icmp_release_and_return(packet, rc); 176 177 return ip_send_msg(icmp_globals.ip_phone, -1, packet, SERVICE_ICMP, 178 error); 179 } 180 181 /** Prepares the ICMP error packet. 182 * 183 * Truncates the original packet if longer than ICMP_KEEP_LENGTH bytes. 184 * Prefixes and returns the ICMP header. 185 * 186 * @param[in,out] packet The original packet. 223 if (rc != EOK) { 224 icmp_release(packet); 225 return rc; 226 } 227 228 return ip_send_msg(phone_ip, -1, packet, SERVICE_ICMP, error); 229 } 230 231 /** Prepare the ICMP error packet. 232 * 233 * Truncate the original packet if longer than ICMP_KEEP_LENGTH bytes. 234 * Prefix and return the ICMP header. 235 * 236 * @param[in,out] packet Original packet. 237 * 187 238 * @return The prefixed ICMP header. 188 239 * @return NULL on errors. 240 * 189 241 */ 190 242 static icmp_header_t *icmp_prepare_packet(packet_t *packet) 191 243 { 192 icmp_header_t *header; 193 size_t header_length; 194 size_t total_length; 195 196 total_length = packet_get_data_length(packet); 244 size_t total_length = packet_get_data_length(packet); 197 245 if (total_length <= 0) 198 246 return NULL; 199 200 header_length = ip_client_header_length(packet);247 248 size_t header_length = ip_client_header_length(packet); 201 249 if (header_length <= 0) 202 250 return NULL; 203 251 204 252 /* Truncate if longer than 64 bits (without the IP header) */ 205 253 if ((total_length > header_length + ICMP_KEEP_LENGTH) && 206 254 (packet_trim(packet, 0, 207 total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) {255 total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) 208 256 return NULL; 209 } 210 211 header = PACKET_PREFIX(packet, icmp_header_t); 257 258 icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t); 212 259 if (!header) 213 260 return NULL; 214 261 215 262 bzero(header, sizeof(*header)); 216 263 return header; 217 264 } 218 265 219 /** Request san echo message.220 * 221 * Send s a packet with specified parameters to the target host and waits for222 * the reply upto the given timeout.223 * Block sthe caller until the reply or the timeout occurs.224 * 225 * @param[in] id The message identifier.226 * @param[in] sequence The message sequence parameter.227 * @param[in] size The message data length in bytes.228 * @param[in] timeout The timeout in miliseconds.229 * @param[in] ttl The time to live.230 * @param[in] tos The type of service.231 * @param[in] dont_fragment The value indicating whether the datagram must not232 * be fragmented. Is used as a MTU discovery.233 * @param[in] addr The target host address.234 * @param[in] addrlen The torget host address length.235 * @return 236 * @return 237 * 238 * @return 239 * @return 240 * 241 * @return 242 * @return EPARTY if there was an internal error.266 /** Request an echo message. 267 * 268 * Send a packet with specified parameters to the target host 269 * and wait for the reply upto the given timeout. 270 * Block the caller until the reply or the timeout occurs. 271 * 272 * @param[in] id Message identifier. 273 * @param[in] sequence Message sequence parameter. 274 * @param[in] size Message data length in bytes. 275 * @param[in] timeout Timeout in miliseconds. 276 * @param[in] ttl Time to live. 277 * @param[in] tos Type of service. 278 * @param[in] dont_fragment Disable fragmentation. 279 * @param[in] addr Target host address. 280 * @param[in] addrlen Torget host address length. 281 * 282 * @return ICMP_ECHO on success. 283 * @return ETIMEOUT if the reply has not arrived before the 284 * timeout. 285 * @return ICMP type of the received error notification. 286 * @return EINVAL if the addrlen parameter is less or equal to 287 * zero. 288 * @return ENOMEM if there is not enough memory left. 289 * 243 290 */ 244 291 static int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size, 245 mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, 246 const struct sockaddr * addr, socklen_t addrlen) 247 { 248 icmp_header_t *header; 249 packet_t *packet; 250 size_t length; 251 uint8_t *data; 252 icmp_reply_t *reply; 253 int reply_key; 254 int index; 255 int rc; 256 292 mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, bool dont_fragment, 293 const struct sockaddr *addr, socklen_t addrlen) 294 { 257 295 if (addrlen <= 0) 258 296 return EINVAL; 259 260 length = (size_t) addrlen; 261 /* TODO do not ask all the time */ 262 rc = ip_packet_size_req(icmp_globals.ip_phone, -1, 263 &icmp_globals.packet_dimension); 264 if (rc != EOK) 265 return rc; 266 267 packet = packet_get_4_remote(icmp_globals.net_phone, size, 268 icmp_globals.packet_dimension.addr_len, 269 ICMP_HEADER_SIZE + icmp_globals.packet_dimension.prefix, 270 icmp_globals.packet_dimension.suffix); 297 298 size_t length = (size_t) addrlen; 299 300 packet_t *packet = packet_get_4_remote(phone_net, size, 301 icmp_dimension.addr_len, ICMP_HEADER_SIZE + icmp_dimension.prefix, 302 icmp_dimension.suffix); 271 303 if (!packet) 272 304 return ENOMEM; 273 305 274 306 /* Prepare the requesting packet, set the destination address. */ 275 rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length); 276 if (rc != EOK) 277 return icmp_release_and_return(packet, rc); 278 307 int rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length); 308 if (rc != EOK) { 309 icmp_release(packet); 310 return rc; 311 } 312 279 313 /* Allocate space in the packet */ 280 data = (uint8_t *) packet_suffix(packet, size); 281 if (!data) 282 return icmp_release_and_return(packet, ENOMEM); 283 314 uint8_t *data = (uint8_t *) packet_suffix(packet, size); 315 if (!data) { 316 icmp_release(packet); 317 return ENOMEM; 318 } 319 284 320 /* Fill the data */ 285 321 length = 0; … … 289 325 } 290 326 memcpy(data + length, ICMP_ECHO_TEXT, size - length); 291 327 292 328 /* Prefix the header */ 293 header = PACKET_PREFIX(packet, icmp_header_t); 294 if (!header) 295 return icmp_release_and_return(packet, ENOMEM); 296 297 bzero(header, sizeof(*header)); 329 icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t); 330 if (!header) { 331 icmp_release(packet); 332 return ENOMEM; 333 } 334 335 bzero(header, sizeof(icmp_header_t)); 298 336 header->un.echo.identifier = id; 299 337 header->un.echo.sequence_number = sequence; 300 338 301 339 /* Prepare the reply structure */ 302 reply = malloc(sizeof(*reply)); 303 if (!reply) 304 return icmp_release_and_return(packet, ENOMEM); 305 306 fibril_mutex_initialize(&reply->mutex); 307 fibril_mutex_lock(&reply->mutex); 340 icmp_reply_t *reply = malloc(sizeof(icmp_reply_t)); 341 if (!reply) { 342 icmp_release(packet); 343 return ENOMEM; 344 } 345 346 reply->id = id; 347 reply->sequence = sequence; 308 348 fibril_condvar_initialize(&reply->condvar); 309 reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier, 310 header->un.echo.sequence_number); 311 index = icmp_replies_add(&icmp_globals.replies, reply_key, reply); 312 if (index < 0) { 313 free(reply); 314 return icmp_release_and_return(packet, index); 315 } 316 317 /* Unlock the globals so that we can wait for the reply */ 318 fibril_rwlock_write_unlock(&icmp_globals.lock); 319 349 350 /* Add the reply to the replies hash table */ 351 fibril_mutex_lock(&reply_lock); 352 353 unsigned long key[REPLY_KEYS] = {id, sequence}; 354 hash_table_insert(&replies, key, &reply->link); 355 320 356 /* Send the request */ 321 357 icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos, 322 358 dont_fragment); 323 359 324 360 /* Wait for the reply. Timeout in microseconds. */ 325 rc = fibril_condvar_wait_timeout(&reply->condvar, &reply ->mutex,361 rc = fibril_condvar_wait_timeout(&reply->condvar, &reply_lock, 326 362 timeout * 1000); 327 363 if (rc == EOK) 328 364 rc = reply->result; 329 330 /* Drop the reply mutex before locking the globals again*/331 fibril_mutex_unlock(&reply->mutex);332 fibril_rwlock_write_lock(&icmp_globals.lock);333 334 /* Destroy the reply structure */335 icmp_replies_exclude_index(&icmp_globals.replies, index);336 365 366 /* Remove the reply from the replies hash table */ 367 hash_table_remove(&replies, key, REPLY_KEYS); 368 369 fibril_mutex_unlock(&reply_lock); 370 371 free(reply); 372 337 373 return rc; 338 374 } 339 375 340 static int icmp_destination_unreachable _msg_local(int icmp_phone,341 icmp_code_t code, icmp_param_t mtu,packet_t *packet)342 { 343 icmp_header_t *header ;344 345 header = icmp_prepare_packet(packet);346 if (!header)347 return icmp_release_and_return(packet, ENOMEM);348 376 static int icmp_destination_unreachable(icmp_code_t code, icmp_param_t mtu, 377 packet_t *packet) 378 { 379 icmp_header_t *header = icmp_prepare_packet(packet); 380 if (!header) { 381 icmp_release(packet); 382 return ENOMEM; 383 } 384 349 385 if (mtu) 350 386 header->un.frag.mtu = mtu; 351 387 352 388 return icmp_send_packet(ICMP_DEST_UNREACH, code, packet, header, 353 SERVICE_ICMP, 0, 0, 0);354 } 355 356 static int icmp_source_quench _msg_local(int icmp_phone,packet_t *packet)357 { 358 icmp_header_t *header ;359 360 header = icmp_prepare_packet(packet);361 if (!header)362 return icmp_release_and_return(packet, ENOMEM);363 389 SERVICE_ICMP, 0, 0, false); 390 } 391 392 static int icmp_source_quench(packet_t *packet) 393 { 394 icmp_header_t *header = icmp_prepare_packet(packet); 395 if (!header) { 396 icmp_release(packet); 397 return ENOMEM; 398 } 399 364 400 return icmp_send_packet(ICMP_SOURCE_QUENCH, 0, packet, header, 365 SERVICE_ICMP, 0, 0, 0); 366 } 367 368 static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code, 401 SERVICE_ICMP, 0, 0, false); 402 } 403 404 static int icmp_time_exceeded(icmp_code_t code, packet_t *packet) 405 { 406 icmp_header_t *header = icmp_prepare_packet(packet); 407 if (!header) { 408 icmp_release(packet); 409 return ENOMEM; 410 } 411 412 return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header, 413 SERVICE_ICMP, 0, 0, false); 414 } 415 416 static int icmp_parameter_problem(icmp_code_t code, icmp_param_t pointer, 369 417 packet_t *packet) 370 418 { 371 icmp_header_t *header; 372 373 header = icmp_prepare_packet(packet); 374 if (!header) 375 return icmp_release_and_return(packet, ENOMEM); 376 377 return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header, 378 SERVICE_ICMP, 0, 0, 0); 379 } 380 381 static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code, 382 icmp_param_t pointer, packet_t *packet) 383 { 384 icmp_header_t *header; 385 386 header = icmp_prepare_packet(packet); 387 if (!header) 388 return icmp_release_and_return(packet, ENOMEM); 389 419 icmp_header_t *header = icmp_prepare_packet(packet); 420 if (!header) { 421 icmp_release(packet); 422 return ENOMEM; 423 } 424 390 425 header->un.param.pointer = pointer; 391 426 return icmp_send_packet(ICMP_PARAMETERPROB, code, packet, header, 392 SERVICE_ICMP, 0, 0, 0);393 } 394 395 /** Tr iesto set the pending reply result as the received message type.427 SERVICE_ICMP, 0, 0, false); 428 } 429 430 /** Try to set the pending reply result as the received message type. 396 431 * 397 432 * If the reply data is not present, the reply timed out and the other fibril 398 * is already awake. 399 * Releases the packet.400 * 401 * @param[in] packet The received reply message.402 * @param[in] header The ICMP message header.403 * @param[in] type The received reply message type.404 * @param[in] code The received reply message code.405 */ 406 static void 433 * is already awake. The packet is released. 434 * 435 * @param[in] packet The received reply message. 436 * @param[in] header The ICMP message header. 437 * @param[in] type The received reply message type. 438 * @param[in] code The received reply message code. 439 * 440 */ 441 static void icmp_process_echo_reply(packet_t *packet, icmp_header_t *header, 407 442 icmp_type_t type, icmp_code_t code) 408 443 { 409 int reply_key; 410 icmp_reply_t *reply; 411 412 /* Compute the reply key */ 413 reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier, 414 header->un.echo.sequence_number); 415 pq_release_remote(icmp_globals.net_phone, packet_get_id(packet)); 416 444 unsigned long key[REPLY_KEYS] = 445 {header->un.echo.identifier, header->un.echo.sequence_number}; 446 447 /* The packet is no longer needed */ 448 icmp_release(packet); 449 417 450 /* Find the pending reply */ 418 fibril_rwlock_write_lock(&icmp_globals.lock); 419 reply = icmp_replies_find(&icmp_globals.replies, reply_key); 420 if (reply) { 451 fibril_mutex_lock(&reply_lock); 452 453 link_t *link = hash_table_find(&replies, key); 454 if (link != NULL) { 455 icmp_reply_t *reply = 456 hash_table_get_instance(link, icmp_reply_t, link); 457 421 458 reply->result = type; 422 459 fibril_condvar_signal(&reply->condvar); 423 460 } 424 fibril_rwlock_write_unlock(&icmp_globals.lock); 425 } 426 427 /** Processes the received ICMP packet. 428 * 429 * Notifies the destination socket application. 430 * 431 * @param[in,out] packet The received packet. 432 * @param[in] error The packet error reporting service. Prefixes the 433 * received packet. 434 * @return EOK on success. 435 * @return EINVAL if the packet is not valid. 436 * @return EINVAL if the stored packet address is not the an_addr_t. 437 * @return EINVAL if the packet does not contain any data. 438 * @return NO_DATA if the packet content is shorter than the user 439 * datagram header. 440 * @return ENOMEM if there is not enough memory left. 441 * @return EADDRNOTAVAIL if the destination socket does not exist. 442 * @return Other error codes as defined for the 443 * ip_client_process_packet() function. 461 462 fibril_mutex_unlock(&reply_lock); 463 } 464 465 /** Process the received ICMP packet. 466 * 467 * Notify the destination socket application. 468 * 469 * @param[in,out] packet Received packet. 470 * @param[in] error Packet error reporting service to prefix 471 * the received packet. 472 * 473 * @return EOK on success. 474 * @return EINVAL if the packet is not valid. 475 * @return EINVAL if the stored packet address is not the an_addr_t. 476 * @return EINVAL if the packet does not contain any data. 477 * @return NO_DATA if the packet content is shorter than the user 478 * datagram header. 479 * @return ENOMEM if there is not enough memory left. 480 * @return EADDRNOTAVAIL if the destination socket does not exist. 481 * @return Other error codes as defined for the 482 * ip_client_process_packet() function. 483 * 444 484 */ 445 485 static int icmp_process_packet(packet_t *packet, services_t error) 446 486 { 447 size_t length;448 uint8_t *src;449 int addrlen;450 int result;451 void *data;452 icmp_header_t *header;453 487 icmp_type_t type; 454 488 icmp_code_t code; … … 460 494 case SERVICE_ICMP: 461 495 /* Process error */ 462 result = icmp_client_process_packet(packet, &type, &code, NULL, 463 NULL); 464 if (result < 0) 465 return result; 466 length = (size_t) result; 496 rc = icmp_client_process_packet(packet, &type, &code, NULL, NULL); 497 if (rc < 0) 498 return rc; 499 467 500 /* Remove the error header */ 468 rc = packet_trim(packet, length, 0);501 rc = packet_trim(packet, (size_t) rc, 0); 469 502 if (rc != EOK) 470 503 return rc; 504 471 505 break; 472 506 default: 473 507 return ENOTSUP; 474 508 } 475 509 476 510 /* Get rid of the IP header */ 477 length = ip_client_header_length(packet);511 size_t length = ip_client_header_length(packet); 478 512 rc = packet_trim(packet, length, 0); 479 513 if (rc != EOK) 480 514 return rc; 481 515 482 516 length = packet_get_data_length(packet); 483 517 if (length <= 0) 484 518 return EINVAL; 485 519 486 520 if (length < ICMP_HEADER_SIZE) 487 521 return EINVAL; 488 489 data = packet_get_data(packet);522 523 void *data = packet_get_data(packet); 490 524 if (!data) 491 525 return EINVAL; 492 526 493 527 /* Get ICMP header */ 494 header = (icmp_header_t *) data;495 528 icmp_header_t *header = (icmp_header_t *) data; 529 496 530 if (header->checksum) { 497 531 while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) { … … 507 541 } 508 542 } 543 509 544 return EINVAL; 510 545 } 511 546 } 512 547 513 548 switch (header->type) { 514 549 case ICMP_ECHOREPLY: … … 517 552 else 518 553 icmp_process_echo_reply(packet, header, ICMP_ECHO, 0); 519 554 520 555 return EOK; 521 556 522 557 case ICMP_ECHO: 523 558 if (error) { … … 527 562 528 563 /* Do not send a reply if disabled */ 529 if (icmp_globals.echo_replying) { 530 addrlen = packet_get_addr(packet, &src, NULL); 531 564 if (echo_replying) { 565 uint8_t *src; 566 int addrlen = packet_get_addr(packet, &src, NULL); 567 532 568 /* 533 * Set both addresses to the source one (avoid sthe569 * Set both addresses to the source one (avoid the 534 570 * source address deletion before setting the 535 571 * destination one). … … 542 578 return EOK; 543 579 } 544 580 545 581 return EINVAL; 546 582 } 547 583 548 584 return EPERM; 549 585 550 586 case ICMP_DEST_UNREACH: 551 587 case ICMP_SOURCE_QUENCH: … … 560 596 case ICMP_SKIP: 561 597 case ICMP_PHOTURIS: 562 ip_received_error_msg( icmp_globals.ip_phone, -1, packet,598 ip_received_error_msg(phone_ip, -1, packet, 563 599 SERVICE_IP, SERVICE_ICMP); 564 600 return EOK; 565 601 566 602 default: 567 603 return ENOTSUP; … … 569 605 } 570 606 571 /** Processes the received ICMP packet.572 *573 * Is used as an entry point from the underlying IP module.574 * Releases the packet on error.575 *576 * @param device_id The device identifier. Ignored parameter.577 * @param[in,out] packet The received packet.578 * @param receiver The target service. Ignored parameter.579 * @param[in] error The packet error reporting service. Prefixes the580 * received packet.581 * @return EOK on success.582 * @return Other error codes as defined for the583 * icmp_process_packet() function.584 */585 static int icmp_received_msg_local(device_id_t device_id, packet_t *packet,586 services_t receiver, services_t error)587 {588 int rc;589 590 rc = icmp_process_packet(packet, error);591 if (rc != EOK)592 return icmp_release_and_return(packet, rc);593 594 return EOK;595 }596 597 607 /** Process IPC messages from the IP module 598 608 * … … 603 613 static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall) 604 614 { 615 bool loop = true; 605 616 packet_t *packet; 606 617 int rc; 607 618 608 while ( true) {619 while (loop) { 609 620 switch (IPC_GET_IMETHOD(*icall)) { 610 621 case NET_TL_RECEIVED: 611 rc = packet_translate_remote( icmp_globals.net_phone, &packet,622 rc = packet_translate_remote(phone_net, &packet, 612 623 IPC_GET_PACKET(*icall)); 613 if (rc == EOK) 614 rc = icmp_received_msg_local(IPC_GET_DEVICE(*icall), packet, 615 SERVICE_ICMP, IPC_GET_ERROR(*icall)); 624 if (rc == EOK) { 625 rc = icmp_process_packet(packet, IPC_GET_ERROR(*icall)); 626 if (rc != EOK) 627 icmp_release(packet); 628 } 616 629 617 630 ipc_answer_0(iid, (sysarg_t) rc); 618 631 break; 632 case IPC_M_PHONE_HUNGUP: 633 loop = false; 634 continue; 619 635 default: 620 636 ipc_answer_0(iid, (sysarg_t) ENOTSUP); … … 649 665 uint8_t *data; 650 666 651 fibril_rwlock_initialize(&icmp_globals.lock); 652 fibril_rwlock_write_lock(&icmp_globals.lock); 653 icmp_replies_initialize(&icmp_globals.replies); 654 icmp_echo_data_initialize(&icmp_globals.echo_data); 655 656 icmp_globals.net_phone = net_phone; 657 658 icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, 659 SERVICE_ICMP, icmp_receiver); 660 if (icmp_globals.ip_phone < 0) { 661 fibril_rwlock_write_unlock(&icmp_globals.lock); 662 return icmp_globals.ip_phone; 663 } 664 665 int rc = ip_packet_size_req(icmp_globals.ip_phone, -1, 666 &icmp_globals.packet_dimension); 667 if (rc != EOK) { 668 fibril_rwlock_write_unlock(&icmp_globals.lock); 667 if (!hash_table_create(&replies, REPLY_BUCKETS, REPLY_KEYS, &reply_ops)) 668 return ENOMEM; 669 670 fibril_mutex_initialize(&reply_lock); 671 atomic_set(&icmp_client, 0); 672 673 phone_net = net_phone; 674 phone_ip = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP, 675 icmp_receiver); 676 if (phone_ip < 0) 677 return phone_ip; 678 679 int rc = ip_packet_size_req(phone_ip, -1, &icmp_dimension); 680 if (rc != EOK) 669 681 return rc; 670 } 671 672 icmp_globals.packet_dimension.prefix += ICMP_HEADER_SIZE; 673 icmp_globals.packet_dimension.content -= ICMP_HEADER_SIZE; 674 675 icmp_globals.error_reporting = NET_DEFAULT_ICMP_ERROR_REPORTING; 676 icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING; 682 683 icmp_dimension.prefix += ICMP_HEADER_SIZE; 684 icmp_dimension.content -= ICMP_HEADER_SIZE; 677 685 678 686 /* Get configuration */ 679 687 configuration = &names[0]; 680 rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count, 681 &data); 682 if (rc != EOK) { 683 fibril_rwlock_write_unlock(&icmp_globals.lock); 688 rc = net_get_conf_req(phone_net, &configuration, count, &data); 689 if (rc != EOK) 684 690 return rc; 685 }686 691 687 692 if (configuration) { 688 if (configuration[0].value) { 689 icmp_globals.error_reporting = 690 (configuration[0].value[0] == 'y'); 691 } 692 if (configuration[1].value) { 693 icmp_globals.echo_replying = 694 (configuration[1].value[0] == 'y'); 695 } 693 if (configuration[0].value) 694 error_reporting = (configuration[0].value[0] == 'y'); 695 696 if (configuration[1].value) 697 echo_replying = (configuration[1].value[0] == 'y'); 698 696 699 net_free_settings(configuration, data); 697 700 } 698 701 699 fibril_rwlock_write_unlock(&icmp_globals.lock);700 702 return EOK; 701 703 } 702 704 703 /** Processes the generic client messages. 704 * 705 * @param[in] call The message parameters. 706 * @return EOK on success. 707 * @return ENOTSUP if the message is not known. 708 * @return Other error codes as defined for the packet_translate() 709 * function. 710 * @return Other error codes as defined for the 711 * icmp_destination_unreachable_msg_local() function. 712 * @return Other error codes as defined for the 713 * icmp_source_quench_msg_local() function. 714 * @return Other error codes as defined for the 715 * icmp_time_exceeded_msg_local() function. 716 * @return Other error codes as defined for the 717 * icmp_parameter_problem_msg_local() function. 718 * 719 * @see icmp_interface.h 720 */ 721 static int icmp_process_message(ipc_call_t *call) 722 { 705 /** Per-connection initialization 706 * 707 * Initialize client-specific global variables. 708 * 709 */ 710 void tl_connection(void) 711 { 712 icmp_id = (icmp_param_t) atomic_postinc(&icmp_client); 713 icmp_seq = 1; 714 } 715 716 /** Process the ICMP message. 717 * 718 * @param[in] callid Message identifier. 719 * @param[in] call Message parameters. 720 * @param[out] answer Answer. 721 * @param[out] count Number of arguments of the answer. 722 * 723 * @return EOK on success. 724 * @return ENOTSUP if the message is not known. 725 * @return Other error codes as defined for the packet_translate() 726 * function. 727 * @return Other error codes as defined for the 728 * icmp_destination_unreachable() function. 729 * @return Other error codes as defined for the 730 * icmp_source_quench() function. 731 * @return Other error codes as defined for the 732 * icmp_time_exceeded() function. 733 * @return Other error codes as defined for the 734 * icmp_parameter_problem() function. 735 * 736 * @see icmp_remote.h 737 * @see IS_NET_ICMP_MESSAGE() 738 * 739 */ 740 int tl_message(ipc_callid_t callid, ipc_call_t *call, 741 ipc_call_t *answer, size_t *count) 742 { 743 struct sockaddr *addr; 744 size_t size; 723 745 packet_t *packet; 724 746 int rc; 725 747 748 *count = 0; 749 726 750 switch (IPC_GET_IMETHOD(*call)) { 751 case NET_ICMP_ECHO: 752 rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &size); 753 if (rc != EOK) 754 return rc; 755 756 rc = icmp_echo(icmp_id, icmp_seq, ICMP_GET_SIZE(*call), 757 ICMP_GET_TIMEOUT(*call), ICMP_GET_TTL(*call), 758 ICMP_GET_TOS(*call), ICMP_GET_DONT_FRAGMENT(*call), 759 addr, (socklen_t) size); 760 761 free(addr); 762 icmp_seq++; 763 return rc; 764 727 765 case NET_ICMP_DEST_UNREACH: 728 rc = packet_translate_remote( icmp_globals.net_phone, &packet,766 rc = packet_translate_remote(phone_net, &packet, 729 767 IPC_GET_PACKET(*call)); 730 768 if (rc != EOK) 731 769 return rc; 732 return icmp_destination_unreachable_msg_local(0, 733 ICMP_GET_CODE(*call), ICMP_GET_MTU(*call), packet); 770 771 return icmp_destination_unreachable(ICMP_GET_CODE(*call), 772 ICMP_GET_MTU(*call), packet); 773 734 774 case NET_ICMP_SOURCE_QUENCH: 735 rc = packet_translate_remote( icmp_globals.net_phone, &packet,775 rc = packet_translate_remote(phone_net, &packet, 736 776 IPC_GET_PACKET(*call)); 737 777 if (rc != EOK) 738 778 return rc; 739 return icmp_source_quench_msg_local(0, packet); 779 780 return icmp_source_quench(packet); 781 740 782 case NET_ICMP_TIME_EXCEEDED: 741 rc = packet_translate_remote( icmp_globals.net_phone, &packet,783 rc = packet_translate_remote(phone_net, &packet, 742 784 IPC_GET_PACKET(*call)); 743 785 if (rc != EOK) 744 786 return rc; 745 return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(*call), 746 packet); 787 788 return icmp_time_exceeded(ICMP_GET_CODE(*call), packet); 789 747 790 case NET_ICMP_PARAMETERPROB: 748 rc = packet_translate_remote( icmp_globals.net_phone, &packet,791 rc = packet_translate_remote(phone_net, &packet, 749 792 IPC_GET_PACKET(*call)); 750 793 if (rc != EOK) 751 794 return rc; 752 return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(*call), 795 796 return icmp_parameter_problem(ICMP_GET_CODE(*call), 753 797 ICMP_GET_POINTER(*call), packet); 754 default:755 return ENOTSUP;756 }757 }758 759 /** Assigns a new identifier for the connection.760 *761 * Fills the echo data parameter with the assigned values.762 *763 * @param[in,out] echo_data The echo data to be bound.764 * @return Index of the inserted echo data.765 * @return EBADMEM if the echo_data parameter is NULL.766 * @return ENOTCONN if no free identifier have been found.767 */768 static int icmp_bind_free_id(icmp_echo_t *echo_data)769 {770 icmp_param_t index;771 772 if (!echo_data)773 return EBADMEM;774 775 /* From the last used one */776 index = icmp_globals.last_used_id;777 do {778 index++;779 /* til the range end */780 if (index >= ICMP_FREE_IDS_END) {781 /* start from the range beginning */782 index = ICMP_FREE_IDS_START - 1;783 do {784 index++;785 /* til the last used one */786 if (index >= icmp_globals.last_used_id) {787 /* none found */788 return ENOTCONN;789 }790 } while(icmp_echo_data_find(&icmp_globals.echo_data,791 index) != NULL);792 793 /* Found, break immediately */794 break;795 }796 } while (icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);797 798 echo_data->identifier = index;799 echo_data->sequence_number = 0;800 801 return icmp_echo_data_add(&icmp_globals.echo_data, index, echo_data);802 }803 804 /** Processes the client messages.805 *806 * Remembers the assigned identifier and sequence numbers.807 * Runs until the client module disconnects.808 *809 * @param[in] callid The message identifier.810 * @param[in] call The message parameters.811 * @return EOK.812 *813 * @see icmp_interface.h814 * @see icmp_api.h815 */816 static int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call)817 {818 bool keep_on_going = true;819 ipc_call_t answer;820 size_t answer_count;821 size_t length;822 struct sockaddr *addr;823 ipc_callid_t data_callid;824 icmp_echo_t *echo_data;825 int rc = EOK;826 827 /*828 * Accept the connection829 * - Answer the first NET_ICMP_INIT call.830 */831 answer_count = 0;832 833 echo_data = (icmp_echo_t *) malloc(sizeof(*echo_data));834 if (!echo_data)835 return ENOMEM;836 837 /* Assign a new identifier */838 fibril_rwlock_write_lock(&icmp_globals.lock);839 rc = icmp_bind_free_id(echo_data);840 fibril_rwlock_write_unlock(&icmp_globals.lock);841 if (rc < 0) {842 free(echo_data);843 return rc;844 }845 846 while (keep_on_going) {847 /* Answer the call */848 answer_call(callid, rc, &answer, answer_count);849 850 /* Refresh data */851 refresh_answer(&answer, &answer_count);852 853 /* Get the next call */854 callid = async_get_call(&call);855 856 /* Process the call */857 switch (IPC_GET_IMETHOD(call)) {858 case IPC_M_PHONE_HUNGUP:859 keep_on_going = false;860 rc = EHANGUP;861 break;862 863 case NET_ICMP_ECHO:864 if (!async_data_write_receive(&data_callid, &length)) {865 rc = EINVAL;866 break;867 }868 869 addr = malloc(length);870 if (!addr) {871 rc = ENOMEM;872 break;873 }874 875 rc = async_data_write_finalize(data_callid, addr,876 length);877 if (rc != EOK) {878 free(addr);879 break;880 }881 882 fibril_rwlock_write_lock(&icmp_globals.lock);883 rc = icmp_echo(echo_data->identifier,884 echo_data->sequence_number, ICMP_GET_SIZE(call),885 ICMP_GET_TIMEOUT(call), ICMP_GET_TTL(call),886 ICMP_GET_TOS(call), ICMP_GET_DONT_FRAGMENT(call),887 addr, (socklen_t) length);888 fibril_rwlock_write_unlock(&icmp_globals.lock);889 890 free(addr);891 892 if (echo_data->sequence_number < UINT16_MAX)893 echo_data->sequence_number++;894 else895 echo_data->sequence_number = 0;896 897 break;898 899 default:900 rc = icmp_process_message(&call);901 }902 903 }904 905 /* Release the identifier */906 fibril_rwlock_write_lock(&icmp_globals.lock);907 icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier);908 fibril_rwlock_write_unlock(&icmp_globals.lock);909 910 return rc;911 }912 913 /** Processes the ICMP message.914 *915 * @param[in] callid The message identifier.916 * @param[in] call The message parameters.917 * @param[out] answer The message answer parameters.918 * @param[out] answer_count The last parameter for the actual answer in the919 * answer parameter.920 * @return EOK on success.921 * @return ENOTSUP if the message is not known.922 *923 * @see icmp_interface.h924 * @see IS_NET_ICMP_MESSAGE()925 */926 int tl_module_message (ipc_callid_t callid, ipc_call_t *call,927 ipc_call_t *answer, size_t *answer_count)928 {929 *answer_count = 0;930 switch (IPC_GET_IMETHOD(*call)) {931 case NET_ICMP_INIT:932 return icmp_process_client_messages(callid, *call);933 default:934 return icmp_process_message(call);935 798 } 936 799 -
uspace/srv/net/tl/tcp/tcp.c
rd08abdb7 r5d00e40 64 64 #include <ip_interface.h> 65 65 #include <icmp_client.h> 66 #include <icmp_ interface.h>66 #include <icmp_remote.h> 67 67 #include <net_interface.h> 68 68 #include <socket_core.h> … … 1204 1204 } 1205 1205 1206 /** Per-connection initialization 1207 * 1208 */ 1209 void tl_connection(void) 1210 { 1211 } 1212 1206 1213 /** Processes the TCP message. 1207 1214 * … … 1217 1224 * @see IS_NET_TCP_MESSAGE() 1218 1225 */ 1219 int tl_m odule_message(ipc_callid_t callid, ipc_call_t *call,1226 int tl_message(ipc_callid_t callid, ipc_call_t *call, 1220 1227 ipc_call_t *answer, size_t *answer_count) 1221 1228 { … … 2472 2479 tcp_globals.net_phone = net_phone; 2473 2480 2474 tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP, 2475 ICMP_CONNECT_TIMEOUT); 2481 tcp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT); 2476 2482 tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP, 2477 2483 SERVICE_TCP, tcp_receiver); -
uspace/srv/net/tl/udp/udp.c
rd08abdb7 r5d00e40 61 61 #include <ip_interface.h> 62 62 #include <icmp_client.h> 63 #include <icmp_ interface.h>63 #include <icmp_remote.h> 64 64 #include <net_interface.h> 65 65 #include <socket_core.h> … … 393 393 udp_globals.net_phone = net_phone; 394 394 395 udp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP, 396 ICMP_CONNECT_TIMEOUT); 395 udp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT); 397 396 398 397 udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP, … … 878 877 } 879 878 879 /** Per-connection initialization 880 * 881 */ 882 void tl_connection(void) 883 { 884 } 885 880 886 /** Processes the UDP message. 881 887 * … … 891 897 * @see IS_NET_UDP_MESSAGE() 892 898 */ 893 int tl_m odule_message(ipc_callid_t callid, ipc_call_t *call,899 int tl_message(ipc_callid_t callid, ipc_call_t *call, 894 900 ipc_call_t *answer, size_t *answer_count) 895 901 {
Note:
See TracChangeset
for help on using the changeset viewer.