home *** CD-ROM | disk | FTP | other *** search
/ Beijing Paradise BBS Backup / PARADISE.ISO / software / BBSDOORW / HOSTBBS.ARJ / CHATMODE.SLT < prev    next >
Text File  |  1990-01-29  |  9KB  |  286 lines
  1.  
  2. //////////////////////////////////////////////////////////////////////////////
  3. //
  4. // chat_mode:
  5. //    this replaces the original chatmode found in original HOST.SLT
  6. //
  7. // entry values:
  8. //    local_stat = local_mode (is this a local mode test?)
  9. //    carrier_stat = carrier_counts (should we look out CD line?)
  10. //    capture_fname: capture file name
  11. //
  12. // return values:
  13. //    0:   normal exit by pressing F2
  14. //    1:   sysop press HOME to exit HOSTBBS
  15. //    2:   sysop press END to terminate user
  16. //    3:   connection is mysteriously lost
  17. //
  18. //////////////////////////////////////////////////////////////////////////////
  19.  
  20. int local_mode, in_chat_mode;
  21. int finished_caller, exit_requested, carrier_counts, kill_user;
  22. str capfname[64];
  23.  
  24. main(int local_stat, int carrier_stat, str capture_fname)
  25.  
  26. {
  27.     str trail[85], chat_buffer[85];
  28.     int j, c;
  29.  
  30.     local_mode = local_stat;
  31.     carrier_counts = carrier_stat;
  32.     capfname = capture_fname;
  33.     in_chat_mode = 1;
  34.     finished_caller = 0;
  35.     exit_requested = 0;
  36.     kill_user = 0;
  37.  
  38.     trail = "";
  39.     host_send("^M^J^M^J---  SysOp Initiated Chat  ---^M^J^M^J");
  40.     do {
  41.      chat_buffer = "";                      // clear chat buffer
  42.      if (strlen(trail) > 0) {        // there is word from previous line
  43.         host_send(trail);            // display it and copy it to
  44.         substr(trail, 0, strlen(trail), chat_buffer);
  45.         host_input_strn(chat_buffer, 79, strlen(trail));
  46.         trail = "";
  47.      }
  48.      else
  49.         host_input_strn(chat_buffer, 79, 0);
  50.      if (finished_caller) {
  51.           if (exit_requested)        // sysop press HOME
  52.         return 1;
  53.           else if (kill_user)        // sysop press END
  54.         return 2;
  55.           else                // connection lost
  56.         return 3;
  57.      }
  58.      if (!in_chat_mode) {            // chat mode terminated by F2
  59.           host_send("^M^J^M^J---  Chat Finished  ---^M^J^M^J");
  60.           host_send("Please press <RET> to continue...");
  61.           host_send("^M^J^M^J");
  62.           c = 0;
  63.           do {
  64.          c = host_input();
  65.           } while (c != '^M' && !finished_caller);
  66.           if (finished_caller) {
  67.          if (exit_requested)           // sysop press HOME
  68.            return 1;
  69.          else if (kill_user)           // sysop press END
  70.            return 2;
  71.          else                   // connection lost
  72.            return 3;
  73.           }
  74.           else return 0;
  75.      }
  76.      if (strlen(chat_buffer) == 79) {        // line buffer is full
  77.          j = strlen(chat_buffer) - 1;        // so remove the last word
  78.          while (subchr(chat_buffer, j) != ' '       // move before last word
  79.             && j > 0)
  80.            --j;            // point j to the first space just before the last word
  81.          substr(chat_buffer, j + 1, 80, trail);  // copy the last word to trail
  82.          while (j < strlen(chat_buffer)){         // erase the last word
  83.            host_send_c(8);         // in current line on screen
  84.            ++j;
  85.          }
  86.          host_send("^M^J");
  87.      }
  88.     } while (1);
  89.  
  90. }   // chat_mode
  91.  
  92. //////////////////////////////////////////////////////////////////////////////
  93. // host_send sends the specified string through two routes:
  94. //    1) terminal emulator, so that ANSI codes can be interpreted locally
  95. //    2) modem port
  96. //////////////////////////////////////////////////////////////////////////////
  97.  
  98. host_send(str outstr)
  99.  
  100. {
  101.  
  102.  if (!local_mode)
  103.     cputs(outstr);        // sends to modem port
  104.  printsc_trm(outstr);        // sends to screen through terminal emulator
  105.  
  106. }
  107.  
  108. //////////////////////////////////////////////////////////////////////////////
  109. // host_send_c sends the specified character through two routes:
  110. //    1) screen
  111. //    2) modem port
  112. //////////////////////////////////////////////////////////////////////////////
  113.  
  114. host_send_c(int chr)
  115.  
  116. {
  117.     str c_str[2];
  118.  
  119.     setchr(c_str, 0, chr);
  120.     setchr(c_str, 1, 0);
  121.     if (!local_mode)
  122.        cputc(chr);           // sends to modem port
  123.     printsc_trm(c_str);        // sends to terminal emulator of host
  124.  
  125. }
  126.  
  127. //////////////////////////////////////////////////////////////////////////////
  128. // host_input_strn waits the sysop/user to input a string or press <CR>
  129. // return value = 1 if string is not empty
  130. //          0 if string is empty
  131. //////////////////////////////////////////////////////////////////////////////
  132.  
  133. host_input_strn(str buf, int maximum, int start_point)
  134.  
  135. {
  136.  int i, j, key;
  137.  
  138.  i = start_point;
  139.  while (1) {                // endless loop until... lets see...
  140.    key = host_input();            // key is from host or user
  141.    if (!key) {                // timeout or user disconnect
  142.      setchr(buf, 0, 0);         // set string to empty
  143.      return 0;                // indicate there is a problem
  144.    }
  145.    if (key == '^M') {                   // Carriage return pressed
  146.       host_send("^J");                  // advance one more line
  147.       setchr(buf, 0, 0);        // and clear the buffer
  148.       break;                // out of the endless loop
  149.    }
  150.    if (key == 127 || key == 8) {  // Backspace or Del
  151.      if (i) {             // if something has been typed
  152.        --i;
  153.        host_send_c(key);     // erase one character backwards
  154.      }
  155.      continue;             // continue the endless loop
  156.    }  // if Backspace or Del
  157.    if (key == 9) {         // Horizontal Tab is converted to up to
  158.      j = 5;             // five blanks.
  159.      while (i < maximum && j > 0){
  160.      setchr(buf, i, ' ');// put char into buffer and
  161.      ++i;
  162.      --j;
  163.      host_send_c(' ');
  164.      }
  165.      continue;
  166.    }
  167.    if (key == 24) {         // Ctrl-X key pressed by user
  168.      while (i >= 0) {         // move cursor to starting point
  169.     host_send_c(8);
  170.     --i;
  171.      }
  172.      i = 0;             // reset i
  173.      continue;
  174.    }
  175.    if (i < maximum) {         // if not more than buffer size
  176.      setchr(buf, i, key);    // put char into buffer and
  177.      ++i;             // take a note about number of characters
  178.    }
  179.    if (i == maximum)         // if maximum count is reached
  180.      break;
  181.   }    // the while endless loop
  182.  
  183.  setchr(buf, i, '^0');       // mark the end of string
  184.  
  185.  if (subchr(buf, 0))         // if this is not an empty string
  186.     return 1;             // then return 1
  187.  else                 // this is an empty string
  188.     return 0;             // so return 0
  189.  
  190. }   // host_input_strn
  191.  
  192. //////////////////////////////////////////////////////////////////////////////
  193. // host input function does this:
  194. //    it starts up a timer to 5 minutes then enters an endless loop
  195. //    (No time limit if SysOp is calling this board)
  196. //    waiting for character coming from keyboard or comm port.
  197. //    any character presented in the keyboard or comm port will terminate
  198. //    the endless loop by doing the following:
  199. //       Keyboard character (from SysOp, of course):
  200. //           HOME -- sysop wants to exit the session
  201. //        END -- sysop kicks the user out (kill user)
  202. //        F1  -- sysop initiates chat mode
  203. //        F2  -- sysop terminates chat mode
  204. //        F3  -- sysop check incoming user's basic data
  205. //        All other char except BS & Del -- sends to screen & modem
  206. //       Comm port character (from User, of course):
  207. //        All other char except BS & Del -- sends to screen & modem
  208. //    return value = 0 if inactivity is too long or connection is lost
  209. //    return value = ASCII value
  210. //////////////////////////////////////////////////////////////////////////////
  211.  
  212. host_input()
  213.  
  214. {
  215.  int c, t, curt, capst;
  216.  
  217.  while (1) {
  218.  
  219.    if (carrier_counts && !carrier()) {
  220.     prints("^M^JConnection has been lost, call terminated.^M^J");
  221.     finished_caller = 1;
  222.     return 0;
  223.    }
  224.  
  225.    if ((c = inkey()) != 0) {    // if keyboard buffer is not empty
  226.  
  227.      if (c <= 255) {
  228.        if (c != 8 && c != 127 && c != 9)  // backspace & delete & tab
  229.       host_send_c(c);      // sends the character to screen & modem
  230.        return c;
  231.      }
  232.  
  233.      else if (c == 0x4700) {        // HOME key, sysop wants to exit
  234.        finished_caller = 1;
  235.        exit_requested = 1;
  236.        return 0;
  237.      }
  238.  
  239.      else if (c == 0x4f00) {        // END key, temrinate user
  240.        prints("^M^JUser terminated!");
  241.        ustamp("Terminated by SysOp", 1, 1);
  242.        if (carrier_counts)
  243.       hangup();
  244.        finished_caller = 1;
  245.        kill_user = 1;
  246.        return 0;
  247.      }
  248.                     // F1 (sysop initiate chat) is disabled
  249.  
  250.      else if (c == 0x3c00) {        // F2 key --> sysop terminate chat
  251.        in_chat_mode = 0;
  252.        return 0;
  253.      }
  254.                     // F3 (display user's data) is disabled
  255.  
  256.      else if (c == 0x3e00) {        // F4 key --> capture on/off
  257.      capst = capture_stat();
  258.      if (capst == 0)        // capture file is currently closed
  259.          capture(capfname);     // so open a capture file
  260.      else if (capst == 1 || capst == 2)  // capture file is currently open
  261.          capture("*CLOSE*");    // so close it
  262.      update_term();
  263.      }
  264.      else if (c == 0x3f00) {        // F5 key --> capture pause/unpause
  265.      capst = capture_stat();
  266.      if (capst == 1)        // capture file is currently open
  267.          capture("*PAUSE*");    // so pause it
  268.      else if (capst == 2)        // capture file is open and paused
  269.          capture("*UNPAUSE*");  // so unpause it
  270.      update_term();
  271.      }
  272.                     // F6 (reset caller's time) is disabled
  273.  
  274.    }  // if keyboard buffer is not empty
  275.  
  276.    if (!local_mode)          // if this is not a local test
  277.       if (cinp_cnt()) {       // and if something is in the comm buffer
  278.      c = cgetc();          // then read that character
  279.      if (c != 8 && c != 127 && c != 9)   // backspace & delete & tab
  280.         host_send_c(c);      // sends the character to screen & modem (echo)
  281.      return c;
  282.       }
  283.   }    // while
  284. }    // host_input
  285.  
  286.