Changes in uspace/srv/net/il/ip/ip.c [7880d58:014dd57b] in mainline
- File:
-
- 1 edited
-
uspace/srv/net/il/ip/ip.c (modified) (33 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/net/il/ip/ip.c
r7880d58 r014dd57b 35 35 * @see arp.h 36 36 */ 37 38 #include "ip.h"39 #include "ip_module.h"40 37 41 38 #include <async.h> … … 52 49 #include <sys/types.h> 53 50 #include <byteorder.h> 51 #include "ip.h" 54 52 55 53 #include <adt/measured_strings.h> … … 70 68 #include <icmp_client.h> 71 69 #include <icmp_interface.h> 72 #include <il_interface.h>73 70 #include <ip_client.h> 74 71 #include <ip_interface.h> 75 72 #include <ip_header.h> 76 73 #include <net_interface.h> 77 #include <nil_ interface.h>78 #include <tl_ interface.h>74 #include <nil_remote.h> 75 #include <tl_remote.h> 79 76 #include <packet_remote.h> 80 #include <il_local.h> 77 #include <il_remote.h> 78 #include <il_skel.h> 81 79 82 80 /** IP module name. */ … … 122 120 INT_MAP_IMPLEMENT(ip_protos, ip_proto_t); 123 121 GENERIC_FIELD_IMPLEMENT(ip_routes, ip_route_t); 122 123 static void ip_receiver(ipc_callid_t, ipc_call_t *); 124 124 125 125 /** Releases the packet and returns the result. … … 244 244 } 245 245 246 /** Initializes the IP module. 247 * 248 * @param[in] client_connection The client connection processing function. The 249 * module skeleton propagates its own one. 250 * @return EOK on success. 251 * @return ENOMEM if there is not enough memory left. 252 */ 253 int ip_initialize(async_client_conn_t client_connection) 254 { 255 int rc; 256 246 int il_initialize(int net_phone) 247 { 257 248 fibril_rwlock_initialize(&ip_globals.lock); 258 249 fibril_rwlock_write_lock(&ip_globals.lock); 259 250 fibril_rwlock_initialize(&ip_globals.protos_lock); 260 251 fibril_rwlock_initialize(&ip_globals.netifs_lock); 252 253 ip_globals.net_phone = net_phone; 261 254 ip_globals.packet_counter = 0; 262 255 ip_globals.gateway.address.s_addr = 0; … … 264 257 ip_globals.gateway.gateway.s_addr = 0; 265 258 ip_globals.gateway.netif = NULL; 266 ip_globals.client_connection = client_connection; 267 268 rc = ip_netifs_initialize(&ip_globals.netifs); 259 260 int rc = ip_netifs_initialize(&ip_globals.netifs); 269 261 if (rc != EOK) 270 262 goto out; … … 275 267 if (rc != EOK) 276 268 goto out; 277 rc = add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME,278 SERVICE_ARP, 0, arp_connect_module);269 rc = add_module(NULL, &ip_globals.modules, (uint8_t *) ARP_NAME, 270 (uint8_t *) ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module); 279 271 280 272 out: … … 312 304 measured_string_t names[] = { 313 305 { 314 ( char*) "IPV",306 (uint8_t *) "IPV", 315 307 3 316 308 }, 317 309 { 318 ( char*) "IP_CONFIG",310 (uint8_t *) "IP_CONFIG", 319 311 9 320 312 }, 321 313 { 322 ( char*) "IP_ADDR",314 (uint8_t *) "IP_ADDR", 323 315 7 324 316 }, 325 317 { 326 ( char*) "IP_NETMASK",318 (uint8_t *) "IP_NETMASK", 327 319 10 328 320 }, 329 321 { 330 ( char*) "IP_GATEWAY",322 (uint8_t *) "IP_GATEWAY", 331 323 10 332 324 }, 333 325 { 334 ( char*) "IP_BROADCAST",326 (uint8_t *) "IP_BROADCAST", 335 327 12 336 328 }, 337 329 { 338 ( char*) "ARP",330 (uint8_t *) "ARP", 339 331 3 340 332 }, 341 333 { 342 ( char*) "IP_ROUTING",334 (uint8_t *) "IP_ROUTING", 343 335 10 344 336 } … … 346 338 measured_string_t *configuration; 347 339 size_t count = sizeof(names) / sizeof(measured_string_t); 348 char*data;340 uint8_t *data; 349 341 measured_string_t address; 350 342 ip_route_t *route; … … 368 360 if (configuration) { 369 361 if (configuration[0].value) 370 ip_netif->ipv = strtol( configuration[0].value, NULL, 0);371 372 ip_netif->dhcp = !str_lcmp( configuration[1].value, "dhcp",362 ip_netif->ipv = strtol((char *) configuration[0].value, NULL, 0); 363 364 ip_netif->dhcp = !str_lcmp((char *) configuration[1].value, "dhcp", 373 365 configuration[1].length); 374 366 … … 394 386 } 395 387 396 if ((inet_pton(AF_INET, configuration[2].value,388 if ((inet_pton(AF_INET, (char *) configuration[2].value, 397 389 (uint8_t *) &route->address.s_addr) != EOK) || 398 (inet_pton(AF_INET, configuration[3].value,390 (inet_pton(AF_INET, (char *) configuration[3].value, 399 391 (uint8_t *) &route->netmask.s_addr) != EOK) || 400 (inet_pton(AF_INET, configuration[4].value,392 (inet_pton(AF_INET, (char *) configuration[4].value, 401 393 (uint8_t *) &gateway.s_addr) == EINVAL) || 402 (inet_pton(AF_INET, configuration[5].value,394 (inet_pton(AF_INET, (char *) configuration[5].value, 403 395 (uint8_t *) &ip_netif->broadcast.s_addr) == EINVAL)) 404 396 { … … 431 423 ip_netif->phone = nil_bind_service(ip_netif->service, 432 424 (sysarg_t) ip_netif->device_id, SERVICE_IP, 433 ip_ globals.client_connection);425 ip_receiver); 434 426 if (ip_netif->phone < 0) { 435 427 printf("Failed to contact the nil service %d\n", … … 441 433 if (ip_netif->arp) { 442 434 if (route) { 443 address.value = ( char*) &route->address.s_addr;435 address.value = (uint8_t *) &route->address.s_addr; 444 436 address.length = sizeof(in_addr_t); 445 437 … … 477 469 ip_globals.gateway.gateway.s_addr = gateway.s_addr; 478 470 ip_globals.gateway.netif = ip_netif; 471 472 char defgateway[INET_ADDRSTRLEN]; 473 inet_ntop(AF_INET, (uint8_t *) &gateway.s_addr, 474 defgateway, INET_ADDRSTRLEN); 475 printf("%s: Default gateway (%s)\n", NAME, defgateway); 479 476 } 480 477 … … 482 479 } 483 480 484 /** Updates the device content length according to the new MTU value. 485 * 486 * @param[in] device_id The device identifier. 487 * @param[in] mtu The new mtu value. 488 * @return EOK on success. 489 * @return ENOENT if device is not found. 490 */ 491 static int ip_mtu_changed_message(device_id_t device_id, size_t mtu) 492 { 481 static int ip_device_req_local(int il_phone, device_id_t device_id, 482 services_t netif) 483 { 484 ip_netif_t *ip_netif; 485 ip_route_t *route; 486 int index; 487 int rc; 488 489 ip_netif = (ip_netif_t *) malloc(sizeof(ip_netif_t)); 490 if (!ip_netif) 491 return ENOMEM; 492 493 rc = ip_routes_initialize(&ip_netif->routes); 494 if (rc != EOK) { 495 free(ip_netif); 496 return rc; 497 } 498 499 ip_netif->device_id = device_id; 500 ip_netif->service = netif; 501 ip_netif->state = NETIF_STOPPED; 502 503 fibril_rwlock_write_lock(&ip_globals.netifs_lock); 504 505 rc = ip_netif_initialize(ip_netif); 506 if (rc != EOK) { 507 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 508 ip_routes_destroy(&ip_netif->routes); 509 free(ip_netif); 510 return rc; 511 } 512 if (ip_netif->arp) 513 ip_netif->arp->usage++; 514 515 // print the settings 516 printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n", 517 NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv, 518 ip_netif->dhcp ? "dhcp" : "static"); 519 520 // TODO ipv6 addresses 521 522 char address[INET_ADDRSTRLEN]; 523 char netmask[INET_ADDRSTRLEN]; 524 char gateway[INET_ADDRSTRLEN]; 525 526 for (index = 0; index < ip_routes_count(&ip_netif->routes); index++) { 527 route = ip_routes_get_index(&ip_netif->routes, index); 528 if (route) { 529 inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr, 530 address, INET_ADDRSTRLEN); 531 inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr, 532 netmask, INET_ADDRSTRLEN); 533 inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr, 534 gateway, INET_ADDRSTRLEN); 535 printf("%s: Route %d (address: %s, netmask: %s, " 536 "gateway: %s)\n", NAME, index, address, netmask, 537 gateway); 538 } 539 } 540 541 inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, address, 542 INET_ADDRSTRLEN); 543 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 544 545 printf("%s: Broadcast (%s)\n", NAME, address); 546 547 return EOK; 548 } 549 550 /** Searches the network interfaces if there is a suitable route. 551 * 552 * @param[in] netif The network interface to be searched for routes. May be 553 * NULL. 554 * @param[in] destination The destination address. 555 * @return The found route. 556 * @return NULL if no route was found. 557 */ 558 static ip_route_t *ip_netif_find_route(ip_netif_t *netif, 559 in_addr_t destination) 560 { 561 int index; 562 ip_route_t *route; 563 564 if (!netif) 565 return NULL; 566 567 /* Start with the first one (the direct route) */ 568 for (index = 0; index < ip_routes_count(&netif->routes); index++) { 569 route = ip_routes_get_index(&netif->routes, index); 570 if ((route) && 571 ((route->address.s_addr & route->netmask.s_addr) == 572 (destination.s_addr & route->netmask.s_addr))) 573 return route; 574 } 575 576 return NULL; 577 } 578 579 /** Searches all network interfaces if there is a suitable route. 580 * 581 * @param[in] destination The destination address. 582 * @return The found route. 583 * @return NULL if no route was found. 584 */ 585 static ip_route_t *ip_find_route(in_addr_t destination) { 586 int index; 587 ip_route_t *route; 493 588 ip_netif_t *netif; 494 589 495 fibril_rwlock_write_lock(&ip_globals.netifs_lock); 496 netif = ip_netifs_find(&ip_globals.netifs, device_id); 497 if (!netif) { 498 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 499 return ENOENT; 500 } 501 netif->packet_dimension.content = mtu; 502 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 503 504 printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu); 505 506 return EOK; 507 } 508 509 /** Updates the device state. 510 * 511 * @param[in] device_id The device identifier. 512 * @param[in] state The new state value. 513 * @return EOK on success. 514 * @return ENOENT if device is not found. 515 */ 516 static int ip_device_state_message(device_id_t device_id, device_state_t state) 517 { 518 ip_netif_t *netif; 519 520 fibril_rwlock_write_lock(&ip_globals.netifs_lock); 521 // find the device 522 netif = ip_netifs_find(&ip_globals.netifs, device_id); 523 if (!netif) { 524 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 525 return ENOENT; 526 } 527 netif->state = state; 528 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 529 530 printf("%s: Device %d changed state to %d\n", NAME, device_id, state); 531 532 return EOK; 533 } 534 535 536 /** Prefixes a middle fragment header based on the last fragment header to the 537 * packet. 538 * 539 * @param[in] packet The packet to be prefixed. 540 * @param[in] last The last header to be copied. 541 * @return The prefixed middle header. 542 * @return NULL on error. 543 */ 544 static ip_header_t * 545 ip_create_middle_header(packet_t *packet, ip_header_t *last) 546 { 547 ip_header_t *middle; 548 549 middle = (ip_header_t *) packet_suffix(packet, IP_HEADER_LENGTH(last)); 550 if (!middle) 551 return NULL; 552 memcpy(middle, last, IP_HEADER_LENGTH(last)); 553 middle->flags |= IPFLAG_MORE_FRAGMENTS; 554 return middle; 590 // start with the last netif - the newest one 591 index = ip_netifs_count(&ip_globals.netifs) - 1; 592 while (index >= 0) { 593 netif = ip_netifs_get_index(&ip_globals.netifs, index); 594 if (netif && (netif->state == NETIF_ACTIVE)) { 595 route = ip_netif_find_route(netif, destination); 596 if (route) 597 return route; 598 } 599 index--; 600 } 601 602 return &ip_globals.gateway; 603 } 604 605 /** Returns the network interface's IP address. 606 * 607 * @param[in] netif The network interface. 608 * @return The IP address. 609 * @return NULL if no IP address was found. 610 */ 611 static in_addr_t *ip_netif_address(ip_netif_t *netif) 612 { 613 ip_route_t *route; 614 615 route = ip_routes_get_index(&netif->routes, 0); 616 return route ? &route->address : NULL; 555 617 } 556 618 … … 621 683 * function. 622 684 */ 623 static int 624 ip_prepare_packet(in_addr_t *source, in_addr_t dest, packet_t *packet, 625 measured_string_t *destination) 685 static int ip_prepare_packet(in_addr_t *source, in_addr_t dest, 686 packet_t *packet, measured_string_t *destination) 626 687 { 627 688 size_t length; … … 752 813 * function. 753 814 */ 754 static int 755 ip_fragment_packet_data(packet_t *packet, packet_t *new_packet, 815 static int ip_fragment_packet_data(packet_t *packet, packet_t *new_packet, 756 816 ip_header_t *header, ip_header_t *new_header, size_t length, 757 817 const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen) … … 787 847 788 848 return pq_insert_after(packet, new_packet); 849 } 850 851 /** Prefixes a middle fragment header based on the last fragment header to the 852 * packet. 853 * 854 * @param[in] packet The packet to be prefixed. 855 * @param[in] last The last header to be copied. 856 * @return The prefixed middle header. 857 * @return NULL on error. 858 */ 859 static ip_header_t *ip_create_middle_header(packet_t *packet, 860 ip_header_t *last) 861 { 862 ip_header_t *middle; 863 864 middle = (ip_header_t *) packet_suffix(packet, IP_HEADER_LENGTH(last)); 865 if (!middle) 866 return NULL; 867 memcpy(middle, last, IP_HEADER_LENGTH(last)); 868 middle->flags |= IPFLAG_MORE_FRAGMENTS; 869 return middle; 789 870 } 790 871 … … 991 1072 * function. 992 1073 */ 993 static int 994 ip_send_route(packet_t *packet, ip_netif_t *netif, ip_route_t *route, 995 in_addr_t *src, in_addr_t dest, services_t error) 1074 static int ip_send_route(packet_t *packet, ip_netif_t *netif, 1075 ip_route_t *route, in_addr_t *src, in_addr_t dest, services_t error) 996 1076 { 997 1077 measured_string_t destination; 998 1078 measured_string_t *translation; 999 char*data;1079 uint8_t *data; 1000 1080 int phone; 1001 1081 int rc; … … 1004 1084 if (netif->arp && (route->address.s_addr != dest.s_addr)) { 1005 1085 destination.value = route->gateway.s_addr ? 1006 ( char *) &route->gateway.s_addr : (char*) &dest.s_addr;1086 (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr; 1007 1087 destination.length = sizeof(dest.s_addr); 1008 1088 … … 1056 1136 } 1057 1137 1058 /** Searches the network interfaces if there is a suitable route. 1059 * 1060 * @param[in] netif The network interface to be searched for routes. May be 1061 * NULL. 1062 * @param[in] destination The destination address. 1063 * @return The found route. 1064 * @return NULL if no route was found. 1065 */ 1066 static ip_route_t * 1067 ip_netif_find_route(ip_netif_t *netif, in_addr_t destination) 1068 { 1069 int index; 1070 ip_route_t *route; 1071 1072 if (!netif) 1073 return NULL; 1074 1075 // start with the first one - the direct route 1076 for (index = 0; index < ip_routes_count(&netif->routes); index++) { 1077 route = ip_routes_get_index(&netif->routes, index); 1078 if (route && 1079 ((route->address.s_addr & route->netmask.s_addr) == 1080 (destination.s_addr & route->netmask.s_addr))) { 1081 return route; 1082 } 1083 } 1084 1085 return NULL; 1086 } 1087 1088 /** Searches all network interfaces if there is a suitable route. 1089 * 1090 * @param[in] destination The destination address. 1091 * @return The found route. 1092 * @return NULL if no route was found. 1093 */ 1094 static ip_route_t *ip_find_route(in_addr_t destination) { 1095 int index; 1096 ip_route_t *route; 1097 ip_netif_t *netif; 1098 1099 // start with the last netif - the newest one 1100 index = ip_netifs_count(&ip_globals.netifs) - 1; 1101 while (index >= 0) { 1102 netif = ip_netifs_get_index(&ip_globals.netifs, index); 1103 if (netif && (netif->state == NETIF_ACTIVE)) { 1104 route = ip_netif_find_route(netif, destination); 1105 if (route) 1106 return route; 1107 } 1108 index--; 1109 } 1110 1111 return &ip_globals.gateway; 1112 } 1113 1114 /** Returns the network interface's IP address. 1115 * 1116 * @param[in] netif The network interface. 1117 * @return The IP address. 1118 * @return NULL if no IP address was found. 1119 */ 1120 static in_addr_t *ip_netif_address(ip_netif_t *netif) 1121 { 1122 ip_route_t *route; 1123 1124 route = ip_routes_get_index(&netif->routes, 0); 1125 return route ? &route->address : NULL; 1126 } 1127 1128 /** Registers the transport layer protocol. 1129 * 1130 * The traffic of this protocol will be supplied using either the receive 1131 * function or IPC message. 1132 * 1133 * @param[in] protocol The transport layer module protocol. 1134 * @param[in] service The transport layer module service. 1135 * @param[in] phone The transport layer module phone. 1136 * @param[in] received_msg The receiving function. 1137 * @return EOK on success. 1138 * @return EINVAL if the protocol parameter and/or the service 1139 * parameter is zero. 1140 * @return EINVAL if the phone parameter is not a positive number 1141 * and the tl_receive_msg is NULL. 1142 * @return ENOMEM if there is not enough memory left. 1143 */ 1144 static int 1145 ip_register(int protocol, services_t service, int phone, 1146 tl_received_msg_t received_msg) 1147 { 1148 ip_proto_t *proto; 1149 int index; 1150 1151 if (!protocol || !service || ((phone < 0) && !received_msg)) 1152 return EINVAL; 1153 1154 proto = (ip_proto_t *) malloc(sizeof(ip_protos_t)); 1155 if (!proto) 1156 return ENOMEM; 1157 1158 proto->protocol = protocol; 1159 proto->service = service; 1160 proto->phone = phone; 1161 proto->received_msg = received_msg; 1162 1163 fibril_rwlock_write_lock(&ip_globals.protos_lock); 1164 index = ip_protos_add(&ip_globals.protos, proto->protocol, proto); 1165 if (index < 0) { 1166 fibril_rwlock_write_unlock(&ip_globals.protos_lock); 1167 free(proto); 1168 return index; 1169 } 1170 fibril_rwlock_write_unlock(&ip_globals.protos_lock); 1171 1172 printf("%s: Protocol registered (protocol: %d, phone: %d)\n", 1173 NAME, proto->protocol, proto->phone); 1174 1175 return EOK; 1176 } 1177 1178 static int 1179 ip_device_req_local(int il_phone, device_id_t device_id, services_t netif) 1180 { 1181 ip_netif_t *ip_netif; 1182 ip_route_t *route; 1183 int index; 1184 int rc; 1185 1186 ip_netif = (ip_netif_t *) malloc(sizeof(ip_netif_t)); 1187 if (!ip_netif) 1188 return ENOMEM; 1189 1190 rc = ip_routes_initialize(&ip_netif->routes); 1191 if (rc != EOK) { 1192 free(ip_netif); 1193 return rc; 1194 } 1195 1196 ip_netif->device_id = device_id; 1197 ip_netif->service = netif; 1198 ip_netif->state = NETIF_STOPPED; 1199 1200 fibril_rwlock_write_lock(&ip_globals.netifs_lock); 1201 1202 rc = ip_netif_initialize(ip_netif); 1203 if (rc != EOK) { 1204 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 1205 ip_routes_destroy(&ip_netif->routes); 1206 free(ip_netif); 1207 return rc; 1208 } 1209 if (ip_netif->arp) 1210 ip_netif->arp->usage++; 1211 1212 // print the settings 1213 printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n", 1214 NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv, 1215 ip_netif->dhcp ? "dhcp" : "static"); 1216 1217 // TODO ipv6 addresses 1218 1219 char address[INET_ADDRSTRLEN]; 1220 char netmask[INET_ADDRSTRLEN]; 1221 char gateway[INET_ADDRSTRLEN]; 1222 1223 for (index = 0; index < ip_routes_count(&ip_netif->routes); index++) { 1224 route = ip_routes_get_index(&ip_netif->routes, index); 1225 if (route) { 1226 inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr, 1227 address, INET_ADDRSTRLEN); 1228 inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr, 1229 netmask, INET_ADDRSTRLEN); 1230 inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr, 1231 gateway, INET_ADDRSTRLEN); 1232 printf("%s: Route %d (address: %s, netmask: %s, " 1233 "gateway: %s)\n", NAME, index, address, netmask, 1234 gateway); 1235 } 1236 } 1237 1238 inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, address, 1239 INET_ADDRSTRLEN); 1240 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 1241 1242 printf("%s: Broadcast (%s)\n", NAME, address); 1243 1244 return EOK; 1245 } 1246 1247 static int 1248 ip_send_msg_local(int il_phone, device_id_t device_id, packet_t *packet, 1249 services_t sender, services_t error) 1138 static int ip_send_msg_local(int il_phone, device_id_t device_id, 1139 packet_t *packet, services_t sender, services_t error) 1250 1140 { 1251 1141 int addrlen; … … 1288 1178 if (device_id > 0) { 1289 1179 netif = ip_netifs_find(&ip_globals.netifs, device_id); 1290 route = ip_netif_find_route(netif, * 1180 route = ip_netif_find_route(netif, *dest); 1291 1181 if (netif && !route && (ip_globals.gateway.netif == netif)) 1292 1182 route = &ip_globals.gateway; … … 1318 1208 } 1319 1209 } 1320 1210 1321 1211 // if the local host is the destination 1322 1212 if ((route->address.s_addr == dest->s_addr) && … … 1351 1241 } 1352 1242 1243 /** Updates the device state. 1244 * 1245 * @param[in] device_id The device identifier. 1246 * @param[in] state The new state value. 1247 * @return EOK on success. 1248 * @return ENOENT if device is not found. 1249 */ 1250 static int ip_device_state_message(device_id_t device_id, device_state_t state) 1251 { 1252 ip_netif_t *netif; 1253 1254 fibril_rwlock_write_lock(&ip_globals.netifs_lock); 1255 // find the device 1256 netif = ip_netifs_find(&ip_globals.netifs, device_id); 1257 if (!netif) { 1258 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 1259 return ENOENT; 1260 } 1261 netif->state = state; 1262 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 1263 1264 printf("%s: Device %d changed state to %d\n", NAME, device_id, state); 1265 1266 return EOK; 1267 } 1268 1269 /** Returns the packet destination address from the IP header. 1270 * 1271 * @param[in] header The packet IP header to be read. 1272 * @return The packet destination address. 1273 */ 1274 static in_addr_t ip_get_destination(ip_header_t *header) 1275 { 1276 in_addr_t destination; 1277 1278 // TODO search set ipopt route? 1279 destination.s_addr = header->destination_address; 1280 return destination; 1281 } 1282 1283 /** Delivers the packet to the local host. 1284 * 1285 * The packet is either passed to another module or released on error. 1286 * The ICMP_PROT_UNREACH error notification may be sent if the protocol is not 1287 * found. 1288 * 1289 * @param[in] device_id The source device identifier. 1290 * @param[in] packet The packet to be delivered. 1291 * @param[in] header The first packet IP header. May be NULL. 1292 * @param[in] error The packet error service. 1293 * @return EOK on success. 1294 * @return ENOTSUP if the packet is a fragment. 1295 * @return EAFNOSUPPORT if the address family is not supported. 1296 * @return ENOENT if the target protocol is not found. 1297 * @return Other error codes as defined for the packet_set_addr() 1298 * function. 1299 * @return Other error codes as defined for the packet_trim() 1300 * function. 1301 * @return Other error codes as defined for the protocol specific 1302 * tl_received_msg() function. 1303 */ 1304 static int ip_deliver_local(device_id_t device_id, packet_t *packet, 1305 ip_header_t *header, services_t error) 1306 { 1307 ip_proto_t *proto; 1308 int phone; 1309 services_t service; 1310 tl_received_msg_t received_msg; 1311 struct sockaddr *src; 1312 struct sockaddr *dest; 1313 struct sockaddr_in src_in; 1314 struct sockaddr_in dest_in; 1315 socklen_t addrlen; 1316 int rc; 1317 1318 if ((header->flags & IPFLAG_MORE_FRAGMENTS) || 1319 IP_FRAGMENT_OFFSET(header)) { 1320 // TODO fragmented 1321 return ENOTSUP; 1322 } 1323 1324 switch (header->version) { 1325 case IPVERSION: 1326 addrlen = sizeof(src_in); 1327 bzero(&src_in, addrlen); 1328 src_in.sin_family = AF_INET; 1329 memcpy(&dest_in, &src_in, addrlen); 1330 memcpy(&src_in.sin_addr.s_addr, &header->source_address, 1331 sizeof(header->source_address)); 1332 memcpy(&dest_in.sin_addr.s_addr, &header->destination_address, 1333 sizeof(header->destination_address)); 1334 src = (struct sockaddr *) &src_in; 1335 dest = (struct sockaddr *) &dest_in; 1336 break; 1337 1338 default: 1339 return ip_release_and_return(packet, EAFNOSUPPORT); 1340 } 1341 1342 rc = packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest, 1343 addrlen); 1344 if (rc != EOK) 1345 return ip_release_and_return(packet, rc); 1346 1347 // trim padding if present 1348 if (!error && 1349 (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) { 1350 rc = packet_trim(packet, 0, 1351 packet_get_data_length(packet) - IP_TOTAL_LENGTH(header)); 1352 if (rc != EOK) 1353 return ip_release_and_return(packet, rc); 1354 } 1355 1356 fibril_rwlock_read_lock(&ip_globals.protos_lock); 1357 1358 proto = ip_protos_find(&ip_globals.protos, header->protocol); 1359 if (!proto) { 1360 fibril_rwlock_read_unlock(&ip_globals.protos_lock); 1361 phone = ip_prepare_icmp_and_get_phone(error, packet, header); 1362 if (phone >= 0) { 1363 // unreachable ICMP 1364 icmp_destination_unreachable_msg(phone, 1365 ICMP_PROT_UNREACH, 0, packet); 1366 } 1367 return ENOENT; 1368 } 1369 1370 if (proto->received_msg) { 1371 service = proto->service; 1372 received_msg = proto->received_msg; 1373 fibril_rwlock_read_unlock(&ip_globals.protos_lock); 1374 rc = received_msg(device_id, packet, service, error); 1375 } else { 1376 rc = tl_received_msg(proto->phone, device_id, packet, 1377 proto->service, error); 1378 fibril_rwlock_read_unlock(&ip_globals.protos_lock); 1379 } 1380 1381 return rc; 1382 } 1383 1384 /** Processes the received packet. 1385 * 1386 * The packet is either passed to another module or released on error. 1387 * 1388 * The ICMP_PARAM_POINTER error notification may be sent if the checksum is 1389 * invalid. 1390 * The ICMP_EXC_TTL error notification may be sent if the TTL is less than two. 1391 * The ICMP_HOST_UNREACH error notification may be sent if no route was found. 1392 * The ICMP_HOST_UNREACH error notification may be sent if the packet is for 1393 * another host and the routing is disabled. 1394 * 1395 * @param[in] device_id The source device identifier. 1396 * @param[in] packet The received packet to be processed. 1397 * @return EOK on success. 1398 * @return EINVAL if the TTL is less than two. 1399 * @return EINVAL if the checksum is invalid. 1400 * @return EAFNOSUPPORT if the address family is not supported. 1401 * @return ENOENT if no route was found. 1402 * @return ENOENT if the packet is for another host and the routing 1403 * is disabled. 1404 */ 1405 static int ip_process_packet(device_id_t device_id, packet_t *packet) 1406 { 1407 ip_header_t *header; 1408 in_addr_t dest; 1409 ip_route_t *route; 1410 int phone; 1411 struct sockaddr *addr; 1412 struct sockaddr_in addr_in; 1413 socklen_t addrlen; 1414 int rc; 1415 1416 header = (ip_header_t *) packet_get_data(packet); 1417 if (!header) 1418 return ip_release_and_return(packet, ENOMEM); 1419 1420 // checksum 1421 if ((header->header_checksum) && 1422 (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) { 1423 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1424 if (phone >= 0) { 1425 // checksum error ICMP 1426 icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER, 1427 ((size_t) ((void *) &header->header_checksum)) - 1428 ((size_t) ((void *) header)), packet); 1429 } 1430 return EINVAL; 1431 } 1432 1433 if (header->ttl <= 1) { 1434 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1435 if (phone >= 0) { 1436 // ttl exceeded ICMP 1437 icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet); 1438 } 1439 return EINVAL; 1440 } 1441 1442 // process ipopt and get destination 1443 dest = ip_get_destination(header); 1444 1445 // set the addrination address 1446 switch (header->version) { 1447 case IPVERSION: 1448 addrlen = sizeof(addr_in); 1449 bzero(&addr_in, addrlen); 1450 addr_in.sin_family = AF_INET; 1451 memcpy(&addr_in.sin_addr.s_addr, &dest, sizeof(dest)); 1452 addr = (struct sockaddr *) &addr_in; 1453 break; 1454 1455 default: 1456 return ip_release_and_return(packet, EAFNOSUPPORT); 1457 } 1458 1459 rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen); 1460 if (rc != EOK) 1461 return rc; 1462 1463 route = ip_find_route(dest); 1464 if (!route) { 1465 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1466 if (phone >= 0) { 1467 // unreachable ICMP 1468 icmp_destination_unreachable_msg(phone, 1469 ICMP_HOST_UNREACH, 0, packet); 1470 } 1471 return ENOENT; 1472 } 1473 1474 if (route->address.s_addr == dest.s_addr) { 1475 // local delivery 1476 return ip_deliver_local(device_id, packet, header, 0); 1477 } 1478 1479 if (route->netif->routing) { 1480 header->ttl--; 1481 return ip_send_route(packet, route->netif, route, NULL, dest, 1482 0); 1483 } 1484 1485 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1486 if (phone >= 0) { 1487 // unreachable ICMP if no routing 1488 icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0, 1489 packet); 1490 } 1491 1492 return ENOENT; 1493 } 1494 1353 1495 /** Returns the device packet dimensions for sending. 1354 1496 * … … 1362 1504 * @return EOK on success. 1363 1505 */ 1364 static int 1365 ip_packet_size_message(device_id_t device_id, size_t *addr_len, size_t *prefix, 1366 size_t *content, size_t *suffix) 1506 static int ip_packet_size_message(device_id_t device_id, size_t *addr_len, 1507 size_t *prefix, size_t *content, size_t *suffix) 1367 1508 { 1368 1509 ip_netif_t *netif; … … 1414 1555 } 1415 1556 1416 /** Returns the packet destination address from the IP header. 1417 * 1418 * @param[in] header The packet IP header to be read. 1419 * @return The packet destination address. 1420 */ 1421 static in_addr_t ip_get_destination(ip_header_t *header) 1422 { 1423 in_addr_t destination; 1424 1425 // TODO search set ipopt route? 1426 destination.s_addr = header->destination_address; 1427 return destination; 1428 } 1429 1430 /** Delivers the packet to the local host. 1431 * 1432 * The packet is either passed to another module or released on error. 1433 * The ICMP_PROT_UNREACH error notification may be sent if the protocol is not 1434 * found. 1435 * 1436 * @param[in] device_id The source device identifier. 1437 * @param[in] packet The packet to be delivered. 1438 * @param[in] header The first packet IP header. May be NULL. 1439 * @param[in] error The packet error service. 1557 /** Updates the device content length according to the new MTU value. 1558 * 1559 * @param[in] device_id The device identifier. 1560 * @param[in] mtu The new mtu value. 1440 1561 * @return EOK on success. 1441 * @return ENOTSUP if the packet is a fragment. 1442 * @return EAFNOSUPPORT if the address family is not supported. 1443 * @return ENOENT if the target protocol is not found. 1444 * @return Other error codes as defined for the packet_set_addr() 1445 * function. 1446 * @return Other error codes as defined for the packet_trim() 1447 * function. 1448 * @return Other error codes as defined for the protocol specific 1449 * tl_received_msg() function. 1562 * @return ENOENT if device is not found. 1563 */ 1564 static int ip_mtu_changed_message(device_id_t device_id, size_t mtu) 1565 { 1566 ip_netif_t *netif; 1567 1568 fibril_rwlock_write_lock(&ip_globals.netifs_lock); 1569 netif = ip_netifs_find(&ip_globals.netifs, device_id); 1570 if (!netif) { 1571 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 1572 return ENOENT; 1573 } 1574 netif->packet_dimension.content = mtu; 1575 fibril_rwlock_write_unlock(&ip_globals.netifs_lock); 1576 1577 printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu); 1578 1579 return EOK; 1580 } 1581 1582 /** Process IPC messages from the registered device driver modules 1583 * 1584 * @param[in] iid Message identifier. 1585 * @param[in,out] icall Message parameters. 1586 * 1587 */ 1588 static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall) 1589 { 1590 packet_t *packet; 1591 int rc; 1592 1593 while (true) { 1594 switch (IPC_GET_IMETHOD(*icall)) { 1595 case NET_IL_DEVICE_STATE: 1596 rc = ip_device_state_message(IPC_GET_DEVICE(*icall), 1597 IPC_GET_STATE(*icall)); 1598 ipc_answer_0(iid, (sysarg_t) rc); 1599 break; 1600 1601 case NET_IL_RECEIVED: 1602 rc = packet_translate_remote(ip_globals.net_phone, &packet, 1603 IPC_GET_PACKET(*icall)); 1604 if (rc == EOK) { 1605 do { 1606 packet_t *next = pq_detach(packet); 1607 ip_process_packet(IPC_GET_DEVICE(*icall), packet); 1608 packet = next; 1609 } while (packet); 1610 } 1611 1612 ipc_answer_0(iid, (sysarg_t) rc); 1613 break; 1614 1615 case NET_IL_MTU_CHANGED: 1616 rc = ip_mtu_changed_message(IPC_GET_DEVICE(*icall), 1617 IPC_GET_MTU(*icall)); 1618 ipc_answer_0(iid, (sysarg_t) rc); 1619 break; 1620 1621 default: 1622 ipc_answer_0(iid, (sysarg_t) ENOTSUP); 1623 } 1624 1625 iid = async_get_call(icall); 1626 } 1627 } 1628 1629 /** Registers the transport layer protocol. 1630 * 1631 * The traffic of this protocol will be supplied using either the receive 1632 * function or IPC message. 1633 * 1634 * @param[in] protocol The transport layer module protocol. 1635 * @param[in] service The transport layer module service. 1636 * @param[in] phone The transport layer module phone. 1637 * @param[in] received_msg The receiving function. 1638 * @return EOK on success. 1639 * @return EINVAL if the protocol parameter and/or the service 1640 * parameter is zero. 1641 * @return EINVAL if the phone parameter is not a positive number 1642 * and the tl_receive_msg is NULL. 1643 * @return ENOMEM if there is not enough memory left. 1450 1644 */ 1451 1645 static int 1452 ip_ deliver_local(device_id_t device_id, packet_t *packet, ip_header_t *header,1453 services_t error)1646 ip_register(int protocol, services_t service, int phone, 1647 tl_received_msg_t received_msg) 1454 1648 { 1455 1649 ip_proto_t *proto; 1456 int phone; 1457 services_t service; 1458 tl_received_msg_t received_msg; 1459 struct sockaddr *src; 1460 struct sockaddr *dest; 1461 struct sockaddr_in src_in; 1462 struct sockaddr_in dest_in; 1463 socklen_t addrlen; 1464 int rc; 1465 1466 if ((header->flags & IPFLAG_MORE_FRAGMENTS) || 1467 IP_FRAGMENT_OFFSET(header)) { 1468 // TODO fragmented 1469 return ENOTSUP; 1470 } 1471 1472 switch (header->version) { 1473 case IPVERSION: 1474 addrlen = sizeof(src_in); 1475 bzero(&src_in, addrlen); 1476 src_in.sin_family = AF_INET; 1477 memcpy(&dest_in, &src_in, addrlen); 1478 memcpy(&src_in.sin_addr.s_addr, &header->source_address, 1479 sizeof(header->source_address)); 1480 memcpy(&dest_in.sin_addr.s_addr, &header->destination_address, 1481 sizeof(header->destination_address)); 1482 src = (struct sockaddr *) &src_in; 1483 dest = (struct sockaddr *) &dest_in; 1484 break; 1485 1486 default: 1487 return ip_release_and_return(packet, EAFNOSUPPORT); 1488 } 1489 1490 rc = packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest, 1491 addrlen); 1492 if (rc != EOK) 1493 return ip_release_and_return(packet, rc); 1494 1495 // trim padding if present 1496 if (!error && 1497 (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) { 1498 rc = packet_trim(packet, 0, 1499 packet_get_data_length(packet) - IP_TOTAL_LENGTH(header)); 1500 if (rc != EOK) 1501 return ip_release_and_return(packet, rc); 1502 } 1503 1504 fibril_rwlock_read_lock(&ip_globals.protos_lock); 1505 1506 proto = ip_protos_find(&ip_globals.protos, header->protocol); 1507 if (!proto) { 1508 fibril_rwlock_read_unlock(&ip_globals.protos_lock); 1509 phone = ip_prepare_icmp_and_get_phone(error, packet, header); 1510 if (phone >= 0) { 1511 // unreachable ICMP 1512 icmp_destination_unreachable_msg(phone, 1513 ICMP_PROT_UNREACH, 0, packet); 1514 } 1515 return ENOENT; 1516 } 1517 1518 if (proto->received_msg) { 1519 service = proto->service; 1520 received_msg = proto->received_msg; 1521 fibril_rwlock_read_unlock(&ip_globals.protos_lock); 1522 rc = received_msg(device_id, packet, service, error); 1523 } else { 1524 rc = tl_received_msg(proto->phone, device_id, packet, 1525 proto->service, error); 1526 fibril_rwlock_read_unlock(&ip_globals.protos_lock); 1527 } 1528 1529 return rc; 1530 } 1531 1532 /** Processes the received packet. 1533 * 1534 * The packet is either passed to another module or released on error. 1535 * 1536 * The ICMP_PARAM_POINTER error notification may be sent if the checksum is 1537 * invalid. 1538 * The ICMP_EXC_TTL error notification may be sent if the TTL is less than two. 1539 * The ICMP_HOST_UNREACH error notification may be sent if no route was found. 1540 * The ICMP_HOST_UNREACH error notification may be sent if the packet is for 1541 * another host and the routing is disabled. 1542 * 1543 * @param[in] device_id The source device identifier. 1544 * @param[in] packet The received packet to be processed. 1545 * @return EOK on success. 1546 * @return EINVAL if the TTL is less than two. 1547 * @return EINVAL if the checksum is invalid. 1548 * @return EAFNOSUPPORT if the address family is not supported. 1549 * @return ENOENT if no route was found. 1550 * @return ENOENT if the packet is for another host and the routing 1551 * is disabled. 1552 */ 1553 static int 1554 ip_process_packet(device_id_t device_id, packet_t *packet) 1555 { 1556 ip_header_t *header; 1557 in_addr_t dest; 1558 ip_route_t *route; 1559 int phone; 1560 struct sockaddr *addr; 1561 struct sockaddr_in addr_in; 1562 socklen_t addrlen; 1563 int rc; 1564 1565 header = (ip_header_t *) packet_get_data(packet); 1566 if (!header) 1567 return ip_release_and_return(packet, ENOMEM); 1568 1569 // checksum 1570 if ((header->header_checksum) && 1571 (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) { 1572 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1573 if (phone >= 0) { 1574 // checksum error ICMP 1575 icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER, 1576 ((size_t) ((void *) &header->header_checksum)) - 1577 ((size_t) ((void *) header)), packet); 1578 } 1650 int index; 1651 1652 if (!protocol || !service || ((phone < 0) && !received_msg)) 1579 1653 return EINVAL; 1580 } 1581 1582 if (header->ttl <= 1) { 1583 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1584 if (phone >= 0) { 1585 // ttl exceeded ICMP 1586 icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet); 1587 } 1588 return EINVAL; 1589 } 1590 1591 // process ipopt and get destination 1592 dest = ip_get_destination(header); 1593 1594 // set the addrination address 1595 switch (header->version) { 1596 case IPVERSION: 1597 addrlen = sizeof(addr_in); 1598 bzero(&addr_in, addrlen); 1599 addr_in.sin_family = AF_INET; 1600 memcpy(&addr_in.sin_addr.s_addr, &dest, sizeof(dest)); 1601 addr = (struct sockaddr *) &addr_in; 1602 break; 1603 1604 default: 1605 return ip_release_and_return(packet, EAFNOSUPPORT); 1606 } 1607 1608 rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen); 1609 if (rc != EOK) 1610 return rc; 1611 1612 route = ip_find_route(dest); 1613 if (!route) { 1614 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1615 if (phone >= 0) { 1616 // unreachable ICMP 1617 icmp_destination_unreachable_msg(phone, 1618 ICMP_HOST_UNREACH, 0, packet); 1619 } 1620 return ENOENT; 1621 } 1622 1623 if (route->address.s_addr == dest.s_addr) { 1624 // local delivery 1625 return ip_deliver_local(device_id, packet, header, 0); 1626 } 1627 1628 if (route->netif->routing) { 1629 header->ttl--; 1630 return ip_send_route(packet, route->netif, route, NULL, dest, 1631 0); 1632 } 1633 1634 phone = ip_prepare_icmp_and_get_phone(0, packet, header); 1635 if (phone >= 0) { 1636 // unreachable ICMP if no routing 1637 icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0, 1638 packet); 1639 } 1640 1641 return ENOENT; 1642 } 1654 1655 proto = (ip_proto_t *) malloc(sizeof(ip_protos_t)); 1656 if (!proto) 1657 return ENOMEM; 1658 1659 proto->protocol = protocol; 1660 proto->service = service; 1661 proto->phone = phone; 1662 proto->received_msg = received_msg; 1663 1664 fibril_rwlock_write_lock(&ip_globals.protos_lock); 1665 index = ip_protos_add(&ip_globals.protos, proto->protocol, proto); 1666 if (index < 0) { 1667 fibril_rwlock_write_unlock(&ip_globals.protos_lock); 1668 free(proto); 1669 return index; 1670 } 1671 fibril_rwlock_write_unlock(&ip_globals.protos_lock); 1672 1673 printf("%s: Protocol registered (protocol: %d, phone: %d)\n", 1674 NAME, proto->protocol, proto->phone); 1675 1676 return EOK; 1677 } 1678 1643 1679 1644 1680 static int … … 1756 1792 (header->destination_address & route->netmask.s_addr))) { 1757 1793 // clear the ARP mapping if any 1758 address.value = ( char*) &header->destination_address;1794 address.value = (uint8_t *) &header->destination_address; 1759 1795 address.length = sizeof(header->destination_address); 1760 1796 arp_clear_address_req(netif->arp->phone, … … 1841 1877 } 1842 1878 1843 /** Processes the received IP packet or the packet queue one by one.1844 *1845 * The packet is either passed to another module or released on error.1846 *1847 * @param[in] device_id The source device identifier.1848 * @param[in,out] packet The received packet.1849 * @return EOK on success and the packet is no longer needed.1850 * @return EINVAL if the packet is too small to carry the IP1851 * packet.1852 * @return EINVAL if the received address lengths differs from the1853 * registered values.1854 * @return ENOENT if the device is not found in the cache.1855 * @return ENOENT if the protocol for the device is not found in1856 * the cache.1857 * @return ENOMEM if there is not enough memory left.1858 */1859 static int ip_receive_message(device_id_t device_id, packet_t *packet)1860 {1861 packet_t *next;1862 1863 do {1864 next = pq_detach(packet);1865 ip_process_packet(device_id, packet);1866 packet = next;1867 } while (packet);1868 1869 return EOK;1870 }1871 1872 1879 /** Processes the IP message. 1873 1880 * … … 1881 1888 * 1882 1889 * @see ip_interface.h 1883 * @see il_ interface.h1890 * @see il_remote.h 1884 1891 * @see IS_NET_IP_MESSAGE() 1885 1892 */ 1886 int 1887 ip_message_standalone(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer, 1888 int *answer_count) 1893 int il_module_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer, 1894 size_t *answer_count) 1889 1895 { 1890 1896 packet_t *packet; 1891 1897 struct sockaddr *addr; 1898 void *header; 1899 size_t headerlen; 1892 1900 size_t addrlen; 1893 1901 size_t prefix; 1894 1902 size_t suffix; 1895 1903 size_t content; 1896 void *header;1897 size_t headerlen;1898 1904 device_id_t device_id; 1899 1905 int rc; … … 1905 1911 1906 1912 case IPC_M_CONNECT_TO_ME: 1907 return ip_register(IL_GET_PROTO( call), IL_GET_SERVICE(call),1908 IPC_GET_PHONE( call), NULL);1909 1910 case NET_I L_DEVICE:1911 return ip_device_req_local(0, IPC_GET_DEVICE( call),1912 IPC_GET_SERVICE( call));1913 1914 case NET_I L_SEND:1913 return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call), 1914 IPC_GET_PHONE(*call), NULL); 1915 1916 case NET_IP_DEVICE: 1917 return ip_device_req_local(0, IPC_GET_DEVICE(*call), 1918 IPC_GET_SERVICE(*call)); 1919 1920 case NET_IP_RECEIVED_ERROR: 1915 1921 rc = packet_translate_remote(ip_globals.net_phone, &packet, 1916 IPC_GET_PACKET( call));1922 IPC_GET_PACKET(*call)); 1917 1923 if (rc != EOK) 1918 1924 return rc; 1919 return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0, 1920 IPC_GET_ERROR(call)); 1921 1922 case NET_IL_DEVICE_STATE: 1923 return ip_device_state_message(IPC_GET_DEVICE(call), 1924 IPC_GET_STATE(call)); 1925 1926 case NET_IL_RECEIVED: 1927 rc = packet_translate_remote(ip_globals.net_phone, &packet, 1928 IPC_GET_PACKET(call)); 1929 if (rc != EOK) 1930 return rc; 1931 return ip_receive_message(IPC_GET_DEVICE(call), packet); 1932 1933 case NET_IP_RECEIVED_ERROR: 1934 rc = packet_translate_remote(ip_globals.net_phone, &packet, 1935 IPC_GET_PACKET(call)); 1936 if (rc != EOK) 1937 return rc; 1938 return ip_received_error_msg_local(0, IPC_GET_DEVICE(call), 1939 packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call)); 1925 return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call), 1926 packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call)); 1940 1927 1941 1928 case NET_IP_ADD_ROUTE: 1942 return ip_add_route_req_local(0, IPC_GET_DEVICE( call),1943 IP_GET_ADDRESS( call), IP_GET_NETMASK(call),1944 IP_GET_GATEWAY( call));1929 return ip_add_route_req_local(0, IPC_GET_DEVICE(*call), 1930 IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call), 1931 IP_GET_GATEWAY(*call)); 1945 1932 1946 1933 case NET_IP_SET_GATEWAY: 1947 return ip_set_gateway_req_local(0, IPC_GET_DEVICE( call),1948 IP_GET_GATEWAY( call));1934 return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call), 1935 IP_GET_GATEWAY(*call)); 1949 1936 1950 1937 case NET_IP_GET_ROUTE: … … 1954 1941 return rc; 1955 1942 1956 rc = ip_get_route_req_local(0, IP_GET_PROTOCOL( call), addr,1943 rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr, 1957 1944 (socklen_t) addrlen, &device_id, &header, &headerlen); 1958 1945 if (rc != EOK) 1959 1946 return rc; 1960 1947 1961 IPC_SET_DEVICE( answer, device_id);1962 IP_SET_HEADERLEN( answer, headerlen);1948 IPC_SET_DEVICE(*answer, device_id); 1949 IP_SET_HEADERLEN(*answer, headerlen); 1963 1950 1964 1951 *answer_count = 2; … … 1971 1958 return rc; 1972 1959 1973 case NET_I L_PACKET_SPACE:1974 rc = ip_packet_size_message(IPC_GET_DEVICE( call), &addrlen,1960 case NET_IP_PACKET_SPACE: 1961 rc = ip_packet_size_message(IPC_GET_DEVICE(*call), &addrlen, 1975 1962 &prefix, &content, &suffix); 1976 1963 if (rc != EOK) 1977 1964 return rc; 1978 1965 1979 IPC_SET_ADDR( answer, addrlen);1980 IPC_SET_PREFIX( answer, prefix);1981 IPC_SET_CONTENT( answer, content);1982 IPC_SET_SUFFIX( answer, suffix);1966 IPC_SET_ADDR(*answer, addrlen); 1967 IPC_SET_PREFIX(*answer, prefix); 1968 IPC_SET_CONTENT(*answer, content); 1969 IPC_SET_SUFFIX(*answer, suffix); 1983 1970 *answer_count = 4; 1984 1971 return EOK; 1985 1972 1986 case NET_IL_MTU_CHANGED: 1987 return ip_mtu_changed_message(IPC_GET_DEVICE(call), 1988 IPC_GET_MTU(call)); 1973 case NET_IP_SEND: 1974 rc = packet_translate_remote(ip_globals.net_phone, &packet, 1975 IPC_GET_PACKET(*call)); 1976 if (rc != EOK) 1977 return rc; 1978 1979 return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0, 1980 IPC_GET_ERROR(*call)); 1989 1981 } 1990 1982 … … 1992 1984 } 1993 1985 1994 /** Default thread for new connections.1995 *1996 * @param[in] iid The initial message identifier.1997 * @param[in] icall The initial message call structure.1998 */1999 static void il_client_connection(ipc_callid_t iid, ipc_call_t *icall)2000 {2001 /*2002 * Accept the connection2003 * - Answer the first IPC_M_CONNECT_ME_TO call.2004 */2005 ipc_answer_0(iid, EOK);2006 2007 while (true) {2008 ipc_call_t answer;2009 int answer_count;2010 2011 /* Clear the answer structure */2012 refresh_answer(&answer, &answer_count);2013 2014 /* Fetch the next message */2015 ipc_call_t call;2016 ipc_callid_t callid = async_get_call(&call);2017 2018 /* Process the message */2019 int res = il_module_message_standalone(callid, &call, &answer,2020 &answer_count);2021 2022 /*2023 * End if told to either by the message or the processing2024 * result.2025 */2026 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||2027 (res == EHANGUP)) {2028 return;2029 }2030 2031 /* Answer the message */2032 answer_call(callid, res, &answer, answer_count);2033 }2034 }2035 2036 /** Starts the module.2037 *2038 * @return EOK on success.2039 * @return Other error codes as defined for each specific module start function.2040 */2041 1986 int main(int argc, char *argv[]) 2042 1987 { 2043 int rc;2044 2045 1988 /* Start the module */ 2046 rc = il_module_start_standalone(il_client_connection); 2047 return rc; 1989 return il_module_start(SERVICE_IP); 2048 1990 } 2049 1991
Note:
See TracChangeset
for help on using the changeset viewer.
