/*
 * Copyright 2003-2007, Waldemar Kornewald <wkornew@gmx.net>
 * Distributed under the terms of the MIT License.
 */

/*!     \class KPPPStateMachine
        \brief PPP state machine belonging to the LCP protocol

        The state machine is responsible for handling events and state changes.

        \sa KPPPLCP
*/

#include <OS.h>

#include <KPPPInterface.h>
#include <KPPPConfigurePacket.h>
#include <KPPPDevice.h>
#include <KPPPLCPExtension.h>
#include <KPPPOptionHandler.h>

#include <KPPPUtils.h>

#include <net/if.h>
#include <arpa/inet.h>

#include <ByteOrder.h>
#include <net_buffer.h>
#include <NetBufferUtilities.h>

extern net_buffer_module_info *gBufferModule;

static const bigtime_t kPPPStateMachineTimeout = 3000000;
        // 3 seconds


//!     Constructor.
KPPPStateMachine::KPPPStateMachine(KPPPInterface& interface)
        : fInterface(interface),
        fLCP(interface.LCP()),
        fState(PPP_INITIAL_STATE),
        fPhase(PPP_DOWN_PHASE),
        fID(system_time() & 0xFF),
        fMagicNumber(0),
        fLastConnectionReportCode(PPP_REPORT_DOWN_SUCCESSFUL),
        fLocalAuthenticationStatus(PPP_NOT_AUTHENTICATED),
        fPeerAuthenticationStatus(PPP_NOT_AUTHENTICATED),
        fLocalAuthenticationName(NULL),
        fPeerAuthenticationName(NULL),
        fMaxRequest(10),
        fMaxTerminate(2),
        fMaxNak(5),
        fRequestID(0),
        fTerminateID(0),
        fEchoID(0),
        fNextTimeout(0),
        fLock(mutex())
{
        mutex_init(&fLock, "KPPPStateMachine");
}


//!     Destructor. Frees loaded memory.
KPPPStateMachine::~KPPPStateMachine()
{
        free(fLocalAuthenticationName);
        free(fPeerAuthenticationName);
}


//!     Creates an ID for the next LCP packet.
uint8
KPPPStateMachine::NextID()
{
        return (uint8) atomic_add(&fID, 1);
}


/*!     \brief Changes the current state.

        Remember: NewState() must always be called \e after IllegalEvent() because
        IllegalEvent() also looks at the current state.
*/
void
KPPPStateMachine::NewState(ppp_state next)
{
        TRACE("KPPPSM: NewState(%d) state=%d\n", next, State());

        // maybe we do not need the timer anymore
        if (next < PPP_CLOSING_STATE || next == PPP_OPENED_STATE)
                fNextTimeout = 0;

        if (State() == PPP_OPENED_STATE && next != State())
                ResetLCPHandlers();

        fState = next;
}


/*!     \brief Changes the current phase.

        This method is responsible for setting the \c if_flags and sending the
        \c PPP_REPORT_UP_SUCCESSFUL report message.
*/
void
KPPPStateMachine::NewPhase(ppp_phase next)
{
#if DEBUG
        if (next <= PPP_ESTABLISHMENT_PHASE || next == PPP_ESTABLISHED_PHASE)
                TRACE("KPPPSM: NewPhase(%d) phase=%d\n", next, Phase());
#endif

        // there is nothing after established phase and nothing before down phase
        if (next > PPP_ESTABLISHED_PHASE)
                next = PPP_ESTABLISHED_PHASE;
        else if (next < PPP_DOWN_PHASE)
                next = PPP_DOWN_PHASE;

        // Report a down event to parent if we are not usable anymore.
        // The report threads get their notification later.
        if (Phase() == PPP_ESTABLISHED_PHASE && next != Phase()) {
                if (Interface().Ifnet()) {
                        // Interface().Ifnet()->flags &= ~IFF_RUNNING;
                        Interface().Ifnet()->flags &= ~IFF_UP;
                }

                if (Interface().Parent())
                        Interface().Parent()->StateMachine().DownEvent(Interface());
        }

        fPhase = next;

        if (Phase() == PPP_ESTABLISHED_PHASE) {
                Interface().fConnectedSince = system_time();

                if (Interface().Ifnet())
                        Interface().Ifnet()->flags |= IFF_UP;// | IFF_RUNNING;

                Interface().fConnectAttempt = 0;
                        // when we Reconnect() this becomes 1 (the first connection attempt)
                send_data_with_timeout(Interface().fReconnectThread, 0, NULL, 0, 200);
                        // abort possible reconnect attempt
                fLastConnectionReportCode = PPP_REPORT_UP_SUCCESSFUL;
                Interface().Report(PPP_CONNECTION_REPORT, PPP_REPORT_UP_SUCCESSFUL,
                        &fInterface.fID, sizeof(ppp_interface_id));
        }
}


// public actions

//!     Reconfigures the state machine. This initiates a new configure request handshake.
bool
KPPPStateMachine::Reconfigure()
{
        TRACE("KPPPSM: Reconfigure() state=%d phase=%d\n", State(), Phase());

        if (State() < PPP_REQ_SENT_STATE)
                return false;

        NewState(PPP_REQ_SENT_STATE);
        NewPhase(PPP_ESTABLISHMENT_PHASE);
                // indicates to handlers that we are reconfiguring

        DownProtocols();
        ResetLCPHandlers();

        return SendConfigureRequest();
}


//!     Sends an echo request packet.
bool
KPPPStateMachine::SendEchoRequest()
{
        TRACE("KPPPSM: SendEchoRequest() state=%d phase=%d\n", State(), Phase());

        if (State() != PPP_OPENED_STATE)
                return false;

        net_buffer *packet = gBufferModule->create(256);
        if (packet == NULL)
                return false;

        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;
}


//!     Sends a discard request packet.
bool
KPPPStateMachine::SendDiscardRequest()
{
        TRACE("KPPPSM: SendDiscardRequest() state=%d phase=%d\n", State(), Phase());

        net_buffer *packet = gBufferModule->create(256);
        if (packet == NULL)
                return false;

        void *data;
        status_t status = gBufferModule->append_size(packet, 1492, &data);
        if (status == B_OK && data == NULL) {
                gBufferModule->free(packet);
                return false;
        }

                // discard requests are at least eight bytes long
        // 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;
}


// authentication events

/*!     Notification that local authentication is requested.

        NOTE: This must be called \e after \c KPPPProtocol::Up().
*/
void
KPPPStateMachine::LocalAuthenticationRequested()
{
        TRACE("KPPPSM: LocalAuthenticationRequested() state=%d phase=%d\n",
                State(), Phase());

        fLastConnectionReportCode = PPP_REPORT_AUTHENTICATION_REQUESTED;
        Interface().Report(PPP_CONNECTION_REPORT,
                PPP_REPORT_AUTHENTICATION_REQUESTED, &fInterface.fID,
                sizeof(ppp_interface_id));

        fLocalAuthenticationStatus = PPP_AUTHENTICATING;
        free(fLocalAuthenticationName);
        fLocalAuthenticationName = NULL;
}


/*!     \brief Notification that local authentication was accepted.

        NOTE: This must be called \e before \c UpEvent().

        \param name The username/login that was accepted.
*/
void
KPPPStateMachine::LocalAuthenticationAccepted(const char *name)
{
        TRACE("KPPPSM: LocalAuthenticationAccepted() state=%d phase=%d\n",
                State(), Phase());

        fLocalAuthenticationStatus = PPP_AUTHENTICATION_SUCCESSFUL;
        free(fLocalAuthenticationName);
        if (name)
                fLocalAuthenticationName = strdup(name);
        else
                fLocalAuthenticationName = NULL;
}


/*!     \brief Notification that local authentication was denied.

        NOTE: This must be called \e before \c UpFailedEvent().

        \param name The username/login that was denied.
*/
void
KPPPStateMachine::LocalAuthenticationDenied(const char *name)
{
        TRACE("KPPPSM: LocalAuthenticationDenied() state=%d phase=%d\n", State(), Phase());

        fLocalAuthenticationStatus = PPP_AUTHENTICATION_FAILED;
        free(fLocalAuthenticationName);
        if (name)
                fLocalAuthenticationName = strdup(name);
        else
                fLocalAuthenticationName = NULL;

        // the report will be sent in DownEvent()
}


//!     Notification that peer authentication is requested.
void
KPPPStateMachine::PeerAuthenticationRequested()
{
        TRACE("KPPPSM: PeerAuthenticationRequested() state=%d phase=%d\n",
                State(), Phase());

        fLastConnectionReportCode = PPP_REPORT_AUTHENTICATION_REQUESTED;
        Interface().Report(PPP_CONNECTION_REPORT,
                PPP_REPORT_AUTHENTICATION_REQUESTED, &fInterface.fID,
                sizeof(ppp_interface_id));

        fPeerAuthenticationStatus = PPP_AUTHENTICATING;
        free(fPeerAuthenticationName);
        fPeerAuthenticationName = NULL;
}


/*!     \brief Notification that peer authentication was accepted.

        NOTE: This must be called \e before \c UpEvent().

        \param name The username/login that was accepted.
*/
void
KPPPStateMachine::PeerAuthenticationAccepted(const char *name)
{
        TRACE("KPPPSM: PeerAuthenticationAccepted() state=%d phase=%d\n",
                State(), Phase());

        fPeerAuthenticationStatus = PPP_AUTHENTICATION_SUCCESSFUL;
        free(fPeerAuthenticationName);
        if (name)
                fPeerAuthenticationName = strdup(name);
        else
                fPeerAuthenticationName = NULL;
}


/*!     \brief Notification that peer authentication was denied.

        NOTE: This must be called \e before \c UpFailedEvent().

        \param name The username/login that was denied.
*/
void
KPPPStateMachine::PeerAuthenticationDenied(const char *name)
{
        TRACE("KPPPSM: PeerAuthenticationDenied() state=%d phase=%d\n", State(), Phase());

        fPeerAuthenticationStatus = PPP_AUTHENTICATION_FAILED;
        free(fPeerAuthenticationName);
        if (name)
                fPeerAuthenticationName = strdup(name);
        else
                fPeerAuthenticationName = NULL;

        CloseEvent();

        // the report will be sent in DownEvent()
}


//!     Notification that a child interface failed to go up.
void
KPPPStateMachine::UpFailedEvent(KPPPInterface& interface)
{
        TRACE("KPPPSM: UpFailedEvent(interface) state=%d phase=%d\n", State(), Phase());

        // TODO:
        // log that an interface did not go up
}


//!     Notification that a child interface went up successfully.
void
KPPPStateMachine::UpEvent(KPPPInterface& interface)
{
        TRACE("KPPPSM: UpEvent(interface) state=%d phase=%d\n", State(), Phase());

        if (Phase() <= PPP_TERMINATION_PHASE) {
                interface.StateMachine().CloseEvent();
                return;
        }

        Interface().CalculateBaudRate();

        if (Phase() == PPP_ESTABLISHMENT_PHASE) {
                // this is the first interface that went up
                Interface().SetMRU(interface.MRU());
                ThisLayerUp();
        } else if (Interface().MRU() > interface.MRU())
                Interface().SetMRU(interface.MRU());
                        // MRU should always be the smallest value of all children

        NewState(PPP_OPENED_STATE);
}


//!     Notification that a child interface went down.
void
KPPPStateMachine::DownEvent(KPPPInterface& interface)
{
        TRACE("KPPPSM: DownEvent(interface) state=%d phase=%d\n", State(), Phase());

        uint32 MRU = 0;
                // the new MRU

        Interface().CalculateBaudRate();

        // when all children are down we should not be running
        if (Interface().IsMultilink() && !Interface().Parent()) {
                uint32 count = 0;
                KPPPInterface *child;
                for (int32 index = 0; index < Interface().CountChildren(); index++) {
                        child = Interface().ChildAt(index);

                        if (child && child->IsUp()) {
                                // set MRU to the smallest value of all children
                                if (MRU == 0)
                                        MRU = child->MRU();
                                else if (MRU > child->MRU())
                                        MRU = child->MRU();

                                ++count;
                        }
                }

                if (MRU == 0)
                        Interface().SetMRU(1500);
                else
                        Interface().SetMRU(MRU);

                if (count == 0)
                        DownEvent();
        }
}


/*!     \brief Notification that a protocol failed to go up.

        NOTE FOR AUTHENTICATORS: This \e must be called \e after an authentication
        notification method like \c LocalAuthenticationFailed().
*/
void
KPPPStateMachine::UpFailedEvent(KPPPProtocol *protocol)
{
        TRACE("KPPPSM: UpFailedEvent(protocol) state=%d phase=%d\n", State(), Phase());

        if ((protocol->Flags() & PPP_NOT_IMPORTANT) == 0) {
                if (Interface().Mode() == PPP_CLIENT_MODE) {
                        // pretend we lost connection
                        if (Interface().IsMultilink() && !Interface().Parent())
                                for (int32 index = 0; index < Interface().CountChildren(); index++)
                                        Interface().ChildAt(index)->StateMachine().CloseEvent();
                        else if (Interface().Device())
                                Interface().Device()->Down();
                        else
                                CloseEvent();
                                        // just to be on the secure side ;)
                } else
                        CloseEvent();
        }
}


/*!     \brief Notification that a protocol went up successfully.

        NOTE FOR AUTHENTICATORS: This \e must be called \e after an authentication
        notification method like \c LocalAuthenticationSuccessful().
*/
void
KPPPStateMachine::UpEvent(KPPPProtocol *protocol)
{
        TRACE("KPPPSM: UpEvent(protocol) state=%d phase=%d\n", State(), Phase());

        if (Phase() >= PPP_ESTABLISHMENT_PHASE)
                BringProtocolsUp();
}


/*!     \brief Notification that a protocol went down.

        NOTE FOR AUTHENTICATORS: This \e must be called \e after an authentication
        notification method like \c LocalAuthenticationFailed().
*/
void
KPPPStateMachine::DownEvent(KPPPProtocol *protocol)
{
        TRACE("KPPPSM: DownEvent(protocol) state=%d phase=%d\n", State(), Phase());
}


/*!     \brief Notification that the device entered establishment phase.

        We can use \c Device::Down() to abort establishment until \c UpEvent() is called.

        \return
                - \c true: We are waiting for an \c UpEvent()
                - \c false: The device should immediately abort its attempt to connect.
*/
bool
KPPPStateMachine::TLSNotify()
{
        TRACE("KPPPSM: TLSNotify() state=%d phase=%d\n", State(), Phase());

        if (State() == PPP_STARTING_STATE) {
                        if (Phase() == PPP_DOWN_PHASE)
                                NewPhase(PPP_ESTABLISHMENT_PHASE);
                                        // this says that the device is going up
                        return true;
        }

        return false;
}


/*!     \brief Notification that the device entered termination phase.

        A \c Device::Up() should wait until the device went down.

        \return
                - \c true: Continue terminating.
                - \c false: We want to stay connected, though we called \c Device::Down().
*/
bool
KPPPStateMachine::TLFNotify()
{
        TRACE("KPPPSM: TLFNotify() state=%d phase=%d\n", State(), Phase());

        NewPhase(PPP_TERMINATION_PHASE);
                // tell DownEvent() that it may create a connection-lost-report

        return true;
}


//!     Notification that the device failed to go up.
void
KPPPStateMachine::UpFailedEvent()
{
        TRACE("KPPPSM: UpFailedEvent() state=%d phase=%d\n", State(), Phase());

        switch (State()) {
                case PPP_STARTING_STATE:
                        fLastConnectionReportCode = PPP_REPORT_DEVICE_UP_FAILED;
                        Interface().Report(PPP_CONNECTION_REPORT, PPP_REPORT_DEVICE_UP_FAILED,
                                &fInterface.fID, sizeof(ppp_interface_id));
                        if (Interface().Parent())
                                Interface().Parent()->StateMachine().UpFailedEvent(Interface());

                        NewPhase(PPP_DOWN_PHASE);
                                // tell DownEvent() that it should not create a connection-lost-report
                        DownEvent();
                        break;

                default:
                        IllegalEvent(PPP_UP_FAILED_EVENT);
        }
}


//!     Notification that the device went up successfully.
void
KPPPStateMachine::UpEvent()
{
        TRACE("KPPPSM: UpEvent() state=%d phase=%d\n", State(), Phase());

        // This call is public, thus, it might not only be called by the device.
        // We must recognize these attempts to fool us and handle them correctly.

        if (!Interface().Device() || !Interface().Device()->IsUp())
                return;
                        // it is not our device that went up...

        Interface().CalculateBaudRate();

        switch (State()) {
                case PPP_INITIAL_STATE:
                        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
                                IllegalEvent(PPP_UP_EVENT);
                                NewState(PPP_CLOSED_STATE);
                                ThisLayerFinished();

                                return;
                        }

                        // TODO: handle server-up! (maybe already done correctly)
                        NewState(PPP_REQ_SENT_STATE);
                        InitializeRestartCount();
                        SendConfigureRequest();
                        break;

                case PPP_STARTING_STATE:
                        // we must have called TLS() which sets establishment phase
                        if (Phase() != PPP_ESTABLISHMENT_PHASE) {
                                // there must be a BUG in the device add-on or someone is trying to
                                // fool us (UpEvent() is public) as we did not request the device
                                // to go up
                                IllegalEvent(PPP_UP_EVENT);
                                NewState(PPP_CLOSED_STATE);
                                ThisLayerFinished();
                                break;
                        }

                        NewState(PPP_REQ_SENT_STATE);
                        InitializeRestartCount();
                        SendConfigureRequest();
                        break;

                default:
                        IllegalEvent(PPP_UP_EVENT);
        }
}


/*!     \brief Notification that the device went down.

        If this is called without a prior \c TLFNotify() the state machine will assume
        that we lost our connection.
*/
void
KPPPStateMachine::DownEvent()
{
        TRACE("KPPPSM: DownEvent() state=%d phase=%d\n", State(), Phase());

        if (Interface().Device() && Interface().Device()->IsUp())
                return;
                        // it is not our device that went down...

        Interface().CalculateBaudRate();

        // reset IdleSince
        Interface().fIdleSince = 0;

        switch (State()) {
                // XXX: this does not belong to the standard, but may happen in our
                // implementation
                case PPP_STARTING_STATE:
                        break;

                case PPP_CLOSED_STATE:
                case PPP_CLOSING_STATE:
                        NewState(PPP_INITIAL_STATE);
                        break;

                case PPP_STOPPED_STATE:
                        // The RFC says we should reconnect, but our implementation
                        // will only do this if auto-reconnect is enabled (only clients).
                        NewState(PPP_STARTING_STATE);
                        break;

                case PPP_STOPPING_STATE:
                case PPP_REQ_SENT_STATE:
                case PPP_ACK_RCVD_STATE:
                case PPP_ACK_SENT_STATE:
                case PPP_OPENED_STATE:
                        NewState(PPP_STARTING_STATE);
                        break;

                default:
                        IllegalEvent(PPP_DOWN_EVENT);
        }

        ppp_phase oldPhase = Phase();
        NewPhase(PPP_DOWN_PHASE);

        DownProtocols();

        // maybe we need to reconnect
        if (State() == PPP_STARTING_STATE) {
                bool deleteInterface = false, retry = false;

                // we do not try to reconnect if authentication failed
                if (fLocalAuthenticationStatus == PPP_AUTHENTICATION_FAILED
                                || fLocalAuthenticationStatus == PPP_AUTHENTICATING
                                || fPeerAuthenticationStatus == PPP_AUTHENTICATION_FAILED
                                || fPeerAuthenticationStatus == PPP_AUTHENTICATING) {
                        fLastConnectionReportCode = PPP_REPORT_AUTHENTICATION_FAILED;
                        Interface().Report(PPP_CONNECTION_REPORT,
                                PPP_REPORT_AUTHENTICATION_FAILED, &fInterface.fID,
                                sizeof(ppp_interface_id));
                        deleteInterface = true;
                } else {
                        if (Interface().fConnectAttempt > (Interface().fConnectRetriesLimit + 1))
                                deleteInterface = true;

                        if (oldPhase == PPP_DOWN_PHASE) {
                                // failed to bring device up (UpFailedEvent() was called)
                                retry = true;
                                        // this may have been overridden by "deleteInterface = true"
                        } else {
                                // lost connection (TLFNotify() was called)
                                fLastConnectionReportCode = PPP_REPORT_CONNECTION_LOST;
                                Interface().Report(PPP_CONNECTION_REPORT, PPP_REPORT_CONNECTION_LOST,
                                        &fInterface.fID, sizeof(ppp_interface_id));
                        }
                }

                if (Interface().Parent())
                        Interface().Parent()->StateMachine().UpFailedEvent(Interface());

                NewState(PPP_INITIAL_STATE);

                if (!deleteInterface && (retry || Interface().DoesAutoReconnect()))
                        Interface().Reconnect(Interface().ReconnectDelay());
                else
                        Interface().Delete();
        } else {
                fLastConnectionReportCode = PPP_REPORT_DOWN_SUCCESSFUL;
                Interface().Report(PPP_CONNECTION_REPORT, PPP_REPORT_DOWN_SUCCESSFUL,
                        &fInterface.fID, sizeof(ppp_interface_id));
                Interface().Delete();
        }

        fLocalAuthenticationStatus = PPP_NOT_AUTHENTICATED;
        fPeerAuthenticationStatus = PPP_NOT_AUTHENTICATED;
}


// private events
void
KPPPStateMachine::OpenEvent()
{
        TRACE("KPPPSM: OpenEvent() state=%d phase=%d\n", State(), Phase());

        // reset all handlers
        if (Phase() != PPP_ESTABLISHED_PHASE) {
                DownProtocols();
                ResetLCPHandlers();
        }

        switch (State()) {
                case PPP_INITIAL_STATE:
                        fLastConnectionReportCode = PPP_REPORT_GOING_UP;
                        Interface().Report(PPP_CONNECTION_REPORT, PPP_REPORT_GOING_UP,
                                        &fInterface.fID, sizeof(ppp_interface_id));

                        if (Interface().Mode() == PPP_SERVER_MODE) {
                                NewPhase(PPP_ESTABLISHMENT_PHASE);

                                if (Interface().Device() && !Interface().Device()->Up()) {
                                        Interface().Device()->UpFailedEvent();
                                        return;
                                }
                        } else
                                NewState(PPP_STARTING_STATE);

                        if (Interface().fAskBeforeConnecting == false)
                                ContinueOpenEvent();
                        break;

                case PPP_CLOSED_STATE:
                        if (Phase() == PPP_DOWN_PHASE) {
                                // the device is already going down
                                return;
                        }

                        NewState(PPP_REQ_SENT_STATE);
                        NewPhase(PPP_ESTABLISHMENT_PHASE);
                        InitializeRestartCount();
                        SendConfigureRequest();
                        break;

                case PPP_CLOSING_STATE:
                        NewState(PPP_STOPPING_STATE);
                        break;

                default:
                        ;
        }
}


void
KPPPStateMachine::ContinueOpenEvent()
{
        TRACE("KPPPSM: ContinueOpenEvent() state=%d phase=%d\n", State(), Phase());

        if (Interface().IsMultilink() && !Interface().Parent()) {
                NewPhase(PPP_ESTABLISHMENT_PHASE);
                for (int32 index = 0; index < Interface().CountChildren(); index++)
                        if (Interface().ChildAt(index)->Mode() == Interface().Mode())
                                Interface().ChildAt(index)->StateMachine().OpenEvent();
        } else
                ThisLayerStarted();
}


void
KPPPStateMachine::CloseEvent()
{
        TRACE("KPPPSM: CloseEvent() state=%d phase=%d\n", State(), Phase());

        if (Interface().IsMultilink() && !Interface().Parent()) {
                NewState(PPP_INITIAL_STATE);

                if (Phase() != PPP_DOWN_PHASE)
                        NewPhase(PPP_TERMINATION_PHASE);

                ThisLayerDown();

                for (int32 index = 0; index < Interface().CountChildren(); index++)
                        Interface().ChildAt(index)->StateMachine().CloseEvent();

                return;
        }

        switch (State()) {
                case PPP_OPENED_STATE:
                case PPP_REQ_SENT_STATE:
                case PPP_ACK_RCVD_STATE:
                case PPP_ACK_SENT_STATE:
                        NewState(PPP_CLOSING_STATE);
                        NewPhase(PPP_TERMINATION_PHASE);
                                // indicates to handlers that we are terminating
                        InitializeRestartCount();
                        if (State() == PPP_OPENED_STATE)
                                ThisLayerDown();
                        SendTerminateRequest();
                        break;

                case PPP_STARTING_STATE:
                        NewState(PPP_INITIAL_STATE);

                        // TLSNotify() will know that we were faster because we
                        // are in PPP_INITIAL_STATE now
                        if (Phase() == PPP_ESTABLISHMENT_PHASE) {
                                // the device is already up
                                NewPhase(PPP_DOWN_PHASE);
                                        // this says the following DownEvent() was not caused by
                                        // a connection fault
                                ThisLayerFinished();
                        }
                        break;

                case PPP_STOPPING_STATE:
                        NewState(PPP_CLOSING_STATE);
                        break;

                case PPP_STOPPED_STATE:
                        NewState(PPP_STOPPED_STATE);
                        break;

                default:
                        ;
        }
}


// timeout (restart counters are > 0)
void
KPPPStateMachine::TOGoodEvent()
{
        TRACE("KPPPSM: TOGoodEvent() state=%d phase=%d\n", State(), Phase());

        switch (State()) {
                case PPP_CLOSING_STATE:
                case PPP_STOPPING_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);
        }
}


// timeout (restart counters are <= 0)
void
KPPPStateMachine::TOBadEvent()
{
        TRACE("KPPPSM: TOBadEvent() state=%d phase=%d\n", State(), Phase());

        switch (State()) {
                case PPP_CLOSING_STATE:
                        NewState(PPP_CLOSED_STATE);
                        NewPhase(PPP_TERMINATION_PHASE);
                        ThisLayerFinished();
                        break;

                case PPP_STOPPING_STATE:
                case PPP_REQ_SENT_STATE:
                case PPP_ACK_RCVD_STATE:
                case PPP_ACK_SENT_STATE:
                        NewState(PPP_STOPPED_STATE);
                        NewPhase(PPP_TERMINATION_PHASE);
                        ThisLayerFinished();
                        break;

                default:
                        IllegalEvent(PPP_TO_BAD_EVENT);
        }
}


// receive configure request (acceptable request)
void
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);
                        gBufferModule->free(packet);
                        break;

                case PPP_CLOSED_STATE:
                        TRACE("%s::%s: PPP_CLOSED_STATE\n", __FILE__, __func__);
                        SendTerminateAck();
                        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()?
                        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
                        ThisLayerDown();
                        SendConfigureRequest();
                        SendConfigureAck(packet);
                        break;

                default:
                        TRACE("free peer's ppp request packet\n");
                        gBufferModule->free(packet);
        }
}


// receive configure request (unacceptable request)
void
KPPPStateMachine::RCRBadEvent(net_buffer *nak, net_buffer *reject)
{
        TRACE("KPPPSM: RCRBadEvent() state=%d phase=%d\n", State(), Phase());

        uint16 lenNak = 0;
        uint16 lenReject = 0;

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RCR_BAD_EVENT);
                        break;

                case PPP_CLOSED_STATE:
                        SendTerminateAck();
                        break;

                case PPP_STOPPED_STATE:
                        // irc,scr,scn/6
                        // XXX: should we do nothing and wait for DownEvent()?
                        break;

                case PPP_OPENED_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        NewPhase(PPP_ESTABLISHMENT_PHASE);
                                // indicates to handlers that we are reconfiguring
                        ThisLayerDown();
                        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_REQ_SENT_STATE:
                case PPP_ACK_RCVD_STATE:
                        if (nak) {
                                NetBufferHeaderReader<ppp_lcp_packet> nakBufferHeader(nak);
                                if (nakBufferHeader.Status() < B_OK)
                                        break;
                                ppp_lcp_packet &nakHeader = nakBufferHeader.Data();
                                lenNak = nakHeader.length;
                        }

                        if (reject) {
                                NetBufferHeaderReader<ppp_lcp_packet> rejectBufferHeader(reject);
                                if (rejectBufferHeader.Status() < B_OK)
                                        break;
                                ppp_lcp_packet &rejectHeader = rejectBufferHeader.Data();
                                lenReject = rejectHeader.length;
                        }

                        if (nak && lenNak > 3)
                                SendConfigureNak(nak);
                        else if (reject && lenReject > 3)
                                SendConfigureNak(reject);
                        return;
                        // prevents the nak/reject from being m_freem()'d

                default:
                        ;
        }

        if (nak)
                gBufferModule->free(nak);
        if (reject)
                gBufferModule->free(reject);
}


// receive configure ack
void
KPPPStateMachine::RCAEvent(net_buffer *packet)
{
        TRACE("KPPPSM: RCAEvent() 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();

        if (fRequestID != header.id) {
                // this packet is not a reply to our request

                // TODO:
                // log this event
                gBufferModule->free(packet);
                return;
        }

        // let the option handlers parse this ack
        KPPPConfigurePacket ack(packet);
        KPPPOptionHandler *optionHandler;
        for (int32 index = 0; index < LCP().CountOptionHandlers(); index++) {
                optionHandler = LCP().OptionHandlerAt(index);
                if (optionHandler->ParseAck(ack) != B_OK) {
                        gBufferModule->free(packet);
                        CloseEvent();
                        return;
                }
        }

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RCA_EVENT);
                        break;

                case PPP_CLOSED_STATE:
                case PPP_STOPPED_STATE:
                        SendTerminateAck();
                        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();
                        ThisLayerUp();
                        break;

                case PPP_OPENED_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        NewPhase(PPP_ESTABLISHMENT_PHASE);
                                // indicates to handlers that we are reconfiguring
                        ThisLayerDown();
                        SendConfigureRequest();
                        break;

                default:
                        ;
        }

        gBufferModule->free(packet);
}


// receive configure nak/reject
void
KPPPStateMachine::RCNEvent(net_buffer *packet)
{
        TRACE("KPPPSM: RCNEvent() 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();

        if (fRequestID != header.id) {
                // this packet is not a reply to our request

                // TODO:
                // log this event
                gBufferModule->free(packet);
                return;
        }

        // let the option handlers parse this nak/reject
        KPPPConfigurePacket nak_reject(packet);
        KPPPOptionHandler *optionHandler;
        for (int32 index = 0; index < LCP().CountOptionHandlers(); index++) {
                optionHandler = LCP().OptionHandlerAt(index);

                if (nak_reject.Code() == PPP_CONFIGURE_NAK) {
                        if (optionHandler->ParseNak(nak_reject) != B_OK) {
                                gBufferModule->free(packet);
                                CloseEvent();
                                return;
                        }
                } else if (nak_reject.Code() == PPP_CONFIGURE_REJECT) {
                        if (optionHandler->ParseReject(nak_reject) != B_OK) {
                                gBufferModule->free(packet);
                                CloseEvent();
                                return;
                        }
                }
        }

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RCN_EVENT);
                        break;

                case PPP_CLOSED_STATE:
                case PPP_STOPPED_STATE:
                        SendTerminateAck();
                        break;

                case PPP_REQ_SENT_STATE:
                case PPP_ACK_SENT_STATE:
                        InitializeRestartCount();

                case PPP_ACK_RCVD_STATE:
                        if (State() == PPP_ACK_RCVD_STATE)
                                NewState(PPP_REQ_SENT_STATE);
                        SendConfigureRequest();
                        break;

                case PPP_OPENED_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        NewPhase(PPP_ESTABLISHMENT_PHASE);
                                // indicates to handlers that we are reconfiguring
                        ThisLayerDown();
                        SendConfigureRequest();
                        break;

                default:
                        ;
        }

        gBufferModule->free(packet);
}


// receive terminate request
void
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 == header.id)
                fID -= 128;

        fLocalAuthenticationStatus = PPP_NOT_AUTHENTICATED;
        fPeerAuthenticationStatus = PPP_NOT_AUTHENTICATED;

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RTR_EVENT);
                        gBufferModule->free(packet);
                        break;

                case PPP_ACK_RCVD_STATE:
                case PPP_ACK_SENT_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        NewPhase(PPP_TERMINATION_PHASE);
                                // indicates to handlers that we are terminating
                        SendTerminateAck(packet);
                        break;

                case PPP_OPENED_STATE:
                        NewState(PPP_STOPPING_STATE);
                        NewPhase(PPP_TERMINATION_PHASE);
                                // indicates to handlers that we are terminating
                        ZeroRestartCount();
                        ThisLayerDown();
                        SendTerminateAck(packet);
                        break;

                default:
                        NewPhase(PPP_TERMINATION_PHASE);
                                // indicates to handlers that we are terminating
                        SendTerminateAck(packet);
        }
}


// receive terminate ack
void
KPPPStateMachine::RTAEvent(net_buffer *packet)
{
        TRACE("KPPPSM: RTAEvent() 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();

        if (fTerminateID != header.id) {
                // this packet is not a reply to our request

                // TODO:
                // log this event
                gBufferModule->free(packet);
                return;
        }

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RTA_EVENT);
                        break;

                case PPP_CLOSING_STATE:
                        NewState(PPP_CLOSED_STATE);
                        ThisLayerFinished();
                        break;

                case PPP_STOPPING_STATE:
                        NewState(PPP_STOPPED_STATE);
                        ThisLayerFinished();
                        break;

                case PPP_ACK_RCVD_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        break;

                case PPP_OPENED_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        NewPhase(PPP_ESTABLISHMENT_PHASE);
                                // indicates to handlers that we are reconfiguring
                        ThisLayerDown();
                        SendConfigureRequest();
                        break;

                default:
                        ;
        }

        gBufferModule->free(packet);
}


// receive unknown code
void
KPPPStateMachine::RUCEvent(net_buffer *packet, uint16 protocolNumber,
        uint8 code)
{
        TRACE("KPPPSM: RUCEvent() state=%d phase=%d\n", State(), Phase());

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RUC_EVENT);
                        gBufferModule->free(packet);
                        break;

                default:
                        SendCodeReject(packet, protocolNumber, code);
        }
}


// receive code/protocol reject (acceptable such as IPX reject)
void
KPPPStateMachine::RXJGoodEvent(net_buffer *packet)
{
        TRACE("KPPPSM: RXJGoodEvent() state=%d phase=%d\n", State(), Phase());

        // This method does not m_freem(packet) because the acceptable rejects are
        // also passed to the parent. RXJEvent() will m_freem(packet) when needed.

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RXJ_GOOD_EVENT);
                        break;

                case PPP_ACK_RCVD_STATE:
                        NewState(PPP_REQ_SENT_STATE);
                        break;

                default:
                        ;
        }
}


// receive code/protocol reject (catastrophic such as LCP reject)
void
KPPPStateMachine::RXJBadEvent(net_buffer *packet)
{
        TRACE("KPPPSM: RXJBadEvent() state=%d phase=%d\n", State(), Phase());

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RXJ_BAD_EVENT);
                        break;

                case PPP_CLOSING_STATE:
                        NewState(PPP_CLOSED_STATE);

                case PPP_CLOSED_STATE:
                        ThisLayerFinished();
                        break;

                case PPP_REQ_SENT_STATE:
                case PPP_ACK_RCVD_STATE:
                case PPP_ACK_SENT_STATE:
                        NewState(PPP_STOPPED_STATE);

                case PPP_STOPPING_STATE:
                        NewPhase(PPP_TERMINATION_PHASE);

                case PPP_STOPPED_STATE:
                        ThisLayerFinished();
                        break;

                case PPP_OPENED_STATE:
                        NewState(PPP_STOPPING_STATE);
                        NewPhase(PPP_TERMINATION_PHASE);
                                // indicates to handlers that we are terminating
                        InitializeRestartCount();
                        ThisLayerDown();
                        SendTerminateRequest();
                        break;
        }

        gBufferModule->free(packet);
}


// receive echo request/reply, discard request
void
KPPPStateMachine::RXREvent(net_buffer *packet)
{
        TRACE("KPPPSM: RXREvent() state=%d phase=%d\n", State(), Phase());

        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) {
                // TODO:
                // log that we got a reply, but no request was sent
        }

        switch (State()) {
                case PPP_INITIAL_STATE:
                case PPP_STARTING_STATE:
                        IllegalEvent(PPP_RXR_EVENT);
                        break;

                case PPP_OPENED_STATE:
                        if (echo.code == PPP_ECHO_REQUEST)
                                SendEchoReply(packet);
                        return;
                                // this prevents the packet from being freed

                default:
                        ;
        }

        gBufferModule->free(packet);
}


// general events (for Good/Bad events)
void
KPPPStateMachine::TimerEvent()
{
#if DEBUG
        if (fNextTimeout != 0)
                TRACE("KPPPSM: TimerEvent()\n");
#endif

        if (fNextTimeout == 0 || fNextTimeout > system_time())
                return;

        fNextTimeout = 0;

        switch (State()) {
                case PPP_CLOSING_STATE:
                case PPP_STOPPING_STATE:
                        if (fTerminateCounter <= 0)
                                TOBadEvent();
                        else
                                TOGoodEvent();
                        break;

                case PPP_REQ_SENT_STATE:
                case PPP_ACK_RCVD_STATE:
                case PPP_ACK_SENT_STATE:
                        if (fRequestCounter <= 0)
                                TOBadEvent();
                        else
                                TOGoodEvent();
                        break;

                default:
                        ;
        }
}


// ReceiveConfigureRequest
// 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(net_buffer *packet)
{
        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 == header.id)
                fID -= 128;
                // or maybe we should use peer's ID plus 1 ?

        nak.SetID(request.ID());
        reject.SetID(request.ID());

        // each handler should add unacceptable values for each item
        status_t result;
                // the return value of ParseRequest()
        KPPPOptionHandler *optionHandler;
        for (int32 index = 0; index < request.CountItems(); index++) {
                optionHandler = LCP().OptionHandlerFor(request.ItemAt(index)->type);

                if (!optionHandler || !optionHandler->IsEnabled()) {
                        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",
                        optionHandler->Name() ? optionHandler->Name() : "Unknown");
                result = optionHandler->ParseRequest(request, index, nak, reject);

                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");
                        gBufferModule->free(packet);
                        CloseEvent();
                        return;
                }
        }

        // Additional values may be appended.
        // If we sent too many naks we should not append additional values.
        if (fNakCounter > 0) {
                for (int32 index = 0; index < LCP().CountOptionHandlers(); index++) {
                        optionHandler = LCP().OptionHandlerAt(index);
                        if (optionHandler && optionHandler->IsEnabled()) {
                                result = optionHandler->ParseRequest(request, request.CountItems(),
                                        nak, reject);

                                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 append error!\n");
                                        gBufferModule->free(packet);
                                        CloseEvent();
                                        return;
                                }
                        }
                }
        }

        if (reject.CountItems() > 0) {
                TRACE("%s:reject number more than 0\n", __func__);
                RCRBadEvent(NULL, reject.ToNetBuffer(Interface().MRU()));
                gBufferModule->free(packet);
        } else if (nak.CountItems() > 0) {
                TRACE("%s:nak number more than 0\n", __func__);
                RCRBadEvent(nak.ToNetBuffer(Interface().MRU()), NULL);
                gBufferModule->free(packet);
        } else
                RCRGoodEvent(packet);
}


// ReceiveCodeReject
// 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(net_buffer *packet)
{
        TRACE("KPPPSM: RXJEvent() state=%d phase=%d\n", State(), Phase());

        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];

                // 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.
                                gBufferModule->free(packet);
                                CloseEvent();
                        } else
                                RXJBadEvent(packet);

                        return;
                }

                // find the LCP extension and disable it
                KPPPLCPExtension *lcpExtension;
                for (int32 index = 0; index < LCP().CountLCPExtensions(); index++) {
                        lcpExtension = LCP().LCPExtensionAt(index);

                        if (lcpExtension->Code() == rejectedCode)
                                lcpExtension->SetEnabled(false);
                }

                gBufferModule->free(packet);
        } else if (reject.code == PPP_PROTOCOL_REJECT) {
                // disable all handlers for rejected protocol type
                uint16 rejected = *((uint16*) reject.data);
                        // rejected protocol number

                if (rejected == PPP_LCP_PROTOCOL) {
                        // LCP must not be rejected!
                        RXJBadEvent(packet);
                        return;
                }

                // disable protocols with the rejected protocol number
                KPPPProtocol *protocol = Interface().FirstProtocol();
                for (; protocol; protocol = protocol->NextProtocol()) {
                        if (protocol->ProtocolNumber() == rejected)
                                protocol->SetEnabled(false);
                                        // disable protocol
                }

                RXJGoodEvent(packet);
                        // this event handler does not m_freem(packet)!!!

                // notify parent, too
                if (Interface().Parent())
                        Interface().Parent()->StateMachine().RXJEvent(packet);
                else
                        gBufferModule->free(packet);
        }
}


// actions (all private)
void
KPPPStateMachine::IllegalEvent(ppp_event event)
{
        // TODO:
        // update error statistics
        TRACE("KPPPSM: IllegalEvent(event=%d) state=%d phase=%d\n",
                event, State(), Phase());
}


void
KPPPStateMachine::ThisLayerUp()
{
        TRACE("KPPPSM: ThisLayerUp() state=%d phase=%d\n", State(), Phase());

        // We begin with authentication phase and wait until each phase is done.
        // We stop when we reach established phase.

        // Do not forget to check if we are going down.
        if (Phase() != PPP_ESTABLISHMENT_PHASE)
                return;

        NewPhase(PPP_AUTHENTICATION_PHASE);

        BringProtocolsUp();
}


void
KPPPStateMachine::ThisLayerDown()
{
        TRACE("KPPPSM: ThisLayerDown() state=%d phase=%d\n", State(), Phase());

        // KPPPProtocol::Down() should block if needed.
        DownProtocols();
}


void
KPPPStateMachine::ThisLayerStarted()
{
        TRACE("KPPPSM: ThisLayerStarted() state=%d phase=%d\n", State(), Phase());

        if (Interface().Device() && !Interface().Device()->Up())
                Interface().Device()->UpFailedEvent();
}


void
KPPPStateMachine::ThisLayerFinished()
{
        TRACE("KPPPSM: ThisLayerFinished() state=%d phase=%d\n", State(), Phase());

        if (Interface().Device())
                Interface().Device()->Down();
}


void
KPPPStateMachine::InitializeRestartCount()
{
        fRequestCounter = fMaxRequest;
        fTerminateCounter = fMaxTerminate;
        fNakCounter = fMaxNak;
}


void
KPPPStateMachine::ZeroRestartCount()
{
        fRequestCounter = 0;
        fTerminateCounter = 0;
        fNakCounter = 0;
}


bool
KPPPStateMachine::SendConfigureRequest()
{
        TRACE("KPPPSM: SendConfigureRequest() state=%d phase=%d\n", State(), Phase());

        --fRequestCounter;
        fNextTimeout = system_time() + kPPPStateMachineTimeout;

        KPPPConfigurePacket request(PPP_CONFIGURE_REQUEST);
        request.SetID(NextID());
        fRequestID = request.ID();

        for (int32 index = 0; index < LCP().CountOptionHandlers(); index++) {
                // add all items
                if (LCP().OptionHandlerAt(index)->AddToRequest(request) != B_OK) {
                        CloseEvent();
                        return false;
                }
        }

        return LCP().Send(request.ToNetBuffer(Interface().MRU())) == B_OK;
}


bool
KPPPStateMachine::SendConfigureAck(net_buffer *packet)
{
        TRACE("KPPPSM: SendConfigureAck() state=%d phase=%d\n", State(), Phase());

        if (!packet)
                return false;

        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) {
                        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(net_buffer *packet)
{
        TRACE("KPPPSM: SendConfigureNak() state=%d phase=%d\n", State(), Phase());

        if (!packet)
                return false;

        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;
                } else
                        --fNakCounter;
        }

        return LCP().Send(packet) == B_OK;
}


bool
KPPPStateMachine::SendTerminateRequest()
{
        TRACE("KPPPSM: SendTerminateRequest() state=%d phase=%d\n", State(), Phase());

        --fTerminateCounter;
        fNextTimeout = system_time() + kPPPStateMachineTimeout;

        net_buffer *buffer = gBufferModule->create(256);
        if (buffer == NULL)
                return false;

        ppp_lcp_packet *packet;
        status_t status = gBufferModule->append_size(buffer, 1492, (void **)&packet);
        if (status == B_OK && packet == NULL) {
                gBufferModule->free(buffer);
                return false;
        }

        if (!packet)
                return false;

        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 false;
        }

        return LCP().Send(buffer) == B_OK;
}


bool
KPPPStateMachine::SendTerminateAck(net_buffer *request)
{
        TRACE("KPPPSM: SendTerminateAck() state=%d phase=%d\n", State(), Phase());

        net_buffer *reply = request;

        NetBufferHeaderReader<ppp_lcp_packet> bufferHeader(request);
        if (bufferHeader.Status() < B_OK)
                return false;
        ppp_lcp_packet &ack = bufferHeader.Data();

        if (!reply) {
                ack.length = htons(4);
                ack.id = NextID();
        }

        ack.code = PPP_TERMINATE_ACK;
        ack.length = htons(4);

        return LCP().Send(reply) == B_OK;
}


bool
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());

        if (!packet)
                return false;

        int32 length;
                // additional space needed for this reject
        if (code == PPP_PROTOCOL_REJECT)
                length = 6;
        else
                length = 4;

        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));

        return LCP().Send(packet) == B_OK;
}


bool
KPPPStateMachine::SendEchoReply(net_buffer *request)
{
        TRACE("KPPPSM: SendEchoReply() state=%d phase=%d\n", State(), Phase());

        if (!request)
                return false;

        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

        memcpy(reply.data, &fMagicNumber, sizeof(fMagicNumber));

        return LCP().Send(request) == B_OK;
}


// methods for bringing protocols up
void
KPPPStateMachine::BringProtocolsUp()
{
        // use a simple check for phase changes (e.g., caused by CloseEvent())
        while (Phase() <= PPP_ESTABLISHED_PHASE && Phase() >= PPP_AUTHENTICATION_PHASE) {
                if (BringPhaseUp() > 0)
                        break;

                if (Phase() < PPP_AUTHENTICATION_PHASE)
                        return;
                                // phase was changed by another event
                else if (Phase() == PPP_ESTABLISHED_PHASE) {
                        if (Interface().Parent())
                                Interface().Parent()->StateMachine().UpEvent(Interface());
                        break;
                } else
                        NewPhase((ppp_phase) (Phase() + 1));
        }
}


// this returns the number of handlers waiting to go up
uint32
KPPPStateMachine::BringPhaseUp()
{
        // Servers do not need to bring all protocols up.
        // The client specifies which protocols he wants to go up.

        // check for phase change
        if (Phase() < PPP_AUTHENTICATION_PHASE)
                return 0;

        uint32 count = 0;
        KPPPProtocol *protocol = Interface().FirstProtocol();
        for (; protocol; protocol = protocol->NextProtocol()) {
                if (protocol->IsEnabled() && protocol->ActivationPhase() == Phase()) {
                        if (protocol->IsGoingUp() && Interface().Mode() == PPP_CLIENT_MODE)
                                ++count;
                        else if (protocol->IsDown() && protocol->IsUpRequested()) {
                                if (Interface().Mode() == PPP_CLIENT_MODE)
                                        ++count;

                                protocol->Up();
                        }
                }
        }

        // We only wait until authentication is complete.
        if (Interface().Mode() == PPP_SERVER_MODE
                        && (LocalAuthenticationStatus() == PPP_AUTHENTICATING
                        || PeerAuthenticationStatus() == PPP_AUTHENTICATING))
                ++count;

        return count;
}


void
KPPPStateMachine::DownProtocols()
{
        KPPPProtocol *protocol = Interface().FirstProtocol();

        for (; protocol; protocol = protocol->NextProtocol())
                if (protocol->IsEnabled())
                        protocol->Down();
}


void
KPPPStateMachine::ResetLCPHandlers()
{
        for (int32 index = 0; index < LCP().CountOptionHandlers(); index++)
                LCP().OptionHandlerAt(index)->Reset();

        for (int32 index = 0; index < LCP().CountLCPExtensions(); index++)
                LCP().LCPExtensionAt(index)->Reset();
}