Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.2 9/18/84; site ucbvax.ARPA
Path: utzoo!watmath!clyde!burl!ulysses!mhuxr!ihnp4!ucbvax!info-vax
From: info-vax@ucbvax.ARPA
Newsgroups: fa.info-vax
Subject: Re: XMODEM and x-assemblers. Info. request.
Message-ID: <6035@ucbvax.ARPA>
Date: Thu, 4-Apr-85 21:27:15 EST
Article-I.D.: ucbvax.6035
Posted: Thu Apr  4 21:27:15 1985
Date-Received: Fri, 5-Apr-85 05:09:27 EST
Sender: daemon@ucbvax.ARPA
Organization: University of California at Berkeley
Lines: 555

From: dual!mordor!seismo!harvard!bu-cs!root@BERKELEY (BostonU SysMgr)

Hope this helps...

--------------------modem.c--------------------
/*
 * a version of Ward Christensen's MODEM program for
 * UNIX v7, 4.1bsd
 *
 * by Andrew Scott Beals
 * (SJOBRG.ANDY%MIT-OZ@MIT-MC)
 *
 *	features added by BZS (root%bostonu@csnet-relay)
 *
 *		sub options
 *			a	ascii (cr/lf->\n etc.)
 *			b	binary (good luck)
 *			q	send to our laser printer
 *	changes by BZS
 *		removed requirement of '-' for first arg
 *		so essentially same as TOPS-20 version
 *		(especially from our dandelion)
 */

#include <stdio.h>
#include <ctype.h>
#include <signal.h>
#include <sgtty.h>

#define uchar   unsigned char

#define SLEEP   30
#define ACKTIMO	30	/* longest we will wait for an ACK	*/

/* Protocol characters used */

#define SOH     1       /* Start Of Header */
#define EOT     4       /* End Of Transmission */
#define ACK     6       /* ACKnowlege */
#define NAK     0x15    /* Negative AcKnowlege */

short           ttyhold;
struct sgttyb   ttymode;
char *prog ;		/* BZS argv[0]		*/
int rflag ;
int sflag ;
int aflag = 1 ;		/* default is ASCII	*/
int qflag ;		/* send to Qms printer Queue with -q flag */
int pflag ;		/* third arg is a command to pipe to	*/
int Sflag ;		/* login server		*/
char *tmpf = "/tmp/MODXXXXXX" ;
#define SERVER	"-MODEM"
#define PRCMD	"qpr -q %s"
#undef tolower
#define tolower(x) (isupper(x) ? (x) - ' ' : x)
/*
 *	collect all error messages here for later logging etc.
 */
eprint(fmt,a,b,c,d) char *fmt, *a, *b, *c, *d ;
{
	fprintf(stderr,fmt,a,b,c,d) ;
}
usage()
{
	eprint("Usage: %s [-]<option><suboption> filename\n",prog) ;
	eprint("\tWhere option can be either r for receive\n") ;
	eprint("\tor s for send and suboptions are:\n") ;
	eprint("\t\ta\tASCII (text) file\n") ;
	eprint("\t\tb\tBINARY file\n") ;
	eprint("\t\tq\tLASER PRINT FILE (implies ASCII)\n") ;
	eprint("\t\t\t(no file name for print files)\n") ;
	eprint("\t\tp\tpipe received data, 2nd arg is UNIX command\n") ;
	exit(1) ;
}
main(argc,argv)
int     argc;
char    **argv;
{
	register uchar  checksum,index,blocknumber,errorcount,
	character;
	uchar           sector[128];
	int             foo,timeout();
	FILE *fout ;
	char *ap ;
	char *fname, *pcmd ;
	static char buf[BUFSIZ+1] ;

	prog = *argv ;
	if(strcmp(prog,SERVER) == 0)
	{
		++qflag ;
		++Sflag ;
		++rflag ;
		goto serv1 ;
	}
	if(argc < 2)
		usage() ;
	/*
	 * skip but don't require initial dash in option list
	 */
	ap = argv[1] ;
	if(*ap == '-') ++ap ;
	/*
	 *	options
	 *		accept either case, twenex people expect this
	 */
	if(tolower(*ap) == 'r') ++rflag ;
	else if(tolower(*ap) == 's') ++sflag ;
	else usage() ;
	++ap ;
	/*
	 *	suboptions
	 */
	switch(tolower(*ap)) {

		case '\0' : break ;
		case 'a' :  break ;	/* DEFAULT	*/
		case 'p' : ++pflag ; break ;
		case 'q' : ++qflag ; break ;
		case 'b' : aflag = 0 ; break ;

		case 'h' :		/* FALL THRU */
		default  : usage() ;
	}

	/*
	 *	check for other absurdities
	 */
	if(*++ap) usage() ;
	if(sflag && (qflag || pflag))
	{
		eprint("%s: only use 'a' or 'b' with 's'\n",prog) ;
		exit(1) ;
	}
	/*
	 * 	The file name
	 */
serv1:
	if(qflag || pflag)
	{
		mktemp(tmpf) ;
		fname = tmpf ;
	}
	else if(argc != 3) usage() ;
	else fname = argv[2] ;
	if(pflag) pcmd = argv[2] ;

	gtty(0,&ttymode);
	ttyhold=ttymode.sg_flags;
	ttymode.sg_flags |= RAW ;
	ttymode.sg_flags& = ~ECHO;

	if(rflag) goto rec ;
	/* (else)	*/
	/* send a file to the remote */

	stty(0,&ttymode);
	if((foo=open(fname,0))==-1)
	{
		fprintf(stderr,"can't open %s for send!\7\n",fname);
		die(1);
	}
	
	fprintf(stderr,"file open, ready to send\r\n");
	fflush(stderr);
	fflush(stdout);
	errorcount=0;
	blocknumber=1;
	signal(SIGALRM,timeout);
	alarm(80);
	
	while((getchar()!=NAK)&&(errorcount<10)) ++errorcount;
	alarm(0);
#ifdef DEBUG
	fprintf(stderr,"transmission beginning\r\n");
	fflush(stderr);
#endif
	if(errorcount==10)
	{
error:          
		fprintf(stderr,"too many errors...aborting\7\7\7\r\n");
		die(1);
	}
	
	while(read(foo,sector,sizeof sector) > 0)
	{
		errorcount=0;
		while(errorcount<10)
		{
#ifdef DEBUG
			fprintf(stderr,"{%d} ",blocknumber);
			fflush(stderr);
#endif
			putchar(SOH); /* here is our header */
			putchar(blocknumber);   /* the block number */
			putchar(~blocknumber);  /* & its complement */
			checksum=0;
			for(index=0;index<128;index++)
			{
				putchar(sector[index]);
				checksum+=sector[index];
			}
			putchar(checksum); /* tell our checksum */
			fflush(stdout);
			alarm(ACKTIMO) ;
			if(getchar() != ACK) ++errorcount;
			else break;
			alarm(0) ;
		}
		alarm(0) ;
		if(errorcount==10)goto error;
		++blocknumber;
	}
	index=1;
	while(index)
	{
		putchar(EOT);
		fflush(stdout);
		index=getchar()==ACK;
	}
	fprintf(stderr,"Transmission complete.\r\n");
	fflush(stderr);
	die(0);

rec:    /* receive a file */

	if(access(fname,0) == 0)
	{
		    fprintf(stderr,
		    	"%s exists; you have 10 seconds to abort (^C)\r\n",
				fname);
		fflush(stderr);
		sleep(10);
		fprintf(stderr,"Too late!\r\n");
		fflush(stderr);
	}
	stty(0,&ttymode);
	if((fout = fopen(fname,"w")) == NULL) {
		perror(fname);
		die(1);
	}
	printf("you have 30 seconds to start transmission...");
	fflush(stdout);
	sleep(SLEEP);   /* wait for the user to get his act together */
#ifdef DEBUG
	fprintf(stderr,"Starting...\r\n");
	fflush(stderr);
#endif
	putchar(NAK);
	fflush(stdout);
	errorcount=0;
	blocknumber=1;
	while((character=getchar())!=EOT)
	{
		register uchar not_ch;
		
		    if(character!=SOH)
		    {
#ifdef DEBUG
			fprintf(stderr,"Not SOH\r\n");
			fflush(stderr);
#endif
			if(++errorcount<10)goto nakit;
			    else goto error;
			
		}
		character=getchar();
		not_ch=~getchar();
#ifdef DEBUG
		fprintf(stderr,"[%d] ",character);
		fflush(stderr);
#endif
		if(character!=not_ch)
		{
#ifdef DEBUG
			fprintf(stderr,"Blockcounts not ~\r\n");
			fflush(stderr);
#endif
			++errorcount;
			goto nakit;
		}
		if(character!=blocknumber)
		{
#ifdef DEBUG
			fprintf(stderr,"Wrong blocknumber\r\n");
			fflush(stderr);
#endif
			++errorcount;
			goto nakit;
			
		}
		
		checksum=0;
		
		for(index=0;index<128;index++)
		{
			sector[index]=getchar();
			checksum+=sector[index];
		}
		if(checksum!=getchar())
		{
#ifdef DEBUG
			fprintf(stderr,"Bad checksum\r\n");
			fflush(stderr);
#endif
			errorcount++;
			goto nakit;
			
		}
		putchar(ACK);
		fflush(stdout);
		blocknumber++;
		if(aflag || qflag) decrlf(fout,sector) ;
		else fwrite(sector,sizeof sector[0],sizeof sector,fout);
		if(!errorcount) continue;
nakit:
		putchar(NAK);
		fflush(stdout);
	}
	
	fclose(fout);
	putchar(ACK);
		/* tell the modem on the other end we accepted his EOT */
	putchar(ACK);
	putchar(ACK);
	fflush(stdout);
	/*
	 *	special hack for stuff going directly to
	 *	our laser printer but an interesting idea
	 *	in general, no? (eg. this can be a shell)
	 *	BZS
	 */
	if(qflag)
	{
		sprintf(buf,PRCMD,fname) ;
		system(buf) ;
		unlink(fname) ;
	}
	else if(pflag)
	{
		sprintf(buf,"cat %s | %s",fname,pcmd) ;
		system(buf) ;
		unlink(fname) ;
	}
	fprintf(stderr,"Completed.\r\n");
	fflush(stderr);
	die(0);
}

timeout()
{
	fprintf(stderr,
	"Timed out waiting for NAK from remote system\7\7\7\r\n");
	die(1);
}

die(how)
register int how;
{
	ttymode.sg_flags=ttyhold;
	stty(0,&ttymode);
	exit(how);
}
/*
 *	typical nuisance is CR/LF pairs in UNIX files
 *	and CR only
 *	this is really the only need for 'ASCII' mode
 */
decrlf(fp,cp) FILE *fp ; register char *cp ;
{
	register int i ;

	for(i = 128 ; i > 0 ; i--,cp++)
	{
		switch(*cp) {

		case '\r' :
			putc('\n',fp) ;
			++cp ;
			if(i && (*cp == '\n')) --i ;
			break ;
		/*
		 *	Any ctrl chars that should pass thru go here
		 */
		case '\t' :	/* TAB	*/
		case 014  :	/* FF	*/
		case 033  :	/* ESC	*/
		case '\b' :	/* BS	*/
		case '\n' :	/* NL	*/
			putc(*cp,fp) ;
			break ;
		default :
			if(*cp >= ' ') putc(*cp,fp) ;
			break ;
		}
	}
}
--------------------modem.proto--------------------

                 MODEM/XMODEM Protocol Explained
                by Kelly Smith, CP/M-Net "SYSOP"
January 8,1980
Edited April 28, 1981 - FJW

     I  thought  that it may be of some interest to those of  you
who use the MODEM/XMODEM file transfer capability to get a little
insight  as  to the communications  protocol  (i.e.  "handshaking
method") used by the system.

     Herein lie the details of a very good (but not perfect) data
communications  protocol that has become the "de facto"  standard
for  various  remote CP/M systems (RCPM's) which  are  accessible
across  the country.   (Refer to RCPMLSTx.DOC on all  RCPM's  for
access  numbers and note that the "x" in that list changes as new
system  are  listed).   I  also  wish  to  give  credit  to  Ward
Christensen  (the "original" CBBS) for writing  MODEM.ASM  (CPMUG
Volume 25.11) and Keith Petersen,  Bruce Ratoff,  Dave Hardy, Rod
Hart,  Tom  "C"  (we  know who you are  Tom!),  and  others,  for
enhancements to Ward's original program which we now call  XMODEM
(external modem).

     Data is sent in 128-byte sequentially numbered blocks,  with
a single checksum byte appended to the end of each block.  As the
receiving  computer acquires the incoming data,  it performs  its
own  checksum  and upon each completion of a block,  it  compares
its  checksum result with that of the sending computers.   If the
receiving computer matches the checksum of the sending  computer,
it   transmits   an  ACK  (ASCII  code  protocol  character   for
ACKNOWLEDGE  (04 Hex,  Control-F)) back to the sending  computer.
The  ACK  therefore  means "all's well on  this  end,  send  some
more...".

Notice in the following example,  that the sending computer  will
transmit  an "initial NAK" (ASCII protocol character for NEGATIVE
ACKNOWLEDGE (15 Hex,  Control-U))...or, "that wasn't quite right,
please send again".

Due  to the asynchronous nature of the initial "hook-up"  between
the two computers, the receiving computer will "time-out" looking
for data,  and send the NAK as the "cue" for the sending computer
to  begin  transmission.   The sending computer  knows  that  the
receiving computer will "time-out", and uses this fact to "get in
sync"...  The sending computer responds to the "initial NAK" with
a  SOH  (ASCII code protocol character for START OF  HEADING  (01
Hex,  Control-A)),  sends  the first block number,  sends the 1's
complement  of the block number (VERY important,  I will  discuss
this later...),  sends 128 bytes of 8 bit data (that's why we can
transfer  ".COM"  files),  and  finally  a  checksum,  where  the
checksum is calculated by summing the SOH,  the block number, the
block number 1's complement, and the 128 bytes of data.

Receiving Computer:

----/NAK/------------------------/ACK/----------------------
    15H                           06H

Sending Computer:

--------/SOH/BLK#/BLK#/DATA/CSUM/---/SOH/BLK#/BLK#/DATA/etc.
         01H 001H 0FEH 8bit 8bit     01H 002H 0FDH 8bit ....

     This  process continues,  with the next 128  bytes,  IF  the
block  was  ACK'ed by the receiving computer,  and then the  next
sequential block number and its 1's complement, etc.

     But  what  happens if the block  is  NAK'ed?...   Easy,  the
sending computer just re-sends the previous block.

     Now the hard part...  What if the sending computer transmits
a block, the receiving computer gets it and sends an ACK, but the
sender does not see it?...   The sending computer thinks that  it
has  failed  and  after  10  seconds  re-transmits  the  block...
ARGH!...  The receiving computer has "stashed" the data in memory
or  on disk (data is written to disk after receiving 16  blocks),
the  receiving  computer is now 1 block AHEAD of the  transmiting
computer!   Here comes the operation of the block numbers...  The
receiver  detects that this is the last block (all  over  again),
and   transmits  back  an  ACK,   throws  away  the  block,   and
(effectively)  "catches  up"...    clever!    What's  more,   the
integrity  of  the  block number is  verified  by  the  receiving
computer,  because  it  "sums"  the SOH (01 Hex) with  the  block
number  plus  the 1's complement of the block  number),  and  the
result  MUST BE zero for a proper transfer (e.g.  01+01+FE hex  =
00, on the first block).  The sequence of events then, looks like
this:

Receiving Computer:

----/ACK/-----------------------/NAK/-----------------------
    06H                          15H

Sending Computer:

CSUM/---/SOH/BLK#/BLK#/DATA/CSUM/---/SOH/BLK#/BLK#/DATA/etc.
8bit     01H 003H 0FCH 8bit 8bit     01H 003H 0FCH 8bit ....

     Normal completion of data transfers will then conclude  with
an EOT (ASCII code protocol END OF TRANSMISSION, 04 Hex, Control-
D) from the sending computer,  and a final ACK from the receiving
computer.   Unfortunately,  if  the receiving computer misses the
EOT,  it will continue to wait for the next block (sending a  NAK
every  10  seconds,  up to 10 times) and  eventually  "time-out".
This is rarely the case however, and although not "bullet-proof",
it is a very workable protocol.

Receiving Computer:

----/ACK/---/ACK/"Transfer Complete"/A>(or B>)
     06H     06H .............................

Sending Computer:

CSUM/---/EOT/---/A>(or B>)
8bit     04H .............

     In   some  cases,   where  the  telephone  transmission   is
repeatedly "trashed" (weak signals, multiple noise "hits", etc.),
the receiving computer (and operator) will be provided the option
to  quit.   Here,  the operator enters "R" or "Q" in response  to
"Retry or Quit?" (after 10 retries).

Receiving Computer:

----/NAK/...NAK's ten times.../"Retry or Quit?"(Q)/A>...
     15H

Sending Computer:

CSUM/---/...Garbled Data....../-----------------------/A>...
8bit

 A  final  consideration when using the MODEM program,  is  a
timing  related  problems when transfer  status  messages  and/or
textual  data  is directed to the screen of a slow (4800 Baud  or
less)  terminal  or  to a hard copy  printer.   This  problem  is
readily apparent (multiple NAK's) when using MODEM for the  first
time, and can usually be "cured" by NOT SPECIFYING the "V" (VIEW)
sub-option  when sending or receiving files.   Users of  Lifeboat
Associates  BSTAM encounter the same problem,  but this is easily
fixed  with  the  files  TQPATCH.ASM  and  RQPATCH.ASM  (transfer
quiet/receive quiet) that Keith Petersen (Royal Oak CP/M,  "call-
back" remote system,  (313)-588-7054) wrote to solve the  problem
of low speed terminal I/O.

     For  users of CBBS's that do not have MODEM.ASM (but DO HAVE
a CP/M disk system...ESSENTIAL!),  let me suggest that you  "data
capture" the file MBOOTx.ASM from one of the RCPM's (it's a small
8  kilo-byte file that "fits" in most systems' memory) to get the
larger  MODEM.ASM (40 kilo-bytes).   Check it very carefully  for
errors  using the "data capture" (read ERROR PRONE method  here).
Then edit and assemble for your modem configuration.

     If  you are tired of buying software where the  advertisment
is written better than the program, then the RCPM's are just what
you have been looking for...and FREE!