Changes in / [e7f6389:f2d2c604] in mainline
- Location:
- uspace
- Files:
-
- 8 edited
-
lib/c/generic/adt/measured_strings.c (modified) (18 diffs)
-
lib/c/include/adt/measured_strings.h (modified) (2 diffs)
-
srv/net/nil/eth/eth.c (modified) (21 diffs)
-
srv/net/nil/eth/eth.h (modified) (2 diffs)
-
srv/net/nil/eth/eth_header.h (modified) (3 diffs)
-
srv/net/nil/eth/eth_module.c (modified) (4 diffs)
-
srv/net/nil/nildummy/nildummy.h (modified) (2 diffs)
-
srv/net/nil/nildummy/nildummy_module.c (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/generic/adt/measured_strings.c
re7f6389 rf2d2c604 52 52 * @param[in] string The initial character string to be stored. 53 53 * @param[in] length The length of the given string without the terminating 54 * zero (' /0') character. If the length is zero (0), the55 * actuallength is computed. The given length is used and56 * appended with the terminating zero ('\ \0') character54 * zero ('\0') character. If the length is zero, the actual 55 * length is computed. The given length is used and 56 * appended with the terminating zero ('\0') character 57 57 * otherwise. 58 58 * @returns The new bundled character string with measured length. … … 60 60 */ 61 61 measured_string_ref 62 measured_string_create_bulk(const char * 62 measured_string_create_bulk(const char *string, size_t length) 63 63 { 64 64 measured_string_ref new; … … 66 66 if (length == 0) { 67 67 while (string[length]) 68 ++length;68 length++; 69 69 } 70 70 new = (measured_string_ref) malloc(sizeof(measured_string_t) + … … 104 104 new->value[new->length] = '\0'; 105 105 return new; 106 } else {107 free(new);108 106 } 107 free(new); 109 108 } 110 109 … … 156 155 return EINVAL; 157 156 } 158 if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,159 sizeof(size_t) * (count + 1)))) {157 if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths, 158 length))) { 160 159 free(lengths); 161 160 return ERROR_CODE; … … 163 162 164 163 *data = malloc(lengths[count]); 165 if (! (*data)) {164 if (!*data) { 166 165 free(lengths); 167 166 return ENOMEM; … … 171 170 *strings = (measured_string_ref) malloc(sizeof(measured_string_t) * 172 171 count); 173 if (! (*strings)) {172 if (!*strings) { 174 173 free(lengths); 175 174 free(*data); … … 178 177 179 178 next = *data; 180 for (index = 0; index < count; ++index) {179 for (index = 0; index < count; index++) { 181 180 (*strings)[index].length = lengths[index]; 182 181 if (lengths[index] > 0) { 183 if ( (!async_data_write_receive(&callid, &length)) ||182 if (!async_data_write_receive(&callid, &length) || 184 183 (length != lengths[index])) { 185 184 free(*data); … … 188 187 return EINVAL; 189 188 } 190 ERROR_PROPAGATE(async_data_write_finalize(callid, next, 191 lengths[index])); 189 if (ERROR_OCCURRED(async_data_write_finalize(callid, 190 next, lengths[index]))) { 191 free(*data); 192 free(*strings); 193 free(lengths); 194 return ERROR_CODE; 195 } 192 196 (*strings)[index].value = next; 193 197 next += lengths[index]; 194 *next = '\0'; 195 ++next; 198 *next++ = '\0'; 196 199 } else { 197 200 (*strings)[index].value = NULL; … … 221 224 222 225 length = 0; 223 for (index = 0; index < count; ++ index) {226 for (index = 0; index < count; index++) { 224 227 lengths[index] = strings[index].length; 225 228 length += lengths[index] + 1; … … 262 265 return ENOMEM; 263 266 264 if ( (!async_data_read_receive(&callid, &length)) ||267 if (!async_data_read_receive(&callid, &length) || 265 268 (length != sizeof(size_t) * (count + 1))) { 266 269 free(lengths); 267 270 return EINVAL; 268 271 } 269 if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, 270 sizeof(size_t) * (count + 1)))) { 272 if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) { 271 273 free(lengths); 272 274 return ERROR_CODE; … … 274 276 free(lengths); 275 277 276 for (index = 0; index < count; ++ index) {278 for (index = 0; index < count; index++) { 277 279 if (strings[index].length > 0) { 278 if ((!async_data_read_receive(&callid, &length))||280 if (!async_data_read_receive(&callid, &length) || 279 281 (length != strings[index].length)) { 280 282 return EINVAL; … … 317 319 char *next; 318 320 319 if ((phone < =0) || (!strings) || (!data) || (count <= 0))321 if ((phone < 0) || (!strings) || (!data) || (count <= 0)) 320 322 return EINVAL; 321 323 … … 331 333 332 334 *data = malloc(lengths[count]); 333 if (! (*data)) {335 if (!*data) { 334 336 free(lengths); 335 337 return ENOMEM; … … 338 340 *strings = (measured_string_ref) malloc(sizeof(measured_string_t) * 339 341 count); 340 if (! (*strings)) {342 if (!*strings) { 341 343 free(lengths); 342 344 free(*data); … … 345 347 346 348 next = *data; 347 for (index = 0; index < count; ++ index) {349 for (index = 0; index < count; index++) { 348 350 (*strings)[index].length = lengths[index]; 349 351 if (lengths[index] > 0) { 350 ERROR_PROPAGATE(async_data_read_start(phone, next, 351 lengths[index])); 352 if (ERROR_OCCURRED(async_data_read_start(phone, next, 353 lengths[index]))) { 354 free(lengths); 355 free(data); 356 free(strings); 357 return ERROR_CODE; 358 } 352 359 (*strings)[index].value = next; 353 360 next += lengths[index]; 354 *next = '\0'; 355 ++ next; 361 *next++ = '\0'; 356 362 } else { 357 363 (*strings)[index].value = NULL; … … 386 392 size_t index; 387 393 388 if ((phone < =0) || (!strings) || (count <= 0))394 if ((phone < 0) || (!strings) || (count <= 0)) 389 395 return EINVAL; 390 396 … … 401 407 free(lengths); 402 408 403 for (index = 0; index < count; ++index) {409 for (index = 0; index < count; index++) { 404 410 if (strings[index].length > 0) { 405 411 ERROR_PROPAGATE(async_data_write_start(phone, -
uspace/lib/c/include/adt/measured_strings.h
re7f6389 rf2d2c604 43 43 44 44 /** Type definition of the character string with measured length. 45 * 45 * @see measured_string 46 46 */ 47 47 typedef struct measured_string measured_string_t; 48 48 49 49 /** Type definition of the character string with measured length pointer. 50 * 50 * @see measured_string 51 51 */ 52 52 typedef measured_string_t *measured_string_ref; … … 59 59 struct measured_string { 60 60 /** Character string data. */ 61 char * 61 char *value; 62 62 /** Character string length. */ 63 63 size_t length; -
uspace/srv/net/nil/eth/eth.c
re7f6389 rf2d2c604 66 66 #include "eth_header.h" 67 67 68 /** The module name. 69 */ 68 /** The module name. */ 70 69 #define NAME "eth" 71 70 72 /** Reserved packet prefix length. 73 */ 74 #define ETH_PREFIX (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t)) 75 76 /** Reserved packet suffix length. 77 */78 #define ETH_SUFFIX sizeof(eth_fcs_t)79 80 /** Maximum packet content length. 81 */71 /** Reserved packet prefix length. */ 72 #define ETH_PREFIX \ 73 (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + \ 74 sizeof(eth_header_snap_t)) 75 76 /** Reserved packet suffix length. */ 77 #define ETH_SUFFIX \ 78 sizeof(eth_fcs_t) 79 80 /** Maximum packet content length. */ 82 81 #define ETH_MAX_CONTENT 1500u 83 82 84 /** Minimum packet content length. 85 */ 83 /** Minimum packet content length. */ 86 84 #define ETH_MIN_CONTENT 46u 87 85 88 /** Maximum tagged packet content length. 89 */ 90 #define ETH_MAX_TAGGED_CONTENT(flags) (ETH_MAX_CONTENT - ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? sizeof(eth_header_lsap_t) : 0) - (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0)) 91 92 /** Minimum tagged packet content length. 93 */ 94 #define ETH_MIN_TAGGED_CONTENT(flags) (ETH_MIN_CONTENT - ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? sizeof(eth_header_lsap_t) : 0) - (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0)) 95 96 /** Dummy flag shift value. 97 */ 86 /** Maximum tagged packet content length. */ 87 #define ETH_MAX_TAGGED_CONTENT(flags) \ 88 (ETH_MAX_CONTENT - \ 89 ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \ 90 sizeof(eth_header_lsap_t) : 0) - \ 91 (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0)) 92 93 /** Minimum tagged packet content length. */ 94 #define ETH_MIN_TAGGED_CONTENT(flags) \ 95 (ETH_MIN_CONTENT - \ 96 ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \ 97 sizeof(eth_header_lsap_t) : 0) - \ 98 (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0)) 99 100 /** Dummy flag shift value. */ 98 101 #define ETH_DUMMY_SHIFT 0 99 102 100 /** Mode flag shift value. 101 */ 103 /** Mode flag shift value. */ 102 104 #define ETH_MODE_SHIFT 1 103 105 104 106 /** Dummy device flag. 105 * 106 */ 107 #define ETH_DUMMY 107 * Preamble and FCS are mandatory part of the packets. 108 */ 109 #define ETH_DUMMY (1 << ETH_DUMMY_SHIFT) 108 110 109 111 /** Returns the dummy flag. 110 * 111 */ 112 #define IS_DUMMY(flags) ((flags) & ETH_DUMMY)112 * @see ETH_DUMMY 113 */ 114 #define IS_DUMMY(flags) ((flags) & ETH_DUMMY) 113 115 114 116 /** Device mode flags. 115 * @see ETH_DIX 116 * @see ETH_8023_2_LSAP 117 * @see ETH_8023_2_SNAP 118 */ 119 #define ETH_MODE_MASK (3 << ETH_MODE_SHIFT) 120 121 /** DIX Ethernet mode flag. 122 */ 123 #define ETH_DIX (1 << ETH_MODE_SHIFT) 117 * @see ETH_DIX 118 * @see ETH_8023_2_LSAP 119 * @see ETH_8023_2_SNAP 120 */ 121 #define ETH_MODE_MASK (3 << ETH_MODE_SHIFT) 122 123 /** DIX Ethernet mode flag. */ 124 #define ETH_DIX (1 << ETH_MODE_SHIFT) 124 125 125 126 /** Returns whether the DIX Ethernet mode flag is set. 126 * @param[in] flags The ethernet flags.127 * @see ETH_DIX128 * /129 #define IS_DIX(flags) (((flags) Ð_MODE_MASK) == ETH_DIX) 130 131 /** 802.3 + 802.2 + LSAP mode flag. 132 */133 #define ETH_8023_2_LSAP 127 * 128 * @param[in] flags The ethernet flags. 129 * @see ETH_DIX 130 */ 131 #define IS_DIX(flags) (((flags) & ETH_MODE_MASK) == ETH_DIX) 132 133 /** 802.3 + 802.2 + LSAP mode flag. */ 134 #define ETH_8023_2_LSAP (2 << ETH_MODE_SHIFT) 134 135 135 136 /** Returns whether the 802.3 + 802.2 + LSAP mode flag is set. 136 * @param[in] flags The ethernet flags.137 * @see ETH_8023_2_LSAP138 * /139 #define IS_8023_2_LSAP(flags) (((flags) Ð_MODE_MASK) == ETH_8023_2_LSAP) 140 141 /** 802.3 + 802.2 + LSAP + SNAP mode flag. 142 */143 #define ETH_8023_2_SNAP 137 * 138 * @param[in] flags The ethernet flags. 139 * @see ETH_8023_2_LSAP 140 */ 141 #define IS_8023_2_LSAP(flags) (((flags) & ETH_MODE_MASK) == ETH_8023_2_LSAP) 142 143 /** 802.3 + 802.2 + LSAP + SNAP mode flag. */ 144 #define ETH_8023_2_SNAP (3 << ETH_MODE_SHIFT) 144 145 145 146 /** Returns whether the 802.3 + 802.2 + LSAP + SNAP mode flag is set. 146 * @param[in] flags The ethernet flags. 147 * @see ETH_8023_2_SNAP 148 */ 149 #define IS_8023_2_SNAP(flags) (((flags) Ð_MODE_MASK) == ETH_8023_2_SNAP) 147 * 148 * @param[in] flags The ethernet flags. 149 * @see ETH_8023_2_SNAP 150 */ 151 #define IS_8023_2_SNAP(flags) (((flags) & ETH_MODE_MASK) == ETH_8023_2_SNAP) 150 152 151 153 /** Type definition of the ethernet address type. 152 * 153 */ 154 typedef enum eth_addr_type 154 * @see eth_addr_type 155 */ 156 typedef enum eth_addr_type eth_addr_type_t; 155 157 156 158 /** Type definition of the ethernet address type pointer. 157 * @see eth_addr_type 158 */ 159 typedef eth_addr_type_t * eth_addr_type_ref; 160 161 /** Ethernet address type. 162 */ 163 enum eth_addr_type{ 164 /** Local address. 165 */ 159 * @see eth_addr_type 160 */ 161 typedef eth_addr_type_t *eth_addr_type_ref; 162 163 /** Ethernet address type. */ 164 enum eth_addr_type { 165 /** Local address. */ 166 166 ETH_LOCAL_ADDR, 167 /** Broadcast address. 168 */ 167 /** Broadcast address. */ 169 168 ETH_BROADCAST_ADDR 170 169 }; 171 170 172 /** Ethernet module global data. 173 */ 174 eth_globals_t eth_globals; 175 176 /** @name Message processing functions 177 */ 178 /*@{*/ 179 180 /** Processes IPC messages from the registered device driver modules in an infinite loop. 181 * @param[in] iid The message identifier. 182 * @param[in,out] icall The message parameters. 183 */ 184 void eth_receiver(ipc_callid_t iid, ipc_call_t * icall); 185 186 /** Registers new device or updates the MTU of an existing one. 187 * Determines the device local hardware address. 188 * @param[in] device_id The new device identifier. 189 * @param[in] service The device driver service. 190 * @param[in] mtu The device maximum transmission unit. 191 * @returns EOK on success. 192 * @returns EEXIST if the device with the different service exists. 193 * @returns ENOMEM if there is not enough memory left. 194 * @returns Other error codes as defined for the net_get_device_conf_req() function. 195 * @returns Other error codes as defined for the netif_bind_service() function. 196 * @returns Other error codes as defined for the netif_get_addr_req() function. 197 */ 198 int eth_device_message(device_id_t device_id, services_t service, size_t mtu); 199 200 /** Registers receiving module service. 201 * Passes received packets for this service. 202 * @param[in] service The module service. 203 * @param[in] phone The service phone. 204 * @returns EOK on success. 205 * @returns ENOENT if the service is not known. 206 * @returns ENOMEM if there is not enough memory left. 207 */ 208 int eth_register_message(services_t service, int phone); 209 210 /** Returns the device packet dimensions for sending. 211 * @param[in] device_id The device identifier. 212 * @param[out] addr_len The minimum reserved address length. 213 * @param[out] prefix The minimum reserved prefix size. 214 * @param[out] content The maximum content size. 215 * @param[out] suffix The minimum reserved suffix size. 216 * @returns EOK on success. 217 * @returns EBADMEM if either one of the parameters is NULL. 218 * @returns ENOENT if there is no such device. 219 */ 220 int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix); 221 222 /** Returns the device hardware address. 223 * @param[in] device_id The device identifier. 224 * @param[in] type Type of the desired address. 225 * @param[out] address The device hardware address. 226 * @returns EOK on success. 227 * @returns EBADMEM if the address parameter is NULL. 228 * @returns ENOENT if there no such device. 229 */ 230 int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address); 231 232 /** Sends the packet queue. 233 * Sends only packet successfully processed by the eth_prepare_packet() function. 234 * @param[in] device_id The device identifier. 235 * @param[in] packet The packet queue. 236 * @param[in] sender The sending module service. 237 * @returns EOK on success. 238 * @returns ENOENT if there no such device. 239 * @returns EINVAL if the service parameter is not known. 240 */ 241 int eth_send_message(device_id_t device_id, packet_t packet, services_t sender); 242 243 /*@}*/ 244 245 /** Processes the received packet and chooses the target registered module. 246 * @param[in] flags The device flags. 247 * @param[in] packet The packet. 248 * @returns The target registered module. 249 * @returns NULL if the packet is not long enough. 250 * @returns NULL if the packet is too long. 251 * @returns NULL if the raw ethernet protocol is used. 252 * @returns NULL if the dummy device FCS checksum is invalid. 253 * @returns NULL if the packet address length is not big enough. 254 */ 255 eth_proto_ref eth_process_packet(int flags, packet_t packet); 256 257 /** Prepares the packet for sending. 258 * @param[in] flags The device flags. 259 * @param[in] packet The packet. 260 * @param[in] src_addr The source hardware address. 261 * @param[in] ethertype The ethernet protocol type. 262 * @param[in] mtu The device maximum transmission unit. 263 * @returns EOK on success. 264 * @returns EINVAL if the packet addresses length is not long enough. 265 * @returns EINVAL if the packet is bigger than the device MTU. 266 * @returns ENOMEM if there is not enough memory in the packet. 267 */ 268 int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu); 269 270 DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t) 271 272 INT_MAP_IMPLEMENT(eth_protos, eth_proto_t) 273 274 int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state){ 171 /** Ethernet module global data. */ 172 eth_globals_t eth_globals; 173 174 DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t); 175 INT_MAP_IMPLEMENT(eth_protos, eth_proto_t); 176 177 int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state) 178 { 275 179 int index; 276 180 eth_proto_ref proto; 277 181 278 182 fibril_rwlock_read_lock(ð_globals.protos_lock); 279 for(index = eth_protos_count(ð_globals.protos) - 1; index >= 0; -- index){ 183 for (index = eth_protos_count(ð_globals.protos) - 1; index >= 0; 184 index--) { 280 185 proto = eth_protos_get_index(ð_globals.protos, index); 281 if(proto && proto->phone){ 282 il_device_state_msg(proto->phone, device_id, state, proto->service); 186 if (proto && proto->phone) { 187 il_device_state_msg(proto->phone, device_id, state, 188 proto->service); 283 189 } 284 190 } 285 191 fibril_rwlock_read_unlock(ð_globals.protos_lock); 192 286 193 return EOK; 287 194 } 288 195 289 int nil_initialize(int net_phone){ 196 int nil_initialize(int net_phone) 197 { 290 198 ERROR_DECLARE; 291 199 292 200 fibril_rwlock_initialize(ð_globals.devices_lock); 293 201 fibril_rwlock_initialize(ð_globals.protos_lock); 202 294 203 fibril_rwlock_write_lock(ð_globals.devices_lock); 295 204 fibril_rwlock_write_lock(ð_globals.protos_lock); 296 205 eth_globals.net_phone = net_phone; 297 eth_globals.broadcast_addr = measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", CONVERT_SIZE(uint8_t, char, ETH_ADDR)); 298 if(! eth_globals.broadcast_addr){ 299 return ENOMEM; 300 } 301 ERROR_PROPAGATE(eth_devices_initialize(ð_globals.devices)); 302 if(ERROR_OCCURRED(eth_protos_initialize(ð_globals.protos))){ 206 eth_globals.broadcast_addr = 207 measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", 208 CONVERT_SIZE(uint8_t, char, ETH_ADDR)); 209 if (!eth_globals.broadcast_addr) { 210 ERROR_CODE = ENOMEM; 211 goto out; 212 } 213 if (ERROR_OCCURRED(eth_devices_initialize(ð_globals.devices))) { 214 free(eth_globals.broadcast_addr); 215 goto out; 216 } 217 if (ERROR_OCCURRED(eth_protos_initialize(ð_globals.protos))) { 218 free(eth_globals.broadcast_addr); 303 219 eth_devices_destroy(ð_globals.devices); 304 return ERROR_CODE;305 } 220 } 221 out: 306 222 fibril_rwlock_write_unlock(ð_globals.protos_lock); 307 223 fibril_rwlock_write_unlock(ð_globals.devices_lock); 308 return EOK; 309 } 310 311 int eth_device_message(device_id_t device_id, services_t service, size_t mtu){ 224 225 return ERROR_CODE; 226 } 227 228 /** Processes IPC messages from the registered device driver modules in an 229 * infinite loop. 230 * 231 * @param[in] iid The message identifier. 232 * @param[in,out] icall The message parameters. 233 */ 234 static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall) 235 { 236 ERROR_DECLARE; 237 238 packet_t packet; 239 240 while (true) { 241 switch (IPC_GET_METHOD(*icall)) { 242 case NET_NIL_DEVICE_STATE: 243 nil_device_state_msg_local(0, IPC_GET_DEVICE(icall), 244 IPC_GET_STATE(icall)); 245 ipc_answer_0(iid, EOK); 246 break; 247 case NET_NIL_RECEIVED: 248 if (ERROR_NONE(packet_translate_remote( 249 eth_globals.net_phone, &packet, 250 IPC_GET_PACKET(icall)))) { 251 ERROR_CODE = nil_received_msg_local(0, 252 IPC_GET_DEVICE(icall), packet, 0); 253 } 254 ipc_answer_0(iid, (ipcarg_t) ERROR_CODE); 255 break; 256 default: 257 ipc_answer_0(iid, (ipcarg_t) ENOTSUP); 258 } 259 260 iid = async_get_call(icall); 261 } 262 } 263 264 /** Registers new device or updates the MTU of an existing one. 265 * 266 * Determines the device local hardware address. 267 * 268 * @param[in] device_id The new device identifier. 269 * @param[in] service The device driver service. 270 * @param[in] mtu The device maximum transmission unit. 271 * @returns EOK on success. 272 * @returns EEXIST if the device with the different service exists. 273 * @returns ENOMEM if there is not enough memory left. 274 * @returns Other error codes as defined for the 275 * net_get_device_conf_req() function. 276 * @returns Other error codes as defined for the 277 * netif_bind_service() function. 278 * @returns Other error codes as defined for the 279 * netif_get_addr_req() function. 280 */ 281 static int 282 eth_device_message(device_id_t device_id, services_t service, size_t mtu) 283 { 312 284 ERROR_DECLARE; 313 285 314 286 eth_device_ref device; 315 287 int index; 316 measured_string_t names[2] = {{str_dup("ETH_MODE"), 8}, {str_dup("ETH_DUMMY"), 9}}; 288 measured_string_t names[2] = { 289 { 290 (char *) "ETH_MODE", 291 8 292 }, 293 { 294 (char *) "ETH_DUMMY", 295 9 296 } 297 }; 317 298 measured_string_ref configuration; 318 299 size_t count = sizeof(names) / sizeof(measured_string_t); 319 char * 300 char *data; 320 301 eth_proto_ref proto; 321 302 … … 323 304 // an existing device? 324 305 device = eth_devices_find(ð_globals.devices, device_id); 325 if (device){326 if (device->service != service){306 if (device) { 307 if (device->service != service) { 327 308 printf("Device %d already exists\n", device->device_id); 328 309 fibril_rwlock_write_unlock(ð_globals.devices_lock); 329 310 return EEXIST; 330 }else{ 331 // update mtu 332 if((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))){ 333 device->mtu = mtu; 334 }else{ 335 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags); 311 } 312 313 // update mtu 314 if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))) 315 device->mtu = mtu; 316 else 317 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags); 318 319 printf("Device %d already exists:\tMTU\t= %d\n", 320 device->device_id, device->mtu); 321 fibril_rwlock_write_unlock(ð_globals.devices_lock); 322 323 // notify all upper layer modules 324 fibril_rwlock_read_lock(ð_globals.protos_lock); 325 for (index = 0; index < eth_protos_count(ð_globals.protos); 326 index++) { 327 proto = eth_protos_get_index(ð_globals.protos, 328 index); 329 if (proto->phone) { 330 il_mtu_changed_msg(proto->phone, 331 device->device_id, device->mtu, 332 proto->service); 336 333 } 337 printf("Device %d already exists:\tMTU\t= %d\n", device->device_id, device->mtu); 338 fibril_rwlock_write_unlock(ð_globals.devices_lock); 339 // notify all upper layer modules 340 fibril_rwlock_read_lock(ð_globals.protos_lock); 341 for(index = 0; index < eth_protos_count(ð_globals.protos); ++ index){ 342 proto = eth_protos_get_index(ð_globals.protos, index); 343 if (proto->phone){ 344 il_mtu_changed_msg(proto->phone, device->device_id, device->mtu, proto->service); 345 } 346 } 347 fibril_rwlock_read_unlock(ð_globals.protos_lock); 348 return EOK; 349 } 350 }else{ 351 // create a new device 352 device = (eth_device_ref) malloc(sizeof(eth_device_t)); 353 if(! device){ 354 return ENOMEM; 355 } 356 device->device_id = device_id; 357 device->service = service; 358 device->flags = 0; 359 if((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))){ 360 device->mtu = mtu; 361 }else{ 362 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags); 363 } 364 configuration = &names[0]; 365 if(ERROR_OCCURRED(net_get_device_conf_req(eth_globals.net_phone, device->device_id, &configuration, count, &data))){ 366 fibril_rwlock_write_unlock(ð_globals.devices_lock); 367 free(device); 368 return ERROR_CODE; 369 } 370 if(configuration){ 371 if(! str_lcmp(configuration[0].value, "DIX", configuration[0].length)){ 372 device->flags |= ETH_DIX; 373 }else if(! str_lcmp(configuration[0].value, "8023_2_LSAP", configuration[0].length)){ 374 device->flags |= ETH_8023_2_LSAP; 375 }else device->flags |= ETH_8023_2_SNAP; 376 if((configuration[1].value) && (configuration[1].value[0] == 'y')){ 377 device->flags |= ETH_DUMMY; 378 } 379 net_free_settings(configuration, data); 380 }else{ 334 } 335 fibril_rwlock_read_unlock(ð_globals.protos_lock); 336 return EOK; 337 } 338 339 // create a new device 340 device = (eth_device_ref) malloc(sizeof(eth_device_t)); 341 if (!device) 342 return ENOMEM; 343 344 device->device_id = device_id; 345 device->service = service; 346 device->flags = 0; 347 if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))) 348 device->mtu = mtu; 349 else 350 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags); 351 352 configuration = &names[0]; 353 if (ERROR_OCCURRED(net_get_device_conf_req(eth_globals.net_phone, 354 device->device_id, &configuration, count, &data))) { 355 fibril_rwlock_write_unlock(ð_globals.devices_lock); 356 free(device); 357 return ERROR_CODE; 358 } 359 if (configuration) { 360 if (!str_lcmp(configuration[0].value, "DIX", 361 configuration[0].length)) { 362 device->flags |= ETH_DIX; 363 } else if(!str_lcmp(configuration[0].value, "8023_2_LSAP", 364 configuration[0].length)) { 365 device->flags |= ETH_8023_2_LSAP; 366 } else { 381 367 device->flags |= ETH_8023_2_SNAP; 382 368 } 383 // bind the device driver 384 device->phone = netif_bind_service(device->service, device->device_id, SERVICE_ETHERNET, eth_receiver); 385 if(device->phone < 0){ 386 fibril_rwlock_write_unlock(ð_globals.devices_lock); 387 free(device); 388 return device->phone; 389 } 390 // get hardware address 391 if(ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id, &device->addr, &device->addr_data))){ 392 fibril_rwlock_write_unlock(ð_globals.devices_lock); 393 free(device); 394 return ERROR_CODE; 395 } 396 // add to the cache 397 index = eth_devices_add(ð_globals.devices, device->device_id, device); 398 if(index < 0){ 399 fibril_rwlock_write_unlock(ð_globals.devices_lock); 400 free(device->addr); 401 free(device->addr_data); 402 free(device); 403 return index; 404 } 405 printf("%s: Device registered (id: %d, service: %d: mtu: %d, " 406 "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n", 407 NAME, device->device_id, device->service, device->mtu, 408 device->addr_data[0], device->addr_data[1], 409 device->addr_data[2], device->addr_data[3], 410 device->addr_data[4], device->addr_data[5], device->flags); 411 } 369 370 if (configuration[1].value && 371 (configuration[1].value[0] == 'y')) { 372 device->flags |= ETH_DUMMY; 373 } 374 net_free_settings(configuration, data); 375 } else { 376 device->flags |= ETH_8023_2_SNAP; 377 } 378 379 // bind the device driver 380 device->phone = netif_bind_service(device->service, device->device_id, 381 SERVICE_ETHERNET, eth_receiver); 382 if (device->phone < 0) { 383 fibril_rwlock_write_unlock(ð_globals.devices_lock); 384 free(device); 385 return device->phone; 386 } 387 388 // get hardware address 389 if (ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id, 390 &device->addr, &device->addr_data))) { 391 fibril_rwlock_write_unlock(ð_globals.devices_lock); 392 free(device); 393 return ERROR_CODE; 394 } 395 396 // add to the cache 397 index = eth_devices_add(ð_globals.devices, device->device_id, 398 device); 399 if (index < 0) { 400 fibril_rwlock_write_unlock(ð_globals.devices_lock); 401 free(device->addr); 402 free(device->addr_data); 403 free(device); 404 return index; 405 } 406 407 printf("%s: Device registered (id: %d, service: %d: mtu: %d, " 408 "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n", 409 NAME, device->device_id, device->service, device->mtu, 410 device->addr_data[0], device->addr_data[1], 411 device->addr_data[2], device->addr_data[3], 412 device->addr_data[4], device->addr_data[5], device->flags); 413 412 414 fibril_rwlock_write_unlock(ð_globals.devices_lock); 413 415 return EOK; 414 416 } 415 417 416 eth_proto_ref eth_process_packet(int flags, packet_t packet){ 418 /** Processes the received packet and chooses the target registered module. 419 * 420 * @param[in] flags The device flags. 421 * @param[in] packet The packet. 422 * @returns The target registered module. 423 * @returns NULL if the packet is not long enough. 424 * @returns NULL if the packet is too long. 425 * @returns NULL if the raw ethernet protocol is used. 426 * @returns NULL if the dummy device FCS checksum is invalid. 427 * @returns NULL if the packet address length is not big enough. 428 */ 429 static eth_proto_ref eth_process_packet(int flags, packet_t packet) 430 { 417 431 ERROR_DECLARE; 418 432 … … 426 440 427 441 length = packet_get_data_length(packet); 428 if(IS_DUMMY(flags)){ 442 443 if (IS_DUMMY(flags)) 429 444 packet_trim(packet, sizeof(eth_preamble_t), 0); 430 } 431 if(length < sizeof(eth_header_t) + ETH_MIN_CONTENT + (IS_DUMMY(flags) ? ETH_SUFFIX : 0)) return NULL; 445 if (length < sizeof(eth_header_t) + ETH_MIN_CONTENT + 446 (IS_DUMMY(flags) ? ETH_SUFFIX : 0)) 447 return NULL; 448 432 449 data = packet_get_data(packet); 433 450 header = (eth_header_snap_ref) data; 434 451 type = ntohs(header->header.ethertype); 435 if(type >= ETH_MIN_PROTO){ 452 453 if (type >= ETH_MIN_PROTO) { 436 454 // DIX Ethernet 437 455 prefix = sizeof(eth_header_t); … … 439 457 fcs = (eth_fcs_ref) data + length - sizeof(eth_fcs_t); 440 458 length -= sizeof(eth_fcs_t); 441 } else if(type <= ETH_MAX_CONTENT){459 } else if(type <= ETH_MAX_CONTENT) { 442 460 // translate "LSAP" values 443 if((header->lsap.dsap == ETH_LSAP_GLSAP) && (header->lsap.ssap == ETH_LSAP_GLSAP)){ 461 if ((header->lsap.dsap == ETH_LSAP_GLSAP) && 462 (header->lsap.ssap == ETH_LSAP_GLSAP)) { 444 463 // raw packet 445 464 // discard 446 465 return NULL; 447 }else if((header->lsap.dsap == ETH_LSAP_SNAP) && (header->lsap.ssap == ETH_LSAP_SNAP)){ 466 } else if((header->lsap.dsap == ETH_LSAP_SNAP) && 467 (header->lsap.ssap == ETH_LSAP_SNAP)) { 448 468 // IEEE 802.3 + 802.2 + LSAP + SNAP 449 469 // organization code not supported 450 470 type = ntohs(header->snap.ethertype); 451 prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t); 452 }else{ 471 prefix = sizeof(eth_header_t) + 472 sizeof(eth_header_lsap_t) + 473 sizeof(eth_header_snap_t); 474 } else { 453 475 // IEEE 802.3 + 802.2 LSAP 454 476 type = lsap_map(header->lsap.dsap); 455 prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t); 456 } 457 suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0u; 477 prefix = sizeof(eth_header_t) + 478 sizeof(eth_header_lsap_t); 479 } 480 suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0U; 458 481 fcs = (eth_fcs_ref) data + prefix + type + suffix; 459 482 suffix += length - prefix - type; 460 483 length = prefix + type + suffix; 461 } else{484 } else { 462 485 // invalid length/type, should not occurr 463 486 return NULL; 464 487 } 465 if(IS_DUMMY(flags)){ 466 if((~ compute_crc32(~ 0u, data, length * 8)) != ntohl(*fcs)){ 488 489 if (IS_DUMMY(flags)) { 490 if ((~compute_crc32(~0U, data, length * 8)) != ntohl(*fcs)) 467 491 return NULL; 468 }469 492 suffix += sizeof(eth_fcs_t); 470 493 } 471 if(ERROR_OCCURRED(packet_set_addr(packet, header->header.source_address, header->header.destination_address, ETH_ADDR)) 472 || ERROR_OCCURRED(packet_trim(packet, prefix, suffix))){ 494 495 if (ERROR_OCCURRED(packet_set_addr(packet, 496 header->header.source_address, header->header.destination_address, 497 ETH_ADDR)) || ERROR_OCCURRED(packet_trim(packet, prefix, suffix))) { 473 498 return NULL; 474 499 } 500 475 501 return eth_protos_find(ð_globals.protos, type); 476 502 } 477 503 478 int nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet, services_t target){ 504 int 505 nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet, 506 services_t target) 507 { 479 508 eth_proto_ref proto; 480 509 packet_t next; … … 484 513 fibril_rwlock_read_lock(ð_globals.devices_lock); 485 514 device = eth_devices_find(ð_globals.devices, device_id); 486 if (! device){515 if (!device) { 487 516 fibril_rwlock_read_unlock(ð_globals.devices_lock); 488 517 return ENOENT; … … 490 519 flags = device->flags; 491 520 fibril_rwlock_read_unlock(ð_globals.devices_lock); 521 492 522 fibril_rwlock_read_lock(ð_globals.protos_lock); 493 do {523 do { 494 524 next = pq_detach(packet); 495 525 proto = eth_process_packet(flags, packet); 496 if(proto){ 497 il_received_msg(proto->phone, device_id, packet, proto->service); 498 }else{ 526 if (proto) { 527 il_received_msg(proto->phone, device_id, packet, 528 proto->service); 529 } else { 499 530 // drop invalid/unknown 500 pq_release_remote(eth_globals.net_phone, packet_get_id(packet)); 531 pq_release_remote(eth_globals.net_phone, 532 packet_get_id(packet)); 501 533 } 502 534 packet = next; 503 } while(packet);535 } while(packet); 504 536 fibril_rwlock_read_unlock(ð_globals.protos_lock); 537 505 538 return EOK; 506 539 } 507 540 508 int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix){ 541 /** Returns the device packet dimensions for sending. 542 * 543 * @param[in] device_id The device identifier. 544 * @param[out] addr_len The minimum reserved address length. 545 * @param[out] prefix The minimum reserved prefix size. 546 * @param[out] content The maximum content size. 547 * @param[out] suffix The minimum reserved suffix size. 548 * @returns EOK on success. 549 * @returns EBADMEM if either one of the parameters is NULL. 550 * @returns ENOENT if there is no such device. 551 */ 552 static int 553 eth_packet_space_message(device_id_t device_id, size_t *addr_len, 554 size_t *prefix, size_t *content, size_t *suffix) 555 { 509 556 eth_device_ref device; 510 557 511 if (!(addr_len && prefix && content && suffix)){558 if (!addr_len || !prefix || !content || !suffix) 512 559 return EBADMEM; 513 }560 514 561 fibril_rwlock_read_lock(ð_globals.devices_lock); 515 562 device = eth_devices_find(ð_globals.devices, device_id); 516 if (! device){563 if (!device) { 517 564 fibril_rwlock_read_unlock(ð_globals.devices_lock); 518 565 return ENOENT; … … 520 567 *content = device->mtu; 521 568 fibril_rwlock_read_unlock(ð_globals.devices_lock); 569 522 570 *addr_len = ETH_ADDR; 523 571 *prefix = ETH_PREFIX; … … 526 574 } 527 575 528 int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address){ 576 /** Returns the device hardware address. 577 * 578 * @param[in] device_id The device identifier. 579 * @param[in] type Type of the desired address. 580 * @param[out] address The device hardware address. 581 * @returns EOK on success. 582 * @returns EBADMEM if the address parameter is NULL. 583 * @returns ENOENT if there no such device. 584 */ 585 static int 586 eth_addr_message(device_id_t device_id, eth_addr_type_t type, 587 measured_string_ref *address) 588 { 529 589 eth_device_ref device; 530 590 531 if (! address){591 if (!address) 532 592 return EBADMEM; 533 } 534 if (type == ETH_BROADCAST_ADDR){593 594 if (type == ETH_BROADCAST_ADDR) { 535 595 *address = eth_globals.broadcast_addr; 536 } else{596 } else { 537 597 fibril_rwlock_read_lock(ð_globals.devices_lock); 538 598 device = eth_devices_find(ð_globals.devices, device_id); 539 if (! device){599 if (!device) { 540 600 fibril_rwlock_read_unlock(ð_globals.devices_lock); 541 601 return ENOENT; … … 544 604 fibril_rwlock_read_unlock(ð_globals.devices_lock); 545 605 } 606 546 607 return (*address) ? EOK : ENOENT; 547 608 } 548 609 549 int eth_register_message(services_t service, int phone){ 610 /** Registers receiving module service. 611 * 612 * Passes received packets for this service. 613 * 614 * @param[in] service The module service. 615 * @param[in] phone The service phone. 616 * @returns EOK on success. 617 * @returns ENOENT if the service is not known. 618 * @returns ENOMEM if there is not enough memory left. 619 */ 620 static int eth_register_message(services_t service, int phone) 621 { 550 622 eth_proto_ref proto; 551 623 int protocol; … … 553 625 554 626 protocol = protocol_map(SERVICE_ETHERNET, service); 555 if (! protocol){627 if (!protocol) 556 628 return ENOENT; 557 } 629 558 630 fibril_rwlock_write_lock(ð_globals.protos_lock); 559 631 proto = eth_protos_find(ð_globals.protos, protocol); 560 if (proto){632 if (proto) { 561 633 proto->phone = phone; 562 634 fibril_rwlock_write_unlock(ð_globals.protos_lock); 563 635 return EOK; 564 } else{636 } else { 565 637 proto = (eth_proto_ref) malloc(sizeof(eth_proto_t)); 566 if (! proto){638 if (!proto) { 567 639 fibril_rwlock_write_unlock(ð_globals.protos_lock); 568 640 return ENOMEM; … … 572 644 proto->phone = phone; 573 645 index = eth_protos_add(ð_globals.protos, protocol, proto); 574 if (index < 0){646 if (index < 0) { 575 647 fibril_rwlock_write_unlock(ð_globals.protos_lock); 576 648 free(proto); … … 579 651 } 580 652 581 printf("%s: Protocol registered (protocol: %d, service: %d, phone: %d)\n",582 NAME, proto->protocol, proto->service, proto->phone);653 printf("%s: Protocol registered (protocol: %d, service: %d, phone: " 654 "%d)\n", NAME, proto->protocol, proto->service, proto->phone); 583 655 584 656 fibril_rwlock_write_unlock(ð_globals.protos_lock); … … 586 658 } 587 659 588 int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu){ 660 /** Prepares the packet for sending. 661 * 662 * @param[in] flags The device flags. 663 * @param[in] packet The packet. 664 * @param[in] src_addr The source hardware address. 665 * @param[in] ethertype The ethernet protocol type. 666 * @param[in] mtu The device maximum transmission unit. 667 * @returns EOK on success. 668 * @returns EINVAL if the packet addresses length is not long 669 * enough. 670 * @returns EINVAL if the packet is bigger than the device MTU. 671 * @returns ENOMEM if there is not enough memory in the packet. 672 */ 673 static int 674 eth_prepare_packet(int flags, packet_t packet, uint8_t *src_addr, int ethertype, 675 size_t mtu) 676 { 589 677 eth_header_snap_ref header; 590 678 eth_header_lsap_ref header_lsap; 591 679 eth_header_ref header_dix; 592 680 eth_fcs_ref fcs; 593 uint8_t * 594 uint8_t * 681 uint8_t *src; 682 uint8_t *dest; 595 683 size_t length; 596 684 int i; 597 void * 685 void *padding; 598 686 eth_preamble_ref preamble; 599 687 600 688 i = packet_get_addr(packet, &src, &dest); 601 if (i < 0){689 if (i < 0) 602 690 return i; 603 } 604 if(i != ETH_ADDR){ 691 if (i != ETH_ADDR) 605 692 return EINVAL; 606 } 693 607 694 length = packet_get_data_length(packet); 608 if (length > mtu){695 if (length > mtu) 609 696 return EINVAL; 610 } 611 if(length < ETH_MIN_TAGGED_CONTENT(flags)){ 612 padding = packet_suffix(packet, ETH_MIN_TAGGED_CONTENT(flags) - length); 613 if(! padding){ 697 698 if (length < ETH_MIN_TAGGED_CONTENT(flags)) { 699 padding = packet_suffix(packet, 700 ETH_MIN_TAGGED_CONTENT(flags) - length); 701 if (!padding) 614 702 return ENOMEM; 615 }616 703 bzero(padding, ETH_MIN_TAGGED_CONTENT(flags) - length); 617 704 } 618 if(IS_DIX(flags)){ 705 706 if (IS_DIX(flags)) { 619 707 header_dix = PACKET_PREFIX(packet, eth_header_t); 620 if (! header_dix){708 if (!header_dix) 621 709 return ENOMEM; 622 }710 623 711 header_dix->ethertype = (uint16_t) ethertype; 624 712 memcpy(header_dix->source_address, src_addr, ETH_ADDR); 625 713 memcpy(header_dix->destination_address, dest, ETH_ADDR); 626 714 src = &header_dix->destination_address[0]; 627 } else if(IS_8023_2_LSAP(flags)){715 } else if(IS_8023_2_LSAP(flags)) { 628 716 header_lsap = PACKET_PREFIX(packet, eth_header_lsap_t); 629 if (! header_lsap){717 if (!header_lsap) 630 718 return ENOMEM; 631 } 632 header_lsap->header.ethertype = htons(length + sizeof(eth_header_lsap_t)); 719 720 header_lsap->header.ethertype = htons(length + 721 sizeof(eth_header_lsap_t)); 633 722 header_lsap->lsap.dsap = lsap_unmap(ntohs(ethertype)); 634 723 header_lsap->lsap.ssap = header_lsap->lsap.dsap; … … 637 726 memcpy(header_lsap->header.destination_address, dest, ETH_ADDR); 638 727 src = &header_lsap->header.destination_address[0]; 639 } else if(IS_8023_2_SNAP(flags)){728 } else if(IS_8023_2_SNAP(flags)) { 640 729 header = PACKET_PREFIX(packet, eth_header_snap_t); 641 if (! header){730 if (!header) 642 731 return ENOMEM; 643 } 644 header->header.ethertype = htons(length + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t)); 732 733 header->header.ethertype = htons(length + 734 sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t)); 645 735 header->lsap.dsap = (uint16_t) ETH_LSAP_SNAP; 646 736 header->lsap.ssap = header->lsap.dsap; 647 737 header->lsap.ctrl = IEEE_8023_2_UI; 648 for(i = 0; i < 3; ++ i){ 738 739 for (i = 0; i < 3; ++ i) 649 740 header->snap.protocol[i] = 0; 650 }741 651 742 header->snap.ethertype = (uint16_t) ethertype; 652 743 memcpy(header->header.source_address, src_addr, ETH_ADDR); … … 654 745 src = &header->header.destination_address[0]; 655 746 } 656 if(IS_DUMMY(flags)){ 747 748 if (IS_DUMMY(flags)) { 657 749 preamble = PACKET_PREFIX(packet, eth_preamble_t); 658 if (! preamble){750 if (!preamble) 659 751 return ENOMEM; 660 }661 for (i = 0; i < 7; ++ i){752 753 for (i = 0; i < 7; ++ i) 662 754 preamble->preamble[i] = ETH_PREAMBLE; 663 }755 664 756 preamble->sfd = ETH_SFD; 757 665 758 fcs = PACKET_SUFFIX(packet, eth_fcs_t); 666 if (! fcs){759 if (!fcs) 667 760 return ENOMEM; 668 } 669 *fcs = htonl(~ compute_crc32(~ 0u, src, length * 8)); 670 } 761 762 *fcs = htonl(~compute_crc32(~0U, src, length * 8)); 763 } 764 671 765 return EOK; 672 766 } 673 767 674 int eth_send_message(device_id_t device_id, packet_t packet, services_t sender){ 768 /** Sends the packet queue. 769 * 770 * Sends only packet successfully processed by the eth_prepare_packet() 771 * function. 772 * 773 * @param[in] device_id The device identifier. 774 * @param[in] packet The packet queue. 775 * @param[in] sender The sending module service. 776 * @returns EOK on success. 777 * @returns ENOENT if there no such device. 778 * @returns EINVAL if the service parameter is not known. 779 */ 780 static int 781 eth_send_message(device_id_t device_id, packet_t packet, services_t sender) 782 { 675 783 ERROR_DECLARE; 676 784 … … 681 789 682 790 ethertype = htons(protocol_map(SERVICE_ETHERNET, sender)); 683 if (! ethertype){791 if (!ethertype) { 684 792 pq_release_remote(eth_globals.net_phone, packet_get_id(packet)); 685 793 return EINVAL; 686 794 } 795 687 796 fibril_rwlock_read_lock(ð_globals.devices_lock); 688 797 device = eth_devices_find(ð_globals.devices, device_id); 689 if (! device){798 if (!device) { 690 799 fibril_rwlock_read_unlock(ð_globals.devices_lock); 691 800 return ENOENT; 692 801 } 802 693 803 // process packet queue 694 804 next = packet; 695 do{ 696 if(ERROR_OCCURRED(eth_prepare_packet(device->flags, next, (uint8_t *) device->addr->value, ethertype, device->mtu))){ 805 do { 806 if (ERROR_OCCURRED(eth_prepare_packet(device->flags, next, 807 (uint8_t *) device->addr->value, ethertype, device->mtu))) { 697 808 // release invalid packet 698 809 tmp = pq_detach(next); 699 if (next == packet){810 if (next == packet) 700 811 packet = tmp; 701 }702 pq_release_remote(eth_globals.net_phone,packet_get_id(next));812 pq_release_remote(eth_globals.net_phone, 813 packet_get_id(next)); 703 814 next = tmp; 704 } else{815 } else { 705 816 next = pq_next(next); 706 817 } 707 }while(next); 818 } while(next); 819 708 820 // send packet queue 709 if(packet){ 710 netif_send_msg(device->phone, device_id, packet, SERVICE_ETHERNET); 821 if (packet) { 822 netif_send_msg(device->phone, device_id, packet, 823 SERVICE_ETHERNET); 711 824 } 712 825 fibril_rwlock_read_unlock(ð_globals.devices_lock); 826 713 827 return EOK; 714 828 } 715 829 716 int nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call, 830 int 831 nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call, 717 832 ipc_call_t *answer, int *answer_count) 718 833 { … … 728 843 *answer_count = 0; 729 844 switch (IPC_GET_METHOD(*call)) { 730 case IPC_M_PHONE_HUNGUP: 731 return EOK; 732 case NET_NIL_DEVICE: 733 return eth_device_message(IPC_GET_DEVICE(call), 734 IPC_GET_SERVICE(call), IPC_GET_MTU(call)); 735 case NET_NIL_SEND: 736 ERROR_PROPAGATE(packet_translate_remote(eth_globals.net_phone, &packet, 737 IPC_GET_PACKET(call))); 738 return eth_send_message(IPC_GET_DEVICE(call), packet, 739 IPC_GET_SERVICE(call)); 740 case NET_NIL_PACKET_SPACE: 741 ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call), 742 &addrlen, &prefix, &content, &suffix)); 743 IPC_SET_ADDR(answer, addrlen); 744 IPC_SET_PREFIX(answer, prefix); 745 IPC_SET_CONTENT(answer, content); 746 IPC_SET_SUFFIX(answer, suffix); 747 *answer_count = 4; 748 return EOK; 749 case NET_NIL_ADDR: 750 ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), 751 ETH_LOCAL_ADDR, &address)); 752 return measured_strings_reply(address, 1); 753 case NET_NIL_BROADCAST_ADDR: 754 ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), 755 ETH_BROADCAST_ADDR, &address)); 756 return measured_strings_reply(address, 1); 757 case IPC_M_CONNECT_TO_ME: 758 return eth_register_message(NIL_GET_PROTO(call), 759 IPC_GET_PHONE(call)); 845 case IPC_M_PHONE_HUNGUP: 846 return EOK; 847 848 case NET_NIL_DEVICE: 849 return eth_device_message(IPC_GET_DEVICE(call), 850 IPC_GET_SERVICE(call), IPC_GET_MTU(call)); 851 case NET_NIL_SEND: 852 ERROR_PROPAGATE(packet_translate_remote(eth_globals.net_phone, 853 &packet, IPC_GET_PACKET(call))); 854 return eth_send_message(IPC_GET_DEVICE(call), packet, 855 IPC_GET_SERVICE(call)); 856 case NET_NIL_PACKET_SPACE: 857 ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call), 858 &addrlen, &prefix, &content, &suffix)); 859 IPC_SET_ADDR(answer, addrlen); 860 IPC_SET_PREFIX(answer, prefix); 861 IPC_SET_CONTENT(answer, content); 862 IPC_SET_SUFFIX(answer, suffix); 863 *answer_count = 4; 864 return EOK; 865 case NET_NIL_ADDR: 866 ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), 867 ETH_LOCAL_ADDR, &address)); 868 return measured_strings_reply(address, 1); 869 case NET_NIL_BROADCAST_ADDR: 870 ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), 871 ETH_BROADCAST_ADDR, &address)); 872 return measured_strings_reply(address, 1); 873 case IPC_M_CONNECT_TO_ME: 874 return eth_register_message(NIL_GET_PROTO(call), 875 IPC_GET_PHONE(call)); 760 876 } 761 877 … … 763 879 } 764 880 765 void eth_receiver(ipc_callid_t iid, ipc_call_t * icall){766 ERROR_DECLARE;767 768 packet_t packet;769 770 while(true){771 // printf("message %d - %d\n", IPC_GET_METHOD(*icall), NET_NIL_FIRST);772 switch(IPC_GET_METHOD(*icall)){773 case NET_NIL_DEVICE_STATE:774 nil_device_state_msg_local(0, IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));775 ipc_answer_0(iid, EOK);776 break;777 case NET_NIL_RECEIVED:778 if(! ERROR_OCCURRED(packet_translate_remote(eth_globals.net_phone, &packet, IPC_GET_PACKET(icall)))){779 ERROR_CODE = nil_received_msg_local(0, IPC_GET_DEVICE(icall), packet, 0);780 }781 ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);782 break;783 default:784 ipc_answer_0(iid, (ipcarg_t) ENOTSUP);785 }786 iid = async_get_call(icall);787 }788 }789 790 881 /** Default thread for new connections. 791 882 * 792 * @param[in] iid 793 * @param[in] icall 883 * @param[in] iid The initial message identifier. 884 * @param[in] icall The initial message call structure. 794 885 * 795 886 */ … … 802 893 ipc_answer_0(iid, EOK); 803 894 804 while (true) {895 while (true) { 805 896 ipc_call_t answer; 806 897 int answer_count; … … 814 905 815 906 /* Process the message */ 816 int res = nil_module_message_standalone(NAME, callid, &call, &answer, 817 &answer_count); 818 819 /* End if said to either by the message or the processing result */ 820 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP)) 907 int res = nil_module_message_standalone(NAME, callid, &call, 908 &answer, &answer_count); 909 910 /* 911 * End if told to either by the message or the processing 912 * result. 913 */ 914 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || 915 (res == EHANGUP)) 821 916 return; 822 917 … … 831 926 832 927 /* Start the module */ 833 if (ERROR_OCCURRED(nil_module_start_standalone(nil_client_connection))) 834 return ERROR_CODE; 835 928 ERROR_PROPAGATE(nil_module_start_standalone(nil_client_connection)); 836 929 return EOK; 837 930 } -
uspace/srv/net/nil/eth/eth.h
re7f6389 rf2d2c604 32 32 33 33 /** @file 34 * 34 * Ethernet module. 35 35 */ 36 36 37 #ifndef __NET_ETH_H__38 #define __NET_ETH_H__37 #ifndef NET_ETH_H_ 38 #define NET_ETH_H_ 39 39 40 40 #include <fibril_synch.h> … … 45 45 46 46 /** Type definition of the Ethernet global data. 47 * 47 * @see eth_globals 48 48 */ 49 typedef struct eth_globals 49 typedef struct eth_globals eth_globals_t; 50 50 51 51 /** Type definition of the Ethernet device specific data. 52 * 52 * @see eth_device 53 53 */ 54 typedef struct eth_device 54 typedef struct eth_device eth_device_t; 55 55 56 56 /** Type definition of the Ethernet device specific data pointer. 57 * 57 * @see eth_device 58 58 */ 59 typedef eth_device_t * 59 typedef eth_device_t *eth_device_ref; 60 60 61 61 /** Type definition of the Ethernet protocol specific data. 62 * 62 * @see eth_proto 63 63 */ 64 typedef struct eth_proto 64 typedef struct eth_proto eth_proto_t; 65 65 66 66 /** Type definition of the Ethernet protocol specific data pointer. 67 * 67 * @see eth_proto 68 68 */ 69 typedef eth_proto_t * 69 typedef eth_proto_t *eth_proto_ref; 70 70 71 71 /** Ethernet device map. 72 * 73 * 72 * Maps devices to the Ethernet device specific data. 73 * @see device.h 74 74 */ 75 DEVICE_MAP_DECLARE(eth_devices, eth_device_t) 75 DEVICE_MAP_DECLARE(eth_devices, eth_device_t); 76 76 77 77 /** Ethernet protocol map. 78 * 79 * 78 * Maps protocol identifiers to the Ethernet protocol specific data. 79 * @see int_map.h 80 80 */ 81 INT_MAP_DECLARE(eth_protos, eth_proto_t) 81 INT_MAP_DECLARE(eth_protos, eth_proto_t); 82 82 83 /** Ethernet device specific data. 84 */ 85 struct eth_device{ 86 /** Device identifier. 87 */ 83 /** Ethernet device specific data. */ 84 struct eth_device { 85 /** Device identifier. */ 88 86 device_id_t device_id; 89 /** Device driver service. 90 */ 87 /** Device driver service. */ 91 88 services_t service; 92 /** Driver phone. 93 */ 89 /** Driver phone. */ 94 90 int phone; 95 /** Maximal transmission unit. 96 */ 91 /** Maximal transmission unit. */ 97 92 size_t mtu; 98 /** Various device flags. 99 * @see ETH_DUMMY 100 * @see ETH_MODE_MASK 93 94 /** 95 * Various device flags. 96 * @see ETH_DUMMY 97 * @see ETH_MODE_MASK 101 98 */ 102 99 int flags; 103 /** Actual device hardware address.104 */100 101 /** Actual device hardware address. */ 105 102 measured_string_ref addr; 106 /** Actual device hardware address data. 107 */ 108 char * addr_data; 103 /** Actual device hardware address data. */ 104 char *addr_data; 109 105 }; 110 106 111 /** Ethernet protocol specific data. 112 */ 113 struct eth_proto{ 114 /** Protocol service. 115 */ 107 /** Ethernet protocol specific data. */ 108 struct eth_proto { 109 /** Protocol service. */ 116 110 services_t service; 117 /** Protocol identifier. 118 */ 111 /** Protocol identifier. */ 119 112 int protocol; 120 /** Protocol module phone. 121 */ 113 /** Protocol module phone. */ 122 114 int phone; 123 115 }; 124 116 125 /** Ethernet global data. 126 */ 127 struct eth_globals{ 128 /** Networking module phone. 129 */ 117 /** Ethernet global data. */ 118 struct eth_globals { 119 /** Networking module phone. */ 130 120 int net_phone; 131 /** Safety lock for devices. 132 */ 121 /** Safety lock for devices. */ 133 122 fibril_rwlock_t devices_lock; 134 /** All known Ethernet devices. 135 */ 123 /** All known Ethernet devices. */ 136 124 eth_devices_t devices; 137 /** Safety lock for protocols. 138 */ 125 /** Safety lock for protocols. */ 139 126 fibril_rwlock_t protos_lock; 140 /** Protocol map. 141 * Service phone map for each protocol. 127 128 /** 129 * Protocol map. 130 * Service phone map for each protocol. 142 131 */ 143 132 eth_protos_t protos; 144 /** Broadcast device hardware address.145 */133 134 /** Broadcast device hardware address. */ 146 135 measured_string_ref broadcast_addr; 147 136 }; -
uspace/srv/net/nil/eth/eth_header.h
re7f6389 rf2d2c604 32 32 33 33 /** @file 34 * 35 * Based on the IEEE~802.3-200536 */ 37 38 #ifndef __NET_ETH_HEADER_H__39 #define __NET_ETH_HEADER_H__34 * Ethernet protocol header definitions. 35 * Based on the IEEE 802.3-2005 36 */ 37 38 #ifndef NET_ETH_HEADER_H_ 39 #define NET_ETH_HEADER_H_ 40 40 41 41 #include <sys/types.h> 42 42 43 /** Ethernet address length. 44 */ 45 #define ETH_ADDR 6 46 47 /** Ethernet header preamble value. 48 */ 43 /** Ethernet address length. */ 44 #define ETH_ADDR 6 45 46 /** Ethernet header preamble value. */ 49 47 #define ETH_PREAMBLE 0x55 50 48 51 /** Ethernet header start of frame value. 52 */ 53 #define ETH_SFD 0xD5 54 55 /** IEEE 802.2 unordered information control field. 56 */ 49 /** Ethernet header start of frame value. */ 50 #define ETH_SFD 0xD5 51 52 /** IEEE 802.2 unordered information control field. */ 57 53 #define IEEE_8023_2_UI 0x03 58 54 59 55 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions. 60 * @see eth_header_snap 61 */ 62 typedef struct eth_header_snap eth_header_snap_t; 63 64 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions pointer. 65 * @see eth_header_snap 66 */ 67 typedef eth_header_snap_t * eth_header_snap_ref; 56 * @see eth_header_snap 57 */ 58 typedef struct eth_header_snap eth_header_snap_t; 59 60 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions 61 * pointer. 62 * 63 * @see eth_header_snap 64 */ 65 typedef eth_header_snap_t *eth_header_snap_ref; 68 66 69 67 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions. 70 * 71 */ 72 typedef struct eth_header_lsap 68 * @see eth_header_lsap 69 */ 70 typedef struct eth_header_lsap eth_header_lsap_t; 73 71 74 72 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 extension pointer. 75 * 76 */ 77 typedef eth_header_lsap_t * 73 * @see eth_header_lsap 74 */ 75 typedef eth_header_lsap_t *eth_header_lsap_ref; 78 76 79 77 /** Type definition of the Ethernet header LSAP extension. 80 * 81 */ 82 typedef struct eth_ieee_lsap 78 * @see eth_ieee_lsap 79 */ 80 typedef struct eth_ieee_lsap eth_ieee_lsap_t; 83 81 84 82 /** Type definition of the Ethernet header LSAP extension pointer. 85 * 86 */ 87 typedef eth_ieee_lsap_t * 83 * @see eth_ieee_lsap 84 */ 85 typedef eth_ieee_lsap_t *eth_ieee_lsap_ref; 88 86 89 87 /** Type definition of the Ethernet header SNAP extension. 90 * 91 */ 92 typedef struct eth_snap 88 * @see eth_snap 89 */ 90 typedef struct eth_snap eth_snap_t; 93 91 94 92 /** Type definition of the Ethernet header SNAP extension pointer. 95 * 96 */ 97 typedef eth_snap_t * 93 * @see eth_snap 94 */ 95 typedef eth_snap_t *eth_snap_ref; 98 96 99 97 /** Type definition of the Ethernet header preamble. 100 * 101 */ 102 typedef struct eth_preamble 98 * @see preamble 99 */ 100 typedef struct eth_preamble eth_preamble_t; 103 101 104 102 /** Type definition of the Ethernet header preamble pointer. 105 * 106 */ 107 typedef eth_preamble_t * 103 * @see eth_preamble 104 */ 105 typedef eth_preamble_t *eth_preamble_ref; 108 106 109 107 /** Type definition of the Ethernet header. 110 * 111 */ 112 typedef struct eth_header 108 * @see eth_header 109 */ 110 typedef struct eth_header eth_header_t; 113 111 114 112 /** Type definition of the Ethernet header pointer. 115 * 116 */ 117 typedef eth_header_t * 118 119 /** Ethernet header Link Service Access Point extension. 120 */ 121 struct eth_ieee_lsap{ 122 /** Destination Service Access Point identifier.113 * @see eth_header 114 */ 115 typedef eth_header_t *eth_header_ref; 116 117 /** Ethernet header Link Service Access Point extension. */ 118 struct eth_ieee_lsap { 119 /** 120 * Destination Service Access Point identifier. 123 121 * The possible values are assigned by an IEEE committee. 124 122 */ 125 123 uint8_t dsap; 126 /** Source Service Access Point identifier. 124 125 /** 126 * Source Service Access Point identifier. 127 127 * The possible values are assigned by an IEEE committee. 128 128 */ 129 129 uint8_t ssap; 130 /** Control parameter. 130 131 /** 132 * Control parameter. 131 133 * The possible values are assigned by an IEEE committee. 132 134 */ … … 134 136 } __attribute__ ((packed)); 135 137 136 /** Ethernet header SNAP extension. 137 */ 138 struct eth_snap{ 139 /** Protocol identifier or organization code. 140 */ 138 /** Ethernet header SNAP extension. */ 139 struct eth_snap { 140 /** Protocol identifier or organization code. */ 141 141 uint8_t protocol[3]; 142 /** Ethernet protocol identifier in the network byte order (big endian). 143 * @see ethernet_protocols.h 142 143 /** 144 * Ethernet protocol identifier in the network byte order (big endian). 145 * @see ethernet_protocols.h 144 146 */ 145 147 uint16_t ethertype; … … 147 149 148 150 /** Ethernet header preamble. 149 * Used for dummy devices. 150 */ 151 struct eth_preamble{ 152 /** Controlling preamble used for the frame transmission synchronization. 153 * All should be set to ETH_PREAMBLE. 151 * 152 * Used for dummy devices. 153 */ 154 struct eth_preamble { 155 /** 156 * Controlling preamble used for the frame transmission synchronization. 157 * All should be set to ETH_PREAMBLE. 154 158 */ 155 159 uint8_t preamble[7]; 156 /** Start of Frame Delimiter used for the frame transmission synchronization. 157 * Should be set to ETH_SFD. 160 161 /** 162 * Start of Frame Delimiter used for the frame transmission 163 * synchronization. 164 * Should be set to ETH_SFD. 158 165 */ 159 166 uint8_t sfd; 160 167 } __attribute__ ((packed)); 161 168 162 /** Ethernet header. 163 */ 164 struct eth_header{ 165 /** Destination host Ethernet address (MAC address). 166 */ 169 /** Ethernet header. */ 170 struct eth_header { 171 /** Destination host Ethernet address (MAC address). */ 167 172 uint8_t destination_address[ETH_ADDR]; 168 /** Source host Ethernet address (MAC address). 169 */ 173 /** Source host Ethernet address (MAC address). */ 170 174 uint8_t source_address[ETH_ADDR]; 171 /** Ethernet protocol identifier in the network byte order (big endian). 172 * @see ethernet_protocols.h 175 176 /** 177 * Ethernet protocol identifier in the network byte order (big endian). 178 * @see ethernet_protocols.h 173 179 */ 174 180 uint16_t ethertype; 175 181 } __attribute__ ((packed)); 176 182 177 /** Ethernet header IEEE 802.3 + 802.2 extension. 178 */ 179 struct eth_header_lsap{ 180 /** Ethernet header. 181 */ 183 /** Ethernet header IEEE 802.3 + 802.2 extension. */ 184 struct eth_header_lsap { 185 /** Ethernet header. */ 182 186 eth_header_t header; 183 /** LSAP extension. 184 * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being used. 185 * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet without any extensions is being used and the frame content starts rigth after the two fields. 187 188 /** 189 * LSAP extension. 190 * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being 191 * used. 192 * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet 193 * without any extensions is being used and the frame content starts 194 * rigth after the two fields. 186 195 */ 187 196 eth_ieee_lsap_t lsap; 188 197 } __attribute__ ((packed)); 189 198 190 /** Ethernet header IEEE 802.3 + 802.2 + SNAP extensions. 191 */ 192 struct eth_header_snap{ 193 /** Ethernet header. 194 */ 199 /** Ethernet header IEEE 802.3 + 802.2 + SNAP extensions. */ 200 struct eth_header_snap { 201 /** Ethernet header. */ 195 202 eth_header_t header; 196 /** LSAP extension. 197 * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being used. 198 * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet without any extensions is being used and the frame content starts rigth after the two fields. 203 204 /** 205 * LSAP extension. 206 * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being 207 * used. 208 * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet 209 * without any extensions is being used and the frame content starts 210 * rigth after the two fields. 199 211 */ 200 212 eth_ieee_lsap_t lsap; 201 /** SNAP extension.202 */213 214 /** SNAP extension. */ 203 215 eth_snap_t snap; 204 216 } __attribute__ ((packed)); 205 217 206 /** Ethernet Frame Check Sequence. 207 */ 208 typedef uint32_t eth_fcs_t; 209 210 /** Ethernet Frame Check Sequence pointer. 211 */ 212 typedef eth_fcs_t * eth_fcs_ref; 218 /** Ethernet Frame Check Sequence. */ 219 typedef uint32_t eth_fcs_t; 220 221 /** Ethernet Frame Check Sequence pointer. */ 222 typedef eth_fcs_t *eth_fcs_ref; 213 223 214 224 #endif -
uspace/srv/net/nil/eth/eth_module.c
re7f6389 rf2d2c604 36 36 */ 37 37 38 #include "eth.h" 39 38 40 #include <async.h> 39 41 #include <stdio.h> … … 48 50 #include <nil_local.h> 49 51 50 #include "eth.h"51 52 52 int nil_module_start_standalone(async_client_conn_t client_connection) 53 53 { … … 59 59 60 60 ipcarg_t phonehash; 61 if (ERROR_OCCURRED(nil_initialize(net_phone)) 62 ||ERROR_OCCURRED(REGISTER_ME(SERVICE_ETHERNET, &phonehash))) {61 if (ERROR_OCCURRED(nil_initialize(net_phone)) || 62 ERROR_OCCURRED(REGISTER_ME(SERVICE_ETHERNET, &phonehash))) { 63 63 pm_destroy(); 64 64 return ERROR_CODE; … … 71 71 } 72 72 73 int nil_module_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call, 74 ipc_call_t *answer, int *answer_count) 73 int 74 nil_module_message_standalone(const char *name, ipc_callid_t callid, 75 ipc_call_t *call, ipc_call_t *answer, int *answer_count) 75 76 { 76 77 return nil_message_standalone(name, callid, call, answer, answer_count); -
uspace/srv/net/nil/nildummy/nildummy.h
re7f6389 rf2d2c604 28 28 29 29 /** @addtogroup nildummy 30 * 30 * @{ 31 31 */ 32 32 33 33 /** @file 34 * 34 * Dummy network interface layer module. 35 35 */ 36 36 37 #ifndef __NET_NILDUMMY_H__38 #define __NET_NILDUMMY_H__37 #ifndef NET_NILDUMMY_H_ 38 #define NET_NILDUMMY_H_ 39 39 40 40 #include <fibril_synch.h> … … 45 45 46 46 /** Type definition of the dummy nil global data. 47 * 47 * @see nildummy_globals 48 48 */ 49 typedef struct nildummy_globals 49 typedef struct nildummy_globals nildummy_globals_t; 50 50 51 51 /** Type definition of the dummy nil device specific data. 52 * 52 * @see nildummy_device 53 53 */ 54 typedef struct nildummy_device 54 typedef struct nildummy_device nildummy_device_t; 55 55 56 56 /** Type definition of the dummy nil device specific data pointer. 57 * 57 * @see nildummy_device 58 58 */ 59 typedef nildummy_device_t * 59 typedef nildummy_device_t *nildummy_device_ref; 60 60 61 61 /** Type definition of the dummy nil protocol specific data. 62 * 62 * @see nildummy_proto 63 63 */ 64 64 typedef struct nildummy_proto nildummy_proto_t; 65 65 66 66 /** Type definition of the dummy nil protocol specific data pointer. 67 * 67 * @see nildummy_proto 68 68 */ 69 typedef nildummy_proto_t * 69 typedef nildummy_proto_t *nildummy_proto_ref; 70 70 71 71 /** Dummy nil device map. 72 * 73 * 72 * Maps devices to the dummy nil device specific data. 73 * @see device.h 74 74 */ 75 DEVICE_MAP_DECLARE(nildummy_devices, nildummy_device_t) 75 DEVICE_MAP_DECLARE(nildummy_devices, nildummy_device_t); 76 76 77 /** Dummy nil device specific data. 78 */ 79 struct nildummy_device{ 80 /** Device identifier. 81 */ 77 /** Dummy nil device specific data. */ 78 struct nildummy_device { 79 /** Device identifier. */ 82 80 device_id_t device_id; 83 /** Device driver service. 84 */ 81 /** Device driver service. */ 85 82 services_t service; 86 /** Driver phone. 87 */ 83 /** Driver phone. */ 88 84 int phone; 89 /** Maximal transmission unit. 90 */ 85 /** Maximal transmission unit. */ 91 86 size_t mtu; 92 /** Actual device hardware address. 93 */ 87 /** Actual device hardware address. */ 94 88 measured_string_ref addr; 95 /** Actual device hardware address data. 96 */ 97 char * addr_data; 89 /** Actual device hardware address data. */ 90 char *addr_data; 98 91 }; 99 92 100 /** Dummy nil protocol specific data. 101 */ 102 struct nildummy_proto{ 103 /** Protocol service. 104 */ 93 /** Dummy nil protocol specific data. */ 94 struct nildummy_proto { 95 /** Protocol service. */ 105 96 services_t service; 106 /** Protocol module phone. 107 */ 97 /** Protocol module phone. */ 108 98 int phone; 109 99 }; 110 100 111 /** Dummy nil global data. 112 */ 113 struct nildummy_globals{ 114 /** Networking module phone. 115 */ 101 /** Dummy nil global data. */ 102 struct nildummy_globals { 103 /** Networking module phone. */ 116 104 int net_phone; 117 /** Safety lock for devices. 118 */ 105 /** Safety lock for devices. */ 119 106 fibril_rwlock_t devices_lock; 120 /** All known Ethernet devices. 121 */ 107 /** All known Ethernet devices. */ 122 108 nildummy_devices_t devices; 123 /** Safety lock for protocols. 124 */ 109 /** Safety lock for protocols. */ 125 110 fibril_rwlock_t protos_lock; 126 /** Default protocol. 127 */ 111 /** Default protocol. */ 128 112 nildummy_proto_t proto; 129 113 }; -
uspace/srv/net/nil/nildummy/nildummy_module.c
re7f6389 rf2d2c604 59 59 60 60 ipcarg_t phonehash; 61 if (ERROR_OCCURRED(nil_initialize(net_phone)) 62 || ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))){61 if (ERROR_OCCURRED(nil_initialize(net_phone)) || 62 ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))) { 63 63 pm_destroy(); 64 64 return ERROR_CODE; … … 71 71 } 72 72 73 int nil_module_message_standalone(const char *name, ipc_callid_t callid, 73 int 74 nil_module_message_standalone(const char *name, ipc_callid_t callid, 74 75 ipc_call_t *call, ipc_call_t *answer, int *answer_count) 75 76 {
Note:
See TracChangeset
for help on using the changeset viewer.
