Changeset 1335 for trunk/dll/worker.c


Ignore:
Timestamp:
Dec 13, 2008, 12:49:02 AM (17 years ago)
Author:
Steven Levine
Message:

Ticket 26: Add exception handlers to all threads using xbeginthread

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/worker.c

    r1324 r1335  
     1
    12/***********************************************************************
    23
    … …  
    2829  20 Jul 08 GKY Add save/append filename to clipboard.
    2930  02 Aug 08 GKY Limit use of "trash can" to local writable fixed drives or to trash can supported
    30                 drives list if it exists. Fix ability to deselect use of trash can.
     31                drives list if it exists. Fix ability to deselect use of trash can.
    3132  01 Sep 08 GKY Add code to retry on Netdrives "pipe error"
    3233  04 Dec 08 GKY Add a DosSleep to allow file extract to complete before rescan
    3334  04 Dec 08 GKY Add mutex semaphore and disable fSyncUpdates for file deletes to prevent the creation
    34                 on dead CNRITEMS.
     35                on dead CNRITEMS.
     36  10 Dec 08 SHL Integrate exception handler support
    3537
    3638***********************************************************************/
    … …  
    4042#include <ctype.h>
    4143#include <share.h>
    42 #include <process.h>                    // _beginthread
     44#include <process.h>                    // _beginthread // 10 Dec 08 SHL
    4345#include <time.h>
    4446
    … …  
    6769#include "strutil.h"                    // GetPString
    6870#include "notebook.h"                   // External viewers
    69 #include "worker.h"                     // Action
    70 #include "notify.h"                     // AddNote
    71 #include "copyf.h"                      // AdjustWildcardName, make_deleteable
     71#include "worker.h"                     // Action
     72#include "notify.h"                     // AddNote
     73#include "copyf.h"                      // AdjustWildcardName, make_deleteable
    7274#include "attribs.h"                    // AttrListDlgProc
    7375#include "chklist.h"                    // CheckListProc
    … …  
    9799#include "wrappers.h"                   // xfopen
    98100#include "fortify.h"
     101#include "excputil.h"                   // 06 May 08 SHL added
    99102
    100103// Data definitions
    … …  
    124127  if (undo->type && undo->list && undo->list[0]) {
    125128    switch (undo->type) {
    126     case IDM_MOVE case IDM_COPY:
     129    case IDM_MOVE:
     130    case IDM_COPY:
    127131    case IDM_EXTRACT:
    128132      {
    … …  
    147151              break;
    148152            }
    149             if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1) {
    150               Runtime_Error(pszSrcFile, __LINE__,
    151                             GetPString(IDS_COULDNTSTARTTHREADTEXT));
     153            if (xbeginthread(MassAction,
     154                             122880,
     155                             wk,
     156                             pszSrcFile,
     157                             __LINE__) == -1)
     158            {
    152159              FreeListInfo(wk->li);
    153160              free(wk);
    … …  
    162169      }
    163170      break;
    164     }
     171    } // switch
    165172  }
    166173  FreeUndo();
    … …  
    477484                  if (needs_quoting(ex.masks) && !strchr(ex.masks, '\"'))
    478485                    maskspaces = TRUE;
    479                   if (!runemf2(SEPARATE | WINDOWED | WAIT |
     486                  if (!runemf2(SEPARATE | WINDOWED | WAIT |
    480487                               fArcStuffVisible ? 0 : (BACKGROUND | MINIMIZED),
    481488                               HWND_DESKTOP, pszSrcFile, __LINE__, ex.extractdir, NULL,
    … …  
    486493                               *ex.masks ? ex.masks : "\"*\"",
    487494                               maskspaces ? "\"" : NullStr) &&
    488                       !stricmp(ex.extractdir, wk->directory)) {
    489                     DosSleep(100); // wait for runemf2 to complete so rescan will actually show something
    490                     if (WinIsWindow((HAB) 0, wk->hwndCnr))
     495                      !stricmp(ex.extractdir, wk->directory)) {
     496                    DosSleep(100); // wait for runemf2 to complete so rescan will actually show something
     497                    if (WinIsWindow((HAB) 0, wk->hwndCnr))
    491498                      WinSendMsg(wk->hwndCnr,
    492499                                 WM_COMMAND,
    … …  
    596603              case IDM_MOVE:
    597604              case IDM_COPY:
    598               case IDM_RENAME:
    599                 {
    600 
    601                   if (!*wk->li->targetpath && (wk->li->type == IDM_MOVE ||
    602                                                wk->li->type == IDM_COPY ||
    603                                                wk->li->type == IDM_WPSMOVE ||
    604                                                wk->li->type == IDM_WPSCOPY)) {
    605 
    606                     APIRET rc = 1;
    607 
    608                     usedtarget = FALSE;
    609                     if (hwndMain) {
    610                       if (!*targetdir)
    611                         TopWindowName(hwndMain,
    612                                       wk->hwndFrame, wk->li->targetpath);
    613                       else {
    614                         strcpy(wk->li->targetpath, targetdir);
    615                         usedtarget = TRUE;
    616                       }
    617                     }
    618                     if (!*wk->li->targetpath)
    619                       strcpy(wk->li->targetpath, wk->directory);
    620                     if (!*wk->li->targetpath) {
    621                       strcpy(wk->li->targetpath, wk->li->list[0]);
    622                       p = strrchr(wk->li->targetpath, '\\');
    623                       if (p) {
    624                         if (*(p - 1) == ':')
    625                           p++;
    626                         *p = 0;
    627                       }
    628                     }
    629                     MakeValidDir(wk->li->targetpath);
    630                     if (fConfirmTarget ||
    631                         (!*targetdir && strcmp(realappname, "FM/4"))) {
    632                     RetryPath:
    633                       usedtarget = FALSE;
    634                       if (wk->li->type == IDM_MOVE ||
    635                           wk->li->type == IDM_WPSMOVE) {
    636                         rc = WinDlgBox(HWND_DESKTOP,
    637                                        wk->hwndFrame,
    638                                        WalkMoveDlgProc,
    639                                        FM3ModHandle,
    640                                        WALK_FRAME, MPFROMP(wk->li->targetpath));
    641                       }
    642                       else if (wk->li->type == IDM_COPY ||
    643                                wk->li->type == IDM_WPSCOPY) {
    644                         rc = WinDlgBox(HWND_DESKTOP,
    645                                        wk->hwndFrame,
    646                                        WalkCopyDlgProc,
    647                                        FM3ModHandle,
    648                                        WALK_FRAME, MPFROMP(wk->li->targetpath));
    649                       }
    650                       else
    651                         rc = WinDlgBox(HWND_DESKTOP,
    652                                        wk->hwndFrame,
    653                                        WalkDlgProc,
    654                                        FM3ModHandle,
    655                                        WALK_FRAME, MPFROMP(wk->li->targetpath));
    656                     }
    657                     if (!rc || !*wk->li->targetpath)
    658                       goto Abort;
    659                     if (driveflags[toupper(*wk->li->targetpath) - 'A'] &
    660                         DRIVE_NOTWRITEABLE) {
    661                       saymsg(MB_CANCEL,
    662                              wk->hwndFrame,
    663                              GetPString(IDS_ERRORTEXT),
    664                              "%s", GetPString(IDS_NOTWRITENOTARGETTEXT));
    665                       goto RetryPath;
    666                     }
    667                   }
    668                 Retry:
    669                   {
    670                     CHAR newname[CCHMAXPATH], *moving, *move, *moved;
    671                     APIRET rc;
    672                     INT type;
    673                     FILESTATUS4L fs4;
    674                     BOOL isnewer, existed;
    675 
    676                     type = (wk->li->type == IDM_RENAME) ? MOVE :
    677                       (wk->li->type == IDM_MOVE) ? MOVE :
    678                       (wk->li->type == IDM_WPSMOVE) ? WPSMOVE :
    679                       (wk->li->type == IDM_WPSCOPY) ? WPSCOPY : COPY;
    680                     moving = (wk->li->type == IDM_RENAME) ?
    681                       GetPString(IDS_RENAMINGTEXT) :
    682                       (wk->li->type == IDM_MOVE ||
    683                        wk->li->type == IDM_WPSMOVE) ?
    684                       GetPString(IDS_MOVINGTEXT) : GetPString(IDS_COPYINGTEXT);
    685                     move = (wk->li->type == IDM_RENAME) ?
    686                       GetPString(IDS_RENAMETEXT) :
    687                       (wk->li->type == IDM_MOVE ||
    688                        wk->li->type == IDM_WPSMOVE) ?
    689                       GetPString(IDS_MOVETEXT) : GetPString(IDS_COPYTEXT);
    690                     moved = (wk->li->type == IDM_RENAME) ?
    691                       GetPString(IDS_RENAMEDTEXT) :
    692                       (wk->li->type == IDM_MOVE ||
    693                        wk->li->type == IDM_WPSMOVE) ?
    694                       GetPString(IDS_MOVEDTEXT) : GetPString(IDS_COPIEDTEXT);
    695                     if (*wk->li->targetpath) {
    696                       strcpy(newname, wk->li->targetpath);
    697                       if (newname[strlen(newname) - 1] != '\\')
    698                         strcat(newname, "\\");
    699                       if (plen)
    700                         p = wk->li->list[x] + plen;
    701                       else {
    702                         p = strrchr(wk->li->list[x], '\\');
    703                         if (p)
    704                           p++;
    705                         else
    706                           p = wk->li->list[x];
    707                       }
    708                       strcat(newname, p);
    709                     }
    710                     else
    711                       strcpy(newname, wk->li->list[x]);
    712                     if ((wildcarding || wk->li->type == IDM_RENAME) &&
    713                         *wildname) {
    714 
    715                       CHAR testname[CCHMAXPATH];
    716 
    717                       strcpy(testname, wildname);
    718                       if (AdjustWildcardName(newname, testname))
    719                         strcpy(newname, testname);
    720                     }
    721                     existed = (IsFile(newname) != -1);
    722                     isnewer = IsNewer(wk->li->list[x], newname);
    723                     /*
    724                        {
    725                        char temp[CCHMAXPATH * 3];
    726                        sprintf(temp,"Target: %s\rSource: %s\rOverold: %lu\rOvernew: %lu\rIsNewer: %lu\rExisted: %lu",newname,wk->li->list[x],overold,overnew,isnewer,existed);
    727                        saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,temp);
    728                        }
    729                      */
    730                     if (existed && wk->li->type != IDM_RENAME && dontask) {
    731                       if (!overold && !overnew)
    732                         break;
    733                       if (!overold && !isnewer)
    734                         break;
    735                       if (!overnew && isnewer)
    736                         break;
    737                     }
    738                     if ((wk->li->type == IDM_RENAME &&
    739                         (!dontask || !*wildname)) ||
    740                         (!dontask && existed) ||
    741                         (!dontask && wildcarding) ||
    742                         (IsFile(newname) == 0 && IsFile(wk->li->list[x]) > 0)) {
    743 
    744                       MOVEIT mv;
    745 
    746                       memset(&mv, 0, sizeof(MOVEIT));
    747                       mv.rename = (wk->li->type == IDM_RENAME);
    748                       mv.source = wk->li->list[x];
    749                       strcpy(mv.target, newname);
    750                       rc = WinDlgBox(HWND_DESKTOP,
    751                                      wk->hwndFrame,
    752                                      RenameProc,
    753                                      FM3ModHandle, REN_FRAME, (PVOID) & mv);
    754                       if (!rc)
    755                         goto Abort;
    756                       DosSleep(1);
    757                       if (mv.skip || !*mv.target)
    758                         break;
    759                       if (mv.dontask)
    760                         dontask = TRUE;
    761                       if (mv.overold)
    762                         overold = TRUE;
    763                       if (mv.overnew)
    764                         overnew = TRUE;
    765                       if (wildcarding || wk->li->type == IDM_RENAME) {
    766                         p = strrchr(mv.target, '\\');
    767                         if (p && (strchr(p, '*') || strchr(p, '?'))) {
    768                           strcpy(wildname, mv.target);
    769                           AdjustWildcardName(wk->li->list[x], mv.target);
    770                         }
    771                         else
    772                           *wildname = 0;
    773                       }
    774                       strcpy(newname, mv.target);
    775                       existed = (IsFile(newname) != -1);
    776                       isnewer = IsNewer(wk->li->list[x], newname);
    777                       if (!mv.overwrite) {
    778                         if (existed && wk->li->type != IDM_RENAME && dontask) {
    779                           if (!overold && !overnew)
    780                             break;
    781                           if (!overold && !isnewer)
    782                             break;
    783                           if (!overnew && isnewer)
    784                             break;
    785                         }
    786                       }
    787                     }
    788                     if (!strcmp(wk->li->list[x], newname) ||
    789                         (wk->li->type == IDM_COPY &&
    790                         !stricmp(wk->li->list[x], newname)))
    791                       break;
    792                     sprintf(message,
    793                             " %s \"%s\" %s\"%s\"%s",
    794                             moving,
    795                             wk->li->list[x],
    796                             GetPString(IDS_TOTEXT),
    797                             newname,
    798                             (usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
    799                             NullStr);
    800                     AddNote(message);
    801                     if (plen) {
    802                       /* make directory/ies, if required */
    803 
    804                       CHAR dirpart[CCHMAXPATH];
    805 
    806                       strcpy(dirpart, newname);
    807                       p = strrchr(dirpart, '\\');
    808                       if (p) {
    809                         *p = 0;
    810                         if (p > dirpart + 3)
    811                           MassMkdir((hwndMain) ? hwndMain : wk->hwndCnr,
    812                                     dirpart);
    813                       }
    814                     }
    815                     if (fRealIdle)
    816                       priority_idle();
    817                     rc = docopyf(type, wk->li->list[x], "%s", newname);
    818                     priority_normal();
    819                     if (rc) {
    820                       if ((rc == ERROR_DISK_FULL ||
    821                            rc == ERROR_HANDLE_DISK_FULL) &&
    822                           isalpha(*newname) &&
    823                           (driveflags[toupper(*newname) - 'A'] &
    824                            DRIVE_REMOVABLE)
    825                           && !(driveflags[toupper(*newname) - 'A'] &
    826                                DRIVE_NOTWRITEABLE)
    827                           && toupper(*newname) != toupper(*wk->li->list[x])
    828                           && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZEL,
    829                                                &fs4, sizeof(fs4))
    830                           && !(fs4.attrFile & FILE_DIRECTORY)) {
    831 
    832                         FSALLOCATE fsa;
    833                         ULONGLONG ullFreeBytes;
    834                         CHAR *ptr;
    835                         INT cntr;
    836 
    837                         Notify(GetPString(IDS_FITTINGTEXT));
    838                         DosError(FERR_DISABLEHARDERR);
    839                         if (!DosQueryFSInfo(toupper(*newname) - '@',
    840                                             FSIL_ALLOC,
    841                                             &fsa, sizeof(FSALLOCATE))) {
    842                           // Assume large file support
    843                           ullFreeBytes = (ULONGLONG) fsa.cUnitAvail * fsa.cSectorUnit *
    844                             fsa.cbSector;
    845                           if (ullFreeBytes) {
    846                             // Find item that will fit in available space
    847                             for (cntr = x + 1; wk->li->list[cntr]; cntr++) {
    848                               DosError(FERR_DISABLEHARDERR);
    849                               if (!DosQueryPathInfo(wk->li->list[cntr],
    850                                                     FIL_QUERYEASIZEL,
    851                                                     &fs4,
    852                                                     sizeof(fs4)) &&
    853                                   !(fs4.attrFile & FILE_DIRECTORY) &&
    854                                   // fixme to use CBLIST_TO_EASIZE?
    855                                   fs4.cbFile + fs4.cbList <= ullFreeBytes) {
    856                                 // Swap with failing item
    857                                 ptr = wk->li->list[x];
    858                                 wk->li->list[x] = wk->li->list[cntr];
    859                                 wk->li->list[cntr] = ptr;
    860                                 goto Retry;
    861                               }
    862                             }
    863                             Notify(GetPString(IDS_COULDNTFITTEXT));
    864                           }
    865                         }
    866                         rc = saymsg(MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION,
    867                                     wk->hwndFrame,
    868                                     GetPString(IDS_DISKFULLTEXT),
    869                                     "%s", GetPString(IDS_ANOTHERDISKTEXT));
    870                         if (rc == MBID_RETRY)
    871                           goto Retry;
    872                         if (rc == MBID_ABORT)
    873                           goto Abort;
    874                       }
    875                       else {
    876                         if (LogFileHandle)
    877                           fprintf(LogFileHandle,
    878                                   GetPString(IDS_LOGTOFAILEDTEXT),
    879                                   move, wk->li->list[x], newname, rc);
    880                         rc = Dos_Error(MB_ENTERCANCEL,
    881                                        rc,
    882                                        wk->hwndFrame,
    883                                        pszSrcFile,
    884                                        __LINE__,
    885                                        "%s %s \"%s\" %s\"%s\" %s.",
    886                                        move,
    887                                        GetPString(IDS_OFTEXT),
    888                                        wk->li->list[x],
    889                                        GetPString(IDS_TOTEXT),
    890                                        newname, GetPString(IDS_FAILEDTEXT));
    891                         if (rc == MBID_CANCEL)
    892                           goto Abort;
    893                       }
    894                     }
    895                     else {
    896                       if (LogFileHandle)
    897                         fprintf(LogFileHandle,
    898                                 "%s \"%s\" %s\"%s\"\n",
    899                                 moved,
    900                                 wk->li->list[x],
    901                                 GetPString(IDS_TOTEXT), newname);
    902                       if (//fSyncUpdates ||
    903                           AddToList(wk->li->list[x],
    904                                     &files, &numfiles, &numalloc))
    905                         Broadcast(hab2,
    906                                   wk->hwndCnr,
    907                                   UM_UPDATERECORD,
    908                                   MPFROMP(wk->li->list[x]), MPVOID);
    909                       if (//fSyncUpdates ||
    910                           AddToList(newname, &files, &numfiles, &numalloc))
    911                         Broadcast(hab2,
    912                                   wk->hwndCnr,
    913                                   UM_UPDATERECORD, MPFROMP(newname), MPVOID);
    914                     }
    915                   }
    916                   break;
    917                 }
     605              case IDM_RENAME:
     606                {
     607
     608                  if (!*wk->li->targetpath && (wk->li->type == IDM_MOVE ||
     609                                               wk->li->type == IDM_COPY ||
     610                                               wk->li->type == IDM_WPSMOVE ||
     611                                               wk->li->type == IDM_WPSCOPY)) {
     612
     613                    APIRET rc = 1;
     614
     615                    usedtarget = FALSE;
     616                    if (hwndMain) {
     617                      if (!*targetdir)
     618                        TopWindowName(hwndMain,
     619                                      wk->hwndFrame, wk->li->targetpath);
     620                      else {
     621                        strcpy(wk->li->targetpath, targetdir);
     622                        usedtarget = TRUE;
     623                      }
     624                    }
     625                    if (!*wk->li->targetpath)
     626                      strcpy(wk->li->targetpath, wk->directory);
     627                    if (!*wk->li->targetpath) {
     628                      strcpy(wk->li->targetpath, wk->li->list[0]);
     629                      p = strrchr(wk->li->targetpath, '\\');
     630                      if (p) {
     631                        if (*(p - 1) == ':')
     632                          p++;
     633                        *p = 0;
     634                      }
     635                    }
     636                    MakeValidDir(wk->li->targetpath);
     637                    if (fConfirmTarget ||
     638                        (!*targetdir && strcmp(realappname, "FM/4"))) {
     639                    RetryPath:
     640                      usedtarget = FALSE;
     641                      if (wk->li->type == IDM_MOVE ||
     642                          wk->li->type == IDM_WPSMOVE) {
     643                        rc = WinDlgBox(HWND_DESKTOP,
     644                                       wk->hwndFrame,
     645                                       WalkMoveDlgProc,
     646                                       FM3ModHandle,
     647                                       WALK_FRAME, MPFROMP(wk->li->targetpath));
     648                      }
     649                      else if (wk->li->type == IDM_COPY ||
     650                               wk->li->type == IDM_WPSCOPY) {
     651                        rc = WinDlgBox(HWND_DESKTOP,
     652                                       wk->hwndFrame,
     653                                       WalkCopyDlgProc,
     654                                       FM3ModHandle,
     655                                       WALK_FRAME, MPFROMP(wk->li->targetpath));
     656                      }
     657                      else
     658                        rc = WinDlgBox(HWND_DESKTOP,
     659                                       wk->hwndFrame,
     660                                       WalkDlgProc,
     661                                       FM3ModHandle,
     662                                       WALK_FRAME, MPFROMP(wk->li->targetpath));
     663                    }
     664                    if (!rc || !*wk->li->targetpath)
     665                      goto Abort;
     666                    if (driveflags[toupper(*wk->li->targetpath) - 'A'] &
     667                        DRIVE_NOTWRITEABLE) {
     668                      saymsg(MB_CANCEL,
     669                             wk->hwndFrame,
     670                             GetPString(IDS_ERRORTEXT),
     671                             "%s", GetPString(IDS_NOTWRITENOTARGETTEXT));
     672                      goto RetryPath;
     673                    }
     674                  }
     675                Retry:
     676                  {
     677                    CHAR newname[CCHMAXPATH], *moving, *move, *moved;
     678                    APIRET rc;
     679                    INT type;
     680                    FILESTATUS4L fs4;
     681                    BOOL isnewer, existed;
     682
     683                    type = (wk->li->type == IDM_RENAME) ? MOVE :
     684                      (wk->li->type == IDM_MOVE) ? MOVE :
     685                      (wk->li->type == IDM_WPSMOVE) ? WPSMOVE :
     686                      (wk->li->type == IDM_WPSCOPY) ? WPSCOPY : COPY;
     687                    moving = (wk->li->type == IDM_RENAME) ?
     688                      GetPString(IDS_RENAMINGTEXT) :
     689                      (wk->li->type == IDM_MOVE ||
     690                       wk->li->type == IDM_WPSMOVE) ?
     691                      GetPString(IDS_MOVINGTEXT) : GetPString(IDS_COPYINGTEXT);
     692                    move = (wk->li->type == IDM_RENAME) ?
     693                      GetPString(IDS_RENAMETEXT) :
     694                      (wk->li->type == IDM_MOVE ||
     695                       wk->li->type == IDM_WPSMOVE) ?
     696                      GetPString(IDS_MOVETEXT) : GetPString(IDS_COPYTEXT);
     697                    moved = (wk->li->type == IDM_RENAME) ?
     698                      GetPString(IDS_RENAMEDTEXT) :
     699                      (wk->li->type == IDM_MOVE ||
     700                       wk->li->type == IDM_WPSMOVE) ?
     701                      GetPString(IDS_MOVEDTEXT) : GetPString(IDS_COPIEDTEXT);
     702                    if (*wk->li->targetpath) {
     703                      strcpy(newname, wk->li->targetpath);
     704                      if (newname[strlen(newname) - 1] != '\\')
     705                        strcat(newname, "\\");
     706                      if (plen)
     707                        p = wk->li->list[x] + plen;
     708                      else {
     709                        p = strrchr(wk->li->list[x], '\\');
     710                        if (p)
     711                          p++;
     712                        else
     713                          p = wk->li->list[x];
     714                      }
     715                      strcat(newname, p);
     716                    }
     717                    else
     718                      strcpy(newname, wk->li->list[x]);
     719                    if ((wildcarding || wk->li->type == IDM_RENAME) &&
     720                        *wildname) {
     721
     722                      CHAR testname[CCHMAXPATH];
     723
     724                      strcpy(testname, wildname);
     725                      if (AdjustWildcardName(newname, testname))
     726                        strcpy(newname, testname);
     727                    }
     728                    existed = (IsFile(newname) != -1);
     729                    isnewer = IsNewer(wk->li->list[x], newname);
     730                    /*
     731                       {
     732                       char temp[CCHMAXPATH * 3];
     733                       sprintf(temp,"Target: %s\rSource: %s\rOverold: %lu\rOvernew: %lu\rIsNewer: %lu\rExisted: %lu",newname,wk->li->list[x],overold,overnew,isnewer,existed);
     734                       saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,temp);
     735                       }
     736                     */
     737                    if (existed && wk->li->type != IDM_RENAME && dontask) {
     738                      if (!overold && !overnew)
     739                        break;
     740                      if (!overold && !isnewer)
     741                        break;
     742                      if (!overnew && isnewer)
     743                        break;
     744                    }
     745                    if ((wk->li->type == IDM_RENAME &&
     746                        (!dontask || !*wildname)) ||
     747                        (!dontask && existed) ||
     748                        (!dontask && wildcarding) ||
     749                        (IsFile(newname) == 0 && IsFile(wk->li->list[x]) > 0)) {
     750
     751                      MOVEIT mv;
     752
     753                      memset(&mv, 0, sizeof(MOVEIT));
     754                      mv.rename = (wk->li->type == IDM_RENAME);
     755                      mv.source = wk->li->list[x];
     756                      strcpy(mv.target, newname);
     757                      rc = WinDlgBox(HWND_DESKTOP,
     758                                     wk->hwndFrame,
     759                                     RenameProc,
     760                                     FM3ModHandle, REN_FRAME, (PVOID) & mv);
     761                      if (!rc)
     762                        goto Abort;
     763                      DosSleep(1);
     764                      if (mv.skip || !*mv.target)
     765                        break;
     766                      if (mv.dontask)
     767                        dontask = TRUE;
     768                      if (mv.overold)
     769                        overold = TRUE;
     770                      if (mv.overnew)
     771                        overnew = TRUE;
     772                      if (wildcarding || wk->li->type == IDM_RENAME) {
     773                        p = strrchr(mv.target, '\\');
     774                        if (p && (strchr(p, '*') || strchr(p, '?'))) {
     775                          strcpy(wildname, mv.target);
     776                          AdjustWildcardName(wk->li->list[x], mv.target);
     777                        }
     778                        else
     779                          *wildname = 0;
     780                      }
     781                      strcpy(newname, mv.target);
     782                      existed = (IsFile(newname) != -1);
     783                      isnewer = IsNewer(wk->li->list[x], newname);
     784                      if (!mv.overwrite) {
     785                        if (existed && wk->li->type != IDM_RENAME && dontask) {
     786                          if (!overold && !overnew)
     787                            break;
     788                          if (!overold && !isnewer)
     789                            break;
     790                          if (!overnew && isnewer)
     791                            break;
     792                        }
     793                      }
     794                    }
     795                    if (!strcmp(wk->li->list[x], newname) ||
     796                        (wk->li->type == IDM_COPY &&
     797                        !stricmp(wk->li->list[x], newname)))
     798                      break;
     799                    sprintf(message,
     800                            " %s \"%s\" %s\"%s\"%s",
     801                            moving,
     802                            wk->li->list[x],
     803                            GetPString(IDS_TOTEXT),
     804                            newname,
     805                            (usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
     806                            NullStr);
     807                    AddNote(message);
     808                    if (plen) {
     809                      /* make directory/ies, if required */
     810
     811                      CHAR dirpart[CCHMAXPATH];
     812
     813                      strcpy(dirpart, newname);
     814                      p = strrchr(dirpart, '\\');
     815                      if (p) {
     816                        *p = 0;
     817                        if (p > dirpart + 3)
     818                          MassMkdir((hwndMain) ? hwndMain : wk->hwndCnr,
     819                                    dirpart);
     820                      }
     821                    }
     822                    if (fRealIdle)
     823                      priority_idle();
     824                    rc = docopyf(type, wk->li->list[x], "%s", newname);
     825                    priority_normal();
     826                    if (rc) {
     827                      if ((rc == ERROR_DISK_FULL ||
     828                           rc == ERROR_HANDLE_DISK_FULL) &&
     829                          isalpha(*newname) &&
     830                          (driveflags[toupper(*newname) - 'A'] &
     831                           DRIVE_REMOVABLE)
     832                          && !(driveflags[toupper(*newname) - 'A'] &
     833                               DRIVE_NOTWRITEABLE)
     834                          && toupper(*newname) != toupper(*wk->li->list[x])
     835                          && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZEL,
     836                                               &fs4, sizeof(fs4))
     837                          && !(fs4.attrFile & FILE_DIRECTORY)) {
     838
     839                        FSALLOCATE fsa;
     840                        ULONGLONG ullFreeBytes;
     841                        CHAR *ptr;
     842                        INT cntr;
     843
     844                        Notify(GetPString(IDS_FITTINGTEXT));
     845                        DosError(FERR_DISABLEHARDERR);
     846                        if (!DosQueryFSInfo(toupper(*newname) - '@',
     847                                            FSIL_ALLOC,
     848                                            &fsa, sizeof(FSALLOCATE))) {
     849                          // Assume large file support
     850                          ullFreeBytes = (ULONGLONG) fsa.cUnitAvail * fsa.cSectorUnit *
     851                            fsa.cbSector;
     852                          if (ullFreeBytes) {
     853                            // Find item that will fit in available space
     854                            for (cntr = x + 1; wk->li->list[cntr]; cntr++) {
     855                              DosError(FERR_DISABLEHARDERR);
     856                              if (!DosQueryPathInfo(wk->li->list[cntr],
     857                                                    FIL_QUERYEASIZEL,
     858                                                    &fs4,
     859                                                    sizeof(fs4)) &&
     860                                  !(fs4.attrFile & FILE_DIRECTORY) &&
     861                                  // fixme to use CBLIST_TO_EASIZE?
     862                                  fs4.cbFile + fs4.cbList <= ullFreeBytes) {
     863                                // Swap with failing item
     864                                ptr = wk->li->list[x];
     865                                wk->li->list[x] = wk->li->list[cntr];
     866                                wk->li->list[cntr] = ptr;
     867                                goto Retry;
     868                              }
     869                            }
     870                            Notify(GetPString(IDS_COULDNTFITTEXT));
     871                          }
     872                        }
     873                        rc = saymsg(MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION,
     874                                    wk->hwndFrame,
     875                                    GetPString(IDS_DISKFULLTEXT),
     876                                    "%s", GetPString(IDS_ANOTHERDISKTEXT));
     877                        if (rc == MBID_RETRY)
     878                          goto Retry;
     879                        if (rc == MBID_ABORT)
     880                          goto Abort;
     881                      }
     882                      else {
     883                        if (LogFileHandle)
     884                          fprintf(LogFileHandle,
     885                                  GetPString(IDS_LOGTOFAILEDTEXT),
     886                                  move, wk->li->list[x], newname, rc);
     887                        rc = Dos_Error(MB_ENTERCANCEL,
     888                                       rc,
     889                                       wk->hwndFrame,
     890                                       pszSrcFile,
     891                                       __LINE__,
     892                                       "%s %s \"%s\" %s\"%s\" %s.",
     893                                       move,
     894                                       GetPString(IDS_OFTEXT),
     895                                       wk->li->list[x],
     896                                       GetPString(IDS_TOTEXT),
     897                                       newname, GetPString(IDS_FAILEDTEXT));
     898                        if (rc == MBID_CANCEL)
     899                          goto Abort;
     900                      }
     901                    }
     902                    else {
     903                      if (LogFileHandle)
     904                        fprintf(LogFileHandle,
     905                                "%s \"%s\" %s\"%s\"\n",
     906                                moved,
     907                                wk->li->list[x],
     908                                GetPString(IDS_TOTEXT), newname);
     909                      if (//fSyncUpdates ||
     910                          AddToList(wk->li->list[x],
     911                                    &files, &numfiles, &numalloc))
     912                        Broadcast(hab2,
     913                                  wk->hwndCnr,
     914                                  UM_UPDATERECORD,
     915                                  MPFROMP(wk->li->list[x]), MPVOID);
     916                      if (//fSyncUpdates ||
     917                          AddToList(newname, &files, &numfiles, &numalloc))
     918                        Broadcast(hab2,
     919                                  wk->hwndCnr,
     920                                  UM_UPDATERECORD, MPFROMP(newname), MPVOID);
     921                    }
     922                  }
     923                  break;
     924                }
    918925
    919926              case IDM_COMPARE:
    … …  
    11101117              if (DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT |
    11111118                                SEARCH_CUR_DIRECTORY,
    1112                                 "PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
     1119                                "PATH", "FM2PLAY.EXE", (PBYTE)fbuf, CCHMAXPATH - 1))
    11131120                total += strlen("..\\FM2UTILS\\FM2PLAY.EXE ");
    11141121              else
    … …  
    11591166                if (DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT |
    11601167                                  SEARCH_CUR_DIRECTORY,
    1161                                   "PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
     1168                                  "PATH", "FM2PLAY.EXE", (PBYTE)fbuf, CCHMAXPATH - 1))
    11621169                  strcpy(szBuffer, "UTILS\\FM2PLAY.EXE");
    11631170                else
    … …  
    12291236
    12301237          case IDM_APPENDTOCLIP:
    1231           case IDM_SAVETOCLIP:
    1232           case IDM_SAVETOCLIPFILENAME:
    1233           case IDM_APPENDTOCLIPFILENAME:
     1238          case IDM_SAVETOCLIP:
     1239          case IDM_SAVETOCLIPFILENAME:
     1240          case IDM_APPENDTOCLIPFILENAME:
    12341241            ListToClipboardHab(hab2,
    12351242                               wk->li->list,
    … …  
    12851292                  strcat(ad.arcname, "\\");
    12861293              }
    1287               if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle,
    1288                              ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
     1294              if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle,
     1295                             ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
    12891296                break;
    12901297              // Provide extension so containers work
    … …  
    14731480              if (wk->li && wk->li->list && wk->li->list[0]) {
    14741481                strcpy(wk->li->targetpath, printer);
    1475                 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) wk->li)
    1476                     == -1)
    1477                   Runtime_Error(pszSrcFile, __LINE__,
    1478                                 GetPString(IDS_COULDNTSTARTTHREADTEXT));
    1479                 else
    1480                   wk->li = NULL;        /* prevent LISTINFO li from being freed */
     1482                if (xbeginthread(PrintListThread,
     1483                                 65536,
     1484                                 wk->li,
     1485                                 pszSrcFile,
     1486                                 __LINE__) != -1)
     1487                {
     1488                  wk->li = NULL;        // prevent LISTINFO li from being freed here
     1489                }
    14811490              }
    14821491            }
    … …  
    15041513              CHAR prompt[CCHMAXPATH * 3];
    15051514              APIRET error = 0;
    1506               HOBJECT hObjectdest, hObjectofObject;
    1507               BYTE G_abSupportedDrives[24] = {0};
    1508               ULONG cbSupportedDrives = sizeof(G_abSupportedDrives);
     1515              HOBJECT hObjectdest, hObjectofObject;
     1516              BYTE G_abSupportedDrives[24] = {0};
     1517              ULONG cbSupportedDrives = sizeof(G_abSupportedDrives);
    15091518
    15101519              for (x = 0; wk->li->list[x]; x++) {
    … …  
    16011610                if (!wk->li->list || !wk->li->list[0])
    16021611                  break;
    1603               }
    1604               DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
     1612              }
     1613              DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    16051614              for (x = 0; wk->li->list[x]; x++) {
    16061615                fsa.attrFile = 0;
    … …  
    16091618                                 FIL_STANDARD,
    16101619                                 &fsa, (ULONG) sizeof(FILESTATUS3));
    1611                 if (fsa.attrFile & FILE_DIRECTORY) {
     1620                if (fsa.attrFile & FILE_DIRECTORY) {
    16121621                  /*sprintf(prompt,
    16131622                          GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
    16141623                  AddNote(prompt);*/ //Duplicate call 12-03-08 GKY
    1615                   DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
     1624                  DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    16161625                  error = (APIRET) wipeallf("%s%s*",
    16171626                                            wk->li->list[x],
    16181627                                            (*wk->li->list[x] &&
    16191628                                             wk->li->
    1620                                              list[x][strlen(wk->li->list[x]) - 1]
    1621                                              != '\\') ? "\\" : NullStr);
     1629                                             list[x][strlen(wk->li->list[x]) - 1]
     1630                                             != '\\') ? "\\" : NullStr);
    16221631                  DosError(FERR_DISABLEHARDERR);
    16231632                  if (!error)
    16241633                    error = DosDeleteDir(wk->li->list[x]);
    16251634                  else
    1626                     DosDeleteDir(wk->li->list[x]);
    1627                   DosReleaseMutexSem(hmtxFM2Delete);
    1628                 }
    1629                 else {
    1630                   DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08
     1635                    DosDeleteDir(wk->li->list[x]);
     1636                  DosReleaseMutexSem(hmtxFM2Delete);
     1637                }
     1638                else {
     1639                  DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08
    16311640                  /*sprintf(prompt,
    16321641                          GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
    … …  
    16351644                  if (wk->li->type == IDM_DELETE){
    16361645                    hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
    1637                     PrfQueryProfileData(HINI_USER,
    1638                                         "XWorkplace",
    1639                                         "TrashCan::Drives",
    1640                                         G_abSupportedDrives,
    1641                                         &cbSupportedDrives);
    1642                     if (hObjectdest != NULLHANDLE && fTrashCan &&
    1643                         (G_abSupportedDrives ? (G_abSupportedDrives[toupper(*wk->li->list[x]) - 'C'] &
    1644                                                 1):(!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
    1645                                                       (DRIVE_REMOVABLE | DRIVE_IGNORE |
    1646                                                       DRIVE_REMOTE | DRIVE_VIRTUAL |
    1647                                                       DRIVE_NOTWRITEABLE | DRIVE_RAMDISK))))) {
    1648                         hObjectofObject = WinQueryObject(wk->li->list[x]);
    1649                         error = WinMoveObject(hObjectofObject, hObjectdest, 0);
    1650                     }
    1651                     else {
    1652                       //DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    1653                       error = DosDelete(wk->li->list[x]);
    1654                       //DosReleaseMutexSem(hmtxFM2Delete);
    1655                     }
     1646                    PrfQueryProfileData(HINI_USER,
     1647                                        "XWorkplace",
     1648                                        "TrashCan::Drives",
     1649                                        G_abSupportedDrives,
     1650                                        &cbSupportedDrives);
     1651                    if (hObjectdest != NULLHANDLE && fTrashCan &&
     1652                        (G_abSupportedDrives ? (G_abSupportedDrives[toupper(*wk->li->list[x]) - 'C'] &
     1653                                                1):(!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
     1654                                                      (DRIVE_REMOVABLE | DRIVE_IGNORE |
     1655                                                      DRIVE_REMOTE | DRIVE_VIRTUAL |
     1656                                                      DRIVE_NOTWRITEABLE | DRIVE_RAMDISK))))) {
     1657                        hObjectofObject = WinQueryObject(wk->li->list[x]);
     1658                        error = WinMoveObject(hObjectofObject, hObjectdest, 0);
     1659                    }
     1660                    else {
     1661                      //DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
     1662                      error = DosDelete(wk->li->list[x]);
     1663                      //DosReleaseMutexSem(hmtxFM2Delete);
     1664                    }
    16561665                  }
    16571666                  else {
    1658                     //DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    1659                     error = DosForceDelete(wk->li->list[x]);
    1660                     //DosReleaseMutexSem(hmtxFM2Delete);
    1661                   }
     1667                    //DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
     1668                    error = DosForceDelete(wk->li->list[x]);
     1669                    //DosReleaseMutexSem(hmtxFM2Delete);
     1670                  }
    16621671                  if (error) {
    16631672                    DosError(FERR_DISABLEHARDERR);
    16641673                    make_deleteable(wk->li->list[x]);
    16651674                    if (wk->li->type == IDM_DELETE){
    1666                       hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
    1667                       PrfQueryProfileData(HINI_USER,
    1668                                           "XWorkplace",
    1669                                           "TrashCan::Drives",
    1670                                           G_abSupportedDrives,
    1671                                           &cbSupportedDrives);
    1672                       if (hObjectdest != NULLHANDLE && fTrashCan &&
    1673                           (G_abSupportedDrives ? (G_abSupportedDrives[toupper(*wk->li->list[x]) - 'C'] &
    1674                                                   1):(!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
    1675                                                         (DRIVE_REMOVABLE | DRIVE_IGNORE |
    1676                                                         DRIVE_REMOTE | DRIVE_VIRTUAL |
    1677                                                         DRIVE_NOTWRITEABLE | DRIVE_RAMDISK))))) {
    1678                           hObjectofObject = WinQueryObject(wk->li->list[x]);
    1679                           error = WinMoveObject(hObjectofObject, hObjectdest, 0);
    1680                       }
     1675                      hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
     1676                      PrfQueryProfileData(HINI_USER,
     1677                                          "XWorkplace",
     1678                                          "TrashCan::Drives",
     1679                                          G_abSupportedDrives,
     1680                                          &cbSupportedDrives);
     1681                      if (hObjectdest != NULLHANDLE && fTrashCan &&
     1682                          (G_abSupportedDrives ? (G_abSupportedDrives[toupper(*wk->li->list[x]) - 'C'] &
     1683                                                  1):(!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
     1684                                                        (DRIVE_REMOVABLE | DRIVE_IGNORE |
     1685                                                        DRIVE_REMOTE | DRIVE_VIRTUAL |
     1686                                                        DRIVE_NOTWRITEABLE | DRIVE_RAMDISK))))) {
     1687                          hObjectofObject = WinQueryObject(wk->li->list[x]);
     1688                          error = WinMoveObject(hObjectofObject, hObjectdest, 0);
     1689                      }
    16811690                      else {
    1682                        // DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    1683                         error = DosDelete(wk->li->list[x]);
    1684                        // DosReleaseMutexSem(hmtxFM2Delete);
    1685                       }
     1691                       // DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
     1692                        error = DosDelete(wk->li->list[x]);
     1693                       // DosReleaseMutexSem(hmtxFM2Delete);
     1694                      }
    16861695                    }
    16871696                    else {
    1688                       //DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
    1689                       error = DosForceDelete(wk->li->list[x]);
    1690                       //DosReleaseMutexSem(hmtxFM2Delete);
    1691                     }
    1692                   }
    1693                   DosReleaseMutexSem(hmtxFM2Delete);
    1694                 }
     1697                      //DosRequestMutexSem(hmtxFM2Delete, SEM_INDEFINITE_WAIT); // Prevent race 12-3-08 GKY
     1698                      error = DosForceDelete(wk->li->list[x]);
     1699                      //DosReleaseMutexSem(hmtxFM2Delete);
     1700                    }
     1701                  }
     1702                  DosReleaseMutexSem(hmtxFM2Delete);
     1703                }
    16951704                if (error) {
    16961705                  if (LogFileHandle)
    … …  
    17161725                }
    17171726                if (//fSyncUpdates ||
    1718                     AddToList(wk->li->list[x], &files, &numfiles, &numalloc)) {
     1727                    AddToList(wk->li->list[x], &files, &numfiles, &numalloc)) {
    17191728                  Broadcast(hab2,
    17201729                            wk->hwndCnr,
    17211730                            UM_UPDATERECORD,
    1722                             MPFROMP(wk->li->list[x]), MPVOID);
    1723                 }
    1724               }
     1731                            MPFROMP(wk->li->list[x]), MPVOID);
     1732                }
     1733              } // for
    17251734            }
    17261735            break;
    … …  
    17411750      }
    17421751    }
    1743     if (wk->li)
    1744       FreeListInfo(wk->li);
     1752    FreeListInfo(wk->li);
    17451753    free(wk);
    17461754#   ifdef FORTIFY
Note: See TracChangeset for help on using the changeset viewer.