From 0d80a4595ffcff95b936907ca82d4870ff7f03c9 Mon Sep 17 00:00:00 2001 From: Waldemar Kornewald Date: Mon, 1 Sep 2003 16:29:24 +0000 Subject: [PATCH] Added libkernelppp.a to the build (although it does not build yet, I need help to fix the problem). Fixed all warnings and errors (except from the one mentioned above). git-svn-id: file:///srv/svn/repos/haiku/trunk/current@4437 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/tests/kits/net/ppp/Jamfile | 3 + .../net/ppp/headers/KPPPConfigurePacket.h | 4 +- src/tests/kits/net/ppp/headers/KPPPDefs.h | 6 - src/tests/kits/net/ppp/headers/KPPPDevice.h | 22 +- .../kits/net/ppp/headers/KPPPEncapsulator.h | 33 ++- .../kits/net/ppp/headers/KPPPInterface.h | 61 +++-- src/tests/kits/net/ppp/headers/KPPPLCP.h | 31 ++- src/tests/kits/net/ppp/headers/KPPPManager.h | 7 +- .../kits/net/ppp/headers/KPPPOptionHandler.h | 17 +- src/tests/kits/net/ppp/headers/KPPPProtocol.h | 24 +- .../kits/net/ppp/headers/KPPPReportDefs.h | 5 +- .../kits/net/ppp/headers/KPPPReportManager.h | 12 +- .../kits/net/ppp/headers/KPPPStateMachine.h | 59 +++-- src/tests/kits/net/ppp/headers/LockerHelper.h | 2 +- src/tests/kits/net/ppp/src/Jamfile | 23 ++ .../kits/net/ppp/src/KPPPConfigurePacket.cpp | 17 +- src/tests/kits/net/ppp/src/KPPPDevice.cpp | 21 +- .../kits/net/ppp/src/KPPPEncapsulator.cpp | 13 +- src/tests/kits/net/ppp/src/KPPPInterface.cpp | 118 ++++++---- src/tests/kits/net/ppp/src/KPPPLCP.cpp | 29 ++- .../kits/net/ppp/src/KPPPOptionHandler.cpp | 2 +- src/tests/kits/net/ppp/src/KPPPProtocol.cpp | 6 +- .../kits/net/ppp/src/KPPPReportManager.cpp | 58 +++-- .../kits/net/ppp/src/KPPPStateMachine.cpp | 213 +++++++++++------- src/tests/kits/net/ppp/src/KPPPUtils.cpp | 12 +- src/tests/kits/net/ppp/src/settings_tools.cpp | 47 ++-- src/tests/kits/net/ppp/src/settings_tools.h | 11 +- 27 files changed, 521 insertions(+), 335 deletions(-) create mode 100644 src/tests/kits/net/ppp/Jamfile create mode 100644 src/tests/kits/net/ppp/src/Jamfile diff --git a/src/tests/kits/net/ppp/Jamfile b/src/tests/kits/net/ppp/Jamfile new file mode 100644 index 0000000000..ddbcc0730f --- /dev/null +++ b/src/tests/kits/net/ppp/Jamfile @@ -0,0 +1,3 @@ +SubDir OBOS_TOP src tests kits net ppp ; + +SubInclude OBOS_TOP src tests kits net ppp src ; \ No newline at end of file diff --git a/src/tests/kits/net/ppp/headers/KPPPConfigurePacket.h b/src/tests/kits/net/ppp/headers/KPPPConfigurePacket.h index 1e9c8a3600..212330baba 100644 --- a/src/tests/kits/net/ppp/headers/KPPPConfigurePacket.h +++ b/src/tests/kits/net/ppp/headers/KPPPConfigurePacket.h @@ -28,7 +28,7 @@ class PPPConfigurePacket { public: PPPConfigurePacket(uint8 code); - PPPConfigurePacket(mbuf *packet); + PPPConfigurePacket(struct mbuf *packet); ~PPPConfigurePacket(); bool SetCode(uint8 code); @@ -46,7 +46,7 @@ class PPPConfigurePacket { { return fItems.CountItems(); } ppp_configure_item *ItemAt(int32 index) const; - mbuf *ToMbuf(uint32 reserve = 0); + struct mbuf *ToMbuf(uint32 reserve = 0); // the user is responsible for freeing the mbuf private: diff --git a/src/tests/kits/net/ppp/headers/KPPPDefs.h b/src/tests/kits/net/ppp/headers/KPPPDefs.h index 8530301d1e..15e10bb997 100644 --- a/src/tests/kits/net/ppp/headers/KPPPDefs.h +++ b/src/tests/kits/net/ppp/headers/KPPPDefs.h @@ -118,12 +118,6 @@ enum PPP_MODE { PPP_SERVER_MODE }; -// report types -enum PPP_REPORT { - PPP_CONNECTION_REPORT = 0x01, - PPP_ERROR_REPORT = 0x02, -}; - // authentication status enum PPP_AUTHENTICATION_STATUS { PPP_AUTHENTICATION_FAILED = -1, diff --git a/src/tests/kits/net/ppp/headers/KPPPDevice.h b/src/tests/kits/net/ppp/headers/KPPPDevice.h index 682c5e525d..181950fa0d 100644 --- a/src/tests/kits/net/ppp/headers/KPPPDevice.h +++ b/src/tests/kits/net/ppp/headers/KPPPDevice.h @@ -8,7 +8,13 @@ #ifndef _K_PPP_DEVICE__H #define _K_PPP_DEVICE__H -#include "KPPPInterface.h" +#include + +#include + +#ifndef _K_PPP_INTERFACE__H +#include +#endif class PPPDevice { @@ -27,12 +33,12 @@ class PPPDevice { PPPInterface *Interface() const { return fInterface; } - driver_parameter *Settings() + driver_parameter *Settings() const { return fSettings; } virtual status_t Control(uint32 op, void *data, size_t length); - virtual bool SetMTU(uint32 mtu) = 0; + virtual bool SetMTU(uint32 MTU); uint32 MTU() const { return fMTU; } virtual uint32 PreferredMTU() const = 0; @@ -52,10 +58,10 @@ class PPPDevice { virtual uint32 CountOutputBytes() const = 0; // how many bytes are waiting to be sent? - virtual status_t Send(mbuf *packet) = 0; + virtual status_t Send(struct mbuf *packet) = 0; // This should enqueue the packet and return immediately. // The device is responsible for freeing the packet. - status_t PassToInterface(mbuf *packet); + status_t PassToInterface(struct mbuf *packet); // This will pass the packet to the interface's queue. // Do not call Interface::ReceiveFromDevice directly // if this can block a Send()! @@ -70,9 +76,9 @@ class PPPDevice { bool DownStarted() const; // report up/down events - void UpFailedEvent() const; - void UpEvent() const; - void DownEvent() const; + void UpFailedEvent(); + void UpEvent(); + void DownEvent(); protected: bool fIsUp; diff --git a/src/tests/kits/net/ppp/headers/KPPPEncapsulator.h b/src/tests/kits/net/ppp/headers/KPPPEncapsulator.h index c22b91dadc..d145facd96 100644 --- a/src/tests/kits/net/ppp/headers/KPPPEncapsulator.h +++ b/src/tests/kits/net/ppp/headers/KPPPEncapsulator.h @@ -8,13 +8,22 @@ #ifndef _K_PPP_ENCAPSULATOR__H #define _K_PPP_ENCAPSULATOR__H -#include "KPPPInterface.h" +#include + +#include + +class PPPInterface; + +#ifndef _K_PPP_INTERFACE__H +#include +#endif class PPPEncapsulator { public: - PPPEncapsulator(const char *name, PPP_ENCAPSULATION_LEVEL level, - uint16 protocol, int32 addressFamily, uint32 overhead, + PPPEncapsulator(const char *name, PPP_PHASE phase, + PPP_ENCAPSULATION_LEVEL level, uint16 protocol, + int32 addressFamily, uint32 overhead, PPPInterface *interface, driver_parameter *settings, int32 flags = PPP_NO_FLAGS); virtual ~PPPEncapsulator(); @@ -24,6 +33,9 @@ class PPPEncapsulator { const char *Name() const { return fName; } + PPP_PHASE Phase() const + { return fPhase; } + PPP_ENCAPSULATION_LEVEL Level() const { return fLevel; } uint32 Overhead() const @@ -31,7 +43,7 @@ class PPPEncapsulator { PPPInterface *Interface() const { return fInterface; } - driver_parameter *Settings() + driver_parameter *Settings() const { return fSettings; } uint16 Protocol() const @@ -62,17 +74,17 @@ class PPPEncapsulator { virtual bool Down() = 0; bool IsUp() const { return fConnectionStatus == PPP_ESTABLISHED_PHASE; } - bool IsDown const - { return fConectionStatus == PPP_DOWN_PHASE; } + bool IsDown() const + { return fConnectionStatus == PPP_DOWN_PHASE; } bool IsGoingUp() const { return fConnectionStatus == PPP_ESTABLISHMENT_PHASE; } bool IsGoingDown() const { return fConnectionStatus == PPP_TERMINATION_PHASE; } - virtual status_t Send(mbuf *packet, uint16 protocol) = 0; - virtual status_t Receive(mbuf *packet, uint16 protocol) = 0; + virtual status_t Send(struct mbuf *packet, uint16 protocol) = 0; + virtual status_t Receive(struct mbuf *packet, uint16 protocol) = 0; - status_t SendToNext(mbuf *packet, uint16 protocol) const; + status_t SendToNext(struct mbuf *packet, uint16 protocol) const; // this will send your packet to the next (up) encapsulator // if there is no next encapsulator (==NULL), it will // call the interface's SendToDevice function @@ -93,6 +105,7 @@ class PPPEncapsulator { private: char *fName; + PPP_PHASE fPhase; PPP_ENCAPSULATION_LEVEL fLevel; uint16 fProtocol; int32 fAddressFamily; @@ -105,7 +118,7 @@ class PPPEncapsulator { bool fEnabled; bool fUpRequested; PPP_PHASE fConnectionStatus; -}: +}; #endif diff --git a/src/tests/kits/net/ppp/headers/KPPPInterface.h b/src/tests/kits/net/ppp/headers/KPPPInterface.h index c000507a07..9c6aebeb56 100644 --- a/src/tests/kits/net/ppp/headers/KPPPInterface.h +++ b/src/tests/kits/net/ppp/headers/KPPPInterface.h @@ -10,20 +10,29 @@ #include -#include "KPPPDefs.h" +#include -#include "KPPPStateMachine.h" -#include "KPPPLCP.h" -#include "KPPPReportManager.h" +#ifndef _K_PPP_LCP__H +#include +#endif -#include "List.h" -#include "LockerHelper.h" +#include + +#ifndef _K_PPP_STATE_MACHINE__H +#include +#endif + +#include +#include class PPPDevice; class PPPProtocol; class PPPEncapsulator; class PPPOptionHandler; +struct ppp_manager_info; +struct ppp_module_info; + class PPPInterface { friend class PPPStateMachine; @@ -45,12 +54,12 @@ class PPPInterface { interface_id ID() const { return fID; } - driver_settings* Settings() + driver_settings* Settings() const { return fSettings; } - PPPStateMachine& StateMachine() const + PPPStateMachine& StateMachine() { return fStateMachine; } - PPPLCP& LCP() const + PPPLCP& LCP() { return fLCP; } struct ifnet *Ifnet() const @@ -75,6 +84,8 @@ class PPPInterface { status_t Control(uint32 op, void *data, size_t length); bool SetDevice(PPPDevice *device); + PPPDevice *Device() const + { return fDevice; } bool AddProtocol(PPPProtocol *protocol); bool RemoveProtocol(PPPProtocol *protocol); @@ -82,7 +93,7 @@ class PPPInterface { { return fProtocols.CountItems(); } PPPProtocol *ProtocolAt(int32 index) const; PPPProtocol *ProtocolFor(uint16 protocol, int32 start = 0) const; - int32 IndexOfProtocol(const PPPProtocol *protocol) const + int32 IndexOfProtocol(PPPProtocol *protocol) const { return fProtocols.IndexOf(protocol); } bool AddEncapsulator(PPPEncapsulator *encapsulator); @@ -90,13 +101,14 @@ class PPPInterface { PPPEncapsulator *FirstEncapsulator() const { return fFirstEncapsulator; } PPPEncapsulator *EncapsulatorFor(uint16 protocol, - PPPEncapsulator start = NULL) const; + PPPEncapsulator *start = NULL) const; // multilink methods - void AddChild(PPPInterface *child); - void RemoveChild(PPPInterface *child); + bool AddChild(PPPInterface *child); + bool RemoveChild(PPPInterface *child); int32 CountChildren() const { return fChildren.CountItems(); } + PPPInterface *ChildAt(int32 index) const; PPPInterface *Parent() const { return fParent; } bool IsMultilink() const @@ -114,30 +126,31 @@ class PPPInterface { { return fMode; } // client or server mode? PPP_STATE State() const - { return StateMachine().State(); } + { return fStateMachine.State(); } PPP_PHASE Phase() const - { return StateMachine().Phase(); } + { return fStateMachine.Phase(); } bool Up(); // in server mode Up() listens for an incoming connection bool Down(); bool IsUp() const; - PPPReportManager& ReportManager() const + PPPReportManager& ReportManager() { return fReportManager; } bool Report(PPP_REPORT_TYPE type, int32 code, void *data, int32 length) - { fReportManager.Report(type, code, data, length); } + { return fReportManager.Report(type, code, data, length); } // returns false if reply was bad (or an error occured) - bool LoadModules(const driver_settings *settings, + bool LoadModules(driver_settings *settings, int32 start, int32 count); - bool LoadModule(const char *name, const driver_parameter *parameter); + bool LoadModule(const char *name, driver_parameter *parameter, + int32 type); - status_t Send(mbuf *packet, uint16 protocol); - status_t Receive(mbuf *packet, uint16 protocol); + status_t Send(struct mbuf *packet, uint16 protocol); + status_t Receive(struct mbuf *packet, uint16 protocol); - status_t SendToDevice(mbuf *packet, uint16 protocol); - status_t ReceiveFromDevice(mbuf *packet); + status_t SendToDevice(struct mbuf *packet, uint16 protocol); + status_t ReceiveFromDevice(struct mbuf *packet); // This is called by the receive-thread. // Only call this if it does not block Send() or // SendToDevice()! @@ -193,7 +206,7 @@ class PPPInterface { PPPDevice *fDevice; PPPEncapsulator *fFirstEncapsulator; List fProtocols; - List fModules; + List fModules; BLocker& fLock; diff --git a/src/tests/kits/net/ppp/headers/KPPPLCP.h b/src/tests/kits/net/ppp/headers/KPPPLCP.h index 3425d93f15..a426ee856a 100644 --- a/src/tests/kits/net/ppp/headers/KPPPLCP.h +++ b/src/tests/kits/net/ppp/headers/KPPPLCP.h @@ -8,15 +8,30 @@ #ifndef _K_PPP_LCP__H #define _K_PPP_LCP__H -#include "KPPPProtocol.h" +#include + +#ifndef _K_PPP_PROTOCOL__H +#include +#endif + +#ifndef _K_PPP_INTERFACE__H +#include +#endif + +#ifndef _K_PPP_STATE_MACHINE__H +#include +#endif + +class PPPEncapsulator; +class PPPOptionHandler; -typedef struct lcp_packet { +typedef struct ppp_lcp_packet { uint8 code; uint8 id; uint16 length; int8 data[0]; -} lcp_packet; +} ppp_lcp_packet; class PPPLCP : public PPPProtocol { @@ -25,7 +40,7 @@ class PPPLCP : public PPPProtocol { private: // may only be constructed/destructed by PPPInterface PPPLCP(PPPInterface& interface); - ~PPPLCP(); + virtual ~PPPLCP(); // copies are not allowed! PPPLCP(const PPPLCP& copy); @@ -33,7 +48,7 @@ class PPPLCP : public PPPProtocol { public: PPPStateMachine& StateMachine() const - { return Interface()->StateMachine(); } + { return fStateMachine; } bool AddOptionHandler(PPPOptionHandler *handler); bool RemoveOptionHandler(PPPOptionHandler *handler); @@ -54,12 +69,14 @@ class PPPLCP : public PPPProtocol { virtual bool Up(); virtual bool Down(); - virtual status_t Send(mbuf *packet); - virtual status_t Receive(mbuf *packet, uint16 protocol); + virtual status_t Send(struct mbuf *packet); + virtual status_t Receive(struct mbuf *packet, uint16 protocol); virtual void Pulse(); private: + PPPStateMachine& fStateMachine; + List fOptionHandlers; PPPEncapsulator *fTarget; diff --git a/src/tests/kits/net/ppp/headers/KPPPManager.h b/src/tests/kits/net/ppp/headers/KPPPManager.h index b9fde301b1..fa3d361134 100644 --- a/src/tests/kits/net/ppp/headers/KPPPManager.h +++ b/src/tests/kits/net/ppp/headers/KPPPManager.h @@ -8,7 +8,7 @@ #ifndef _K_PPP_MANAGER__H #define _K_PPP_MANAGER__H -#include +#include "net_module.h" #define PPP_MANAGER_MODULE_NAME "network/interfaces/ppp" @@ -23,8 +23,9 @@ enum PPP_INTERFACE_FILTER { typedef struct ppp_manager_info { kernel_net_module_info knminfo; - uint32 (*create_interface)(driver_settings *settings, interface_id parent); - // you should always create interfaces using this function + interface_id (*create_interface)(const driver_settings *settings, + interface_id parent); + // you should always create interfaces using this function void (*delete_interface)(interface_id ID); // this marks the interface for deletion diff --git a/src/tests/kits/net/ppp/headers/KPPPOptionHandler.h b/src/tests/kits/net/ppp/headers/KPPPOptionHandler.h index b91b70b296..be5b73f176 100644 --- a/src/tests/kits/net/ppp/headers/KPPPOptionHandler.h +++ b/src/tests/kits/net/ppp/headers/KPPPOptionHandler.h @@ -8,8 +8,15 @@ #ifndef _K_PPP_OPTION_HANDLER__H #define _K_PPP_OPTION_HANDLER__H -#include "KPPPConfigurePacket.h" -#include "KPPPInterface.h" +#include + +#include + +#ifndef _K_PPP_INTERFACE__H +#include +#endif + +class PPPConfigurePacket; class PPPOptionHandler { @@ -29,7 +36,7 @@ class PPPOptionHandler { PPPInterface *Interface() const { return fInterface; } - driver_parameter *Settings() + driver_parameter *Settings() const { return fSettings; } virtual void Reset() = 0; @@ -53,9 +60,9 @@ class PPPOptionHandler { // notification that we ack these values private: - const char *fName; + char *fName; PPPInterface *fInterface; - driver_parameters *fSettings; + driver_parameter *fSettings; bool fEnabled; }; diff --git a/src/tests/kits/net/ppp/headers/KPPPProtocol.h b/src/tests/kits/net/ppp/headers/KPPPProtocol.h index 4e31a147eb..74d400c1f8 100644 --- a/src/tests/kits/net/ppp/headers/KPPPProtocol.h +++ b/src/tests/kits/net/ppp/headers/KPPPProtocol.h @@ -8,7 +8,11 @@ #ifndef _K_PPP_PROTOCOL__H #define _K_PPP_PROTOCOL__H -#include "KPPPInterface.h" +#include + +#include + +class PPPInterface; class PPPProtocol { @@ -26,7 +30,9 @@ class PPPProtocol { PPP_PHASE Phase() const { return fPhase; } - driver_parameter *Settings() + PPPInterface *Interface() const + { return fInterface; } + driver_parameter *Settings() const { return fSettings; } uint16 Protocol() const @@ -52,15 +58,15 @@ class PPPProtocol { virtual bool Down() = 0; bool IsUp() const { return fConnectionStatus == PPP_ESTABLISHED_PHASE; } - bool IsDown const - { return fConectionStatus == PPP_DOWN_PHASE; } + bool IsDown() const + { return fConnectionStatus == PPP_DOWN_PHASE; } bool IsGoingUp() const { return fConnectionStatus == PPP_ESTABLISHMENT_PHASE; } bool IsGoingDown() const { return fConnectionStatus == PPP_TERMINATION_PHASE; } - virtual status_t Send(mbuf *packet) = 0; - virtual status_t Receive(mbuf *packet, uint16 protocol) = 0; + virtual status_t Send(struct mbuf *packet) = 0; + virtual status_t Receive(struct mbuf *packet, uint16 protocol) = 0; virtual void Pulse(); @@ -74,12 +80,12 @@ class PPPProtocol { // report up/down events private: - char *name; + char *fName; PPP_PHASE fPhase; uint16 fProtocol; int32 fAddressFamily; - PPPInterface fInterface; - driver_parameter fSettings; + PPPInterface *fInterface; + driver_parameter *fSettings; int32 fFlags; bool fEnabled; diff --git a/src/tests/kits/net/ppp/headers/KPPPReportDefs.h b/src/tests/kits/net/ppp/headers/KPPPReportDefs.h index b68aa682af..3810ad88a2 100644 --- a/src/tests/kits/net/ppp/headers/KPPPReportDefs.h +++ b/src/tests/kits/net/ppp/headers/KPPPReportDefs.h @@ -8,6 +8,7 @@ #ifndef _K_PPP_REPORT_DEFS__H #define _K_PPP_REPORT_DEFS__H + #define PPP_REPORT_DATA_LIMIT 128 // how much optional data can be added to the report #define PPP_REPORT_CODE '_3PR' @@ -47,7 +48,7 @@ enum PPP_CONNECTION_REPORT_CODES { typedef struct ppp_report_packet { int32 type; int32 code; - uint8 len; + uint8 length; char data[PPP_REPORT_DATA_LIMIT]; } ppp_report_packet; @@ -59,7 +60,7 @@ typedef struct ppp_report_packet { #define PPP_REPORT_TIMEOUT 10 typedef struct ppp_report_request { - port_id port; + thread_id thread; int32 type; int32 flags; } ppp_report_request; diff --git a/src/tests/kits/net/ppp/headers/KPPPReportManager.h b/src/tests/kits/net/ppp/headers/KPPPReportManager.h index 769958b015..9a04f0a408 100644 --- a/src/tests/kits/net/ppp/headers/KPPPReportManager.h +++ b/src/tests/kits/net/ppp/headers/KPPPReportManager.h @@ -8,17 +8,19 @@ #ifndef _K_PPP_REPORT_MANAGER__H #define _K_PPP_REPORT_MANAGER__H -#include "KPPPReportDefs.h" +#include -#include "List.h" -#include "LockerHelper.h" +#include + +#include -#define PPP_REPLY(sender, value) send_data_with_timeout((sender), (value), NULL, 0, B_REPORT_TIMEOUT) +#define PPP_REPLY(sender, value) send_data_with_timeout((sender), (value), NULL, 0, PPP_REPORT_TIMEOUT) class PPPReportManager { public: PPPReportManager(BLocker& lock); + ~PPPReportManager(); void EnableReports(PPP_REPORT_TYPE type, thread_id thread, int32 flags = PPP_NO_REPORT_FLAGS); @@ -29,7 +31,7 @@ class PPPReportManager { private: BLocker& fLock; - List fReportRequests; + List fReportRequests; }; diff --git a/src/tests/kits/net/ppp/headers/KPPPStateMachine.h b/src/tests/kits/net/ppp/headers/KPPPStateMachine.h index 0e6dc8fe98..2be9d7a445 100644 --- a/src/tests/kits/net/ppp/headers/KPPPStateMachine.h +++ b/src/tests/kits/net/ppp/headers/KPPPStateMachine.h @@ -8,9 +8,17 @@ #ifndef _K_PPP_STATE_MACHINE__H #define _K_PPP_STATE_MACHINE__H -#include "KPPPLCP.h" +#include -#include "Locker.h" +class PPPEncapsulator; +class PPPInterface; +class PPPProtocol; + +#ifndef _K_PPP_INTERFACE__H +#include +#endif + +#include class PPPStateMachine { @@ -30,7 +38,7 @@ class PPPStateMachine { PPPInterface *Interface() const { return fInterface; } PPPLCP& LCP() const - { return Interface()->LCP(); } + { return fLCP; } PPP_STATE State() const { return fState; } @@ -44,16 +52,16 @@ class PPPStateMachine { void AuthenticationRequested(); void AuthenticationAccepted(const char *name); void AuthenticationDenied(const char *name); - const char *AuthenticationName() const; - // returns NULL if not authenticated + const char *AuthenticationName() const + { return fAuthenticationName; } PPP_AUTHENTICATION_STATUS AuthenticationStatus() const { return fAuthenticationStatus; } void PeerAuthenticationRequested(); void PeerAuthenticationAccepted(const char *name); void PeerAuthenticationDenied(const char *name); - const char *PeerAuthenticationName() const; - // returns NULL if not authenticated + const char *PeerAuthenticationName() const + { return fPeerAuthenticationName; } PPP_AUTHENTICATION_STATUS PeerAuthenticationStatus() const { return fPeerAuthenticationStatus; } @@ -92,21 +100,21 @@ class PPPStateMachine { void CloseEvent(); void TOGoodEvent(); void TOBadEvent(); - void RCRGoodEvent(mbuf *packet); - void RCRBadEvent(mbuf *nak, mbuf *reject); - void RCAEvent(mbuf *packet); - void RCNEvent(mbuf *packet); - void RTREvent(mbuf *packet); - void RTAEvent(mbuf *packet); - void RUCEvent(mbuf *packet, uint16 protocol, uint8 type = PPP_PROTOCOL_REJECT); - void RXJGoodEvent(mbuf *packet); - void RXJBadEvent(mbuf *packet); - void RXREvent(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, uint16 protocol, uint8 type = PPP_PROTOCOL_REJECT); + void RXJGoodEvent(struct mbuf *packet); + void RXJBadEvent(struct mbuf *packet); + void RXREvent(struct mbuf *packet); // general events (for Good/Bad events) void TimerEvent(); - void RCREvent(mbuf *packet); - void RXJEvent(mbuf *packet); + void RCREvent(struct mbuf *packet); + void RXJEvent(struct mbuf *packet); // actions void IllegalEvent(PPP_EVENT event); @@ -117,12 +125,12 @@ class PPPStateMachine { void InitializeRestartCount(); void ZeroRestartCount(); void SendConfigureRequest(); - void SendConfigureAck(mbuf *packet); - void SendConfigureNak(mbuf *packet); + void SendConfigureAck(struct mbuf *packet); + void SendConfigureNak(struct mbuf *packet); void SendTerminateRequest(); - void SendTerminateAck(mbuf *request); - void SendCodeReject(mbuf *packet, uint16 protocol, uint8 type); - void SendEchoReply(mbuf *request); + void SendTerminateAck(struct mbuf *request); + void SendCodeReject(struct mbuf *packet, uint16 protocol, uint8 type); + void SendEchoReply(struct mbuf *request); void BringHandlersUp(); uint32 BringPhaseUp(); @@ -133,6 +141,7 @@ class PPPStateMachine { private: PPPInterface *fInterface; + PPPLCP& fLCP; PPP_PHASE fPhase; PPP_STATE fState; @@ -141,7 +150,7 @@ class PPPStateMachine { PPP_AUTHENTICATION_STATUS fAuthenticationStatus, fPeerAuthenticationStatus; - int32 fAuthenticatorIndex, fPeerAuthenticatorIndex; + char *fAuthenticationName, *fPeerAuthenticationName; BLocker fLock; diff --git a/src/tests/kits/net/ppp/headers/LockerHelper.h b/src/tests/kits/net/ppp/headers/LockerHelper.h index 628641e474..9e4af94d92 100644 --- a/src/tests/kits/net/ppp/headers/LockerHelper.h +++ b/src/tests/kits/net/ppp/headers/LockerHelper.h @@ -19,7 +19,7 @@ #ifndef _LOCKER_HELPER__H #define _LOCKER_HELPER__H -#include "Locker.h" +#include class LockerHelper { diff --git a/src/tests/kits/net/ppp/src/Jamfile b/src/tests/kits/net/ppp/src/Jamfile new file mode 100644 index 0000000000..0d3434de83 --- /dev/null +++ b/src/tests/kits/net/ppp/src/Jamfile @@ -0,0 +1,23 @@ +SubDir OBOS_TOP src tests kits net ppp src ; + +LOCATE_SOURCE += [ FDirName $(OBOS_TOP) src add-ons kernel file_systems bfs ] ; +SubDirHdrs [ FDirName $(OBOS_TOP) src add-ons kernel file_systems bfs ] ; + +UsePrivateHeaders net ; +UseHeaders [ FDirName $(OBOS_TOP) src tests kits net ppp headers ] ; + +R5KernelStaticLibrary kernelppp : + KPPPConfigurePacket.cpp + KPPPDevice.cpp + KPPPEncapsulator.cpp + KPPPInterface.cpp + KPPPLCP.cpp + KPPPOptionHandler.cpp + KPPPProtocol.cpp + KPPPReportManager.cpp + KPPPStateMachine.cpp + KPPPUtils.cpp + Locker.cpp + settings_tools.cpp + cpp.cpp +; diff --git a/src/tests/kits/net/ppp/src/KPPPConfigurePacket.cpp b/src/tests/kits/net/ppp/src/KPPPConfigurePacket.cpp index 90b59aa43b..549a6aa536 100644 --- a/src/tests/kits/net/ppp/src/KPPPConfigurePacket.cpp +++ b/src/tests/kits/net/ppp/src/KPPPConfigurePacket.cpp @@ -5,7 +5,8 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPConfigurePacket.h" +#include +#include PPPConfigurePacket::PPPConfigurePacket(uint8 code) @@ -14,10 +15,10 @@ PPPConfigurePacket::PPPConfigurePacket(uint8 code) } -PPPConfigurePacket::PPPConfigurePacket(mbuf *packet) +PPPConfigurePacket::PPPConfigurePacket(struct mbuf *packet) { // decode packet - lcp_packet *data = mtod(packet, lcp_packet*); + ppp_lcp_packet *data = mtod(packet, ppp_lcp_packet*); if(!SetCode(data->code)) return; @@ -30,7 +31,7 @@ PPPConfigurePacket::PPPConfigurePacket(mbuf *packet) ppp_configure_item *item; while(position <= data->length - 4) { - item = data->data + position; + item = (ppp_configure_item*) (data->data + position); position += item->length; AddItem(item); @@ -64,7 +65,7 @@ PPPConfigurePacket::AddItem(const ppp_configure_item *item, int32 index = -1) if(item->length < 2) return false; - ppp_configure_item *add = malloc(item->length); + ppp_configure_item *add = (ppp_configure_item*) malloc(item->length); memcpy(add, item, item->length); bool status; @@ -106,13 +107,13 @@ PPPConfigurePacket::ItemAt(int32 index) const } -mbuf* +struct mbuf* PPPConfigurePacket::ToMbuf(uint32 reserve = 0) { - mbuf *packet = m_gethdr(MT_DATA); + struct mbuf *packet = m_gethdr(MT_DATA); packet->m_data += reserve; - lcp_packet *data = mtod(packet, lcp_packet*); + ppp_lcp_packet *data = mtod(packet, ppp_lcp_packet*); data->code = Code(); diff --git a/src/tests/kits/net/ppp/src/KPPPDevice.cpp b/src/tests/kits/net/ppp/src/KPPPDevice.cpp index d8b31f31bf..2ab2d43cbb 100644 --- a/src/tests/kits/net/ppp/src/KPPPDevice.cpp +++ b/src/tests/kits/net/ppp/src/KPPPDevice.cpp @@ -5,7 +5,10 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPDevice.h" +#include + +#include +#include PPPDevice::PPPDevice(const char *name, uint32 overhead, PPPInterface *interface, @@ -15,7 +18,7 @@ PPPDevice::PPPDevice(const char *name, uint32 overhead, PPPInterface *interface, { fName = name ? strdup(name) : NULL; - SetMTU(PreferredMTU()); + SetMTU(1500); if(interface) interface->SetDevice(this); @@ -59,13 +62,25 @@ PPPDevice::Control(uint32 op, void *data, size_t length) return B_OK; } + +bool +PPPDevice::SetMTU(uint32 MTU) +{ + fMTU = MTU; + + return true; +} + + status_t -PPPDevice::PassToInterface(mbuf *packet) +PPPDevice::PassToInterface(struct mbuf *packet) { if(!Interface() || !Interface()->InQueue()) return B_ERROR; IFQ_ENQUEUE(Interface()->InQueue(), packet); + + return B_OK; } diff --git a/src/tests/kits/net/ppp/src/KPPPEncapsulator.cpp b/src/tests/kits/net/ppp/src/KPPPEncapsulator.cpp index 1fe032086f..c243bfdc0d 100644 --- a/src/tests/kits/net/ppp/src/KPPPEncapsulator.cpp +++ b/src/tests/kits/net/ppp/src/KPPPEncapsulator.cpp @@ -5,14 +5,15 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPEncapsulator.h" +#include -PPPEncapsulator::PPPEncapsulator(const char *name, PPP_ENCAPSULATION_LEVEL level, - uint16 protocol, int32 addressFamily, uint32 overhead, +PPPEncapsulator::PPPEncapsulator(const char *name, PPP_PHASE phase, + PPP_ENCAPSULATION_LEVEL level, uint16 protocol, + int32 addressFamily, uint32 overhead, PPPInterface *interface, driver_parameter *settings, int32 flags = PPP_NO_FLAGS) - : fOverhead(overhead), fLevel(level), fProtocol(protocol), + : fOverhead(overhead), fPhase(phase), fLevel(level), fProtocol(protocol), fAddressFamily(addressFamily), fInterface(interface), fSettings(settings), fFlags(flags), fEnabled(true), fUpRequested(true), fConnectionStatus(PPP_DOWN_PHASE) @@ -52,7 +53,7 @@ PPPEncapsulator::SetEnabled(bool enabled = true) return; if(!enabled) { - if(IsUp() || IsGoingUp())) + if(IsUp() || IsGoingUp()) Down(); } else if(!IsUp() && !IsGoingUp() && IsUpRequested() && Interface()->IsUp()) Up(); @@ -80,7 +81,7 @@ PPPEncapsulator::Control(uint32 op, void *data, size_t length) status_t -PPPEncapsulator::SendToNext(mbuf *packet, uint16 protocol) const +PPPEncapsulator::SendToNext(struct mbuf *packet, uint16 protocol) const { if(Next()) return Next()->Send(packet, protocol); diff --git a/src/tests/kits/net/ppp/src/KPPPInterface.cpp b/src/tests/kits/net/ppp/src/KPPPInterface.cpp index 650214e9a9..8f95fda200 100644 --- a/src/tests/kits/net/ppp/src/KPPPInterface.cpp +++ b/src/tests/kits/net/ppp/src/KPPPInterface.cpp @@ -5,26 +5,33 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPInterface.h" +// Stdio.h must be included before PPPModule.h/PPPManager.h because +// dprintf is defined twice with different return values, once with +// void (KernelExport.h) and once with int (stdio.h). +#include +#include +#include + +// now our headers... +#include // our other classes -#include "KPPPModule.h" -#include "KPPPManager.h" +#include +#include +#include +#include // general helper classes not only belonging to us -#include "LockerHelper.h" +#include // tools only for us :) #include "KPPPUtils.h" #include "settings_tools.h" -#include -#include - // TODO: // - implement timers with support for settings next time instead of receiving timer -// events +// events periodically // needed for redial: @@ -42,7 +49,7 @@ status_t in_queue_thread(void *data); PPPInterface::PPPInterface(uint32 ID, driver_settings *settings, PPPInterface *parent = NULL) : fID(ID), fSettings(dup_driver_settings(settings)), - fStateMachine(*this), fLCP(*this), ReportManager()(StateMachine().Locker()), + fStateMachine(*this), fLCP(*this), fReportManager(StateMachine().Locker()), fIfnet(NULL), fUpThread(-1), fRedialThread(-1), fDialRetry(0), fDialRetriesLimit(0), fIdleSince(0), fLinkMTU(1500), fDevice(NULL), fFirstEncapsulator(NULL), fLock(StateMachine().Locker()) @@ -144,10 +151,14 @@ PPPInterface::~PPPInterface() while(FirstEncapsulator()) delete FirstEncapsulator(); - for(int32 index = 0; index < fModules.CountItems(); index++) - put_module((module_info**) &fModules.ItemAt(index)); + for(int32 index = 0; index < fModules.CountItems(); index++) { + put_module(fModules.ItemAt(index)); + free(fModules.ItemAt(index)); + } - put_module((module_info**) &fManager); + put_module(PPP_MANAGER_MODULE_NAME); + + free_driver_settings(fSettings); } @@ -231,6 +242,8 @@ PPPInterface::SetDevice(PPPDevice *device) CalculateMRU(); CalculateBaudRate(); + + return true; } @@ -250,6 +263,8 @@ PPPInterface::AddProtocol(PPPProtocol *protocol) if(IsUp() || Phase() >= protocol->Phase()) protocol->Up(); + + return true; } @@ -357,7 +372,7 @@ PPPInterface::RemoveEncapsulator(PPPEncapsulator *encapsulator) return false; // a running connection may not change - PPPEncapsulator *current = fFirstEncapsulator, previous = NULL; + PPPEncapsulator *current = fFirstEncapsulator, *previous = NULL; while(current) { if(current == encapsulator) { @@ -386,7 +401,7 @@ PPPInterface::RemoveEncapsulator(PPPEncapsulator *encapsulator) PPPEncapsulator* PPPInterface::EncapsulatorFor(uint16 protocol, - PPPEncapsulator start = NULL) const + PPPEncapsulator *start = NULL) const { PPPEncapsulator *current = start ? start : fFirstEncapsulator; @@ -433,11 +448,23 @@ PPPInterface::RemoveChild(PPPInterface *child) } +PPPInterface* +PPPInterface::ChildAt(int32 index) const +{ + PPPInterface *child = fChildren.ItemAt(index); + + if(child == fChildren.GetDefaultItem()) + return NULL; + + return child; +} + + void PPPInterface::SetAutoRedial(bool autoredial = true) { if(Mode() == PPP_CLIENT_MODE) - return false; + return; LockerHelper locker(fLock); @@ -449,7 +476,7 @@ void PPPInterface::SetDialOnDemand(bool dialondemand = true) { if(Mode() != PPP_CLIENT_MODE) - return false; + return; LockerHelper locker(fLock); @@ -517,7 +544,6 @@ PPPInterface::Up() return true; } - if(report.type == PPP_DESTRUCTION_REPORT) { if(me == fUpThread) { fDialRetry = 0; @@ -676,13 +702,12 @@ PPPInterface::IsUp() const { LockerHelper locker(fLock); - return StateMachine().Phase() == PPP_ESTABLISHED_PHASE; + return Phase() == PPP_ESTABLISHED_PHASE; } bool -PPPInterface::LoadModules(const driver_settings *settings, - int32 start, int32 count) +PPPInterface::LoadModules(driver_settings *settings, int32 start, int32 count) { if(Phase() != PPP_DOWN_PHASE) return false; @@ -698,8 +723,8 @@ PPPInterface::LoadModules(const driver_settings *settings, i < settings->parameter_count && i < start + count; i++) { if(!strcasecmp(settings->parameters[i].name, PPP_MULTILINK_KEY) && settings->parameters[i].value_count > 0) { - if(!LoadModule(settings->parameters[i].value[0], - parameters[i].parameters, PPP_MULTILINK_TYPE)) + if(!LoadModule(settings->parameters[i].values[0], + settings->parameters[i].parameters, PPP_MULTILINK_TYPE)) return false; break; } @@ -734,7 +759,7 @@ PPPInterface::LoadModules(const driver_settings *settings, if(type >= 0) for(int32 value_id = 0; value_id < settings->parameters[i].value_count; value_id++) - if(!LoadModule(settings->parameters[i].value[value_id], + if(!LoadModule(settings->parameters[i].values[value_id], settings->parameters[i].parameters, type)) return false; } @@ -744,7 +769,7 @@ PPPInterface::LoadModules(const driver_settings *settings, bool -PPPInterface::LoadModule(const char *name, const driver_parameter *parameter, +PPPInterface::LoadModule(const char *name, driver_parameter *parameter, int32 type) { if(Phase() != PPP_DOWN_PHASE) @@ -754,7 +779,7 @@ PPPInterface::LoadModule(const char *name, const driver_parameter *parameter, if(!name || strlen(name) > B_FILE_NAME_LENGTH) return false; - char module_name[B_PATH_NAME_LENGTH]; + char *module_name = (char*) malloc(B_PATH_NAME_LENGTH); sprintf(module_name, "%s/%s", PPP_MODULES_PATH, name); @@ -762,17 +787,16 @@ PPPInterface::LoadModule(const char *name, const driver_parameter *parameter, if(get_module(module_name, (module_info**) &module) != B_OK) return false; - if(!module->add_to(Parent()?Parent():this, this, parameter, type)) - return false; - // add the module to the list of loaded modules // for putting them on our destruction - return fModules.AddItem(module); + fModules.AddItem(module_name); + + return module->add_to(Parent()?Parent():this, this, parameter, type); } status_t -PPPInterface::Send(mbuf *packet, uint16 protocol) +PPPInterface::Send(struct mbuf *packet, uint16 protocol) { if(!packet) return B_ERROR; @@ -815,14 +839,14 @@ PPPInterface::Send(mbuf *packet, uint16 protocol) return SendToDevice(packet, protocol); if(!fFirstEncapsulator->IsEnabled()) - return fFirstEncapsulator->SendToNext(); + return fFirstEncapsulator->SendToNext(packet, protocol); return fFirstEncapsulator->Send(packet, protocol); } status_t -PPPInterface::Receive(mbuf *packet, uint16 protocol) +PPPInterface::Receive(struct mbuf *packet, uint16 protocol) { if(!packet) return B_ERROR; @@ -877,20 +901,20 @@ PPPInterface::Receive(mbuf *packet, uint16 protocol) // maybe the parent interface can handle it if(Parent()) - return Parent->Receive(packet, protocol); + return Parent()->Receive(packet, protocol); - if(result == PPP_UNHANDLED) + if(result == PPP_UNHANDLED) { m_freem(packet); return PPP_DISCARDED; - else { - StateMachine()->RUCEvent(packet, protocol); + } else { + StateMachine().RUCEvent(packet, protocol); return PPP_REJECTED; } } status_t -PPPInterface::SendToDevice(mbuf *packet, uint16 protocol) +PPPInterface::SendToDevice(struct mbuf *packet, uint16 protocol) { if(!packet) return B_ERROR; @@ -930,7 +954,7 @@ PPPInterface::SendToDevice(mbuf *packet, uint16 protocol) } // encode in ppp frame - M_PREPEND(packet, sizeof(uint16)); + M_PREPEND(packet, 2); if(packet == NULL) return B_ERROR; @@ -945,7 +969,7 @@ PPPInterface::SendToDevice(mbuf *packet, uint16 protocol) // pass to device/children if(!IsMultilink() || Parent()) { // check if packet is too big for device - if((packet->m_flags & M_PKTHDR && packet->m_pkthdr.len > LinkMTU()) + if((packet->m_flags & M_PKTHDR && (uint32) packet->m_pkthdr.len > LinkMTU()) || packet->m_len > LinkMTU()) { m_freem(packet); return B_ERROR; @@ -961,7 +985,7 @@ PPPInterface::SendToDevice(mbuf *packet, uint16 protocol) status_t -PPPInterface::ReceiveFromDevice(mbuf *packet) +PPPInterface::ReceiveFromDevice(struct mbuf *packet) { if(!packet) return B_ERROR; @@ -984,7 +1008,7 @@ PPPInterface::ReceiveFromDevice(mbuf *packet) if(packet->m_flags & M_PKTHDR) packet->m_pkthdr.rcvif = Ifnet(); - return Receive(packet, protocol); + return Receive(packet, *protocol); } @@ -1068,7 +1092,7 @@ PPPInterface::CalculateMRU() // sum all headers fHeaderLength = sizeof(uint16); - PPPEncapsulator encapsulator = fFirstEncapsulator; + PPPEncapsulator *encapsulator = fFirstEncapsulator; for(; encapsulator; encapsulator = encapsulator->Next()) fHeaderLength += encapsulator->Overhead(); @@ -1091,7 +1115,7 @@ PPPInterface::CalculateBaudRate() return; if(Device()) - fIfnet->if_baudrate = max(Device()->InputTransferRate(), + fIfnet->if_baudrate = max_c(Device()->InputTransferRate(), Device()->OutputTransferRate()); else { fIfnet->if_baudrate = 0; @@ -1110,8 +1134,8 @@ PPPInterface::Redial() // start a new thread that calls our Up() method redial_info *info = new redial_info; - info.interface = this; - info.thread = &fRedialThread; + info->interface = this; + info->thread = &fRedialThread; fRedialThread = spawn_kernel_thread(redial_func, "PPPInterface: redial_thread", B_NORMAL_PRIORITY, info); @@ -1129,6 +1153,8 @@ redial_func(void *data) *info->thread = -1; delete info; + + return B_OK; } @@ -1137,7 +1163,7 @@ in_queue_thread(void *data) { PPPInterface *interface = (PPPInterface*) data; struct ifq *queue = interface->InQueue(); - mbuf *packet; + struct mbuf *packet; status_t error; while(true) { diff --git a/src/tests/kits/net/ppp/src/KPPPLCP.cpp b/src/tests/kits/net/ppp/src/KPPPLCP.cpp index fbea4c90d8..da5ae7c497 100644 --- a/src/tests/kits/net/ppp/src/KPPPLCP.cpp +++ b/src/tests/kits/net/ppp/src/KPPPLCP.cpp @@ -5,7 +5,16 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPLCP.h" +#include +#include +#include +#include + +#include + +#include +#include +#include #define PPP_PROTOCOL_OVERHEAD 2 @@ -17,7 +26,7 @@ PPPLCP::PPPLCP(PPPInterface& interface) : PPPProtocol("LCP", PPP_ESTABLISHMENT_PHASE, PPP_LCP_PROTOCOL, AF_UNSPEC, &interface, NULL, PPP_ALWAYS_ALLOWED), - fTarget(NULL) + fStateMachine(interface.StateMachine()), fTarget(NULL) { SetUpRequested(false); // the state machine does everything for us @@ -35,7 +44,7 @@ bool PPPLCP::AddOptionHandler(PPPOptionHandler *handler) { if(!handler) - return false + return false; LockerHelper locker(StateMachine().Locker()); @@ -43,7 +52,7 @@ PPPLCP::AddOptionHandler(PPPOptionHandler *handler) return false; // a running connection may not change - fOptionHandlers.AddItem(handler); + return fOptionHandlers.AddItem(handler); } @@ -65,7 +74,7 @@ PPPLCP::OptionHandlerAt(int32 index) const { PPPOptionHandler *handler = fOptionHandlers.ItemAt(index); - if(handler == fOptionHandlers.DefaultItem()) + if(handler == fOptionHandlers.GetDefaultItem()) return NULL; return handler; @@ -74,7 +83,7 @@ PPPLCP::OptionHandlerAt(int32 index) const uint32 PPPLCP::AdditionalOverhead() const { - uint32 overhead += PPP_PROTOCOL_OVERHEAD; + uint32 overhead = PPP_PROTOCOL_OVERHEAD; if(Target()) overhead += Target()->Overhead(); @@ -88,17 +97,19 @@ PPPLCP::AdditionalOverhead() const bool PPPLCP::Up() { + return true; } bool PPPLCP::Down() { + return true; } status_t -PPPLCP::Send(mbuf *packet) +PPPLCP::Send(struct mbuf *packet) { if(!Interface()) return B_ERROR; @@ -108,12 +119,12 @@ PPPLCP::Send(mbuf *packet) status_t -PPPLCP::Receive(mbuf *packet, uint16 protocol) +PPPLCP::Receive(struct mbuf *packet, uint16 protocol) { if(protocol != PPP_LCP_PROTOCOL) return PPP_UNHANDLED; - lcp_packet *data = mtod(packet, lcp_packet*); + ppp_lcp_packet *data = mtod(packet, ppp_lcp_packet*); if(ntohs(data->length) < 4) return B_ERROR; diff --git a/src/tests/kits/net/ppp/src/KPPPOptionHandler.cpp b/src/tests/kits/net/ppp/src/KPPPOptionHandler.cpp index 0a9d971ca9..08e55552b1 100644 --- a/src/tests/kits/net/ppp/src/KPPPOptionHandler.cpp +++ b/src/tests/kits/net/ppp/src/KPPPOptionHandler.cpp @@ -5,7 +5,7 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPOptionHandler.h" +#include PPPOptionHandler::PPPOptionHandler(const char *name, PPPInterface *interface, diff --git a/src/tests/kits/net/ppp/src/KPPPProtocol.cpp b/src/tests/kits/net/ppp/src/KPPPProtocol.cpp index 216eeb4681..dab65ca5b2 100644 --- a/src/tests/kits/net/ppp/src/KPPPProtocol.cpp +++ b/src/tests/kits/net/ppp/src/KPPPProtocol.cpp @@ -5,7 +5,9 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPProtocol.h" +#include + +#include PPPProtocol::PPPProtocol(const char *name, PPP_PHASE phase, uint16 protocol, @@ -50,7 +52,7 @@ PPPProtocol::SetEnabled(bool enabled = true) return; if(!enabled) { - if(IsUp() || IsGoingUp())) + if(IsUp() || IsGoingUp()) Down(); } else if(!IsUp() && !IsGoingUp() && IsUpRequested() && Interface()->IsUp()) Up(); diff --git a/src/tests/kits/net/ppp/src/KPPPReportManager.cpp b/src/tests/kits/net/ppp/src/KPPPReportManager.cpp index 0071de981d..f54cc574b5 100644 --- a/src/tests/kits/net/ppp/src/KPPPReportManager.cpp +++ b/src/tests/kits/net/ppp/src/KPPPReportManager.cpp @@ -5,7 +5,12 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPReportManager.h" +#include +#include + +#include "KPPPUtils.h" + +#include PPPReportManager::PPPReportManager(BLocker& lock) @@ -14,16 +19,23 @@ PPPReportManager::PPPReportManager(BLocker& lock) } +PPPReportManager::~PPPReportManager() +{ + for(int32 index = 0; index < fReportRequests.CountItems(); index++) + delete fReportRequests.ItemAt(index); +} + + void PPPReportManager::EnableReports(PPP_REPORT_TYPE type, thread_id thread, int32 flags = PPP_NO_REPORT_FLAGS) { LockerHelper locker(fLock); - ppp_report_request request; - request.type = type; - request.thread = thread; - request.flags = flags; + ppp_report_request *request = new ppp_report_request; + request->type = type; + request->thread = thread; + request->flags = flags; fReportRequests.AddItem(request); } @@ -34,14 +46,16 @@ PPPReportManager::DisableReports(PPP_REPORT_TYPE type, thread_id thread) { LockerHelper locker(fLock); + ppp_report_request *request; + for(int32 i = 0; i < fReportRequests.CountItems(); i++) { - ppp_report_request& request = fReportRequests.ItemAt(i); + request = fReportRequests.ItemAt(i); - if(request.thread != thread) + if(request->thread != thread) continue; - if(report.type == type) - fReportRequest.RemoveItem(request); + if(request->type == type) + fReportRequests.RemoveItem(request); } } @@ -51,10 +65,12 @@ PPPReportManager::DoesReport(PPP_REPORT_TYPE type, thread_id thread) { LockerHelper locker(fLock); + ppp_report_request *request; + for(int32 i = 0; i < fReportRequests.CountItems(); i++) { - ppp_report_request& request = fReportRequests.ItemAt(i); + request = fReportRequests.ItemAt(i); - if(request.thread == thread && request.type == type) + if(request->thread == thread && request->type == type) return true; } @@ -76,20 +92,22 @@ PPPReportManager::Report(PPP_REPORT_TYPE type, int32 code, void *data, int32 len LockerHelper locker(fLock); - int32 code, query, result; + status_t result; thread_id sender; bool acceptable = true; - report_packet report; + ppp_report_packet report; report.type = type; report.code = code; report.length = length; memcpy(report.data, data, length); + ppp_report_request *request; + for(int32 index = 0; index < fReportRequests.CountItems(); index++) { - ppp_report_request& request = fReportRequests.ItemAt(index); + request = fReportRequests.ItemAt(index); - result = send_data_with_timeout(request.thread, PPP_REPORT_CODE, &report, + result = send_data_with_timeout(request->thread, PPP_REPORT_CODE, &report, sizeof(report), PPP_REPORT_TIMEOUT); if(result == B_BAD_THREAD_ID || result == B_NO_MEMORY) { @@ -97,16 +115,16 @@ PPPReportManager::Report(PPP_REPORT_TYPE type, int32 code, void *data, int32 len --index; continue; } else if(result == B_OK) { - if(request.flags & PPP_WAIT_FOR_REPLY) { - if(request.flags & PPP_NO_REPLY_TIMEOUT) { + if(request->flags & PPP_WAIT_FOR_REPLY) { + if(request->flags & PPP_NO_REPLY_TIMEOUT) { sender = -1; - while(sender != request.thread) + while(sender != request->thread) code = receive_data(&sender, NULL, 0); result = B_OK; } else { sender = -1; result = B_OK; - while(sender != request.thread && result == B_OK) + while(sender != request->thread && result == B_OK) result = receive_data_with_timeout(&sender, &code, NULL, 0, PPP_REPORT_TIMEOUT); } @@ -116,7 +134,7 @@ PPPReportManager::Report(PPP_REPORT_TYPE type, int32 code, void *data, int32 len } } - if(request.flags & PPP_REMOVE_AFTER_REPORT) { + if(request->flags & PPP_REMOVE_AFTER_REPORT) { fReportRequests.RemoveItem(request); --index; } diff --git a/src/tests/kits/net/ppp/src/KPPPStateMachine.cpp b/src/tests/kits/net/ppp/src/KPPPStateMachine.cpp index 0c4aa80a8c..434cfb4b8c 100644 --- a/src/tests/kits/net/ppp/src/KPPPStateMachine.cpp +++ b/src/tests/kits/net/ppp/src/KPPPStateMachine.cpp @@ -5,19 +5,28 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPStateMachine.h" +#include + +#include +#include +#include +#include +#include + +#include +#include #define PPP_STATE_MACHINE_TIMEOUT 3000000 PPPStateMachine::PPPStateMachine(PPPInterface& interface) - : fInterface(&interface), fPhase(PPP_DOWN_PHASE), + : fInterface(&interface), fLCP(interface.LCP()), fPhase(PPP_DOWN_PHASE), fState(PPP_INITIAL_STATE), fID(system_time() & 0xFF), fAuthenticationStatus(PPP_NOT_AUTHENTICATED), fPeerAuthenticationStatus(PPP_NOT_AUTHENTICATED), fAuthenticationName(NULL), fPeerAuthenticationName(NULL), - fMaxTerminate(2), fMaxConfigure(10), fMaxNak(5), + fMaxRequest(10), fMaxTerminate(2), fMaxNak(5), fRequestID(0), fTerminateID(0), fNextTimeout(0) { } @@ -100,7 +109,8 @@ PPPStateMachine::AuthenticationAccepted(const char *name) free(fAuthenticationName); fAuthenticationName = strdup(name); - Interface()->Report(PPP_CONNECTION_REPORT, PPP_REPORT_AUTHENTICATION_SUCCESSFUL, 0); + Interface()->Report(PPP_CONNECTION_REPORT, PPP_REPORT_AUTHENTICATION_SUCCESSFUL, + NULL, 0); } @@ -115,15 +125,6 @@ PPPStateMachine::AuthenticationDenied(const char *name) } -const char* -PPPStateMachine::AuthenticationName() const -{ - LockerHelper locker(fLock); - - return fAuthenticationName; -} - - void PPPStateMachine::PeerAuthenticationRequested() { @@ -145,7 +146,7 @@ PPPStateMachine::PeerAuthenticationAccepted(const char *name) fPeerAuthenticationName = strdup(name); Interface()->Report(PPP_CONNECTION_REPORT, - PPP_REPORT_PEER_AUTHENTICATION_SUCCESSFUL, 0); + PPP_REPORT_PEER_AUTHENTICATION_SUCCESSFUL, NULL, 0); } @@ -157,15 +158,8 @@ PPPStateMachine::PeerAuthenticationDenied(const char *name) fPeerAuthenticationStatus = PPP_AUTHENTICATION_FAILED; free(fPeerAuthenticationName); fPeerAuthenticationName = strdup(name); -} - - -const char* -PPPStateMachine::PeerAuthenticationName() const -{ - LockerHelper locker(fLock); - return fPeerAuthenticationName; + CloseEvent(); } @@ -387,7 +381,7 @@ PPPStateMachine::UpEvent() LockerHelper locker(fLock); - if(!Interface()->Device() || !Interface()->Device->IsUp()) + if(!Interface()->Device() || !Interface()->Device()->IsUp()) return; // it is not our device that went up... @@ -395,7 +389,7 @@ PPPStateMachine::UpEvent() switch(State()) { case PPP_INITIAL_STATE: - if(Mode() != PPP_SERVER_MODE + if(Interface()->Mode() != PPP_SERVER_MODE || Phase() != PPP_ESTABLISHMENT_PHASE) { // we are a client or we do not listen for an incoming // connection, so this is an illegal event @@ -444,7 +438,7 @@ PPPStateMachine::DownEvent() { LockerHelper locker(fLock); - if(Interface()->Device() && Interface()->Device->IsUp()) + if(Interface()->Device() && Interface()->Device()->IsUp()) return; // it is not our device that went up... @@ -489,7 +483,7 @@ PPPStateMachine::DownEvent() if(State() == PPP_STARTING_STATE) { bool needsRedial = false; - if(fAuthentiactionStatus == PPP_AUTHENTICATION_FAILED + if(fAuthenticationStatus == PPP_AUTHENTICATION_FAILED || fAuthenticationStatus == PPP_AUTHENTICATING || fPeerAuthenticationStatus == PPP_AUTHENTICATION_FAILED || fPeerAuthenticationStatus == PPP_AUTHENTICATING) @@ -569,6 +563,10 @@ PPPStateMachine::OpenEvent() case PPP_CLOSING_STATE: NewState(PPP_STOPPING_STATE); + break; + + default: + ; } } @@ -628,6 +626,9 @@ PPPStateMachine::CloseEvent() case PPP_STOPPED_STATE: NewState(PPP_STOPPED_STATE); break; + + default: + ; } } @@ -692,7 +693,7 @@ PPPStateMachine::TOBadEvent() // receive configure request (acceptable request) void -PPPStateMachine::RCRGoodEvent(mbuf *packet) +PPPStateMachine::RCRGoodEvent(struct mbuf *packet) { LockerHelper locker(fLock); @@ -704,7 +705,7 @@ PPPStateMachine::RCRGoodEvent(mbuf *packet) case PPP_CLOSED_STATE: locker.UnlockNow(); - SendTerminateAck(); + SendTerminateAck(packet); break; case PPP_STOPPED_STATE: @@ -737,13 +738,16 @@ PPPStateMachine::RCRGoodEvent(mbuf *packet) SendConfigureRequest(); SendConfigureAck(packet); break; + + default: + ; } } // receive configure request (unacceptable request) void -PPPStateMachine::RCRBadEvent(mbuf *nak, mbuf *reject) +PPPStateMachine::RCRBadEvent(struct mbuf *nak, struct mbuf *reject) { LockerHelper locker(fLock); @@ -755,7 +759,7 @@ PPPStateMachine::RCRBadEvent(mbuf *nak, mbuf *reject) case PPP_CLOSED_STATE: locker.UnlockNow(); - SendTerminateAck(); + SendTerminateAck(NULL); break; case PPP_STOPPED_STATE: @@ -779,22 +783,25 @@ PPPStateMachine::RCRBadEvent(mbuf *nak, mbuf *reject) case PPP_REQ_SENT_STATE: case PPP_ACK_RCVD_STATE: locker.UnlockNow(); - if(!nak && ntohs(mtod(nak, lcp_packet*)->length) > 3) + if(nak && ntohs(mtod(nak, ppp_lcp_packet*)->length) > 3) SendConfigureNak(nak); - else if(!reject && ntohs(mtod(reject, lcp_packet*)->length) > 3) + else if(reject && ntohs(mtod(reject, ppp_lcp_packet*)->length) > 3) SendConfigureNak(reject); break; + + default: + ; } } // receive configure ack void -PPPStateMachine::RCAEvent(mbuf *packet) +PPPStateMachine::RCAEvent(struct mbuf *packet) { LockerHelper locker(fLock); - if(fRequestID != mtod(packet, lcp_packet*)->id) { + if(fRequestID != mtod(packet, ppp_lcp_packet*)->id) { // this packet is not a reply to our request // TODO: @@ -807,7 +814,7 @@ PPPStateMachine::RCAEvent(mbuf *packet) for(int32 index = 0; index < LCP().CountOptionHandlers(); index++) { handler = LCP().OptionHandlerAt(index); - handler->ParseAck(ack); + handler->ParseAck(&ack); } switch(State()) { @@ -819,7 +826,7 @@ PPPStateMachine::RCAEvent(mbuf *packet) case PPP_CLOSED_STATE: case PPP_STOPPED_STATE: locker.UnlockNow(); - SendTerminateAck(); + SendTerminateAck(NULL); break; case PPP_REQ_SENT_STATE: @@ -848,17 +855,20 @@ PPPStateMachine::RCAEvent(mbuf *packet) ThisLayerDown(); SendConfigureRequest(); break; + + default: + ; } } // receive configure nak/reject void -PPPStateMachine::RCNEvent(mbuf *packet) +PPPStateMachine::RCNEvent(struct mbuf *packet) { LockerHelper locker(fLock); - if(fRequestID != mtod(packet, lcp_packet*)->id) { + if(fRequestID != mtod(packet, ppp_lcp_packet*)->id) { // this packet is not a reply to our request // TODO: @@ -873,9 +883,9 @@ PPPStateMachine::RCNEvent(mbuf *packet) handler = LCP().OptionHandlerAt(index); if(nak_reject.Code() == PPP_CONFIGURE_NAK) - handler->ParseNak(nak_reject); + handler->ParseNak(&nak_reject); else if(nak_reject.Code() == PPP_CONFIGURE_REJECT) - handler->ParseReject(nak_reject); + handler->ParseReject(&nak_reject); } switch(State()) { @@ -887,7 +897,7 @@ PPPStateMachine::RCNEvent(mbuf *packet) case PPP_CLOSED_STATE: case PPP_STOPPED_STATE: locker.UnlockNow(); - SendTermintateAck(packet); + SendTerminateAck(packet); break; case PPP_REQ_SENT_STATE: @@ -909,18 +919,21 @@ PPPStateMachine::RCNEvent(mbuf *packet) ThisLayerDown(); SendConfigureRequest(); break; + + default: + ; } } // receive terminate request void -PPPStateMachine::RTREvent(mbuf *packet) +PPPStateMachine::RTREvent(struct mbuf *packet) { LockerHelper locker(fLock); // we should not use the same ID as the peer - if(fID == mtod(packet, lcp_packet*)->id) + if(fID == mtod(packet, ppp_lcp_packet*)->id) fID -= 128; fAuthenticationStatus = PPP_NOT_AUTHENTICATED; @@ -962,11 +975,11 @@ PPPStateMachine::RTREvent(mbuf *packet) // receive terminate ack void -PPPStateMachine::RTAEvent(mbuf *packet) +PPPStateMachine::RTAEvent(struct mbuf *packet) { LockerHelper locker(fLock); - if(fTerminateID != mtod(packet, lcp_packet*)->id) { + if(fTerminateID != mtod(packet, ppp_lcp_packet*)->id) { // this packet is not a reply to our request // TODO: @@ -986,14 +999,14 @@ PPPStateMachine::RTAEvent(mbuf *packet) ThisLayerFinished(); break; - case PPP_CLOSING_STATE: + case PPP_STOPPING_STATE: NewState(PPP_STOPPED_STATE); locker.UnlockNow(); ThisLayerFinished(); break; case PPP_ACK_RCVD_STATE: - NewState(REQ_SENT_STATE); + NewState(PPP_REQ_SENT_STATE); break; case PPP_OPENED_STATE: @@ -1002,13 +1015,16 @@ PPPStateMachine::RTAEvent(mbuf *packet) ThisLayerDown(); SendConfigureRequest(); break; + + default: + ; } } // receive unknown code void -PPPStateMachine::RUCEvent(mbuf *packet, uint16 protocol, uint8 type = PPP_PROTOCOL_REJECT) +PPPStateMachine::RUCEvent(struct mbuf *packet, uint16 protocol, uint8 type = PPP_PROTOCOL_REJECT) { LockerHelper locker(fLock); @@ -1027,7 +1043,7 @@ PPPStateMachine::RUCEvent(mbuf *packet, uint16 protocol, uint8 type = PPP_PROTOC // receive code/protocol reject (acceptable such as IPX reject) void -PPPStateMachine::RXJGoodEvent(mbuf *packet) +PPPStateMachine::RXJGoodEvent(struct mbuf *packet) { LockerHelper locker(fLock); @@ -1040,20 +1056,23 @@ PPPStateMachine::RXJGoodEvent(mbuf *packet) case PPP_ACK_RCVD_STATE: NewState(PPP_REQ_SENT_STATE); break; + + default: + ; } } // receive code/protocol reject (catastrophic such as LCP reject) void -PPPStateMachine::RXJBadEvent(mbuf *packet) +PPPStateMachine::RXJBadEvent(struct mbuf *packet) { LockerHelper locker(fLock); switch(State()) { case PPP_INITIAL_STATE: case PPP_STARTING_STATE: - IllegalEvent(PPP_RJX_BAD_EVENT); + IllegalEvent(PPP_RXJ_BAD_EVENT); break; case PPP_CLOSING_STATE: @@ -1088,9 +1107,9 @@ PPPStateMachine::RXJBadEvent(mbuf *packet) // receive echo request/reply, discard request void -PPPStateMachine::RXREvent(mbuf *packet) +PPPStateMachine::RXREvent(struct mbuf *packet) { - lcp_packet *echo = mtod(mbuf, lcp_packet*); + ppp_lcp_packet *echo = mtod(packet, ppp_lcp_packet*); switch(State()) { case PPP_INITIAL_STATE: @@ -1102,6 +1121,9 @@ PPPStateMachine::RXREvent(mbuf *packet) if(echo->code == PPP_ECHO_REQUEST) SendEchoReply(packet); break; + + default: + ; } } @@ -1118,7 +1140,7 @@ PPPStateMachine::TimerEvent() switch(State()) { case PPP_CLOSING_STATE: - case PPP_STOPPTING_STATE: + case PPP_STOPPING_STATE: if(fTerminateCounter <= 0) TOBadEvent(); else @@ -1128,11 +1150,14 @@ PPPStateMachine::TimerEvent() case PPP_REQ_SENT_STATE: case PPP_ACK_RCVD_STATE: case PPP_ACK_SENT_STATE: - if(fConfigureCounter <= 0) + if(fRequestCounter <= 0) TOBadEvent(); else TOGoodEvent(); break; + + default: + ; } } @@ -1142,14 +1167,14 @@ PPPStateMachine::TimerEvent() // Here we get a configure-request packet from LCP and aks all OptionHandlers // if its values are acceptable. From here we call our Good/Bad counterparts. void -PPPStateMachine::RCREvent(mbuf *packet) +PPPStateMachine::RCREvent(struct mbuf *packet) { PPPConfigurePacket request(packet), nak(PPP_CONFIGURE_NAK), reject(PPP_CONFIGURE_REJECT); PPPOptionHandler *handler; // we should not use the same id as the peer - if(fID == mtod(packet, lcp_packet*)->id) + if(fID == mtod(packet, ppp_lcp_packet*)->id) fID -= 128; nak.SetID(request.ID()); @@ -1169,14 +1194,14 @@ PPPStateMachine::RCREvent(mbuf *packet) index++) { handler = LCP().OptionHandlerAt(index); error = handler->ParseRequest(&request, item, &nak, &reject); - if(error == PPP_UNHANLED) + if(error == PPP_UNHANDLED) continue; else if(error == B_ERROR) { // the request contains a value that has been sent more than // once or the value is corrupted CloseEvent(); return; - } else if(error = B_OK) + } else if(error == B_OK) handled = true; } @@ -1188,7 +1213,7 @@ PPPStateMachine::RCREvent(mbuf *packet) if(nak.CountItems() > 0) RCRBadEvent(nak.ToMbuf(LCP().AdditionalOverhead()), NULL); - else if(reject.CountItmes() > 0) + else if(reject.CountItems() > 0) RCRBadEvent(NULL, reject.ToMbuf(LCP().AdditionalOverhead())); else RCRGoodEvent(packet); @@ -1199,9 +1224,9 @@ PPPStateMachine::RCREvent(mbuf *packet) // LCP received a code/protocol-reject packet and we look if it is acceptable. // From here we call our Good/Bad counterparts. void -PPPStateMachine::RXJEvent(mbuf *packet) +PPPStateMachine::RXJEvent(struct mbuf *packet) { - lcp_packet *reject mtod(packet, lcp_packet*); + ppp_lcp_packet *reject mtod(packet, ppp_lcp_packet*); if(reject->code == PPP_CODE_REJECT) { // we only have basic codes, so there must be something wrong @@ -1304,7 +1329,7 @@ PPPStateMachine::ThisLayerFinished() void PPPStateMachine::InitializeRestartCount() { - fConfigureCounter = fMaxConfigure; + fRequestCounter = fMaxRequest; fTerminateCounter = fMaxTerminate; fNakCounter = fMaxNak; @@ -1316,7 +1341,7 @@ PPPStateMachine::InitializeRestartCount() void PPPStateMachine::ZeroRestartCount() { - fConfigureCounter = 0; + fRequestCounter = 0; fTerminateCounter = 0; fNakCounter = 0; @@ -1328,11 +1353,11 @@ PPPStateMachine::ZeroRestartCount() void PPPStateMachine::SendConfigureRequest() { - --fConfigureCounter; + --fRequestCounter; PPPConfigurePacket request(PPP_CONFIGURE_REQUEST); request.SetID(NextID()); - fConfigureID = request.ID(); + fRequestID = request.ID(); for(int32 index = 0; index < LCP().CountOptionHandlers(); index++) { // add all items @@ -1347,12 +1372,12 @@ PPPStateMachine::SendConfigureRequest() void -PPPStateMachine::SendConfigureAck(mbuf *packet) +PPPStateMachine::SendConfigureAck(struct mbuf *packet) { - mtod(packet, lcp_packet*)->code = PPP_CONFIGURE_ACK; + mtod(packet, ppp_lcp_packet*)->code = PPP_CONFIGURE_ACK; PPPConfigurePacket ack(packet); - for(int32 index = 0; index < LCP().CountOptionHandlers; index++) + for(int32 index = 0; index < LCP().CountOptionHandlers(); index++) LCP().OptionHandlerAt(index)->SendingAck(&ack); LCP().Send(packet); @@ -1360,9 +1385,9 @@ PPPStateMachine::SendConfigureAck(mbuf *packet) void -PPPStateMachine::SendConfigureNak(mbuf *packet) +PPPStateMachine::SendConfigureNak(struct mbuf *packet) { - lcp_packet *nak = mtod(packet, lcp_packet*); + ppp_lcp_packet *nak = mtod(packet, ppp_lcp_packet*); if(nak->code == PPP_CONFIGURE_NAK) { if(fNakCounter == 0) { // We sent enough naks. Let's try a reject. @@ -1378,7 +1403,7 @@ PPPStateMachine::SendConfigureNak(mbuf *packet) void PPPStateMachine::SendTerminateRequest() { - mbuf *m = m_gethdr(MT_DATA); + struct mbuf *m = m_gethdr(MT_DATA); if(!m) return; @@ -1389,7 +1414,7 @@ PPPStateMachine::SendTerminateRequest() // reserve some space for other protocols m->m_data += LCP().AdditionalOverhead(); - lcp_packet *request = mtod(m, lcp_packet*); + ppp_lcp_packet *request = mtod(m, ppp_lcp_packet*); request->code = PPP_TERMINATE_REQUEST; request->id = fTerminateID = NextID(); request->length = htons(4); @@ -1399,18 +1424,34 @@ PPPStateMachine::SendTerminateRequest() void -PPPStateMachine::SendTerminateAck(mbuf *request) +PPPStateMachine::SendTerminateAck(struct mbuf *request) { - lcp_packet *ack = mtod(request, lcp_packet*); - reply->code = PPP_TERMINATE_ACK; - // the request becomes an ack + struct mbuf *reply = request; - LCP().Send(request); + ppp_lcp_packet *ack; + + if(!reply) { + reply = m_gethdr(MT_DATA); + if(!reply) + return; + + reply->m_data += LCP().AdditionalOverhead(); + reply->m_len = 4; + + ack = mtod(reply, ppp_lcp_packet*); + ack->id = NextID(); + ack->length = 4; + } + + ack = mtod(reply, ppp_lcp_packet*); + ack->code = PPP_TERMINATE_ACK; + + LCP().Send(reply); } void -PPPStateMachine::SendCodeReject(mbuf *packet, uint16 protocol, uint8 type) +PPPStateMachine::SendCodeReject(struct mbuf *packet, uint16 protocol, uint8 type) { int32 length; // additional space needed for this reject @@ -1422,7 +1463,7 @@ PPPStateMachine::SendCodeReject(mbuf *packet, uint16 protocol, uint8 type) int32 adjust = 0; // adjust packet size by this value if packet is too big if(packet->m_flags & M_PKTHDR) { - if(packet->m_pkthdr.len > Interface()->LinkMTU()) + if((uint32) packet->m_pkthdr.len > Interface()->LinkMTU()) adjust = Interface()->LinkMTU() - packet->m_pkthdr.len; } else if(packet->m_len > Interface()->LinkMTU()) adjust = Interface()->LinkMTU() - packet->m_len; @@ -1430,7 +1471,7 @@ PPPStateMachine::SendCodeReject(mbuf *packet, uint16 protocol, uint8 type) if(adjust != 0) m_adj(packet, adjust); - lcp_packet *reject = mtod(packet, lcp_packet*); + ppp_lcp_packet *reject = mtod(packet, ppp_lcp_packet*); reject->code = type; reject->id = NextID(); if(packet->m_flags & M_PKTHDR) @@ -1440,16 +1481,16 @@ PPPStateMachine::SendCodeReject(mbuf *packet, uint16 protocol, uint8 type) protocol = htons(protocol); if(type == PPP_PROTOCOL_REJECT) - memcpy(&data->data, &protocol, sizeof(protocol)); + memcpy(&reject->data, &protocol, sizeof(protocol)); LCP().Send(packet); } void -PPPStateMachine::SendEchoReply(mbuf *request) +PPPStateMachine::SendEchoReply(struct mbuf *request) { - lcp_packet *reply = mtod(request, lcp_packet*); + ppp_lcp_packet *reply = mtod(request, ppp_lcp_packet*); reply->code = PPP_ECHO_REPLY; // the request becomes a reply @@ -1478,7 +1519,7 @@ PPPStateMachine::BringHandlersUp() Interface()->Report(PPP_CONNECTION_REPORT, PPP_REPORT_UP_SUCCESSFUL, NULL, 0); } else - NewPhase(Phase() + 1); + NewPhase((PPP_PHASE) (Phase() + 1)); } } @@ -1539,7 +1580,7 @@ PPPStateMachine::DownEncapsulators() for(; encapsulator_handler; encapsulator_handler = encapsulator_handler->Next()) if(encapsulator_handler->IsEnabled()) - encapsualtor_handler->Down(); + encapsulator_handler->Down(); } diff --git a/src/tests/kits/net/ppp/src/KPPPUtils.cpp b/src/tests/kits/net/ppp/src/KPPPUtils.cpp index e15289f41f..24c00e7d46 100644 --- a/src/tests/kits/net/ppp/src/KPPPUtils.cpp +++ b/src/tests/kits/net/ppp/src/KPPPUtils.cpp @@ -5,10 +5,10 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- -#include "KPPPUtils.h" - #include +#include "KPPPUtils.h" + // These are very simple send/receive_data functions with a timeout // and there is a race condition beween has_data() and send/receive_data(). @@ -17,9 +17,7 @@ status_t send_data_with_timeout(thread_id thread, int32 code, void *buffer, size_t buffer_size, uint32 timeout) { - int32 tries; - - for(tries = 0; tries < timeout; tries++) { + for(uint32 tries = 0; tries < timeout; tries++) { if(has_data(thread)) snooze(1000); } @@ -35,9 +33,7 @@ status_t receive_data_with_timeout(thread_id *sender, int32 *code, void *buffer, size_t buffer_size, uint32 timeout) { - int32 tries; - - for(tries = 0; tries < timeout; tries++) { + for(uint32 tries = 0; tries < timeout; tries++) { if(!has_data(find_thread(NULL))) { snooze(1000); continue; diff --git a/src/tests/kits/net/ppp/src/settings_tools.cpp b/src/tests/kits/net/ppp/src/settings_tools.cpp index fa8102ac7d..f7712936ff 100644 --- a/src/tests/kits/net/ppp/src/settings_tools.cpp +++ b/src/tests/kits/net/ppp/src/settings_tools.cpp @@ -5,10 +5,12 @@ // Copyright (c) 2003 Waldemar Kornewald, Waldemar.Kornewald@web.de //--------------------------------------------------------------------- +#include + #include "settings_tools.h" #include -#include +#include static void copy_parameter(const driver_parameter *from, driver_parameter *to); @@ -17,7 +19,7 @@ static void free_driver_parameter(driver_parameter *p); driver_settings *dup_driver_settings(const driver_settings *dup) { - if(!settings) + if(!dup) return NULL; // we got a NULL pointer, so return nothing driver_settings *ret = (driver_settings*) malloc(sizeof(driver_settings)); @@ -37,7 +39,7 @@ static void copy_parameter(const driver_parameter *from, driver_parameter *to) to->name = strdup(from->name); to->value_count = from->value_count; - to->values = (char**) malloc(values * sizeof(char*)); + to->values = (char**) malloc(to->value_count * sizeof(char*)); for(int32 i=0; i < to->value_count; i++) to->values[i] = strdup(from->values[i]); @@ -77,38 +79,25 @@ void free_driver_parameter(driver_parameter *p) } -void add_settings(const driver_settings *from, driver_settings *to) -{ - if(!from || !to) - return; - - to->parameters = realloc(to->parameters, - (to->parameter_count + from->parameter_count) * sizeof(driver_parameter)); - - for(int32 i=0; i < from->parameter_count; i++) - copy_parameters(&from->parameters[i], &to->parameters[to->parameter_count++]); -} - - -bool get_boolean_value(const char *string, bool unknownValue) +bool get_string_value(const char *string, bool unknownValue) { if(!string) return unknownValue; - if (!strcmp(boolean, "1") - || !strcasecmp(boolean, "true") - || !strcasecmp(boolean, "yes") - || !strcasecmp(boolean, "on") - || !strcasecmp(boolean, "enable") - || !strcasecmp(boolean, "enabled")) + if (!strcmp(string, "1") + || !strcasecmp(string, "true") + || !strcasecmp(string, "yes") + || !strcasecmp(string, "on") + || !strcasecmp(string, "enable") + || !strcasecmp(string, "enabled")) return true; - if (!strcmp(boolean, "0") - || !strcasecmp(boolean, "false") - || !strcasecmp(boolean, "no") - || !strcasecmp(boolean, "off") - || !strcasecmp(boolean, "disable") - || !strcasecmp(boolean, "disabled")) + if (!strcmp(string, "0") + || !strcasecmp(string, "false") + || !strcasecmp(string, "no") + || !strcasecmp(string, "off") + || !strcasecmp(string, "disable") + || !strcasecmp(string, "disabled")) return false; // no correct value has been found => return default value diff --git a/src/tests/kits/net/ppp/src/settings_tools.h b/src/tests/kits/net/ppp/src/settings_tools.h index 6937389e74..b25c084cd7 100644 --- a/src/tests/kits/net/ppp/src/settings_tools.h +++ b/src/tests/kits/net/ppp/src/settings_tools.h @@ -17,19 +17,10 @@ struct driver_parameter; driver_settings *dup_driver_settings(const driver_settings *settings); void free_driver_settings(driver_settings *settings); -void add_settings(const driver_settings *from, driver_settings *to); -void add_settings(const driver_settings *from, driver_parameter *to) - { add_settings(from, (driver_settings*) &to->parameter_count); } -void add_parameter(const driver_parameter *from, driver_settings *to) - { add_settings((driver_settings*) &from->parameter_count, to); } -void add_parameter(const driver_parameter *from, driver_parameter *to) - { add_settings((driver_settings*) &from->parameter_count, - (driver_settings*) &to->parameter_count); } - bool get_boolean_value(const char *string, bool unknownValue); const char *get_settings_value(const char *name, const driver_settings *settings); const char *get_parameter_value(const char *name, const driver_parameter *parameters) - { get_settings_value(name, (driver_settings*) ¶meter->parameter_count); } + { return get_settings_value(name, (driver_settings*) ¶meters->parameter_count); } #endif