home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / WWIV2.ZIP / SRRCV.C < prev    next >
C/C++ Source or Header  |  1992-12-03  |  8KB  |  367 lines
  1. /*****************************************************************************
  2.  
  3.                 WWIV Version 4
  4.                     Copyright (C) 1988-1993 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 "vars.h"
  18.  
  19. #pragma hdrstop
  20.  
  21. #include <math.h>
  22.  
  23.  
  24. char modemkey(int *tout)
  25. {
  26.   double d1;
  27.   char ch;
  28.  
  29.   if (comhit()) {
  30.     ch=get1c();
  31.     calc_CRC(ch);
  32.     return(ch);
  33.   }
  34.   if (*tout)
  35.     return(0);
  36.   d1=timer();
  37.   while ((fabs(timer()-d1)<0.5) && (!comhit()) && (!hangup)) {
  38.     checkhangup();
  39.   }
  40.   if (comhit()) {
  41.     ch=get1c();
  42.     calc_CRC(ch);
  43.     return(ch);
  44.   }
  45.   *tout=1;
  46.   return(0);
  47. }
  48.  
  49.  
  50.  
  51. int receive_block(char *b, unsigned char *bln, int ucrc)
  52. {
  53.   int i,i1,bs,cerr,abort,err,tout,cc1;
  54.   unsigned char ch,bn,bn1,cs1;
  55.  
  56.   abort=0;
  57.   ch=gettimeout(5.0,&abort);
  58.   err=0;
  59.   if (abort)
  60.     return(6);
  61.   tout=0;
  62.   if (ch==0x81) {
  63.     bn=modemkey(&tout);
  64.     bn1=modemkey(&tout);
  65.     if ((bn ^ bn1)==0xff) {
  66.       b[0]=bn;
  67.       *bln=bn;
  68.       return(8);
  69.     } else
  70.       return(3);
  71.   } else
  72.     if (ch==1) {
  73.       bn=modemkey(&tout);
  74.       bn1=modemkey(&tout);
  75.       if ((bn ^ bn1)!=0xff)
  76.         err=3;
  77.       *bln=bn;
  78.       crc=0;
  79.       checksum=0;
  80.       for (i=0; (i<128) && (!hangup); i++)
  81.         b[i]=modemkey(&tout);
  82.       if ((!ucrc) && (!hangup)) {
  83.         cs1=checksum;
  84.         bn1=modemkey(&tout);
  85.         if (bn1!=cs1) {
  86.           err=2;
  87.         }
  88.       } else if (!hangup) {
  89.         cc1=crc;
  90.         bn=modemkey(&tout);
  91.         bn1=modemkey(&tout);
  92.         if ((bn!=(unsigned char)(cc1 >> 8)) || (bn1!=(unsigned char)(cc1 & 0x00ff)))
  93.           err=2;
  94.       }
  95.       if (tout)
  96.         return(7);
  97.       return(err);
  98.     } else
  99.       if (ch==2) {
  100.         bn=modemkey(&tout);
  101.         bn1=modemkey(&tout);
  102.         crc=0;
  103.         checksum=0;
  104.         if ((bn ^ bn1)!=0xff)
  105.           err=3;
  106.         *bln=bn;
  107.         for (i=0; (i<1024) && (!hangup); i++)
  108.           b[i]=modemkey(&tout);
  109.         if ((!ucrc) && (!hangup)){
  110.           cs1=checksum;
  111.           bn1=modemkey(&tout);
  112.           if (bn1!=cs1)
  113.             err=2;
  114.         } else if (!hangup) {
  115.           cc1=crc;
  116.           bn=modemkey(&tout);
  117.           bn1=modemkey(&tout);
  118.           if ((bn!=(unsigned char)(cc1 >> 8)) || (bn1!=(unsigned char)(cc1 & 0x00ff)))
  119.             err=2;
  120.         }
  121.         if (tout)
  122.           return(7);
  123.         if (err==0)
  124.           return(1);
  125.         else
  126.           return(err);
  127.       } else
  128.         if (ch==24) {
  129.           return(4);
  130.         } else
  131.           if (ch==4) {
  132.             return(5);
  133.           } else
  134.             if (ch==0)
  135.               return(7);
  136.              else
  137.               return(9);
  138. }
  139.  
  140.  
  141. void xymodem_receive(char *fn, char *ft, int *received, int ucrc)
  142. {
  143.   char b[1025],x[81],x1[20],ch;
  144.   unsigned char bln;
  145.   unsigned int bn;
  146.   int done,ok,lastcan,lasteot,terr,cerr;
  147.   long pos,reallen,filedatetime,lx;
  148.   int f,i,i1,i2,i3,ox,oy;
  149.   double tpb;
  150.   struct ftime ff;
  151.   struct date d;
  152.   struct time t;
  153.   double d1;
  154.  
  155.   unlink(fn);
  156.   f=open(fn,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  157.   ok=1;
  158.   lastcan=0;
  159.   lasteot=0;
  160.   terr=0;
  161.   cerr=0;
  162.   if (f<0) {
  163.     nl();
  164.     nl();
  165.     pl(get_string(908));
  166.     nl();
  167.     *received=0;
  168.     return;
  169.   }
  170.   pos=0L;
  171.   reallen=0L;
  172.   filedatetime=0L;
  173.   bn=1;
  174.   done=0;
  175.   tpb=(12.656) / ((double) (modem_speed));
  176.   nl();
  177.   pl(get_string(887));
  178.   ox=wherex();
  179.   oy=wherey();
  180.   movecsr(52,0);
  181.   outs(get_stringx(1,67));
  182.   movecsr(52,1);
  183.   outs(get_stringx(1,68));
  184.   movecsr(52,2);
  185.   outs(get_stringx(1,69));
  186.   movecsr(52,3);
  187.   outs(get_stringx(1,70));
  188.   movecsr(52,4);
  189.   outs(get_stringx(1,71));
  190.   movecsr(52,5);
  191.   outs(get_stringx(1,72));
  192.   movecsr(52,6);
  193.   outs(get_stringx(1,73));
  194.   movecsr(65,0);
  195.   outs(stripfn(fn));
  196.   i=0;
  197.   do {
  198.     if (i++>9) {
  199.       *received=0;
  200.       close(f);
  201.       unlink(fn);
  202.       return;
  203.     }
  204.     if (ucrc)
  205.       outcomch('C');
  206.     else
  207.       outcomch(21);
  208.  
  209.     d1=timer();
  210.     while ((fabs(timer()-d1)<10.0) && (!comhit()) && (!hangup)) {
  211.       checkhangup();
  212.       if (kbhitb()) {
  213.         ch=getchd();
  214.         if (ch==0)
  215.           getchd();
  216.         else
  217.           if (ch==27) {
  218.             done=1;
  219.             ok=0;
  220.           }
  221.       }
  222.     }
  223.   } while(!comhit() && !hangup);
  224.  
  225.   do {
  226.     bln=255;
  227.     itoa(cerr,x,10);
  228.     strcat(x,"  ");
  229.     movecsr(69,4);
  230.     outs(x);
  231.     itoa(terr,x,10);
  232.     movecsr(69,5);
  233.     outs(x);
  234.     sprintf(x,"%ld - %ldk",
  235.       pos/128+1,
  236.       pos/1024+1);
  237.     movecsr(65,3);
  238.     outs(x);
  239.     if (reallen) {
  240.       movecsr(65,1);
  241.       outs(ctim(((double)(reallen-pos))*tpb));
  242.     }
  243.  
  244.     i=receive_block(b,&bln,ucrc);
  245.     if ((i==0) || (i==1)) {
  246.       if ((bln==0) && (pos==0L)) {
  247.         i1=strlen(b)+1;
  248.     i3=i1;
  249.     while ((b[i3]>='0') && (b[i3]<='9') && ((i3-i1)<15))
  250.       x[i3-i1]=b[i3++];
  251.     x[i3-i1]=0;
  252.         reallen=atol(x);
  253.         sprintf(x,"%ld - %ldk",
  254.           (reallen+127)/128,
  255.           (reallen+1023)/1024);
  256.         movecsr(65,2);
  257.         outs(x);
  258.         while ((b[i1]!=32) && (i1<64))
  259.           ++i1;
  260.         if (b[i1]==32) {
  261.           ++i1;
  262.           while ((b[i1]>='0') && (b[i1]<='8')) {
  263.             filedatetime=(filedatetime*8) + ((long) (b[i1]-'0'));
  264.             ++i1;
  265.           }
  266.           i1+=timezone+5*60*60;
  267.         }
  268.         outcomch(6);
  269.       } else
  270.         if ((bn & 0x00ff)==(unsigned int)bln) {
  271.           lseek(f,pos, SEEK_SET);
  272.           lx=reallen-pos;
  273.           if (i==0)
  274.             i2=128;
  275.           else
  276.             i2=1024;
  277.           if ((((long) i2)>lx) && (reallen))
  278.             i2=(int) lx;
  279.           write(f,(void *)b,i2);
  280.           pos += (long)i2;
  281.           ++bn;
  282.           outcomch(6);
  283.         } else
  284.           if (((bn-1) & 0x00ff)==(unsigned int)bln) {
  285.             outcomch(6);
  286.           } else {
  287.             outcomch(24);
  288.             ok=0;
  289.             done=1;
  290.           }
  291.       cerr=0;
  292.     } else
  293.       if ((i==2) || (i==7) || (i==3)) {
  294.         if ((pos==0L) && (reallen==0L) && (ucrc))
  295.           outcomch('C');
  296.         else
  297.           outcomch(21);
  298.         ++cerr;
  299.         ++terr;
  300.         if (cerr>9) {
  301.           outcomch(24);
  302.           ok=0;
  303.           done=1;
  304.         }
  305.       } else
  306.         if (i==6) {
  307.           ok=0;
  308.           done=1;
  309.           outcomch(24);
  310.         } else
  311.           if (i==4) {
  312.             if (lastcan) {
  313.               ok=0;
  314.               done=1;
  315.               outcomch(6);
  316.             } else {
  317.               lastcan=1;
  318.               outcomch(21);
  319.             }
  320.           } else
  321.             if (i==5) {
  322.           lasteot=1;
  323.               if (lasteot) {
  324.                 done=1;
  325.                 outcomch(6);
  326.               } else {
  327.                 lasteot=1;
  328.                 outcomch(21);
  329.               }
  330.             } else
  331.               if (i==8) {
  332.                 *ft=bln;
  333.                 outcomch(6);
  334.                 cerr=0;
  335.               } else
  336.                 if (i==9)
  337.                   dump();
  338.     if (i!=4)
  339.       lastcan=0;
  340.     if (i!=5)
  341.       lasteot=0;
  342.   } while ((!hangup) && (!done));
  343.   movecsr(ox,oy);
  344.   if (ok) {
  345.     if (filedatetime) {
  346.       unixtodos(filedatetime,&d,&t);
  347.       if (d.da_year>=1980) {
  348.         ff.ft_min=t.ti_min;
  349.         ff.ft_hour=t.ti_hour;
  350.         ff.ft_tsec=t.ti_sec/2;
  351.         ff.ft_year=d.da_year-1980;
  352.         ff.ft_day=d.da_day;
  353.         ff.ft_month=d.da_mon;
  354.         setftime(f,&ff);
  355.       }
  356.     }
  357.     close(f);
  358.     *received=1;
  359.   } else {
  360.     close(f);
  361.     unlink(fn);
  362.     *received=0;
  363.   }
  364. }
  365.  
  366.  
  367.