/*++ Copyright (c) 1988-1999 Microsoft Corporation Module Name: cfile.c Abstract: File manipulation support --*/ #include "cmd.h" #define Wild(spec) ((spec)->flags & (CI_NAMEWILD)) extern int LastRetCode ; extern jmp_buf CmdJBuf2 ; extern TCHAR Fmt19[], Fmt17[]; extern TCHAR CurDrvDir[] ; extern TCHAR YesChar, NoChar ; extern TCHAR *SaveDir ; extern TCHAR PathChar, TmpBuf[], SwitChar; extern unsigned DosErr ; extern unsigned flgwd ; /* M021 */ extern int LastRetCode ; extern BOOL CtrlCSeen; extern PTCHAR pszTitleCur; extern BOOLEAN fTitleChanged; // // Internal prototypes // PCPYINFOSetFsSetSaveDir() ; /*** ErrorDisplayAndJumnp - handle errors * * Purpose: * eRename and eMove error handler. Returns to routine via longjmp * * ErrorDisplayAndJump(unsigned int errmsg) * * * Args: * errmsg - the error message to print * */ void ErrorDisplayAndJump( unsigned int errmsg ) { PutStdErr( errmsg, NOARGS ); RestoreSavedDirectory( ); longjmp( CmdJBuf2, 1 ) ; } /* ** This routine returns the longest pathlength possible from the input path ** It assumes that the input path is a buffer that it can extend by a ** wildcard '\*' to search the file, if it is a directory. ** The input path must be fully qualified, eg: "c:\winnt\system32\kernel32.dll" ** ** Input: ** pPath fully qualified Pathname ** pCch pointer to length of pathname ** Returns: ** TRUE succeeded, pCch contains length ** FALSE error occurred */ BOOL GreatestLength( TCHAR *pPath, int *pCch ) { WIN32_FIND_DATA fd; HANDLE hFind; DWORD err; int cch; int cchThis; DWORD attr; TCHAR *pLast; BOOL MoreFiles; /* assume a file, or empty directory */ *pCch = cch = _tcslen(pPath) - 2; /* _tcslen(TEXT("C:")) */ if ((attr=GetFileAttributes(pPath)) == 0xffffffff) { PutStdErr(GetLastError(), NOARGS); return FALSE; } if ( !(attr & FILE_ATTRIBUTE_DIRECTORY)) { /* if just a file... */ return TRUE; } /* path is a directory, search it ... */ pLast = pPath + _tcslen(pPath); if (*(pLast-1) == BSLASH) { *pLast = STAR; *(pLast+1) = NULLC; } else { *pLast = BSLASH; *(pLast+1) = STAR; *(pLast+2) = NULLC; } if ((hFind=FindFirstFile(pPath, &fd)) == INVALID_HANDLE_VALUE) { // // Check that failure was not due to some system error such // as an abort on access to floppy // err = GetLastError(); FindClose(hFind); if (err != ERROR_FILE_NOT_FOUND && err != ERROR_NO_MORE_FILES) { PutStdErr(err, NOARGS); return FALSE; } return TRUE; } MoreFiles = TRUE; do { if (!_tcscmp(fd.cFileName, TEXT("."))) continue; if (!_tcscmp(fd.cFileName, TEXT(".."))) continue; if (_tcslen( fd.cFileName ) == 0) { continue; } if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { TCHAR path[MAX_PATH]; _tcscpy(path, pPath); *(path+_tcslen(path)-1) = NULLC; /* zap asterisk */ _tcscat(path, fd.cFileName); if (!GreatestLength(path, &cchThis)) break; *pCch = max(*pCch, cch + cchThis); } else { *pCch = max(*pCch, (int) _tcslen(fd.cFileName)); } } while ( MoreFiles = FindNextFile(hFind, &fd) ); err = GetLastError(); FindClose(hFind); if ( MoreFiles ) { return FALSE; } else if ( err != ERROR_NO_MORE_FILES ) { PutStdErr(err, NOARGS); return FALSE; } return TRUE; } void RestoreSavedDirectory( void ) { if (SaveDir) { mystrcpy( CurDrvDir, SaveDir ); SaveDir = NULL; } } BOOL GetPromptOkay( const TCHAR *arg, BOOL *promptokay ) { BOOL Result; const TCHAR *p, *p1; Result = TRUE; if (arg != NULL) { p = arg; while (*p && *p <= SPACE) p += 1; p1 = p; while (*p1 && *p1 > SPACE) p1 += 1; if (!_tcsnicmp(p, TEXT("/Y"),(UINT)(p1-p))) *promptokay = FALSE; else if (!_tcsnicmp(p, TEXT("/-Y"),(UINT)(p1-p))) *promptokay = TRUE; else Result = FALSE; } return Result; } int eCopy(n) struct cmdnode *n ; { return(LastRetCode = copy(n->argptr)) ; } int eDelete(n) struct cmdnode *n ; { int DelWork() ; return(LastRetCode = DelWork(n->argptr)); } /********************* START OF SPECIFICATION **************************/ /* */ /* SUBROUTINE NAME: eRename */ /* */ /* DESCRIPTIVE NAME: Rename Internal Command */ /* */ /* FUNCTION: Rename files and subdirectories. Wildcards only applies */ /* to file names. */ /* */ /* NOTES: @@5* */ /* */ /* ENTRY POINT: eRename */ /* LINKAGE: NEAR */ /* */ /* INPUT: */ /* n - the parse tree node containing the rename command */ /* */ /* OUTPUT: None. */ /* */ /* EXIT-NORMAL: */ /* Return SUCCESS to the caller. */ /* */ /* EXIT-ERROR: */ /* Return FAILURE to the caller. */ /* */ /* EFFECTS: None. */ /* */ /* INTERNAL REFERENCES: */ /* ROUTINES: */ /* RenWork - Worker routine for rename. */ /* */ /* EXTERNAL REFERENCES: */ /* ROUTINES: */ /* None */ /* */ /********************** END OF SPECIFICATION **************************/ int eRename(n) struct cmdnode *n ; { int RenWork(); /* @@ */ return(LastRetCode = RenWork( n )); /* @@ */ } /********************* START OF SPECIFICATION **************************/ /* */ /* SUBROUTINE NAME: RenWork */ /* */ /* DESCRIPTIVE NAME: Rename Internal Command Worker */ /* */ /* FUNCTION: Rename files and subdirectories. Wildcards only applies */ /* to file names. */ /* */ /* NOTES: @@5* */ /* */ /* ENTRY POINT: RenWork */ /* LINKAGE: NEAR */ /* */ /* INPUT: */ /* n - The parse tree node containing the rename command */ /* */ /* OUTPUT: None. */ /* */ /* EXIT-NORMAL: */ /* Return SUCCESS to the caller. */ /* */ /* EXIT-ERROR: */ /* Return FAILURE to the caller. */ /* */ /* EFFECTS: None. */ /* */ /* INTERNAL REFERENCES: */ /* ROUTINES: */ /* ffirst - Find the first matching specified file. */ /* fnext - Find the next matching specified file handle*/ /* findclose - Close the file with the specified file handle, */ /* hnFirst which is given by ffirst or fnext. */ /* TokStr - Tokenize argument strings. */ /* wildcard_rename - Obtain name based on wildcard specification.*/ /* SetFsSetSaveDir - Save the current directory. */ /* GetDir - Get the specified directory. */ /* ChangeDir - Change to the specified directory. */ /* PutStdErr - Displays an error message. */ /* Wild - check if the arg contains wild card. */ /* */ /* EXTERNAL REFERENCES: */ /* ROUTINES: */ /* None */ /* DOSMOVE - Rename file and directory names. */ /* DOSCASEMAP - Change lower case character to upper case. */ /* DOSFILEMODE - Get attribute of specified file. */ /* */ /********************** END OF SPECIFICATION **************************/ int RenWork(n) /* @@ */ struct cmdnode *n ; { TCHAR *arg1 ; /* Ptr to 1st arg */ TCHAR *arg2 ; /* Ptr to 2nd arg */ PCPYINFO a1info ; /* Holds arg1 fspec info */ PCPYINFO SetFsSetSaveDir(); TCHAR Source[MAX_PATH]; TCHAR bufdst[MAX_PATH]; /* path of destination file*/ TCHAR Replacement[MAX_PATH]; int wlen; /* length of source path */ int rc; /* return code */ HANDLE hnFirst ; /* Findfirst handle */ unsigned attr ; unsigned i; /* Temp Return Code */ TCHAR *j ; /* Temp Ptr to dir name */ unsigned wild_flag ; /* wildcard flag */ TCHAR pcstr[3] ; unsigned retval = SUCCESS; DEBUG((FCGRP, RELVL, "RENAME: arptr = `%ws'", n->argptr)) ; if (setjmp(CmdJBuf2)) return(FAILURE) ; /* There should be only two arguments */ if (!*(arg1 = TokStr(n->argptr, NULL, TS_NOFLAGS)) || !*(arg2 = arg1 + mystrlen(arg1) + 1) || *(arg2 + mystrlen(arg2) +1)) { /* @@5g */ ErrorDisplayAndJump( MSG_BAD_SYNTAX ); } mystrcpy( arg1, StripQuotes(arg1) ); /* 509 */ mystrcpy( arg2, StripQuotes(arg2) ); /* 509 */ if ((a1info = SetFsSetSaveDir(arg1)) == (PCPYINFO)FAILURE) { ErrorDisplayAndJump( DosErr ); } mystrcpy( Source, CurDrvDir ); mystrcpy(bufdst,CurDrvDir); /* save path of dest */ wlen = mystrlen( Source ); /* get len of src path */ if ( (a1info->buf->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 ) { mystrcpy(&Source[wlen],a1info->fnptr); } else { Source[--wlen] = NULLC ; bufdst[wlen] = NULLC ; } /* if not wild since */ if (!Wild(a1info)) { a1info->buf->dwFileAttributes = GetFileAttributes( StripQuotes(Source) ); if (a1info->buf->dwFileAttributes == -1 ) { ErrorDisplayAndJump( GetLastError( )) ; } } if (*(arg2+1) == COLON || mystrchr(arg2,PathChar)) { ErrorDisplayAndJump( MSG_BAD_SYNTAX ); } /**********************************************/ /* M009 - Always specifiy drive, filename, */ /* and extension. Note, it is */ /* assumed that SaveDir always starts */ /* with a drive letter */ /**********************************************/ Replacement[0] = CurDrvDir[0] ; /* @@5h */ Replacement[1] = COLON ; /**********************************************/ /* Set flag whether arg1 contains */ /* wildcard or not. */ /**********************************************/ pcstr[0] = STAR ; pcstr[1] = QMARK ; pcstr[2] = NULLC ; wild_flag = ((mystrcspn(arg1,pcstr)) < mystrlen(arg1)) ; /**********************************************/ /* Issue ffirst for a file name */ /**********************************************/ if ( !ffirst(Source, attr = FILE_ATTRIBUTE_ARCHIVE, a1info->buf, &hnFirst )) { /*********************************************/ /* Issue ffirst for a directory name */ /*********************************************/ if (!ffirst(Source, attr = FILE_ATTRIBUTE_DIRECTORY, a1info->buf, &hnFirst )) { if (DosErr == ERROR_NO_MORE_FILES) { DosErr = ERROR_FILE_NOT_FOUND; } ErrorDisplayAndJump( DosErr ); } else { if (wild_flag) { findclose( hnFirst ); ErrorDisplayAndJump( MSG_BAD_SYNTAX ); } } } Source[wlen] = NULLC; /* make filename = NULL */ rc = 0 ; /* @@5 */ do { if (CtrlCSeen) { findclose(hnFirst) ; RestoreSavedDirectory( ); return(FAILURE); } /**********************************************/ /* if the file attribute of Source is */ /* directory then concatenate arg2 after the */ /* last "\" character of bufdst */ /**********************************************/ if ( a1info->buf->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) { /* @@5c*/ j = mystrrchr(bufdst,PathChar) ; /* @@5 */ if ( !j ) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } *(++j) = NULLC; if ( (mystrlen(arg2) + 1 + mystrlen(bufdst)) > MAX_PATH ) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } mystrcpy(j,arg2); /* @@5 */ bufdst[mystrlen(bufdst)] = NULLC ; /* @@5 */ } /* @@5 */ else { /* @@5 */ mystrcpy(&Source[wlen],a1info->buf->cFileName); wildcard_rename( Replacement, arg2, &Source[wlen], MAX_PATH ); if ( (wlen + 1 + mystrlen( Replacement )) > MAX_PATH ) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } mystrcpy(&bufdst[wlen],&Replacement[0]); /*@@4 @J1*/ } /**********************************************/ /* Rename a file or directory */ /**********************************************/ DEBUG((FCGRP, RELVL, "RENAME: src:`%ws', dst:`%ws'", Source, bufdst)) ; if ( !MoveFile( Source, bufdst ) ) { /**********************************************/ /* rename fails */ /**********************************************/ i = GetLastError(); if (i == ERROR_ALREADY_EXISTS) { i = MSG_DUP_FILENAME_OR_NOT_FD; } rc = i ; /* @@5 Save the error code*/ PutStdErr(rc,NOARGS); /* @@5 Put our err message*/ } } while (fnext(a1info->buf, attr, hnFirst )); /**********************************************/ /* No more file is found */ /**********************************************/ findclose(hnFirst) ; RestoreSavedDirectory( ); return( rc ? FAILURE : SUCCESS ); /* @@5 */ } /********************* START OF SPECIFICATION **************************/ /* */ /* SUBROUTINE NAME: eMove */ /* */ /* DESCRIPTIVE NAME: Move Internal Command */ /* */ /* FUNCTION: Parse the parameter passed and */ /* moves one or more files from directory to another */ /* directory on the same drive. If you prefer you can give */ /* the files different names. */ /* */ /* NOTES: ( New routine for Relaese 1.2 ) @@5* */ /* */ /* ENTRY POINT: eMove */ /* LINKAGE: NEAR */ /* */ /* INPUT: */ /* n - the parse tree node containing the copy command */ /* */ /* OUTPUT: None. */ /* */ /* EXIT-NORMAL: */ /* Return SUCCESS to the caller. */ /* */ /* EXIT-ERROR: */ /* Return FAILURE to caller. */ /* */ /* EFFECTS: None. */ /* */ /* INTERNAL REFERENCES: */ /* ROUTINES: */ /* MoveParse - parse move command parameter */ /* Move - routine which actually call DosMove to move */ /* file or directory. */ /* */ /* EXTERNAL REFERENCES: */ /* ROUTINES: */ /* None */ /* */ /********************** END OF SPECIFICATION **************************/ int eMove(n) struct cmdnode *n ; { unsigned i; BOOL PromptOnOverwrite; TCHAR arg1[MAX_PATH] ; /* Ptr to 1st arg */ TCHAR arg2[MAX_PATH] ; /* Ptr to 2nd arg */ PCPYINFO a1info ; /* Holds arg1 fspec info */ unsigned int is_dest_dir; /* generated by MoveParse(), used by Move() */ DEBUG((FCGRP, RELVL, "RENAME: arptr = `%ws'", n->argptr)) ; if (setjmp(CmdJBuf2)) return(LastRetCode = FAILURE) ; // // Get default prompt okay flag from COPYCMD variable. Allow // user to override with /Y or /-Y switch. Always assume /Y // if command executed from inside batch script or via CMD.EXE // command line switch (/C or /K) // if (SingleBatchInvocation || SingleCommandInvocation || CurrentBatchFile != 0) PromptOnOverwrite = FALSE; // Assume /Y else PromptOnOverwrite = TRUE; // Assume /-Y /* MoveParse parses the command line parameters to arg1 */ /* and arg1. In addition, a1info holds the fspec */ /* information for arg1. */ /* Based on arg1 and arg2, Move moves file(s)/directory. */ /* Move uses a1info to determine that arg1 contains */ /* wildcard. */ i = MoveParse( n, &PromptOnOverwrite, arg1, arg2, &a1info, &is_dest_dir, MAX_PATH, MAX_PATH ); if (!i) { i = Move( arg1, arg2, PromptOnOverwrite, a1info, is_dest_dir ) ; } return(LastRetCode = i) ; } /********************* START OF SPECIFICATION **************************/ /* */ /* SUBROUTINE NAME: MoveParse */ /* */ /* DESCRIPTIVE NAME: Move Parser */ /* */ /* FUNCTION: Move Internal Function Parser */ /* */ /* NOTES: This parser breaks up the command line information */ /* into two parameters. */ /* ( New routine for Relaese 1.2 ) @@5* */ /* */ /* ENTRY POINT: MoveParse */ /* LINKAGE: NEAR */ /* */ /* INPUT: */ /* n - the parse tree node containing the move command */ /* */ /* OUTPUT: ptr1 - pointer to [drive:][path]filename to be moved from */ /* ptr2 - pointer to [path]filename to be moved to */ /* a1info - pointer to cpyinfo which has arg1 fspec info */ /* is_dest_dir - flag used by Move() */ /* */ /* EXIT-NORMAL: */ /* Return SUCCESS to the caller. */ /* */ /* EXIT-ERROR: */ /* Return FAILURE to the caller. */ /* */ /* EFFECTS: None. */ /* */ /* INTERNAL REFERENCES: */ /* ROUTINES: */ /* TokStr - Tokenize argument strings. */ /* FullPath - Figure out the full path for a file. */ /* SetFsSetSaveDir - Save current directory. */ /* */ /* EXTERNAL REFERENCES: */ /* ROUTINES: */ /* DOSQFILEMODE - Get file mode of the specified file/dir. */ /* */ /********************** END OF SPECIFICATION **************************/ int MoveParse(n, promptokay, source, target , a1info, is_dest_dir, sizpath1, sizpath2) struct cmdnode *n ; BOOL *promptokay ; TCHAR *source ; /* Ptr to source file(s)/directory name */ TCHAR *target ; /* Ptr to target file(s)/directory name */ PCPYINFO* a1info ; /* Holds arg1 fspec information */ unsigned int *is_dest_dir; /* to pass to move */ unsigned sizpath1; /* size of source buffer */ unsigned sizpath2; /* size of target buffer */ { PCPYINFO SetFsSetSaveDir() ; TCHAR *arg1 ; /* Ptr to 1st arg */ TCHAR *arg2 ; /* Ptr to 2nd arg */ TCHAR *p1; TCHAR *p2; TCHAR arg22[MAX_PATH] ; /* Ptr to modified 2nd arg */ unsigned i; unsigned concat_flag ; unsigned att ; /*509*/unsigned arg1len, arg2len; // // Get default prompt okay flag from COPYCMD variable. Allow // user to override with first token after command. // GetPromptOkay(MyGetEnvVarPtr(TEXT("COPYCMD")), promptokay); arg1 = TokStr(n->argptr, NULL, TS_NOFLAGS); if (GetPromptOkay(arg1, promptokay)) while (*arg1++) ; /* Get arg1. If fail to get arg1, display error message. */ if (!*arg1) { ErrorDisplayAndJump( MSG_BAD_SYNTAX ); } /*509*/ else if ( (arg1len = mystrlen(arg1)) > MAX_PATH) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } /*CurDrvDir = current directory or directory which is specified in arg1*/ /*509*/mystrcpy( arg1, StripQuotes( arg1 ) ); if (((*a1info) = SetFsSetSaveDir(arg1)) == (PCPYINFO)FAILURE) { ErrorDisplayAndJump( DosErr ); } /* */ /* Get arg2 out of arg1 */ arg2 = arg1 + arg1len + 1; if ( !(*arg2) ) { arg22[0] = SaveDir[0]; /* get current drive */ arg22[1] = COLON; arg22[2] = NULLC; } else if (*(arg2 + mystrlen(arg2) + 1)) { /* @@5g */ ErrorDisplayAndJump( MSG_BAD_SYNTAX ); } /*509*/ else if ( (arg2len = mystrlen(arg2)) > MAX_PATH) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } else { /* If arg2 conatins a drive name, display an error message. */ /*509*/ mystrcpy ( arg2, StripQuotes( arg2 ) ); // UNC names fix if ( ( *(arg2+1) != COLON ) && ( ! ( ( *arg2 == BSLASH ) && ( *(arg2+1) == BSLASH ) ) ) ) { arg22[0] = SaveDir[0]; /* get drive we're using */ arg22[1] = COLON; arg22[2] = NULLC; if ((mystrlen(arg22) + mystrlen(arg2)+1) > MAX_PATH) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } mystrcat( arg22, arg2 ) ; } else { mystrcpy(arg22,arg2) ; } } /* source = complete path for arg1 */ if ( i = FullPath(source, arg1,sizpath1) ) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } // // If preserve file name portion from arg1 as FullPath will map *. to * which // is not what the user wants. // if (!((*a1info)->buf->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { p1 = mystrrchr(source,PathChar) ; if (p1 != NULL) p1 += 1; else p1 = source; p2 = mystrrchr((*a1info)->fnptr,PathChar) ; if (p2 == NULL) p2 = (*a1info)->fnptr; mystrcpy(p1, p2); } /* target = complete path for arg2 */ if ( i = FullPath(target, arg22,sizpath2) ) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } concat_flag = FALSE ; DosErr = NO_ERROR ; SetLastError(NO_ERROR); *is_dest_dir = 0; if (*lastc(target) == PathChar) { /* test for last non DBCS character path char @@5@J3 */ concat_flag = TRUE ; target[mystrlen(target)-1] = NULLC ; }; if ( (att = GetFileAttributes( target )) != -1 ) { if (att & FILE_ATTRIBUTE_DIRECTORY) { /* if target is a directory, copy the file */ /* name from source. */ *is_dest_dir = 1; concat_flag = TRUE ; }; } else if ( (DosErr = GetLastError()) && ( ( DosErr != ERROR_FILE_NOT_FOUND ) && ( DosErr != ERROR_PATH_NOT_FOUND ) ) ) { ErrorDisplayAndJump( DosErr ); }; if (concat_flag) { arg1 = mystrrchr(source,PathChar); if ((mystrlen(arg1) + mystrlen(target) + 1) > MAX_PATH) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ); } mystrcat( target, arg1 ) ; }; return(SUCCESS) ; } BOOL MyMoveFile( TCHAR *src, TCHAR *dst, BOOL *promptokay, BOOL *file_moved ) { DWORD dwFlags; dwFlags = MOVEFILE_COPY_ALLOWED; if (!*promptokay) { dwFlags |= MOVEFILE_REPLACE_EXISTING; } *file_moved = FALSE; if (!MoveFileEx(src, dst, dwFlags)) { if (GetLastError() == ERROR_ALREADY_EXISTS) { switch (PromptUser(dst, MSG_MOVE_COPY_OVERWRITE, MSG_NOYESALL_RESPONSE_DATA)) { case 0: // No return TRUE; break; case 2: // All *promptokay = FALSE; default: // Yes dwFlags |= MOVEFILE_REPLACE_EXISTING; return(*file_moved = MoveFileEx(src, dst, dwFlags)); break; } } return FALSE; } else { *file_moved = TRUE; return TRUE; } } /********************* START OF SPECIFICATION **************************/ /* */ /* SUBROUTINE NAME: Move */ /* */ /* DESCRIPTIVE NAME: Move Process */ /* */ /* FUNCTION: Moves one or more files from directory to another */ /* directory on the same drive. If you prefer you can give */ /* the files different names. */ /* */ /* NOTES: ( New routine for Release 1.2 ) @@5* */ /* */ /* ENTRY POINT: eMove */ /* LINKAGE: NEAR */ /* */ /* INPUT: ptr1 - pointer to [drive:][path]filename to be moved from */ /* ptr2 - pointer to [path]filename to be moved to */ /* a1info - pointer to cpyinfo which has arg1 fspec info */ /* is_dest_dir - from MoveParse() */ /* */ /* OUTPUT: None. */ /* */ /* EXIT-NORMAL: */ /* Return Success to the caller. */ /* */ /* EXIT-ERROR: */ /* Return error code from DosMove API. */ /* */ /* EFFECTS: None. */ /* */ /* INTERNAL REFERENCES: */ /* ROUTINES: */ /* ChangeDir - Change back to the original directory. */ /* ffirst - Find the first file which matches the specified */ /* file name that may contain * or ?. */ /* fnext - Find the next file which matches the specified */ /* file name that may contain * or ?. */ /* findclose - Close the file with the specified file handle, */ /* hnFirst which is given by ffirst or fnext. */ /* PutStdErr - Displays an error message. */ /* PutStdOut - Displays a message. */ /* Wild - check if the arg contains wild card. */ /* */ /* EXTERNAL REFERENCES: */ /* ROUTINES: */ /* DOSMOVE - move directories and files. */ /* */ /********************** END OF SPECIFICATION **************************/ int Move( arg1, arg2, promptokay, a1info, is_dest_dir ) TCHAR *arg1 ; /* Ptr to 1st arg */ TCHAR *arg2 ; /* Ptr to 2nd arg */ BOOL promptokay ; PCPYINFO a1info ; /* Holds arg1 fspec info */ unsigned int is_dest_dir; /* flag if set--> dest. is a dir */ { unsigned attr ; unsigned i, n; unsigned long number_of_files_moved ; TCHAR Source[MAX_PATH]; /* path of source file */ TCHAR bufdst[MAX_PATH]; /* path of destination file*/ HANDLE hnFirst ; /* Findfirst handle */ TCHAR *j, *k,*l; /* Tmp Ptr */ unsigned wild_flag ; /* wildcard flag */ BOOL file_moved; unsigned save_error ; /* Saved error code */ TCHAR pcstr[3] ; unsigned rc; int retc; int how_many_src=0; /* =f_RET_DIR if dir; =0 if none; = else */ char type_format_dest=0; /* decide on how to format dest */ char fl_move_once=0; /* if =1 execute move once only */ how_many_src = f_how_many (arg1, (ULONG) (attr=FILE_ATTRIBUTE_ARCHIVE) ); /**********************************************/ /* Set flag whether arg1 contains */ /* wildcard or not. */ /**********************************************/ pcstr[0] = STAR ; pcstr[1] = QMARK ; pcstr[2] = NULLC ; wild_flag = ((mystrcspn(arg1,pcstr)) < mystrlen(arg1)) ; // Decide on what to do depending on: <1.multiple/single src; 2.is dest dir ?> if (how_many_src == f_RET_DIR) { if (is_dest_dir) { if (!MyMoveFile(arg1, arg2, &promptokay, &file_moved) ) { i = GetLastError(); if (i == ERROR_ALREADY_EXISTS) { i = MSG_DUP_FILENAME_OR_NOT_FD; } ErrorDisplayAndJump( i ); } else { RestoreSavedDirectory( ); return(SUCCESS) ; } } else { type_format_dest = 2; fl_move_once = 1; } } else if (how_many_src > 1 ) { if (is_dest_dir) { type_format_dest = 1; fl_move_once = 0; } else { ErrorDisplayAndJump( MSG_MOVE_MULTIPLE_FAIL ); } } else { // single source or source doesn't exist if (is_dest_dir) { type_format_dest = 1; fl_move_once = 1; } else { type_format_dest = 2; fl_move_once = 1; } } /**********************************************/ /* Issue ffirst for a file name */ /**********************************************/ /*M006*/ if (!ffirst(arg1, attr = FILE_ATTRIBUTE_ARCHIVE, a1info->buf, &hnFirst )) { /**********************************************/ /* Issue ffirst for a directory name */ /**********************************************/ rc = ffirst(arg1, attr = FILE_ATTRIBUTE_DIRECTORY, a1info->buf, &hnFirst ) ; if ( !rc) { /**********************************************/ /* No file or directory which arg1 */ /* specifies found */ /**********************************************/ if (!rc && DosErr == ERROR_NO_MORE_FILES) { /* @@5e */ rc = ERROR_FILE_NOT_FOUND; } else if (wild_flag) { rc = MSG_DUP_FILENAME_OR_NOT_FD; } else { rc = DosErr; } ErrorDisplayAndJump( rc ); } } number_of_files_moved = 0 ; /* Reset the counter to zero */ save_error = NO_ERROR ; /* Reset error code to zero */ mystrcpy(Source,arg1) ; j = mystrrchr(Source,PathChar) ; ++j; /* get to filename area */ do { if (CtrlCSeen) { findclose(hnFirst) ; RestoreSavedDirectory( ); return(FAILURE); } /**********************************************/ /* build bufdst */ /**********************************************/ mystrcpy(j,a1info->buf->cFileName) ; mystrcpy(bufdst,arg2); if (type_format_dest == 1 ) { l = mystrrchr(bufdst,PathChar); ++l; mystrcpy(l,a1info->buf->cFileName) ; if ((mystrlen(bufdst) ) > MAX_PATH) { ErrorDisplayAndJump( MSG_REN_INVAL_PATH_FILENAME ) ; } } /**********************************************/ /* check to see if filename is legal */ /**********************************************/ { TCHAR TempBuffer[MAX_PATH]; DWORD Length; Length = GetFullPathName( bufdst, MAX_PATH, TempBuffer, NULL ); if (Length == 0 || Length >= MAX_PATH) { goto badness; } n = _tcslen( TempBuffer ); Length = GetFullPathName( Source, MAX_PATH, TempBuffer, NULL ); if (Length == 0 || Length >= MAX_PATH) { goto badness; } if (!GreatestLength( TempBuffer, &i)) continue; i -= _tcslen( TempBuffer ); } if (n + i > MAX_PATH) { i = ERROR_FILENAME_EXCED_RANGE; goto badness2; } /**********************************************/ /* Move a file or directory */ /**********************************************/ if (!MyMoveFile(Source, bufdst, &promptokay, &file_moved)) { /**********************************************/ /* Move fails */ /**********************************************/ badness: i = GetLastError(); badness2: if (i == ERROR_ALREADY_EXISTS) { i = MSG_DUP_FILENAME_OR_NOT_FD; } save_error = i ; /* Save the error code */ PutStdErr(i, NOARGS); /* Put out an error message */ i = mystrlen(bufdst) ; if ( bufdst[--i] == DOT ) { /* @@5a */ bufdst[i] = 0 ; /* @@5a */ } /* @@5a */ /* @@5a */ /*509*/if (!_tcsicmp(Source,bufdst)) { /* @@5a */ break ; /* @@5a */ } /* @@5a */ } else if (file_moved) { number_of_files_moved += 1; if ( wild_flag ) { /* If wild card is used */ cmd_printf(Fmt17,Source); /* display the file name*/ } } if (fl_move_once) break; } while (fnext(a1info->buf, attr, hnFirst )); /**********************************************/ /* No more files to be found */ /**********************************************/ findclose(hnFirst) ; RestoreSavedDirectory( ); /**********************************************/ /* Display the total number of file(s) moved */ /**********************************************/ if ( (a1info->buf->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 ) { PutStdOut(MSG_FILES_MOVED, ONEARG, argstr1(TEXT("%9d"), (unsigned long)number_of_files_moved)) ; } return(save_error == NO_ERROR ? SUCCESS : FAILURE) ; } int eTitle ( IN struct cmdnode *pcmdnode ) { LPTSTR NewTitle; if (!pszTitleCur) { pszTitleCur = HeapAlloc(GetProcessHeap(), 0, MAX_PATH*sizeof(TCHAR) + 2*sizeof(TCHAR)); if (pszTitleCur == NULL) { PutStdErr(ERROR_NOT_ENOUGH_MEMORY, NOARGS); return( FAILURE ); } } if (mystrlen(pcmdnode->argptr) >= MAX_PATH) { PutStdErr(ERROR_NOT_ENOUGH_MEMORY, NOARGS); return( FAILURE ); } NewTitle = EatWS(pcmdnode->argptr, NULL); if (NewTitle && *NewTitle) { mystrcpy(pszTitleCur,NewTitle); } SetConsoleTitle(pszTitleCur); // // This insures that ResetConTitle does not undo what // we have just done // fTitleChanged = FALSE; return( SUCCESS ); } /*** eStart - Entry point for Start routine * * Purpose: * to call Start and pass it a pointer to the command line * arguments * * Args: * a pointer to the command node structure * */ int eStart( n ) /* @@ */ struct cmdnode *n; /* @@ */ { /* @@ */ DBG_UNREFERENCED_PARAMETER( n ); return( Start(n->argptr) ); } /* @@ */