haiku.git

/*
 * Copyright 2003-2004, Haiku Inc.
 * Distributed under the terms of the MIT License.
 */

#ifndef _K_PPP_PROTOCOL__H
#define _K_PPP_PROTOCOL__H

#include <KPPPDefs.h>
#include <KPPPLayer.h>

class KPPPInterface;
class KPPPOptionHandler;


class KPPPProtocol : public KPPPLayer {
	protected:
		// KPPPProtocol must be subclassed
		KPPPProtocol(const char *name, ppp_phase activationPhase,
			uint16 protocolNumber, ppp_level level, int32 addressFamily,
			uint32 overhead, KPPPInterface& interface,
			driver_parameter *settings, int32 flags = PPP_NO_FLAGS,
			const char *type = NULL, KPPPOptionHandler *optionHandler = NULL);

	public:
		virtual ~KPPPProtocol();
		
		virtual void Uninit();
		
		//!	Returns the interface that owns this protocol.
		KPPPInterface& Interface() const
			{ return fInterface; }
		//!	Returns the protocol's settings.
		driver_parameter *Settings() const
			{ return fSettings; }
		
		//!	The activation phase is the phase when Up() should be called.
		ppp_phase ActivationPhase() const
			{ return fActivationPhase; }
		
		//!	The protocol number.
		uint16 ProtocolNumber() const
			{ return fProtocolNumber; }
		//!	The address family. Negative values and values > 0xFF are ignored.
		int32 AddressFamily() const
			{ return fAddressFamily; }
		//!	This protocol's flags.
		int32 Flags() const
			{ return fFlags; }
		//!	Which side this protocol works for.
		ppp_side Side() const
			{ return fSide; }
				
		//!	Protocol type. May be NULL.
		const char *Type() const
			{ return fType; }
		//!	The (optional) KPPPOptionHandler object of this protocol.
		KPPPOptionHandler *OptionHandler() const
			{ return fOptionHandler; }
		
		//!	Sets the next protocol in the list.
		void SetNextProtocol(KPPPProtocol *protocol)
			{ fNextProtocol = protocol; SetNext(protocol); }
		//!	Returns the next protocol in the list.
		KPPPProtocol *NextProtocol() const
			{ return fNextProtocol; }
		
		void SetEnabled(bool enabled = true);
		//!	Returns whether this protocol is enabled.
		bool IsEnabled() const
			{ return fEnabled; }
		
		//!	Returns whether an Up() is requested.
		bool IsUpRequested() const
			{ return fUpRequested; }
		
		virtual status_t Control(uint32 op, void *data, size_t length);
		virtual status_t StackControl(uint32 op, void *data);
			// called by netstack (forwarded by KPPPInterface)
		
		/*!	\brief Bring this protocol up.
			
			You must call \c UpStarted() from here.
		*/
		virtual bool Up() = 0;
		/*!	\brief Bring this protocol down.
			
			You must call DownStarted() from here. \n
			If ConnectOnDemand is supported check for ConnectOnDemand settings change.
		*/
		virtual bool Down() = 0;
		//!	Is this protocol up?
		bool IsUp() const
			{ return fConnectionPhase == PPP_ESTABLISHED_PHASE; }
		//!	Is this protocol down?
		bool IsDown() const
			{ return fConnectionPhase == PPP_DOWN_PHASE; }
		//!	Is this protocol going up?
		bool IsGoingUp() const
			{ return fConnectionPhase == PPP_ESTABLISHMENT_PHASE; }
		//!	Is this protocol going down?
		bool IsGoingDown() const
			{ return fConnectionPhase == PPP_TERMINATION_PHASE; }
		
		virtual bool IsAllowedToSend() const;
		
		//!	Encapsulate the packet with the given protocol number.
		virtual status_t Send(net_buffer *packet, uint16 protocolNumber) = 0;
		//!	Receive a packet with the given protocol number.
		virtual status_t Receive(net_buffer *packet, uint16 protocolNumber) = 0;

	protected:
		//!	\brief Requests Up() to be called.
		void SetUpRequested(bool requested = true)
			{ fUpRequested = requested; }
		
		// Report that we are going up/down
		// (from now on, the Up() process can be aborted).
		void UpStarted();
		void DownStarted();
		
		// report up/down events
		void UpFailedEvent();
		void UpEvent();
		void DownEvent();

	protected:
		ppp_side fSide;

	private:
		ppp_phase fActivationPhase;
		uint16 fProtocolNumber;
		int32 fAddressFamily;
		KPPPInterface& fInterface;
		driver_parameter *fSettings;
		int32 fFlags;
		char *fType;
		KPPPOptionHandler *fOptionHandler;
		
		KPPPProtocol *fNextProtocol;
		bool fEnabled;
		bool fUpRequested;
		ppp_phase fConnectionPhase;
};


#endif