/*
   Dear "get archive/unpack/do_not_read_dox/compile/run" users :
   configuration instructions section begins below, just after
   "Main configuration"

   Thank you for your att (I do not write anything more since usually
   nobody read this sort of stuff. Except you. Err... and me. Uck.)
*/


/*
   This program is free software; you can redistribute it and/or modify   
   it under the terms of the GNU General Public License as published by 
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,    
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   <...>

Name : uuPollChk
Status : public (GPL), quick hack !
Purpose :
check the last date/time of any UUCP session and requires an UUCP poll
 (<=> touches /var/spool/uucp/<system>/C./C.A0000)
if the last session is too old

Does not use "uustat -m" output (because it is biased by failed dials,
no sessions errors reporting ...)
=> parses the Log file

  - slurps the entire Log file ONLY if necessary
  - does not ignore connection errors occured during sessions
  - ignores the UUCP configuration (ex : data volume limitation when
    calling/called ...) and state (ex : uustat -a ...)

Does not invoke uucico (cron may do it !)


Context :
	Any Unix machine, UUCP (Taylor with Taylor config)

Language : ANSI C++, conversion to pure C should be _VERY_ easy
Author : Nat.Makarevitch@nataa.fr.eu.org  (LINUX!)
1994 to 1997

Diplays :
----
uuPollChk x.yz (last UUCP sessions) : <locking-file presence>
<infos for system 1>
<infos for system 2>
...

---

Format of <infos for system x> lines :
--
<remote UUCP host name> : <date/time of last session>
<time elapsed since session, human-readable form> "ago"\
{"next poll:",""} <time {before,after} poll time, human-readable form> \
[Err]  [Poll]
--
[Err]  : Last session with connection-related error
[Poll] : A poll will be required

"human-readable form" means, for example :
1H 49M 37S   meaning : 1 hour, 49 minutes and 37 seconds


Notes :
 Please run uucico in -x2 (or more) mode
 Must be setuid uucp in order to touch the /var/spool/uucp ... files
 Tested with a dial-out only system under Linux 1.1.x, gcc 2.x and Taylor
 UUCP 1.06.1


---------------------------------
Installation :
 - edit the section of user-configurable options (see below)

 - compile in "config test and debug" mode :
		gcc uuPollChk.C -DCONFIG_TST -o uuPollChk

Please become root to perform the next two steps :
 chown uucp uuPollChk
 chmod a+rx,u+s uuPollChk 

 - invoke it :
 ./uuPollChk


 - Correct the errors if necessary (then recompile ...)

When it works :
 - recompile a standard binary :
	gcc -s -O2 uuPollChk.C -o uuPollChk

Please become root to perform the next three steps :
 chown uucp uuPollChk
 chmod a+rx,u+rxs uuPollChk 
 - copy it in the directory used by the genric UUCP binaries
   (usually /usr/local/bin)

 - invoke it periodically

I invoke it via the crontab of the root account :
44 0-23 * * * /usr/local/bin/uuPollChk &> /dev/null

and to my ~/.bash_profile :
/usr/local/bin/uuPollChk

---------------------------------

TODO :
 - AnalyzeSessions : is ErrorsStr[] complete ?
 - Test this piece of crap with a system accepting incoming calls
 - Provide locking-file presence report even for multi-modems machines
 - Some "DEV" comments (check it out)
*/

#define VERSION "0.54"


#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

typedef struct
{
	char *SysName;	// Name of the remote UUCP, followed by a space char
	char SysNameLen;	// Length of SysNameLen (including the final space char)
	long NbSecs;	// Max number of seconds without UUCP connection

  /*
    Divisor applied to NbSecs when evaluating the necessity of a poll if the
    last poll had suffered from a connection-related error
    Put a huge value if you want a rapid poll request after a bad connection.
    Minimum value : 1
    */
	unsigned char SessionErrorDivisor;

	long TempValue;	// Do not use, let "-1"
	char SessionError;	// Do not use, let "1"
} PollCfg_st;

const long SecsPerDay = 86400;	// Number of seconds in each day

// ############################################################	
// Begining of the section containing user-configurable options

// Where is Ur Tayor Log file ?
const char UUCP_TAYLOR_LOG_FILENAME[]="/var/log/uucp/Log";

const char UUCP_SPOOL_DIR[]="/var/spool/uucp/";

// Where is your lock file (only one, sorry)
const char UUCP_LOCK_FILE_NAME[]="/var/lock/LCK..modem";

/* Substring searching in Log file "uucico"-related lines will begin at this
offset
The value covers the first (static) fields :
uucico x - (DATE HOUR P)

Do not change it if you don't understand!
*/
const int OffsetOnLogLine=37;
/*
Amount of trailing bytes analyzed in the Log file at the first pass.
Provided in order to minimize the I/O activity.
Note : uuPollChk will theoritically NEVER fail since the parser slurps the
file by chunks, starting at the last one and going up to the beginning
while last sessions of all systems are not found.
Please see ParseLogFile

This value varies with the volume of data transmited via UUCP, the uucico
debug level (-x) and the number of systems (UUCP hosts)

If you do not understand that ... please move along without modifying
*/
const long BytesAnalyzed=32768;


/*
Main cfg (Ouch. Dirty. Sorry. It is a hack)
*/

// DEV : Author's configuration :
PollCfg_st PollCfg[]=\
{
  {"frmug ", 6, SecsPerDay + SecsPerDay/2, 3, -1, 1}
    //  {"keltia ", 7, 8*SecsPerDay, 3, -1, 1},
};

/*
(useless) example with (boring) comments :

 {"boom ", 8, 600, 2, -1, 1}

"boom " : the UUCP (remote) system named "boom"
          Must appear if you do a "uuname -a"
          (beware : a space char MUST terminate the name in this field)

5 : length of the preceeding field (including the terminating space char)

600 : number of seconds max. between two successive calls (unit : second)
      Here : 10 minutes
			You may use "SecsPerDay" (for "a day") or any multiple

2 : influence of a bad connection.
    1  : a session with errors will not shorten the delay (see field 3)
   ...
   100 : a session with errors will divide the latency between two calls
         (field 3) by 100
... and so on ...

-1 : pliz do let this field at this value

1 : same as above
*/

// Comment out the next define if you want forced polling of all systems if
// the Log file is empty (or non existant) or contains no trace of activity
// for the system
//#define POLL_ON_EMPTY_LOGFILE

/* End of main config. */

// No more user parameters!
// ***************************************************************

// Please send me your diff files (indicate the version U use)
// if you modify anything below

#ifndef CONFIG_TST
#define NDEBUG
#endif

#include <assert.h>


#define min(a,b) ((a) <= (b) ? (a) : (b))

void Warn(const char *Msg, ...)
{
  va_list Arg;

  va_start(Arg, Msg);
  vfprintf(stderr, Msg, Arg);
  va_end(Arg);
  fprintf(stderr, "\n");
}

void Die(int ErrCod, const char *Msg, ...)
{
  va_list Arg;

	fflush(stdout);
  fprintf(stderr, "\n\n-> ERROR : ");
  va_start(Arg, Msg);
  vfprintf(stderr, Msg, Arg);
  va_end(Arg);
  fprintf(stderr, "\n");
	exit(ErrCod);
}

int	AnalyzeSessions(FILE *Fil_Log, PollCfg_st *Sys)
{
  /*
    Must be called after ParseLogFile complete analysis.
    Analyzes the last session for all systems by parsing Log file lines between
    "Login success" and "Call complete"

    Returns 0 if error
    */

	static char Buf[256], *CPnt;
	long CrtOffLog;
	int Rep;
  const int NBSTRERR=6;
	static char *ErrorsStr[NBSTRERR]=
  {"Got hangup signal", \
   "Got termination signal", \
   "Line disconnected", \
   "Received unexpected CLOSE packet", \
   "Timed out waiting for packet", \
   "Too many '"};


	fseek(Fil_Log, Sys->TempValue, SEEK_SET);

// DEV : recuperer ici heure de debut de connexion

	while ( (CrtOffLog=ftell(Fil_Log)) != -1)
		{
      if (fgets(Buf, sizeof(Buf)*sizeof(char), Fil_Log)==NULL)
        break;
      if (strncmp(Buf, "uucico", 6)!=0)
        continue;

      if (strncmp(&Buf[7], Sys->SysName, Sys->SysNameLen)!=0)
        continue;
      
      if (strstr(&Buf[OffsetOnLogLine], "Call complete (") != NULL)
        {
          Sys->TempValue=CrtOffLog;
          // DEV : recuperer heure de fin de connexion et calculer duree appel
          // DEV : indiquer aussi si appel en cours (non encore "Call complete")
          return(1);
        }

      if ( (CPnt = strstr(&Buf[OffsetOnLogLine], "ERROR: ")) == NULL)
        continue;
      CPnt+=7;

      for (Rep=0; Rep<NBSTRERR; Rep++)
        {
          if (strstr(CPnt, ErrorsStr[Rep])!=NULL)
            {
              Sys->SessionError=Sys->SessionErrorDivisor;
              break;
            }
        }
		}
	return(!ferror(Fil_Log));
}

int ParseLogFile(FILE *Fil_Log, long Bytes, long FileLen)
{
  /*
    Finds, for all systems, the last "Login success" line in the Log file
    between line after offset "Byte" and before the last line analyzed in a
    preceeding call

    Returns 0 if error
    */

	static char Buf[256];
	static long LastOffsetAnalyzed=FileLen;
	unsigned int RepSys;
  long CrtOffLog=0;

	assert(FileLen >= Bytes);
	fseek(Fil_Log, -Bytes, SEEK_END);

  fgets(Buf, sizeof(Buf)*sizeof(char), Fil_Log);

	if (ferror(Fil_Log))
		Die(20, "Can not read the Log file");

	while ( (CrtOffLog = ftell(Fil_Log)) != -1)
		{
      if (CrtOffLog >= LastOffsetAnalyzed)
        break;

      if (fgets(Buf, sizeof(Buf)*sizeof(char), Fil_Log)==NULL)
        return(!ferror(Fil_Log));
      if (strncmp(Buf, "uucico", 6) != 0)
        continue;

      if (strstr(&Buf[OffsetOnLogLine], "Handshake successful")==NULL)
        continue;
      for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
        {
          if (strncmp(&Buf[7], PollCfg[RepSys].SysName, PollCfg[RepSys].SysNameLen)==0)
            {
              if (PollCfg[RepSys].TempValue < CrtOffLog)
                PollCfg[RepSys].TempValue=CrtOffLog;
              break;
            }
        }
		}
	LastOffsetAnalyzed=FileLen-Bytes;
	return(!ferror(Fil_Log));
}

typedef struct
{
	const char *Unit;
	long SecAmount;
} TimeDiv_ty;

void RuptSecs(long &NbSecs, const TimeDiv_ty &Tim)
{
	if (NbSecs < Tim.SecAmount)
		return;

	if (islower(Tim.Unit[0]))
		{
      printf("%ld %s", NbSecs / Tim.SecAmount, Tim.Unit);
      if (NbSecs / Tim.SecAmount > 1)
        printf("s ");
      else
        putchar(' ');
		}
	else
		printf("%ld%s ", NbSecs / Tim.SecAmount, Tim.Unit);
	NbSecs %= Tim.SecAmount;
}

void CreatePollFile(const char *SysName, int LenName)
{
	char Buf[256];
	FILE *Fil_Tmp;

	strcpy(Buf, UUCP_SPOOL_DIR);
	strncat(Buf, SysName, LenName);
	strcat(Buf, "/C./C.A0000");
	if (access(Buf, R_OK)==-1)
		{
      Fil_Tmp = fopen(Buf, "w");
      if (Fil_Tmp == NULL)
        Die(112, "Cannot create %s", Buf);
      fclose(Fil_Tmp);
		}
}

int main(void)
{
	const TimeDiv_ty TimeDiv[]={{"week", SecsPerDay*7}, {"day", SecsPerDay},{"H", 3600},{"M", 60}, {"S", 1}};
	FILE *Fil_Log;
	unsigned int RepSys;
  int DoPoll;
	long FileLen, BytesAna, TmpL;
	char Buf[256], *CPnt, FirstDate[23];
	struct tm Time;
	time_t Now;

	printf("uuPollChk %s (last UUCP sessions, device status is : %s)\n", VERSION, access(UUCP_LOCK_FILE_NAME, R_OK) ? "AVAILABLE" : "LOCKED");

#ifdef CONFIG_TST
	char Error=0;

	if (BytesAnalyzed<512)
		{
      fprintf(stderr, "DEBUG/ Bad BytesAnalyzed value (must be>512)\n");
      Error=1;
		}
		
	for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
		{
      if (strlen(PollCfg[RepSys].SysName)==0)
        {
          fprintf(stderr, "DEBUG/ Bad configuration : PollCfg[%d].SysName is illegal\n", RepSys);
          Error=1;
        }

      if (strlen(PollCfg[RepSys].SysName) != PollCfg[RepSys].SysNameLen)
        {
          fprintf(stderr, "DEBUG/ Bad configuration : PollCfg[%d].SysNameLen is illegal (must be %d)\n", RepSys, strlen(PollCfg[RepSys].SysName));
          Error=1;
        }

      if (PollCfg[RepSys].NbSecs<300)
        fprintf(stderr, "DEBUG/ PollCfg[%d].NbSecs : strange value !\n", RepSys);

      if (PollCfg[RepSys].SessionErrorDivisor<1)
        {
          fprintf(stderr, "DEBUG/ Bad configuration : PollCfg[%d].SessionErrorDivisor is illegal (must be >0)\n", RepSys);
          Error=1;
        }

      if (PollCfg[RepSys].TempValue!=-1)
        {
          fprintf(stderr, "DEBUG/ Bad configuration : PollCfg[%d].TempValue is illegal (must be -1)\n", RepSys);
          Error=1;
        }

      if (PollCfg[RepSys].SessionError!=1)
        {
          fprintf(stderr, "DEBUG/ Bad configuration : PollCfg[%d].SessionError is illegal (must be 1)\n", RepSys);
          Error=1;
        }
		}
	if (Error)
		Die(99, "EXITING");
#endif

	Time.tm_isdst=-1;

  Fil_Log = fopen(UUCP_TAYLOR_LOG_FILENAME, "r");
  if (Fil_Log == NULL)
		{
#ifdef POLL_ON_EMPTY_LOGFILE
      for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
        CreatePollFile(PollCfg[RepSys].SysName, PollCfg[RepSys].SysNameLen-1);
      Die( 11, "Log file does not exists : pollings requested");
#else
      Die(4, "Cannot open the Log file");
#endif
		}
  // Get the date in the first line of the Log file
	if (fgets(Buf, sizeof(Buf)*sizeof(char), Fil_Log)==NULL)
		{
#ifdef POLL_ON_EMPTY_LOGFILE
      if (feof(Fil_Log))
        {
          for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
            CreatePollFile(PollCfg[RepSys].SysName, PollCfg[RepSys].SysNameLen-1);
          Die( 11, "Log file is empty");
        }
#else
      Die(6, "Log file : read error");
#endif
		}
	CPnt=strchr(Buf, '(');
	if (CPnt==NULL)
		Die(11, "Strange first line in Log file");
	strncpy(FirstDate, CPnt+1, 22);

  // Get the size of the Log file
	fseek(Fil_Log, 0, SEEK_END);
	FileLen=ftell(Fil_Log);

	BytesAna=min(BytesAnalyzed, FileLen);
	while (ParseLogFile(Fil_Log, BytesAna, FileLen))
		{
      for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
        if (PollCfg[RepSys].TempValue==-1)
          break;
      if (RepSys == sizeof(PollCfg)/sizeof(PollCfg[0]))
        break;
      if (BytesAna==FileLen)
        break;
      BytesAna+=BytesAna/10;
      if (BytesAna > FileLen)
        BytesAna=FileLen;
		}
#ifndef NDEBUG
	if (BytesAna > 3 * BytesAnalyzed)
		Warn("Bytes read / BytesAnalyzed : %ld / %ld\n", BytesAna, BytesAnalyzed);
#endif

  if (ferror(Fil_Log))
		Die(5, "Cannot read");

	for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
		if (!AnalyzeSessions(Fil_Log, &PollCfg[RepSys]))
			break;

  if (ferror(Fil_Log))
		Die(19, "Cannot read");

	time(&Now);
	for (RepSys=0; RepSys<sizeof(PollCfg)/sizeof(PollCfg[0]); RepSys++)
		{
      if (PollCfg[RepSys].TempValue==-1)
        {
          printf("%-16s : no log since %.19s\n\n", PollCfg[RepSys].SysName, FirstDate);
#ifdef POLL_ON_EMPTY_LOGFILE
          CreatePollFile(PollCfg[RepSys].SysName, PollCfg[RepSys].SysNameLen-1);
#endif
          continue;
        }			

      fseek(Fil_Log, PollCfg[RepSys].TempValue, SEEK_SET);
      if (fgets(Buf, sizeof(Buf)*sizeof(char), Fil_Log)==NULL)
        Die(7, "Read error");

      CPnt=strchr(Buf, '(');
      if (CPnt==NULL)
        Die(15, "Strange first line in Log file (no date), byte offset %ld", PollCfg[RepSys].TempValue);

      Time.tm_sec=atoi(&CPnt[18]);
      Time.tm_min=atoi(&CPnt[15]);
      Time.tm_hour=atoi(&CPnt[12]);
      Time.tm_mday=atoi(&CPnt[9]);
      Time.tm_mon=atoi(&CPnt[6])-1;
      Time.tm_year=atoi(&CPnt[3]);

      PollCfg[RepSys].TempValue= Now - mktime(&Time);

      DoPoll = (PollCfg[RepSys].TempValue >= (PollCfg[RepSys].NbSecs/PollCfg[RepSys].SessionError));

      printf("%-16s : %.22s  %s%s", \
             PollCfg[RepSys].SysName, CPnt+1, \
             (PollCfg[RepSys].SessionError>1) ? "Err " : "    ", \
             DoPoll ? "Poll\n" : "\n");

      TmpL=PollCfg[RepSys].TempValue;
      int Rep=0;
      while (TmpL)
        RuptSecs(TmpL, TimeDiv[Rep++]);
      TmpL=PollCfg[RepSys].NbSecs-PollCfg[RepSys].TempValue;
      if (TmpL<0)
        {
          printf("ago    due since: ");
          TmpL=-TmpL;
        }
      else
        printf("ago    next poll: ");
      Rep=0;
      while (TmpL)
        RuptSecs(TmpL, TimeDiv[Rep++]);

      if (DoPoll)
        CreatePollFile(PollCfg[RepSys].SysName, PollCfg[RepSys].SysNameLen-1);

      puts("");
  	}
  if (fclose(Fil_Log)==EOF)
		Die(99, "Cannot close the Log file");
	return(0);
}