home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume23 / xmodem3.9 / part01 / receive.c < prev    next >
C/C++ Source or Header  |  1991-01-08  |  18KB  |  643 lines
  1. #include "xmodem.h"
  2.  
  3. /**  receive a file  **/
  4.  
  5. /* returns TRUE if in the midst of a batch transfer */
  6. /* returns FALSE if no more files are coming */
  7.  
  8. /* This routine is one HUGE do-while loop with far to many indented levels.
  9.  * I chose this route to facilitate error processing and to avoid GOTOs.
  10.  * Given the troubles I've had keeping the nested IF statements straight,
  11.  * I was probably mistaken...
  12.  */
  13.  
  14. rfile(name)
  15. char *name;
  16. {
  17.  
  18. char *sectdisp();
  19. char *cpm_unix();
  20. char *strcpy();
  21. char *ctime();
  22. time_t time();
  23.  
  24. int fd,     /* file descriptor for created file */
  25. checksum,   /* packet checksum */
  26. firstchar,  /* first character of a packet */
  27. sectnum,    /* number of last received packet (modulo 128) */
  28. sectcurr,   /* second byte of packet--should be packet number (mod 128) */
  29. sectcomp,   /* third byte of packet--should be complement of sectcurr */
  30. tmode,      /* text mode if true */
  31. amode,      /* apple mode if true */
  32. errors,     /* count of errors for each packet */
  33. sterrors,   /* count of errors during startup handshake */
  34. errorflag,  /* set true when packet (or first char of putative packet) is invalid */
  35. fatalerror, /* set within main "read-packet" Do-While when bad error found */
  36. inchecksum, /* incoming checksum or CRC */
  37. expsect,    /* expected number of sectors (YMODEM batch) */
  38. firstwait,  /* seconds to wait for first character in a packet */
  39. nocancanabort, /* if true, don't allow CAN-CAN abort */
  40. bufsize;    /* packet size (128 or 1024) */
  41. long recvsectcnt;   /* running sector count (128 byte sectors) */
  42. long modtime;       /* Unix style file mod time from YMODEM header */
  43. int filemode;       /* Unix style file mode from YMODEM header */
  44. int serial;    /* serial # from YMODEM header */
  45. int filesleft;        /* # of files left from YMODEM header */
  46. long totalleft;        /* # of bytes left from YMODEM header */
  47. int yfiletype;        /* file type from YMODEM header */
  48. long readbackup;    /* "backup" value for characters read in file */
  49. time_t timep[2];    /* used in setting mod time of received file */
  50. char *p;    /* generic pointer */
  51. int bufctr; /* number of real chars in read packet */
  52. unsigned char *nameptr; /* ptr in filename for MODEM7 protocol */
  53. time_t start;       /* starting time of transfer */
  54. int openflag = FALSE;   /* is file open for writing? */
  55.  
  56. logit("----\nXMODEM File Receive Function\n");
  57. tlogit("----\nXMODEM File Receive Function\n");
  58. if (CRCMODE)
  59.     {
  60.     logit("CRC mode requested on command line\n");
  61.     tlogit("CRC mode requested on command line\n");
  62.     }
  63.  
  64. if (YMODEMG)
  65.     {
  66.     logit("YMODEM-G mode requested on command line\n");
  67.     tlogit("YMODEM-G mode requested on command line\n");
  68.     }
  69.  
  70. BATCH = FALSE;          /* don't know if really are in batch mode ! */
  71. fatalerror = FALSE;
  72. firstwait = WAITFIRST;  /* For first packet, wait short time */
  73. sectnum = errors = recvsectcnt = 0;
  74. bufsize = 128;
  75. modtime = 0l; filemode = 0;
  76. serial = 0; filesleft = 0; totalleft = 0l; yfiletype = 0;
  77. filelength = 0l; fileread =0l; CHECKLENGTH = FALSE;
  78. nocancanabort = FALSE;
  79.  
  80. tmode = (XMITTYPE == 't') ? TRUE : FALSE;
  81. amode = (XMITTYPE == 'a') ? TRUE : FALSE;
  82.  
  83. /* start up transfer */
  84.  
  85. sterrors = 0;
  86. flushin();         /* flush input queue */
  87.  
  88. if (YMODEMG)
  89.     sendbyte(GCHR);
  90. else if (CRCMODE && !MDM7BAT)        
  91. {
  92.     sendbyte(CRCCHR);
  93.     if (LONGPACK && !MDM7BAT)
  94.         sendbyte(KCHR);
  95. }
  96. else
  97.     sendbyte(NAK);
  98.  
  99.  
  100. do                  /* start of MAIN Do-While loop to read packets */
  101. {   
  102.     errorflag = FALSE;
  103.     do              /* start by reading first byte in packet */
  104.     {
  105.         firstchar = readbyte(firstwait);
  106.     } 
  107.     while ((firstchar != SOH) 
  108.         && (firstchar != STX) 
  109.         && (firstchar != EOT) 
  110.         && (firstchar != ACK || recvsectcnt > 0) 
  111.         && (firstchar != TIMEOUT) 
  112.         && (firstchar != CAN || nocancanabort));
  113.  
  114.     if (firstchar == EOT && !NOEOT)           /* check for REAL EOT */
  115.     {
  116.         flushin();
  117.         sendbyte(NAK);              /* NAK the EOT */
  118.         if ((firstchar = readbyte(5)) != EOT)   /* check next character */
  119.         {
  120.             logit("Spurious EOT detected; ignored\n");
  121.             tlogit("Spurious EOT detected; ignored\n");
  122.             if ((firstchar == SOH) || (firstchar == STX) ||
  123.                 (firstchar == ACK && recvsectcnt == 0) ||
  124.                 (firstchar == CAN && !nocancanabort) ||
  125.                 (firstchar == TIMEOUT))
  126.                 ;
  127.             else
  128.             {
  129.                 firstchar = 0;
  130.                 errorflag = TRUE;
  131.             }
  132.         }
  133.     }
  134.  
  135.     if (firstchar == TIMEOUT)       /* timeout? */
  136.     {  
  137.         if (recvsectcnt > 0)
  138.             {
  139.             logitarg("Timeout on Sector %s\n", sectdisp(recvsectcnt,bufsize,1));
  140.             tlogitarg("Timeout on Sector %s\n", sectdisp(recvsectcnt,bufsize,1));
  141.             }
  142.         errorflag = TRUE;
  143.     }
  144.  
  145.     if (firstchar == CAN)           /* bailing out? (only at beginning or if CANCAN flag set) */
  146.     {
  147.         if ((readbyte(3) & 0x7f) == CAN)
  148.             {
  149.             if (openflag)
  150.                 {
  151.                 close(fd);
  152.                 unlink(name);
  153.                 error("Reception Canceled by CAN-CAN; partial file deleted",TRUE);
  154.                 }
  155.             else
  156.                 error("Reception Canceled by CAN-CAN",TRUE);
  157.             }
  158.         else
  159.         {
  160.             errorflag = TRUE;
  161.             logit("Received single CAN character\n");
  162.             tlogit("Received single CAN character\n");
  163.         }
  164.     }
  165.  
  166.     if (firstchar == ACK)           /* MODEM7 batch? (only at beginning) */
  167.     {
  168.         int i,c; 
  169.  
  170.         logit("MODEM7 Batch Protocol\n");
  171.         tlogit("MODEM7 Batch Protocol\n");
  172.         nameptr = buff;
  173.         checksum = 0;
  174.  
  175.         for (i=0; i<NAMSIZ; i++)
  176.         {
  177.             c = readbyte(3);
  178.  
  179.             if (c == CAN)
  180.             {
  181.                 if (readbyte(3) == CAN)
  182.                     error("Program Canceled by CAN-CAN", TRUE);
  183.                 else
  184.                 {
  185.                     logit("Received single CAN character in MODEM7 filename\n");
  186.                     tlogit("Received single CAN character in MODEM7 filename\n");
  187.                     errorflag = TRUE;
  188.                     break;
  189.                 }
  190.             }
  191.  
  192.             if (c == EOT && i == 0)
  193.             {
  194.                 sendbyte(ACK);          /* acknowledge EOT */
  195.                 logit("MODEM7 Batch Receive Complete\n");
  196.                 tlogit("MODEM7 Batch Receive Complete\n");
  197.                 return (FALSE);
  198.             }
  199.  
  200.             if (c == TIMEOUT)
  201.             {
  202.                 logit("Timeout waiting for MODEM7 filename character\n");
  203.                 tlogit("Timeout waiting for MODEM7 filename character\n");
  204.                 errorflag = TRUE;
  205.                 break;
  206.             }
  207.  
  208.             if (c == BAD_NAME)
  209.             {
  210.                 logit("Error during MODEM7 filename transfer\n");
  211.                 tlogit("Error during MODEM7 filename transfer\n");
  212.                 errorflag = TRUE;
  213.                 break;
  214.             }
  215.  
  216.             *nameptr++ = c;
  217.             checksum += c;
  218.             sendbyte(ACK);
  219.         }
  220.  
  221.         if (!errorflag)
  222.         {
  223.             c = readbyte(3);
  224.             if (c == CTRLZ)     /* OK; end of string found */
  225.             {
  226.                 sendbyte(checksum + CTRLZ);
  227.                 if (readbyte(15) == ACK)     /* file name found! */
  228.                 {
  229.                     xmdebug("MODEM7 file name OK");
  230.                     *nameptr = '\000';  /* unixify the file name */
  231.                     name = cpm_unix(buff);
  232.                     BATCH = TRUE;
  233.                     logitarg("MODEM7 file name: %s\n", name);
  234.                     tlogitarg("MODEM7 file name: %s\n", name);
  235.                     errors = 0;     /* restart crc handshake */
  236.                     sleep(2);       /* give other side a chance */
  237.                 }
  238.                 else
  239.                 {
  240.                     logit("Checksum error in MODEM7 filename\n");
  241.                     tlogit("Checksum error in MODEM7 filename\n");
  242.                     errorflag = TRUE;
  243.                 }
  244.             }
  245.             else
  246.             {
  247.                 logit("Length error in MODEM7 filename\n");
  248.                 tlogit("Length error in MODEM7 filename\n");
  249.                 errorflag = TRUE;
  250.             }
  251.         }
  252.     }
  253.  
  254.  
  255.     if (firstchar == SOH || firstchar == STX)  /* start reading packet */
  256.     {
  257.         bufsize = (firstchar == SOH) ? 128 : 1024;
  258.  
  259.         if (recvsectcnt == 0)           /* 1st data packet, initialize */
  260.         {
  261.             if (bufsize == 1024)
  262.                 {
  263.                 logit("1K packet mode chosen\n");
  264.                 tlogit("1K packet mode chosen\n");
  265.                 }
  266.             start = time((time_t *) 0);
  267.             errors = 0;
  268.             firstwait = 5;
  269.         }
  270.  
  271.         sectcurr = readbyte(3);
  272.         sectcomp = readbyte(3);
  273.         if ((sectcurr + sectcomp) == 0xff)  /* is packet number checksum correct? */
  274.         {  
  275.             if (sectcurr == ((sectnum+1) & 0xff))   /* is packet number correct? */
  276.             {  
  277.                 if (DEBUG)
  278.                     fprintf(LOGFP,"DEBUG: packet with sector number %d started\n", sectnum);
  279.  
  280.                 /* Read, process and calculate checksum for a buffer of data */
  281.  
  282.                 readbackup = fileread;
  283.                 if (readbuf(bufsize, 1, tmode, amode, recvsectcnt, &checksum, &bufctr) != TIMEOUT) 
  284.                 {
  285.  
  286.                     /* verify checksum or CRC */
  287.  
  288.                     if (CRCMODE) 
  289.                     {
  290.                         checksum &= 0xffff;
  291.                         inchecksum = readbyte(3);  /* get 16-bit CRC */
  292.                         inchecksum = (inchecksum<<8) | readbyte(3);
  293.                     }
  294.  
  295.                     else
  296.                         inchecksum = readbyte(3);  /* get simple 8-bit checksum */
  297.  
  298.                     if (inchecksum == checksum) /* good checksum, hence good packet */
  299.                     {  
  300.                         xmdebug("checksum ok");
  301.                         errors = 0;
  302.                         recvsectcnt += (bufsize == 128) ? 1 : 8;
  303.                         nocancanabort = CANCAN ? FALSE : TRUE;
  304.                         sectnum = sectcurr; 
  305.  
  306.                         if (!openflag)      /* open output file if necessary */
  307.                         {
  308.                             openflag = TRUE;
  309.                             if ((fd = creat(name, CREATMODE)) < 0)
  310.                             {
  311.                                 sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
  312.                                 error("Can't create file for receive", TRUE);
  313.                             }
  314.                             if (!BATCH)
  315.                                 {
  316.                                 logitarg("File Name: %s\n", name);
  317.                                 tlogitarg("File Name: %s\n", name);
  318.                                 }
  319.                         }
  320.  
  321.                         if (write(fd, (char *) buff, bufctr) != bufctr)
  322.                         {
  323.                             close(fd);
  324.                             unlink(name);
  325.                             error("File Write Error", TRUE);
  326.                         }
  327.                         else
  328.                         {
  329.                             if (TIPFLAG && recvsectcnt % 32 == 0)
  330.                                 tlogitarg("Sector %s received\n", sectdisp(recvsectcnt,bufsize,0));
  331.                             if (!YMODEMG)
  332.                                 {
  333.                                 flushin();          /* flush input */
  334.                                 sendbyte(ACK);      /* ACK the received packet */
  335.                                 }
  336.                         }
  337.                     }
  338.  
  339.                     /* Start handling various errors and special conditions */
  340.  
  341.                     else        /* bad checksum */
  342.                     {  
  343.                         logitarg("Checksum Error on Sector %s:  ", sectdisp(recvsectcnt,bufsize,1));
  344.                         logitarg("sent=%x  ", inchecksum);
  345.                         logitarg("recvd=%x\n", checksum);
  346.                         tlogitarg("Checksum Error on Sector %s:  ", sectdisp(recvsectcnt,bufsize,1));
  347.                         tlogitarg("sent=%x  ", inchecksum);
  348.                         tlogitarg("recvd=%x\n", checksum);
  349.                         fileread = readbackup;
  350.                         errorflag = TRUE;
  351.                         if (YMODEMG)
  352.                             fatalerror = TRUE;
  353.                     }
  354.                 }
  355.  
  356.                 else    /* read timeout */
  357.                 {
  358.                     logitarg("Timeout while reading sector %s\n",sectdisp(recvsectcnt,bufsize,1));
  359.                     tlogitarg("Timeout while reading sector %s\n",sectdisp(recvsectcnt,bufsize,1));
  360.                     fileread = readbackup;
  361.                     errorflag = TRUE;
  362.                     if (YMODEMG)
  363.                         fatalerror = TRUE;
  364.                 }
  365.             }
  366.  
  367.             else        /* sector number is wrong OR Ymodem filename */
  368.             { 
  369.                 if (sectcurr == 0 && recvsectcnt == 0)  /* Ymodem file-name packet */
  370.                 {
  371.                     logit("YMODEM Batch Protocol\n");
  372.                     tlogit("YMODEM Batch Protocol\n");
  373.  
  374.                     /* Read and process a file-name packet */
  375.  
  376.                     if (readbuf(bufsize, 1, FALSE, FALSE, recvsectcnt, &checksum, &bufctr) != TIMEOUT) 
  377.                     {
  378.  
  379.                         /* verify checksum or CRC */
  380.  
  381.                         if (CRCMODE) 
  382.                         {
  383.                             checksum &= 0xffff;
  384.                             inchecksum = readbyte(3);  /* get 16-bit CRC */
  385.                             inchecksum = (inchecksum<<8) | readbyte(3);
  386.                         }
  387.  
  388.                         else
  389.                             inchecksum = readbyte(3);  /* get simple 8-bit checksum */
  390.  
  391.                         if (inchecksum == checksum) /* good checksum, hence good filename */
  392.                         {
  393.                             xmdebug("checksum ok");
  394.                             strcpy(name, (char *)buff);
  395.                             expsect = ((buff[bufsize-1]<<8) | buff[bufsize-2]);
  396.                             BATCH = TRUE;
  397.                             YMDMBAT = TRUE;
  398.                             if (strlen(name) == 0)  /* check for no more files */
  399.                             {
  400.                                 flushin();          /* flush input */
  401.                                 sendbyte(ACK);      /* ACK the packet */
  402.                                 logit("YMODEM Batch Receive Complete\n");
  403.                                 tlogit("YMODEM Batch Receive Complete\n");
  404.                                 return (FALSE);
  405.                             }
  406.                             unixify(name);       /* make filename canonical */
  407.  
  408.                             /* read rest of YMODEM header */
  409.                             p = (char *)buff + strlen((char *)buff) + 1;
  410.                             if (DEBUG)
  411.                                 fprintf(LOGFP, "DEBUG: header info: %s\n", p);
  412.                             sscanf(p, "%ld%lo%o%o%d%ld%d", 
  413.                               &filelength, &modtime, &filemode, 
  414.                               &serial, &filesleft, &totalleft,
  415.                               &yfiletype);
  416.                             logitarg("YMODEM file name: %s\n", name);
  417.                             tlogitarg("YMODEM file name: %s\n", name);
  418.                             fileread = 0l;
  419.                             if (filelength)
  420.                             {
  421.                                 CHECKLENGTH = TRUE;
  422.                                 logitarg("YMODEM file size: %ld\n", filelength);
  423.                                 tlogitarg("YMODEM file size: %ld\n", filelength);
  424.                             }
  425.                             else if (expsect)
  426.                                 logitarg("YMODEM estimated file length %d sectors\n", expsect);
  427.                             if (modtime)
  428.                             {
  429.                                 logitarg("YMODEM file date: %s", ctime((time_t *)&modtime));
  430.                             }
  431.                             if (filemode)
  432.                                 logitarg("YMODEM file mode: %o\n", filemode);
  433.  
  434.                             if (filesleft)
  435.                             {
  436.                                 logitarg("YMODEM %d file(s) left to receive ", filesleft);
  437.                                 logitarg("containing %ld bytes\n", totalleft);
  438.                                 tlogitarg("YMODEM %d file(s) left to receive ", filesleft);
  439.                                 tlogitarg("containing %ld bytes\n", totalleft);
  440.                             }
  441.                             if (serial)
  442.                                 logitarg("YMODEM sender's serial number: %d\n", serial);
  443.                             if (yfiletype)
  444.                                 logitarg("YMODEM file type %d\n", yfiletype);
  445.  
  446.                             openflag = TRUE;    /* open the file for writing */
  447.                             if ((fd = creat(name, CREATMODE)) < 0)
  448.                             {
  449.                                 sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
  450.                                 error("Can't create file for receive", TRUE);
  451.                             }
  452.                             if (!YMODEMG)
  453.                                 {
  454.                                 flushin();        /* flush the input stream */
  455.                                 sendbyte(ACK);        /* ACK the filename packet */
  456.                                 }
  457.                             /* do initial handshake to start file transfer */
  458.                             if (YMODEMG)
  459.                                 sendbyte(GCHR);
  460.                             else if (CRCMODE) 
  461.                             {
  462.                                 sendbyte(CRCCHR);
  463.                                 if (LONGPACK)
  464.                                     sendbyte(KCHR);
  465.                             }
  466.                             else
  467.                                 sendbyte(NAK);
  468.                             firstwait = WAITFIRST;  /* reset waiting time */
  469.                         }
  470.  
  471.                         else                /* bad filename checksum */
  472.                         {
  473.                             logit("checksum error on filename sector\n");
  474.                             tlogit("checksum error on filename sector\n");
  475.                             errorflag = TRUE;
  476.                             if (YMODEMG)
  477.                                 fatalerror = TRUE;
  478.                         }
  479.                     }
  480.                     else
  481.                     {
  482.                         logit("Timeout while reading filename packet\n");
  483.                         tlogit("Timeout while reading filename packet\n");
  484.                         errorflag = TRUE;
  485.                         if (YMODEMG)
  486.                             fatalerror = TRUE;
  487.                     }
  488.                 }
  489.  
  490.                 else if (sectcurr == sectnum)   /* duplicate sector? */
  491.                 {  
  492.                     logitarg("Duplicate sector %s flushed\n", sectdisp(recvsectcnt,bufsize,0));
  493.                     tlogitarg("Duplicate sector %s flushed\n", sectdisp(recvsectcnt,bufsize,0));
  494.                     if (YMODEMG)
  495.                         {
  496.                         errorflag = TRUE;
  497.                         fatalerror = TRUE;
  498.                         }
  499.                     else
  500.                         {
  501.                         flushin();                  /* REALLY flush input */
  502.                         while(readbyte(1) != TIMEOUT)
  503.                             ;
  504.                         sendbyte(ACK);
  505.                         }
  506.                 }
  507.                 else                /* no, real phase error */
  508.                 {
  509.                     logitarg("Phase Error - Expected packet is %s\n", sectdisp(recvsectcnt,bufsize,1));
  510.                     tlogitarg("Phase Error - Expected packet is %s\n", sectdisp(recvsectcnt,bufsize,1));
  511.                     errorflag = TRUE;
  512.                     fatalerror = TRUE;
  513.                 }
  514.             }
  515.         }
  516.  
  517.         else        /* bad packet number checksum */
  518.         {  
  519.             logitarg("Header Sector Number Error on Sector %s\n", sectdisp(recvsectcnt, bufsize,1));
  520.             tlogitarg("Header Sector Number Error on Sector %s\n", sectdisp(recvsectcnt, bufsize,1));
  521.             errorflag = TRUE;
  522.             if (YMODEMG)
  523.                 fatalerror = TRUE;
  524.         }
  525.  
  526.     }           /* END reading packet loop */
  527.  
  528.     if (errorflag && !fatalerror && recvsectcnt != 0)   /* Handle errors */
  529.     {  
  530.         errors++;
  531.  
  532.         if (errors >= ERRORMAX)     /* over error limit? */
  533.             fatalerror = TRUE;
  534.         else                        /* flush input and NAK the packet */
  535.         {
  536.             flushin();
  537.             while (readbyte(2) != TIMEOUT)  /* wait for line to settle */
  538.                 ;
  539.             sendbyte(NAK);
  540.         }
  541.     }
  542.  
  543.     if (recvsectcnt == 0 && errorflag && !fatalerror && firstchar != EOT)     /* handle startup handshake */
  544.     {
  545.         sterrors++;
  546.  
  547.         if (sterrors >= STERRORMAX)
  548.             fatalerror = TRUE;
  549.  
  550.         else if (CRCMODE && MDM7BAT && !BATCH)
  551.             sendbyte(NAK);
  552.         
  553.         else if (CRCMODE && sterrors == CRCSWMAX && !YMDMBAT)
  554.         {
  555.             CRCMODE = FALSE;
  556.             logit("Sender not accepting CRC request, changing to checksum\n");
  557.             tlogit("Sender not accepting CRC request, changing to checksum\n");
  558.             sendbyte(NAK);
  559.         }
  560.  
  561.         else if (!CRCMODE && sterrors == CRCSWMAX && !YMDMBAT)
  562.         {
  563.             CRCMODE = TRUE;
  564.             logit("Sender not accepting checksum request, changing to CRC\n");
  565.             tlogit("Sender not accepting checksum request, changing to CRC\n");
  566.             sendbyte(CRCCHR);
  567.             if (LONGPACK && !MDM7BAT)
  568.                 sendbyte(KCHR);
  569.         }
  570.  
  571.         else if (YMODEMG)
  572.             sendbyte(GCHR);
  573.  
  574.         else if (CRCMODE)
  575.             {
  576.             sendbyte(CRCCHR);
  577.             if (LONGPACK && !MDM7BAT)
  578.                 sendbyte(KCHR);
  579.             }
  580.  
  581.         else
  582.             sendbyte(NAK);
  583.     }
  584. }
  585. while ((firstchar != EOT) && !fatalerror);   /* end of MAIN Do-While */
  586.  
  587. if ((firstchar == EOT) && !fatalerror)  /* normal exit? */
  588. {
  589.     if (openflag)       /* close the file */
  590.         close(fd);
  591.     sendbyte(ACK);      /* ACK the EOT */
  592.     logit("Receive Complete\n");
  593.     tlogit("Receive Complete\n");
  594.     if (LOGFLAG)
  595.         prtime (recvsectcnt, time((time_t *) 0) - start, LOGFP);
  596.     if (TIPFLAG)
  597.         prtime (recvsectcnt, time((time_t *) 0) - start, stderr);
  598.  
  599.     if (openflag && modtime)   /* set file modification time */
  600.     {
  601.         timep[0] = time((time_t *) 0);
  602.         timep[1] = modtime;
  603.         utime(name, timep);
  604.     }
  605.  
  606.     if (BATCH)          /* send appropriate return code */
  607.         return(TRUE);
  608.     else
  609.         return(FALSE);
  610. }
  611. else                /* no, error exit */
  612. { 
  613.     if (openflag)
  614.     {
  615.         sendbyte(CAN); sendbyte(CAN); sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
  616.         close(fd);
  617.         unlink(name);
  618.         flushin();
  619.         while (readbyte(2) != TIMEOUT)  /* wait for line to settle */
  620.             ;
  621.         error("ABORTED -- Too Many Errors -- Deleting File", TRUE);
  622.     }
  623.     else if (recvsectcnt != 0)
  624.         {
  625.         sendbyte(CAN); sendbyte(CAN); sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
  626.         flushin();
  627.         while (readbyte(2) != TIMEOUT)  /* wait for line to settle */
  628.             ;
  629.         error("ABORTED -- Too Many Errors", TRUE);
  630.         }
  631.     else
  632.         {
  633.         flushin();
  634.         while (readbyte(2) != TIMEOUT)  /* wait for line to settle */
  635.             ;
  636.         error("ABORTED -- Remote system is not responding", TRUE);
  637.         }
  638.  
  639. }
  640.  
  641. return(FALSE);
  642. }
  643.