353 lines
8.8 KiB
C++
353 lines
8.8 KiB
C++
|
//+--------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Microsoft Windows
|
||
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1992.
|
||
|
|
//
|
||
|
|
// File: funcs.cxx
|
||
|
|
//
|
||
|
|
// Contents: Generic DocFile support functions
|
||
|
|
//
|
||
|
|
// Functions: ModeToTFlags
|
||
|
|
// CheckName
|
||
|
|
// wcsdup
|
||
|
|
// VerifyPerms
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------
|
||
|
|
|
||
|
|
#include <dfhead.cxx>
|
||
|
|
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// 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;
|
||
|
|
}
|