[haiku-commits] r37896 - in haiku/trunk: headers/private/net src/add-ons/kernel/network/protocols/icmp src/add-ons/kernel/network/protocols/ipv4 src/add-ons/kernel/network/protocols/ipv6 src/add-ons/kernel/network/protocols/l2cap ...

  • From: axeld@xxxxxxxxxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Wed, 4 Aug 2010 12:35:40 +0200 (CEST)

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;


Other related posts:

  • » [haiku-commits] r37896 - in haiku/trunk: headers/private/net src/add-ons/kernel/network/protocols/icmp src/add-ons/kernel/network/protocols/ipv4 src/add-ons/kernel/network/protocols/ipv6 src/add-ons/kernel/network/protocols/l2cap ... - axeld