Ticket #812: 0001-merge-pppoe_branch.patch

build/jam/HaikuImage

@@ -90 +90 @@
     syslog_daemon dns_resolver_server nfs4_idmapper_server
 ] ;
 
-SYSTEM_NETWORK_DEVICES = ethernet loopback ;
+SYSTEM_NETWORK_DEVICES = ethernet loopback ppp ;
 SYSTEM_NETWORK_DATALINK_PROTOCOLS = ethernet_frame <module>arp loopback_frame
-    ipv6_datagram ;
+    ipv6_datagram ppp_frame ;
+SYSTEM_NETWORK_PPP = ipcp pap pppoe KPPPManager ;
 #SYSTEM_NETWORK_PPP = ipcp modem pap pppoe ;
 SYSTEM_NETWORK_PROTOCOLS = ipv4 tcp udp icmp unix icmp6 ipv6 ;
 

build/jam/ReleaseBuildProfiles

@@ -41 +41 @@
         AddGroupToHaikuImage party : 101 : user sshd ;
         HAIKU_STRIP_DEBUG_FROM_OPTIONAL_PACKAGES = 1 ;
         HAIKU_IMAGE_HOST_NAME = shredder ;
-        HAIKU_IMAGE_SIZE = 600 ;
+        HAIKU_IMAGE_SIZE = 800 ;
 
         AddOptionalHaikuImagePackages Pe Nano Vision P7zip XZ-Utils ;
         AddOptionalHaikuImagePackages Development Git OpenSSH OpenSSL ;

headers/private/net/net_datalink.h

@@ -86 +86 @@
                         net_interface_address** _interfaceAddress);
 
     net_interface*  (*get_interface)(net_domain* domain, uint32 index);
+    net_interface*  (*get_interface_by_name)(net_domain* domain, const char* ifname);
     net_interface*  (*get_interface_with_address)(
                         const struct sockaddr* address);
     void            (*put_interface)(net_interface* interface);
 
     net_interface_address* (*get_interface_address)(
                         const struct sockaddr* address);
+    net_interface_address* (*get_interface_address_by_name)(const char* name,
+                        net_domain* domain);
+    status_t        (*set_interface_address)(
+                    net_domain* _domain, struct ifaliasreq request);
     bool            (*get_next_interface_address)(net_interface* interface,
                         net_interface_address** _address);
     void            (*put_interface_address)(net_interface_address* address);

headers/private/net/net_datalink_protocol.h

@@ -7 +7 @@
 
 
 #include <net_buffer.h>
-
+#define NET_DATA_LINK_INTERFACE_MODULE_NAME "network/stack/datalink/interface/v1"
+    
 
 typedef struct net_datalink_protocol {
     struct net_datalink_protocol*               next;

headers/private/net/net_stack.h

@@ -86 +86 @@
     B_NET_FRAME_TYPE_IPV6               = 0x0002,
     B_NET_FRAME_TYPE_IPX                = 0x0003,
     B_NET_FRAME_TYPE_APPLE_TALK         = 0x0004,
+    B_NET_FRAME_TYPE_PPPOE_DISCOVERY        = 0x0005,
+    B_NET_FRAME_TYPE_PPPOE              = 0x0006,
 
     B_NET_FRAME_TYPE_ALL                = 0x0000
 };

src/add-ons/kernel/network/Jamfile

@@ -6 +6 @@
 SubInclude HAIKU_TOP src add-ons kernel network notifications ;
 SubInclude HAIKU_TOP src add-ons kernel network protocols ;
 SubInclude HAIKU_TOP src add-ons kernel network stack ;
+SubInclude HAIKU_TOP src add-ons kernel network ppp ;

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

@@ -36 +36 @@
 int32
 ethernet_deframe(net_device* device, net_buffer* buffer)
 {
-    //dprintf("asked to deframe buffer for device %s\n", device->name);
-
     NetBufferHeaderRemover<ether_header> bufferHeader(buffer);
     if (bufferHeader.Status() != B_OK)
         return bufferHeader.Status();
@@ -84 +82 @@
             buffer->type = B_NET_FRAME_TYPE_IPX;
             break;
 
+        case ETHER_TYPE_PPPOE_DISCOVERY:
+            buffer->type = B_NET_FRAME_TYPE(IFT_ETHER, type);
+            // buffer->type = B_NET_FRAME_PPPOE_DISCOVERY;
+            break;
+
+        case ETHER_TYPE_PPPOE:
+            buffer->type = B_NET_FRAME_TYPE(IFT_ETHER, type);
+            // buffer->type = B_NET_FRAME_PPPOE;
+            break;
+
         default:
             buffer->type = B_NET_FRAME_TYPE(IFT_ETHER, type);
             break;

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

@@ -100 +100 @@
             break;
 
         // check link state of all existing devices
-
         DoublyLinkedList<ethernet_device>::Iterator iterator
             = sCheckList.GetIterator();
         while (iterator.HasNext()) {
@@ -342 +341 @@
 
 err:
     gBufferModule->free(buffer);
+    // should free the unused buffer
+    dprintf("%s::%s!!!!!!!!!!!!!!!!!!!!!!!!some severe fault!!!!!!!!!!!!!\n",__FILE__,__func__);
     return status;
 }
 

src/add-ons/kernel/network/ppp/Jamfile

@@ -1 +1 @@
 SubDir HAIKU_TOP src add-ons kernel network ppp ;
 
 SubInclude HAIKU_TOP src add-ons kernel network ppp ipcp ;
-SubInclude HAIKU_TOP src add-ons kernel network ppp modem ;
+# SubInclude HAIKU_TOP src add-ons kernel network ppp modem ;
 SubInclude HAIKU_TOP src add-ons kernel network ppp pap ;
 SubInclude HAIKU_TOP src add-ons kernel network ppp pppoe ;
 SubInclude HAIKU_TOP src add-ons kernel network ppp shared ;
+SubInclude HAIKU_TOP src add-ons kernel network ppp ppp ;
+SubInclude HAIKU_TOP src add-ons kernel network ppp ppp_frame ;
+SubInclude HAIKU_TOP src add-ons kernel network ppp KPPPManager ;

new file src/add-ons/kernel/network/ppp/KPPPManager/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src add-ons kernel network ppp KPPPManager ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+if $(TARGET_PLATFORM) != haiku {
+    UseHeaders [ FStandardOSHeaders ] : true ;
+        # Needed for <support/Errors.h> and maybe other stuff.
+    UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
+        # We need the public network headers also when not compiling for Haiku.
+        # Unfortunately we get more than we want, namely all POSIX headers.
+}
+
+UsePrivateKernelHeaders ;
+    # UsePrivateHeaders net ;
+
+UsePrivateHeaders kernel net ;
+UsePrivateHeaders [ FDirName kernel ] ;
+UsePrivateHeaders [ FDirName kernel util ] ;
+
+UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared
+    libkernelppp headers ] : true ;
+
+
+{
+    SubDirC++Flags -fno-rtti ;
+}
+
+
+KernelAddon KPPPManager :
+    KPPPManager.cpp
+;
+
+LinkAgainst KPPPManager : libkernelppp.a ;
+
+# Installation
+HaikuInstall install-networking : /boot/home/config/add-ons/kernel/haiku_network/ppp
+    : KPPPManager ;
+
+Package haiku-networkingkit-cvs :
+    haiku :
+    boot home config add-ons kernel haiku_network datalink_protocols ;
+
+SEARCH on [ FGristFiles kernel_cpp.cpp ]
+    = [ FDirName $(HAIKU_TOP) src system kernel util ] ;

new file src/add-ons/kernel/network/ppp/KPPPManager/KPPPManager.cpp

@@ +1 @@
+/*
+ * Copyright 2006-2010, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Axel Dörfler, axeld@pinc-software.de
+ */
+
+#include <net_stack.h>
+#include <NetBufferUtilities.h>
+
+#include <ByteOrder.h>
+#include <KernelExport.h>
+
+#include <lock.h>
+#include <util/AutoLock.h>
+#include <util/DoublyLinkedList.h>
+
+#include <new>
+#include <string.h>
+
+#include <KPPPInterface.h>
+#include <KPPPManager.h>
+#include <ppp_device.h>
+
+// #define TRACE(x) dprintf(x)
+
+struct entry_private : ppp_interface_entry, DoublyLinkedListLinkImpl<entry_private> {
+};
+
+static DoublyLinkedList<entry_private> sEntryList;
+
+net_buffer_module_info* gBufferModule = NULL;
+net_stack_module_info* gStackModule = NULL;
+// static struct net_interface* sinterface;
+static mutex sListLock;
+static uint32 ppp_interface_count;
+ppp_interface_entry entry[4];
+
+//  #pragma mark -
+
+static KPPPInterface * GetInterface(ppp_interface_id ID);
+
+static ppp_interface_id
+CreateInterface(const driver_settings *settings, ppp_interface_id parentID)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    if (parentID>0){
+        TRACE("Not support Multi_Link yet!\n");
+        return 0l;
+    }
+
+    if (settings==NULL){
+        TRACE("No driver_settings yet!\n");
+        return 0l;
+    }
+
+    ppp_interface_count++;
+
+    if (GetInterface(ppp_interface_count) != NULL)
+        return 0l;
+
+    entry_private* pentry = new (std::nothrow) entry_private;
+    memset(pentry,0,sizeof(entry_private));
+    pentry->accessing=ppp_interface_count;
+    sEntryList.Add(pentry);
+
+    KPPPInterface *device = new (std::nothrow) KPPPInterface(NULL,
+        pentry,ppp_interface_count,NULL,NULL);
+
+    if(device==NULL || pentry==NULL) {
+        TRACE("device or pentry is NULL\n");
+        ppp_interface_count--;
+        return 0l;
+    }
+
+    TRACE("setting ppp_interface_count %ld\n",ppp_interface_count);
+
+
+    return ppp_interface_count; // only support 1 ppp connection right now
+}
+
+
+static ppp_interface_id
+CreateInterfaceWithName(const char *name, ppp_interface_id parentID)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    if (parentID>0){
+        dprintf("Not support Multi_Link yet!\n");
+        return(0);
+    }
+
+    if (!strncmp(name,"ppp1",4) || !strncmp(name,"ppp2",4) || !strncmp(name,"ppp3",4)){
+        dprintf("create ppp fine: you are requesting %s!\n",name);
+    } else {
+        dprintf("only ppp1-3 support: you are requesting %s!\n",name);
+        return(0);
+    }
+        
+    ppp_interface_count++;
+    if (GetInterface(ppp_interface_count) != NULL){
+        TRACE("PPP Interface already exist!\n");
+        return 0l;
+    }
+
+    entry_private* pentry = new (std::nothrow) entry_private;
+    memset(pentry,0,sizeof(entry_private));
+    pentry->accessing=ppp_interface_count;
+    sEntryList.Add(pentry);
+
+    KPPPInterface* device = new (std::nothrow) KPPPInterface(name,
+        pentry,ppp_interface_count,NULL,NULL);
+
+
+    if(device==NULL || pentry==NULL) {
+        TRACE("can not create ppp interface!\n");
+        ppp_interface_count--;
+        return 0l;
+    } else
+        TRACE("create ppp interface:%ld!\n", ppp_interface_count);
+        
+    TRACE("setting ppp_interface_count %ld\n",ppp_interface_count);
+
+    return ppp_interface_count;
+}
+
+
+static bool
+DeleteInterface(ppp_interface_id ID)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    DoublyLinkedList<entry_private>::Iterator iterator
+        = sEntryList.GetIterator();
+    while (iterator.HasNext()) {
+        entry_private* pentry = iterator.Next();
+        if ((ppp_interface_id)pentry->accessing == ID){
+            pentry->deleting=true;
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+
+static bool
+RemoveInterface(ppp_interface_id ID)
+{
+    MutexLocker _(sListLock); // auto_lock
+    if (ID <= 0 || ID > ppp_interface_count)
+        return false;
+
+        DoublyLinkedList<entry_private>::Iterator iterator
+                = sEntryList.GetIterator();
+        while (iterator.HasNext()) {
+                entry_private* pentry = iterator.Next();
+                if ((ppp_interface_id)pentry->accessing==ID){
+            pentry->deleting=true;
+                        break;
+                }
+        }
+    
+    return false;
+}
+
+
+static net_device *
+RegisterInterface(ppp_interface_id ID)
+{
+    // MutexLocker _(sListLock); // auto_lock
+
+    entry_private* entry = NULL;
+
+        DoublyLinkedList<entry_private>::Iterator iterator
+                = sEntryList.GetIterator();
+        while (iterator.HasNext()) {
+                entry_private* pentry = iterator.Next();
+                if ((ppp_interface_id)pentry->accessing==ID){
+            entry = pentry;
+                        break;
+                }
+        }
+
+    if (entry == NULL)
+        return NULL;
+
+    ppp_device *device = new (std::nothrow) ppp_device;
+    if(device==NULL)
+        return NULL;
+
+    memset(device, 0, sizeof(ppp_device));
+    device->KPPP_Interface = entry->interface;
+
+    return device;
+}
+
+
+static KPPPInterface *
+GetInterface(ppp_interface_id ID)
+{
+    // MutexLocker _(sListLock); // auto_lock
+
+        DoublyLinkedList<entry_private>::Iterator iterator
+                = sEntryList.GetIterator();
+        while (iterator.HasNext()) {
+                entry_private* pentry = iterator.Next();
+        TRACE("testing interface id:%ld\n",pentry->accessing);
+                if ((ppp_interface_id)(pentry->accessing)==ID){
+            TRACE("get interface id:%ld\n",ID);
+                        return pentry->interface;
+                }
+        }
+
+    TRACE("can not get interface id:%ld\n",ID);
+
+    return NULL;
+
+}
+
+
+static bool
+UnregisterInterface(ppp_interface_id ID)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    if(ID<=0 || ID>ppp_interface_count)
+        return false;
+    return true;
+}
+
+
+static status_t
+ControlInterface(ppp_interface_id ID, uint32 op, void *data, size_t length)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    if(ID<=0 || ID>ppp_interface_count)
+        return B_ERROR;
+
+        DoublyLinkedList<entry_private>::Iterator iterator
+                = sEntryList.GetIterator();
+        while (iterator.HasNext()) {
+                entry_private* pentry = iterator.Next();
+        if ((ppp_interface_id)pentry->accessing == ID)
+            return B_OK;
+        }
+
+    return B_ERROR;
+}
+
+
+static int32
+GetInterfaces(ppp_interface_id *interfaces, int32 count, ppp_interface_filter filter)
+{
+    MutexLocker _(sListLock);
+
+    if (count<=0 || count>(int32)ppp_interface_count)
+        return(0);
+
+    uint32 ppp_count = 0;
+
+        DoublyLinkedList<entry_private>::Iterator iterator
+                = sEntryList.GetIterator();
+        while (iterator.HasNext()) {
+                entry_private* pentry = iterator.Next();
+        interfaces[ppp_count] = pentry->accessing;
+        ppp_count++;
+        }
+
+    return(ppp_count); 
+}
+
+
+static int32
+CountInterfaces(ppp_interface_filter filter)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    uint32 ppp_count = 0;
+
+        DoublyLinkedList<entry_private>::Iterator iterator
+                = sEntryList.GetIterator();
+        while (iterator.HasNext()) {
+                // entry_private* pentry =
+        iterator.Next();
+        ppp_count++;
+        }
+
+    return(ppp_count); 
+}
+
+
+static void
+EnableReports(ppp_report_type type, thread_id thread, int32 flags)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    return; // need more portrait
+}
+
+
+static void
+DisableReports(ppp_report_type type, thread_id thread)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    return; // need more portrait
+}
+
+
+static bool
+DoesReport(ppp_report_type type, thread_id thread)
+{
+    MutexLocker _(sListLock); // auto_lock
+
+    return false; // need more portrait
+}
+
+
+
+static status_t
+KPPPManager_std_ops(int32 op, ...)
+{
+    switch (op) {
+        case B_MODULE_INIT:
+            mutex_init(&sListLock, "KPPPManager");
+                        new (&sEntryList) DoublyLinkedList<entry_private>;
+                                // static C++ objects are not initialized in the module startup
+            ppp_interface_count = 0;
+            get_module(NET_STACK_MODULE_NAME, (module_info**)&gStackModule);
+            get_module(NET_BUFFER_MODULE_NAME, (module_info**)&gBufferModule);
+            return B_OK;
+
+        case B_MODULE_UNINIT:
+                        mutex_destroy(&sListLock);
+
+            put_module(NET_BUFFER_MODULE_NAME);
+            put_module(NET_STACK_MODULE_NAME);
+            return B_OK;
+
+        default:
+            return B_ERROR;
+    }
+}
+
+
+static ppp_interface_module_info sKPPPManagerModule = {
+    {
+        PPP_INTERFACE_MODULE_NAME,
+        0,
+        KPPPManager_std_ops
+    },
+    CreateInterface,
+    CreateInterfaceWithName,
+    DeleteInterface,
+    RemoveInterface,
+    RegisterInterface,
+    GetInterface,
+    UnregisterInterface,
+    ControlInterface,
+    GetInterfaces,
+    CountInterfaces,
+    EnableReports,
+    DisableReports,
+    DoesReport
+};
+
+
+module_info* modules[] = {
+    (module_info*)&sKPPPManagerModule,
+    NULL
+};

src/add-ons/kernel/network/ppp/ipcp/Jamfile

@@ -3 +3 @@
 SetSubDirSupportedPlatformsBeOSCompatible ;
 
 if $(TARGET_PLATFORM) != haiku {
+        UseHeaders [ FStandardOSHeaders ] : true ;
+                # Needed for the atomic_add64() prototype. :-/
     UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
         # We need the public network headers also when not compiling for Haiku.
         # Unfortunately we get more than we want, namely all POSIX headers.
 }
 
 # for kernel_cpp.h and BLocker
-UseHeaders [ FDirName $(HAIKU_TOP) headers cpp ] : true ;
+# UseHeaders [ FDirName $(HAIKU_TOP) headers cpp ] : true ;
+# UseHeaders [ FDirName $(HAIKU_TOP) headers kernel shared ] : true ;
+UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
+    # for linking inet_addr function
+
+# UsePrivateHeaders shared ;
+UsePrivateKernelHeaders ;
 UsePrivateHeaders net ;
+
+UsePrivateHeaders libroot net ;
 UsePrivateHeaders [ FDirName kernel ] ;
 UsePrivateHeaders [ FDirName kernel util ] ;
 UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared
@@ -23 +33 @@
 
 
 KernelAddon ipcp :
+        atomic.S
+        kernel_cpp.cpp
+
     # imported from libnet
     inet_addr.c
     
@@ -30 +43 @@
     Protocol.cpp
 ;
 
+SEARCH on [ FGristFiles bitypes.h ]
+    = [ FDirName $(HAIKU_TOP) src kits network libbind include sys ] ;
+
+SEARCH on [ FGristFiles port_before.h ]
+    = [ FDirName $(HAIKU_TOP) src kits network libbind ] ;
+
+SEARCH on [ FGristFiles port_after.h ]
+    = [ FDirName $(HAIKU_TOP) src kits network libbind ] ;
+
+SEARCH on [ FGristFiles config.h ]
+    = [ FDirName $(HAIKU_TOP) src kits network libbind ] ;
+
 SEARCH on [ FGristFiles inet_addr.c ]
-    = [ FDirName $(HAIKU_TOP) src kits network compat libnet ] ;
+    = [ FDirName $(HAIKU_TOP) src kits network libbind inet ] ;
+
+SEARCH on [ FGristFiles kernel_cpp.cpp ]
+        = [ FDirName $(HAIKU_TOP) src system kernel util ] ;
+SEARCH on [ FGristFiles atomic.S ]
+        = [ FDirName $(HAIKU_TOP) src system libroot os arch $(TARGET_ARCH) ] ;
 
 LinkAgainst ipcp : libkernelppp.a ;
 
 # Installation
 HaikuInstall install-networking
-    : /boot/home/config/add-ons/kernel/obos_network/ppp
+    : /boot/home/config/add-ons/kernel/haiku_network/ppp
     : ipcp ;
 
 Package haiku-networkingkit-cvs :
     ipcp :
-    boot home config add-ons kernel obos_network ppp ;
+    boot home config add-ons kernel haiku_network ppp ;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

@@ -14 +14 @@
 #include <settings_tools.h>
 
 #include <cstring>
-#include <netinet/in_var.h>
-#include <core_funcs.h>
+
+#include <net/route.h> // for route_entry
+#include <arpa/inet.h>  // for inet_addr
+#include <net_stack.h>
+#include <net_buffer.h>
 #include <sys/sockio.h>
 
+extern net_buffer_module_info *gBufferModule;
+static net_datalink_protocol_module_info *sDatalinkInterfaceProtocolModule; 
+static struct net_datalink_module_info *sDatalinkModule;
+static struct net_stack_module_info *sStackModule;
 
 #if DEBUG
 #include <unistd.h>
@@ -26 +33 @@
     // the file descriptor for debug output
 static char sDigits[] = "0123456789ABCDEF";
 void
-dump_packet(struct mbuf *packet, const char *direction)
+dump_packet(net_buffer *packet, const char *direction)
 {
     if(!packet)
         return;
-    
+
     uint8 *data = mtod(packet, uint8*);
     uint8 buffer[128];
     uint8 bufferIndex = 0;
-    
+
     sprintf((char*) buffer, "Dumping %s packet;len=%ld;pkthdr.len=%d\n", direction,
         packet->m_len, packet->m_flags & M_PKTHDR ? packet->m_pkthdr.len : -1);
     write(sFD, buffer, strlen((char*) buffer));
-    
+
     for(uint32 index = 0; index < packet->m_len; index++) {
         buffer[bufferIndex++] = sDigits[data[index] >> 4];
         buffer[bufferIndex++] = sDigits[data[index] & 0x0F];
@@ -75 +82 @@
     // reset configurations
     memset(&fLocalConfiguration, 0, sizeof(ipcp_configuration));
     memset(&fPeerConfiguration, 0, sizeof(ipcp_configuration));
-    
+
     // reset requests
     memset(&fLocalRequests, 0, sizeof(ipcp_requests));
     memset(&fPeerRequests, 0, sizeof(ipcp_requests));
-    
+
     // Parse settings:
     // "Local" and "Peer" describe each side's settings
     ParseSideRequests(get_parameter_with_name(IPCP_LOCAL_SIDE_KEY, Settings()),
         PPP_LOCAL_SIDE);
     ParseSideRequests(get_parameter_with_name(IPCP_PEER_SIDE_KEY, Settings()),
         PPP_PEER_SIDE);
-    
+
+    get_module(NET_DATALINK_MODULE_NAME, (module_info **)&sDatalinkModule);
+    get_module(NET_STACK_MODULE_NAME, (module_info **)&sStackModule);
+    get_module(NET_DATA_LINK_INTERFACE_MODULE_NAME, (module_info **)&sDatalinkInterfaceProtocolModule);
 #if DEBUG
     sFD = open("/boot/home/ipcpdebug", O_WRONLY | O_CREAT | O_TRUNC);
 #endif
@@ -95 +105 @@
 
 IPCP::~IPCP()
 {
+
+    put_module(NET_DATALINK_MODULE_NAME);
+    put_module(NET_STACK_MODULE_NAME);
+    put_module(NET_DATA_LINK_INTERFACE_MODULE_NAME);
 #if DEBUG
     close(sFD);
 #endif
@@ -112 +126 @@
 IPCP::StackControl(uint32 op, void *data)
 {
     TRACE("IPCP: StackControl(op=%ld)\n", op);
-    
+
     // TODO:
     // check values
-    
+
     switch(op) {
         case SIOCSIFADDR:
         break;
-        
+
         case SIOCSIFFLAGS:
         break;
-        
+
         case SIOCSIFDSTADDR:
         break;
-        
+
         case SIOCSIFNETMASK:
         break;
-        
+
         default:
             ERROR("IPCP: Unknown ioctl: %ld\n", op);
             return KPPPProtocol::StackControl(op, data);
     }
-    
+
     return B_OK;
 }
 
@@ -142 +156 @@
 IPCP::Up()
 {
     TRACE("IPCP: Up() state=%d\n", State());
-    
+
     // Servers do not send a configure-request when Up() is called. They wait until
     // the client requests this protocol.
     if(Interface().Mode() == PPP_SERVER_MODE)
         return true;
-    
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             NewState(PPP_REQ_SENT_STATE);
             InitializeRestartCount();
             SendConfigureRequest();
         break;
-        
+
         default:
             ;
     }
-    
+
     return true;
 }
 
@@ -167 +181 @@
 IPCP::Down()
 {
     TRACE("IPCP: Down() state=%d\n", State());
-    
+
     switch(Interface().Phase()) {
         case PPP_DOWN_PHASE:
             // interface finished terminating
@@ -175 +189 @@
             ReportDownEvent();
                 // this will also reset and update addresses
         break;
-        
+
 /*      case PPP_TERMINATION_PHASE:
             // interface is terminating
         break;
-        
+
         case PPP_ESTABLISHMENT_PHASE:
             // interface is reconfiguring
         break;
-*/      
+*/
         case PPP_ESTABLISHED_PHASE:
             // terminate this NCP individually (block until we finished terminating)
             if(State() != PPP_INITIAL_STATE && State() != PPP_CLOSING_STATE) {
@@ -191 +205 @@
                 InitializeRestartCount();
                 SendTerminateRequest();
             }
-            
+
             while(State() == PPP_CLOSING_STATE)
                 snooze(50000);
         break;
-        
+
         default:
             ;
     }
-    
+
     return true;
 }
 
 
 status_t
-IPCP::Send(struct mbuf *packet, uint16 protocolNumber)
+IPCP::Send(net_buffer *packet, uint16 protocolNumber)
 {
     TRACE("IPCP: Send(0x%X)\n", protocolNumber);
-    
+
     if((protocolNumber == IP_PROTOCOL && State() == PPP_OPENED_STATE)
             || protocolNumber == IPCP_PROTOCOL) {
 #if DEBUG
@@ -217 +231 @@
         Interface().UpdateIdleSince();
         return SendToNext(packet, protocolNumber);
     }
-    
+
     ERROR("IPCP: Send() failed because of wrong state or protocol number!\n");
-    
-    m_freem(packet);
+
+    gBufferModule->free(packet);
     return B_ERROR;
 }
 
 
 status_t
-IPCP::Receive(struct mbuf *packet, uint16 protocolNumber)
+IPCP::Receive(net_buffer *packet, uint16 protocolNumber)
 {
     TRACE("IPCP: Receive(0x%X)\n", protocolNumber);
-    
+
     if(!packet)
         return B_ERROR;
-    
+
     if(protocolNumber == IP_PROTOCOL)
         return ReceiveIPPacket(packet, protocolNumber);
-    
+
     if(protocolNumber != IPCP_PROTOCOL)
         return PPP_UNHANDLED;
-    
-    ppp_lcp_packet *data = mtod(packet, ppp_lcp_packet*);
-    
-    // remove padding
-    int32 length = packet->m_len;
-    if(packet->m_flags & M_PKTHDR)
-        length = packet->m_pkthdr.len;
-    length -= ntohs(data->length);
-    if(length)
-        m_adj(packet, -length);
-    
-    if(ntohs(data->length) < 4)
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
         return B_ERROR;
-    
+    ppp_lcp_packet &data = bufferheader.Data();
+
+    // // remove padding
+    // int32 length = packet->m_len;
+    // if(packet->m_flags & M_PKTHDR)
+    //  length = packet->m_pkthdr.len;
+    // length -= ntohs(data.length);
+    // if(length)
+    //  m_adj(packet, -length);
+
+    if(ntohs(data.length) < 4)
+        return B_ERROR;
+
     // packet is freed by event methods
-    switch(data->code) {
+    switch(data.code) {
         case PPP_CONFIGURE_REQUEST:
             RCREvent(packet);
         break;
-        
+
         case PPP_CONFIGURE_ACK:
             RCAEvent(packet);
         break;
-        
+
         case PPP_CONFIGURE_NAK:
         case PPP_CONFIGURE_REJECT:
             RCNEvent(packet);
         break;
-        
+
         case PPP_TERMINATE_REQUEST:
             RTREvent(packet);
         break;
-        
+
         case PPP_TERMINATE_ACK:
             RTAEvent(packet);
         break;
-        
+
         case PPP_CODE_REJECT:
             RXJBadEvent(packet);
                 // we implemented the minimum requirements
         break;
-        
+
         default:
             RUCEvent(packet);
             return PPP_REJECTED;
     }
-    
+
     return B_OK;
 }
 
 
 status_t
-IPCP::ReceiveIPPacket(struct mbuf *packet, uint16 protocolNumber)
+IPCP::ReceiveIPPacket(net_buffer *packet, uint16 protocolNumber)
 {
     if(protocolNumber != IP_PROTOCOL || State() != PPP_OPENED_STATE)
         return PPP_UNHANDLED;
-    
+
     // TODO: add VJC support (the packet would be decoded here)
-    
-    if (gProto[IPPROTO_IP] && gProto[IPPROTO_IP]->pr_input) {
+
+    if (packet) // gProto[IPPROTO_IP] && gProto[IPPROTO_IP]->pr_input)
+    {
 #if DEBUG
         dump_packet(packet, "incoming");
 #endif
         Interface().UpdateIdleSince();
-        gProto[IPPROTO_IP]->pr_input(packet, 0);
+        // gProto[IPPROTO_IP]->pr_input(packet, 0);
+        TRACE("We got 1 IP packet from %s::%s\n", __FILE__, __func__);
+        gBufferModule->free(packet);
         return B_OK;
     } else {
         ERROR("IPCP: Error: Could not find input function for IP!\n");
-        m_freem(packet);
+        gBufferModule->free(packet);
         return B_ERROR;
     }
 }
@@ -318 +338 @@
     if(fNextTimeout == 0 || fNextTimeout > system_time())
         return;
     fNextTimeout = 0;
-    
+
     switch(State()) {
         case PPP_CLOSING_STATE:
             if(fTerminateCounter <= 0)
@@ -326 +346 @@
             else
                 TOGoodEvent();
         break;
-        
+
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_RCVD_STATE:
         case PPP_ACK_SENT_STATE:
@@ -335 +355 @@
             else
                 TOGoodEvent();
         break;
-        
+
         default:
             ;
     }
@@ -347 +367 @@
 {
     if(!requests)
         return false;
-    
+
     ipcp_requests *selectedRequests;
-    
+
     if(side == PPP_LOCAL_SIDE) {
         selectedRequests = &fLocalRequests;
         fRequestPrimaryDNS = fRequestSecondaryDNS = false;
     } else
         selectedRequests = &fPeerRequests;
-    
+
     memset(selectedRequests, 0, sizeof(ipcp_requests));
         // reset current requests
-    
+
     // The following values are allowed:
     //  "Address"       the ip address that will be suggested
     //  "Netmask"       the netmask that should be used
     //  "PrimaryDNS"    primary DNS server
     //  "SecondaryDNS"  secondary DNS server
     // Setting any value to 0.0.0.0 or "auto" means it should be chosen automatically.
-    
+
     in_addr_t address = INADDR_ANY;
     for(int32 index = 0; index < requests->parameter_count; index++) {
         if(requests->parameters[index].value_count == 0)
             continue;
-        
+
         // all values are IP addresses, so parse the address here
         if(strcasecmp(requests->parameters[index].values[0], "auto")) {
             address = inet_addr(requests->parameters[index].values[0]);
+            // address = INADDR_ANY;
             if(address == INADDR_NONE)
                 continue;
         }
-        
+
         if(!strcasecmp(requests->parameters[index].name, IPCP_IP_ADDRESS_KEY))
             selectedRequests->address = address;
         else if(!strcasecmp(requests->parameters[index].name, IPCP_NETMASK_KEY))
@@ -393 +414 @@
                 fRequestSecondaryDNS = true;
         }
     }
-    
+
     return true;
 }
 
@@ -401 +422 @@
 void
 IPCP::UpdateAddresses()
 {
+    TRACE("%s::%s: entering UpdateAddresses\n",__FILE__,__func__);
     RemoveRoutes();
-    
+
     if(State() != PPP_OPENED_STATE && !Interface().DoesConnectOnDemand())
         return;
-    
-    struct in_aliasreq inreq;
-    struct ifreq ifreqAddress, ifreqDestination;
-    memset(&inreq, 0, sizeof(struct in_aliasreq));
-    memset(&ifreqAddress, 0, sizeof(struct ifreq));
-    memset(&ifreqDestination, 0, sizeof(struct ifreq));
-    memset(&fGateway, 0, sizeof(struct sockaddr_in));
-    
+
+    struct sockaddr newAddr = {6, AF_INET, {0x00,0x00,0x00,0x00,0x00,0x0}};
+        // newAddr.sa_len=8; newAddr.sa_family=AF_INET; newAddr.sa_data
+
     // create local address
-    inreq.ifra_addr.sin_family = AF_INET;
     if(fLocalRequests.address != INADDR_ANY)
-        inreq.ifra_addr.sin_addr.s_addr = fLocalRequests.address;
-    else if(fLocalConfiguration.address == INADDR_ANY)
-        inreq.ifra_addr.sin_addr.s_addr = 0x010F0F0F; // was: INADDR_BROADCAST
-    else
-        inreq.ifra_addr.sin_addr.s_addr = fLocalConfiguration.address;
-    inreq.ifra_addr.sin_len = sizeof(struct sockaddr_in);
-    memcpy(&ifreqAddress.ifr_addr, &inreq.ifra_addr, sizeof(struct sockaddr_in));
-    
-    // create destination address
-    fGateway.sin_family = AF_INET;
-    if(fPeerRequests.address != INADDR_ANY)
-        fGateway.sin_addr.s_addr = fPeerRequests.address;
-    else if(fPeerConfiguration.address == INADDR_ANY)
-        fGateway.sin_addr.s_addr = 0x020F0F0F; // was: INADDR_BROADCAST
-    else
-        fGateway.sin_addr.s_addr = fPeerConfiguration.address;
-    fGateway.sin_len = sizeof(struct sockaddr_in);
-    memcpy(&inreq.ifra_dstaddr, &fGateway,
-        sizeof(struct sockaddr_in));
-    memcpy(&ifreqDestination.ifr_dstaddr, &inreq.ifra_dstaddr,
-        sizeof(struct sockaddr_in));
-    
-    // create netmask
-    inreq.ifra_mask.sin_family = AF_INET;
-    inreq.ifra_mask.sin_addr.s_addr = fLocalRequests.netmask;
-    inreq.ifra_mask.sin_len = sizeof(struct sockaddr_in);
-    
-    // tell stack to use these values
-    if(in_control(NULL, SIOCAIFADDR, (caddr_t) &inreq,
-            Interface().Ifnet()) != B_OK)
-        ERROR("IPCP: UpdateAddress(): SIOCAIFADDR returned error!\n");
-    if(in_control(NULL, SIOCSIFADDR, (caddr_t) &ifreqAddress,
-            Interface().Ifnet()) != B_OK)
-        ERROR("IPCP: UpdateAddress(): SIOCSIFADDR returned error!\n");
-    if(in_control(NULL, SIOCSIFDSTADDR, (caddr_t) &ifreqDestination,
-            Interface().Ifnet()) != B_OK)
-        ERROR("IPCP: UpdateAddress(): SIOCSIFDSTADDR returned error!\n");
-    memcpy(&inreq.ifra_addr, &inreq.ifra_mask, sizeof(struct sockaddr_in));
-        // SIOCISFNETMASK wants the netmask to be in ifra_addr
-    if(in_control(NULL, SIOCSIFNETMASK, (caddr_t) &inreq,
-            Interface().Ifnet()) != B_OK)
-        ERROR("IPCP: UpdateAddress(): SIOCSIFNETMASK returned error!\n");
-    
+        memcpy(newAddr.sa_data+2, &fLocalRequests.address, sizeof(in_addr_t));
+    else if(fLocalConfiguration.address == INADDR_ANY) {
+        in_addr_t inaddr_broadcast = 0x010F0F0F; // was: INADDR_BROADCAST
+        memcpy(newAddr.sa_data+2, &inaddr_broadcast, sizeof(in_addr_t));
+    } else
+        memcpy(newAddr.sa_data+2, &fLocalConfiguration.address, sizeof(in_addr_t));
+
+    TRACE("%s::%s: entering ChangeAddress\n",__FILE__,__func__);
+    if (sDatalinkInterfaceProtocolModule == NULL || sDatalinkModule == NULL) {
+        TRACE("%s::%s: some module not found!\n",__FILE__,__func__);
+        return;
+    }
+
+    net_domain* nd = sStackModule->get_domain(AF_INET);
+    net_interface_address* ppp_interface_address = sDatalinkModule->get_interface_address_by_name(Interface().Name(), nd);
+    if (ppp_interface_address != NULL){
+        TRACE("%s::%s: ppp_interface_address found\n",__FILE__,__func__);
+        sDatalinkInterfaceProtocolModule->change_address(NULL, ppp_interface_address, SIOCSIFADDR, ppp_interface_address->local, &newAddr);
+        // sDatalinkModule->put_interface_address(ppp_interface_address);
+    } else
+        dprintf("%s::%s: ppp_interface_address not found\n",__FILE__,__func__);
+
+    /*
+    struct ifaliasreq inreq;
+    memset(&inreq, 0, sizeof(struct ifaliasreq));
+    memcpy(inreq.ifra_name, Interface().Name(), IF_NAMESIZE);
+
+    struct sockaddr_in netmask;
+    memset(&netmask, 0, sizeof(struct sockaddr_in));
+    netmask.sin_family = AF_INET;
+    netmask.sin_addr.s_addr = fLocalRequests.netmask;
+    netmask.sin_len = sizeof(struct sockaddr_in);
+    memcpy(&inreq.ifra_mask, &netmask, sizeof(struct sockaddr_in));
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(struct sockaddr_in));
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = fLocalRequests.address;
+    addr.sin_len = sizeof(struct sockaddr_in);
+    memcpy(&inreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
+
+    struct sockaddr_in broadaddr;
+    memset(&broadaddr, 0, sizeof(struct sockaddr_in));
+    broadaddr.sin_family = AF_INET;
+    broadaddr.sin_addr.s_addr = fLocalRequests.address | (~fLocalRequests.netmask);
+    broadaddr.sin_len = sizeof(struct sockaddr_in);
+    memcpy(&inreq.ifra_addr, &broadaddr, sizeof(struct sockaddr_in));
+
+    //status_t status = sDatalinkModule->set_interface_address(nd, inreq);
+    status_t status = B_OK;
+    if (status != B_OK){
+        dprintf("%s:%s: sDatalinkModule->set_interface_address\n", __FILE__, __func__);
+        return;
+    }
+    // dprintf("%s:%s: add interface address fine\n", __FILE__, __func__);
+    */
+
+    // struct in_aliasreq inreq;
+    // struct ifreq ifreqAddress, ifreqDestination;
+    // memset(&inreq, 0, sizeof(struct in_aliasreq));
+    // memset(&ifreqAddress, 0, sizeof(struct ifreq));
+    // memset(&ifreqDestination, 0, sizeof(struct ifreq));
+    // memset(&fGateway, 0, sizeof(struct sockaddr_in));
+
+    // // create netmask
+    // inreq.ifra_mask.sin_family = AF_INET;
+    // inreq.ifra_mask.sin_addr.s_addr = fLocalRequests.netmask;
+    // inreq.ifra_mask.sin_len = sizeof(struct sockaddr_in);
+    // 
+    //    tell stack to use these values
+    //    if(in_control(NULL, SIOCAIFADDR, (caddr_t) &inreq,
+    //      Interface().Ifnet()) != B_OK)
+    //  ERROR("IPCP: UpdateAddress(): SIOCAIFADDR returned error!\n");
+    //    if(in_control(NULL, SIOCSIFADDR, (caddr_t) &ifreqAddress,
+    //      Interface().Ifnet()) != B_OK)
+    //  ERROR("IPCP: UpdateAddress(): SIOCSIFADDR returned error!\n");
+    //    if(in_control(NULL, SIOCSIFDSTADDR, (caddr_t) &ifreqDestination,
+    //      Interface().Ifnet()) != B_OK)
+    //  ERROR("IPCP: UpdateAddress(): SIOCSIFDSTADDR returned error!\n");
+    // memcpy(&inreq.ifra_addr, &inreq.ifra_mask, sizeof(struct sockaddr_in));
+    //  SIOCISFNETMASK wants the netmask to be in ifra_addr
+    //    if(in_control(NULL, SIOCSIFNETMASK, (caddr_t) &inreq,
+    //      Interface().Ifnet()) != B_OK)
+    //  ERROR("IPCP: UpdateAddress(): SIOCSIFNETMASK returned error!\n");
+
     // add default/subnet route
     if(Side() == PPP_LOCAL_SIDE) {
-        if(rtrequest(RTM_ADD, (struct sockaddr*) &inreq.ifra_mask,
-                (struct sockaddr*) &fGateway, (struct sockaddr*) &inreq.ifra_mask,
-                RTF_UP | RTF_GATEWAY, &fDefaultRoute) != B_OK)
-            ERROR("IPCP: UpdateAddress(): could not add default/subnet route!\n");
-        
-        --fDefaultRoute->rt_refcnt;
+        // struct sockaddr ethaddr = { 8, AF_INET, {0x00,0x00,0x0a,0x00,0x00,0x00} };
+        struct sockaddr gw_addr = { 8, AF_INET, {0x00,0x00,0x00,0x00,0x00,0x00} };
+        // ethaddr.sa_len=4; ethaddr.sa_family = AF_INET; ethaddr.sa_data={0x85,0xBE,0x00,0x00};
+
+        // create destination address
+        if(fPeerRequests.address != INADDR_ANY)
+            memcpy(gw_addr.sa_data+2, &fPeerRequests.address, sizeof(in_addr_t));
+        else if(fPeerConfiguration.address == INADDR_ANY) {
+            in_addr_t gateway = 0x020F0F0F;
+            memcpy(gw_addr.sa_data+2, &gateway, sizeof(in_addr_t));
+                // was: INADDR_BROADCAST
+        } else
+            memcpy(gw_addr.sa_data+2,&fPeerConfiguration.address,sizeof(in_addr_t));
+
+        // net_domain* nd = sStackModule->get_domain(AF_INET);
+        // net_route* rt = sDatalinkModule->get_route(nd, &ethaddr);
+        net_route dft_rt;
+
+        dft_rt.destination = NULL;
+        dft_rt.mask = NULL;
+        dft_rt.gateway = &gw_addr;
+        dft_rt.flags= RTF_DEFAULT | RTF_GATEWAY;
+        dft_rt.interface_address = ppp_interface_address;//rt->interface_address;
+
+        status_t st = sDatalinkModule->add_route(nd, &dft_rt);
+
+        if(st==B_OK)
+            dprintf("%s::%s: add route default OK!\n",__FILE__,__func__);
+        else
+            dprintf("%s::%s: add route default Fail!\n",__FILE__,__func__);
+
+        // if(rtrequest(RTM_ADD, (struct sockaddr*) &inreq.ifra_mask,
+            // (struct sockaddr*) &fGateway, (struct sockaddr*) &inreq.ifra_mask,
+            // RTF_UP | RTF_GATEWAY, &fDefaultRoute) != B_OK)
+        //  ERROR("IPCP: UpdateAddress(): could not add default/subnet route!\n");
+
+        // --fDefaultRoute->rt_refcnt;
     }
 }
 
@@ -475 +565 @@
 IPCP::RemoveRoutes()
 {
     // note: netstack creates and deletes destination route automatically
-    
+    dprintf("%s::%s: entering RemoveRoutes!\n",__FILE__,__func__);
+
+    struct sockaddr ethaddr = { 8, AF_INET, {0x00,0x00,0x85,0xBD,0x00,0x00} };
+    // ethaddr.sa_len = 4; ethaddr.sa_family = AF_INET; ethaddr.sa_data = {0x85,0xBE,0x00,0x00};
+
+    net_domain* nd = sStackModule->get_domain(AF_INET);
+    net_route* rt = sDatalinkModule->get_route(nd, &ethaddr);
+
+    if(rt == NULL) {
+        dprintf("%s::%s: can not get route 133.189.0.0\n",__FILE__,__func__);
+    } else {
+        dprintf("get route 133.189.0.0!\n");
+        status_t st = sDatalinkModule->remove_route(nd, rt);
+        if(st==B_OK)
+            dprintf("%s::%s: remove route 133.189.0.0 OK!\n",__FILE__,__func__);
+        else
+            dprintf("%s::%s: remove route 133.189.0.0 Fail!\n",__FILE__,__func__);
+    }
+
     if(fDefaultRoute) {
         struct sockaddr_in netmask;
         memset(&netmask, 0, sizeof(struct sockaddr_in));
-        
+
         netmask.sin_family = AF_INET;
         netmask.sin_addr.s_addr = fLocalRequests.netmask;
         netmask.sin_len = sizeof(struct sockaddr_in);
-        
-        if(rtrequest(RTM_DELETE, (struct sockaddr*) &netmask,
-                (struct sockaddr*) &fGateway, (struct sockaddr*) &netmask,
-                RTF_UP | RTF_GATEWAY, &fDefaultRoute) != B_OK)
+
+        // if(rtrequest(RTM_DELETE, (struct sockaddr*) &netmask,
+                // (struct sockaddr*) &fGateway, (struct sockaddr*) &netmask,
+                // RTF_UP | RTF_GATEWAY, &fDefaultRoute) != B_OK)
             ERROR("IPCP: RemoveRoutes(): could not remove default/subnet route!\n");
-        
+
         fDefaultRoute = NULL;
     }
 }
@@ -505 +613 @@
 IPCP::NewState(ppp_state next)
 {
     TRACE("IPCP: NewState(%d) state=%d\n", next, State());
-    
+
     // report state changes
     if(State() == PPP_INITIAL_STATE && next != State())
         UpStarted();
     else if(State() == PPP_OPENED_STATE && next != State())
         DownStarted();
-    
+
     // maybe we do not need the timer anymore
     if(next < PPP_CLOSING_STATE || next == PPP_OPENED_STATE)
         fNextTimeout = 0;
-    
+
     fState = next;
 }
 
@@ -526 +634 @@
 #if DEBUG
 printf("IPCP: TOGoodEvent() state=%d\n", State());
 #endif
-    
+
     switch(State()) {
         case PPP_CLOSING_STATE:
             SendTerminateRequest();
         break;
-        
+
         case PPP_ACK_RCVD_STATE:
             NewState(PPP_REQ_SENT_STATE);
-        
+
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_SENT_STATE:
             SendConfigureRequest();
         break;
-        
+
         default:
             IllegalEvent(PPP_TO_GOOD_EVENT);
     }
@@ -550 +658 @@
 IPCP::TOBadEvent()
 {
     TRACE("IPCP: TOBadEvent() state=%d\n", State());
-    
+
     switch(State()) {
         case PPP_CLOSING_STATE:
             NewState(PPP_INITIAL_STATE);
             ReportDownEvent();
         break;
-        
+
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_RCVD_STATE:
         case PPP_ACK_SENT_STATE:
             NewState(PPP_INITIAL_STATE);
             ReportUpFailedEvent();
         break;
-        
+
         default:
             IllegalEvent(PPP_TO_BAD_EVENT);
     }
@@ -571 +679 @@
 
 
 void
-IPCP::RCREvent(struct mbuf *packet)
+IPCP::RCREvent(net_buffer *packet)
 {
     TRACE("IPCP: RCREvent() state=%d\n", State());
-    
+
     KPPPConfigurePacket request(packet);
     KPPPConfigurePacket nak(PPP_CONFIGURE_NAK);
     KPPPConfigurePacket reject(PPP_CONFIGURE_REJECT);
-    
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+
     // we should not use the same id as the peer
-    if(fID == mtod(packet, ppp_lcp_packet*)->id)
+    if(fID == lcp_hdr.id)
         fID -= 128;
-    
+
     nak.SetID(request.ID());
     reject.SetID(request.ID());
-    
+
     // parse each item
     ppp_configure_item *item;
     in_addr_t *requestedAddress, *wishedAddress = NULL;
@@ -593 +706 @@
         item = request.ItemAt(index);
         if(!item)
             continue;
-        
+
         // addresses have special handling to reduce code size
         switch(item->type) {
             case IPCP_ADDRESSES:
@@ -601 +714 @@
             case IPCP_ADDRESS:
                 wishedAddress = &fPeerRequests.address;
             break;
-            
+
             case IPCP_PRIMARY_DNS:
                 wishedAddress = &fPeerRequests.primaryDNS;
             break;
-            
+
             case IPCP_SECONDARY_DNS:
                 wishedAddress = &fPeerRequests.secondaryDNS;
             break;
         }
-        
+
         // now parse item
         switch(item->type) {
             case IPCP_ADDRESSES:
@@ -620 +733 @@
             case IPCP_SECONDARY_DNS:
                 if(item->length != 6) {
                     // the packet is invalid
-                    m_freem(packet);
+                    gBufferModule->free(packet);
                     NewState(PPP_INITIAL_STATE);
                     ReportUpFailedEvent();
                     return;
                 }
-                
+
                 requestedAddress = (in_addr_t*) item->data;
                 if(*wishedAddress == INADDR_ANY) {
                     if(*requestedAddress == INADDR_ANY) {
                         // we do not have an address for you
-                        m_freem(packet);
+                        gBufferModule->free(packet);
                         NewState(PPP_INITIAL_STATE);
                         ReportUpFailedEvent();
                         return;
@@ -644 +757 @@
                     nak.AddItem((ppp_configure_item*) &ipItem);
                 }
             break;
-            
+
 //          case IPCP_COMPRESSION_PROTOCOL:
                 // TODO: implement me!
 //          break;
-            
+
             default:
                 reject.AddItem(item);
         }
     }
-    
+
     // append additional values to the nak
     if(!request.ItemWithType(IPCP_ADDRESS) && fPeerRequests.address == INADDR_ANY) {
         // The peer did not provide us his address. Tell him to do so.
@@ -663 +776 @@
         ipItem.address = INADDR_ANY;
         nak.AddItem((ppp_configure_item*) &ipItem);
     }
-    
+
     if(nak.CountItems() > 0) {
         RCRBadEvent(nak.ToMbuf(Interface().MRU(), Interface().PacketOverhead()), NULL);
-        m_freem(packet);
+        gBufferModule->free(packet);
     } else if(reject.CountItems() > 0) {
         RCRBadEvent(NULL, reject.ToMbuf(Interface().MRU(),
             Interface().PacketOverhead()));
-        m_freem(packet);
+        gBufferModule->free(packet);
     } else
         RCRGoodEvent(packet);
 }
 
 
 void
-IPCP::RCRGoodEvent(struct mbuf *packet)
+IPCP::RCRGoodEvent(net_buffer *packet)
 {
     TRACE("IPCP: RCRGoodEvent() state=%d\n", State());
-    
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             NewState(PPP_ACK_SENT_STATE);
@@ -688 +801 @@
             SendConfigureRequest();
             SendConfigureAck(packet);
         break;
-        
+
         case PPP_REQ_SENT_STATE:
             NewState(PPP_ACK_SENT_STATE);
-        
+
         case PPP_ACK_SENT_STATE:
             SendConfigureAck(packet);
         break;
-        
+
         case PPP_ACK_RCVD_STATE:
             NewState(PPP_OPENED_STATE);
             SendConfigureAck(packet);
             ReportUpEvent();
         break;
-        
+
         case PPP_OPENED_STATE:
             NewState(PPP_ACK_SENT_STATE);
             SendConfigureRequest();
             SendConfigureAck(packet);
         break;
-        
+
         default:
-            m_freem(packet);
+            gBufferModule->free(packet);
     }
 }
 
 
 void
-IPCP::RCRBadEvent(struct mbuf *nak, struct mbuf *reject)
+IPCP::RCRBadEvent(net_buffer *nak, net_buffer *reject)
 {
     TRACE("IPCP: RCRBadEvent() state=%d\n", State());
-    
+
+    uint16 lcp_hdr_reject_length = 0;
+    uint16 lcp_hdr_nak_length = 0;
+
+    if (nak) {
+        NetBufferHeaderReader<ppp_lcp_packet> bufferheader_nak(nak);
+        if(bufferheader_nak.Status()!=B_OK)
+            return;
+        ppp_lcp_packet &lcp_hdr_nak = bufferheader_nak.Data();
+        lcp_hdr_nak_length = lcp_hdr_nak.length;
+    }
+
+
+    if (reject) {
+        NetBufferHeaderReader<ppp_lcp_packet> bufferheader_reject(reject);
+        if(bufferheader_reject.Status()!=B_OK)
+            return;
+        ppp_lcp_packet &lcp_hdr_reject = bufferheader_reject.Data();
+        lcp_hdr_reject_length = lcp_hdr_reject.length;
+    }
+
     switch(State()) {
         case PPP_OPENED_STATE:
             NewState(PPP_REQ_SENT_STATE);
             SendConfigureRequest();
-        
+
         case PPP_ACK_SENT_STATE:
             if(State() == PPP_ACK_SENT_STATE)
                 NewState(PPP_REQ_SENT_STATE);
                     // OPENED_STATE might have set this already
-        
+
         case PPP_INITIAL_STATE:
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_RCVD_STATE:
-            if(nak && ntohs(mtod(nak, ppp_lcp_packet*)->length) > 3)
+            if(nak && ntohs(lcp_hdr_nak_length) > 3)
                 SendConfigureNak(nak);
-            else if(reject && ntohs(mtod(reject, ppp_lcp_packet*)->length) > 3)
+            else if(reject && ntohs(lcp_hdr_reject_length) > 3)
                 SendConfigureNak(reject);
         return;
             // prevents the nak/reject from being m_freem()'d
-        
+
         default:
             ;
     }
-    
+
     if(nak)
-        m_freem(nak);
+        gBufferModule->free(nak);
     if(reject)
-        m_freem(reject);
+        gBufferModule->free(reject);
 }
 
 
 void
-IPCP::RCAEvent(struct mbuf *packet)
+IPCP::RCAEvent(net_buffer *packet)
 {
-    TRACE("IPCP: RCAEvent() state=%d\n", State());
-    
-    if(fRequestID != mtod(packet, ppp_lcp_packet*)->id) {
+    ERROR("IPCP: RCAEvent() state=%d\n", State());
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+    if(fRequestID != lcp_hdr.id) {
         // this packet is not a reply to our request
-        
+
         // TODO: log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
-    
+
     // parse this ack
     KPPPConfigurePacket ack(packet);
     ppp_configure_item *item;
@@ -771 +908 @@
         item = ack.ItemAt(index);
         if(!item)
             continue;
-        
+
         // addresses have special handling to reduce code size
         switch(item->type) {
             case IPCP_ADDRESSES:
@@ -780 +917 @@
                 wishedAddress = &fLocalRequests.address;
                 configuredAddress = &fLocalConfiguration.address;
             break;
-            
+
             case IPCP_PRIMARY_DNS:
                 wishedAddress = &fLocalRequests.primaryDNS;
                 configuredAddress = &fLocalConfiguration.primaryDNS;
             break;
-            
+
             case IPCP_SECONDARY_DNS:
                 wishedAddress = &fLocalRequests.secondaryDNS;
                 configuredAddress = &fLocalConfiguration.secondaryDNS;
             break;
         }
-        
+
         // now parse item
         switch(item->type) {
             case IPCP_ADDRESSES:
@@ -804 +941 @@
                         || *wishedAddress == *requestedAddress)
                     *configuredAddress = *requestedAddress;
             break;
-            
+
 //          case IPCP_COMPRESSION_PROTOCOL:
                 // TODO: implement me
 //          break;
-            
+
             default:
                 ;
         }
     }
-    
+
     // if address was not specified we should select the given one
     if(!ack.ItemWithType(IPCP_ADDRESS))
         fLocalConfiguration.address = fLocalRequests.address;
-    
-    
+
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             IllegalEvent(PPP_RCA_EVENT);
         break;
-        
+
         case PPP_REQ_SENT_STATE:
             NewState(PPP_ACK_RCVD_STATE);
             InitializeRestartCount();
         break;
-        
+
         case PPP_ACK_RCVD_STATE:
             NewState(PPP_REQ_SENT_STATE);
             SendConfigureRequest();
         break;
-        
+
         case PPP_ACK_SENT_STATE:
             NewState(PPP_OPENED_STATE);
             InitializeRestartCount();
             ReportUpEvent();
         break;
-        
+
         case PPP_OPENED_STATE:
             NewState(PPP_REQ_SENT_STATE);
             SendConfigureRequest();
         break;
-        
+
         default:
             ;
     }
-    
-    m_freem(packet);
+
+    gBufferModule->free(packet);
 }
 
 
 void
-IPCP::RCNEvent(struct mbuf *packet)
+IPCP::RCNEvent(net_buffer *packet)
 {
     TRACE("IPCP: RCNEvent() state=%d\n", State());
-    
-    if(fRequestID != mtod(packet, ppp_lcp_packet*)->id) {
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+
+    if(fRequestID != lcp_hdr.id) {
         // this packet is not a reply to our request
-        
+
         // TODO: log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
-    
+
     // parse this nak/reject
     KPPPConfigurePacket nak_reject(packet);
     ppp_configure_item *item;
@@ -875 +1017 @@
             item = nak_reject.ItemAt(index);
             if(!item)
                 continue;
-            
+
             switch(item->type) {
                 case IPCP_ADDRESSES:
                     // abandoned by the standard
                 case IPCP_ADDRESS:
                     if(item->length != 6)
                         continue;
-                    
+
                     requestedAddress = (in_addr_t*) item->data;
                     if(fLocalRequests.address == INADDR_ANY
                             && *requestedAddress != INADDR_ANY)
                         fLocalConfiguration.address = *requestedAddress;
                             // this will be used in our next request
                 break;
-                
+
 //              case IPCP_COMPRESSION_PROTOCOL:
                     // TODO: implement me!
 //              break;
-                
+
                 case IPCP_PRIMARY_DNS:
                     if(item->length != 6)
                         continue;
-                    
+
                     requestedAddress = (in_addr_t*) item->data;
                     if(fRequestPrimaryDNS
                             && fLocalRequests.primaryDNS == INADDR_ANY
@@ -905 +1047 @@
                         fLocalConfiguration.primaryDNS = *requestedAddress;
                             // this will be used in our next request
                 break;
-                
+
                 case IPCP_SECONDARY_DNS:
                     if(item->length != 6)
                         continue;
-                    
+
                     requestedAddress = (in_addr_t*) item->data;
                     if(fRequestSecondaryDNS
                             && fLocalRequests.secondaryDNS == INADDR_ANY
@@ -917 +1059 @@
                         fLocalConfiguration.secondaryDNS = *requestedAddress;
                             // this will be used in our next request
                 break;
-                
+
                 default:
                     ;
             }
@@ -927 +1069 @@
             item = nak_reject.ItemAt(index);
             if(!item)
                 continue;
-            
+
             switch(item->type) {
 //              case IPCP_COMPRESSION_PROTOCOL:
                     // TODO: implement me!
 //              break;
-                
+
                 default:
                     // DNS and addresses must be supported if we set them to auto
-                    m_freem(packet);
+                    gBufferModule->free(packet);
                     NewState(PPP_INITIAL_STATE);
                     ReportUpFailedEvent();
                     return;
             }
         }
-    
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             IllegalEvent(PPP_RCN_EVENT);
         break;
-        
+
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_SENT_STATE:
             InitializeRestartCount();
-        
+
         case PPP_ACK_RCVD_STATE:
         case PPP_OPENED_STATE:
             if(State() == PPP_ACK_RCVD_STATE || State() == PPP_OPENED_STATE)
                 NewState(PPP_REQ_SENT_STATE);
             SendConfigureRequest();
         break;
-        
+
         default:
             ;
     }
-    
-    m_freem(packet);
+
+    gBufferModule->free(packet);
 }
 
 
 void
-IPCP::RTREvent(struct mbuf *packet)
+IPCP::RTREvent(net_buffer *packet)
 {
     TRACE("IPCP: RTREvent() state=%d\n", State());
-    
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+
     // we should not use the same ID as the peer
-    if(fID == mtod(packet, ppp_lcp_packet*)->id)
+    if(fID == lcp_hdr.id)
         fID -= 128;
-    
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             IllegalEvent(PPP_RTR_EVENT);
         break;
-        
+
         case PPP_ACK_RCVD_STATE:
         case PPP_ACK_SENT_STATE:
             NewState(PPP_REQ_SENT_STATE);
-        
+
         case PPP_CLOSING_STATE:
         case PPP_REQ_SENT_STATE:
             SendTerminateAck(packet);
         return;
-            // do not m_freem() packet
-        
+            // do not free packet
+
         case PPP_OPENED_STATE:
             NewState(PPP_CLOSING_STATE);
             ResetRestartCount();
             SendTerminateAck(packet);
         return;
-            // do not m_freem() packet
-        
+            // do not free packet
+
         default:
             ;
     }
-    
-    m_freem(packet);
+
+    gBufferModule->free(packet);
 }
 
 
 void
-IPCP::RTAEvent(struct mbuf *packet)
+IPCP::RTAEvent(net_buffer *packet)
 {
     TRACE("IPCP: RTAEvent() state=%d\n", State());
-    
-    if(fTerminateID != mtod(packet, ppp_lcp_packet*)->id) {
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+    if(fTerminateID != lcp_hdr.id) {
         // this packet is not a reply to our request
-        
+
         // TODO: log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
-    
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             IllegalEvent(PPP_RTA_EVENT);
         break;
-        
+
         case PPP_CLOSING_STATE:
             NewState(PPP_INITIAL_STATE);
             ReportDownEvent();
         break;
-        
+
         case PPP_ACK_RCVD_STATE:
             NewState(PPP_REQ_SENT_STATE);
         break;
-        
+
         case PPP_OPENED_STATE:
             NewState(PPP_REQ_SENT_STATE);
             SendConfigureRequest();
         break;
-        
+
         default:
             ;
     }
-    
-    m_freem(packet);
+
+    gBufferModule->free(packet);
 }
 
 
 void
-IPCP::RUCEvent(struct mbuf *packet)
+IPCP::RUCEvent(net_buffer *packet)
 {
     TRACE("IPCP: RUCEvent() state=%d\n", State());
-    
+
     SendCodeReject(packet);
 }
 
 
 void
-IPCP::RXJBadEvent(struct mbuf *packet)
+IPCP::RXJBadEvent(net_buffer *packet)
 {
     TRACE("IPCP: RXJBadEvent() state=%d\n", State());
-    
+
     switch(State()) {
         case PPP_INITIAL_STATE:
             IllegalEvent(PPP_RXJ_BAD_EVENT);
         break;
-        
+
         case PPP_CLOSING_STATE:
             NewState(PPP_INITIAL_STATE);
             ReportDownEvent();
         break;
-        
+
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_RCVD_STATE:
         case PPP_ACK_SENT_STATE:
             NewState(PPP_INITIAL_STATE);
             ReportUpFailedEvent();
         break;
-        
+
         case PPP_OPENED_STATE:
             NewState(PPP_CLOSING_STATE);
             InitializeRestartCount();
             SendTerminateRequest();
         break;
-        
+
         default:
             ;
     }
-    
-    m_freem(packet);
+
+    gBufferModule->free(packet);
 }
 
 
@@ -1105 +1256 @@
     // reset configurations
     memset(&fLocalConfiguration, 0, sizeof(ipcp_configuration));
     memset(&fPeerConfiguration, 0, sizeof(ipcp_configuration));
-    
+
     UpdateAddresses();
-    
+
     UpFailedEvent();
 }
 
@@ -1116 +1267 @@
 IPCP::ReportUpEvent()
 {
     UpdateAddresses();
-    
+
     UpEvent();
 }
 
@@ -1127 +1278 @@
     // reset configurations
     memset(&fLocalConfiguration, 0, sizeof(ipcp_configuration));
     memset(&fPeerConfiguration, 0, sizeof(ipcp_configuration));
-    
+
     UpdateAddresses();
-    
+
     DownEvent();
 }
 
@@ -1156 +1307 @@
 IPCP::SendConfigureRequest()
 {
     TRACE("IPCP: SendConfigureRequest() state=%d\n", State());
-    
+
     --fRequestCounter;
     fNextTimeout = system_time() + kIPCPStateMachineTimeout;
-    
+
     KPPPConfigurePacket request(PPP_CONFIGURE_REQUEST);
     request.SetID(NextID());
     fRequestID = request.ID();
     ip_item ipItem;
     ipItem.length = 6;
-    
+
     // add address
     ipItem.type = IPCP_ADDRESS;
     if(fLocalRequests.address == INADDR_ANY)
-        ipItem.address = fLocalConfiguration.address;
+        ipItem.address = (fLocalConfiguration.address);
     else
-        ipItem.address = fLocalRequests.address;
+        ipItem.address =(fLocalRequests.address);
     request.AddItem((ppp_configure_item*) &ipItem);
-    
-    TRACE("IPCP: SCR: confaddr=%lX; reqaddr=%lX; addr=%lX\n",
+
+    TRACE("IPCP: SCR: confaddr=%X; reqaddr=%X; addr=%X\n",
         fLocalConfiguration.address, fLocalRequests.address,
         ((ip_item*)request.ItemAt(0))->address);
-    
+
     // add primary DNS (if needed)
     if(fRequestPrimaryDNS && fLocalRequests.primaryDNS == INADDR_ANY) {
         ipItem.type = IPCP_PRIMARY_DNS;
@@ -1185 +1336 @@
             // at first this is 0.0.0.0, but a nak might have set it to a correct value
         request.AddItem((ppp_configure_item*) &ipItem);
     }
-    
+
     // add secondary DNS (if needed)
     if(fRequestSecondaryDNS && fLocalRequests.primaryDNS == INADDR_ANY) {
         ipItem.type = IPCP_SECONDARY_DNS;
@@ -1193 +1344 @@
             // at first this is 0.0.0.0, but a nak might have set it to a correct value
         request.AddItem((ppp_configure_item*) &ipItem);
     }
-    
+
     // TODO: add VJC support
-    
+
     return Send(request.ToMbuf(Interface().MRU(),
         Interface().PacketOverhead())) == B_OK;
 }
 
 
 bool
-IPCP::SendConfigureAck(struct mbuf *packet)
+IPCP::SendConfigureAck(net_buffer *packet)
 {
     TRACE("IPCP: SendConfigureAck() state=%d\n", State());
-    
+
     if(!packet)
         return false;
-    
-    mtod(packet, ppp_lcp_packet*)->code = PPP_CONFIGURE_ACK;
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return false;
+    ppp_lcp_packet &lcpheader = bufferheader.Data();
+    lcpheader.code = PPP_CONFIGURE_ACK;
+
+    bufferheader.Sync();
+
     KPPPConfigurePacket ack(packet);
-    
+
     // verify items
     ppp_configure_item *item;
     in_addr_t *requestedAddress, *wishedAddress = NULL, *configuredAddress = NULL;
@@ -1219 +1377 @@
         item = ack.ItemAt(index);
         if(!item)
             continue;
-        
+
         // addresses have special handling to reduce code size
         switch(item->type) {
             case IPCP_ADDRESSES:
@@ -1228 +1386 @@
                 wishedAddress = &fPeerRequests.address;
                 configuredAddress = &fPeerConfiguration.address;
             break;
-            
+
             case IPCP_PRIMARY_DNS:
                 wishedAddress = &fPeerRequests.primaryDNS;
                 configuredAddress = &fPeerConfiguration.primaryDNS;
             break;
-            
+
             case IPCP_SECONDARY_DNS:
                 wishedAddress = &fPeerRequests.secondaryDNS;
                 configuredAddress = &fPeerConfiguration.secondaryDNS;
             break;
         }
-        
+
         // now parse item
         switch(item->type) {
             case IPCP_ADDRESSES:
@@ -1252 +1410 @@
                         || *wishedAddress == *requestedAddress)
                     *configuredAddress = *requestedAddress;
             break;
-            
+
 //          case IPCP_COMPRESSION_PROTOCOL:
                 // TODO: implement me!
 //          break;
-            
+
             default:
                 ;
         }
     }
-    
+
     // if address was not specified we should select the given one
     if(!ack.ItemWithType(IPCP_ADDRESS))
         fPeerConfiguration.address = fPeerRequests.address;
-    
+
     return Send(packet) == B_OK;
 }
 
 
 bool
-IPCP::SendConfigureNak(struct mbuf *packet)
+IPCP::SendConfigureNak(net_buffer *packet)
 {
     TRACE("IPCP: SendConfigureNak() state=%d\n", State());
-    
+
     if(!packet)
         return false;
-    
-    ppp_lcp_packet *nak = mtod(packet, ppp_lcp_packet*);
-    if(nak->code == PPP_CONFIGURE_NAK) {
+
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return false;
+
+    ppp_lcp_packet &nak = bufferheader.Data();
+
+    if(nak.code == PPP_CONFIGURE_NAK) {
         if(fNakCounter == 0) {
             // We sent enough naks. Let's try a reject.
-            nak->code = PPP_CONFIGURE_REJECT;
+            nak.code = PPP_CONFIGURE_REJECT;
         } else
             --fNakCounter;
     }
-    
+
+    bufferheader.Sync();
+
     return Send(packet) == B_OK;
 }
 
@@ -1295 +1460 @@
 IPCP::SendTerminateRequest()
 {
     TRACE("IPCP: SendTerminateRequest() state=%d\n", State());
-    
+
     --fTerminateCounter;
     fNextTimeout = system_time() + kIPCPStateMachineTimeout;
-    
-    struct mbuf *packet = m_gethdr(MT_DATA);
+
+    net_buffer *packet = gBufferModule->create(256);
     if(!packet)
         return false;
-    
-    packet->m_pkthdr.len = packet->m_len = 4;
-    
-    // reserve some space for other protocols
-    packet->m_data += Interface().PacketOverhead();
-    
-    ppp_lcp_packet *request = mtod(packet, ppp_lcp_packet*);
+
+    ppp_lcp_packet *request;
+    status_t status = gBufferModule->append_size(packet,1492,(void **)(&request));
+    if(status!=B_OK)
+        return false;
+
     request->code = PPP_TERMINATE_REQUEST;
     request->id = fTerminateID = NextID();
     request->length = htons(4);
-    
+
+    status=gBufferModule->trim(packet,4);
+    if(status!=B_OK)
+        return false;
+
     return Send(packet) == B_OK;
 }
 
 
 bool
-IPCP::SendTerminateAck(struct mbuf *request)
+IPCP::SendTerminateAck(net_buffer *request)
 {
     TRACE("IPCP: SendTerminateAck() state=%d\n", State());
-    
-    struct mbuf *reply = request;
-    
-    ppp_lcp_packet *ack;
-    
+
+    net_buffer *reply = request;
+
     if(!reply) {
-        reply = m_gethdr(MT_DATA);
-        if(!reply)
+        reply = gBufferModule->create(256);
+        ppp_lcp_packet *ack;
+        status_t status = gBufferModule->append_size(reply,1492,(void **)(&ack) );
+        if (status != B_OK) {
+            gBufferModule->free(reply);
             return false;
-        
-        reply->m_data += Interface().PacketOverhead();
-        reply->m_pkthdr.len = reply->m_len = 4;
-        
-        ack = mtod(reply, ppp_lcp_packet*);
+        }
         ack->id = NextID();
-    } else
-        ack = mtod(reply, ppp_lcp_packet*);
-    
-    ack->code = PPP_TERMINATE_ACK;
-    ack->length = htons(4);
-    
+        ack->code = PPP_TERMINATE_ACK;
+        ack->length = htons(4);
+        gBufferModule->trim(reply,4);
+    } else {
+        NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(reply);
+        if (bufferHeader.Status() < B_OK)
+            return false;
+        ppp_lcp_packet &ack = bufferHeader.Data();  
+        ack.code = PPP_TERMINATE_ACK;
+        ack.length = htons(4);
+    }
+
     return Send(reply) == B_OK;
 }
 
 
 bool
-IPCP::SendCodeReject(struct mbuf *packet)
+IPCP::SendCodeReject(net_buffer *packet)
 {
     TRACE("IPCP: SendCodeReject() state=%d\n", State());
-    
+
     if(!packet)
         return false;
-    
-    M_PREPEND(packet, 4);
-        // add some space for the header
-    
-    // adjust packet if too big
-    int32 adjust = Interface().MRU();
-    if(packet->m_flags & M_PKTHDR) {
-        adjust -= packet->m_pkthdr.len;
-    } else
-        adjust -= packet->m_len;
-    
-    if(adjust < 0)
-        m_adj(packet, adjust);
-    
-    ppp_lcp_packet *reject = mtod(packet, ppp_lcp_packet*);
-    reject->code = PPP_CODE_REJECT;
-    reject->id = NextID();
-    if(packet->m_flags & M_PKTHDR)
-        reject->length = htons(packet->m_pkthdr.len);
-    else
-        reject->length = htons(packet->m_len);
-    
+
+    NetBufferPrepend<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() != B_OK)
+        return false;
+
+    ppp_lcp_packet &reject = bufferHeader.Data();
+
+    reject.code = PPP_CODE_REJECT;
+    reject.id = NextID();
+    reject.length = htons(packet->size);
+
+    bufferHeader.Sync();
+
     return Send(packet) == B_OK;
 }

src/add-ons/kernel/network/ppp/ipcp/Protocol.h

@@ -9 +9 @@
 #include <driver_settings.h>
 
 #include <KPPPProtocol.h>
-#include <Locker.h>
 
 #include <arpa/inet.h>
+#include <net_datalink.h>
+#include <net_datalink_protocol.h>
+#include <net/route.h>
 
 
 #define IPCP_PROTOCOL   0x8021
@@ -71 +73 @@
         virtual bool Up();
         virtual bool Down();
         
-        virtual status_t Send(struct mbuf *packet,
+        virtual status_t Send(net_buffer *packet,
             uint16 protocolNumber = IPCP_PROTOCOL);
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber);
-        status_t ReceiveIPPacket(struct mbuf *packet, uint16 protocolNumber);
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber);
+        status_t ReceiveIPPacket(net_buffer *packet, uint16 protocolNumber);
         virtual void Pulse();
 
     private:
@@ -90 +92 @@
         // events
         void TOGoodEvent();
         void TOBadEvent();
-        void RCREvent(struct mbuf *packet);
-        void RCRGoodEvent(struct mbuf *packet);
-        void RCRBadEvent(struct mbuf *nak, struct mbuf *reject);
-        void RCAEvent(struct mbuf *packet);
-        void RCNEvent(struct mbuf *packet);
-        void RTREvent(struct mbuf *packet);
-        void RTAEvent(struct mbuf *packet);
-        void RUCEvent(struct mbuf *packet);
-        void RXJBadEvent(struct mbuf *packet);
+        void RCREvent(net_buffer *packet);
+        void RCRGoodEvent(net_buffer *packet);
+        void RCRBadEvent(net_buffer *nak, net_buffer *reject);
+        void RCAEvent(net_buffer *packet);
+        void RCNEvent(net_buffer *packet);
+        void RTREvent(net_buffer *packet);
+        void RTAEvent(net_buffer *packet);
+        void RUCEvent(net_buffer *packet);
+        void RXJBadEvent(net_buffer *packet);
         
         // actions
         void IllegalEvent(ppp_event event);
@@ -108 +110 @@
         void InitializeRestartCount();
         void ResetRestartCount();
         bool SendConfigureRequest();
-        bool SendConfigureAck(struct mbuf *packet);
-        bool SendConfigureNak(struct mbuf *packet);
+        bool SendConfigureAck(net_buffer *packet);
+        bool SendConfigureNak(net_buffer *packet);
         bool SendTerminateRequest();
-        bool SendTerminateAck(struct mbuf *request = NULL);
-        bool SendCodeReject(struct mbuf *packet);
+        bool SendTerminateAck(net_buffer *request = NULL);
+        bool SendCodeReject(net_buffer *packet);
 
     private:
         ipcp_configuration fLocalConfiguration, fPeerConfiguration;
@@ -120 +122 @@
         
         // default route
         struct sockaddr_in fGateway;
-        rtentry *fDefaultRoute;
+        net_route *fDefaultRoute;
         
         // used for local requests
         bool fRequestPrimaryDNS, fRequestSecondaryDNS;

new file src/add-ons/kernel/network/ppp/ipcp/bitypes.h

@@ +1 @@
+#include <stdint.h>

new file src/add-ons/kernel/network/ppp/ipcp/config.h

@@ +1 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* #undef _SOCKADDR_LEN */
+#define HAVE_FCNTL_H 1
+#define HAVE_PATHS_H 1
+#define HAVE_INTTYPES_H 1
+/* #undef HAVE_STROPTS_H */
+/* #undef HAVE_SYS_TIMERS_H */
+#define HAVE_SYS_SELECT_H 1
+#define HAVE_MEMORY_H 1
+/* #undef SYS_CDEFS_H */
+/* #undef _POSIX_PTHREAD_SEMANTICS */
+/* #undef POSIX_GETPWUID_R */
+/* #undef POSIX_GETPWNAM_R */
+/* #undef POSIX_GETGRGID_R */
+/* #undef POSIX_GETGRNAM_R */
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMCHR 1
+/* #undef SPRINTF_CHAR */
+/* #undef VSPRINTF_CHAR */
+#define USE_SYSERROR_LIST 1
+/* #undef NEED_STRTOUL */
+/* #undef NEED_SUN4PROTOS */
+/* #undef REENABLE_SEND */
+
+#define NEED_SETGROUPENT 1
+/* #undef NEED_GETGROUPLIST */
+
+/* define if prototype for getgrnam_r() is required */
+/* #undef NEED_GETGRNAM_R */
+/* #undef NEED_GETGRGID_R */
+/* #undef NEED_GETGRENT_R */
+#define NEED_SETGRENT_R 1
+#define NEED_ENDGRENT_R 1
+
+#define NEED_INNETGR_R 1
+/* #undef NEED_SETNETGRENT_R */
+#define NEED_ENDNETGRENT_R 1
+
+/* #undef NEED_GETPWNAM_R */
+/* #undef NEED_GETPWUID_R */
+#define NEED_SETPWENT_R 1
+#define NEED_SETPASSENT_R 1
+#define NEED_SETPWENT_R 1
+/* #undef NEED_GETPWENT_R */
+#define NEED_ENDPWENT_R 1
+
+#define NEED_SETPASSENT 1
+
+/* #undef HAS_PW_CLASS */
+
+/* #undef ssize_t */
+/* #undef uintptr_t */
+
+/* Shut up warnings about sputaux in stdio.h on BSD/OS pre-4.1 */
+/* #undef SHUTUP_SPUTAUX */
+#ifdef SHUTUP_SPUTAUX
+struct __sFILE;
+extern __inline int __sputaux(int _c, struct __sFILE *_p);
+#endif
+/* #undef BROKEN_IN6ADDR_INIT_MACROS */
+#define HAVE_STRLCAT 1
+/* Shut up warnings about missing braces */
+/* #undef SHUTUP_MUTEX_INITIALIZER */
+#ifdef SHUTUP_MUTEX_INITIALIZER
+#define LIBBIND_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
+#else
+#define LIBBIND_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+#endif
+

src/add-ons/kernel/network/ppp/ipcp/ipcp.cpp

@@ -5 +5 @@
 
 #include <KernelExport.h>
 #include <driver_settings.h>
-#include <core_funcs.h>
-#include <net_module.h>
 
-#include <KPPPInterface.h>
+#include <net_buffer.h>
+#include <net_stack.h>
+#include <NetBufferUtilities.h>
+
+#include <KPPPDefs.h>
 #include <KPPPModule.h>
+#include <KPPPInterface.h>
 
 #include "Protocol.h"
+// #define NET_CORE_MODULE_NAME "net_stack"
+// #define NET_STACK_MODULE_NAME "network/stack/v1"
 
+#define IPCP_MODULE_NAME        NETWORK_MODULES_ROOT "/ppp/ipcp"
 
-#define IPCP_MODULE_NAME        NETWORK_MODULES_ROOT "ppp/ipcp"
-
-struct protosw *gProto[IPPROTO_MAX];
-struct core_module_info *core = NULL;
 status_t std_ops(int32 op, ...);
 
+net_stack_module_info *gStackModule = NULL;
+net_buffer_module_info *gBufferModule = NULL;
+// net_device_module_info *sEthernetModule;
+
+
 
 // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 // TODO: Remove isascii() (needed for inet_aton()) when our kernel is finished!
@@ -28 +35 @@
 int
 isascii(char c)
 {
-    return c & ~0x7f == 0; // If c is a 7 bit value.
+    return ( (c & (~0x7f)) == 0 ); // If c is a 7 bit value.
 }
 // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
@@ -51 +58 @@
         success = mainInterface.AddProtocol(ipcp);
     }
     
-    TRACE("IPCP: add_to(): %s\n",
+    dprintf("IPCP: add_to(): %s\n",
         success && ipcp && ipcp->InitCheck() == B_OK ? "OK" : "ERROR");
     
     return success && ipcp && ipcp->InitCheck() == B_OK;
 }
 
 
+
 static ppp_module_info ipcp_module = {
     {
         IPCP_MODULE_NAME,
@@ -75 +83 @@
 {
     switch(op) {
         case B_MODULE_INIT:
-            if(get_module(NET_CORE_MODULE_NAME, (module_info**) &core) != B_OK)
+            if(get_module(NET_STACK_MODULE_NAME,
+                    (module_info**) &gStackModule) != B_OK)
+                return B_ERROR;
+            if(get_module(NET_BUFFER_MODULE_NAME,
+                                (module_info **)&gBufferModule) != B_OK) {
+                put_module(NET_STACK_MODULE_NAME);
                 return B_ERROR;
-            memset(gProto, 0, sizeof(struct protosw*) * IPPROTO_MAX);
-            add_protosw(gProto, NET_LAYER1);
-        return B_OK;
+            }
+            return B_OK;
+            break;
         
         case B_MODULE_UNINIT:
-            put_module(NET_CORE_MODULE_NAME);
-        break;
+            put_module(NET_BUFFER_MODULE_NAME);
+            put_module(NET_STACK_MODULE_NAME);
+            break;
         
         default:
             return B_ERROR;

new file src/add-ons/kernel/network/ppp/ipcp/port_after.h

@@ +1 @@
+/*
+ * Copyright (C) 2004-2008  Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (C) 2001-2003  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* $Id: port_after.h.in,v 1.60 2008/02/28 05:34:17 marka Exp $ */
+
+#ifndef port_after_h
+#define port_after_h
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#if (!defined(BSD)) || (BSD < 199306)
+#include "bitypes.h"
+#endif
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif /* HAVE_SYS_SELECT_H */
+
+#ifdef REENABLE_SEND
+#undef send
+#endif
+
+#undef NEED_PSELECT
+#define HAVE_SA_LEN 1
+#undef HAVE_MINIMUM_IFREQ
+#undef NEED_DAEMON
+    /* manual Haiku change */
+#define NEED_STRSEP 1
+#undef NEED_STRERROR
+#ifdef NEED_STRERROR
+const char *isc_strerror(int);
+#define strerror isc_strerror
+#endif
+#define HAS_INET6_STRUCTS 1
+#define HAVE_SIN6_SCOPE_ID 1
+#undef NEED_IN6ADDR_ANY
+#define HAS_IN_ADDR6
+#define HAVE_SOCKADDR_STORAGE 1
+#undef NEED_GETTIMEOFDAY
+#define HAVE_STRNDUP 1
+#undef USE_FIONBIO_IOCTL
+#undef INNETGR_ARGS
+#undef SETNETGRENT_ARGS
+#undef USE_IFNAMELINKID
+#define PORT_NONBLOCK O_NONBLOCK
+
+#ifndef _POSIX_PATH_MAX
+#define _POSIX_PATH_MAX 255
+#endif
+#ifndef PATH_MAX
+#define PATH_MAX _POSIX_PATH_MAX
+#endif
+
+/*
+ * We need to know the IPv6 address family number even on IPv4-only systems.
+ * Note that this is NOT a protocol constant, and that if the system has its
+ * own AF_INET6, different from ours below, all of BIND's libraries and
+ * executables will need to be recompiled after the system <sys/socket.h>
+ * has had this type added.  The type number below is correct on most BSD-
+ * derived systems for which AF_INET6 is defined.
+ */
+#ifndef AF_INET6
+#define AF_INET6        24
+#endif
+
+#ifndef PF_INET6
+#define PF_INET6        AF_INET6
+#endif
+
+#ifndef HAS_INET6_STRUCTS
+/* Replace with structure from later rev of O/S if known. */
+struct in6_addr {
+    u_int8_t        s6_addr[16];
+};
+
+#define IN6ADDR_ANY_INIT \
+    {{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}
+
+#define IN6ADDR_LOOPBACK_INIT \
+    {{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}
+
+/* Replace with structure from later rev of O/S if known. */
+struct sockaddr_in6 {
+#ifdef  HAVE_SA_LEN
+    u_int8_t        sin6_len;       /* length of this struct */
+    u_int8_t        sin6_family;    /* AF_INET6 */
+#else
+    u_int16_t       sin6_family;    /* AF_INET6 */
+#endif
+    u_int16_t       sin6_port;      /* transport layer port # */
+    u_int32_t       sin6_flowinfo;  /* IPv6 flow information */
+    struct in6_addr sin6_addr;      /* IPv6 address */
+    u_int32_t       sin6_scope_id;  /* set of interfaces for a scope */
+};
+#endif  /* HAS_INET6_STRUCTS */
+
+#ifdef BROKEN_IN6ADDR_INIT_MACROS
+#undef IN6ADDR_ANY_INIT
+#undef IN6ADDR_LOOPBACK_INIT
+#endif
+
+#ifdef _AIX
+#ifndef IN6ADDR_ANY_INIT
+#define IN6ADDR_ANY_INIT {{{ 0, 0, 0, 0 }}}
+#endif
+#ifndef IN6ADDR_LOOPBACK_INIT
+#if BYTE_ORDER == BIG_ENDIAN
+#define IN6ADDR_LOOPBACK_INIT {{{ 0, 0, 0, 1 }}}
+#else
+#define IN6ADDR_LOOPBACK_INIT {{{0, 0, 0, 0x01000000}}}
+#endif
+#endif
+#endif
+
+#ifdef __HAIKU__
+#define isc_in6addr_any in6addr_any
+#define isc_in6addr_loopback in6addr_loopback
+#endif
+
+#ifndef IN6ADDR_ANY_INIT
+#ifdef s6_addr
+#define IN6ADDR_ANY_INIT \
+    {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}}
+#else
+#define IN6ADDR_ANY_INIT \
+    {{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}
+#endif
+
+#endif
+#ifndef IN6ADDR_LOOPBACK_INIT
+#ifdef s6_addr
+#define IN6ADDR_LOOPBACK_INIT \
+    {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}}
+#else
+#define IN6ADDR_LOOPBACK_INIT \
+    {{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}
+#endif
+#endif
+
+#ifndef HAVE_SOCKADDR_STORAGE
+#define __SS_MAXSIZE 128
+#define __SS_ALLIGSIZE (sizeof (long))
+
+struct sockaddr_storage {
+#ifdef  HAVE_SA_LEN
+    u_int8_t        ss_len;       /* address length */
+    u_int8_t        ss_family;    /* address family */
+    char            __ss_pad1[__SS_ALLIGSIZE - 2 * sizeof(u_int8_t)];
+    long            __ss_align;
+    char            __ss_pad2[__SS_MAXSIZE - 2 * __SS_ALLIGSIZE];
+#else
+    u_int16_t       ss_family;    /* address family */
+    char            __ss_pad1[__SS_ALLIGSIZE - sizeof(u_int16_t)];
+    long            __ss_align;
+    char            __ss_pad2[__SS_MAXSIZE - 2 * __SS_ALLIGSIZE];
+#endif
+};
+#endif
+
+
+#if !defined(HAS_INET6_STRUCTS) || defined(NEED_IN6ADDR_ANY)
+#define in6addr_any isc_in6addr_any
+extern const struct in6_addr in6addr_any;
+#endif
+
+/*
+ * IN6_ARE_ADDR_EQUAL, IN6_IS_ADDR_UNSPECIFIED, IN6_IS_ADDR_V4COMPAT and
+ * IN6_IS_ADDR_V4MAPPED are broken in glibc 2.1.
+ */
+#ifdef __GLIBC__
+#if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 2)
+#undef IN6_ARE_ADDR_EQUAL
+#undef IN6_IS_ADDR_UNSPECIFIED
+#undef IN6_IS_ADDR_V4COMPAT
+#undef IN6_IS_ADDR_V4MAPPED
+#endif
+#endif
+
+#ifndef IN6_ARE_ADDR_EQUAL
+#define IN6_ARE_ADDR_EQUAL(a,b) \
+   (memcmp(&(a)->s6_addr[0], &(b)->s6_addr[0], sizeof(struct in6_addr)) == 0)
+#endif
+
+#ifndef IN6_IS_ADDR_UNSPECIFIED
+#define IN6_IS_ADDR_UNSPECIFIED(a)      \
+    IN6_ARE_ADDR_EQUAL(a, &in6addr_any)
+#endif
+
+#ifndef IN6_IS_ADDR_LOOPBACK
+extern const struct in6_addr isc_in6addr_loopback;
+#define IN6_IS_ADDR_LOOPBACK(a) \
+    IN6_ARE_ADDR_EQUAL(a, &isc_in6addr_loopback)
+#endif
+
+#ifndef IN6_IS_ADDR_V4MAPPED
+#define IN6_IS_ADDR_V4MAPPED(a) \
+    ((a)->s6_addr[0] == 0x00 && (a)->s6_addr[1] == 0x00 && \
+    (a)->s6_addr[2] == 0x00 && (a)->s6_addr[3] == 0x00 && \
+    (a)->s6_addr[4] == 0x00 && (a)->s6_addr[5] == 0x00 && \
+    (a)->s6_addr[6] == 0x00 && (a)->s6_addr[9] == 0x00 && \
+    (a)->s6_addr[8] == 0x00 && (a)->s6_addr[9] == 0x00 && \
+    (a)->s6_addr[10] == 0xff && (a)->s6_addr[11] == 0xff)
+#endif
+
+#ifndef IN6_IS_ADDR_SITELOCAL
+#define IN6_IS_ADDR_SITELOCAL(a)        \
+    (((a)->s6_addr[0] == 0xfe) && (((a)->s6_addr[1] & 0xc0) == 0xc0))
+#endif
+
+#ifndef IN6_IS_ADDR_LINKLOCAL
+#define IN6_IS_ADDR_LINKLOCAL(a)        \
+    (((a)->s6_addr[0] == 0xfe) && (((a)->s6_addr[1] & 0xc0) == 0x80))
+#endif
+
+#ifndef IN6_IS_ADDR_MULTICAST
+#define IN6_IS_ADDR_MULTICAST(a)        ((a)->s6_addr[0] == 0xff)
+#endif
+
+#ifndef __IPV6_ADDR_MC_SCOPE
+#define __IPV6_ADDR_MC_SCOPE(a)         ((a)->s6_addr[1] & 0x0f)
+#endif
+
+#ifndef __IPV6_ADDR_SCOPE_SITELOCAL
+#define __IPV6_ADDR_SCOPE_SITELOCAL 0x05
+#endif
+#ifndef __IPV6_ADDR_SCOPE_ORGLOCAL
+#define __IPV6_ADDR_SCOPE_ORGLOCAL  0x08
+#endif
+
+#ifndef IN6_IS_ADDR_MC_SITELOCAL
+#define IN6_IS_ADDR_MC_SITELOCAL(a)     \
+    (IN6_IS_ADDR_MULTICAST(a) &&    \
+     (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_SITELOCAL))
+#endif
+
+#ifndef IN6_IS_ADDR_MC_ORGLOCAL
+#define IN6_IS_ADDR_MC_ORGLOCAL(a)      \
+    (IN6_IS_ADDR_MULTICAST(a) &&    \
+     (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_ORGLOCAL))
+#endif
+
+#ifndef INADDR_NONE
+#define INADDR_NONE 0xffffffff
+#endif
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 256
+#endif
+
+#ifndef INET6_ADDRSTRLEN
+/* sizeof("aaaa:bbbb:cccc:dddd:eeee:ffff:123.123.123.123") */
+#define INET6_ADDRSTRLEN 46
+#endif
+
+#ifndef MIN
+#define MIN(x,y) (((x) <= (y)) ? (x) : (y))
+#endif
+
+#ifndef MAX
+#define MAX(x,y) (((x) >= (y)) ? (x) : (y))
+#endif
+
+#ifdef NEED_DAEMON
+int daemon(int nochdir, int noclose);
+#endif
+
+#ifdef NEED_STRSEP
+char * strsep(char **stringp, const char *delim);
+#endif
+
+#ifndef ALIGN
+#define ALIGN(p) (((uintptr_t)(p) + (sizeof(long) - 1)) & ~(sizeof(long) - 1))
+#endif
+
+#ifdef NEED_SETGROUPENT
+int setgroupent(int stayopen);
+#endif
+
+#ifdef NEED_GETGROUPLIST
+int getgrouplist(GETGROUPLIST_ARGS);
+#endif
+
+#ifdef POSIX_GETGRNAM_R
+int
+__posix_getgrnam_r(const char *, struct group *, char *, int, struct group **);
+#endif
+
+#ifdef NEED_GETGRNAM_R
+int
+getgrnam_r(const char *,  struct group *, char *, size_t, struct group **);
+#endif
+
+#ifdef POSIX_GETGRGID_R
+int
+__posix_getgrgid_r(gid_t, struct group *, char *, int, struct group **) ;
+#endif
+
+#ifdef NEED_GETGRGID_R
+int
+getgrgid_r(gid_t, struct group *, char *, size_t, struct group **);
+#endif
+
+#ifdef NEED_GETGRENT_R
+GROUP_R_RETURN getgrent_r(struct group *gptr, GROUP_R_ARGS);
+#endif
+
+#ifdef NEED_SETGRENT_R
+GROUP_R_SET_RETURN setgrent_r(GROUP_R_ENT_ARGS);
+#endif
+
+#ifdef NEED_ENDGRENT_R
+GROUP_R_END_RETURN endgrent_r(GROUP_R_ENT_ARGS);
+#endif
+
+#if defined(NEED_INNETGR_R) && defined(NGR_R_RETURN)
+NGR_R_RETURN
+innetgr_r(const char *, const char *, const char *, const char *);
+#endif
+
+#ifdef NEED_SETNETGRENT_R
+#ifdef NGR_R_SET_ARGS
+NGR_R_SET_RETURN setnetgrent_r(NGR_R_SET_CONST char *netgroup, NGR_R_SET_ARGS);
+#else
+NGR_R_SET_RETURN setnetgrent_r(NGR_R_SET_CONST char *netgroup);
+#endif
+#endif
+
+#ifdef NEED_ENDNETGRENT_R
+#ifdef NGR_R_END_ARGS
+NGR_R_END_RETURN endnetgrent_r(NGR_R_END_ARGS);
+#else
+NGR_R_END_RETURN endnetgrent_r(void);
+#endif
+#endif
+
+#ifdef POSIX_GETPWNAM_R
+int
+__posix_getpwnam_r(const char *login,  struct passwd *pwptr,
+        char *buf, size_t buflen, struct passwd **result);
+#endif
+
+#ifdef NEED_GETPWNAM_R
+int
+getpwnam_r(const char *login,  struct passwd *pwptr,
+        char *buf, size_t buflen, struct passwd **result);
+#endif
+
+#ifdef POSIX_GETPWUID_R
+int
+__posix_getpwuid_r(uid_t uid, struct passwd *pwptr,
+        char *buf, int buflen, struct passwd **result);
+#endif
+
+#ifdef NEED_GETPWUID_R
+int
+getpwuid_r(uid_t uid, struct passwd *pwptr,
+        char *buf, size_t buflen, struct passwd **result);
+#endif
+
+#ifdef NEED_SETPWENT_R
+#ifdef PASS_R_ENT_ARGS
+PASS_R_SET_RETURN setpwent_r(PASS_R_ENT_ARGS);
+#else
+PASS_R_SET_RETURN setpwent_r(void);
+#endif
+
+#endif
+
+#ifdef NEED_SETPASSENT_R
+#ifdef PASS_R_ENT_ARGS
+PASS_R_SET_RETURN setpassent_r(int stayopen, PASS_R_ENT_ARGS);
+#else
+PASS_R_SET_RETURN setpassent_r(int stayopen);
+#endif
+#endif
+
+#ifdef NEED_GETPWENT_R
+PASS_R_RETURN getpwent_r(struct passwd *pwptr, PASS_R_ARGS);
+#endif
+
+#ifdef NEED_ENDPWENT_R
+void endpwent_r(void);
+#endif
+
+#ifdef NEED_SETPASSENT
+int setpassent(int stayopen);
+#endif
+
+#ifndef __HAIKU__
+#define gettimeofday isc__gettimeofday
+#ifdef NEED_GETTIMEOFDAY
+int isc__gettimeofday(struct timeval *tvp, struct _TIMEZONE *tzp);
+#else
+int isc__gettimeofday(struct timeval *tp, struct timezone *tzp);
+#endif
+#endif
+
+int getnetgrent(NGR_R_CONST char **machinep, NGR_R_CONST char **userp,
+        NGR_R_CONST char **domainp);
+
+#ifdef NGR_R_ARGS
+int getnetgrent_r(NGR_R_CONST char **machinep, NGR_R_CONST char **userp,
+          NGR_R_CONST char **domainp, NGR_R_ARGS);
+#endif
+
+#ifdef SETNETGRENT_ARGS
+void setnetgrent(SETNETGRENT_ARGS);
+#else
+void setnetgrent(const char *netgroup);
+#endif
+
+void endnetgrent(void);
+
+#ifdef INNETGR_ARGS
+int innetgr(INNETGR_ARGS);
+#else
+int innetgr(const char *netgroup, const char *machine,
+        const char *user, const char *domain);
+#endif
+
+#ifdef NGR_R_SET_ARGS
+NGR_R_SET_RETURN
+setnetgrent_r(NGR_R_SET_CONST char *netgroup, NGR_R_SET_ARGS);
+#else
+NGR_R_SET_RETURN
+setnetgrent_r(NGR_R_SET_CONST char *netgroup);
+#endif
+
+#ifdef NEED_STRTOUL
+unsigned long strtoul(const char *, char **, int);
+#endif
+
+#ifdef NEED_SUN4PROTOS
+#include <stdarg.h>
+#ifndef __SIZE_TYPE__
+#define __SIZE_TYPE__ int
+#endif
+struct sockaddr;
+struct iovec;
+struct timeval;
+struct timezone;
+int fprintf(FILE *, const char *, ...);
+int getsockname(int, struct sockaddr *, int *);
+int getpeername(int, struct sockaddr *, int *);
+int socket(int, int, int);
+int connect(int, const struct sockaddr *, int);
+int writev(int, struct iovec *, int);
+int readv(int, struct iovec *, int);
+int send(int, const char *, int, int);
+void bzero(char *, int);
+int recvfrom(int, char *, int, int, struct sockaddr *, int *);
+int syslog(int, const char *, ... );
+int printf(const char *, ...);
+__SIZE_TYPE__ fread(void *, __SIZE_TYPE__, __SIZE_TYPE__, FILE *);
+__SIZE_TYPE__ fwrite(const void *, __SIZE_TYPE__, __SIZE_TYPE__, FILE *);
+int fclose(FILE *);
+int ungetc(int, FILE *);
+int scanf(const char *, ...);
+int sscanf(const char *, const char *, ... );
+int tolower(int);
+int toupper(int);
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, int);
+int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
+#ifdef gettimeofday
+#undef gettimeofday
+int gettimeofday(struct timeval *, struct timezone *);
+#define gettimeofday isc__gettimeofday
+#else
+int gettimeofday(struct timeval *, struct timezone *);
+#endif
+long strtol(const char*, char **, int);
+int fseek(FILE *, long, int);
+int setsockopt(int, int, int, const char *, int);
+int bind(int, const struct sockaddr *, int);
+void bcopy(char *, char *, int);
+int fputc(char, FILE *);
+int listen(int, int);
+int accept(int, struct sockaddr *, int *);
+int getsockopt(int, int, int, char *, int *);
+int vfprintf(FILE *, const char *, va_list);
+int fflush(FILE *);
+int fgetc(FILE *);
+int fputs(const char *, FILE *);
+int fchown(int, int, int);
+void setbuf(FILE *, char *);
+int gethostname(char *, int);
+int rename(const char *, const char *);
+time_t time(time_t *);
+int fscanf(FILE *, const char *, ...);
+int sscanf(const char *, const char *, ...);
+int ioctl(int, int, caddr_t);
+void perror(const char *);
+
+#if !defined(__USE_FIXED_PROTOTYPES__) && !defined(__cplusplus) && !defined(__STRICT_ANSI__)
+/*
+ * 'gcc -ansi' changes the prototype for vsprintf().
+ * Use this prototype when 'gcc -ansi' is not in effect.
+ */
+char *vsprintf(char *, const char *, va_list);
+#endif
+#endif
+
+#endif

new file src/add-ons/kernel/network/ppp/ipcp/port_before.h

@@ +1 @@
+/*
+ * Copyright (C) 2005-2008  Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (C) 2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* $Id: port_before.h.in,v 1.31 2008/02/28 05:36:10 marka Exp $ */
+
+#ifndef port_before_h
+#define port_before_h
+#include "config.h"
+
+#ifdef NEED_SUN4PROTOS
+#define _PARAMS(x) x
+#endif
+
+#ifdef __HAIKU__
+#   include <sys/sockio.h>
+#   define ETOOMANYREFS EBADF
+
+// inet_*() are just weak symbols
+#   define  inet_addr       __inet_addr
+#   define  inet_aton       __inet_aton
+#   define  inet_lnaof      __inet_lnaof
+#   define  inet_makeaddr   __inet_makeaddr
+#   define  inet_neta       __inet_neta
+#   define  inet_netof      __inet_netof
+#   define  inet_network    __inet_network
+#   define  inet_net_ntop   __inet_net_ntop
+#   define  inet_net_pton   __inet_net_pton
+#   define  inet_cidr_ntop  __inet_cidr_ntop
+#   define  inet_cidr_pton  __inet_cidr_pton
+#   define  inet_ntoa       __inet_ntoa
+#   define  inet_pton       __inet_pton
+#   define  inet_ntop       __inet_ntop
+#   define  inet_nsap_addr  __inet_nsap_addr
+#   define  inet_nsap_ntoa  __inet_nsap_ntoa
+#endif
+
+struct group;           /* silence warning */
+struct passwd;          /* silence warning */
+struct timeval;         /* silence warning */
+struct timezone;        /* silence warning */
+
+#ifdef HAVE_SYS_TIMERS_H
+#include <sys/timers.h>
+#endif
+#include <limits.h>
+
+#ifdef ISC_PLATFORM_NEEDTIMESPEC
+#include <time.h>       /* For time_t */
+struct timespec {
+    time_t  tv_sec;         /* seconds */
+    long    tv_nsec;        /* nanoseconds */
+};
+#endif
+#ifndef HAVE_MEMMOVE
+#define memmove(a,b,c) bcopy(b,a,c)
+#endif
+
+#undef WANT_IRS_GR
+#undef WANT_IRS_NIS
+#undef WANT_IRS_PW
+
+#undef BSD_COMP
+#undef HAVE_POLL
+#undef HAVE_MD5
+#undef SOLARIS2
+
+#define DO_PTHREADS
+#define GETGROUPLIST_ARGS const char *name, gid_t basegid, gid_t *groups, int *ngroups
+#define GETNETBYADDR_ADDR_T long
+#define SETPWENT_VOID 1
+#define SETGRENT_VOID 1
+
+#define NET_R_ARGS char *buf, int buflen
+#define NET_R_BAD NULL
+#define NET_R_COPY buf, buflen
+#define NET_R_COPY_ARGS NET_R_ARGS
+#define NET_R_END_RESULT(x) /*empty*/
+#define NET_R_END_RETURN void
+#undef NET_R_ENT_ARGS /*empty*/
+#define NET_R_OK nptr
+#define NET_R_RETURN struct netent *
+#undef NET_R_SET_RESULT /*empty*/
+#undef NET_R_SETANSWER
+#define NET_R_SET_RETURN void
+#undef NETENT_DATA
+
+
+#define GROUP_R_SET_RETURN void
+#undef GROUP_R_SET_RESULT /*empty*/
+#define GROUP_R_END_RETURN void
+#define GROUP_R_END_RESULT(x) /*empty*/
+
+#define GROUP_R_ENT_ARGS void
+
+
+
+#define HOST_R_ARGS char *buf, int buflen, int *h_errnop
+#define HOST_R_BAD NULL
+#define HOST_R_COPY buf, buflen
+#define HOST_R_COPY_ARGS char *buf, int buflen
+#define HOST_R_END_RESULT(x) /*empty*/
+#define HOST_R_END_RETURN void
+#undef HOST_R_ENT_ARGS /*empty*/
+#define HOST_R_ERRNO *h_errnop = h_errno
+#define HOST_R_OK hptr
+#define HOST_R_RETURN struct hostent *
+#undef HOST_R_SETANSWER
+#undef HOST_R_SET_RESULT
+#define HOST_R_SET_RETURN void
+#undef HOSTENT_DATA
+
+#define NGR_R_ARGS char *buf, int buflen
+#define NGR_R_BAD (0)
+#define NGR_R_COPY buf, buflen
+#define NGR_R_COPY_ARGS NGR_R_ARGS
+#define NGR_R_CONST
+#define NGR_R_END_RESULT(x)  /*empty*/
+#define NGR_R_END_RETURN void
+#undef NGR_R_END_ARGS /*empty*/
+#define NGR_R_OK 1
+#define NGR_R_RETURN int
+#define NGR_R_SET_CONST const
+#undef NGR_R_SET_RESULT /*empty*/
+#define NGR_R_SET_RETURN void
+#undef NGR_R_SET_ARGS
+
+
+#if !defined(NGR_R_SET_ARGS) && defined(NGR_R_END_ARGS)
+#define NGR_R_SET_ARGS NGR_R_END_ARGS
+#endif
+
+#define PROTO_R_ARGS char *buf, int buflen
+#define PROTO_R_BAD NULL
+#define PROTO_R_COPY buf, buflen
+#define PROTO_R_COPY_ARGS PROTO_R_ARGS
+#define PROTO_R_END_RESULT(x) /*empty*/
+#define PROTO_R_END_RETURN void
+#undef PROTO_R_ENT_ARGS /*empty*/
+#undef PROTO_R_ENT_UNUSED
+#define PROTO_R_OK pptr
+#undef PROTO_R_SETANSWER
+#define PROTO_R_RETURN struct protoent *
+#undef PROTO_R_SET_RESULT
+#define PROTO_R_SET_RETURN void
+#undef PROTOENT_DATA
+
+
+
+
+
+#define PASS_R_END_RESULT(x) /*empty*/
+#define PASS_R_END_RETURN void
+#undef PASS_R_ENT_ARGS
+
+
+#undef PASS_R_SET_RESULT /*empty*/
+#define PASS_R_SET_RETURN void
+
+#define SERV_R_ARGS char *buf, int buflen
+#define SERV_R_BAD NULL
+#define SERV_R_COPY buf, buflen
+#define SERV_R_COPY_ARGS SERV_R_ARGS
+#define SERV_R_END_RESULT(x) /*empty*/
+#define SERV_R_END_RETURN void
+#undef SERV_R_ENT_ARGS /*empty*/
+#undef SERV_R_ENT_UNUSED /*empty*/
+#define SERV_R_OK sptr
+#undef SERV_R_SETANSWER
+#define SERV_R_RETURN struct servent *
+#undef SERV_R_SET_RESULT
+#define SERV_R_SET_RETURN void
+
+
+
+#define DE_CONST(konst, var) \
+    do { \
+        union { const void *k; void *v; } _u; \
+        _u.k = konst; \
+        var = _u.v; \
+    } while (0)
+
+#define UNUSED(x) (x) = (x)
+
+#undef NEED_SOLARIS_BITTYPES
+#define ISC_SOCKLEN_T socklen_t
+
+#ifdef __GNUC__
+#define ISC_FORMAT_PRINTF(fmt, args) \
+    __attribute__((__format__(__printf__, fmt, args)))
+#else
+#define ISC_FORMAT_PRINTF(fmt, args)
+#endif
+
+/* Pull in host order macros when _XOPEN_SOURCE_EXTENDED is defined. */
+#if defined(__hpux) && defined(_XOPEN_SOURCE_EXTENDED)
+#include <sys/byteorder.h>
+#endif
+
+#endif
+
+/*! \file */

src/add-ons/kernel/network/ppp/pap/Jamfile

@@ -9 +9 @@
 }
 
 # for kernel_cpp.h and BLocker
-UseHeaders [ FDirName $(HAIKU_TOP) headers cpp ] : true ;
+# UseHeaders [ FDirName $(HAIKU_TOP) headers cpp ] : true ;
+UsePrivateKernelHeaders ;
+    #for arch_int.h
 UsePrivateHeaders net ;
 UsePrivateHeaders [ FDirName kernel ] ;
 UsePrivateHeaders [ FDirName kernel util ] ;
@@ -31 +33 @@
 
 # Installation
 HaikuInstall install-networking
-    : /boot/home/config/add-ons/kernel/obos_network/ppp
+    : /boot/home/config/add-ons/kernel/haiku_network/ppp
     : pap ;
 
 Package haiku-networkingkit-cvs :
     pap :
-    boot home config add-ons kernel obos_network ppp ;
+    boot home config add-ons kernel haiku_network ppp ;

src/add-ons/kernel/network/ppp/pap/Protocol.cpp

@@ -9 +9 @@
 
 #include <cstring>
 #include <netinet/in.h>
-#include <core_funcs.h>
-#include <sys/sockio.h>
 
+#include <net_buffer.h>
+
+#include <sys/sockio.h>
 
+// static net_buffer_module_info *gBufferModule = NULL;
 static const bigtime_t kPAPTimeout = 3000000;
     // 3 seconds
 
@@ -33 +35 @@
 {
 }
 
+status_t
+PAPHandler::SendingAck(const KPPPConfigurePacket& ack)
+{
+    TRACE("%s::%s: We should activate PAP Protocol here\n", __FILE__, __func__);
+    return KPPPOptionHandler::SendingAck(ack);
+}
+
 
 status_t
 PAPHandler::AddToRequest(KPPPConfigurePacket& request)
@@ -159 +168 @@
 
 
 status_t
-PAP::Send(struct mbuf *packet, uint16 protocolNumber)
+PAP::Send(net_buffer *packet, uint16 protocolNumber)
 {
     // we do not encapsulate PAP packets
-    m_freem(packet);
+    TRACE("PAP: we should not send packet!\n");
+    if (packet != NULL)
+        gBufferModule->free(packet);
     return B_ERROR;
 }
 
 
 status_t
-PAP::Receive(struct mbuf *packet, uint16 protocolNumber)
+PAP::Receive(net_buffer *packet, uint16 protocolNumber)
 {
     if(!packet)
         return B_ERROR;
@@ -176 +187 @@
     if(protocolNumber != PAP_PROTOCOL)
         return PPP_UNHANDLED;
     
-    ppp_lcp_packet *data = mtod(packet, ppp_lcp_packet*);
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return B_ERROR;
+    ppp_lcp_packet &data = bufferheader.Data();
     
     // check if the packet is meant for us:
     // only peer authenticators handle requests
-    if(data->code == PPP_CONFIGURE_REQUEST && Side() != PPP_PEER_SIDE)
+    if(data.code == PPP_CONFIGURE_REQUEST && Side() != PPP_PEER_SIDE)
         return PPP_UNHANDLED;
     // only local authenticators handle acks and naks
-    if((data->code == PPP_CONFIGURE_ACK || data->code == PPP_CONFIGURE_NAK)
+    if((data.code == PPP_CONFIGURE_ACK || data.code == PPP_CONFIGURE_NAK)
             && Side() != PPP_LOCAL_SIDE)
         return PPP_UNHANDLED;
     
     // remove padding
-    int32 length = packet->m_len;
-    if(packet->m_flags & M_PKTHDR)
-        length = packet->m_pkthdr.len;
-    length -= ntohs(data->length);
-    if(length)
-        m_adj(packet, -length);
-    
-    if(ntohs(data->length) < 4)
+    int32 length = packet->size;
+    length -= ntohs(data.length);
+    
+    if(ntohs(data.length) < 4)
         return B_ERROR;
     
     // packet is freed by event methods
     // code values are the same as for LCP (but very reduced)
-    switch(data->code) {
+    switch(data.code) {
         case PPP_CONFIGURE_REQUEST:
             RREvent(packet);
         break;
@@ -320 +330 @@
 
 
 void
-PAP::RREvent(struct mbuf *packet)
+PAP::RREvent(net_buffer *packet)
 {
     TRACE("PAP: RREvent() state=%d\n", State());
     
-    ppp_lcp_packet *request = mtod(packet, ppp_lcp_packet*);
-    int32 length = ntohs(request->length);
-    uint8 *data = request->data;
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &request = bufferheader.Data();
+    int32 length = ntohs(request.length);
+    uint8 *data = request.data;
     uint8 *userLength = data;
     uint8 *passwordLength = data + 1 + data[0];
     
     // make sure the length values are all okay
     if(6 + *userLength + *passwordLength > length) {
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
     
@@ -357 +370 @@
 
 
 void
-PAP::RAEvent(struct mbuf *packet)
+PAP::RAEvent(net_buffer *packet)
 {
     TRACE("PAP: RAEvent() state=%d\n", State());
     
-    if(fRequestID != mtod(packet, ppp_lcp_packet*)->id) {
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+    if(fRequestID != lcp_hdr.id) {
         // this packet is not a reply to our request
         
         // TODO: log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
     
@@ -381 +398 @@
             ;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
 void
-PAP::RNEvent(struct mbuf *packet)
+PAP::RNEvent(net_buffer *packet)
 {
     TRACE("PAP: RNEvent() state=%d\n", State());
     
-    if(fRequestID != mtod(packet, ppp_lcp_packet*)->id) {
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return;
+    ppp_lcp_packet &lcp_hdr = bufferheader.Data();
+    if(fRequestID != lcp_hdr.id) {
         // this packet is not a reply to our request
         
         // TODO: log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
     
@@ -410 +431 @@
             ;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
@@ -429 +450 @@
     --fRequestCounter;
     fNextTimeout = system_time() + kPAPTimeout;
     
-    struct mbuf *packet = m_gethdr(MT_DATA);
+    net_buffer *packet = gBufferModule->create(256);
     if(!packet)
         return false;
-    
+
+    ppp_lcp_packet *request;
+    gBufferModule->append_size(packet,1492,(void **)&request);
+
     const char *username = Interface().Username(), *password = Interface().Password();
+    uint16 pack_len = 6 + strlen(username) + strlen(password);
+        // 6 : lcp header 4 byte + username length 1 byte + password length 1 byte
     
-    packet->m_pkthdr.len = packet->m_len = 6 + strlen(username) + strlen(password);
-    
-    // reserve some space for overhead (we are lazy and reserve too much)
-    packet->m_data += Interface().PacketOverhead();
-    
-    ppp_lcp_packet *request = mtod(packet, ppp_lcp_packet*);
     request->code = PPP_CONFIGURE_REQUEST;
     request->id = fRequestID = NextID();
-    request->length = htons(packet->m_len);
+    request->length = htons(pack_len);
     uint8 *data = request->data;
     data[0] = strlen(username);
     memcpy(data + 1, username, strlen(username));
     data[1 + data[0]] = strlen(password);
     memcpy(data + 2 + data[0], password, strlen(password));
+
+    gBufferModule->trim(packet,pack_len);
     
     return Interface().Send(packet, PAP_PROTOCOL) == B_OK;
 }
 
 
 bool
-PAP::SendAck(struct mbuf *packet)
+PAP::SendAck(net_buffer *packet)
 {
     TRACE("PAP: SendAck() state=%d\n", State());
     
     if(!packet)
         return false;
     
-    ppp_lcp_packet *ack = mtod(packet, ppp_lcp_packet*);
-    ack->code = PPP_CONFIGURE_ACK;
-    packet->m_len = 5;
-    if(packet->m_flags & M_PKTHDR)
-        packet->m_pkthdr.len = 5;
-    ack->length = htons(packet->m_len);
-    
-    ack->data[0] = 0;
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return false;
+    ppp_lcp_packet &ack = bufferheader.Data();
+
+    ack.code = PPP_CONFIGURE_ACK;
+    ack.length = htons(5);
+    ack.data[0] = 0;
+    gBufferModule->trim(packet,5);
+
+    bufferheader.Sync();
     
     return Interface().Send(packet, PAP_PROTOCOL) == B_OK;
 }
 
 
 bool
-PAP::SendNak(struct mbuf *packet)
+PAP::SendNak(net_buffer *packet)
 {
-    TRACE("PAP: SendNak() state=%d\n", State());
+    ERROR("PAP: SendNak() state=%d\n", State());
     
     if(!packet)
         return false;
     
-    ppp_lcp_packet *nak = mtod(packet, ppp_lcp_packet*);
-    nak->code = PPP_CONFIGURE_NAK;
-    packet->m_len = 5;
-    if(packet->m_flags & M_PKTHDR)
-        packet->m_pkthdr.len = 5;
-    nak->length = htons(packet->m_len);
-    
-    nak->data[0] = 0;
+    NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK)
+        return false;
+    ppp_lcp_packet &nak = bufferheader.Data();
+    nak.code = PPP_CONFIGURE_NAK;
+    nak.length = htons(5);
+    nak.data[0] = 0;
+    gBufferModule->trim(packet,5);
     
     return Interface().Send(packet, PAP_PROTOCOL) == B_OK;
 }

src/add-ons/kernel/network/ppp/pap/Protocol.h

@@ -36 +36 @@
             { return fOwner; }
         
         virtual status_t AddToRequest(KPPPConfigurePacket& request);
+        virtual status_t SendingAck(const KPPPConfigurePacket&);
         virtual status_t ParseRequest(const KPPPConfigurePacket& request,
             int32 index, KPPPConfigurePacket& nak, KPPPConfigurePacket& reject);
 
@@ -57 +58 @@
         virtual bool Up();
         virtual bool Down();
         
-        virtual status_t Send(struct mbuf *packet, uint16 protocolNumber);
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber);
+        virtual status_t Send(net_buffer *packet, uint16 protocolNumber);
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber);
         virtual void Pulse();
 
     private:
@@ -70 +71 @@
         // events
         void TOGoodEvent();
         void TOBadEvent();
-        void RREvent(struct mbuf *packet);
-        void RAEvent(struct mbuf *packet);
-        void RNEvent(struct mbuf *packet);
+        void RREvent(net_buffer *packet);
+        void RAEvent(net_buffer *packet);
+        void RNEvent(net_buffer *packet);
         
         // actions
         void ReportUpFailedEvent();
@@ -80 +81 @@
         void ReportDownEvent();
         void InitializeRestartCount();
         bool SendRequest();
-        bool SendAck(struct mbuf *packet);
-        bool SendNak(struct mbuf *packet);
+        bool SendAck(net_buffer *packet);
+        bool SendNak(net_buffer *packet);
 
     private:
         // for state machine

src/add-ons/kernel/network/ppp/pap/pap.cpp

@@ -5 +5 @@
 
 #include <KernelExport.h>
 #include <driver_settings.h>
-#include <core_funcs.h>
-#include <net_module.h>
+
+#include <net_stack.h>
+#include <net_buffer.h>
 
 #include <KPPPInterface.h>
 #include <KPPPModule.h>
 
 #include "Protocol.h"
 
+#define PAP_MODULE_NAME     NETWORK_MODULES_ROOT "/ppp/pap"
 
-#define PAP_MODULE_NAME     NETWORK_MODULES_ROOT "ppp/pap"
-
-struct core_module_info *core = NULL;
+net_stack_module_info *gStackModule = NULL;
+net_buffer_module_info *gBufferModule = NULL;
 status_t std_ops(int32 op, ...);
 
-
-static
-bool
+static bool
 add_to(KPPPInterface& mainInterface, KPPPInterface *subInterface,
     driver_parameter *settings, ppp_module_key_type type)
 {
@@ -62 +61 @@
 {
     switch(op) {
         case B_MODULE_INIT:
-            if(get_module(NET_CORE_MODULE_NAME, (module_info**) &core) != B_OK)
+            if(get_module(NET_STACK_MODULE_NAME, (module_info**) &gStackModule) != B_OK)
+                return B_ERROR;
+            if(get_module(NET_BUFFER_MODULE_NAME,
+                                (module_info **)&gBufferModule) != B_OK) {
+                put_module(NET_STACK_MODULE_NAME);
                 return B_ERROR;
+            }
         return B_OK;
         
         case B_MODULE_UNINIT:
-            put_module(NET_CORE_MODULE_NAME);
+            put_module(NET_BUFFER_MODULE_NAME);
+            put_module(NET_STACK_MODULE_NAME);
         break;
         
         default:

new file src/add-ons/kernel/network/ppp/ppp/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src add-ons kernel network ppp ppp ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+if $(TARGET_PLATFORM) != haiku {
+    UseHeaders [ FStandardOSHeaders ] : true ;
+        # Needed for <support/Errors.h> and maybe other stuff.
+    UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
+        # We need the public network headers also when not compiling for Haiku.
+        # Unfortunately we get more than we want, namely all POSIX headers.
+}
+
+UsePrivateKernelHeaders ;
+UsePrivateHeaders net ;
+UsePrivateHeaders [ FDirName kernel ] ;
+UsePrivateHeaders [ FDirName kernel util ] ;
+
+UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared
+    libkernelppp headers ] : true ;
+
+
+{
+    SubDirC++Flags -fno-rtti ;
+}
+
+
+KernelAddon ppp :
+    ppp.cpp
+;
+
+# Installation
+HaikuInstall install-networking : /boot/home/config/add-ons/kernel/haiku_network/ppp
+    : ppp ;
+
+Package haiku-networkingkit-cvs :
+    haiku :
+    boot home config add-ons kernel haiku_network ppp ;
+

new file src/add-ons/kernel/network/ppp/ppp/ppp.cpp

@@ +1 @@
+/*
+ * Copyright 2006-2009, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Axel Dörfler, axeld@pinc-software.de
+ */
+
+
+#include <ethernet.h>
+#include <ether_driver.h>
+#include <net_datalink_protocol.h>
+#include <net_buffer.h>
+#include <net_device.h>
+#include <net_stack.h>
+#include <NetBufferUtilities.h>
+
+#include <lock.h>
+#include <util/AutoLock.h>
+#include <util/DoublyLinkedList.h>
+
+#include <KernelExport.h>
+
+#include <errno.h>
+#include <ByteOrder.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/if_media.h>
+#include <net/if_types.h>
+#include <new>
+#include <stdlib.h>
+#include <string.h>
+
+#include <KPPPInterface.h>
+#include <KPPPManager.h>
+
+#include <ppp_device.h>
+
+#define PPP_HEADER_LENGTH (8+ETHER_HEADER_LENGTH)
+
+
+net_buffer* create_buffer_for_frame(uint8 *frame, uint16 frame_size);
+
+static const bigtime_t kLinkCheckInterval = 1000000;
+    // 1 second
+// static ppp_device * s_ppp_dev= NULL;
+
+net_buffer_module_info *gBufferModule;
+ppp_interface_module_info* gPPPInterfaceModule;
+// net_device_module_info *sEthernetModule;
+static net_stack_module_info *sStackModule;
+
+static mutex sListLock;
+static DoublyLinkedList<ppp_device> sCheckList;
+static sem_id sLinkChangeSemaphore;
+static thread_id sLinkCheckerThread;
+
+
+
+//  #pragma mark -
+//
+
+status_t
+ppp_init(const char *name, net_device **_device)
+{
+    // ppp device
+    dprintf("%s::%s: entering!\n",__FILE__,__func__);
+    if (strncmp(name, "ppp", 3)) {
+        dprintf("[%s] not ppp device\n",name);
+        return B_BAD_VALUE;
+    }else{
+        dprintf("[%s] is ppp device\n",name);
+    }
+        
+    status_t status = get_module(NET_BUFFER_MODULE_NAME, (module_info **)&gBufferModule);
+    if (status < B_OK)
+        return status;
+
+    // ppp_device *device = new (std::nothrow) ppp_device;
+    ppp_interface_id interface_id = gPPPInterfaceModule->CreateInterfaceWithName(name,0);
+    KPPPInterface * ppp_interface = gPPPInterfaceModule->GetInterface(interface_id);
+
+    if (interface_id <= 0 || ppp_interface==NULL) {
+        if(interface_id<=0)
+            dprintf("%s::%s: interface_id:%ld\n",__FILE__,__func__,interface_id);
+        else
+            dprintf("%s::%s: ppp_interface==NULL %ld\n",__FILE__,__func__,interface_id);
+        put_module(NET_BUFFER_MODULE_NAME);
+        return B_NO_MEMORY;
+    }
+
+    // Ifnet available until interface up phase
+    ppp_device *device = (ppp_device *)ppp_interface->Ifnet();
+    if (device==NULL) {
+        dprintf("%s::%s: can not get ppp_device\n",__FILE__,__func__);
+        put_module(NET_BUFFER_MODULE_NAME);
+        return B_NO_MEMORY;
+    }
+
+    strcpy(device->name, name);
+    device->flags = (IFF_BROADCAST | IFF_LINK) & (~IFF_UP);
+    device->type = IFT_PPP;
+    device->mtu = 1492;
+    device->frame_size = 1500;
+    device->media = IFM_ACTIVE | IFM_ETHER;
+    device->header_length = PPP_HEADER_LENGTH;
+
+    status =sStackModule->init_fifo(&(device->ppp_fifo), "ppp_fifo", 10*1500); //10 ppp at most
+    if (status < B_OK){
+        dprintf("sorry! can not init ppp_fifo\n");
+        return(status);
+    }
+
+    TRACE("[%s] finish\n", "allocate ppp_device");
+    *_device = device;
+
+    return B_OK;
+}
+
+
+status_t
+ppp_uninit(net_device *device)
+{
+    dprintf("%s::%s:  uninit ppp\n",__FILE__,__func__);
+    ppp_device *ppp_dev=(ppp_device *)device;
+
+    sStackModule->uninit_fifo(&(ppp_dev->ppp_fifo));
+    put_module(NET_BUFFER_MODULE_NAME);
+
+    // delete ppp_dev->KPPP_Interface;
+    delete ppp_dev;
+
+    return B_OK;
+}
+
+status_t
+ppp_up(net_device *_device)
+{
+    ppp_device *device = (ppp_device *)_device;
+
+    if (device->KPPP_Interface == NULL) {
+        dprintf("%s::%s: warning! can not find pppinterface KPPP_Interface\n",__FILE__,__func__);
+        return B_ERROR;
+    }
+
+    if(device->KPPP_Interface->Up() != true)
+    {
+        dprintf("%s::%s: warning! KPPP_Interface->Up() failure\n",__FILE__,__func__);
+        return B_ERROR;
+    }
+
+    device->mtu = device->frame_size - device->header_length;
+    // s_pppoe_dev=device;
+
+    dprintf("%s::%s: congratulations! Find pppinterface (device->KPPP_Interface)\n",__FILE__,__func__);
+
+    return B_OK;
+}
+
+
+void
+ppp_down(net_device *_device)
+{
+    dprintf("%s::%s: set ppp down\n",__FILE__,__func__);
+    ppp_device *device = (ppp_device *)_device;
+    device->KPPP_Interface->Down();
+
+    MutexLocker _(sListLock);
+
+    // if the device is still part of the list, remove it
+    if (device->GetDoublyLinkedListLink()->next != NULL
+        || device->GetDoublyLinkedListLink()->previous != NULL
+        || device == sCheckList.Head())
+        sCheckList.Remove(device);
+
+    // device->KPPP_Interface=NULL;
+
+    return;
+}
+
+
+status_t
+ppp_control(net_device *_device, int32 op, void *argument,
+    size_t length)
+{
+    TRACE("%s::%s: ppp control\n",__FILE__,__func__);
+    ppp_device *device = (ppp_device *)_device;
+
+    if (device->KPPP_Interface != NULL){
+        dprintf("ppp's KPPP_Interface is found \n");
+        return B_OK;
+    } else {
+        dprintf("%s::%s: can not find KPPP_Interface for ppp\n",__FILE__,__func__);
+        return B_OK;
+    }
+
+    device->KPPP_Interface->Control(op,argument,length);
+
+    return B_OK;
+}
+
+status_t
+ppp_send_data(net_device *_device, net_buffer *buffer)
+{
+    TRACE("%s::%s: ppp send data\n",__FILE__,__func__);
+    ppp_device *device = (ppp_device *)_device;
+
+    if (buffer->size > device->frame_size || buffer->size < device->header_length){
+        device->stats.send.errors++;
+        dprintf("sorry! we can't send out the ppp packet,size wrong!\n");
+        return B_BAD_VALUE;
+    }
+
+    if (device->KPPP_Interface==NULL) {
+        device->stats.send.errors++;
+        dprintf("sorry! we can't send out the ppp packet,no eth for ppp!\n");
+        return B_BAD_VALUE;
+    }
+
+    device->KPPP_Interface->Send(buffer,0x0021); //IP_PROTOCOL 0x0021
+    // set the size for ppp payload length
+    // uint16 ip_frame_size=buffer->size;
+
+    return B_OK;
+}
+
+status_t
+ppp_receive_data(net_device *_device, net_buffer **_buffer)
+{
+    TRACE("%s::%s:  receive data\n",__FILE__,__func__);
+    ppp_device *device = (ppp_device *)_device;
+
+    if (device->KPPP_Interface == NULL)
+        return B_FILE_ERROR;
+
+    TRACE("%s::%s: trying fifo_dequeue_buffer\n",__FILE__,__func__);
+    status_t status = sStackModule->fifo_dequeue_buffer(&(device->ppp_fifo), 0, 10000000, _buffer);
+
+    if (status < B_OK) {
+        TRACE("sorry! can not fifo_dequeue_buffer!\n");
+        return status;
+    }
+
+    // (*_buffer)->interface_address = NULL; // strange need to put here
+    device->stats.receive.bytes += (*_buffer)->size;
+    device->stats.receive.packets++;
+
+    return B_OK;
+}
+
+
+status_t
+ppp_set_mtu(net_device *_device, size_t mtu)
+{
+    ppp_device *device = (ppp_device *)_device;
+
+    if (mtu > device->frame_size - ETHER_HEADER_LENGTH - 8
+        || mtu <= ETHER_HEADER_LENGTH + 8 + 10)
+        return B_BAD_VALUE;
+
+    device->mtu = mtu;
+    return B_OK;
+}
+
+
+status_t
+ppp_set_promiscuous(net_device *_device, bool promiscuous)
+{
+    return B_NOT_SUPPORTED;
+}
+
+
+status_t
+ppp_set_media(net_device *device, uint32 media)
+{
+    return B_NOT_SUPPORTED;
+}
+
+
+status_t
+ppp_add_multicast(struct net_device *_device, const sockaddr *_address)
+{
+    // ppp_device *device = (ppp_device *)_device;
+
+    if (_address->sa_family != AF_LINK)
+        return B_BAD_VALUE;
+
+    const sockaddr_dl *address = (const sockaddr_dl *)_address;
+    if (address->sdl_type != IFT_ETHER)
+        return B_BAD_VALUE;
+
+    return B_NOT_SUPPORTED;
+}
+
+
+status_t
+ppp_remove_multicast(struct net_device *_device, const sockaddr *_address)
+{
+    // ppp_device *device = (ppp_device *)_device;
+
+    if (_address->sa_family != AF_LINK)
+        return B_BAD_VALUE;
+
+    const sockaddr_dl *address = (const sockaddr_dl *)_address;
+    if (address->sdl_type != IFT_ETHER)
+        return B_BAD_VALUE;
+
+    return B_NOT_SUPPORTED;
+}
+
+
+static status_t
+ppp_std_ops(int32 op, ...)
+{
+    switch (op) {
+        case B_MODULE_INIT:
+        {
+            status_t status = get_module(NET_STACK_MODULE_NAME,
+                (module_info **)&sStackModule);
+            if (status < B_OK)
+                return status;
+
+                        status = get_module(PPP_INTERFACE_MODULE_NAME,
+                                (module_info**)&gPPPInterfaceModule);
+            if (status < B_OK){
+                dprintf("%s::%s: can not get %s module\n",__FILE__,__func__,PPP_INTERFACE_MODULE_NAME);
+                return status;
+            }
+
+            new (&sCheckList) DoublyLinkedList<ppp_device>;
+                // static C++ objects are not initialized in the module startup
+
+            sLinkCheckerThread = -1;
+
+            sLinkChangeSemaphore = create_sem(0, "ppp link change");
+            if (sLinkChangeSemaphore < B_OK) {
+                put_module(NET_STACK_MODULE_NAME);
+                put_module(PPP_INTERFACE_MODULE_NAME);
+                return sLinkChangeSemaphore;
+            }
+
+            mutex_init(&sListLock, "ppp devices");
+
+            return B_OK;
+        }
+
+        case B_MODULE_UNINIT:
+        {
+            delete_sem(sLinkChangeSemaphore);
+
+            status_t status;
+            wait_for_thread(sLinkCheckerThread, &status);
+
+            mutex_destroy(&sListLock);
+            // put_module("network/devices/ethernet/v1");
+                        put_module(PPP_INTERFACE_MODULE_NAME);
+            put_module(NET_STACK_MODULE_NAME);
+            return B_OK;
+        }
+
+        default:
+            return B_ERROR;
+    }
+}
+
+
+net_device_module_info spppModule = {
+    {
+        "network/devices/ppp/v1",
+        0,
+        ppp_std_ops
+    },
+    ppp_init,
+    ppp_uninit,
+    ppp_up,
+    ppp_down,
+    ppp_control,
+    ppp_send_data,
+    ppp_receive_data,
+    ppp_set_mtu,
+    ppp_set_promiscuous,
+    ppp_set_media,
+    ppp_add_multicast,
+    ppp_remove_multicast,
+};
+
+module_info *modules[] = {
+    (module_info *)&spppModule,
+    NULL
+};

new file src/add-ons/kernel/network/ppp/ppp_frame/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src add-ons kernel network ppp ppp_frame ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+if $(TARGET_PLATFORM) != haiku {
+    UseHeaders [ FStandardOSHeaders ] : true ;
+        # Needed for <support/Errors.h> and maybe other stuff.
+    UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
+        # We need the public network headers also when not compiling for Haiku.
+        # Unfortunately we get more than we want, namely all POSIX headers.
+}
+
+UsePrivateKernelHeaders ;
+UsePrivateHeaders kernel net ;
+UsePrivateHeaders [ FDirName kernel ] ;
+UsePrivateHeaders [ FDirName kernel util ] ;
+
+UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared
+    libkernelppp headers ] : true ;
+
+
+{
+    SubDirC++Flags -fno-rtti ;
+}
+
+
+KernelAddon ppp_frame :
+    ppp_frame.cpp
+;
+
+# Installation
+HaikuInstall install-networking : /boot/home/config/add-ons/kernel/haiku_network/ppp
+    : ppp_frame ;
+
+Package haiku-networkingkit-cvs :
+    haiku :
+    boot home config add-ons kernel haiku_network ppp ;
+
+SEARCH on [ FGristFiles kernel_cpp.cpp ]
+    = [ FDirName $(HAIKU_TOP) src system kernel util ] ;

new file src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

@@ +1 @@
+/*
+ * Copyright 2006-2010, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Axel Dörfler, axeld@pinc-software.de
+ */
+
+
+#include <ethernet.h>
+#include <net_datalink_protocol.h>
+#include <net_device.h>
+#include <net_datalink.h>
+#include <net_stack.h>
+#include <NetBufferUtilities.h>
+
+#include <ByteOrder.h>
+#include <KernelExport.h>
+
+#include <lock.h>
+// #include <util/AutoLock.h>
+#include <util/DoublyLinkedList.h>
+
+
+#include <net/if.h>
+#include <net/if_types.h>
+#include <net/if_dl.h>
+#include <new>
+#include <string.h>
+
+#include <KPPPManager.h>
+#include <KPPPInterface.h>
+#include <PPPControl.h>
+
+
+#define TRACE_PPPoED
+// #define TRACE(x) dprintf(x)
+
+struct ppp_device : net_device, DoublyLinkedListLinkImpl<ppp_device> {
+        KPPPInterface *     KPPP_Interface;
+        uint32                  frame_size;
+};
+
+struct ppp_frame_protocol : net_datalink_protocol {
+};
+
+struct net_buffer_module_info* gBufferModule;
+struct ppp_interface_module_info* gPPPInterfaceModule;
+static struct net_interface* sinterface;
+
+status_t
+ppp_deframe(net_device* device, net_buffer* buffer)
+{
+    // dprintf("%s::%s: I am deframeing pppoe frame\n",__FILE__,__FUNCTION__);
+    return B_OK;
+}
+
+//  #pragma mark -
+
+status_t
+ppp_frame_init(struct net_interface* interface, net_domain* domain,
+    net_datalink_protocol** _protocol)
+{
+    // We only support a single type!
+    dprintf("in function: %s::%s\n",__FILE__,__func__);
+    if (interface->device->type != IFT_PPP)
+        return B_BAD_TYPE;
+
+    ppp_frame_protocol* protocol;
+
+    net_stack_module_info* stack;
+    status_t status = get_module(NET_STACK_MODULE_NAME, (module_info**)&stack);
+    if (status != B_OK)
+        return status;
+
+    status = stack->register_device_deframer(interface->device,
+        &ppp_deframe);
+    if (status != B_OK)
+        goto err1;
+
+        status = stack->register_domain_device_handler(
+                interface->device, B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE), domain);
+    if (status != B_OK)
+        goto err1;
+
+        status = stack->register_domain_device_handler(
+                interface->device, B_NET_FRAME_TYPE_IPV4, domain);
+    if (status != B_OK)
+        goto err1;
+
+    sinterface = interface;
+
+    // Locally received buffers don't need a domain device handler, as the
+    // buffer reception is handled internally.
+
+    protocol = new(std::nothrow) ppp_frame_protocol;
+    if (protocol == NULL) {
+        status = B_NO_MEMORY;
+        goto err2;
+    }
+
+    put_module(NET_STACK_MODULE_NAME);
+
+    *_protocol = protocol;
+    return B_OK;
+
+err2:
+    stack->unregister_device_deframer(interface->device);
+err1:
+    put_module(NET_STACK_MODULE_NAME);
+    return status;
+}
+
+
+status_t
+ppp_frame_uninit(net_datalink_protocol* protocol)
+{
+    net_stack_module_info* stack;
+    if (get_module(NET_STACK_MODULE_NAME, (module_info**)&stack) == B_OK) {
+        stack->unregister_device_deframer(protocol->interface->device);
+        stack->unregister_device_handler(protocol->interface->device, 0);
+        put_module(NET_STACK_MODULE_NAME);
+    }
+
+    delete protocol;
+    dprintf("in function: %s\n",__func__);
+    return B_OK;
+}
+
+
+status_t
+ppp_frame_send_data(net_datalink_protocol* protocol, net_buffer* buffer)
+{
+    TRACE("%s::%s: next module is %s\n",__FILE__,__func__,protocol->next->module->info.name);
+    return protocol->next->module->send_data(protocol->next, buffer);
+}
+
+
+status_t
+ppp_frame_up(net_datalink_protocol* protocol)
+{
+    TRACE("in function: %s\n",__func__);
+    net_stack_module_info* stack;
+    status_t status = get_module(NET_STACK_MODULE_NAME, (module_info**)&stack);
+    if (status != B_OK)
+        return status;
+
+    status = stack->register_device_deframer(sinterface->device,
+        &ppp_deframe);
+    if (status != B_OK)
+        dprintf("%s::%s: can not register_device_deframer for pppoe\n",__FILE__,__func__);
+
+    put_module(NET_STACK_MODULE_NAME);
+
+    return protocol->next->module->interface_up(protocol->next);
+}
+
+
+void
+ppp_frame_down(net_datalink_protocol* protocol)
+{
+    TRACE("%s::%s: entry\n", __FILE__, __func__);
+    protocol->next->module->interface_down(protocol->next);
+    return;
+}
+
+
+status_t
+ppp_frame_change_address(net_datalink_protocol* protocol,
+    net_interface_address* address, int32 option,
+    const struct sockaddr* oldAddress, const struct sockaddr* newAddress)
+{
+    TRACE("in function: %s::%s\n", __FILE__, __func__);
+    return protocol->next->module->change_address(protocol->next, address,
+        option, oldAddress, newAddress);
+}
+
+
+static status_t
+PPP_module_control(int32 option, void* argument, size_t length)
+{
+    // control_net_module_args* args=(control_net_module_args*)argument;
+
+    if(option < PPPC_CONTROL_MODULE || option > PPP_CONTROL_OPS_END)
+        return B_ERROR;
+
+    // if(args->name != PPP_INTERFACE_MODULE_NAME)
+        // return B_ERROR;
+
+    switch(option)
+    {
+        case PPPC_CREATE_INTERFACE:
+            // process_CreateInterface(args->data, args->length);
+        case PPPC_CREATE_INTERFACE_WITH_NAME:
+        case PPPC_DELETE_INTERFACE:
+        case PPPC_BRING_INTERFACE_UP:
+        case PPPC_BRING_INTERFACE_DOWN:
+        case PPPC_CONTROL_INTERFACE:
+        case PPPC_GET_INTERFACES:
+        case PPPC_COUNT_INTERFACES:
+        case PPPC_FIND_INTERFACE_WITH_SETTINGS:
+
+        // interface control
+        case PPPC_GET_INTERFACE_INFO:
+        case PPPC_SET_USERNAME:
+        case PPPC_SET_PASSWORD:
+        case PPPC_SET_ASK_BEFORE_CONNECTING:
+          // ppp_up uses this in order to finalize a connection request
+        case PPPC_SET_MRU:
+        case PPPC_SET_CONNECT_ON_DEMAND:
+        case PPPC_SET_AUTO_RECONNECT:
+        case PPPC_HAS_INTERFACE_SETTINGS:
+        case PPPC_GET_STATISTICS:
+        // handler access
+        case PPPC_CONTROL_DEVICE:
+        case PPPC_CONTROL_PROTOCOL:
+        case PPPC_CONTROL_OPTION_HANDLER:
+        case PPPC_CONTROL_LCP_EXTENSION:
+        case PPPC_CONTROL_CHILD:
+        // KPPPDevice
+        case PPPC_GET_DEVICE_INFO:
+        // KPPPProtocol
+        case PPPC_GET_PROTOCOL_INFO:
+        // Common/mixed ops
+        case PPPC_ENABLE:
+        case PPPC_GET_SIMPLE_HANDLER_INFO:
+
+        // these two control ops use the ppp_report_request structure
+        case PPPC_ENABLE_REPORTS:
+        case PPPC_DISABLE_REPORTS:
+
+        case PPP_CONTROL_OPS_END:
+        case PPPC_CONTROL_MODULE:
+        default:
+            return B_ERROR;
+    }
+    
+
+}
+
+static status_t
+ppp_frame_control(net_datalink_protocol* protocol, int32 option,
+    void* argument, size_t length)
+{
+    TRACE("in function: %s\n",__func__);
+
+    if(option >= PPPC_CONTROL_MODULE && option <=PPP_CONTROL_OPS_END)
+    {
+        status_t status =PPP_module_control(option,argument,length);
+        // gPPPInterfaceModule->ControlInterface(1, option, argument, length);
+        return(status);
+    }
+
+    return protocol->next->module->control(protocol->next, option, argument,
+        length);
+}
+
+
+static status_t
+ppp_frame_join_multicast(net_datalink_protocol* protocol,
+    const sockaddr* address)
+{
+    TRACE("in function: %s\n",__func__);
+    return protocol->next->module->join_multicast(protocol->next, address);
+}
+
+
+static status_t
+ppp_frame_leave_multicast(net_datalink_protocol* protocol,
+    const sockaddr* address)
+{
+    TRACE("in function: %s\n",__func__);
+    return protocol->next->module->leave_multicast(protocol->next, address);
+}
+
+
+static status_t
+pppoe_frame_std_ops(int32 op, ...)
+{
+    switch (op) {
+        case B_MODULE_INIT:
+            get_module(PPP_INTERFACE_MODULE_NAME,
+                (module_info**)&gPPPInterfaceModule);
+            return get_module(NET_BUFFER_MODULE_NAME,
+                (module_info**)&gBufferModule);
+
+        case B_MODULE_UNINIT:
+            put_module(NET_BUFFER_MODULE_NAME);
+            put_module(PPP_INTERFACE_MODULE_NAME);
+            return B_OK;
+
+        default:
+            return B_ERROR;
+    }
+}
+
+
+static net_datalink_protocol_module_info sPPPFrameModule = {
+    {
+        "network/datalink_protocols/ppp_frame/v1",
+        0,
+        pppoe_frame_std_ops
+    },
+    ppp_frame_init,
+    ppp_frame_uninit,
+    ppp_frame_send_data,
+    ppp_frame_up,
+    ppp_frame_down,
+    ppp_frame_change_address,
+    ppp_frame_control,
+    ppp_frame_join_multicast,
+    ppp_frame_leave_multicast,
+};
+
+module_info* modules[] = {
+    (module_info*)&sPPPFrameModule,
+    NULL
+};

src/add-ons/kernel/network/ppp/pppoe/DiscoveryPacket.cpp

@@ -5 +5 @@
 
 #include "DiscoveryPacket.h"
 
-#include <core_funcs.h>
-
+#include <net_buffer.h>
+#include <NetBufferUtilities.h>
+#include <ByteOrder.h>
 
 DiscoveryPacket::DiscoveryPacket(uint8 code, uint16 sessionID)
     : fCode(code),
@@ -16 +17 @@
 }
 
 
-DiscoveryPacket::DiscoveryPacket(struct mbuf *packet, uint32 start)
+DiscoveryPacket::DiscoveryPacket(net_buffer *packet, uint32 start)
 {
     // decode packet
-    uint8 *data = mtod(packet, uint8*);
-    data += start;
-    pppoe_header *header = (pppoe_header*) data;
+    NetBufferHeaderReader<pppoe_header> bufferheader(packet);
+    if(bufferheader.Status()!=B_OK) {
+        dprintf("NetBufferHeaderReader create fail\n");
+        fInitStatus = B_ERROR;
+        return;
+    }
+    pppoe_header &header = bufferheader.Data();
     
-    SetCode(header->code);
+    SetCode(header.code);
     
-    uint16 length = ntohs(header->length);
+    uint16 length = ntohs(header.length);
     
-    if(length > packet->m_len - PPPoE_HEADER_SIZE - start) {
+    if(length > packet->size - PPPoE_HEADER_SIZE) {
+        dprintf("packet size less than pppoe payload\n");
+        dprintf("pppoe payload:%d\n",length);
+        dprintf("PPPoE_HEADER_SIZE:%d\n",PPPoE_HEADER_SIZE);
+        dprintf("packet->size:%ld\n",packet->size);
         fInitStatus = B_ERROR;
         return;
             // there are no tags (or one corrupted tag)
@@ -37 +46 @@
     pppoe_tag *tag;
     
     while(position <= length - 4) {
-        tag = (pppoe_tag*) (header->data + position);
+        tag = (pppoe_tag*) (header.data + position);
         position += ntohs(tag->length) + 4;
         
         AddTag(ntohs(tag->type), tag->data, ntohs(tag->length));
@@ -116 +125 @@
 }
 
 
-struct mbuf*
+net_buffer*
 DiscoveryPacket::ToMbuf(uint32 MTU, uint32 reserve)
 {
-    struct mbuf *packet = m_gethdr(MT_DATA);
-    packet->m_data += reserve;
-    
-    pppoe_header *header = mtod(packet, pppoe_header*);
+    net_buffer *packet = gBufferModule->create(256);
+    if (packet==NULL){
+        dprintf("create buffer failure\n");
+        return NULL;
+    }
+
+    pppoe_header *header ;
+    status_t status = gBufferModule->append_size(packet,1492,(void **)&header);
+    if (status != B_OK){
+        dprintf("append size failure\n");
+        return NULL;
+    }
     
     header->version = PPPoE_VERSION;
     header->type = PPPoE_TYPE;
@@ -137 +154 @@
         
         // make sure we have enough space left
         if(MTU - length < tag->length) {
-            m_freem(packet);
+            gBufferModule->free(packet);
             return NULL;
         }
         
@@ -150 +167 @@
     }
     
     header->length = htons(length);
-    packet->m_pkthdr.len = packet->m_len = length + PPPoE_HEADER_SIZE;
-    
+    status = gBufferModule->trim(packet,length + PPPoE_HEADER_SIZE);
+    if (status != B_OK){
+        dprintf("trim buffer failure\n");
+        return NULL;
+    }
+
     return packet;
 }

src/add-ons/kernel/network/ppp/pppoe/DiscoveryPacket.h

@@ -10 +10 @@
 
 #include <TemplateList.h>
 
+#define ETHER_HDR_LEN 14
 
 enum PPPoE_TAG_TYPE {
     END_OF_LIST = 0x0000,
@@ -37 +38 @@
     uint16 type;
     uint16 length;
     uint8 data[0];
-};
+} pppoe_tag;
 
 
 class DiscoveryPacket {
     public:
         DiscoveryPacket(uint8 code, uint16 sessionID = 0x0000);
-        DiscoveryPacket(struct mbuf *packet, uint32 start = 0);
+        DiscoveryPacket(net_buffer *packet, uint32 start = 0);
         ~DiscoveryPacket();
         
         status_t InitCheck() const
@@ -66 +67 @@
         pppoe_tag *TagAt(int32 index) const;
         pppoe_tag *TagWithType(uint16 type) const;
         
-        struct mbuf *ToMbuf(uint32 MTU, uint32 reserve = ETHER_HDR_LEN);
-            // the user is responsible for freeing the mbuf
+        net_buffer *ToMbuf(uint32 MTU, uint32 reserve = ETHER_HDR_LEN);
+            // the user is responsible for freeing the net_buffer
 
     private:
         uint8 fCode;

src/add-ons/kernel/network/ppp/pppoe/Jamfile

@@ -9 +9 @@
 }
 
 # for kernel_cpp.h and BLocker
-UseHeaders [ FDirName $(HAIKU_TOP) headers cpp ] : true ;
+# UseHeaders [ FDirName $(HAIKU_TOP) headers cpp ] : true ;
+
+UsePrivateKernelHeaders ;
 UsePrivateHeaders net ;
 UsePrivateHeaders [ FDirName kernel ] ;
 UsePrivateHeaders [ FDirName kernel util ] ;
@@ -32 +34 @@
 
 # Installation
 HaikuInstall install-networking
-    : /boot/home/config/add-ons/kernel/obos_network/ppp
+    : /boot/home/config/add-ons/kernel/haiku_network/ppp
     : pppoe ;
 
 Package haiku-networkingkit-cvs :
     pppoe :
-    boot home config add-ons kernel obos_network ppp ;
+    boot home config add-ons kernel haiku_network ppp ;

src/add-ons/kernel/network/ppp/pppoe/PPPoE.h

@@ -8 +8 @@
 
 #include <SupportDefs.h>
 #include <net/if.h>
-#include <netinet/if_ether.h>
+#include <ethernet.h>
+#include <ether_driver.h>
+#include <net_stack.h>
+// #include <netinet/if_ether.h>
 
 class PPPoEDevice;
 
@@ -60 +63 @@
 
 
 // defined in pppoe.cpp
-extern ifnet *FindPPPoEInterface(const char *name);
+extern net_device *FindPPPoEInterface(const char *name);
 extern uint32 NewHostUniq();
 extern void add_device(PPPoEDevice *device);
 extern void remove_device(PPPoEDevice *device);
 
 #if DEBUG
 // defined in PPPoEDevice.cpp
-extern void dump_packet(struct mbuf *packet);
+extern void dump_packet(net_buffer *packet);
 #endif // DEBUG
 
 

src/add-ons/kernel/network/ppp/pppoe/PPPoEDevice.cpp

@@ -5 +5 @@
 
 #include "PPPoEDevice.h"
 #include "DiscoveryPacket.h"
+#include <ethernet.h>
+#include <ether_driver.h>
+
+#include <net_stack.h>
+#include <ByteOrder.h>
+#include <net/if_dl.h>
 
-#include <core_funcs.h>
 #include <cstdlib>
 
 // from libkernelppp
 #include <settings_tools.h>
 
+extern net_stack_module_info *gStackModule;
+extern net_buffer_module_info *gBufferModule;
+extern status_t
+pppoe_input(void *cookie, net_device *_device, net_buffer *packet);
 
 #if DEBUG
 static char sDigits[] = "0123456789ABCDEF";
 void
-dump_packet(struct mbuf *packet)
+dump_packet(net_buffer *packet)
 {
     if(!packet)
         return;
     
-    uint8 *data = mtod(packet, uint8*);
+    BufferHeaderReader<uint8> bufferheader(packet);
+    if(bufferheader.Status() != B_OK)
+        return;
+    uint8 &buffer = bufferheader.Data();
+    uint8 *data = &buffer;
     uint8 buffer[33];
     uint8 bufferIndex = 0;
     
@@ -62 +75 @@
         // we do not want to fail just because the other side requests PFC
     
     memset(fPeer, 0xFF, sizeof(fPeer));
+    memcpy(fEtherAddr,etheraddr,sizeof(fEtherAddr));
+
     SetMTU(1494);
         // MTU size does not contain PPP header
     
+    if(!settings)
+        dprintf("%s::%s: settings is NULL\n",__FILE__,__func__);
+
     // find ethernet device
-    const char *interfaceName = get_parameter_value(PPPoE_INTERFACE_KEY, settings);
-    if(!interfaceName)
-        return;
-    
+    finterfaceName = get_parameter_value(PPPoE_INTERFACE_KEY, settings);
+    TRACE("%s::%s: finterfaceName is %s\n",__FILE__,__func__,
+            finterfaceName ? finterfaceName : "NULL");
+
     fACName = get_parameter_value(PPPoE_AC_NAME_KEY, settings);
+    TRACE("fACName is %s\n",fACName ? fACName : "NULL");
+
     fServiceName = get_parameter_value(PPPoE_SERVICE_NAME_KEY, settings);
+    TRACE("fServiceName is %s\n", fServiceName ? fServiceName : "NULL");
     
-    fEthernetIfnet = FindPPPoEInterface(interfaceName);
+    // fEthernetIfnet = FindPPPoEInterface(interfaceName);
     
 #if DEBUG
     if(!fEthernetIfnet)
         TRACE("PPPoEDevice::ctor: could not find ethernet interface\n");
+    else
+        TRACE("%s::%s: Find Ethernet device",__FILE__,__func__);
 #endif
 }
 
@@ -85 +108 @@
 status_t
 PPPoEDevice::InitCheck() const
 {
-    return EthernetIfnet() && EthernetIfnet()->output
-        && KPPPDevice::InitCheck() == B_OK ? B_OK : B_ERROR;
+    if(KPPPDevice::InitCheck() != B_OK)
+        dprintf("%s::%s: KPPPDevice::InitCheck() has error\n",__FILE__,__func__);
+    
+    return KPPPDevice::InitCheck() == B_OK ? B_OK : B_ERROR;
 }
 
 
@@ -101 +126 @@
     if(IsUp())
         return true;
     
+    fEthernetIfnet = FindPPPoEInterface(finterfaceName);
+
+    if(fEthernetIfnet == NULL){
+        dprintf("%s::%s: fEthernetIfnet %s not found\n",__FILE__,__func__,finterfaceName);
+        return false;
+    }
+
+    memcpy(fEtherAddr, fEthernetIfnet->address.data, ETHER_ADDRESS_LENGTH);
+    dprintf("ppp's corresponding addr is %02x:%02x:%02x:%02x:%02x:%02x\n",
+            fEtherAddr[0],fEtherAddr[1],fEtherAddr[2],
+            fEtherAddr[3],fEtherAddr[4],fEtherAddr[5]);
+
+    if(fEthernetIfnet->module == NULL){
+        dprintf("%s::%s: fEthernetIfnet->module not found\n",__FILE__,__func__);
+        return false;
+    }
+
     add_device(this);
     
     fState = INITIAL;
@@ -125 +167 @@
     discovery.AddTag(END_OF_LIST, NULL, 0);
     
     // set up PPP header
-    struct mbuf *packet = discovery.ToMbuf(MTU());
+    net_buffer *packet = discovery.ToMbuf(MTU());
     if(!packet)
         return false;
     
-    // create destination
-    struct ether_header *ethernetHeader;
-    struct sockaddr destination;
-    memset(&destination, 0, sizeof(destination));
-    destination.sa_family = AF_UNSPEC;
-        // raw packet with ethernet header
-    ethernetHeader = (struct ether_header*) destination.sa_data;
-    ethernetHeader->ether_type = ETHERTYPE_PPPOEDISC;
-    memcpy(ethernetHeader->ether_dhost, fPeer, sizeof(fPeer));
-    
+    // create ether header
+    NetBufferPrepend<ether_header> ethernetHeader(packet);
+    if (ethernetHeader.Status() != B_OK)
+                return false;
+    ether_header &header = ethernetHeader.Data();
+
+    memset(header.destination, 0xff, ETHER_ADDRESS_LENGTH);
+    memcpy(header.source, fEtherAddr, ETHER_ADDRESS_LENGTH);
+    header.type=htons(ETHER_TYPE_PPPOE_DISCOVERY);
+    ethernetHeader.Sync();
+    // raw packet with ethernet header
+
     // check if we are allowed to go up now (user intervention might disallow that)
     if(fAttempts > 0 && !UpStarted()) {
         fAttempts = 0;
@@ -151 +195 @@
     fState = PADI_SENT;
         // needed before sending, otherwise we might not get all packets
     
-    if(EthernetIfnet()->output(EthernetIfnet(), packet, &destination, NULL) != B_OK) {
+    status_t status = gStackModule->register_device_handler(fEthernetIfnet,
+                B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE_DISCOVERY), &pppoe_input, NULL);
+    if (status != B_OK)
+        return false;
+
+    status = gStackModule->register_device_handler(fEthernetIfnet,
+                B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE), &pppoe_input, NULL);
+    if (status != B_OK)
+        return false;
+
+    if(EthernetIfnet()->module->send_data(EthernetIfnet(), packet) != B_OK) {
         fState = INITIAL;
         fAttempts = 0;
         ERROR("PPPoEDevice::Up(): EthernetIfnet()->output() failed!\n");
         return false;
     }
-    
+
+    dprintf("PPPoEDevice::Up(): EthernetIfnet()->output() success!\n");
     fNextTimeout = system_time() + PPPoE_TIMEOUT;
     
     return true;
@@ -169 +224 @@
 {
     TRACE("PPPoEDevice: Down()\n");
     
+    gStackModule->unregister_device_handler(fEthernetIfnet,
+        B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE_DISCOVERY));
+    gStackModule->unregister_device_handler(fEthernetIfnet,
+        B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE));
+
     remove_device(this);
     
     if(InitCheck() != B_OK)
@@ -191 +251 @@
     DiscoveryPacket discovery(PADT, SessionID());
     discovery.AddTag(END_OF_LIST, NULL, 0);
     
-    struct mbuf *packet = discovery.ToMbuf(MTU());
+    net_buffer *packet = discovery.ToMbuf(MTU());
     if(!packet) {
         ERROR("PPPoEDevice::Down(): ToMbuf() failed; MTU=%ld\n", MTU());
         DownEvent();
@@ -205 +265 @@
     destination.sa_family = AF_UNSPEC;
         // raw packet with ethernet header
     ethernetHeader = (struct ether_header*) destination.sa_data;
-    ethernetHeader->ether_type = ETHERTYPE_PPPOEDISC;
-    memcpy(ethernetHeader->ether_dhost, fPeer, sizeof(fPeer));
+    ethernetHeader->type = ETHER_TYPE_PPPOE_DISCOVERY;
+    memcpy(ethernetHeader->destination, fPeer, sizeof(fPeer));
     
     // reset connection settings
     memset(fPeer, 0xFF, sizeof(fPeer));
     
-    EthernetIfnet()->output(EthernetIfnet(), packet, &destination, NULL);
+    EthernetIfnet()->module->send_data(EthernetIfnet(), packet);
     DownEvent();
     
     return true;
@@ -242 +302 @@
 
 
 status_t
-PPPoEDevice::Send(struct mbuf *packet, uint16 protocolNumber)
+PPPoEDevice::Send(net_buffer *packet, uint16 protocolNumber)
 {
     // Send() is only for PPP packets. PPPoE packets are sent directly to ethernet.
     
@@ -252 +312 @@
         return B_ERROR;
     else if(InitCheck() != B_OK || protocolNumber != 0) {
         ERROR("PPPoEDevice::Send(): InitCheck() != B_OK!\n");
-        m_freem(packet);
+        gBufferModule->free(packet);
         return B_ERROR;
     }
     
     if(!IsUp()) {
         ERROR("PPPoEDevice::Send(): no connection!\n");
-        m_freem(packet);
+        gBufferModule->free(packet);
         return PPP_NO_CONNECTION;
     }
     
-    uint16 length = packet->m_flags & M_PKTHDR ? packet->m_pkthdr.len : packet->m_len;
+    uint16 length = packet->size;
     
     // encapsulate packet into pppoe header
-    M_PREPEND(packet, PPPoE_HEADER_SIZE);
-    pppoe_header *header = mtod(packet, pppoe_header*);
-    header->version = PPPoE_VERSION;
-    header->type = PPPoE_TYPE;
-    header->code = 0x00;
-    header->sessionID = SessionID();
-    header->length = htons(length);
-    
-    // create destination
-    struct ether_header *ethernetHeader;
-    struct sockaddr destination;
-    memset(&destination, 0, sizeof(destination));
-    destination.sa_family = AF_UNSPEC;
-        // raw packet with ethernet header
-    ethernetHeader = (struct ether_header*) destination.sa_data;
-    ethernetHeader->ether_type = ETHERTYPE_PPPOE;
-    memcpy(ethernetHeader->ether_dhost, fPeer, sizeof(fPeer));
+    NetBufferPrepend<pppoe_header> bufferheader(packet);
+    if(bufferheader.Status() != B_OK)
+        return B_ERROR;
+    pppoe_header &header = bufferheader.Data();
+    header.version = PPPoE_VERSION;
+    header.type = PPPoE_TYPE;
+    header.code = 0x00;
+    header.sessionID = SessionID();
+    header.length = htons(length);
+    bufferheader.Sync();
+
+    // create ether header
+    NetBufferPrepend<ether_header> ethernetHeader(packet);
+    if (ethernetHeader.Status() != B_OK)
+        return false;
+    ether_header &ethheader = ethernetHeader.Data();
+
+    memcpy(ethheader.destination, fPeer, ETHER_ADDRESS_LENGTH);
+    memcpy(ethheader.source, fEtherAddr, ETHER_ADDRESS_LENGTH);
+    ethheader.type=htons(ETHER_TYPE_PPPOE);
+    ethernetHeader.Sync();
+    // raw packet with ethernet header
     
-    if(!packet || !mtod(packet, pppoe_header*))
+    if(!packet)
         ERROR("PPPoEDevice::Send(): packet is NULL!\n");
     
-    if(EthernetIfnet()->output(EthernetIfnet(), packet, &destination, NULL) != B_OK) {
+    if(EthernetIfnet()->module->send_data(EthernetIfnet(), packet) != B_OK) {
         ERROR("PPPoEDevice::Send(): EthernetIfnet()->output() failed!\n");
         remove_device(this);
         DownEvent();
@@ -297 +362 @@
     return B_OK;
 }
 
-
 status_t
-PPPoEDevice::Receive(struct mbuf *packet, uint16 protocolNumber)
+PPPoEDevice::Receive(net_buffer *packet, uint16 protocolNumber)
 {
+    TRACE("%s entering %s: protocolNumber:%x\n",__FILE__,__func__,protocolNumber);
     if(!packet)
         return B_ERROR;
     else if(InitCheck() != B_OK || IsDown()) {
-        m_freem(packet);
+        dprintf("PPPoED InitCheck fail or IsDown\n");
+        //gBufferModule->free(packet);
+        dprintf("PPPoEDevice::Receive fail\n");
         return B_ERROR;
     }
     
-    complete_pppoe_header *completeHeader = mtod(packet, complete_pppoe_header*);
-    if(!completeHeader) {
-        m_freem(packet);
-        return B_ERROR;
-    }
+//  NetBufferHeaderReader<pppoe_header> bufferheader(packet);
+//  if(bufferheader.Status() != B_OK)
+//      return B_ERROR;
+//  pppoe_header &completeHeader = bufferheader.Data();
+
+//  if(!completeHeader) {
+//      gBufferModule->free(packet);
+//      return B_ERROR;
+//  }
     
     uint8 ethernetSource[6];
-    memcpy(ethernetSource, completeHeader->ethernetHeader.ether_shost, sizeof(fPeer));
+        struct sockaddr_dl& source = *(struct sockaddr_dl*)packet->source;
+    memcpy(ethernetSource, source.sdl_data, sizeof(fPeer));
+
     status_t result = B_OK;
-    
-    if(completeHeader->ethernetHeader.ether_type == ETHERTYPE_PPPOE) {
-        m_adj(packet, ETHER_HDR_LEN);
-        pppoe_header *header = mtod(packet, pppoe_header*);
-        
-        if(!IsUp() || header->version != PPPoE_VERSION || header->type != PPPoE_TYPE
-                || header->code != 0x0 || header->sessionID != SessionID()) {
-            m_freem(packet);
+
+//  bufferheader.Remove();
+//  bufferheader.Sync();
+
+    if(packet->type == B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE)) {
+        TRACE("ETHER_TYPE_PPPOE\n");
+        NetBufferHeaderReader<pppoe_header> bufferheader(packet);
+        if(bufferheader.Status() != B_OK) {
+            TRACE("creat NetBufferHeaderReader fail\n");
             return B_ERROR;
         }
-        
-        m_adj(packet, PPPoE_HEADER_SIZE);
+        pppoe_header &header = bufferheader.Data();
+        uint16 ppppoe_payload = ntohs(header.length);
+
+        if(!IsUp() || header.version != PPPoE_VERSION || header.type != PPPoE_TYPE
+                || header.code != 0x0 || header.sessionID != SessionID()) {
+            // gBufferModule->free(packet);
+            TRACE("basic pppoe header check fail\n");
+            return B_ERROR;
+        }
+
+        bufferheader.Remove();
+        bufferheader.Sync();
+
+        //trim the packet according to actual pppoe_payload
+        gBufferModule->trim(packet, ppppoe_payload);
+
         return Interface().ReceiveFromDevice(packet);
-    } else if(completeHeader->ethernetHeader.ether_type == ETHERTYPE_PPPOEDISC) {
-        m_adj(packet, ETHER_HDR_LEN);
-        pppoe_header *header = mtod(packet, pppoe_header*);
+    } else if(packet->type == B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE_DISCOVERY)) {
+        TRACE("ETHER_TYPE_PPPOE_DISCOVERY\n");
+        NetBufferHeaderReader<pppoe_header> bufferheader(packet);
+        if(bufferheader.Status() != B_OK) {
+            TRACE("create NetBufferHeaderReader fail\n");
+            return B_ERROR;
+        }
+        pppoe_header &header = bufferheader.Data();
         
         // we do not need to check HOST_UNIQ tag as this is done in pppoe.cpp
-        if(header->version != PPPoE_VERSION || header->type != PPPoE_TYPE) {
-            m_freem(packet);
+        if(header.version != PPPoE_VERSION || header.type != PPPoE_TYPE) {
+            //gBufferModule->free(packet);
+            dprintf("PPPoEDevice::Receive fail version type wrong\n");
             return B_ERROR;
         }
         
         if(IsDown()) {
-            m_freem(packet);
+            //gBufferModule->free(packet);
+            dprintf("PPPoEDevice::Receive fail PPPoEDev IsDown\n");
             return B_ERROR;
         }
         
         DiscoveryPacket discovery(packet);
         switch(discovery.Code()) {
             case PADO: {
+                dprintf("processing PADO\n");
                 if(fState != PADI_SENT) {
-                    m_freem(packet);
+                    //gBufferModule->free(packet);
+                    dprintf("PPPoEDevice::Receive faile not PADI_Sent \n");
                     return B_OK;
                 }
                 
@@ -364 +461 @@
                     switch(tag->type) {
                         case SERVICE_NAME:
                             if(!hasServiceName && (!ServiceName()
-                                    || (strlen(ServiceName()) == tag->length)
+                                    || ((strlen(ServiceName()) == tag->length)
                                         && !memcmp(tag->data, ServiceName(),
-                                            tag->length))) {
+                                            tag->length)))) {
                                 hasServiceName = true;
                                 reply.AddTag(tag->type, tag->data, tag->length);
                             }
@@ -374 +471 @@
                         
                         case AC_NAME:
                             if(!hasACName && (!ACName()
-                                    || (strlen(ACName()) == tag->length)
+                                    || ((strlen(ACName()) == tag->length)
                                         && !memcmp(tag->data, ACName(),
-                                            tag->length))) {
+                                            tag->length)))) {
                                 hasACName = true;
                                 reply.AddTag(tag->type, tag->data, tag->length);
                             }
@@ -390 +487 @@
                         case SERVICE_NAME_ERROR:
                         case AC_SYSTEM_ERROR:
                         case GENERIC_ERROR:
-                            m_freem(packet);
+                            //gBufferModule->free(packet);
+                            dprintf("PPPoEDevice::generic error faile\n");
                             return B_ERROR;
                         break;
                         
@@ -400 +498 @@
                 }
                 
                 if(!hasServiceName) {
-                    m_freem(packet);
+                    //gBufferModule->free(packet);
+                    dprintf("PPPoEDevice::Receive faile no svc name\n");
                     return B_ERROR;
                 }
                 
+                dprintf("reply.AddTag\n");
                 reply.AddTag(HOST_UNIQ, &fHostUniq, sizeof(fHostUniq));
                 reply.AddTag(END_OF_LIST, NULL, 0);
-                struct mbuf *replyPacket = reply.ToMbuf(MTU());
+                net_buffer *replyPacket = reply.ToMbuf(MTU());
                 if(!replyPacket) {
-                    m_freem(packet);
+                    //gBufferModule->free(packet);
+                    dprintf("PPPoEDevice::Receive fail no reply pack\n");
                     return B_ERROR;
                 }
                 
-                memcpy(fPeer, ethernetSource, sizeof(fPeer));
+                memcpy(fPeer, ethernetSource, ETHER_ADDRESS_LENGTH);
                 
-                // create destination
-                struct ether_header *ethernetHeader;
-                struct sockaddr destination;
-                memset(&destination, 0, sizeof(destination));
-                destination.sa_family = AF_UNSPEC;
-                    // raw packet with ethernet header
-                ethernetHeader = (struct ether_header*) destination.sa_data;
-                ethernetHeader->ether_type = ETHERTYPE_PPPOEDISC;
-                memcpy(ethernetHeader->ether_dhost, fPeer, sizeof(fPeer));
+                // create ether header
+                NetBufferPrepend<ether_header> ethernetHeader(replyPacket);
+                if (ethernetHeader.Status() != B_OK)
+                    return false;
+                ether_header &header = ethernetHeader.Data();
+
+                memcpy(header.destination, fPeer, ETHER_ADDRESS_LENGTH);
+                memcpy(header.source, fEtherAddr, ETHER_ADDRESS_LENGTH);
+                header.type=htons(ETHER_TYPE_PPPOE_DISCOVERY);
+                ethernetHeader.Sync();
+                // raw packet with ethernet header
                 
                 fState = PADR_SENT;
                 
-                if(EthernetIfnet()->output(EthernetIfnet(), replyPacket, &destination,
-                        NULL) != B_OK) {
-                    m_freem(packet);
+                if(EthernetIfnet()->module->send_data(EthernetIfnet(), replyPacket) != B_OK) {
+                    gBufferModule->free(replyPacket);
+                    dprintf("PPPoEDevice::Receive fail send PADR\n");
                     return B_ERROR;
                 }
                 
@@ -436 +539 @@
             } break;
             
             case PADS:
+                dprintf("procesing PADS\n");
                 if(fState != PADR_SENT
                         || memcmp(ethernetSource, fPeer, sizeof(fPeer))) {
-                    m_freem(packet);
+                    //gBufferModule->free(packet);
+                    dprintf("PPPoEDevice::Receive PADS but no PADR sent\n");
                     return B_ERROR;
                 }
                 
-                fSessionID = header->sessionID;
+                fSessionID = header.sessionID;
                 fState = OPENED;
                 fNextTimeout = 0;
                 UpEvent();
             break;
             
             case PADT:
+                dprintf("procesing PADT\n");
                 if(!IsUp()
                         || memcmp(ethernetSource, fPeer, sizeof(fPeer))
-                        || header->sessionID != SessionID()) {
-                    m_freem(packet);
+                        || header.sessionID != SessionID()) {
+                    //gBufferModule->free(packet);
+                    dprintf("PPPoEDevice::Receive fail not up yet\n");
                     return B_ERROR;
                 }
                 
@@ -465 +572 @@
             break;
             
             default:
-                m_freem(packet);
+                dprintf("PPPoEDevice::Receive fail unknown pppoed code\n");
+                //gBufferModule->free(packet);
                 return B_ERROR;
         }
     } else
         result = B_ERROR;
     
-    m_freem(packet);
+    dprintf("PPPoEDevice::Receive fail unknow packet type\n");
+    //gBufferModule->free(packet);
     return result;
 }
 
@@ -480 +589 @@
 PPPoEDevice::Pulse()
 {
     // We use Pulse() for timeout of connection establishment.
-    
     if(fNextTimeout == 0 || IsUp() || IsDown())
         return;
     

src/add-ons/kernel/network/ppp/pppoe/PPPoEDevice.h

@@ -10 +10 @@
 
 #include <KPPPDevice.h>
 
+#include <net/if_types.h>
+#include <net_stack.h>
+
+
+const uint8 etheraddr[6]={
+    0x00,0x00,0x00,0x00,0x00,0x00  //src for Y470
+};
+
 
 enum pppoe_state {
     INITIAL,
@@ -25 +33 @@
     public:
         PPPoEDevice(KPPPInterface& interface, driver_parameter *settings);
         
-        ifnet *EthernetIfnet() const
+        net_device *EthernetIfnet() const
             { return fEthernetIfnet; }
         
         const uint8 *Peer() const
@@ -50 +58 @@
         
         virtual uint32 CountOutputBytes() const;
         
-        virtual status_t Send(struct mbuf *packet, uint16 protocolNumber = 0);
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber = 0);
+        virtual status_t Send(net_buffer *packet, uint16 protocolNumber = 0);
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber = 0);
         
         virtual void Pulse();
 
     private:
-        ifnet *fEthernetIfnet;
+        net_device *fEthernetIfnet;
         uint8 fPeer[6];
+        uint8 fEtherAddr[6];
         uint16 fSessionID;
         uint32 fHostUniq;
         const char *fACName, *fServiceName;
+        const char *finterfaceName;
         
         uint32 fAttempts;
         bigtime_t fNextTimeout;

src/add-ons/kernel/network/ppp/pppoe/pppoe.cpp

@@ -5 +5 @@
 
 #include <KernelExport.h>
 #include <driver_settings.h>
-#include <core_funcs.h>
-#include <net_module.h>
 
-#include <ethernet_module.h>
+#include <net_stack.h>
+#include <net_datalink.h> //for get_interface_by_name
+#include <net_buffer.h>
+#include <NetBufferUtilities.h>
+
+#include <net/if_types.h>
+#include <net/if_dl.h>
 
 #include <KPPPInterface.h>
 #include <KPPPModule.h>
 #include <KPPPUtils.h>
-#include <LockerHelper.h>
+
+#include <lock.h>
+#include <util/AutoLock.h>
+#include <ByteOrder.h>
 
 #include "PPPoEDevice.h"
 #include "DiscoveryPacket.h"
 
 
 typedef struct pppoe_query {
-    ifnet *ethernetIfnet;
+    net_device *ethernetIfnet;
     uint32 hostUniq;
     thread_id receiver;
 } pppoe_query;
 
-#define PPPoE_MODULE_NAME       NETWORK_MODULES_ROOT "ppp/pppoe"
+#define PPPoE_MODULE_NAME   "network/ppp/pppoe"
+
+net_stack_module_info *gStackModule = NULL;
+net_buffer_module_info *gBufferModule = NULL;
+net_datalink_module_info *sDatalinkModule = NULL;
 
-struct core_module_info *core = NULL;
-static struct ethernet_module_info *sEthernet;
+// static net_device_module_info *sEthernetModule = NULL;
 static int32 sHostUniq = 0;
 status_t std_ops(int32 op, ...);
 
-static BLocker sLock("PPPoEList");
+// static mutex sLock("PPPoEList");
+// static mutex sLock; // ("PPPoEList");
+
 static TemplateList<PPPoEDevice*> *sDevices;
 static TemplateList<pppoe_query*> *sQueries;
 
@@ -76 +88 @@
 }
 
 
-ifnet*
+net_device*
 FindPPPoEInterface(const char *name)
 {
     if(!name)
         return NULL;
     
-    ifnet *current = get_interfaces();
-    for(; current; current = current->if_next) {
-        if(current->if_type == IFT_ETHER && current->if_name
-                && !strcmp(current->if_name, name))
-            return current;
+    // net_device *current = NULL;
+    // sEthernetModule->get_device(&current, name);
+    net_interface* eth_if = NULL;
+    net_domain* nd = NULL;
+
+    if (sDatalinkModule){
+        TRACE("sDatalinkModule can not find eth\n");
+        nd = gStackModule->get_domain(AF_INET);
+        eth_if = sDatalinkModule->get_interface_by_name(nd, name);
     }
-    
+
+    if (eth_if == NULL)
+        dprintf("sDatalinkModule->get_interface_by_name can not find eth\n");
+    else {
+        dprintf("interface name:%s, device name:%s\n", eth_if->name, eth_if->device->name);
+    }
+            
+    if (eth_if && eth_if->device)
+        return eth_if->device;
+
     return NULL;
 }
 
-
 uint32
 NewHostUniq()
 {
@@ -105 +129 @@
 {
     TRACE("PPPoE: add_device()\n");
     
-    LockerHelper locker(sLock);
+    // MutexLocker locker(sLock);
     if(!sDevices->HasItem(device))
         sDevices->AddItem(device);
 }
@@ -116 +140 @@
 {
     TRACE("PPPoE: remove_device()\n");
     
-    LockerHelper locker(sLock);
+    // MutexLocker locker(sLock);
     sDevices->RemoveItem(device);
 }
 
 
-static
-void
-pppoe_input(struct mbuf *packet)
+status_t
+pppoe_input(void *cookie, net_device *_device, net_buffer *packet)
 {
     if(!packet)
-        return;
+        return B_ERROR;
+    TRACE("%s::%s: receive pppoe packet type:%ld!\n",__FILE__,__func__,packet->type);
     
-    ifnet *sourceIfnet = packet->m_pkthdr.rcvif;
-    complete_pppoe_header *header = mtod(packet, complete_pppoe_header*);
+    NetBufferHeaderReader<pppoe_header> bufferheader(packet);
+    if(bufferheader.Status() != B_OK)
+        return B_ERROR;
+    pppoe_header &header = bufferheader.Data();
+
+    // remove the following two lines when pppoe server is enabled
+    if (header.code==PADI)
+        return B_ERROR;
+
+    if (header.code==PADI || header.code==PADO || header.code==PADR || header.code==PADS ||
+        header.code==PADT)
+    {
+        uint8 peerether_addr[ETHER_ADDRESS_LENGTH];
+        struct sockaddr_dl& source = *(struct sockaddr_dl*)packet->source;
+        memcpy(peerether_addr, source.sdl_data, ETHER_ADDRESS_LENGTH);
+        const char *str = (header.code==PADI) ? "PADI" :
+                (header.code==PADO) ? "PADO" :
+                (header.code==PADR) ? "PADR" :
+                (header.code==PADS) ? "PADS" :
+                                      "PADT" ;
+
+        dprintf("%s from:%02x:%02x:%02x:%02x:%02x:%02x code:%02x\n", str,
+            peerether_addr[0],peerether_addr[1],peerether_addr[2],
+            peerether_addr[3],peerether_addr[4],peerether_addr[5],
+            header.code);
+    }
+
     PPPoEDevice *device;
     pppoe_query *query;
+
+    sockaddr_dl& linkAddress = *(sockaddr_dl*)packet->source;
+    int32 specificType = B_NET_FRAME_TYPE(linkAddress.sdl_type,
+                ntohs(linkAddress.sdl_e_type));
     
-    LockerHelper locker(sLock);
-    
-    if(header->ethernetHeader.ether_type == ETHERTYPE_PPPOEDISC
-            && header->pppoeHeader.length <= PPPoE_QUERY_REPORT_SIZE) {
+    // MutexLocker locker(sLock);
+    TRACE("type by linkAddress: %lx\n", specificType);
+    TRACE("packet->type: %lx\n", packet->type );
+
+    // why packet->type changed since ethernet_deframe???
+    packet->type = specificType;
+
+    if( (packet->type == B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE_DISCOVERY))
+            && ntohs(header.length) <= PPPoE_QUERY_REPORT_SIZE) {
         for(int32 index = 0; index < sDevices->CountItems(); index++) {
             query = sQueries->ItemAt(index);
-            
-            if(query && query->ethernetIfnet == sourceIfnet) {
-                if(header->pppoeHeader.code == PADO) {
+
+            if(query) {// && query->ethernetIfnet == sourceIfnet) {
+                if(header.code == PADO) {
                     DiscoveryPacket discovery(packet, ETHER_HDR_LEN);
                     if(discovery.InitCheck() != B_OK) {
                         ERROR("PPPoE: received corrupted discovery packet!\n");
-                        m_freem(packet);
-                        return;
+                        // gBufferModule->free(packet);
+                        return B_ERROR;
                     }
                     
                     pppoe_tag *hostTag = discovery.TagWithType(HOST_UNIQ);
                     if(hostTag && hostTag->length == 4
                             && *((uint32*)hostTag->data) == query->hostUniq) {
                         SendQueryPacket(query, discovery);
-                        m_freem(packet);
-                        return;
+                        // gBufferModule->free(packet);
+                        return B_ERROR;
                     }
                 }
             }
         }
     }
     
+    TRACE("in pppoed processing sDevices->CountItems(): %ld\n",sDevices->CountItems());
     for(int32 index = 0; index < sDevices->CountItems(); index++) {
         device = sDevices->ItemAt(index);
-        
-        if(device && device->EthernetIfnet() == sourceIfnet) {
-            if(header->ethernetHeader.ether_type == ETHERTYPE_PPPOE
-                    && header->pppoeHeader.sessionID == device->SessionID()) {
+
+        TRACE("device->SessionID() %d,header.sessionID: %d\n", device->SessionID(),
+                        header.sessionID);
+
+        if(device) {// && device->EthernetIfnet() == sourceIfnet) {
+
+            if( (packet->type == B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE))
+                    && header.sessionID == device->SessionID()) {
                 TRACE("PPPoE: session packet\n");
                 device->Receive(packet);
-                return;
-            } else if(header->ethernetHeader.ether_type == ETHERTYPE_PPPOEDISC
-                    && header->pppoeHeader.code != PADI
-                    && header->pppoeHeader.code != PADR
+                return B_OK;
+            } else if( (packet->type ==
+                B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE_DISCOVERY))
+                    && header.code != PADI
+                    && header.code != PADR 
                     && !device->IsDown()) {
                 TRACE("PPPoE: discovery packet\n");
+
                 DiscoveryPacket discovery(packet, ETHER_HDR_LEN);
                 if(discovery.InitCheck() != B_OK) {
                     ERROR("PPPoE: received corrupted discovery packet!\n");
-                    m_freem(packet);
-                    return;
+                    gBufferModule->free(packet);
+                    return B_OK;
                 }
                 
                 pppoe_tag *tag = discovery.TagWithType(HOST_UNIQ);
-                if(header->pppoeHeader.code == PADT || (tag && tag->length == 4
-                        && *((uint32*)tag->data) == device->HostUniq())) {
+                if(header.code == PADT || (tag && tag->length == 4
+                    && *((uint32*)tag->data) == device->HostUniq())) {
                     device->Receive(packet);
-                    return;
+                    return B_OK;
                 }
+                
             }
         }
     }
     
-    ERROR("PPPoE: No device found for packet from: %s\n", sourceIfnet->if_name);
-    m_freem(packet);
+    ERROR("PPPoE: No device found for packet from: %s\n", "ethernet");
+    // gBufferModule->free(packet);
+    return B_ERROR;
 }
 
 
@@ -231 +298 @@
             int32 position = 0, count = 0;
             char *names = (char*) data;
             
-            ifnet *current = get_interfaces();
-            for(; current; current = current->if_next) {
-                if(current->if_type == IFT_ETHER && current->if_name) {
-                    if(position + strlen(current->if_name) + 1 > length)
+            net_device *current = NULL;//get_interfaces();
+            for(; current; current = NULL) {
+                if(current->type == IFT_ETHER && current->name) {
+                    if(position + strlen(current->name) + 1 > length)
                         return B_NO_MEMORY;
                     
-                    strcpy(names + position, current->if_name);
-                    position += strlen(current->if_name);
+                    strcpy(names + position, current->name);
+                    position += strlen(current->name);
                     names[position++] = 0;
                     ++count;
                 }
@@ -263 +330 @@
             query.hostUniq = NewHostUniq();
             query.receiver = request->receiver;
             
-            sLock.Lock();
-            sQueries->AddItem(&query);
-            sLock.Unlock();
+            {
+                // MutexLocker tlocker(sLock);
+                TRACE("add query\n");
+                sQueries->AddItem(&query);
+            }
             
             snooze(2000000);
                 // wait two seconds for results
-            
-            sLock.Lock();
-            sQueries->RemoveItem(&query);
-            sLock.Unlock();
+            {
+                // MutexLocker tlocker(sLock);
+                TRACE("remove query\n");
+                sQueries->RemoveItem(&query);
+            }
         } break;
         
         default:
@@ -300 +370 @@
 {
     switch(op) {
         case B_MODULE_INIT:
-            if(get_module(NET_CORE_MODULE_NAME, (module_info**)&core) != B_OK)
+            if(get_module(NET_STACK_MODULE_NAME, (module_info**)&gStackModule) != B_OK)
                 return B_ERROR;
+            // if(get_module("network/devices/ethernet/v1",
+                        //      (module_info **)&sEthernetModule) != B_OK)
+                        //       return B_ERROR;
+            if(get_module(NET_DATALINK_MODULE_NAME,
+                                (module_info **)&sDatalinkModule) != B_OK)
+                                return B_ERROR;
+            if(get_module(NET_BUFFER_MODULE_NAME,
+                                (module_info **)&gBufferModule) != B_OK)
+                                return B_ERROR;
             
-            if(get_module(NET_ETHERNET_MODULE_NAME,
-                    (module_info**) &sEthernet) != B_OK) {
-                put_module(NET_CORE_MODULE_NAME);
-                return B_ERROR;
-            }
+//          if(get_module(NET_ETHERNET_MODULE_NAME,
+//                  (module_info**) &sEthernet) != B_OK) {
+//              put_module(NET_CORE_MODULE_NAME);
+//              return B_ERROR;
+//          }
             
-            set_max_linkhdr(2 + PPPoE_HEADER_SIZE + ETHER_HDR_LEN);
+            // set_max_linkhdr(2 + PPPoE_HEADER_SIZE + ETHER_HDR_LEN);
                 // 2 bytes for PPP header
             sDevices = new TemplateList<PPPoEDevice*>;
             sQueries = new TemplateList<pppoe_query*>;
-            sEthernet->set_pppoe_receiver(pppoe_input);
+            // sEthernet->set_pppoe_receiver(pppoe_input);
             
             TRACE("PPPoE: Registered PPPoE receiver.\n");
         return B_OK;
         
         case B_MODULE_UNINIT:
             delete sDevices;
-            sEthernet->unset_pppoe_receiver();
+            // sEthernet->unset_pppoe_receiver();
             TRACE("PPPoE: Unregistered PPPoE receiver.\n");
-            put_module(NET_CORE_MODULE_NAME);
-            put_module(NET_ETHERNET_MODULE_NAME);
+            put_module(NET_BUFFER_MODULE_NAME);
+            put_module(NET_DATALINK_MODULE_NAME);
+            // put_module("network/devices/ethernet/v1");
+            put_module(NET_STACK_MODULE_NAME);
         break;
         
         default:

src/add-ons/kernel/network/ppp/shared/libkernelppp/Jamfile

@@ -10 +10 @@
         # Unfortunately we get more than we want, namely all POSIX headers.
 }
 
+UsePrivateKernelHeaders ;
+UsePrivateHeaders net ;
+
 UsePrivateHeaders libroot net ;
 UsePrivateHeaders [ FDirName kernel ] ;
 UsePrivateHeaders [ FDirName kernel util ] ;
@@ -37 +40 @@
     KPPPReportManager.cpp
     KPPPStateMachine.cpp
     KPPPUtils.cpp
-    Locker.cpp
     settings_tools.cpp
     
     # integrated modules
@@ -49 +51 @@
 
 SEARCH on [ FGristFiles kernel_cpp.cpp ]
     = [ FDirName $(HAIKU_TOP) src system kernel util ] ;
-SEARCH on [ FGristFiles Locker.cpp ]
-    = [ FDirName $(HAIKU_TOP) src system kernel disk_device_manager ] ;
 SEARCH on [ FGristFiles atomic.S ]
     = [ FDirName $(HAIKU_TOP) src system libroot os arch $(TARGET_ARCH) ] ;

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPConfigurePacket.cpp

@@ -12 +12 @@
 #include <KPPPConfigurePacket.h>
 #include <KPPPInterface.h>
 
-#include <core_funcs.h>
+#include <net_buffer.h>
+#include <ByteOrder.h>
+#include <net_stack.h>
 
 
 /*! \brief Constructor.
@@ -27 +29 @@
 
 
 //! Decodes a packet and adds its items to this object.
-KPPPConfigurePacket::KPPPConfigurePacket(struct mbuf *packet)
+KPPPConfigurePacket::KPPPConfigurePacket(net_buffer *packet)
 {
     // decode packet
-    ppp_lcp_packet *header = mtod(packet, ppp_lcp_packet*);
+    NetBufferHeaderReader<ppp_lcp_packet> bufferhead(packet);
+    if(bufferhead.Status() != B_OK)
+        return;
+    ppp_lcp_packet &header = bufferhead.Data();
     
-    SetID(header->id);
-    if (!SetCode(header->code))
+    SetID(header.id);
+    if (!SetCode(header.code))
         return;
     
-    uint16 length = ntohs(header->length);
+    uint16 length = ntohs(header.length);
     
-    if (length < 6 || length > packet->m_len)
+    if (length < 6 || length > packet->size)
         return;
             // there are no items (or one corrupted item)
     
@@ -46 +51 @@
     ppp_configure_item *item;
     
     while (position < length - 4) {
-        item = (ppp_configure_item*) (header->data + position);
+        item = (ppp_configure_item*) (header.data + position);
         if (item->length < 2)
             return;
                 // found a corrupted item
@@ -157 +162 @@
 }
 
 
-/*! \brief Converts this packet into an mbuf structure.
+/*! \brief Converts this packet into an net_buffer structure.
     
     ATTENTION: You are responsible for freeing this packet by calling \c m_freem()!
     
     \param MRU The interface's maximum receive unit (MRU).
     \param reserve Number of bytes to reserve at the beginning of the packet.
     
-    \return The mbuf structure or \c NULL on error (e.g.: too big for given MRU).
+    \return The net_buffer structure or \c NULL on error (e.g.: too big for given MRU).
 */
-struct mbuf*
+net_buffer*
 KPPPConfigurePacket::ToMbuf(uint32 MRU, uint32 reserve)
 {
-    struct mbuf *packet = m_gethdr(MT_DATA);
-    packet->m_data += reserve;
-    
-    ppp_lcp_packet *header = mtod(packet, ppp_lcp_packet*);
-    
+    net_buffer *buffer = gBufferModule->create(256);
+    if (buffer == NULL){
+        TRACE("%s::%s: gBufferModule->create fail\n", __FILE__, __func__);
+        return(NULL);
+    }
+
+    ppp_lcp_packet *header;
+    status_t status = gBufferModule->append_size(buffer, 1492, (void **)&header);
+    if (status != B_OK) {
+        TRACE("%s::%s: gBufferModule->append_size\n", __FILE__, __func__);
+        gBufferModule->free(buffer);
+        return(NULL);
+    }   
+
     header->code = Code();
     header->id = ID();
     
@@ -185 +199 @@
         
         // make sure we have enough space left
         if (MRU - length < item->length) {
-            m_freem(packet);
+            gBufferModule->free(buffer);
             return NULL;
         }
         
@@ -195 +209 @@
     
     length += 4;
     header->length = htons(length);
-    packet->m_pkthdr.len = packet->m_len = length;
-    
-    return packet;
+
+        status = gBufferModule->trim(buffer, length);
+        if (status < B_OK) {
+        dprintf("%s::%s: gBufferModule->trim\n", __FILE__, __func__);
+                gBufferModule->free(buffer);
+                return(NULL);
+        }
+
+    return buffer;
 }

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPDevice.cpp

@@ -14 +14 @@
 #include <KPPPDevice.h>
 
 #include <net/if.h>
-#include <core_funcs.h>
 
 #include <PPPControl.h>
 
@@ -89 +88 @@
 
 //! This method is never used.
 status_t
-KPPPDevice::Receive(struct mbuf *packet, uint16 protocolNumber)
+KPPPDevice::Receive(net_buffer *packet, uint16 protocolNumber)
 {
     // let the interface handle the packet
     if (protocolNumber == 0)

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPInterface.cpp

@@ -23 +23 @@
 // void (KernelExport.h) and once with int (stdio.h).
 #include <cstdio>
 #include <cstring>
-#include <core_funcs.h>
+#include <net_buffer.h>
 
+#include <ppp_device.h>
+#include <net_stack.h>
+#include <ByteOrder.h>
 // now our headers...
 #include <KPPPInterface.h>
 
@@ -38 +41 @@
 #include <KPPPUtils.h>
 
 // general helper classes not only belonging to us
-#include <LockerHelper.h>
+// #include <lock.h>
+// #include <util/AutoLock.h>
 
 // tools only for us :)
 #include "settings_tools.h"
@@ -62 +66 @@
     uint32 delay;
 } reconnect_info;
 
+// module related to net_buffer objects
+extern net_buffer_module_info *gBufferModule;
+extern net_stack_module_info *gStackModule;
+
 status_t reconnect_thread(void *data);
 
 // other functions
@@ -250 +258 @@
     // This lock is not released until we are actually deleted.
     while (true) {
         Down();
-        fLock.Lock();
-        if (State() == PPP_INITIAL_STATE && Phase() == PPP_DOWN_PHASE)
-            break;
-        fLock.Unlock();
+        {
+            MutexLocker (fLock);
+            if (State() == PPP_INITIAL_STATE && Phase() == PPP_DOWN_PHASE)
+                break;
+        }
     }
     
     Report(PPP_DESTRUCTION_REPORT, 0, &fID, sizeof(ppp_interface_id));
@@ -296 +305 @@
 void
 KPPPInterface::Delete()
 {
-    LockerHelper locker(fLock);
+    // MutexLocker locker(fLock);
+        // alreay locked in KPPPStatemachine::DownEvent
+        // uncomment this line will cause double lock
     
     if (fDeleteCounter > 0)
         return;
@@ -364 +375 @@
     if (Device() && MRU > Device()->MTU() - 2)
         return false;
     
-    LockerHelper locker(fLock);
+    // MutexLocker locker(fLock);
+        //uncomment this line will cause double lock
+        //alreay locked in ::Up and ::KPPPInterface
     
     fMRU = MRU;
     
@@ -417 +430 @@
             if (Name())
                 strncpy(info->name, Name(), PPP_HANDLER_NAME_LENGTH_LIMIT);
             if (Ifnet())
-                info->if_unit = Ifnet()->if_unit;
+                info->if_unit = Ifnet()->index;
             else
                 info->if_unit = -1;
             info->mode = Mode();
@@ -456 +469 @@
             if (!data)
                 return B_ERROR;
 
-            LockerHelper locker(fLock);
+            MutexLocker locker(fLock);
             // login information can only be changed before we authenticate
             if (Phase() >= PPP_AUTHENTICATION_PHASE)
                 return B_NOT_ALLOWED;
@@ -471 +484 @@
             if (!data)
                 return B_ERROR;
             
-            LockerHelper locker(fLock);
+            MutexLocker locker(fLock);
             // login information can only be changed before we authenticate
             if (Phase() >= PPP_AUTHENTICATION_PHASE)
                 return B_NOT_ALLOWED;
@@ -524 +537 @@
             if (length < sizeof(ppp_report_request) || !data)
                 return B_ERROR;
 
-            LockerHelper locker(fLock);
+            MutexLocker locker(fLock);
             ppp_report_request *request = (ppp_report_request*) data;
             // first, we send an initial state report
             if (request->type == PPP_CONNECTION_REPORT) {
@@ -656 +669 @@
         return false;
             // main interfaces do not have devices
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (Phase() != PPP_DOWN_PHASE)
         return false;
@@ -704 +717 @@
             || protocol->Level() == PPP_INTERFACE_LEVEL)
         return false;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (Phase() != PPP_DOWN_PHASE)
         return false;
@@ -768 +781 @@
     TRACE("KPPPInterface: RemoveProtocol(%X)\n",
         protocol ? protocol->ProtocolNumber() : 0);
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (Phase() != PPP_DOWN_PHASE)
         return false;
@@ -809 +822 @@
 int32
 KPPPInterface::CountProtocols() const
 {
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     KPPPProtocol *protocol = FirstProtocol();
     
@@ -825 +838 @@
 KPPPProtocol*
 KPPPInterface::ProtocolAt(int32 index) const
 {
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     KPPPProtocol *protocol = FirstProtocol();
     
@@ -849 +862 @@
 {
     TRACE("KPPPInterface: ProtocolFor(%X)\n", protocolNumber);
     
-    LockerHelper locker(fLock);
+    // MutexLocker locker(fLock);
+        // already locked in ::Receive,uncomment this line will cause double lock
     
     KPPPProtocol *current = start ? start : FirstProtocol();
     
@@ -874 +888 @@
     if (!child)
         return false;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (fChildren.HasItem(child) || !fChildren.AddItem(child))
         return false;
@@ -891 +905 @@
 {
     TRACE("KPPPInterface: RemoveChild(%lX)\n", child ? child->ID() : 0);
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (!fChildren.RemoveItem(child))
         return false;
@@ -912 +926 @@
 {
     TRACE("KPPPInterface: ChildAt(%ld)\n", index);
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     KPPPInterface *child = fChildren.ItemAt(index);
     
@@ -945 +959 @@
     
     TRACE("KPPPInterface: SetConnectOnDemand(%s)\n", connectOnDemand ? "true" : "false");
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     // Only clients support ConnectOnDemand.
     if (Mode() != PPP_CLIENT_MODE) {
@@ -973 +987 @@
     // check if we need to set/unset flags
     if (connectOnDemand) {
         if (Ifnet())
-            Ifnet()->if_flags |= IFF_UP;
+            Ifnet()->flags |= IFF_UP;
     } else if (!connectOnDemand && Phase() < PPP_ESTABLISHED_PHASE) {
         if (Ifnet())
-            Ifnet()->if_flags &= ~IFF_UP;
+            Ifnet()->flags &= ~IFF_UP;
     }
 }
 
@@ -985 +999 @@
 void
 KPPPInterface::SetAskBeforeConnecting(bool ask)
 {
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     bool old = fAskBeforeConnecting;
     fAskBeforeConnecting = ask;
     
     if (old && fAskBeforeConnecting == false && State() == PPP_STARTING_STATE
             && Phase() == PPP_DOWN_PHASE) {
-        locker.UnlockNow();
+        // locker.Unlock();
         StateMachine().ContinueOpenEvent();
     }
 }
@@ -1004 +1018 @@
 {
     TRACE("KPPPInterface: SetPFCOptions(0x%X)\n", pfcOptions);
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (PFCOptions() & PPP_FREEZE_PFC_OPTIONS)
         return false;
@@ -1032 +1046 @@
     if (IsUp())
         return true;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     StateMachine().OpenEvent();
     
     return true;
@@ -1059 +1073 @@
     send_data_with_timeout(fReconnectThread, 0, NULL, 0, 200);
         // tell the reconnect thread to abort its attempt (if it's still waiting)
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     StateMachine().CloseEvent();
     
     return true;
@@ -1074 +1088 @@
     
     if (InitCheck() != B_OK)
         return false;
+
+    return true; // for temporary
     
     ReportManager().EnableReports(PPP_CONNECTION_REPORT, find_thread(NULL));
     
@@ -1097 +1113 @@
     }
     
     ReportManager().DisableReports(PPP_CONNECTION_REPORT, find_thread(NULL));
+    dprintf("KPPPInterface: WaitForConnection():%s\n", successful?"True":"False");
     return successful;
 }
 
@@ -1233 +1250 @@
         - \c B_ERROR: Some error occured.
 */
 status_t
-KPPPInterface::Send(struct mbuf *packet, uint16 protocolNumber)
+KPPPInterface::Send(net_buffer *packet, uint16 protocolNumber)
 {
     TRACE("KPPPInterface: Send(0x%X)\n", protocolNumber);
     
     if (!packet)
         return B_ERROR;
-    
+
     // we must pass the basic tests like:
     // do we have a device?
     // did we load all modules?
     if (InitCheck() != B_OK) {
-        m_freem(packet);
+        ERROR("InitCheck() fail\n");
+        gBufferModule->free(packet);
         return B_ERROR;
     }
-    
+
+
     // go up if ConnectOnDemand is enabled and we are disconnected
     // TODO: our new netstack will simplify ConnectOnDemand handling, so
     // we do not have to handle it here
@@ -1255 +1274 @@
             && (Phase() == PPP_DOWN_PHASE
                 || Phase() == PPP_ESTABLISHMENT_PHASE)
             && !Up()) || !WaitForConnection()) {
-        m_freem(packet);
+        gBufferModule->free(packet);
         return B_ERROR;
     }
     
@@ -1279 +1298 @@
 #endif
     
     // make sure that protocol is allowed to send and everything is up
-    if (!Device()->IsUp() || !protocol || !protocol->IsEnabled()
+    if (Device()->IsUp() && protocolNumber==0x0021){ //IP_PROTOCOL 0x0021
+        TRACE("KPPPInterface::Send(): send IP packet!\n");
+    } else if (!Device()->IsUp() || !protocol || !protocol->IsEnabled()
             || !IsProtocolAllowed(*protocol)) {
         ERROR("KPPPInterface::Send(): cannot send!\n");
-        m_freem(packet);
+        gBufferModule->free(packet);
         return B_ERROR;
     }
     
     // encode in ppp frame and consider using PFC
-    if (UseLocalPFC() && protocolNumber & 0xFF00 == 0) {
-        M_PREPEND(packet, 1);
-        
-        if (packet == NULL)
-            return B_ERROR;
+    if ( UseLocalPFC() && ((protocolNumber & 0xFF00) == 0) ) {
+        TRACE("%s::%s should not go here\n",__FILE__,__func__);
+        NetBufferPrepend<uint8> bufferHeader(packet);
+        if (bufferHeader.Status() != B_OK)
+            return bufferHeader.Status();
+
+        uint8 &header = bufferHeader.Data();
+
+        // memcpy(header.destination, ether_pppoe_ppp_header, 1);
+        header = (protocolNumber & 0x00FF);
+        // bufferHeader.Sync();
         
-        uint8 *header = mtod(packet, uint8*);
-        *header = protocolNumber & 0xFF;
     } else {
-        M_PREPEND(packet, 2);
-        
-        if (packet == NULL)
-            return B_ERROR;
-        
+        NetBufferPrepend<uint16> bufferHeader(packet);
+        if (bufferHeader.Status() != B_OK)
+            return bufferHeader.Status();
+
+        uint16 &header = bufferHeader.Data();
+
         // set protocol (the only header field)
-        protocolNumber = htons(protocolNumber);
-        uint16 *header = mtod(packet, uint16*);
-        *header = protocolNumber;
+        header = htons(protocolNumber);
+        // bufferHeader.Sync();
     }
-    
+
     // pass to device if we're either not a multilink interface or a child interface
     if (!IsMultilink() || Parent()) {
         // check if packet is too big for device
-        uint32 length = packet->m_flags & M_PKTHDR ? (uint32) packet->m_pkthdr.len :
-            packet->m_len;
+        uint32 length = packet->size;
         
         if (length > MRU()) {
-            m_freem(packet);
+            dprintf("packet too large!\n");
+            gBufferModule->free(packet);
             return B_ERROR;
         }
         
         atomic_add64(&fStatistics.bytesSent, length);
         atomic_add64(&fStatistics.packetsSent, 1);
+        TRACE("%s::%s SendToNext\n",__FILE__,__func__);
         return SendToNext(packet, 0);
             // this is normally the device, but there can be something inbetween
     } else {
         // the multilink protocol should have sent it to some child interface
-        m_freem(packet);
+        TRACE("It is weird to go here!\n");
+        gBufferModule->free(packet);
         return B_ERROR;
     }
 }
@@ -1348 +1375 @@
         - \c PPP_DISCARDED: The protocol handler(s) did not handle this packet.
 */
 status_t
-KPPPInterface::Receive(struct mbuf *packet, uint16 protocolNumber)
+KPPPInterface::Receive(net_buffer *packet, uint16 protocolNumber)
 {
     TRACE("KPPPInterface: Receive(0x%X)\n", protocolNumber);
     
     if (!packet)
         return B_ERROR;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     int32 result = PPP_REJECTED;
         // assume we have no handler
     
-    // Set our interface as the receiver.
-    // The real netstack protocols (IP, IPX, etc.) might get confused if our
-    // interface is a main interface and at the same time not registered
-    // because then there is no receiver interface.
-    // PPP NCPs should be aware of that!
-    if (packet->m_flags & M_PKTHDR && Ifnet() != NULL)
-        packet->m_pkthdr.rcvif = Ifnet();
+    if (protocolNumber==0x0021 && Device() && Device()->IsUp()){ //IP_PROTOCOL 0x0021
+        TRACE("%s::%s: receiving IP packet\n", __FILE__, __func__);
+        ppp_device* dev=(ppp_device*)Ifnet();
+
+        if(dev){
+            return gStackModule->fifo_enqueue_buffer(&(dev->ppp_fifo), packet);
+        } else {
+            dprintf("%s::%s: no ppp_device\n", __FILE__, __func__);
+            return B_ERROR;
+        }
+    }
+    // // Set our interface as the receiver.
+    // // The real netstack protocols (IP, IPX, etc.) might get confused if our
+    // // interface is a main interface and at the same time not registered
+    // // because then there is no receiver interface.
+    // // PPP NCPs should be aware of that!
+    // if (packet->m_flags & M_PKTHDR && Ifnet() != NULL)
+    //  packet->m_pkthdr.rcvif = Ifnet();
     
     // Find handler and let it parse the packet.
     // The handler does need not be up because if we are a server
@@ -1396 +1434 @@
         return Parent()->Receive(packet, protocolNumber);
     
     if (result == PPP_UNHANDLED) {
-        m_freem(packet);
+        gBufferModule->free(packet);
         return PPP_DISCARDED;
     } else {
         StateMachine().RUCEvent(packet, protocolNumber);
@@ -1419 +1457 @@
         - \c PPP_DISCARDED: The protocol handler(s) did not handle this packet.
 */
 status_t
-KPPPInterface::ReceiveFromDevice(struct mbuf *packet)
+KPPPInterface::ReceiveFromDevice(net_buffer *packet)
 {
     TRACE("KPPPInterface: ReceiveFromDevice()\n");
     
@@ -1427 +1465 @@
         return B_ERROR;
     
     if (InitCheck() != B_OK) {
-        m_freem(packet);
+        gBufferModule->free(packet);
         return B_ERROR;
     }
     
-    uint32 length = packet->m_flags & M_PKTHDR ? (uint32) packet->m_pkthdr.len :
-        packet->m_len;
-    
+    uint32 length = packet->size;
     // decode ppp frame and recognize PFC
-    uint16 protocolNumber = *mtod(packet, uint8*);
-    if (protocolNumber & 1) {
-        m_adj(packet, 1);
+        NetBufferHeaderReader<uint16> bufferHeader(packet);
+        if (bufferHeader.Status() < B_OK)
+                return bufferHeader.Status();
+
+        uint16 &header = bufferHeader.Data();
+    uint16 protocolNumber=ntohs(header); //copy the protocol number
+    TRACE("%s::%s: ppp protocol number:%x\n",__FILE__,__func__,protocolNumber);
+
+    bufferHeader.Remove();
+    bufferHeader.Sync();
+
+    // PFC only use 1 byte for protocol, the next byte is in first byte of message
+    if (protocolNumber & (1UL<<8)) {
+        NetBufferPrepend<uint8> bufferprepend(packet);
+        if (bufferprepend.Status() < B_OK){
+            gBufferModule->free(packet);
+            return bufferprepend.Status();
+        }
+
+        uint8 &prepend = bufferprepend.Data();
+        prepend = (uint8)(protocolNumber & 0x00FF);
+        // bufferprepend.Sync();
+
+        TRACE("%s::%s:PFC protocol:%x\n",__FILE__,__func__,protocolNumber>>8);
     } else {
-        protocolNumber = ntohs(*mtod(packet, uint16*));
-        m_adj(packet, 2);
+        TRACE("%s::%s:Non-PFC protocol:%x\n",__FILE__,__func__, protocolNumber);
     }
-    
+
     atomic_add64(&fStatistics.bytesReceived, length);
     atomic_add64(&fStatistics.packetsReceived, 1);
     return Receive(packet, protocolNumber);
@@ -1453 +1509 @@
 void
 KPPPInterface::Pulse()
 {
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (Device())
         Device()->Pulse();
@@ -1485 +1541 @@
         return true;
             // we are already registered
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     // only MainInterfaces get an ifnet
     if (IsMultilink() && Parent() && Parent()->RegisterInterface())
@@ -1496 +1552 @@
     
     fIfnet = fManager->RegisterInterface(ID());
     
-    if (!fIfnet)
+    if (!fIfnet){
+        dprintf("%s:%s: damn it no fIfnet device\n", __FILE__, __func__);
         return false;
+    }
     
     if (DoesConnectOnDemand())
-        fIfnet->if_flags |= IFF_UP;
+        fIfnet->flags |= IFF_UP;
     
     CalculateInterfaceMTU();
     CalculateBaudRate();
@@ -1519 +1577 @@
         return true;
             // we are already unregistered
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     // only MainInterfaces get an ifnet
     if (IsMultilink() && Parent())
@@ -1587 +1645 @@
     
     status_t result = B_BAD_VALUE, tmp;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     KPPPProtocol *protocol = FirstProtocol();
     for (; protocol; protocol = protocol->NextProtocol()) {
@@ -1613 +1671 @@
 {
     TRACE("KPPPInterface: CalculateInterfaceMTU()\n");
     
-    LockerHelper locker(fLock);
+    // MutexLocker locker(fLock);
+        //uncomment this line will cause double lock
+        //alreay locked in ::KPPPInterface
     
     fInterfaceMTU = fMRU;
     fHeaderLength = 2;
@@ -1628 +1688 @@
     fInterfaceMTU -= fHeaderLength;
     
     if (Ifnet()) {
-        Ifnet()->if_mtu = fInterfaceMTU;
-        Ifnet()->if_hdrlen = fHeaderLength;
+        Ifnet()->mtu = fInterfaceMTU;
+        Ifnet()->header_length = fHeaderLength;
+        return;
     }
     
     if (Parent())
@@ -1643 +1704 @@
 {
     TRACE("KPPPInterface: CalculateBaudRate()\n");
     
-    LockerHelper locker(fLock);
+    // MutexLocker locker(fLock); //uncomment this will cause double lock
     
     if (!Ifnet())
         return;
     
     if (Device())
-        fIfnet->if_baudrate = max_c(Device()->InputTransferRate(),
-            Device()->OutputTransferRate());
+        fIfnet->link_speed = max_c(Device()->InputTransferRate(),
+        Device()->OutputTransferRate());
     else {
-        fIfnet->if_baudrate = 0;
+        fIfnet->link_speed = 0;
         for (int32 index = 0; index < CountChildren(); index++)
             if (ChildAt(index)->Ifnet())
-                fIfnet->if_baudrate += ChildAt(index)->Ifnet()->if_baudrate;
+                fIfnet->link_speed += ChildAt(index)->Ifnet()->link_speed;
+                return;
     }
 }
 
@@ -1666 +1728 @@
 {
     TRACE("KPPPInterface: Reconnect(%ld)\n", delay);
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     if (fReconnectThread != -1)
         return;

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPLCP.cpp

@@ -20 +20 @@
 #include <KPPPOptionHandler.h>
 
 #include <netinet/in.h>
-#include <core_funcs.h>
+
+#include <net_buffer.h>
 #include <sys/socket.h>
 
+extern net_buffer_module_info *gBufferModule;
+
 
 //! Creates a new LCP protocol for the given interface.
 KPPPLCP::KPPPLCP(KPPPInterface& interface)
@@ -230 +233 @@
 
 //! Sends a packet to the target (if there is one) or to the interface.
 status_t
-KPPPLCP::Send(struct mbuf *packet, uint16 protocolNumber)
+KPPPLCP::Send(net_buffer *packet, uint16 protocolNumber)
 {
     if (Target())
         return Target()->Send(packet, PPP_LCP_PROTOCOL);
@@ -241 +244 @@
 
 //! Decodes the LCP packet and passes it to the KPPPStateMachine or an LCP extension.
 status_t
-KPPPLCP::Receive(struct mbuf *packet, uint16 protocolNumber)
+KPPPLCP::Receive(net_buffer *packet, uint16 protocolNumber)
 {
     if (!packet)
         return B_ERROR;
@@ -250 +253 @@
         ERROR("KPPPLCP::Receive(): wrong protocol number!\n");
         return PPP_UNHANDLED;
     }
-    
-    ppp_lcp_packet *data = mtod(packet, ppp_lcp_packet*);
+
+        NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+        if (bufferHeader.Status() < B_OK)
+                return bufferHeader.Status();
+
+        ppp_lcp_packet &data = bufferHeader.Data();
     
     // remove padding
-    int32 length = packet->m_len;
-    if (packet->m_flags & M_PKTHDR)
-        length = packet->m_pkthdr.len;
-    length -= ntohs(data->length);
-    if (length)
-        m_adj(packet, -length);
-    
-    struct mbuf *copy = m_gethdr(MT_DATA);
-    if (copy) {
-        copy->m_data += AdditionalOverhead();
-        copy->m_pkthdr.len = copy->m_len = packet->m_len;
-        memcpy(copy->m_data, packet->m_data, copy->m_len);
-    }
     
-    if (ntohs(data->length) < 4)
+    net_buffer *copy=gBufferModule->duplicate(packet);
+    
+    if (ntohs(data.length) < 4)
         return B_ERROR;
 
     bool handled = true;
 
-    switch (data->code) {
+    switch (data.code) {
         case PPP_CONFIGURE_REQUEST:
             StateMachine().RCREvent(packet);
             break;
@@ -310 +306 @@
             break;
 
         default:
-            m_freem(packet);
+            // gBufferModule->free(packet);
             handled = false;
     }
     
@@ -324 +320 @@
     // Try to find LCP extensions that can handle this code.
     // We must duplicate the packet in order to ask all handlers.
     int32 index = 0;
-    KPPPLCPExtension *lcpExtension = LCPExtensionFor(data->code, &index);
-    for (; lcpExtension; lcpExtension = LCPExtensionFor(data->code, &(++index))) {
+    KPPPLCPExtension *lcpExtension = LCPExtensionFor(data.code, &index);
+    for (; lcpExtension; lcpExtension = LCPExtensionFor(data.code, &(++index))) {
         if (!lcpExtension->IsEnabled())
             continue;
         
-        result = lcpExtension->Receive(packet, data->code);
+        result = lcpExtension->Receive(packet, data.code);
         
         // check return value and return it on error
         if (result == B_OK)
             handled = true;
         else if (result != PPP_UNHANDLED) {
-            m_freem(packet);
+            gBufferModule->free(packet);
             return result;
         }
     }
@@ -345 +341 @@
         return PPP_REJECTED;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
     
     return result;
 }

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPLayer.cpp

@@ -19 +19 @@
 
 #include <KPPPLayer.h>
 
+#include <net_buffer.h>
+
 #include <cstdlib>
 #include <cstring>
-#include <core_funcs.h>
 
+extern net_buffer_module_info *gBufferModule;
 
 /*! \brief Creates a new layer.
     
@@ -56 +58 @@
 
 //! Sends a packet to the next layer in the chain.
 status_t
-KPPPLayer::SendToNext(struct mbuf *packet, uint16 protocolNumber) const
+KPPPLayer::SendToNext(net_buffer *packet, uint16 protocolNumber) const
 {
     if (!packet)
         return B_ERROR;
@@ -70 +72 @@
             return Next()->SendToNext(packet, protocolNumber);
     } else {
         ERROR("KPPPLayer: SendToNext() failed because there is no next handler!\n");
-        m_freem(packet);
+        gBufferModule->free(packet);
         return B_ERROR;
     }
 }

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPReportManager.cpp

@@ -9 +9 @@
 
 #include <KPPPReportManager.h>
 
-#include <LockerHelper.h>
+#include <lock.h>
+#include <util/AutoLock.h>
+
 #include <KPPPUtils.h>
 
 
@@ -33 +35 @@
     
     \param lock The BLocker that should be used by this report manager.
 */
-KPPPReportManager::KPPPReportManager(BLocker& lock)
+KPPPReportManager::KPPPReportManager(mutex& lock)
     : fLock(lock)
 {
 }
@@ -88 +90 @@
     if (thread < 0 || type == PPP_ALL_REPORTS)
         return;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     ppp_report_request *request = new ppp_report_request;
     request->type = type;
@@ -106 +108 @@
     if (thread < 0)
         return;
     
-    LockerHelper locker(fLock);
+     MutexLocker locker(fLock);
     
     ppp_report_request *request;
     
@@ -135 +137 @@
     if (thread < 0)
         return false;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     ppp_report_request *request;
     
@@ -177 +179 @@
     if (!data)
         length = 0;
     
-    LockerHelper locker(fLock);
+    MutexLocker locker(fLock);
     
     status_t result;
     thread_id me = find_thread(NULL);

src/add-ons/kernel/network/ppp/shared/libkernelppp/KPPPStateMachine.cpp

@@ -22 +22 @@
 #include <KPPPUtils.h>
 
 #include <net/if.h>
-#include <core_funcs.h>
 
+#include <net_buffer.h>
+#include <ByteOrder.h>
+#include <NetBufferUtilities.h>
+
+extern net_buffer_module_info *gBufferModule;
 
 static const bigtime_t kPPPStateMachineTimeout = 3000000;
     // 3 seconds
@@ -48 +52 @@
     fRequestID(0),
     fTerminateID(0),
     fEchoID(0),
-    fNextTimeout(0),
-    fLock("KPPPStateMachine")
+    fNextTimeout(0)//,
+    //fLock("KPPPStateMachine")
 {
+    mutex_init(&fLock,"KPPPStateMachine");
 }
 
 
@@ -114 +119 @@
     // The report threads get their notification later.
     if (Phase() == PPP_ESTABLISHED_PHASE && next != Phase()) {
         if (Interface().Ifnet()) {
-            Interface().Ifnet()->if_flags &= ~IFF_RUNNING;
-            Interface().Ifnet()->if_flags &= ~IFF_UP;
+            // Interface().Ifnet()->flags &= ~IFF_RUNNING;
+            Interface().Ifnet()->flags &= ~IFF_UP;
         }
         
         if (Interface().Parent())
@@ -128 +133 @@
         Interface().fConnectedSince = system_time();
         
         if (Interface().Ifnet())
-            Interface().Ifnet()->if_flags |= IFF_UP | IFF_RUNNING;
+            Interface().Ifnet()->flags |= IFF_UP;// | IFF_RUNNING;
         
         Interface().fConnectAttempt = 0;
             // when we Reconnect() this becomes 1 (the first connection attempt)
@@ -172 +177 @@
     if (State() != PPP_OPENED_STATE)
         return false;
     
-    struct mbuf *packet = m_gethdr(MT_DATA);
-    if (!packet)
+        net_buffer *packet = gBufferModule->create(256);
+        if (packet == NULL)
         return false;
-    
-    packet->m_data += LCP().AdditionalOverhead();
-    packet->m_pkthdr.len = packet->m_len = 8;
-        // echo requests are at least eight bytes long
-    
-    ppp_lcp_packet *request = mtod(packet, ppp_lcp_packet*);
-    request->code = PPP_ECHO_REQUEST;
-    request->id = NextID();
-    fEchoID = request->id;
-    request->length = htons(packet->m_len);
-    memcpy(request->data, &fMagicNumber, sizeof(fMagicNumber));
+
+        void *data;
+        status_t status = gBufferModule->append_size(packet, 1492, &data);
+        if (status == B_OK && data == NULL) {
+                gBufferModule->free(packet);
+        return false;
+        }
+
+    // echo requests are at least eight bytes long
+    ppp_lcp_packet request;
+    request.code = PPP_ECHO_REQUEST;
+    request.id = NextID();
+    request.length = htons(8);
+    fEchoID = request.id;
+
+    memcpy(data, &request, sizeof(request));
+    memcpy(request.data, &fMagicNumber, sizeof(fMagicNumber));
+
+        status = gBufferModule->trim(packet, sizeof(request)+sizeof(fMagicNumber));
+        if (status < B_OK) {
+                gBufferModule->free(packet);
+        return false;
+        }
     
     return LCP().Send(packet) == B_OK;
 }
@@ -197 +214 @@
 {
     TRACE("KPPPSM: SendDiscardRequest() state=%d phase=%d\n", State(), Phase());
     
-    if (State() != PPP_OPENED_STATE)
+    net_buffer *packet = gBufferModule->create(256);
+    if (packet == NULL)
         return false;
-    
-    struct mbuf *packet = m_gethdr(MT_DATA);
-    if (!packet)
+
+    void *data;
+    status_t status = gBufferModule->append_size(packet, 1492, &data);
+    if (status == B_OK && data == NULL) {
+        gBufferModule->free(packet);
         return false;
-    
-    packet->m_data += LCP().AdditionalOverhead();
-    packet->m_pkthdr.len = packet->m_len = 8;
+    }
+
         // discard requests are at least eight bytes long
-    
-    ppp_lcp_packet *request = mtod(packet, ppp_lcp_packet*);
-    request->code = PPP_DISCARD_REQUEST;
-    request->id = NextID();
-    request->length = htons(packet->m_len);
-    memcpy(request->data, &fMagicNumber, sizeof(fMagicNumber));
+    // echo requests are at least eight bytes long
+    ppp_lcp_packet request;
+    request.code = PPP_DISCARD_REQUEST;
+    request.id = NextID();
+    request.length = htons(8);
+    fEchoID = request.id;
+
+    memcpy(data, &request, sizeof(request));
+    memcpy(request.data, &fMagicNumber, sizeof(fMagicNumber));
+
+    status = gBufferModule->trim(packet, sizeof(request)+sizeof(fMagicNumber));
+    if (status < B_OK) {
+        gBufferModule->free(packet);
+        return false;
+    }
     
     return LCP().Send(packet) == B_OK;
 }
@@ -893 +921 @@
 
 // receive configure request (acceptable request)
 void
-KPPPStateMachine::RCRGoodEvent(struct mbuf *packet)
+KPPPStateMachine::RCRGoodEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RCRGoodEvent() state=%d phase=%d\n", State(), Phase());
     
     switch (State()) {
         case PPP_INITIAL_STATE:
         case PPP_STARTING_STATE:
+            TRACE("%s::%s: PPP_STARTING_STATE\n",__FILE__,__func__);
             IllegalEvent(PPP_RCR_GOOD_EVENT);
-            m_freem(packet);
+            gBufferModule->free(packet);
             break;
         
         case PPP_CLOSED_STATE:
+            TRACE("%s::%s: PPP_CLOSED_STATE\n",__FILE__,__func__);
             SendTerminateAck();
-            m_freem(packet);
+            gBufferModule->free(packet);
             break;
         
         case PPP_STOPPED_STATE:
+            TRACE("%s::%s: PPP_STOPPED_STATE\n",__FILE__,__func__);
             // irc,scr,sca/8
             // XXX: should we do nothing and wait for DownEvent()?
-            m_freem(packet);
+            gBufferModule->free(packet);
             break;
         
         case PPP_REQ_SENT_STATE:
             NewState(PPP_ACK_SENT_STATE);
         
         case PPP_ACK_SENT_STATE:
+            TRACE("%s::%s: PPP_ACK_SENT_STATE size %ld\n",__FILE__,__func__,
+                        packet->size);
             SendConfigureAck(packet);
             break;
         
         case PPP_ACK_RCVD_STATE:
+            TRACE("%s::%s: PPP_ACK_RCVD_STATE\n",__FILE__,__func__);
             NewState(PPP_OPENED_STATE);
             SendConfigureAck(packet);
             ThisLayerUp();
             break;
         
         case PPP_OPENED_STATE:
+            TRACE("%s::%s: PPP_OPENED_STATE\n",__FILE__,__func__);
             NewState(PPP_ACK_SENT_STATE);
             NewPhase(PPP_ESTABLISHMENT_PHASE);
                 // indicates to handlers that we are reconfiguring
@@ -938 +973 @@
             break;
         
         default:
-            m_freem(packet);
+            TRACE("free peer's ppp request packet\n");
+            gBufferModule->free(packet);
     }
 }
 
 
 // receive configure request (unacceptable request)
 void
-KPPPStateMachine::RCRBadEvent(struct mbuf *nak, struct mbuf *reject)
+KPPPStateMachine::RCRBadEvent(net_buffer *nak, net_buffer *reject)
 {
     TRACE("KPPPSM: RCRBadEvent() state=%d phase=%d\n", State(), Phase());
+
+    uint16 nak_len,reject_len;
     
     switch (State()) {
         case PPP_INITIAL_STATE:
@@ -978 +1016 @@
         
         case PPP_REQ_SENT_STATE:
         case PPP_ACK_RCVD_STATE:
-            if (nak && ntohs(mtod(nak, ppp_lcp_packet*)->length) > 3)
+            if (nak) {
+                    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader_nak(nak);
+                if (bufferHeader_nak.Status() < B_OK)
+                    break;
+                ppp_lcp_packet &header_nak = bufferHeader_nak.Data();
+                nak_len=header_nak.length;
+            }
+
+            if (reject) {
+                    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader_reject(reject);
+                if (bufferHeader_reject.Status() < B_OK)
+                    break;
+                ppp_lcp_packet &header_reject = bufferHeader_reject.Data();
+                reject_len=header_reject.length;
+            }
+
+            if (nak && nak_len > 3)
                 SendConfigureNak(nak);
-            else if (reject && ntohs(mtod(reject, ppp_lcp_packet*)->length) > 3)
+            else if (reject && reject_len > 3)
                 SendConfigureNak(reject);
             return;
             // prevents the nak/reject from being m_freem()'d
@@ -990 +1044 @@
     }
     
     if (nak)
-        m_freem(nak);
+        gBufferModule->free(nak);
     if (reject)
-        m_freem(reject);
+        gBufferModule->free(reject);
 }
 
 
 // receive configure ack
 void
-KPPPStateMachine::RCAEvent(struct mbuf *packet)
+KPPPStateMachine::RCAEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RCAEvent() state=%d phase=%d\n", State(), Phase());
     
-    if (fRequestID != mtod(packet, ppp_lcp_packet*)->id) {
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &header = bufferHeader.Data();
+
+    if (fRequestID != header.id) {
         // this packet is not a reply to our request
         
         // TODO:
         // log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
     
@@ -1017 +1076 @@
     for (int32 index = 0; index < LCP().CountOptionHandlers(); index++) {
         optionHandler = LCP().OptionHandlerAt(index);
         if (optionHandler->ParseAck(ack) != B_OK) {
-            m_freem(packet);
+            gBufferModule->free(packet);
             CloseEvent();
             return;
         }
@@ -1062 +1121 @@
             ;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
 // receive configure nak/reject
 void
-KPPPStateMachine::RCNEvent(struct mbuf *packet)
+KPPPStateMachine::RCNEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RCNEvent() state=%d phase=%d\n", State(), Phase());
     
-    if (fRequestID != mtod(packet, ppp_lcp_packet*)->id) {
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &header = bufferHeader.Data();
+
+    if (fRequestID != header.id) {
         // this packet is not a reply to our request
         
         // TODO:
         // log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
     
@@ -1089 +1153 @@
         
         if (nak_reject.Code() == PPP_CONFIGURE_NAK) {
             if (optionHandler->ParseNak(nak_reject) != B_OK) {
-                m_freem(packet);
+                gBufferModule->free(packet);
                 CloseEvent();
                 return;
             }
         } else if (nak_reject.Code() == PPP_CONFIGURE_REJECT) {
             if (optionHandler->ParseReject(nak_reject) != B_OK) {
-                m_freem(packet);
+                gBufferModule->free(packet);
                 CloseEvent();
                 return;
             }
@@ -1135 +1199 @@
             ;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
 // receive terminate request
 void
-KPPPStateMachine::RTREvent(struct mbuf *packet)
+KPPPStateMachine::RTREvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RTREvent() state=%d phase=%d\n", State(), Phase());
     
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &header = bufferHeader.Data();
+
     // we should not use the same ID as the peer
-    if (fID == mtod(packet, ppp_lcp_packet*)->id)
+    if (fID == header.id)
         fID -= 128;
     
     fLocalAuthenticationStatus = PPP_NOT_AUTHENTICATED;
@@ -1156 +1225 @@
         case PPP_INITIAL_STATE:
         case PPP_STARTING_STATE:
             IllegalEvent(PPP_RTR_EVENT);
-            m_freem(packet);
+            gBufferModule->free(packet);
             break;
         
         case PPP_ACK_RCVD_STATE:
@@ -1186 +1255 @@
 
 // receive terminate ack
 void
-KPPPStateMachine::RTAEvent(struct mbuf *packet)
+KPPPStateMachine::RTAEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RTAEvent() state=%d phase=%d\n", State(), Phase());
     
-    if (fTerminateID != mtod(packet, ppp_lcp_packet*)->id) {
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &header = bufferHeader.Data();
+
+    if (fTerminateID != header.id) {
         // this packet is not a reply to our request
         
         // TODO:
         // log this event
-        m_freem(packet);
+        gBufferModule->free(packet);
         return;
     }
     
@@ -1231 +1305 @@
             ;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
 // receive unknown code
 void
-KPPPStateMachine::RUCEvent(struct mbuf *packet, uint16 protocolNumber,
+KPPPStateMachine::RUCEvent(net_buffer *packet, uint16 protocolNumber,
     uint8 code)
 {
     TRACE("KPPPSM: RUCEvent() state=%d phase=%d\n", State(), Phase());
@@ -1246 +1320 @@
         case PPP_INITIAL_STATE:
         case PPP_STARTING_STATE:
             IllegalEvent(PPP_RUC_EVENT);
-            m_freem(packet);
+            gBufferModule->free(packet);
             break;
         
         default:
@@ -1257 +1331 @@
 
 // receive code/protocol reject (acceptable such as IPX reject)
 void
-KPPPStateMachine::RXJGoodEvent(struct mbuf *packet)
+KPPPStateMachine::RXJGoodEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RXJGoodEvent() state=%d phase=%d\n", State(), Phase());
     
@@ -1282 +1356 @@
 
 // receive code/protocol reject (catastrophic such as LCP reject)
 void
-KPPPStateMachine::RXJBadEvent(struct mbuf *packet)
+KPPPStateMachine::RXJBadEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RXJBadEvent() state=%d phase=%d\n", State(), Phase());
     
@@ -1321 +1395 @@
             break;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
 // receive echo request/reply, discard request
 void
-KPPPStateMachine::RXREvent(struct mbuf *packet)
+KPPPStateMachine::RXREvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RXREvent() state=%d phase=%d\n", State(), Phase());
     
-    ppp_lcp_packet *echo = mtod(packet, ppp_lcp_packet*);
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &echo = bufferHeader.Data();
     
-    if (echo->code == PPP_ECHO_REPLY && echo->id != fEchoID) {
+    if (echo.code == PPP_ECHO_REPLY && echo.id != fEchoID) {
         // TODO:
         // log that we got a reply, but no request was sent
     }
@@ -1345 +1422 @@
             break;
         
         case PPP_OPENED_STATE:
-            if (echo->code == PPP_ECHO_REQUEST)
+            if (echo.code == PPP_ECHO_REQUEST)
                 SendEchoReply(packet);
             return;
                 // this prevents the packet from being freed
@@ -1354 +1431 @@
             ;
     }
     
-    m_freem(packet);
+    gBufferModule->free(packet);
 }
 
 
@@ -1397 +1474 @@
 
 
 // ReceiveConfigureRequest
-// Here we get a configure-request packet from LCP and aks all OptionHandlers
+// Here we get a configure-request packet from LCP and ask all OptionHandlers
 // if its values are acceptable. From here we call our Good/Bad counterparts.
 void
-KPPPStateMachine::RCREvent(struct mbuf *packet)
+KPPPStateMachine::RCREvent(net_buffer *packet)
 {
-    TRACE("KPPPSM: RCREvent() state=%d phase=%d\n", State(), Phase());
+    TRACE("KPPPSM: RCREvent() state=%d phase=%d lcppacket size=%ld\n", State(), Phase(), 
+                packet->size);
     
     KPPPConfigurePacket request(packet);
     KPPPConfigurePacket nak(PPP_CONFIGURE_NAK);
     KPPPConfigurePacket reject(PPP_CONFIGURE_REJECT);
     
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &header = bufferHeader.Data();
+
     // we should not use the same id as the peer
-    if (fID == mtod(packet, ppp_lcp_packet*)->id)
+    if (fID == header.id)
         fID -= 128;
+        // or maybe we should use peer's ID plus 1 ?
     
     nak.SetID(request.ID());
     reject.SetID(request.ID());
@@ -1423 +1507 @@
         optionHandler = LCP().OptionHandlerFor(request.ItemAt(index)->type);
         
         if (!optionHandler || !optionHandler->IsEnabled()) {
-            ERROR("KPPPSM::RCREvent():unknown type:%d\n", request.ItemAt(index)->type);
-            // unhandled items should be added to the reject
-            reject.AddItem(request.ItemAt(index));
-            continue;
+            TRACE("KPPPSM::RCREvent():unknown type:%d\n", request.ItemAt(index)->type);
+            if(request.ItemAt(index)->type==0x5)
+            {
+                // type 0x5 is Magic Number, Need no processing.
+                TRACE("Peer Magic Number:%02x %02x %02x %02x\n",
+                    (request.ItemAt(index)->data)[0],
+                    (request.ItemAt(index)->data)[1],
+                    (request.ItemAt(index)->data)[2],
+                    (request.ItemAt(index)->data)[3]);
+                continue;
+            } else {
+                // unhandled items should be added to the reject
+                TRACE("why come here %ld\n",index);
+                reject.AddItem(request.ItemAt(index));
+                continue;
+            }
         }
         
         TRACE("KPPPSM::RCREvent(): OH=%s\n",
@@ -1435 +1531 @@
         
         if (result == PPP_UNHANDLED) {
             // unhandled items should be added to the reject
+            TRACE("PPP_UNHANDLED %ld\n",index);
             reject.AddItem(request.ItemAt(index));
             continue;
         } else if (result != B_OK) {
             // the request contains a value that has been sent more than
             // once or the value is corrupted
             ERROR("KPPPSM::RCREvent(): OptionHandler returned parse error!\n");
-            m_freem(packet);
+            gBufferModule->free(packet);
             CloseEvent();
             return;
         }
@@ -1460 +1557 @@
                     // the request contains a value that has been sent more than
                     // once or the value is corrupted
                     ERROR("KPPPSM::RCREvent():OptionHandler returned append error!\n");
-                    m_freem(packet);
+                    gBufferModule->free(packet);
                     CloseEvent();
                     return;
                 }
@@ -1469 +1566 @@
     }
     
     if (reject.CountItems() > 0) {
+        TRACE("%s:reject number more than 0\n",__func__);
         RCRBadEvent(NULL, reject.ToMbuf(Interface().MRU(), LCP().AdditionalOverhead()));
-        m_freem(packet);
+        gBufferModule->free(packet);
     } else if (nak.CountItems() > 0) {
+        TRACE("%s:nak number more than 0\n",__func__);
         RCRBadEvent(nak.ToMbuf(Interface().MRU(), LCP().AdditionalOverhead()), NULL);
-        m_freem(packet);
+        gBufferModule->free(packet);
     } else
         RCRGoodEvent(packet);
 }
@@ -1483 +1582 @@
 // LCP received a code/protocol-reject packet and we look if it is acceptable.
 // From here we call our Good/Bad counterparts.
 void
-KPPPStateMachine::RXJEvent(struct mbuf *packet)
+KPPPStateMachine::RXJEvent(net_buffer *packet)
 {
     TRACE("KPPPSM: RXJEvent() state=%d phase=%d\n", State(), Phase());
     
-    ppp_lcp_packet *reject = mtod(packet, ppp_lcp_packet*);
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return;
+    ppp_lcp_packet &reject = bufferHeader.Data();
     
-    if (reject->code == PPP_CODE_REJECT) {
-        uint8 rejectedCode = reject->data[0];
+    if (reject.code == PPP_CODE_REJECT) {
+        uint8 rejectedCode = reject.data[0];
         
         // test if the rejected code belongs to the minimum LCP requirements
         if (rejectedCode >= PPP_MIN_LCP_CODE && rejectedCode <= PPP_MAX_LCP_CODE) {
             if (Interface().IsMultilink() && !Interface().Parent()) {
                 // Main interfaces do not have states between STARTING and OPENED.
                 // An RXJBadEvent() would enter one of those states which is bad.
-                m_freem(packet);
+                gBufferModule->free(packet);
                 CloseEvent();
             } else
                 RXJBadEvent(packet);
@@ -1514 +1616 @@
                 lcpExtension->SetEnabled(false);
         }
         
-        m_freem(packet);
-    } else if (reject->code == PPP_PROTOCOL_REJECT) {
+        gBufferModule->free(packet);
+    } else if (reject.code == PPP_PROTOCOL_REJECT) {
         // disable all handlers for rejected protocol type
-        uint16 rejected = *((uint16*) reject->data);
+        uint16 rejected = *((uint16*) reject.data);
             // rejected protocol number
         
         if (rejected == PPP_LCP_PROTOCOL) {
@@ -1541 +1643 @@
         if (Interface().Parent())
             Interface().Parent()->StateMachine().RXJEvent(packet);
         else
-            m_freem(packet);
+            gBufferModule->free(packet);
     }
 }
 
@@ -1552 +1654 @@
 {
     // TODO:
     // update error statistics
-    ERROR("KPPPSM: IllegalEvent(event=%d) state=%d phase=%d\n",
+    TRACE("KPPPSM: IllegalEvent(event=%d) state=%d phase=%d\n",
         event, State(), Phase());
 }
 
@@ -1649 +1751 @@
 
 
 bool
-KPPPStateMachine::SendConfigureAck(struct mbuf *packet)
+KPPPStateMachine::SendConfigureAck(net_buffer *packet)
 {
     TRACE("KPPPSM: SendConfigureAck() state=%d phase=%d\n", State(), Phase());
     
     if (!packet)
         return false;
     
-    mtod(packet, ppp_lcp_packet*)->code = PPP_CONFIGURE_ACK;
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return false;
+    ppp_lcp_packet &header = bufferHeader.Data();
+
+    header.code = PPP_CONFIGURE_ACK;
+    bufferHeader.Sync();
+
     KPPPConfigurePacket ack(packet);
     
     // notify all option handlers that we are sending an ack for each value
     for (int32 index = 0; index < LCP().CountOptionHandlers(); index++) {
         if (LCP().OptionHandlerAt(index)->SendingAck(ack) != B_OK) {
-            m_freem(packet);
+            TRACE("%s::%s: SendingAck %ld fail\n",__FILE__,__func__,index);
+            gBufferModule->free(packet);
             CloseEvent();
             return false;
         }
     }
     
+    TRACE("%s::%s: LCP().Send\n",__FILE__,__func__);
     return LCP().Send(packet) == B_OK;
 }
 
 
 bool
-KPPPStateMachine::SendConfigureNak(struct mbuf *packet)
+KPPPStateMachine::SendConfigureNak(net_buffer *packet)
 {
     TRACE("KPPPSM: SendConfigureNak() state=%d phase=%d\n", State(), Phase());
     
     if (!packet)
         return false;
     
-    ppp_lcp_packet *nak = mtod(packet, ppp_lcp_packet*);
-    if (nak->code == PPP_CONFIGURE_NAK) {
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return false;
+    ppp_lcp_packet &nak = bufferHeader.Data();
+
+    if (nak.code == PPP_CONFIGURE_NAK) {
         if (fNakCounter == 0) {
             // We sent enough naks. Let's try a reject.
-            nak->code = PPP_CONFIGURE_REJECT;
+            nak.code = PPP_CONFIGURE_REJECT;
         } else
             --fNakCounter;
     }
@@ -1700 +1815 @@
     
     --fTerminateCounter;
     fNextTimeout = system_time() + kPPPStateMachineTimeout;
-    
-    struct mbuf *packet = m_gethdr(MT_DATA);
+
+        net_buffer *buffer = gBufferModule->create(256);
+        if (buffer == NULL) 
+                return(NULL);
+
+        ppp_lcp_packet *packet;
+        status_t status = gBufferModule->append_size(buffer, 1492, (void **)&packet);
+        if (status == B_OK && packet == NULL) {
+                gBufferModule->free(buffer);
+                return(NULL);
+    }
+
     if (!packet)
         return false;
     
-    packet->m_pkthdr.len = packet->m_len = 4;
-    
-    // reserve some space for other protocols
-    packet->m_data += LCP().AdditionalOverhead();
-    
-    ppp_lcp_packet *request = mtod(packet, ppp_lcp_packet*);
-    request->code = PPP_TERMINATE_REQUEST;
-    request->id = fTerminateID = NextID();
-    request->length = htons(4);
-    
-    return LCP().Send(packet) == B_OK;
+    packet->code = PPP_TERMINATE_REQUEST;
+    packet->id = fTerminateID = NextID();
+    packet->length = htons(4);
+
+        status = gBufferModule->trim(buffer, 4);
+        if (status < B_OK) {
+                gBufferModule->free(buffer);
+                return(NULL);
+        }
+
+    return LCP().Send(buffer) == B_OK;
 }
 
 
 bool
-KPPPStateMachine::SendTerminateAck(struct mbuf *request)
+KPPPStateMachine::SendTerminateAck(net_buffer *request)
 {
     TRACE("KPPPSM: SendTerminateAck() state=%d phase=%d\n", State(), Phase());
     
-    struct mbuf *reply = request;
+    net_buffer *reply = request;
     
-    ppp_lcp_packet *ack;
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(request);
+    if (bufferHeader.Status() < B_OK)
+        return false;
+    ppp_lcp_packet &ack = bufferHeader.Data();
     
     if (!reply) {
-        reply = m_gethdr(MT_DATA);
-        if (!reply)
-            return false;
-        
-        reply->m_data += LCP().AdditionalOverhead();
-        reply->m_pkthdr.len = reply->m_len = 4;
-        
-        ack = mtod(reply, ppp_lcp_packet*);
-        ack->id = NextID();
-    } else
-        ack = mtod(reply, ppp_lcp_packet*);
+        ack.length = htons(4);
+        ack.id = NextID();
+    }
     
-    ack->code = PPP_TERMINATE_ACK;
-    ack->length = htons(4);
+    ack.code = PPP_TERMINATE_ACK;
+    ack.length = htons(4);
     
     return LCP().Send(reply) == B_OK;
 }
 
 
 bool
-KPPPStateMachine::SendCodeReject(struct mbuf *packet, uint16 protocolNumber, uint8 code)
+KPPPStateMachine::SendCodeReject(net_buffer *packet, uint16 protocolNumber, uint8 code)
 {
     TRACE("KPPPSM: SendCodeReject(protocolNumber=%X;code=%d) state=%d phase=%d\n",
         protocolNumber, code, State(), Phase());
@@ -1764 +1884 @@
     else
         length = 4;
     
-    M_PREPEND(packet, length);
-        // add some space for the header
-    
-    // adjust packet if too big
-    int32 adjust = Interface().MRU();
-    if (packet->m_flags & M_PKTHDR) {
-        adjust -= packet->m_pkthdr.len;
-    } else
-        adjust -= packet->m_len;
-    
-    if (adjust < 0)
-        m_adj(packet, adjust);
-    
-    ppp_lcp_packet *reject = mtod(packet, ppp_lcp_packet*);
-    reject->code = code;
-    reject->id = NextID();
-    if (packet->m_flags & M_PKTHDR)
-        reject->length = htons(packet->m_pkthdr.len);
-    else
-        reject->length = htons(packet->m_len);
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(packet);
+    if (bufferHeader.Status() < B_OK)
+        return false;
+    ppp_lcp_packet &reject = bufferHeader.Data();
+
+    reject.code = code;
+    reject.id = NextID();
+    reject.length = htons(length);
     
     protocolNumber = htons(protocolNumber);
     if (code == PPP_PROTOCOL_REJECT)
-        memcpy(&reject->data, &protocolNumber, sizeof(protocolNumber));
+        memcpy(&reject.data, &protocolNumber, sizeof(protocolNumber));
     
     return LCP().Send(packet) == B_OK;
 }
 
 
 bool
-KPPPStateMachine::SendEchoReply(struct mbuf *request)
+KPPPStateMachine::SendEchoReply(net_buffer *request)
 {
     TRACE("KPPPSM: SendEchoReply() state=%d phase=%d\n", State(), Phase());
     
     if (!request)
         return false;
     
-    ppp_lcp_packet *reply = mtod(request, ppp_lcp_packet*);
-    reply->code = PPP_ECHO_REPLY;
+    NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(request);
+    if (bufferHeader.Status() < B_OK)
+        return false;
+    ppp_lcp_packet &reply = bufferHeader.Data();
+
+    reply.code = PPP_ECHO_REPLY;
         // the request becomes a reply
     
-    if (request->m_flags & M_PKTHDR)
-        request->m_pkthdr.len = 8;
-    request->m_len = 8;
-    
-    memcpy(reply->data, &fMagicNumber, sizeof(fMagicNumber));
+    memcpy(reply.data, &fMagicNumber, sizeof(fMagicNumber));
     
     return LCP().Send(request) == B_OK;
 }

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPConfigurePacket.h

@@ -7 +7 @@
 #define _K_PPP_CONFIGURE_PACKET__H
 
 #include <TemplateList.h>
-
-struct mbuf;
+#include <net_buffer.h>
 
 //! An abstract configure item.
 typedef struct ppp_configure_item {
@@ -29 +28 @@
 
     public:
         KPPPConfigurePacket(uint8 code);
-        KPPPConfigurePacket(struct mbuf *packet);
+        KPPPConfigurePacket(net_buffer *packet);
         ~KPPPConfigurePacket();
         
         bool SetCode(uint8 code);
@@ -52 +51 @@
         ppp_configure_item *ItemAt(int32 index) const;
         ppp_configure_item *ItemWithType(uint8 type) const;
         
-        struct mbuf *ToMbuf(uint32 MRU, uint32 reserve = 0);
-            // the user is responsible for freeing the mbuf
+        net_buffer *ToMbuf(uint32 MRU, uint32 reserve = 0);
+            // the user is responsible for freeing the net_buffer
 
     private:
         uint8 fCode, fID;

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPDevice.h

@@ -9 +9 @@
 #include <KPPPDefs.h>
 #include <KPPPLayer.h>
 
+#include <net_buffer.h>
+
 #ifndef _K_PPP_INTERFACE__H
 #include <KPPPInterface.h>
 #endif
@@ -96 +98 @@
             This should enqueue the packet and return immediately (never block).
             The device is responsible for freeing the packet by calling \c m_freem().
         */
-        virtual status_t Send(struct mbuf *packet, uint16 protocolNumber) = 0;
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber);
+        virtual status_t Send(net_buffer *packet, uint16 protocolNumber) = 0;
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber);
 
     protected:
         //! Use this to set the device's maximum transfer unit (in bytes).

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPInterface.h

@@ -30 +30 @@
 
 #include <TemplateList.h>
 
+#include <net_buffer.h>
+#include <net_device.h>
+
+#include <lock.h>
+#include <util/AutoLock.h>
+
 class KPPPDevice;
 class KPPPProtocol;
 class KPPPOptionHandler;
@@ -48 +54 @@
         KPPPInterface(const KPPPInterface& copy);
         KPPPInterface& operator= (const KPPPInterface& copy);
         
+    public:
+        // we should set to private after finishing test
         // only PPPManager may construct us!
         KPPPInterface(const char *name, ppp_interface_entry *entry,
             ppp_interface_id ID, const driver_settings *settings,
@@ -75 +83 @@
             { return fLCP; }
         
         //! Returns the interfac's ifnet structure that is exported to the netstack.
-        struct ifnet *Ifnet() const
-            { return fIfnet; }
+        net_device *Ifnet() const
+            { return fIfnet; }
         
         const char *Username() const;
         const char *Password() const;
@@ -220 +228 @@
         virtual bool IsAllowedToSend() const;
             // always returns true
         
-        virtual status_t Send(struct mbuf *packet, uint16 protocolNumber);
+        virtual status_t Send(net_buffer *packet, uint16 protocolNumber);
             // sends the packet to the next handler (normally the device)
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber);
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber);
         
-        status_t ReceiveFromDevice(struct mbuf *packet);
+        status_t ReceiveFromDevice(net_buffer *packet);
             // This must not block KPPPDevice::Send()!
         
         void Pulse();
@@ -255 +263 @@
         ppp_interface_id fID;
             // the manager assigns an ID to every interface
         driver_settings *fSettings;
-        struct ifnet *fIfnet;
+        net_device *fIfnet;
         
         char *fUsername, *fPassword;
         
@@ -288 +296 @@
         KPPPStateMachine fStateMachine;
         KPPPLCP fLCP;
         KPPPReportManager fReportManager;
-        BLocker& fLock;
+        mutex& fLock;
         int32 fDeleteCounter;
 };
 

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPLCP.h

@@ -20 +20 @@
 #include <KPPPStateMachine.h>
 #endif
 
+#include <net_buffer.h>
+#include <NetBufferUtilities.h>
+
 class KPPPLCPExtension;
 class KPPPOptionHandler;
 
@@ -85 +88 @@
         virtual bool Up();
         virtual bool Down();
         
-        virtual status_t Send(struct mbuf *packet,
+        virtual status_t Send(net_buffer *packet,
             uint16 protocolNumber = PPP_LCP_PROTOCOL);
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber);
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber);
         
         virtual void Pulse();
 

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPLCPExtension.h

@@ -51 +51 @@
             // called by netstack (forwarded by KPPPInterface)
         
         //! Must be overridden. Called when an LCP packet with your code is received.
-        virtual status_t Receive(struct mbuf *packet, uint8 code) = 0;
+        virtual status_t Receive(net_buffer *packet, uint8 code) = 0;
         
         virtual void Reset();
         virtual void Pulse();

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPLayer.h

@@ -8 +8 @@
 
 #include <KPPPDefs.h>
 
+#include <net_buffer.h>
 
 class KPPPLayer {
     protected:
@@ -48 +49 @@
         virtual bool IsAllowedToSend() const = 0;
         
         //! Send a packet with the given protocol number.
-        virtual status_t Send(struct mbuf *packet, uint16 protocolNumber) = 0;
+        virtual status_t Send(net_buffer *packet, uint16 protocolNumber) = 0;
         //! Receive a packet with the given protocol number.
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber) = 0;
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber) = 0;
         
-        status_t SendToNext(struct mbuf *packet, uint16 protocolNumber) const;
+        status_t SendToNext(net_buffer *packet, uint16 protocolNumber) const;
             // send the packet to the next layer
         
         virtual void Pulse();

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPManager.h

@@ -6 +6 @@
 #ifndef _K_PPP_MANAGER__H
 #define _K_PPP_MANAGER__H
 
-#include "net_module.h"
+#include <module.h>
+#include <net_device.h>
 #include <PPPControl.h>
 #include <PPPReportDefs.h>
 
-
-#define PPP_INTERFACE_MODULE_NAME        NETWORK_MODULES_ROOT "interfaces/ppp"
+#define PPP_INTERFACE_MODULE_NAME   NETWORK_MODULES_ROOT    "/ppp/KPPPManager/v1"
 
 #define PPP_UNDEFINED_INTERFACE_ID  0
     // CreateInterface() returns this value on failure
@@ -34 +34 @@
     deletes them when they are not needed anymore.
 */
 typedef struct ppp_interface_module_info {
-    kernel_net_module_info knminfo;
-        //!< Exports needed network module functions.
+        struct module_info info;
     
     ppp_interface_id (*CreateInterface)(const driver_settings *settings,
         ppp_interface_id parentID);
@@ -46 +45 @@
     bool (*RemoveInterface)(ppp_interface_id ID);
         // remove the interface from database (make sure you can delete it yourself!)
     
-    ifnet *(*RegisterInterface)(ppp_interface_id ID);
+    net_device *(*RegisterInterface)(ppp_interface_id ID);
+    KPPPInterface *(*GetInterface)(ppp_interface_id ID);
+        // for accessing KPPPInterface directly
     bool (*UnregisterInterface)(ppp_interface_id ID);
     
     status_t (*ControlInterface)(ppp_interface_id ID, uint32 op, void *data,

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPProtocol.h

@@ -105 +105 @@
         virtual bool IsAllowedToSend() const;
         
         //! Encapsulate the packet with the given protocol number.
-        virtual status_t Send(struct mbuf *packet, uint16 protocolNumber) = 0;
+        virtual status_t Send(net_buffer *packet, uint16 protocolNumber) = 0;
         //! Receive a packet with the given protocol number.
-        virtual status_t Receive(struct mbuf *packet, uint16 protocolNumber) = 0;
+        virtual status_t Receive(net_buffer *packet, uint16 protocolNumber) = 0;
 
     protected:
         //! \brief Requests Up() to be called.

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPReportManager.h

@@ -13 +13 @@
 
 #include <TemplateList.h>
 
+#include <lock.h>
+#include <util/AutoLock.h>
+
 
 class KPPPReportManager {
     public:
-        KPPPReportManager(BLocker& lock);
+        KPPPReportManager(mutex& lock);
         ~KPPPReportManager();
         
         static bool SendReport(thread_id thread, const ppp_report_packet *report);
@@ -30 +33 @@
             // returns false if reply was bad (or an error occured)
 
     private:
-        BLocker& fLock;
+        mutex& fLock;
         TemplateList<ppp_report_request*> fReportRequests;
 };
 

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/KPPPStateMachine.h

@@ -14 +14 @@
 #include <KPPPInterface.h>
 #endif
 
-#include <Locker.h>
+#include <lock.h>
+#include <util/AutoLock.h>
 
 class PPPManager;
 class KPPPInterface;
@@ -116 +117 @@
         void CloseEvent();
         void TOGoodEvent();
         void TOBadEvent();
-        void RCRGoodEvent(struct mbuf *packet);
-        void RCRBadEvent(struct mbuf *nak, struct mbuf *reject);
-        void RCAEvent(struct mbuf *packet);
-        void RCNEvent(struct mbuf *packet);
-        void RTREvent(struct mbuf *packet);
-        void RTAEvent(struct mbuf *packet);
-        void RUCEvent(struct mbuf *packet, uint16 protocolNumber,
+        void RCRGoodEvent(net_buffer *packet);
+        void RCRBadEvent(net_buffer *nak, net_buffer *reject);
+        void RCAEvent(net_buffer *packet);
+        void RCNEvent(net_buffer *packet);
+        void RTREvent(net_buffer *packet);
+        void RTAEvent(net_buffer *packet);
+        void RUCEvent(net_buffer *packet, uint16 protocolNumber,
             uint8 code = PPP_PROTOCOL_REJECT);
-        void RXJGoodEvent(struct mbuf *packet);
-        void RXJBadEvent(struct mbuf *packet);
-        void RXREvent(struct mbuf *packet);
+        void RXJGoodEvent(net_buffer *packet);
+        void RXJBadEvent(net_buffer *packet);
+        void RXREvent(net_buffer *packet);
         
         // general events (for Good/Bad events)
         void TimerEvent();
-        void RCREvent(struct mbuf *packet);
-        void RXJEvent(struct mbuf *packet);
+        void RCREvent(net_buffer *packet);
+        void RXJEvent(net_buffer *packet);
         
         // actions
         void IllegalEvent(ppp_event event);
@@ -142 +143 @@
         void InitializeRestartCount();
         void ZeroRestartCount();
         bool SendConfigureRequest();
-        bool SendConfigureAck(struct mbuf *packet);
-        bool SendConfigureNak(struct mbuf *packet);
+        bool SendConfigureAck(net_buffer *packet);
+        bool SendConfigureNak(net_buffer *packet);
         bool SendTerminateRequest();
-        bool SendTerminateAck(struct mbuf *request = NULL);
-        bool SendCodeReject(struct mbuf *packet, uint16 protocolNumber, uint8 code);
-        bool SendEchoReply(struct mbuf *request);
+        bool SendTerminateAck(net_buffer *request = NULL);
+        bool SendCodeReject(net_buffer *packet, uint16 protocolNumber, uint8 code);
+        bool SendEchoReply(net_buffer *request);
         
         void BringProtocolsUp();
         uint32 BringPhaseUp();
@@ -177 +178 @@
             // the ID we used for the last configure/terminate/echo request
         bigtime_t fNextTimeout;
         
-        BLocker fLock;
+        mutex fLock;
 };
 
 

src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/PPPDefs.h

@@ -10 +10 @@
 
 #include <directories.h>
 
-#include "net_module.h"
+// #include "net_module.h"
 
 
 typedef uint32 ppp_interface_id;
@@ -37 +37 @@
 #define PPP_SERVER_MODE_VALUE               "Server"
 
 // path defines
-#define PPP_MODULES_PATH                    NETWORK_MODULES_ROOT "ppp"
+#define NETWORK_MODULES_ROOT "network"
+#define PPP_MODULES_PATH            NETWORK_MODULES_ROOT "/ppp"
 #define PTP_INTERFACE_SETTINGS_PATH \
     kUserSettingsDirectory "/kernel/drivers/ptpnet"
         // TODO: should be: /etc/ptpnet

new file src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/asm_defs.h

@@ +1 @@
+/*
+ * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef SYSTEM_ARCH_X86_ASM_DEFS_H
+#define SYSTEM_ARCH_X86_ASM_DEFS_H
+
+
+#define SYMBOL(name)            .global name; name
+#define SYMBOL_END(name)        1: .size name, 1b - name
+#define STATIC_FUNCTION(name)   .type name, @function; name
+#define FUNCTION(name)          .global name; .type name, @function; name
+#define FUNCTION_END(name)      1: .size name, 1b - name
+
+
+#endif  /* SYSTEM_ARCH_X86_ASM_DEFS_H */
+

new file src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/directories.h

@@ +1 @@
+/*
+ * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _SYSTEM_DIRECTORIES_H
+#define _SYSTEM_DIRECTORIES_H
+
+
+#define kGlobalBinDirectory             "/bin"
+#define kGlobalEtcDirectory             "/etc"
+#define kGlobalPackageLinksDirectory    "/packages"
+#define kGlobalSystemDirectory          "/system"
+#define kGlobalTempDirectory            "/tmp"
+#define kGlobalVarDirectory             "/var"
+
+#define kAppsDirectory                  "/boot/apps"
+#define kPreferencesDirectory           "/boot/preferences"
+
+#define kAppLocalAddonsDirectory        "%A/add-ons"
+#define kAppLocalLibDirectory           "%A/lib"
+
+#define kVolumeLocalSystemKernelAddonsDirectory "system/add-ons/kernel"
+#define kVolumeLocalCommonNonpackagedKernelAddonsDirectory  \
+    "common/non-packaged/add-ons/kernel"
+#define kVolumeLocalCommonKernelAddonsDirectory "common/add-ons/kernel"
+#define kVolumeLocalUserNonpackagedKernelAddonsDirectory    \
+    "home/config/non-packaged/add-ons/kernel"
+#define kVolumeLocalUserKernelAddonsDirectory   "home/config/add-ons/kernel"
+
+#define kSystemDirectory                "/boot/system"
+#define kSystemAddonsDirectory          "/boot/system/add-ons"
+#define kSystemAppsDirectory            "/boot/system/apps"
+#define kSystemBinDirectory             "/boot/system/bin"
+#define kSystemDataDirectory            "/boot/system/data"
+#define kSystemDevelopDirectory         "/boot/develop"
+#define kSystemLibDirectory             "/boot/system/lib"
+#define kSystemPackagesDirectory        "/boot/system/packages"
+#define kSystemPackageLinksDirectory        "/boot/system/package-links"
+#define kSystemPreferencesDirectory     "/boot/system/preferences"
+#define kSystemServersDirectory         "/boot/system/servers"
+
+#define kCommonDirectory                "/boot/common"
+#define kCommonAddonsDirectory          "/boot/common/add-ons"
+#define kCommonBinDirectory             "/boot/common/bin"
+#define kCommonDevelopToolsBinDirectory "/boot/develop/tools/current/bin"
+#define kCommonEtcDirectory             "/boot/common/etc"
+#define kCommonLibDirectory             "/boot/common/lib"
+#define kCommonPackagesDirectory        "/boot/common/packages"
+#define kCommonSettingsDirectory        "/boot/common/settings"
+#define kCommonTempDirectory            "/boot/common/cache/tmp"
+#define kCommonVarDirectory             "/boot/common/var"
+#define kCommonLogDirectory             "/boot/common/var/log"
+#define kCommonNonpackagedAddonsDirectory   "/boot/common/non-packaged/add-ons"
+#define kCommonNonpackagedBinDirectory  "/boot/common/non-packaged/bin"
+#define kCommonNonpackagedLibDirectory  "/boot/common/non-packaged/lib"
+
+#define kUserDirectory                  "/boot/home"
+#define kUserConfigDirectory            "/boot/home/config"
+#define kUserAddonsDirectory            "/boot/home/config/add-ons"
+#define kUserBinDirectory               "/boot/home/config/bin"
+#define kUserLibDirectory               "/boot/home/config/lib"
+#define kUserPackagesDirectory          "/boot/home/config/packages"
+#define kUserSettingsDirectory          "/boot/home/config/settings"
+#define kUserNonpackagedAddonsDirectory "/boot/home/config/non-packaged/add-ons"
+#define kUserNonpackagedBinDirectory    "/boot/home/config/non-packaged/bin"
+#define kUserNonpackagedLibDirectory    "/boot/home/config/non-packaged/lib"
+
+
+#endif  // _SYSTEM_DIRECTORIES_H

new file src/add-ons/kernel/network/ppp/shared/libkernelppp/headers/ppp_device.h

@@ +1 @@
+#ifndef __PPP_DEV_H
+#define __PPP_DEV_H
+#include <net_device.h>
+#include <net_stack.h>
+#include <KPPPInterface.h>
+
+#include <lock.h>
+#include <util/AutoLock.h>
+#include <util/DoublyLinkedList.h>
+
+struct ppp_device : net_device, DoublyLinkedListLinkImpl<ppp_device> {
+    KPPPInterface *         KPPP_Interface;
+    uint32                  frame_size;
+    net_fifo                ppp_fifo;
+};
+
+#endif

src/add-ons/kernel/network/ppp/shared/libkernelppp/settings_tools.cpp

@@ -366 +366 @@
         return NULL;
     
     for (int32 index = 0; index < settings->parameter_count; index++)
+    {
+        // dprintf("parameter name: %s \n",settings->parameters[index].name);
         if (!strcasecmp(settings->parameters[index].name, name))
             return &settings->parameters[index];
+    }
     
     return NULL;
 }
@@ -378 +381 @@
 {
     const driver_parameter *parameter = get_parameter_with_name(name, settings);
     
-    if (parameter && parameter->value_count > 0 && parameter->values)
+    if (parameter && parameter->value_count > 0 && parameter->values){
+        // dprintf("name: %s value: %s \n", name, parameter->values[0]);
         return parameter->values[0];
+    }
     
     return NULL;
 }

src/add-ons/kernel/network/ppp/shared/libppp/Jamfile

@@ -10 +10 @@
         # Unfortunately we get more than we want, namely all POSIX headers.
 }
 
+UsePrivateKernelHeaders ;
 UsePrivateHeaders net ;
 UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared libppp
     headers ] : true ;
@@ -19 +20 @@
 
 StaticLibrary libppp.a :
     strlcat.c
-    driver_settings.c
+    driver_settings.cpp
     settings_tools.cpp
     KPPPUtils.cpp
     
@@ -31 +32 @@
 ;
 
 SEARCH on [ FGristFiles strlcat.c ] = [ FDirName $(HAIKU_TOP) src system libroot posix string ] ;
-SEARCH on [ FGristFiles driver_settings.c ] = [ FDirName $(HAIKU_TOP) src system libroot os ] ;
+SEARCH on [ FGristFiles driver_settings.cpp ] = [ FDirName $(HAIKU_TOP) src system libroot os ] ;
 SEARCH on [ FGristFiles settings_tools.cpp ] = [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared libkernelppp ] ;
 SEARCH on [ FGristFiles KPPPUtils.cpp ] = [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared libkernelppp ] ;

src/add-ons/kernel/network/ppp/shared/libppp/_libppputils.cpp

@@ -9 +9 @@
 #include <cstring>
 
 
-char*
+const char*
 get_stack_driver_path()
 {
     char *path;

src/add-ons/kernel/network/ppp/shared/libppp/_libppputils.h

@@ -6 +6 @@
 #ifndef __libppputils__h
 #define __libppputils__h
 
-#include <net_stack_driver.h>
+#include "net_stack_driver.h"
+// #define NET_STACK_DRIVER_PATH "/boot/common/system/add-ons/kernel/network"
 
-
-char *get_stack_driver_path();
+const char *get_stack_driver_path();
 
 
 #endif

src/add-ons/kernel/network/ppp/shared/libppp/headers/PPPManager.h

@@ -8 +8 @@
 
 #include <KPPPManager.h>
 #include <String.h>
+#include <Directory.h>
 
 
 class PPPManager {

new file src/add-ons/kernel/network/ppp/shared/libppp/net_stack_driver.h

@@ +1 @@
+/* net_stack_driver.h
+ * structures and defines to deal with the network stack pseudo-driver...
+ */
+
+#ifndef NET_STACK_DRIVER_H
+#define NET_STACK_DRIVER_H
+
+#include <OS.h>         
+#include <sys/select.h>
+
+// Forward declaration
+struct sockaddr; 
+
+#define NET_STACK_DRIVER_DEV    "net/stack"
+#define NET_STACK_DRIVER_PATH   "/dev/net/stack" // ## NET_STACK_DRIVER_DEV
+
+enum {
+    // Paranoia mode: be far away of B_DEVICE_OP_CODES_END opcodes!!!
+    // You never know what another device driver ioctl() will do
+    // if think our NET_STACK_* is in fact his DO_RISKY_BUSINESS opcode, or whatever...
+    NET_IOCTL_BASE = 0xbe230000,            
+    NET_STACK_IOCTL_BASE = NET_IOCTL_BASE + 0x200
+};
+
+enum {
+    NET_STACK_SOCKET = NET_STACK_IOCTL_BASE,    // socket_args *
+    NET_STACK_BIND,                             // sockaddr_args *
+    NET_STACK_RECVFROM,                         // struct msghdr *
+    NET_STACK_RECV,                             // transfer_args *
+    NET_STACK_SENDTO,                           // struct msghdr *
+    NET_STACK_SEND,                             // transfer_args *
+    NET_STACK_LISTEN,                           // int_args * (value = backlog)
+    NET_STACK_ACCEPT,                           // sockaddr_args *
+    NET_STACK_CONNECT,                          // sockaddr_args *
+    NET_STACK_SHUTDOWN,                         // int_args * (value = how)
+    NET_STACK_GETSOCKOPT,                       // sockopt_args *
+    NET_STACK_SETSOCKOPT,                       // sockopt_args *
+    NET_STACK_GETSOCKNAME,                      // sockaddr_args *
+    NET_STACK_GETPEERNAME,                      // sockaddr_args *
+
+    NET_STACK_SYSCTL,                           // sysctl_args *
+    NET_STACK_SELECT,                           // select_args *
+    NET_STACK_DESELECT,                         // select_args *
+
+    NET_STACK_GET_COOKIE,                       // void ** 
+
+    NET_STACK_STOP,
+    
+    NET_STACK_NOTIFY_SOCKET_EVENT,              // notify_socket_event_args * (userland stack only)
+    
+    NET_STACK_CONTROL_NET_MODULE,
+    
+    NET_STACK_IOCTL_MAX
+};
+
+struct sockaddr_args {  // used by NET_STACK_CONNECT/_BIND/_GETSOCKNAME/_GETPEERNAME
+    struct sockaddr *addr;
+    int addrlen;
+};
+
+struct sockopt_args {   // used by NET_STACK_SETSOCKOPT/_GETSOCKOPT
+    int     level;
+    int     option;
+    void  *optval;
+    int     optlen;
+};
+
+struct transfer_args {  // used by NET_STACK_SEND/_RECV
+    void *data;
+    size_t datalen;
+    int flags;
+    struct sockaddr *addr;  // unused in *_SEND and *_RECV cases
+    int addrlen;            // unused in *_SEND and *_RECV cases
+};
+
+struct socket_args {    // used by NET_STACK_SOCKET
+    int family;
+    int type;
+    int proto;
+};
+
+struct accept_args {  // used by NET_STACK_ACCEPT 
+    void *cookie; 
+    struct sockaddr *addr; 
+    int addrlen; 
+};
+
+struct sysctl_args {    // used by NET_STACK_SYSCTL
+    int *name;
+    uint namelen;
+    void *oldp;
+    size_t *oldlenp;
+    void *newp;
+    size_t newlen;
+};
+
+struct control_net_module_args {    // used by NET_STACK_CONTROL_NET_MODULE
+    const char *name;
+    uint32 op;
+    void *data;
+    size_t length;
+};
+
+/*
+    Userland stack driver on_socket_event() callback mecanism implementation:
+    the driver start a kernel thread waiting on a port for
+    a NET_STACK_SOCKET_EVENT_MSG message, which come with a socket_event_data block.
+
+    The on_socket_event() mechanism stay in driver (kernelland) because it's
+    only there we can call kernel's notify_select_event() on BONE systems.
+    For non-BONE systems, we use our own r5_notify_select_event()
+    implementation, that could be moved into the userland net_server code,
+    but it'll have split (again!) the /dev/net/stack driver code...
+*/  
+   
+struct notify_socket_event_args {   // used by NET_STACK_NOTIFY_SOCKET_EVENT
+    port_id notify_port;    // port waiting for notification, -1 = stop notify
+    void * cookie;          // this cookie value will be pass back in the socket_event_args
+};
+
+#define NET_STACK_SOCKET_EVENT_NOTIFICATION 'sevn'
+
+struct socket_event_data {
+    uint32 event;   // B_SELECT_READ, B_SELECT_WRITE or B_SELECT_ERROR
+    void * cookie;  // The cookie as set in notify_socket_event_args for this socket
+};
+
+/*
+    R5.0.3 and before select() kernel support is too buggy to be used, so
+    here are the structures we used to support select() on sockets, and *only* on
+    sockets!
+*/
+
+struct select_args {    // used by NET_STACK_SELECT and NET_STACK_DESELECT
+    struct selectsync * sync;   // in fact, it's the area_id of a r5_selectsync struct!!!
+    uint32 ref;
+};
+
+struct r5_selectsync {
+    sem_id lock;    // lock this r5_selectsync
+    sem_id wakeup;  // sem to release to wakeup select()
+    struct fd_set rbits;    // read event bits field
+    struct fd_set wbits;    // write event bits field
+    struct fd_set ebits;    // exception event bits field
+};
+
+
+struct stack_driver_args {
+    union {
+        int                             integer;
+        struct socket_args              socket;
+        struct accept_args              accept;
+        struct sockaddr_args            sockaddr;
+        struct sockopt_args             sockopt;
+        struct transfer_args            transfer;
+        struct sysctl_args              sysctl;
+        struct select_args              select;
+        struct control_net_module_args  control;
+    } u;
+};
+
+#endif /* NET_STACK_DRIVER_H */

src/add-ons/kernel/network/stack/datalink.cpp

@@ -193 +193 @@
 
 //  #pragma mark - datalink module
 
+static status_t
+datalink_set_interface_address(net_domain* _domain, struct ifaliasreq request)
+{
+
+    net_domain_private* domain = (net_domain_private*)_domain;
+
+    Interface* interface = get_interface(domain, request.ifra_name);
+    if (interface != NULL) {
+        // A new alias is added to this interface
+        status_t status = interface->ChangeAddress(domain, request);
+        notify_interface_changed(interface);
+        interface->ReleaseReference();
+
+        return status;
+    }
+
+    return B_ERROR;
+}
 
 static status_t
 datalink_control(net_domain* _domain, int32 option, void* value,
@@ -528 +546 @@
 
 
 static net_interface*
+datalink_get_interface_by_name(net_domain* domain, const char* ifname)
+{
+    return get_interface(domain, ifname);
+}
+
+
+static net_interface*
 datalink_get_interface_with_address(const sockaddr* address)
 {
     InterfaceAddress* interfaceAddress = get_interface_address(address);
@@ -560 +585 @@
 }
 
 
+static net_interface_address*
+datalink_get_interface_address_by_name(const char* name, net_domain* domain)
+{
+    if (name==NULL || domain==NULL)
+        return NULL;
+
+    Interface* interface = get_interface(domain, name);
+    if (interface==NULL)
+        return NULL;
+
+    return interface->FirstForFamily(domain->family);
+}
+
 /*! Returns a reference to the next address of the given interface in
     \a _address. When you call this function the first time, \a _address must
     point to a NULL address. Upon the next call, the reference to the previous
@@ -1008 +1046 @@
     datalink_is_local_link_address,
 
     datalink_get_interface,
+    datalink_get_interface_by_name,
     datalink_get_interface_with_address,
     datalink_put_interface,
 
     datalink_get_interface_address,
+    datalink_get_interface_address_by_name,
+    datalink_set_interface_address,
     datalink_get_next_interface_address,
     datalink_put_interface_address,
 
@@ -1030 +1071 @@
 
 net_datalink_protocol_module_info gDatalinkInterfaceProtocolModule = {
     {
-        NULL,
+        NET_DATA_LINK_INTERFACE_MODULE_NAME,
         0,
         NULL
     },

src/add-ons/kernel/network/stack/device_interfaces.cpp

@@ -129 +129 @@
             }
         }
 
-        if (buffer != NULL)
+        if (buffer != NULL){
+            // should free the unused buffer
+            dprintf("%s::%s: severe fault!!!!\n",__FILE__,__func__);
             gNetBufferModule.free(buffer);
+        }
     }
 
     return B_OK;
@@ -556 +559 @@
         status_t status;
         wait_for_thread(readerThread, &status);
     }
+
+
 }
 
 

src/add-ons/kernel/network/stack/interfaces.cpp

@@ -729 +729 @@
 }
 
 
+status_t
+Interface::ChangeAddress(net_domain* domain, ifaliasreq& aliasRequest)
+{
+    RecursiveLocker locker(fLock);
+
+    InterfaceAddress* address = NULL;
+    if (aliasRequest.ifra_index < 0) {
+        if (!domain->address_module->is_empty_address(
+                (const sockaddr*)&aliasRequest.ifra_addr, false)) {
+            // Find first address that matches the local address
+            address = AddressForLocal(domain,
+                (const sockaddr*)&aliasRequest.ifra_addr);
+        }
+        if (address == NULL) {
+            // Find first address for family
+            address = FirstForFamily(domain->family);
+        }
+        if (address == NULL) {
+            // Create new on the fly
+            address = new(std::nothrow) InterfaceAddress(this, domain);
+            if (address == NULL)
+                return B_NO_MEMORY;
+
+            status_t status = AddAddress(address);
+            if (status != B_OK) {
+                delete address;
+                return status;
+            }
+
+            // Note, even if setting the address failed, the empty
+            // address added here will still be added to the interface.
+            address->AcquireReference();
+        }
+    } else
+        address = AddressAt(aliasRequest.ifra_index);
+
+    if (address == NULL)
+        return B_BAD_VALUE;
+
+    status_t status = B_OK;
+
+    if (!domain->address_module->equal_addresses(
+            (sockaddr*)&aliasRequest.ifra_addr, address->local)) {
+        status = _ChangeAddress(locker, address, SIOCSIFADDR,
+            address->local, (sockaddr*)&aliasRequest.ifra_addr);
+    }
+
+    if (status == B_OK && !domain->address_module->equal_addresses(
+            (sockaddr*)&aliasRequest.ifra_mask, address->mask)
+        && !domain->address_module->is_empty_address(
+            (sockaddr*)&aliasRequest.ifra_mask, false)) {
+        status = _ChangeAddress(locker, address, SIOCSIFNETMASK,
+            address->mask, (sockaddr*)&aliasRequest.ifra_mask);
+    }
+
+    if (status == B_OK && !domain->address_module->equal_addresses(
+            (sockaddr*)&aliasRequest.ifra_destination,
+            address->destination)
+        && !domain->address_module->is_empty_address(
+            (sockaddr*)&aliasRequest.ifra_destination, false)) {
+        status = _ChangeAddress(locker, address,
+            (domain->address_module->flags
+                & NET_ADDRESS_MODULE_FLAG_BROADCAST_ADDRESS) != 0
+                    ? SIOCSIFBRDADDR : SIOCSIFDSTADDR,
+            address->destination,
+            (sockaddr*)&aliasRequest.ifra_destination);
+    }
+
+    address->ReleaseReference();
+    return status;
+}
+
+
 /*! This is called in order to call the correct methods of the datalink
     protocols, ie. it will translate address changes to
     net_datalink_protocol::change_address(), and IFF_UP changes to
@@ -823 +896 @@
 
             status_t status = B_OK;
 
+            dprintf("%s:%s: begin change address\n", __FILE__, __func__);
+
             if (!domain->address_module->equal_addresses(
                     (sockaddr*)&aliasRequest.ifra_addr, address->local)) {
                 status = _ChangeAddress(locker, address, SIOCSIFADDR,

src/add-ons/kernel/network/stack/interfaces.h

@@ -139 +139 @@
                                     ifreq& request, ifreq* userRequest,
                                     size_t length);
 
+            status_t            ChangeAddress(net_domain* domain,
+                                ifaliasreq& aliasRequest);
             void                SetDown();
             void                WentDown();
 

src/add-ons/kernel/network/stack/stack.cpp

@@ -836 +836 @@
     // TODO: for now!
     register_domain_datalink_protocols(AF_INET, IFT_LOOP,
         "network/datalink_protocols/loopback_frame/v1", NULL);
+    // add ppp datalink protocol
+    register_domain_datalink_protocols(AF_INET, IFT_PPP,
+        "network/datalink_protocols/ppp_frame/v1", NULL);
     register_domain_datalink_protocols(AF_INET6, IFT_LOOP,
         "network/datalink_protocols/loopback_frame/v1", NULL);
     register_domain_datalink_protocols(AF_INET, IFT_ETHER,
@@ -992 +995 @@
     (module_info*)&gNetDatalinkModule,
     (module_info*)&gLinkModule,
     (module_info*)&gNetStackInterfaceModule,
+    (module_info*)&gDatalinkInterfaceProtocolModule,
     NULL
 };

src/bin/network/Jamfile

@@ -12 +12 @@
 SubInclude HAIKU_TOP src bin network mount_nfs ;
 SubInclude HAIKU_TOP src bin network netcat ;
 SubInclude HAIKU_TOP src bin network netstat ;
-#SubInclude HAIKU_TOP src bin network pppconfig ;
-#SubInclude HAIKU_TOP src bin network ppp_up ;
+SubInclude HAIKU_TOP src bin network pppconfig ;
+SubInclude HAIKU_TOP src bin network ppp_up ;
 SubInclude HAIKU_TOP src bin network ping ;
 SubInclude HAIKU_TOP src bin network ping6 ;
 SubInclude HAIKU_TOP src bin network route ;

src/bin/network/ifconfig/ifconfig.cpp

@@ -739 +739 @@
 
         status_t status = roster.AddInterface(interface);
         if (status != B_OK) {
-            fprintf(stderr, "%s: Could not add interface: %s\n", kProgramName,
-                strerror(status));
+            fprintf(stderr, "%s: Could not add interface: %s;error code:[%d]\n", kProgramName,
+                strerror(status),status);
             exit(1);
         }
     }

src/bin/network/ppp_up/Jamfile

@@ -1 @@
-SubDir HAIKU_TOP src bin ppp_up ;
+SubDir HAIKU_TOP src bin network ppp_up ;
 
 SetSubDirSupportedPlatforms $(HAIKU_BONE_COMPATIBLE_PLATFORMS) ;
 
@@ -8 +8 @@
         # Unfortunately we get more than we want, namely all POSIX headers.
 }
 
-UsePrivateHeaders net ;
+UsePrivateHeaders net app libroot shared interface libbe be root tracker textencoding
+            root ;
+
 UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared libppp
     headers ] : true ;
 UseHeaders [ FDirName $(HAIKU_TOP) src add-ons kernel network ppp shared
@@ -24 +26 @@
     PPPStatusWindow.cpp
     PPPUpApplication.cpp
     :
-    libppp.a be
+    libppp.a be $(TARGET_LIBSUPC++) translation $(HAIKU_LOCALE_LIBS) root
 ;
 
 # Installation

src/bin/network/ppp_up/PPPStatusView.h

@@ -6 +6 @@
 #ifndef STATUS_VIEW__H
 #define STATUS_VIEW__H
 
-#include <View.h>
+// #include <View.h>
+#include <StringView.h>
 #include <PPPInterface.h>
+#include <Button.h>
 
 
 class PPPStatusView : public BView {

src/bin/network/pppconfig/Jamfile

@@ -1 @@
-SubDir HAIKU_TOP src bin pppconfig ;
+SubDir HAIKU_TOP src bin network pppconfig ;
 
 SetSubDirSupportedPlatforms $(HAIKU_BONE_COMPATIBLE_PLATFORMS) ;
 
@@ -17 +17 @@
 BinCommand pppconfig :
     pppconfig.cpp
     :
-    be libppp.a
+    be libppp.a $(TARGET_LIBSUPC++)
 ;
 
 # Installation -- in the test directory for the time being