Author: axeld Date: 2010-08-04 12:35:40 +0200 (Wed, 04 Aug 2010) New Revision: 37896 Changeset: http://dev.haiku-os.org/changeset/37896 Added: haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.h Removed: haiku/trunk/headers/private/net/icmp.h Modified: haiku/trunk/headers/private/net/net_protocol.h haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.cpp haiku/trunk/src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp haiku/trunk/src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp haiku/trunk/src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp haiku/trunk/src/add-ons/kernel/network/protocols/tcp/tcp.cpp haiku/trunk/src/add-ons/kernel/network/protocols/udp/udp.cpp haiku/trunk/src/add-ons/kernel/network/protocols/unix/unix.cpp haiku/trunk/src/add-ons/kernel/network/stack/link.cpp Log: * Finished groundwork on ICMP by introducing a completely protocol agnostic error mechanism. Modified: haiku/trunk/headers/private/net/net_protocol.h =================================================================== --- haiku/trunk/headers/private/net/net_protocol.h 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/headers/private/net/net_protocol.h 2010-08-04 10:35:40 UTC (rev 37896) @@ -1,5 +1,5 @@ /* - * Copyright 2006-2008, Haiku, Inc. All Rights Reserved. + * Copyright 2006-2010, Haiku, Inc. All Rights Reserved. * Distributed under the terms of the MIT License. */ #ifndef NET_PROTOCOL_H @@ -10,84 +10,109 @@ #include <net_socket.h> +struct ancillary_data_container; +struct ancillary_data_header; +struct iovec; +typedef struct net_domain net_domain; +typedef struct net_route net_route; + + // level flags to pass to control() #define LEVEL_SET_OPTION 0x10000000 #define LEVEL_GET_OPTION 0x20000000 #define LEVEL_DRIVER_IOCTL 0x0f000000 #define LEVEL_MASK 0x0fffffff -struct ancillary_data_container; -struct ancillary_data_header; +// Error codes for error_received(), and error_reply() +enum net_error { + B_NET_ERROR_REDIRECT_HOST = 1, + B_NET_ERROR_UNREACH_NET, + B_NET_ERROR_UNREACH_HOST, + B_NET_ERROR_UNREACH_PROTOCOL, + B_NET_ERROR_UNREACH_PORT, + B_NET_ERROR_MESSAGE_SIZE, + B_NET_ERROR_TRANSIT_TIME_EXCEEDED, + B_NET_ERROR_REASSEMBLY_TIME_EXCEEDED, + B_NET_ERROR_PARAMETER_PROBLEM, + B_NET_ERROR_QUENCH, +}; -struct iovec; +typedef union net_error_data { + struct sockaddr_storage gateway; + uint32 mtu; + uint32 error_offset; +} net_error_data; typedef struct net_protocol { - struct net_protocol *next; - struct net_protocol_module_info *module; - net_socket *socket; + struct net_protocol* next; + struct net_protocol_module_info* module; + net_socket* socket; } net_protocol; + // net_protocol_module_info::flags field #define NET_PROTOCOL_ATOMIC_MESSAGES 0x01 + struct net_protocol_module_info { module_info info; uint32 flags; - net_protocol *(*init_protocol)(net_socket *socket); - status_t (*uninit_protocol)(net_protocol *self); + net_protocol* (*init_protocol)(net_socket* socket); + status_t (*uninit_protocol)(net_protocol* self); - status_t (*open)(net_protocol *self); - status_t (*close)(net_protocol *self); - status_t (*free)(net_protocol *self); + status_t (*open)(net_protocol* self); + status_t (*close)(net_protocol* self); + status_t (*free)(net_protocol* self); - status_t (*connect)(net_protocol *self, const struct sockaddr *address); - status_t (*accept)(net_protocol *self, struct net_socket **_acceptedSocket); - status_t (*control)(net_protocol *self, int level, int option, void *value, - size_t *_length); - status_t (*getsockopt)(net_protocol *self, int level, int option, - void *value, int *_length); - status_t (*setsockopt)(net_protocol *self, int level, int option, - const void *value, int length); + status_t (*connect)(net_protocol* self, const struct sockaddr* address); + status_t (*accept)(net_protocol* self, net_socket** _acceptedSocket); + status_t (*control)(net_protocol* self, int level, int option, + void* value, size_t* _length); + status_t (*getsockopt)(net_protocol* self, int level, int option, + void* value, int* _length); + status_t (*setsockopt)(net_protocol* self, int level, int option, + const void* value, int length); - status_t (*bind)(net_protocol *self, const struct sockaddr *address); - status_t (*unbind)(net_protocol *self, struct sockaddr *address); - status_t (*listen)(net_protocol *self, int count); - status_t (*shutdown)(net_protocol *self, int direction); + status_t (*bind)(net_protocol* self, const struct sockaddr* address); + status_t (*unbind)(net_protocol* self, struct sockaddr* address); + status_t (*listen)(net_protocol* self, int count); + status_t (*shutdown)(net_protocol* self, int direction); - status_t (*send_data)(net_protocol *self, net_buffer *buffer); - status_t (*send_routed_data)(net_protocol *self, - struct net_route *route, net_buffer *buffer); - ssize_t (*send_avail)(net_protocol *self); + status_t (*send_data)(net_protocol* self, net_buffer* buffer); + status_t (*send_routed_data)(net_protocol* self, net_route* route, + net_buffer* buffer); + ssize_t (*send_avail)(net_protocol* self); - status_t (*read_data)(net_protocol *self, size_t numBytes, uint32 flags, - net_buffer **_buffer); - ssize_t (*read_avail)(net_protocol *self); + status_t (*read_data)(net_protocol* self, size_t numBytes, uint32 flags, + net_buffer** _buffer); + ssize_t (*read_avail)(net_protocol* self); - struct net_domain *(*get_domain)(net_protocol *self); - size_t (*get_mtu)(net_protocol *self, const struct sockaddr *address); + net_domain* (*get_domain)(net_protocol* self); + size_t (*get_mtu)(net_protocol* self, const struct sockaddr* address); - status_t (*receive_data)(net_buffer *data); - status_t (*deliver_data)(net_protocol *protocol, net_buffer *data); + status_t (*receive_data)(net_buffer* data); + status_t (*deliver_data)(net_protocol* self, net_buffer* data); - status_t (*error_received)(uint32 code, net_buffer *data); - status_t (*error_reply)(net_protocol *self, net_buffer *causedError, - uint32 code, void *errorData); + status_t (*error_received)(net_error error, net_buffer* data); + status_t (*error_reply)(net_protocol* self, net_buffer* cause, + net_error error, net_error_data* errorData); - status_t (*add_ancillary_data)(net_protocol *self, - ancillary_data_container *container, const cmsghdr *header); - ssize_t (*process_ancillary_data)(net_protocol *self, - const ancillary_data_header *header, const void *data, - void *buffer, size_t bufferSize); - ssize_t (*process_ancillary_data_no_container)(net_protocol *self, - net_buffer *buffer, void *data, size_t bufferSize); + status_t (*add_ancillary_data)(net_protocol* self, + ancillary_data_container* container, const cmsghdr* header); + ssize_t (*process_ancillary_data)(net_protocol* self, + const ancillary_data_header* header, const void* data, + void* buffer, size_t bufferSize); + ssize_t (*process_ancillary_data_no_container)(net_protocol* self, + net_buffer* buffer, void* data, size_t bufferSize); - ssize_t (*send_data_no_buffer)(net_protocol *self, const iovec *vecs, - size_t vecCount, ancillary_data_container *ancillaryData, - const struct sockaddr *address, socklen_t addressLength); - ssize_t (*read_data_no_buffer)(net_protocol *self, const iovec *vecs, - size_t vecCount, ancillary_data_container **_ancillaryData, - struct sockaddr *_address, socklen_t *_addressLength); + ssize_t (*send_data_no_buffer)(net_protocol* self, const iovec* vecs, + size_t vecCount, ancillary_data_container* ancillaryData, + const struct sockaddr* address, socklen_t addressLength); + ssize_t (*read_data_no_buffer)(net_protocol* self, const iovec* vecs, + size_t vecCount, ancillary_data_container** _ancillaryData, + struct sockaddr* _address, socklen_t* _addressLength); }; + #endif // NET_PROTOCOL_H Modified: haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -12,6 +12,8 @@ */ +#include "icmp.h" + #include <algorithm> #include <netinet/in.h> #include <new> @@ -21,7 +23,6 @@ #include <KernelExport.h> #include <OS.h> -#include <icmp.h> #include <net_datalink.h> #include <net_protocol.h> #include <net_stack.h> @@ -55,11 +56,10 @@ uint16 _reserved; uint16 next_mtu; } path_mtu; - uint32 gateway; struct { - uint16 unused; - uint16 mtu; - } frag; + uint8 pointer; + uint8 _reserved[3]; + } parameter_problem; uint32 zero; }; @@ -82,6 +82,34 @@ static net_stack_module_info* sStackModule; +#ifdef TRACE_ICMP + + +static const char* +net_error_to_string(net_error error) +{ +#define CODE(x) case x: return #x; + switch (error) { + CODE(B_NET_ERROR_REDIRECT_HOST) + CODE(B_NET_ERROR_UNREACH_NET) + CODE(B_NET_ERROR_UNREACH_HOST) + CODE(B_NET_ERROR_UNREACH_PROTOCOL) + CODE(B_NET_ERROR_UNREACH_PORT) + CODE(B_NET_ERROR_MESSAGE_SIZE) + CODE(B_NET_ERROR_TRANSIT_TIME_EXCEEDED) + CODE(B_NET_ERROR_REASSEMBLY_TIME_EXCEEDED) + CODE(B_NET_ERROR_PARAMETER_PROBLEM) + CODE(B_NET_ERROR_QUENCH) + default: + return "unknown"; + } +#undef CODE +} + + +#endif // TRACE_ICMP + + static net_domain* get_domain(struct net_buffer* buffer) { @@ -112,13 +140,113 @@ is_icmp_error(uint8 type) { return type == ICMP_TYPE_UNREACH - || type == ICMP_TYPE_PARAM_PROBLEM + || type == ICMP_TYPE_PARAMETER_PROBLEM || type == ICMP_TYPE_REDIRECT || type == ICMP_TYPE_TIME_EXCEEDED || type == ICMP_TYPE_SOURCE_QUENCH; } +static net_error +icmp_to_net_error(uint8 type, uint8 code) +{ + switch (type) { + case ICMP_TYPE_UNREACH: + switch (code) { + case ICMP_CODE_FRAGMENTATION_NEEDED: + return B_NET_ERROR_MESSAGE_SIZE; + case ICMP_CODE_NET_UNREACH: + return B_NET_ERROR_UNREACH_NET; + case ICMP_CODE_HOST_UNREACH: + return B_NET_ERROR_UNREACH_HOST; + case ICMP_CODE_PROTOCOL_UNREACH: + return B_NET_ERROR_UNREACH_PROTOCOL; + case ICMP_CODE_PORT_UNREACH: + return B_NET_ERROR_UNREACH_PORT; + } + break; + + case ICMP_TYPE_PARAMETER_PROBLEM: + return B_NET_ERROR_PARAMETER_PROBLEM; + + case ICMP_TYPE_REDIRECT: + return B_NET_ERROR_REDIRECT_HOST; + + case ICMP_TYPE_SOURCE_QUENCH: + return B_NET_ERROR_QUENCH; + + case ICMP_TYPE_TIME_EXCEEDED: + switch (code) { + case ICMP_CODE_TIME_EXCEEDED_IN_TRANSIT: + return B_NET_ERROR_TRANSIT_TIME_EXCEEDED; + case ICMP_CODE_REASSEMBLY_TIME_EXCEEDED: + return B_NET_ERROR_REASSEMBLY_TIME_EXCEEDED; + } + break; + + default: + break; + } + + return (net_error)0; +} + + +static void +net_error_to_icmp(net_error error, uint8& type, uint8& code) +{ + switch (error) { + // redirect + case B_NET_ERROR_REDIRECT_HOST: + type = ICMP_TYPE_REDIRECT; + code = ICMP_CODE_REDIRECT_HOST; + break; + + // unreach + case B_NET_ERROR_UNREACH_NET: + type = ICMP_TYPE_UNREACH; + code = ICMP_CODE_NET_UNREACH; + break; + case B_NET_ERROR_UNREACH_HOST: + type = ICMP_TYPE_UNREACH; + code = ICMP_CODE_HOST_UNREACH; + break; + case B_NET_ERROR_UNREACH_PROTOCOL: + type = ICMP_TYPE_UNREACH; + code = ICMP_CODE_PROTOCOL_UNREACH; + break; + case B_NET_ERROR_UNREACH_PORT: + type = ICMP_TYPE_UNREACH; + code = ICMP_CODE_PORT_UNREACH; + break; + case B_NET_ERROR_MESSAGE_SIZE: + type = ICMP_TYPE_UNREACH; + code = ICMP_CODE_FRAGMENTATION_NEEDED; + break; + + // time exceeded + case B_NET_ERROR_TRANSIT_TIME_EXCEEDED: + type = ICMP_TYPE_TIME_EXCEEDED; + code = ICMP_CODE_TIME_EXCEEDED_IN_TRANSIT; + break; + case B_NET_ERROR_REASSEMBLY_TIME_EXCEEDED: + type = ICMP_TYPE_TIME_EXCEEDED; + code = ICMP_CODE_REASSEMBLY_TIME_EXCEEDED; + break; + + // other + case B_NET_ERROR_PARAMETER_PROBLEM: + type = ICMP_TYPE_PARAMETER_PROBLEM; + code = 0; + break; + case B_NET_ERROR_QUENCH: + type = ICMP_TYPE_SOURCE_QUENCH; + code = 0; + break; + } +} + + // #pragma mark - module API @@ -353,17 +481,17 @@ case ICMP_TYPE_UNREACH: case ICMP_TYPE_SOURCE_QUENCH: - case ICMP_TYPE_PARAM_PROBLEM: + case ICMP_TYPE_PARAMETER_PROBLEM: case ICMP_TYPE_TIME_EXCEEDED: { net_domain* domain = get_domain(buffer); if (domain == NULL) break; - uint32 error = icmp_encode(header.type, header.code); - if (error > 0) { - // Deliver the error to the domain protocol which will - // propagate the error to the upper protocols + // Deliver the error to the domain protocol which will + // propagate the error to the upper protocols + net_error error = icmp_to_net_error(header.type, header.code); + if (error != 0) { bufferHeader.Remove(); return domain->module->error_received(error, buffer); } @@ -390,7 +518,7 @@ status_t -icmp_error_received(uint32 code, net_buffer* data) +icmp_error_received(net_error code, net_buffer* data) { return B_ERROR; } @@ -400,13 +528,14 @@ error. */ status_t -icmp_error_reply(net_protocol* protocol, net_buffer* buffer, uint32 code, - void* errorData) +icmp_error_reply(net_protocol* protocol, net_buffer* buffer, net_error error, + net_error_data* errorData) { - TRACE("icmp_error_reply(code %#" B_PRIx32 ")\n", code); + TRACE("icmp_error_reply(code %s)\n", net_error_to_string(error)); uint8 icmpType, icmpCode; - icmp_decode(code, icmpType, icmpCode); + net_error_to_icmp(error, icmpType, icmpCode); + TRACE(" icmp type %u, code %u\n", icmpType, icmpCode); ipv4_header header; @@ -452,11 +581,33 @@ } // Now prepare the ICMP header + NetBufferPrepend<icmp_header> icmpHeader(reply); icmpHeader->type = icmpType; icmpHeader->code = icmpCode; - icmpHeader->gateway = errorData ? *((uint32*)errorData) : 0; + icmpHeader->zero = 0; icmpHeader->checksum = 0; + + if (errorData != NULL) { + switch (error) { + case B_NET_ERROR_REDIRECT_HOST: + { + sockaddr_in& gateway = (sockaddr_in&)errorData->gateway; + icmpHeader->redirect.gateway = gateway.sin_addr.s_addr; + break; + } + case B_NET_ERROR_PARAMETER_PROBLEM: + icmpHeader->parameter_problem.pointer = errorData->error_offset; + break; + case B_NET_ERROR_MESSAGE_SIZE: + icmpHeader->path_mtu.next_mtu = errorData->mtu; + break; + + default: + break; + } + } + icmpHeader.Sync(); // Append IP header + 8 byte of the original datagram Copied: haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.h (from rev 37892, haiku/trunk/headers/private/net/icmp.h) =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.h (rev 0) +++ haiku/trunk/src/add-ons/kernel/network/protocols/icmp/icmp.h 2010-08-04 10:35:40 UTC (rev 37896) @@ -0,0 +1,53 @@ +/* + * Copyright 2006-2010, Haiku, Inc. All Rights Reserved. + * Distributed under the terms of the MIT License. + */ +#ifndef ICMP_H +#define ICMP_H + + +// ICMP types + +// RFC 792 +#define ICMP_TYPE_ECHO_REPLY 0 +#define ICMP_TYPE_UNREACH 3 +#define ICMP_TYPE_SOURCE_QUENCH 4 +#define ICMP_TYPE_REDIRECT 5 +#define ICMP_TYPE_ECHO_REQUEST 8 +#define ICMP_TYPE_TIME_EXCEEDED 11 +#define ICMP_TYPE_PARAMETER_PROBLEM 12 +#define ICMP_TYPE_TIMESTAMP_REQUEST 13 +#define ICMP_TYPE_TIMESTAMP_REPLY 14 +#define ICMP_TYPE_INFO_REQUEST 15 +#define ICMP_TYPE_INFO_REPLY 16 +// RFC 950 +#define ICMP_TYPE_ADDR_MASK_REQUEST 17 +#define ICMP_TYPE_ADDR_MASK_REPLY 18 + + +// ICMP codes + +// ICMP_TYPE_TIME_EXCEEDED codes +#define ICMP_CODE_TIME_EXCEEDED_IN_TRANSIT 0 +#define ICMP_CODE_REASSEMBLY_TIME_EXCEEDED 1 + +// ICMP_TYPE_PARAMETER_PROBLEM codes +#define ICMP_CODE_INVALID_PARAMETER 0 +#define ICMP_CODE_PARAMETER_MISSING 1 + +// ICMP_TYPE_UNREACH codes +#define ICMP_CODE_NET_UNREACH 0 +#define ICMP_CODE_HOST_UNREACH 1 +#define ICMP_CODE_PROTOCOL_UNREACH 2 +#define ICMP_CODE_PORT_UNREACH 3 +#define ICMP_CODE_FRAGMENTATION_NEEDED 4 +#define ICMP_CODE_SOURCE_ROUTE_FAIL 5 + +// ICMP_TYPE_REDIRECT codes +#define ICMP_CODE_REDIRECT_NET 0 +#define ICMP_CODE_REDIRECT_HOST 1 +#define ICMP_CODE_REDIRECT_TOS_NET 2 +#define ICMP_CODE_REDIRECT_TOS_HOST 3 + + +#endif // ICMP_H Modified: haiku/trunk/src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -11,7 +11,6 @@ #include "ipv4_address.h" #include "multicast.h" -#include <icmp.h> #include <net_datalink.h> #include <net_datalink_protocol.h> #include <net_device.h> @@ -430,7 +429,7 @@ if (!packet->fFragments.IsEmpty()) { // Send error: fragment reassembly time exceeded sDomain->module->error_reply(NULL, packet->fFragments.First(), - icmp_encode(ICMP_TYPE_TIME_EXCEEDED, ICMP_CODE_TIMEEX_FRAG), NULL); + B_NET_ERROR_REASSEMBLY_TIME_EXCEEDED, NULL); } delete packet; @@ -1602,8 +1601,8 @@ ntohl(header.source), ntohl(header.destination)); // Send ICMP error: Host unreachable - sDomain->module->error_reply(NULL, buffer, - icmp_encode(ICMP_TYPE_UNREACH, ICMP_CODE_HOST_UNREACH), NULL); + sDomain->module->error_reply(NULL, buffer, B_NET_ERROR_UNREACH_HOST, + NULL); return B_ERROR; } @@ -1658,7 +1657,7 @@ // no handler for this packet if (!rawDelivered) { sDomain->module->error_reply(NULL, buffer, - icmp_encode(ICMP_TYPE_UNREACH, ICMP_CODE_PROTO_UNREACH), NULL); + B_NET_ERROR_UNREACH_PROTOCOL, NULL); } return EAFNOSUPPORT; } @@ -1690,10 +1689,10 @@ status_t -ipv4_error_received(uint32 code, net_buffer* buffer) +ipv4_error_received(net_error error, net_buffer* buffer) { TRACE(" ipv4_error_received(code %" B_PRIx32 ", buffer %p [%zu bytes])", - code, buffer, buffer->size); + error, buffer, buffer->size); NetBufferHeaderReader<ipv4_header> bufferHeader(buffer); if (bufferHeader.Status() != B_OK) @@ -1741,20 +1740,20 @@ return B_ERROR; // propagate error - return protocol->error_received(code, buffer); + return protocol->error_received(error, buffer); } status_t -ipv4_error_reply(net_protocol* protocol, net_buffer* causedError, uint32 code, - void* errorData) +ipv4_error_reply(net_protocol* protocol, net_buffer* cause, net_error error, + net_error_data* errorData) { // Directly obtain the ICMP protocol module net_protocol_module_info* icmp = receiving_protocol(IPPROTO_ICMP); if (icmp == NULL) return B_ERROR; - return icmp->error_reply(protocol, causedError, code, errorData); + return icmp->error_reply(protocol, cause, error, errorData); } Modified: haiku/trunk/src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -1020,15 +1020,15 @@ status_t -ipv6_error(uint32 code, net_buffer* data) +ipv6_error_received(net_error error, net_buffer* data) { return B_ERROR; } status_t -ipv6_error_reply(net_protocol* protocol, net_buffer* causedError, uint32 code, - void* errorData) +ipv6_error_reply(net_protocol* protocol, net_buffer* cause, net_error error, + net_error_data* errorData) { return B_ERROR; } @@ -1219,7 +1219,7 @@ ipv6_get_mtu, ipv6_receive_data, ipv6_deliver_data, - ipv6_error, + ipv6_error_received, ipv6_error_reply, NULL, // add_ancillary_data() NULL, // process_ancillary_data() Modified: haiku/trunk/src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -18,6 +18,7 @@ * documentation and/or other materials provided with the distribution. */ + #include <net_datalink.h> #include <net_protocol.h> #include <net_stack.h> @@ -39,6 +40,7 @@ #include <bluetooth/HCI/btHCI_acl.h> #include <btModules.h> + #define BT_DEBUG_THIS_MODULE #define SUBMODULE_NAME "L2cap" #define SUBMODULE_COLOR 32 @@ -281,7 +283,8 @@ l2cap_receive_data(net_buffer* buffer) { HciConnection* conn = (HciConnection*)buffer; - debugf("received some data, buffer length %lu\n", conn->currentRxPacket->size); + debugf("received some data, buffer length %lu\n", + conn->currentRxPacket->size); l2cap_receive(conn, conn->currentRxPacket); @@ -290,7 +293,7 @@ status_t -l2cap_error(uint32 code, net_buffer* data) +l2cap_error_received(net_error error, net_buffer* data) { flowf("\n"); @@ -299,8 +302,8 @@ status_t -l2cap_error_reply(net_protocol* protocol, net_buffer* causedError, uint32 code, - void* errorData) +l2cap_error_reply(net_protocol* protocol, net_buffer* cause, net_error error, + net_error_data* errorData) { flowf("\n"); @@ -308,10 +311,9 @@ } -#if 0 -#pragma mark - -#endif +// #pragma mark - + static status_t l2cap_std_ops(int32 op, ...) { @@ -329,14 +331,15 @@ if (error != B_OK) return error; - error = gStackModule->register_domain_receiving_protocol(AF_BLUETOOTH, + error = gStackModule->register_domain_receiving_protocol( + AF_BLUETOOTH, BLUETOOTH_PROTO_L2CAP, "network/protocols/l2cap/v1"); if (error != B_OK) return error; - error = gStackModule->register_domain(AF_BLUETOOTH, "l2cap", &gL2CAPModule, - &gL2cap4AddressModule, &sDomain); + error = gStackModule->register_domain(AF_BLUETOOTH, "l2cap", + &gL2CAPModule, &gL2cap4AddressModule, &sDomain); if (error != B_OK) return error; @@ -391,7 +394,7 @@ l2cap_get_mtu, l2cap_receive_data, NULL, // deliver_data() - l2cap_error, + l2cap_error_received, l2cap_error_reply, NULL, // add_ancillary_data() NULL, // process_ancillary_data() Modified: haiku/trunk/src/add-ons/kernel/network/protocols/tcp/tcp.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/tcp/tcp.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/tcp/tcp.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -728,15 +728,15 @@ status_t -tcp_error(uint32 code, net_buffer* data) +tcp_error_received(net_error error, net_buffer* data) { return B_ERROR; } status_t -tcp_error_reply(net_protocol* protocol, net_buffer* causedError, uint32 code, - void* errorData) +tcp_error_reply(net_protocol* protocol, net_buffer* cause, net_error error, + net_error_data* errorData) { return B_ERROR; } @@ -861,7 +861,7 @@ tcp_get_mtu, tcp_receive_data, NULL, // deliver_data() - tcp_error, + tcp_error_received, tcp_error_reply, NULL, // add_ancillary_data() NULL, // process_ancillary_data() Modified: haiku/trunk/src/add-ons/kernel/network/protocols/udp/udp.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/udp/udp.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/udp/udp.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -13,8 +13,6 @@ #include <net_protocol.h> #include <net_stack.h> -#include <icmp.h> - #include <lock.h> #include <util/AutoLock.h> #include <util/DoublyLinkedList.h> @@ -698,7 +696,7 @@ TRACE_EPM(" ReceiveData(): no endpoint."); // Send port unreachable error domainSupport->Domain()->module->error_reply(NULL, buffer, - icmp_encode(ICMP_TYPE_UNREACH, ICMP_CODE_PORT_UNREACH), NULL); + B_NET_ERROR_UNREACH_PORT, NULL); return B_ERROR; } @@ -1235,52 +1233,46 @@ status_t -udp_error_received(uint32 code, net_buffer* buffer) +udp_error_received(net_error error, net_buffer* buffer) { - uint8 icmpType, icmpCode; - icmp_decode(code, icmpType, icmpCode); + status_t notifyError = B_OK; - status_t error = B_OK; - switch (icmpType) { - case ICMP_TYPE_UNREACH: - if (icmpCode == ICMP_CODE_NET_UNREACH) - error = ENETUNREACH; - else if (icmpCode == ICMP_CODE_HOST_UNREACH) - error = EHOSTUNREACH; - else if (icmpCode == ICMP_CODE_SOURCE_ROUTE_FAIL) - error = B_NOT_SUPPORTED; - else if (icmpCode == ICMP_CODE_PROTO_UNREACH) - error = ENOPROTOOPT; - else if (icmpCode == ICMP_CODE_PORT_UNREACH) - error = ECONNREFUSED; - else if (icmpCode == ICMP_CODE_FRAG_NEEDED) - error = EMSGSIZE; - else - error = B_NOT_SUPPORTED; + switch (error) { + case B_NET_ERROR_UNREACH_NET: + notifyError = ENETUNREACH; break; - case ICMP_TYPE_TIME_EXCEEDED: - error = EHOSTUNREACH; + case B_NET_ERROR_UNREACH_HOST: + case B_NET_ERROR_TRANSIT_TIME_EXCEEDED: + notifyError = EHOSTUNREACH; break; - case ICMP_TYPE_PARAM_PROBLEM: - error = EPROTO; + case B_NET_ERROR_UNREACH_PROTOCOL: + case B_NET_ERROR_UNREACH_PORT: + notifyError = ECONNREFUSED; break; - case ICMP_TYPE_SOURCE_QUENCH: + case B_NET_ERROR_MESSAGE_SIZE: + notifyError = EMSGSIZE; + break; + case B_NET_ERROR_PARAMETER_PROBLEM: + notifyError = ENOPROTOOPT; + break; + + case B_NET_ERROR_QUENCH: default: // ignore them break; } - - if (error != B_OK) - sUdpEndpointManager->ReceiveError(error, buffer); + if (notifyError != B_OK) + sUdpEndpointManager->ReceiveError(notifyError, buffer); + gBufferModule->free(buffer); return B_OK; } status_t -udp_error_reply(net_protocol *protocol, net_buffer *causedError, uint32 code, - void *errorData) +udp_error_reply(net_protocol *protocol, net_buffer *cause, net_error error, + net_error_data *errorData) { return B_ERROR; } Modified: haiku/trunk/src/add-ons/kernel/network/protocols/unix/unix.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/protocols/unix/unix.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/protocols/unix/unix.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -3,6 +3,7 @@ * Distributed under the terms of the MIT License. */ + #include <stdio.h> #include <sys/un.h> @@ -268,15 +269,15 @@ status_t -unix_error(uint32 code, net_buffer *data) +unix_error_received(net_error error, net_buffer *data) { return B_ERROR; } status_t -unix_error_reply(net_protocol *protocol, net_buffer *causedError, uint32 code, - void *errorData) +unix_error_reply(net_protocol *protocol, net_buffer *cause, net_error error, + net_error_data *errorData) { return B_ERROR; } @@ -504,7 +505,7 @@ unix_get_mtu, unix_receive_data, unix_deliver_data, - unix_error, + unix_error_received, unix_error_reply, unix_add_ancillary_data, unix_process_ancillary_data, Modified: haiku/trunk/src/add-ons/kernel/network/stack/link.cpp =================================================================== --- haiku/trunk/src/add-ons/kernel/network/stack/link.cpp 2010-08-04 08:42:25 UTC (rev 37895) +++ haiku/trunk/src/add-ons/kernel/network/stack/link.cpp 2010-08-04 10:35:40 UTC (rev 37896) @@ -603,7 +603,7 @@ static status_t -link_error_received(uint32 code, net_buffer* data) +link_error_received(net_error error, net_buffer* data) { // We don't do any error processing return B_ERROR; @@ -611,8 +611,8 @@ static status_t -link_error_reply(net_protocol* protocol, net_buffer* causedError, uint32 code, - void* errorData) +link_error_reply(net_protocol* protocol, net_buffer* cause, net_error error, + net_error_data* errorData) { // We don't do any error processing return B_ERROR;