home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / uupoll068.lha / misc / uupoll067.lha / src / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-16  |  25.1 KB  |  784 lines
  1. /*
  2.                         UUPoll -- uucico polling server
  3.  
  4.       This programm is designed to provide us with the ability to
  5.     control the UUCP polling procedure in a more comfortable way.  It
  6.     controls the uucico command automatically, so we have not to think
  7.     about it.  Intead of invoking uucico manually with the desired
  8.     options all we have to do is calling this program with optional
  9.     arguments.
  10.  
  11.      Genesis     : Fri Sep 20 23:26:29 1991
  12.      Last Change : Fri Jun 19 14:47:01 1992
  13.  
  14.     Developed and debugged with SAS/C Compiler V5.10a
  15.     running under AmigaOS 2.04 (37.175), Workbench 2.04 (37.67)
  16.     on an european PAL-Amiga 2000 B Rev 4.4
  17.     with 3MB RAM and 16KB runtime stack.
  18.  
  19.                                        Ralf S. Engelschall
  20.                                        rse@angle.muc.sub.org
  21.                                                                             */
  22.  
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <dos.h>
  27.  
  28. #include <proto/exec.h>
  29. #include <proto/dos.h>
  30. #include <exec/types.h>
  31. #include <exec/nodes.h>
  32. #include <exec/tasks.h>
  33. #include <exec/ports.h>
  34. #include <devices/timer.h>
  35. #include <libraries/dos.h>
  36. #include <libraries/dosextens.h>
  37.  
  38. #include "cus.h"
  39. #include "proto.h"
  40. #include "defines.h"
  41. #include "dbg.h"
  42. #include "rev.h"
  43. #include "status.h"
  44.  
  45. #define DEFAULT_RETRIES         0
  46. #define DEFAULT_DELAY         0
  47. #define DEFAULT_RESTRICTION  0
  48. #define DEFAULT_PENDINGFILES 1
  49. #define DEFAULT_ARGS         "-7"
  50. #define DEFAULT_NOTIFYUSER     "postmaster"
  51.  
  52. #define JOBCTL_NOTSPECIFIED 0
  53. #define JOBCTL_SWITCH       1
  54. #define JOBCTL_ENABLE       2
  55. #define JOBCTL_DISABLE      3
  56.  
  57. #define CHECK_NOTSPECIFIED 0
  58. #define CHECK_TOABORT      1
  59. #define CHECK_TOBREAK      2
  60. #define CHECK_TOBREAK_DELAY 20
  61.  
  62. #define SPOOLDIR    "uuspool:"
  63. #define LOG            "uuspool:logfile"
  64. #define MODEMSETUP    "uulib:modemsetup"
  65. #define LSYS        "uulib:l.sys"
  66. #define CONFIG        "uulib:config"
  67. #define FIELD        "DefaultNode"
  68.  
  69. #define DEFAULT_EXECCMND "uuxqt"
  70. #define UUCICO_DOSNAME     "uucico"
  71.  
  72. /* dependend return codes from uucico release 1.15d */
  73. #define UUCICORC_SUCCESS                        0
  74. #define UUCICORC_FAILURE-IN-CALL-OR-PROTOCOL    5
  75. #define UUCICORC_BREAK-OR-SOFTWARE-ERROR        10
  76.  
  77. #define TIMERMODE_RESTRICTION  1L
  78. #define TIMERMODE_SURVIVAL     TIMERMODE_RESTRICTION << 1
  79. #define TIMERMODE_DELAY        TIMERMODE_SURVIVAL << 1
  80.  
  81. #define SURVIVALMODE_WHOLESESSION    1L
  82. #define SURVIVALMODE_ABORTION        SURVIVALMODE_WHOLESESSION << 1
  83. #define SURVIVALTIME_WHOLESESSION    60*60*3    /*  3 hours   */
  84. #define SURVIVALTIME_ABORTION        30        /* 30 seconds */
  85.  
  86. static char caSystem[RANGE_6BIT];
  87. static char caCmnd[RANGE_7BIT];
  88. static char caTmp[RANGE_7BIT];
  89. static char *cpaArgv[RANGE_7BIT];
  90. static char caEnvname[RANGE_6BIT];
  91.  
  92. struct timermsg {
  93.     struct timerequest tm_timereq;
  94.     UBYTE tm_timermode;
  95. };
  96.  
  97.  
  98. int main(int argc, char **argv)
  99. {
  100.     unsigned int nRetriesMax = DEFAULT_RETRIES;
  101.     unsigned int iRetries = 0;
  102.     unsigned int nDelay = DEFAULT_DELAY;
  103.     unsigned int nRestriction = DEFAULT_RESTRICTION;
  104.     signed   int nRestrictionTmp;
  105.     unsigned int wJobcontrol = JOBCTL_NOTSPECIFIED;
  106.     unsigned int nPendingFiles = DEFAULT_PENDINGFILES;
  107.     unsigned int wCheck = CHECK_NOTSPECIFIED;
  108.     unsigned int wInfo = HOSTINFO_NO;
  109.  
  110.     char opt;
  111.     char *optarg;
  112.     char *optstr;
  113.     int optidx;
  114.  
  115.     char *cpConfig = CONFIG;
  116.     char *cpLsys = LSYS;
  117.     char *cpArgs = DEFAULT_ARGS;
  118.     char *cpExeccmndá= DEFAULT_EXECCMND;
  119.     char *cpLog = LOG;
  120.     char *cpField = FIELD;
  121.     char *cpSystemá= NULL;
  122.     char *cpModemsetup = MODEMSETUP;
  123.     char *cpEnvvar = NULL;
  124.     char *cpNotifyuser = DEFAULT_NOTIFYUSER;
  125.  
  126.     BOOL fModemsetupá= FALSE;
  127.     BOOL fAlways = FALSE;
  128.     BOOL fProfane = FALSE;
  129.     BOOL fExeccmnd = FALSE;
  130.     BOOL fRestriction = FALSE;
  131.     BOOL fPendingwork = FALSE;
  132.     BOOL fNotifyuser = FALSE;
  133.     BOOL fWebreaked = FALSE;
  134.  
  135.     extern char caSystem[];
  136.     extern char caCmnd[];
  137.     extern char caTmp[];
  138.  
  139.     struct MsgPort *timerport = NULL;
  140.     struct MsgPort *forkport = NULL;
  141.     ULONG timerport_sigmask;
  142.     ULONG forkport_sigmask;
  143.     ULONG signals;
  144.     struct timermsg *timermsg_restriction = NULL;
  145.     struct timermsg *timermsg_survival = NULL;
  146.     struct timermsg *timermsg_delay = NULL;
  147.     struct timermsg *pMsg;
  148.     UBYTE timerdeviceflag_restriction = 0;
  149.     UBYTE timerdeviceflag_survival = 0;
  150.     UBYTE timerdeviceflag_delay = 0;
  151.     UBYTE active_timermsg = 0;
  152.     UBYTE survivalmode = 0;
  153.     struct ProcID *forkprocID = NULL;
  154.     struct FORKENV *forkprocENV = NULL;
  155.  
  156.     struct Process *PID;
  157.     char *cpProgname;
  158.     char *cp;
  159.     int rc = DOSRC_SUCCESS;
  160.  
  161.  
  162.     cpProgname = strlwr(argv[0]);
  163.     if (    (cp = strrchr(cpProgname, '/')) != NULL
  164.          ||    (cp = strrchr(cpProgname, ':')) != NULL    )
  165.         cpProgname = ++cp;
  166.     PID = (struct Process *)FindTask(NULL);
  167.     ulog(cpLog, cpProgname, "-", "Startup Release %s.%02d (%s) [PID:%02d]",
  168.         Version, Revision, Date, PID->pr_TaskNum);
  169.  
  170.  
  171.     dbg(2, "processing argument line\n");
  172.     optidx = 1;
  173.     optstr = "sSrdtueEnpcjx";
  174.     for ( ; (optarg = argopt(argc, argv, optstr, &optidx, &opt)) != NULL; ) {
  175.         switch(opt) {
  176.             case 's':    fProfane = FALSE;
  177.                         dbg(3, "fProfane = FALSE\n");
  178.                         if (*optarg != NUL) {
  179.                             cpSystem = strlwr(strcvt(optarg));
  180.                             dbg(3, "cpSystem = \"%s\"\n", cpSystem);
  181.                         }
  182.                         break;
  183.  
  184.             case 'S':    fProfane = TRUE;
  185.                         dbg(3, "fProfane = TRUE\n");
  186.                         if (*optarg != NUL) {
  187.                             cpSystem = strlwr(strcvt(optarg));
  188.                             dbg(3, "cpSystem = \"%s\"\n", cpSystem);
  189.                         }
  190.                         break;
  191.  
  192.             case 'r':    nRetriesMax = abs(atoi(optarg));
  193.                         dbg(3, "nRetriesMax = %d\n", nRetriesMax);
  194.                         break;
  195.  
  196.             case 'd':    nDelay = abs(atoi(optarg));
  197.                         dbg(3, "nDelay = %d\n", nDelay);
  198.                         break;
  199.  
  200.             case 't':    nRestriction = abs(atoi(optarg));
  201.                         fRestriction = TRUE;
  202.                         dbg(3, "nRestriction = %d\n", nRestriction);
  203.                         break;
  204.  
  205.             case 'u':    cpArgs = strcvt(optarg);
  206.                         dbg(3, "cpArgs = \"%s\"\n", cpArgs);
  207.                         break;
  208.  
  209.             case 'm':    fModemsetup= TRUE;
  210.                         dbg(3, "fModemsetup = TRUE\n");
  211.                         break;
  212.  
  213.             case 'e':    fExeccmnd = FALSE;
  214.                         dbg(3, "fExeccmnd = FALSE\n");
  215.                         cpExeccmnd = strcvt(optarg);
  216.                         dbg(3, "cpExeccmnd = \"%s\"\n", cpExeccmnd);
  217.                         break;
  218.  
  219.             case 'E':    fExeccmnd = TRUE;
  220.                         dbg(3, "fExeccmnd = TRUE\n");
  221.                         if (*optarg != NUL) {
  222.                             cpExeccmnd = strcvt(optarg);
  223.                             dbg(3, "cpExeccmnd = \"%s\"\n", cpExeccmnd);
  224.                         }
  225.                         break;
  226.  
  227.             case 'a':    fAlways = TRUE;
  228.                         dbg(3, "fAlways = TRUE\n");
  229.                         break;
  230.  
  231.             case 'p':    fPendingwork = TRUE;
  232.                         dbg(3, "fPendingwork = TRUE\n");
  233.                         if (*optarg != NUL) {
  234.                             nPendingFiles = abs(atoi(optarg));
  235.                             dbg(3, "nPendingFiles = %d\n", nPendingFiles);
  236.                         }
  237.                         break;
  238.  
  239.             case 'j':    if (*optarg != NUL) {
  240.                             if (abs(atoi(optarg)) == 0) {
  241.                                 wJobcontrol = JOBCTL_DISABLE;
  242.                                 dbg(3, "wJobcontrol = JOBCTL_DISABLE\n");
  243.                             }
  244.                             else {
  245.                                 wJobcontrol = JOBCTL_ENABLE;
  246.                                 dbg(3, "wJobcontrol = JOBCTL_ENABLE\n");
  247.                             }
  248.                         }
  249.                         else {
  250.                             wJobcontrol = JOBCTL_SWITCH;
  251.                             dbg(3, "wJobcontrol = JOBCTL_SWITCH\n");
  252.                         }
  253.                         break;
  254.  
  255.             case 'c':    if (*optarg != NUL && abs(atoi(optarg)) == 1) {
  256.                             wCheck = CHECK_TOBREAK;
  257.                             dbg(3, "wCheck = CHECK_TOBREAK\n");
  258.                         }
  259.                         else {
  260.                             wCheck = CHECK_TOABORT;
  261.                             dbg(3, "wCheck = CHECK_TOABORT\n");
  262.                         }
  263.                         break;
  264.  
  265.             case 'n':    fNotifyuser = TRUE;
  266.                         dbg(3, "fNotifyuser = TRUE\n");
  267.                         if (*optarg != NUL) {
  268.                             cpNotifyuser = strcvt(optarg);
  269.                             dbg(3, "cpNotifyuser = \"%s\"\n", cpNotifyuser);
  270.                         }
  271.                         break;
  272.  
  273.             case 'x':    dbglevel = abs(atoi(optarg));
  274.                         break;
  275.  
  276.             case 'i':    if (*optarg != NUL) {
  277.                             if (abs(atoi(optarg)) == 0) {
  278.                                 wInfo = HOSTINFO_SHORT;
  279.                                 dbg(3, "wInfo = HOSTINFO_SHORT\n");
  280.                             }
  281.                             else {
  282.                                 wInfo = HOSTINFO_LONG;
  283.                                 dbg(3, "wInfo = HOSTINFO_LONG\n");
  284.                             }
  285.                         }
  286.                         else {
  287.                             wInfo = HOSTINFO_SHORT;
  288.                             dbg(3, "wInfo = HOSTINFO_SHORT\n");
  289.                         }
  290.                         break;
  291.  
  292.             case 'v':    dbg(2, "giving version info\n");
  293.                         giveversioninfo(cpProgname);
  294.                         CU(DOSRC_SUCCESS);
  295.  
  296.             case '?':    dbg(2, "giving usage info\n");
  297.                         giveusage(cpProgname);
  298.                         CU(DOSRC_SUCCESS);
  299.  
  300.             default :    ulog(cpLog, cpProgname, "-", "Ignored bad option '%c'", opt);
  301.         }
  302.     }
  303.     for ( ; optidx < argc; optidx++)
  304.         ulog(cpLog, cpProgname, "-", "Ignored arg '%s'", argv[optidx]);
  305.  
  306.     if (cpSystem == NULL) {
  307.         dbg(2, "getting default system name\n");
  308.         if ((cpSystem = getfield(cpConfig, cpField, caSystem)) == NULL) {
  309.             ulog(cpLog, cpProgname, "-", "Failed because cannot get default hostname from '%s' field of '%s'", cpField, cpConfig);
  310.             CU(DOSRC_FAIL);
  311.         }
  312.         truncdomain(cpSystem);
  313.         dbg(2, "cpSystem = \"%s\"\n", cpSystem);
  314.     }
  315.  
  316.     if (!inlsys(cpLsys, cpSystem)) {
  317.         ulog(cpLog, cpProgname, "-", "Failed due to invalid hostname: %s", cpSystem);
  318.         CU(DOSRC_FAIL);
  319.     }
  320.  
  321.     if (wInfo != HOSTINFO_NO) {
  322.         dbg(2, "giving info about current status\n");
  323.         hostinfo(cpProgname, cpLsys, cpConfig, cpSystem, wInfo);
  324.         CU(DOSRC_SUCCESS);
  325.     }
  326.  
  327.     sprintf(caEnvname, "%s.JOBCTL", cpProgname);
  328.     if ((cpEnvvar = getenv(caEnvname)) == NULL) {
  329.         ulog(cpLog, cpProgname, "-", "Failed to get job control enviroment %s", caEnvname);
  330.             sprintf(caEnvname, "%s.JOBCTL=ENABLE", cpProgname);
  331.             strupr(caEnvname);
  332.             if (putenv(caEnvname) != 0)
  333.                 ulog(cpLog, cpProgname, cpSystem, "Failed to set new job control enviroment %s", caEnvname);
  334.     }
  335.  
  336.     if (wJobcontrol != JOBCTL_NOTSPECIFIED) {
  337.         switch(wJobcontrol) {
  338.             case JOBCTL_SWITCH :    if (strcmp(cpEnvvar, "DISABLE") == 0)
  339.                                         strcpy(caTmp, "ENABLE");
  340.                                     else
  341.                                         strcpy(caTmp, "DISABLE");
  342.                                     break;
  343.             case JOBCTL_ENABLE :    strcpy(caTmp, "ENABLE");
  344.                                     break;
  345.             case JOBCTL_DISABLE :    strcpy(caTmp, "DISABLE");
  346.                                     break;
  347.         }
  348.         sprintf(caEnvname, "%s.JOBCTL=%s", cpProgname, caTmp);
  349.         strupr(caEnvname);
  350.         if (putenv(caEnvname) != 0)
  351.             ulog(cpLog, cpProgname, cpSystem, "Failed to set new job control enviroment %s", caEnvname);
  352.         CU(DOSRC_SUCCESS);
  353.     }
  354.  
  355.     if (strcmp(cpEnvvar, "DISABLE") == 0) {
  356.         ulog(cpLog, cpProgname, "-", "Abort because we are currently disabled");
  357.         CU(DOSRC_SUCCESS);
  358.     }
  359.  
  360.     if (wCheck != CHECK_NOTSPECIFIED) {
  361.         if (IsProcRunning(UUCICO_DOSNAME)) {
  362.             switch(wCheck) {
  363.                 case CHECK_TOABORT :
  364.                     ulog(cpLog, cpProgname, cpSystem, "abort due to `check' option and a already running uucico process");
  365.                     CU(DOSRC_SUCCESS);
  366.                 case CHECK_TOBREAK :
  367.                     ulog(cpLog, cpProgname, cpSystem, "sending break signal to still running uucico process due to `check' option");
  368.                     BreakProc(UUCICO_DOSNAME);
  369.                     ulog(cpLog, cpProgname, cpSystem, "waiting %d seconds sending break signal to still running uucico process due to `check' option", CHECK_TOBREAK_DELAY);
  370.                     Delay(50*CHECK_TOBREAK_DELAY);
  371.                     break;
  372.             }
  373.         }
  374.     }
  375.  
  376.     if (!fProfane) {
  377.         dbg(2, "calculating restriction time\n");
  378.         if ((nRestrictionTmp = timerestriction(cpLsys, cpSystem)) == -1) {
  379.             printf("polling time violation for host %s\n", cpSystem);
  380.             ulog(cpLog, cpProgname, cpSystem, "Failed due to polling time violation for host %s", cpSystem);
  381.             CU(DOSRC_FAIL);
  382.         } else {
  383.             if (nRestriction == 0)
  384.                 nRestriction = nRestrictionTmp;
  385.             dbg(2, "nRestriction = %d\n", nRestriction);
  386.         }
  387.     } else {
  388.         if (!fRestriction) {
  389.             dbg(2, "setting restriction time to zero due to left option and profanation\n");
  390.             nRestriction = 0;
  391.         }
  392.     }
  393.  
  394.     if (fAlways) {
  395.         dbg(2, "setting enviroment of system \"%s\" to 'FAILED' because of 'always' option\n", cpSystem);
  396.         sprintf(caEnvname, "%s.%s=FAILED", cpProgname, cpSystem);
  397.         strupr(caEnvname);
  398.         if (putenv(caEnvname) != 0) {
  399.             ulog(cpLog, cpProgname, cpSystem, "Failed to set enviroment %s", caEnvname);
  400.         }
  401.     } else {
  402.         dbg(2, "getting enviroment of system \"%s\"\n", cpSystem);
  403.         sprintf(caEnvname, "%s.%s", cpProgname, cpSystem);
  404.         if ((cpEnvvar = getenv(caEnvname)) == NULL) {
  405.             ulog(cpLog, cpProgname, cpSystem, "Failed to get enviroment %s", caEnvname);
  406.             sprintf(caEnvname, "%s.%s=FAILED", cpProgname, cpSystem);
  407.             strupr(caEnvname);
  408.             if (putenv(caEnvname) != 0)
  409.                 ulog(cpLog, cpProgname, cpSystem, "Failed to set new enviroment %s", caEnvname);
  410.         } else {
  411.             if (fPendingwork && nPendingFiles > 0) {
  412.                 if (!PendingWork(SPOOLDIR, cpSystem, nPendingFiles)) {
  413.                     ulog(cpLog, cpProgname, cpSystem, "Abort because not enough or no pending work for host %s", cpSystem);
  414.                     CU(DOSRC_SUCCESS);
  415.                 }
  416.             }
  417.             else {
  418.                 if (strcmp(cpEnvvar, "SUCCESSFUL") == 0) {
  419.                     ulog(cpLog, cpProgname, cpSystem, "Abort because last time we had polled already successful");
  420.                     CU(DOSRC_SUCCESS);
  421.                 }
  422.             }
  423.         }
  424.     }
  425.  
  426.     ulog(cpLog, cpProgname, cpSystem, "OK Startup");
  427.  
  428.  
  429.     dbg(2, "create env of forkprocess\n");
  430.     dbg(3, "create fork msgport\n");
  431.     if ((forkport = CreatePort(0, 0)) == NULL)
  432.         CU(DOSRC_FAIL);
  433.     dbg(3, "alloc mem for forkprocess ID struct\n");
  434.     if ((forkprocID = (struct ProcID *)calloc(sizeof(struct ProcID), 1)) == NULL)
  435.         CU(DOSRC_FAIL);
  436.     dbg(3, "alloc mem for forkprocess ENV struct\n");
  437.     if ((forkprocENV = (struct FORKENV *)calloc(sizeof(struct FORKENV), 1)) == NULL)
  438.         CU(DOSRC_FAIL);
  439.  
  440.  
  441.     dbg(2, "create env of timers\n");
  442.     dbg(3, "create timer msgport\n");
  443.     if ((timerport = CreatePort(0, 0)) == NULL)
  444.         CU(DOSRC_FAIL);
  445.  
  446.     dbg(3, "create IORequest struct for restriction timer\n");
  447.     if ((timermsg_restriction = (struct timermsg *)CreateExtIO(timerport, sizeof(struct timermsg))) == NULL)
  448.         CU(DOSRC_FAIL);
  449.     dbg(3, "open timer.device for restriction timer\n");
  450.     if ((timerdeviceflag_restriction = OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *)timermsg_restriction, 0)) != NULL)
  451.         CU(DOSRC_FAIL);
  452.  
  453.     dbg(3, "create IORequest struct for survival timer\n");
  454.     if ((timermsg_survival = (struct timermsg *)CreateExtIO(timerport, sizeof(struct timermsg))) == NULL)
  455.         CU(DOSRC_FAIL);
  456.     dbg(3, "open timer.device for survival timer\n");
  457.     if ((timerdeviceflag_survival = OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *)timermsg_survival, 0)) != NULL)
  458.         CU(DOSRC_FAIL);
  459.  
  460.     dbg(3, "create IORequest struct for delay timer\n");
  461.     if ((timermsg_delay = (struct timermsg *)CreateExtIO(timerport, sizeof(struct timermsg))) == NULL)
  462.         CU(DOSRC_FAIL);
  463.     dbg(3, "open timer.device for delay timer\n");
  464.     if ((timerdeviceflag_delay = OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *)timermsg_delay, 0)) != NULL)
  465.         CU(DOSRC_FAIL);
  466.  
  467.  
  468.     if (nRestriction) {
  469.         timermsg_restriction->tm_timereq.tr_node.io_Command = TR_ADDREQUEST;
  470.         timermsg_restriction->tm_timereq.tr_time.tv_secs = nRestriction * 60 - (fRestriction ? 0 : 30);
  471.         timermsg_restriction->tm_timereq.tr_time.tv_micro = 0;
  472.         timermsg_restriction->tm_timermode = TIMERMODE_RESTRICTION;
  473.         dbg(2, "starting restriction timer with %d seconds\n", timermsg_restriction->tm_timereq.tr_time.tv_secs);
  474.         SendIO((struct IORequest *)timermsg_restriction);
  475.         active_timermsg = active_timermsg | TIMERMODE_RESTRICTION;
  476.     }
  477.  
  478.     timermsg_survival->tm_timereq.tr_node.io_Command = TR_ADDREQUEST;
  479.     timermsg_survival->tm_timereq.tr_time.tv_secs = SURVIVALTIME_WHOLESESSION;
  480.     timermsg_survival->tm_timereq.tr_time.tv_micro = 0;
  481.     timermsg_survival->tm_timermode = TIMERMODE_SURVIVAL;
  482.     dbg(2, "starting survival timer with %d seconds\n", timermsg_survival->tm_timereq.tr_time.tv_secs);
  483.     SendIO((struct IORequest *)timermsg_survival);
  484.     active_timermsg = active_timermsg | TIMERMODE_SURVIVAL;
  485.     survivalmode = SURVIVALMODE_WHOLESESSION;
  486.  
  487.  
  488.     if (fModemsetup) {
  489.         dbg(2, "setting up modem\n");
  490.         if (!setupmodem(cpModemsetup, cpLsys, cpSystem)) {
  491.             ulog(cpLog, cpProgname, cpSystem, "Modem setup failed");
  492.             CU(DOSRC_FAIL);
  493.         }
  494.         ulog(cpLog, cpProgname, cpSystem, "Modem setup successful");
  495.     }
  496.  
  497.     for ( ; ; ) {
  498.         dbg(2, "(re)entering outer loop (spawn loop)\n");
  499.  
  500.         if (iRetries == 0)
  501.             ulog(cpLog, cpProgname, cpSystem, "Trying to poll host");
  502.         else
  503.             ulog(cpLog, cpProgname, cpSystem, "Retrying (#%d) to poll host", iRetries);
  504.  
  505.         forkprocENV->priority = (long)(PID->pr_Task.tc_Node.ln_Pri);
  506.         forkprocENV->stack    = (long)(PID->pr_StackSize);
  507.         forkprocENV->std_in   = (long)(PID->pr_CIS);
  508.         forkprocENV->std_out  = (long)(PID->pr_COS);
  509.         forkprocENV->console  = (long)(PID->pr_WindowPtr);
  510.         forkprocENV->msgport  = forkport;
  511.  
  512.         sprintf(caCmnd, "%s -%s%s %s", UUCICO_DOSNAME, (fProfane) ? "S" : "s", cpSystem, cpArgs);
  513.         dbg(2, "forking: %s\n", caCmnd);
  514.         splitarg(cpaArgv, caCmnd);
  515.  
  516.         if (forkv(UUCICO_DOSNAME, cpaArgv, forkprocENV, forkprocID) == -1) {
  517.             ulog(cpLog, cpProgname, cpSystem, "FAILED because cannot fork %s %s", UUCICO_DOSNAME, caCmnd);
  518.             CU(DOSRC_FAIL);
  519.         }
  520.  
  521.         for ( ; ; ) {
  522.             dbg(2, "(re)entering inner loop (wait loop)\n");
  523.  
  524.             dbg(2, "go sleeping until wakeup\n");
  525.             timerport_sigmask = 1L << timerport->mp_SigBit;
  526.             forkport_sigmask = 1L << forkport->mp_SigBit;
  527.             signals = Wait( (ULONG)(timerport_sigmask | forkport_sigmask | SIGBREAKF_CTRL_C) );
  528.  
  529.  
  530.             if (signals & timerport_sigmask) {
  531.                 dbg(2, "awakened through timer interrupt\n");
  532.                 if (pMsg = (struct timermsg *)GetMsg(timerport)) {
  533.  
  534.                     if (pMsg->tm_timermode == TIMERMODE_SURVIVAL) {
  535.                         active_timermsg = active_timermsg & ~(TIMERMODE_SURVIVAL);
  536.  
  537.                         if (survivalmode == SURVIVALMODE_ABORTION) {
  538.                             ulog(cpLog, cpProgname, cpSystem, "interupted due to survival timeout for uucico abortion");
  539.                             survivalmode = survivalmode & ~(SURVIVALMODE_ABORTION);
  540.                             CU(DOSRC_FAIL);
  541.                         }
  542.                         if (survivalmode == SURVIVALMODE_WHOLESESSION) {
  543.                             ulog(cpLog, cpProgname, cpSystem, "interupted due to survival timeout for whole session");
  544.                             survivalmode = survivalmode & ~(SURVIVALMODE_WHOLESESSION);
  545.                             CU(DOSRC_FAIL);
  546.                         }
  547.                         continue;
  548.                     }
  549.  
  550.                     if (pMsg->tm_timermode == TIMERMODE_RESTRICTION) {
  551.  
  552.                         ulog(cpLog, cpProgname, cpSystem, "interupted due to restriction timeout of %d minute%s", nRestriction, (nRestriction != 1) ? "s" : "" );
  553.                         ulog(cpLog, cpProgname, cpSystem, "sending break signal to abort uucico process");
  554.                         Signal((struct Task *)(forkprocID->process), SIGBREAKF_CTRL_C);
  555.                         fWebreaked = TRUE;
  556.  
  557.                         dbg(2, "cancelling currently active survival timer\n");
  558.                         AbortIO((struct IORequest *)timermsg_survival);
  559.                         WaitIO((struct IORequest *)timermsg_survival);
  560.                         timermsg_survival->tm_timereq.tr_node.io_Command = TR_ADDREQUEST;
  561.                         timermsg_survival->tm_timereq.tr_time.tv_secs = SURVIVALTIME_ABORTION;
  562.                         timermsg_survival->tm_timereq.tr_time.tv_micro = 0;
  563.                         timermsg_survival->tm_timermode = TIMERMODE_SURVIVAL;
  564.                         dbg(2, "starting survival timer with %d seconds for abortion process\n", timermsg_survival->tm_timereq.tr_time.tv_secs);
  565.                         SendIO((struct IORequest *)timermsg_survival);
  566.                         active_timermsg = active_timermsg | TIMERMODE_SURVIVAL;
  567.                         survivalmode = SURVIVALMODE_ABORTION;
  568.  
  569.                         fExeccmnd = TRUE;
  570.                         dbg(3, "fExeccmnd = TRUE\n");
  571.                         continue;
  572.                     }
  573.  
  574.                     if (pMsg->tm_timermode == TIMERMODE_DELAY) {
  575.  
  576.                         ulog(cpLog, cpProgname, cpSystem, "interupted due to delay timer of %d second%s", nDelay, (nDelay != 1) ? "s" : "" );
  577.                         active_timermsg = active_timermsg & ~(TIMERMODE_DELAY);
  578.                         break;
  579.                     }
  580.  
  581.                 }
  582.             }
  583.  
  584.             if (signals & SIGBREAKF_CTRL_C) {
  585.                 dbg(2, "awakened through ctrl-c signal\n");
  586.                 ulog(cpLog, cpProgname, cpSystem, "interupted due to ctrl-c signal");
  587.  
  588.                 if (active_timermsg & TIMERMODE_DELAY) {
  589.                     dbg(2, "aborting delay timer\n");
  590.                     AbortIO((struct IORequest *)timermsg_delay);
  591.                     WaitIO((struct IORequest *)timermsg_delay);
  592.                     active_timermsg = active_timermsg & ~(TIMERMODE_DELAY);
  593.                     dbg(2, "cancelling currently active survival timer\n");
  594.                     AbortIO((struct IORequest *)timermsg_survival);
  595.                     WaitIO((struct IORequest *)timermsg_survival);
  596.                     CU(DOSRC_FAIL);
  597.                 }
  598.                 else {
  599.                     ulog(cpLog, cpProgname, cpSystem, "sending break signal to abort uucico process");
  600.                     Signal((struct Task *)(forkprocID->process), SIGBREAKF_CTRL_C);
  601.  
  602.                     dbg(2, "cancelling currently active survival timer\n");
  603.                     AbortIO((struct IORequest *)timermsg_survival);
  604.                     WaitIO((struct IORequest *)timermsg_survival);
  605.                     timermsg_survival->tm_timereq.tr_node.io_Command = TR_ADDREQUEST;
  606.                     timermsg_survival->tm_timereq.tr_time.tv_secs = SURVIVALTIME_ABORTION;
  607.                     timermsg_survival->tm_timereq.tr_time.tv_micro = 0;
  608.                     timermsg_survival->tm_timermode = TIMERMODE_SURVIVAL;
  609.                     dbg(2, "starting survival timer with %d seconds for abortion process\n", timermsg_survival->tm_timereq.tr_time.tv_secs);
  610.                     SendIO((struct IORequest *)timermsg_survival);
  611.                     active_timermsg = active_timermsg | TIMERMODE_SURVIVAL;
  612.                     survivalmode = survivalmode | SURVIVALMODE_ABORTION;
  613.  
  614.                     fExeccmnd = TRUE;
  615.                     dbg(3, "fExeccmnd = TRUE\n");
  616.                     continue;
  617.                 }
  618.             }
  619.  
  620.  
  621.             if (signals & forkport_sigmask) {
  622.                 dbg(2, "awakened through forkprocess termination\n");
  623.  
  624.                 rc = wait(forkprocID);
  625.  
  626.                 if (rc == 0) {
  627.                     dbg(2, "uucico was succesfull\n");
  628.                     ulog(cpLog, cpProgname, cpSystem, "finished (polling was successful)");
  629.  
  630.                     dbg(2, "setting enviroment to 'SUCCESSFUL'\n");
  631.                     sprintf(caEnvname, "%s.%s=SUCCESSFUL", cpProgname, cpSystem);
  632.                     strupr(caEnvname);
  633.                     if (putenv(caEnvname) != 0)
  634.                         ulog(cpLog, cpProgname, cpSystem, "Failed to set enviroment %s", caEnvname);
  635.  
  636.                     fExeccmnd = TRUE;
  637.                     dbg(3, "fExeccmnd = TRUE\n");
  638.                     CU(DOSRC_SUCCESS);
  639.                 }
  640.  
  641.                 if (rc == 5) {
  642.                     dbg(2, "uucico failure in call and/or protocol\n");
  643.                     iRetries++;
  644.                     if (iRetries > nRetriesMax) {
  645.                         if (nRetriesMax != 0)
  646.                             ulog(cpLog, cpProgname, cpSystem, "stopped due to max retries of %d", nRetriesMax);
  647.                         dbg(2, "setting enviroment to 'FAILED'\n");
  648.                         sprintf(caEnvname, "%s.%s=FAILED", cpProgname, cpSystem);
  649.                         strupr(caEnvname);
  650.                         if (putenv(caEnvname) != 0)
  651.                             ulog(cpLog, cpProgname, cpSystem, "Failed to set enviroment %s", caEnvname);
  652.  
  653.                         if (fNotifyuser) {
  654.                             ulog(cpLog, cpProgname, cpSystem, "notifying user `%s' about this failed session", cpNotifyuser);
  655.                             sprintf(caTmp, "session stopped due to max retries of %d", nRetriesMax);
  656.                             NotifyOnFailure(cpNotifyuser, cpSystem, caTmp);
  657.                         }
  658.                         CU(DOSRC_FAIL);
  659.                     }
  660.  
  661.                     if (nDelay) {
  662.                         timermsg_delay->tm_timereq.tr_node.io_Command = TR_ADDREQUEST;
  663.                         timermsg_delay->tm_timereq.tr_time.tv_secs = nDelay;
  664.                         timermsg_delay->tm_timereq.tr_time.tv_micro = 0;
  665.                         timermsg_delay->tm_timermode = TIMERMODE_DELAY;
  666.                         dbg(2, "starting delay timer with %d seconds for retry procedure\n", timermsg_delay->tm_timereq.tr_time.tv_secs);
  667.                         SendIO((struct IORequest *)timermsg_delay);
  668.                         active_timermsg = active_timermsg | TIMERMODE_DELAY;
  669.                         continue;
  670.                     }
  671.                     break;
  672.                 }
  673.  
  674.                 dbg(2, "uucico break/software failure\n");
  675.  
  676.                 if (survivalmode == SURVIVALMODE_ABORTION) {
  677.                     dbg(2, "cancelling currently active survival timer\n");
  678.                     AbortIO((struct IORequest *)timermsg_survival);
  679.                     WaitIO((struct IORequest *)timermsg_survival);
  680.                     survivalmode = survivalmode & ~(SURVIVALMODE_ABORTION);
  681.                 }
  682.  
  683.                 dbg(2, "setting enviroment to 'FAILED'\n");
  684.                 sprintf(caEnvname, "%s.%s=FAILED", cpProgname, cpSystem);
  685.                 strupr(caEnvname);
  686.                 if (putenv(caEnvname) != 0)
  687.                     ulog(cpLog, cpProgname, cpSystem, "Failed to set enviroment %s", caEnvname);
  688.  
  689.                 if (fNotifyuser) {
  690.                     if (fWebreaked) {
  691.                         ulog(cpLog, cpProgname, cpSystem, "notifying user `%s' about this failed session", cpNotifyuser);
  692.                         sprintf(caTmp, "session stopped due to restriction timeout of %d minute%s", nRestriction, (nRestriction != 1) ? "s" : "");
  693.                         NotifyOnFailure(cpNotifyuser, cpSystem, caTmp);
  694.                     }
  695.                 }
  696.  
  697.                 fExeccmnd = TRUE;
  698.                 dbg(3, "fExeccmnd = TRUE\n");
  699.                 CU(DOSRC_FAIL);
  700.             }
  701.  
  702.         }
  703.     }
  704.  
  705. CUS:
  706.     if (fExeccmnd && strlen(cpExeccmnd) > 0) {
  707.         ulog(cpLog, cpProgname, cpSystem, "Spawning %s", cpExeccmnd);
  708.         sprintf(caCmnd, "run <nil: >nil: %s", cpExeccmnd);
  709.         if (system(caCmnd) == -1)
  710.             ulog(cpLog, cpProgname, cpSystem, "Error spawning %s", cpExeccmnd);
  711.     }
  712.  
  713.     if (active_timermsg & TIMERMODE_DELAY) {
  714.         dbg(2, "aborting delay timer\n");
  715.         AbortIO((struct IORequest *)timermsg_delay);
  716.         WaitIO((struct IORequest *)timermsg_delay);
  717.         active_timermsg = active_timermsg & ~(TIMERMODE_DELAY);
  718.     }
  719.  
  720.     if (active_timermsg & TIMERMODE_RESTRICTION) {
  721.         dbg(2, "aborting restriction timer\n");
  722.         AbortIO((struct IORequest *)timermsg_restriction);
  723.         WaitIO((struct IORequest *)timermsg_restriction);
  724.         active_timermsg = active_timermsg & ~(TIMERMODE_RESTRICTION);
  725.     }
  726.  
  727.     if (active_timermsg & TIMERMODE_SURVIVAL) {
  728.         dbg(2, "aborting survival timer\n");
  729.         AbortIO((struct IORequest *)timermsg_survival);
  730.         WaitIO((struct IORequest *)timermsg_survival);
  731.         active_timermsg = active_timermsg & ~(TIMERMODE_SURVIVAL);
  732.     }
  733.  
  734.     dbg(2, "delete env of timers\n");
  735.     if (timerdeviceflag_delay) {
  736.         dbg(3, "closing timer.device of delay timer\n");
  737.         CloseDevice((struct IORequest *)timermsg_delay);
  738.     }
  739.     if (timerdeviceflag_restriction) {
  740.         dbg(3, "closing timer.device of restriction timer\n");
  741.         CloseDevice((struct IORequest *)timermsg_restriction);
  742.     }
  743.     if (timerdeviceflag_survival) {
  744.         dbg(3, "closing timer.device of survival timer\n");
  745.         CloseDevice((struct IORequest *)timermsg_survival);
  746.     }
  747.     if (timerport) {
  748.         dbg(3, "delete timer msgport\n");
  749.         DeletePort(timerport);
  750.     }
  751.     if (timermsg_delay) {
  752.         dbg(3, "delete IORequest struct of delay timer\n");
  753.         DeleteExtIO((struct IORequest *)timermsg_delay);
  754.     }
  755.     if (timermsg_restriction) {
  756.         dbg(3, "delete IORequest struct of restriction timer\n");
  757.         DeleteExtIO((struct IORequest *)timermsg_restriction);
  758.     }
  759.     if (timermsg_survival) {
  760.         dbg(3, "delete IORequest struct of surval timer\n");
  761.         DeleteExtIO((struct IORequest *)timermsg_survival);
  762.     }
  763.  
  764.     dbg(2, "delete env of forkprocess\n");
  765.     if (forkport) {
  766.         dbg(3, "delete fork msgport\n");
  767.         DeletePort(forkport);
  768.     }
  769.     if (forkprocENV) {
  770.         dbg(3, "freeing mem for ENV of forkprocess\n");
  771.         free(forkprocENV);
  772.     }
  773.     if (forkprocID) {
  774.         dbg(3, "freeing mem for ID of forkprocess\n");
  775.         free(forkprocID);
  776.     }
  777.  
  778.     ulog(cpLog, cpProgname, (cpSystem) ? cpSystem : "-", "OK Exit");
  779.     dbg(3, "rc = %d\n", rc);
  780.     dbg(2, "exit\n");
  781.     return rc;
  782. }
  783.  
  784.