home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / ncr9800 / ckvbuf.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  12KB  |  445 lines
  1. /* CKVBUF_C  12 June 90 */
  2.  
  3. /***********************************************************************
  4. * MCS-Kermit REL 2                                                    *
  5. * source code                                                         *
  6. *                                                                     *
  7. * Change History:                                                     *
  8. *                                                                     *
  9. *                1. Modify C-Kermit(4E) source code to                *
  10. *                   produce new module for MCS/IVS-Kermit             *
  11. *                   ORIGINAL RELEASE                                  *
  12. *                   June 22, 1990                                     *
  13. *                                                                     *
  14. *                                                                     *
  15. ***********************************************************************/
  16.  
  17.  
  18. #include <stdio.h>
  19. #include <string.h>
  20. #include <memory.h>
  21. #include "mcs_defs_h"
  22. #include "ckcdeb.h"                      /* DRE 030690 */
  23. #include "ckcker.h"                      /* DRE 060690 */
  24.  
  25. extern FILE *Log;
  26. extern int         server;                       /* DRE 020890 */
  27. extern int         deblog;                       /* DRE 030690 */
  28.  
  29. static char         _inbuffer[MAXRP] = { '\0' };
  30. static char         _outbuffer[MAXSP] = { '\0' };
  31.  
  32. static char         *_instart = &_inbuffer[0];
  33. static char         *_inend = &_inbuffer[0];
  34. static char         *_outstart = &_outbuffer[0];
  35. static char         *_outend = &_outbuffer[0];
  36.  
  37. static char         mcsstr[MAXSP];
  38. static char         buf[MAXRP];
  39.  
  40. #define _insize  (_inend - _instart)
  41. #define _outsize (_outend - _outstart)
  42.  
  43. /*****************************************************************************
  44.  *****************************************************************************
  45.  *********                   OUTPUT ROUTINES                          ********
  46.  *****************************************************************************
  47.  *****************************************************************************/
  48.  
  49. mcs_printf(tmp_string)
  50. char         *tmp_string;
  51. {
  52.          if (deblog)
  53.              debug (F110, "funct: mcs_printf", tmp_string, 0);
  54.          if (_myprnt(tmp_string))
  55.              return strlen(tmp_string);
  56.          else
  57.              return EOF;
  58. }
  59.  
  60. mcs_fprintf(stream, tmp_string)
  61. FILE *stream;
  62. char         *tmp_string;
  63. {
  64.          if (deblog)
  65.              debug (F110, "funct: mcs_fprintf", tmp_string, 0);
  66.  
  67.          if (stream == stdout) {
  68.              if (_myprnt(tmp_string))
  69.                  return strlen(tmp_string);
  70.              else
  71.                  return EOF;
  72.          } else
  73.              return(fprintf(stream, tmp_string));
  74. }
  75.  
  76. mcs_puts(tmp_string)
  77. char         *tmp_string;
  78. {
  79.          if (deblog)
  80.              debug (F110, "funct: mcs_puts", tmp_string, 0);
  81.  
  82.          if (!_myprnt(tmp_string))
  83.              return EOF;
  84.          if (!_myprnt("\n"))
  85.              return EOF;
  86.          else
  87.              return '\n';
  88. }
  89.  
  90. mcs_fputs(tmp_string, stream)
  91. char         *tmp_string;
  92. FILE *stream;
  93. {
  94.          if (deblog)
  95.              debug (F110, "funct: mcs_fputs", tmp_string, 0);
  96.  
  97.          if (stream == stdout) {                     /* DRE 1/24/90 */
  98.              if (_myprnt(tmp_string))
  99.                  return 0;
  100.              else
  101.                  return EOF;
  102.          } else
  103.              return(fputs(tmp_string, stream));
  104. }
  105.  
  106. mcs_fputc(ch, stream)
  107. int         ch;
  108. FILE *stream;
  109. {
  110.          char    tmp_string[5];
  111.  
  112.          if (deblog)
  113.              debug (F101, "funct: mcs_fputc", "", ch);
  114.  
  115.          if (stream == stdout) {                     /* DRE 1/24/90 */
  116.              tmp_string[0] = ch;
  117.              tmp_string[1] = '\0';
  118.              if (_myprnt(tmp_string))
  119.                  return tmp_string[0];
  120.              else
  121.                  return EOF;
  122.          } else
  123.              return(fputc(ch, stream));
  124. }
  125.  
  126. mcs_fputchar(ch)
  127. int         ch;
  128. {
  129.          char    tmp_string[5];
  130.  
  131.          if (deblog)
  132.              debug (F101, "funct: mcs_fputchar", "", ch);
  133.  
  134.          tmp_string[0] = ch;
  135.          tmp_string[1] = '\0';
  136.          if (_myprnt(tmp_string))
  137.              return tmp_string[0];
  138.          else
  139.              return EOF;
  140. }
  141.  
  142. mcs_putchar(tmp_char)
  143. char         tmp_char;
  144. {
  145.          char    tmp_string[5];
  146.  
  147.          if (deblog)
  148.              debug (F101, "funct: mcs_putchar", "", tmp_char);
  149.  
  150.          tmp_string[0] = tmp_char;
  151.          tmp_string[1] = '\0';
  152.          if (_myprnt(tmp_string))
  153.              return tmp_string[0];
  154.          else
  155.              return EOF;
  156. }
  157.  
  158. mcs_fflush()
  159. {
  160.          int    mesg_len;
  161.          char    status[3];
  162.  
  163.          if (deblog)
  164.              debug (F100, "funct: mcs_fflush", "", 0);
  165.  
  166.          if (_outend != _outstart) {
  167.              mesg_len = _outend - _outstart + 1;
  168.              strncpy(mcsstr, _outstart, mesg_len);
  169.              mcsstr[mesg_len] = '\0';
  170.              mcs_send(QUEUENAME, mcsstr, mesg_len, OUT_TERM, status);
  171.              _outstart = &_outbuffer[0];
  172.              _outend = _outstart;
  173.          }
  174.  
  175. }
  176.  
  177. mcs_clrbuf()
  178. {
  179.          if (deblog)
  180.              debug (F100, "funct: mcs_clrbuf", "", 0);
  181.          _instart = &_inbuffer[0];
  182.          _inend = _instart;
  183. }
  184.  
  185. mcs_write(fildes, buffer, nbyte)
  186. int         fildes;
  187. char         *buffer;
  188. unsigned         nbyte;
  189. {
  190.          int    mesg_len = nbyte;
  191.          char    status[3];
  192.  
  193.          if (deblog)
  194.              debug (F100, "funct: mcs_write", "", 0);
  195.  
  196.          if (fildes == 1) {
  197.              mcs_send(QUEUENAME, buffer, mesg_len, OUT_TERM, status);
  198.              return(nbyte);
  199.              /* NEED A RETURN STATUS */
  200.          } else
  201.              return(write(fildes, buffer, nbyte));
  202. }
  203.  
  204. /*****************************************************************************
  205.  *****************************************************************************
  206.  *********                    INPUT ROUTINES                          ********
  207.  *****************************************************************************
  208.  *****************************************************************************/
  209.  
  210. mcs_gets(tmp_string)
  211. char         *tmp_string;
  212. {
  213.          int    mesg_len;
  214.  
  215.          if (deblog)
  216.              debug (F100, "funct: mcs_gets", "", 0);
  217.  
  218.          mesg_len = _myread(tmp_string, 0);
  219.          if (mesg_len == 0)
  220.              return NULL;
  221.          tmp_string[mesg_len - 1] = '\0';
  222.          return (int)tmp_string;
  223. }
  224.  
  225. mcs_getchar()
  226. {
  227.          char    tmp_string[5];
  228.          int    mesg_len;
  229.  
  230.          if (deblog)
  231.              debug (F100, "funct: mcs_getchar", "", 0);
  232.  
  233.          mesg_len = _myread(tmp_string, 1);
  234.          if (mesg_len == 0)
  235.              return EOF;
  236.          return(tmp_string[0]);
  237. }
  238.  
  239. char         *mcs_fgets(str, num, stream)
  240. char         *str;
  241. int         num;
  242. FILE *stream;
  243. {
  244.          int    mesg_len;
  245.  
  246.          if (deblog)
  247.              debug (F100, "funct: mcs_fgets", "", 0);
  248.  
  249.          if (stream == stdin) {
  250.              mesg_len = _myread(str, num - 1);
  251.              if (mesg_len == 0)
  252.                  return NULL;
  253.              return str;
  254.          } else
  255.              return(fgets(str, num, stream));
  256. }
  257.  
  258. mcs_fgetc(stream)
  259. FILE *stream;
  260. {
  261.          char    tmp_string[5];
  262.          int    mesg_len;
  263.  
  264.          if (deblog)
  265.              debug (F100, "funct: mcs_fgetc", "", 0);
  266.  
  267.          if (stream == stdin) {
  268.              mesg_len = _myread(tmp_string, 1);
  269.              if (mesg_len == 0)
  270.                  return EOF;
  271.              return(tmp_string[0]);
  272.          } else
  273.              return(fgetc(stream));
  274. }
  275.  
  276. mcs_read(fildes, buffer, nbyte)
  277. int         fildes;
  278. char         *buffer;
  279. unsigned         nbyte;
  280. {
  281.          int    mesg_len = nbyte;
  282.          int    num = 0, i;
  283.          char    status[3];
  284.  
  285.          if (deblog)
  286.              debug (F100, "funct: mcs_read", "", 0);
  287.  
  288.          if (fildes == 0) {
  289.  
  290.              /* WHAT IS THE MINIMUM BYTES ALLOWED TO BE READ?  -  80 chars */
  291.              /* msleep(500);  */
  292.  
  293.              for (; num < nbyte; num++) {
  294.                  *(buffer + num) = mcs_getchar();
  295.                  if (*(buffer + num) == '\n') {
  296.                      num++;
  297.                      break;
  298.                  }
  299.              }
  300.              buffer[num] = '\0';
  301.              /* NEED A RETURN STATUS */
  302.              return(num);
  303.          } else
  304.              return(read(fildes, buffer, nbyte));
  305. }
  306.  
  307. _myprnt(str)
  308. char         *str;
  309. {
  310.          register char    *p;
  311.          char    status[3], tmp_c;
  312.          register int    mesg_len, size;
  313.          int outcome;                                /* DRE 060690 */
  314.  
  315.          if (deblog)
  316.              debug (F110, "funct: _myprnt", str, 0);
  317.  
  318.          outcome = 1;                   /* start with good outcome */
  319.  
  320.          for (p = str; *p != '\0'; )
  321.              *_outend++ = *p++;      /* append string to buffer */
  322.          *_outend = *p;                 /* put null character at end */
  323.  
  324.          for (p = _outstart; *p; ) {
  325.              if (*p == '\n') {       /* if newline found, send line */
  326.                  p++;
  327.                  mesg_len = p - _outstart;
  328.                  tmp_c = *p;
  329.                  *p = '\0';
  330.  
  331.                  mcs_send(QUEUENAME, _outstart, mesg_len, OUT_TERM,
  332.                       status);
  333.  
  334.                  if ((strncmp(status, "00", 2) != 0) &&
  335.                             (strncmp(status, "98", 2) != 0)) {
  336.  
  337.                            /* log the message then throw it away */
  338.  
  339.                            fprintf(stderr,"_myprnt: mcs_send failed\n");
  340.                            fprintf(stderr,"  ==> %s", _outstart);
  341.                            outcome = 0;       /* bad outcome */
  342.                  }
  343.                  *p  = tmp_c;
  344.                  _outstart = p;
  345.              } else
  346.                  p++;
  347.          }
  348.  
  349.          if (_outstart != &_outbuffer[0]) {    /* we must have sent a msg */
  350.              if (_outstart != _outend) {    /* reset the buffer */
  351.                  size = _outsize;
  352.  /*
  353.         The strcpy function call was removed on 6-12-90
  354.         because it was causing some type of buffer corruption
  355.         problem.  The exact cause was not determined, but the
  356.         problem disappeared when strcpy was replaced by the
  357.         sprintf function call.
  358.  
  359.                   strcpy(_outbuffer, _outstart);
  360. */
  361.                         sprintf(_outbuffer,"%s",_outstart);
  362.                  _outstart = &_outbuffer[0];
  363.                  _outend = _outstart + size;
  364.              } else {
  365.                  _outstart = &_outbuffer[0];
  366.                  _outend = _outstart;
  367.              }
  368.          }
  369.  
  370.          return (outcome);
  371. }
  372.  
  373. _myread(str, num)
  374. char         *str;
  375. int         num;
  376. {
  377.          register char    *p;
  378.          char    status[3], *endstr;
  379.          register int    i, size;
  380.          int    mesg_len;
  381.  
  382.          if (deblog)
  383.              debug (F100, "funct: _myread", "", 0);
  384.  
  385.          if (_insize == 0) {
  386.                 if (!server)  mcs_fflush();
  387.  
  388.              mcs_recv(QUEUENAME, buf, &mesg_len, IN_TERM, status);
  389.  
  390.              if ((strncmp(status, "00", 2) != 0) &&  (strncmp(status,
  391.                   "98", 2) != 0)) {
  392.  
  393.                  if (!server)
  394.                      mcs_send(QUEUENAME, "\n", 1, OUT_TERM,
  395.                           status);
  396.                  return 0;
  397.              }
  398.  
  399.                 if (!server)
  400.                  mcs_send(QUEUENAME, "\n", 1, OUT_TERM, status);
  401.  
  402.                 memcpy(_instart,buf,(mesg_len+1));
  403. /*
  404.  *              _inend = _instart + mesg_len + 1;
  405.  */
  406.                 _inend = _instart + mesg_len;
  407.  
  408.          }
  409.  
  410.          if (num == 0) {
  411.              for (p = _instart; *p != '\n'; )
  412.                  *str++ = *p++;
  413.              *str++ = *p++;
  414.              *str = '\0';
  415.              mesg_len = p - _instart;
  416.              _instart = p;
  417.          } else {
  418.              for (i = 0; i < num; i++) {
  419.                  str[i] = _instart[i];
  420.                  if (str[i] == '\n') {
  421.                      i++;
  422.                      break;
  423.                  }
  424.              }
  425.              mesg_len = i;
  426.              str[mesg_len] = '\0';
  427.              _instart = _instart + mesg_len;
  428.          }
  429.  
  430.          if (_instart != &_inbuffer[0]) {
  431.              if (_instart != _inend) {
  432.                  size = _insize;
  433.                  memcpy(_inbuffer, _instart,size);
  434.                  _instart = &_inbuffer[0];
  435.                  _inend = _instart + size;
  436.  
  437.              } else {
  438.                  _instart = &_inbuffer[0];
  439.                  _inend = _instart;
  440.              }
  441.          }
  442.  
  443.          return mesg_len;
  444. }
  445.