home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Columbia Kermit
/
kermit.zip
/
archives
/
ncr9800.tar.gz
/
ncr9800.tar
/
ckvbuf.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-07-13
|
12KB
|
445 lines
/* CKVBUF_C 12 June 90 */
/***********************************************************************
* MCS-Kermit REL 2 *
* source code *
* *
* Change History: *
* *
* 1. Modify C-Kermit(4E) source code to *
* produce new module for MCS/IVS-Kermit *
* ORIGINAL RELEASE *
* June 22, 1990 *
* *
* *
***********************************************************************/
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include "mcs_defs_h"
#include "ckcdeb.h" /* DRE 030690 */
#include "ckcker.h" /* DRE 060690 */
extern FILE *Log;
extern int server; /* DRE 020890 */
extern int deblog; /* DRE 030690 */
static char _inbuffer[MAXRP] = { '\0' };
static char _outbuffer[MAXSP] = { '\0' };
static char *_instart = &_inbuffer[0];
static char *_inend = &_inbuffer[0];
static char *_outstart = &_outbuffer[0];
static char *_outend = &_outbuffer[0];
static char mcsstr[MAXSP];
static char buf[MAXRP];
#define _insize (_inend - _instart)
#define _outsize (_outend - _outstart)
/*****************************************************************************
*****************************************************************************
********* OUTPUT ROUTINES ********
*****************************************************************************
*****************************************************************************/
mcs_printf(tmp_string)
char *tmp_string;
{
if (deblog)
debug (F110, "funct: mcs_printf", tmp_string, 0);
if (_myprnt(tmp_string))
return strlen(tmp_string);
else
return EOF;
}
mcs_fprintf(stream, tmp_string)
FILE *stream;
char *tmp_string;
{
if (deblog)
debug (F110, "funct: mcs_fprintf", tmp_string, 0);
if (stream == stdout) {
if (_myprnt(tmp_string))
return strlen(tmp_string);
else
return EOF;
} else
return(fprintf(stream, tmp_string));
}
mcs_puts(tmp_string)
char *tmp_string;
{
if (deblog)
debug (F110, "funct: mcs_puts", tmp_string, 0);
if (!_myprnt(tmp_string))
return EOF;
if (!_myprnt("\n"))
return EOF;
else
return '\n';
}
mcs_fputs(tmp_string, stream)
char *tmp_string;
FILE *stream;
{
if (deblog)
debug (F110, "funct: mcs_fputs", tmp_string, 0);
if (stream == stdout) { /* DRE 1/24/90 */
if (_myprnt(tmp_string))
return 0;
else
return EOF;
} else
return(fputs(tmp_string, stream));
}
mcs_fputc(ch, stream)
int ch;
FILE *stream;
{
char tmp_string[5];
if (deblog)
debug (F101, "funct: mcs_fputc", "", ch);
if (stream == stdout) { /* DRE 1/24/90 */
tmp_string[0] = ch;
tmp_string[1] = '\0';
if (_myprnt(tmp_string))
return tmp_string[0];
else
return EOF;
} else
return(fputc(ch, stream));
}
mcs_fputchar(ch)
int ch;
{
char tmp_string[5];
if (deblog)
debug (F101, "funct: mcs_fputchar", "", ch);
tmp_string[0] = ch;
tmp_string[1] = '\0';
if (_myprnt(tmp_string))
return tmp_string[0];
else
return EOF;
}
mcs_putchar(tmp_char)
char tmp_char;
{
char tmp_string[5];
if (deblog)
debug (F101, "funct: mcs_putchar", "", tmp_char);
tmp_string[0] = tmp_char;
tmp_string[1] = '\0';
if (_myprnt(tmp_string))
return tmp_string[0];
else
return EOF;
}
mcs_fflush()
{
int mesg_len;
char status[3];
if (deblog)
debug (F100, "funct: mcs_fflush", "", 0);
if (_outend != _outstart) {
mesg_len = _outend - _outstart + 1;
strncpy(mcsstr, _outstart, mesg_len);
mcsstr[mesg_len] = '\0';
mcs_send(QUEUENAME, mcsstr, mesg_len, OUT_TERM, status);
_outstart = &_outbuffer[0];
_outend = _outstart;
}
}
mcs_clrbuf()
{
if (deblog)
debug (F100, "funct: mcs_clrbuf", "", 0);
_instart = &_inbuffer[0];
_inend = _instart;
}
mcs_write(fildes, buffer, nbyte)
int fildes;
char *buffer;
unsigned nbyte;
{
int mesg_len = nbyte;
char status[3];
if (deblog)
debug (F100, "funct: mcs_write", "", 0);
if (fildes == 1) {
mcs_send(QUEUENAME, buffer, mesg_len, OUT_TERM, status);
return(nbyte);
/* NEED A RETURN STATUS */
} else
return(write(fildes, buffer, nbyte));
}
/*****************************************************************************
*****************************************************************************
********* INPUT ROUTINES ********
*****************************************************************************
*****************************************************************************/
mcs_gets(tmp_string)
char *tmp_string;
{
int mesg_len;
if (deblog)
debug (F100, "funct: mcs_gets", "", 0);
mesg_len = _myread(tmp_string, 0);
if (mesg_len == 0)
return NULL;
tmp_string[mesg_len - 1] = '\0';
return (int)tmp_string;
}
mcs_getchar()
{
char tmp_string[5];
int mesg_len;
if (deblog)
debug (F100, "funct: mcs_getchar", "", 0);
mesg_len = _myread(tmp_string, 1);
if (mesg_len == 0)
return EOF;
return(tmp_string[0]);
}
char *mcs_fgets(str, num, stream)
char *str;
int num;
FILE *stream;
{
int mesg_len;
if (deblog)
debug (F100, "funct: mcs_fgets", "", 0);
if (stream == stdin) {
mesg_len = _myread(str, num - 1);
if (mesg_len == 0)
return NULL;
return str;
} else
return(fgets(str, num, stream));
}
mcs_fgetc(stream)
FILE *stream;
{
char tmp_string[5];
int mesg_len;
if (deblog)
debug (F100, "funct: mcs_fgetc", "", 0);
if (stream == stdin) {
mesg_len = _myread(tmp_string, 1);
if (mesg_len == 0)
return EOF;
return(tmp_string[0]);
} else
return(fgetc(stream));
}
mcs_read(fildes, buffer, nbyte)
int fildes;
char *buffer;
unsigned nbyte;
{
int mesg_len = nbyte;
int num = 0, i;
char status[3];
if (deblog)
debug (F100, "funct: mcs_read", "", 0);
if (fildes == 0) {
/* WHAT IS THE MINIMUM BYTES ALLOWED TO BE READ? - 80 chars */
/* msleep(500); */
for (; num < nbyte; num++) {
*(buffer + num) = mcs_getchar();
if (*(buffer + num) == '\n') {
num++;
break;
}
}
buffer[num] = '\0';
/* NEED A RETURN STATUS */
return(num);
} else
return(read(fildes, buffer, nbyte));
}
_myprnt(str)
char *str;
{
register char *p;
char status[3], tmp_c;
register int mesg_len, size;
int outcome; /* DRE 060690 */
if (deblog)
debug (F110, "funct: _myprnt", str, 0);
outcome = 1; /* start with good outcome */
for (p = str; *p != '\0'; )
*_outend++ = *p++; /* append string to buffer */
*_outend = *p; /* put null character at end */
for (p = _outstart; *p; ) {
if (*p == '\n') { /* if newline found, send line */
p++;
mesg_len = p - _outstart;
tmp_c = *p;
*p = '\0';
mcs_send(QUEUENAME, _outstart, mesg_len, OUT_TERM,
status);
if ((strncmp(status, "00", 2) != 0) &&
(strncmp(status, "98", 2) != 0)) {
/* log the message then throw it away */
fprintf(stderr,"_myprnt: mcs_send failed\n");
fprintf(stderr," ==> %s", _outstart);
outcome = 0; /* bad outcome */
}
*p = tmp_c;
_outstart = p;
} else
p++;
}
if (_outstart != &_outbuffer[0]) { /* we must have sent a msg */
if (_outstart != _outend) { /* reset the buffer */
size = _outsize;
/*
The strcpy function call was removed on 6-12-90
because it was causing some type of buffer corruption
problem. The exact cause was not determined, but the
problem disappeared when strcpy was replaced by the
sprintf function call.
strcpy(_outbuffer, _outstart);
*/
sprintf(_outbuffer,"%s",_outstart);
_outstart = &_outbuffer[0];
_outend = _outstart + size;
} else {
_outstart = &_outbuffer[0];
_outend = _outstart;
}
}
return (outcome);
}
_myread(str, num)
char *str;
int num;
{
register char *p;
char status[3], *endstr;
register int i, size;
int mesg_len;
if (deblog)
debug (F100, "funct: _myread", "", 0);
if (_insize == 0) {
if (!server) mcs_fflush();
mcs_recv(QUEUENAME, buf, &mesg_len, IN_TERM, status);
if ((strncmp(status, "00", 2) != 0) && (strncmp(status,
"98", 2) != 0)) {
if (!server)
mcs_send(QUEUENAME, "\n", 1, OUT_TERM,
status);
return 0;
}
if (!server)
mcs_send(QUEUENAME, "\n", 1, OUT_TERM, status);
memcpy(_instart,buf,(mesg_len+1));
/*
* _inend = _instart + mesg_len + 1;
*/
_inend = _instart + mesg_len;
}
if (num == 0) {
for (p = _instart; *p != '\n'; )
*str++ = *p++;
*str++ = *p++;
*str = '\0';
mesg_len = p - _instart;
_instart = p;
} else {
for (i = 0; i < num; i++) {
str[i] = _instart[i];
if (str[i] == '\n') {
i++;
break;
}
}
mesg_len = i;
str[mesg_len] = '\0';
_instart = _instart + mesg_len;
}
if (_instart != &_inbuffer[0]) {
if (_instart != _inend) {
size = _insize;
memcpy(_inbuffer, _instart,size);
_instart = &_inbuffer[0];
_inend = _instart + size;
} else {
_instart = &_inbuffer[0];
_inend = _instart;
}
}
return mesg_len;
}