home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / System / lpDaemon SRC / lpd Sources / Init.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-24  |  11.1 KB  |  417 lines  |  [TEXT/KAHL]
  1. /************************************************************************
  2.  *                                                                        *
  3.  *    Init.c                                                                *
  4.  *                                                                        *
  5.  *  Line Printer Daemon using TCP/IP printer protocol                    *
  6.  *                                                                        *
  7.  *        -------------- The initialisation routines --------------        *
  8.  *                                                                        *
  9.  *  Written by Casper Boon, August, 1992.                                *
  10.  *                                                                        *
  11.  *    © 1992 Casper Boon.                                                    *
  12.  *                                                                        *
  13.  ************************************************************************/
  14. #include "LPD.H"
  15. #include "CvtAddr.h"
  16. #include "Spooler.H"
  17. #include "lpdProtos.H"
  18. #include <Traps.H>
  19.  
  20.  
  21. Boolean TrapAvailable(integer tNumb, TrapType tType);
  22. void GetParameters(void);
  23.  
  24. /************************************************************************
  25.  *                                                                        *
  26.  * Normal Macintosh initialisations.                                    *
  27.  *                                                                        *
  28.  ************************************************************************/
  29. void Initialise()
  30. {
  31.     integer    i;
  32.     WindowPtr    WhichWindow;
  33.     Handle        menuBar;
  34.     SysEnvRec    envir;
  35.  
  36.     MaxApplZone();
  37.  
  38.     for (i = 0; i < 16; i++)
  39.         MoreMasters();
  40.  
  41.     ShowCursor();
  42.     InitGraf((Ptr)&thePort);
  43.     ShowCursor();
  44.     InitFonts();
  45.     ShowCursor();
  46.     FlushEvents(everyEvent, 0);
  47.     ShowCursor();
  48.     InitWindows();
  49.     InitMenus();
  50.     TEInit();
  51.     InitDialogs((ProcPtr) NIL);
  52.  
  53.     haveWaitEvnt = TrapAvailable(_WaitNextEvent, ToolTrap);
  54.     SysEnvirons(1, &envir);        /* look for at least 128K ROMS */
  55.     if (envir.machineType < 0)
  56.         {
  57.         AlertUser(eWrongROM);
  58.         ExitToShell();
  59.         }
  60.  
  61.     if ( !(menuBar = GetNewMBar(rMenuBar)) )
  62.         {
  63.         AlertUser(eNoMemory);
  64.         ExitToShell();
  65.         }
  66.  
  67.     SetMenuBar(menuBar);
  68.     DisposHandle(menuBar);
  69.     AddResMenu(GetMHandle(appleMenu), 'DRVR');
  70.     DrawMenuBar();
  71.  
  72.     InitCursor();
  73.     ShowCursor();
  74.     GetWMgrPort(&WhichWindow);
  75.     SetPort(WhichWindow);
  76.     screenRect = WhichWindow->portRect;
  77.     screenRect.top += MBarHeight;
  78.  
  79.     ShowCursor();
  80.  
  81.     cursRgn = NewRgn();
  82.  
  83. }
  84.  
  85. /************************************************************************
  86.  ************************************************************************/
  87. static Boolean TrapAvailable(integer tNumb, TrapType tType)
  88. {
  89.     return NGetTrapAddress(tNumb, tType) != GetTrapAddress(_Unimplemented);
  90. }
  91.  
  92. /************************************************************************
  93.  *                                                                        *
  94.  * Read a line from the configuration file. This repeats until it finds    *
  95.  * a line with something in it after stripping comments and white space    *
  96.  * from the start and end.                                                *
  97.  *                                                                        *
  98.  ************************************************************************/
  99. static integer ReadLn(integer f, char *ibuf)
  100. {
  101.     char c, *buf;
  102.     integer    len;
  103.     do    {
  104.         buf = ibuf; len = 1;
  105.  
  106.         /* skip white space */
  107.         do    { c = fgetc(f); }
  108.         while (c && (c == ' ' || c == '\t') );
  109.  
  110.         while (c && c != '\r' && c != '\n' && c != '#')
  111.             {
  112.             *buf++ = c; c = fgetc(f); len++;
  113.             }
  114.  
  115.         if (c == '#')    /* if it was a '#' skip to the end of line */
  116.             {
  117.             do    { c = fgetc(f); }
  118.             while ( c && c != '\r' && c != '\n' );
  119.             }
  120.  
  121.  
  122.         /* strip trailing spaces */
  123.         do    {
  124.             *buf-- = 0; len--;
  125.             }
  126.         while ( len > 0 && (*buf == ' ' || *buf == '\t') );
  127.         }
  128.     while ( !len && c );    /* c will be 0 on eof */
  129.  
  130.     return (len || c);
  131. }
  132.  
  133.  
  134. /************************************************************************
  135.  ************************************************************************/
  136. #define NO_CMMND    0
  137. #define PRINTER     1
  138. #define HOST        2
  139. #define ALIAS        3
  140. #define ADMIN        4
  141. #define CFA_STR        5
  142. #define NOMAIL        6
  143. #define NOACNT        7
  144. #define LASERWRTR    8
  145. #define DEBUG_CMD    9
  146. #define NO_ACTION    10
  147.  
  148.  
  149. /************************************************************************
  150.  ************************************************************************/
  151. char toupper(char c);
  152. char toupper(char c)
  153. {
  154.     if (c >= 'a' && c <= 'z')
  155.         return c - 'a' + 'A';
  156.     return c;
  157. }
  158.  
  159. /************************************************************************
  160.  *                                                                        *
  161.  * Convert a command string to a command number                            *
  162.  *                                                                        *
  163.  ************************************************************************/
  164. static char * GetCmmnd(char *buf, integer *cmmnd);
  165. char * GetCmmnd(char *buf, integer *cmmnd)
  166. {
  167.     char cmd[12];
  168.     integer    i = 0;
  169.     while (*buf && *buf != ' ' && *buf != '\t' && i < 11) cmd[i++] = toupper(*buf++);
  170.     cmd[i] = 0;
  171.     if (strcmp("PRINTER", cmd) == 0)             *cmmnd = PRINTER;
  172.     else if (strcmp("HOST", cmd) == 0)           *cmmnd = HOST;
  173.     else if (strcmp("ALIAS", cmd) == 0)          *cmmnd = ALIAS;
  174.     else if (strcmp("ADMIN", cmd) == 0)          *cmmnd = ADMIN;
  175.     else if (strcmp("CTLFIL", cmd) == 0)      *cmmnd = CFA_STR;
  176.     else if (strcmp("NOMAIL", cmd) == 0)      *cmmnd = NOMAIL;
  177.     else if (strcmp("NOACNT", cmd) == 0)      *cmmnd = NOACNT;
  178.     else if (strcmp("LASERWRITER", cmd) == 0) *cmmnd = LASERWRTR;
  179.     else if (strcmp("DEBUG", cmd) == 0)          *cmmnd = DEBUG_CMD;
  180.     else if (strcmp("NOACTION", cmd) == 0)      *cmmnd = NO_ACTION;
  181.     else                                      *cmmnd = NO_CMMND;
  182.  
  183.     while (*buf && (*buf == ' ' || *buf == '\t')) buf++;
  184.  
  185.     return buf;
  186. }
  187.  
  188.  
  189. /************************************************************************
  190.  *                                                                        *
  191.  * Read the configuration file.                                            *
  192.  *                                                                        *
  193.  ************************************************************************/
  194. integer ReadConfig()
  195. {
  196.     integer cfg_dir = GetLogDir();                  /* get the logging folder    */
  197.     integer    f, cmmnd;
  198.     char    buf[128], *str;
  199.     Str255    mess;
  200.  
  201.     CONFIG_Banner_Up();
  202.  
  203.     if (FSOpen("\pLPD.Config", cfg_dir, &f) != noErr)
  204.         {
  205.         AlertUser(eNoConfig);
  206.         FSClose(f);
  207.         Exit();
  208.         }
  209.  
  210.     while ( ReadLn(f, buf) )
  211.         {
  212.         str = GetCmmnd(buf, &cmmnd);
  213.  
  214.         psprintf(mess, " %s", buf);
  215.         PSTAT_Banner_Step(mess);
  216.  
  217.         switch (cmmnd)
  218.             {
  219.             case PRINTER    : ParsePrinter(str);    break;
  220.             case HOST        : ParseHost(str);        break;
  221.             case ALIAS        : ParseAlias(str);        break;
  222.             case ADMIN        : ParseAdmin(str);        break;
  223.             case CFA_STR    : ParseCFA(str);        break;
  224.             case NOMAIL        : mailing = FALSE;        break;
  225.             case NOACNT        : accounting = FALSE;    break;
  226.             case LASERWRTR    : ParseLaser(str);        break;
  227.             case DEBUG_CMD    : debugOn = !debugOn;    break;
  228.             case NO_ACTION    : noAction = TRUE;        break;
  229.             }
  230.         }
  231.  
  232.     UnloadSeg(ConvertStringToAddr);
  233.     UnloadSeg(ParseAlias);
  234.     FSClose(f);
  235.  
  236.     PSTAT_Banner_Down();
  237. }
  238.  
  239. /************************************************************************
  240.  *                                                                        *
  241.  * For those commands that require a a name this utility function will    *
  242.  * extract it,  allowing for quoted strings. Without quotes it stops on *
  243.  * whitespace, with quotes it stops on the terminating quote.            *
  244.  *                                                                        *
  245.  ************************************************************************/
  246. char *ReadAName(char *str, char *name);
  247. static char *ReadAName(char *str, char *name)
  248. {
  249.     char term = ' ', term2 = '\t';
  250.  
  251.     if (*str == '"') { term = *str++; term2 = term; }
  252.     while (*str && *str != term && *str != term2) *name++ = *str++;
  253.     if (*str == term) str++;
  254.     *name = 0;
  255.     while (*str && (*str == ' ' || *str == '\t') ) str++;
  256.     return str;
  257. }
  258.  
  259. /************************************************************************
  260.  ************************************************************************/
  261. char *ReadANum(char *str, integer *num);
  262. static char *ReadANum(char *str, integer *num)
  263. {
  264.     integer tnum = 0;
  265.  
  266.     while (*str && *str >= '0' && *str <= '9')
  267.         { tnum *= 10; tnum += (*str++ - '0'); }
  268.     *num = tnum;
  269.     while (*str && (*str == ' ' || *str == '\t') ) str++;
  270.     return str;
  271. }
  272.  
  273.  
  274. /************************************************************************
  275.  ************************************************************************/
  276.  
  277.  
  278. #include <serial.h>
  279.  
  280. extern prtHandle printers;
  281.  
  282. /************************************************************************
  283.  ************************************************************************/
  284. static void ParsePrinter(char *str)
  285. {
  286.     char        cmd[12], parity;
  287.     prtRecord    prt;
  288.     integer        i = 0, baud, bits, stop, parm, nPrtrs = 0;
  289.  
  290.  
  291.     str = ReadAName(str, prt.in_name);
  292.     while (*str && *str != ' ' && *str != '\t' && i < 11) cmd[i++] = toupper(*str++);
  293.     cmd[i] = 0;
  294.     if (strcmp("PAP", cmd) == 0)    prt.pap = TRUE;
  295.     else if (strcmp("SERIAL", cmd) == 0)  prt.pap = FALSE;
  296.     else return;    /* bad type */
  297.     while (*str && (*str == ' ' || *str == '\t')) str++;
  298.     str = ReadAName(str, (char*)&prt.outname[1]);
  299.     prt.outname[0] = strlen((char*)&prt.outname[1]);
  300.     parm = 0;
  301.     if (!prt.pap)
  302.         {
  303.         str = ReadANum(str, &baud);
  304.         str = ReadANum(str, &stop);
  305.         parity = *str++;
  306.         while (*str && *str != ' ' && *str != '\t') str++;
  307.         while (*str && (*str == ' ' || *str == '\t')) str++;
  308.         str = ReadANum(str, &bits);
  309.         switch (baud)
  310.             {
  311.             case 300:   parm = baud300;   break;
  312.             case 600:   parm = baud600;   break;
  313.             case 1200:  parm = baud1200;  break;
  314.             case 1800:  parm = baud1800;  break;
  315.             case 2400:  parm = baud2400;  break;
  316.             case 3600:  parm = baud3600;  break;
  317.             case 4800:  parm = baud4800;  break;
  318.             case 7200:  parm = baud7200;  break;
  319.             case 9600:  parm = baud9600;  break;
  320.             case 19200: parm = baud19200; break;
  321.             case 57600: parm = baud57600; break;
  322.             }
  323.         switch (stop)
  324.             {
  325.             case 10: parm |= stop10; break;
  326.             case 15: parm |= stop15; break;
  327.             case 20: parm |= stop20; break;
  328.             }
  329.         switch (parity)
  330.             {
  331.             case 'N': parm |= noParity; break;
  332.             case 'O': parm |= oddParity; break;
  333.             case 'E': parm |= evenParity; break;
  334.             }
  335.         switch (bits)
  336.             {
  337.             case 5: parm |= data5; break;
  338.             case 6: parm |= data6; break;
  339.             case 7: parm |= data7; break;
  340.             case 8: parm |= data8; break;
  341.             }
  342.         prt.params = parm;
  343.         }
  344.  
  345.     prt.postscript = (*str == 'P');
  346.  
  347.     if (!printers)
  348.         printers = (prtHandle)NewHandle(sizeof(prtRecord));
  349.     else
  350.         {
  351.         HUnlock((Handle)printers);
  352.         nPrtrs = (GetHandleSize((Handle)printers) / sizeof(prtRecord));
  353.         SetHandleSize((Handle)printers, GetHandleSize((Handle)printers) + sizeof(prtRecord) );
  354.         }
  355.  
  356.     MoveHHi((Handle)printers);
  357.     HLock((Handle)printers);
  358.     (*printers)[nPrtrs] = prt;
  359.  
  360.     if DEBUGGING
  361.         {
  362.         log_printf("PRINTER \"%s\" is \"%p\"\n", prt.in_name, prt.outname);
  363.         if (!prt.pap) log_printf("Serial printer %d %d %c %d\n",
  364.                                             baud, stop, parity, bits);
  365.         log_printf("%d printers found\n", nPrtrs+1);
  366.         }
  367. }
  368.  
  369.  
  370. /************************************************************************
  371.  ************************************************************************/
  372. static void ParseHost(char *str)
  373. {
  374.     LongWord    ipAddress;
  375.     Byte        *ip = (Byte*)&ipAddress;
  376.     integer        nHosts = 0;
  377.  
  378.  
  379.     if (ConvertStringToAddr(str, &ipAddress)==noErr)
  380.         {
  381.         if (!hosts)
  382.             hosts = NewHandle(sizeof(LongWord));
  383.         else
  384.             {
  385.             nHosts = (GetHandleSize(hosts) / sizeof(LongWord));
  386.             SetHandleSize( hosts, GetHandleSize(hosts) + sizeof(LongWord) );
  387.             }
  388.         HLock(hosts);
  389.         ((LongWord*)(*hosts))[nHosts] = ipAddress;
  390.         HUnlock(hosts);
  391.         if DEBUGGING
  392.             log_printf("HOST \"%s\" resolved %d.%d.%d.%d\n", str, ip[0], ip[1], ip[2], ip[3]);
  393.         }
  394.     else
  395.         log_printf("cannot resolve HOST \"%s\"\n", str);
  396. }
  397.  
  398.  
  399. /************************************************************************
  400.  ************************************************************************/
  401. static void ParseCFA(char *str)
  402. {
  403.     extern char *cfA;
  404.     cfA = (char*)NewPtr(strlen(str));
  405.     str = ReadAName(str, cfA);
  406. }
  407.  
  408.  
  409. /************************************************************************
  410.  ************************************************************************/
  411. static void ParseLaser(char *str)
  412. {
  413.     extern Byte *LaserWriterName;
  414.     str = ReadAName(str, (char*)&LaserWriterName[1]);
  415.     LaserWriterName[0] = strlen((char*)LaserWriterName);
  416. }
  417.