home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / LO241SRV.ZIP / door.c < prev    next >
C/C++ Source or Header  |  1998-08-01  |  31KB  |  1,209 lines
  1.  
  2. // LoraBBS Version 2.41 Free Edition
  3. // Copyright (C) 1987-98 Marco Maccaferri
  4. //
  5. // This program is free software; you can redistribute it and/or modify
  6. // it under the terms of the GNU General Public License as published by
  7. // the Free Software Foundation; either version 2 of the License, or
  8. // (at your option) any later version.
  9. //
  10. // This program is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. // GNU General Public License for more details.
  14. //
  15. // You should have received a copy of the GNU General Public License
  16. // along with this program; if not, write to the Free Software
  17. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <time.h>
  23. #include <ctype.h>
  24. #include <process.h>
  25. #include <io.h>
  26. #include <dir.h>
  27. #include <fcntl.h>
  28. #include <stdlib.h>
  29. #include <errno.h>
  30. #include <sys/stat.h>
  31.  
  32. #define INCL_DOS
  33. #include <os2.h>
  34.  
  35. #include <cxl\cxlvid.h>
  36. #include <cxl\cxlwin.h>
  37. #include <cxl\cxlstr.h>
  38.  
  39. #include "lsetup.h"
  40. #include "sched.h"
  41. #include "msgapi.h"
  42. #include "externs.h"
  43. #include "prototyp.h"
  44. #include "zmodem.h"
  45.  
  46. extern int errno, freeze;
  47.  
  48. void VioUpdate (void);
  49. extern HFILE hfComHandle;
  50.  
  51. void update_status_line (void);
  52. void open_logfile (void);
  53. void general_door (char *, int);
  54. void create_door_sys(char *, int, int);
  55. void create_dorinfo_def(char *,int ,int );
  56.  
  57. int spawn_program (int swapout, char *outstring)
  58. {
  59.     int retval, x;
  60.     char *p, *spawnarg[30], privstring[140];
  61.  
  62.     UNBUFFER_BYTES ();
  63.     VioUpdate ();
  64.  
  65.     if ((p = strchr (outstring, ' ')) != NULL)
  66.         *p = '\0';
  67.  
  68.     if (stristr (outstring, ".BAT") != NULL || stristr (outstring, ".CMD") != NULL) {
  69.         spawnarg[0] = getenv ("COMSPEC");
  70.       spawnarg[1] = "/C";
  71.       if (spawnarg[0] == NULL)
  72.      spawnarg[0] = "CMD.EXE";
  73.       x = 2;
  74.    }
  75.    else
  76.       x = 0;
  77.  
  78.    if (p != NULL)
  79.       *p = ' ';
  80.  
  81.     strcpy (privstring, outstring);
  82.     if ((p = strtok (privstring, " ")) != NULL)
  83.       do {
  84.      spawnarg[x++] = p;
  85.       } while ((p = strtok (NULL, " ")) != NULL);
  86.    spawnarg[x] = NULL;
  87.  
  88.     if (swapout)
  89.       retval = spawnvp (P_WAIT, spawnarg[0], spawnarg);
  90.    else
  91.       retval = spawnvp (P_WAIT, spawnarg[0], spawnarg);
  92.  
  93.    if (retval == -1 && stristr (spawnarg[0], ".BAT") == NULL && stristr (spawnarg[0], ".CMD") == NULL) {
  94.       strcpy (privstring, outstring);
  95.       spawnarg[0] = getenv ("COMSPEC");
  96.       spawnarg[1] = "/C";
  97.       if (spawnarg[0] == NULL)
  98.      spawnarg[0] = "CMD.EXE";
  99.       x = 2;
  100.  
  101.       if ((p = strtok (privstring, " ")) != NULL)
  102.      do {
  103.         spawnarg[x++] = p;
  104.      } while ((p = strtok (NULL, " ")) != NULL);
  105.       spawnarg[x] = NULL;
  106.  
  107.       retval = spawnvp (P_WAIT, spawnarg[0], spawnarg);
  108.    }
  109.    return (retval);
  110. }
  111.  
  112. void open_outside_door (s)
  113. char *s;
  114. {
  115.    general_door (s, 0);
  116. }
  117.  
  118. void editor_door (s)
  119. char *s;
  120. {
  121.     general_door (s, 1);
  122. }
  123.  
  124. void general_door(s, flag)
  125. char *s;
  126. int flag;
  127. {
  128.     int i, m, oldtime, noreread, retval, oldcume, *varr, count,door_type = 0, handle=0;
  129.     char ext[200], buffer[50], swapping, tmp[36], workdir[80], doordir[40];
  130.     char noinfo;
  131.     long t, freeze_time;
  132.     struct _usr tmpusr;
  133.  
  134.     if (!flag)
  135.         status_line(":External %s", s);
  136.  
  137.     getcwd (workdir, 79);
  138.  
  139.     noinfo = 0;
  140.     freeze = 0;
  141.     swapping = 0;
  142.     m = 0;
  143.     noreread = 0;
  144.     set_useron_record(DOOR, 0, 0);
  145.     ext[0] = '\0';
  146.     doordir[0] = 0;
  147.  
  148.     freeze_time = time(NULL);
  149.  
  150.     for (i=0;i<strlen(s);i++) {
  151.         if (s[i] != '*') {
  152.             ext[m++] = s[i];
  153.             ext[m] = '\0';
  154.             continue;
  155.         }
  156.  
  157.         switch (s[++i]) {
  158.             case '#':
  159.                 lorainfo.wants_chat = 0;
  160.                 if (function_active == 1)
  161.                     f1_status();
  162.                 break;
  163.             case '!':
  164.                 freeze = 1;
  165.                 break;
  166.             case '0':
  167.                 strcat(ext, sys.filepath);
  168.                 m += strlen(sys.filepath);
  169.                 break;
  170.             case '1':
  171.                 strcat(ext, sys.msg_path);
  172.                 m += strlen(sys.msg_path);
  173.                 break;
  174.             case '2':
  175.                 if (sys.filelist[0]) {
  176.                     strcat (ext, sys.filelist);
  177.                     m += strlen (sys.filelist);
  178.                 }
  179.                 else {
  180.                     strcat (ext, sys.filepath);
  181.                     strcat (ext, "FILES.BBS");
  182.                     m += strlen (sys.filepath);
  183.                     m += strlen ("FILES.BBS");
  184.                 }
  185.                 break;
  186.             case 'A':
  187.                 count=0;
  188.                 do    {
  189.                     doordir[count++] = s[++i];
  190.                 } while (s[i]!=' ' && s[i]!=0 && s[i]!='*');
  191.  
  192.                 doordir[count-1] = 0;
  193.                 if (doordir[0] && doordir[strlen (doordir) - 1] != '\\')
  194.                         strcat (doordir, "\\");
  195.                 break;
  196.             case 'B':
  197.                 sprintf(buffer,"%lu", local_mode ? 0L : rate);
  198.                 strcat(ext, buffer);
  199.                 m += strlen(buffer);
  200.                 break;
  201.             case 'C':
  202.                 if (getenv("COMSPEC") != NULL)
  203.                     strcpy(buffer,getenv("COMSPEC"));
  204.                 strcat(ext, buffer);
  205.                 m += strlen(buffer);
  206.                 break;
  207.             case 'D':
  208.                 switch(s[++i]) {
  209.                     case 'D':
  210.                         door_type=1; // DOOR.SYS
  211.                         if(s[++i]=='h')
  212.                             handle=1;
  213.                         else {
  214.                             handle=0;
  215.                             i--;
  216.                         }
  217.                         break;
  218.                     case 'F':
  219.                         door_type=2;  //DOORx.SYS
  220.                         if(s[++i]=='h')
  221.                             handle=1;
  222.                         else {
  223.                             handle=0;
  224.                             i--;
  225.                         }
  226.                         break;
  227.                     case 'I':
  228.                         door_type=3; // DORINFO1.DEF
  229.                         if(s[++i]=='h')
  230.                             handle=1;
  231.                         else {
  232.                             handle=0;
  233.                             i--;
  234.                         }
  235.                         break;
  236.                     case 'J':
  237.                         door_type=4;  // DORINFOx.DEF
  238.                         if(s[++i]=='h')
  239.                             handle=1;
  240.                         else {
  241.                             handle=0;
  242.                             i--;
  243.                         }
  244.                         break;
  245.                 }
  246.             case 'F':
  247.                 strcpy(tmp, usr.name);
  248.                 get_fancy_string(tmp, buffer);
  249.                 strcat(ext, buffer);
  250.                 m += strlen(buffer);
  251.                 break;
  252.             case 'G':
  253.                 if (usr.ansi)
  254.                     sprintf(buffer,"%d", 1);
  255.                 else if (usr.avatar)
  256.                     sprintf(buffer,"%d", 2);
  257.                 else
  258.                     sprintf(buffer,"%d", 0);
  259.                 strcat(ext, buffer);
  260.                 m += strlen(buffer);
  261.                 break;
  262.             case 'H':
  263.                 if (!local_mode)
  264.                     MDM_DISABLE();
  265.                 break;
  266.             case 'L':
  267.                 strcpy(tmp, usr.name);
  268.                 get_fancy_string(tmp, buffer);
  269.                 get_fancy_string(tmp, buffer);
  270.                 strcat(ext, buffer);
  271.                 m += strlen(buffer);
  272.                 break;
  273.             case 'M':
  274.                 swapping = registered ? 1 : 0;
  275.                 break;
  276.             case 'N':
  277.                 sprintf(buffer,"%d", line_offset);
  278.                 strcat(ext, buffer);
  279.                 m += strlen(buffer);
  280.                 break;
  281.             case 'P':
  282.                 sprintf(buffer,"%d", com_port+1);
  283.                 strcat(ext, buffer);
  284.                 m += strlen(buffer);
  285.                 break;
  286.             case 'R':
  287.                 sprintf(buffer,"%d", lorainfo.posuser);
  288.                 strcat(ext, buffer);
  289.                 m += strlen(buffer);
  290.                 break;
  291.             case 'S':
  292.                 noreread = 1;
  293.                 break;
  294.             case 'T':
  295.                 sprintf(buffer,"%d", time_remain());
  296.                 strcat(ext, buffer);
  297.                 m += strlen(buffer);
  298.                 break;
  299.             case 'U':
  300.                 sprintf (buffer, "%s%08lx", config->boxpath, usr.id);
  301.                 if (buffer[1] == ':')
  302.                     setdisk (toupper (buffer[0]) - 'A');
  303.                 chdir (buffer);
  304.                 break;
  305.             case 'W':
  306.                 FOSSIL_WATCHDOG (1);
  307.                 break;
  308.             case 'X':
  309.                 noinfo = 1;
  310.                 break;
  311.             default:
  312.                 ext[m++] = s[i];
  313.                 ext[m] = '\0';
  314.                 break;
  315.         }
  316.     }
  317.     if(door_type == 1)
  318.         create_door_sys(doordir,handle,0);
  319.     else
  320.         if(door_type == 2)
  321.             create_door_sys(doordir,handle,1);
  322.         else
  323.             if(door_type == 3)
  324.                 create_dorinfo_def(doordir,handle,0);
  325.             else
  326.                 if(door_type == 4)
  327.                     create_dorinfo_def(doordir,handle,1);
  328.  
  329.     translate_filenames (ext, ' ', NULL);
  330.  
  331.     sprintf(buffer, "%sLORAINFO.T%02X", config->sys_path, line_offset);
  332.     memcpy ((char *)&tmpusr, (char *)&usr, sizeof(struct _usr));
  333.     oldcume = tmpusr.time;
  334.     tmpusr.time += (int)((time(&t) - start_time) / 60);
  335.     tmpusr.baud_rate = local_mode ? 0 : (unsigned int)(rate / 100L);
  336.     lorainfo.baud = local_mode ? 0 : (unsigned int)(rate / 100L);
  337.     lorainfo.port = com_port + 1;
  338.     oldtime = lorainfo.time = time_remain ();
  339.     strcpy (lorainfo.log, log_name);
  340.     strcpy (lorainfo.system, system_name);
  341.     strcpy (lorainfo.sysop, sysop);
  342.     lorainfo.task = line_offset;
  343.     lorainfo.max_baud = speed;
  344.     lorainfo.downloadlimit = config->class[usr_class].max_dl;
  345.     lorainfo.max_time = config->class[usr_class].max_time;
  346.     lorainfo.max_call = config->class[usr_class].max_call;
  347.     lorainfo.ratio = config->class[usr_class].ratio;
  348.     lorainfo.min_baud = config->class[usr_class].min_baud;
  349.     lorainfo.min_file_baud = config->class[usr_class].min_file_baud;
  350.     strcpy (lorainfo.from, msg.from);
  351.     strcpy (lorainfo.to, msg.to);
  352.     strcpy (lorainfo.subj, msg.subj);
  353.     strcpy (lorainfo.msgdate, msg.date);
  354.     if (locked && password != NULL && registered) {
  355.         lorainfo.keylock = 1;
  356.         strcpy (lorainfo.password, password);
  357.         strcode (lorainfo.password, "YG&%FYTF%$RTD");
  358.     }
  359.     lorainfo.total_calls = sysinfo.total_calls;
  360.  
  361.     if (!noinfo) {
  362.         i = cshopen (buffer, O_WRONLY|O_BINARY|O_TRUNC|O_CREAT, S_IREAD|S_IWRITE);
  363.         write (i, (char *)&tmpusr, sizeof (struct _usr));
  364.         write (i, (char *)&lorainfo, sizeof (struct _lorainfo));
  365.         close (i);
  366.     }
  367.  
  368.     if (!flag)
  369.         read_system_file ("LEAVING");
  370.  
  371.     if (flag)
  372.         status_line(":External %s", ext);
  373.  
  374.     varr = ssave ();
  375.     cclrscrn (LGREY|_BLACK);
  376.     showcur ();
  377.     fclose (logf);
  378.  
  379.     retval = spawn_program (swapping, ext);
  380.  
  381.     setdisk (workdir[0] - 'A');
  382.     chdir (workdir);
  383.  
  384.     if (!local_mode) {
  385.         if (!config->lock_baud)
  386.             com_baud (rate);
  387.         FOSSIL_WATCHDOG (0);
  388.     }
  389.  
  390.     if (varr != NULL)
  391.         srestore (varr);
  392.  
  393.     if (freeze)
  394.         allowed += (int)((time(NULL)-freeze_time)/60);
  395.  
  396.     if (!noreread && !noinfo) {
  397.         sprintf(buffer, "%sLORAINFO.T%02X", config->sys_path, line_offset);
  398.         i = shopen (buffer, O_RDONLY|O_BINARY);
  399.         read (i, (char *)&tmpusr, sizeof(struct _usr));
  400.         read (i, (char *)&lorainfo, sizeof(struct _lorainfo));
  401.         close (i);
  402.  
  403.         if (lorainfo.time != oldtime) {
  404.             if (time_to_next (1) < lorainfo.time) {
  405.                 lorainfo.time = time_to_next (1);
  406.                 read_system_file("TIMEWARN");
  407.             }
  408.  
  409.             i = (int)((time(&t) - start_time) / 60);
  410.             allowed = i + lorainfo.time;
  411.  
  412.             if (lorainfo.time < oldtime)
  413.                 tmpusr.time += oldtime - lorainfo.time;
  414.         }
  415.  
  416.  
  417.         tmpusr.time = oldcume;
  418.         strcpy (tmpusr.name, usr.name);
  419.         strcpy (tmpusr.pwd, usr.pwd);
  420.         if (tmpusr.priv > max_readpriv)
  421.             tmpusr.priv = usr.priv;
  422.  
  423.         memcpy ((char *)&usr, (char *)&tmpusr, sizeof(struct _usr));
  424.     }
  425.  
  426.     open_logfile ();
  427.     if (!flag)
  428.         status_line(":Returned from door (%d)", retval);
  429.  
  430.    unlink(buffer);
  431.  
  432.     if (local_mode || snooping)
  433.         showcur();
  434.  
  435.     if (function_active == 1)
  436.         f1_status ();
  437.     else if (function_active == 3)
  438.         f3_status ();
  439.  
  440.     if (!flag)
  441.         read_system_file ("RETURN");
  442. }
  443.  
  444. void outside_door(s)
  445. char *s;
  446. {
  447.     general_door (s, 0);
  448. }
  449.  
  450. void translate_filenames(s, mecca_resp, readln)
  451. char *s, mecca_resp, *readln;
  452. {
  453.    int i, m;
  454.     char ext[128], buffer[50], tmp[36];
  455.    long t;
  456.  
  457.    m = 0;
  458.    ext[0] = '\0';
  459.  
  460.    for (i=0;i<strlen(s);i++) {
  461.         if (s[i] != '%') {
  462.          ext[m++] = s[i];
  463.          ext[m] = '\0';
  464.          continue;
  465.         }
  466.  
  467.       switch (s[++i]) {
  468.          case '%':
  469.             strcat (ext, "%");
  470.             m += strlen(buffer);
  471.                 break;
  472.          case '!':
  473.             strcat (ext, "\n");
  474.             m += strlen (buffer);
  475.             break;
  476.          case 'A':
  477.             strcpy(tmp, usr.name);
  478.                 get_fancy_string(tmp, buffer);
  479.             strcat(ext, strupr(buffer));
  480.             m += strlen(buffer);
  481.             break;
  482.          case 'b':
  483.             sprintf(buffer,"%lu", local_mode ? 0L : rate);
  484.             strcat(ext, buffer);
  485.             m += strlen(buffer);
  486.             break;
  487.          case 'B':
  488.                 strcpy(tmp, usr.name);
  489.             if (get_fancy_string(tmp, buffer) == NULL)
  490.                break;
  491.             if (get_fancy_string(tmp, buffer) == NULL)
  492.                break;
  493.             strcat(ext, strupr(buffer));
  494.             m += strlen(buffer);
  495.                 break;
  496.          case 'c':
  497.             strcat(ext, usr.city);
  498.             m += strlen(usr.city);
  499.                 break;
  500.             case 'C':
  501.             ext[m++] = mecca_resp;
  502.             ext[m] = '\0';
  503.             break;
  504.          case 'd':
  505.             sprintf(buffer,"%d", usr.msg);
  506.                 strcat(ext, buffer);
  507.             m += strlen(buffer);
  508.             break;
  509.          case 'D':
  510.             sprintf(buffer,"%d", usr.files);
  511.             strcat(ext, buffer);
  512.             m += strlen(buffer);
  513.                 break;
  514.          case 'E':
  515.             sprintf(buffer,"%d", usr.len);
  516.             strcat(ext, buffer);
  517.             m += strlen(buffer);
  518.             break;
  519.          case 'f':
  520.             strcpy(tmp, usr.name);
  521.             get_fancy_string(tmp, buffer);
  522.                 strcat(ext, buffer);
  523.             m += strlen(buffer);
  524.             break;
  525.          case 'F':
  526.             strcat(ext, sys.filepath);
  527.             m += strlen(sys.filepath);
  528.             break;
  529.             case 'g':
  530.             if (usr.ansi)
  531.                sprintf(buffer,"%d", 1);
  532.             else if (usr.avatar)
  533.                     sprintf(buffer,"%d", 2);
  534.                 else
  535.                sprintf(buffer,"%d", 0);
  536.             strcat(ext, buffer);
  537.             m += strlen(buffer);
  538.             break;
  539.          case 'G':
  540.             sprintf(buffer,"%d", config->class[usr_class].max_dl);
  541.                 strcat(ext, buffer);
  542.             m += strlen(buffer);
  543.             break;
  544.          case 'h':
  545.             strcat(ext, usr.voicephone);
  546.             m += strlen(usr.voicephone);
  547.             break;
  548.             case 'H':
  549.             sprintf(buffer,"%u", usr.dnldl);
  550.             strcat(ext, buffer);
  551.             m += strlen(buffer);
  552.             break;
  553.          case 'i':
  554.             sprintf(buffer,"%ld", usr.dnld);
  555.             strcat(ext, buffer);
  556.                 m += strlen(buffer);
  557.             break;
  558.          case 'I':
  559.             sprintf(buffer,"%ld", usr.upld);
  560.             strcat(ext, buffer);
  561.             m += strlen(buffer);
  562.             break;
  563.             case 'j':
  564.             sprintf(buffer,"%ld", (int)((time(&t) - start_time)/60));
  565.             strcat(ext, buffer);
  566.             m += strlen(buffer);
  567.                 break;
  568.             case 'J':
  569.             if (readln != NULL) {
  570.                strcat(ext, readln);
  571.                m += strlen(buffer);
  572.             }
  573.             break;
  574.          case 'K':
  575.             sprintf(buffer,"%02X", line_offset);
  576.                 strcat(ext, buffer);
  577.             m += strlen(buffer);
  578.             break;
  579.          case 'k':
  580.             sprintf(buffer,"%d", line_offset);
  581.             strcat(ext, buffer);
  582.             m += strlen(buffer);
  583.                 break;
  584.          case 'l':
  585.             strcpy(tmp, usr.name);
  586.             get_fancy_string(tmp, buffer);
  587.             get_fancy_string(tmp, buffer);
  588.             strcat(ext, buffer);
  589.             m += strlen(buffer);
  590.                 break;
  591.          case 'L':
  592.             if (!local_mode)
  593.                sprintf(buffer, "-p%d -b%lu", com_port+1, rate);
  594.             else
  595.                strcpy(buffer,"-k");
  596.             strcat(ext, buffer);
  597.                 m += strlen(buffer);
  598.             break;
  599.          case 'M':
  600.             strcat(ext, sys.msg_path);
  601.                 m += strlen(sys.msg_path);
  602.                 break;
  603.          case 'n':
  604.             strcat (ext, usr.name);
  605.             m += strlen (usr.name);
  606.             break;
  607.          case 'N':
  608.             strcat (ext, system_name);
  609.             m += strlen (system_name);
  610.             break;
  611.             case 'p':
  612.         sprintf (buffer, "%ld", local_mode ? 0L : hfComHandle);
  613.             strcat (ext, buffer);
  614.                 m += strlen (buffer);
  615.             break;
  616.          case 'P':
  617.             sprintf (buffer, "%d", local_mode ? 0 : com_port + 1);
  618.             strcat (ext, buffer);
  619.             m += strlen (buffer);
  620.                 break;
  621.          case 'q':
  622.             strcat(ext, sys.msg_path);
  623.             ext[strlen(ext)-1] = '\0';
  624.             m += strlen(sys.msg_path)-1;
  625.             break;
  626.          case 'Q':
  627.                 strcat(ext, sys.filepath);
  628.             ext[strlen(ext)-1] = '\0';
  629.             m += strlen(sys.filepath)-1;
  630.             break;
  631.             case 'R':
  632.                 strcat (ext, cmd_string);
  633.             m += strlen (cmd_string);
  634.             cmd_string[0] = '\0';
  635.             break;
  636.          case 'r':
  637.             sprintf (buffer, "%s%08lx", config->boxpath, usr.id);
  638.             strcat (ext, buffer);
  639.             m += strlen (buffer);
  640.             break;
  641.          case 's':
  642.                 strcpy(tmp, sysop);
  643.             get_fancy_string(tmp, buffer);
  644.             get_fancy_string(tmp, buffer);
  645.             strcat(ext, strupr(buffer));
  646.             m += strlen(buffer);
  647.             break;
  648.          case 'S':
  649.                 strcpy(tmp, sysop);
  650.             get_fancy_string(tmp, buffer);
  651.             strcat(ext, strupr(buffer));
  652.             m += strlen(buffer);
  653.             break;
  654.             case 't':
  655.             sprintf(buffer,"%d", time_remain());
  656.             strcat(ext, buffer);
  657.             m += strlen(buffer);
  658.             break;
  659.          case 'T':
  660.             sprintf(buffer,"%d", time_remain()*60);
  661.                 strcat(ext, buffer);
  662.             m += strlen(buffer);
  663.             break;
  664.          case 'u':
  665.                 sprintf(buffer,"%u", lorainfo.posuser);
  666.                 strcat(ext, buffer);
  667.             m += 1;
  668.             break;
  669.          case 'U':
  670.             ext[m++] = '_';
  671.             ext[m] = '\0';
  672.             break;
  673.          case 'v':
  674.             strcat(ext, sys.uppath);
  675.             m += strlen(sys.filepath);
  676.             break;
  677.             case 'V':
  678.             strcat(ext, sys.uppath);
  679.             ext[strlen(ext)-1] = '\0';
  680.             m += strlen(sys.filepath)-1;
  681.             break;
  682.          case 'w':
  683.             strcat(ext, sys.filelist);
  684.                 m += strlen(sys.filelist);
  685.             break;
  686.          case 'W':
  687.             sprintf(buffer,"%u", speed);
  688.                 strcat(ext, buffer);
  689.             m += strlen(buffer);
  690.             break;
  691.          case 'x':
  692.             getcwd (buffer, 40);
  693.             sprintf(buffer,"%c", buffer[0]);
  694.             strcat(ext, buffer);
  695.                 m += strlen(buffer);
  696.             break;
  697.          case 'X':
  698.             sprintf(buffer,"%d", lastread);
  699.                 strcat(ext, buffer);
  700.                 m += strlen(buffer);
  701.             break;
  702.          case 'Y':
  703.             sprintf(buffer,"%d", usr.language);
  704.             strcat(ext, buffer);
  705.             m += strlen(buffer);
  706.             break;
  707.          case 'Z':
  708.             strcat(ext, strupr(usr.name));
  709.             m += strlen(usr.name);
  710.             break;
  711.          default:
  712.                 ext[m++] = s[i];
  713.             ext[m] = '\0';
  714.             break;
  715.       }
  716.    }
  717.  
  718.    strcpy (s, ext);
  719. }
  720.  
  721. int external_mailer(s)
  722. char *s;
  723. {
  724.    int retval;
  725.  
  726.    status_line(":Shelling to front-end", s);
  727.  
  728.    cclrscrn(LGREY|_BLACK);
  729.     showcur();
  730.    fclose (logf);
  731.  
  732.    retval = spawn_program (1, s);
  733.  
  734.     com_install (com_port);
  735.    com_baud (rate);
  736.    FOSSIL_WATCHDOG (0);
  737.  
  738.    open_logfile ();
  739.    status_line(":Returned from front-end shell (%d)", retval);
  740.  
  741.    return (retval);
  742. }
  743.  
  744. void external_bbs (char *s)
  745. {
  746.    int i, m, retval, *varr;
  747.     char ext[200], buffer[50], swapping;
  748.  
  749.    status_line ("+Shelling to BBS");
  750.  
  751.    swapping = 0;
  752.    m = 0;
  753.    ext[0] = '\0';
  754.  
  755.    for (i=0;i<strlen(s);i++) {
  756.         if (s[i] != '*') {
  757.          ext[m++] = s[i];
  758.          ext[m] = '\0';
  759.          continue;
  760.       }
  761.  
  762.       switch (s[++i]) {
  763.             case 'B':
  764.             sprintf (buffer,"%lu", local_mode ? 0L : rate);
  765.             strcat (ext, buffer);
  766.             m += strlen (buffer);
  767.                 break;
  768.             case 'C':
  769.             if (getenv("COMSPEC") != NULL)
  770.                strcpy(buffer,getenv("COMSPEC"));
  771.             strcat(ext, buffer);
  772.             m += strlen(buffer);
  773.             break;
  774.          case 'H':
  775.         sprintf (buffer, "%ld", hfComHandle);
  776.         strcat (ext, buffer);
  777.         m += strlen (buffer);
  778.         break;
  779.      case 'M':
  780.             swapping = registered ? 1 : 0;
  781.             break;
  782.          case 'N':
  783.             sprintf(buffer,"%d", line_offset);
  784.                 strcat(ext, buffer);
  785.                 m += strlen(buffer);
  786.             break;
  787.          case 'P':
  788.             sprintf(buffer,"%d", com_port+1);
  789.             strcat(ext, buffer);
  790.             m += strlen(buffer);
  791.             break;
  792.             case 'T':
  793.             sprintf(buffer,"%d", time_to_next (0));
  794.             strcat(ext, buffer);
  795.             m += strlen(buffer);
  796.                 break;
  797.             case 'W':
  798.             FOSSIL_WATCHDOG (1);
  799.             break;
  800.          default:
  801.             ext[m++] = s[i];
  802.             ext[m] = '\0';
  803.             break;
  804.       }
  805.    }
  806.  
  807.    fclose (logf);
  808.  
  809.    varr = ssave ();
  810.    clown_clear ();
  811.    showcur();
  812.  
  813.    getcwd (buffer, 49);
  814.  
  815.    retval = spawn_program (swapping, ext);
  816.  
  817.    setdisk (buffer[0] - 'A');
  818.    chdir (buffer);
  819.     hidecur ();
  820.  
  821.    if (varr != NULL)
  822.       srestore (varr);
  823.  
  824.    open_logfile ();
  825.    status_line ("+BBS Return Code: %d", retval);
  826.  
  827.    get_down (retval, 2);
  828. }
  829.  
  830. void update_status_line ()
  831. {
  832.    if (function_active == 1)
  833.       f1_status ();
  834.    else if (function_active == 2)
  835.       f3_status ();
  836.    else if (function_active == 3)
  837.       f3_status ();
  838.    else if (function_active == 4)
  839.       f4_status ();
  840.    else if (function_active == 5);
  841.    else if (function_active == 6);
  842.    else if (function_active == 7);
  843.    else if (function_active == 8);
  844.    else if (function_active == 9)
  845.       f9_status ();
  846. }
  847.  
  848. #define MAX_LOCKS   200
  849.  
  850. typedef struct {
  851.    int Zone;
  852.    int Net;
  853.     int Node;
  854.     int Point;
  855.    char had_to_punt;
  856. } ADDR;
  857.  
  858. int flag_file (int function, int zone, int net, int node, int point, int do_stat)
  859. {
  860.     static ADDR *last_set = NULL;
  861.    static int numlocks = 0;
  862.    FILE *fptr;
  863.    int i;
  864.     char *HoldName, flagname[128], tmpname[128], BSYname[15];
  865.  
  866.    if (!line_offset || !config->multitask)
  867.       return (FALSE);
  868.  
  869.    if (last_set == NULL)
  870.       last_set = (ADDR *)malloc (sizeof (ADDR) * MAX_LOCKS);
  871.  
  872.    HoldName = HoldAreaNameMunge (zone);
  873.  
  874.    switch (function) {
  875.       case INITIALIZE:
  876.          numlocks = 0;
  877.          last_set[numlocks].Zone = -1;
  878.          last_set[numlocks].had_to_punt = 0;
  879.          break;
  880.  
  881.       case CLEAR_SESSION_FLAG:
  882.             // Per prima cosa libera tutti i flag creati, in modo da assicurarsi
  883.          // di non lasciare roba bloccata in giro.
  884.          if (numlocks != 0) {
  885.             for (i = 0; i < numlocks; i++) {
  886.                HoldName = HoldAreaNameMunge (last_set[i].Zone);
  887.                     if (last_set[i].Point != 0) {
  888.                   sprintf (flagname, "%s%04x%04x.PNT\\", HoldName, last_set[i].Net, last_set[i].Node);
  889.                         sprintf (BSYname, "%08x.BSY", last_set[i].Point);
  890.                }
  891.                else {
  892.                   strcpy (flagname, HoldName);
  893.                   sprintf (BSYname, "%04x%04x.BSY", last_set[i].Net, last_set[i].Node);
  894.                     }
  895.  
  896.                if (last_set[i].had_to_punt)
  897.                   strcpy (flagname, config->flag_dir);
  898.                     strcat (flagname, BSYname);
  899.  
  900.                last_set[i].had_to_punt = 0;
  901.                last_set[i].Zone = -1;
  902.  
  903.                if (!unlink (flagname)) {
  904.                   if (do_stat && config->doflagfile)
  905.                      status_line (msgtxt[M_CLEARED_FLAGFILE], flagname);
  906.                 }
  907.             }
  908.  
  909.             numlocks = 0;
  910.          }
  911.  
  912.          // Cancella il flag di sessione relativo a questo task.
  913.          if (config->flag_dir[0]) {
  914.             sprintf (flagname, "%sTask.%02x", config->flag_dir, line_offset);
  915.             unlink (flagname);
  916.          }
  917.             return (FALSE);
  918.  
  919.       case SET_SESSION_FLAG:
  920.          if (config->flag_dir[0]) {
  921.                 sprintf (flagname, "%sTask.%02x", config->flag_dir, line_offset);
  922.             fptr = fopen (flagname, "wb");
  923.             fclose (fptr);
  924.             }
  925.          return (FALSE);
  926.  
  927.       case TEST_AND_SET:
  928.             for (i = 0; i < numlocks; i++) {
  929.             if (last_set[i].Zone == zone && last_set[i].Net == net && last_set[i].Node == node && last_set[i].Point == point)
  930.                return (FALSE);
  931.          }
  932.  
  933.             if (point != 0) {
  934.             sprintf (flagname, "%s%04x%04x.PNT\\", HoldName, net, node);
  935.             sprintf (BSYname, "%08x.BSY", point);
  936.          }
  937.          else {
  938.             strcpy (flagname, HoldName);
  939.             sprintf (BSYname, "%04x%04x.BSY", net, node);
  940.          }
  941.  
  942.          last_set[numlocks].had_to_punt = 0;
  943.          sprintf (tmpname, "%sLORABSY.%02x", flagname, line_offset);
  944.          fptr = fopen (tmpname, "wb");
  945.  
  946.          if ((fptr == NULL) && (config->flag_dir[0])) {
  947.             last_set[numlocks].had_to_punt = 1;
  948.             strcpy (flagname, config->flag_dir);
  949.             sprintf (tmpname, "%sLORABSY.%02x", flagname, line_offset);
  950.             fptr = fopen (tmpname, "wb");
  951.          }         
  952.  
  953.          if (fptr == NULL) {
  954.             if (do_stat && config->doflagfile)
  955.                     status_line (msgtxt[M_FAILED_CREATE_FLAG], tmpname);
  956.  
  957.             last_set[numlocks].Zone = -1;
  958.             return (TRUE);
  959.             }
  960.  
  961.          fclose (fptr);
  962.  
  963.          strcat (flagname, BSYname);
  964.  
  965.          if (!rename (tmpname, flagname)) {
  966.                 if (do_stat && config->doflagfile)
  967.                     status_line (msgtxt[M_CREATED_FLAGFILE], flagname);
  968.  
  969.             last_set[numlocks].Zone = zone;
  970.             last_set[numlocks].Net = net;
  971.             last_set[numlocks].Node = node;
  972.             last_set[numlocks].Point = point;
  973.             numlocks++;
  974.  
  975.             return (FALSE);
  976.          }
  977.  
  978.          if (do_stat && config->doflagfile)
  979.             status_line (msgtxt[M_THIS_ADDRESS_LOCKED], zone, net, node, point);
  980.  
  981.          unlink (tmpname);
  982.          last_set[numlocks].Zone = -1;
  983.  
  984.          return (TRUE);
  985.  
  986.       case CLEAR_FLAG:
  987.             if (numlocks == 0)
  988.                 return (TRUE);
  989.  
  990.             for (i = 0; i < numlocks; i++) {
  991.                 if (last_set[i].Zone == zone && last_set[i].Net == net && last_set[i].Node == node && last_set[i].Point == point)
  992.                     break;
  993.             }
  994.             if (i == numlocks) {
  995.                 if (do_stat && config->doflagfile)
  996.                     status_line (msgtxt[M_BAD_CLEAR_FLAGFILE], zone, net, node, point);
  997.                 return (TRUE);
  998.             }
  999.  
  1000.             if (point != 0) {
  1001.                 sprintf (flagname, "%s%04x%04x.PNT\\", HoldName, net, node);
  1002.                 sprintf (BSYname, "%08x.BSY", point);
  1003.             }
  1004.             else {
  1005.                 strcpy (flagname, HoldName);
  1006.                 sprintf (BSYname, "%04x%04x.BSY", net, node);
  1007.             }
  1008.  
  1009.             if (last_set[i].had_to_punt)
  1010.                 strcpy (flagname, config->flag_dir);
  1011.             strcat (flagname, BSYname);
  1012.  
  1013.             last_set[i].had_to_punt = 0;
  1014.             last_set[i].Zone = -1;
  1015.  
  1016.             if (!unlink (flagname)) {
  1017.                 if (do_stat && config->doflagfile)
  1018.                     status_line (msgtxt[M_CLEARED_FLAGFILE], flagname);
  1019.                 return (TRUE);
  1020.             }
  1021.  
  1022.             return (FALSE);
  1023.  
  1024.         case TEST_FLAG:
  1025.             for (i = 0; i < numlocks; i++) {
  1026.                 if (last_set[i].Zone == zone && last_set[i].Net == net && last_set[i].Node == node && last_set[i].Point == point)
  1027.                     return (FALSE);
  1028.             }
  1029.  
  1030.             if (point != 0) {
  1031.                 sprintf (flagname, "%s%04x%04x.PNT\\", HoldName, net, node);
  1032.                 sprintf (BSYname, "%08x.BSY", point);
  1033.             }
  1034.             else {
  1035.                 strcpy (flagname, HoldName);
  1036.                 sprintf (BSYname, "%04x%04x.BSY", net, node);
  1037.             }
  1038.  
  1039.             strcat (flagname, BSYname);
  1040.  
  1041.             fptr = fopen (flagname, "rb");
  1042.             if (fptr == NULL)
  1043.                 return (FALSE);
  1044.             fclose (fptr);
  1045.  
  1046.             return (TRUE);
  1047.  
  1048.         default:
  1049.             break;
  1050.     }
  1051.  
  1052.     return (TRUE);
  1053. }
  1054.  
  1055. void create_door_sys(char *path,int handle,int tasknum)
  1056. {
  1057.  
  1058.     char buffer[80],day[5],month[5],year[5],filename[20];
  1059.     FILE *fp;
  1060.  
  1061.     if(tasknum)
  1062.         sprintf (filename,"DOOR%d.SYS",line_offset);
  1063.     else
  1064.         strcpy (filename,"DOOR.SYS");
  1065.  
  1066.     if(*path)
  1067.         sprintf (buffer, "%s%s", path,filename);
  1068.     else
  1069.         sprintf (buffer, "%s%s", config->sys_path,filename);
  1070.  
  1071.           fp = fopen(buffer,"wt");
  1072.     if (!fp) {
  1073.         status_line("!Unable to create %s",buffer);
  1074.         return;
  1075.     }
  1076.     status_line(":Creating %s",buffer);
  1077.  
  1078.     fprintf(fp,"COM%d:\n",local_mode ? 0 : com_port + 1);
  1079.     fprintf(fp,"%ld\n",local_mode ? 0 : speed);
  1080.     fprintf(fp,"8\n");
  1081.     fprintf(fp,"%d\n",line_offset);
  1082.     fprintf(fp,"%ld\n",local_mode ? 0 : rate );
  1083.     fprintf(fp,"Y\n");
  1084.     fprintf(fp,"Y\n");
  1085.     fprintf(fp,"Y\n");
  1086.     fprintf(fp,"Y\n");
  1087.     if(handle)
  1088.         fprintf(fp,"%s\n",usr.handle);
  1089.     else
  1090.         fprintf(fp,"%s\n",usr.name);
  1091.     fprintf(fp,"%s\n",usr.city);
  1092.     fprintf(fp,"%s\n",usr.voicephone);
  1093.     fprintf(fp,"%s\n",usr.dataphone);
  1094. //    fprintf(fp,"%s\n",usr.pwd);
  1095.     fprintf(fp,"\n"); // La password di Lora e' crittata, skippo.
  1096.     fprintf(fp,"%d\n",usr.priv);
  1097.     fprintf(fp,"%ld\n",usr.times);
  1098.     sscanf(usr.ldate,"%s%s%s",day,month,year);
  1099.     if(strstr(strupr(month),"JAN"))
  1100.         strcpy(month,"01");
  1101.     else if(strstr(month,"FEB"))
  1102.                 strcpy(month,"02");
  1103.     else if(strstr(month,"MAR"))
  1104.                 strcpy(month,"03");
  1105.     else if(strstr(month,"APR"))
  1106.                 strcpy(month,"04");
  1107.     else if(strstr(month,"MAY"))
  1108.                 strcpy(month,"05");
  1109.     else if(strstr(month,"JUN"))
  1110.                 strcpy(month,"06");
  1111.     else if(strstr(month,"JUL"))
  1112.                 strcpy(month,"07");
  1113.     else if(strstr(month,"AUG"))
  1114.                 strcpy(month,"08");
  1115.     else if(strstr(month,"SEP"))
  1116.                 strcpy(month,"09");
  1117.     else if(strstr(month,"OCT"))
  1118.                 strcpy(month,"10");
  1119.     else if(strstr(month,"NOV"))
  1120.                 strcpy(month,"11");
  1121.     else if(strstr(month,"DEC"))
  1122.                 strcpy(month,"12");
  1123.     fprintf(fp,"%s/%s/%s\n",month,day,year);
  1124.     fprintf(fp,"%ld\n",(long)time_remain()*60);
  1125.     fprintf(fp,"%d\n",time_remain());
  1126.     strcpy(buffer,"NG");
  1127.     if(usr.ansi||usr.avatar)
  1128.         strcpy(buffer,"GR");
  1129.     fprintf(fp,"%s\n",buffer);
  1130.     fprintf(fp,"%d\n",usr.len);
  1131.           fprintf(fp,"Y\n");
  1132.           fprintf(fp,"\n");
  1133.           fprintf(fp,"\n");
  1134.     fprintf(fp,"01/01/99\n");
  1135.     fprintf(fp,"1\n");
  1136.     fprintf(fp,"N\n");
  1137.     fprintf(fp,"%d\n",usr.n_upld);
  1138.     fprintf(fp,"%d\n",usr.n_dnld);
  1139.     fprintf(fp,"%d\n",usr.dnldl);
  1140.     fprintf(fp,"%d\n",config->class[usr_class].max_dl);
  1141.  
  1142.     fclose(fp);
  1143.     return;
  1144. }
  1145.  
  1146. void create_dorinfo_def(char *path,int handle,int tasknum)
  1147. {
  1148.  
  1149.     char buffer[80],filename[20],*p,g=0;
  1150.     FILE *fp;
  1151.  
  1152.     if(tasknum)
  1153.         sprintf (filename,"DORINFO%d.DEF",line_offset);
  1154.     else
  1155.         strcpy (filename,"DORINFO1.DEF");
  1156.  
  1157.     if(*path)
  1158.         sprintf (buffer, "%s%s", path,filename);
  1159.     else
  1160.         sprintf (buffer, "%s%s", config->sys_path,filename);
  1161.  
  1162.           fp = fopen(buffer,"wt");
  1163.     if (!fp) {
  1164.         status_line("!Unable to create %s",buffer);
  1165.         return;
  1166.     }
  1167.     status_line(":Creating %s",buffer);
  1168.     strcpy(buffer,config->system_name);
  1169.     fprintf(fp,"%s\n",strupr(buffer));
  1170.     strcpy(buffer,config->sysop);
  1171.     p = strtok(buffer," ");
  1172.     if(p)
  1173.         fprintf(fp,"%s\n",strupr(p));
  1174.     else
  1175.         fprintf(fp,"\n");
  1176.     filename[0]=0;
  1177.     while((p=strtok(NULL," "))!=0)
  1178.         strcat(filename,p);
  1179.     fprintf(fp,"%s\n",strupr(filename));
  1180.     fprintf(fp,"COM%d\n",local_mode ? 0 : com_port + 1);
  1181.     fprintf(fp,"%ld BAUD,N,8,1\n",local_mode ? 0 : speed );
  1182.     fprintf(fp,"%d\n",line_offset);
  1183.     if(handle)
  1184.         strcpy(buffer,usr.handle);
  1185.     else
  1186.         strcpy(buffer,usr.name);
  1187.     if(!stricmp(buffer,config->sysop))
  1188.         strcpy(buffer,"SYSOP");
  1189.         p = strtok(buffer," ");
  1190.     if(p)
  1191.         fprintf(fp,"%s\n",strupr(p));
  1192.     else
  1193.         fprintf(fp,"\n");
  1194.     filename[0]=0;
  1195.     while((p=strtok(NULL," "))!=0)
  1196.         strcat(filename,p);
  1197.     fprintf(fp,"%s\n",strupr(filename));
  1198.     strcpy(buffer,usr.city);
  1199.     fprintf(fp,"%s\n",strupr(buffer));
  1200.     if(usr.avatar) g='2';
  1201.     else if(usr.ansi) g='1';
  1202.     fprintf(fp,"%c\n",g);
  1203.     fprintf(fp,"%d\n",usr.priv);
  1204.     fprintf(fp,"%d\n",time_remain());
  1205.     fprintf(fp,"-1");
  1206.     fclose(fp);
  1207.     return;
  1208. }
  1209.