You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2070 lines
50 KiB
2070 lines
50 KiB
/*
|
|
* persist.cpp - IPersist, IPersistFile, and IPersistStream implementations for
|
|
* CConfLink class.
|
|
*
|
|
* Taken from URL code - very similar to DavidDi's original code
|
|
*
|
|
* Created: ChrisPi 9-11-95
|
|
*
|
|
*/
|
|
|
|
|
|
/* Headers
|
|
**********/
|
|
|
|
#include "precomp.h"
|
|
|
|
#include "CLinkID.h"
|
|
#include "clrefcnt.hpp"
|
|
#include "clenumft.hpp"
|
|
#include "clCnfLnk.hpp"
|
|
|
|
/* Global Constants
|
|
*******************/
|
|
|
|
#pragma data_seg(DATA_SEG_READ_ONLY)
|
|
|
|
static const UINT g_ucMaxNameLen = MAX_DIALINFO_STRING; // (was 1024)
|
|
static const UINT g_ucMaxAddrLen = MAX_DIALINFO_STRING; // (was 1024)
|
|
static const UINT g_ucMaxRemoteConfNameLen = MAX_DIALINFO_STRING; // (was 1024)
|
|
|
|
static const char g_cszConfLinkExt[] = ".cnf";
|
|
static const char g_cszConfLinkDefaultFileNamePrompt[] = "*.cnf";
|
|
static const char g_cszCRLF[] = "\r\n";
|
|
|
|
static const char g_cszEmpty[] = "";
|
|
#define EMPTY_STRING g_cszEmpty
|
|
|
|
#pragma data_seg()
|
|
|
|
|
|
|
|
|
|
/* Module Constants
|
|
*******************/
|
|
|
|
#pragma data_seg(DATA_SEG_READ_ONLY)
|
|
|
|
// case-insensitive
|
|
|
|
const char s_cszSectionBefore[] = "[";
|
|
const char s_cszSectionAfter[] = "]";
|
|
const char s_cszKeyValueSep[] = "=";
|
|
|
|
const char s_cszConferenceShortcutSection[] = "ConferenceShortcut";
|
|
|
|
const char s_cszNameKey[] = "ConfName";
|
|
const char s_cszAddressKey[] = "Address";
|
|
const char s_cszTransportKey[] = "Transport";
|
|
const char s_cszRemoteConfNameKey[] = "RemoteConfName";
|
|
const char s_cszCallFlagsKey[] = "CallFlags";
|
|
|
|
const char s_cszIconFileKey[] = "IconFile";
|
|
const char s_cszIconIndexKey[] = "IconIndex";
|
|
const char s_cszHotkeyKey[] = "Hotkey";
|
|
const char s_cszWorkingDirectoryKey[] = "WorkingDirectory";
|
|
const char s_cszShowCmdKey[] = "ShowCommand";
|
|
|
|
const UINT s_ucMaxIconIndexLen = 1 + 10 + 1; // -2147483647
|
|
const UINT s_ucMaxTransportLen = 10 + 1; // 4294967296
|
|
const UINT s_ucMaxCallFlagsLen = 10 + 1; // 4294967296
|
|
const UINT s_ucMaxHotkeyLen = s_ucMaxIconIndexLen;
|
|
const UINT s_ucMaxShowCmdLen = s_ucMaxIconIndexLen;
|
|
|
|
#pragma data_seg()
|
|
|
|
|
|
/***************************** Private Functions *****************************/
|
|
|
|
|
|
BOOL DeletePrivateProfileString(PCSTR pcszSection, PCSTR pcszKey,
|
|
PCSTR pcszFile)
|
|
{
|
|
ASSERT(IS_VALID_STRING_PTR(pcszSection, CSTR));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszKey, CSTR));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
|
|
return(WritePrivateProfileString(pcszSection, pcszKey, NULL, pcszFile));
|
|
}
|
|
|
|
HRESULT ReadConfNameFromFile(PCSTR pcszFile, PSTR *ppszName)
|
|
{
|
|
HRESULT hr;
|
|
PSTR pszNewName;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszName, PSTR));
|
|
|
|
*ppszName = NULL;
|
|
|
|
pszNewName = new(char[g_ucMaxNameLen]);
|
|
|
|
if (pszNewName)
|
|
{
|
|
DWORD dwcValueLen;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszNameKey, EMPTY_STRING,
|
|
pszNewName, g_ucMaxNameLen, pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
hr = S_OK;
|
|
|
|
*ppszName = pszNewName;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
WARNING_OUT(("ReadConfNameFromFile: No Name found in file %s.",
|
|
pcszFile));
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (FAILED(hr) ||
|
|
hr == S_FALSE)
|
|
{
|
|
if (pszNewName)
|
|
{
|
|
delete [] pszNewName;
|
|
pszNewName = NULL;
|
|
}
|
|
}
|
|
|
|
ASSERT((hr == S_OK &&
|
|
IS_VALID_STRING_PTR(*ppszName, STR)) ||
|
|
(hr != S_OK &&
|
|
! *ppszName));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT WriteConfNameToFile(PCSTR pcszFile, PCSTR pcszName)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(! pcszName ||
|
|
IS_VALID_STRING_PTR(pcszName, CSTR));
|
|
|
|
if (AnyMeat(pcszName))
|
|
{
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszName, PSTR));
|
|
|
|
// (- 1) for null terminator.
|
|
|
|
hr = (WritePrivateProfileString(s_cszConferenceShortcutSection, s_cszNameKey,
|
|
pcszName, pcszFile)) ? S_OK : E_FAIL;
|
|
|
|
}
|
|
else
|
|
hr = (DeletePrivateProfileString(s_cszConferenceShortcutSection, s_cszNameKey, pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT ReadAddressFromFile(PCSTR pcszFile, PSTR *ppszAddress)
|
|
{
|
|
HRESULT hr;
|
|
PSTR pszNewAddr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszAddress, PSTR));
|
|
|
|
*ppszAddress = NULL;
|
|
|
|
pszNewAddr = new(char[g_ucMaxAddrLen]);
|
|
|
|
if (pszNewAddr)
|
|
{
|
|
DWORD dwcValueLen;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszAddressKey, EMPTY_STRING,
|
|
pszNewAddr, g_ucMaxAddrLen, pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
hr = S_OK;
|
|
|
|
*ppszAddress = pszNewAddr;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
WARNING_OUT(("ReadAddressFromFile: No Address found in file %s.",
|
|
pcszFile));
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (FAILED(hr) ||
|
|
hr == S_FALSE)
|
|
{
|
|
if (pszNewAddr)
|
|
{
|
|
delete [] pszNewAddr;
|
|
pszNewAddr = NULL;
|
|
}
|
|
}
|
|
|
|
ASSERT((hr == S_OK &&
|
|
IS_VALID_STRING_PTR(*ppszAddress, STR)) ||
|
|
(hr != S_OK &&
|
|
! *ppszAddress));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT WriteAddressToFile(PCSTR pcszFile, PCSTR pcszAddress)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(! pcszAddress ||
|
|
IS_VALID_STRING_PTR(pcszAddress, CSTR));
|
|
|
|
if (AnyMeat(pcszAddress))
|
|
{
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszAddress, PSTR));
|
|
|
|
// (- 1) for null terminator.
|
|
|
|
hr = (WritePrivateProfileString(s_cszConferenceShortcutSection, s_cszAddressKey,
|
|
pcszAddress, pcszFile)) ? S_OK : E_FAIL;
|
|
|
|
}
|
|
else
|
|
hr = (DeletePrivateProfileString(s_cszConferenceShortcutSection, s_cszAddressKey, pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT ReadRemoteConfNameFromFile(PCSTR pcszFile,
|
|
PSTR *ppszRemoteConfName)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszRemoteConfName, PSTR));
|
|
|
|
*ppszRemoteConfName = NULL;
|
|
|
|
PSTR pszNewRemoteConfName = new(char[g_ucMaxAddrLen]);
|
|
|
|
if (pszNewRemoteConfName)
|
|
{
|
|
DWORD dwcValueLen;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszRemoteConfNameKey, EMPTY_STRING,
|
|
pszNewRemoteConfName,
|
|
g_ucMaxRemoteConfNameLen, pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
hr = S_OK;
|
|
|
|
*ppszRemoteConfName = pszNewRemoteConfName;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("ReadRemoteConfNameFromFile: No RemoteConfName found in file %s.",
|
|
pcszFile));
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (FAILED(hr) ||
|
|
hr == S_FALSE)
|
|
{
|
|
delete [] pszNewRemoteConfName;
|
|
pszNewRemoteConfName = NULL;
|
|
}
|
|
|
|
ASSERT((hr == S_OK &&
|
|
IS_VALID_STRING_PTR(*ppszRemoteConfName, STR)) ||
|
|
(hr != S_OK &&
|
|
! *ppszRemoteConfName));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT WriteRemoteConfNameToFile(PCSTR pcszFile,
|
|
PCSTR pcszRemoteConfName)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(! pcszRemoteConfName ||
|
|
IS_VALID_STRING_PTR(pcszRemoteConfName, CSTR));
|
|
|
|
if (AnyMeat(pcszRemoteConfName))
|
|
{
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszRemoteConfName, PSTR));
|
|
|
|
// (- 1) for null terminator.
|
|
|
|
hr = (WritePrivateProfileString(s_cszConferenceShortcutSection, s_cszRemoteConfNameKey,
|
|
pcszRemoteConfName, pcszFile)) ? S_OK : E_FAIL;
|
|
|
|
}
|
|
else
|
|
{
|
|
hr = (DeletePrivateProfileString( s_cszConferenceShortcutSection,
|
|
s_cszRemoteConfNameKey,
|
|
pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT ReadTransportFromFile(PCSTR pcszFile, PDWORD pdwTransport)
|
|
{
|
|
HRESULT hr;
|
|
char rgchNewTransport[s_ucMaxTransportLen];
|
|
DWORD dwcValueLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdwTransport, INT));
|
|
|
|
*pdwTransport = 0;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszTransportKey, EMPTY_STRING,
|
|
rgchNewTransport,
|
|
sizeof(rgchNewTransport), pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
*pdwTransport = DecimalStringToUINT(rgchNewTransport);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("ReadTransportFromFile: No transport found in file %s.",
|
|
pcszFile));
|
|
}
|
|
|
|
ASSERT((hr == S_OK) ||
|
|
(hr == S_FALSE &&
|
|
EVAL(*pdwTransport == 0)));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT WriteTransportToFile(PCSTR pcszFile, DWORD dwTransport)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
|
|
char rgchTransportRHS[s_ucMaxTransportLen];
|
|
int ncLen;
|
|
|
|
ncLen = wsprintf(rgchTransportRHS, "%u", dwTransport);
|
|
ASSERT(ncLen > 0);
|
|
ASSERT(ncLen < sizeof(rgchTransportRHS));
|
|
ASSERT(ncLen == lstrlen(rgchTransportRHS));
|
|
|
|
hr = (WritePrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszTransportKey, rgchTransportRHS,
|
|
pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT ReadCallFlagsFromFile(PCSTR pcszFile, PDWORD pdwCallFlags)
|
|
{
|
|
HRESULT hr;
|
|
char rgchNewCallFlags[s_ucMaxCallFlagsLen];
|
|
DWORD dwcValueLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pdwCallFlags, INT));
|
|
|
|
*pdwCallFlags = 0;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszCallFlagsKey, EMPTY_STRING,
|
|
rgchNewCallFlags,
|
|
sizeof(rgchNewCallFlags), pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
*pdwCallFlags = DecimalStringToUINT(rgchNewCallFlags);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("ReadCallFlagsFromFile: No CallFlags found in file %s.",
|
|
pcszFile));
|
|
}
|
|
|
|
ASSERT((hr == S_OK) ||
|
|
(hr == S_FALSE &&
|
|
EVAL(*pdwCallFlags == 0)));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT WriteCallFlagsToFile(PCSTR pcszFile, DWORD dwCallFlags)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
|
|
char rgchCallFlagsRHS[s_ucMaxCallFlagsLen];
|
|
int ncLen;
|
|
|
|
ncLen = wsprintf(rgchCallFlagsRHS, "%u", dwCallFlags);
|
|
ASSERT(ncLen > 0);
|
|
ASSERT(ncLen < sizeof(rgchCallFlagsRHS));
|
|
ASSERT(ncLen == lstrlen(rgchCallFlagsRHS));
|
|
|
|
hr = (WritePrivateProfileString(s_cszConferenceShortcutSection,
|
|
s_cszCallFlagsKey, rgchCallFlagsRHS,
|
|
pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
|
HRESULT ReadIconLocationFromFile(PCSTR pcszFile,
|
|
PSTR *ppszIconFile, PINT pniIcon)
|
|
{
|
|
HRESULT hr;
|
|
char rgchNewIconFile[MAX_PATH_LEN];
|
|
DWORD dwcValueLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszIconFile, PSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pniIcon, INT));
|
|
|
|
*ppszIconFile = NULL;
|
|
*pniIcon = 0;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszIconFileKey, EMPTY_STRING,
|
|
rgchNewIconFile,
|
|
sizeof(rgchNewIconFile), pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
char rgchNewIconIndex[s_ucMaxIconIndexLen];
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszIconIndexKey,
|
|
EMPTY_STRING, rgchNewIconIndex,
|
|
sizeof(rgchNewIconIndex),
|
|
pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
int niIcon = DecimalStringToUINT(rgchNewIconIndex);
|
|
|
|
*ppszIconFile = new(char[lstrlen(rgchNewIconFile) + 1]);
|
|
|
|
if (*ppszIconFile)
|
|
{
|
|
lstrcpy(*ppszIconFile, rgchNewIconFile);
|
|
*pniIcon = niIcon;
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
WARNING_OUT(("ReadIconLocationFromFile(): No icon index found in file %s.",
|
|
pcszFile));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("ReadIconLocationFromFile(): No icon file found in file %s.",
|
|
pcszFile));
|
|
}
|
|
|
|
ASSERT(IsValidIconIndex(hr, *ppszIconFile, MAX_PATH_LEN, *pniIcon));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT WriteIconLocationToFile(PCSTR pcszFile,
|
|
PCSTR pcszIconFile,
|
|
int niIcon)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(! pcszIconFile ||
|
|
IS_VALID_STRING_PTR(pcszIconFile, CSTR));
|
|
ASSERT(IsValidIconIndex((pcszIconFile ? S_OK : S_FALSE), pcszIconFile, MAX_PATH_LEN, niIcon));
|
|
|
|
if (AnyMeat(pcszIconFile))
|
|
{
|
|
char rgchIconIndexRHS[s_ucMaxIconIndexLen];
|
|
int ncLen;
|
|
|
|
ncLen = wsprintf(rgchIconIndexRHS, "%d", niIcon);
|
|
ASSERT(ncLen > 0);
|
|
ASSERT(ncLen < sizeof(rgchIconIndexRHS));
|
|
ASSERT(ncLen == lstrlen(rgchIconIndexRHS));
|
|
|
|
hr = (WritePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszIconFileKey, pcszIconFile,
|
|
pcszFile) &&
|
|
WritePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszIconIndexKey, rgchIconIndexRHS,
|
|
pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
}
|
|
else
|
|
hr = (DeletePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszIconFileKey, pcszFile) &&
|
|
DeletePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszIconIndexKey, pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT ReadHotkeyFromFile(PCSTR pcszFile, PWORD pwHotkey)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
char rgchHotkey[s_ucMaxHotkeyLen];
|
|
DWORD dwcValueLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pwHotkey, WORD));
|
|
|
|
*pwHotkey = 0;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszHotkeyKey, EMPTY_STRING,
|
|
rgchHotkey, sizeof(rgchHotkey),
|
|
pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
*pwHotkey = (WORD) DecimalStringToUINT(rgchHotkey);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
WARNING_OUT(("ReadHotkeyFromFile(): No hotkey found in file %s.",
|
|
pcszFile));
|
|
|
|
ASSERT((hr == S_OK &&
|
|
IsValidHotkey(*pwHotkey)) ||
|
|
(hr == S_FALSE &&
|
|
! *pwHotkey));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT WriteHotkeyToFile(PCSTR pcszFile, WORD wHotkey)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(! wHotkey ||
|
|
IsValidHotkey(wHotkey));
|
|
|
|
if (wHotkey)
|
|
{
|
|
char rgchHotkeyRHS[s_ucMaxHotkeyLen];
|
|
int ncLen;
|
|
|
|
ncLen = wsprintf(rgchHotkeyRHS, "%u", (UINT)wHotkey);
|
|
ASSERT(ncLen > 0);
|
|
ASSERT(ncLen < sizeof(rgchHotkeyRHS));
|
|
ASSERT(ncLen == lstrlen(rgchHotkeyRHS));
|
|
|
|
hr = WritePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszHotkeyKey, rgchHotkeyRHS,
|
|
pcszFile)
|
|
? S_OK
|
|
: E_FAIL;
|
|
}
|
|
else
|
|
hr = DeletePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszHotkeyKey, pcszFile)
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT ReadWorkingDirectoryFromFile(PCSTR pcszFile,
|
|
PSTR *ppszWorkingDirectory)
|
|
{
|
|
HRESULT hr;
|
|
char rgchDirValue[MAX_PATH_LEN];
|
|
DWORD dwcValueLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszWorkingDirectory, PSTR));
|
|
|
|
*ppszWorkingDirectory = NULL;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszWorkingDirectoryKey,
|
|
EMPTY_STRING, rgchDirValue,
|
|
sizeof(rgchDirValue), pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
char rgchFullPath[MAX_PATH_LEN];
|
|
PSTR pszFileName;
|
|
|
|
if (GetFullPathName(rgchDirValue, sizeof(rgchFullPath), rgchFullPath,
|
|
&pszFileName) > 0)
|
|
{
|
|
// (+ 1) for null terminator.
|
|
|
|
*ppszWorkingDirectory = new(char[lstrlen(rgchFullPath) + 1]);
|
|
|
|
if (*ppszWorkingDirectory)
|
|
{
|
|
lstrcpy(*ppszWorkingDirectory, rgchFullPath);
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("ReadWorkingDirectoryFromFile: No working directory found in file %s.",
|
|
pcszFile));
|
|
}
|
|
|
|
ASSERT(IsValidPathResult(hr, *ppszWorkingDirectory, MAX_PATH_LEN));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT WriteWorkingDirectoryToFile(PCSTR pcszFile,
|
|
PCSTR pcszWorkingDirectory)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(! pcszWorkingDirectory ||
|
|
IS_VALID_STRING_PTR(pcszWorkingDirectory, CSTR));
|
|
|
|
if (AnyMeat(pcszWorkingDirectory))
|
|
hr = (WritePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszWorkingDirectoryKey,
|
|
pcszWorkingDirectory, pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
else
|
|
hr = (DeletePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszWorkingDirectoryKey, pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT ReadShowCmdFromFile(PCSTR pcszFile, PINT pnShowCmd)
|
|
{
|
|
HRESULT hr;
|
|
char rgchNewShowCmd[s_ucMaxShowCmdLen];
|
|
DWORD dwcValueLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pnShowCmd, INT));
|
|
|
|
*pnShowCmd = g_nDefaultShowCmd;
|
|
|
|
dwcValueLen = GetPrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszShowCmdKey, EMPTY_STRING,
|
|
rgchNewShowCmd,
|
|
sizeof(rgchNewShowCmd), pcszFile);
|
|
|
|
if (dwcValueLen > 0)
|
|
{
|
|
*pnShowCmd = DecimalStringToUINT(rgchNewShowCmd);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("ReadShowCmdFromFile: No show command found in file %s.",
|
|
pcszFile));
|
|
}
|
|
|
|
ASSERT((hr == S_OK &&
|
|
EVAL(IsValidShowCmd(*pnShowCmd))) ||
|
|
(hr == S_FALSE &&
|
|
EVAL(*pnShowCmd == g_nDefaultShowCmd)));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT WriteShowCmdToFile(PCSTR pcszFile, int nShowCmd)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
ASSERT(IsValidShowCmd(nShowCmd));
|
|
|
|
if (nShowCmd != g_nDefaultShowCmd)
|
|
{
|
|
char rgchShowCmdRHS[s_ucMaxShowCmdLen];
|
|
int ncLen;
|
|
|
|
ncLen = wsprintf(rgchShowCmdRHS, "%d", nShowCmd);
|
|
ASSERT(ncLen > 0);
|
|
ASSERT(ncLen < sizeof(rgchShowCmdRHS));
|
|
ASSERT(ncLen == lstrlen(rgchShowCmdRHS));
|
|
|
|
hr = (WritePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszShowCmdKey, rgchShowCmdRHS,
|
|
pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
}
|
|
else
|
|
hr = (DeletePrivateProfileString(s_cszInternetShortcutSection,
|
|
s_cszShowCmdKey, pcszFile))
|
|
? S_OK
|
|
: E_FAIL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
#endif // 0
|
|
|
|
/****************************** Public Functions *****************************/
|
|
|
|
// BUGBUG - Isn't this already in NMUTIL?
|
|
HRESULT UnicodeToANSI(LPCOLESTR pcwszUnicode, PSTR *ppszANSI)
|
|
{
|
|
HRESULT hr;
|
|
int ncbLen;
|
|
|
|
// BUGBUG: Need OLESTR validation function to validate pcwszUnicode here.
|
|
ASSERT(IS_VALID_WRITE_PTR(ppszANSI, PSTR));
|
|
|
|
*ppszANSI = NULL;
|
|
|
|
// Get length of translated string.
|
|
|
|
ncbLen = WideCharToMultiByte(CP_ACP, 0, pcwszUnicode, -1, NULL, 0, NULL,
|
|
NULL);
|
|
|
|
if (ncbLen > 0)
|
|
{
|
|
PSTR pszNewANSI;
|
|
|
|
// (+ 1) for null terminator.
|
|
|
|
pszNewANSI = new(char[ncbLen]);
|
|
|
|
if (pszNewANSI)
|
|
{
|
|
// Translate string.
|
|
|
|
if (WideCharToMultiByte(CP_ACP, 0, pcwszUnicode, -1, pszNewANSI,
|
|
ncbLen, NULL, NULL) > 0)
|
|
{
|
|
*ppszANSI = pszNewANSI;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
delete [] pszNewANSI;
|
|
pszNewANSI = NULL;
|
|
|
|
hr = E_UNEXPECTED;
|
|
|
|
WARNING_OUT(("UnicodeToANSI(): Failed to translate Unicode string to ANSI."));
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
|
|
WARNING_OUT(("UnicodeToANSI(): Failed to get length of translated ANSI string."));
|
|
}
|
|
|
|
ASSERT(FAILED(hr) ||
|
|
IS_VALID_STRING_PTR(*ppszANSI, STR));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT ANSIToUnicode(PCSTR pcszANSI, LPOLESTR *ppwszUnicode)
|
|
{
|
|
HRESULT hr;
|
|
int ncbWideLen;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pcszANSI, CSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppwszUnicode, LPOLESTR));
|
|
|
|
*ppwszUnicode = NULL;
|
|
|
|
// Get length of translated string.
|
|
|
|
ncbWideLen = MultiByteToWideChar(CP_ACP, 0, pcszANSI, -1, NULL, 0);
|
|
|
|
if (ncbWideLen > 0)
|
|
{
|
|
PWSTR pwszNewUnicode;
|
|
|
|
// (+ 1) for null terminator.
|
|
|
|
pwszNewUnicode = new(WCHAR[ncbWideLen]);
|
|
|
|
if (pwszNewUnicode)
|
|
{
|
|
// Translate string.
|
|
|
|
if (MultiByteToWideChar(CP_ACP, 0, pcszANSI, -1, pwszNewUnicode,
|
|
ncbWideLen) > 0)
|
|
{
|
|
*ppwszUnicode = pwszNewUnicode;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
delete [] pwszNewUnicode;
|
|
pwszNewUnicode = NULL;
|
|
|
|
hr = E_UNEXPECTED;
|
|
|
|
WARNING_OUT(("ANSIToUnicode(): Failed to translate ANSI path string to Unicode."));
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
|
|
WARNING_OUT(("ANSIToUnicode(): Failed to get length of translated Unicode string."));
|
|
}
|
|
|
|
// BUGBUG: Need OLESTR validation function to validate *ppwszUnicode here.
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
/********************************** Methods **********************************/
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::SaveToFile(PCSTR pcszFile,
|
|
BOOL bRemember)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::SaveToFile);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
|
|
#if 0
|
|
PSTR pszName;
|
|
hr = GetName(&pszName);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = WriteConfNameToFile(pcszFile, pszName);
|
|
|
|
// Free the string:
|
|
if (pszName)
|
|
{
|
|
LPMALLOC pMalloc = NULL;
|
|
|
|
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
|
|
{
|
|
pMalloc->Free(pszName);
|
|
pMalloc->Release();
|
|
pMalloc = NULL;
|
|
pszName = NULL;
|
|
}
|
|
}
|
|
}
|
|
#endif // 0
|
|
|
|
hr = S_OK;
|
|
|
|
if (NULL != m_pszName)
|
|
{
|
|
hr = WriteConfNameToFile(pcszFile, m_pszName);
|
|
}
|
|
|
|
if ((S_OK == hr) &&
|
|
(NULL != m_pszAddress))
|
|
{
|
|
hr = WriteAddressToFile(pcszFile, m_pszAddress);
|
|
}
|
|
|
|
if ((S_OK == hr) &&
|
|
(NULL != m_pszRemoteConfName))
|
|
{
|
|
hr = WriteRemoteConfNameToFile(pcszFile, m_pszRemoteConfName);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = WriteCallFlagsToFile(pcszFile, m_dwCallFlags);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = WriteTransportToFile(pcszFile, m_dwTransport);
|
|
}
|
|
|
|
#if 0
|
|
if (hr == S_OK)
|
|
{
|
|
char rgchBuf[MAX_PATH_LEN];
|
|
int niIcon;
|
|
|
|
hr = GetIconLocation(rgchBuf, sizeof(rgchBuf), &niIcon);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = WriteIconLocationToFile(pcszFile, rgchBuf, niIcon);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
WORD wHotkey;
|
|
|
|
hr = GetHotkey(&wHotkey);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = WriteHotkeyToFile(pcszFile, wHotkey);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = GetWorkingDirectory(rgchBuf, sizeof(rgchBuf));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = WriteWorkingDirectoryToFile(pcszFile, rgchBuf);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
int nShowCmd;
|
|
|
|
GetShowCmd(&nShowCmd);
|
|
|
|
hr = WriteShowCmdToFile(pcszFile, nShowCmd);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
/* Remember file if requested. */
|
|
|
|
#endif
|
|
if (bRemember)
|
|
{
|
|
// Replace existing file string, if any
|
|
if (m_pszFile)
|
|
{
|
|
delete m_pszFile;
|
|
}
|
|
|
|
m_pszFile = new TCHAR[lstrlen(pcszFile)+1];
|
|
if (NULL != m_pszFile)
|
|
{
|
|
lstrcpy(m_pszFile, pcszFile);
|
|
|
|
TRACE_OUT(("CConfLink::SaveToFile(): Remembering file %s, as requested.",
|
|
m_pszFile));
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
Dirty(FALSE);
|
|
|
|
SHChangeNotify(SHCNE_UPDATEITEM,
|
|
(SHCNF_PATH | SHCNF_FLUSH), pcszFile,
|
|
NULL);
|
|
|
|
#ifdef DEBUG
|
|
TRACE_OUT(("CConfLink::SaveToFile(): Conf Link saved to file %s:",
|
|
pcszFile));
|
|
Dump();
|
|
#endif // DEBUG
|
|
}
|
|
#if 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif // 0
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::SaveToFile, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::LoadFromFile( PCSTR pcszFile,
|
|
BOOL bRemember)
|
|
{
|
|
HRESULT hr;
|
|
PSTR pszName;
|
|
PSTR pszAddr;
|
|
PSTR pszRemoteConfName;
|
|
DWORD dwTransport;
|
|
DWORD dwCallFlags;
|
|
|
|
DebugEntry(CConfLink::LoadFromFile);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRING_PTR(pcszFile, CSTR));
|
|
|
|
hr = ReadConfNameFromFile(pcszFile, &pszName);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = SetName(pszName);
|
|
|
|
if (pszName)
|
|
{
|
|
delete pszName;
|
|
pszName = NULL;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ReadAddressFromFile(pcszFile, &pszAddr);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = SetAddress(pszAddr);
|
|
|
|
if (NULL != pszAddr)
|
|
{
|
|
delete pszAddr;
|
|
pszAddr = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ReadTransportFromFile(pcszFile, &dwTransport);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = SetTransport(dwTransport);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ReadCallFlagsFromFile(pcszFile, &dwCallFlags);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = SetCallFlags(dwCallFlags);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ReadRemoteConfNameFromFile(pcszFile, &pszRemoteConfName);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = SetRemoteConfName(pszRemoteConfName);
|
|
|
|
delete pszRemoteConfName;
|
|
pszRemoteConfName = NULL;
|
|
}
|
|
}
|
|
#if 0
|
|
if (hr == S_OK)
|
|
{
|
|
PSTR pszIconFile;
|
|
int niIcon;
|
|
|
|
hr = ReadIconLocationFromFile(pcszFile, &pszIconFile, &niIcon);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SetIconLocation(pszIconFile, niIcon);
|
|
|
|
if (pszIconFile)
|
|
{
|
|
delete pszIconFile;
|
|
pszIconFile = NULL;
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
WORD wHotkey;
|
|
|
|
hr = ReadHotkeyFromFile(pcszFile, &wHotkey);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SetHotkey(wHotkey);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
PSTR pszWorkingDirectory;
|
|
|
|
hr = ReadWorkingDirectoryFromFile(pcszFile,
|
|
&pszWorkingDirectory);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SetWorkingDirectory(pszWorkingDirectory);
|
|
|
|
if (pszWorkingDirectory)
|
|
{
|
|
delete pszWorkingDirectory;
|
|
pszWorkingDirectory = NULL;
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
int nShowCmd;
|
|
|
|
hr = ReadShowCmdFromFile(pcszFile, &nShowCmd);
|
|
|
|
#endif // 0
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
/* Remember file if requested. */
|
|
|
|
if (bRemember)
|
|
{
|
|
// PSTR pszFileCopy;
|
|
|
|
//
|
|
if (NULL != m_pszFile)
|
|
{
|
|
delete m_pszFile;
|
|
}
|
|
|
|
m_pszFile = new TCHAR[lstrlen(pcszFile) + 1];
|
|
|
|
if (NULL != m_pszFile)
|
|
{
|
|
lstrcpy(m_pszFile, pcszFile);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
// if (StringCopy(pcszFile, &pszFileCopy))
|
|
// {
|
|
// if (m_pszFile)
|
|
// delete m_pszFile;
|
|
|
|
// m_pszFile = pszFileCopy;
|
|
|
|
// TRACE_OUT(("CConfLink::LoadFromFile(): Remembering file %s, as requested.",
|
|
// m_pszFile));
|
|
// }
|
|
// else
|
|
// hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// SetShowCmd(nShowCmd);
|
|
|
|
Dirty(FALSE);
|
|
|
|
hr = S_OK;
|
|
|
|
#ifdef DEBUG
|
|
TRACE_OUT(("CConfLink::LoadFromFile(): Conf Link loaded from file %s:",
|
|
pcszFile));
|
|
Dump();
|
|
#endif
|
|
}
|
|
}
|
|
#if 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // 0
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::LoadFromFile, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::GetCurFile(PSTR pszFile,
|
|
UINT ucbLen)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::GetCurFile);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszFile, STR, ucbLen));
|
|
|
|
if (m_pszFile)
|
|
{
|
|
lstrcpyn(pszFile, m_pszFile, ucbLen);
|
|
|
|
TRACE_OUT(("CConfLink::GetCurFile(): Current file name is %s.",
|
|
pszFile));
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = S_FALSE;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, STR) &&
|
|
EVAL((UINT)lstrlen(pszFile) < ucbLen));
|
|
ASSERT(hr == S_OK ||
|
|
hr == S_FALSE);
|
|
|
|
DebugExitHRESULT(CConfLink::GetCurFile, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::Dirty(BOOL bDirty)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::Dirty);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
if (bDirty)
|
|
{
|
|
if (IS_FLAG_CLEAR(m_dwFlags, CONFLNK_FL_DIRTY))
|
|
{
|
|
TRACE_OUT(("CConfLink::Dirty(): Now dirty."));
|
|
}
|
|
|
|
SET_FLAG(m_dwFlags, CONFLNK_FL_DIRTY);
|
|
}
|
|
else
|
|
{
|
|
if (IS_FLAG_SET(m_dwFlags, CONFLNK_FL_DIRTY))
|
|
{
|
|
TRACE_OUT(("CConfLink::Dirty(): Now clean."));
|
|
}
|
|
|
|
CLEAR_FLAG(m_dwFlags, CONFLNK_FL_DIRTY);
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(hr == S_OK);
|
|
|
|
DebugExitVOID(CConfLink::Dirty);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::GetClassID(PCLSID pclsid)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::GetClassID);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pclsid, CCLSID));
|
|
|
|
*pclsid = CLSID_ConfLink;
|
|
hr = S_OK;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(FAILED(hr) ||
|
|
IS_VALID_STRUCT_PTR(pclsid, CCLSID));
|
|
|
|
DebugExitHRESULT(CConfLink::GetClassID, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::IsDirty(void)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::IsDirty);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
if (IS_FLAG_SET(m_dwFlags, CONFLNK_FL_DIRTY))
|
|
hr = S_OK;
|
|
else
|
|
hr = S_FALSE;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::IsDirty, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::Save( LPCOLESTR pcwszFile,
|
|
BOOL bRemember)
|
|
{
|
|
HRESULT hr;
|
|
PSTR pszFile;
|
|
|
|
DebugEntry(CConfLink::Save);
|
|
|
|
// bRemember may be any value.
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
// BUGBUG: Need OLESTR validation function to validate pcwszFile here.
|
|
|
|
if (pcwszFile)
|
|
{
|
|
hr = UnicodeToANSI(pcwszFile, &pszFile);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = SaveToFile(pszFile, bRemember);
|
|
|
|
delete pszFile;
|
|
pszFile = NULL;
|
|
}
|
|
}
|
|
else if (m_pszFile)
|
|
// Ignore bRemember.
|
|
hr = SaveToFile(m_pszFile, FALSE);
|
|
else
|
|
hr = E_FAIL;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::Save, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
// #pragma warning(disable:4100) /* "unreferenced formal parameter" warning */
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::SaveCompleted(LPCOLESTR pcwszFile)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::SaveCompleted);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
// BUGBUG: Need OLESTR validation function to validate pcwszFile here.
|
|
|
|
hr = S_OK;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::SaveCompleted, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::Load( LPCOLESTR pcwszFile,
|
|
DWORD dwMode)
|
|
{
|
|
HRESULT hr;
|
|
PSTR pszFile;
|
|
|
|
DebugEntry(CConfLink::Load);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
// BUGBUG: Need OLESTR validation function to validate pcwszFile here.
|
|
// BUGBUG: Validate dwMode here.
|
|
|
|
// BUGBUG: Implement dwMode flag support.
|
|
|
|
hr = UnicodeToANSI(pcwszFile, &pszFile);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = LoadFromFile(pszFile, TRUE);
|
|
|
|
delete pszFile;
|
|
pszFile = NULL;
|
|
}
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::Load, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
// #pragma warning(default:4100) /* "unreferenced formal parameter" warning */
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::GetCurFile(LPOLESTR *ppwszFile)
|
|
{
|
|
HRESULT hr;
|
|
LPOLESTR pwszTempFile;
|
|
|
|
DebugEntry(CConfLink::GetCurFile);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppwszFile, LPOLESTR));
|
|
|
|
if (m_pszFile)
|
|
{
|
|
hr = ANSIToUnicode(m_pszFile, &pwszTempFile);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
TRACE_OUT(("CConfLink::GetCurFile(): Current file name is %s.",
|
|
m_pszFile));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = ANSIToUnicode(g_cszConfLinkDefaultFileNamePrompt, &pwszTempFile);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
TRACE_OUT(("CConfLink::GetCurFile(): No current file name. Returning default file name prompt %s.",
|
|
g_cszConfLinkDefaultFileNamePrompt));
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// We should really call OleGetMalloc() to get the process IMalloc here.
|
|
// Use SHAlloc() here instead to avoid loading ole32.dll.
|
|
// SHAlloc() / SHFree() turn in to IMalloc::Alloc() and IMalloc::Free()
|
|
// once ole32.dll is loaded.
|
|
|
|
// N.b., lstrlenW() returns the length of the given string in characters,
|
|
// not bytes.
|
|
|
|
// (+ 1) for null terminator.
|
|
|
|
LPMALLOC pMalloc = NULL;
|
|
*ppwszFile = NULL;
|
|
|
|
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
|
|
{
|
|
*ppwszFile = (LPOLESTR) pMalloc->Alloc((lstrlenW(pwszTempFile) + 1) *
|
|
sizeof(*pwszTempFile));
|
|
pMalloc->Release();
|
|
pMalloc = NULL;
|
|
}
|
|
|
|
|
|
if (*ppwszFile)
|
|
{
|
|
LStrCpyW(*ppwszFile, pwszTempFile);
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
delete pwszTempFile;
|
|
pwszTempFile = NULL;
|
|
}
|
|
|
|
// BUGBUG: Need OLESTR validation function to validate *ppwszFile here.
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::GetCurFile, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
// #pragma warning(disable:4100) /* "unreferenced formal parameter" warning */
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::Load(PIStream pistr)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::Load);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_INTERFACE_PTR(pistr, IStream));
|
|
|
|
hr = E_NOTIMPL;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::Load, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::Save( PIStream pistr,
|
|
BOOL bClearDirty)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::Save);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_INTERFACE_PTR(pistr, IStream));
|
|
|
|
hr = E_NOTIMPL;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::Save, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::GetSizeMax(PULARGE_INTEGER pcbSize)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::GetSizeMax);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_WRITE_PTR(pcbSize, ULARGE_INTEGER));
|
|
|
|
hr = E_NOTIMPL;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitHRESULT(CConfLink::GetSizeMax, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
// #pragma warning(default:4100) /* "unreferenced formal parameter" warning */
|
|
|
|
|
|
DWORD STDMETHODCALLTYPE CConfLink::GetFileContentsSize(void)
|
|
{
|
|
DWORD dwcbLen;
|
|
|
|
DebugEntry(CConfLink::GetFileContentsSize);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
// Section length.
|
|
|
|
// (- 1) for each null terminator.
|
|
|
|
dwcbLen = sizeof(s_cszSectionBefore) - 1 +
|
|
sizeof(s_cszConferenceShortcutSection) - 1 +
|
|
sizeof(s_cszSectionAfter) - 1;
|
|
|
|
if (m_pszName)
|
|
{
|
|
// Name length.
|
|
dwcbLen += sizeof(g_cszCRLF) - 1 +
|
|
sizeof(s_cszNameKey) - 1 +
|
|
sizeof(s_cszKeyValueSep) - 1 +
|
|
lstrlen(m_pszName);
|
|
}
|
|
|
|
if (m_pszAddress)
|
|
{
|
|
// Address length.
|
|
dwcbLen += sizeof(g_cszCRLF) - 1 +
|
|
sizeof(s_cszAddressKey) - 1 +
|
|
sizeof(s_cszKeyValueSep) - 1 +
|
|
lstrlen(m_pszAddress);
|
|
}
|
|
|
|
if (m_pszRemoteConfName)
|
|
{
|
|
// RemoteConfName length.
|
|
dwcbLen += sizeof(g_cszCRLF) - 1 +
|
|
sizeof(s_cszRemoteConfNameKey) - 1 +
|
|
sizeof(s_cszKeyValueSep) - 1 +
|
|
lstrlen(m_pszRemoteConfName);
|
|
}
|
|
|
|
// CallFlags length
|
|
dwcbLen += sizeof(g_cszCRLF) - 1 +
|
|
sizeof(s_cszCallFlagsKey) - 1 +
|
|
sizeof(s_cszKeyValueSep) - 1 +
|
|
s_ucMaxCallFlagsLen;
|
|
|
|
// Transport length
|
|
dwcbLen += sizeof(g_cszCRLF) - 1 +
|
|
sizeof(s_cszTransportKey) - 1 +
|
|
sizeof(s_cszKeyValueSep) - 1 +
|
|
s_ucMaxTransportLen;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
DebugExitDWORD(CConfLink::GetFileContentsSize, dwcbLen);
|
|
|
|
return(dwcbLen);
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
void STDMETHODCALLTYPE CConfLink::Dump(void)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
|
|
TRACE_OUT(("m_dwFlags = %#08lx", m_dwFlags));
|
|
TRACE_OUT(("m_pszFile = \"%s\"", CHECK_STRING(m_pszFile)));
|
|
TRACE_OUT(("m_pszName = \"%s\"", CHECK_STRING(m_pszName)));
|
|
#if 0
|
|
TRACE_OUT(("m_pszIconFile = \"%s\"", CHECK_STRING(m_pszIconFile)));
|
|
TRACE_OUT(("m_niIcon = %d", m_niIcon));
|
|
TRACE_OUT(("m_wHotkey = %#04x", (UINT)m_wHotkey));
|
|
TRACE_OUT(("m_pszWorkingDirectory = \"%s\"", CHECK_STRING(m_pszWorkingDirectory)));
|
|
TRACE_OUT(("m_nShowCmd = %d", m_nShowCmd));
|
|
#endif // 0
|
|
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if 0
|
|
HRESULT STDMETHODCALLTYPE CConfLink::TransferConfLink( PFORMATETC pfmtetc,
|
|
PSTGMEDIUM pstgmed)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::TransferConfLink);
|
|
|
|
ASSERT(0 && "If we hit this assert, we need to implement this function");
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pfmtetc, CFORMATETC));
|
|
ASSERT(IS_VALID_WRITE_PTR(pstgmed, STGMEDIUM));
|
|
|
|
ASSERT(pfmtetc->dwAspect == DVASPECT_CONTENT);
|
|
ASSERT(pfmtetc->lindex == -1);
|
|
|
|
ZeroMemory(pstgmed, sizeof(*pstgmed));
|
|
|
|
if (IS_FLAG_SET(pfmtetc->tymed, TYMED_HGLOBAL))
|
|
{
|
|
// BUGBUG: ChrisPi 9-15-95
|
|
// This only transfers the conference name
|
|
// (It does not transfer the address)
|
|
|
|
if (m_pszName)
|
|
{
|
|
HGLOBAL hgName;
|
|
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
// (+ 1) for null terminator.
|
|
hgName = GlobalAlloc(0, lstrlen(m_pszName) + 1);
|
|
|
|
if (hgName)
|
|
{
|
|
PSTR pszName;
|
|
|
|
pszName = (PSTR)GlobalLock(hgName);
|
|
|
|
if (EVAL(pszName))
|
|
{
|
|
lstrcpy(pszName, m_pszName);
|
|
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = hgName;
|
|
ASSERT(! pstgmed->pUnkForRelease);
|
|
|
|
hr = S_OK;
|
|
|
|
GlobalUnlock(hgName);
|
|
pszName = NULL;
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
GlobalFree(hgName);
|
|
hgName = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DV_E_FORMATETC;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DV_E_TYMED;
|
|
}
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT((hr == S_OK &&
|
|
IS_VALID_STRUCT_PTR(pstgmed, CSTGMEDIUM)) ||
|
|
(FAILED(hr) &&
|
|
(EVAL(pstgmed->tymed == TYMED_NULL) &&
|
|
EVAL(! pstgmed->hGlobal) &&
|
|
EVAL(! pstgmed->pUnkForRelease))));
|
|
|
|
DebugExitHRESULT(CConfLink::TransferConfLink, hr);
|
|
|
|
return(hr);
|
|
}
|
|
#endif // 0
|
|
|
|
#if 0
|
|
HRESULT STDMETHODCALLTYPE CConfLink::TransferText( PFORMATETC pfmtetc,
|
|
PSTGMEDIUM pstgmed)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::TransferText);
|
|
|
|
// Assume CConfLink::TransferConfLink() will perform
|
|
// input and output validation.
|
|
|
|
hr = TransferConfLink(pfmtetc, pstgmed);
|
|
|
|
DebugExitHRESULT(CConfLink::TransferText, hr);
|
|
|
|
return(hr);
|
|
}
|
|
#endif // 0
|
|
|
|
#if 0
|
|
HRESULT STDMETHODCALLTYPE CConfLink::TransferFileGroupDescriptor( PFORMATETC pfmtetc,
|
|
PSTGMEDIUM pstgmed)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::TransferFileGroupDescriptor);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pfmtetc, CFORMATETC));
|
|
ASSERT(IS_VALID_WRITE_PTR(pstgmed, STGMEDIUM));
|
|
|
|
ASSERT(pfmtetc->dwAspect == DVASPECT_CONTENT);
|
|
ASSERT(pfmtetc->lindex == -1);
|
|
|
|
pstgmed->tymed = TYMED_NULL;
|
|
pstgmed->hGlobal = NULL;
|
|
pstgmed->pUnkForRelease = NULL;
|
|
|
|
if (IS_FLAG_SET(pfmtetc->tymed, TYMED_HGLOBAL))
|
|
{
|
|
HGLOBAL hgFileGroupDesc;
|
|
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
hgFileGroupDesc = GlobalAlloc(GMEM_ZEROINIT,
|
|
sizeof(FILEGROUPDESCRIPTOR));
|
|
|
|
if (hgFileGroupDesc)
|
|
{
|
|
PFILEGROUPDESCRIPTOR pfgd;
|
|
|
|
pfgd = (PFILEGROUPDESCRIPTOR)GlobalLock(hgFileGroupDesc);
|
|
|
|
if (EVAL(pfgd))
|
|
{
|
|
PFILEDESCRIPTOR pfd = &(pfgd->fgd[0]);
|
|
|
|
// Do we already have a file name to use?
|
|
|
|
if (m_pszName)
|
|
{
|
|
TCHAR szFileName[MAX_PATH];
|
|
|
|
// copy shortcut
|
|
// BUGBUG: needs to be a resource INTL
|
|
lstrcpy(szFileName, _TEXT("Shortcut to "));
|
|
|
|
// copy Conference Name
|
|
lstrcat(szFileName, m_pszName);
|
|
|
|
// copy extension
|
|
lstrcat(szFileName, g_cszConfLinkExt);
|
|
|
|
MyLStrCpyN(pfd->cFileName, szFileName,
|
|
sizeof(pfd->cFileName));
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
// BUGBUG: need resource here! INTL
|
|
//if (EVAL(LoadString(GetThisModulesHandle(),
|
|
// IDS_NEW_INTERNET_SHORTCUT, pfd->cFileName,
|
|
// sizeof(pfd->cFileName))))
|
|
|
|
MyLStrCpyN(pfd->cFileName, "New Conference Shortcut.cnf",
|
|
sizeof(pfd->cFileName));
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
pfd->dwFlags = (FD_FILESIZE |
|
|
FD_LINKUI);
|
|
pfd->nFileSizeHigh = 0;
|
|
|
|
pfd->nFileSizeLow = GetFileContentsSize();
|
|
|
|
pfgd->cItems = 1;
|
|
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = hgFileGroupDesc;
|
|
ASSERT(! pstgmed->pUnkForRelease);
|
|
}
|
|
|
|
GlobalUnlock(hgFileGroupDesc);
|
|
pfgd = NULL;
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
GlobalFree(hgFileGroupDesc);
|
|
hgFileGroupDesc = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DV_E_TYMED;
|
|
}
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT((hr == S_OK &&
|
|
IS_VALID_STRUCT_PTR(pstgmed, CSTGMEDIUM)) ||
|
|
(FAILED(hr) &&
|
|
(EVAL(pstgmed->tymed == TYMED_NULL) &&
|
|
EVAL(! pstgmed->hGlobal) &&
|
|
EVAL(! pstgmed->pUnkForRelease))));
|
|
|
|
DebugExitHRESULT(CConfLink::TransferFileGroupDescriptor, hr);
|
|
|
|
return(hr);
|
|
}
|
|
#endif // 0
|
|
|
|
HRESULT STDMETHODCALLTYPE CConfLink::TransferFileContents( PFORMATETC pfmtetc,
|
|
PSTGMEDIUM pstgmed)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DebugEntry(CConfLink::TransferFileContents);
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT(IS_VALID_STRUCT_PTR(pfmtetc, CFORMATETC));
|
|
ASSERT(IS_VALID_WRITE_PTR(pstgmed, STGMEDIUM));
|
|
|
|
ASSERT(pfmtetc->dwAspect == DVASPECT_CONTENT);
|
|
ASSERT(! pfmtetc->lindex);
|
|
|
|
pstgmed->tymed = TYMED_NULL;
|
|
pstgmed->hGlobal = NULL;
|
|
pstgmed->pUnkForRelease = NULL;
|
|
|
|
if (IS_FLAG_SET(pfmtetc->tymed, TYMED_HGLOBAL))
|
|
{
|
|
DWORD dwcbLen;
|
|
HGLOBAL hgFileContents;
|
|
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
dwcbLen = GetFileContentsSize();
|
|
|
|
hgFileContents = GlobalAlloc(0, dwcbLen);
|
|
|
|
if (hgFileContents)
|
|
{
|
|
PSTR pszFileContents;
|
|
|
|
pszFileContents = (PSTR)GlobalLock(hgFileContents);
|
|
|
|
if (EVAL(pszFileContents))
|
|
{
|
|
PSTR psz = pszFileContents;
|
|
|
|
// Copy section.
|
|
|
|
CopyMemory(psz, s_cszSectionBefore, sizeof(s_cszSectionBefore) - 1);
|
|
psz += sizeof(s_cszSectionBefore) - 1;
|
|
|
|
CopyMemory(psz, s_cszConferenceShortcutSection, sizeof(s_cszConferenceShortcutSection) - 1);
|
|
psz += sizeof(s_cszConferenceShortcutSection) - 1;
|
|
|
|
CopyMemory(psz, s_cszSectionAfter, sizeof(s_cszSectionAfter) - 1);
|
|
psz += sizeof(s_cszSectionAfter) - 1;
|
|
|
|
if (m_pszName)
|
|
{
|
|
// Copy Name.
|
|
|
|
CopyMemory(psz, g_cszCRLF, sizeof(g_cszCRLF) - 1);
|
|
psz += sizeof(g_cszCRLF) - 1;
|
|
|
|
CopyMemory(psz, s_cszNameKey, sizeof(s_cszNameKey) - 1);
|
|
psz += sizeof(s_cszNameKey) - 1;
|
|
|
|
CopyMemory(psz, s_cszKeyValueSep, sizeof(s_cszKeyValueSep) - 1);
|
|
psz += sizeof(s_cszKeyValueSep) - 1;
|
|
|
|
CopyMemory(psz, m_pszName, lstrlen(m_pszName));
|
|
psz += lstrlen(m_pszName);
|
|
}
|
|
|
|
if (m_pszAddress)
|
|
{
|
|
// Copy Name.
|
|
|
|
CopyMemory(psz, g_cszCRLF, sizeof(g_cszCRLF) - 1);
|
|
psz += sizeof(g_cszCRLF) - 1;
|
|
|
|
CopyMemory(psz, s_cszAddressKey, sizeof(s_cszAddressKey) - 1);
|
|
psz += sizeof(s_cszAddressKey) - 1;
|
|
|
|
CopyMemory(psz, s_cszKeyValueSep, sizeof(s_cszKeyValueSep) - 1);
|
|
psz += sizeof(s_cszKeyValueSep) - 1;
|
|
|
|
CopyMemory(psz, m_pszAddress, lstrlen(m_pszAddress));
|
|
psz += lstrlen(m_pszAddress);
|
|
}
|
|
|
|
// Copy Transport.
|
|
CopyMemory(psz, g_cszCRLF, sizeof(g_cszCRLF) - 1);
|
|
psz += sizeof(g_cszCRLF) - 1;
|
|
|
|
CopyMemory(psz, s_cszTransportKey, sizeof(s_cszTransportKey) - 1);
|
|
psz += sizeof(s_cszTransportKey) - 1;
|
|
|
|
CopyMemory(psz, s_cszKeyValueSep, sizeof(s_cszKeyValueSep) - 1);
|
|
psz += sizeof(s_cszKeyValueSep) - 1;
|
|
|
|
TCHAR szBuf[s_ucMaxTransportLen];
|
|
wsprintf(szBuf, "%10u", m_dwTransport);
|
|
CopyMemory(psz, szBuf, lstrlen(szBuf));
|
|
psz += lstrlen(szBuf);
|
|
|
|
|
|
|
|
ASSERT(psz == pszFileContents + dwcbLen);
|
|
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = hgFileContents;
|
|
ASSERT(! pstgmed->pUnkForRelease);
|
|
|
|
hr = S_OK;
|
|
|
|
GlobalUnlock(hgFileContents);
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
GlobalFree(hgFileContents);
|
|
hgFileContents = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = DV_E_TYMED;
|
|
}
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
|
|
ASSERT((hr == S_OK &&
|
|
IS_VALID_STRUCT_PTR(pstgmed, CSTGMEDIUM)) ||
|
|
(FAILED(hr) &&
|
|
(EVAL(pstgmed->tymed == TYMED_NULL) &&
|
|
EVAL(! pstgmed->hGlobal) &&
|
|
EVAL(! pstgmed->pUnkForRelease))));
|
|
|
|
DebugExitHRESULT(CConfLink::TransferFileContents, hr);
|
|
|
|
return(hr);
|
|
}
|
|
|