home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 11 / 11.iso / n / n002 / 4.ddi / DEMOS.ZIP / BBS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-16  |  44.3 KB  |  1,441 lines
  1. /*
  2.     BBS.C - Bulletin board system
  3.  
  4.     You are free to use this program as you see fit, with or
  5.     without the copyright notices.
  6.  
  7.     Revisions :
  8.     JHL 12-90 : eliminated all warnings with forward function declarations.
  9.     JHL 01-91 : After connecting over modem, pause 2 seconds for line
  10.                to stabilize.
  11.  
  12.     (C) Copyright 1986, 1987, 1988, 1989, 1991 South Mountain Software, Inc. 
  13. */
  14.  
  15. #include <stdio.h>
  16. #include <string.h>
  17.  
  18. #include "eclproto.h"
  19. #include "im.h"     /* Intelligent modem */
  20. #include "xm.h"     /* XMODEM */
  21. #include "xc.h"     /* Communications services */
  22. #include "i86.h"
  23.  
  24. /* Forward declarations of static functions */
  25. static int intro(void);
  26. static char *logit(char *string);
  27. static int is_dead(void);
  28. static int is_break(void);
  29. static int passwd(char *prompt);
  30. static int add(char *password);
  31. static int search(char *pwd,char *name);
  32. static int online(void);
  33. static int download(void);
  34. static int upload(void);
  35. static int files(int display);
  36. static int typefile(void);
  37. static int send_msg(int display,int inputd);
  38. static int read_msg(int display,int inputd);
  39. static int chat(void);
  40. static int leave(int reason);
  41. static int idle(void);
  42. static int echoln(char *string,int option);
  43. static int echo(char ch,int  option);
  44. static int getinput(char *buffer,int option);
  45. static int main_menu(void);
  46. static int options(void);
  47. static int window(int row,int row_count,int column,char attribute,int flag);
  48. static void sclear(void);
  49. static void wclear(void);
  50. static int dfield(int index);
  51. static char *int2asc(int ivalue);
  52. static char *tod(void);
  53. static int modem_type = 0;
  54.  
  55.  
  56.  
  57. /*  Keyboard definitions   */
  58.  
  59. #define FK1         0x3B00          /* Function key 1 */
  60. #define FK2         0x3C00          /* Function key 2 */
  61. #define FK3         0x3D00          /* Function key 3 */
  62. #define FK4         0x3E00          /* Function key 4 */
  63. #define FK5         0x3F00          /* Function key 5 */
  64. #define RUB1        0x08            /* Rubout */
  65. #define RUB2        0x7F            /* Rubout */
  66. #define RET         0x0D            /* CR */
  67.  
  68. #define RINGS       5               /* Number of rings to answer on */
  69. #define CTRL_Z      0x1A            /* EOFILE */
  70. #define XON         0x11            /* Enable data transmission */
  71. #define XOFF        0x13            /* Disable data transmission */
  72.  
  73. /*  Miscellaneous  */
  74.  
  75. #define RETRIES      3              /* Signon retries */
  76. #define MIN_BUFFERS  8              /* Minimum buffers required */
  77. #define SCROLL       1              /* Scroll flag value */
  78. #define CLEARS       0              /* Clear the screen value */
  79. #define MAXFIELD    79              /* Maximum field */
  80. #define STATUSROW   24              /* Row address of status row */
  81. #define SCRWIDTH    79              /* Last column */
  82. #define STATCOLUMN  31              /* Starting column of rightmost status */
  83. #define STATWIDTH   48              /* Width of the rightmost status */
  84.  
  85. #define LOG_INTRO   0                   /* logs[...] */
  86. #define LOG_EXIT    1
  87. #define LOG_SON     2
  88. #define LOG_NEW     3
  89. #define LOG_OLD     4
  90. #define LOG_OFF     5
  91. #define LOG_TERM    6
  92. #define LOG_PASS    7
  93. #define LOG_CONN    8
  94. #define LOG_RING    9
  95. #define LOG_TIMO    10
  96.  
  97. #define XMODEM      11
  98. #define SESSION     12
  99. #define FAILED      13
  100. #define CANCELLD    14
  101. #define USERABORT   15
  102. #define FILEOPEN    16
  103. #define FILEIO      17
  104.  
  105. static char *logs[] = {
  106.     "*** BBS Started",                  /* LOG_INTRO */
  107.     "*** BBS Exited",                   /* LOG_EXIT */
  108.     "Answered at ",                     /* LOG_SON */
  109.     " new user on ",                    /* LOG_NEW */
  110.     " old user on ",                    /* LOG_OLD */
  111.     " logged off",                      /* LOG_OFF */
  112.     " aborted by BBS - shutdown ",      /* LOG_TERM */
  113.     " aborted by BBS - bad password ",  /* LOG_PASS */
  114.     " User lost connection ",           /* LOG_CONN */
  115.     " RING acknowledged by BBS ",       /* LOG_RING */
  116.     " User timeout ",                   /* LOG_TIMO */
  117.  
  118.     "Transfer completed",
  119.     "Transfer session error",
  120.     "Transfer failed",
  121.     "Transfer cancelled by user",
  122.     "Transfer was terminated by BBS",
  123.     "Transfer file open error",
  124.     "Transfer file I/O error",
  125.  
  126.     ""
  127. };
  128.  
  129. static char    logbuf[80];
  130. static char    Username[40];
  131. static char    bbs[] = "BBS";
  132.  
  133. static char xmodeminfo[] =
  134.   "Blocks transferred [%d]  refused [%d]  timeouts [%d]  garbled [%d]";
  135. /*  File names used by BBS  */
  136. static char    log_file[] = "LOG.ASC";
  137. static char    int_file[] = "INTRO.ASC";
  138. static char    msg_file[] = "MESSAGE.ASC";
  139. static char    msg_temp[] = "MESSAGE.$$$";
  140. static char    pas_file[] = "PASSWORD.ASC";
  141. static char    dir_file[] = "FILES.ASC";
  142.  
  143. static char    product[]  =  "\n\nSouth Mountain Bulletin Board System Rev. 4.0\n";
  144. static char    copyr1[]   =  "Copyright (C) 1991 South Mountain Software, Inc.\n";
  145.  
  146. /*  Field indices (into the <text> array structure) */
  147.  
  148. #define MAIN_F1     0
  149. #define MAIN_EXIT   1
  150. #define MAIN_STAT   2
  151. #define OPTN_F1     3
  152. #define OPTN_F2     4
  153. #define OPTN_F3     5
  154. #define OPTN_F4     6
  155. #define OPTN_EXIT   7
  156.  
  157. #define NULL_STR    8                   /* The last one */
  158.  
  159. #define COMPORT     28
  160. #define COMBAUD     30
  161. #define COMPARITY   38
  162. #define COMDATA     41
  163. #define COMSTOP     43
  164.  
  165. #define COM_HELP    45
  166. #define COM_ACCEPT  46
  167. #define COM_ABORT   47
  168. #define COM_ACP     48
  169.  
  170.  
  171. static struct {
  172.     int row;                            /* Row coordinate */
  173.     int col;                            /* Column coordinate */
  174.     int wid;                            /* Width */
  175.     char *str;                          /* Character string */
  176. } text[] = {
  177.     { STATUSROW, 18, 12, "[F1] options" },
  178.     { STATUSROW,  0, 17, "[Ctrl-Break] Exit" },
  179.     { STATUSROW, STATCOLUMN, STATWIDTH, logbuf },
  180.  
  181.     { STATUSROW,  0, 14, "[F1] Send mail" },
  182.     { STATUSROW, 15, 14, "[F2] Read mail" },
  183.     { STATUSROW, 30, 13, "[F3] File dir" },
  184.     { STATUSROW, 44, 14, "[F4] File load" },
  185.     { STATUSROW, 59, 17, "[Ctrl-Break] Exit" },
  186.  
  187.     { STATUSROW,  0, SCRWIDTH, "" },
  188.     { 0, 0, 0, "" }
  189. };
  190.  
  191. static char *baudstr[] = {
  192.     "110 baud", "150 baud", "300 baud", "600 baud", 
  193.     "1200 baud", "2400 baud", "4800 baud", "9600 baud",
  194.      "19200 baud", "38400 baud","57K baud","115K baud"
  195. };
  196.  
  197. static char Firstname[] = "\nEnter your name : ";
  198. static char Nouser[]    = "\n\007There is no user with that name\n";
  199. static char Password[]  = "\nWelcome back! Please enter your password : ";
  200. static char Hellonew[]  = "\nA new USER! - create a password : ";
  201. static char Logoff[]    = "\nThe BBS is coming down - NOW!\n";
  202. static char NoResponse[]= "\nYou haven't typed anything in 2 minutes - BYE!\n";
  203. static char Oops[]      = "\007 Please enter a valid command letter\n";
  204. static char Illpass[]   = "\nPassword is not legal\n";
  205. static char Thanks[]    = "\nThank you very much\n";
  206. static char Chat1[]     = "\nEnter characters (press Ctrl-Z to exit):\n";
  207. static char Nofile[]    = "\n\007No files are available for download\n";
  208. static char Whatfile[]  = "\nWhat file do you wish to view : ";
  209. static char Upfile[]    = "\nWhat file do you wish to upload : ";
  210. static char Downfile[]  = "\nWhat file do you wish to download : ";
  211. static char Towhom[]    = "\nSend message to (give user name or 'BBS') : ";
  212. static char Nofilex[]   = "\n\007The file you requested does not exist\n";
  213. static char Textend[]   = "\n[Thank you]\n";
  214. static char No_msg[]    = "\n\007You have no messages\n";
  215. static char Msgwhen[]   = "[Message dated] ";
  216. static char Msgfrom[]   = "\n[From] ";
  217. static char Msgstart[]  = "\n";
  218. static char Msgend[]    = "\n";
  219. static char Delmsg[]    = "\nDo you wish to delete the message (Y or N) : ";
  220. static char Byebye[]    = "\nBye bye - please disconnect your modem\n";
  221. static char Filereq[]   = "\nEnter the filename you wish to load into BBS : ";
  222. static char Descrip[]   = "\nEnter in a brief description : ";
  223. static char Opt_inst[]  = "\nPress one of the function keys below\n\n";
  224. static char Getready[]  = "\nNow, start your PC file transfer\n";
  225. static char NoModem[]   = "\nYour modem is not working!\n";
  226. static char *Menu[] = {
  227.     "\n\nCommand Choices are:\n\n",
  228.     "R  Read messages\n",
  229.     "S  Send messages\n",
  230.     "C  Chat with the BBS\n",
  231.     "U  Upload a file\n",
  232.     "D  Download a file\n",
  233.     "F  File directory list\n",
  234.     "V  View a text file\n",
  235.     "Q  Quit\n",
  236.     "\nEnter command desired : ",
  237.     ""
  238. };
  239.  
  240.  
  241. #define INPT_COM    64                      /* User keyboard entry */
  242. #define INPT_KEY    32                      /* BBS keyboard entry */
  243. #define INPT_UPR    16                      /* Uppercase conversion */
  244. #define ECHO_SCR    8                       /* Send to the screen */
  245. #define ECHO_COM    4                       /* Send to the comm port */
  246. #define ECHO_DOT    1                       /* Display a dot */
  247.  
  248. /*  User or BBS abort status */
  249.  
  250. #define BBS_OK      0                       /* abort_status */
  251. #define BBS_TERM    1                       /* BBS wants to terminate user */
  252. #define USER_DISC   2                       /* User dropped CD */
  253. #define USER_TIMO   3                       /* No response */
  254.  
  255. static int abort_status    = BBS_OK;
  256.  
  257.  
  258. /*  Modem session status */
  259.  
  260. #define COMM_IDLE   0           
  261. #define COMM_CONN   1
  262.  
  263. static int comm_status     = COMM_IDLE;
  264. static int bbs_noecho = 0;                  /* Enable bbs_noecho */
  265. static int bbs_hardwire = 0;                     /* linked via null modem if = 1 */
  266.                                              /* or 2nd command line arg = 'H' */
  267.  
  268. #define TIMEOUT 1500
  269. static int timeoutf = 0;                   /* Flag if set means waiting for input */
  270.  
  271.  
  272. /*  COMMUNICATIONS CONFIGURATION -- ALWAYS COM1!  */
  273.  
  274. #define DEFBAUD BAUD1200
  275. static int Port = COM1;                    /* Default communications port */
  276. static int Baud = DEFBAUD;                 /* Default baud rate */
  277. static int Parity = NOPAR;                 /* Default parity */
  278. static int Data = DATA8;                   /* Default data bit size */
  279. static int Stop = STOP1;                   /* Default stop bit */
  280. static int attr_status = 0x70;             /* Default attribute */
  281. static int attr_text   = 0x07;             /* Text window (emulator) attribute */
  282.  
  283. static char *days[] = {
  284.     "Sun ", "Mon ", "Tue ", "Wed ", "Thu ", "Fri ", "Sat "
  285. };
  286.  
  287. static char    buffer[26];            /* Working character buffer */
  288. static  union i86_reg packet;  /* DOS interrupt request handler */
  289.  
  290. static char intbuffer[3];      /* Convert an 8-bit integer to ASCII-decimal */
  291.  
  292.  
  293. void main(
  294. int argc,
  295. char *argv[])
  296. {
  297.     int     i, idx;
  298.  
  299.     if (argc == 3) {
  300.         switch (*argv[1]) {
  301.         case '1':       /* Assume 1200, 19200, 115K baud */
  302.                 switch (argv[1][1]) {
  303.                     case '2':  /* Assume 1200 Baud */                
  304.                         Baud = BAUD1200;
  305.                       break;
  306.                     case '9':  /* Assume 19200 Baud */                
  307.                         Baud = BAUD19200;
  308.                       break;
  309.                     case '1':  /* Assume 115K Baud */                
  310.                         Baud = BAUD115K;
  311.                       break;
  312.                 }                            
  313.                 break;
  314.  
  315.         case '2':                   /* Assume 2400 baud */
  316.             Baud = BAUD2400;
  317.             break;
  318.  
  319.         case '3':                   
  320.                 if ((argv[1][1]) == '8')  /* Assume 38400 baud */
  321.                 Baud = BAUD38400;
  322.                 else  /* Assume 300 baud */
  323.                 Baud = BAUD300;
  324.             break;
  325.  
  326.         case '4':                   /* Assume 4800 baud */
  327.             Baud = BAUD4800;
  328.             break;
  329.  
  330.         case '5':                   /* Assume 57K baud */
  331.             Baud = BAUD57K;
  332.             break;
  333.  
  334.         case '6':                   /* Assume 600 baud */
  335.             Baud = BAUD600;
  336.             break;
  337.  
  338.         case '9':                   /* Assume 9600 baud */
  339.             Baud = BAUD9600;
  340.             break;
  341.         }
  342.  
  343.            if(( *argv[2] == 'H' || *argv[2] == 'h'))  {
  344.                   bbs_hardwire = 1;        /* not going through modem */
  345.          }
  346.           else {
  347.                   modem_type = atoi(argv[2]);
  348.           }
  349.  
  350.         if (argc > 3)
  351.             bbs_noecho = 1;         /* Disable bbs_noecho */
  352.  
  353.     }
  354.     else  {
  355.         printf("\nFORMAT : \nbbs [baud] [mt]");
  356.         printf("\n\nWHERE:\n  baud: opening baud rate : 1200 to 155K baud");
  357.         printf("\n  mt: modem type");
  358.           printf("\n        0 = Hayes Ultra; 1 = USR Courier;     2 = Microcom QX or UDS Fastalk;");
  359.           printf("\n        3 = Telebit;     4 = MultiTech;       5 = GVC SM96;");
  360.           printf("\n        6 = Ventel;      7 = Digicom Systems; 8 = Generic type;");
  361.           printf("\n                         9 = Standard type;");
  362.           printf("\n                 H = Hardwired togeather without modem");
  363.         return;
  364.     }
  365.  
  366.     
  367.     printf("Setting up BBS on COM1 at %s, 8 data, no parity, 1 stop\n", baudstr[Baud]);
  368.     switch (xc_entr(MIN_BUFFERS)) {
  369.     case 0:
  370.         xc_link(Port, 2);
  371.         xc_init(Port, Baud, Parity, Data, Stop);
  372.         xck_link();
  373.         xct_link();
  374.           if (!bbs_hardwire){
  375.               im_setmodem(Port,modem_type,2);    
  376.             if (im_fopen(Port) < IM_OK) {
  377.                 echoln(NoModem, ECHO_SCR);
  378.                 xc_exit();
  379.                 break;
  380.             }
  381.            else
  382.                xctp_pend(Port,36);  /* pause 2 secs. */
  383.                im_spkr(Port,IM_SPKR_OFF);
  384.  
  385.           }
  386.         wclear();
  387.         sclear();
  388.         logit(logs[LOG_INTRO]);
  389.         while (abort_status != BBS_TERM) {
  390.           for (idx = 0; (idx < 1); ++idx) { /* Do it once */
  391.             if (idle() < 0)
  392.                 break;
  393.             if (modem_type == 9) /* if STANDARD_TYPE MODEM, pause in case
  394.                                     there is an MNP on the other end. Otherwise
  395.                                     the intro may get lost while the modems
  396.                                     finish negotiating */
  397.                {
  398.                xct_link();
  399.                xct_pend(18 * 2); /* wait 2 seconds */
  400.                xct_unlk();
  401.                }
  402.             if (intro() < 0) 
  403.                 break;
  404.             for (i = 0; ((is_dead() == 0) && (i < RETRIES)); ++i) {
  405.                 if (passwd(Firstname) == 0)
  406.                     break;                  /* Found the user */
  407.             }
  408.             if (i == RETRIES) {             /* Too many retries ! */
  409.                 leave(LOG_PASS);
  410.             } else {                        /* Signed on! */
  411.                 if (is_dead() == 0)         /* Handle all of the menus */
  412.                     online();
  413.                 if (is_dead() == 0) 
  414.                     leave(LOG_OFF);         /* Graceful exit */
  415.                 else {                      /* Error exit */
  416.                     switch (abort_status) {
  417.                     case BBS_TERM:
  418.                         echoln(Logoff, ECHO_SCR | ECHO_COM);
  419.                         leave(LOG_TERM);
  420.                         break;
  421.                     case USER_DISC:
  422.                         leave(LOG_CONN);    /* User lost connection */
  423.                         break;
  424.                     case USER_TIMO:
  425.                         echoln(NoResponse, ECHO_SCR | ECHO_COM);
  426.                         leave(LOG_TIMO);
  427.                         break;
  428.                     }
  429.                 }
  430.             }
  431.           }                                 /* Do it once */
  432.         }                                   /* End of while loop */
  433.  
  434.         echoln(logs[LOG_EXIT], ECHO_SCR | ECHO_COM);
  435.         logit(logs[LOG_EXIT]);
  436.  
  437.         xck_unlk();
  438.           if(!bbs_hardwire)
  439.             im_close(Port);
  440.         xc_unlk(Port);
  441.         wclear();
  442.         sclear();
  443.         xc_exit();
  444.         break;
  445.     case -1:
  446.         printf("XCOMMS is not properly installed\n");
  447.         break;
  448.     case -2:
  449.         printf("Internal error - BBS improperly exited before\n");
  450.         break;
  451.     default:
  452.         xct_unlk();
  453.         xc_exit();  
  454.         printf("Not enough buffers are allocated for BBS\n");
  455.         break;
  456.     }
  457. }
  458.  
  459. static int intro(void)
  460. {
  461.     char buffer[82];
  462.     FILE *Stream;
  463.  
  464.     if (echoln(product, ECHO_SCR | ECHO_COM) < 0)
  465.         return(-1);
  466.     if (echoln(copyr1, ECHO_SCR | ECHO_COM) < 0)
  467.         return(-1);
  468.      Stream = fopen(int_file, "r");
  469.     if (Stream)  {
  470.         while (fgets(buffer, 80, Stream) != NULL) {
  471.             if (echoln(buffer, ECHO_SCR | ECHO_COM) < 0)
  472.                 return(-1);
  473.         }
  474.         fclose(Stream);
  475.     }
  476.     return(0);
  477. }
  478.  
  479. /*
  480.     logit   Add the character string to the current log file - append
  481.             the date and time.  Also, report this status to the user
  482.             on the status line automatically.  
  483. */
  484.  
  485. static char *logit(char *string)
  486. {
  487.  
  488.     FILE *Stream;
  489.      Stream = fopen(log_file, "a+");
  490.     if (Stream)  {
  491.         strncpy(logbuf, string, 80);
  492.         strcat(logbuf, " ");
  493.         strcat(logbuf, tod());
  494.         dfield(MAIN_STAT);
  495.         fputs(logbuf, Stream);
  496.         fclose(Stream);
  497.     } 
  498.     return(0);                              /* Status is ignored */
  499. }
  500.  
  501.  
  502.  
  503. /*
  504.     is_dead     VERY IMPORTANT!
  505. */
  506.  
  507. static int is_dead(void)
  508. {
  509.     int status = -1;                    /* Assume all failed */
  510.     if (abort_status  == BBS_OK) {
  511.         if (is_break() == 0) {
  512.             if (comm_status == COMM_CONN) {
  513.                 if (xc_dcd(Port) == 0) {
  514.                     abort_status = USER_DISC;
  515.                 } else {                /* Connection (DCD) still on */
  516.                     status = 0;
  517.                 }
  518.                 if (timeoutf) {         /* Waiting for user input */
  519.                     if (xct_test() == 0) {
  520.                         timeoutf = 0;   /* Ignore the timeoutf now */
  521.                         abort_status = USER_TIMO;
  522.                         status = -1;
  523.                     }
  524.                 }
  525.             } else {                    /* No connection anyways ... */
  526.                 status = 0;
  527.             }
  528.         } else {                        /* User pressed Ctrl-Break */
  529.             abort_status = BBS_TERM;
  530.         }
  531.     }
  532.   if (!bbs_hardwire || (abort_status == BBS_TERM))
  533.       return(status);
  534.   else
  535.       return(0);
  536.  
  537. }
  538.  
  539. static int is_break(void)  /* Test for the presence of a Ctrl-Break abort */
  540. {               /* This does not assume a catestrophic error! */
  541.     int status;
  542.  
  543.      status = xck_test();
  544.     if (status) {          /* Ctrl-Break pressed */
  545.         while (xck_keyt())
  546.             xck_getc();
  547.     }
  548.     return(status);
  549. }
  550.  
  551. static int passwd(         /* Log in the user return a 0 if OK, -1 if in error */
  552. char *prompt)       /* Will not let user login as BBS */
  553. {
  554.     char    buff3[81];
  555.     char    buffer[81];
  556.     char    real_pwd[81];
  557.     int     status = 0;            /* Assume all is OK */
  558.  
  559. /*  Ask the user for first and last name */
  560.  
  561.     real_pwd[0] = CTRL_Z; 
  562.     real_pwd[1] = '\n';
  563.     real_pwd[2] = '\000';
  564.     echoln(prompt, ECHO_SCR | ECHO_COM);
  565.     getinput(Username, ECHO_SCR | ECHO_COM | INPT_UPR | INPT_KEY | INPT_COM);
  566.  
  567. /*  Now search for existence of it */
  568.  
  569.     if (is_dead())
  570.         return(-1);             /* OOPS - DROPPED CONNECTION */
  571.  
  572.     if  (search(real_pwd, Username) == 0) {         /* Found the entry */
  573.         echoln(Password, ECHO_SCR | ECHO_COM);
  574.         getinput(buff3,ECHO_SCR|ECHO_COM|INPT_UPR|INPT_KEY|ECHO_DOT|INPT_COM);
  575.         strcat(buff3, "\n");
  576.         if (is_dead())
  577.             return(-1);             /* OOPS - DROPPED CONNECTION */
  578.         if (strcmp(buff3, real_pwd) == 0) {
  579.             echoln(Thanks, ECHO_SCR | ECHO_COM);
  580.             strcpy(buffer, Username);
  581.             strcat(buffer, logs[LOG_OLD]);
  582.             logit(buffer);
  583.         } else {
  584.             status = -1;
  585.             echoln(Illpass, ECHO_SCR | ECHO_COM);
  586.         }
  587.     } else {                            /* New user */
  588.         echoln(Hellonew, ECHO_SCR | ECHO_COM);
  589.         getinput(buff3,ECHO_SCR|ECHO_COM|INPT_UPR|INPT_KEY|ECHO_DOT|INPT_COM);
  590.         add(buff3);
  591.         strcpy(buffer, Username);
  592.         strcat(buffer, logs[LOG_NEW]);
  593.         logit(buffer);
  594.     }
  595.     comm_status = COMM_CONN;            /* User is now connected */
  596.     return(status);   
  597. }
  598.  
  599. static int add(       /* Add a username, password, and original date */
  600. char *password)
  601. {
  602.     char    buffer[81];
  603.     FILE    *Stream;
  604.  
  605.     Stream = fopen(pas_file, "a+");
  606.     strcpy(buffer, Username);
  607.     strcat(buffer, "\n");
  608.     fputs(buffer, Stream);
  609.     strcpy(buffer, password);
  610.     strcat(buffer, "\n");
  611.     fputs(buffer, Stream);
  612.     fputs(tod(), Stream);
  613.     fclose(Stream);
  614.     return(0);    
  615. }
  616.  
  617. /*  User BBS is the default and is quickly qualified  */
  618. static int search(          /* Search the password data base for the Username */
  619. char *pwd,                  /* Return the password if found */
  620. char *name)                 /* Given the name to search */
  621. {
  622.     int status = -1;    /* Assume that there is none */
  623.     char    buffer[81];
  624.     char    _user[81];
  625.     FILE    *Stream;
  626.  
  627.     if (strcmp(name, bbs) != 0) {
  628.         
  629.     if ((Stream = fopen(pas_file, "r")) != NULL) {
  630.     strcpy(_user, name);
  631.     strcat(_user, "\n");
  632.         while ( (char *) fgets(buffer,  80, Stream) != NULL) {
  633.             if (strcmp(buffer, _user) == 0) {
  634.                 fgets(pwd, 80, Stream);       /* Return the password */
  635.                 status = 0;                   /* Signal successful search */
  636.                 break;
  637.             } else {
  638.                 fgets(buffer, 80, Stream);    /* Read past password */
  639.                 fgets(buffer, 80, Stream);    /* And startup date */
  640.             }
  641.         }
  642.         fclose(Stream);
  643.     }    
  644.     } else
  645.         status = 0;
  646.     return(status);
  647. }
  648.  
  649.  
  650. static int online(void)    /* Return a 0 if user wishes to exit, -1 if error */
  651. {           /* Stay here as long as user is using the menus */
  652.     int i;
  653.     char    buffer[81];
  654.     int exitflag = 0;
  655.     while (exitflag == 0) {
  656.         for (i = 0;(*Menu[i]);++i) {    /* Display the user online options */
  657.             echoln(Menu[i], ECHO_SCR | ECHO_COM);
  658.         }
  659.         getinput(buffer, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM | INPT_UPR);
  660.         if (echoln("\n", ECHO_SCR | ECHO_COM) < 0)
  661.             return(-1);
  662.         switch (buffer[0]) {
  663.         case 'R':
  664.             read_msg(ECHO_SCR | ECHO_COM, INPT_KEY | INPT_COM);
  665.             break;
  666.         case 'S':
  667.             send_msg(ECHO_SCR | ECHO_COM, INPT_KEY | INPT_COM);
  668.             break;
  669.         case 'C':
  670.             chat();
  671.             break;
  672.         case 'U':
  673.             upload();
  674.             break;
  675.         case 'D':
  676.             download();
  677.             break;
  678.         case 'F':
  679.             files(ECHO_SCR | ECHO_COM | INPT_COM | INPT_KEY);
  680.             break;
  681.         case 'V':
  682.             typefile();
  683.             break;
  684.         case 'Q':
  685.             exitflag = 1;
  686.             break;
  687.         default:
  688.             echoln(Oops, ECHO_SCR | ECHO_COM);
  689.  
  690.             break;
  691.         }
  692.     }
  693.     return(0);    /* User wishes to exit now */
  694. }
  695.  
  696. static int download(void)
  697. { 
  698.     int row, column;
  699.     char answer[81];
  700.     char buffer[81];
  701.     int status;
  702.     int index;
  703.      char protocol;
  704.  
  705.      status = 1;
  706.      while(status)
  707.          {
  708.         echoln("\n\nDownload Choices Are:\n\n" , ECHO_SCR | ECHO_COM);
  709.         echoln("X  XMODEM\n", ECHO_SCR | ECHO_COM);
  710.         echoln("M  XMODEM 1K\n", ECHO_SCR | ECHO_COM);
  711.          echoln("Y  YMODEM\n", ECHO_SCR | ECHO_COM);
  712.         echoln("K  KERMIT\n", ECHO_SCR | ECHO_COM);
  713.         echoln("Q  QUIT\n", ECHO_SCR | ECHO_COM);
  714.           echoln("\n Enter your choice: ", ECHO_SCR | ECHO_COM);
  715.  
  716.          getinput(answer, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM | INPT_UPR);
  717.          switch(answer[0])
  718.              {
  719.              case 'X':
  720.              case 'M':
  721.              case 'Y':
  722.              case 'K':
  723.                  {
  724.                  status = 0;
  725.                  protocol = answer[0];
  726.                  break;
  727.                  }
  728.              case 'Q':
  729.                  return(0);
  730.              default:
  731.                 echoln("\n\n\007Invalid Response\n\n", ECHO_SCR | ECHO_COM);
  732.              }
  733.          }
  734.  
  735.      echoln(Downfile, ECHO_SCR | ECHO_COM);
  736.      getinput(answer, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM | INPT_UPR);
  737.      echoln(Getready, ECHO_SCR | ECHO_COM);
  738.  
  739.     xcv_gcur(&row, &column);
  740.     xcv_scur(STATUSROW, 0);
  741.     dfield(NULL_STR);
  742.  
  743.      switch(protocol)
  744.          {
  745.          case 'X':
  746.              index = XMODEM + (- ( status = xmk_putf(Port, answer, xmodeminfo, 1,
  747.                                                             XMODEM_128,XMODEM_CRC)));
  748.              break;
  749.          case 'M':
  750.              index = XMODEM + (- ( status = xmk_putf(Port, answer, xmodeminfo, 1,
  751.                                                             XMODEM_1K,XMODEM_CRC)));
  752.              break;
  753.          case 'Y':
  754.              xct_pend(18*10);        /* pause for 10 seconds */
  755.              index = XMODEM + (- ( status = ym_putf(Port, answer, 1, 1)));
  756.             index = (index == 0) ? 0 : -2;
  757.              break;
  758.          case 'K':
  759.              xct_pend(18*10);        /* pause for 10 seconds */
  760.              index = XMODEM + (- ( status = km_putf(Port, answer, 1, 1)));
  761.             index = (index == 0) ? 0 : -2;
  762.             break;
  763.              }
  764.  
  765.     
  766.                                                         
  767.      xcv_scur(row, column);
  768.     echoln(logs[index], ECHO_SCR | ECHO_COM);
  769.     strcpy(buffer, answer);         /* Log it */
  770.     strcat(buffer, " ");
  771.     strcat(buffer, logs[index]);
  772.     logit(buffer);
  773.     main_menu();
  774.     return(status);
  775. }
  776.  
  777. static int upload(void)    /* XMODEM upload */
  778. {
  779.     int row, column;
  780.     char desc[81];
  781.     char buffer[81];
  782.     char answer[81];
  783.     int status;
  784.     FILE *Stream;
  785.     int  index;
  786.      char protocol;
  787.  
  788.      status = 1;
  789.      while(status)
  790.          {
  791.         echoln("\n\nUpload Choices Are:\n\n" , ECHO_SCR | ECHO_COM);
  792.         echoln("X  XMODEM\n", ECHO_SCR | ECHO_COM);
  793.         echoln("M  XMODEM 1K\n", ECHO_SCR | ECHO_COM);
  794.          echoln("Y  YMODEM\n", ECHO_SCR | ECHO_COM);
  795.         echoln("K  KERMIT\n", ECHO_SCR | ECHO_COM);
  796.         echoln("Q  QUIT\n", ECHO_SCR | ECHO_COM);
  797.           echoln("\n Enter your choice: ", ECHO_SCR | ECHO_COM);
  798.  
  799.          getinput(answer, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM | INPT_UPR);
  800.          switch(answer[0])
  801.              {
  802.              case 'X':
  803.              case 'M':
  804.              case 'Y':
  805.              case 'K':
  806.                  {
  807.                  status = 0;
  808.                  protocol = answer[0];
  809.                  break;
  810.                  }
  811.              case 'Q':
  812.                  return(0);
  813.              default:
  814.                 echoln("\n\n\007Invalid Response\n\n", ECHO_SCR | ECHO_COM);
  815.              }
  816.          }
  817.  
  818.  
  819.      if((protocol != 'K') && (protocol != 'Y'))
  820.          {
  821.          echoln(Upfile, ECHO_SCR | ECHO_COM);
  822.         getinput(answer, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM | INPT_UPR);
  823.          }
  824.     echoln(Getready, ECHO_SCR | ECHO_COM);
  825.  
  826.     xcv_gcur(&row, &column);
  827.     xcv_scur(STATUSROW, 0);
  828.     dfield(NULL_STR);
  829.  
  830.      switch(protocol)
  831.          {
  832.          case 'X':
  833.              index = XMODEM + (- ( status = xmk_getf(Port, answer, xmodeminfo, 1,
  834.                                                             XMODEM_128,XMODEM_CRC)));
  835.              break;
  836.          case 'M':
  837.              index = XMODEM + (- ( status = xmk_getf(Port, answer, xmodeminfo, 1,
  838.                                                             XMODEM_1K,XMODEM_CRC)));
  839.              break;
  840.          case 'Y':
  841.              xct_pend(18*10);        /* pause for 10 seconds */
  842.              index = XMODEM + (- ( status = ym_getf(Port, "", 1, 1)));
  843.             index = (index == 0) ? 0 : -2;
  844.              break;
  845.          case 'K':
  846.              xct_pend(18*10);        /* pause for 10 seconds */
  847.              index = XMODEM + (- ( status = km_getf(Port, "", 1, 1)));
  848.             index = (index == 0) ? 0 : -2;
  849.             break;
  850.              }
  851.     
  852.      
  853.      xcv_scur(row, column);
  854.     echoln(logs[index], ECHO_SCR | ECHO_COM);
  855.  
  856.     strcpy(buffer, answer);         /* Log it */
  857.     strcat(buffer, " ");
  858.     strcat(buffer, logs[index]);
  859.     logit(buffer);
  860.  
  861.     if (status >= XM_OK) {          /* If successful, then write it */
  862.         echoln(Descrip, ECHO_SCR | ECHO_COM);
  863.         getinput(desc, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM);
  864.         if (desc[0] >= ' ') {
  865.             if ((Stream = fopen(dir_file, "a+")) != NULL) {
  866.                 fprintf(Stream, "%-15s %s\n", answer, desc, buffer);
  867.                 fclose(Stream);
  868.             }
  869.         }
  870.         echoln(Textend, ECHO_SCR | ECHO_COM);
  871.     }
  872.     main_menu();
  873.     return(status);
  874.  }
  875.  
  876. static int files( /* Display THE DIRECTORY */
  877. int display)
  878. { 
  879.     int  status = 0;
  880.     FILE *Stream;
  881.     char buffer[81];
  882.  
  883.     if ((Stream = fopen(dir_file, "r")) == NULL) {
  884.         echoln(Nofile, display);
  885.     } else {
  886.         while (fgets(buffer, 80, Stream) != NULL) {
  887.             if (echoln(buffer, display) < 0)
  888.                 return(-1);
  889.         }
  890.         fclose(Stream);
  891.     }
  892.     return(status);
  893. }
  894.  
  895.  
  896. static int typefile(void)
  897. { 
  898.     int  status = 0;
  899.     FILE *Stream;
  900.     char buffer[81];
  901.     char filename[81];
  902.  
  903.     echoln(Whatfile, ECHO_SCR | ECHO_COM);
  904.     getinput(filename, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM);
  905.     echoln("\n", ECHO_SCR | ECHO_COM);
  906.  
  907.     if ((Stream = fopen(filename, "r")) == NULL) {
  908.         echoln(Nofilex, ECHO_SCR | ECHO_COM);
  909.     } else {
  910.         while (fgets(buffer, 80, Stream) != NULL) {
  911.             if (echoln(buffer, ECHO_SCR | ECHO_COM) < 0)
  912.                 return(-1);         /* OOPS - DROPPED CONNECTION */
  913.         }
  914.         fclose(Stream);
  915.     }
  916.     return(status);
  917. }
  918.  
  919. static int send_msg( /* 0 if sent OK, 1 if no user, -1 if error */
  920. int display,
  921. int inputd)
  922. { 
  923.     int     status = 0;
  924.     FILE    *Stream;
  925.     char    buffer[81];
  926.     char    receivr[81];
  927.     int     exitflag = 0;
  928.  
  929.     echoln(Towhom, display);
  930.     getinput(receivr, display | INPT_UPR | inputd);
  931.     if (search(buffer, receivr) == 0) {
  932.  
  933.         Stream = fopen(msg_file, "a+");
  934.         strcpy(buffer, receivr);
  935.         strcat(buffer, "\n");
  936.         fputs(buffer, Stream);
  937.         strcpy(buffer, Username);
  938.         strcat(buffer, "\n");
  939.         fputs(buffer, Stream);
  940.         fputs(tod(), Stream);
  941.         echoln(Chat1, display);
  942.         while (exitflag == 0) {
  943.             if (is_dead())
  944.                 return(-1);             /* OOPS - DROPPED CONNECTION */
  945.             getinput(buffer, display | inputd);
  946.             echoln("\n", display);
  947.             if (buffer[0] == CTRL_Z) {
  948.                 exitflag = 1;
  949.                 buffer[0] = '^';
  950.                 buffer[2] = '\000';
  951.             }
  952.             strcat(buffer, "\n");
  953.             fputs(buffer, Stream);
  954.         }
  955.         fclose(Stream);
  956.     } else {
  957.         echoln(Nouser, display);
  958.         status = 1;
  959.     }
  960.     return(status);
  961. }
  962.  
  963.  
  964. static int read_msg(   /* 0 if message, 1 no message, -1 error */
  965. int display,
  966. int inputd)
  967. { 
  968.     int  status =  1;               /* Assume no message read */
  969.     FILE *INStream;
  970.     FILE *OUTStream;
  971.     char buffer[81];
  972.     char _name[81];
  973.  
  974.     if ((INStream = fopen(msg_file, "r")) != NULL) {
  975.         OUTStream = fopen(msg_temp, "w");
  976.         strcpy(_name, Username);
  977.         strcat(_name, "\n");
  978.  
  979.         while (fgets(buffer, 80, INStream) != NULL) {
  980.             if (is_dead())
  981.                 return (-1);        /* OOPS - DROPPED CONNECTION */
  982.             if (strcmp(buffer, _name) == 0) {
  983.                 status = 0;
  984.                 echoln(Msgfrom, display);
  985.                 echoln(fgets(buffer, 80, INStream), display);
  986.                 echoln(Msgwhen, display);
  987.                 echoln(fgets(buffer, 80, INStream), display);
  988.                 echoln(Msgstart, display);
  989.                 while (fgets(buffer, 80, INStream) != NULL) {
  990.                     if (buffer[0] == '^')
  991.                         break;
  992.                     echoln(buffer, display);
  993.                 }
  994.                 while (fgets(buffer, 80, INStream) != NULL) {
  995.                     fputs(buffer, OUTStream);
  996.                 }
  997.                 echoln(Msgend, display);
  998.             } else {
  999.                 fputs(buffer, OUTStream);
  1000.                 while (fgets(buffer, 80, INStream) != NULL) {
  1001.                     fputs(buffer, OUTStream);
  1002.                     if (buffer[0] == '^')
  1003.                         break;
  1004.                 }
  1005.             }
  1006.         }
  1007.  
  1008.         fclose(INStream);
  1009.         fclose(OUTStream);
  1010.         if (status == 0) {
  1011.             echoln(Delmsg, display);
  1012.             getinput(buffer, display | inputd);
  1013.             if ((buffer[0] == 'Y') || (buffer[0] == 'y')) {
  1014.                 unlink(msg_file);
  1015.                 rename(msg_temp, msg_file);
  1016.             }
  1017.         }        
  1018.     }
  1019.     if (status == 1)
  1020.         echoln(No_msg, display);
  1021.     return(status);
  1022. }
  1023.  
  1024. static int chat(void)
  1025. { 
  1026.     char    buffer[81];
  1027.  
  1028.     echoln(Chat1, ECHO_SCR | ECHO_COM);
  1029.     do {
  1030.         getinput(buffer, ECHO_SCR | ECHO_COM | INPT_KEY | INPT_COM);
  1031.         if (echoln("\n", ECHO_SCR | ECHO_COM) < 0)
  1032.             return(-1);                 /* EXIT DUE TO ERROR */
  1033.     } while (buffer[0] != CTRL_Z);
  1034.     return(0);
  1035. }
  1036.  
  1037.  
  1038. /*      ================== DISCONNECT ================== */
  1039.  
  1040. static int leave(    /*  Hang up the modem */
  1041. int reason)
  1042. {
  1043.     char    buffer[81];
  1044.  
  1045.     echoln(Byebye, ECHO_SCR | ECHO_COM);    /* Tell the user to hangup */
  1046.     strcpy(buffer, Username);               /* Log the occurence */
  1047.     strcat(buffer, logs[reason]);
  1048.     logit(buffer);
  1049.     comm_status  = COMM_IDLE;               /* Communications now down */
  1050.     im_hangu(Port);                         /* Force the connection down */
  1051.     return(0);                              /* Leave abort_status alone */
  1052. }
  1053.  
  1054. static int idle(void)    /* Wait for the modem to ring */
  1055.              /* Return a -1 if BBS hit Ctrl-Break or the baud rate code */
  1056. {
  1057.     char    buffer[81];
  1058.     int     ch;
  1059.     int     status;
  1060.  
  1061.     xc_init(Port, Baud, Parity, Data, Stop);
  1062.     Username[0] = '\000';
  1063.     comm_status = COMM_IDLE; /* === SESSION STATUS === */
  1064.     abort_status = BBS_OK; /* === SESSION STATUS === */
  1065.     main_menu();
  1066.  
  1067. /*  Answer the ring */
  1068.  
  1069.     while (1) {  
  1070.           if (!bbs_hardwire){
  1071.                 if (xc_ri(Port) != 0)    /*  Have a ring ? ... */
  1072.                     break;
  1073.           }
  1074.           else  {  /* direct conection */
  1075.                     break;
  1076.           }
  1077.         if (xck_keyt()) {       /* BBS user want to do F1 options? */
  1078.             ch = xck_getc();
  1079.             if (ch == FK1) {
  1080.                 options();
  1081.             } else if ((ch & 0xFF) == RET) {
  1082.                 break;          /* Direct connect forced by BBS owner */
  1083.             }
  1084.         }
  1085.           if (is_break()){
  1086.                 abort_status = BBS_TERM;
  1087.                 return(-1);
  1088.           }
  1089.     }
  1090.     strcpy(buffer, logs[LOG_RING]);
  1091.     logit(buffer);
  1092.  
  1093.      if (!bbs_hardwire){
  1094.         if ((status = im_answ(Port)) <= IM_OK)
  1095.             return(status);        /* Answer the phone */
  1096.          else  {
  1097.             if(modem_type == IM_STANDARD_TYPE)
  1098.                   Baud = status;
  1099.             /* pause 2 seconds for new connection to stablize */
  1100.             xctp_pend(Port,36);
  1101.         }
  1102.      }
  1103.  
  1104. /*    else
  1105.               Baud = BAUD9600; */       /*   hardwire set to 9600 baud   */
  1106.  
  1107.     xc_init(Port, Baud, Parity, Data, Stop);
  1108.     xc_flush(Port);
  1109.  
  1110. /*  The phone has been answered */
  1111.  
  1112.     comm_status  = COMM_CONN; /* === SESSION STATUS === */
  1113. /*
  1114.     if (getinput(buffer, INPT_COM) < 0)
  1115.         return(-1);
  1116. */
  1117.     strcpy(buffer, logs[LOG_SON]);
  1118.     strcat(buffer, baudstr[Baud]);
  1119.     logit(buffer);
  1120.     main_menu();
  1121.     return(Baud);
  1122. }
  1123.  
  1124. static int echoln(  /* String write, return a -1 if error */
  1125. char *string,
  1126. int option)
  1127. {   
  1128.     int status = 0;
  1129.     char *ch_ptr = string;
  1130.     while (*ch_ptr) {
  1131.         if (*ch_ptr == '\n')
  1132.             status = echo(RET, option);
  1133.         status = echo(*ch_ptr, option);
  1134.           ch_ptr++;
  1135.     }
  1136.     return(status);
  1137. }
  1138.  
  1139. static int echo( /* Display a character & optionally scroll up one line */
  1140. char ch,            /* Return a 0 meaning success or a -1 if we must exit */
  1141. int  option)
  1142. {
  1143.     int oldrow, oldcol;
  1144.  
  1145.     if (is_dead())                  /* Check the connection */
  1146.         return(-1);
  1147.  
  1148.     /* Echo on the screen only if <bbs_noecho> flag is set to 0 */
  1149.  
  1150.     if ((option & ECHO_SCR) && (bbs_noecho == 0)) { /* Display on the screen */
  1151.         xcv_wtty( (char)((char)(option & ECHO_DOT) ? (char)'.' : (char)ch));
  1152.         if (xck_keyt()) {
  1153.             if ((xck_getc() & 0xFF) == XOFF) {
  1154.                 while ((xck_getc() & 0xFF) != XON) {
  1155.                     if (is_dead())
  1156.                         return(-1);     /* **** OOPS - LOST CONNECTION */
  1157.                 }
  1158.             }
  1159.         }
  1160.         xcv_gcur(&oldrow, &oldcol);
  1161.         if (oldrow == STATUSROW) {
  1162.             window(0, STATUSROW, SCRWIDTH, (char)attr_text, SCROLL);
  1163.             xcv_scur(oldrow - 1, oldcol);
  1164.         }
  1165.     } 
  1166.     /* Display to the comms user  only if a session is on */
  1167.  
  1168.     if ((option & ECHO_COM) && (comm_status == COMM_CONN)) {
  1169.         if (xc_test(Port)) {
  1170.             if ((xc_getc(Port) & 0xFF) == XOFF) {
  1171.                 while ((xc_getc(Port) & 0xFF) != XON) {
  1172.                     if (is_dead())
  1173.                         return(-1);     /* **** OOPS - LOST CONNECTION */
  1174.                 }
  1175.                     ;
  1176.             }
  1177.         }
  1178.         xc_putc(Port, (char)((char)(option & ECHO_DOT) ? (char)'.' : (char)ch));
  1179.     }
  1180.     return(0);                      /* Always succeeds! */
  1181. }
  1182.  
  1183. /*
  1184.     getinput - Given the character string buffer address, accept the
  1185.     user input string and return the number of characters entered.  Accept
  1186.     input at the current cursor location.  There is a limit of 80 characters.
  1187.     Returns:
  1188.  
  1189.         0   Only Enter key pressed
  1190.         >0  The character string of n characters returned
  1191.         -1  Connection down via timeout or otherwise
  1192. */
  1193. static int getinput(
  1194. char buffer[],
  1195. int  option)
  1196. {
  1197.     int i = 0;
  1198.     int exitflag = 0;
  1199.     int got_one;
  1200.     char ch;
  1201.  
  1202.     timeoutf = 1;
  1203.     xct_set(TIMEOUT);               /* Start the timeout */
  1204.  
  1205.     while (exitflag == 0) {
  1206.         if (is_dead())              /* ************************* */
  1207.             return(-1);             /* OOPS - lost the session ! */
  1208.         got_one = 0;
  1209.         if (xck_keyt() && (option & INPT_KEY)) {
  1210.             got_one = 1;
  1211.             ch = (char)xck_getc();
  1212.         } else if (xc_test(Port) && (option & INPT_COM)) {
  1213.             got_one = 1;
  1214.             ch = (char)xc_getc(Port);
  1215.         }
  1216.         if (got_one) {
  1217.         if (i >= 80) {
  1218.             buffer[i] = '\000';
  1219.             exitflag = 1;
  1220.             break;
  1221.         }
  1222.         if (option & INPT_UPR) {
  1223.             if ((ch >= 'a') && (ch <= 'z'))
  1224.                 ch = ch - ('a' - 'A');
  1225.         }
  1226.         switch ((ch) & 0xFF) {
  1227.         case RET:
  1228.             buffer[i] = '\000';
  1229.             exitflag = 1;               /* Exit file entry */
  1230.             break;
  1231.         case RUB1:
  1232.         case RUB2:
  1233.             if (i) {
  1234.                 --i;
  1235.                 echo(RUB1, option & (~ ECHO_DOT));
  1236.                 echo(' ', option & (~ ECHO_DOT));
  1237.                 echo(RUB1, option & (~ ECHO_DOT));
  1238.             }
  1239.             break;
  1240.         default:
  1241.             buffer[i++] = ch;
  1242.             if (ch == CTRL_Z) {
  1243.                 echo('^', option);
  1244.                 echo('Z', option);
  1245.             } 
  1246.             if ((ch >= ' ') && (ch <= RUB2))
  1247.                 echo(ch, option);
  1248.             }
  1249.         }
  1250.     }
  1251.     timeoutf = 0;                       /* Reset the flag */
  1252.     return(i);                          /* Return size of answer */
  1253. }
  1254.  
  1255. static int main_menu(void)
  1256. {
  1257.     sclear(); 
  1258.     if (comm_status == COMM_IDLE)
  1259.         dfield(MAIN_F1);             
  1260.     dfield(MAIN_EXIT);
  1261.     dfield(MAIN_STAT);
  1262.     return(0);                      /* Always successful! */
  1263. }
  1264.  
  1265. static int options(void)                       /* Display THE OPTIONS */
  1266. {
  1267.     char _old_user[81];
  1268.     char name[81];
  1269.     char desc[81];
  1270.     char buffer[81];
  1271.     FILE *Stream;
  1272.  
  1273.     sclear(); 
  1274.     dfield(OPTN_F1);
  1275.     dfield(OPTN_F2);
  1276.     dfield(OPTN_F3);
  1277.     dfield(OPTN_F4);
  1278.     dfield(OPTN_EXIT);
  1279.     wclear();
  1280.     echoln(Opt_inst, ECHO_SCR);
  1281.     for (;;) {
  1282.         if (is_break()) {
  1283.             wclear();
  1284.             break;
  1285.         }
  1286.         if (xck_keyt()) {
  1287.             switch (xck_getc()) {
  1288.             case FK1:
  1289.                 strcpy(_old_user, Username);
  1290.                 strcpy(Username, "BBS");
  1291.                 send_msg(ECHO_SCR, INPT_KEY);
  1292.                 strcpy(Username, _old_user);
  1293.                 echoln("\n", ECHO_SCR);
  1294.                 break;
  1295.             case FK2:
  1296.                 strcpy(_old_user, Username);
  1297.                 strcpy(Username, "BBS");
  1298.                 read_msg(ECHO_SCR, INPT_KEY);
  1299.                 strcpy(Username, _old_user);
  1300.                 echoln("\n", ECHO_SCR);
  1301.                 break;
  1302.             case FK3:
  1303.                 files(ECHO_SCR | INPT_KEY);
  1304.                 echoln("\n", ECHO_SCR);
  1305.                 break;
  1306.             case FK4:
  1307.                 echoln(Filereq, ECHO_SCR);
  1308.                 getinput(name, ECHO_SCR | INPT_KEY | INPT_UPR);
  1309.                 if ((Stream = fopen(name, "r")) == NULL) {
  1310.                     echoln(Nofilex, ECHO_SCR);
  1311.                 } else {
  1312.                     fclose(Stream);
  1313.                     echoln(Descrip, ECHO_SCR);
  1314.                     getinput(desc, ECHO_SCR | INPT_KEY);
  1315.                     if ((Stream = fopen(dir_file, "a+")) != NULL) {
  1316.                         fprintf(Stream, "%-15s %s\n", name, desc, buffer);
  1317.                         fclose(Stream);
  1318.                     }
  1319.                     echoln(Textend, ECHO_SCR);
  1320.                 }
  1321.                 break;
  1322.                 case 0:                    /* can get this on Ctrl-Break */
  1323.                  is_break();
  1324.                  wclear();
  1325.                     main_menu();
  1326.                     return(0);                      /* Always successful! */
  1327.                 }
  1328.             echoln(Opt_inst, ECHO_SCR);
  1329.  
  1330.         }
  1331.     }
  1332.     main_menu();
  1333.     return(0);                      /* Always successful! */
  1334. }
  1335.  
  1336.  
  1337. /*
  1338.     window - perform a window scroll up or clear for an entire line
  1339.              or lines given the attribute
  1340.  
  1341. */
  1342. static int window(
  1343. int row,                            /* Row address starting at 0 */
  1344. int row_count,                      /* Number of rows to scroll or clear */
  1345. int column,                         /* Last column number */
  1346. char attribute,                     /* Attribute for the window */
  1347. int flag)                           /* SCROLL or CLEARS flag */
  1348. {
  1349.     xcv_scrl(row, 0, row + row_count - 1, column, attribute, flag);    
  1350.     return(0);                      /* Always succeeds! */
  1351. }
  1352.  
  1353. static void sclear(void)                  /* Clear status line */
  1354. {
  1355.     window(STATUSROW, 1, SCRWIDTH, (char)attr_text, CLEARS);
  1356.  
  1357. }
  1358.  
  1359. static void wclear(void)                        /* Clear window text area */
  1360. {
  1361.     xcv_scur(0, 0);                 /* Home cursor */
  1362.     window(0, STATUSROW, SCRWIDTH, (char)attr_text, CLEARS);
  1363. }
  1364.  
  1365. /*
  1366.     dfield - display field on the bottom line using the 
  1367.              attr_status attribute.  The cursor is not moved.
  1368. */
  1369. static int dfield(
  1370. int index)                          /* Index into text array */
  1371. {
  1372.     char _string[MAXFIELD];         /* Maximum string field width */
  1373.     int i;                          /* Counter variable */
  1374.     int width = text[index].wid;    /* Maximum LEGAL field width */
  1375.     int column = text[index].col;   /* Number of columns */
  1376.     char *string = text[index].str;
  1377.     int oldrow, oldcol;             /* Old cursor address */
  1378.  
  1379.     if (width > MAXFIELD)
  1380.         width = MAXFIELD;           /* Specified field is too big */
  1381.                                     /* Create the fixed field */
  1382.     for (i = 0; (_string[i] = *string++) >= ' '; ++i)
  1383.         ;
  1384.     for (; (i < width); ++i)
  1385.         _string[i] = ' ';
  1386.     xcv_gcur(&oldrow, &oldcol);     /* Save the cursor location */
  1387.     
  1388.                                     /* Write out the field */
  1389.     for (i = 0; (i < width); ++i) {
  1390.         xcv_scur(STATUSROW, column + i);
  1391.         xcv_chat(_string[i], attr_status);    
  1392.     }
  1393.     xcv_scur(oldrow, oldcol);       /* Restore the cursor */
  1394.     return(0);                      /* Always succeeds! */
  1395. }
  1396.  
  1397.  
  1398. /*
  1399.     bbstod.c    - Return the time of day
  1400.  
  1401.     Copyright (C) 1986, 1987, 1988 Essential Software Incorporated
  1402.     Copyright (C) 1986, 1987, 1988 Advanced Firmware Engineering
  1403.  
  1404.     Return a character string indicating the date and time and \n
  1405.  
  1406.                10        20   25
  1407.       ....|....|....|....|....|
  1408.       DAY MM/DD/YY HH:MM:SS.hh\n        
  1409. */
  1410.  
  1411. static char *int2asc(
  1412. int ivalue)
  1413. {
  1414.     int scratch;
  1415.     intbuffer[2] = '\000';
  1416.     scratch = ivalue / 10;
  1417.     intbuffer[0] = (char) scratch + '0';
  1418.     intbuffer[1] = (char) (ivalue - (scratch * 10)) + '0';
  1419.  
  1420.     return(intbuffer);
  1421. }
  1422.  
  1423. static char *tod(void)                 /* Return the time-of-day */
  1424. {
  1425.     packet.breg.AH = 0x2A;
  1426.     i86_int(0x21, &packet);         /* Get the date */
  1427.     strcpy(buffer, days[(int) packet.breg.AL]);
  1428.     strcat(buffer, int2asc(packet.breg.DH)); strcat(buffer, "/");
  1429.     strcat(buffer, int2asc(packet.breg.DL)); strcat(buffer, "/");
  1430.     strcat(buffer, int2asc(packet.wreg.CX - 1900)); strcat(buffer, " ");
  1431.  
  1432.     packet.breg.AH = 0x2C;
  1433.     i86_int(0x21, &packet);         /* Get the time */
  1434.     strcat(buffer, int2asc(packet.breg.CH)); strcat(buffer, ":");
  1435.     strcat(buffer, int2asc(packet.breg.CL)); strcat(buffer, ":");
  1436.     strcat(buffer, int2asc(packet.breg.DH)); strcat(buffer, ".");
  1437.     strcat(buffer, int2asc(packet.breg.DL)); strcat(buffer, "\n");
  1438.     return(buffer);
  1439. }
  1440.  
  1441.