home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / winsock / wsftp32 / ws_main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  67.6 KB  |  2,089 lines
  1. /***************************************************************************
  2.   Windows Sockets FTP Client Application
  3.  
  4.   Written by:
  5.       John A. Junod             Internet: <junodj@gordon-emh2.army.mil>
  6.       267 Hillwood Street                 <zj8549@trotter.usma.edu>
  7.       Martinez, GA 30907      Compuserve: 72321,366 
  8.  
  9.   This program executable and all source code is released into the public
  10.   domain.  It would be nice (but is not required) to give me a little 
  11.   credit for any use of this code.
  12.  
  13.   The user interface for this FTP client is designed with the novice FTP user
  14.   in mind.  Usage should (??) be obvious with the possible exception of the
  15.   the transfer mode; ascii, binary or l8.  All controls are standard Windows
  16.   controls.
  17.  
  18.   My development and testing was all completed at home on two 386 PC's using
  19.   the Trumpet Windows Sockets DLL Alpha 15 with NCSA Telnet and WinQVT/Net 2.6
  20.   and 3.9 as the remote host.  Source code may be compiled with Borland C++
  21.   in large mode.
  22.  
  23.   Some code concepts and names are based on code that is copyright by the
  24.   Regents of the University of California or code published in UNIX Network
  25.   Programming by W. Richard Stevens or code in WATTCP or other public sources.
  26.   The rest is based on my knowledge of Windows programming and my 
  27.   interpretation of RFC 969 and the Windows Sockets API version 1.1.
  28.  
  29.   THE INFORMATION AND CODE PROVIDED IS PROVIDED AS IS WITHOUT WARRANTY 
  30.   OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  31.   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
  32.   PURPOSE. IN NO EVENT SHALL JOHN A. JUNOD BE LIABLE FOR ANY DAMAGES 
  33.   WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS 
  34.   OF BUSINESS PROFITS OR SPECIAL DAMAGES, EVEN IF JOHN A. JUNOD HAS BEEN 
  35.   ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  36.  
  37. *****************************************************************************/
  38. // modified extensively by l kahn for windows nt and multi threading
  39. // turn off list windows for mirror operation
  40.  
  41. //----------------------
  42. #include "ws_glob.h"
  43. #include "WS_ftp.H"
  44. #include "version.h"
  45. //----------------------
  46. #include <stdarg.h>
  47. #include <ctype.h>
  48. #include <shellapi.h>
  49. #include <stdlib.h>
  50. #include <string.h>
  51.  
  52.  // lgk new debugging variable
  53. BOOLEAN DEBUGGING_ON = FALSE;
  54.  
  55. int selects[256];
  56. extern char szInitDir[];
  57. HBRUSH hbrGray1,hbrGray2,hbrWhite;
  58. extern HWND hWndDbg;
  59. BOOLEAN connectpending = FALSE;
  60. volatile BOOLEAN aborttimerexpired = FALSE;
  61.  
  62.  
  63. // lgk new stuff for multiple threads
  64. extern int check_command_line();
  65. CRITICAL_SECTION busy_variable;
  66. BOOLEAN busy = FALSE;
  67. HWND globalhWnd;
  68. WPARAM globalwParam;
  69. DWORD threadid;
  70. HANDLE threadhandle;
  71.  
  72. #ifndef USEASYNC
  73. SubProcessAsync(HWND hWnd,UINT Message,WPARAM wParam,LPARAM lParam)
  74. {
  75.   return(FALSE);
  76. }
  77. #endif
  78.  
  79. // lgk new routine to get the local search string
  80.  
  81. extern char *localsearchstring();
  82.      
  83.  
  84. int VerifyDelete(LPSTR fname)
  85. {
  86.   wsprintf(szDlgPrompt,"Are you sure you want to delete \"%s\"?",fname);
  87.   return(MessageBox(hWndMain,szDlgPrompt,"Verify Deletion",MB_YESNO)==IDYES);
  88. }
  89.   
  90.  VOID CALLBACK myaborttimerproc(wind,msg,idevent,systime)
  91.  HWND wind;
  92.  UINT msg;
  93.  UINT idevent;
  94.  DWORD systime;
  95.  {
  96.         KillTimer(wind,21);
  97.         aborttimerexpired = TRUE;
  98.  }
  99.  
  100. void turnofflistwindows()
  101.  
  102.  
  103.  {
  104.  
  105.   BOOL rv;
  106.  
  107.   rv = ShowWindow(hLbxLDir,SW_HIDE);
  108.   rv = ShowWindow(hLbxLFiles,SW_HIDE);
  109.   rv = ShowWindow(hLbxRDir,SW_HIDE);
  110.   rv = ShowWindow(hLbxRFiles,SW_HIDE);
  111.  
  112.   EnableWindow(hBtnLCWD,FALSE);
  113.   EnableWindow(hBtnLMKD,FALSE);
  114.   EnableWindow(hBtnLRMD,FALSE);
  115.   EnableWindow(hLdirBox,FALSE);
  116.   EnableWindow(hRdirBox,FALSE);
  117.   EnableWindow(hBtnLDisplay,FALSE);
  118.   EnableWindow(hBtnLREN,FALSE);
  119.   EnableWindow(hBtnLDEL,FALSE);
  120.  
  121.   
  122.  }
  123.  
  124.  void turnonlistwindows()
  125.  
  126.  {
  127.  
  128.  BOOL rv;
  129.  
  130.   rv = ShowWindow(hLbxLDir,SW_SHOW);
  131.   rv = ShowWindow(hLbxLFiles,SW_SHOW);
  132.   rv = ShowWindow(hLbxRDir,SW_SHOW);
  133.   rv = ShowWindow(hLbxRFiles,SW_SHOW);
  134.  
  135.   EnableWindow(hBtnLCWD,TRUE);
  136.   EnableWindow(hBtnLMKD,TRUE);
  137.   EnableWindow(hBtnLRMD,TRUE);
  138.   EnableWindow(hLdirBox,TRUE);
  139.   EnableWindow(hRdirBox,TRUE);
  140.   EnableWindow(hBtnLDisplay,TRUE);
  141.   EnableWindow(hBtnLREN,TRUE);
  142.   EnableWindow(hBtnLDEL,TRUE);
  143.  
  144.  }
  145.   
  146. void MakeLower(LPSTR str) {
  147.   while(*str) {
  148.     *str=tolower(*str);
  149.     str++;
  150.   }
  151. }
  152. // lgk function to set busy variable so that we don't get collisions
  153. void set_busy(invalue)
  154.  BOOLEAN invalue;
  155.    {
  156.      EnterCriticalSection(&busy_variable);
  157.      busy = invalue;
  158.      LeaveCriticalSection(&busy_variable);
  159.    }
  160.    
  161. BOOLEAN check_busy()
  162.    {
  163.      BOOLEAN rvalue;
  164.       
  165.      EnterCriticalSection(&busy_variable);
  166.      rvalue = busy;
  167.      LeaveCriticalSection(&busy_variable);
  168.      return rvalue;
  169.    }
  170.  
  171.   /* ------------------------------------------------------------------------------------------- */
  172.      
  173. // lgk new functions that will run in a thread
  174.  
  175. DWORD local_to_remote_fx()
  176. {
  177.     
  178.   int nIndex,nRC;
  179.  
  180.             u_char tmp[300];
  181.             char localname[256];
  182.             char remotename[256];
  183.             int count;
  184.  
  185.             count=SendMessage(hLbxLFiles,
  186.                       LB_GETSELITEMS,256,(LPARAM)(int far *)selects);
  187.             if(count>0 && count!=LB_ERR)
  188.               {
  189.                EnableWindow(hBtnAbort,TRUE);
  190.              for(nIndex=0;nIndex<count;nIndex++)
  191.                  {
  192.                 SendMessage(hLbxLFiles,LB_GETTEXT,selects[nIndex],
  193.                                  (LONG)localname);
  194.                 lstrcpy(remotename,localname);
  195.                 if(bInteractive) 
  196.                   StdInput(remotename,"Enter remote file name for %s:",localname);
  197.                 wsprintf(tmp,"sending %s as %s (%u of %u)",localname,remotename,nIndex+1,count);
  198.                 SendMessage(hTxtStatus,WM_SETTEXT,0,(LPARAM)tmp);
  199.                 wsprintf(tmp,"STOR %s",remotename);
  200.                 nRC=SendFile(ctrl_socket,tmp,(LPSTR)localname,fType);
  201.                 if(nRC!=2) break;
  202.                  }  
  203.               GetRemoteDirForWnd(globalhWnd);
  204.           }
  205. set_busy(FALSE);
  206. EnableWindow(hBtnAbort,FALSE);
  207. return 0;
  208. }
  209.  
  210.  
  211. /* ---------------------------------------------------------------------------------------------- */
  212.      
  213. // lgk new functions that will run in a thread
  214. // other version that does not update directory
  215.  
  216. DWORD local_to_remote_fx2()
  217. {
  218.     
  219.   int nIndex,nRC;
  220.  
  221.             u_char tmp[300];
  222.             char localname[256];
  223.             char remotename[256];
  224.             int count;
  225.  
  226.             count=SendMessage(hLbxLFiles,
  227.                       LB_GETSELITEMS,256,(LPARAM)(int far *)selects);
  228.             if(count>0 && count!=LB_ERR)
  229.               {
  230.                EnableWindow(hBtnAbort,TRUE);
  231.              for(nIndex=0;nIndex<count;nIndex++)
  232.                  {
  233.                 SendMessage(hLbxLFiles,LB_GETTEXT,selects[nIndex],
  234.                                  (LONG)localname);
  235.                 lstrcpy(remotename,localname);
  236.                 if(bInteractive) 
  237.                   StdInput(remotename,"Enter remote file name for %s:",localname);
  238.                 wsprintf(tmp,"sending %s as %s (%u of %u)",localname,remotename,nIndex+1,count);
  239.                 SendMessage(hTxtStatus,WM_SETTEXT,0,(LPARAM)tmp);
  240.                 wsprintf(tmp,"STOR %s",remotename);
  241.                 nRC=SendFile(ctrl_socket,tmp,localname,fType);
  242.                 if(nRC!=2) break;
  243.                  }  
  244.           }
  245. set_busy(FALSE);
  246. EnableWindow(hBtnAbort,FALSE);
  247. return 0;
  248. }
  249.  
  250.  
  251. /* ---------------------------------------------------------------------------------------------- */
  252.  
  253.  
  254. DWORD local_to_remote_mirror_fx()
  255. {
  256.   char localdirname[256];
  257.   int count,count2, count3;
  258.   char ldirsave[_MAX_PATH];
  259.   char rdirsave[_MAX_PATH];
  260.   int nIndex,nRC;
  261.   int lselects[256];
  262.  
  263.   /* different from renmote to local we must skip the drives here which show up as local dirs ie [-a-]
  264.     also make sure selected strings dont have the drive in it ..
  265.     */
  266.  
  267.  
  268.  
  269.             count=SendMessage(hLbxLDir,LB_GETSELITEMS,
  270.                                  256,(LPARAM)(int *)lselects);
  271.             if(count>0 && count!=LB_ERR)
  272.               {
  273.  
  274.                 /* Get the current working directory: */
  275.                 if (_getcwd(ldirsave, _MAX_PATH ) != NULL )
  276.                   {
  277.                   SendMessage(hTxtRDir,WM_GETTEXT,_MAX_PATH,(LONG)rdirsave);
  278.                   EnableWindow(hBtnAbort,TRUE);
  279.                   turnofflistwindows();
  280.                   for(nIndex=0;nIndex<count;nIndex++)
  281.                    {
  282.                      // skip the first one if selected as it is bogus
  283.                      if (lselects[nIndex] != 0)
  284.                        {
  285.                          SendMessage(hLbxLDir,LB_GETTEXT,lselects[nIndex],
  286.                                  (LONG)localdirname);
  287.  
  288.                           if (strncmp(localdirname,"[-",2) != 0)
  289.                             {
  290.                              
  291.                            nRC=DoMKD(ctrl_socket,localdirname);
  292.                            if (nRC == 550)
  293.                             {
  294.                               DoPrintf("Warning failure creating remote directory %s, directory may already exist.",
  295.                                        localdirname);
  296.                             }
  297.                            else if (nRC == FTP_ERROR)
  298.                             {
  299.                              DoPrintf("Aborting since remote mkdir failed...ecode = %d",nRC);
  300.                              set_busy(FALSE);
  301.                              EnableWindow(hBtnAbort,FALSE);
  302.                              turnonlistwindows();
  303.                              return 0;
  304.                            }
  305.                            else
  306.                             {
  307.                               // now change to the dir
  308.                             ++totaldirscreated;
  309.                             DoPrintf("Created remote directory %s",localdirname);
  310.                             nRC=DoCWD(ctrl_socket,localdirname);
  311.                             if(nRC==FTP_COMPLETE)
  312.                               {
  313.                                GetRemoteDirForWnd(globalhWnd);
  314.                    --totalfilestransfered;
  315.                        }
  316.                             else
  317.                              {
  318.                                DoPrintf("Aborting since remote cwd failed...");
  319.                                set_busy(FALSE);
  320.                                EnableWindow(hBtnAbort,FALSE);
  321.                                turnonlistwindows();
  322.                                return 0;
  323.                             }
  324.                             }
  325.                             
  326.                          chdir(localdirname);
  327.                          GetLocalDirForWnd(globalhWnd);
  328.                
  329.                   // now change the remote directory also and do a list
  330.  
  331.              // now go through everything in the file window and get it
  332.  
  333.             count2=SendMessage(hLbxLFiles,LB_GETCOUNT,0,0);
  334.             if(count2>0 && count2!=LB_ERR)
  335.               {
  336.  
  337.                count3=SendMessage(hLbxLFiles,LB_SELITEMRANGEEX,
  338.                                  (WPARAM)0 ,(LPARAM) count2);
  339.                   if (count3 != LB_ERR)
  340.                     {
  341.                       // now that this worked ok call the function to get them
  342.                       set_busy(TRUE);
  343.                       local_to_remote_fx2();
  344.                       set_busy(FALSE);
  345.                     }
  346.                   else
  347.                     {
  348.                     DoPrintf("Aborting since local file selection failed...");
  349.                     set_busy(FALSE);
  350.                     EnableWindow(hBtnAbort,FALSE);
  351.                     turnonlistwindows();
  352.                     return 0;
  353.             }  
  354.               }
  355.               
  356.              // now we got all files in this directory so select all dirs
  357.              // under it and recall ourself
  358.              // then cd back to orig directory so we can continue
  359.              // with next dir at this level
  360.              // ignore first dir which is always ..
  361.  
  362.             count2=SendMessage(hLbxLDir,LB_GETCOUNT,0,0);
  363.             if(count2>1 && count2!=LB_ERR)
  364.               {
  365.  
  366.                count3=SendMessage(hLbxLDir,LB_SELITEMRANGEEX,
  367.                                  (WPARAM)1 ,(LPARAM) count2);
  368.                   if (count3 != LB_ERR)
  369.                     {
  370.                       // now that this worked ok call ourself to recurse
  371.                       local_to_remote_mirror_fx();
  372.                     }
  373.               }
  374.              
  375.             // now cd back to the original dir so we can continue
  376.             chdir(ldirsave);
  377.             GetLocalDirForWnd(globalhWnd);
  378.             nRC=DoCWD(ctrl_socket,rdirsave);
  379.             if(nRC==FTP_COMPLETE)
  380.               {
  381.                GetRemoteDirForWnd(globalhWnd);
  382.            --totalfilestransfered; // decrement twice for both remote operations
  383.  
  384.               }
  385.               else
  386.                {
  387.                 DoPrintf("Aborting since remote cwd failed...");
  388.                 set_busy(FALSE);
  389.                 EnableWindow(hBtnAbort,FALSE);
  390.                 turnonlistwindows();
  391.                 return 0;
  392.                }
  393.  
  394.                 } // skip drive selection
  395.                } // skip bogus .. selection
  396.             // continue the loop
  397.                    } // end of loop
  398.                   } // end of getcwd ok
  399.           } // end of count ok
  400.  
  401. // print the totals
  402.  if (totalfilestransfered > 0)
  403.     { 
  404.       char str1[30];
  405.       char str2[30];
  406.  
  407.      if (totalfilestransfered == 1)
  408.       strcpy(str1,"file");
  409.       else strcpy(str1,"files");
  410.      
  411.      if (totaldirscreated == 1)
  412.        strcpy(str2,"directory");
  413.        else strcpy(str2,"directories");
  414.        
  415.      DoPrintf("%ld %s tranmitted, %ld %s created.",
  416.       totalfilestransfered,str1,totaldirscreated,str2);
  417.     }
  418. if (totaltimefortransfer > 0)
  419.   {
  420.     DoPrintf("%ld bytes tranfered in %.2f seconds, (%3.2fKbytes/sec).",
  421.       totalbytestransfered,(float)totaltimefortransfer,
  422.       (float)totalbytestransfered/1024.000/(float)totaltimefortransfer);
  423.   }
  424.  
  425. mirrorinprogress = FALSE;
  426. set_busy(FALSE);
  427. EnableWindow(hBtnAbort,FALSE);
  428. turnonlistwindows();
  429. return 0;
  430.  
  431. }
  432.  
  433. /* -------------------------------------------------------------- */
  434. DWORD remote_mkdir_fx()
  435. {
  436.     
  437.   int nRC;
  438.  
  439.   if(StdInput(NULL,"Enter new remote directory name:"))
  440.   if((nRC=DoMKD(ctrl_socket,szDlgEdit))==FTP_COMPLETE)
  441.     {
  442.       GetRemoteDirForWnd(globalhWnd);
  443.     }
  444. set_busy(FALSE);
  445. EnableWindow(hBtnAbort,FALSE);
  446. return 0;
  447. }
  448.  
  449. /* ---------------------------------------- */
  450. DWORD remote_rmdir_fx()
  451. {
  452.     
  453.   int nIndex,nRC;
  454.  
  455.   if((nIndex=SendMessage(hLbxRDir,LB_GETCURSEL,0,0L))!=LB_ERR)
  456.     {
  457.        SendMessage(hLbxRDir,LB_GETTEXT,nIndex,(LONG)szMsgBuf2);
  458.        if(VerifyDelete(szMsgBuf2))
  459.          if((nRC=DoRMD(ctrl_socket,szMsgBuf2))==FTP_COMPLETE)
  460.                   GetRemoteDirForWnd(globalhWnd);
  461.     }
  462. set_busy(FALSE);
  463. EnableWindow(hBtnAbort,FALSE);
  464. return 0;
  465. } 
  466.  
  467. /* ------------------------------------------------- */
  468.  
  469. DWORD remote_list_fx()
  470.   {
  471.     
  472.    GetRemoteDirForWnd(globalhWnd);
  473. EnableWindow(hBtnAbort,TRUE);
  474. set_busy(FALSE);
  475. EnableWindow(hBtnAbort,FALSE);
  476. return 0;
  477. }
  478.  
  479. /* ----------------------------- */
  480. DWORD remote_delete_fx()
  481. {
  482.     
  483.   int nIndex,nRC;
  484.  
  485.   int count;
  486.   count=SendMessage(hLbxRFiles,LB_GETSELITEMS,
  487.                                  256,(LPARAM)(int far *)selects);
  488.   if(count>0 && count!=LB_ERR)
  489.       {
  490.        for(nIndex=0;nIndex<count;nIndex++)
  491.          {
  492.            SendMessage(hLbxRFiles,LB_GETTEXT,selects[nIndex],
  493.                                  (LONG)szDlgEdit);
  494.            if(VerifyDelete(szDlgEdit))
  495.              nRC=DoDELE(ctrl_socket,szDlgEdit);
  496.          } 
  497.               GetRemoteDirForWnd(globalhWnd);
  498.       }
  499. set_busy(FALSE);
  500. EnableWindow(hBtnAbort,FALSE);
  501. return 0;
  502. }
  503.  
  504. /* ----------------------------------------------------------- */
  505. DWORD remote_rename_fx()
  506. {
  507.     
  508.   int nIndex,nRC;
  509.  
  510.           if((nIndex=SendMessage(hLbxRFiles,LB_GETCURSEL,
  511.                 0,0L))!=LB_ERR)
  512.           {
  513.             SendMessage(hLbxRFiles,LB_GETTEXT,nIndex,
  514.                                (LONG)szMsgBuf2);
  515.                 if(StdInput(NULL,"Enter new name for \"%s\":",szMsgBuf2))
  516.                 if((nRC=command(ctrl_socket,"RNFR %s",szMsgBuf2))==FTP_CONTINUE)
  517.                 if((nRC=command(ctrl_socket,"RNTO %s",szDlgEdit))==FTP_COMPLETE)
  518.                     GetRemoteDirForWnd(globalhWnd);
  519.           }
  520. set_busy(FALSE);
  521. EnableWindow(hBtnAbort,FALSE);
  522. return 0;
  523. }
  524.  
  525. /* ----------------------------------------------------------- */
  526. DWORD remote_cwd_fx()
  527. {
  528.     
  529.   int nIndex,nRC;
  530.   int count = SendMessage(hLbxRDir,LB_GETSELCOUNT,
  531.                 0,0L);
  532.   int count2 = 0;
  533.             
  534.             if (count > 1)
  535.               {
  536.                 DoPrintf("Only 1 directory can be selected for the chdir operation.");
  537.               }  
  538.             else if (count == 0)
  539.              { // ok case so ask
  540.  
  541.               if(StdInput(NULL,"Enter remote directory name:")) 
  542.               if((nRC=DoCWD((SOCKET)ctrl_socket,szDlgEdit))==FTP_COMPLETE)
  543.               GetRemoteDirForWnd(globalhWnd);
  544.  
  545.          }
  546.              
  547.            else // (count == 1)
  548.              {
  549.                 count2=SendMessage(hLbxRDir,
  550.                       LB_GETSELITEMS,256,(LPARAM)(int far *)selects);
  551.                  nIndex = selects[0];
  552.  
  553.                 EnableWindow(hBtnAbort,TRUE);
  554.                 SendMessage(hLbxRDir,LB_GETTEXT,nIndex,
  555.                                       (LONG)szMsgBuf2);
  556.                 nRC=DoCWD(ctrl_socket,szMsgBuf2);
  557.                 if(nRC==FTP_COMPLETE)
  558.                    GetRemoteDirForWnd(globalhWnd);
  559.              }
  560.  
  561.   
  562. set_busy(FALSE);
  563. EnableWindow(hBtnAbort,FALSE);
  564. return 0;
  565. }
  566.  
  567. /* ----------------------------------------------------------- */
  568. DWORD remote_to_local_fx()
  569. {
  570.   char tmp[300];
  571.   char remotename[256];
  572.   char localname[256];
  573.   char shortname[80];
  574.   int count;
  575.  
  576.   int nIndex,nRC;
  577.  
  578.             count=SendMessage(hLbxRFiles,LB_GETSELITEMS,
  579.                                  256,(LPARAM)(int far *)selects);
  580.             if(count>0 && count!=LB_ERR)
  581.               {
  582.                   EnableWindow(hBtnAbort,TRUE);
  583.                   for(nIndex=0;nIndex<count;nIndex++)
  584.                    {
  585.                      SendMessage(hLbxRFiles,LB_GETTEXT,selects[nIndex],
  586.                                  (LONG)remotename);
  587.                      MakeLocalName(localname,shortname,remotename);
  588.                      if(bInteractive)
  589.                       StdInput(localname,"Enter local file name for %s:",remotename);
  590.                       DoPrintf("receiving %s as %s (%u of %u)",
  591.                          remotename,localname,nIndex+1,count);
  592.                       wsprintf(tmp,"RETR %s",remotename);
  593.                       nRC=RetrieveFile((SOCKET)ctrl_socket,(LPSTR)tmp,
  594.                         (LPSTR)localname,(LPSTR)shortname,fType);
  595.                 if(nRC==2)
  596.                   SendMessage(hLbxLFiles,LB_ADDSTRING,0,(LONG)remotename);
  597.                 else
  598.                   break;
  599.                    } // end of loop
  600.                  GetLocalDirForWnd(globalhWnd);
  601.               } // end of count ok
  602.  
  603. set_busy(FALSE);
  604. EnableWindow(hBtnAbort,FALSE);
  605. return 0;
  606. }
  607.  
  608. /* ----------------------------------------------------------- */
  609.  
  610. /* zzz
  611.   instead of getting files here we need to change the local directory
  612.   to the newly created directory and then change the remote dir to
  613.   each selected dir and then do a remote list then select all items in
  614.   the files window and call remote_to_local for each
  615.   then select all items except .. in the dir window and recall this function
  616.   to recurse through that directory
  617. */
  618.  
  619. DWORD remote_to_local_mirror_fx()
  620. {
  621.   char remotedirname[256];
  622.   int count,count2, count3;
  623.   char ldirsave[_MAX_PATH];
  624.   char rdirsave[_MAX_PATH];
  625.   int nIndex,nRC;
  626.   int lselects[256];
  627.  
  628.            count=SendMessage(hLbxRDir,LB_GETSELITEMS,
  629.                                  256,(LPARAM)(int *)lselects);
  630.             if(count>0 && count!=LB_ERR)
  631.               {
  632.  
  633.                 /* Get the current working directory: */
  634.                 if (_getcwd(ldirsave, _MAX_PATH ) != NULL )
  635.                   {
  636.                   SendMessage(hTxtRDir,WM_GETTEXT,_MAX_PATH,(LONG)rdirsave);
  637.                   EnableWindow(hBtnAbort,TRUE);
  638.                   turnofflistwindows();
  639.                   for(nIndex=0;nIndex<count;nIndex++)
  640.                    {
  641.                      // skip the first one if selected as it is bogus
  642.                      if (lselects[nIndex] != 0)
  643.                        {
  644.                          SendMessage(hLbxRDir,LB_GETTEXT,lselects[nIndex],
  645.                                  (LONG)remotedirname);
  646.                          if (mkdir(remotedirname) == 0)
  647.                            {
  648.                             DoPrintf("Created local directory %s",remotedirname);
  649.                             ++totaldirscreated;
  650.                            }
  651.                             
  652.                          chdir(remotedirname);
  653.                          GetLocalDirForWnd(globalhWnd);
  654.                
  655.                   // now change the remote directory also and do a list
  656.  
  657.                   nRC=DoCWD(ctrl_socket,remotedirname);
  658.                   if(nRC==FTP_COMPLETE)
  659.                      {
  660.                        GetRemoteDirForWnd(globalhWnd);
  661.                --totalfilestransfered;
  662.  
  663.                      }
  664.                   else
  665.                    {
  666.                     DoPrintf("Aborting since remote cwd failed...");
  667.                     set_busy(FALSE);
  668.                     EnableWindow(hBtnAbort,FALSE);
  669.                     turnonlistwindows();
  670.                     return 0;
  671.                    }
  672.  
  673.              // now go through everything in the file window and get it
  674.  
  675.             count2=SendMessage(hLbxRFiles,LB_GETCOUNT,0,0);
  676.             if(count2>0 && count2!=LB_ERR)
  677.               {
  678.  
  679.                count3=SendMessage(hLbxRFiles,LB_SELITEMRANGEEX,
  680.                                  (WPARAM)0 ,(LPARAM) count2);
  681.                   if (count3 != LB_ERR)
  682.                     {
  683.                       // now that this worked ok call the function to get them
  684.                       
  685.                       set_busy(TRUE);
  686.                       remote_to_local_fx();
  687.                       set_busy(FALSE);
  688.                     }
  689.                   else
  690.                     {
  691.                     DoPrintf("Aborting since remote file selection failed...");
  692.                     set_busy(FALSE);
  693.                     EnableWindow(hBtnAbort,FALSE);
  694.                     turnonlistwindows();
  695.                     return 0;
  696.             }  
  697.               }
  698.               
  699.              // now we got all files in this directory so select all dirs
  700.              // under it and recall ourself
  701.              // then cd back to orig directory so we can continue
  702.              // with next dir at this level
  703.              // ignore first dir which is always ..
  704.  
  705.             count2=SendMessage(hLbxRDir,LB_GETCOUNT,0,0);
  706.             if(count2>1 && count2!=LB_ERR)
  707.               {
  708.  
  709.                count3=SendMessage(hLbxRDir,LB_SELITEMRANGEEX,
  710.                                  (WPARAM)1 ,(LPARAM) count2);
  711.                   if (count3 != LB_ERR)
  712.                     {
  713.                       // now that this worked ok call ourself to recurse
  714.                       remote_to_local_mirror_fx();
  715.                     }
  716.               }
  717.              
  718.             // now cd back to the original dir so we can continue
  719.             chdir(ldirsave);
  720.             GetLocalDirForWnd(globalhWnd);
  721.             nRC=DoCWD(ctrl_socket,rdirsave);
  722.             if(nRC==FTP_COMPLETE)
  723.                { 
  724.                 GetRemoteDirForWnd(globalhWnd);
  725.                 --totalfilestransfered;
  726.  
  727.                }
  728.               else
  729.                {
  730.                 DoPrintf("Aborting since remote cwd failed...");
  731.                 set_busy(FALSE);
  732.                 EnableWindow(hBtnAbort,FALSE);
  733.                 turnonlistwindows();
  734.                 return 0;
  735.                }
  736.  
  737.                } // skip bogus .. selection
  738.             // continue the loop
  739.                    } // end of loop
  740.                  } // end of getcwd ok
  741.           } // end of count ok
  742.  
  743. // print the totals
  744.   if (totalfilestransfered > 0)
  745.     { 
  746.       char str1[30];
  747.       char str2[30];
  748.  
  749.      if (totalfilestransfered == 1)
  750.       strcpy(str1,"file");
  751.       else strcpy(str1,"files");
  752.      
  753.      if (totaldirscreated == 1)
  754.        strcpy(str2,"directory");
  755.        else strcpy(str2,"directories");
  756.        
  757.      DoPrintf("%ld %s tranmitted, %ld %s created.",
  758.       totalfilestransfered,str1,totaldirscreated,str2);
  759.     } 
  760. if (totaltimefortransfer > 0)
  761.   {
  762.     DoPrintf("%ld bytes received in %.2f seconds, (%3.2fKbytes/sec).",
  763.       totalbytestransfered,(float)totaltimefortransfer,
  764.       (float)totalbytestransfered/1024.000/(float)totaltimefortransfer);
  765.   }
  766.  
  767. mirrorinprogress = FALSE;
  768. set_busy(FALSE);
  769. EnableWindow(hBtnAbort,FALSE);
  770. turnonlistwindows();
  771. return 0;
  772.  
  773. }
  774.  
  775. /* --------------------------------------------------------- */
  776.  
  777.  
  778. DWORD remote_display_fx()
  779.  
  780. {
  781.     
  782.   int nIndex,nRC;
  783.  
  784.             char tmp[300];
  785.             char remotename[80];
  786.  
  787.             if((nIndex=SendMessage(hLbxRFiles,LB_GETCURSEL,
  788.                 0,0L))!=LB_ERR)
  789.             {
  790.                  SendMessage(hLbxRFiles,LB_GETTEXT,nIndex,
  791.                                  (LONG)remotename);
  792.                  wsprintf(tmp,"RETR %s",remotename);
  793.                  EnableWindow(hBtnAbort,TRUE);
  794.                  nRC=RetrieveFile((SOCKET)ctrl_socket,(LPSTR)tmp,
  795.                            (LPSTR)szTmp1File,(LPSTR)szTmp1File,TYPE_A);
  796.                  if(nRC==2)
  797.                    {
  798.                     wsprintf(szString,"%s %s",szViewer,szTmp1File);
  799.                     if(strchr(szTmp1File,'.')==NULL)
  800.                        strcat(szString,".");
  801.                     WinExec(szString,SW_SHOW);
  802.                    }
  803.                  GetLocalDirForWnd(globalhWnd);
  804.          }
  805. set_busy(FALSE);
  806. EnableWindow(hBtnAbort,FALSE);
  807. return 0;
  808. }
  809.  
  810.  
  811.  
  812. /* ----------------------------------------------------------- */
  813. DWORD connect_fx()
  814. {
  815.     
  816.   int nRC;
  817.   
  818.   connectpending = TRUE;
  819.  
  820.           if(ctrl_socket==INVALID_SOCKET)
  821.           {
  822.              EnableWindow(hBtnConnect,FALSE);
  823.              use_gateway=0;
  824.              nRC=DialogBox(hInst,(LPSTR)"DLG_HOST",globalhWnd,WS_HostMsgProc);
  825.              if(nRC)
  826.              {
  827.               EnableWindow(hBtnAbort,TRUE);
  828.               ctrl_socket=(SOCKET)DoConnect(szRemoteHost);
  829.               if(ctrl_socket!=INVALID_SOCKET)
  830.                 {
  831.                 if(szInitDir[0]!=0)
  832.                   DoCWD(ctrl_socket,szInitDir);
  833.                 }
  834.                else // didn't connect so renable button
  835.                  EnableWindow(hBtnConnect,TRUE);
  836.  
  837.                 if(LOWORD(globalwParam)==BTN_CONNECT)
  838.                   GetRemoteDirForWnd(globalhWnd);
  839.              } // ok nrc
  840.           }
  841.             else
  842.             SendMessage(hTxtStatus,WM_SETTEXT,0,(LPARAM)"Already connected");
  843. set_busy(FALSE);
  844. connectpending = FALSE;
  845. EnableWindow(hBtnAbort,FALSE);
  846. return 0;
  847. }
  848.           
  849. /* ---------------------------------------------------------- */
  850. DWORD drop_files_fx()
  851.  
  852. {
  853.     
  854.   int nRC;
  855.  
  856.          POINT pt;
  857.          WORD cFiles, a;
  858.          char szFile[256];
  859.          char szRemoteName[256];
  860.          u_char tmp[2300];
  861.          LPSTR lpszBaseName;
  862.  
  863.          DragQueryPoint((HANDLE) globalwParam, &pt);
  864.  
  865.          cFiles = DragQueryFile((HANDLE) globalwParam, 0xFFFF, (LPSTR) NULL, 0);
  866.          if(!bConnected)
  867.            DoPrintf("NOT CONNECTED!! File(s) ignored.");
  868.          else if(bCmdInProgress)
  869.            DoPrintf("We are already busy!! File(s) ignored.");
  870.          else
  871.            {
  872.            for(a = 0; a < cFiles; pt.y += 20, a++)
  873.             {
  874.              DragQueryFile((HANDLE) globalwParam, a, szFile, sizeof(szFile));
  875.              MakeLower(szFile);
  876.              if((lpszBaseName=strrchr(szFile,'\\'))!=NULL)
  877.               {
  878.                lstrcpy(szRemoteName,++lpszBaseName);
  879.                if(bInteractive) 
  880.                   StdInput(szRemoteName,"Enter remote file name for %s:",lpszBaseName);
  881.                EnableWindow(hBtnAbort,TRUE);
  882.                wsprintf(tmp,"sending %s as %s (%u of %u)",szFile,szRemoteName,a,cFiles);
  883.                SendMessage(hTxtStatus,WM_SETTEXT,0,(LPARAM)tmp);
  884.                wsprintf(tmp,"STOR %s",szRemoteName);
  885.                nRC=SendFile(ctrl_socket,tmp,szFile,fType);
  886.                if(nRC!=2) break;
  887.               }
  888.             } // end of loop
  889.            GetRemoteDirForWnd(globalhWnd);
  890.            } // end ok case
  891.          DragFinish((HANDLE) globalwParam);
  892.  
  893. set_busy(FALSE);
  894. EnableWindow(hBtnAbort,FALSE);
  895. return 0;
  896. }
  897.  
  898. /* -------------------------------------------- */
  899.       
  900. int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  901.                    LPSTR lpszCmdLine, int nCmdShow)
  902. {
  903.   MSG        msg;
  904.   int        nRc;
  905.   long       nWndunits;
  906.   int        nX;
  907.   int        nY;
  908.   int        nWidth;
  909.   int        nHeight;
  910.   int        err;
  911. //  HINSTANCE hWinSock;
  912.  
  913.   InitializeCriticalSection(&busy_variable);
  914.  
  915.   if (strstr(lpszCmdLine,"-d") != NULL)
  916.     {
  917.       // we want debugging
  918.       DEBUGGING_ON = TRUE;
  919.     }
  920.    
  921.   if ((err = WSAStartup((WORD)0x0101, &WSAData))!=0)  // register task with
  922.   {                                         // winsock tcp/ip API
  923.     MessageBox(NULL,ReturnWSError(err,NULL),"WS_FTP - WSAStartup",
  924.           MB_OK|MB_ICONEXCLAMATION);
  925.   } else {
  926.     strcpy(szAppName, "WS_FTP");
  927.     hInst = hInstance;
  928.  
  929.     if(!hPrevInstance)
  930.     {
  931.       // register window classes if first instance of application
  932.       if ((nRc = nCwRegisterClasses()) == -1)
  933.       {
  934.         // registering one of the windows failed
  935.         MessageBox((HWND)NULL, "Window creation failed",
  936.               NULL, MB_ICONEXCLAMATION);
  937.         return nRc;    
  938.       }
  939.     }
  940.  
  941.     // Create a device independant size and location
  942.     nWndunits = GetDialogBaseUnits();
  943.     nWndx = LOWORD(nWndunits);
  944.     nWndy = HIWORD(nWndunits);
  945.     nX = ((18 * nWndx) / 4);
  946.     nY = ((18 * nWndy) / 8);
  947.     nWidth = ((247 * nWndx) / 4);
  948.     nHeight = ((211 * nWndy) / 8);
  949.  
  950.     // create application's Main window
  951.     hWndMain = CreateWindow(
  952.       szAppName, "WinSock_FTP",
  953.       WS_CAPTION     | WS_SYSMENU    | WS_MINIMIZEBOX  |
  954.       WS_CLIPCHILDREN | WS_OVERLAPPED,
  955.       nX,nY, nWidth, nHeight,
  956.       (HWND)NULL, (HMENU)NULL, hInst,  NULL);
  957.  
  958.     if(hWndMain == (HWND)NULL)
  959.     {
  960.       MessageBox((HWND)NULL, "Error registering class",
  961.             NULL, MB_ICONEXCLAMATION);
  962.       return 2;
  963.     }
  964.  
  965.     ShowWindow(hWndMain, nCmdShow);         // display main window
  966.     GetLocalInfo();
  967.     if(bAutoStart)
  968.       PostMessage(hWndMain,WM_COMMAND,BTN_CONNECT,0L);
  969.  
  970.       // lgk now check if command line stuff
  971.       if (check_command_line() == 1)
  972.        { 
  973.        // use to exit here when not multi-threaded but now returns immediately
  974.        }
  975.         
  976.  
  977.     while(GetMessage(&msg, (HWND)NULL, 0, 0))     // Until WM_QUIT message
  978.     {
  979.     // lgk add extra code to check for carriage return in our dir boxes
  980.       if (msg.message == WM_KEYDOWN     &&
  981.           msg.wParam == VK_RETURN)
  982.           // ok we have it now do it
  983.         {
  984.         
  985.          if (msg.hwnd == hLdirBox)
  986.          {
  987.            GetLocalDirForWnd(msg.hwnd);
  988.          }
  989.          else
  990.           if (msg.hwnd == hRdirBox)
  991.              {
  992.            if (check_busy())
  993.                DoPrintf("Currently Busy with another remote operation ...\n");
  994.             else
  995.               {
  996.                 globalhWnd = msg.hwnd;
  997.                 globalwParam = msg.wParam;
  998.                 set_busy(TRUE);
  999.                // create thread and start remote list fx
  1000.                 threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_list_fx,NULL,0,&threadid);
  1001.               }               
  1002.           }
  1003.    
  1004.       }
  1005.       
  1006.       TranslateMessage(&msg);
  1007.       DispatchMessage(&msg);
  1008.     }
  1009.     WSACleanup();
  1010.     ReleaseDisplayMem();
  1011.  
  1012.     // Do clean up before exiting from the application
  1013.     CwUnRegisterClasses();
  1014.   }
  1015.   return msg.wParam;
  1016. } //  End of WinMain
  1017.  
  1018.  
  1019. int StdInput(LPSTR dest,LPSTR fmt,...)
  1020. {
  1021.   va_list args;
  1022. //  FARPROC lpfnMsgProc;
  1023.   int  iRetCode;
  1024.  
  1025.   va_start(args,fmt);
  1026.   vsprintf(szDlgPrompt,fmt,args);
  1027.   va_end(args);
  1028.   if (dest != NULL) // lgk fix for nt caused access violation
  1029.    lstrcpy(szDlgEdit,dest);
  1030.   
  1031.   else szDlgEdit[0] = 0;
  1032.  
  1033. //  lpfnMsgProc=MakeProcInstance((FARPROC)WS_InputMsgProc,hInst);
  1034.     iRetCode=DialogBox(hInst,(LPSTR)"DLG_INPUT",hWndMain,WS_InputMsgProc);
  1035. //  FreeProcInstance(lpfnMsgProc);
  1036.   if(iRetCode && dest) 
  1037.   
  1038.   // lgk fix here since if dest was null we cannot copy to it
  1039.    if (dest != NULL)
  1040.     lstrcpy(dest,szDlgEdit);
  1041.   
  1042.   return(iRetCode);
  1043. }
  1044.  
  1045. int StdInputPassword(LPSTR dest,LPSTR fmt,...)
  1046. {
  1047.   va_list args;
  1048.   //FARPROC lpfnMsgProc;
  1049.   int  iRetCode;
  1050.  
  1051.   va_start(args,fmt);
  1052.   vsprintf(szDlgPrompt,fmt,args);
  1053.   va_end(args);
  1054.   lstrcpy(szDlgEdit,dest);
  1055. //  lpfnMsgProc=MakeProcInstance((FARPROC)WS_InputMsgProc,hInst);
  1056.   iRetCode=DialogBox(hInst,(LPSTR)"DLG_INPUT_PASSWORD",hWndMain,WS_InputMsgProc);
  1057. //  FreeProcInstance(lpfnMsgProc);
  1058.   if(iRetCode && dest) lstrcpy(dest,szDlgEdit);
  1059.   return(iRetCode);
  1060. }
  1061.  
  1062. /************************************************************************/
  1063. /* Main Window Procedure                                                */
  1064. /************************************************************************/
  1065. LRESULT CALLBACK WndProc(HWND hWnd,UINT Message,WPARAM wParam,LPARAM lParam)
  1066. {
  1067.   int nIndex; //,nRC;
  1068.   char tempdirectoryname[256];
  1069.  
  1070.  
  1071.   switch (Message)
  1072.   {
  1073.     
  1074.     case WM_COMMAND:
  1075.       if(LOWORD(wParam)==BTN_CLOSE || LOWORD(wParam)==BTN_EXIT ||
  1076.          LOWORD(wParam)==CMD_CLOSE || LOWORD(wParam)==IDM_EXIT)
  1077.         {
  1078.         BOOLEAN rfile = FALSE;
  1079.         BOOLEAN sfile = FALSE;
  1080.         bAborted=TRUE;
  1081.  
  1082.             // kill remote thread first 
  1083.             if (check_busy())
  1084.             {
  1085.              DoAddLine("Aborting thread before closing/exiting\n");
  1086.              TerminateThread(threadhandle,1);
  1087.              mirrorinprogress = FALSE;
  1088.              turnonlistwindows();
  1089.              set_busy(FALSE);
  1090.              bCmdInProgress = 0;
  1091.  
  1092.             }
  1093.        
  1094.        if(data_socket!=INVALID_SOCKET)
  1095.           {
  1096.             // DWORD waitval = 0;
  1097.                int tid = 0;
  1098.                   data_socket=DoClose(data_socket);
  1099.                   // now wait for the abort message
  1100.                   DoPrintf("Waiting for Abort Response message. (550)\n");
  1101.                   // create thread and start remote list fx
  1102.               // threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)waitfor550,NULL,0,&threadid);
  1103.                   aborttimerexpired = FALSE;
  1104.                   SetTimer(hWnd,21,15000,(TIMERPROC)myaborttimerproc);
  1105.                   waitfor550((SOCKET)ctrl_socket);
  1106.                   KillTimer(hWnd,21);
  1107.  
  1108.                 //  waitval = WaitForSingleObject(threadhandle,15000);
  1109.                   // wait 15 seconds if this fails terminate the thread
  1110.  
  1111.                 /*  if (waitval == WAIT_TIMEOUT)
  1112.                    {
  1113.                     DoPrintf("Abort Timeout has Expired\n");
  1114.                     DoPrintf("Abort Failed... Recommend you close/reconnect\n");
  1115.                     TerminateThread(threadhandle,1);
  1116.                     mirrorinprogress = FALSE;
  1117.                     turnonlistwindows();
  1118.                     set_busy(FALSE);
  1119.                     bCmdInProgress = 0;
  1120.                    } */
  1121.  
  1122.              // now check if files were open and close them
  1123.              closefilesonabort(&rfile,&sfile);
  1124.           }
  1125.  
  1126.                  bAborted=TRUE;
  1127.              bCmdInProgress = 0;
  1128.  
  1129.  
  1130.         if(listen_socket!=INVALID_SOCKET)
  1131.           listen_socket=DoClose(listen_socket);
  1132.         if(ctrl_socket!=INVALID_SOCKET)
  1133.          {
  1134.           command(ctrl_socket,"QUIT");
  1135.           ctrl_socket=DoClose(ctrl_socket);
  1136.           bConnected=FALSE;
  1137.         }
  1138.  
  1139.         bCmdInProgress = 0;
  1140.         SetWindowText(hWnd,"WS_FTP32");
  1141.         if(LOWORD(wParam)==IDM_EXIT || LOWORD(wParam)==BTN_EXIT)
  1142.           SendMessage(hWnd,WM_CLOSE,0,0L);
  1143.         else
  1144.           { // close not exit so enable windows correctly
  1145.             EnableWindow(hBtnConnect,TRUE);
  1146.             EnableWindow(hBtnAbort,FALSE);
  1147.             EnableWindow(hBtnClose,FALSE);
  1148.             GetRemoteDirForWnd(hWnd);
  1149.           }
  1150.        // if we are closing we still need to close files that were open or if we
  1151.        // were receiving we need to update display
  1152.        // we don't care about remote since this is updated anyway
  1153.        if (rfile)
  1154.         GetLocalDirForWnd(hWnd);
  1155.           
  1156.         break;
  1157.         } //else if ((bCmdInProgress)  return(FALSE);
  1158.  
  1159.       switch (LOWORD(wParam))
  1160.       {
  1161.  
  1162. // child windows messages ************************************
  1163. // local buttons and boxes
  1164.  
  1165. // lgk new case for abort
  1166.            case BTN_ABORT:
  1167.  
  1168.           // kill remote thread first 
  1169.           // problem here if we abort during a connect we also need to close the control socket
  1170.           // check this via the connect flag
  1171.   
  1172.            // since we cant get this to work correctly disable it for now
  1173.          //  DoPrintf("Abort is Not Yet Implemented Due to problems.\n");
  1174.          
  1175.           if (check_busy())
  1176.             {
  1177.              BOOLEAN rfile = FALSE;
  1178.              BOOLEAN sfile = FALSE;
  1179.              
  1180.              DoPrintf("Aborting Remote thread\n");
  1181.              DoPrintf("WARNING: If the abort fails you may have to close/exit");
  1182.              TerminateThread(threadhandle,1);
  1183.              mirrorinprogress = FALSE;
  1184.              turnonlistwindows();
  1185.              set_busy(FALSE);
  1186.        
  1187.              if(data_socket!=INVALID_SOCKET)
  1188.                 {
  1189.                  //DWORD waitval = 0;
  1190.                  int tid = 0;
  1191.  
  1192.                 //  shutdown(data_socket,2);
  1193.                   data_socket=DoClose((SOCKET)data_socket);
  1194.                   // now wait for the abort message
  1195.                   DoPrintf("Waiting for Abort Response message. (550)\n");
  1196.                 // create thread and start remote list fx
  1197.             //     threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)waitfor550,(LPVOID)ctrl_socket,0,&threadid);
  1198.            //     myctrlsocket = (SOCKET)ctrl_socket;
  1199.                   aborttimerexpired = FALSE;
  1200.                   SetTimer(hWnd,21,15000,(TIMERPROC)myaborttimerproc);
  1201.                   waitfor550((SOCKET)ctrl_socket);
  1202.                   KillTimer(hWnd,21);
  1203.              //     waitval = WaitForSingleObject(threadhandle,20000);
  1204.                   // wait 20 seconds if this fails terminate the thread
  1205.  
  1206.                    // ok now close any open files
  1207.                    closefilesonabort(&rfile,&sfile);
  1208.                    
  1209.                  }
  1210.              bAborted=TRUE;
  1211.              bCmdInProgress = 0;
  1212.  
  1213.              if(listen_socket!=INVALID_SOCKET)
  1214.                listen_socket=DoClose((SOCKET)listen_socket);
  1215.              
  1216.                 bCmdInProgress = 0;
  1217.               
  1218.               if (connectpending)
  1219.               {
  1220.                 int err = 0;
  1221.                 if (ctrl_socket!=INVALID_SOCKET)
  1222.                   {
  1223.                     
  1224.                     command((SOCKET)ctrl_socket,"QUIT");
  1225.                     ctrl_socket = DoClose((SOCKET)ctrl_socket);
  1226.                   }
  1227.                     bConnected = FALSE;
  1228.                     DoPrintf("Remote Connect Aborted\n");
  1229.                     connectpending = FALSE;
  1230.                     bCmdInProgress = 0;
  1231.                     EnableWindow(hBtnConnect,TRUE);
  1232.                     EnableWindow(hBtnAbort,FALSE);
  1233.                     EnableWindow(hBtnClose,FALSE);
  1234.                     SetWindowText(hWnd,"WS_FTP32");
  1235.                     iCode = 0;
  1236.  
  1237.                 
  1238.               } 
  1239.               else
  1240.                         {
  1241.                           DoPrintf("Remote Operation Aborted\n");
  1242.                           // only do this if no connect pending
  1243.                           if (sfile)
  1244.                             GetRemoteDirForWnd(hWnd);
  1245.                         }
  1246.    
  1247.                     // now if we were sending or receiving a file update the windows accordingly
  1248.                      if (rfile)
  1249.                       GetLocalDirForWnd(hWnd);
  1250.             }    
  1251.         break;
  1252.  
  1253.  
  1254.        // lgk new case for changing txt in directory search routine
  1255.            case TXT_LDIRSEL:
  1256.          {
  1257.           // check if carriage return
  1258.           char *temp = localsearchstring();
  1259.           if ((HIWORD(wParam) == EN_KILLFOCUS) && SendMessage(hLdirBox,EM_GETMODIFY,0,0))
  1260.            {
  1261.              GetLocalDirForWnd(hWnd);
  1262.            }
  1263.            // bug in redraw so force it
  1264.           if (HIWORD(wParam) == EN_UPDATE)
  1265.              {
  1266.               SendMessage(hLdirBox,WM_SETFONT,0,MAKELPARAM(TRUE,0));
  1267.               }
  1268.  
  1269.           }    
  1270.         break;
  1271.  
  1272.         case LST_LDIRS:
  1273.           if (HIWORD(wParam) !=LBN_DBLCLK) return(FALSE);
  1274.         case BTN_LCHANGE:
  1275.           {
  1276.             int count = SendMessage(hLbxLDir,LB_GETSELCOUNT,
  1277.                 0,0L);
  1278.             int count2 = 0;
  1279.             
  1280.             if (count > 1)
  1281.               {
  1282.                 DoPrintf("Only 1 directory can be selected for the chdir operation.");
  1283.               }  
  1284.             else if (count == 0)
  1285.              { // ok case so ask
  1286.               if(StdInput(NULL,"Enter local directory name:")) {
  1287.                 if(szDlgEdit[1]==':')
  1288. #ifdef _MSC_
  1289.                   _chdrive(tolower(szDlgEdit[0])-0x60);
  1290. #else
  1291.                   setdisk(tolower(szDlgEdit[0])-'a');
  1292. #endif
  1293.                 chdir(szDlgEdit);
  1294.                 GetLocalDirForWnd(hWnd);
  1295.               }
  1296.              }
  1297.            else // (count == 1)
  1298.              {
  1299.             count2=SendMessage(hLbxLDir,
  1300.                       LB_GETSELITEMS,256,(LPARAM)(int far *)selects);
  1301.               nIndex = selects[0];
  1302.               SendMessage(hLbxLDir,LB_GETTEXT,nIndex,
  1303.                                  (LONG)szMsgBuf2);
  1304.               if(strncmp(szMsgBuf2,"[-",2)==0) {
  1305. #ifdef _MSC_
  1306.                 _chdrive(tolower(szMsgBuf2[2])-0x60);
  1307. #else
  1308.                 setdisk(szMsgBuf2[2]-'a');
  1309. #endif
  1310.                 GetLocalDirForWnd(hWnd);
  1311.               } else if(chdir(szMsgBuf2)==0)
  1312.                 GetLocalDirForWnd(hWnd);
  1313.              }
  1314.           }
  1315.           break;
  1316.         case LST_LFILES:
  1317.           if(HIWORD(wParam) !=LBN_DBLCLK) return(FALSE);
  1318.         case BTN_LOCAL_TO_REMOTE:
  1319.           {
  1320.             globalhWnd = hWnd;
  1321.             globalwParam = wParam;
  1322.             // lgk new code first check if busy and if so print out a message
  1323.             if (check_busy())
  1324.                DoPrintf("Currently Busy with another remote operation ...\n");
  1325.             else
  1326.               {
  1327.                globalhWnd = hWnd;
  1328.                globalwParam = wParam;
  1329.                 set_busy(TRUE);
  1330.  
  1331.                   {
  1332.                  int dircount,filecount = 0;
  1333.                    
  1334.                  filecount =  SendMessage(hLbxLFiles,LB_GETSELCOUNT,0,0);
  1335.                  dircount = SendMessage(hLbxLDir,LB_GETSELCOUNT,0,0);
  1336.                  if ((dircount > 0) && (filecount == 0))
  1337.                    {
  1338.                     mirrorinprogress = TRUE;
  1339.             totalbytestransfered = 0L;
  1340.                     totaltimefortransfer = 0L;
  1341.                     totalfilestransfered = 0;
  1342.                     totaldirscreated = 0;
  1343.  
  1344.                      // create thread and start remote to local fx
  1345.                     threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)local_to_remote_mirror_fx,NULL,0,&threadid);
  1346.  
  1347.                    }
  1348.                 else
  1349.                 {
  1350.               
  1351.                // create and call button to remote thread here
  1352.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)local_to_remote_fx,NULL,0,&threadid);
  1353.             }
  1354.               }
  1355.               } // end of not busy
  1356.           } // end of btn local to remote
  1357.           break;
  1358.  
  1359.           // lgk allow local commands while remote are running
  1360.  
  1361.           
  1362.         case BTN_LMKDIR:
  1363.           if(StdInput(NULL,"Enter new local directory name:")) {
  1364.             mkdir(szDlgEdit);
  1365.             GetLocalDirForWnd(hWnd);
  1366.           }
  1367.           break;
  1368.         case BTN_LRMDIR:
  1369.             if((nIndex=SendMessage(hLbxLDir,LB_GETCURSEL,
  1370.                 0,0L))!=LB_ERR)
  1371.             {
  1372.               SendMessage(hLbxLDir,LB_GETTEXT,nIndex,
  1373.                                  (LONG)szMsgBuf2);
  1374.               if(VerifyDelete(szMsgBuf2))
  1375.                 if(rmdir(szMsgBuf2)==0)
  1376.                   GetLocalDirForWnd(hWnd);
  1377.             }
  1378.           break;
  1379.         case BTN_LDELETE:
  1380.           {
  1381.             int count;
  1382.             count=SendMessage(hLbxLFiles,
  1383.                       LB_GETSELITEMS,256,(LPARAM)(int far *)selects);
  1384.             if(count>0 && count!=LB_ERR) {
  1385.               for(nIndex=0;nIndex<count;nIndex++) {
  1386.                 SendMessage(hLbxLFiles,LB_GETTEXT,selects[nIndex],
  1387.                                  (LONG)szDlgEdit);
  1388.                 if(VerifyDelete(szDlgEdit))
  1389.                   unlink(szDlgEdit);
  1390.               }  
  1391.               GetLocalDirForWnd(hWnd);
  1392.             }
  1393.           }
  1394.           break;
  1395.         case BTN_LRENAME:
  1396.           if((nIndex=SendMessage(hLbxLFiles,LB_GETCURSEL,
  1397.                 0,0L))!=LB_ERR)
  1398.           {
  1399.             SendMessage(hLbxLFiles,LB_GETTEXT,nIndex,
  1400.                                (LONG)szMsgBuf2);
  1401.             if(StdInput(NULL,"Enter new name for \"%s\":",szMsgBuf2))
  1402.               if(rename(szMsgBuf2,szDlgEdit)==0)
  1403.                 GetLocalDirForWnd(hWnd);
  1404.           }
  1405.           break;
  1406.         case BTN_LDISPLAY:
  1407.           {
  1408.             char remotename[80];
  1409.             if((nIndex=SendMessage(hLbxLFiles,LB_GETCURSEL,
  1410.                 0,0L))!=LB_ERR)
  1411.             {
  1412.               SendMessage(hLbxLFiles,LB_GETTEXT,nIndex,
  1413.                                  (LONG)remotename);
  1414.               wsprintf(szMsgBuf2,"%s %s",szViewer,remotename);
  1415.               if(strchr(remotename,'.')==NULL)
  1416.                 strcat(szMsgBuf2,".");
  1417.               WinExec(szMsgBuf2,SW_SHOW);
  1418.             }
  1419.           }
  1420.           break;
  1421.  
  1422.          // remote buttons and boxes
  1423.         case BTN_RMKDIR:
  1424.            // lgk new code first check if busy and if so print out a message
  1425.             if (check_busy())
  1426.                DoPrintf("Currently Busy with another remote operation ...\n");
  1427.             else
  1428.               {
  1429.                globalhWnd = hWnd;
  1430.                globalwParam = wParam;
  1431.                set_busy(TRUE);
  1432.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_mkdir_fx,NULL,0,&threadid);
  1433.                // create thread and start remote makedir fx
  1434.           }               
  1435.           break;
  1436.           
  1437.         case BTN_RRMDIR:
  1438.             // lgk new code first check if busy and if so print out a message
  1439.             if (check_busy())
  1440.                DoPrintf("Currently Busy with another remote operation ...\n");
  1441.             else
  1442.               {
  1443.                 globalhWnd = hWnd;
  1444.                 globalwParam = wParam;
  1445.                 set_busy(TRUE);
  1446.                // create thread and start remote remove dir fx
  1447.                 threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_rmdir_fx,NULL,0,&threadid);
  1448.           }               
  1449.           break;
  1450.  
  1451.         case BTN_RDELETE:
  1452.             // lgk new code first check if busy and if so print out a message
  1453.             if (check_busy())
  1454.                DoPrintf("Currently Busy with another remote operation ...\n");
  1455.             else
  1456.               {
  1457.                globalhWnd = hWnd;
  1458.                globalwParam = wParam;
  1459.                set_busy(TRUE);
  1460.                // create thread and start remote delete fx
  1461.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_delete_fx,NULL,0,&threadid);
  1462.           }               
  1463.           break;
  1464.  
  1465.           
  1466.         case BTN_RRENAME:
  1467.           // lgk new code first check if busy and if so print out a message
  1468.            if (check_busy())
  1469.                DoPrintf("Currently Busy with another remote operation ...\n");
  1470.             else
  1471.               {
  1472.                 globalhWnd = hWnd;
  1473.                 globalwParam = wParam;
  1474.                  set_busy(TRUE);
  1475.                // create thread and start remote rename fx
  1476.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_rename_fx,NULL,0,&threadid);
  1477.           }               
  1478.           break;
  1479.  
  1480.         // lgk new case for changing txt in directory search routine
  1481.            case TXT_RDIRSEL:
  1482.            // bug in redraw so force it
  1483.           if (HIWORD(wParam) == EN_UPDATE)
  1484.              {
  1485.               SendMessage(hRdirBox,WM_SETFONT,0,MAKELPARAM(TRUE,0));
  1486.               }
  1487.           if ((HIWORD(wParam) == EN_KILLFOCUS) && SendMessage(hRdirBox,EM_GETMODIFY,0,0))
  1488.             // lgk new code first check if busy and if so print out a message
  1489.             if (check_busy())
  1490.                DoPrintf("Currently Busy with another remote operation ...\n");
  1491.             else
  1492.               {
  1493.                 globalhWnd = hWnd;
  1494.                 globalwParam = wParam;
  1495.                 set_busy(TRUE);
  1496.                // create thread and start remote list fx
  1497.                 threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_list_fx,NULL,0,&threadid);
  1498.           }               
  1499.           break;
  1500.        
  1501.    
  1502.         case LST_RDIRS:
  1503.          if (HIWORD(wParam) == LBN_SELCANCEL)
  1504.            {
  1505.             // turn off the item
  1506.             DoPrintf("Selection cancled.");
  1507.            }
  1508.             
  1509.           else if(HIWORD(wParam)!=LBN_DBLCLK) return(FALSE);
  1510.         case BTN_RCHANGE:
  1511.             // lgk new code first check if busy and if so print out a message
  1512.             if (check_busy())
  1513.                DoPrintf("Currently Busy with another remote operation ...\n");
  1514.             else
  1515.               {
  1516.                 globalhWnd = hWnd;
  1517.                 globalwParam = wParam;
  1518.                 set_busy(TRUE);
  1519.                // create thread and start remote cwd fx
  1520.                 threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_cwd_fx,NULL,0,&threadid);
  1521.           }               
  1522.           break;
  1523.           
  1524.         case LST_RFILES:
  1525.           if(HIWORD(wParam)!=LBN_DBLCLK) return(FALSE);
  1526.         case BTN_REMOTE_TO_LOCAL:
  1527.  
  1528.  
  1529.             // lgk new code first check if busy and if so print out a message
  1530.             if (check_busy())
  1531.                DoPrintf("Currently Busy with another remote operation ...\n");
  1532.             else
  1533.               {
  1534.                 globalhWnd = hWnd;
  1535.                 globalwParam = wParam;
  1536.                set_busy(TRUE);
  1537.  
  1538.                // if no files selected and some directories selected
  1539.                 {
  1540.                  int dircount,filecount = 0;
  1541.                    
  1542.                  filecount =  SendMessage(hLbxRFiles,LB_GETSELCOUNT,0,0);
  1543.                  dircount = SendMessage(hLbxRDir,LB_GETSELCOUNT,0,0);
  1544.                  if ((dircount > 0) && (filecount == 0))
  1545.                    {
  1546.                     mirrorinprogress = TRUE;
  1547.                     totalbytestransfered = 0L;
  1548.                     totaltimefortransfer = 0L;
  1549.                     totalfilestransfered = 0;
  1550.                     totaldirscreated = 0;
  1551.  
  1552.                      // create thread and start remote to local fx
  1553.                     threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_to_local_mirror_fx,NULL,0,&threadid);
  1554.  
  1555.                    }
  1556.                 else
  1557.                 {
  1558.                // create thread and start remote to local fx
  1559.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_to_local_fx,NULL,0,&threadid);
  1560.             }
  1561.         }
  1562.           }             
  1563.           break;
  1564.  
  1565.           
  1566.         case BTN_RDISPLAY:
  1567.             // lgk new code first check if busy and if so print out a message
  1568.             if (check_busy())
  1569.                DoPrintf("Currently Busy with another remote operation ...\n");
  1570.             else
  1571.               {
  1572.                globalhWnd = hWnd;
  1573.                globalwParam = wParam;
  1574.                 set_busy(TRUE);
  1575.                // create thread and start remote display fx
  1576.                   threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)remote_display_fx,NULL,0,&threadid);
  1577.           }               
  1578.           break;
  1579.  
  1580.         case RB_ASCII:
  1581.           fType=TYPE_A;
  1582. ShowType:
  1583.         case RB_SHOWCHECKS:
  1584.           SendMessage(hRBascii, BM_SETCHECK,fType==TYPE_A,0L);
  1585.           SendMessage(hRBbinary,BM_SETCHECK,fType==TYPE_I,0L);
  1586.           SendMessage(hRBl8,    BM_SETCHECK,fType==TYPE_L,0L);
  1587.           break;
  1588.         case RB_BINARY:
  1589.           fType=TYPE_I;
  1590.           goto ShowType;
  1591.         case RB_L8:
  1592.           fType=TYPE_L;
  1593.           goto ShowType;
  1594.  
  1595. // end of child window message processing *******************
  1596.  
  1597.         case BTN_CONNECT:
  1598.         case CMD_CONNECT:
  1599.             // lgk new code first check if busy and if so print out a message
  1600.             if (check_busy())
  1601.                DoPrintf("Currently Busy with another remote operation ...\n");
  1602.             else
  1603.               {
  1604.                globalhWnd = hWnd;
  1605.                globalwParam = wParam;
  1606.                set_busy(TRUE);
  1607.                // create thread and start connect fx
  1608.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)connect_fx,NULL,0,&threadid);
  1609.           }               
  1610.           break;
  1611.  
  1612.         case BTN_LONG:
  1613.           if(bConnected) {
  1614.             wsprintf(szMsgBuf2,"%s %s",szViewer,szTmpFile);
  1615.             WinExec(szMsgBuf2,SW_SHOW);
  1616.           }
  1617.           break;
  1618.  
  1619.         case BTN_OPTION:
  1620.           {
  1621.            //FARPROC lpfnMsgProc;
  1622.     //        lpfnMsgProc = MakeProcInstance((FARPROC)WS_StatMsgProc, hInst);
  1623.             DialogBox(hInst, (LPSTR)"DLG_STATUS", hWnd, WS_StatMsgProc);
  1624.        //     FreeProcInstance(lpfnMsgProc);
  1625.           }
  1626.           SendMessage(hWnd,WM_COMMAND,RB_SHOWCHECKS,0l);
  1627.           break;
  1628.  
  1629.         case BTN_ABOUT:
  1630.         case IDM_ABOUT:
  1631.           { 
  1632.             DialogBox(hInst, (LPSTR)"DLG_ABOUT", hWnd, WS_AboutMsgProc);
  1633.           }
  1634.           break;
  1635.  
  1636.         default:
  1637.           if(!SubProcessAsync(hWnd,Message,wParam,lParam))
  1638.             return DefWindowProc(hWnd, Message, wParam, lParam);
  1639.       }
  1640.       break;
  1641.  
  1642.     case WM_VSCROLL:
  1643.       switch(LOWORD(wParam)) {
  1644.         case SB_LINEUP:
  1645.           ScrollStatus(-1);
  1646.           break;
  1647.         case SB_LINEDOWN:
  1648.           ScrollStatus(1);
  1649.           break;
  1650.       }
  1651.       break;
  1652.  
  1653.     case WM_CREATE:
  1654.       hStdCursor=LoadCursor((HINSTANCE)NULL,IDC_ARROW);
  1655.       hWaitCursor=LoadCursor((HINSTANCE)NULL,IDC_APPSTARTING);
  1656.       LoadUserInfo();
  1657.       hbrGray1= CreateSolidBrush(RGB(192,192,192));
  1658.       hbrGray2=CreateSolidBrush(RGB(128,128,128)); 
  1659.       hbrWhite=CreateSolidBrush(RGB(255,255,255));
  1660.     
  1661.       if (DEBUGGING_ON)
  1662.         CreateDebugWindow(hWnd,hInst);
  1663.       
  1664.       CreateSubWindows(hWnd,hInst);
  1665.       SendMessage(hLdirBox,EM_LIMITTEXT,(WPARAM)50,0);
  1666.       SendMessage(hRdirBox,EM_LIMITTEXT,(WPARAM)50,0);
  1667.       SendMessage(hLdirBox,WM_SETTEXT,0,(LPARAM)"");
  1668.       SendMessage(hRdirBox,WM_SETTEXT,0,(LPARAM)"");
  1669.       SendMessage(hLdirBox,EM_GETMODIFY,0,0);
  1670.       SendMessage(hRdirBox,EM_GETMODIFY,0,0);     
  1671.       SendMessage(hLdirBox,EM_FMTLINES,(WPARAM)1,0);     
  1672.       SendMessage(hRdirBox,EM_FMTLINES,(WPARAM)1,0);     
  1673.       GetLocalDirForWnd(hWnd);
  1674.       GetRemoteDirForWnd(hWnd);
  1675.       SendMessage(hWnd,WM_COMMAND,RB_SHOWCHECKS,0L);
  1676.       GetCurrentDirectory(140,tempdirectoryname);
  1677.       GetTempFileName(tempdirectoryname,"DIR",0,szTmpFile);
  1678.       GetTempFileName(tempdirectoryname,"DSP",0,szTmp1File);
  1679.       DragAcceptFiles(hWnd,TRUE);
  1680.       // lgk limit the text for both dir boxes and initialize them to blank
  1681.  
  1682.         break;
  1683.   // lgk timer messages do not work between threads so use a timer proc now
  1684.  
  1685.     case WM_TIMER:
  1686.     if(wParam==10)
  1687.         {
  1688.         KillTimer(hWndMain,10);
  1689.         if(WSAIsBlocking())
  1690.          {
  1691.             // lgk if we are blocking in another thread here we need to kill
  1692.             // it also
  1693.            if (check_busy())
  1694.             {
  1695.              DoAddLine("Timer cancelled blocking call");    
  1696.              bAborted=TRUE;
  1697.              WSACancelBlockingCall();
  1698.              TerminateThread(threadhandle,1);
  1699.              mirrorinprogress = FALSE;
  1700.              turnonlistwindows();
  1701.              set_busy(FALSE);
  1702.             }
  1703.          else
  1704.          {
  1705.           DoAddLine("Timer cancelled blocking call");    
  1706.           bAborted=TRUE;
  1707.           WSACancelBlockingCall();
  1708.      }
  1709.      }         
  1710.         }
  1711.       break;
  1712.  
  1713.  
  1714.      case WM_CTLCOLORBTN:
  1715.            if(LOWORD(lParam)<10) return((LRESULT)NULL);
  1716.  // lgk add suport for background color change for our edit box
  1717.      case WM_CTLCOLORSTATIC:
  1718.                SelectObject((HDC)wParam, GetStockObject(ANSI_VAR_FONT));
  1719.                 SetBkColor((HDC) wParam, RGB(192,192,192));
  1720.                 return(LRESULT)hbrGray1;
  1721.                 break;
  1722.  
  1723.      case WM_CTLCOLOREDIT:
  1724.                SelectObject((HDC)wParam, GetStockObject(ANSI_VAR_FONT));
  1725.                 SetBkColor((HDC) wParam, RGB(255, 255, 255));
  1726.                 return(LRESULT)hbrWhite;
  1727.                 break;
  1728.         
  1729.  
  1730.     case WM_SETCURSOR:
  1731.       if(bCmdInProgress) {
  1732.         SetCursor(hWaitCursor);
  1733.         return(TRUE);
  1734.       } else
  1735.         return DefWindowProc(hWnd, Message, wParam, lParam);
  1736.  
  1737.     case WM_DROPFILES:
  1738.             // lgk new code first check if busy and if so print out a message
  1739.             if (check_busy())
  1740.                DoPrintf("Currently Busy with another remote operation ...\n");
  1741.             else
  1742.               {
  1743.                globalhWnd = hWnd;
  1744.                globalwParam = wParam;
  1745.                 set_busy(TRUE);
  1746.                // create thread and start dropfiles fx
  1747.                threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)drop_files_fx,NULL,0,&threadid);
  1748.           }               
  1749.           break;
  1750.  
  1751.     case WM_PAINT:  // code for the window's client area
  1752.       DoMainPaint(hWnd);
  1753.       break;
  1754.  
  1755.     case WM_CLOSE:  // close the window 
  1756.       // Destroy child windows, modeless dialogs, then, this window
  1757.       if (hWnd == hWndMain) {
  1758.         if(data_socket!=INVALID_SOCKET)
  1759.           data_socket=DoClose(data_socket);
  1760.         if(listen_socket!=INVALID_SOCKET)
  1761.           listen_socket=DoClose(data_socket);
  1762.         if(ctrl_socket!=INVALID_SOCKET)
  1763.           ctrl_socket=DoClose(ctrl_socket);
  1764.         DestroyWindow(hWnd);
  1765.         SaveUserInfo();
  1766.         DeleteObject(hbrGray1);
  1767.         DeleteObject(hbrGray2);
  1768.         DeleteObject(hbrWhite);
  1769.         _unlink(szTmpFile);
  1770.         _unlink(szTmp1File);
  1771.         DragAcceptFiles(hWnd,FALSE);
  1772.    // lgk if we are busy here we must kill any active task
  1773.    if (check_busy())
  1774.      {
  1775.        DoPrintf("Killing active thread ... \n");
  1776.        TerminateThread(threadhandle,1);
  1777.        mirrorinprogress = FALSE;
  1778.        turnonlistwindows();
  1779.        set_busy(FALSE);
  1780.      }
  1781.         PostQuitMessage(0);  // Quit the application
  1782.       } else
  1783.         DestroyWindow(hWnd);
  1784.         DeleteCriticalSection(&busy_variable);
  1785.       break;
  1786.  
  1787.     default:
  1788.       if(!SubProcessAsync(hWnd,Message,wParam,lParam))
  1789.         return DefWindowProc(hWnd, Message, wParam, lParam);
  1790.   }
  1791.   return 0L;
  1792. } // End of WndProc
  1793.  
  1794. /************************************************************************/
  1795. /* Misc Dialog Window Procedures                                        */
  1796. /************************************************************************/
  1797. BOOL CALLBACK WS_AboutMsgProc(HWND hWndDlg, UINT Message, 
  1798.                                 WPARAM wParam, LPARAM lParam)
  1799. {
  1800.  char buf[40];
  1801.   
  1802.  switch(Message)
  1803.  {
  1804.  
  1805.   case WM_INITDIALOG:
  1806.      {
  1807.      {
  1808.        struct hostent FAR *hostptr;
  1809.        struct in_addr *iptr;
  1810.        
  1811.          cwCenter(hWndDlg, 0);
  1812.          if(gethostname((LPSTR)buf,
  1813.              MAXHOSTNAMELEN)!=SOCKET_ERROR) 
  1814.            {
  1815.              if((hostptr=gethostbyname(buf))!=NULL) 
  1816.               {
  1817.                iptr=(struct in_addr *)*(hostptr->h_addr_list);
  1818.                wsprintf(szString,"%s [%s]",buf,inet_ntoa(*iptr));
  1819.               } 
  1820.              else lstrcpy(szString,buf);
  1821.              SetDlgItemText(hWndDlg,DLG_ABT_L2,szString);
  1822.            }
  1823.      }
  1824.      SetDlgItemText(hWndDlg,DLG_ABT_L1,
  1825.          (LPSTR)WSAData.szDescription);
  1826.      wsprintf(buf,"Version %s",VERSION);
  1827.      SetDlgItemText(hWndDlg,DLG_VERSION,buf);
  1828.      break;
  1829.   }
  1830.  
  1831.  
  1832.       case WM_CTLCOLORBTN:
  1833.           if(LOWORD(lParam)<10) return((BOOL)NULL);
  1834.  
  1835.      case WM_CTLCOLORDLG:
  1836.      case WM_CTLCOLORSTATIC:
  1837.           SetBkColor((HDC) wParam, RGB(192,192,192));
  1838.         return (BOOL)hbrGray1;
  1839.         break;
  1840.  
  1841.  
  1842.    case WM_CLOSE:
  1843.      PostMessage(hWndDlg, WM_COMMAND, IDCANCEL, 0L);
  1844.      break;
  1845.  
  1846.    case WM_COMMAND:
  1847.      switch(LOWORD(wParam))
  1848.      {
  1849.        case IDOK:
  1850.          EndDialog(hWndDlg, TRUE);
  1851.          break;
  1852.        case IDCANCEL:
  1853.          EndDialog(hWndDlg, FALSE);
  1854.          break;
  1855.      }
  1856.      break;
  1857.     default:
  1858.         return FALSE;
  1859.   }
  1860.   return TRUE;
  1861. }
  1862.  
  1863. BOOL CALLBACK WS_InputMsgProc(HWND hWndDlg, UINT Message,
  1864.                                 WPARAM wParam, LPARAM lParam)
  1865. { 
  1866.   switch(Message)
  1867.   {
  1868.      case WM_GETDLGCODE:
  1869.      return DLGC_WANTALLKEYS;
  1870.      break;
  1871.  
  1872.      case WM_KEYDOWN:
  1873.       DoPrintf("a key is down");
  1874.       break;
  1875.  
  1876.       case WM_CHAR:
  1877.       DoPrintf("wmchar a key is down");
  1878.       break;
  1879.  
  1880.     case WM_INITDIALOG:
  1881.       SetDlgItemText(hWndDlg,DLG_PROMPT,szDlgPrompt);
  1882.       SetDlgItemText(hWndDlg,DLG_EDIT,szDlgEdit);
  1883.       cwCenter(hWndDlg, 0);                                            
  1884.       break;
  1885.  
  1886.  
  1887.         case WM_CTLCOLORBTN:
  1888.              if(LOWORD(lParam)<10) return((LRESULT)NULL);
  1889.  
  1890.         case WM_CTLCOLORDLG:
  1891.         case WM_CTLCOLORSTATIC:
  1892.         SetBkColor((HDC) wParam, RGB(192,192,192));
  1893.          return(LRESULT)hbrGray1;
  1894.           break;
  1895.   
  1896.      case WM_CLOSE:
  1897.       PostMessage(hWndDlg, WM_COMMAND, IDCANCEL, 0L);
  1898.       break;
  1899.  
  1900.     case WM_COMMAND:
  1901.       switch(LOWORD(wParam))
  1902.       {
  1903.         case IDOK:
  1904.           GetDlgItemText(hWndDlg,DLG_EDIT,szDlgEdit,70);
  1905.           EndDialog(hWndDlg, TRUE);
  1906.           break;
  1907.         case IDCANCEL:
  1908.           EndDialog(hWndDlg, FALSE);
  1909.           break;
  1910.       }
  1911.       break;
  1912.     default:
  1913.       return FALSE;
  1914.   }
  1915.   return TRUE;
  1916. }
  1917.  
  1918. BOOL CALLBACK WS_StatMsgProc(HWND hWndDlg, UINT Message,
  1919.                                WPARAM wParam, LPARAM lParam)
  1920. { 
  1921.   switch(Message)
  1922.   {
  1923.     case WM_INITDIALOG:
  1924.       SetDlgItemText(hWndDlg,DLG_EDIT,szViewer);
  1925.       SetDlgItemText(hWndDlg,DLG_MAILADDR,szMailAddress);
  1926.       if(fType==TYPE_A)
  1927.         CheckRadioButton(hWndDlg,RB_ASCII,RB_L8,RB_ASCII);
  1928.       else if(fType==TYPE_I)
  1929.         CheckRadioButton(hWndDlg,RB_ASCII,RB_L8,RB_BINARY);
  1930.       else
  1931.         CheckRadioButton(hWndDlg,RB_ASCII,RB_L8,RB_L8);
  1932.       CheckDlgButton(hWndDlg,CKB_VERBOSE,bVerbose);
  1933.       CheckDlgButton(hWndDlg,CKB_BELL,bBell);
  1934.       CheckDlgButton(hWndDlg,CKB_GLOBBING,bDoGlob);
  1935.       CheckDlgButton(hWndDlg,CKB_HASH,bHash);
  1936.       CheckDlgButton(hWndDlg,CKB_PROMPT,bInteractive);
  1937.       CheckDlgButton(hWndDlg,CKB_MCASE,bMCase);
  1938.       CheckDlgButton(hWndDlg,CKB_PORT_CMDS,bSendPort);
  1939.       CheckDlgButton(hWndDlg,CKB_RECV_UNIQUE,bRecvUniq);
  1940.       CheckDlgButton(hWndDlg,CKB_STOR_UNIQUE,bStorUniq);
  1941.       CheckDlgButton(hWndDlg,CKB_CRSTRIP,bCRstrip);
  1942.       CheckDlgButton(hWndDlg,CKB_AUTOSTART,bAutoStart);
  1943.       break;
  1944.  
  1945.     case WM_CLOSE:
  1946.       PostMessage(hWndDlg, WM_COMMAND, IDCANCEL, 0L);
  1947.       break;
  1948.  
  1949.     case WM_SETCURSOR:
  1950.       if(bCmdInProgress)
  1951.         SetCursor(hWaitCursor);
  1952.       else
  1953.         return FALSE;
  1954.       break;
  1955.  
  1956.         case WM_CTLCOLORBTN:
  1957.              if(LOWORD(lParam)<10) return((LRESULT)NULL);
  1958.        case WM_CTLCOLORDLG:
  1959.         case WM_CTLCOLORSTATIC:
  1960.          SetBkColor((HDC) wParam, RGB(192,192,192));
  1961.           return(LRESULT)hbrGray1;
  1962.           break;
  1963.  
  1964.     case WM_COMMAND:
  1965.       switch(LOWORD(wParam))
  1966.       {
  1967.         case IDOK:
  1968.           if(IsDlgButtonChecked(hWndDlg,RB_ASCII)) fType=TYPE_A;
  1969.           else if(IsDlgButtonChecked(hWndDlg,RB_BINARY)) fType=TYPE_I;
  1970.           else fType=TYPE_L;
  1971.  
  1972.           bVerbose=IsDlgButtonChecked(hWndDlg,CKB_VERBOSE);
  1973.           bBell=IsDlgButtonChecked(hWndDlg,CKB_BELL);
  1974.           bDoGlob=IsDlgButtonChecked(hWndDlg,CKB_GLOBBING);
  1975.           bHash=IsDlgButtonChecked(hWndDlg,CKB_HASH);
  1976.           bInteractive=IsDlgButtonChecked(hWndDlg,CKB_PROMPT);
  1977.           bMCase=IsDlgButtonChecked(hWndDlg,CKB_MCASE);
  1978.           bSendPort=IsDlgButtonChecked(hWndDlg,CKB_PORT_CMDS);
  1979.           bRecvUniq=IsDlgButtonChecked(hWndDlg,CKB_RECV_UNIQUE);
  1980.           bStorUniq=IsDlgButtonChecked(hWndDlg,CKB_STOR_UNIQUE);
  1981.           bCRstrip=IsDlgButtonChecked(hWndDlg,CKB_CRSTRIP);
  1982.           bAutoStart=IsDlgButtonChecked(hWndDlg,CKB_AUTOSTART);
  1983.  
  1984.           GetDlgItemText(hWndDlg,DLG_EDIT,szViewer,70);
  1985.           GetDlgItemText(hWndDlg,DLG_MAILADDR,szMailAddress,127);
  1986.           EndDialog(hWndDlg, TRUE);
  1987.           break;
  1988.         case IDCANCEL:
  1989.           EndDialog(hWndDlg, FALSE);
  1990.           break;
  1991.       }
  1992.       break;    // End of WM_COMMAND
  1993.     default:
  1994.       return FALSE;
  1995.   }
  1996.   return TRUE;
  1997. }
  1998.  
  1999. /************************************************************************/
  2000. /* nCwRegisterClasses Function                                          */
  2001. /* The following function registers all the classes of all the windows  */
  2002. /* associated with this application. The function returns an error code */
  2003. /* if unsuccessful, otherwise it returns 0.                             */
  2004. /************************************************************************/
  2005. int nCwRegisterClasses(void)
  2006. {
  2007.   WNDCLASS   wndclass;    // struct to define a window class
  2008.   memset(&wndclass, 0x00, sizeof(WNDCLASS));
  2009.  
  2010.   // load WNDCLASS with window's characteristics
  2011.   wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_BYTEALIGNWINDOW;
  2012.   wndclass.lpfnWndProc = WndProc;
  2013.   // Extra storage for Class and Window objects
  2014.   wndclass.cbClsExtra = 0;
  2015.   wndclass.cbWndExtra = 0;
  2016.   wndclass.hInstance = hInst;
  2017.   wndclass.hIcon = LoadIcon(hInst, szAppName);
  2018.   wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  2019.   // Create brush for erasing background
  2020.   wndclass.hbrBackground = (HBRUSH)CreateSolidBrush(RGB(192,192,192));
  2021.   wndclass.lpszMenuName = NULL; // szAppName;   /* Menu Name is App Name */
  2022.   wndclass.lpszClassName = szAppName; /* Class Name is App Name */
  2023.   if(!RegisterClass(&wndclass))
  2024.     return -1;
  2025.   return(0);
  2026. } // End of nCwRegisterClasses
  2027.  
  2028. /************************************************************************/
  2029. /*  cwCenter Function                                                   */
  2030. /*  centers a window based on the client area of its parent             */
  2031. /************************************************************************/
  2032. void cwCenter(hWnd, top)
  2033. HWND hWnd;
  2034. int top;
  2035. {
  2036.   POINT      pt;
  2037.   RECT       swp;
  2038.   RECT       rParent;
  2039.   int        iwidth;
  2040.   int        iheight;
  2041.  
  2042.   // get the rectangles for the parent and the child
  2043.   GetWindowRect(hWnd, &swp);
  2044.  
  2045.   // calculate the height and width for MoveWindow
  2046.   iwidth = swp.right - swp.left;
  2047.   iheight = swp.bottom - swp.top;
  2048.  
  2049.   if(IsIconic(hWndMain))
  2050.     MoveWindow(hWnd, 0, 0, iwidth, iheight, FALSE);
  2051.   else {
  2052.     GetClientRect(hWndMain, &rParent);
  2053.  
  2054.     // find the center point and convert to screen coordinates
  2055.     pt.x = (rParent.right - rParent.left) / 2;
  2056.     pt.y = (rParent.bottom - rParent.top) / 2;
  2057.     ClientToScreen(hWndMain, &pt);
  2058.  
  2059.     // calculate the new x, y starting point
  2060.     pt.x = pt.x - (iwidth / 2);
  2061.     pt.y = pt.y - (iheight / 2);
  2062.  
  2063.     // top will adjust the window position, up or down
  2064.     if(top)
  2065.       pt.y = pt.y + top;
  2066.  
  2067.     // move the window
  2068.     MoveWindow(hWnd,max(0,pt.x),max(0,pt.y), iwidth, iheight, FALSE);
  2069.   }
  2070. } // end of cwCenter
  2071.  
  2072. /************************************************************************/
  2073. /*  CwUnRegisterClasses Function                                        */
  2074. /*  Deletes any refrences to windows resources created for this         */
  2075. /*  application, frees memory, deletes instance, handles and does       */
  2076. /*  clean up prior to exiting the window                                */
  2077. /************************************************************************/
  2078. void CwUnRegisterClasses(void)
  2079. {
  2080.   WNDCLASS   wndclass;    // struct to define a window class
  2081.   memset(&wndclass, 0x00, sizeof(WNDCLASS));
  2082.  
  2083.   GetClassInfo(hInst, szAppName, &wndclass);
  2084.   DeleteObject(wndclass.hbrBackground);
  2085.   UnregisterClass(szAppName, hInst);
  2086.   UnregisterClass(DBUGWNDCLASS,hInst);
  2087. } // End of CwUnRegisterClasses
  2088.  
  2089.