wht@tridom.uucp (Warren Tucker) (10/09/89)
---- Cut Here and unpack ----
#!/bin/sh
# this is part 13 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
# file ecuxfer.c continued
#
CurArch=13
if test ! -r s2_seq_.tmp
then echo "Please unpack part 1 first!"
exit 1; fi
( read Scheck
if test "$Scheck" != $CurArch
then echo "Please unpack part $Scheck next!"
exit 1;
else exit 0; fi
) < s2_seq_.tmp || exit 1
echo "x - Continuing file ecuxfer.c"
sed 's/^X//' << 'SHAR_EOF' >> ecuxfer.c
X stand_end();
X ff(se,"\r\n");
X }
X
X ff(se,"\r\n");
X
X file_xfer_done_bell();
X start_rcvr_process(1);
X} /* end of send_files_to_remote */
X
X/*+-------------------------------------------------------------------------
X receive_files_from_remote(argc,argv)
X--------------------------------------------------------------------------*/
Xvoid
Xreceive_files_from_remote(argc,argv)
Xint argc;
Xchar **argv;
X{
Xregister itmp;
Xchar execcmd[256];
Xint xfertype;
Xchar bottom_label[64];
X
X sprintf(bottom_label,"-C 'Connected to %s' ",
X (Llogical[0]) ? Llogical : "?");
X
X switch(to_lower(*(argv[0] + 1)))
X {
X case 'k': xfertype = CKERMIT; break;
X case 's': xfertype = ECUSEA; break;
X case 'x': xfertype = ECURZ_X; break;
X case 'y': xfertype = ECURZ_Y; break;
X case 'z': xfertype = ECURZ_Z; break;
X default: ff(se,"receive command invalid\n");
X return;
X }
X
X if(xfertype == ECURZ_X)
X {
X char p[128];
X kill_rcvr_process(SIGUSR1);
X sprintf(execcmd,"ecurz -X -. %d -c ",Liofd);
X strcat(execcmd,bottom_label);
X if(protocol_log_packets)
X strcpy(&execcmd[strlen(execcmd) ],"-, ");
X
X /* get xmodem ascii or binary */
X ff(se," Translate CR/LF to NL (ASCII)? ");
X switch(itmp = to_lower(ttygetc(0)))
X {
X case 'y': strcat(execcmd,"-a "); break;
X case 'n': strcat(execcmd,"-b "); break;
X default:
X ff(se,"transfer abandoned\r\n");
X start_rcvr_process(1);
X return;
X }
X ff(se,"%s\r\n",(itmp == 'y') ? "yes" : "no");
X ff(se,"File name to receive via XMODEM/CRC: ");
X ttygets(p,sizeof(p),1);
X if( (p[0] != ESC) && strlen(p) )
X {
X strcat(execcmd,p);
X file_xfer_start();
X exec_cmd(execcmd);
X file_xfer_done_bell();
X }
X else
X ff(se,"transfer abandoned\r\n");
X }
X else if(xfertype == ECURZ_Y)
X {
X ff(se,"\r\n");
X kill_rcvr_process(SIGUSR1);
X sprintf(execcmd,"ecurz -Y -. %d -y ",Liofd);
X strcat(execcmd,bottom_label);
X if(protocol_log_packets)
X strcpy(&execcmd[strlen(execcmd) ],"-, ");
X file_xfer_start();
X exec_cmd(execcmd);
X file_xfer_done_bell();
X }
X else if(xfertype == ECURZ_Z)
X {
X ff(se,"\r\n");
X kill_rcvr_process(SIGUSR1);
X sprintf(execcmd,"ecurz -Z -. %d ",Liofd);
X strcat(execcmd,bottom_label);
X if(protocol_log_packets)
X sprintf(&execcmd[strlen(execcmd) ],"-, ");
X file_xfer_start();
X exec_cmd(execcmd);
X file_xfer_done_bell();
X }
X else if(xfertype == CKERMIT)
X {
X kill_rcvr_process(SIGUSR1);
X sprintf(execcmd,"ckermit -r -e 512 -l %d -b %d -p %c",
X Liofd,Lbaud,(Lparity) ? Lparity : 'n');
X ff(se," Translate CR/LF to NL (ASCII)? ");
X switch(itmp = to_lower(ttygetc(0)))
X {
X case 'y': strcat(execcmd," -i"); break;
X case 'n': break;
X default:
X ff(se,"transfer abandoned\r\n");
X start_rcvr_process(1);
X return;
X }
X ff(se,"%s\r\n",(itmp == 'a') ? "yes" : "no");
X file_xfer_start();
X exec_cmd(execcmd);
X file_xfer_done_bell();
X }
X else if(xfertype == ECUSEA)
X {
X kill_rcvr_process(SIGUSR1);
X sprintf(execcmd,"ecusea -r -. %d -/ %s",Liofd,curr_dir);
X if(protocol_log_packets)
X strcat(execcmd," -,");
X file_xfer_start();
X exec_cmd(execcmd);
X file_xfer_done_bell();
X }
X lreset_ksr();
X start_rcvr_process(1);
X} /* end of receive_files_from_remote */
X/* end of ecuxfer.c */
X/* vi: set tabstop=4 shiftwidth=4: */
SHAR_EOF
echo "File ecuxfer.c is complete"
chmod 0644 ecuxfer.c || echo "restore of ecuxfer.c fails"
echo "x - extracting esdutil.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > esdutil.c &&
X/* CHK=0x7C00 */
X/*+----------------------------------------------------------------
X esdutil.c - ecu extended string descriptor manipulation
X Copyright 1989 Warren H. Tucker, III. All Rights Reserved
X
X Defined functions:
X append_zstr_to_esd(param,zstr)
X end_of_cmd(param)
X esdstrindex(esd1,esd2,index1_flag,index2_flag)
X fgetesd(param,fileptr)
X fputesd(param,fileptr,index_flag,nl_flag)
X free_esd(tesd)
X get_alpha_zstr(param,strbuf,strbuf_maxcb)
X get_alphanum_zstr(param,strbuf,strbuf_maxcb)
X get_cmd_char(param,pchar)
X get_numeric_value(param,value)
X get_numeric_zstr(param,strbuf,strbuf_maxcb)
X get_switches(param,switches,switches_max)
X get_word_zstr(param,strbuf,strbuf_maxcb)
X init_esd(tesd,cptr,maxcb)
X keyword_lookup(ktable,param)
X make_esd(maxcb)
X null_terminate_esd(tesd)
X show_esd(tesd,title)
X skip_cmd_break(param)
X skip_cmd_char(param,skipchar)
X skip_colon(param)
X skip_comma(param)
X skip_paren(param,fLeft)
X strindex(str1,str2)
X strip_trailing_spaces_esd(ztext)
X zero_esd(tesd)
X
X-----------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:07-03-1989-22:57-wht------------- ecu 2.00 ---------------- */
X/*:06-24-1989-16:53-wht-flush edits --- ecu 1.95 */
X
X#include <ctype.h>
X#include "ecu.h"
X#include "ecuerror.h"
X#include "esd.h"
X
Xchar *malloc();
X
X/*+-------------------------------------------------------------------------
X null_terminate_esd(&esd)
X puts null at 'cb' position of string (standard esd always
X has one more byte in buffer than maxcb says)
X--------------------------------------------------------------------------*/
Xvoid
Xnull_terminate_esd(tesd)
Xregister ESD *tesd;
X{
X tesd->pb[tesd->cb] = 0;
X} /* end of null_terminate_esd */
X
X/*+-----------------------------------------------------------------------
X zero_esd(tesd) zero an esd
X------------------------------------------------------------------------*/
Xvoid
Xzero_esd(tesd)
Xregister ESD *tesd;
X{
X tesd->cb = 0; /* current count == 0 */
X tesd->index = 0; /* parse index to first position */
X tesd->old_index = 0; /* parse index to first position */
X *tesd->pb = 0; /* start with null terminated string */
X
X} /* end of zero_esd */
X
X/*+-----------------------------------------------------------------------
X init_esd(tesd,cptr,maxcb) init an esd
X------------------------------------------------------------------------*/
Xvoid
Xinit_esd(tesd,cptr,maxcb)
Xregister ESD *tesd;
Xchar *cptr;
Xregister maxcb;
X{
X tesd->pb = cptr; /* pointer to string */
X tesd->maxcb = maxcb; /* max characters in buffer */
X zero_esd(tesd);
X
X} /* end of init_esd */
X
X/*+-----------------------------------------------------------------------
X esdptr = make_esd(maxcb) allocate an esd and buffer
X------------------------------------------------------------------------*/
XESD *
Xmake_esd(maxcb)
Xregister maxcb; /* desired maxcb */
X{
Xregister ESD *tesd;
Xregister actual_cb;
X
X /* we get an extra character to ensure room for null past maxcb */
X actual_cb = maxcb + sizeof(ESD) + 1;
X if(actual_cb & 1) /* even allocation */
X ++actual_cb;
X if((tesd = (ESD *)malloc( (unsigned)actual_cb )) == NULL)
X return((ESD *)0); /* return NULL if failure */
X
X init_esd(tesd,(char *)(tesd + 1),maxcb);
X return(tesd);
X
X} /* end of make_esd */
X
X/*+-----------------------------------------------------------------------
X free_esd(esdptr)
X------------------------------------------------------------------------*/
Xvoid
Xfree_esd(tesd)
Xregister ESD *tesd;
X{
X tesd->maxcb = 0;
X tesd->cb = 0;
X free((char *)tesd);
X}
X
X/*+-------------------------------------------------------------------------
X show_esd(tesd,title)
X--------------------------------------------------------------------------*/
Xvoid
Xshow_esd(tesd,title)
XESD *tesd;
Xchar *title;
X{
Xregister itmp;
X
X if(title && *title)
X {
X pputs(title);
X pputs("\n");
X }
X null_terminate_esd(tesd);
X pputs(tesd->pb);
X pputs("\n");
X for(itmp = 0; itmp <= tesd->cb; itmp++)
X {
X if(itmp == tesd->old_index)
X pputc('^');
X else if(itmp == tesd->index)
X pputc('^');
X else
X pputc(' ');
X if((itmp > tesd->old_index) && (itmp > tesd->index))
X break;
X }
X pprintf(" o%d i%d c%d\n",tesd->old_index,tesd->index,tesd->cb);
X
X} /* end of show_esd */
X
X/*+----------------------------------------------------------------
X strindex: string index function
X
X Returns position of 'str2' in 'str1' if found
X If 'str2' is null, then 0 is returned (null matches anything)
X Returns -1 if not found
X-----------------------------------------------------------------*/
Xint
Xstrindex(str1,str2)
Xchar *str1; /* the (target) string to search */
Xchar *str2; /* the (comparand) string to search for */
X{
Xregister istr1 = 0;
Xregister lstr2 = strlen(str2);
Xregister char *mstr = str1; /* the (target) string to search */
X
X if(*str2 == 0) /* null string matches anything */
X return(0);
X
X while(*mstr)
X {
X if(*mstr == *str2)
X { /* we have a first char match... does rest of string match? */
X if(!strncmp(mstr,str2,lstr2))
X return(istr1); /* if so, return match position */
X }
X mstr++;
X istr1++;
X }
X
X return(-1); /* if we exhaust target string, flunk */
X
X} /* end of strindex */
X
X/*+-------------------------------------------------------------------------
X esdstrindex(esd1,esd2,index1_flag,index2_flag)
X
X Call strindex with esd1->pb and esd2->pb.
X If index1_flag != 0, esd1->pb + esd1->index passed
X If index2_flag != 0, esd2->pb + esd2->index passed
X--------------------------------------------------------------------------*/
Xesdstrindex(esd1,esd2,index1_flag,index2_flag)
Xregister ESD *esd1;
Xregister ESD *esd2;
Xregister index1_flag;
Xregister index2_flag;
X{
X return(strindex((index1_flag) ? esd1->pb : esd1->pb + esd1->index,
X (index2_flag) ? esd2->pb : esd2->pb + esd2->index));
X
X} /* end of esdstrindex */
X
X/*+----------------------------------------------------------------
X keyword_lookup(ktable,param)
X
X Lookup string in keyword_table struct array
X Returns table->key_token if 'param' found in
X 'table', else -1
X
X Beware substrings. "type","typedef" will both match "type"
X-----------------------------------------------------------------*/
Xkeyword_lookup(ktable,param)
Xregister KEYTAB *ktable;
Xregister char *param;
X{
Xregister plen = strlen(param);
X
X while(ktable->key_word)
X {
X if(!strncmp(ktable->key_word,param,plen))
X return(ktable->key_token);
X ++ktable;
X } /* end of while */
X
X return(-1); /* search failed */
X
X} /* end of keyword_lookup */
X
X/*+----------------------------------------------------------------
X skip_cmd_break(param)
X
X Finds next non-break
X
X 'param' is an esd with valid 'index' field
X Returns 0 index field points to non-break character
X eNoParameter end of command found
X-----------------------------------------------------------------*/
Xint
Xskip_cmd_break(param)
Xregister ESD *param;
X{
Xregister cb = param->cb;
Xregister index = param->index;
Xregister char *pb = param->pb;
X
X while(index < cb)
X {
X if(!isspace(*(pb + index)))
X break;
X index++;
X }
X param->old_index = param->index = index;
X if(index >= cb)
X return(eNoParameter);
X return(0);
X
X} /* end of skip_cmd_break */
X
X/*+-------------------------------------------------------------------------
X end_of_cmd(param) - return 1 if at end of command
X--------------------------------------------------------------------------*/
Xint
Xend_of_cmd(param)
Xregister ESD *param;
X{
X if(skip_cmd_break(param) || (*(param->pb + param->index) == ';') ||
X (*(param->pb + param->index) == '#'))
X return(1);
X return(0);
X} /* end of end_of_cmd */
X
X/*+-------------------------------------------------------------------------
X erc = skip_cmd_char(param,skipchar)
X--------------------------------------------------------------------------*/
Xint
Xskip_cmd_char(param,skipchar)
Xregister ESD *param;
Xregister char skipchar;
X{
Xint erc;
X
X if(erc = skip_cmd_break(param))
X return(erc);
X
X if(param->pb[param->index] == skipchar)
X {
X ++param->index;
X return(0);
X }
X
X return(eSyntaxError);
X
X} /* end of skip_cmd_char */
X
X/*+-------------------------------------------------------------------------
X erc = skip_colon(param)
X--------------------------------------------------------------------------*/
Xint
Xskip_colon(param)
Xregister ESD *param;
X{
X register erc;
X
X if(erc = skip_cmd_break(param))
X return(erc);
X
X if(param->pb[param->index] == ':')
X {
X ++param->index;
X return(0);
X }
X
X return(eCommaExpected);
X
X} /* end of skip_colon */
X
X/*+-------------------------------------------------------------------------
X erc = skip_comma(param)
X--------------------------------------------------------------------------*/
Xint
Xskip_comma(param)
Xregister ESD *param;
X{
X register erc;
X
X if(erc = skip_cmd_break(param))
X return(erc);
X
X if(param->pb[param->index] == ',')
X {
X ++param->index;
X return(0);
X }
X
X return(eCommaExpected);
X
X} /* end of skip_comma */
X
X/*+-------------------------------------------------------------------------
X erc = skip_paren(fparam,LEFT or RIGHT)
X--------------------------------------------------------------------------*/
Xint
Xskip_paren(param,fLeft)
Xregister ESD *param;
Xint fLeft;
X{
Xregister erc = (fLeft) ? eMissingLeftParen : eMissingRightParen;
Xregister char search = (fLeft) ? '(' : ')';
X
X if(erc = skip_cmd_break(param))
X return(erc);
X
X if(param->pb[param->index] == search)
X {
X param->index++;
X return(0);
X }
X return(erc);
X
X} /* end of skip_paren */
X
X/*+-------------------------------------------------------------------------
X get_cmd_char(param,pchar)
X--------------------------------------------------------------------------*/
Xint
Xget_cmd_char(param,pchar)
Xregister ESD *param;
Xchar *pchar;
X{
Xint erc;
X
X if(erc = skip_cmd_break(param))
X return(erc);
X *pchar = param->pb[param->index++];
X return(0);
X
X} /* end of get_cmd_char */
X
X/*+----------------------------------------------------------------
X get_alpha_zstr(&esd,&strbuf,strbuf_maxcb)
X
X places next alphabetic string token [A_Za_z_] into
X the null-terminated 'strbuf' string. returns 0 or -1
X or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_alpha_zstr(param,strbuf,strbuf_maxcb)
XESD *param;
Xregister char *strbuf;
Xint strbuf_maxcb;
X{
Xregister izstr;
Xregister schar;
Xregister char *pb = param->pb;
X
X if(izstr = skip_cmd_break(param))
X return(izstr);
X izstr = 0;
X while( (izstr < strbuf_maxcb-1) && (param->index < param->cb) )
X {
X schar = pb[param->index];
X if((!isalpha(schar)) && (schar != '_'))
X break;
X strbuf[izstr++] = schar;
X param->index++;
X }
X
X strbuf[izstr] = 0;
X return(izstr ? 0 : eBadParameter);
X
X} /* end of get_alpha_zstr */
X
X/*+----------------------------------------------------------------
X get_alphanum_zstr(&esd,&strbuf,strbuf_maxcb)
X
X places next alphanumeric string token [A-Za-z0-9_]
X into the null-terminated 'strbuf' string. returns 0
X or -1 or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_alphanum_zstr(param,strbuf,strbuf_maxcb)
Xregister ESD *param;
Xregister char *strbuf;
Xint strbuf_maxcb;
X{
Xint izstr = 0;
Xint schar;
Xregister cb = param->cb;
Xregister index;
X
X if(izstr = skip_cmd_break(param))
X return(izstr);
X
X index = param->index;
X while( (izstr < strbuf_maxcb-1) && (index < cb))
X {
X schar = param->pb[index++];
X if(isalnum(schar) || (schar == '_'))
X strbuf[izstr++] = schar;
X else
X {
X --index;
X break;
X }
X }
X
X param->index = index;
X strbuf[izstr]=0;
X return(izstr ? 0 : eBadParameter);
X
X} /* end of get_alphanum_zstr */
X
X/*+----------------------------------------------------------------
X get_numeric_zstr(&esd,&strbuf,strbuf_maxcb)
X gets next numeric string token places it
X into the null-terminated 'strbuf' string. returns 0 or -1
X or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_numeric_zstr(param,strbuf,strbuf_maxcb)
Xregister ESD *param;
Xregister char *strbuf;
Xregister strbuf_maxcb;
X{
X register izstr;
X register schar;
X
X if(izstr = skip_cmd_break(param))
X return(izstr);
X
X while( (izstr < strbuf_maxcb-1) && (param->index < param->cb) )
X {
X schar = param->pb[param->index++];
X if( isdigit(schar) )
X strbuf[izstr++]=schar;
X else
X {
X --param->index;
X break;
X }
X }
X
X strbuf[izstr]=0;
X return(izstr ? 0 : eBadParameter);
X
X} /* end of get_numeric_zstr */
X
X/*+-----------------------------------------------------------------------
X get_numeric_value(param,&long_var)
X------------------------------------------------------------------------*/
Xget_numeric_value(param,value)
Xregister ESD *param;
Xregister long *value;
X{
Xregister erc;
Xchar buf[32];
X
X if(erc = get_numeric_zstr(param,buf,sizeof(buf)))
X return(erc);
X sscanf(buf,"%ld",value);
X return(0);
X
X} /* end of get_numeric_value */
X
X/*+----------------------------------------------------------------
X get_word_zstr(&esd,&strbuf,strbuf_maxcb)
X
X gets next word (continuous string of characters without spaces
X or tabs) returns 0 or -1 or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_word_zstr(param,strbuf,strbuf_maxcb)
Xregister ESD *param;
Xregister char *strbuf;
Xregister strbuf_maxcb;
X{
X register izstr;
X register schar;
X
X if(izstr = skip_cmd_break(param))
X return(izstr);
X
X while( (izstr < strbuf_maxcb-1) && (param->index < param->cb) )
X {
X schar = param->pb[param->index++];
X if( (schar > 0x20) && (schar <= 0x7e))
X strbuf[izstr++]=schar;
X else
X {
X --param->index;
X break;
X }
X }
X
X strbuf[izstr]=0;
X return(izstr ? 0 : eBadParameter);
X
X} /* end of get_word_zstr */
X
X/*+-------------------------------------------------------------------------
X strip_trailing_spaces_esd(param)
X--------------------------------------------------------------------------*/
Xvoid
Xstrip_trailing_spaces_esd(ztext)
Xregister ESD *ztext;
X{
X while(ztext->cb && (ztext->pb[ztext->cb-1] == 0x20))
X ztext->cb--;
X} /* end of strip_trailing_spaces_esd */
X
X/*+-------------------------------------------------------------------------
X fgetesd(&esd,fileptr)
X
X stdio read from FILE *fileptr into esd
X returns param->cb set up not including trailing nl, param->index == 0
X--------------------------------------------------------------------------*/
Xint
Xfgetesd(param,fileptr)
Xregister ESD *param;
Xregister FILE *fileptr;
X{
Xregister char *cptr;
X
X if(fgets(param->pb,param->maxcb,fileptr) == NULL)
X return(eEOF);
X if((cptr = strchr(param->pb,0x0A)) == NULL)
X return(eBufferTooSmall);
X param->cb = (int)(cptr - param->pb);
X null_terminate_esd(param);
X param->index = 0;
X param->old_index = 0;
X return(0);
X
X} /* end of fgetesd */
X
X/*+-------------------------------------------------------------------------
X fputesd(&esd,fileptr,index_flag,nl_flag)
X
X write esd contents to stdio FILE *fileptr
X if index_flag is true, write from param->index thru end of esd
X otherwise, from start of esd
X if nl_flag is true, append nl to write, else just esd contents
X--------------------------------------------------------------------------*/
Xint
Xfputesd(param,fileptr,index_flag,nl_flag)
Xregister ESD *param;
XFILE *fileptr;
Xint index_flag;
Xint nl_flag;
X{
Xregister char *cptr;
Xregister write_length;
X
X if(index_flag)
X {
X cptr = ¶m->pb[param->index];
X write_length = param->cb - param->index;
X }
X else
X {
X cptr = param->pb;
X write_length = param->cb;
X }
X
X if(write_length)
X fwrite(cptr,write_length,1,fileptr);
X
X if(nl_flag)
X fputc(0x0A,fileptr);
X
X return(0);
X} /* end of fputesd */
X
X/*+-----------------------------------------------------------------
X append_zstr_to_esd(param,zstr)
X------------------------------------------------------------------*/
Xappend_zstr_to_esd(param,zstr)
XESD *param;
Xchar *zstr;
X{
Xregister zstrlen = strlen(zstr);
Xregister erc = 0;
X
X if(zstrlen > (param->maxcb - param->cb))
X {
X zstrlen = param->maxcb - param->cb;
X erc = eBufferTooSmall;
X }
X
X if(zstrlen)
X {
X strncpy(param->pb + param->cb,zstr,zstrlen);
X param->cb += zstrlen;
X }
X return(erc);
X}
X
X/*+-------------------------------------------------------------------------
X get_switches(param,switches,switches_max)
X--------------------------------------------------------------------------*/
Xint
Xget_switches(param,switches,switches_max)
XESD *param;
Xchar *switches;
Xint switches_max;
X{
Xregister itmp;
Xregister index;
Xregister char *pb = param->pb;
Xint cb = param->cb;
Xchar schar;
X
X *switches = 0;
X
X if(itmp = skip_cmd_break(param))
X return(itmp);
X
X index = param->index;
X if(*(param->pb + index) != '-')
X return(eNoSwitches);
X
X switches_max--;
X *switches++ = '-';
X index++;
X while((itmp < switches_max) && (index < cb))
X {
X schar = *(pb + index++);
X if(isspace(schar))
X break;
X *switches++ = schar;
X }
X
X param->index = index;
X *switches = 0;
X return(0);
X
X} /* end of get_switches() */
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of esdutil.c */
SHAR_EOF
chmod 0644 esdutil.c || echo "restore of esdutil.c fails"
echo "x - extracting fcrc.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > fcrc.c &&
X/* CHK=0x5634 */
Xchar *rev="2.16";
X/*+------------------------------------------------------------------------
X fcrc.c - calculate, check &/or store CRC for file
X
X CCITT CRC-16 x^16 + x^12 + x^5 + 1
X
X Since carriage returns and line feeds present a problem between
X MS-DOS and UNIX/XENIX, these two characters are not
X included in a CRC calculation. Refer to the main procedure
X for usage information.
X
X For MSDOS versions, take note that this source does NOT work
X with MSC 3.0 because under that system rename(newfile,oldfile)
X is the rule rather than MSC 4.0 rename(oldfile,newfile). If you
X want to compile under MSC 3.0, swap rename() arguments.
X
X Compilation:
Xpyr BSD4.2 cc -O fcrc.c -o fcrc; strip fcrc
XXENIX/286 cc -O -M2 -K fcrc.c -o fcrc; strip fcrc
Xsys V cc -O -DATT fcrc.c -o fcrc; strip fcrc
XMSDOS(MSC4) msc fcrc.c; link fcrc+ssetargv/stack:2048; exepack fcrc...
X
X Defined functions:
X build_temp_names(base_fname)
X crc_clear()
X crc_finish(crc)
X filecrc(filename,crc_returned,crc_found,source_type)
X main(argc,argv,envp)
X str_index(str1,str2)
X to_upper(ch)
X trigger_type(source_type,trigger_str)
X usage()
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:06-21-1989-16:23-wht-add .68k support */
X/*:06-14-1989-17:05-wht-add .ep support */
X/*:06-13-1989-11:39-wht-add .sa as motorola asm */
X/*:05-06-1989-15:14-wht-allow .l files (same as .c) */
X/*:04-17-1989-13:41-wht-adapt to pyr 4.4 chgs need sys/types.h */
X/*:04-15-1989-13:18-wht-do not allow -u operation if access(fn,2) fails */
X/*:12-01-1988-13:23-wht-skip non-regular files */
X/*:09-08-1988-21:22-wht-allow .y files (same as .c) */
X/*:06-06-1988-20:27-wht-add -r, get rid of ulcmpb/ulindex */
X/*:05-29-1988-14:53-wht-major overhaul -- use read/write not stdio for .NEW */
X/*:05-29-1988-13:50-wht-assign version number */
X/*:05-28-1988-16:58-wht-crc_update table driven: speed up order of magnitude! */
X/*:02-21-1987-18:03-wht-use prototyping under XENIX and MSDOS */
X/*:02-04-1987-16:20-wht-fix what happened if file matched *make*.c */
X/*:01-30-1987-00:40-wht-unlink MSDOS savef before rename to it */
X/*:01-29-1987-14:10-wht-better answer for MSDOS/Intermetrics asm diffs */
X/*:12-18-1986-16:30-wht-use ':' in tempname rather than '$' */
X/*:12-05-1986-15:00-wht-bug in BSD4.2 version did not unlink(savef) */
X/*:12-04-1986-18:30-wht-make skip of 0x0D/0x0A optional */
X/*:12-04-1986-15:30-wht-fflush stdout when write performed */
X/*:11-18-1986-09:30-wht-move new program to Pyramid for BSD4.2 test */
X/*:10-18-1986-14:00-wht-make perror calls more helpful */
X/*:08-14-1986-17:30-WHT-add make source support */
X/*:08-14-1986-15:30-WHT-add assembler source support */
X/*:08-10-1986-15:20-WHT-add correct report code for no update_flag */
X/*:07-30-1986-17:00-WHT-add code for creating CRC record in file */
X/*:07-29-1986-15:30-WHT-Creation */
X
X#include <stdio.h>
X
X#define STYPE_c 0
X#define STYPE_asm 1 /* Intermetrics C68k */
X#define STYPE_make 2
X#define STYPE_bat 3
X
X#define ff fprintf
X#define se stderr
X
X#if defined(M_XENIX)
X#define SYSV 1
X#endif
X#if defined(ATT)
X#define SYSV 1
X#endif
X
X#include <sys/types.h>
X
X#if defined(M_XENIX)
X#include <fcntl.h>
X#endif
X
X#if defined(ATT)
X#include <fcntl.h>
X#endif
X
X#if MSDOS /* MSC 4.00 */
X#include <fcntl.h>
X#include <process.h>
X#include <io.h>
X#include <string.h>
X#endif
X
X#include <sys/stat.h>
X
X#ifndef MSDOS
X#define strcmpi strcmp /* only case-sensitive comparison under UNIX */
X#define strncmpi strncmp /* only case-sensitive comparison under UNIX */
X#endif
X
X#if defined(pyr) /* Pyr OSx */
X#include <sys/file.h>
X#define strchr index
X#define strrchr rindex
Xextern char *index();
Xextern char *rindex();
X#endif
X
X#if SYSV
Xextern char *strchr();
Xextern char *strrchr();
X#endif
X
X#if MSDOS | XENIX
X#if LINT_ARGS
Xchar to_upper(char );
Xint filecrc(char *,unsigned int *,char *,int );
Xint str_index(char *,char *);
Xunsigned short crc_clear(void);
Xunsigned short crc_finish(unsigned short );
Xvoid build_temp_names(char *);
Xvoid trigger_type(int ,char *);
Xvoid usage(void);
X#endif
X#endif
X
Xextern int errno;
X
Xchar rdbuf[32768-1024];
Xchar errmsg[80];
Xchar savef[128]; /* see build_temp_names */
Xchar tempf[128]; /* see build_temp_names */
Xchar trigger[32];
Xint buflen;
Xint skip_cr_nl = 1; /* if we should ignore CR and LF chars */
X
X#if MSDOS
Xint msdos = 1;
X#else
Xint msdos = 0;
X#endif
Xint msdos_switch = 0; /* -m switch */
X
X/* crc_table calculated by Mark G. Mendel, Network Systems Corporation */
Xunsigned short crc_table[256] =
X{
X 0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
X 0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
X 0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
X 0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
X 0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
X 0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
X 0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
X 0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
X 0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
X 0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
X 0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
X 0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
X 0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
X 0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
X 0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
X 0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
X 0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
X 0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
X 0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
X 0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
X 0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
X 0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
X 0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
X 0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
X 0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
X 0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
X 0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
X 0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
X 0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
X 0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
X 0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
X 0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
X};
X
X/*+-------------------------------------------------------------------------
X crc_update(crc,cp)
X from article Copyright (C) 1986 Stephen Satchell.
X NOTE:
X First argument is referenced twice.
X Second argument must be in range 0 to 255.
X
X Programmers may incorporate any or all code into their programs,
X giving proper credit within the source. Publication of the
X source routines is permitted so long as proper credit is given
X to Stephen Satchell, Satchell Evaluations and Chuck Forsberg,
X Omen Technology.
X--------------------------------------------------------------------------*/
X#define crc_update(crc,data) \
X (crc_table[((crc >> 8) & 255)] ^ (crc << 8) ^ data)
X
X/*+------------------------------------------------------------------------
X crc = crc_clear();
X
X This function clears the CRC to zero. It should be called prior to
X the start of the processing of a block for both received messages,
X and messages to be transmitted.
X--------------------------------------------------------------------------*/
Xunsigned short crc_clear()
X{
X return(0);
X}
X
X/*+------------------------------------------------------------------------
X crc = crc_finish(crc);
X
X This function must be called once after all the characters in a block
X have been processed for a message which is to be TRANSMITTED. It
X returns the calculated CRC bytes, which should be transmitted as the
SHAR_EOF
echo "End of part 13"
echo "File fcrc.c is continued in part 14"
echo "14" > s2_seq_.tmp
exit 0
--
-------------------------------------------------------------------
Warren Tucker, Tridom Corporation ...!gatech!emory!tridom!wht
Ker-au'-lo-phon. An 8-foot partial flue-stop, having metal pipes
surmounted by adjustable rings, and with a hole bored near the top
of each pipe, producing a soft and "reedy" tone.