home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / LO241SRV.ZIP / cmdfile.c < prev    next >
C/C++ Source or Header  |  1998-08-01  |  60KB  |  1,953 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 <string.h>
  21. #include <time.h>
  22. #include <ctype.h>
  23. #include <io.h>
  24. #include <fcntl.h>
  25. #include <share.h>
  26. #include <dos.h>
  27. #include <dir.h>
  28. #include <stdarg.h>
  29. #include <alloc.h>
  30. #include <stdlib.h>
  31. #include <sys\stat.h>
  32.  
  33. #define INCL_DOSPROCESS
  34. #include <os2.h>
  35.  
  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.  
  45. extern int msg_parent, msg_child;
  46. extern char usr_rip;
  47.  
  48. void VioUpdate (void);
  49. int check_hotkey (char c);
  50. int process_menu_option(int, char *);
  51. int get_user_age (void);
  52. void rpnInit (void);
  53. char *rpnProcessString (char *p);
  54. FILE *get_system_file (char *);
  55. int check_subscription (void);
  56.  
  57. static void raise_priv (void);
  58. static void lower_priv (void);
  59. static int set_priv (char);
  60. static void big_char (char);
  61. static void big_string (int, char *, ...);
  62. static void build_flags (char *, long);
  63.  
  64. int ansi_attr = 7;
  65. char vx = 1, vy = 1, stop_hotkey = 0, isrip = 0;
  66.  
  67. void read_hourly_files ()
  68. {
  69.    int start, stop;
  70.    char filename[80];
  71.    struct ffblk blk;
  72.    struct time timep;
  73.  
  74.    gettime (&timep);
  75.  
  76.    sprintf (filename, "%s????.*", text_path);
  77.    if (findfirst (filename, &blk, 0))
  78.       return;
  79.  
  80.    do {
  81.       if (isdigit (blk.ff_name[0]) && isdigit (blk.ff_name[1]) && isdigit (blk.ff_name[2]) && isdigit (blk.ff_name[3]) && blk.ff_name[4] == '.') {
  82.          start = (blk.ff_name[0] - '0') * 10 + (blk.ff_name[1] - '0');
  83.          stop = (blk.ff_name[2] - '0') * 10 + (blk.ff_name[3] - '0');
  84.          if (timep.ti_hour < start || timep.ti_hour > stop)
  85.             continue;
  86.  
  87.          blk.ff_name[4] = '\0';
  88.          sprintf (filename, "%s%s", text_path, blk.ff_name);
  89.          read_system_file (blk.ff_name);
  90.          return;
  91.       }
  92.    } while (!findnext (&blk));
  93.  
  94.    if (config->glob_text_path[0]) {
  95.       sprintf (filename, "%s????.*", config->glob_text_path);
  96.       if (findfirst (filename, &blk, 0))
  97.          return;
  98.  
  99.       do {
  100.          if (isdigit (blk.ff_name[0]) && isdigit (blk.ff_name[1]) && isdigit (blk.ff_name[2]) && isdigit (blk.ff_name[3]) && blk.ff_name[4] == '.') {
  101.             start = (blk.ff_name[0] - '0') * 10 + (blk.ff_name[1] - '0');
  102.             stop = (blk.ff_name[2] - '0') * 10 + (blk.ff_name[3] - '0');
  103.             if (timep.ti_hour < start || timep.ti_hour > stop)
  104.                continue;
  105.  
  106.             blk.ff_name[4] = '\0';
  107.             sprintf (filename, "%s%s", config->glob_text_path, blk.ff_name);
  108.             read_system_file (blk.ff_name);
  109.             return;
  110.          }
  111.       } while (!findnext (&blk));
  112.    }
  113. }
  114.  
  115. int naplps_read_file (char *name)
  116. {
  117.    FILE *fp;
  118.    int c;
  119.    char *p, prolog = 0, epilog = 0;
  120.  
  121.    XON_ENABLE();
  122.    _BRK_ENABLE();
  123.  
  124.    if (!name || !(*name))
  125.       return (-1);
  126.  
  127.    if ((p = strstr (name, "/NAP")) != NULL) {
  128.       if (p[4] != '=')
  129.          prolog = epilog = 1;
  130.       else if (!strnicmp (&p[5], "ON", 2))
  131.          prolog = 1;
  132.       else if (!strnicmp (&p[5], "OFF", 3))
  133.          epilog = 1;
  134.    }
  135.  
  136.    if ((p = strchr (name,'/')) != NULL)
  137.       *(p - 1) = '\0';
  138.  
  139.    fp = get_system_file (name);
  140.  
  141.    if (p != NULL)
  142.       *(p - 1) = ' ';
  143.  
  144.    if (fp == NULL)
  145.       return (-1);
  146.  
  147.    if (prolog) {
  148.       BUFFER_BYTE (0x1B);
  149.       BUFFER_BYTE (0x25);
  150.       BUFFER_BYTE (0x41);
  151.    }
  152.  
  153.    while ((c = getc (fp)) != EOF)
  154.       BUFFER_BYTE (c);
  155.  
  156.    if (epilog) {
  157.       BUFFER_BYTE (0x1B);
  158.       BUFFER_BYTE (0x25);
  159.       BUFFER_BYTE (0x40);
  160.    }
  161.  
  162.    fclose (fp);
  163.  
  164.    UNBUFFER_BYTES ();
  165.    FLUSH_OUTPUT();
  166.  
  167.    return (1);
  168. }
  169.  
  170. char *line_fgets (char *dest, int max, FILE *fp)
  171. {
  172.    int i, c;
  173.  
  174.    i = 0;
  175.  
  176.    while (i < max) {
  177.       if ((c = fgetc (fp)) == EOF) {
  178.          if (i == 0)
  179.             return (NULL);
  180.          else
  181.             break;
  182.       }
  183.       dest[i++] = (char )c;
  184.       if ((char )c == 0x0D) {
  185.          if ((c = fgetc (fp)) == 0x0A)
  186.             dest[i++] = (char )c;
  187.          else
  188.             ungetc (c, fp);
  189.          break;
  190.       }
  191.    }
  192.  
  193.    dest[i] = '\0';
  194.    return (dest);
  195. }
  196.  
  197. int read_system_file (char *name)
  198. {
  199.    int i;
  200.    char filename[128];
  201.  
  202.    strcpy (filename, text_path);
  203.    strcat (filename, name);
  204.  
  205.    if (stristr (name, "/R") == NULL)
  206.       i = read_file (filename);
  207.    else
  208.       i = naplps_read_file (filename);
  209.  
  210.    if (i == 0 && config->glob_text_path[0]) {
  211.       strcpy (filename, config->glob_text_path);
  212.       strcat (filename, name);
  213.  
  214.       if (stristr (name, "/R") == NULL)
  215.          i = read_file (filename);
  216.       else
  217.          i = naplps_read_file (filename);
  218.    }
  219.  
  220.    return (i == -1 ? 0 : i);
  221. }
  222.  
  223. FILE *get_system_file (char *name)
  224. {
  225.    FILE *fp;
  226.    char linea[80];
  227.  
  228.    isrip = 0;
  229.  
  230.    fp = sh_fopen (name, "rb", SH_DENYWR);
  231.  
  232.    if (strchr (name, '.') == NULL) {
  233.       if (fp == NULL && usr_rip) {
  234.          sprintf (linea, "%s.RIP", name);
  235.          fp = sh_fopen (linea, "rb", SH_DENYWR);
  236.          if (fp != NULL) {
  237.             isrip = 1;
  238.             return (fp);
  239.          }
  240.       }
  241.       if (fp == NULL && !usr.ansi && !usr.avatar) {
  242.          sprintf (linea, "%s.ASC", name);
  243.          fp = sh_fopen (linea, "rb", SH_DENYWR);
  244.       }
  245.       if (fp == NULL && usr.ansi) {
  246.          sprintf (linea, "%s.ANS", name);
  247.          fp = sh_fopen (linea, "rb", SH_DENYWR);
  248.       }
  249.       if (fp == NULL && usr.avatar) {
  250.          sprintf (linea, "%s.AVT", name);
  251.          fp = sh_fopen (linea, "rb", SH_DENYWR);
  252.       }
  253.       if (fp == NULL) {
  254.          sprintf (linea, "%s.BBS", name);
  255.          fp = sh_fopen (linea, "rb", SH_DENYWR);
  256.       }
  257.    }
  258.  
  259.    return (fp);
  260. }
  261.  
  262. #define MAX_LINE_LENGTH  2050
  263.  
  264. int read_file (char *name)
  265. {
  266.    FILE *fp, *answer, *fpc;
  267.    char *linea, stringa[80], parola[80], *p, lastresp[80];
  268.    char onexit[40], resp, c;
  269.    int line, required, more, m, a, day, mont, year, bignum, fd;
  270.    word search;
  271.    long tempo;
  272.    struct ffblk blk;
  273.    struct tm *tim;
  274.  
  275.    ansi_attr = 7;
  276.    vx = vy = 1;
  277.    XON_ENABLE();
  278.    _BRK_ENABLE();
  279.  
  280.    if (!name || !(*name))
  281.       return(0);
  282.  
  283.    if ((p=strchr(name,'/')) != NULL)
  284.       *(p-1) = '\0';
  285.  
  286.    fp = get_system_file (name);
  287.  
  288.    if (p != NULL)
  289.       *(p-1) = ' ';
  290.  
  291.    if (fp == NULL)
  292.       return (0);
  293.  
  294.    if ((linea = (char *)malloc (MAX_LINE_LENGTH)) == NULL) {
  295.       fclose (fp);
  296.       return (0);
  297.    }
  298.  
  299.    more = line = 1;
  300.    nopause = bignum = required = 0;
  301.    fpc = answer = NULL;
  302.    resp = ' ';
  303.    onexit[0] = '\0';
  304.  
  305.    rpnInit ();
  306.  
  307. loop:
  308.    change_attr (LGREY|_BLACK);
  309.  
  310.    while (line_fgets (linea, MAX_LINE_LENGTH - 2, fp) != NULL) {
  311.       linea[MAX_LINE_LENGTH - 2] = '\0';
  312.  
  313.       for (p = linea; (*p) && (*p != 0x1A); p++) {
  314.          if (!local_mode) {
  315.             if (!CARRIER || RECVD_BREAK()) {
  316.                CLEAR_OUTBOUND();
  317.  
  318.                fclose (fp);
  319.                if (answer)
  320.                   fclose (answer);
  321.            VioUpdate ();
  322.                free (linea);
  323.                return (line);
  324.             }
  325.  
  326.             if (stop_hotkey && CHAR_AVAIL ()) {
  327.                c = (char)PEEKBYTE ();
  328.                if (check_hotkey (c)) {
  329.                   CLEAR_OUTBOUND();
  330.  
  331.                   fclose (fp);
  332.                   if (answer)
  333.                      fclose (answer);
  334.           VioUpdate ();
  335.                   free (linea);
  336.                   return (line);
  337.                }
  338.                else
  339.                   TIMED_READ (1);
  340.             }
  341.          }
  342.  
  343.          switch (*p) {
  344.             case CTRLA:
  345.                if (*(p + 1) == CTRLA) {
  346.                   big_string (bignum, bbstxt[B_PRESS_ENTER]);
  347.                   p++;
  348.                }
  349.            VioUpdate ();
  350.                input (stringa, 0);
  351.                line = 1;
  352.                break;
  353.             case CTRLD:
  354.                _BRK_ENABLE ();
  355.                more=1;
  356.                break;
  357.             case CTRLE:
  358.                _BRK_DISABLE ();
  359.                more=0;
  360.                break;
  361.             case CTRLF:
  362.                p++;
  363.                switch(toupper(*p)) {
  364.                case '"':
  365.                   for (m = 0; m < 10; m++) {
  366.                      if (config->packid[m].display[0] == usr.archiver)
  367.                         break;
  368.                   }
  369.                   if (m < 10)
  370.                      big_string (bignum, "%s", &config->packid[m].display[1]);
  371.                   else
  372.                      big_string (bignum, "%s", &bbstxt[B_NONE][1]);
  373.                   break;
  374.                case '%':
  375.                   if (usr.protocol == '\0')
  376.                      big_string (bignum, "%s", &bbstxt[B_NONE][1]);
  377.                   else if (usr.protocol == protocols[0][0])
  378.                      big_string (bignum, "%s", &protocols[0][1]);
  379.                   else if (usr.protocol == protocols[1][0])
  380.                      big_string (bignum, "%s", &protocols[1][1]);
  381.                   else if (usr.protocol == protocols[2][0])
  382.                      big_string (bignum, "%s", &protocols[2][1]);
  383.                   else if (usr.protocol == protocols[5][0])
  384.                      big_string (bignum, "%s", &protocols[5][1]);
  385.                   else if (config->hslink && usr.protocol == protocols[3][0])
  386.                      big_string (bignum, "%s", &protocols[3][1]);
  387.                   else if (config->puma && usr.protocol == protocols[4][0])
  388.                      big_string (bignum, "%s", &protocols[4][1]);
  389.                   else {
  390.                      PROTOCOL prot;
  391.  
  392.                      sprintf (stringa, "%sPROTOCOL.DAT", config->sys_path);
  393.                      fd = sh_open (stringa, O_RDONLY|O_BINARY, SH_DENYWR, S_IREAD|S_IWRITE);
  394.                      if (fd != -1) {
  395.                         while (read (fd, &prot, sizeof (PROTOCOL)) == sizeof (PROTOCOL)) {
  396.                            if (prot.active && prot.hotkey == usr.protocol) {
  397.                               big_string (bignum, "%s", prot.name);
  398.                               break;
  399.                            }
  400.                         }
  401.                         close (fd);
  402.                      }
  403.                      if (fd == -1 || !prot.active || prot.hotkey != usr.protocol)
  404.                         big_string (bignum, "%s", &bbstxt[B_NONE][1]);
  405.                   }
  406.                   break;
  407.                case 'C':
  408.                   big_string (bignum, "%ld", cps);
  409.                   break;
  410.                case 'D':
  411.                   big_string (bignum, "%s",usr.dataphone);
  412.                   break;
  413.                case 'E':
  414.                   big_string (bignum, "%s",usr.voicephone);
  415.                   break;
  416.                case 'F':
  417.                   usr.ldate[9] = '\0';
  418.                   big_string (bignum, "%s", usr.ldate);
  419.                   usr.ldate[9] = ' ';
  420.                   break;
  421.                case 'G':
  422.                   big_string (bignum, "%s",&usr.ldate[11]);
  423.                   break;
  424.                case 'H':
  425.                   big_string (bignum, "%ld", (cps * 100) / (rate / 10));
  426.                   break;
  427.                case 'I':
  428.                   big_string (bignum, "%s",usr.ibmset ? bbstxt[B_YES] : bbstxt[B_NO]);
  429.                   break;
  430.                case 'K':
  431.                   big_string (bignum, "%s",usr.kludge ? bbstxt[B_YES] : bbstxt[B_NO]);
  432.                   break;
  433.                case 'L':
  434.                   big_string (bignum, "%d", usr.credit);
  435.                   break;
  436.                case 'M':
  437.                   big_string (bignum, "%d", last_mail);
  438.                   break;
  439.                case 'N':
  440.                   big_string (bignum, "%d", lastread);
  441.                   break;
  442.                case 'O':
  443.                   big_string (bignum, "%s", get_priv_text(usr.priv));
  444.                   break;
  445.                case 'Q':
  446.                   big_string (bignum, "%u", usr.n_upld);
  447.                   break;
  448.                case 'R':
  449.                   big_string (bignum, "%lu", usr.upld);
  450.                   break;
  451.                case 'S':
  452.                   big_string (bignum, "%u", usr.n_dnld);
  453.                   break;
  454.                case 'T':
  455.                   big_string (bignum, "%lu", usr.dnld);
  456.                   break;
  457.                case 'V':
  458.                   big_string (bignum, "%d", usr.len);
  459.                   break;
  460.                case 'X':
  461.                   big_string (bignum, "%s",usr.ansi ? bbstxt[B_YES] : bbstxt[B_NO]);
  462.                   break;
  463.                case 'Y':
  464.                   big_string (bignum, "%s",usr.more ? bbstxt[B_YES] : bbstxt[B_NO]);
  465.                   break;
  466.                case 'Z':
  467.                   big_string (bignum, "%s",usr.formfeed ? bbstxt[B_YES] : bbstxt[B_NO]);
  468.                   break;
  469.                case '0':
  470.                   big_string (bignum, "%s",usr.use_lore ? bbstxt[B_NO] : bbstxt[B_YES]);
  471.                   break;
  472.                case '2':
  473.                   big_string (bignum, "%d", get_user_age ());
  474.                   break;
  475.                case '3':
  476.                   big_string (bignum, "%s",usr.hotkey ? bbstxt[B_YES] : bbstxt[B_NO]);
  477.                   break;
  478.                case '4':
  479.                   big_string (bignum, "%s",usr.firstdate);
  480.                   break;
  481.                case '5':
  482.                   big_string (bignum, "%s",usr.birthdate);
  483.                   break;
  484.                case '6':
  485.                   big_string (bignum, "%s",usr.scanmail ? bbstxt[B_YES] : bbstxt[B_NO]);
  486.                   break;
  487.                case '7':
  488.                   big_string (bignum, "%s",usr.subscrdate);
  489.                   break;
  490.                case '8':
  491.                   big_string (bignum, "%s",usr.avatar ? bbstxt[B_YES] : bbstxt[B_NO]);
  492.                   break;
  493.                case '1':
  494.                   m = check_subscription ();
  495.                   if (m != -1)
  496.                      big_string (bignum, "%d", m);
  497.                   break;
  498.                case '!':
  499.                   big_string (bignum, "%s",usr.color ? bbstxt[B_YES] : bbstxt[B_NO]);
  500.                   break;
  501.                case CTRLA:
  502.                   show_quote();
  503.                   break;
  504.                case 'A':
  505.                case CTRLB:
  506.                   big_string (bignum, "%s", usr.name);
  507.                   break;
  508.                case 'B':
  509.                case CTRLC:
  510.                   big_string (bignum, "%s", usr.city);
  511.                   break;
  512.                case CTRLD:
  513.                   data(stringa);
  514.                   stringa[9] = '\0';
  515.                   big_string (bignum, "%s",stringa);
  516.                   break;
  517.                case 'P':
  518.                case CTRLE:
  519.                   big_string (bignum, "%ld",usr.times);
  520.                   break;
  521.                case 'W':
  522.                case CTRLF:
  523.                   strcpy(stringa,usr.name);
  524.                   get_fancy_string(stringa, parola);
  525.                   big_string (bignum, parola);
  526.                   break;
  527.                case CTRLG:
  528.                   timer(10);
  529.                   break;
  530.                case CTRLK:
  531.                   m = (int)((time(NULL)-start_time)/60);
  532.                   m += usr.time;
  533.                   big_string (bignum, "%d",m);
  534.                   break;
  535.                case 'U':
  536.                case CTRLL:
  537.                   m = (int)((time(0)-start_time)/60);
  538.                   big_string (bignum, "%d",m);
  539.                   break;
  540.                case CTRLN:
  541.           VioUpdate ();
  542.                   modem_hangup();
  543.                   free (linea);
  544.                   return (line);
  545.                case CTRLO:
  546.                   big_string (bignum, "%d",time_remain());
  547.                   break;
  548.                case CTRLP:
  549.                   big_string (bignum, "%s",ctime(&start_time));
  550.                   break;
  551.                case CTRLQ:
  552.                   big_string (bignum, "%lu",sysinfo.total_calls);
  553.                   break;
  554.                case CTRLR:
  555.                   big_string (bignum, "%lu",usr.dnld-usr.upld);
  556.                   break;
  557.                case CTRLS:
  558.                   big_string (bignum, "%s",usr.signature);
  559.                   break;
  560.                case CTRLT:
  561.                   data(stringa);
  562.                   big_string (bignum, &stringa[10]);
  563.                   break;
  564.                case CTRLU:
  565.                   required=1;
  566.                   break;
  567.                case CTRLV:
  568.                   required=0;
  569.                   break;
  570.                case CTRLW:
  571.                   big_string (bignum, "%lu", usr.upld);
  572.                   break;
  573.                case CTRLX:
  574.                   big_string (bignum, "%lu",usr.dnld);
  575.                   break;
  576.                case '9':
  577.                   if(usr.n_upld == 0)
  578.                      big_string (bignum, "0:%u", usr.n_dnld);
  579.                   else {
  580.                       m = (unsigned int)(usr.n_dnld / usr.n_upld);
  581.                       big_string (bignum, "1:%u", m);
  582.                   }
  583.                   break;
  584.                case CTRLY:
  585.                case ':':
  586.                   if (usr.upld == 0)
  587.                      big_string (bignum, "0:%lu", usr.dnld);
  588.                   else {
  589.                      m = (unsigned int)(usr.dnld / usr.upld);
  590.                         big_string (bignum, "1:%u", m);
  591.                   }
  592.                   break;
  593.                case ';':
  594.                   big_string (bignum, "%s",usr.full_read ? bbstxt[B_YES] : bbstxt[B_NO]);
  595.                   break;
  596.                case '[':
  597.                   big_string (bignum, "%lu", config->class[usr_class].max_dl - usr.dnldl);
  598.                   break;
  599.                case '\\':
  600.                   big_string (bignum, "%s", &config->language[usr.language].descr[1]);
  601.                   break;
  602.                case ']':
  603.                   big_string (bignum, "%s", usr.comment);
  604.                   break;
  605.                }
  606.                break;
  607.                 case CR:
  608.                     break;
  609.                 case LF:
  610.  
  611.                     if (vy<25) vy++;
  612.                     vx=1;
  613.  
  614.                     if (!local_mode) {
  615.                   BUFFER_BYTE('\r');
  616.                   BUFFER_BYTE('\n');
  617.                }
  618.                if (snooping) {
  619.                   wputc (CR);
  620.                   wputc (LF);
  621.                }
  622.  
  623.                if (!(line++ < (usr.len-1)) && usr.len != 0) {
  624.                   if (!more)
  625.                      continue;
  626.                   if (!(line = more_question (line))) {
  627.                       fclose(fp);
  628.                       fp = NULL;
  629.                   }
  630.                }
  631.                break;
  632.             case CTRLK:
  633.                p++;
  634.                switch(toupper(*p)) {
  635.                case 'A':
  636.                   big_string (bignum, "%lu",sysinfo.total_calls);
  637.                   break;
  638.                case 'B':
  639.                   big_string (bignum, "%s",lastcall.name);
  640.                   break;
  641.                case 'C':
  642.                   big_string (bignum, "%d", msg_child);
  643.                   break;
  644.                case 'D':
  645.                   big_string (bignum, "%d",first_msg);
  646.                   break;
  647.                case 'E':
  648.                   big_string (bignum, "%d",last_msg);
  649.                   break;
  650.                case 'F':
  651.                   p++;
  652.                   sscanf(usr.ldate, "%2d %3s %2d", &day, parola, &year);
  653.                   parola[3] = '\0';
  654.                   for (mont = 0; mont < 12; mont++) {
  655.                      if ((!stricmp(mtext[mont], parola)) || (!stricmp(mesi[mont], parola)))
  656.                         break;
  657.                   }
  658.                   search=(year-80)*512+(mont+1)*32+day;
  659.                   translate_filenames (p, resp, lastresp);
  660.                   if (findfirst(p,&blk,0) || blk.ff_fdate < search)
  661.                      p = strchr(linea,'\0') - 1;
  662.                   break;
  663.                case 'G':
  664.                   tempo = time(0);
  665.                   tim = localtime(&tempo);
  666.                   big_string (bignum, "%s", bbstxt[B_SUNDAY + tim->tm_wday]);
  667.                   break;
  668.                case 'I':
  669.                   data(stringa);
  670.                   big_string (bignum, &stringa[10]);
  671.                   break;
  672.                case 'J':
  673.                   data(stringa);
  674.                   stringa[9] = '\0';
  675.                   big_string (bignum, "%s",stringa);
  676.                   break;
  677.                case 'K':
  678.                   m = (int)((time(NULL)-start_time)/60);
  679.                   big_string (bignum, "%d",m);
  680.                   break;
  681.                case 'M':
  682.                   big_string (bignum, "%d",max_priv_mail);
  683.                   break;
  684.                case 'O':
  685.                   big_string (bignum, "%d",time_remain());
  686.                   break;
  687.                case 'P':
  688.                   big_string (bignum, "%d", msg_parent);
  689.                   break;
  690.                case 'Q':
  691.                   big_string (bignum, "%d",config->class[usr_class].max_call);
  692.                   break;
  693.                case 'R':
  694.                   big_string (bignum, "%ld", local_mode ? 0 : rate);
  695.                   break;
  696.                case 'T':
  697.                   big_string (bignum, "%d",config->class[usr_class].max_dl);
  698.                   break;
  699.                case 'U':
  700.                   big_string (bignum, "%d", time_to_next (1));
  701.                   break;
  702.                case 'W':
  703.                   big_string (bignum, "%d", line_offset);
  704.                   break;
  705.                case 'X':
  706.           VioUpdate ();
  707.                   terminating_call ();
  708.                   free (linea);
  709.                   return (line);
  710.                case 'Y':
  711.                   big_string (bignum, "%s",sys.msg_name);
  712.                   break;
  713.                case 'Z':
  714.                   big_string (bignum, "%s",sys.file_name);
  715.                   break;
  716.                case '0':
  717.                case '9':
  718.                   big_string (bignum, "%d",num_msg);
  719.                   break;
  720.                case '1':
  721.                   big_string (bignum, "%d",usr.msg);
  722.                   break;
  723.                case '2':
  724.                   big_string (bignum, "%d",usr.files);
  725.                   break;
  726.                case '5':
  727.                   big_string (bignum, "%s", sys.msg_name);
  728.                   break;
  729.                case '7':
  730.                   big_string (bignum, "%u",usr.account);
  731.                   break;
  732.                case '8':
  733.                   big_string (bignum, "%u",usr.f_account);
  734.                   break;
  735.                case '[':
  736.                   big_string (bignum, "%d", config->class[usr_class].max_dl - usr.dnldl);
  737.                   break;
  738.                case '\\':
  739.                   del_line ();
  740.                   break;
  741.                default:
  742.                   p--;
  743.                   _BRK_DISABLE ();
  744.                   more = 0;
  745.                   break;
  746.                }
  747.                break;
  748.             case CTRLL:
  749.                cls();
  750.                vx = vy = 1;
  751.                line=1;
  752.                break;
  753.             case CTRLO:
  754.                p++;
  755.                switch(toupper(*p)) {
  756.                case 'C':
  757.                   p++;
  758.                   while (p[strlen (p) - 1] == '\r' || p[strlen (p) - 1] == '\n')
  759.                      p[strlen (p) - 1] = '\0';
  760.                   translate_filenames (p, resp, lastresp);
  761.                   open_outside_door (p);
  762.                   p = strchr(linea,'\0') - 1;
  763.                   break;
  764.                case 'E':
  765.                   if (!usr.ansi && !usr.avatar)
  766.                      p = strchr(linea,'\0') - 1;
  767.                   break;
  768.                case 'F':
  769.                   p++;
  770.                   strcpy(onexit,p);
  771.                   p = strchr(linea,'\0') - 1;
  772.                   break;
  773.                case 'M':
  774.                   if(answer) {
  775.                      p++;
  776.                      fprintf(answer,"%s %c\r\n",p,resp);
  777.                   }
  778.  
  779.                   p = strchr(linea,'\0') - 1;
  780.                   break;
  781.                case 'N':
  782.                   while (CARRIER && time_remain() > 0) {
  783.                      input(stringa,usr.width-1);
  784.                      if(strlen(stringa))
  785.                         break;
  786.                      if(!required)
  787.                         break;
  788.                      big_string (bignum, bbstxt[B_TRY_AGAIN]);
  789.                   }
  790.  
  791.                   strcpy (lastresp, stringa);
  792.  
  793.                   if(answer) {
  794.                      putc(' ',answer);
  795.                      putc(' ',answer);
  796.                      p++;
  797.                      fprintf(answer,"%s",p);
  798.                      putc(':',answer);
  799.                      putc(' ',answer);
  800.                      fprintf(answer,"%s\r\n",stringa);
  801.                   }
  802.  
  803.                   p = strchr(linea,'\0') - 1;
  804.                   break;
  805.                case 'O':
  806.                   if(answer)
  807.                      fclose(answer);
  808.                   p++;
  809.                   p[strlen(p)-2] = '\0';
  810.                   translate_filenames (p, resp, lastresp);
  811.                   answer = fopen (p, "ab");
  812.                   if(answer == NULL)
  813.                      status_line(msgtxt[M_UNABLE_TO_OPEN],p);
  814.  
  815.                   p = strchr(linea,'\0') - 1;
  816.                   break;
  817.                case 'P':
  818.                   if(answer) {
  819.                      fprintf(answer,"\r\n");
  820.                      usr.ptrquestion = ftell(answer);
  821.                      fprintf(answer,"* %s\t%s\t%s\r\n",usr.name,usr.city,data(parola));
  822.                   }
  823.                   break;
  824.                case 'Q':
  825.                   if (fp != NULL)
  826.                      fclose(fp);
  827.  
  828.                   UNBUFFER_BYTES ();
  829.                   FLUSH_OUTPUT ();
  830.  
  831.                   if (fpc == NULL) {
  832.                      fp = fopen(onexit,"rb");
  833.                      if (fp == NULL) {
  834.                         if (answer)
  835.                            fclose (answer);
  836.             VioUpdate ();
  837.                         free (linea);
  838.                         return (line);
  839.                      }
  840.                   }
  841.                   else {
  842.                      fp = fpc;
  843.                      fpc = NULL;
  844.                      p[1] = '\0';
  845.                   }
  846.  
  847.                   p = strchr(p,'\0') - 1;
  848.                   break;
  849.                case 'R':
  850.                   line=1;
  851.                   p++;
  852.                   while (CARRIER && time_remain() > 0) {
  853.                      input (stringa, 1);
  854.                      c = toupper(stringa[0]);
  855.                      if(c == '\0')
  856.                         c = 0x7C;
  857.                      if(strchr(strupr(p),c) != NULL)
  858.                         break;
  859.                      big_string (bignum, bbstxt[B_TRY_AGAIN]);
  860.                   }
  861.  
  862.                   p = strchr(linea,'\0') - 1;
  863.                   resp = c;
  864.                   big_string (bignum, "\n");
  865.                   break;
  866.                case 'S':
  867.                   p++;
  868.                   fclose (fp);
  869.                   fp = get_system_file (p);
  870.                   if (fp == NULL) {
  871.                      fp = get_system_file (onexit);
  872.                      onexit[0] = '\0';
  873.                      if (fp == NULL) {
  874.             VioUpdate ();
  875.                         free (linea);
  876.                         return (line);
  877.                      }
  878.                   }
  879.  
  880.                   p = strchr (linea, '\0') - 1;
  881.                   break;
  882.                case 'T':
  883.                   rewind (fp);
  884.                   break;
  885.                case 'U':
  886.                   p++;
  887.                   if(toupper(*p) != resp)
  888.                      p = strchr(linea,'\0') - 1;
  889.                   break;
  890.                case 'V':
  891.                   p++;
  892.                   fseek (fp, atol (p), SEEK_SET);
  893.                   if(toupper(*p) != resp)
  894.                      p = strchr(linea,'\0') - 1;
  895.                   break;
  896.                }
  897.                break;
  898.             case CTRLP:
  899.                p++;
  900.                if ( *p == 'B' ) {
  901.                   p++;
  902.                   a = set_priv ( *p );
  903.                   if (usr.priv > a)
  904.                      p = strchr(linea,'\0') - 1;
  905.                }
  906.                else if ( *p == 'L' ) {
  907.                   p++;
  908.                   a = set_priv ( *p );
  909.                   if (usr.priv < a)
  910.                      p = strchr(linea,'\0') - 1;
  911.                }
  912.                else if ( *p == 'Q' ) {
  913.                   p++;
  914.                   a = set_priv ( *p );
  915.                   if (a != usr.priv)
  916.                      p = strchr(linea,'\0') - 1;
  917.                }
  918.                else if ( *p == 'X' ) {
  919.                   p++;
  920.                   a = set_priv ( *p );
  921.                   if (usr.priv == a)
  922.                      p = strchr(linea,'\0') - 1;
  923.                }
  924.                else {
  925.                   a = set_priv ( *p );
  926.                   if (usr.priv < a)
  927.                      fseek (fp, 0L, SEEK_END);
  928.                }
  929.                break;
  930.             case CTRLV:
  931.                p++;
  932.                switch (*p) {
  933.                case CTRLA:
  934.                   p++;
  935.                   if (*p == CTRLP) {
  936.                      p++;
  937.                      *p &= 0x7F;
  938.                   }
  939.  
  940.                   if (!*p) {
  941.                      change_attr(13);
  942.                      ansi_attr = 13;
  943.                   }
  944.                   else {
  945.                      change_attr(*p);
  946.                      ansi_attr = *p;
  947.                   }
  948.                   break;
  949.                case CTRLC:
  950.                   cup (1);
  951.                   line--;
  952.                   if (vy > 0)
  953.                      vy++;
  954.                   break;
  955.                case CTRLD:
  956.                   cdo (1);
  957.                   line++;
  958.                   if (vy < usr.len - 1)
  959.                      vy++;
  960.                   break;
  961.                case CTRLE:
  962.                   cle (1);
  963.                   if (vx > 0)
  964.                      vx--;
  965.                   break;
  966.                case CTRLF:
  967.                   cri (1);
  968.                   if (vx < 79)
  969.                      vx++;
  970.                   break;
  971.                case CTRLG:
  972.                   del_line();
  973.                   break;
  974.                case CTRLH:
  975.                   cpos ( *(p + 1), *(p + 2) );
  976.                   vy = line = *(p + 1);
  977.                   vx = *(p + 2);
  978.                   p += 2;
  979.                   break;
  980.                case CTRLY:
  981.                   p++;
  982.                   strncpy (stringa, &p[1], *p);
  983.                   stringa[*p] = '\0';
  984.                   p += *p + 1;
  985.                   for (m = 0; m < *p; m++) {
  986.                      m_print (stringa);
  987.                      vx += strlen (stringa);
  988.                      if (vx >= 80) {
  989.                         vx -= 80;
  990.                         if (vy < usr.len - 1)
  991.                            vy++;
  992.                      }
  993.                   }
  994.                   break;
  995.                }
  996.                break;
  997.             case CTRLR:
  998.                p++;
  999.                p = rpnProcessString (p);
  1000.                break;
  1001.             case CTRLW:
  1002.                p++;
  1003.                switch(*p) {
  1004.                case 'A':
  1005.                   p++;
  1006.                   p[strlen(p)-2] = '\0';
  1007.                   translate_filenames (p, resp, lastresp);
  1008.                   status_line (p);
  1009.                   p = strchr(linea,'\0') - 1;
  1010.                   break;
  1011.                case 'a':
  1012.                   p++;
  1013.                   p[strlen(p)-2] = '\0';
  1014.                   translate_filenames (p, resp, lastresp);
  1015.                   broadcast_message (p);
  1016.                   p = strchr(linea,'\0') - 1;
  1017.                   break;
  1018.                case CTRLA:
  1019.                   usr.ldate[9] = '\0';
  1020.                   big_string (bignum, "%s",usr.ldate);
  1021.                   usr.ldate[9] = ' ';
  1022.                   break;
  1023.                case 'B':
  1024.                   bignum = bignum ? 0 : 1;
  1025.                   break;
  1026.                case 'c':
  1027.                   p++;
  1028.                   if ( *p == 'A' && !local_mode)
  1029.                      p = strchr(linea,'\0') - 1;
  1030.                   else if ( *p == 'R' && local_mode)
  1031.                      p = strchr(linea,'\0') - 1;
  1032.                   break;
  1033.                case CTRLB:
  1034.                   p++;
  1035.                   if ( (*p == '1' && rate >= 1200) ||
  1036.                        (*p == '2' && rate >= 2400) ||
  1037.                        (*p == '9' && rate >= 9600)
  1038.                      )
  1039.                      break;
  1040.                   p = strchr(linea,'\0') - 1;
  1041.                   break;
  1042.                case CTRLC:
  1043.                   big_string (bignum, system_name);
  1044.                   break;
  1045.                case CTRLD:
  1046.                   big_string (bignum, sysop);
  1047.                   break;
  1048.                case CTRLE:
  1049.                   big_string (bignum, lastresp);
  1050.                   break;
  1051.                case CTRLG:
  1052.           DosBeep (1000, 30);
  1053.                   break;
  1054.                case CR:
  1055.                   p++;
  1056.                   if ( *p == 'A')
  1057.                      big_string (bignum, "%d", usr.msg);
  1058.                   if ( *p == 'L')
  1059.                      big_string (bignum, "%d",lastread);
  1060.                   else if ( *p == 'N')
  1061.                      big_string (bignum, "%s",sys.msg_name);
  1062.                   else if ( *p == 'H')
  1063.                      big_string (bignum, "%d",last_msg);
  1064.                   else if ( *p == '#')
  1065.                      big_string (bignum, "%d",first_msg - last_msg + 1);
  1066.                   break;
  1067.                case CTRLN:
  1068.                   p++;
  1069.                   if ( *p == 'B' || *p == 'C' )
  1070.                      big_string (bignum, "%d", usr.credit);
  1071.                   else if ( *p == 'D' )
  1072.                      SENDBYTE ('0');
  1073.                   break;
  1074.                case '8':
  1075.                   if (usr.len < 79)
  1076.                      p = strchr(linea,'\0') - 1;
  1077.                   break;
  1078.                case 'D':
  1079.                   p++;
  1080.                   p[strlen(p)-2] = '\0';
  1081.                   translate_filenames (p, resp, lastresp);
  1082.                   unlink (p);
  1083.                   p = strchr(linea,'\0') - 1;
  1084.                   break;
  1085.                case CTRLF:
  1086.                case 'G':
  1087.                   p++;
  1088.                   if ( *p == 'A')
  1089.                      big_string (bignum, "%d", usr.files);
  1090.                   else if ( *p == 'N')
  1091.                      big_string (bignum, "%s",sys.file_name);
  1092.                   break;
  1093.                case 'I':
  1094.                   p++;
  1095.                   if ( *p == 'L' && !local_mode)
  1096.                      p = strchr(linea,'\0') - 1;
  1097.                   else if ( *p == 'R' && local_mode)
  1098.                      p = strchr(linea,'\0') - 1;
  1099.                   break;
  1100.                case 'k':
  1101.                   p++;
  1102.                   if ( *p == 'D' ) {
  1103.                      build_flags (parola, usr.flags);
  1104.                      big_string (bignum, parola);
  1105.                   }
  1106.                   else if ( *p == 'F' ) {
  1107.                      p++;
  1108.                      usr.flags &= ~get_flags (p);
  1109.                      while (*p != ' ' && *p != '\0')
  1110.                         p++;
  1111.                      if (*p == '\0')
  1112.                         p--;
  1113.                   }
  1114.                   else if ( *p == 'I' ) {
  1115.                      p++;
  1116.                      if ((usr.flags & get_flags (p)) != get_flags (p))
  1117.                         p = strchr(linea,'\0') - 1;
  1118.                      else {
  1119.                         while (*p != ' ' && *p != '\0')
  1120.                            p++;
  1121.                         if (*p == '\0')
  1122.                            p--;
  1123.                      }
  1124.                   }
  1125.                   else if ( *p == 'N' ) {
  1126.                      p++;
  1127.                      if ((usr.flags & get_flags (p)) == 0)
  1128.                         p = strchr(linea,'\0') - 1;
  1129.                      else {
  1130.                         while (*p != ' ' && *p != '\0')
  1131.                            p++;
  1132.                         if (*p == '\0')
  1133.                            p--;
  1134.                      }
  1135.                   }
  1136.                   else if ( *p == 'O' ) {
  1137.                      p++;
  1138.                      usr.flags |= get_flags (p);
  1139.                      while (*p != ' ' && *p != '\0')
  1140.                         p++;
  1141.                      if (*p == '\0')
  1142.                         p--;
  1143.                   }
  1144.                   else if ( *p == 'T' ) {
  1145.                      p++;
  1146.                      usr.flags ^= get_flags (p);
  1147.                      while (*p != ' ' && *p != '\0')
  1148.                         p++;
  1149.                      if (*p == '\0')
  1150.                         p--;
  1151.                   }
  1152.                   break;
  1153.                case 'L':
  1154.                   p++;
  1155.                   fpc = fp;
  1156.                   p[strlen (p) - 2] = '\0';
  1157.                   fp = get_system_file (p);
  1158.                   if (fp == NULL) {
  1159.                      fp = fpc;
  1160.                      fpc = NULL;
  1161.                   }
  1162.                   p = strchr (p, '\0') - 1;
  1163.                   break;
  1164.                case 'l':
  1165.                   m = 0;
  1166.                   p++;
  1167.                   while (*p && isdigit (*p)) {
  1168.                      m *= 10;
  1169.                      m += *p++ - '0';
  1170.                   }
  1171.                   if (*p == ' ')
  1172.                      p++;
  1173.                   if (line_offset != m)
  1174.                      p = strchr (p, '\0') - 1;
  1175.                   break;
  1176.                case 'M':
  1177.                   p++;
  1178.                   if (*p == CTRLP) {
  1179.                      p++;
  1180.                      *p &= 0x7F;
  1181.                   }
  1182.                   process_menu_option (*p, p + 1);
  1183.                   p = strchr (p, '\0') - 1;
  1184.                   break;
  1185.                case 'p':
  1186.                   p++;
  1187.                   if ( *p == 'D' )
  1188.                      lower_priv ();
  1189.                   else if ( *p == 'U' )
  1190.                      raise_priv ();
  1191.                   break;
  1192.                case 'P':
  1193.                   big_string (bignum, "%s", usr.voicephone);
  1194.                   break;
  1195.                case 'R':
  1196.                   big_string (bignum, "%s", usr.handle);
  1197.                   break;
  1198.                case 'S':
  1199.                   big_string (bignum, "%s", usr.signature);
  1200.                   break;
  1201.                case 's':
  1202.                   p++;
  1203.                   usr.priv = set_priv ( *p );
  1204.                   usr_class = get_class(usr.priv);
  1205.                   break;
  1206.                case 'W':
  1207.                   p++;
  1208.                   if(answer) {
  1209.                      translate_filenames (p, resp, lastresp);
  1210.                      fprintf(answer, "%s", p);
  1211.                   }
  1212.                   p = strchr(p,'\0') - 1;
  1213.                   break;
  1214.                case 'h':
  1215.                   online_users (1, 1);
  1216.                   break;
  1217.                case 'w':
  1218.                   online_users (1, 0);
  1219.                   break;
  1220.                case 'X':
  1221.                   p++;
  1222.                   if ( *p == 'D' || *p == 'R' ) {
  1223.                      p++;
  1224.                      translate_filenames (p, resp, lastresp);
  1225.                      open_outside_door (p);
  1226.                      p = strchr(p,'\0') - 1;
  1227.                   }
  1228.                   break;
  1229.                default:
  1230.                   p--;
  1231.                   timer(5);
  1232.                   break;
  1233.                }
  1234.                break;
  1235.             case CTRLX:
  1236.                p++;
  1237.                translate_filenames (p, resp, lastresp);
  1238.                open_outside_door(p);
  1239.                *p = '\0';
  1240.                p--;
  1241.                break;
  1242.             case CTRLY:
  1243.                c = *(++p);
  1244.                if (!usr.ibmset && (unsigned char)c >= 128)
  1245.                   c = bbstxt[B_ASCII_CONV][(unsigned char)c - 128];
  1246.                a = *(++p);
  1247.                vx += a;
  1248.                if (vx > 80) {
  1249.                   vx -= 80;
  1250.                   if (vy < 25)
  1251.                      vy++;
  1252.                }
  1253.                if(usr.avatar && !local_mode) {
  1254.                   BUFFER_BYTE(CTRLY);
  1255.                   BUFFER_BYTE(c);
  1256.                   BUFFER_BYTE(a);
  1257.                }
  1258.                else if (!local_mode)
  1259.                   for(m=0;m<a;m++)
  1260.                      BUFFER_BYTE(c);
  1261.                if (snooping)
  1262.                   wdupc (c, a);
  1263.                break;
  1264.             case CTRLZ:
  1265.                break;
  1266.             case 0x1B:
  1267.                p = translate_ansi (p);
  1268.                break;
  1269.             default:
  1270.                c = *p;
  1271.                if (!usr.ibmset && (unsigned char)c >= 128)
  1272.                   c = bbstxt[B_ASCII_CONV][(unsigned char)c - 128];
  1273.                if (!bignum || (!usr.ansi && !usr.avatar)) {
  1274.                   if (!local_mode)
  1275.                      BUFFER_BYTE (c);
  1276.                   if (snooping && !isrip)
  1277.                      wputc (c);
  1278.                   vx++;
  1279.                   if (vx > 80) {
  1280.                      vx -= 80;
  1281.                      if (vy < 25)
  1282.                         vy++;
  1283.                   }
  1284.                }
  1285.                else
  1286.                   big_char (c);
  1287.                break;
  1288.          }
  1289.  
  1290.          if (fp == NULL)
  1291.             break;
  1292.       }
  1293.  
  1294.       if (*p == CTRLZ || fp == NULL) {
  1295.          if (fp != NULL)
  1296.             fclose(fp);
  1297.  
  1298.          if (!local_mode) {
  1299.             UNBUFFER_BYTES ();
  1300.             FLUSH_OUTPUT ();
  1301.          }
  1302.  
  1303.          if (fpc == NULL) {
  1304.             fp = fopen(onexit,"rb");
  1305.             if (fp == NULL)
  1306.                break;
  1307.          }
  1308.          else {
  1309.             fp = fpc;
  1310.             fpc = NULL;
  1311.          }
  1312.       }
  1313.    }
  1314.  
  1315.    if (fp != NULL)
  1316.       fclose(fp);
  1317.  
  1318.    VioUpdate ();
  1319.  
  1320.    if (fpc == NULL) {
  1321.       fp = fopen(onexit,"rb");
  1322.       if (fp != NULL)
  1323.          goto loop;
  1324.    }
  1325.    else {
  1326.       fp = fpc;
  1327.       fpc = NULL;
  1328.       goto loop;
  1329.    }
  1330.  
  1331.    if (fp != NULL)
  1332.       fclose(fp);
  1333.    if (answer != NULL)
  1334.       fclose(answer);
  1335.  
  1336.    if (!local_mode) {
  1337.       UNBUFFER_BYTES ();
  1338.       FLUSH_OUTPUT();
  1339.    }
  1340.  
  1341.    free (linea);
  1342.  
  1343.    return (line ? line : -1);
  1344. }
  1345.  
  1346. void show_quote()
  1347. {
  1348.    FILE *quote;
  1349.    char linea[129];
  1350.  
  1351.    strcpy(linea, text_path);
  1352.    strcat(linea, "QUOTES.BBS");
  1353.  
  1354.    quote = fopen (linea, "rt");
  1355.    if (quote == NULL) {
  1356.       strcpy (linea, config->glob_text_path);
  1357.       strcat (linea, "QUOTES.BBS");
  1358.       if (quote == NULL)
  1359.          return;
  1360.    }
  1361.  
  1362.    fseek(quote,sysinfo.quote_position,0);
  1363.  
  1364.    for (;;) {
  1365.       if ((fgets(linea,128,quote) == NULL) || linea[0] == CTRLZ) {
  1366.          rewind(quote);
  1367.          continue;
  1368.       }
  1369.  
  1370.       if(linea[0] == '\n') {
  1371.          sysinfo.quote_position = ftell(quote);
  1372.          break;
  1373.       }
  1374.  
  1375.       m_print( "%s", linea);
  1376.    }
  1377.  
  1378.    fclose (quote);
  1379.  
  1380.    write_sysinfo ();
  1381. }
  1382.  
  1383. char far macro_bitmap[95][5]=
  1384. {
  1385.   {  0x00,0x00,0x00,0x00,0x00  },   //
  1386.   {  0x00,0x00,0x3d,0x00,0x00  },   //  !
  1387.   {  0x00,0x30,0x00,0x30,0x00  },   //  "
  1388.   {  0x12,0x3f,0x12,0x3f,0x12  },   //  #
  1389.   {  0x09,0x15,0x3f,0x15,0x12  },   //  $
  1390.   {  0x19,0x1a,0x04,0x0b,0x13  },   //  %
  1391.   {  0x16,0x29,0x15,0x02,0x05  },   //  &
  1392.   {  0x00,0x08,0x30,0x00,0x00  },   //  '
  1393.   {  0x00,0x1e,0x21,0x00,0x00  },   //  (
  1394.   {  0x00,0x21,0x1e,0x00,0x00  },   //  )
  1395.   {  0x04,0x15,0x0e,0x15,0x04  },   //  *
  1396.   {  0x04,0x04,0x1f,0x04,0x04  },   //  +
  1397.   {  0x00,0x00,0x01,0x02,0x00  },   //  ,
  1398.   {  0x04,0x04,0x04,0x04,0x04  },   //  -
  1399.   {  0x00,0x00,0x03,0x03,0x00  },   //  .
  1400.   {  0x01,0x02,0x04,0x08,0x10  },   //  /
  1401.   {  0x1e,0x21,0x25,0x21,0x1e  },   //  0
  1402.   {  0x00,0x11,0x3f,0x01,0x00  },   //  1
  1403.   {  0x11,0x23,0x25,0x29,0x11  },   //  2
  1404.   {  0x21,0x29,0x29,0x29,0x16  },   //  3
  1405.   {  0x06,0x0a,0x12,0x3f,0x02  },   //  4
  1406.   {  0x3a,0x29,0x29,0x29,0x26  },   //  5
  1407.   {  0x1e,0x29,0x29,0x29,0x26  },   //  6
  1408.   {  0x21,0x22,0x24,0x28,0x30  },   //  7
  1409.   {  0x16,0x29,0x29,0x29,0x16  },   //  8
  1410.   {  0x10,0x29,0x29,0x29,0x1e  },   //  9
  1411.   {  0x00,0x00,0x12,0x00,0x00  },   //  :
  1412.   {  0x00,0x01,0x12,0x00,0x00  },   //  ;
  1413.   {  0x00,0x04,0x0a,0x11,0x00  },   //  <
  1414.   {  0x0a,0x0a,0x0a,0x0a,0x0a  },   //  =
  1415.   {  0x00,0x11,0x0a,0x04,0x00  },   //  >
  1416.   {  0x10,0x20,0x25,0x28,0x10  },   //  ?
  1417.   {  0x1e,0x29,0x35,0x29,0x15  },   //  @
  1418.   {  0x1f,0x24,0x24,0x24,0x1f  },   //  A
  1419.   {  0x3f,0x29,0x29,0x29,0x16  },   //  B
  1420.   {  0x1e,0x21,0x21,0x21,0x12  },   //  C
  1421.   {  0x3f,0x21,0x21,0x21,0x1e  },   //  D
  1422.   {  0x3f,0x29,0x29,0x29,0x21  },   //  E
  1423.   {  0x3f,0x28,0x28,0x28,0x20  },   //  F
  1424.   {  0x1e,0x21,0x25,0x25,0x16  },   //  G
  1425.   {  0x3f,0x08,0x08,0x08,0x3f  },   //  H
  1426.   {  0x00,0x21,0x3f,0x21,0x00  },   //  I
  1427.   {  0x02,0x01,0x01,0x01,0x3e  },   //  J
  1428.   {  0x3f,0x08,0x14,0x22,0x01  },   //  K
  1429.   {  0x3f,0x01,0x01,0x01,0x01  },   //  L
  1430.   {  0x3f,0x10,0x08,0x10,0x3f  },   //  M
  1431.   {  0x3f,0x10,0x08,0x04,0x3f  },   //  N
  1432.   {  0x1e,0x21,0x21,0x21,0x1e  },   //  O
  1433.   {  0x3f,0x24,0x24,0x24,0x18  },   //  P
  1434.   {  0x1e,0x21,0x25,0x23,0x1e  },   //  Q
  1435.   {  0x3f,0x24,0x24,0x26,0x19  },   //  R
  1436.   {  0x12,0x29,0x29,0x29,0x26  },   //  S
  1437.   {  0x20,0x20,0x3f,0x20,0x20  },   //  T
  1438.   {  0x3e,0x01,0x01,0x01,0x3e  },   //  U
  1439.   {  0x38,0x06,0x01,0x06,0x38  },   //  V
  1440.   {  0x3e,0x01,0x06,0x01,0x3e  },   //  W
  1441.   {  0x23,0x14,0x08,0x14,0x23  },   //  X
  1442.   {  0x38,0x04,0x03,0x04,0x38  },   //  Y
  1443.   {  0x23,0x25,0x29,0x31,0x21  },   //  Z
  1444.   {  0x00,0x3f,0x21,0x21,0x00  },   //  [
  1445.   {  0x10,0x08,0x04,0x02,0x01  },   //  \
  1446.   {  0x00,0x21,0x21,0x3f,0x00  },   //  ]
  1447.   {  0x00,0x10,0x20,0x10,0x00  },   //  ^
  1448.   {  0x01,0x01,0x01,0x01,0x01  },   //  _
  1449.   {  0x00,0x00,0x30,0x08,0x00  },   //  `
  1450.   {  0x02,0x15,0x15,0x15,0x0f  },   //  a
  1451.   {  0x3f,0x09,0x09,0x09,0x06  },   //  b
  1452.   {  0x0e,0x11,0x11,0x11,0x0a  },   //  c
  1453.   {  0x06,0x09,0x09,0x09,0x3f  },   //  d
  1454.   {  0x0e,0x15,0x15,0x15,0x09  },   //  e
  1455.   {  0x00,0x09,0x1f,0x29,0x00  },   //  f
  1456.   {  0x08,0x15,0x15,0x15,0x0e  },   //  g
  1457.   {  0x3f,0x08,0x08,0x08,0x07  },   //  h
  1458.   {  0x00,0x01,0x17,0x01,0x00  },   //  i
  1459.   {  0x02,0x01,0x01,0x01,0x16  },   //  j
  1460.   {  0x3f,0x04,0x0a,0x11,0x00  },   //  k
  1461.   {  0x00,0x21,0x3f,0x01,0x00  },   //  l
  1462.   {  0x1f,0x10,0x1f,0x10,0x0f  },   //  m
  1463.   {  0x1f,0x10,0x10,0x10,0x0f  },   //  n
  1464.   {  0x0e,0x11,0x11,0x11,0x0e  },   //  o
  1465.   {  0x1f,0x12,0x12,0x12,0x0c  },   //  p
  1466.   {  0x0c,0x12,0x12,0x12,0x1f  },   //  q
  1467.   {  0x0f,0x10,0x10,0x10,0x10  },   //  r
  1468.   {  0x09,0x15,0x15,0x15,0x12  },   //  s
  1469.   {  0x10,0x3e,0x11,0x11,0x00  },   //  t
  1470.   {  0x1e,0x01,0x01,0x01,0x1e  },   //  u
  1471.   {  0x1c,0x02,0x01,0x02,0x1c  },   //  v
  1472.   {  0x1e,0x01,0x0e,0x01,0x1e  },   //  w
  1473.   {  0x11,0x0a,0x04,0x0a,0x11  },   //  x
  1474.   {  0x19,0x05,0x05,0x05,0x1e  },   //  y
  1475.   {  0x11,0x13,0x15,0x19,0x11  },   //  z
  1476.   {  0x08,0x16,0x21,0x21,0x00  },   //  {
  1477.   {  0x00,0x00,0x37,0x00,0x00  },   //  |
  1478.   {  0x00,0x21,0x21,0x16,0x08  },   //  }
  1479.   {  0x00,0x10,0x20,0x10,0x20  }    //  ~
  1480. };
  1481.  
  1482. static void big_char (ch)
  1483. char ch;
  1484. {
  1485.   char chars_bitmap[]=" ▄▀█";
  1486.   char bitbuf[3][5];
  1487.   char far *q;
  1488.  
  1489.   q = (char far *)¯o_bitmap[ch-' '][0];
  1490.  
  1491.   for (ch = 0; ch < 5; ch++)
  1492.   {
  1493.     bitbuf[0][ch] = chars_bitmap[q[ch] >> 4];
  1494.     bitbuf[1][ch] = chars_bitmap[(q[ch] >> 2) & 3];
  1495.     bitbuf[2][ch] = chars_bitmap[q[ch] & 3];
  1496.   }
  1497.  
  1498.   cup (2);
  1499.   m_print ("%5.5s ", bitbuf[0]);
  1500.   cle (6);
  1501.   cdo (1);
  1502.   m_print ("%5.5s ", bitbuf[1]);
  1503.   cle (6);
  1504.   cdo (1);
  1505.   m_print ("%5.5s ", bitbuf[2]);
  1506.  
  1507.   vx += 6;
  1508.   if (vx > 80) {
  1509.      vx -= 80;
  1510.      if (vy < 25)
  1511.         vy++;
  1512.   }
  1513. }
  1514.  
  1515. static void big_string (int big, char *format, ...)
  1516. {
  1517.    char *s;
  1518.    va_list var_args;
  1519.    char *string;
  1520.  
  1521.    string=(char *)malloc(256);
  1522.  
  1523.    if (string==NULL || strlen(format) > 256) {
  1524.       if (string)
  1525.          free(string);
  1526.       return;
  1527.    }
  1528.  
  1529.    va_start(var_args,format);
  1530.    vsprintf(string,format,var_args);
  1531.    va_end(var_args);
  1532.  
  1533.    if (!big || (!usr.ansi && !usr.avatar)) {
  1534.       m_print (string);
  1535.       vx += strlen (string);
  1536.       if (vx > 80) {
  1537.          vx -= 80;
  1538.          if (vy < 25)
  1539.             vy++;
  1540.       }
  1541.    }
  1542.    else
  1543.       for (s = string; *s; s++)
  1544.          big_char (*s);
  1545.  
  1546.    free(string);
  1547. }
  1548.  
  1549. static void lower_priv ()
  1550. {
  1551.    switch (usr.priv)
  1552.    {
  1553.       case DISGRACE:
  1554.          usr.priv = TWIT;
  1555.          break;
  1556.       case LIMITED:
  1557.          usr.priv = DISGRACE;
  1558.          break;
  1559.       case NORMAL:
  1560.          usr.priv = LIMITED;
  1561.          break;
  1562.       case WORTHY:
  1563.          usr.priv = NORMAL;
  1564.          break;
  1565.       case PRIVIL:
  1566.          usr.priv = WORTHY;
  1567.          break;
  1568.       case FAVORED:
  1569.          usr.priv = PRIVIL;
  1570.          break;
  1571.       case EXTRA:
  1572.          usr.priv = FAVORED;
  1573.          break;
  1574.       case CLERK:
  1575.          usr.priv = EXTRA;
  1576.          break;
  1577.       case ASSTSYSOP:
  1578.          usr.priv = CLERK;
  1579.          break;
  1580.       case SYSOP:
  1581.          usr.priv = ASSTSYSOP;
  1582.          break;
  1583.    }
  1584.  
  1585.    usr_class = get_class(usr.priv);
  1586. }
  1587.  
  1588. static void raise_priv ()
  1589. {
  1590.    switch (usr.priv)
  1591.    {
  1592.       case TWIT:
  1593.          usr.priv = DISGRACE;
  1594.          break;
  1595.       case DISGRACE:
  1596.          usr.priv = LIMITED;
  1597.          break;
  1598.       case LIMITED:
  1599.          usr.priv = NORMAL;
  1600.          break;
  1601.       case NORMAL:
  1602.          usr.priv = WORTHY;
  1603.          break;
  1604.       case WORTHY:
  1605.          usr.priv = PRIVIL;
  1606.          break;
  1607.       case PRIVIL:
  1608.          usr.priv = FAVORED;
  1609.          break;
  1610.       case FAVORED:
  1611.          usr.priv = EXTRA;
  1612.          break;
  1613.       case EXTRA:
  1614.          usr.priv = CLERK;
  1615.          break;
  1616.       case CLERK:
  1617.          usr.priv = ASSTSYSOP;
  1618.          break;
  1619.       case ASSTSYSOP:
  1620.          usr.priv = SYSOP;
  1621.          break;
  1622.    }
  1623.  
  1624.    usr_class = get_class(usr.priv);
  1625. }
  1626.  
  1627. static int set_priv (c)
  1628. char c;
  1629. {
  1630.    register int i;
  1631.  
  1632.    i = usr.priv;
  1633.  
  1634.    switch (c)
  1635.    {
  1636.       case 'T':
  1637.          i = TWIT;
  1638.          break;
  1639.       case 'D':
  1640.          i = DISGRACE;
  1641.          break;
  1642.       case 'L':
  1643.          i = LIMITED;
  1644.          break;
  1645.       case 'N':
  1646.          i = NORMAL;
  1647.          break;
  1648.       case 'W':
  1649.          i = WORTHY;
  1650.          break;
  1651.       case 'P':
  1652.          i = PRIVIL;
  1653.          break;
  1654.       case 'F':
  1655.          i = FAVORED;
  1656.          break;
  1657.       case 'E':
  1658.          i = EXTRA;
  1659.          break;
  1660.       case 'C':
  1661.          i = CLERK;
  1662.          break;
  1663.       case 'A':
  1664.          i = ASSTSYSOP;
  1665.          break;
  1666.       case 'S':
  1667.          i = SYSOP;
  1668.          break;
  1669.    }
  1670.  
  1671.    return (i);
  1672. }
  1673.  
  1674. static void build_flags (buffer, flag)
  1675. char *buffer;
  1676. long flag;
  1677. {
  1678.    int i, x;
  1679.  
  1680.    memset (buffer, ' ', 36);
  1681.    buffer[36] = '\0';
  1682.  
  1683.    x = 0;
  1684.  
  1685.    for (i=0;i<8;i++) {
  1686.       if (flag & 0x80000000L)
  1687.          buffer[x++] = '0' + i;
  1688.       flag = flag << 1;
  1689.    }
  1690.  
  1691.    for (i=0;i<8;i++) {
  1692.       if (flag & 0x80000000L)
  1693.          buffer[x++] = ((i<2)?'8':'?') + i;
  1694.       flag = flag << 1;
  1695.    }
  1696.  
  1697.    for (i=0;i<8;i++) {
  1698.       if (flag & 0x80000000L)
  1699.          buffer[x++] = 'G' + i;
  1700.       flag = flag << 1;
  1701.    }
  1702.  
  1703.    for (i=0;i<8;i++) {
  1704.       if (flag & 0x80000000L)
  1705.          buffer[x++] = 'O' + i;
  1706.       flag = flag << 1;
  1707.    }
  1708. }
  1709.  
  1710. #define  NORM   0x07
  1711. #define  BOLD   0x08
  1712. #define  FAINT  0xF7
  1713. #define  VBLINK 0x80
  1714. #define  REVRS  0x77
  1715.  
  1716. char *translate_ansi (pf)
  1717. char *pf;
  1718. {
  1719.    static char sx = 1, sy = 1;
  1720.    char c, str[10];
  1721.    int Pn[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  1722.    int i = 0, p = 0;
  1723.  
  1724.    pf++;
  1725.    c = *pf;
  1726.    if (c != '[') {
  1727.       m_print ("\x1b%c", c);
  1728.       vx += 2;
  1729.       if (vx > 80) {
  1730.          vx -= 80;
  1731.          if (vy < 25)
  1732.             vy++;
  1733.       }
  1734.       return (pf);
  1735.    }
  1736.  
  1737.    while (1) {
  1738.       pf++;
  1739.       c = *pf;
  1740.  
  1741.       if (isdigit (c))
  1742.          *(str + i++) = c;
  1743.       else {
  1744.          *(str + i) = '\0';
  1745.          i = 0;
  1746.          Pn[p++] = atoi (str);
  1747.  
  1748.          if (c == ';')
  1749.             continue;
  1750.          else
  1751.             switch(c) {
  1752.                /* (CUP) set cursor position  */
  1753.                case 'H':
  1754.                case 'F':
  1755.                case 'h':
  1756.                case 'f':
  1757.                   vy = Pn[0] ? Pn[0] : 1;
  1758.                   vx = Pn[1] ? Pn[1] : 1;
  1759.                   cpos (vy, vx);
  1760.                   return (pf);
  1761.                   /* (CUU) cursor up   */
  1762.                case 'A':
  1763.                   if (!Pn[0])
  1764.                      Pn[0]++;
  1765.                   vy -= Pn[0];
  1766.                   if (vy < 1)
  1767.                      vy = 1;
  1768.                   cup (Pn[0]);
  1769.                   return (pf);
  1770.                   /* (CUD) cursor down */
  1771.                case 'B':
  1772.                   if (!Pn[0])
  1773.                      Pn[0]++;
  1774.                   vy += Pn[0];
  1775.                   if (vy > 25)
  1776.                      vy = 25;
  1777.                   cdo (Pn[0]);
  1778.                   return (pf);
  1779.                   /* (CUF) cursor forward */
  1780.                case 'C':
  1781.                   if (!Pn[0])
  1782.                      Pn[0]++;
  1783.                   vx += Pn[0];
  1784.                   if (vx > 80)
  1785.                      vx = 80;
  1786.                   cri (Pn[0]);
  1787.                   return (pf);
  1788.                   /* (CUB) cursor backward   */
  1789.                case 'D':
  1790.                   if (!Pn[0])
  1791.                      Pn[0]++;
  1792.                   vx -= Pn[0];
  1793.                   if (vx < 1)
  1794.                      vx = 1;
  1795.                   cle (Pn[0]);
  1796.                   return (pf);
  1797.                   /* (SCP) save cursor position */
  1798.                case 's':
  1799.                   sx = vx;
  1800.                   sy = vy;
  1801.                   return (pf);
  1802.                   /* (RCP) restore cursor position */
  1803.                case 'u':
  1804.                   vx = sx;
  1805.                   vy = sy;
  1806.                   cpos (vy, vx);
  1807.                   return (pf);
  1808.                   /* clear screen   */
  1809.                case 'J':
  1810.                   if (Pn[0] == 2) {
  1811.                      vx = vy = 1;
  1812.                      cls ();
  1813.                   }
  1814.                   return (pf);
  1815.                   /* (EL) erase line   */
  1816.                case 'K':
  1817.                   del_line ();
  1818.                   return (pf);
  1819.                   /* An attribute command is more elaborate than the    */
  1820.                   /* others because it may have many numeric parameters */
  1821.                case 'm':
  1822.                   for(i=0; i<p; i++) {
  1823.                      if (Pn[i] >= 30 && Pn[i] <= 37) {
  1824.                         ansi_attr &= 0xf8;
  1825.                         switch (Pn[i]) {
  1826.                            case 30:
  1827.                               ansi_attr |= BLACK;
  1828.                               break;
  1829.                            case 31:
  1830.                               ansi_attr |= RED;
  1831.                               break;
  1832.                            case 32:
  1833.                               ansi_attr |= GREEN;
  1834.                               break;
  1835.                            case 33:
  1836.                               ansi_attr |= BROWN;
  1837.                               break;
  1838.                            case 34:
  1839.                               ansi_attr |= BLUE;
  1840.                               break;
  1841.                            case 35:
  1842.                               ansi_attr |= MAGENTA;
  1843.                               break;
  1844.                            case 36:
  1845.                               ansi_attr |= CYAN;
  1846.                               break;
  1847.                            case 37:
  1848.                               ansi_attr |= LGREY;
  1849.                               break;
  1850.                         }
  1851.                      }
  1852.  
  1853.                      if (Pn[i] >= 40 && Pn[i] <= 47) {
  1854.                         ansi_attr &= 0x8f;
  1855.                         switch (Pn[i]) {
  1856.                            case 40:
  1857.                               ansi_attr |= _BLACK;
  1858.                               break;
  1859.                            case 41:
  1860.                               ansi_attr |= _RED;
  1861.                               break;
  1862.                            case 42:
  1863.                               ansi_attr |= _GREEN;
  1864.                               break;
  1865.                            case 43:
  1866.                               ansi_attr |= _BROWN;
  1867.                               break;
  1868.                            case 44:
  1869.                               ansi_attr |= _BLUE;
  1870.                               break;
  1871.                            case 45:
  1872.                               ansi_attr |= _MAGENTA;
  1873.                               break;
  1874.                            case 46:
  1875.                               ansi_attr |= _CYAN;
  1876.                               break;
  1877.                            case 47:
  1878.                               ansi_attr |= _LGREY;
  1879.                               break;
  1880.                         }
  1881.                      }
  1882.  
  1883.                      if (Pn[i] >= 0 && Pn[i] <= 7)
  1884.                         switch(Pn[i]) {
  1885.                            case 0:
  1886.                               ansi_attr = NORM;
  1887.                               break;
  1888.                            case 1:
  1889.                               ansi_attr |= BOLD;
  1890.                               break;
  1891.                            case 2:
  1892.                               ansi_attr &= FAINT;
  1893.                               break;
  1894.                            case 5:
  1895.                            case 6:
  1896.                               ansi_attr |= VBLINK;
  1897.                               break;
  1898.                            case 7:
  1899.                               ansi_attr ^= REVRS;
  1900.                               break;
  1901.                            default:
  1902.                               ansi_attr = NORM;
  1903.                               break;
  1904.                         }
  1905.                   }
  1906.  
  1907.                   change_attr (ansi_attr);
  1908.                   return (pf);
  1909.  
  1910.                default:
  1911.                   return (pf);
  1912.             }
  1913.       }
  1914.    }
  1915. }
  1916.  
  1917. int exist_system_file (char *name)
  1918. {
  1919.    char linea[80], tmpstr[80], *p;
  1920.  
  1921.    strcpy (tmpstr, name);
  1922.    if ((p = strchr (tmpstr, '/')) != NULL)
  1923.       *(p - 1) = '\0';
  1924.  
  1925.    strtrim (tmpstr);
  1926.  
  1927.    if (dexists (tmpstr))
  1928.       return (-1);
  1929.  
  1930.    sprintf (linea, "%s.ASC", tmpstr);
  1931.    if (dexists (linea))
  1932.       return (-1);
  1933.  
  1934.    if (usr.ansi) {
  1935.       sprintf (linea, "%s.ANS", tmpstr);
  1936.       if (dexists (linea))
  1937.          return (-1);
  1938.    }
  1939.  
  1940.    if (usr.avatar) {
  1941.       sprintf (linea, "%s.AVT", tmpstr);
  1942.       if (dexists (linea))
  1943.          return (-1);
  1944.    }
  1945.  
  1946.    sprintf (linea, "%s.BBS", tmpstr);
  1947.    if (dexists (linea))
  1948.       return (-1);
  1949.  
  1950.    return (0);
  1951. }
  1952.  
  1953.