windows-server-2003/base/mvdm/dos/dem/demfcb.c

/* demfcb.c - SVC handlers for misc. FCB operations
 *
 * demCloseFCB
 * demCreateFCB
 * demDate16
 * demDeleteFCB
 * demFCBIO
 * demGetFileInfo
 * demOpenFCB
 * demRenameFCB
 *
 * Modification History:
 *
 * Sudeepb 09-Apr-1991 Created
 * Sudeepb 21-Nov-1991 Added FCB based IO functions
 * Jonle   30-Jun-1994 add wild card support for fcb rename
 */

#include "dem.h"
#include "demmsg.h"

#include <softpc.h>
#include <winbase.h>
#include <mvdm.h>
#include "dpmtbls.h"

#define DOT '.'
#define QMARK '?'


/* demDeleteFCB - FCB based File Delete
 *
 *
 * Entry - Client (ES:DI) - Full File Path
 *    Client (AL)   - 0 if not extended FCB
 *    Client (DL)   - File Attr. to be deleted (valid only if Al !=0 )
 *
 * Exit
 *    SUCCESS
 *      Client (CF) = 0
 *
 *    FAILURE
 *      Client (CF) = 1
 *      Client (AX) = system status code
 *     HARD ERROR
 *      Client (CF) = 1
 *      Client (AX) = 0ffffh
 *
 * Notes:  Following are the rules for FCB based delete:
 * 1. If normal FCB than dont allow delete on hidden,system files
 * 2. if extended FCB than search attributes should include hidden,
 *    system or read-only if that kind of file is to be deleted.
 */

VOID demDeleteFCB (VOID)
{
HANDLE   hFind;
LPSTR lpFileName;
BYTE  bClientAttr=0;
BOOL  fExtendedFCB=FALSE;
WIN32_FIND_DATA  wfBuffer;
BOOL  fSuccess = FALSE;
DWORD dwAttr;
USHORT   uErr;

CHAR szPath_buffer[_MAX_PATH];
CHAR szDrive[_MAX_DRIVE];
CHAR szDir[_MAX_DIR];
CHAR szFname[_MAX_FNAME];
CHAR szExt[_MAX_EXT];

DWORD dwErrCode = 0, dwErrCodeKeep = 0;

    // Get the file name
    lpFileName = (LPSTR) GetVDMAddr (getES(),getDI());

    _splitpath( lpFileName, szDrive, szDir, szFname, szExt );

    // Check if handling extended FCB
    if(getAL() != 0){
   bClientAttr = getDL();

    /* Special case for delete volume label (INT 21 Func 13H, Attr = 8H */

    if((bClientAttr == ATTR_VOLUME_ID)) {
   if((uErr = demDeleteLabel(lpFileName[DRIVEBYTE]))) {
       setCF(1);
       setAX(uErr);
       return;
   }
   setAX(0);
   setCF(0);
   return;
    }


   bClientAttr &= (ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM);
   fExtendedFCB = TRUE;
    }

    // Find the first instance of file
    if((hFind = FindFirstFileOem (lpFileName,&wfBuffer)) == (HANDLE)-1){
        demClientError(INVALID_HANDLE_VALUE, *lpFileName);
        return;
    }

    // loop for all files which match the name and attributes
    do {
   // Check if read_only,hidden or system file
   if((dwAttr= wfBuffer.dwFileAttributes & (FILE_ATTRIBUTE_READONLY |
            FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM))){

       // if so, try next file if normal FCB case. If extended fcb case
       // then check if right attributes are given by client.
       if(fExtendedFCB && ((dwAttr & (DWORD)bClientAttr) == dwAttr)){

      // Yes, right attributes are given. So if the file is read
      // only then change the modes to normal. Note NT will
      // delete hidden and system files anyway.
      if (dwAttr & FILE_ATTRIBUTE_READONLY){
          strcpy( szPath_buffer, szDrive);
          strcat( szPath_buffer, szDir);
          strncat( szPath_buffer, wfBuffer.cFileName,sizeof(szPath_buffer)-strlen(szPath_buffer));
          szPath_buffer[sizeof(szPath_buffer)-1] = 0;

          // if set attributes fail try next file
          if(SetFileAttributesOemSys (szPath_buffer,
                    FILE_ATTRIBUTE_NORMAL, FALSE) == -1)
         continue;
      }
       }
       else {
      dwErrCodeKeep = ERROR_ACCESS_DENIED;
      continue;
       }
   }

   strcpy( szPath_buffer, szDrive);
   strcat( szPath_buffer, szDir);
   strncat( szPath_buffer, wfBuffer.cFileName,sizeof(szPath_buffer)-strlen(szPath_buffer));
   szPath_buffer[sizeof(szPath_buffer)-1] = 0;

   if(DeleteFileOem(szPath_buffer) == FALSE) {
       dwErrCode = GetLastError();

       SetLastError(dwErrCode);

       if (((dwErrCode >= ERROR_WRITE_PROTECT) &&
         (dwErrCode <= ERROR_GEN_FAILURE)) ||
         dwErrCode == ERROR_WRONG_DISK ) {
      demClientError(INVALID_HANDLE_VALUE, szPath_buffer[0]);
      return;
       }
       continue;
   }

   // We have deleted at least one file, so report success
   fSuccess = TRUE;

    } while (FindNextFileOem(hFind,&wfBuffer) == TRUE);

    if(DPM_FindClose(hFind) == FALSE)
   demPrintMsg (MSG_INVALID_HFIND);

    if (fSuccess == TRUE){
   setCF(0);
   return;
    }

    setCF(1);

    if(dwErrCodeKeep)
   setAX((SHORT) dwErrCodeKeep);
    else
   setAX(ERROR_FILE_NOT_FOUND);
    return;
}


/* demRenameFCB - FCB based Rename file
 *
 * Entry - Client (DS:SI)    Sources file to be renamed
 *    Client (ES:DI)    Destination file to be renamed to
 *
 * Exit  - SUCCESS
 *    Client (CF) = 0
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */

VOID demRenameFCB (VOID)
{
    LPSTR  lpSrc,lpDst;
    DWORD  dw;
    HANDLE hFind;
    PCHAR pNewDstFilePart;
    PCHAR pDstFilePart;
    PCHAR pCurrSrcFilePart;
    WIN32_FIND_DATA  W32FindData;
    CHAR  NewDst[MAX_PATH];
    CHAR  CurrSrc[MAX_PATH];

    lpSrc = (LPSTR) GetVDMAddr (getDS(),getSI());
    lpDst = (LPSTR) GetVDMAddr (getES(),getDI());

      // Find the first instance of the source file
    hFind = FindFirstFileOem (lpSrc,&W32FindData);
    if (hFind == INVALID_HANDLE_VALUE) {
        dw = GetLastError();
        if (dw == ERROR_BAD_PATHNAME || dw == ERROR_DIRECTORY ) {
            SetLastError(ERROR_PATH_NOT_FOUND);
            }
        demClientError(INVALID_HANDLE_VALUE, *lpSrc);
        return;
        }

    //
    // Source string consists of the path taken from the original
    // source specified plus the filename part retrieved from the
    // FindFile call
    //
    strncpy(CurrSrc, lpSrc,sizeof(CurrSrc));
    CurrSrc[sizeof(CurrSrc)-1] = 0;
    pCurrSrcFilePart = strrchr(CurrSrc, '\\');
    pCurrSrcFilePart++;

    //
    // Destination string is template for meta character substitution
    //
    pDstFilePart = strrchr(lpDst, '\\');
    pDstFilePart++;

    //
    //  NewDst string is constructed from template and the source string
    //  when doing meta file character substitution.
    //
    strncpy(NewDst, lpDst, sizeof(NewDst));
    NewDst[sizeof(NewDst)-1] = 0;
    pNewDstFilePart = strrchr(NewDst, '\\');
    pNewDstFilePart++;


    do {
       PCHAR pNew;
       PCHAR pSrc;
       PCHAR pDst;

       strncpy(pCurrSrcFilePart,
              W32FindData.cAlternateFileName[0]
                  ? W32FindData.cAlternateFileName
                  : W32FindData.cFileName,  //// ??? hpfs lfns ????
              sizeof(CurrSrc)+CurrSrc-pCurrSrcFilePart);
              CurrSrc[sizeof(CurrSrc)-1] = 0;

       pSrc = pCurrSrcFilePart; // source fname
       pNew = pNewDstFilePart;  // dest fname to be constructed
       pDst = pDstFilePart;     // raw dest fname template (with metas)

       while (*pDst) {

              //
              // If Found a '?' in Dest template, use character from src
              //
          if (*pDst == QMARK) {
              if (*pSrc != DOT && *pSrc)
                  *pNew++ = *pSrc++;
              }

              //
              // if Found a DOT in Dest template, Align DOTS between Src\Dst
              //
          else if (*pDst == DOT) {
              while (*pSrc != DOT && *pSrc) {  // mov src to one past DOT
                  pSrc++;
                  }
              if (*pSrc)
                  pSrc++;

              *pNew++ = DOT;
              }

              //
              // Nothing special found, use character from Dest template
              //
          else {
              if (*pSrc != DOT && *pSrc)
                  pSrc++;
              *pNew++ = *pDst;
              }

          pDst++;
          }

       *pNew = '\0';

       //
       // MoveFile does not return error if dst and src are the same,
       // but DOS does, so check first..
       //
       if (!_stricmp (CurrSrc, NewDst)) {
           setCF(1);
           setAX(0x5);
           DPM_FindClose(hFind);
           return;
           }

       if (!MoveFileOem(CurrSrc, NewDst)){
           demClientError(INVALID_HANDLE_VALUE, *lpSrc);
           DPM_FindClose(hFind);
           return;
           }

       } while (FindNextFileOem(hFind,&W32FindData));



   //
   // If the search on the source string for any reason besides
   // no more files, then its a genuine error.
   //
   dw = GetLastError();
   if (dw != ERROR_NO_MORE_FILES) {
       if (dw == ERROR_BAD_PATHNAME || dw == ERROR_DIRECTORY ) {
           SetLastError(ERROR_PATH_NOT_FOUND);
           }
       demClientError(INVALID_HANDLE_VALUE, *lpSrc);
       }
   else {
       setCF(0);
       }

   DPM_FindClose(hFind);
   return;
}



/* demCloseFCB - Close the NT handle associated with the FCB being closed.
 *
 * Entry - Client (AX:SI)    DWORD NT handle
 *
 * Exit  - SUCCESS
 *    Client (CF) = 0
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */

VOID demCloseFCB (VOID)
{
HANDLE   hFile;

    hFile = GETHANDLE (getAX(),getSI());

    if(hFile == 0) {

   setCF(0);
   return;
    }

    if (DPM_CloseHandle (hFile) == FALSE){

   demClientError(hFile, (CHAR)-1);
   return;

    }
    setCF(0);
    return;
}

/* demCreateFCB - An FCB is being created get the NT handle.
 *
 * Entry - Client (AL)    Creation Mode
 *         00 - Normal File
 *         01 - Read-only file
 *         02 - Hidden File
 *         04 - System file
 *    Client (DS:SI) Full path filename
 *    Client (ES:DI) SFT address
 *
 * Exit  - SUCCESS
 *    Client (CF)   = 0
 *    Client (AX:BP) = NT Handle
 *    Client (BX)   = Time
 *    Client (CX)   = Date
 *    Client (DX:SI) = Size
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */

VOID demCreateFCB (VOID)
{
    demFCBCommon (CREATE_ALWAYS);
    return;
}

/* demDate16 - Get the current date/time in DOS FCB format.
 *
 * Entry - None
 *
 * Exit  - Always Success
 *    Client (AX) has date
 *    Client (DX) has time
 * NOTES:
 *
 * DemDate16 returns the current date in AX, current time in DX in this format
 *    AX - YYYYYYYMMMMDDDDD   years months days
 *    DX - HHHHHMMMMMMSSSSS   hours minutes seconds/2
 */

VOID demDate16 (VOID)
{
SYSTEMTIME TimeDate;

    GetLocalTime(&TimeDate);
    // date is stored in a packed word: ((year-1980)*512) + (month*32) + day
    setAX ( (USHORT) (((TimeDate.wYear-1980) << 9 ) |
       ((TimeDate.wMonth & 0xf) << 5 ) |
            (TimeDate.wDay & 0x1f))
     );
    setDX ( (USHORT) ((TimeDate.wHour << 11) |
       ((TimeDate.wMinute & 0x3f) << 5) |
            ((TimeDate.wSecond / 2) & 0x1f))
     );
    return;
}

/* demFCBIO - Carry out the FCB based IO operation.
 *
 * Entry - Client (BX) = 1 if read operation, 0 if write
 *    Client (AX:BP)  NT Handle
 *    Client (DI:DX)  offset to start the operation with
 *    Client (CX)    Count of bytes
 *
 * Exit  - SUCCESS
 *    Client (CF) = 0
 *    Client (CX) = counts of bytes read/written
 *    Client (AX:BX)  = size
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */

VOID demFCBIO (VOID)
{
HANDLE   hFile;
ULONG CurOffset;
PVOID   pBuf;
DWORD dwBytesIO=0;
DWORD dwSize,dwSizeHigh;
DWORD dwErrCode;

    hFile = GETHANDLE (getAX(),getBP());
    CurOffset = (((ULONG)getDI()) << 16) + (ULONG)getDX();

    if (DPM_SetFilePointer (hFile,
         (LONG)CurOffset,
         NULL,
         (DWORD)FILE_BEGIN) == -1L){
        demClientError(hFile, (CHAR)-1);
        return ;
    }

    pBuf = (PVOID)GetVDMAddr(*((PUSHORT)pulDTALocation + 1),
                              *((PUSHORT)pulDTALocation));

    if(getBX()) { // Read Operation
       if (DPM_ReadFile (hFile,
                      pBuf,
            (DWORD)getCX(),
            &dwBytesIO,
            NULL) == FALSE){

            Sim32FlushVDMPointer(*pulDTALocation, getCX(), pBuf, FALSE);
            Sim32FreeVDMPointer(*pulDTALocation, getCX(), pBuf, FALSE);
            demClientError(hFile, (CHAR)-1);
            return ;
       }
       Sim32FlushVDMPointer (*pulDTALocation, getCX(),pBuf, FALSE);
       Sim32FreeVDMPointer (*pulDTALocation, getCX(), pBuf, FALSE);
    }
    else {
        if (getCX() == 0) {
            //0 byte write, adjust file size
           if(!DPM_SetEndOfFile(hFile)) {
              dwErrCode = GetLastError();
              SetLastError(dwErrCode);
              demClientError(hFile,(CHAR)-1);
              return;
           }
        }
        else if (DPM_WriteFile (hFile,
                            pBuf,
                            (DWORD)getCX(),
                            &dwBytesIO,
                            NULL) == FALSE) {

                            // If disk is full then we should return number of bytes written
                            // AX = 1 and CF = 1

                            dwErrCode = GetLastError();
                            if(dwErrCode == ERROR_DISK_FULL) {

                               setCX( (USHORT) dwBytesIO);
                               setAX(1);
                               setCF(1);
                               return;
                            }

                            SetLastError(dwErrCode);

                            demClientError(hFile, (CHAR)-1);
                            return ;

        }
    }

    // Get File Size
    if((dwSize = DPM_GetFileSize(hFile,&dwSizeHigh)) == -1){

   demPrintMsg(MSG_FILEINFO);
        ASSERT(FALSE);
        demClientError(hFile, (CHAR)-1);
        return;
    }

    if(dwSizeHigh) {
   demPrintMsg(MSG_FILESIZE_TOOBIG);
        ASSERT(FALSE);
        demClientError(hFile, (CHAR)-1);
        return;
    }

    // Setup the exit registers
    setCX((USHORT)dwBytesIO);
    setBX((USHORT)dwSize);
    setAX((USHORT)(dwSize >> 16 ));
    setCF(0);
    return;
}

/* demGetFileInfo - Get Misc. file info in FCB format.
 *
 * Entry - Client (DS:SI)    full path file name
 *
 * Exit  - SUCCESS
 *    Client (CF) = 0
 *    Client (AX) = Attribute of file
 *    Client (CX) = Time stamp of file
 *    Client (DX  = Date stamp of file
 *    Client (BX:DI)= Size of file (32 bit)
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */

VOID demGetFileInfo (VOID)
{
HANDLE   hFile;
LPSTR lpFileName;
WORD  wDate,wTime;
DWORD dwSize,dwAttr;

    lpFileName = (LPSTR) GetVDMAddr (getDS(),getSI());

    if ((hFile = CreateFileOem(lpFileName,
                               GENERIC_READ,
                               FILE_SHARE_READ,
                               NULL,
                               OPEN_EXISTING,
                               0,
                               NULL)) == (HANDLE)-1){
            demClientError(INVALID_HANDLE_VALUE, *lpFileName);
            return;
    }

    // Get Misc. INfo
    if (demGetMiscInfo (hFile,&wTime, &wDate, &dwSize) == FALSE) {
        DPM_CloseHandle (hFile);
        return;
    }

    DPM_CloseHandle (hFile);

    if ((dwAttr = GetFileAttributesOemSys (lpFileName, FALSE)) == -1) {
         demClientError(INVALID_HANDLE_VALUE, *lpFileName);
         return;
    }

    if (dwAttr == FILE_ATTRIBUTE_NORMAL)
   dwAttr = 0;

    setAX((USHORT)dwAttr);
    setCX(wTime);
    setDX(wDate);
    setDI((USHORT)dwSize);
    setBX((USHORT)(dwSize >> 16));
    return;
}


/* demOpenFCB - An FCB is being opened get the NT handle.
 *
 * Entry - Client (AL)    Open Mode
 *    Client (DS:SI) Full path filename
 *
 * Exit  - SUCCESS
 *    Client (CF)   = 0
 *    Client (AX:BP) = NT Handle
 *    Client (BX)   = Time
 *    Client (CX)   = Date
 *    Client (DX:SI) = Size
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */

VOID demOpenFCB (VOID)
{
    demFCBCommon (OPEN_EXISTING);
    return;
}

/* demFCBCommon - FCB Open/Create.
 *
 * Entry - CreateDirective - Open/Create
 *    Client (AL)   Open Mode
 *    Client (DS:SI) Full path filename
 *
 * Exit  - SUCCESS
 *    Client (CF)   = 0
 *    Client (AX:BP) = NT Handle
 *    Client (BX)   = Time
 *    Client (CX)   = Date
 *    Client (DX:SI) = Size
 *
 *    FAILURE
 *    Client(CF)  = 1
 *    Client(AX)  = error code
 */
VOID demFCBCommon (ULONG CreateDirective)
{
HANDLE   hFile;
LPSTR lpFileName;
UCHAR uchMode,uchAccess;
DWORD dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
WORD  wDate,wTime;
DWORD dwSize,dwAttr=0;
USHORT   uErr;
SECURITY_ATTRIBUTES sa;

    lpFileName = (LPSTR) GetVDMAddr (getDS(),getSI());
    uchMode = getAL();

    /* Special case for delete volume label (INT 21 Func 13H, Attr = 8H */

    if((uchMode == ATTR_VOLUME_ID) && (CreateDirective == CREATE_ALWAYS)) {
   if((uErr = demCreateLabel(lpFileName[DRIVEBYTE],
             lpFileName+LABELOFF))) {
       setCF(1);
       setAX(uErr);
       return;
   }
   setAX(0);
   setBP(0);
   setCF(0);
   return;
    }


    // In create case AL has creation attributes. By default
    // Access is for read/write and sharing for both. In open
    // case AL has appropriate access and sharing information.
    if((CreateDirective == CREATE_ALWAYS) && ((uchMode &0xff) == 0)) {

   dwAttr = FILE_ATTRIBUTE_NORMAL;
   dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ;
    }
    else {
   uchAccess = uchMode & (UCHAR)ACCESS_MASK;

   if (uchAccess == OPEN_FOR_READ)
       dwDesiredAccess = GENERIC_READ;

   else if (uchAccess == OPEN_FOR_WRITE)
       dwDesiredAccess = GENERIC_WRITE;

   uchMode = uchMode & (UCHAR)SHARING_MASK;

   switch (uchMode) {
       case SHARING_DENY_BOTH:
      dwShareMode = 0;
      break;
       case SHARING_DENY_WRITE:
      dwShareMode = FILE_SHARE_READ;
      break;
       case SHARING_DENY_READ:
      dwShareMode = FILE_SHARE_WRITE;
      break;
   }
    }
    sa.nLength = sizeof (SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;

    if ((hFile = CreateFileOem(lpFileName,
                dwDesiredAccess,
                dwShareMode | FILE_SHARE_DELETE,
                               &sa,
                               CreateDirective,
                               dwAttr,
                               NULL)) == (HANDLE)-1){
            demClientError(INVALID_HANDLE_VALUE, *lpFileName);
            return;
    }

    // Get Misc. INfo
    if (demGetMiscInfo (hFile,&wTime, &wDate, &dwSize) == FALSE)
        return;

    // Setup the exit registers
    setBX(wTime);
    setCX(wDate);
    setBP((USHORT)hFile);
    setAX((USHORT)((ULONG)hFile >> 16));
    setSI((USHORT)dwSize);
    setDX((USHORT)(dwSize >> 16));
    setCF(0);
    return;
}


BOOL demGetMiscInfo (hFile, lpTime, lpDate, lpSize)
HANDLE hFile;
LPWORD lpTime;
LPWORD lpDate;
LPDWORD lpSize;
{
FILETIME LastWriteTime,ftLocal;
DWORD  dwSizeHigh=0;

    if(GetFileTime (hFile,NULL,NULL,&LastWriteTime) == -1){
   demPrintMsg(MSG_FILEINFO);
        ASSERT(FALSE);
        demClientError(hFile, (CHAR)-1);
        DPM_CloseHandle (hFile);
        return FALSE;
    }

    FileTimeToLocalFileTime (&LastWriteTime,&ftLocal);

    if(FileTimeToDosDateTime(&ftLocal,
              lpDate,
              lpTime) == FALSE){
   demPrintMsg(MSG_FILEINFO);
        ASSERT(FALSE);
        demClientError(hFile, (CHAR)-1);
        return FALSE;
    }

    if((*lpSize = DPM_GetFileSize(hFile,&dwSizeHigh)) == -1){
   demPrintMsg(MSG_FILEINFO);
        ASSERT(FALSE);
        demClientError(hFile, (CHAR)-1);
        return FALSE;
    }

    if(dwSizeHigh) {
   demPrintMsg(MSG_FILESIZE_TOOBIG);
        ASSERT(FALSE);
        demClientError(hFile, (CHAR)-1);
        return FALSE;
    }
    return TRUE;
}