home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / Dloads / OTHERUTI / WWIV412S.ZIP / SRRCV.C < prev    next >
C/C++ Source or Header  |  1990-07-26  |  9KB  |  390 lines

  1. /*****************************************************************************
  2.  
  3.                 WWIV Version 4
  4.               Copyright (C) 1988 by Wayne Bell
  5.  
  6. Distribution of the source code for WWIV, in any form, modified or unmodified,
  7. without PRIOR, WRITTEN APPROVAL by the author, is expressly prohibited.
  8. Distribution of compiled versions of WWIV is limited to copies compiled BY
  9. THE AUTHOR.  Distribution of any copies of WWIV not compiled by the author
  10. is expressly prohibited.
  11.  
  12.  
  13. *****************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vardec.h"
  18. #include "fcns.h"
  19. #include <string.h>
  20. #include <io.h>
  21. #include <stdio.h>
  22. #include <sys\stat.h>
  23. #include <fcntl.h>
  24. #include <time.h>
  25. #include <dos.h>
  26. #include <math.h>
  27. #include <stdlib.h>
  28.  
  29. extern userrec thisuser;
  30. extern int hangup,usernum,incom,numextrn,high_speed;
  31. extern unsigned char checksum;
  32. extern unsigned short crc;
  33. extern char curspeed[81];
  34. extern unsigned int modem_speed,com_speed;
  35. extern configrec syscfg;
  36. extern long timezone;
  37. extern float batchtime;
  38. extern batchrec *batch;
  39. extern int numbatch,numbatchdl;
  40. extern externalrec *externs;
  41. extern configrec syscfg;
  42. extern int checkext[81];
  43.  
  44.  
  45. char modemkey(int *tout)
  46. {
  47.   double d1;
  48.   char ch;
  49.  
  50.   if (comhit()) {
  51.     ch=get1c();
  52.     calc_CRC(ch);
  53.     return(ch);
  54.   }
  55.   if (*tout)
  56.     return(0);
  57.   d1=timer();
  58.   while ((fabs(timer()-d1)<0.5) && (!comhit()) && (!hangup)) {
  59.     checkhangup();
  60.   }
  61.   if (comhit()) {
  62.     ch=get1c();
  63.     calc_CRC(ch);
  64.     return(ch);
  65.   }
  66.   *tout=1;
  67.   return(0);
  68. }
  69.  
  70.  
  71.  
  72. int receive_block(char *b, unsigned char *bln, int ucrc)
  73. {
  74.   int i,i1,bs,cerr,abort,err,tout,cc1;
  75.   unsigned char ch,bn,bn1,cs1;
  76.  
  77.   abort=0;
  78.   ch=gettimeout(5.0,&abort);
  79.   err=0;
  80.   if (abort)
  81.     return(6);
  82.   tout=0;
  83.   if (ch==0x81) {
  84.     bn=modemkey(&tout);
  85.     bn1=modemkey(&tout);
  86.     if ((bn ^ bn1)==0xff) {
  87.       b[0]=bn;
  88.       *bln=bn;
  89.       return(8);
  90.     } else
  91.       return(3);
  92.   } else
  93.     if (ch==1) {
  94.       bn=modemkey(&tout);
  95.       bn1=modemkey(&tout);
  96.       if ((bn ^ bn1)!=0xff)
  97.         err=3;
  98.       *bln=bn;
  99.       crc=0;
  100.       checksum=0;
  101.       for (i=0; (i<128) && (!hangup); i++)
  102.         b[i]=modemkey(&tout);
  103.       if ((!ucrc) && (!hangup)) {
  104.         cs1=checksum;
  105.         bn1=modemkey(&tout);
  106.         if (bn1!=cs1) {
  107.           err=2;
  108.         }
  109.       } else if (!hangup) {
  110.         cc1=crc;
  111.         bn=modemkey(&tout);
  112.         bn1=modemkey(&tout);
  113.         if ((bn!=(unsigned char)(cc1 >> 8)) || (bn1!=(unsigned char)(cc1 & 0x00ff)))
  114.           err=2;
  115.       }
  116.       if (tout)
  117.         return(7);
  118.       return(err);
  119.     } else
  120.       if (ch==2) {
  121.         bn=modemkey(&tout);
  122.         bn1=modemkey(&tout);
  123.         crc=0;
  124.         checksum=0;
  125.         if ((bn ^ bn1)!=0xff)
  126.           err=3;
  127.         *bln=bn;
  128.         for (i=0; (i<1024) && (!hangup); i++)
  129.           b[i]=modemkey(&tout);
  130.         if ((!ucrc) && (!hangup)){
  131.           cs1=checksum;
  132.           bn1=modemkey(&tout);
  133.           if (bn1!=cs1)
  134.             err=2;
  135.         } else if (!hangup) {
  136.           cc1=crc;
  137.           bn=modemkey(&tout);
  138.           bn1=modemkey(&tout);
  139.           if ((bn!=(unsigned char)(cc1 >> 8)) || (bn1!=(unsigned char)(cc1 & 0x00ff)))
  140.             err=2;
  141.         }
  142.         if (tout)
  143.           return(7);
  144.         if (err==0)
  145.           return(1);
  146.         else
  147.           return(err);
  148.       } else
  149.         if (ch==24) {
  150.           return(4);
  151.         } else
  152.           if (ch==4) {
  153.             return(5);
  154.           } else
  155.             if (ch==0)
  156.               return(7);
  157.              else
  158.               return(9);
  159. }
  160.  
  161.  
  162. void xymodem_receive(char *fn, char *ft, int *received, int ucrc)
  163. {
  164.   char b[1025],x[81],x1[20],ch;
  165.   unsigned char bln;
  166.   unsigned int bn;
  167.   int done,ok,lastcan,lasteot,terr,cerr;
  168.   long pos,reallen,filedatetime,lx;
  169.   int f,i,i1,i2,i3,ox,oy;
  170.   double tpb;
  171.   struct ftime ff;
  172.   struct date d;
  173.   struct time t;
  174.   double d1;
  175.  
  176.   unlink(fn);
  177.   f=open(fn,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  178.   ok=1;
  179.   lastcan=0;
  180.   lasteot=0;
  181.   terr=0;
  182.   cerr=0;
  183.   if (f<0) {
  184.     nl();
  185.     nl();
  186.     pl("DOS error - Can't create file.");
  187.     nl();
  188.     *received=0;
  189.     return;
  190.   }
  191.   pos=0L;
  192.   reallen=0L;
  193.   filedatetime=0L;
  194.   bn=1;
  195.   done=0;
  196.   tpb=(12.656) / ((double) (modem_speed));
  197.   nl();
  198.   pl("> Ready to receive, ^X to abort.");
  199.   ox=wherex();
  200.   oy=wherey();
  201.   movecsr(52,0);
  202.   outs("│ Filename :               ");
  203.   movecsr(52,1);
  204.   outs("│ Xfer Time:               ");
  205.   movecsr(52,2);
  206.   outs("│ File Size:               ");
  207.   movecsr(52,3);
  208.   outs("│ Cur Block: 1 - 1k        ");
  209.   movecsr(52,4);
  210.   outs("│ Consec Errors: 0         ");
  211.   movecsr(52,5);
  212.   outs("│ Total Errors : 0         ");
  213.   movecsr(52,6);
  214.   outs("└──────────────────────────");
  215.   movecsr(65,0);
  216.   outs(stripfn(fn));
  217.   i=0;
  218.   do {
  219.     if (i++>9) {
  220.       *received=0;
  221.       return;
  222.     }
  223.     if (ucrc)
  224.       outcomch('C');
  225.     else
  226.       outcomch(21);
  227.  
  228.     d1=timer();
  229.     while ((fabs(timer()-d1)<10.0) && (!comhit()) && (!hangup)) {
  230.       checkhangup();
  231.       if (kbhitb()) {
  232.         ch=getchd();
  233.         if (ch==0)
  234.           getchd();
  235.         else
  236.           if (ch==27) {
  237.             done=1;
  238.             ok=0;
  239.           }
  240.       }
  241.     }
  242.   } while(!comhit() && !hangup);
  243.  
  244.   do {
  245.     bln=255;
  246.     itoa(cerr,x,10);
  247.     strcat(x,"  ");
  248.     movecsr(69,4);
  249.     outs(x);
  250.     itoa(terr,x,10);
  251.     movecsr(69,5);
  252.     outs(x);
  253.     ltoa(pos/128 +1,x,10);
  254.     strcat(x," - ");
  255.     ltoa(pos/1024 +1,x1,10);
  256.     strcat(x,x1);
  257.     strcat(x,"k");
  258.     movecsr(65,3);
  259.     outs(x);
  260.     if (reallen) {
  261.       movecsr(65,1);
  262.       outs(ctim(((double)(reallen-pos))*tpb));
  263.     }
  264.  
  265.     i=receive_block(b,&bln,ucrc);
  266.     if ((i==0) || (i==1)) {
  267.       if ((bln==0) && (pos==0L)) {
  268.         i1=strlen(b)+1;
  269.     i3=i1;
  270.     while ((b[i3]>='0') && (b[i3]<='9') && ((i3-i1)<15))
  271.       x[i3-i1]=b[i3++];
  272.     x[i3-i1]=0;
  273.         reallen=atol(x);
  274.         ltoa((reallen+127)/128,x,10);
  275.         strcat(x," - ");
  276.         ltoa((reallen+1023)/1024,x1,10);
  277.         strcat(x,x1);
  278.         strcat(x,"k");
  279.         movecsr(65,2);
  280.         outs(x);
  281.         while ((b[i1]!=32) && (i1<64))
  282.           ++i1;
  283.         if (b[i1]==32) {
  284.           ++i1;
  285.           while ((b[i1]>='0') && (b[i1]<='8')) {
  286.             filedatetime=(filedatetime*8) + ((long) (b[i1]-'0'));
  287.             ++i1;
  288.           }
  289.           i1+=timezone+5*60*60;
  290.         }
  291.         outcomch(6);
  292.       } else
  293.         if ((bn & 0x00ff)==(unsigned int)bln) {
  294.           lseek(f,pos, SEEK_SET);
  295.           lx=reallen-pos;
  296.           if (i==0)
  297.             i2=128;
  298.           else
  299.             i2=1024;
  300.           if ((((long) i2)>lx) && (reallen))
  301.             i2=(int) lx;
  302.           write(f,(void *)b,i2);
  303.           pos += (long)i2;
  304.           ++bn;
  305.           outcomch(6);
  306.         } else
  307.           if (((bn-1) & 0x00ff)==(unsigned int)bln) {
  308.             outcomch(6);
  309.           } else {
  310.             outcomch(24);
  311.             ok=0;
  312.             done=1;
  313.           }
  314.       cerr=0;
  315.     } else
  316.       if ((i==2) || (i==7) || (i==3)) {
  317.         if ((pos==0L) && (reallen==0L) && (ucrc))
  318.           outcomch('C');
  319.         else
  320.           outcomch(21);
  321.         ++cerr;
  322.         ++terr;
  323.         if (cerr>9) {
  324.           outcomch(24);
  325.           ok=0;
  326.           done=1;
  327.         }
  328.       } else
  329.         if (i==6) {
  330.           ok=0;
  331.           done=1;
  332.           outcomch(24);
  333.         } else
  334.           if (i==4) {
  335.             if (lastcan) {
  336.               ok=0;
  337.               done=1;
  338.               outcomch(6);
  339.             } else {
  340.               lastcan=1;
  341.               outcomch(21);
  342.             }
  343.           } else
  344.             if (i==5) {
  345.           lasteot=1;
  346.               if (lasteot) {
  347.                 done=1;
  348.                 outcomch(6);
  349.               } else {
  350.                 lasteot=1;
  351.                 outcomch(21);
  352.               }
  353.             } else
  354.               if (i==8) {
  355.                 *ft=bln;
  356.                 outcomch(6);
  357.                 cerr=0;
  358.               } else
  359.                 if (i==9)
  360.                   dump();
  361.     if (i!=4)
  362.       lastcan=0;
  363.     if (i!=5)
  364.       lasteot=0;
  365.   } while ((!hangup) && (!done));
  366.   movecsr(ox,oy);
  367.   if (ok) {
  368.     if (filedatetime) {
  369.       unixtodos(filedatetime,&d,&t);
  370.       if (d.da_year>=1980) {
  371.         ff.ft_min=t.ti_min;
  372.         ff.ft_hour=t.ti_hour;
  373.         ff.ft_tsec=t.ti_sec/2;
  374.         ff.ft_year=d.da_year-1980;
  375.         ff.ft_day=d.da_day;
  376.         ff.ft_month=d.da_mon;
  377.         setftime(f,&ff);
  378.       }
  379.     }
  380.     close(f);
  381.     *received=1;
  382.   } else {
  383.     close(f);
  384.     unlink(fn);
  385.     *received=0;
  386.   }
  387. }
  388.  
  389.  
  390.