/*
* ipcp_close - Take IPCP down.
*/
static void
ipcp_close(
int unit,
char *reason)
{
fsm_close(&ipcp_fsm[unit], reason);
}
/*
* ccp_close - Terminate CCP.
*/
static void
ccp_close(
int unit,
char *reason)
{
ccp_flags_set(unit, 0, 0);
fsm_close(&ccp_fsm[unit], reason);
}
/*
* ccp_close - Terminate CCP.
*/
void
ccp_close(PPP_IF_VAR_T *pPppIf)
{
fsm *f = &pPppIf->ccp_fsm;
ccp_flags_set(&pPppIf->pSc->sc_flags,0, 0);
//fsm_close(&ccp_fsm[unit], reason);
fsm_close(f);
}
static void
lcp_open(fsm *f)
{
lcp *_this;
int peer_auth = 0;
LCP_ASSERT(f != NULL);
_this = &f->ppp->lcp;
if (psm_opt_is_accepted(_this, pap))
peer_auth = PPP_AUTH_PAP;
else if (psm_opt_is_accepted(_this, chap))
peer_auth = PPP_AUTH_CHAP_MD5;
else if (psm_opt_is_accepted(_this, chapms))
peer_auth = PPP_AUTH_CHAP_MS;
else if (psm_opt_is_accepted(_this, chapms_v2))
peer_auth = PPP_AUTH_CHAP_MS_V2;
else if (psm_opt_is_accepted(_this, eap))
peer_auth = PPP_AUTH_EAP;
else {
if (_this->auth_order[0] > 0) {
fsm_log(f, LOG_INFO,
"failed to negotiate a auth protocol.");
fsm_close(f, "Authentication is required");
ppp_set_disconnect_cause(f->ppp,
PPP_DISCON_AUTH_PROTOCOL_UNACCEPTABLE,
_this->auth_order[0] /* first one */,
1 /* peer refused */, NULL);
ppp_stop(f->ppp, "Authentication is required");
return;
}
}
f->ppp->peer_auth = peer_auth;
if (_this->xxxmru > 0 && f->ppp->peer_mru <= 0)
f->ppp->peer_mru = _this->xxxmru;
if (f->ppp->peer_mru <= 0)
f->ppp->peer_mru = f->ppp->mru;
/* checking the size of ppp->peer_mru. */
LCP_ASSERT(f->ppp->peer_mru > 500);
fsm_log(f, LOG_INFO, "logtype=Opened mru=%d/%d auth=%s magic=%08x/%08x"
, f->ppp->mru, f->ppp->peer_mru
, lcp_auth_string(peer_auth)
, f->ppp->lcp.magic_number, f->ppp->lcp.peer_magic_number
);
lcp_reset_timeout(_this);
ppp_lcp_up(f->ppp);
}
/**
* This function will be called by the physical layer when it is down.
* <p>
* Use this function only on such conditions that the physical layer cannot
* input or output PPP frames. Use {@link ::ppp_stop()} instead if we can
* disconnect PPP gently.</p>
*/
void
ppp_phy_downed(npppd_ppp *_this)
{
PPP_ASSERT(_this != NULL);
ppp_down_others(_this);
fsm_lowerdown(&_this->lcp.fsm);
fsm_close(&_this->lcp.fsm, NULL);
#ifdef USE_NPPPD_RADIUS
ppp_set_radius_terminate_cause(_this,
RADIUS_TERMNATE_CAUSE_LOST_CARRIER);
#endif
ppp_stop0(_this);
}
/**
* Stop the PPP and destroy the npppd_ppp instance
* @param reason Reason of stopping the PPP. Specify NULL if there is
* no special reason. This reason will be used as a
* reason field of LCP Terminate-Request message and
* notified to the peer.
*/
void
ppp_stop(npppd_ppp *_this, const char *reason)
{
PPP_ASSERT(_this != NULL);
#ifdef USE_NPPPD_RADIUS
ppp_set_radius_terminate_cause(_this,
RADIUS_TERMNATE_CAUSE_ADMIN_RESET);
#endif
ppp_set_disconnect_cause(_this, PPP_DISCON_NORMAL, 0, 2 /* by local */,
NULL);
ppp_down_others(_this);
fsm_close(&_this->lcp.fsm, reason);
}
/*
* lcp_close - Take LCP down.
*/
void
lcp_close(
int unit,
char *reason)
{
fsm *f = &lcp_fsm[unit];
if (pppd_phase != PHASE_DEAD)
new_phase(PHASE_TERMINATE);
if (f->state == STOPPED && f->flags & (OPT_PASSIVE|OPT_SILENT)) {
/*
* This action is not strictly according to the FSM in RFC1548,
* but it does mean that the program terminates if you do a
* lcp_close() in passive/silent mode when a connection hasn't
* been established.
*/
f->state = CLOSED;
lcp_finished(f);
} else
fsm_close(&lcp_fsm[unit], reason);
}
static void
ccp_close (void)
{
fsm_close(&ccp_fsm);
}