head	1.1;
access;
symbols;
locks
	alexis:1.1; strict;
comment	@ * @;


1.1
date	97.01.31.14.43.34;	author alexis;	state Exp;
branches;
next	;


desc
@MILEPOST - MAY NOT WORK
@


1.1
log
@Initial revision
@
text
@#include "pppld.h"				/* for delayq defs */
#include <signal.h>				/* for SIG* */
#include "pppld_utils.h"			/* for DBG_* */
#include "pppld_ipc.h"				/* for forward refs */
#include "pppld_msgids.h"			/* for message ids */
#include "patchlevel.h"				/* for forward ref */


#define REASON_UP       0
#define REASON_QUALITY  1
#define REASON_IDLE     2
#define REASON_HANGUP   3
#define REASON_REDIAL   4

#define QTEST_CMD       "/home/alexis/dev/ppp/qtest"
#define SNDMAIL_CMD     "/home/alexis/dev/ppp/sndmail"
#define GETMAIL_CMD     "/home/alexis/dev/ppp/getmail"
#define SNDNEWS_CMD     "/home/alexis/dev/ppp/sndnews"
#define GETNEWS_CMD     "/home/alexis/dev/ppp/getnews"

int reason_down;
static char *rcs_id = "$Id$";


/*
 *  Global data - idle check info
 */

int idlecheck_oldusecnt = -1;
unsigned long idlecheck_oldusetim = 0;

mhf_load_config()
{
    debug(DBG_FUNCS, "mhf_load_config: sof");

    state_cfgok = load_config("master.cfg", 0) ? 0 : 1;
}

mhf_info(
int *info_requestp)
{
    int i;
    long t = time(NULL);

    debug(DBG_FUNCS, "mhf_info: sof");

    if (!(debug_level & DBG_INFO)) {
        debug_level |= DBG_INFO;
        debug(DBG_INFO, "turning info messages on");
    }

    if (*info_requestp == 1) {
        info("STATES");
        info("state_cfgok:                %d", state_cfgok);
        info("state_curr:                 %d", state_curr);
        info("state_want:                 %d", state_want);
        info("state_done:                 %d", state_done);
        info("state_inipup:               %d", state_inipup);
        info("state_donenx:               %d", state_donenx);
        info("state_donemx:               %d", state_donemx);
        info("state_quit:                 %d", state_quit);
        info("QUEUES");
        info("delayq_top:                 %d", delayq_top);
        for (i=0; i<delayq_top; i++)
            info("delayq (%d)                  in %ld secs, id %d, en %d", i, delayq[i].time-t, delayq[i].id, delayq[i].en);
        info("CONFIG");
        info("idlecheck_interval:         %d", idlecheck_interval);
        info("idlecheck_timeout:          %d", idlecheck_timeout);
        info("qualitycheck_interval:      %d", qualitycheck_interval);
        info("qualitycheck_minquality:    %d", qualitycheck_minquality);
        info("FLAGS");
        info("do_xfer_news_flag:          %d", do_xfer_news_flag);
        info("MISC");
        info("idlecheck_oldusecnt:        %d", idlecheck_oldusecnt);
        info("idlecheck_oldusetim:        %ld", idlecheck_oldusetim);
        info("debug_level:                %ld", debug_level);
    } else if (*info_requestp == 0) {
         info("PROGRAM: %s", progname);
         info("VERSION: %s", patchlevel);
    } else if (*info_requestp == 2) {
         info("VALID MESSAGES");
         for (i=0; svrmsginfdat[i].id != MSGID_LAST_MARKER; i+=2)
             if (svrmsginfdat[i+1].id != MSGID_LAST_MARKER)
                 info("%2d (%d): %-15s\t%2d (%d): %-15s", svrmsginfdat[i].id, svrmsginfdat[i].argc, svrmsginfdat[i].cmt, svrmsginfdat[i+1].id, svrmsginfdat[i+1].argc, svrmsginfdat[i+1].cmt);
             else
                 info("%2d (%d): %-15s", svrmsginfdat[i].id, svrmsginfdat[i].argc, svrmsginfdat[i].cmt);
    } else 
        warning("invalid information request type: %d", *info_requestp);

    /* pppld_ipc_send_msg(MSGTO_INFO, buf);
    pppld_ipc_send_msg(MSGTO_INFO, "."); */
}

mhf_exec_pppd()
{
    char cmdbuf[512];

    debug(DBG_FUNCS, "mhf_exec_pppd: sof");

    /* what about regenning the chat file? should that do here? no - another step is needed - so
       that ppp-on results in MSGID_EXEC_PREPPPD getting queued, and then this checks doregen_flag,
       if it's set - which the server does at startup - then the file get's regenerated by a fork
       and send sort of thing - perhaps not forking - and the flag gets cleared, either way, the
       next step should be to queueu MSGID_EXEC_PPPD - either in mhf_exec_prepppd - which would
       be the non-forking function mentioned above - or should it fork? could be slow? - note
       that it would be queued from there only if the regen was *not* necessary, otherwise it
       would be queed from mhf_ok_prepppd(). */
       
    if (state_curr) {
        warning("already connected or attempt in progress!");
        return;
    }

    if (state_cfgok) {
        state_want = 1;
        state_done = 0;
        sprintf(cmdbuf, "%s %s %d connect \"%s -v -f %s\" crtscts defaultroute lock netmask %s danae.demon.co.uk: asyncmap 0x00000000 mru 576 mtu 576 lcp-echo-interval 180 -detach", 
            pppd_cmd, port, speed, chat_cmd, chatfile, netmask);
        forkandsend(cmdbuf, MSGID_OK_PPPD, MSGID_NOK_PPPD);
    } else
        warning("config has not been successfully loaded");
}

mhf_ok_pppd()
{
    debug(DBG_FUNCS, "mhf_ok_pppd: sof");

    if (state_curr != 0)
        internal("(%s,%d): state_curr should be 0!", __FILE__, __LINE__);

    if (state_want == 0) {
       printf("%s: mhf_ok_pppd: no action required\n", progname);
    } else {
        pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_PPPD, NULL);
    }
}

mhf_nok_pppd()
{
    debug(DBG_FUNCS, "mhf_nok_pppd: sof");

    mhf_ok_pppd();
}

/*
 *  IPUP Functions
 */

mhf_exec_ipup()
{
    debug(DBG_FUNCS, "mhf_exec_ipup: sof");

    if (state_want) {
        state_inipup = 1;
        if (qualitycheck_interval && qualitycheck_minquality) {
            debug(DBG_QUALITY, "mhf_exec_ipup: queuing immediate qtest execution");
            pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_QTEST, NULL);
        } else {
            debug(DBG_QUALITY, "mhf_exec_ipup: NOT queuing immediate qtest execution");
            mhf_got_good_conn();
        }
    } else {
        /* is it necessary to kill pppd? Presumably the user has done hangup, redial while the chat
        was running, and both of those will issue their own kills. But didn't pppd ignore the kill
        in that situation? Wasn't that the reason for having the 'S1' state in the old version? Let's
        leave it out for the moment and see how it responds. Maybe put it back in later */
        /* kill_pppd(); */
    }
}

mhf_exec_qtest()
{
    char cmdbuf[128];

    debug(DBG_FUNCS, "mhf_exec_qtest: sof");

    sprintf(cmdbuf, "%s %d %s", QTEST_CMD, qualitycheck_minquality, qualitycheck_remhost);
    forkandsend(cmdbuf, MSGID_OK_QTEST, MSGID_NOK_QTEST);
}

mhf_ok_qtest()
{
    debug(DBG_FUNCS, "mhf_ok_qtest: sof");

    if (state_inipup)
        mhf_got_good_conn();

    /* qualitycheck_flag is likely to be on, hey!, or why would we be here in the 
       first place? but it could have been turned off while the test was
       running, so we check again */

    if (qualitycheck_minquality && qualitycheck_interval && state_curr && state_want) {
       debug(DBG_QUALITY, "mhf_ok_qtest: requeuing qtest check for %d secs", qualitycheck_interval);
       delaysendmsg(time(NULL)+qualitycheck_interval, MSGID_EXEC_QTEST, NULL);
    } else
       debug(DBG_QUALITY, "mhf_ok_qtest: NOT requeuing qtest");
}


mhf_got_good_conn()
{
    char cmdbuf[128];

    debug(DBG_FUNCS, "mhf_got_good_conn: sof");

    /* 
     *  Don't pursue the normal routine if the user has changed their mind
     *  while the quality test was running. There are no further actions
     *  required (hopefully); the instruction to kill the pppd process should
     *  have been issued elsewhere.
     */

    if (!state_want)
        return;

    /*
     *  Announce it!
     */

    sprintf(cmdbuf, "%s %d", announce_cmd, REASON_UP);
    forkandsend(cmdbuf, MSGID_NOACTION, MSGID_NOACTION);
    state_done = 1;
    state_curr = 1;

    /*
     *  Do mail, news and idle checks concurrently
     */

    state_donenx = state_donemx = 0;
    pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_SNDMAIL, NULL);
    if (do_xfer_news_flag) 
        pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_SNDNEWS, NULL);
    if (idlecheck_timeout) 
        pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_IDLECHECK, NULL);
}


mhf_nok_qtest()
{
     debug(DBG_FUNCS, "mhf_nok_qtest: sof");

     /*
      *  The reason should only be read if we have already announced we 
      *  are up. Doesn't really matter if it isn't since the ipdown function
      *  also interrogates state_curr before producing a message.
      */

     if (state_curr)
         reason_down = REASON_QUALITY;

     if (kill_pppd() != 0) {
         debug(DBG_SPECIAL2, "mhf_nok_qtest: Oops! couldn't kill pppd, so EXEC_PPPD won't be reissued");
     }
}

/*
 *  SNDMAIL Functions
 */

mhf_exec_sndmail()
{
    debug(DBG_FUNCS, "mhf_exec_sndmail: sof");

    forkandsend(SNDMAIL_CMD, MSGID_OK_SNDMAIL, MSGID_NOK_SNDMAIL);
}

mhf_ok_sndmail()
{
    debug(DBG_FUNCS, "mhf_ok_sndmail: sof");

    if (state_inipup) {
        pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_GETMAIL, NULL);
    }
}

mhf_nok_sndmail()
{
    debug(DBG_FUNCS, "mhf_nok_sndmail: sof");

    mhf_ok_sndmail();
}

/*
 *  GETMAIL Functions
 */

mhf_exec_getmail()
{
    debug(DBG_FUNCS, "mhf_exec_getmail: sof");

    forkandsend(GETMAIL_CMD, MSGID_OK_GETMAIL, MSGID_NOK_GETMAIL);
}

mhf_ok_getmail()
{
    debug(DBG_FUNCS, "mhf_ok_getmail: sof");

    if (state_inipup) {
        state_donemx = 1;
        if (state_donemx && (state_donenx || !do_xfer_news_flag))
            state_inipup = 0;
    } 
}

mhf_nok_getmail()
{
    debug(DBG_FUNCS, "mhf_nok_getmail: sof");

    mhf_ok_getmail();
}

/*
 *  SNDNEWS Functions
 */

mhf_exec_sndnews()
{
    debug(DBG_FUNCS, "mhf_exec_sndnews: sof");

    forkandsend(SNDNEWS_CMD, MSGID_OK_SNDNEWS, MSGID_NOK_SNDNEWS);
}

mhf_ok_sndnews()
{
    debug(DBG_FUNCS, "mhf_ok_sndnews: sof");

    pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_GETNEWS, NULL);
}

mhf_nok_sndnews()
{
    debug(DBG_FUNCS, "mhf_nok_sndnews: sof");

    mhf_ok_sndnews();
}

/*
 *  GETNEWS Functions
 */

mhf_exec_getnews()
{
    debug(DBG_FUNCS, "mhf_exec_getnews: sof");

    forkandsend(GETNEWS_CMD, MSGID_OK_GETNEWS, MSGID_NOK_GETNEWS);
}

mhf_ok_getnews()
{
    debug(DBG_FUNCS, "mhf_ok_getnews: sof");

    if (state_inipup) {
        state_donenx = 1;
        if (state_donemx && state_donenx)
            state_inipup = 0;
    } 
}

mhf_nok_getnews()
{
    debug(DBG_FUNCS, "mhf_nok_getnews: sof");

    mhf_ok_getnews();
}

mhf_exec_idle()
{
    int state_idle;		/* only local!! */
    FILE *fp;
    char buf[128];
    char iface[8];
    int recd, sent, junk, use;

    debug(DBG_FUNCS, "mhf_exec_idle: sof");

    /*
     *  Connection stats are in /proc/net/dev on Linux
     */

    if ((fp=fopen("/proc/net/dev", "r")) == NULL) {
        perror("fopen");
        exit(1);
    }
  
    /*
     *  Get sum of packets transferred.
     */

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        sscanf(buf, " %s %d %d %d %d %d %d ", iface, &recd, &junk, &junk, &junk, &junk, &sent);
        debug(DBG_IDLE, "mhf_exec_idle: iface: %s, recd: %d, sent %d", iface, recd, sent);
        if (strcmp(iface, "ppp0:") == 0)
            use = recd + sent;
    }
    fclose(fp);

    /* 
     *  Assess whether we are idle or not by comparing the use count with
     *  the old use count. If we are idle then have we been idle sufficiently
     *  long to warrant hanging up? If we are not idle then save the current
     *  time and use counts for next time round.
     */

    state_idle = 0;
    if (use == idlecheck_oldusecnt && time(NULL) > idlecheck_oldusetim + idlecheck_timeout) {
        debug(DBG_IDLE, "mhf_exec_idle: idle and time limit expired!");
        state_idle = 1;
    } else if (use == idlecheck_oldusecnt) {
        debug(DBG_IDLE, "mhf_exec_idle: idle");
    } else {
        debug(DBG_IDLE, "mhf_exec_idle: not idle, saving current usage levels");
        idlecheck_oldusetim = time(NULL);
        idlecheck_oldusecnt = use;
    }

    /* 
     *  Send a message to be acted on according to whether we have been idle
     *  long enough or not. The code called could be incorporated here since
     *  *this* function is so quick, but why bother?
     */

    pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, state_idle ? MSGID_NOK_IDLECHECK : MSGID_OK_IDLECHECK, NULL);
}

mhf_ok_idle()
{
    debug(DBG_FUNCS, "mhf_ok_idle: sof");

    if (idlecheck_timeout && state_curr) {
       debug(DBG_IDLE, "mhf_ok_idle: requeuing idle check for %d secs", idlecheck_interval);
       delaysendmsg(time(NULL)+idlecheck_interval, MSGID_EXEC_IDLECHECK, NULL);
    } else 
       debug(DBG_IDLE, "mhf_ok_idle: NOT requeuing idle check");
}

mhf_nok_idle()
{
    debug(DBG_FUNCS, "mhf_nok_idle: sof");

    /* no need to requeue the check message ... just let the idle process die */
    state_want = 0;
    reason_down = REASON_IDLE;
    kill_pppd();
}

mhf_unset_qualitycheck_interval()
{
    int q = 0;

    debug(DBG_FUNCS, "mhf_unset_qualitycheck_interval: sof");

    /* 
     *  That variable may be automatic since pppld_ipc_send_msg() really
     *  has finished with the memory it's in when it exits. (It constructs
     *  a text string from the args and dispatches the message.
     */

    pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_SET_QUALITYCHECK, &q);
}

mhf_set_debug(
int *debug_levelp)
{
    debug(DBG_FUNCS, "mhf_set_debug: sof");

    /*
     *  Note that the mhf functions currently take integers as parameters
     *  and that debug_level is a long. Really the parameter should be the
     *  address of a union of int, unsigned long and char *. And the
     *  mhf functions should extract the bit they want. But we'll leave
     *  that for the time being.
     */

    debug_level = (unsigned long) *debug_levelp;
}

mhf_set_qualitycheck_interval(
int *new_qualitycheck_intervalp)
{
    int old_qualitycheck_interval = qualitycheck_interval;
    int i; 

    debug(DBG_FUNCS, "mhf_set_qualitycheck_interval: sof");

    qualitycheck_interval = *new_qualitycheck_intervalp;
   
    /* 
     *  if we require a positive quality and we have a positive interval but 
     *  didn't have one already! ... and of course we're connected and
     *  want to be ...
     */

    if (qualitycheck_interval && !old_qualitycheck_interval && qualitycheck_minquality) {
        if (state_curr && state_want)
            pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_QTEST, NULL);

    /* 
     *  if it is the toggling of the quality interval that should deactivate
     *  the delayed queued quality checks then cancel them now 
     */

    } else if (qualitycheck_minquality)
        /* dequeuing could go here, instead od being in a separate function */
        for (i=0; i<delayq_top; i++)
            if (delayq[i].id == MSGID_EXEC_QTEST)
                delayq[i].en = 0;
}

mhf_unset_idlecheck()
{
    int i;

    debug(DBG_FUNCS, "mhf_unset_idlecheck: sof");

    for (i=0; i<delayq_top; i++)
        if (delayq[i].id == MSGID_EXEC_IDLECHECK)
            delayq[i].en = 0;

    idlecheck_timeout = 0;
}

mhf_set_idlecheck()
{
    debug(DBG_FUNCS, "mhf_set_idlecheck: sof");

    if (!idlecheck_timeout)
        pppld_ipc_send_msg(svrmsginfdat, MSGTO_SVR, MSGID_EXEC_IDLECHECK, NULL);

    idlecheck_timeout = 300;
}

mhf_set_quit()
{
    debug(DBG_FUNCS, "mhf_set_quit: sof");

    state_quit = !state_quit;
}

mhf_set_donews()
{
    debug(DBG_FUNCS, "mhf_set_donews: sof");

    do_xfer_news_flag = 1;
}

mhf_unset_donews()
{
    debug(DBG_FUNCS, "mhf_unset_donews: sof");

    do_xfer_news_flag = 0;
}

mhf_redial()
{
    debug(DBG_FUNCS, "mhf_redial: sof");

    state_want = 1;
    reason_down = REASON_REDIAL;
    if (kill_pppd() != 0)
         debug(DBG_SPECIAL2, "mhf_redial: Oops! couldn't kill pppd, so EXEC_PPPD won't be reissued");
}

mhf_hangup()
{
    debug(DBG_FUNCS, "mhf_hangup: sof");

    state_want = 0;
    reason_down = REASON_HANGUP;
    kill_pppd();
}

mhf_exec_ipdown()
{
    char cmdbuf[128];

    debug(DBG_FUNCS, "mhf_exec_ipdown: sof");

    if (reason_down == REASON_IDLE || reason_down == REASON_HANGUP)
        state_want = 0;

    if (state_curr) {
        sprintf(cmdbuf, "%s %d", announce_cmd, reason_down);
        forkandsend(cmdbuf, MSGID_NOACTION, MSGID_NOACTION);
        state_curr = 0;
    }

    delayq_top = 0;
    signal(SIGALRM, SIG_IGN);
}

mhf_noaction()
{
    debug(DBG_FUNCS, "mhf_noaction: sof");
}

@