home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / LO241SRV.ZIP / lora.c < prev    next >
C/C++ Source or Header  |  1998-08-04  |  63KB  |  1,732 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 <dos.h>
  21. #include <signal.h>
  22. #include <string.h>
  23. #include <process.h>
  24. #include <stdlib.h>
  25. #include <conio.h>
  26. #include <dir.h>
  27. #include <time.h>
  28. #include <fcntl.h>
  29.  
  30. #define INCL_DOS
  31. #include <os2.h>
  32.  
  33. void VioUpdate (void);
  34.  
  35. #include <cxl\cxlvid.h>
  36. #include <cxl\cxlwin.h>
  37. #include <cxl\cxlkey.h>
  38.  
  39. #include "lsetup.h"
  40. #include "sched.h"
  41. #include "msgapi.h"
  42. #include "externs.h"
  43. #include "prototyp.h"
  44.  
  45. #define IEMSI_ON        0x0001
  46. #define IEMSI_MAILCHECK 0x0002
  47. #define IEMSI_FILECHECK 0x0004
  48. #define IEMSI_NEWS      0x0008
  49.  
  50. extern int blank_timer;
  51. extern short tcpip;
  52. extern char *mday[], *wtext[], **dos_argv, fulleditor, nopoll, nomailproc;
  53.  
  54. extern HFILE hfComHandle;
  55.  
  56. void open_logfile (void);
  57. int spawn_program (int swapout, char *outstring);
  58. void set_prior (int);
  59. void rebuild_call_queue (void);
  60. void edit_outbound_info (void);
  61. void set_flags (void);
  62. void external_bbs (char *s);
  63. int iemsi_session (void);
  64. void get_bad_call (int, int, int, int, int);
  65. void check_new_netmail (void);
  66. char *tcpip_name (char *);
  67.  
  68. int blanked, outinfo = 0, to_row = 0, iemsi = 0;
  69. long elapsed = 0L, timeout = 0L, exectime = 0L;
  70.  
  71. int posit = 0, old_event, last_sel = 100;
  72. char interpoint = ':';
  73. long events, clocks, blankto, to, verfile, fram;
  74. struct _minf minf;
  75.  
  76. //static long pollkey = 0L;
  77.  
  78. static void remote_task (long);
  79. static int execute_events (void);
  80. static void snake_screen_blanker (int init);
  81. static void star_screen_blanker (int init);
  82.  
  83. void pull_down_menu (void);
  84. void run_external_editor (void);
  85. void shell_to_dos (void);
  86. void shell_to_config (void);
  87. void autoprocess_mail (int argc, char *argv[], long fmem);
  88. void parse_config_line (int argc, char **argv);
  89.  
  90. void main (argc, argv)
  91. int argc;
  92. char **argv;
  93. {
  94.    int j;
  95.  
  96.    _fmode = SH_DENYNONE|O_BINARY;
  97.  
  98.    signal (SIGINT, SIG_IGN);
  99.    signal (SIGABRT, SIG_IGN);
  100. //   signal (SIGTERM, SIG_IGN);
  101.    _wscroll = 0;
  102.  
  103. //   DosSetPrty (PRTYS_PROCESSTREE, PRTYC_IDLETIME, PRTYD_MAXIMUM, 0);
  104.  
  105.    directvideo = 1;
  106.    tzset ();
  107.  
  108.    exectime = time (NULL);
  109.    init_system();
  110.  
  111.    parse_config_line (argc, argv);
  112.    if (!parse_config ())
  113.       exit (1);
  114.  
  115.    parse_command_line (argc, argv);
  116.  
  117.    if (tcpip != 0) {
  118.       caller = 1;
  119.       snooping = 1;
  120.       dos_argv = NULL;
  121.    }
  122.  
  123.    if (local_mode != 2) {
  124.       setup_screen ();
  125.       local_status ("Startup");
  126.    }
  127.    else
  128.       setup_bbs_screen ();
  129.  
  130.    /* Initialize the random number generator */
  131.    j = (int) time (NULL);
  132.    srand ((unsigned int) j);
  133.  
  134.    old_event = -1;
  135.    open_logfile ();
  136.  
  137.    activation_key();
  138.    if (!registered && !local_mode && line_offset > 2) {
  139.       local_mode = 1;
  140.       dos_argv = NULL;
  141.    }
  142.  
  143.    events = time (NULL);
  144.    while (events == time (NULL))
  145.       ;
  146.  
  147.    events = 0L;
  148.         clocks = 0L;
  149.    verfile = 0L;
  150.  
  151.    minf.def_zone = config->alias[0].zone;
  152.    MsgOpenApi (&minf);
  153.  
  154. //   set_prior (2);
  155.    autoprocess_mail (argc, argv, atol (argv[argc - 1]));
  156.  
  157.    if (!local_mode)
  158.       SET_DTR_ON ();
  159.    remote_task (atol (argv[argc - 1]));
  160.  
  161.    exit (1);
  162. }
  163.  
  164. long random_time (int x)
  165. {
  166.    int i;
  167.  
  168.    if (x == 0)
  169.       x = 10;
  170.  
  171.    if (!config->random_redial)
  172.       return (timerset ((unsigned int) (x * 100)));
  173.  
  174.    /* Number of seconds to delay is random based on x +/- 50% */
  175.    i = (rand () % (x + 1)) + (x / 2);
  176.  
  177.    return (timerset ((unsigned int) (i * 100)));
  178. }
  179.  
  180. static void remote_task (fmem)
  181. long fmem;
  182. {
  183.    int i, m;
  184.    char buffer[80];
  185.    long ansto = 0L, t;
  186.    struct ffblk blk;
  187.  
  188.    fram = fmem;
  189.    if (!caller && !local_mode && tcpip == 0) {
  190.       get_call_list();
  191.       display_outbound_info (outinfo);
  192.       check_new_netmail ();
  193.    }
  194.  
  195.    if (caller && remote_net && remote_node) {
  196.       caller = 0;
  197.       poll (1, 1, remote_zone, remote_net, remote_node);
  198.       terminating_call();
  199.       get_down(aftercaller_exit, 2);
  200.       return;
  201.    }
  202.  
  203.    rate = speed;
  204.    com_baud (speed);
  205.  
  206.    if (!local_mode && !caller && tcpip == 0) {
  207.       local_status (msgtxt[M_SETTING_BAUD]);
  208.  
  209.       caller = 0;
  210.       to = timerset (200);
  211.       blankto = timerset (0);
  212.       blankto += blank_timer * 6000L;
  213.       set_useron_record (WFC, 0, 0);
  214.  
  215.       do {
  216.          if (answer_flag) {
  217.             if ((i = wait_for_connect(1)) == 1)
  218.                break;
  219.             if (!answer_flag)
  220.                local_status(msgtxt[M_SETTING_BAUD]);
  221.             else if (timeup (ansto)) {
  222.                answer_flag = 0;
  223.                status_line ("!Answer timeout");
  224.                initialize_modem ();
  225.                local_status(msgtxt[M_SETTING_BAUD]);
  226.                to = timerset (30000);
  227.             }
  228.          }
  229.          else {
  230.             if ((i = wait_for_connect(1)) == 1)
  231.                break;
  232.             if (answer_flag) {
  233.                ansto = timerset (6000);
  234.                sysinfo.today.idletime += time (NULL) - elapsed;
  235.                sysinfo.week.idletime += time (NULL) - elapsed;
  236.                sysinfo.month.idletime += time (NULL) - elapsed;
  237.                sysinfo.year.idletime += time (NULL) - elapsed;
  238.                local_status ("Answering");
  239.             }
  240.          }
  241.  
  242.          if (timeup (verfile)) {
  243.             if (registered) {
  244.                if (dexists ("ECHOMAIL.RSN") || dexists ("NETMAIL.RSN")) {
  245.                   function_active = 0;
  246.                   if (blanked)
  247.                      stop_blanking ();
  248.                   if (modem_busy != NULL)
  249.                      mdm_sendcmd (modem_busy);
  250.  
  251.                   t = time (NULL);
  252.  
  253.                   if (dexists ("NETMAIL.RSN")) {
  254.                      if (dexists ("ECHOMAIL.RSN")) {
  255.                         if (config->mail_method) {
  256.                            export_mail (NETMAIL_RSN);
  257.                            export_mail (ECHOMAIL_RSN);
  258.                         }
  259.                         else
  260.                            export_mail (NETMAIL_RSN|ECHOMAIL_RSN);
  261.                      }
  262.                      else
  263.                         export_mail (NETMAIL_RSN);
  264.                      unlink ("NETMAIL.RSN");
  265.                   }
  266.                   else
  267.                      export_mail (ECHOMAIL_RSN);
  268.                   unlink ("ECHOMAIL.RSN");
  269.  
  270.                   sysinfo.today.echoscan += time (NULL) - t;
  271.                   sysinfo.week.echoscan += time (NULL) - t;
  272.                   sysinfo.month.echoscan += time (NULL) - t;
  273.                   sysinfo.year.echoscan += time (NULL) - t;
  274.  
  275.                   if (cur_event >= 0) {
  276.                      if ( (call_list[next_call].type & MAIL_WILLGO) || !(e_ptrs[cur_event]->behavior & MAT_NOOUT))
  277.                         events = random_time (e_ptrs[cur_event]->wait_time);
  278.                   }
  279.                   else if (cur_event < 0)
  280.                      events = timerset (500);
  281.  
  282.                   local_status(msgtxt[M_SETTING_BAUD]);
  283.                   rebuild_call_queue ();
  284.                   outinfo = 0;
  285.                   unlink ("RESCAN.NOW");
  286.                   display_outbound_info (outinfo);
  287.                   events = 0L;
  288.                                                 clocks = 0L;
  289.                   to = 0L;
  290.                   old_event = -1;
  291.                   function_active = 99;
  292.  
  293.                   blankto = timerset (0);
  294.                   blankto += blank_timer * 6000L;
  295.                }
  296.  
  297.                if (dexists ("RESCAN.NOW")) {
  298.                   if (blanked)
  299.                      stop_blanking ();
  300.                   rebuild_call_queue ();
  301.                   outinfo = 0;
  302.                   display_outbound_info (outinfo);
  303.                   unlink ("RESCAN.NOW");
  304.                   blankto = timerset (0);
  305.                   blankto += blank_timer * 6000L;
  306.                }
  307.  
  308.                sprintf (buffer, "%sLEXIT*.*", config->sys_path);
  309.                if (!findfirst (buffer, &blk, 0))
  310.                   do {
  311.                      i = m = 0;
  312.                      sscanf (blk.ff_name, "LEXIT%d.%d", &i, &m);
  313.                      if (i == line_offset || i == 0) {
  314.                         unlink (blk.ff_name);
  315.                         get_down (m, 3);
  316.                      }
  317.                   } while (!findnext (&blk));
  318.             }
  319.  
  320.             verfile = timerset (1000);
  321.          }
  322.  
  323.          else if (!execute_events ()) {
  324.             local_status(msgtxt[M_SETTING_BAUD]);
  325.             to = timerset (30000);
  326.         }
  327.  
  328.          else if (timeup(to)) {
  329.                                 if (!answer_flag && !terminal) {
  330.                                         CLEAR_INBOUND ();
  331.                                         initialize_modem ();
  332.             }
  333.             to = timerset (30000);
  334.          }
  335.  
  336.          else if (timeup (blankto) && blank_timer) {
  337.             if (answer_flag) {
  338.                blankto = timerset (0);
  339.                blankto += blank_timer * 6000L;
  340.             }
  341.             else {
  342.                if (!blanked)
  343.                   begin_blanking ();
  344.                else
  345.                   blank_progress ();
  346.                blankto = timerset (20);
  347.                time_release ();
  348.                                         release_timeslice ();
  349.             }
  350.          }
  351.  
  352.          else {
  353.             time_release ();
  354.                                 release_timeslice ();
  355.          }
  356.  
  357.          if (local_kbd != -1) {
  358.             switch (local_kbd) {
  359.  
  360.                // ESC Attiva i menu' pull-down
  361.                case 0x1B:
  362.                   pull_down_menu ();
  363.                   break;
  364.  
  365.                // Alt-A Manual Answer
  366.                case 0x1E00:
  367.                   mdm_sendcmd( (config->answer[0] == '\0') ? "ATA|" : config->answer);
  368.                   answer_flag=1;
  369.                   ansto = timerset (6000);
  370.                   sysinfo.today.idletime += time (NULL) - elapsed;
  371.                   sysinfo.week.idletime += time (NULL) - elapsed;
  372.                   sysinfo.month.idletime += time (NULL) - elapsed;
  373.                   sysinfo.year.idletime += time (NULL) - elapsed;
  374.                   local_status ("Answering");
  375.                   break;
  376.  
  377.                // Alt-D Chiama subito
  378.                case 0x2000:
  379.                   events = timerset (0);
  380.                   break;
  381.  
  382.                // Alt-I Inizializza il modem
  383.                case 0x1700:
  384.                   initialize_modem ();
  385.                   break;
  386.  
  387.                // ALT-X Esce dal programma
  388.                case 0x2D00:
  389.                   if (!caller && !local_mode) {
  390.                      local_status("Shutdown");
  391.                      status_line(msgtxt[M_EXIT_REQUEST]);
  392.                      get_down(-1, 3);
  393.                   }
  394.                   break;
  395.  
  396.                // ALT-P Process ECHOmail
  397.                case 0x1900:
  398.                   process_startup_mail (1);
  399.                   break;
  400.  
  401.                // ALT-Q Rebuild outbound
  402.                case 0x1000:
  403.                   if (!answer_flag && !CARRIER) {
  404.                      rebuild_call_queue ();
  405.                      unlink ("RESCAN.NOW");
  406.                      outinfo = 0;
  407.                      display_outbound_info (outinfo);
  408.                   }
  409.                   break;
  410.  
  411.                // ALT-C Setup
  412.                case 0x2E00:
  413.                   shell_to_config ();
  414.                   break;
  415.  
  416.                // ALT-M Poll manuale
  417.                case 0x3200:
  418.                   manual_poll ();
  419.                   break;
  420.  
  421.                // Alt-V View/Modify Outbound
  422.                case 0x2F00:
  423.                   edit_outbound_info ();
  424.                   break;
  425.  
  426.                // ALT-E Editor esterno
  427.                case 0x1200:
  428.                   run_external_editor ();
  429.                   break;
  430.  
  431.                // ALT-T Terminale
  432.                case 0x1400:
  433.                   terminal_emulator ();
  434.                   hidecur ();
  435.                   events = 0L;
  436.                   to = 0L;
  437.                                                 clocks = 0L;
  438.                   blankto = timerset (0);
  439.                   blankto += blank_timer * 6000L;
  440.                   verfile = 0L;
  441.                   break;
  442.  
  443.                // ALT-S File attach
  444.                case 0x1F00:
  445.                   file_attach ();
  446.                   break;
  447.  
  448.                // ALT-R File request
  449.                case 0x1300:
  450.                   file_request ();
  451.                   break;
  452.  
  453.                // Entra nel BBS in modo locale
  454.                case 0x2500:
  455.                   if (!local_mode)
  456.                      local_mode = 1;
  457.                   break;
  458.  
  459.                // ALT-J DOS Shell
  460.                case 0x2400:
  461.                   shell_to_dos ();
  462.                   break;
  463.  
  464.                // ALT-L Lock keyboard
  465.                case 0x2600:
  466.                                                 keyboard_password ();
  467.                                                 if (locked && password != NULL && registered)
  468.                                                         prints (23, 43, YELLOW|_BLACK, "LOCKED  ");
  469.                                                 break;
  470.  
  471.                // Up arrow
  472.                case 0x4800:
  473.                   if (outinfo > 0) {
  474.                      outinfo--;
  475.                      display_outbound_info (outinfo);
  476.                   }
  477.                   break;
  478.  
  479.                // Down arrow
  480.                case 0x5000:
  481.                   if ( (outinfo + 8) < max_call) {
  482.                      outinfo++;
  483.                      display_outbound_info (outinfo);
  484.                   }
  485.                   break;
  486.  
  487.                // ALT-F1 - ALT-F10 Exit with errorlevel
  488.                case 0x6800:
  489.                case 0x6900:
  490.                case 0x6A00:
  491.                case 0x6B00:
  492.                case 0x6C00:
  493.                case 0x6D00:
  494.                case 0x6E00:
  495.                case 0x6F00:
  496.                case 0x7000:
  497.                case 0x7100:
  498.                   i = (int) (((unsigned) local_kbd) >> 8);
  499.                   status_line (msgtxt[M_FUNCTION_KEY], (i - 0x67) * 10);
  500.                   get_down ((i - 0x67) * 10, 3);
  501.                                                 break;
  502.             }
  503.  
  504.             local_kbd = -1;
  505.          }
  506.  
  507.       } while (!local_mode);
  508.  
  509.       if (local_mode) {
  510.          rate = speed;
  511.          local_status("LocalMode");
  512.       }
  513.    }
  514.  
  515.    if (local_mode) {
  516.       if (modem_busy != NULL)
  517.          mdm_sendcmd (modem_busy);
  518.       status_line ("#Connect Local");
  519.       i = 0;
  520.       config->snooping = 1;
  521.       snooping = 1;
  522.    }
  523. #if defined (__OCC__) || defined (__TCPIP__)
  524.    else if (tcpip) {
  525.       status_line ("#Connect TCP/IP (%s)", tcpip_name (buffer));
  526.       i = 0;
  527.       config->snooping = 1;
  528.       snooping = 1;
  529.    }
  530. #endif
  531.    else if (rate == -1) {
  532.       // E' stato ricevuto un CONNECT FAX
  533.       if (mdm_flags == NULL) {
  534.                         status_line("#Connect FAX%s%s", "", "");
  535.          mdm_flags = "";
  536.       }
  537.       else
  538.          status_line("#Connect FAX%s%s", "/", mdm_flags);
  539.  
  540.       // Forza lo stato delle variabili per evitare di abbattere la chiamata
  541.       // prima di lanciare il programma di ricezione dei fax.
  542.       local_mode = 0;
  543.       modem_busy = NULL;
  544.  
  545.       // Se e' presente un errorlevel di uscita per il fax, allora esce al
  546.       // DOS con l'errorlevel, altrimenti utilizza il RCVFAX.
  547.  
  548.       if (config->fax_errorlevel)
  549.          get_down (config->fax_errorlevel, 0);
  550.       else {
  551.          sprintf (e_input, "RCVFAX %d %ld %ld", com_port + 1, rate, hfComHandle);
  552.          status_line ("+Start FAX receiving program");
  553.          if ((i = spawn_program (registered, e_input)) != 0)
  554.             status_line (":Return code: %d", i);
  555.  
  556.          modem_hangup ();
  557.          get_down (0, 2);
  558.       }
  559.    }
  560.    else {
  561.       caller = 0;
  562.       function_active = 0;
  563.  
  564.       if (mdm_flags == NULL) {
  565.          status_line(msgtxt[M_READY_CONNECT],rate, "", "");
  566.          mdm_flags = "";
  567.       }
  568.       else
  569.          status_line(msgtxt[M_READY_CONNECT],rate, "/", mdm_flags);
  570.  
  571.       if (!no_logins || !registered || (cur_event >= 0 && (e_ptrs[cur_event]->behavior & MAT_OUTONLY)))
  572.          i = mail_session ();
  573.       else {
  574.          iemsi_session ();
  575.          i = 0;
  576.       }
  577.    }
  578.  
  579.    caller = 1;
  580.  
  581.    if (!i) {
  582.       if (!config->bbs_batch[0]) {
  583. #ifndef POINT
  584.          snooping = config->snooping;
  585.          if (config->snooping) {
  586.             if (local_mode != 2)
  587.                setup_bbs_screen ();
  588.             showcur ();
  589.          }
  590.          else
  591.             local_status ("Login");
  592.  
  593.          load_language (0);
  594.          text_path = config->language[0].txt_path;
  595.  
  596.          if (login_user ()) {
  597.             if (!snooping)
  598.                prints (5, 65, YELLOW|_BLACK, "User on-line");
  599.  
  600.             sprintf (buffer, "B%ld", rate);
  601.             read_system_file (buffer);
  602.  
  603.             sprintf (buffer, "SEC%d", usr.priv);
  604.             if (!read_system_file (buffer))
  605.                read_system_file ("SECALL");
  606.  
  607.             if ((i = check_subscription ()) != -1) {
  608.                status_line ("+Subscription left: %d (%s)", i, usr.subscrdate);
  609.                if (i < 31) {
  610.                   if (i > 0)
  611.                      read_system_file ("SUBWARN");
  612.                   else
  613.                      read_system_file ("SUBDATE");
  614.                }
  615.             }
  616.  
  617.             if (usr.scanmail || (iemsi & IEMSI_MAILCHECK))
  618.                if (scan_mailbox()) {
  619.                   mail_read_forward (0);
  620.                   menu_dispatcher("READMAIL");
  621.                }
  622.  
  623.             if (!iemsi || (iemsi & IEMSI_MAILCHECK))
  624.                download_filebox (1);
  625.  
  626.             if (config->newfilescheck) {
  627.                if (config->newfilescheck == 2 && !(iemsi & IEMSI_FILECHECK)) {
  628.                   m_print (bbstxt[B_CHECK_NEW_FILES]);
  629.                   if (yesno_question (DEF_NO))
  630.                      new_file_list (2);
  631.                }
  632.                else if (config->newfilescheck == 1 || (iemsi & IEMSI_FILECHECK))
  633.                   new_file_list (2);
  634.             }
  635.  
  636.             read_system (usr.msg, 1);
  637.             read_system (usr.files, 2);
  638.  
  639.             if (!iemsi || (iemsi & IEMSI_NEWS))
  640.                read_system_file("NEWS");
  641.  
  642.             menu_dispatcher(NULL);
  643.          }
  644. #endif
  645.       }
  646.       else
  647.          external_bbs (config->bbs_batch);
  648.    }
  649.    else
  650.       caller = 0;
  651.  
  652.    hidecur ();
  653.  
  654.    if (!(MODEM_STATUS() & 0x80) && !local_mode)
  655.       status_line (msgtxt[M_NO_CARRIER]);
  656.  
  657.    terminating_call ();
  658.  
  659.    get_down(aftercaller_exit, 2);
  660. }
  661.  
  662. void resume_blanked_screen ()
  663. {
  664.    if (blanked)
  665.       stop_blanking ();
  666.    else {
  667.                 blankto = timerset (0);
  668.                 blankto += blank_timer * 6000L;
  669.         }
  670. }
  671.  
  672. void time_release (void)
  673. {
  674.         int sc, i, ch, hh, mm, ss, scanc;
  675.         char cmdname[40];
  676.         long t;
  677.         struct time timep;
  678.         struct tm *tp, tpt;
  679.  
  680. //      if (!emulator && local_mode != 3) {
  681.         if (!emulator) {
  682.                 if (kbmhit ()) {
  683.                         ch = getxch ();
  684.  
  685.                         // Se lo schermo e' in blank-mode, ripristina lo schermo del mailer e
  686.                         // ritorna immediatamente. Qualunque tasto premuto ha il solo effetto di
  687.                         // fermare lo screen blanker se e' attivo.
  688.                         if (blanked) {
  689.                                 resume_blanked_screen ();
  690.                                 return;
  691.                         }
  692.  
  693.                         if ( !(ch & 0xFF) ) {
  694.                                 if (locked && registered && password != NULL && ch != 0x2500)
  695.                                         ch = -1;
  696.                         }
  697.                         else if (locked && registered && password != NULL && !local_mode) {
  698.                                 ch &= 0xFF;
  699.  
  700.                                 if (ch == password[posit]) {
  701.                                         locked = (password[++posit] == '\0') ? 0 : 1;
  702.                                         if (!locked) {
  703.                                                 if (function_active == 4)
  704.                                                         f4_status ();
  705.                                                 else if (!caller) {
  706.                                                          prints (23, 43, YELLOW|_BLACK, "UNLOCKED");
  707. //                                                       (23, 43, 23, 50, ' ', YELLOW|_BLACK);
  708.                                                 }
  709.                                         }
  710.                                 }
  711.                                 else
  712.                                         posit = 0;
  713.  
  714.                                 ch = -1;
  715.                         }
  716.                         else {
  717.                                 scanc = (ch & 0xFF00) >> 8;
  718.                                 ch &= 0xFF;
  719.                         }
  720.  
  721.          if (ch != -1) {
  722.             if (caller) {
  723.                switch (ch) {
  724.  
  725.                   // Grey +
  726.                   case '+':
  727.                      if (scanc != 0x4E) {
  728.                         local_kbd = ch;
  729.                         break;
  730.                      }
  731.                      if (usr.priv == TWIT)
  732.                         usr.priv = DISGRACE;
  733.                      else if (usr.priv == DISGRACE)
  734.                         usr.priv = LIMITED;
  735.                      else if (usr.priv == LIMITED)
  736.                         usr.priv = NORMAL;
  737.                      else if (usr.priv == NORMAL)
  738.                         usr.priv = WORTHY;
  739.                      else if (usr.priv == WORTHY)
  740.                         usr.priv = PRIVIL;
  741.                      else if (usr.priv == PRIVIL)
  742.                                                                 usr.priv = FAVORED;
  743.                                                         else if (usr.priv == FAVORED)
  744.                         usr.priv = EXTRA;
  745.                      else if (usr.priv == EXTRA)
  746.                         usr.priv = CLERK;
  747.                      else if (usr.priv == CLERK)
  748.                         usr.priv = ASSTSYSOP;
  749.                      else if (usr.priv == ASSTSYSOP)
  750.                         usr.priv = SYSOP;
  751.                      else if (usr.priv == SYSOP)
  752.                         usr.priv = TWIT;
  753.                      if (function_active == 1)
  754.                         f1_status ();
  755.                      break;
  756.  
  757.                   // Grey -
  758.                   case '-':
  759.                      if (scanc != 0x4A) {
  760.                         local_kbd = ch;
  761.                         break;
  762.                      }
  763.                      if (usr.priv == TWIT)
  764.                         usr.priv = SYSOP;
  765.                      else if (usr.priv == DISGRACE)
  766.                         usr.priv = TWIT;
  767.                      else if (usr.priv == LIMITED)
  768.                         usr.priv = DISGRACE;
  769.                      else if (usr.priv == NORMAL)
  770.                         usr.priv = LIMITED;
  771.                      else if (usr.priv == WORTHY)
  772.                         usr.priv = NORMAL;
  773.                      else if (usr.priv == PRIVIL)
  774.                         usr.priv = WORTHY;
  775.                                                         else if (usr.priv == FAVORED)
  776.                         usr.priv = PRIVIL;
  777.                      else if (usr.priv == EXTRA)
  778.                                                                 usr.priv = FAVORED;
  779.                      else if (usr.priv == CLERK)
  780.                         usr.priv = EXTRA;
  781.                      else if (usr.priv == ASSTSYSOP)
  782.                         usr.priv = CLERK;
  783.                      else if (usr.priv == SYSOP)
  784.                         usr.priv = ASSTSYSOP;
  785.                      if (function_active == 1)
  786.                         f1_status ();
  787.                      break;
  788.  
  789.                   // ALT-H Hangup forzato
  790.                   case 0x2300:
  791.                      hidecur();
  792.                      terminating_call();
  793.                      get_down(aftercaller_exit, 2);
  794.                      break;
  795.  
  796.                   // ALT-S Set security
  797.                   case 0x1F00:
  798.                      set_security ();
  799.                      break;
  800.  
  801.                   // ALT-F Set flags
  802.                   case 0x2100:
  803.                      set_flags ();
  804.                      break;
  805.  
  806.                   // ALT-L Lock-out user
  807.                   case 0x2600:
  808.                      hidecur();
  809.                      usr.priv = 0;
  810.                      terminating_call();
  811.                      get_down(aftercaller_exit, 2);
  812.                      break;
  813.  
  814.                   // ALT-N Toggle NERD flag
  815.                   case 0x3100:
  816.                      usr.nerd ^= 1;
  817.                      break;
  818.  
  819.                   // ALT-J DOS Shell
  820.                   case 0x2400:
  821.                      shell_to_dos ();
  822.                      break;
  823.  
  824.                   case 0x3B00:
  825.                      f1_status();
  826.                      break;
  827.  
  828.                   case 0x3C00:
  829.                      f2_status();
  830.                      break;
  831.  
  832.                   case 0x3D00:
  833.                      f3_status();
  834.                      break;
  835.  
  836.                   case 0x3E00:
  837.                      f4_status();
  838.                      break;
  839.  
  840.                   case 0x4300:
  841.                      f9_status();
  842.                      break;
  843.  
  844.                   // UpArr Add one minute
  845.                   case 0x4800:
  846.                      if (fulleditor) {
  847.                         local_kbd = ch;
  848.                         break;
  849.                      }
  850.                      allowed += 1;
  851.                      if (function_active == 1)
  852.                         f1_status ();
  853.                      break;
  854.  
  855.                   // DnArr Subtract one minute
  856.                   case 0x5000:
  857.                      if (fulleditor) {
  858.                         local_kbd = ch;
  859.                         break;
  860.                      }
  861.                      allowed -= 1;
  862.                      if (function_active == 1)
  863.                         f1_status ();
  864.                      break;
  865.  
  866.                   // ALT-F1 - ALT-F10  Visualizza un file .BBS
  867.                   case 0x6800:
  868.                   case 0x6900:
  869.                   case 0x6A00:
  870.                                                 case 0x6B00:
  871.                                                 case 0x6C00:
  872.                                                 case 0x6D00:
  873.                                                 case 0x6E00:
  874.                                                 case 0x6F00:
  875.                                                 case 0x7000:
  876.                                                 case 0x7100:
  877.                                                         i = (int) (((unsigned) ch) >> 8);
  878.                                                         sprintf (cmdname, "ALTF%d", (i - 0x67) * 10);
  879.                                                         read_system_file (cmdname);
  880.                                                         break;
  881.  
  882.                                                 default:
  883.                                                         local_kbd = ch;
  884.                                                         break;
  885.                                         }
  886.                                 }
  887.                                 else if (ch != -1)
  888.                                         local_kbd = ch;
  889.                         }
  890.                 }
  891.  
  892.                 if (timeup (clocks)) {
  893.                         clocks = timerset (97);
  894.  
  895.                         if (caller && snooping) {
  896.                                 if (local_mode != 2) {
  897.                                         hidecur ();
  898.                                         i = whandle();
  899.                                         wactiv (status);
  900.  
  901.                                         gettime ((struct time *)&timep);
  902.                                         sprintf (cmdname, "%02d%c%02d", timep.ti_hour % 24, interpoint, timep.ti_min % 60);
  903.                                         wprints (0, 73, BLACK|_LGREY, cmdname);
  904.                                         interpoint = (interpoint == ':') ? ' ' : ':';
  905.  
  906.                                         if (function_active == 1) {
  907.                                                 sc = time_remain ();
  908.                                                 sprintf (cmdname, "%d mins ", sc);
  909.                                                 wprints (1, 26, BLACK|_LGREY, cmdname);
  910.                                         }
  911.                                         else if ( function_active == 4 ) {
  912.                                                 sc = time_to_next (0);
  913.                                                 if (old_event != cur_event && !blanked) {
  914.                                                         wgotoxy (1, 1);
  915.                                                         wdupc (' ', 34);
  916.                                                         old_event = cur_event;
  917.                                                 }
  918.  
  919.                                                 if ( next_event >= 0 ) {
  920.                                                         sprintf (cmdname, msgtxt[M_NEXT_EVENT], next_event + 1, sc / 60, sc % 60);
  921.                                                         wprints (1, 1, BLACK|_LGREY, cmdname);
  922.                                                 }
  923.                                                 else
  924.                                                         wprints(1, 1, BLACK|_LGREY, msgtxt[M_NONE_EVENTS]);
  925.                                         }
  926.  
  927.                                         wactiv (i);
  928.                                         showcur ();
  929.                                 }
  930.                         }
  931.                         else {
  932.                                 if (!blanked) {
  933.                                         t = time (NULL);
  934.                                         tp = localtime (&t);
  935.                                         sprintf (cmdname, "%s, %s %d %d", wtext[tp->tm_wday], mday[tp->tm_mon], tp->tm_mday, tp->tm_year + 1900);
  936.                                         prints (2, 54 + ((25 - strlen (cmdname)) / 2), YELLOW|_BLACK, cmdname);
  937.                                         sprintf (cmdname, "%02d:%02d:%02d", tp->tm_hour % 24, tp->tm_min % 60, tp->tm_sec % 60);
  938.                                         prints (3, 54 + ((25 - strlen (cmdname)) / 2), YELLOW|_BLACK, cmdname);
  939.  
  940.                                         if (elapsed) {
  941.                                                 t -= elapsed;
  942.                                                 sprintf (cmdname, "%02ld:%02ld  ", t / 60L, t % 60L);
  943.                                                 prints (6, 65, YELLOW|_BLACK, cmdname);
  944.                                         }
  945.  
  946.                                         if (timeout) {
  947.                                                 t = (timeout - timerset (0)) / 100;
  948.                                                 if (t < 0L)
  949.                                                         t = 0L;
  950.                                                 sprintf (cmdname, "%02ld:%02ld", t / 60L, t % 60L);
  951.                                                 prints (to_row, 65, YELLOW|_BLACK, cmdname);
  952.                                         }
  953.                                         else if (function_active == 99) {
  954.                                                 sc = time_to_next (0);
  955.                                                 t = time (NULL);
  956.                                                 tp = localtime (&t);
  957.  
  958.                                                 if (old_event != cur_event) {
  959.                                                         old_event = cur_event;
  960.                                                         if (!blanked) {
  961.                                                                 prints (9, 65, YELLOW|_BLACK, "              ");
  962.  
  963.                                                                 if (cur_event >= 0) {
  964.                                                                         sprintf (cmdname, "%d / %02d:%02d", cur_event + 1, e_ptrs[cur_event]->minute / 60, e_ptrs[cur_event]->minute % 60);
  965.                                                                         prints (9, 65, YELLOW|_BLACK, cmdname);
  966.                                                                 }
  967.                                                                 else
  968.                                                                         prints (9, 65, YELLOW|_BLACK, "None");
  969.  
  970.                                                                 prints (7, 65, YELLOW|_BLACK, "              ");
  971.  
  972.                                                                 if (next_event >= 0) {
  973.                                                                         tpt.tm_hour = tp->tm_hour + (sc / 60);
  974.                                                                         tpt.tm_min = tp->tm_min + (sc % 60);
  975.                                                                         if (tpt.tm_min >= 60) {
  976.                                                                                 tpt.tm_min -= 60;
  977.                                                                                 tpt.tm_hour++;
  978.                                                                         }
  979.  
  980.                                                                         sprintf (cmdname, "%d / %02d:%02d", next_event + 1, tpt.tm_hour % 24, tpt.tm_min % 60);
  981.                                                                         prints (7, 65, YELLOW|_BLACK, cmdname);
  982.                                                                 }
  983.                                                                 else
  984.                                                                         prints (7, 65, YELLOW|_BLACK, "None");
  985.  
  986.                                     whline (22, 0, 30, 0, LGREY|_BLACK);
  987.                                                                         prints (22, 1, LCYAN|_BLACK, "EVENT: ");
  988.                                                                         sprintf (cmdname,"%s",e_ptrs[cur_event]->cmd);
  989.                                     cmdname[22]=0;
  990.                                                                         if(!cmdname[0])
  991.                                                                                 strcpy(cmdname,"N/A");
  992.                                                                         prints (22, 8, LGREEN|_BLACK, cmdname);
  993.  
  994.                                                                 if(e_ptrs[cur_event]->behavior & MAT_BBS)
  995.                                                                         prints (23, 2, YELLOW|_BLACK, "HUMANS OK");
  996.                                                                 else
  997.                                                                         prints (23, 2, YELLOW|_BLACK, "MAIL ONLY");
  998.  
  999.                                                                 if(e_ptrs[cur_event]->behavior & MAT_NOREQ)
  1000.                                                                         prints (23, 13, YELLOW|_BLACK, "NO FREQ");
  1001.                                                                 else
  1002.                                                                         prints (23, 13, YELLOW|_BLACK, "FREQ OK");
  1003.  
  1004.                                                                 if(e_ptrs[cur_event]->behavior & MAT_NOOUT)
  1005.                                                                         prints (23, 22, YELLOW|_BLACK, "NO OUTC.");
  1006.                                                                 else
  1007.                                                                         prints (23, 22, YELLOW|_BLACK, "CALL OUT");
  1008.  
  1009.                                                         }
  1010.                                                 }
  1011.  
  1012.                                                 if (cur_event >= 0) {
  1013.                                                         t = sc * 60L - tp->tm_sec;
  1014.                                                         ss = (int)(t % 60);
  1015.                                                         mm = (int)(t / 60) % 60;
  1016.                                                         hh = (int)(t / 3600) % 24;
  1017.                                                         sprintf (cmdname, "%02d:%02d:%02d", hh, mm, ss);
  1018.                                                         prints (8, 65, YELLOW|_BLACK, cmdname);
  1019.                                                 }
  1020.                                         }
  1021.                                 }
  1022.          }
  1023.       }
  1024.    }
  1025.  
  1026.         DosSleep (5L);
  1027. }
  1028.  
  1029. static int execute_events (void)
  1030. {
  1031.         int i, rc;
  1032.         char filename[80];
  1033.         struct ffblk blk;
  1034.  
  1035.         i = 1;
  1036.  
  1037.         if (events == 0L) {
  1038.                 find_event ();
  1039.  
  1040.                 if (cur_event >= 0) {
  1041.                         if ( (call_list[next_call].type & MAIL_WILLGO) || !(e_ptrs[cur_event]->behavior & MAT_NOOUT))
  1042.                                 events = random_time (e_ptrs[cur_event]->wait_time);
  1043.                 }
  1044.                 else if (cur_event < 0)
  1045.                         events = timerset (500);
  1046.         }
  1047.  
  1048.         if (timeup (events) && events > 0L) {
  1049.                 events = 0L;
  1050.  
  1051.                 if (answer_flag || nopoll)
  1052.                         return (1);
  1053.  
  1054.                 if (next_call < 0)
  1055.                         next_call = 0;
  1056.                 if (next_call >= max_call)
  1057.                         next_call = 0;
  1058.  
  1059.                 for (;next_call < max_call; next_call++) {
  1060.                         if (!(call_list[next_call].type & MAIL_WILLGO)) {
  1061.                                 if ((e_ptrs[cur_event]->behavior & MAT_NOOUT))
  1062.                                         continue;
  1063.                                 if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1064.                                         continue;
  1065.             if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1066.                continue;
  1067.             if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1068.                continue;
  1069.             if (e_ptrs[cur_event]->res_net && (call_list[next_call].zone != e_ptrs[cur_event]->res_zone || call_list[next_call].net != e_ptrs[cur_event]->res_net || call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1070.                continue;
  1071.             sprintf (filename, "%s%04X%04X.*", HoldAreaNameMunge (call_list[next_call].zone), call_list[next_call].net, call_list[next_call].node);
  1072.             rc = 0;
  1073.             if (!findfirst (filename, &blk, 0))
  1074.                do {
  1075.                   if (blk.ff_name[9] != 'H' && blk.ff_name[10] == 'L' && blk.ff_name[11] == 'O') {
  1076.                      rc = 1;
  1077.                      break;
  1078.                   }
  1079.                   if (blk.ff_name[9] != 'H' && blk.ff_name[10] == 'U' && blk.ff_name[11] == 'T') {
  1080.                      rc = 1;
  1081.                      break;
  1082.                   }
  1083.                } while (!findnext (&blk));
  1084.             if (!rc) {
  1085.                for (i = next_call + 1; i < max_call; i++)
  1086.                                                 memcpy (&call_list[i - 1], &call_list[i], sizeof (struct _call_list));
  1087.                max_call--;
  1088.                if (next_call >= max_call)
  1089.                   next_call = -1;
  1090.                else
  1091.                   next_call--;
  1092.                display_outbound_info (outinfo);
  1093.                continue;
  1094.             }
  1095.          }
  1096.  
  1097.                         if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1098.             continue;
  1099.          else {
  1100.             if (flag_file (TEST_AND_SET, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1101.                continue;
  1102.  
  1103.             if (blanked)
  1104.                stop_blanking ();
  1105.  
  1106.             i = poll (1, 1, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node);
  1107.             flag_file (CLEAR_FLAG, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0);
  1108.  
  1109.             if (i <= 0) {
  1110.                call_list[next_call].flags = i;
  1111.                i = 0;
  1112.                get_bad_call (call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, next_call);
  1113.             }
  1114.             else {
  1115.                bad_call (call_list[next_call].net, call_list[next_call].node, -2, 0);
  1116.                get_call_list ();
  1117.                outinfo = 0;
  1118.             }
  1119.  
  1120.             // Se la chiamata appena fatta era di tipo immediato, allora cerca
  1121.             // nella coda un altro nodo immediato, oppure sempre lo stesso se
  1122.             // non ce ne sono altri.
  1123.             if (call_list[next_call].type & MAIL_WILLGO) {
  1124.                next_call++;
  1125.  
  1126.                if (next_call >= max_call)
  1127.                   next_call = 0;
  1128.  
  1129.                for (;next_call < max_call; next_call++) {
  1130.                   if (!(call_list[next_call].type & MAIL_WILLGO))
  1131.                      continue;
  1132.  
  1133.                   if (flag_file (TEST_FLAG, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1134.                      continue;
  1135.  
  1136.                   if (bad_call (call_list[next_call].net, call_list[next_call].node, 0, 0)) {
  1137.                      call_list[next_call].type &= ~MAIL_WILLGO;
  1138.                      continue;
  1139.                   }
  1140.                   else
  1141.                      break;
  1142.                }
  1143.  
  1144.                if (next_call >= max_call) {
  1145.                   for (next_call = 0; next_call < max_call; next_call++) {
  1146.                      if (!(call_list[next_call].type & MAIL_WILLGO))
  1147.                         continue;
  1148.  
  1149.                      if (flag_file (TEST_FLAG, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1150.                         continue;
  1151.  
  1152.                      if (bad_call (call_list[next_call].net, call_list[next_call].node, 0, 0)) {
  1153.                         call_list[next_call].type &= ~MAIL_WILLGO;
  1154.                         continue;
  1155.                      }
  1156.                      else
  1157.                         break;
  1158.                   }
  1159.                }
  1160.  
  1161.                if (next_call >= max_call) {
  1162.                   for (next_call = 0; next_call < max_call; next_call++) {
  1163.                      if ((e_ptrs[cur_event]->behavior & MAT_NOOUT))
  1164.                         continue;
  1165.                      if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1166.                         continue;
  1167.                      if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1168.                         continue;
  1169.                      if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1170.                         continue;
  1171.                      if (e_ptrs[cur_event]->res_net && (call_list[next_call].zone != e_ptrs[cur_event]->res_zone || call_list[next_call].net != e_ptrs[cur_event]->res_net || call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1172.                         continue;
  1173.  
  1174.                      if (flag_file (TEST_FLAG, config->alias[0].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1175.                         continue;
  1176.  
  1177.                      if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1178.                         continue;
  1179.                      else
  1180.                         break;
  1181.                   }
  1182.  
  1183.                   if (next_call >= max_call)
  1184.                      next_call = -1;
  1185.                }
  1186.             }
  1187.             else {
  1188.                next_call++;
  1189.  
  1190.                if (next_call >= max_call)
  1191.                   next_call = 0;
  1192.  
  1193.                for (;next_call < max_call; next_call++) {
  1194.                   if (!(call_list[next_call].type & MAIL_WILLGO)) {
  1195.                      if ((e_ptrs[cur_event]->behavior & MAT_NOOUT))
  1196.                         continue;
  1197.                      if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1198.                         continue;
  1199.                      if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1200.                         continue;
  1201.                      if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1202.                         continue;
  1203.                      if (e_ptrs[cur_event]->res_net && (call_list[next_call].zone != e_ptrs[cur_event]->res_zone || call_list[next_call].net != e_ptrs[cur_event]->res_net || call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1204.                         continue;
  1205.                   }
  1206.  
  1207.                   if (flag_file (TEST_FLAG, config->alias[0].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1208.                      continue;
  1209.  
  1210.                   if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1211.                      continue;
  1212.                   else
  1213.                      break;
  1214.                }
  1215.  
  1216.                if (next_call >= max_call) {
  1217.                   for (next_call = 0; next_call < max_call; next_call++) {
  1218.                      if (!(call_list[next_call].type & MAIL_WILLGO)) {
  1219.                         if ((e_ptrs[cur_event]->behavior & MAT_NOOUT))
  1220.                            continue;
  1221.                         if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1222.                            continue;
  1223.                         if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1224.                            continue;
  1225.                         if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1226.                            continue;
  1227.                         if (e_ptrs[cur_event]->res_net && (call_list[next_call].zone != e_ptrs[cur_event]->res_zone || call_list[next_call].net != e_ptrs[cur_event]->res_net || call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1228.                            continue;
  1229.                      }
  1230.  
  1231.                      if (flag_file (TEST_FLAG, config->alias[0].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1232.                         continue;
  1233.  
  1234.                      if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1235.                         continue;
  1236.                      else
  1237.                         break;
  1238.                   }
  1239.  
  1240.                   if (next_call >= max_call)
  1241.                      next_call = -1;
  1242.                }
  1243.             }
  1244.  
  1245.             display_outbound_info (outinfo);
  1246.             break;
  1247.          }
  1248.       }
  1249.    }
  1250.  
  1251. //   if (!called) {
  1252. //      if (cur_event > -1 && (e_ptrs[cur_event]->behavior & MAT_DYNAM)) {
  1253. //         e_ptrs[cur_event]->behavior |= MAT_SKIP;
  1254. //         write_sched ();
  1255. //      }
  1256. //   }
  1257.  
  1258.    if (!i) {
  1259.       old_event = -1;
  1260.       events = 0L;
  1261.                 clocks = 0L;
  1262.       blankto = timerset (0);
  1263.       blankto += blank_timer * 6000L;
  1264.    }
  1265.  
  1266.    return (i);
  1267. }
  1268.  
  1269. /*
  1270. static int execute_events (void)
  1271. {
  1272.    int i, m, rc;
  1273.    char filename[80], called = 0;
  1274.    struct ffblk blk;
  1275.  
  1276.    i = 1;
  1277.  
  1278.    if (events == 0L) {
  1279.       find_event ();
  1280.  
  1281.       if (cur_event >= 0) {
  1282.          if ( (call_list[next_call].type & MAIL_WILLGO) || !(e_ptrs[cur_event]->behavior & MAT_NOOUT))
  1283.             events = random_time (e_ptrs[cur_event]->wait_time);
  1284.       }
  1285.       else if (cur_event < 0)
  1286.          events = timerset (500);
  1287.    }
  1288.  
  1289.    if (timeup (events) && events > 0L) {
  1290.       events = 0L;
  1291.  
  1292.       if (answer_flag)
  1293.          return (1);
  1294.  
  1295.       if (next_call >= max_call)
  1296.          next_call = 0;
  1297.  
  1298.       for (;next_call < max_call; next_call++) {
  1299.          if (!(call_list[next_call].type & MAIL_WILLGO)) {
  1300.             if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1301.                continue;
  1302.             if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1303.                continue;
  1304.             if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1305.                continue;
  1306.             if (e_ptrs[cur_event]->res_net && (call_list[next_call].net != e_ptrs[cur_event]->res_net ||
  1307.                                                call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1308.                continue;
  1309.             sprintf (filename, "%s%04X%04X.*", HoldAreaNameMunge (call_list[next_call].zone), call_list[next_call].net, call_list[next_call].node);
  1310.             rc = 0;
  1311.             if (!findfirst (filename, &blk, 0))
  1312.                do {
  1313.                   if (blk.ff_name[9] != 'H' && blk.ff_name[10] == 'L' && blk.ff_name[11] == 'O') {
  1314.                      rc = 1;
  1315.                      break;
  1316.                   }
  1317.                   if (blk.ff_name[9] != 'H' && blk.ff_name[10] == 'U' && blk.ff_name[11] == 'T') {
  1318.                      rc = 1;
  1319.                      break;
  1320.                   }
  1321.                } while (!findnext (&blk));
  1322.             if (!rc) {
  1323.                for (i = next_call + 1; i < max_call; i++)
  1324.                   memcpy (&call_list[i - 1], &call_list[i], sizeof (struct _call_list));
  1325.                max_call--;
  1326.                if (next_call >= max_call)
  1327.                   next_call = -1;
  1328.                else
  1329.                   next_call--;
  1330.                display_outbound_info (outinfo);
  1331.                continue;
  1332.             }
  1333.          }
  1334.  
  1335.          if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1336.             continue;
  1337.          else {
  1338.             if (flag_file (TEST_AND_SET, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1339.                continue;
  1340.  
  1341.             if (blanked)
  1342.                stop_blanking ();
  1343.  
  1344.             called = 1;
  1345.             i = poll(1, 1, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node);
  1346.  
  1347.             flag_file (CLEAR_FLAG, call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0);
  1348.             if (!(call_list[next_call].type & MAIL_WILLGO))
  1349.                m = next_call + 1;
  1350.             else
  1351.                m = next_call;
  1352.  
  1353.             if (i <= 0) {
  1354.                call_list[next_call].flags = i;
  1355.                i = 0;
  1356.                get_bad_call (call_list[next_call].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, next_call);
  1357.             }
  1358.             else {
  1359.                bad_call (call_list[next_call].net, call_list[next_call].node, -2, 0);
  1360.                get_call_list ();
  1361.                outinfo = 0;
  1362.             }
  1363.  
  1364.             next_call = m;
  1365.             if (next_call >= max_call)
  1366.                next_call = 0;
  1367.  
  1368.             for (;next_call < max_call; next_call++) {
  1369.                if (!(call_list[next_call].type & MAIL_WILLGO)) {
  1370.                   if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1371.                      continue;
  1372.                   if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1373.                      continue;
  1374.                   if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1375.                      continue;
  1376.                   if (e_ptrs[cur_event]->res_net && (call_list[next_call].net != e_ptrs[cur_event]->res_net || call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1377.                      continue;
  1378.                }
  1379.  
  1380.                if (flag_file (TEST_FLAG, config->alias[0].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1381.                   continue;
  1382.  
  1383.                if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1384.                   continue;
  1385.                else
  1386.                   break;
  1387.             }
  1388.  
  1389.             if (next_call >= max_call) {
  1390.                for (next_call = 0; next_call < max_call; next_call++) {
  1391.                   if (!(call_list[next_call].type & MAIL_WILLGO)) {
  1392.                      if ((call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_NOCM))
  1393.                         continue;
  1394.                      if (!(call_list[next_call].type & MAIL_CRASH) && (e_ptrs[cur_event]->behavior & MAT_CM))
  1395.                         continue;
  1396.                      if (!(call_list[next_call].type & (MAIL_CRASH|MAIL_DIRECT|MAIL_NORMAL)))
  1397.                         continue;
  1398.                      if (e_ptrs[cur_event]->res_net && (call_list[next_call].net != e_ptrs[cur_event]->res_net || call_list[next_call].node != e_ptrs[cur_event]->res_node))
  1399.                         continue;
  1400.                   }
  1401.  
  1402.                   if (flag_file (TEST_FLAG, config->alias[0].zone, call_list[next_call].net, call_list[next_call].node, call_list[next_call].point, 0))
  1403.                      continue;
  1404.  
  1405.                   if (bad_call(call_list[next_call].net,call_list[next_call].node,0,0))
  1406.                      continue;
  1407.                   else
  1408.                      break;
  1409.                }
  1410.  
  1411.                if (next_call >= max_call)
  1412.                   next_call = 0;
  1413.             }
  1414.  
  1415.             display_outbound_info (outinfo);
  1416.             break;
  1417.          }
  1418.       }
  1419.    }
  1420.  
  1421. //   if (!called) {
  1422. //      if (cur_event > -1 && (e_ptrs[cur_event]->behavior & MAT_DYNAM)) {
  1423. //         e_ptrs[cur_event]->behavior |= MAT_SKIP;
  1424. //         write_sched ();
  1425. //      }
  1426. //   }
  1427.  
  1428.    if (!i) {
  1429.       old_event = -1;
  1430.       events = 0L;
  1431.                 clocks = 0L;
  1432.       blankto = timerset (0);
  1433.       blankto += blank_timer * 6000L;
  1434.    }
  1435.  
  1436.    return (i);
  1437. }
  1438. */
  1439.  
  1440. // []----------------------------------------------------------------------[]
  1441. //    Screen blanker
  1442. // []----------------------------------------------------------------------[]
  1443. static int *scrsv;
  1444.  
  1445. static void begin_blanking ()
  1446. {
  1447.    scrsv = ssave ();
  1448.    wtextattr (LGREY|_BLACK);
  1449.    cclrscrn (LGREY|_BLACK);
  1450.  
  1451.    switch (config->blanker_type) {
  1452.       case 1:
  1453.          star_screen_blanker (1);
  1454.          break;
  1455.       case 2:
  1456.          snake_screen_blanker (1);
  1457.          break;
  1458.    }
  1459.  
  1460.    blanked = 1;
  1461.  
  1462.    VioUpdate ();
  1463. }
  1464.  
  1465. void stop_blanking (void)
  1466. {
  1467.    if (blanked) {
  1468.       switch (config->blanker_type) {
  1469.          case 1:
  1470.             star_screen_blanker (0);
  1471.             break;
  1472.          case 2:
  1473.             snake_screen_blanker (0);
  1474.             break;
  1475.       }
  1476.  
  1477.       if (scrsv != NULL)
  1478.          srestore (scrsv);
  1479.  
  1480.       blanked = 0;
  1481.       blankto = timerset (0);
  1482.       blankto += blank_timer * 6000L;
  1483.  
  1484.       VioUpdate ();
  1485.    }
  1486. }
  1487.  
  1488. static void blank_progress ()
  1489. {
  1490.    if (!blanked)
  1491.       return;
  1492.  
  1493.    switch (config->blanker_type) {
  1494.       case 1:
  1495.          star_screen_blanker (0);
  1496.          break;
  1497.       case 2:
  1498.          snake_screen_blanker (0);
  1499.          break;
  1500.    }
  1501.  
  1502.    VioUpdate ();
  1503. }
  1504.  
  1505. struct _star {
  1506.    char x;
  1507.    char y;
  1508.    char magnitude;
  1509. };
  1510.  
  1511. #define MAX_STAR  50
  1512.  
  1513. static void star_screen_blanker (int init)
  1514. {
  1515.    static struct _star *star;
  1516.    int i, m, count;
  1517.    unsigned char c;
  1518.  
  1519.    // Inizializzazione dello screen blanker
  1520.    if (init == 1) {
  1521.       randomize ();
  1522.  
  1523.       star = (struct _star *)malloc (sizeof (struct _star) * MAX_STAR);
  1524.  
  1525.       for (i = 0; i < MAX_STAR; i++) {
  1526.          do {
  1527.             star[i].x = random (80);
  1528.             star[i].y = random (25);
  1529.             for (m = 0; m < i; m++)
  1530.                if (star[i].x == star[m].x && star[i].y == star[m].y)
  1531.                   break;
  1532.          } while (m < i);
  1533.          star[i].magnitude = 0;
  1534.          printc (star[i].y, star[i].x, LCYAN|_BLACK, 249);
  1535.       }
  1536.    }
  1537.    // Eliminazione dello screen blanker
  1538.    else if (init == 2) {
  1539.       free (star);
  1540.    }
  1541.    // Se lo screen blanker deve fare qualcosa, con init == 0 puo' essere
  1542.    // fatto.
  1543.    else if (init == 0) {
  1544.       count = 0;
  1545.  
  1546.       for (i = 0; i < MAX_STAR; i++) {
  1547.          if (star[i].magnitude > 0) {
  1548.             switch (star[i].magnitude) {
  1549.                case 0:
  1550.                   c = 249;
  1551.                   break;
  1552.                case 1:
  1553.                   c = 7;
  1554.                   break;
  1555.                case 2:
  1556.                   c = 4;
  1557.                   break;
  1558.                case 3:
  1559.                   c = 42;
  1560.                   break;
  1561.                case 4:
  1562.                   c = 15;
  1563.                   break;
  1564.             }
  1565.             if (c == 249)
  1566.                printc (star[i].y, star[i].x, LCYAN|_BLACK, c);
  1567.             else
  1568.                printc (star[i].y, star[i].x, WHITE|_BLACK, c);
  1569.             star[i].magnitude++;
  1570.             if (star[i].magnitude >= 5) {
  1571.                printc (star[i].y, star[i].x, WHITE|_BLACK, ' ');
  1572.                do {
  1573.                   star[i].x = random (80);
  1574.                   star[i].y = random (25);
  1575.                   for (m = 0; m < i; m++)
  1576.                      if (star[i].x == star[m].x && star[i].y == star[m].y)
  1577.                         break;
  1578.                } while (m < i);
  1579.                star[i].magnitude = 0;
  1580.                printc (star[i].y, star[i].x, LCYAN|_BLACK, 249);
  1581.             }
  1582.  
  1583.             count++;
  1584.          }
  1585.       }
  1586.  
  1587.       for (i = count; i < 4; i++) {
  1588.          i = random (MAX_STAR);
  1589.          star[i].magnitude++;
  1590.       }
  1591.    }
  1592. }
  1593.  
  1594. #define MAX_ELEMENTS   20
  1595.  
  1596. static void snake_screen_blanker (int init)
  1597. {
  1598.    static int x[3], y[3], dir[3], oldx[3], oldy[3];
  1599.    static int elemx[3][MAX_ELEMENTS], elemy[3][MAX_ELEMENTS];
  1600.    int i, m;
  1601.  
  1602.    // Inizializzazione dello screen blanker
  1603.    if (init == 1) {
  1604.       randomize ();
  1605.  
  1606.       dir[0] = random (4);
  1607.       do {
  1608.          dir[1] = random (4);
  1609.       } while (dir[1] == dir[0]);
  1610.       do {
  1611.          dir[2] = random (4);
  1612.       } while (dir[2] == dir[0] || dir[2] == dir[1]);
  1613.  
  1614.       for (m = 0; m < 3; m++) {
  1615.          for (i = 0; i < MAX_ELEMENTS; i++)
  1616.             elemx[m][i] = elemy[m][i] = 0;
  1617.       }
  1618.  
  1619.       elemx[0][0] = x[0] = 40;
  1620.       elemy[0][0] = y[0] = 12;
  1621.       elemx[1][0] = x[1] = 20;
  1622.       elemy[1][0] = y[1] = 12;
  1623.       elemx[2][0] = x[2] = 60;
  1624.       elemy[2][0] = y[2] = 12;
  1625.       prints (y[0] - 1, x[0] - 1, LGREEN|_BLACK, "██");
  1626.                 prints (y[1] - 1, x[1] - 1, LRED|_BLACK, "██");
  1627.       prints (y[2] - 1, x[2] - 1, BLUE|_BLACK, "██");
  1628.    }
  1629.    // Eliminazione dello screen blanker
  1630.    else if (init == 2) {
  1631.       return;
  1632.    }
  1633.    // Se lo screen blanker deve fare qualcosa, con init == 0 puo' essere
  1634.    // fatto.
  1635.    else if (init == 0) {
  1636.       for (m = 0; m < 3; m++) {
  1637.          switch (dir[m]) {
  1638.             case 0:
  1639.                y[m]--;
  1640.                x[m]++;
  1641.                break;
  1642.             case 1:
  1643.                x[m]++;
  1644.                y[m]++;
  1645.                break;
  1646.             case 2:
  1647.                y[m]++;
  1648.                x[m]--;
  1649.                break;
  1650.             case 3:
  1651.                x[m]--;
  1652.                y[m]--;
  1653.                break;
  1654.          }
  1655.  
  1656.          oldx[m] = elemx[m][MAX_ELEMENTS - 1];
  1657.          oldy[m] = elemy[m][MAX_ELEMENTS - 1];
  1658.  
  1659.          for (i = MAX_ELEMENTS - 1; i > 0; i--) {
  1660.             elemx[m][i] = elemx[m][i - 1];
  1661.             elemy[m][i] = elemy[m][i - 1];
  1662.          }
  1663.  
  1664.          elemx[m][0] = x[m];
  1665.          elemy[m][0] = y[m];
  1666.  
  1667.          if (oldx[m])
  1668.             prints (oldy[m] - 1, oldx[m] - 1, WHITE|_BLACK, "  ");
  1669.  
  1670.          for (i = 0; i < MAX_ELEMENTS; i++) {
  1671.             if (elemx[m][i] == 0)
  1672.                break;
  1673.  
  1674.             if (i == 0) {
  1675.                if (m == 0)
  1676.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, LGREEN|_BLACK, "██");
  1677.                else if (m == 1)
  1678.                                                 prints (elemy[m][i] - 1, elemx[m][i] - 1, LRED|_BLACK, "██");
  1679.                else
  1680.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, BLUE|_BLACK, "██");
  1681.             }
  1682.             else if (i < MAX_ELEMENTS / 3) {
  1683.                if (m == 0)
  1684.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, LGREEN|_BLACK, "▓▓");
  1685.                else if (m == 1)
  1686.                                                 prints (elemy[m][i] - 1, elemx[m][i] - 1, LRED|_BLACK, "▓▓");
  1687.                else
  1688.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, BLUE|_BLACK, "▓▓");
  1689.             }
  1690.             else if (i < (MAX_ELEMENTS / 3) * 2) {
  1691.                if (m == 0)
  1692.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, LGREEN|_BLACK, "▒▒");
  1693.                else if (m == 1)
  1694.                                                 prints (elemy[m][i] - 1, elemx[m][i] - 1, LRED|_BLACK, "▒▒");
  1695.                else
  1696.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, BLUE|_BLACK, "▒▒");
  1697.             }
  1698.             else {
  1699.                if (m == 0)
  1700.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, LGREEN|_BLACK, "░░");
  1701.                else if (m == 1)
  1702.                                                 prints (elemy[m][i] - 1, elemx[m][i] - 1, LRED|_BLACK, "░░");
  1703.                else
  1704.                   prints (elemy[m][i] - 1, elemx[m][i] - 1, BLUE|_BLACK, "░░");
  1705.             }
  1706.          }
  1707.  
  1708.          if (x[m] == 1 && (dir[m] == 2 || dir[m] == 3)) {
  1709.             if (y[m] == 1)
  1710.                dir[m] = 1;
  1711.             else if (y[m] == 24)
  1712.                dir[m] = 0;
  1713.             else
  1714.                dir[m] = (dir[m] == 3) ? 0 : 1;
  1715.          }
  1716.          else if (x[m] == 79 && (dir[m] == 0 || dir[m] == 1)) {
  1717.             if (y[m] == 1)
  1718.                dir[m] = 2;
  1719.             else if (y[m] == 24)
  1720.                dir[m] = 3;
  1721.             else
  1722.                dir[m] = (dir[m] == 0) ? 3 : 2;
  1723.          }
  1724.          else if (y[m] == 1 && (dir[m] == 0 || dir[m] == 3))
  1725.             dir[m] = (dir[m] == 0) ? 1 : 2;
  1726.          else if (y[m] == 24 && (dir[m] == 2 || dir[m] == 1))
  1727.             dir[m] = (dir[m] == 2) ? 3 : 0;
  1728.       }
  1729.    }
  1730. }
  1731.  
  1732.