home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / windows / winkerm.zip / WINRCV.C < prev    next >
C/C++ Source or Header  |  1986-10-10  |  9KB  |  380 lines
  1.  
  2. /***************************************************************************
  3. *
  4. * Winrcv
  5. *
  6. * Receive file using Kermit protocol
  7. *
  8. ***************************************************************************/
  9. #include <windows.h>
  10. #include "winkrm.h"
  11.      
  12. /* These are local functions */
  13. int NEAR recsw();
  14. char NEAR rinit();
  15. char NEAR rfile();
  16. char NEAR rdata();
  17. void NEAR bufemp(char*, int);
  18.      
  19. /***************************************************************************
  20. *
  21. * receive
  22. *
  23. * Prepare to receive a file.
  24. *
  25. * Entry: None
  26. *
  27. * Exit:  Files sent by remote Kermit received and saved to disk.
  28. *
  29. ***************************************************************************/
  30. receive()
  31. {
  32.      
  33.     RECT rect;        /* used to measure location on screen of window */
  34.     char RXTitle[20];    /* title to receive popup window */
  35.      
  36.     eol = CR;                /* eol for outgoing packet */
  37.     quote = MYQUOTE;            /* standard quote */
  38.     pad = MYPAD;            /* no padding */
  39.     padchar = MYPCHAR;            /* if any, use this */
  40.      
  41.     StateStr[0] = '\0';            /* set up popup window params */
  42.     PacketStr[0] = '\0';
  43.     filnam1[0] = '\0';
  44.      
  45.     debug = FALSE;            /* these should be menu items */
  46.     pktdeb = FALSE;
  47.     ThisState = RECEIVESTATE;
  48.      
  49.     GetWindowRect(hKermWnd, (LPRECT)&rect);    /* get window size */
  50.     strcpy(RXTitle, szWinTitle);    /* initialize the popup headings */
  51.     strcat(RXTitle," Receive");
  52.      
  53. /* Create a popup window */
  54.     hRXWnd = CreateWindow((LPSTR)szAppName,
  55.                         (LPSTR)RXTitle,
  56.             WS_POPUP | WS_CAPTION,
  57.             5*CharWidth + rect.left,
  58.             4*CharHeight + rect.top,
  59.             21*CharWidth,
  60.             5*CharHeight - CharHeight/2,
  61.                         (HWND)hKermWnd,
  62.                         (HMENU)NULL,
  63.                         (HANDLE)hInst,
  64.                         (LPSTR)NULL
  65.                         );
  66.      
  67.     SetMenu(hRXWnd, (HANDLE)NULL);    /* kill off any menus */
  68.     ShowWindow(hRXWnd, SHOW_OPENNOACTIVATE);    /* show the popup */
  69.     UpdateWindow(hRXWnd);
  70.      
  71.     if (pktdeb) {            /* debugging stuff */
  72.     dpfp = fopen("PACKET.LOG", "wb");
  73.         if (dpfp == NULL)
  74.             MessageBox(hKermWnd, (LPSTR)"Cannot open packet debug file",
  75.                 (LPSTR)szWinTitle, MB_OK | MB_ICONEXCLAMATION);
  76.     }
  77.      
  78.     if (recsw() == FALSE)        /* go do it */
  79.     printmsg("Receive failed");
  80.     else
  81.     printmsg("Receive Done");
  82.      
  83.     if (pktdeb)
  84.         fclose(dpfp);
  85.      
  86.     DestroyWindow(hRXWnd);        /* get rid of popup */
  87.      
  88.     if (CurrentState == RECEIVESTATE)    /* simulate a mouse selection */
  89.     SendMessage(hKermWnd, WM_COMMAND, RECEIVESTATE, (LONG)NULL);
  90.      
  91. }
  92.      
  93. /***************************************************************************
  94. *
  95. * recsw
  96. *
  97. * Receive state switcher.
  98. *
  99. * Entry: None.
  100. *
  101. * Exit: Succesful transfer or abort.
  102. *
  103. ***************************************************************************/
  104. int NEAR recsw()
  105. {
  106.      
  107.     state = 'R';
  108.     n = 0;
  109.     numtry = 0;
  110.     PacketCount = 0;
  111.      
  112.     while (TRUE) {
  113.     if (debug)
  114.         printf("recsw state %c\n", state);
  115. /* prepare info for the receive popup window and send it out */
  116.         StateStr[0] = state;
  117.     strcpy(PacketStr, itoa(PacketCount, PacketStr,10));
  118.     hRXWndDC = GetDC(hRXWnd);
  119.     TextOut(hRXWndDC,9*CharWidth,2,(LPSTR)StateStr,1);
  120.     TextOut(hRXWndDC,10*CharWidth,CharHeight+2,(LPSTR)PacketStr,strlen(PacketStr));
  121.     ReleaseDC(hRXWnd, hRXWndDC);
  122.     PacketCount += 1;
  123.      
  124.     switch (state) {
  125.         case 'R':
  126.         state = rinit();    /* get init packet */
  127.         break;
  128.         case 'F':
  129.         state = rfile();    /* get file name */
  130.         break;
  131.         case 'D':
  132.         state = rdata();    /* get data */
  133.         break;
  134.         case 'C':
  135.         return (TRUE);        /* all done */
  136.         case 'A':
  137.         return (FALSE);        /* abort */
  138.     }
  139.     }
  140. }
  141.      
  142. /*
  143.  *
  144.  * For more detail on the following routines, see the file KERMIT.C
  145.  * as published in the Kermit protocol manual from Columbia University.
  146.  *
  147.  */
  148.      
  149. /***************************************************************************
  150. *
  151. * rinit
  152. *
  153. * Receive send init paramters from remote Kermit
  154. *
  155. * Entry: None.
  156. *
  157. * Exit: Next state.
  158. *
  159. ***************************************************************************/
  160. char NEAR rinit()
  161. {
  162.     int len, num;
  163.      
  164.     if (numtry++ > MAXTRY)
  165.     return('A');
  166.      
  167.     switch(rpack(&len, &num, packet)) {
  168.     case 'S':
  169.         rpar(packet);
  170.         spar(packet);
  171.         spack('Y', n, 6, packet);
  172.         oldtry = numtry;
  173.         numtry = 0;
  174.         n = (n+1) % 64;
  175.         return('F');
  176.      
  177.     case 'E':
  178.         prerrpkt(recpkt);
  179.         return('A');
  180.     
  181.     case FALSE:
  182.         spack('N', n, 0, 0);
  183.         return(state);
  184.      
  185.     default:
  186.         return('A');
  187.     }
  188. }
  189.      
  190. /***************************************************************************
  191. *
  192. * rfile
  193. *
  194. * Get a file name from remote Kermit.
  195. *
  196. * Entry: None
  197. *
  198. * Exit:  Next state.
  199. *
  200. ***************************************************************************/
  201. char NEAR rfile()
  202. {
  203.      
  204.     int num, len;
  205.      
  206.     if (numtry++ > MAXTRY)
  207.     return('A');
  208.      
  209.     switch(rpack(&len,&num,packet)) {
  210.     case 'S':
  211.         if (oldtry++ > MAXTRY)
  212.         return('A');
  213.         if (num == ((n == 0) ? 63:n-1)) {
  214.         spar(packet);
  215.         spack('Y', num, 6, packet);
  216.         numtry = 0;
  217.         return(state);
  218.         }
  219.         else
  220.         return('A');
  221.      
  222.     case 'Z':
  223.         if (oldtry++ > MAXTRY)
  224.         return('A');
  225.         if (num == ((n == 0) ? 63:n-1)) {
  226.         spack('Y', num, 0,0);
  227.         numtry = 0;
  228.         return(state);
  229.         }
  230.         else
  231.         return('A');
  232.      
  233.     case 'F':
  234.         if (num != n)
  235.         return('A');
  236.         strncpy(filnam1, packet, NAMESIZE);
  237.         hRXWndDC = GetDC(hRXWnd);
  238.         TextOut(hRXWndDC,8*CharWidth,2*CharHeight+2,
  239.             (LPSTR)"            ", 12);
  240.         TextOut(hRXWndDC,8*CharWidth,2*CharHeight+2,(LPSTR)filnam1,strlen(filnam1));
  241.         ReleaseDC(hRXWnd, hRXWndDC);
  242.      
  243.         if ((fp = fopen(filnam1, "wb")) == NULL) {
  244.             MessageBox(hKermWnd, (LPSTR)"Cannot open to receive",
  245.             (LPSTR)filnam1, MB_OK | MB_ICONEXCLAMATION);
  246.         return('A');
  247.         }
  248.         else {
  249.         /* display the name */
  250.         }
  251.         spack('Y', n, 0, 0);
  252.         oldtry = numtry;
  253.         numtry = 0;
  254.         n = (n+1)%64;
  255.         return ('D');
  256.      
  257.     case 'B':
  258.         if (num != n)
  259.         return('A');
  260.         spack('Y',n,0,0);
  261.         return('C');
  262.      
  263.     case 'E':
  264.         prerrpkt(recpkt);
  265.         return('A');
  266.      
  267.     case FALSE:
  268.         spack('N', n, 0, 0);
  269.         return(state);
  270.      
  271.     default:
  272.         return('A');
  273.     }
  274. }
  275.      
  276. /***************************************************************************
  277. *
  278. * rdata
  279. *
  280. * Receive data from remote Kermit.
  281. *
  282. * Entry: None.
  283. *
  284. * Exit: Next state.
  285. *
  286. ***************************************************************************/
  287. char NEAR rdata()
  288. {
  289.      
  290.     int num, len;
  291.      
  292.     if (numtry++ > MAXTRY)
  293.     return('A');
  294.      
  295.     switch(rpack(&len,&num,packet)) {
  296.     case 'D':
  297.         if (num != n) {
  298.         if (oldtry++ > MAXTRY)
  299.             return('A');
  300.         if (num == ((n == 0) ? 63:n-1)) {
  301.             spack('Y', num, 6, packet);
  302.             numtry = 0;
  303.             return(state);
  304.             }
  305.         else
  306.             return('A');
  307.         }
  308.         bufemp(packet, len);
  309.         spack('Y', n, 0 ,0);
  310.         oldtry = numtry;
  311.         numtry = 0;
  312.         n = (n+1) % 64;
  313.         return('D');
  314.      
  315.     case 'F':
  316.         if (oldtry++ > MAXTRY)
  317.         return('A');
  318.         if (num == ((n == 0) ? 63:n-1)) {
  319.         spack('Y', num, 0, 0);
  320.         numtry = 0;
  321.         return(state);
  322.         }
  323.         else
  324.         return('A');
  325.      
  326.     case 'Z':
  327.         if (num != n)
  328.         return('A');
  329.         spack('Y', n, 0, 0);
  330.         fclose(fp);
  331.         n = (n+1)%64;
  332.         return('F');
  333.      
  334.     case 'E':
  335.         prerrpkt(recpkt);
  336.         return('A');
  337.      
  338.     case FALSE:
  339.         spack('N', n, 0, 0);
  340.         return(state);
  341.      
  342.     default:
  343.         return('A');
  344.     }
  345. }
  346.      
  347. /***************************************************************************
  348. *
  349. * bufemp
  350. *
  351. * Empty a data buffer receive from remote Kermit to disk file.
  352. *
  353. * Entry: buffer and its length.
  354. *
  355. * Exit: buffer written to file.
  356. *
  357. * Notes: This routine needs to handle any error conditions returned
  358. *     by putc.  As it is now, it will continue to write characters
  359. *     to a full disk.  In addition, it is not suitable for a binary
  360. *     file transfer.
  361. *
  362. ***************************************************************************/
  363. void NEAR bufemp(buffer, len)
  364. char buffer[];
  365. int len;
  366. {
  367.     int i;
  368.     char t;
  369.      
  370.     for (i = 0; i < len; i++) {
  371.     t = buffer[i];
  372.     if (t == MYQUOTE) {
  373.         t = buffer[++i];
  374.         if ((t & 0177) != MYQUOTE)
  375.         t = ctl(t);
  376.     }
  377.     putc(t, fp);
  378.     }
  379. }    
  380.