/* finalize L2TP daemon instance */
void
l2tpd_uninit(l2tpd *_this)
{
l2tpd_listener *plsnr;
L2TPD_ASSERT(_this != NULL);
slist_fini(&_this->free_session_id_list);
if (_this->ctrl_map != NULL) {
hash_free(_this->ctrl_map);
_this->ctrl_map = NULL;
}
slist_itr_first(&_this->listener);
while (slist_itr_has_next(&_this->listener)) {
plsnr = slist_itr_next(&_this->listener);
L2TPD_ASSERT(plsnr != NULL);
L2TPD_ASSERT(plsnr->sock == -1);
free(plsnr);
}
slist_fini(&_this->listener);
event_del(&_this->ev_timeout); /* just in case */
_this->state = L2TPD_STATE_STOPPED;
}
void
pptpd_uninit(pptpd *_this)
{
pptpd_listener *plstn;
slist_fini(&_this->ctrl_list);
slist_fini(&_this->call_free_list);
slist_itr_first(&_this->listener);
while (slist_itr_has_next(&_this->listener)) {
plstn = slist_itr_next(&_this->listener);
PPTPD_ASSERT(plstn != NULL);
PPTPD_ASSERT(plstn->sock == -1);
PPTPD_ASSERT(plstn->sock_gre == -1);
free(plstn);
}
slist_fini(&_this->listener);
if (_this->call_id_map != NULL) {
hash_free(_this->call_id_map);
}
if (_this->ip4_allow != NULL)
in_addr_range_list_remove_all(&_this->ip4_allow);
_this->call_id_map = NULL;
_this->config = NULL;
}
/* uninitialize (free) PPPoE daemon */
void
pppoed_uninit(pppoed *_this)
{
if (_this->session_hash != NULL) {
hash_free(_this->session_hash);
_this->session_hash = NULL;
}
if (_this->acookie_hash != NULL) {
hash_free(_this->acookie_hash);
_this->acookie_hash = NULL;
}
slist_fini(&_this->session_free_list);
/* listener themself has been released already */
slist_fini(&_this->listener);
}
static void
test_10()
{
int i;
slist sl;
slist *l = &sl;
slist_init(l);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
slist_itr_first(l);
ASSERT((int)slist_itr_next(l) == 1);
ASSERT((int)slist_itr_next(l) == 2);
for (i = 4; i < 10000; i++) {
ASSERT(slist_itr_has_next(l));
ASSERT((int)slist_itr_next(l) == i - 1);
if (i % 3 == 1)
slist_add(l, (void *)i);
if (i % 3 == 0)
ASSERT((int)slist_itr_remove(l) == i - 1);
if (i % 3 != 1)
slist_add(l, (void *)i);
}
slist_itr_first(l);
while (slist_itr_has_next(l)) {
slist_itr_next(l);
slist_itr_remove(l);
}
ASSERT((int)slist_length(l) == 0);
slist_fini(l);
}
void
pptpd_stop_immediatly(pptpd *_this)
{
pptp_ctrl *ctrl;
if (event_initialized(&_this->ev_timer))
evtimer_del(&_this->ev_timer);
if (_this->state != PPTPD_STATE_STOPPED) {
/* lock, to avoid multiple call from pptp_ctrl_stop() */
_this->state = PPTPD_STATE_STOPPED;
pptpd_close_1723(_this);
for (slist_itr_first(&_this->ctrl_list);
(ctrl = slist_itr_next(&_this->ctrl_list)) != NULL;) {
pptp_ctrl_stop(ctrl, 0);
}
pptpd_close_gre(_this);
slist_fini(&_this->ctrl_list);
slist_fini(&_this->call_free_list);
pptpd_log(_this, LOG_NOTICE, "Stopped");
} else {
PPTPD_DBG((_this, LOG_DEBUG, "(Already) Stopped"));
}
}
/*
* Terminate the control connection
*
* <p>
* please specify an appropriate value to result( >0 ) for
* StopCCN ResultCode AVP, when to sent Active Close (which
* require StopCCN sent).</p>
* <p>
* When the return value of this function is zero, the _this
* is already released. The lt2p_ctrl process that was bound to it
* could not contine.
* When the return value of this function is one, the timer
* is reset.</p>
*
* @return return 0 if terminate process was completed.
*/
int
l2tp_ctrl_stop(l2tp_ctrl *_this, int result)
{
int i;
l2tpd *_l2tpd;
L2TP_CTRL_ASSERT(_this != NULL);
switch (_this->state) {
case L2TP_CTRL_STATE_ESTABLISHED:
_this->state = L2TP_CTRL_STATE_CLEANUP_WAIT;
if (result > 0) {
_this->active_closing = result;
l2tp_ctrl_send_disconnect_notify(_this);
break;
}
goto cleanup;
default:
l2tp_ctrl_log(_this, LOG_DEBUG, "%s() unexpected state=%s",
__func__, l2tp_ctrl_state_string(_this));
/* FALLTHROUGH */
case L2TP_CTRL_STATE_WAIT_CTL_CONN:
/* FALLTHROUGH */
case L2TP_CTRL_STATE_CLEANUP_WAIT:
cleanup:
if (slist_length(&_this->call_list) != 0) {
if (l2tp_ctrl_disconnect_all_calls(_this, 1) > 0)
break;
}
#if 0
if (L2TP_CTRL_CONF(_this)e_ipsec_sa != 0)
l2tp_ctrl_purge_ipsec_sa(_this);
#endif
l2tp_ctrl_log(_this, LOG_NOTICE, "logtype=Finished");
evtimer_del(&_this->ev_timeout);
/* free send buffer */
if (_this->snd_buffers != NULL) {
for (i = 0; i < _this->winsz; i++)
bytebuffer_destroy(_this->snd_buffers[i]);
free(_this->snd_buffers);
_this->snd_buffers = NULL;
}
if (_this->zlb_buffer != NULL) {
bytebuffer_destroy(_this->zlb_buffer);
_this->zlb_buffer = NULL;
}
/* free l2tp_call */
l2tp_ctrl_destroy_all_calls(_this);
slist_fini(&_this->call_list);
l2tpd_remove_ctrl(_this->l2tpd, _this->tunnel_id);
_l2tpd = _this->l2tpd;
l2tp_ctrl_destroy(_this);
l2tpd_ctrl_finished_notify(_l2tpd);
return 0; /* stopped */
}
l2tp_ctrl_reset_timeout(_this);
return 1;
}
/** Reload the account list */
static int
npppd_auth_reload_acctlist(npppd_auth_base *base)
{
CSVREADER_STATUS status;
int linno, ncols, usersz, nuser, eof, off;
const char **cols, *passwd, *callnum;
char line[8192];
csvreader *csv;
npppd_auth_user *user;
struct in_addr ip4, ip4mask;
slist users;
FILE *file;
struct stat st;
if (base->acctlist_ready != 0 && lstat(base->acctlist_path, &st) == 0) {
if (st.st_mtime == base->last_load)
return 0;
base->last_load = st.st_mtime;
}
slist_init(&users);
csv = NULL;
if ((file = priv_fopen(base->acctlist_path)) == NULL) {
/* hash is empty if file is not found. */
if (errno == ENOENT)
hash_delete_all(base->users_hash, 1);
npppd_auth_base_log(base,
(errno == ENOENT)? LOG_DEBUG : LOG_ERR,
"Open %s failed: %m", base->acctlist_path);
return 0;
}
if ((csv = csvreader_create()) == NULL) {
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: csvreader_create(): %m");
goto fail;
}
for (linno = 0, eof = 0; !eof;) {
ip4.s_addr = 0;
ip4mask.s_addr = 0xffffffffL;
if (fgets(line, sizeof(line), file) != NULL) {
int linelen;
linelen = strlen(line);
if (linelen <= 0) {
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: lineno=%d "
"line too short", linno + 1);
goto fail;
}
if (line[linelen - 1] != '\n' && !feof(file)) {
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: lineno=%d "
"line too long", linno + 1);
goto fail;
}
status = csvreader_parse(csv, line);
} else {
if (!feof(file)) {
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: %m");
goto fail;
}
status = csvreader_parse_flush(csv);
eof = 1;
}
if (status != CSVREADER_NO_ERROR) {
if (status == CSVREADER_OUT_OF_MEMORY)
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: %m");
else
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list "
"failed: lineno=%d parse error", linno);
goto fail;
}
ncols = csvreader_get_number_of_column(csv);
if ((cols = csvreader_get_column(csv)) == NULL)
continue;
linno++; /* count up here because line number is treated as CSV. */
if (linno == 1) {
/* skip a title line */
continue;
}
if (ncols < 1) {
npppd_auth_base_log(base, LOG_ERR,
"account list lineno=%d has only %d fields.",
linno, ncols);
continue;
}
if (strlen(cols[0]) <= 0)
continue; /* skip if the user-name is empty */
if (ncols >= 3) {
if (*cols[2] != '\0' && inet_aton(cols[2], &ip4) != 1) {
npppd_auth_base_log(base, LOG_ERR,
"account list lineno=%d parse error: "
"invalid 'Framed-IP-Address' field: %s",
linno, cols[2]);
continue;
}
}
if (ncols >= 4) {
if ((*cols[3] != '\0' &&
inet_aton(cols[3], &ip4mask) != 1) ||
netmask2prefixlen(htonl(ip4mask.s_addr)) < 0) {
npppd_auth_base_log(base, LOG_ERR,
"account list lineno=%d parse error: "
"invalid 'Framed-IP-Netmask' field: %s",
linno, cols[3]);
continue;
}
}
passwd = "";
if (cols[1] != NULL)
passwd = cols[1];
callnum = "";
if (ncols >= 6 && cols[5] != NULL)
callnum = cols[5];
usersz = sizeof(npppd_auth_user);
usersz += strlen(cols[0]) + 1;
usersz += strlen(passwd) + 1;
usersz += strlen(callnum) + 1;
if ((user = malloc(usersz)) == NULL) {
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: %m");
goto fail;
}
memset(user, 0, usersz);
off = 0;
user->username = user->space + off;
off += strlcpy(user->username, cols[0], usersz - off);
++off;
user->password = user->space + off;
off += strlcpy(user->password, passwd, usersz - off);
++off;
user->calling_number = user->space + off;
strlcpy(user->calling_number, callnum, usersz - off);
user->framed_ip_address = ip4;
user->framed_ip_netmask = ip4mask;
slist_add(&users, user);
}
hash_delete_all(base->users_hash, 1);
nuser = 0;
for (slist_itr_first(&users); slist_itr_has_next(&users);) {
user = slist_itr_next(&users);
if (hash_lookup(base->users_hash, user->username) != NULL) {
npppd_auth_base_log(base, LOG_WARNING,
"Record for user='******' is redefined, the first "
"record will be used.", user->username);
free(user);
goto next_user;
}
if (hash_insert(base->users_hash, user->username, user) != 0) {
npppd_auth_base_log(base, LOG_ERR,
"Loading a account list failed: hash_insert(): %m");
goto fail;
}
nuser++;
next_user:
slist_itr_remove(&users);
}
slist_fini(&users);
csvreader_destroy(csv);
fclose(file);
npppd_auth_base_log(base, LOG_INFO,
"Loaded users from='%s' successfully. %d users",
base->acctlist_path, nuser);
base->acctlist_ready = 1;
return 0;
fail:
fclose(file);
if (csv != NULL)
csvreader_destroy(csv);
hash_delete_all(base->users_hash, 1);
for (slist_itr_first(&users); slist_itr_has_next(&users);) {
user = slist_itr_next(&users);
free(user);
}
slist_fini(&users);
return 1;
}
static void
test_09()
{
slist sl;
slist *l = &sl;
/*
* #1
*/
slist_init(l);
slist_set_size(l, 3);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
slist_itr_first(l);
ASSERT((int)slist_itr_next(l) == 1); /* 1 */
ASSERT((int)slist_itr_next(l) == 2); /* 2 */
ASSERT((int)slist_itr_next(l) == 3); /* 3 */
/* reaches the last */
slist_add(l, (void *)4); /* add a new item */
ASSERT(slist_itr_has_next(l)); /* iterates the new */
ASSERT((int)slist_itr_next(l) == 4);
slist_fini(l);
/*
* #2
*/
slist_init(l);
slist_set_size(l, 3);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
slist_itr_first(l);
ASSERT((int)slist_itr_next(l) == 1); /* 1 */
ASSERT((int)slist_itr_next(l) == 2); /* 2 */
ASSERT((int)slist_itr_next(l) == 3); /* 3 */
/* reaches the last */
slist_itr_remove(l); /* and remove the last*/
slist_add(l, (void *)4); /* add 4 (new last)*/
ASSERT(slist_itr_has_next(l)); /* */
ASSERT((int)slist_itr_next(l) == 4); /* 4 */
slist_fini(l);
/*
* #3
*/
slist_init(l);
slist_set_size(l, 3);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
slist_itr_first(l);
ASSERT((int)slist_itr_next(l) == 1); /* 1 */
ASSERT((int)slist_itr_next(l) == 2); /* 2 */
ASSERT((int)slist_itr_next(l) == 3); /* 3 */
/* reaches the last */
slist_add(l, (void *)4); /* add a new */
slist_itr_remove(l);
ASSERT(slist_itr_has_next(l));
ASSERT((int)slist_itr_next(l) == 4); /* 4 */
slist_fini(l);
/*
* #4 - remove iterator's next and it is the last
*/
slist_init(l);
slist_set_size(l, 3);
slist_add(l, (void *)1);
slist_add(l, (void *)2);
slist_add(l, (void *)3);
slist_itr_first(l);
ASSERT((int)slist_itr_next(l) == 1); /* 1 */
ASSERT((int)slist_itr_next(l) == 2); /* 2 */
slist_remove(l, 2); /* remove the next */
slist_add(l, (void *)4); /* add the new next */
ASSERT(slist_itr_has_next(l)); /* iterates the new */
ASSERT((int)slist_itr_next(l) == 4);
slist_fini(l);
}
