home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Libraries / xmodem 3.10 / getput.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-10  |  12.2 KB  |  469 lines  |  [TEXT/MPS ]
  1. /*
  2.  * Contains system routines to get and put bytes, change tty modes, etc
  3.  * Most of the routines are VERY 4.2BSD Specific!!!
  4.  */
  5.  
  6. #include "xmodem.h"
  7.  
  8. /*
  9.  *
  10.  *    Get a byte from the specified file.  Buffer the read so we don't
  11.  *    have to use a system call for each character.
  12.  *
  13.  */
  14. getbyte(fildes, ch)                /* Buffered disk read */
  15. int fildes;
  16. char *ch;
  17.  
  18.     {
  19.     static char buf[BUFSIZ];    /* Remember buffer */
  20.     static char *bufp = buf;    /* Remember where we are in buffer */
  21.     
  22.     if (nbchr == 0)            /* Buffer exausted; read some more */
  23.         {
  24.         if ((nbchr = read(fildes, buf, BUFSIZ)) < 0)
  25.             error("File Read Error", TRUE);
  26.         bufp = buf;        /* Set pointer to start of array */
  27.         }
  28.     if (--nbchr >= 0)
  29.         {
  30.         *ch = *bufp++;
  31.         return(0);
  32.         }
  33.     else
  34.         {
  35.         return(EOF);
  36.         }
  37.     }
  38.  
  39. /* Count the number of newlines in a file so we know the REAL file size */
  40.  
  41. long
  42. countnl(fd)
  43. int fd;
  44. {
  45.     char buf[BUFSIZ];
  46.     char *bufp;
  47.     long nltot = 0;
  48.     int numchar;
  49.     long lseek();
  50.  
  51.     while (numchar = read(fd, buf, BUFSIZ))        /* cycle through file */
  52.         for (bufp=buf; numchar--; bufp++)
  53.             if (*bufp == '\n')
  54.                 nltot++;
  55.  
  56.     (void) lseek (fd, 0l, 0);            /* rewind file */
  57.     if (DEBUG)
  58.         fprintf(LOGFP, "DEBUG: countnl--%ld newlines counted\n", nltot);
  59.     return (nltot);
  60. }
  61.  
  62. /*   CRC-16 constant array...
  63.      from Usenet contribution by Mark G. Mendel, Network Systems Corp.
  64.      (ihnp4!umn-cs!hyper!mark)
  65. */
  66.  
  67. /* crctab as calculated by initcrctab() */
  68. unsigned short crctab[1<<B] = { 
  69.     0x0000,  0x1021,  0x2042,  0x3063,  0x4084,  0x50a5,  0x60c6,  0x70e7,
  70.     0x8108,  0x9129,  0xa14a,  0xb16b,  0xc18c,  0xd1ad,  0xe1ce,  0xf1ef,
  71.     0x1231,  0x0210,  0x3273,  0x2252,  0x52b5,  0x4294,  0x72f7,  0x62d6,
  72.     0x9339,  0x8318,  0xb37b,  0xa35a,  0xd3bd,  0xc39c,  0xf3ff,  0xe3de,
  73.     0x2462,  0x3443,  0x0420,  0x1401,  0x64e6,  0x74c7,  0x44a4,  0x5485,
  74.     0xa56a,  0xb54b,  0x8528,  0x9509,  0xe5ee,  0xf5cf,  0xc5ac,  0xd58d,
  75.     0x3653,  0x2672,  0x1611,  0x0630,  0x76d7,  0x66f6,  0x5695,  0x46b4,
  76.     0xb75b,  0xa77a,  0x9719,  0x8738,  0xf7df,  0xe7fe,  0xd79d,  0xc7bc,
  77.     0x48c4,  0x58e5,  0x6886,  0x78a7,  0x0840,  0x1861,  0x2802,  0x3823,
  78.     0xc9cc,  0xd9ed,  0xe98e,  0xf9af,  0x8948,  0x9969,  0xa90a,  0xb92b,
  79.     0x5af5,  0x4ad4,  0x7ab7,  0x6a96,  0x1a71,  0x0a50,  0x3a33,  0x2a12,
  80.     0xdbfd,  0xcbdc,  0xfbbf,  0xeb9e,  0x9b79,  0x8b58,  0xbb3b,  0xab1a,
  81.     0x6ca6,  0x7c87,  0x4ce4,  0x5cc5,  0x2c22,  0x3c03,  0x0c60,  0x1c41,
  82.     0xedae,  0xfd8f,  0xcdec,  0xddcd,  0xad2a,  0xbd0b,  0x8d68,  0x9d49,
  83.     0x7e97,  0x6eb6,  0x5ed5,  0x4ef4,  0x3e13,  0x2e32,  0x1e51,  0x0e70,
  84.     0xff9f,  0xefbe,  0xdfdd,  0xcffc,  0xbf1b,  0xaf3a,  0x9f59,  0x8f78,
  85.     0x9188,  0x81a9,  0xb1ca,  0xa1eb,  0xd10c,  0xc12d,  0xf14e,  0xe16f,
  86.     0x1080,  0x00a1,  0x30c2,  0x20e3,  0x5004,  0x4025,  0x7046,  0x6067,
  87.     0x83b9,  0x9398,  0xa3fb,  0xb3da,  0xc33d,  0xd31c,  0xe37f,  0xf35e,
  88.     0x02b1,  0x1290,  0x22f3,  0x32d2,  0x4235,  0x5214,  0x6277,  0x7256,
  89.     0xb5ea,  0xa5cb,  0x95a8,  0x8589,  0xf56e,  0xe54f,  0xd52c,  0xc50d,
  90.     0x34e2,  0x24c3,  0x14a0,  0x0481,  0x7466,  0x6447,  0x5424,  0x4405,
  91.     0xa7db,  0xb7fa,  0x8799,  0x97b8,  0xe75f,  0xf77e,  0xc71d,  0xd73c,
  92.     0x26d3,  0x36f2,  0x0691,  0x16b0,  0x6657,  0x7676,  0x4615,  0x5634,
  93.     0xd94c,  0xc96d,  0xf90e,  0xe92f,  0x99c8,  0x89e9,  0xb98a,  0xa9ab,
  94.     0x5844,  0x4865,  0x7806,  0x6827,  0x18c0,  0x08e1,  0x3882,  0x28a3,
  95.     0xcb7d,  0xdb5c,  0xeb3f,  0xfb1e,  0x8bf9,  0x9bd8,  0xabbb,  0xbb9a,
  96.     0x4a75,  0x5a54,  0x6a37,  0x7a16,  0x0af1,  0x1ad0,  0x2ab3,  0x3a92,
  97.     0xfd2e,  0xed0f,  0xdd6c,  0xcd4d,  0xbdaa,  0xad8b,  0x9de8,  0x8dc9,
  98.     0x7c26,  0x6c07,  0x5c64,  0x4c45,  0x3ca2,  0x2c83,  0x1ce0,  0x0cc1,
  99.     0xef1f,  0xff3e,  0xcf5d,  0xdf7c,  0xaf9b,  0xbfba,  0x8fd9,  0x9ff8,
  100.     0x6e17,  0x7e36,  0x4e55,  0x5e74,  0x2e93,  0x3eb2,  0x0ed1,  0x1ef0
  101.     };
  102.  
  103. /* get a byte from data stream -- timeout if "seconds" elapses */
  104. /* This routine is VERY 4.2 specific */
  105.  
  106. int
  107. readbyte(seconds)
  108. int seconds;
  109.     {
  110.     int readfd;
  111.     char c;
  112.     struct timeval tmout;
  113.  
  114.     tmout.tv_sec = seconds;
  115.     tmout.tv_usec = 0;
  116.  
  117.     readfd = 1<<0;
  118.  
  119.     if ((select(1, &readfd, (int *)0, (int *)0, &tmout)) == 0)
  120.         {
  121.         if (DEBUG)
  122.             fprintf(LOGFP, "DEBUG: readbyte TIMEOUT after %d seconds\n", seconds);
  123.         return(TIMEOUT);
  124.         }
  125.  
  126.     read(0, &c, 1);
  127.  
  128.     if (DEBUG)
  129.         fprintf(LOGFP, "DEBUG: readbyte %02xh\n", c & 0xff);
  130.  
  131.     return(c & 0xff);  /* return the char */
  132.     }
  133.  
  134. /* flush input stream by reading pending characters */
  135.  
  136. flushin()
  137.     {
  138.     int readfd;
  139.     char inbuf[BBUFSIZ];
  140.     struct timeval tmout;
  141.  
  142.     /* set up a usec timeout on stdin */
  143.     tmout.tv_sec = 0;
  144.     tmout.tv_usec = 1;
  145.     readfd = 1<<0;
  146.  
  147.     /* any characters pending?; return if none */
  148.     if ((select(1, &readfd, (int *)0, (int *)0, &tmout)) == 0)
  149.         return;
  150.  
  151.     /* read the characters to flush them (assume there are fewer than BBUFSIZ */
  152.     (void) read(0, inbuf, BBUFSIZ);
  153.     }
  154.  
  155. /* 
  156.  get a buffer (length bufsize) from data stream -- timeout if "seconds" elapses.
  157.  Read bunches of characters to save system overhead;
  158.  Further process data while kernel is reading stream (calculating "checksum").
  159.  Try to nap long enough so kernel collects 100 characters or so until we wake up
  160.  unless TOOBUSY is set.
  161. */
  162.  
  163. /* This routine is VERY 4.2 specific */
  164.  
  165. int
  166. readbuf(bufsize, seconds, tmode, amode, recvsectcnt, checksum, bufctr)
  167.  
  168. int bufsize,    /* number of chars to be read */
  169. seconds,     /* timeout period for each read */
  170. tmode,         /* transmission mode: TRUE if text */
  171. amode,         /* transmission mode: TRUE if apple macintosh */
  172. *checksum,     /* pointer to checksum value */
  173. *bufctr;    /* length of actual data string in buffer */
  174. long recvsectcnt;    /* running sector count (128 byte sectors) */
  175.  
  176. {
  177.     int readfd;        /* mask for select call */
  178.     struct timeval tmout;    /* timeout structure for select */
  179.     int numread;        /* number of chars read */
  180.     int left;        /* number of chars left to read */
  181.     int recfin = FALSE;        /* flag that EOF read */
  182.     char inbuf[BBUFSIZ];    /* buffer for incoming packet */
  183.     register unsigned char c;    /* character being processed */
  184.     register unsigned short chksm;    /* working copy of checksum */
  185.     register int bfctr;    /* working copy of bufctr */
  186.     int j;            /* loop index */
  187.     char *sectdisp();
  188.  
  189.     tmout.tv_sec = seconds;
  190.     tmout.tv_usec = 0;
  191.     readfd = 1<<0;
  192.     chksm = 0;
  193.     bfctr = 0;
  194.  
  195.     for (left = bufsize; left > 0;) {
  196.  
  197.         /* read however many chars are waiting */
  198.  
  199.         if ((select(1, &readfd, (int *)0, (int *)0, &tmout)) == 0)
  200.             return(TIMEOUT);
  201.  
  202.         numread = read(0, inbuf, left);
  203.         left -= numread;
  204.  
  205.         if (DEBUG)
  206.             fprintf(LOGFP, "DEBUG: readbuf--read %d characters\n", numread);
  207.  
  208.         /* now process part of packet we just read */
  209.  
  210.         for (j =  0; j < numread; j++) 
  211.             {  
  212.                 buff[bfctr] = c = inbuf[j] & 0xff;
  213.                 fileread++;
  214.  
  215.                 if (MOREDEBUG)
  216.                     fprintf(LOGFP, "DEBUG: character read %02xh\n", c & 0xff);
  217.  
  218.                 if (CRCMODE)  /* CRC */
  219.                     chksm = (chksm<<B) ^ crctab[(chksm>>(W-B)) ^ c];
  220.  
  221.                 else        /* checksum */
  222.                            chksm = ((chksm+c) & 0xff);
  223.  
  224.                 if (CHECKLENGTH && fileread > filelength)    /* past EOF ? */
  225.                     continue;
  226.  
  227.                 if (tmode)         /* text mode processing */
  228.                     {
  229.                     buff[bfctr] &= 0x7f;    /* nuke bit 8 */
  230.                     if (c == CR || c == 0)    /* skip CRs and nulls */
  231.                         continue;
  232.                     else if (c == CTRLZ)    /* CP/M EOF char */
  233.                         {  
  234.                         recfin = TRUE;
  235.                                continue;
  236.                                }
  237.                            else if (!recfin)    /* don't increment if past EOF */
  238.                         bfctr++;
  239.                     }
  240.                 else if (amode)     /* Apple macintosh text mode processing */
  241.                     {
  242.                     buff[bfctr] &= 0x7f;    /* nuke bit 8 */
  243.                     if (c == 0)        /* skip nulls */
  244.                         continue;
  245.                     else if (c == CR)    /* translate CR to LF */
  246.                         buff[bfctr] = LF;
  247.                     else if (c == CTRLZ)    /* CP/M EOF char */
  248.                         {  
  249.                         recfin = TRUE;
  250.                                continue;
  251.                                }
  252.                            if (!recfin)        /* don't increment if past EOF */
  253.                         bfctr++;
  254.                     }
  255.                 else            /* binary */
  256.                     bfctr++;
  257.  
  258.                  }    
  259.  
  260.         /* go to sleep to save uneeded system calls while kernel
  261.            is reading data from serial line; 
  262.            fudge constant from 10000 to 9000 to avoid sleeping too long.
  263.         */
  264.         if (left && !TOOBUSY)
  265.             napms( (left<SLEEPNUM ? left:SLEEPNUM) * 9000/ttyspeed);
  266.  
  267.     }
  268.  
  269.     if (CHECKLENGTH && fileread >= filelength)
  270.         logitarg("File end from YMODEM length found in sector %s\n",
  271.           sectdisp(recvsectcnt,bufsize,1));
  272.     *checksum = chksm;
  273.     *bufctr = bfctr;
  274.     return(0);
  275. }
  276.  
  277. /* send a byte to data stream */
  278.  
  279. sendbyte(data)
  280. char data;
  281.     {
  282.     if (DEBUG)
  283.         fprintf(LOGFP, "DEBUG: sendbyte %02xh\n", data & 0xff);
  284.  
  285.     if (write(1, &data, 1) != 1)      /* write the byte (assume it goes NOW; no flushing needed) */
  286.         error ("Write error on stream", TRUE);
  287.     return;
  288.     }
  289.  
  290. /* send a buffer to data stream */
  291.  
  292. writebuf(buffer, nbytes)
  293. char *buffer;
  294. int  nbytes;
  295.     {
  296.     if (DEBUG)
  297.         fprintf(LOGFP, "DEBUG: writebuf (%d bytes)\n", nbytes);
  298.  
  299.     if (write(1, buffer, nbytes) != nbytes)        /* write the buffer (assume no TIOCFLUSH needed) */
  300.         error ("Write error on stream", TRUE);
  301.     return;
  302.     }
  303.  
  304. /*
  305.  * "nap" for specified time -- VERY 4.2BSD specific
  306.  */
  307.  
  308. napms (milliseconds)
  309. int    milliseconds;
  310. {
  311.     struct    timeval    timeout;
  312.     int readfd;
  313.  
  314.     if (milliseconds == 0)
  315.         return;
  316.     if (DEBUG)
  317.         fprintf (LOGFP, "DEBUG: napping for %d ms\n", milliseconds);
  318.     timeout.tv_sec = 0;
  319.     timeout.tv_usec = milliseconds * 1000;
  320.     readfd = 0;
  321.  
  322.     (void) select(1, &readfd, (int *)0, (int *)0, &timeout);
  323. }
  324.  
  325.  
  326. /* set and restore tty modes for XMODEM transfers */
  327. /* These routines are 4.2/v7(?) specific */
  328.  
  329. struct sgttyb ttys, ttysnew;    /* for stty terminal mode calls */
  330. struct stat statbuf;        /* for terminal message on/off control */
  331.  
  332. int wason;            /* holds status of tty read write/modes */
  333. char *tty;            /* current tty name */
  334.  
  335.  
  336. setmodes()
  337.     {
  338.     char *ttyname();
  339.  
  340.     int n;
  341.  
  342.     extern onintr();
  343.  
  344.     sleep(2);            /* let the output appear */
  345.     if (ioctl(0,TIOCGETP,&ttys)<0)  /* get tty params [V7] */
  346.         error("Can't get TTY Parameters", TRUE);
  347.  
  348.     tty = ttyname(0);  /* identify current tty */
  349.     
  350.     ttysnew.sg_ispeed = ttys.sg_ispeed;    /* copy input speed */
  351.     ttysnew.sg_ospeed = ttys.sg_ospeed;    /* copy input speed */
  352.     ttysnew.sg_flags |= RAW;    /* set for RAW Mode */
  353.     ttysnew.sg_flags &= ~ECHO;    /* set for no echoing */
  354.     ttysnew.sg_flags &= ~TANDEM;    /* turn off flow control */
  355.  
  356.     /* set new paramters */
  357.     if (ioctl(0,TIOCSETP,&ttysnew) < 0)
  358.         error("Can't set new TTY Parameters", TRUE);
  359.  
  360.     /* Flush characters waiting for read or write */
  361.     n = 0;
  362.     if (ioctl(0,TIOCFLUSH,&n) < 0)
  363.         {
  364.         logit("Can't flush terminal queue\n");
  365.         tlogit("Can't flush terminal queue\n");
  366.         }
  367.  
  368.     if (stat(tty, &statbuf) < 0)    /* get tty modes */ 
  369.         {
  370.         logit("Can't get your TTY Status\n");
  371.         tlogit("Can't get your TTY Status\n");
  372.         wason = FALSE;
  373.         }
  374.     else
  375.         {
  376.         if (statbuf.st_mode & 022)
  377.             {
  378.             if (chmod(tty, (int)statbuf.st_mode & ~022) < 0)
  379.                 {
  380.                 logit("Can't change TTY mode\n");
  381.                 tlogit("Can't change TTY mode\n");
  382.                 wason = FALSE;
  383.                 }
  384.             else 
  385.                 wason = TRUE;
  386.             }
  387.         else 
  388.             wason = FALSE;
  389.         }
  390.  
  391.     /* set up signal catcher to restore tty state if we are KILLed */
  392.  
  393.     if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
  394.         signal(SIGTERM, onintr);
  395.     }
  396.  
  397. /* restore normal tty modes */
  398.  
  399. restoremodes(errcall)
  400. int errcall;
  401.     {
  402.     if (wason)
  403.         if (chmod(tty, (int)statbuf.st_mode | 022) < 0)
  404.             error("Can't change TTY mode", FALSE);
  405.     if (ioctl(0,TIOCSETP,&ttys) < 0)
  406.         { if (!errcall)
  407.            error("RESET - Can't restore normal TTY Params", FALSE);
  408.         else
  409.              printf("RESET - Can't restore normal TTY Params\n");
  410.         }
  411.     if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
  412.         signal(SIGTERM, SIG_DFL);
  413.     return;
  414.     }
  415.  
  416.  
  417.  
  418.  
  419. /* signal catcher */
  420. onintr()
  421.     {
  422.     error("Kill signal; bailing out", TRUE);
  423.     }
  424.  
  425. /* create string with a timestamp for log file */
  426.  
  427. char *stamptime()
  428. {
  429.     char *asctime();        /* stuff to get timestamp */
  430.     struct tm *localtime(), *tp;
  431.     struct timeval tv;
  432.     struct timezone tz;
  433.  
  434.     gettimeofday (&tv, &tz);        /* fill in timestamp */
  435.     tp = localtime ((time_t *)&tv.tv_sec);
  436.     return(asctime(tp));
  437. }
  438.  
  439.  
  440.  
  441. /* get tty speed for time estimates */
  442.  
  443. getspeed()
  444.     {
  445.     static int speedtbl[] = {0, 50, 75, 110, 134, 150, 200, 300, 600, 
  446.        1200, 1800, 2400, 4800, 9600, 19200, 0};
  447.     if (ioctl(0,TIOCGETP,&ttys) < 0)    /* get tty structure */
  448.         error("Can't get TTY parameters", FALSE);
  449.  
  450.     if (ttys.sg_ispeed >= 0 && ttys.sg_ispeed <= 14)
  451.         {
  452.         ttyspeed = speedtbl[ttys.sg_ispeed];
  453.         logitarg ("Line speed = %d bits per second\n", ttyspeed);
  454.         }
  455.     else
  456.         {
  457.         ttyspeed = 1200;
  458.         logit ("Can't determine line speed; assuming 1200 bps\n");
  459.         }
  460.     }
  461.  
  462.  
  463. /* turn off keyboard stop signal so stray ^X don't put us in background */
  464.  
  465. stopsig()
  466.     {
  467.     signal(SIGTSTP, SIG_IGN);
  468.     }
  469.