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.
669 lines
14 KiB
669 lines
14 KiB
|
|
/****************************** Module Header ******************************\
|
|
* Module Name: utils.c
|
|
*
|
|
* Purpose: Conatains all the utility routines
|
|
*
|
|
* Created: 1990
|
|
*
|
|
* Copyright (c) 1990, 1991 Microsoft Corporation
|
|
*
|
|
* History:
|
|
* Raor, srinik (../../1990,91) Designed and coded
|
|
*
|
|
\***************************************************************************/
|
|
|
|
#include <windows.h>
|
|
#include <shellapi.h>
|
|
|
|
#include "dll.h"
|
|
|
|
#define KB_64 65536
|
|
|
|
extern ATOM aPackage;
|
|
extern OLEOBJECTVTBL vtblMF, vtblBM, vtblDIB, vtblGEN;
|
|
|
|
// QuerySize API support
|
|
DWORD dwObjSize = NULL;
|
|
OLESTREAMVTBL dllStreamVtbl;
|
|
OLESTREAM dllStream;
|
|
|
|
|
|
#pragma alloc_text(_DDETEXT, UtilMemClr, MapStrToH, MapExtToClass, FileExists)
|
|
|
|
BOOL PutStrWithLen(lpstream, lpbytes)
|
|
LPOLESTREAM lpstream;
|
|
LPSTR lpbytes;
|
|
{
|
|
LONG len;
|
|
|
|
len = (LONG) lstrlen(lpbytes) + 1;
|
|
|
|
if (PutBytes (lpstream, (LPSTR)&len, sizeof(len)))
|
|
return TRUE;
|
|
|
|
return PutBytes(lpstream, lpbytes, len);
|
|
|
|
}
|
|
|
|
BOOL GetStrWithLen(lpstream, lpbytes)
|
|
LPOLESTREAM lpstream;
|
|
LPSTR lpbytes;
|
|
{
|
|
if (GetBytes (lpstream, lpbytes, sizeof(LONG)))
|
|
return TRUE;
|
|
|
|
return GetBytes (lpstream, lpbytes + sizeof(LONG), (*(LONG FAR *)lpbytes));
|
|
}
|
|
|
|
ATOM GetAtomFromStream(lpstream)
|
|
LPOLESTREAM lpstream;
|
|
{
|
|
BOOL err = TRUE;
|
|
LONG len;
|
|
char str[MAX_STR+1];
|
|
|
|
|
|
if (GetBytes (lpstream, (LPSTR)&len, sizeof(len)))
|
|
return NULL;
|
|
|
|
if (len == 0)
|
|
return NULL;
|
|
|
|
if (GetBytes(lpstream, (LPSTR)str, len))
|
|
return NULL;
|
|
|
|
return GlobalAddAtom(str);
|
|
|
|
}
|
|
|
|
BOOL PutAtomIntoStream(lpstream, at)
|
|
LPOLESTREAM lpstream;
|
|
ATOM at;
|
|
{
|
|
LONG len = 0;
|
|
char buf[MAX_STR + 1];
|
|
|
|
if (at == 0)
|
|
return (PutBytes (lpstream, (LPSTR)&len, sizeof(len)));
|
|
|
|
|
|
len = GlobalGetAtomName (at,(LPSTR)buf, MAX_STR) + 1;
|
|
|
|
if (PutBytes (lpstream, (LPSTR)&len, sizeof(len)))
|
|
return TRUE;
|
|
|
|
return PutBytes(lpstream, buf, len);
|
|
}
|
|
|
|
|
|
// DuplicateAtom: Bump the use count up on a global atom.
|
|
|
|
ATOM FARINTERNAL DuplicateAtom (ATOM atom)
|
|
{
|
|
char buffer[MAX_ATOM+1];
|
|
|
|
Puts("DuplicateAtom");
|
|
|
|
if (!atom)
|
|
return NULL;
|
|
|
|
GlobalGetAtomName (atom, buffer, MAX_ATOM);
|
|
return GlobalAddAtom (buffer);
|
|
}
|
|
|
|
|
|
|
|
BOOL GetBytes(lpstream, lpstr, len)
|
|
LPOLESTREAM lpstream;
|
|
LPSTR lpstr;
|
|
LONG len;
|
|
{
|
|
|
|
ASSERT (lpstream->lpstbl->Get , "stream get function is null");
|
|
return (((*lpstream->lpstbl->Get)(lpstream, lpstr, (DWORD)len)) != (DWORD)len);
|
|
}
|
|
|
|
|
|
BOOL PutBytes(lpstream, lpstr, len)
|
|
LPOLESTREAM lpstream;
|
|
LPSTR lpstr;
|
|
LONG len;
|
|
{
|
|
|
|
ASSERT (lpstream->lpstbl->Put , "stream get function is null");
|
|
return (((*lpstream->lpstbl->Put)(lpstream, lpstr, (DWORD)len)) != (DWORD)len);
|
|
}
|
|
|
|
|
|
BOOL FARINTERNAL UtilMemCmp (lpmem1, lpmem2, dwCount)
|
|
LPSTR lpmem1;
|
|
LPSTR lpmem2;
|
|
DWORD dwCount;
|
|
{
|
|
WORD HUGE * hpmem1;
|
|
WORD HUGE * hpmem2;
|
|
WORD FAR * lpwMem1;
|
|
WORD FAR * lpwMem2;
|
|
DWORD words;
|
|
DWORD bytes;
|
|
|
|
bytes = dwCount % 2;
|
|
words = dwCount >> 1; //* we should compare DWORDS
|
|
//* in the 32 bit version
|
|
if (dwCount <= KB_64) {
|
|
lpwMem1 = (WORD FAR *) lpmem1;
|
|
lpwMem2 = (WORD FAR *) lpmem2;
|
|
|
|
while (words--) {
|
|
if (*lpwMem1++ != *lpwMem2++)
|
|
return FALSE;
|
|
}
|
|
|
|
if (bytes) {
|
|
if (* (char FAR *) lpwMem1 != *(char FAR *) lpwMem2)
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
else {
|
|
hpmem1 = (WORD HUGE *) lpmem1;
|
|
hpmem2 = (WORD HUGE *) lpmem2;
|
|
|
|
while (words--) {
|
|
if (*hpmem1++ != *hpmem2++)
|
|
return FALSE;
|
|
}
|
|
|
|
if (bytes) {
|
|
if (* (char HUGE *) hpmem1 != * (char HUGE *) hpmem2)
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void FARINTERNAL UtilMemCpy (lpdst, lpsrc, dwCount)
|
|
LPSTR lpdst;
|
|
LPSTR lpsrc;
|
|
DWORD dwCount;
|
|
{
|
|
WORD HUGE * hpdst;
|
|
WORD HUGE * hpsrc;
|
|
WORD FAR * lpwDst;
|
|
WORD FAR * lpwSrc;
|
|
DWORD words;
|
|
DWORD bytes;
|
|
|
|
bytes = dwCount % 2;
|
|
words = dwCount >> 1; //* we should compare DWORDS
|
|
//* in the 32 bit version
|
|
if (dwCount <= KB_64) {
|
|
lpwDst = (WORD FAR *) lpdst;
|
|
lpwSrc = (WORD FAR *) lpsrc;
|
|
|
|
while (words--)
|
|
*lpwDst++ = *lpwSrc++;
|
|
|
|
if (bytes)
|
|
* (char FAR *) lpwDst = * (char FAR *) lpwSrc;
|
|
}
|
|
else {
|
|
hpdst = (WORD HUGE *) lpdst;
|
|
hpsrc = (WORD HUGE *) lpsrc;
|
|
|
|
while (words--)
|
|
*hpdst++ = *hpsrc++;
|
|
|
|
if (bytes)
|
|
*(char HUGE *) hpdst = * (char HUGE *) hpsrc;
|
|
}
|
|
}
|
|
|
|
|
|
//DuplicateData: Duplicates a given Global data handle.
|
|
HANDLE FARINTERNAL DuplicateGlobal (hdata, flags)
|
|
HANDLE hdata;
|
|
WORD flags;
|
|
{
|
|
LPSTR lpdst = NULL;
|
|
LPSTR lpsrc = NULL;
|
|
HANDLE hdup = NULL;
|
|
DWORD size;
|
|
BOOL err = TRUE;
|
|
|
|
if (!hdata)
|
|
return NULL;
|
|
|
|
if(!(lpsrc = GlobalLock (hdata)))
|
|
return NULL;
|
|
|
|
hdup = GlobalAlloc (flags, (size = GlobalSize(hdata)));
|
|
|
|
if(!(lpdst = GlobalLock (hdup)))
|
|
goto errRtn;;
|
|
|
|
err = FALSE;
|
|
UtilMemCpy (lpdst, lpsrc, size);
|
|
|
|
errRtn:
|
|
if(lpsrc)
|
|
GlobalUnlock (hdata);
|
|
|
|
if(lpdst)
|
|
GlobalUnlock (hdup);
|
|
|
|
if (err && hdup) {
|
|
GlobalFree (hdup);
|
|
hdup = NULL;
|
|
}
|
|
|
|
return hdup;
|
|
}
|
|
|
|
|
|
BOOL FARINTERNAL CmpGlobals (hdata1, hdata2)
|
|
HANDLE hdata1;
|
|
HANDLE hdata2;
|
|
{
|
|
LPSTR lpdata1 = NULL;
|
|
LPSTR lpdata2 = NULL;
|
|
DWORD size1;
|
|
DWORD size2;
|
|
BOOL retval = FALSE;
|
|
|
|
|
|
size1 = GlobalSize (hdata1);
|
|
size2 = GlobalSize (hdata2);
|
|
|
|
if (size1 != size2)
|
|
return FALSE;
|
|
|
|
if (!(lpdata1 = GlobalLock (hdata1)))
|
|
goto errRtn;
|
|
|
|
if (!(lpdata2 = GlobalLock (hdata2)))
|
|
goto errRtn;
|
|
|
|
retval = UtilMemCmp (lpdata1, lpdata2, size1);
|
|
|
|
errRtn:
|
|
if (lpdata1)
|
|
GlobalUnlock (hdata1);
|
|
|
|
if (lpdata2)
|
|
GlobalUnlock (hdata2);
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
int FARINTERNAL GlobalGetAtomLen (aItem)
|
|
ATOM aItem;
|
|
{
|
|
// !!! Change this
|
|
char buf[MAX_STR];
|
|
|
|
if (!aItem)
|
|
return NULL;
|
|
|
|
return (GlobalGetAtomName (aItem, (LPSTR)buf, MAX_STR));
|
|
|
|
}
|
|
|
|
|
|
BOOL FARINTERNAL MapExtToClass (lptemplate, lpbuf, len)
|
|
LPSTR lptemplate;
|
|
LPSTR lpbuf;
|
|
int len;
|
|
{
|
|
LONG cb;
|
|
|
|
while (*lptemplate && *lptemplate != '.')
|
|
lptemplate++;
|
|
|
|
cb = len;
|
|
if (*(lptemplate+1) == NULL)
|
|
return FALSE;
|
|
|
|
if (RegQueryValue (HKEY_CLASSES_ROOT, lptemplate, lpbuf, &cb))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Get exe name from aClass and set it as aServer
|
|
void INTERNAL SetExeAtom (lpobj)
|
|
LPOBJECT_LE lpobj;
|
|
{
|
|
char key[MAX_STR];
|
|
|
|
// if old link object assume the class same as the exe file name.
|
|
if (lpobj->bOldLink)
|
|
lpobj->aServer = DuplicateAtom (lpobj->app);
|
|
else {
|
|
if (GlobalGetAtomName (lpobj->app, key, sizeof(key)))
|
|
lpobj->aServer = GetAppAtom ((LPSTR)key);
|
|
}
|
|
}
|
|
|
|
|
|
ATOM FARINTERNAL GetAppAtom (lpclass)
|
|
LPSTR lpclass;
|
|
{
|
|
char buf1[MAX_STR];
|
|
|
|
|
|
if (!QueryApp (lpclass, PROTOCOL_EDIT, buf1)) {
|
|
return NULL;
|
|
}
|
|
|
|
return GlobalAddAtom ((LPSTR)buf1);
|
|
}
|
|
|
|
|
|
BOOL FARINTERNAL QueryVerb (lpobj, verb, lpbuf, cbmax)
|
|
LPOBJECT_LE lpobj;
|
|
WORD verb;
|
|
LPSTR lpbuf;
|
|
LONG cbmax;
|
|
{
|
|
LONG cb = MAX_STR;
|
|
char key[MAX_STR];
|
|
// do not need 256 bytes buffer
|
|
char class[MAX_STR];
|
|
int len;
|
|
|
|
if (!GlobalGetAtomName (lpobj->app, (LPSTR)class, sizeof(class)))
|
|
return FALSE;
|
|
|
|
lstrcpy (key, (LPSTR)class);
|
|
lstrcat (key, "\\protocol\\StdFileEditing\\verb\\");
|
|
len = lstrlen (key);
|
|
key [len++] = (char) ('0' + verb);
|
|
key [len++] = 0;
|
|
|
|
if (RegQueryValue (HKEY_CLASSES_ROOT, key, lpbuf, &cbmax))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL QueryApp (lpclass, lpprotocol, lpbuf)
|
|
LPSTR lpclass;
|
|
LPSTR lpprotocol;
|
|
LPSTR lpbuf;
|
|
{
|
|
LONG cb = MAX_STR;
|
|
char key[MAX_STR];
|
|
|
|
lstrcpy (key, lpclass);
|
|
lstrcat (key, "\\protocol\\");
|
|
lstrcat (key, lpprotocol);
|
|
lstrcat (key, "\\server");
|
|
|
|
if (RegQueryValue (HKEY_CLASSES_ROOT, key, lpbuf, &cb))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
HANDLE MapStrToH (lpstr)
|
|
LPSTR lpstr;
|
|
{
|
|
|
|
HANDLE hdata = NULL;
|
|
LPSTR lpdata = NULL;
|
|
|
|
hdata = GlobalAlloc (GMEM_DDESHARE, lstrlen (lpstr) + 1);
|
|
if (hdata == NULL || (lpdata = (LPSTR)GlobalLock (hdata)) == NULL)
|
|
goto errRtn;
|
|
|
|
lstrcpy (lpdata, lpstr);
|
|
GlobalUnlock (hdata);
|
|
return hdata;
|
|
|
|
errRtn:
|
|
if (lpdata)
|
|
GlobalUnlock (hdata);
|
|
|
|
if (hdata)
|
|
GlobalFree (hdata);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
HANDLE FARINTERNAL CopyData (lpsrc, dwBytes)
|
|
LPSTR lpsrc;
|
|
DWORD dwBytes;
|
|
{
|
|
HANDLE hnew;
|
|
LPSTR lpnew;
|
|
BOOL retval = FALSE;
|
|
|
|
if (hnew = GlobalAlloc (GMEM_MOVEABLE, dwBytes)){
|
|
if (lpnew = GlobalLock (hnew)){
|
|
UtilMemCpy (lpnew, lpsrc, dwBytes);
|
|
GlobalUnlock (hnew);
|
|
return hnew;
|
|
}
|
|
else
|
|
GlobalFree (hnew);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void UtilMemClr (pstr, size)
|
|
PSTR pstr;
|
|
WORD size;
|
|
{
|
|
|
|
while (size--)
|
|
*pstr++ = 0;
|
|
|
|
}
|
|
|
|
|
|
OLESTATUS FAR PASCAL ObjQueryName (lpobj, lpBuf, lpcbBuf)
|
|
LPOLEOBJECT lpobj;
|
|
LPSTR lpBuf;
|
|
WORD FAR * lpcbBuf;
|
|
{
|
|
if (lpobj->ctype != CT_LINK && lpobj->ctype != CT_EMBEDDED
|
|
&& lpobj->ctype != CT_STATIC)
|
|
return OLE_ERROR_OBJECT;
|
|
|
|
PROBE_WRITE(lpBuf);
|
|
if (!*lpcbBuf)
|
|
return OLE_ERROR_SIZE;
|
|
|
|
if (!CheckPointer(lpBuf+*lpcbBuf-1, WRITE_ACCESS))
|
|
return OLE_ERROR_SIZE;
|
|
|
|
ASSERT(lpobj->aObjName, "object name ATOM is NULL\n");
|
|
*lpcbBuf = GlobalGetAtomName (lpobj->aObjName, lpBuf, *lpcbBuf);
|
|
return OLE_OK;
|
|
}
|
|
|
|
|
|
OLESTATUS FAR PASCAL ObjRename (lpobj, lpNewName)
|
|
LPOLEOBJECT lpobj;
|
|
LPSTR lpNewName;
|
|
{
|
|
if (lpobj->ctype != CT_LINK && lpobj->ctype != CT_EMBEDDED
|
|
&& lpobj->ctype != CT_STATIC)
|
|
return OLE_ERROR_OBJECT;
|
|
|
|
PROBE_READ(lpNewName);
|
|
if (!lpNewName[0])
|
|
return OLE_ERROR_NAME;
|
|
|
|
if (lpobj->aObjName)
|
|
GlobalDeleteAtom (lpobj->aObjName);
|
|
lpobj->aObjName = GlobalAddAtom (lpNewName);
|
|
return OLE_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL QueryHandler(cfFormat)
|
|
WORD cfFormat;
|
|
{
|
|
HANDLE hInfo = NULL;
|
|
LPSTR lpInfo = NULL;
|
|
BOOL fRet = FALSE, fOpen = FALSE;
|
|
LONG cb = MAX_STR;
|
|
char str[MAX_STR];
|
|
HKEY hKey;
|
|
|
|
// we don't have the client app window handle, use the screen handle
|
|
fOpen = OpenClipboard (NULL);
|
|
|
|
if (!(hInfo = GetClipboardData (cfFormat)))
|
|
goto errRtn;
|
|
|
|
if (!(lpInfo = GlobalLock(hInfo)))
|
|
goto errRtn;
|
|
|
|
// First string of lpInfo is CLASS. See whether any handler is installed
|
|
// for this class.
|
|
|
|
lstrcpy (str, lpInfo);
|
|
lstrcat (str, "\\protocol\\StdFileEditing\\handler");
|
|
if (RegOpenKey (HKEY_CLASSES_ROOT, str, &hKey))
|
|
goto errRtn;
|
|
RegCloseKey (hKey);
|
|
fRet = TRUE;
|
|
|
|
errRtn:
|
|
if (lpInfo)
|
|
GlobalUnlock (hInfo);
|
|
|
|
if (fOpen)
|
|
CloseClipboard();
|
|
return fRet;
|
|
}
|
|
|
|
OLESTATUS INTERNAL FileExists (lpobj)
|
|
LPOBJECT_LE lpobj;
|
|
{
|
|
char filename[MAX_STR];
|
|
OFSTRUCT ofstruct;
|
|
|
|
if (!GlobalGetAtomName (lpobj->topic, filename, MAX_STR))
|
|
return OLE_ERROR_MEMORY;
|
|
|
|
// For package with link we append "/LINK" to the filename. We don't want
|
|
// to check for it's existence here.
|
|
if (lpobj->app != aPackage) {
|
|
// when OF_EXIST is specified, file is opened and closed immediately
|
|
if (OpenFile (filename, &ofstruct, OF_EXIST) == -1)
|
|
return OLE_ERROR_OPEN;
|
|
}
|
|
|
|
return OLE_OK;
|
|
}
|
|
|
|
|
|
BOOL FARINTERNAL UtilQueryProtocol (lpobj, lpprotocol)
|
|
LPOBJECT_LE lpobj;
|
|
LPSTR lpprotocol;
|
|
{
|
|
char buf[MAX_STR];
|
|
ATOM aExe;
|
|
|
|
if (!GlobalGetAtomName (lpobj->app, (LPSTR) buf, MAX_STR))
|
|
return FALSE;
|
|
|
|
if (!QueryApp (buf, lpprotocol, (LPSTR) buf))
|
|
return FALSE;
|
|
|
|
aExe = GlobalAddAtom (buf);
|
|
if (aExe)
|
|
GlobalDeleteAtom (aExe);
|
|
if (aExe != lpobj->aServer)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
WORD FARINTERNAL FarCheckPointer (lp, iAccessType)
|
|
LPVOID lp;
|
|
int iAccessType;
|
|
{
|
|
return (CheckPointer (lp, iAccessType));
|
|
}
|
|
|
|
|
|
DWORD PASCAL FAR DllPut (lpstream, lpstr, dwSize)
|
|
LPOLESTREAM lpstream;
|
|
LPSTR lpstr;
|
|
DWORD dwSize;
|
|
{
|
|
dwObjSize += dwSize;
|
|
return dwSize;
|
|
}
|
|
|
|
|
|
|
|
OLESTATUS FARINTERNAL ObjQueryType (lpobj, lptype)
|
|
LPOLEOBJECT lpobj;
|
|
LPLONG lptype;
|
|
{
|
|
Puts("ObjQueryType");
|
|
|
|
if (lpobj->ctype != CT_STATIC)
|
|
return OLE_ERROR_OBJECT;
|
|
|
|
*lptype = lpobj->ctype;
|
|
return OLE_OK;
|
|
}
|
|
|
|
OLESTATUS FARINTERNAL ObjQuerySize (lpobj, lpdwSize)
|
|
LPOLEOBJECT lpobj;
|
|
DWORD FAR * lpdwSize;
|
|
{
|
|
Puts("ObjQuerySize");
|
|
|
|
*lpdwSize = dwObjSize = NULL;
|
|
|
|
if ((*lpobj->lpvtbl->SaveToStream) (lpobj, &dllStream) == OLE_OK) {
|
|
*lpdwSize = dwObjSize;
|
|
return OLE_OK;
|
|
}
|
|
|
|
return OLE_ERROR_BLANK;
|
|
}
|
|
|
|
BOOL FARINTERNAL IsObjectBlank (lpobj)
|
|
LPOBJECT_LE lpobj;
|
|
{
|
|
LPOLEOBJECT lpPictObj;
|
|
BOOL retval;
|
|
|
|
// Cleaner way is to provide a method like QueryBlank()
|
|
|
|
if (!lpobj->hnative)
|
|
return TRUE;
|
|
|
|
if (!(lpPictObj = lpobj->lpobjPict))
|
|
return FALSE;
|
|
|
|
if (lpPictObj->lpvtbl == (LPOLEOBJECTVTBL)&vtblMF)
|
|
retval = (BOOL) (((LPOBJECT_MF)lpPictObj)->hmfp);
|
|
else if (lpPictObj->lpvtbl == (LPOLEOBJECTVTBL)&vtblBM)
|
|
retval = (BOOL) (((LPOBJECT_BM)lpPictObj)->hBitmap);
|
|
if (lpPictObj->lpvtbl == (LPOLEOBJECTVTBL)&vtblDIB)
|
|
retval = (BOOL) (((LPOBJECT_DIB)lpPictObj)->hDIB);
|
|
if (lpPictObj->lpvtbl == (LPOLEOBJECTVTBL)&vtblGEN)
|
|
retval = (BOOL) (((LPOBJECT_GEN)lpPictObj)->hData);
|
|
|
|
return retval;
|
|
}
|