//+-------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1992. // // File: funcs.cxx // // Contents: Generic DocFile support functions // // Functions: ModeToTFlags // CheckName // wcsdup // VerifyPerms // //--------------------------------------------------------------- #include //+-------------------------------------------------------------- // // Function: ModeToDFlags, private // // Synopsis: Translates STGM flags to DF flags // // Arguments: [dwModeFlags] // // Returns: DF_* // //--------------------------------------------------------------- DFLAGS ModeToDFlags(DWORD const dwModeFlags) { DFLAGS df; olDebugOut((DEB_ITRACE, "In ModeToDFlags(%lX)\n", dwModeFlags)); if ((dwModeFlags & STGM_TRANSACTED) == 0) df = DF_DIRECT; else df = DF_TRANSACTED; if ((dwModeFlags & STGM_TRANSACTED) && (dwModeFlags & STGM_PRIORITY) == 0 && (dwModeFlags & STGM_DENY) != STGM_SHARE_DENY_WRITE && (dwModeFlags & STGM_DENY) != STGM_SHARE_EXCLUSIVE) df |= DF_INDEPENDENT; switch(dwModeFlags & STGM_RDWR) { case STGM_READ: df |= DF_READ; break; case STGM_WRITE: df |= DF_WRITE; break; case STGM_READWRITE: df |= DF_READWRITE; break; default: olAssert(FALSE); break; } switch(dwModeFlags & STGM_DENY) { case STGM_SHARE_DENY_READ: df |= DF_DENYREAD; break; case STGM_SHARE_DENY_WRITE: df |= DF_DENYWRITE; break; case STGM_SHARE_EXCLUSIVE: df |= DF_DENYALL; break; // Default is deny none } if (dwModeFlags & STGM_PRIORITY) df |= DF_PRIORITY; olDebugOut((DEB_ITRACE, "Out ModeToDFlags => %lX\n", df)); return df; } //+-------------------------------------------------------------- // // Function: DFlagsToMode, private // // Synopsis: Converts the read/write/denials/transacted/priority // to STGM flags // // Arguments: [df] - DFlags // // Returns: STGM flags // //--------------------------------------------------------------- DWORD DFlagsToMode(DFLAGS const df) { DWORD dwMode; olDebugOut((DEB_ITRACE, "In DFlagsToMode(%X)\n", df)); if (P_READ(df)) if (P_WRITE(df)) dwMode = STGM_READWRITE; else dwMode = STGM_READ; else if (P_WRITE(df)) dwMode = STGM_WRITE; // Must have either read or write, so no else if (P_DENYREAD(df)) if (P_DENYWRITE(df)) dwMode |= STGM_SHARE_EXCLUSIVE; else dwMode |= STGM_SHARE_DENY_READ; else if (P_DENYWRITE(df)) dwMode |= STGM_SHARE_DENY_WRITE; else dwMode |= STGM_SHARE_DENY_NONE; if (P_TRANSACTED(df)) dwMode |= STGM_TRANSACTED; if (P_PRIORITY(df)) dwMode |= STGM_PRIORITY; olDebugOut((DEB_ITRACE, "Out DFlagsToMode\n")); return dwMode; } //+-------------------------------------------------------------- // // Function: VerifyPerms, private // // Synopsis: Checks flags to see if they are valid // // Arguments: [grfMode] - Permissions // // Returns: Appropriate status code // //--------------------------------------------------------------- SCODE VerifyPerms(DWORD grfMode) { SCODE sc = S_OK; olDebugOut((DEB_ITRACE, "In VerifyPerms(%lX)\n", grfMode)); // Check for valid flags if ((grfMode & STGM_RDWR) > STGM_READWRITE || (grfMode & STGM_DENY) > STGM_SHARE_DENY_NONE || (grfMode & ~(STGM_RDWR | STGM_DENY | STGM_DIRECT | STGM_TRANSACTED | STGM_PRIORITY | STGM_CREATE | STGM_CONVERT | STGM_FAILIFTHERE | STGM_DELETEONRELEASE))) olErr(EH_Err, STG_E_INVALIDFLAG); // If priority is specified... if (grfMode & STGM_PRIORITY) { return STG_E_INVALIDFUNCTION; } if (grfMode & STGM_TRANSACTED) { return STG_E_INVALIDFUNCTION; } // Check to make sure only one existence flag is specified // FAILIFTHERE is zero so it can't be checked if ((grfMode & (STGM_CREATE | STGM_CONVERT)) == (STGM_CREATE | STGM_CONVERT)) olErr(EH_Err, STG_E_INVALIDFLAG); // If not transacted and not priority, you can either be // read-only deny write or read-write deny all if ((grfMode & (STGM_TRANSACTED | STGM_PRIORITY)) == 0) { if ((grfMode & STGM_RDWR) == STGM_READ) { // we're asking for read-only access if ((grfMode & STGM_DENY) != STGM_SHARE_EXCLUSIVE && (grfMode & STGM_DENY) != STGM_SHARE_DENY_WRITE) { // Can't allow others to have write access olErr(EH_Err, STG_E_INVALIDFLAG); } } else { // we're asking for write access if ((grfMode & STGM_DENY) != STGM_SHARE_EXCLUSIVE) { // Can't allow others to have any access olErr(EH_Err, STG_E_INVALIDFLAG); } } } olDebugOut((DEB_ITRACE, "Out VerifyPerms\n")); // Fall through EH_Err: return sc; } //+-------------------------------------------------------------- // // Function: wcsdup, public // // Synopsis: Duplicates a WCHAR string // // Arguments: [pwcs] - String // // Returns: Pointer to new string or Appropriate status code // //--------------------------------------------------------------- WCHAR * _CRTAPI1 wcsdup(WCHAR const *pwcs) { WCHAR *pwcsNew; olDebugOut((DEB_ITRACE, "In wcsdup(%ws)\n", pwcs)); pwcsNew = new WCHAR[wcslen(pwcs)+1]; if (pwcsNew == NULL) return NULL; wcscpy(pwcsNew, pwcs); olDebugOut((DEB_ITRACE, "Out wcsdup => %p\n", pwcsNew)); return pwcsNew; } //+-------------------------------------------------------------- // // Function: ValidateSNB, private // // Synopsis: Validates SNB memory // // Arguments: [snb] - SNB // // Returns: Appropriate status code // //--------------------------------------------------------------- SCODE ValidateSNB(SNBW snb) { SCODE sc; olDebugOut((DEB_ITRACE, "In ValidateSNB(%p)\n", snb)); for (;;) { olChk(ValidatePtrBuffer(snb)); if (*snb == NULL) break; olChk(ValidateNameW(*snb, CWCMAXPATHCOMPLEN)); snb++; } olDebugOut((DEB_ITRACE, "Out ValidateSNB\n")); return S_OK; EH_Err: return sc; } //+-------------------------------------------------------------- // // Function: CopySStreamToSStream // // Synopsis: Copies the contents of a stream to another stream // // Arguments: [psstFrom] - Stream to copy from // [psstTo] - Stream to copy to // // Returns: Appropriate status code // // Notes: This function may fail due to out of memory. It // may not be used by callers who must not fail due // to out of memory. // //--------------------------------------------------------------- SCODE CopySStreamToSStream(PSStream *psstFrom, PSStream *psstTo) { BYTE *pbBuffer; SCODE sc; ULONG cbRead, cbWritten, cbSize, cbPos; // Set destination size for contiguity psstFrom->GetSize(&cbSize); olChk(psstTo->SetSize(cbSize)); // We're allowed to fail due to out of memory olMem(pbBuffer = new BYTE[STREAMBUFFERSIZE]); // Copy between streams cbPos = 0; for (;;) { olChkTo(EH_pbBuffer, psstFrom->ReadAt(cbPos, pbBuffer, STREAMBUFFERSIZE, (ULONG STACKBASED *)&cbRead)); if (cbRead == 0) // EOF break; olChkTo(EH_pbBuffer, psstTo->WriteAt(cbPos, pbBuffer, cbRead, (ULONG STACKBASED *)&cbWritten)); if (cbRead != cbWritten) olErr(EH_Err, STG_E_WRITEFAULT); cbPos += cbWritten; } delete pbBuffer; return S_OK; EH_pbBuffer: delete pbBuffer; EH_Err: return sc; } //+-------------------------------------------------------------- // // Function: NameInSNB, private // // Synopsis: Determines whether the given name is in the SNB // // Arguments: [dfn] - Name // [snb] - SNB // // Returns: S_OK or S_FALSE // //--------------------------------------------------------------- SCODE NameInSNB(CDfName const *dfn, SNBW snb) { SCODE sc = S_FALSE; olDebugOut((DEB_ITRACE, "In NameInSNB(%ws, %p)\n", dfn, snb)); TRY { for (; *snb; snb++) if (dfwcsnicmp((WCHAR *)dfn->GetBuffer(), (WCHAR *)*snb, dfn->GetLength()) == 0) { sc = S_OK; break; } } CATCH(CException, e) { sc = e.GetErrorCode(); } END_CATCH olDebugOut((DEB_ITRACE, "Out NameInSNB\n")); return sc; }