ddemisc.c File Reference

#include <user32.h>
#include "dde_private.h"

Include dependency graph for ddemisc.c:

Go to the source code of this file.

Classes
struct	tagWDML_BroadcastPmt

Macros
#define	ATOM2HSZ(atom)   ((HSZ) (ULONG_PTR)(atom))
#define	HSZ2ATOM(hsz)   ((ATOM) (ULONG_PTR)(hsz))

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ddeml)
LPARAM WINAPI	PackDDElParam (UINT msg, UINT_PTR uiLo, UINT_PTR uiHi)
BOOL WINAPI	UnpackDDElParam (UINT msg, LPARAM lParam, PUINT_PTR uiLo, PUINT_PTR uiHi)
BOOL WINAPI	FreeDDElParam (UINT msg, LPARAM lParam)
LPARAM WINAPI	ReuseDDElParam (LPARAM lParam, UINT msgIn, UINT msgOut, UINT_PTR uiLo, UINT_PTR uiHi)
BOOL WINAPI	ImpersonateDdeClientWindow (HWND hWndClient, HWND hWndServer)
BOOL WINAPI	DdeSetQualityOfService (HWND hwndClient, const SECURITY_QUALITY_OF_SERVICE *pqosNew, PSECURITY_QUALITY_OF_SERVICE pqosPrev)
UINT WINAPI	DdeGetLastError (DWORD idInst)
static void	WDML_SetAllLastError (DWORD lastError)
static HSZNode *	WDML_FindNode (WDML_INSTANCE *pInstance, HSZ hsz)
ATOM	WDML_MakeAtomFromHsz (HSZ hsz)
HSZ	WDML_MakeHszFromAtom (const WDML_INSTANCE *pInstance, ATOM atom)
BOOL	WDML_IncHSZ (WDML_INSTANCE *pInstance, HSZ hsz)
BOOL	WDML_DecHSZ (WDML_INSTANCE *pInstance, HSZ hsz)
static void	WDML_FreeAllHSZ (WDML_INSTANCE *pInstance)
static void	WDML_InsertHSZNode (WDML_INSTANCE *pInstance, HSZ hsz)
static int	WDML_QueryString (WDML_INSTANCE *pInstance, HSZ hsz, LPVOID ptr, DWORD cchMax, int codepage)
DWORD WINAPI	DdeQueryStringA (DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT iCodePage)
DWORD WINAPI	DdeQueryStringW (DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT iCodePage)
static HSZ	WDML_CreateString (WDML_INSTANCE *pInstance, LPCVOID ptr, int codepage)
HSZ WINAPI	DdeCreateStringHandleA (DWORD idInst, LPCSTR psz, INT codepage)
HSZ WINAPI	DdeCreateStringHandleW (DWORD idInst, LPCWSTR psz, INT codepage)
BOOL WINAPI	DdeFreeStringHandle (DWORD idInst, HSZ hsz)
BOOL WINAPI	DdeKeepStringHandle (DWORD idInst, HSZ hsz)
INT WINAPI	DdeCmpStringHandles (HSZ hsz1, HSZ hsz2)
static void	WDML_IncrementInstanceId (WDML_INSTANCE *pInstance)
static LRESULT CALLBACK	WDML_EventProc (HWND hwndEvent, UINT uMsg, WPARAM wParam, LPARAM lParam)
static UINT	WDML_Initialize (LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes, BOOL bUnicode)
UINT WINAPI	DdeInitializeA (LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes)
UINT WINAPI	DdeInitializeW (LPDWORD pidInst, PFNCALLBACK pfnCallback, DWORD afCmd, DWORD ulRes)
BOOL WINAPI	DdeUninitialize (DWORD idInst)
void	WDML_NotifyThreadDetach (void)
HDDEDATA	WDML_InvokeCallback (WDML_INSTANCE *pInstance, UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA hdata, ULONG_PTR dwData1, ULONG_PTR dwData2)
WDML_INSTANCE *	WDML_GetInstance (DWORD instId)
WDML_INSTANCE *	WDML_GetInstanceFromWnd (HWND hWnd)
HDDEDATA WINAPI	DdeCreateDataHandle (DWORD idInst, LPBYTE pSrc, DWORD cb, DWORD cbOff, HSZ hszItem, UINT wFmt, UINT afCmd)
HDDEDATA WINAPI	DdeAddData (HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff)
DWORD WINAPI	DdeGetData (HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff)
LPBYTE WINAPI	DdeAccessData (HDDEDATA hData, LPDWORD pcbDataSize)
BOOL WINAPI	DdeUnaccessData (HDDEDATA hData)
BOOL WINAPI	DdeFreeDataHandle (HDDEDATA hData)
BOOL	WDML_IsAppOwned (HDDEDATA hData)
HDDEDATA	WDML_Global2DataHandle (WDML_CONV *pConv, HGLOBAL hMem, WINE_DDEHEAD *p)
HGLOBAL	WDML_DataHandle2Global (HDDEDATA hDdeData, BOOL fResponse, BOOL fRelease, BOOL fDeferUpd, BOOL fAckReq)
WDML_SERVER *	WDML_AddServer (WDML_INSTANCE *pInstance, HSZ hszService, HSZ hszTopic)
void	WDML_RemoveServer (WDML_INSTANCE *pInstance, HSZ hszService, HSZ hszTopic)
WDML_SERVER *	WDML_FindServer (WDML_INSTANCE *pInstance, HSZ hszService, HSZ hszTopic)
void	WDML_AddLink (WDML_INSTANCE *pInstance, HCONV hConv, WDML_SIDE side, UINT wType, HSZ hszItem, UINT wFmt)
void	WDML_RemoveLink (WDML_INSTANCE *pInstance, HCONV hConv, WDML_SIDE side, HSZ hszItem, UINT uFmt)
static void	WDML_RemoveAllLinks (WDML_INSTANCE *pInstance, WDML_CONV *pConv, WDML_SIDE side)
WDML_LINK *	WDML_FindLink (WDML_INSTANCE *pInstance, HCONV hConv, WDML_SIDE side, HSZ hszItem, BOOL use_fmt, UINT uFmt)
WDML_XACT *	WDML_AllocTransaction (WDML_INSTANCE *pInstance, UINT ddeMsg, UINT wFmt, HSZ hszItem)
void	WDML_QueueTransaction (WDML_CONV *pConv, WDML_XACT *pXAct)
BOOL	WDML_UnQueueTransaction (WDML_CONV *pConv, WDML_XACT *pXAct)
void	WDML_FreeTransaction (WDML_INSTANCE *pInstance, WDML_XACT *pXAct, BOOL doFreePmt)
static WDML_XACT *	WDML_FindTransaction (WDML_CONV *pConv, DWORD tid)
WDML_CONV *	WDML_AddConv (WDML_INSTANCE *pInstance, WDML_SIDE side, HSZ hszService, HSZ hszTopic, HWND hwndClient, HWND hwndServer)
WDML_CONV *	WDML_FindConv (WDML_INSTANCE *pInstance, WDML_SIDE side, HSZ hszService, HSZ hszTopic)
void	WDML_RemoveConv (WDML_CONV *pRef, WDML_SIDE side)
static BOOL	WDML_EnableCallback (WDML_CONV *pConv, UINT wCmd)
BOOL WINAPI	DdeEnableCallback (DWORD idInst, HCONV hConv, UINT wCmd)
WDML_CONV *	WDML_GetConv (HCONV hConv, BOOL checkConnected)
WDML_CONV *	WDML_GetConvFromWnd (HWND hWnd)
BOOL	WDML_PostAck (WDML_CONV *pConv, WDML_SIDE side, WORD appRetCode, BOOL fBusy, BOOL fAck, UINT_PTR pmt, LPARAM lParam, UINT oldMsg)
BOOL WINAPI	DdeSetUserHandle (HCONV hConv, DWORD id, DWORD hUser)
static BOOL	WDML_GetLocalConvInfo (WDML_CONV *pConv, CONVINFO *ci, DWORD id)
UINT WINAPI	DdeQueryConvInfo (HCONV hConv, DWORD id, PCONVINFO lpConvInfo)
static BOOL CALLBACK	WDML_BroadcastEnumProc (HWND hWnd, LPARAM lParam)
void	WDML_BroadcastDDEWindows (LPCWSTR clsName, UINT uMsg, WPARAM wParam, LPARAM lParam)

Variables
static WDML_INSTANCE *	WDML_InstanceList = NULL
static LONG	WDML_MaxInstanceID = 0
const WCHAR	WDML_szEventClass [] = L"DDEMLEvent"
static CRITICAL_SECTION	WDML_CritSect = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug

Macro Definition Documentation

ATOM2HSZ

#define ATOM2HSZ

(

atom

)

((HSZ) (ULONG_PTR)(atom))

Definition at line 33 of file ddemisc.c.

HSZ2ATOM

#define HSZ2ATOM

(

hsz

)

((ATOM) (ULONG_PTR)(hsz))

Definition at line 34 of file ddemisc.c.

Function Documentation

DdeAccessData()

LPBYTE WINAPI DdeAccessData	(	HDDEDATA	hData,
		LPDWORD	pcbDataSize
	)

Definition at line 1422 of file ddemisc.c.

{
    HGLOBAL         hMem = hData;
    DDE_DATAHANDLE_HEAD*    pDdh;
 
    TRACE("(%p,%p)\n", hData, pcbDataSize);
 
    pDdh = GlobalLock(hMem);
    if (pDdh == NULL)
    {
    ERR("Failed on GlobalLock(%p)\n", hMem);
    return 0;
    }
 
    if (pcbDataSize != NULL)
    {
    *pcbDataSize = GlobalSize(hMem) - sizeof(DDE_DATAHANDLE_HEAD);
    }
    TRACE("=> %p (%lu) fmt %04x\n", pDdh + 1, GlobalSize(hMem) - sizeof(DDE_DATAHANDLE_HEAD), pDdh->cfFormat);
    return (LPBYTE)(pDdh + 1);
}

Referenced by Dde_OnExecute(), DdeAddData(), DdeGetData(), map_A_to_W(), map_W_to_A(), server_ddeml_callback(), test_DdeCreateDataHandle(), test_ddeml_client(), WDML_ClientQueueExecute(), and WDML_ServerNameProc().

DdeAddData()

HDDEDATA WINAPI DdeAddData	(	HDDEDATA	hData,
		LPBYTE	pSrc,
		DWORD	cb,
		DWORD	cbOff
	)

Definition at line 1340 of file ddemisc.c.

{
    DWORD   old_sz, new_sz;
    LPBYTE  pDst;
 
    TRACE("(%p,%p,cb %d, cbOff %d)\n", hData, pSrc, cb, cbOff);
 
    pDst = DdeAccessData(hData, &old_sz);
    if (!pDst) return 0;
 
    new_sz = cb + cbOff;
    if (new_sz > old_sz)
    {
    DdeUnaccessData(hData);
    hData = GlobalReAlloc(hData, new_sz + sizeof(DDE_DATAHANDLE_HEAD),
                  GMEM_MOVEABLE | GMEM_DDESHARE);
    pDst = DdeAccessData(hData, &old_sz);
    }
 
    if (!pDst) return 0;
 
    memcpy(pDst + cbOff, pSrc, cb);
    DdeUnaccessData(hData);
    return hData;
}

DdeCmpStringHandles()

INT WINAPI DdeCmpStringHandles	(	HSZ	hsz1,
		HSZ	hsz2
	)

Definition at line 685 of file ddemisc.c.

{
    WCHAR   psz1[MAX_BUFFER_LEN];
    WCHAR   psz2[MAX_BUFFER_LEN];
    int     ret = 0;
    int     ret1, ret2;
 
    ret1 = GetAtomNameW(HSZ2ATOM(hsz1), psz1, MAX_BUFFER_LEN);
    ret2 = GetAtomNameW(HSZ2ATOM(hsz2), psz2, MAX_BUFFER_LEN);
 
    TRACE("(%p<%s> %p<%s>);\n", hsz1, debugstr_w(psz1), hsz2, debugstr_w(psz2));
 
    /* Make sure we found both strings. */
    if (ret1 == 0 && ret2 == 0)
    {
    /* If both are not found, return both  "zero strings". */
    ret = 0;
    }
    else if (ret1 == 0)
    {
    /* If hsz1 is a not found, return hsz1 is "zero string". */
    ret = -1;
    }
    else if (ret2 == 0)
    {
    /* If hsz2 is a not found, return hsz2 is "zero string". */
    ret = 1;
    }
    else
    {
    /* Compare the two strings we got (case insensitive). */
    ret = lstrcmpiW(psz1, psz2);
    /* Since strcmp returns any number smaller than
     * 0 when the first string is found to be less than
     * the second one we must make sure we are returning
     * the proper values.
     */
    if (ret < 0)
    {
        ret = -1;
    }
    else if (ret > 0)
    {
        ret = 1;
    }
    }
 
    return ret;
}

Referenced by dde_proc(), ddeCb(), DdePostAdvise(), WDML_FindConv(), WDML_FindLink(), WDML_HandleAdviseReply(), WDML_HandlePokeReply(), WDML_HandleRequestReply(), WDML_HandleUnadviseReply(), WDML_RemoveLink(), WDML_RemoveServer(), and WDML_ServerNameProc().

DdeCreateDataHandle()

HDDEDATA WINAPI DdeCreateDataHandle	(	DWORD	idInst,
		LPBYTE	pSrc,
		DWORD	cb,
		DWORD	cbOff,
		HSZ	hszItem,
		UINT	wFmt,
		UINT	afCmd
	)

Definition at line 1275 of file ddemisc.c.

{
 
    /* Other than check for validity we will ignore for now idInst, hszItem.
     * The purpose of these arguments still need to be investigated.
     */
 
    WDML_INSTANCE*      pInstance;
    HGLOBAL             hMem;
    LPBYTE              pByte;
    DDE_DATAHANDLE_HEAD*    pDdh;
    WCHAR psz[MAX_BUFFER_LEN];
 
    pInstance = WDML_GetInstance(idInst);
    if (pInstance == NULL)
    {
        WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
        return NULL;
    }
 
    if (!GetAtomNameW(HSZ2ATOM(hszItem), psz, MAX_BUFFER_LEN))
    {
        psz[0] = HSZ2ATOM(hszItem);
        psz[1] = 0;
    }
 
    TRACE("(%d,%p,cb %d, cbOff %d,%p <%s>,fmt %04x,%x)\n",
      idInst, pSrc, cb, cbOff, hszItem, debugstr_w(psz), wFmt, afCmd);
 
    if (afCmd != 0 && afCmd != HDATA_APPOWNED)
        return 0;
 
    /* we use the first 4 bytes to store the size */
    if (!(hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cb + cbOff + sizeof(DDE_DATAHANDLE_HEAD))))
    {
    ERR("GlobalAlloc failed\n");
    return 0;
    }
 
    pDdh = GlobalLock(hMem);
    if (!pDdh)
    {
        GlobalFree(hMem);
        return 0;
    }
 
    pDdh->cfFormat = wFmt;
    pDdh->bAppOwned = (afCmd == HDATA_APPOWNED);
 
    pByte = (LPBYTE)(pDdh + 1);
    if (pSrc)
    {
    memcpy(pByte, pSrc + cbOff, cb);
    }
    GlobalUnlock(hMem);
 
    TRACE("=> %p\n", hMem);
    return hMem;
}

Referenced by dde_execute(), map_A_to_W(), map_W_to_A(), server_ddeml_callback(), test_DdeCreateDataHandle(), test_ddeml_client(), WDML_Global2DataHandle(), WDML_ServerHandleExecute(), and WDML_ServerHandlePoke().

DdeCreateStringHandleA()

HSZ WINAPI DdeCreateStringHandleA	(	DWORD	idInst,
		LPCSTR	psz,
		INT	codepage
	)

Definition at line 577 of file ddemisc.c.

{
    HSZ         hsz = 0;
    WDML_INSTANCE*  pInstance;
 
    TRACE("(%d,%s,%d)\n", idInst, debugstr_a(psz), codepage);
 
    pInstance = WDML_GetInstance(idInst);
    if (pInstance == NULL)
    WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
    else
    {
    if (codepage == 0) codepage = CP_WINANSI;
    hsz = WDML_CreateString(pInstance, psz, codepage);
    }
 
    return hsz;
}

Referenced by dde_request(), doChild(), START_TEST(), test_dde_default_app(), test_DdeCreateDataHandle(), test_ddeml_client(), test_ddeml_server(), test_end_to_end_client(), test_end_to_end_server(), and test_initialisation().

DdeCreateStringHandleW()

HSZ WINAPI DdeCreateStringHandleW	(	DWORD	idInst,
		LPCWSTR	psz,
		INT	codepage
	)

Definition at line 608 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
    HSZ         hsz = 0;
 
    pInstance = WDML_GetInstance(idInst);
    if (pInstance == NULL)
    WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
    else
    {
    if (codepage == 0) codepage = CP_WINUNICODE;
    hsz = WDML_CreateString(pInstance, psz, codepage);
    }
 
    return hsz;
}

Referenced by dde_connect(), init_dde(), ShellDDEInit(), test_dde_aw_transaction(), test_DdeCreateDataHandle(), test_DdeCreateStringHandleW(), test_end_to_end_client(), WDML_AddServer(), and WDML_MakeHszFromAtom().

DdeEnableCallback()

BOOL WINAPI DdeEnableCallback	(	DWORD	idInst,
		HCONV	hConv,
		UINT	wCmd
	)

Definition at line 2178 of file ddemisc.c.

{
    BOOL ret = FALSE;
    WDML_CONV *pConv;
 
    TRACE("(%d, %p, %04x)\n", idInst, hConv, wCmd);
 
    if (hConv)
    {
        pConv = WDML_GetConv(hConv, TRUE);
 
        if (pConv && pConv->instance->instanceID == idInst)
            ret = WDML_EnableCallback(pConv, wCmd);
    }
    else
    {
        WDML_INSTANCE *pInstance = WDML_GetInstance(idInst);
 
        if (!pInstance)
            return FALSE;
 
        TRACE("adding flags %04x to instance %p\n", wCmd, pInstance);
        pInstance->wStatus |= wCmd;
 
        if (wCmd == EC_DISABLE)
        {
            pInstance->wStatus |= ST_BLOCKED;
            TRACE("EC_DISABLE: inst %p status flags %04x\n", pInstance, pInstance->wStatus);
        }
        else if (wCmd == EC_ENABLEALL)
        {
            pInstance->wStatus &= ~ST_BLOCKED;
            TRACE("EC_ENABLEALL: inst %p status flags %04x\n", pInstance, pInstance->wStatus);
        }
 
        ret = TRUE;
 
        for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv != NULL; pConv = pConv->next)
        {
            ret = WDML_EnableCallback(pConv, wCmd);
            if (ret && wCmd == EC_QUERYWAITING) break;
        }
    }
 
    return ret;
}

DdeFreeDataHandle()

BOOL WINAPI DdeFreeDataHandle

(

HDDEDATA

hData

)

Definition at line 1461 of file ddemisc.c.

{
    TRACE("(%p)\n", hData);
 
    /* 1 is the handle value returned by an asynchronous operation. */
    if (hData == (HDDEDATA)1)
        return TRUE;
 
    return GlobalFree(hData) == 0;
}

Referenced by dde_connect(), ddeCb(), DdePostAdvise(), test_DdeCreateDataHandle(), test_ddeml_client(), WDML_HandleIncomingData(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), and WDML_ServerNameProc().

DdeFreeStringHandle()

BOOL WINAPI DdeFreeStringHandle	(	DWORD	idInst,
		HSZ	hsz
	)

Definition at line 631 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
    BOOL        ret = FALSE;
 
    TRACE("(%d,%p):\n", idInst, hsz);
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if (pInstance)
    ret = WDML_DecHSZ(pInstance, hsz);
 
    return ret;
}

Referenced by doChild(), release_dde(), ShellDDEInit(), START_TEST(), test_dde_aw_transaction(), test_dde_default_app(), test_DdeCreateStringHandleW(), test_ddeml_client(), test_end_to_end_client(), test_initialisation(), and WDML_FreeAllHSZ().

DdeGetData()

DWORD WINAPI DdeGetData	(	HDDEDATA	hData,
		LPBYTE	pDst,
		DWORD	cbMax,
		DWORD	cbOff
	)

Definition at line 1379 of file ddemisc.c.

{
    DWORD   dwSize, dwRet;
    LPBYTE  pByte;
 
    TRACE("(%p,%p,%d,%d)\n", hData, pDst, cbMax, cbOff);
 
    pByte = DdeAccessData(hData, &dwSize);
 
    if (pByte)
    {
        if (!pDst)
        {
            dwRet = dwSize;
        }
        else if (cbOff + cbMax < dwSize)
    {
        dwRet = cbMax;
    }
    else if (cbOff < dwSize)
    {
        dwRet = dwSize - cbOff;
    }
    else
    {
        dwRet = 0;
    }
    if (pDst && dwRet != 0)
    {
        memcpy(pDst, pByte + cbOff, dwRet);
    }
    DdeUnaccessData(hData);
    }
    else
    {
    dwRet = 0;
    }
    return dwRet;
}

Referenced by dde_proc(), dde_request(), ddeCb(), server_ddeml_callback(), and server_end_to_end_callback().

DdeGetLastError()

UINT WINAPI DdeGetLastError

(

DWORD

idInst

)

Definition at line 253 of file ddemisc.c.

{
    DWORD       error_code;
    WDML_INSTANCE*  pInstance;
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if  (pInstance == NULL)
    {
    error_code = DMLERR_INVALIDPARAMETER;
    }
    else
    {
    error_code = pInstance->lastError;
    pInstance->lastError = 0;
    }
 
    return error_code;
}

Referenced by dde_connect(), dde_execute(), dde_request(), init_dde(), START_TEST(), test_dde_aw_transaction(), test_DdeCreateDataHandle(), test_DdeCreateStringHandle(), test_DdeCreateStringHandleW(), test_ddeml_client(), test_end_to_end_client(), test_initialisation(), and test_request_groups().

DdeInitializeA()

UINT WINAPI DdeInitializeA	(	LPDWORD	pidInst,
		PFNCALLBACK	pfnCallback,
		DWORD	afCmd,
		DWORD	ulRes
	)

Definition at line 1075 of file ddemisc.c.

{
    return WDML_Initialize(pidInst, pfnCallback, afCmd, ulRes, FALSE);
}

Referenced by dde_connect(), doChild(), START_TEST(), test_dde_aw_transaction(), test_dde_default_app(), test_DdeCreateDataHandle(), test_ddeml_client(), test_ddeml_server(), test_end_to_end_client(), test_end_to_end_server(), and test_initialisation().

DdeInitializeW()

UINT WINAPI DdeInitializeW	(	LPDWORD	pidInst,
		PFNCALLBACK	pfnCallback,
		DWORD	afCmd,
		DWORD	ulRes
	)

Definition at line 1095 of file ddemisc.c.

{
    return WDML_Initialize(pidInst, pfnCallback, afCmd, ulRes, TRUE);
}

Referenced by dde_connect(), init_dde(), ShellDDEInit(), START_TEST(), test_dde_aw_transaction(), test_DdeCreateStringHandle(), test_end_to_end_client(), and test_end_to_end_server().

DdeKeepStringHandle()

BOOL WINAPI DdeKeepStringHandle	(	DWORD	idInst,
		HSZ	hsz
	)

Definition at line 654 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
    BOOL        ret = FALSE;
 
    TRACE("(%d,%p):\n", idInst, hsz);
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if (pInstance)
    ret = WDML_IncHSZ(pInstance, hsz);
 
    return ret;
}

DdeQueryConvInfo()

UINT WINAPI DdeQueryConvInfo	(	HCONV	hConv,
		DWORD	id,
		PCONVINFO	lpConvInfo
	)

Definition at line 2426 of file ddemisc.c.

{
    UINT    ret = lpConvInfo->cb;
    CONVINFO    ci;
    WDML_CONV*  pConv;
 
    TRACE("(%p,%x,%p)\n", hConv, id, lpConvInfo);
 
    if (!hConv)
    {
        FIXME("hConv is NULL\n");
        return 0;
    }
 
    pConv = WDML_GetConv(hConv, FALSE);
    if (pConv != NULL)
    {
        if (!WDML_GetLocalConvInfo(pConv, &ci, id))
            ret = 0;
    }
    else
    {
        if ((ULONG_PTR)hConv & 1)
        {
            pConv = WDML_GetConv((HCONV)((ULONG_PTR)hConv & ~1), FALSE);
            if (pConv != NULL)
                FIXME("Request on remote conversation information is not implemented yet\n");
        }
        ret = 0;
    }
 
    if (ret != 0)
    {
    ci.cb = lpConvInfo->cb;
    memcpy(lpConvInfo, &ci, min((size_t)lpConvInfo->cb, sizeof(ci)));
    }
    return ret;
}

Referenced by test_dde_aw_transaction().

DdeQueryStringA()

DWORD WINAPI DdeQueryStringA	(	DWORD	idInst,
		HSZ	hsz,
		LPSTR	psz,
		DWORD	cchMax,
		INT	iCodePage
	)

Definition at line 501 of file ddemisc.c.

{
    DWORD       ret = 0;
    WDML_INSTANCE*  pInstance;
 
    TRACE("(%d, %p, %p, %d, %d)\n", idInst, hsz, psz, cchMax, iCodePage);
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if (pInstance != NULL)
    {
    if (iCodePage == 0) iCodePage = CP_WINANSI;
    ret = WDML_QueryString(pInstance, hsz, psz, cchMax, iCodePage);
    }
 
    TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
    return ret;
}

Referenced by ddeCb(), server_ddeml_callback(), server_end_to_end_callback(), and test_DdeCreateStringHandleW().

DdeQueryStringW()

DWORD WINAPI DdeQueryStringW	(	DWORD	idInst,
		HSZ	hsz,
		LPWSTR	psz,
		DWORD	cchMax,
		INT	iCodePage
	)

Definition at line 525 of file ddemisc.c.

{
    DWORD       ret = 0;
    WDML_INSTANCE*  pInstance;
 
    TRACE("(%d, %p, %p, %d, %d)\n", idInst, hsz, psz, cchMax, iCodePage);
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if (pInstance != NULL)
    {
    if (iCodePage == 0) iCodePage = CP_WINUNICODE;
    ret = WDML_QueryString(pInstance, hsz, psz, cchMax, iCodePage);
    }
 
    TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
    return ret;
}

Referenced by Dde_OnConnect(), Dde_OnConnectConfirm(), Dde_OnExecute(), Dde_OnRequest(), Dde_OnWildConnect(), test_DdeCreateStringHandleW(), and WDML_AddServer().

DdeSetQualityOfService()

BOOL WINAPI DdeSetQualityOfService	(	HWND	hwndClient,
		const SECURITY_QUALITY_OF_SERVICE *	pqosNew,
		PSECURITY_QUALITY_OF_SERVICE	pqosPrev
	)

Definition at line 231 of file ddemisc.c.

{
     FIXME("(%p %p %p): stub\n", hwndClient, pqosNew, pqosPrev);
     return TRUE;
}

DdeSetUserHandle()

BOOL WINAPI DdeSetUserHandle	(	HCONV	hConv,
		DWORD	id,
		DWORD	hUser
	)

Definition at line 2314 of file ddemisc.c.

{
    WDML_CONV*  pConv;
 
    pConv = WDML_GetConv(hConv, FALSE);
    if (pConv == NULL)
    return FALSE;
 
    if (id == QID_SYNC)
    {
    pConv->hUser = hUser;
    }
    else
    {
    WDML_XACT*  pXAct;
 
    pXAct = WDML_FindTransaction(pConv, id);
    if (pXAct)
    {
        pXAct->hUser = hUser;
    }
    else
    {
        pConv->instance->lastError = DMLERR_UNFOUND_QUEUE_ID;
        return  FALSE;
    }
    }
    return TRUE;
}

DdeUnaccessData()

BOOL WINAPI DdeUnaccessData

(

HDDEDATA

hData

)

Definition at line 1447 of file ddemisc.c.

{
    HGLOBAL hMem = hData;
 
    TRACE("(%p)\n", hData);
 
    GlobalUnlock(hMem);
 
    return TRUE;
}

Referenced by Dde_OnExecute(), DdeAddData(), DdeGetData(), server_ddeml_callback(), test_DdeCreateDataHandle(), test_ddeml_client(), WDML_ClientQueueExecute(), and WDML_ServerNameProc().

DdeUninitialize()

BOOL WINAPI DdeUninitialize

(

DWORD

idInst

)

Definition at line 1112 of file ddemisc.c.

{
    /*  Stage one - check if we have a handle for this instance
     */
    WDML_INSTANCE*      pInstance;
    WDML_CONV*          pConv;
    WDML_CONV*          pConvNext;
 
    TRACE("(%d)\n", idInst);
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if (pInstance == NULL)
    {
    /*
     *  Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
     */
    return FALSE;
    }
 
    /* first terminate all conversations client side
     * this shall close existing links...
     */
    for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv != NULL; pConv = pConvNext)
    {
    pConvNext = pConv->next;
    DdeDisconnect((HCONV)pConv);
    }
    if (pInstance->convs[WDML_CLIENT_SIDE])
    FIXME("still pending conversations\n");
 
    /* then unregister all known service names */
    DdeNameService(idInst, 0, 0, DNS_UNREGISTER);
 
    /* Free the nodes that were not freed by this instance
     * and remove the nodes from the list of HSZ nodes.
     */
    WDML_FreeAllHSZ(pInstance);
 
    DestroyWindow(pInstance->hwndEvent);
 
    /* OK now delete the instance handle itself */
 
    if (WDML_InstanceList == pInstance)
    {
    /* special case - the first/only entry */
    WDML_InstanceList = pInstance->next;
    }
    else
    {
    /* general case, remove entry */
    WDML_INSTANCE*  inst;
 
    for (inst = WDML_InstanceList; inst->next != pInstance; inst = inst->next);
    inst->next = pInstance->next;
    }
    /* release the heap entry
     */
    HeapFree(GetProcessHeap(), 0, pInstance);
 
    return TRUE;
}

Referenced by dde_connect(), doChild(), release_dde(), ShellDDEInit(), START_TEST(), test_dde_default_app(), test_DdeCreateDataHandle(), test_DdeCreateStringHandle(), test_ddeml_client(), test_ddeml_server(), test_end_to_end_client(), test_end_to_end_server(), test_initialisation(), and WDML_NotifyThreadDetach().

FreeDDElParam()

BOOL WINAPI FreeDDElParam	(	UINT	msg,
		LPARAM	lParam
	)

Definition at line 147 of file ddemisc.c.

{
    switch (msg)
    {
    case WM_DDE_ACK:
    case WM_DDE_ADVISE:
    case WM_DDE_DATA:
    case WM_DDE_POKE:
        /* first check if it's a global handle */
        if (!GlobalHandle( (LPVOID)lParam )) return TRUE;
        return !GlobalFree( (HGLOBAL)lParam );
 
    default:
        return TRUE;
     }
}

Referenced by post_dde_message(), ReuseDDElParam(), test_FreeDDElParam(), test_PackDDElParam(), WDML_HandleAdviseReply(), WDML_HandleExecuteReply(), WDML_HandleIncomingData(), WDML_HandlePokeReply(), WDML_HandleRequestReply(), WDML_HandleUnadviseReply(), WDML_PostAck(), and WDML_ServerHandleUnadvise().

ImpersonateDdeClientWindow()

BOOL WINAPI ImpersonateDdeClientWindow	(	HWND	hWndClient,
		HWND	hWndServer
	)

Definition at line 221 of file ddemisc.c.

{
     FIXME("(%p %p): stub\n", hWndClient, hWndServer);
     return FALSE;
}

Referenced by DdeImpersonateClient().

PackDDElParam()

LPARAM WINAPI PackDDElParam	(	UINT	msg,
		UINT_PTR	uiLo,
		UINT_PTR	uiHi
	)

Definition at line 63 of file ddemisc.c.

{
    HGLOBAL hMem;
    UINT_PTR *params;
 
    switch (msg)
    {
    case WM_DDE_ACK:
    case WM_DDE_ADVISE:
    case WM_DDE_DATA:
    case WM_DDE_POKE:
        if (!(hMem = GlobalAlloc(GMEM_DDESHARE, sizeof(UINT_PTR) * 2)))
        {
            ERR("GlobalAlloc failed\n");
            return 0;
        }
        if (!(params = GlobalLock(hMem)))
        {
            ERR("GlobalLock failed (%p)\n", hMem);
            return 0;
        }
        params[0] = uiLo;
        params[1] = uiHi;
        GlobalUnlock(hMem);
        return (LPARAM)hMem;
 
    case WM_DDE_EXECUTE:
        return uiHi;
 
    default:
        return MAKELONG(uiLo, uiHi);
    }
}

Referenced by dde_server_wndproc(), dde_server_wndprocA(), dde_server_wndprocW(), DdePostAdvise(), ReuseDDElParam(), test_msg_client(), test_PackDDElParam(), unpack_dde_message(), WDML_ClientQueueAdvise(), WDML_ClientQueuePoke(), WDML_ClientQueueRequest(), WDML_ClientQueueUnadvise(), and WDML_PostAck().

ReuseDDElParam()

LPARAM WINAPI ReuseDDElParam	(	LPARAM	lParam,
		UINT	msgIn,
		UINT	msgOut,
		UINT_PTR	uiLo,
		UINT_PTR	uiHi
	)

Definition at line 171 of file ddemisc.c.

{
    UINT_PTR *params;
 
    switch (msgIn)
    {
    case WM_DDE_ACK:
    case WM_DDE_ADVISE:
    case WM_DDE_DATA:
    case WM_DDE_POKE:
        switch(msgOut)
        {
        case WM_DDE_ACK:
        case WM_DDE_ADVISE:
        case WM_DDE_DATA:
        case WM_DDE_POKE:
            if (!lParam) return 0;
            if (!(params = GlobalLock( (HGLOBAL)lParam )))
            {
                ERR("GlobalLock failed\n");
                return 0;
            }
            params[0] = uiLo;
            params[1] = uiHi;
            TRACE("Reusing pack %08lx %08lx\n", uiLo, uiHi);
            GlobalUnlock( (HGLOBAL)lParam );
            return lParam;
 
        case WM_DDE_EXECUTE:
            FreeDDElParam( msgIn, lParam );
            return uiHi;
 
        default:
            FreeDDElParam( msgIn, lParam );
            return MAKELPARAM(uiLo, uiHi);
        }
 
    default:
        return PackDDElParam( msgOut, uiLo, uiHi );
    }
}

Referenced by dde_server_wndproc(), dde_server_wndprocA(), dde_server_wndprocW(), WDML_PostAck(), and WDML_ServerHandleRequest().

UnpackDDElParam()

BOOL WINAPI UnpackDDElParam	(	UINT	msg,
		LPARAM	lParam,
		PUINT_PTR	uiLo,
		PUINT_PTR	uiHi
	)

Definition at line 105 of file ddemisc.c.

{
    UINT_PTR *params;
 
    switch (msg)
    {
    case WM_DDE_ACK:
    case WM_DDE_ADVISE:
    case WM_DDE_DATA:
    case WM_DDE_POKE:
        if (!lParam || !(params = GlobalLock((HGLOBAL)lParam)))
        {
            if (uiLo) *uiLo = 0;
            if (uiHi) *uiHi = 0;
            return FALSE;
        }
        if (uiLo) *uiLo = params[0];
        if (uiHi) *uiHi = params[1];
        GlobalUnlock( (HGLOBAL)lParam );
        return TRUE;
 
    case WM_DDE_EXECUTE:
        if (uiLo) *uiLo = 0;
        if (uiHi) *uiHi = lParam;
        return TRUE;
 
    default:
        if (uiLo) *uiLo = LOWORD(lParam);
        if (uiHi) *uiHi = HIWORD(lParam);
        return TRUE;
    }
}

Referenced by dde_msg_client_wndproc(), dde_server_wndproc(), dde_server_wndprocA(), dde_server_wndprocW(), hook_dde_client_wndprocA(), hook_dde_client_wndprocW(), post_dde_message(), test_PackDDElParam(), test_UnpackDDElParam(), WDML_HandleAdviseReply(), WDML_HandleExecuteReply(), WDML_HandleIncomingData(), WDML_HandlePokeReply(), WDML_HandleRequestReply(), WDML_HandleUnadviseReply(), WDML_ServerNameProc(), WDML_ServerQueueAdvise(), WDML_ServerQueuePoke(), WDML_ServerQueueRequest(), and WDML_ServerQueueUnadvise().

WDML_AddConv()

WDML_CONV * WDML_AddConv	(	WDML_INSTANCE *	pInstance,
		WDML_SIDE	side,
		HSZ	hszService,
		HSZ	hszTopic,
		HWND	hwndClient,
		HWND	hwndServer
	)

Definition at line 2008 of file ddemisc.c.

{
    WDML_CONV*  pConv;
 
    /* no conversation yet, add it */
    pConv = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_CONV));
    if (!pConv) return NULL;
 
    pConv->instance = pInstance;
    WDML_IncHSZ(pInstance, pConv->hszService = hszService);
    WDML_IncHSZ(pInstance, pConv->hszTopic = hszTopic);
    pConv->magic = WDML_CONV_MAGIC;
    pConv->hwndServer = hwndServer;
    pConv->hwndClient = hwndClient;
    pConv->transactions = NULL;
    pConv->hUser = 0;
    pConv->wStatus = (side == WDML_CLIENT_SIDE) ? ST_CLIENT : 0L;
    pConv->wStatus |= pInstance->wStatus;
    /* check if both side of the conversation are of the same instance */
    if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
    WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
    {
    pConv->wStatus |= ST_ISSELF;
    }
    pConv->wConvst = XST_NULL;
 
    pConv->next = pInstance->convs[side];
    pInstance->convs[side] = pConv;
 
    TRACE("pConv->wStatus %04x pInstance(%p)\n", pConv->wStatus, pInstance);
 
    return pConv;
}

Referenced by WDML_ClientProc(), and WDML_CreateServerConv().

WDML_AddLink()

void WDML_AddLink	(	WDML_INSTANCE *	pInstance,
		HCONV	hConv,
		WDML_SIDE	side,
		UINT	wType,
		HSZ	hszItem,
		UINT	wFmt
	)

Definition at line 1755 of file ddemisc.c.

{
    WDML_LINK*  pLink;
 
    pLink = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_LINK));
    if (pLink == NULL)
    {
    ERR("OOM\n");
    return;
    }
 
    pLink->hConv = hConv;
    pLink->transactionType = wType;
    WDML_IncHSZ(pInstance, pLink->hszItem = hszItem);
    pLink->uFmt = wFmt;
    pLink->next = pInstance->links[side];
    pInstance->links[side] = pLink;
}

Referenced by WDML_HandleAdviseReply(), and WDML_ServerHandleAdvise().

WDML_AddServer()

WDML_SERVER * WDML_AddServer	(	WDML_INSTANCE *	pInstance,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 1638 of file ddemisc.c.

{
    static const WCHAR fmtW[] = {'%','s','(','0','x','%','*','x',')',0};
    WDML_SERVER*    pServer;
    WCHAR       buf1[256];
    WCHAR       buf2[256];
 
    pServer = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_SERVER));
    if (pServer == NULL) return NULL;
 
    pServer->hszService = hszService;
    WDML_IncHSZ(pInstance, hszService);
 
    DdeQueryStringW(pInstance->instanceID, hszService, buf1, 256, CP_WINUNICODE);
    snprintfW(buf2, 256, fmtW, buf1, 2*sizeof(ULONG_PTR), GetCurrentProcessId());
    pServer->hszServiceSpec = DdeCreateStringHandleW(pInstance->instanceID, buf2, CP_WINUNICODE);
 
    pServer->atomService = WDML_MakeAtomFromHsz(pServer->hszService);
    pServer->atomServiceSpec = WDML_MakeAtomFromHsz(pServer->hszServiceSpec);
 
    pServer->filterOn = TRUE;
 
    pServer->next = pInstance->servers;
    pInstance->servers = pServer;
    return pServer;
}

Referenced by DdeNameService().

WDML_AllocTransaction()

WDML_XACT * WDML_AllocTransaction	(	WDML_INSTANCE *	pInstance,
		UINT	ddeMsg,
		UINT	wFmt,
		HSZ	hszItem
	)

Definition at line 1900 of file ddemisc.c.

{
    WDML_XACT*      pXAct;
    static WORD     tid = 1;    /* FIXME: wrap around */
 
    pXAct = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_XACT));
    if (!pXAct)
    {
    pInstance->lastError = DMLERR_MEMORY_ERROR;
    return NULL;
    }
 
    pXAct->xActID = tid++;
    pXAct->ddeMsg = ddeMsg;
    pXAct->hDdeData = 0;
    pXAct->hUser = 0;
    pXAct->next = NULL;
    pXAct->wType = 0;
    pXAct->wFmt = wFmt;
    if ((pXAct->hszItem = hszItem)) WDML_IncHSZ(pInstance, pXAct->hszItem);
    pXAct->atom = 0;
    pXAct->hMem = 0;
    pXAct->lParam = 0;
 
    return pXAct;
}

Referenced by WDML_ClientQueueAdvise(), WDML_ClientQueueExecute(), WDML_ClientQueuePoke(), WDML_ClientQueueRequest(), WDML_ClientQueueTerminate(), WDML_ClientQueueUnadvise(), WDML_ServerQueueAdvise(), WDML_ServerQueueExecute(), WDML_ServerQueuePoke(), WDML_ServerQueueRequest(), WDML_ServerQueueTerminate(), and WDML_ServerQueueUnadvise().

WDML_BroadcastDDEWindows()

void WDML_BroadcastDDEWindows	(	LPCWSTR	clsName,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2502 of file ddemisc.c.

{
    struct tagWDML_BroadcastPmt s;
 
    s.clsName = clsName;
    s.uMsg    = uMsg;
    s.wParam  = wParam;
    s.lParam  = lParam;
    EnumWindows(WDML_BroadcastEnumProc, (LPARAM)&s);
}

Referenced by DdeNameService(), and WDML_RemoveServer().

WDML_BroadcastEnumProc()

static BOOL CALLBACK WDML_BroadcastEnumProc ( HWND  hWnd, LPARAM  lParam  )

static

Definition at line 2484 of file ddemisc.c.

{
    struct tagWDML_BroadcastPmt*    s = (struct tagWDML_BroadcastPmt*)lParam;
    WCHAR               buffer[128];
 
    if (GetClassNameW(hWnd, buffer, 128) > 0 &&
    lstrcmpiW(buffer, s->clsName) == 0)
    {
    PostMessageW(hWnd, s->uMsg, s->wParam, s->lParam);
    }
    return TRUE;
}

Referenced by WDML_BroadcastDDEWindows().

WDML_CreateString()

static HSZ WDML_CreateString ( WDML_INSTANCE *  pInstance, LPCVOID  ptr, int  codepage  )

static

Definition at line 550 of file ddemisc.c.

{
    HSZ     hsz;
 
    switch (codepage)
    {
    case CP_WINANSI:
    hsz = ATOM2HSZ(AddAtomA(ptr));
    TRACE("added atom %s with HSZ %p,\n", debugstr_a(ptr), hsz);
    break;
    case CP_WINUNICODE:
    hsz = ATOM2HSZ(AddAtomW(ptr));
    TRACE("added atom %s with HSZ %p,\n", debugstr_w(ptr), hsz);
    break;
    default:
    ERR("Unknown code page %d\n", codepage);
    return 0;
    }
    WDML_InsertHSZNode(pInstance, hsz);
    return hsz;
}

Referenced by DdeCreateStringHandleA(), and DdeCreateStringHandleW().

WDML_DataHandle2Global()

HGLOBAL WDML_DataHandle2Global	(	HDDEDATA	hDdeData,
		BOOL	fResponse,
		BOOL	fRelease,
		BOOL	fDeferUpd,
		BOOL	fAckReq
	)

Definition at line 1563 of file ddemisc.c.

{
    DDE_DATAHANDLE_HEAD*    pDdh;
    DWORD                       dwSize;
    HGLOBAL                     hMem = 0;
 
    dwSize = GlobalSize(hDdeData) - sizeof(DDE_DATAHANDLE_HEAD);
    pDdh = GlobalLock(hDdeData);
    if (dwSize && pDdh)
    {
        WINE_DDEHEAD*    wdh = NULL;
 
        switch (pDdh->cfFormat)
        {
        default:
            FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
                   pDdh->cfFormat, hDdeData);
            /* fall through */
        case 0:
        case CF_TEXT:
            hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(WINE_DDEHEAD) + dwSize);
            if (hMem && (wdh = GlobalLock(hMem)))
            {
                memcpy(wdh + 1, pDdh + 1, dwSize);
            }
            break;
        case CF_BITMAP:
            if (dwSize >= sizeof(HBITMAP))
            {
                BITMAP  bmp;
                DWORD   count;
                HBITMAP hbmp = *(HBITMAP*)(pDdh + 1);
 
                if (GetObjectW(hbmp, sizeof(bmp), &bmp))
                {
                    count = bmp.bmWidthBytes * bmp.bmHeight;
                    hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
                                       sizeof(WINE_DDEHEAD) + sizeof(bmp) + count);
                    if (hMem && (wdh = GlobalLock(hMem)))
                    {
                        memcpy(wdh + 1, &bmp, sizeof(bmp));
                        GetBitmapBits(hbmp, count, ((char*)(wdh + 1)) + sizeof(bmp));
                    }
                }
            }
            break;
        }
        if (wdh)
        {
            wdh->unused = 0;
            wdh->fResponse = fResponse;
            wdh->fRelease = fRelease;
            wdh->fDeferUpd = fDeferUpd;
            wdh->fAckReq = fAckReq;
            wdh->cfFormat = pDdh->cfFormat;
            GlobalUnlock(hMem);
        }
        GlobalUnlock(hDdeData);
    }
 
    return hMem;
}

Referenced by DdePostAdvise(), and WDML_ServerHandleRequest().

WDML_DecHSZ()

BOOL WDML_DecHSZ	(	WDML_INSTANCE *	pInstance,
		HSZ	hsz
	)

Definition at line 380 of file ddemisc.c.

{
    HSZNode*    pPrev = NULL;
    HSZNode*    pCurrent;
 
    for (pCurrent = pInstance->nodeList; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
    {
    /* If we found the node we were looking for and its ref count is one,
     * we can remove it
     */
    if (pCurrent->hsz == hsz)
    {
        if (--pCurrent->refCount == 0)
        {
        if (pCurrent == pInstance->nodeList)
        {
            pInstance->nodeList = pCurrent->next;
        }
        else
        {
            pPrev->next = pCurrent->next;
        }
        HeapFree(GetProcessHeap(), 0, pCurrent);
        DeleteAtom(HSZ2ATOM(hsz));
        }
        return TRUE;
    }
    }
    WARN("HSZ %p not found\n", hsz);
 
    return FALSE;
}

Referenced by DdeFreeStringHandle(), WDML_EventProc(), WDML_FreeTransaction(), WDML_HandleIncomingData(), WDML_RemoveAllLinks(), WDML_RemoveConv(), WDML_RemoveLink(), WDML_RemoveServer(), WDML_ServerHandleAdvise(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), and WDML_ServerHandleUnadvise().

WDML_EnableCallback()

static BOOL WDML_EnableCallback ( WDML_CONV *  pConv, UINT  wCmd  )

static

Definition at line 2127 of file ddemisc.c.

{
    if (wCmd == EC_DISABLE)
    {
        pConv->wStatus |= ST_BLOCKED;
        TRACE("EC_DISABLE: conv %p status flags %04x\n", pConv, pConv->wStatus);
        return TRUE;
    }
 
    if (wCmd == EC_QUERYWAITING)
        return pConv->transactions != NULL;
 
    if (wCmd != EC_ENABLEALL && wCmd != EC_ENABLEONE)
    {
        FIXME("Unknown command code %04x\n", wCmd);
        return FALSE;
    }
 
    if (wCmd == EC_ENABLEALL)
    {
        pConv->wStatus &= ~ST_BLOCKED;
        TRACE("EC_ENABLEALL: conv %p status flags %04x\n", pConv, pConv->wStatus);
    }
 
    while (pConv->transactions)
    {
        WDML_XACT *pXAct = pConv->transactions;
 
        if (pConv->wStatus & ST_CLIENT)
        {
            /* transaction should be in the queue until handled */
            WDML_ClientHandle(pConv, pXAct, 0, NULL);
            WDML_UnQueueTransaction(pConv, pXAct);
        }
        else
        {
            /* transaction should be removed from the queue before handling */
            WDML_UnQueueTransaction(pConv, pXAct);
            WDML_ServerHandle(pConv, pXAct);
        }
 
        WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
 
        if (wCmd == EC_ENABLEONE) break;
    }
    return TRUE;
}

Referenced by DdeEnableCallback().

WDML_EventProc()

static LRESULT CALLBACK WDML_EventProc ( HWND  hwndEvent, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 759 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
    HSZ         hsz1, hsz2;
 
    switch (uMsg)
    {
    case WM_WDML_REGISTER:
    pInstance = WDML_GetInstanceFromWnd(hwndEvent);
        /* try calling the Callback */
    if (pInstance && !(pInstance->CBFflags & CBF_SKIP_REGISTRATIONS))
    {
        hsz1 = WDML_MakeHszFromAtom(pInstance, wParam);
        hsz2 = WDML_MakeHszFromAtom(pInstance, lParam);
        WDML_InvokeCallback(pInstance, XTYP_REGISTER, 0, 0, hsz1, hsz2, 0, 0, 0);
        WDML_DecHSZ(pInstance, hsz1);
        WDML_DecHSZ(pInstance, hsz2);
    }
    break;
 
    case WM_WDML_UNREGISTER:
    pInstance = WDML_GetInstanceFromWnd(hwndEvent);
    if (pInstance && !(pInstance->CBFflags & CBF_SKIP_UNREGISTRATIONS))
    {
        hsz1 = WDML_MakeHszFromAtom(pInstance, wParam);
        hsz2 = WDML_MakeHszFromAtom(pInstance, lParam);
        WDML_InvokeCallback(pInstance, XTYP_UNREGISTER, 0, 0, hsz1, hsz2, 0, 0, 0);
        WDML_DecHSZ(pInstance, hsz1);
        WDML_DecHSZ(pInstance, hsz2);
    }
    break;
 
    case WM_WDML_CONNECT_CONFIRM:
    pInstance = WDML_GetInstanceFromWnd(hwndEvent);
    if (pInstance && !(pInstance->CBFflags & CBF_SKIP_CONNECT_CONFIRMS))
    {
        WDML_CONV*  pConv;
        /* confirm connection...
         * lookup for this conv handle
         */
            HWND client = WIN_GetFullHandle( (HWND)wParam );
            HWND server = WIN_GetFullHandle( (HWND)lParam );
        for (pConv = pInstance->convs[WDML_SERVER_SIDE]; pConv != NULL; pConv = pConv->next)
        {
        if (pConv->hwndClient == client && pConv->hwndServer == server)
            break;
        }
        if (pConv)
        {
        pConv->wStatus |= ST_ISLOCAL;
 
        WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
                    pConv->hszTopic, pConv->hszService, 0, 0,
                    (pConv->wStatus & ST_ISSELF) ? 1 : 0);
        }
    }
    break;
    default:
    return DefWindowProcW(hwndEvent, uMsg, wParam, lParam);
    }
    return 0;
}

Referenced by WDML_Initialize().

WDML_FindConv()

WDML_CONV * WDML_FindConv	(	WDML_INSTANCE *	pInstance,
		WDML_SIDE	side,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 2048 of file ddemisc.c.

{
    WDML_CONV*  pCurrent;
 
    for (pCurrent = pInstance->convs[side]; pCurrent != NULL; pCurrent = pCurrent->next)
    {
    if (DdeCmpStringHandles(pCurrent->hszService, hszService) == 0 &&
        DdeCmpStringHandles(pCurrent->hszTopic, hszTopic) == 0)
    {
        return pCurrent;
    }
 
    }
    return NULL;
}

Referenced by DdeConnect().

WDML_FindLink()

WDML_LINK * WDML_FindLink	(	WDML_INSTANCE *	pInstance,
		HCONV	hConv,
		WDML_SIDE	side,
		HSZ	hszItem,
		BOOL	use_fmt,
		UINT	uFmt
	)

Definition at line 1868 of file ddemisc.c.

{
    WDML_LINK*  pCurrent;
 
    for (pCurrent = pInstance->links[side]; pCurrent != NULL; pCurrent = pCurrent->next)
    {
    /* we don't need to check for transaction type as it can be altered */
 
    if (pCurrent->hConv == hConv &&
        DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
        (!use_fmt || pCurrent->uFmt == uFmt))
    {
        break;
    }
 
    }
 
    return pCurrent;
}

Referenced by WDML_HandleAdviseReply(), WDML_HandleIncomingData(), WDML_ServerHandleAdvise(), and WDML_ServerHandleUnadvise().

WDML_FindNode()

static HSZNode * WDML_FindNode ( WDML_INSTANCE *  pInstance, HSZ  hsz  )

static

Definition at line 305 of file ddemisc.c.

{
    HSZNode*    pNode;
 
    if (pInstance == NULL) return NULL;
 
    for (pNode = pInstance->nodeList; pNode != NULL; pNode = pNode->next)
    {
    if (pNode->hsz == hsz) break;
    }
    if (!pNode) WARN("HSZ %p not found\n", hsz);
    return pNode;
}

Referenced by WDML_IncHSZ().

WDML_FindServer()

WDML_SERVER * WDML_FindServer	(	WDML_INSTANCE *	pInstance,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 1729 of file ddemisc.c.

{
    WDML_SERVER*    pServer;
 
    for (pServer = pInstance->servers; pServer != NULL; pServer = pServer->next)
    {
    if (hszService == pServer->hszService)
    {
        return pServer;
    }
    }
    TRACE("Service name missing\n");
    return NULL;
}

Referenced by DdeNameService().

WDML_FindTransaction()

static WDML_XACT * WDML_FindTransaction ( WDML_CONV *  pConv, DWORD  tid  )

static

Definition at line 1984 of file ddemisc.c.

{
    WDML_XACT* pXAct;
 
    tid = HIWORD(tid);
    for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
    {
    if (pXAct->xActID == tid)
        break;
    }
    return pXAct;
}

Referenced by DdeSetUserHandle(), and WDML_GetLocalConvInfo().

WDML_FreeAllHSZ()

static void WDML_FreeAllHSZ ( WDML_INSTANCE *  pInstance )

static

Definition at line 419 of file ddemisc.c.

{
    /* Free any strings created in this instance.
     */
    while (pInstance->nodeList != NULL)
    {
    DdeFreeStringHandle(pInstance->instanceID, pInstance->nodeList->hsz);
    }
}

Referenced by DdeUninitialize().

WDML_FreeTransaction()

void WDML_FreeTransaction	(	WDML_INSTANCE *	pInstance,
		WDML_XACT *	pXAct,
		BOOL	doFreePmt
	)

Definition at line 1967 of file ddemisc.c.

{
    /* free pmt(s) in pXAct too. check against one for not deleting TRUE return values */
    if (doFreePmt && (ULONG_PTR)pXAct->hMem > 1)
    {
    GlobalFree(pXAct->hMem);
    }
    if (pXAct->hszItem) WDML_DecHSZ(pInstance, pXAct->hszItem);
 
    HeapFree(GetProcessHeap(), 0, pXAct);
}

Referenced by DdeAbandonTransaction(), DdeClientTransaction(), DdeDisconnect(), WDML_EnableCallback(), WDML_RemoveConv(), and WDML_ServerConvProc().

WDML_GetConv()

WDML_CONV * WDML_GetConv	(	HCONV	hConv,
		BOOL	checkConnected
	)

Definition at line 2230 of file ddemisc.c.

{
    WDML_CONV*  pConv = (WDML_CONV*)hConv;
 
    /* FIXME: should do better checking */
    if (pConv == NULL || pConv->magic != WDML_CONV_MAGIC) return NULL;
 
    if (!pConv->instance)
    {
        WARN("wrong thread ID, no instance\n");
    return NULL;
    }
 
    if (pConv->instance->threadID != GetCurrentThreadId())
    {
        WARN("wrong thread ID\n");
        pConv->instance->lastError = DMLERR_INVALIDPARAMETER; /* FIXME: check */
    return NULL;
    }
 
    if (checkConnected && !(pConv->wStatus & ST_CONNECTED))
    {
        WARN("found conv but ain't connected\n");
        pConv->instance->lastError = DMLERR_NO_CONV_ESTABLISHED;
    return NULL;
    }
 
    return pConv;
}

Referenced by DdeAbandonTransaction(), DdeClientTransaction(), DdeDisconnect(), DdeEnableCallback(), DdeImpersonateClient(), DdePostAdvise(), DdeQueryConvInfo(), DdeReconnect(), DdeSetUserHandle(), and WDML_SyncWaitTransactionReply().

WDML_GetConvFromWnd()

WDML_CONV * WDML_GetConvFromWnd

(

HWND

hWnd

)

Definition at line 2265 of file ddemisc.c.

{
    return (WDML_CONV*)GetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION);
}

Referenced by DdeConnect(), DdeReconnect(), WDML_ClientProc(), and WDML_ServerConvProc().

WDML_GetInstance()

WDML_INSTANCE * WDML_GetInstance

(

DWORD

instId

)

Definition at line 1230 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
 
    EnterCriticalSection(&WDML_CritSect);
 
    for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = pInstance->next)
    {
    if (pInstance->instanceID == instId)
    {
        if (GetCurrentThreadId() != pInstance->threadID)
        {
        FIXME("Tried to get instance from wrong thread\n");
        continue;
        }
        break;
    }
    }
 
    LeaveCriticalSection(&WDML_CritSect);
 
    if (!pInstance)
        WARN("Instance entry missing for id %04x\n", instId);
    return pInstance;
}

Referenced by DdeAbandonTransaction(), DdeConnect(), DdeCreateDataHandle(), DdeCreateStringHandleA(), DdeCreateStringHandleW(), DdeEnableCallback(), DdeFreeStringHandle(), DdeGetLastError(), DdeKeepStringHandle(), DdeNameService(), DdePostAdvise(), DdeQueryStringA(), DdeQueryStringW(), and DdeUninitialize().

WDML_GetInstanceFromWnd()

WDML_INSTANCE * WDML_GetInstanceFromWnd

(

HWND

hWnd

)

Definition at line 1261 of file ddemisc.c.

{
    return (WDML_INSTANCE*)GetWindowLongPtrW(hWnd, GWL_WDML_INSTANCE);
}

Referenced by WDML_AddConv(), WDML_ClientProc(), WDML_EventProc(), WDML_ServerConvProc(), and WDML_ServerNameProc().

WDML_GetLocalConvInfo()

static BOOL WDML_GetLocalConvInfo ( WDML_CONV *  pConv, CONVINFO *  ci, DWORD  id  )

static

Definition at line 2349 of file ddemisc.c.

{
    BOOL    ret = TRUE;
    WDML_LINK*  pLink;
    WDML_SIDE   side;
 
    ci->hConvPartner = (pConv->wStatus & ST_ISLOCAL) ? (HCONV)((ULONG_PTR)pConv | 1) : 0;
    ci->hszSvcPartner = pConv->hszService;
    ci->hszServiceReq = pConv->hszService; /* FIXME: they shouldn't be the same, should they ? */
    ci->hszTopic = pConv->hszTopic;
    ci->wStatus = pConv->wStatus;
 
    side = (pConv->wStatus & ST_CLIENT) ? WDML_CLIENT_SIDE : WDML_SERVER_SIDE;
 
    for (pLink = pConv->instance->links[side]; pLink != NULL; pLink = pLink->next)
    {
    if (pLink->hConv == (HCONV)pConv)
    {
        ci->wStatus |= ST_ADVISE;
        break;
    }
    }
 
    /* FIXME: non handled status flags:
       ST_BLOCKED
       ST_BLOCKNEXT
       ST_INLIST
    */
 
    ci->wConvst = pConv->wConvst; /* FIXME */
 
    ci->wLastError = 0; /* FIXME: note it's not the instance last error */
    ci->hConvList = 0;
    ci->ConvCtxt = pConv->convContext;
    if (ci->wStatus & ST_CLIENT)
    {
    ci->hwnd = pConv->hwndClient;
    ci->hwndPartner = pConv->hwndServer;
    }
    else
    {
    ci->hwnd = pConv->hwndServer;
    ci->hwndPartner = pConv->hwndClient;
    }
    if (id == QID_SYNC)
    {
    ci->hUser = pConv->hUser;
    ci->hszItem = 0;
    ci->wFmt = 0;
    ci->wType = 0;
    }
    else
    {
    WDML_XACT*  pXAct;
 
    pXAct = WDML_FindTransaction(pConv, id);
    if (pXAct)
    {
        ci->hUser = pXAct->hUser;
        ci->hszItem = pXAct->hszItem;
        ci->wFmt = pXAct->wFmt;
        ci->wType = pXAct->wType;
    }
    else
    {
        ret = 0;
        pConv->instance->lastError = DMLERR_UNFOUND_QUEUE_ID;
    }
    }
    return ret;
}

Referenced by DdeQueryConvInfo().

WDML_Global2DataHandle()

HDDEDATA WDML_Global2DataHandle	(	WDML_CONV *	pConv,
		HGLOBAL	hMem,
		WINE_DDEHEAD *	p
	)

Definition at line 1504 of file ddemisc.c.

{
    DDEDATA*    pDd;
    HDDEDATA    ret = 0;
    DWORD       size;
 
    if (hMem)
    {
        pDd = GlobalLock(hMem);
        size = GlobalSize(hMem) - sizeof(WINE_DDEHEAD);
        if (pDd)
        {
        if (p) memcpy(p, pDd, sizeof(WINE_DDEHEAD));
            switch (pDd->cfFormat)
            {
            default:
                FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
                      pDd->cfFormat, hMem);
                /* fall through */
            case 0:
            case CF_TEXT:
                ret = DdeCreateDataHandle(pConv->instance->instanceID, pDd->Value, size, 0, 0, pDd->cfFormat, 0);
                break;
            case CF_BITMAP:
                if (size >= sizeof(BITMAP))
                {
                    BITMAP*     bmp = (BITMAP*)pDd->Value;
                    int         count = bmp->bmWidthBytes * bmp->bmHeight * bmp->bmPlanes;
                    if (size >= sizeof(BITMAP) + count)
                    {
                        HBITMAP hbmp;
 
                        if ((hbmp = CreateBitmap(bmp->bmWidth, bmp->bmHeight,
                                                 bmp->bmPlanes, bmp->bmBitsPixel,
                                                 pDd->Value + sizeof(BITMAP))))
                        {
                            ret = DdeCreateDataHandle(pConv->instance->instanceID, (LPBYTE)&hbmp, sizeof(hbmp),
                                                      0, 0, CF_BITMAP, 0);
                        }
                        else ERR("Can't create bmp\n");
                    }
                    else
                    {
                        ERR("Wrong count: %u / %d\n", size, count);
                    }
                } else ERR("No bitmap header\n");
                break;
            }
            GlobalUnlock(hMem);
        }
    }
    return ret;
}

Referenced by WDML_HandleIncomingData(), and WDML_HandleRequestReply().

WDML_IncHSZ()

BOOL WDML_IncHSZ	(	WDML_INSTANCE *	pInstance,
		HSZ	hsz
	)

Definition at line 362 of file ddemisc.c.

{
    HSZNode*    pNode;
 
    pNode = WDML_FindNode(pInstance, hsz);
    if (!pNode) return FALSE;
 
    pNode->refCount++;
    return TRUE;
}

Referenced by DdeKeepStringHandle(), DdeNameService(), WDML_AddConv(), WDML_AddLink(), WDML_AddServer(), and WDML_AllocTransaction().

WDML_IncrementInstanceId()

static void WDML_IncrementInstanceId ( WDML_INSTANCE *  pInstance )

static

Definition at line 746 of file ddemisc.c.

{
    DWORD   id = InterlockedIncrement(&WDML_MaxInstanceID);
 
    pInstance->instanceID = id;
    TRACE("New instance id %d allocated\n", id);
}

Referenced by WDML_Initialize().

WDML_Initialize()

static UINT WDML_Initialize ( LPDWORD  pidInst, PFNCALLBACK  pfnCallback, DWORD  afCmd, DWORD  ulRes, BOOL  bUnicode  )

static

Definition at line 827 of file ddemisc.c.

{
    WDML_INSTANCE*      pInstance;
    WDML_INSTANCE*      reference_inst;
    UINT            ret;
    WNDCLASSEXW         wndclass;
 
    TRACE("(%p,%p,0x%x,%d,0x%x)\n",
      pidInst, pfnCallback, afCmd, ulRes, bUnicode);
 
    if (ulRes)
    {
    ERR("Reserved value not zero?  What does this mean?\n");
    /* trap this and no more until we know more */
    return DMLERR_NO_ERROR;
    }
 
    /* grab enough heap for one control struct - not really necessary for re-initialise
     *  but allows us to use same validation routines */
    pInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_INSTANCE));
    if (pInstance == NULL)
    {
    /* catastrophe !! warn user & abort */
    ERR("Instance create failed - out of memory\n");
    return DMLERR_SYS_ERROR;
    }
    pInstance->next = NULL;
    pInstance->monitor = (afCmd | APPCLASS_MONITOR);
 
    /* messy bit, spec implies that 'Client Only' can be set in 2 different ways, catch 1 here */
 
    pInstance->clientOnly = afCmd & APPCMD_CLIENTONLY;
    pInstance->instanceID = *pidInst; /* May need to add calling proc Id */
    pInstance->threadID = GetCurrentThreadId();
    pInstance->callback = *pfnCallback;
    pInstance->unicode = bUnicode;
    pInstance->nodeList = NULL; /* node will be added later */
    pInstance->monitorFlags = afCmd & MF_MASK;
    pInstance->wStatus = 0;
    pInstance->lastError = DMLERR_NO_ERROR;
    pInstance->servers = NULL;
    pInstance->convs[0] = NULL;
    pInstance->convs[1] = NULL;
    pInstance->links[0] = NULL;
    pInstance->links[1] = NULL;
 
    /* isolate CBF flags in one go, expect this will go the way of all attempts to be clever !! */
 
    pInstance->CBFflags = afCmd^((afCmd&MF_MASK)|((afCmd&APPCMD_MASK)|(afCmd&APPCLASS_MASK)));
 
    if (!pInstance->clientOnly)
    {
    /* Check for other way of setting Client-only !! */
    pInstance->clientOnly =
        (pInstance->CBFflags & CBF_FAIL_ALLSVRXACTIONS) == CBF_FAIL_ALLSVRXACTIONS;
    }
 
    TRACE("instance created - checking validity\n");
 
    if (*pidInst == 0)
    {
    /*  Initialisation of new Instance Identifier */
    TRACE("new instance, callback %p flags %X\n",pfnCallback,afCmd);
 
    EnterCriticalSection(&WDML_CritSect);
 
    if (WDML_InstanceList == NULL)
    {
        /* can't be another instance in this case, assign to the base pointer */
        WDML_InstanceList = pInstance;
 
        /* since first must force filter of XTYP_CONNECT and XTYP_WILDCONNECT for
         *      present
         *  -------------------------------      NOTE NOTE NOTE    --------------------------
         *
         *  the manual is not clear if this condition
         *  applies to the first call to DdeInitialize from an application, or the
         *  first call for a given callback !!!
         */
 
        pInstance->CBFflags = pInstance->CBFflags|APPCMD_FILTERINITS;
        TRACE("First application instance detected OK\n");
        /*  allocate new instance ID */
        WDML_IncrementInstanceId(pInstance);
    }
    else
    {
        /* really need to chain the new one in to the latest here, but after checking conditions
         *  such as trying to start a conversation from an application trying to monitor */
        reference_inst = WDML_InstanceList;
        TRACE("Subsequent application instance - starting checks\n");
        while (reference_inst->next != NULL)
        {
        /*
         *  This set of tests will work if application uses same instance Id
         *  at application level once allocated - which is what manual implies
         *  should happen. If someone tries to be
         *  clever (lazy ?) it will fail to pick up that later calls are for
         *  the same application - should we trust them ?
         */
        if (pInstance->instanceID == reference_inst->instanceID)
        {
            /* Check 1 - must be same Client-only state */
 
            if (pInstance->clientOnly != reference_inst->clientOnly)
            {
            ret = DMLERR_DLL_USAGE;
            goto theError;
            }
 
            /* Check 2 - cannot use 'Monitor' with any non-monitor modes */
 
            if (pInstance->monitor != reference_inst->monitor)
            {
            ret = DMLERR_INVALIDPARAMETER;
            goto theError;
            }
 
            /* Check 3 - must supply different callback address */
 
            if (pInstance->callback == reference_inst->callback)
            {
            ret = DMLERR_DLL_USAGE;
            goto theError;
            }
        }
        reference_inst = reference_inst->next;
        }
        /*  All cleared, add to chain */
 
        TRACE("Application Instance checks finished\n");
        WDML_IncrementInstanceId(pInstance);
        reference_inst->next = pInstance;
    }
    LeaveCriticalSection(&WDML_CritSect);
 
    *pidInst = pInstance->instanceID;
 
    /* for deadlock issues, windows must always be created when outside the critical section */
    wndclass.cbSize        = sizeof(wndclass);
    wndclass.style         = 0;
    wndclass.lpfnWndProc   = WDML_EventProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = sizeof(ULONG_PTR);
    wndclass.hInstance     = 0;
    wndclass.hIcon         = 0;
    wndclass.hCursor       = 0;
    wndclass.hbrBackground = 0;
    wndclass.lpszMenuName  = NULL;
    wndclass.lpszClassName = WDML_szEventClass;
    wndclass.hIconSm       = 0;
 
    RegisterClassExW(&wndclass);
 
    pInstance->hwndEvent = CreateWindowW(WDML_szEventClass, NULL,
                        WS_POPUP, 0, 0, 0, 0,
                        0, 0, 0, 0);
 
    SetWindowLongPtrW(pInstance->hwndEvent, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
 
    TRACE("New application instance processing finished OK\n");
    }
    else
    {
    /* Reinitialisation situation   --- FIX  */
    TRACE("reinitialisation of (%p,%p,0x%x,%d): stub\n", pidInst, pfnCallback, afCmd, ulRes);
 
    EnterCriticalSection(&WDML_CritSect);
 
    if (WDML_InstanceList == NULL)
    {
        ret = DMLERR_INVALIDPARAMETER;
        goto theError;
    }
    /* can't reinitialise if we have initialised nothing !! */
    reference_inst = WDML_InstanceList;
    /* must first check if we have been given a valid instance to re-initialise !!  how do we do that ? */
    /*
     *  MS allows initialisation without specifying a callback, should we allow addition of the
     *  callback by a later call to initialise ? - if so this lot will have to change
     */
    while (reference_inst->next != NULL)
    {
        if (*pidInst == reference_inst->instanceID && pfnCallback == reference_inst->callback)
        {
        /* Check 1 - cannot change client-only mode if set via APPCMD_CLIENTONLY */
 
        if (reference_inst->clientOnly)
        {
            if  ((reference_inst->CBFflags & CBF_FAIL_ALLSVRXACTIONS) != CBF_FAIL_ALLSVRXACTIONS)
            {
                /* i.e. Was set to Client-only and through APPCMD_CLIENTONLY */
 
            if (!(afCmd & APPCMD_CLIENTONLY))
            {
                ret = DMLERR_INVALIDPARAMETER;
                goto theError;
            }
            }
        }
        /* Check 2 - cannot change monitor modes */
 
        if (pInstance->monitor != reference_inst->monitor)
        {
            ret = DMLERR_INVALIDPARAMETER;
            goto theError;
        }
 
        /* Check 3 - trying to set Client-only via APPCMD when not set so previously */
 
        if ((afCmd&APPCMD_CLIENTONLY) && !reference_inst->clientOnly)
        {
            ret = DMLERR_INVALIDPARAMETER;
            goto theError;
        }
        break;
        }
        reference_inst = reference_inst->next;
    }
    if (reference_inst->next == NULL)
    {
        ret = DMLERR_INVALIDPARAMETER;
        goto theError;
    }
    /* All checked - change relevant flags */
 
    reference_inst->CBFflags = pInstance->CBFflags;
    reference_inst->clientOnly = pInstance->clientOnly;
    reference_inst->monitorFlags = pInstance->monitorFlags;
 
    HeapFree(GetProcessHeap(), 0, pInstance); /* finished - release heap space used as work store */
 
    LeaveCriticalSection(&WDML_CritSect);
    }
 
    return DMLERR_NO_ERROR;
 theError:
    HeapFree(GetProcessHeap(), 0, pInstance);
    LeaveCriticalSection(&WDML_CritSect);
    return ret;
}

Referenced by DdeInitializeA(), and DdeInitializeW().

WDML_InsertHSZNode()

static void WDML_InsertHSZNode ( WDML_INSTANCE *  pInstance, HSZ  hsz  )

static

Definition at line 434 of file ddemisc.c.

{
    if (hsz != 0)
    {
    HSZNode* pNew = NULL;
    /* Create a new node for this HSZ.
     */
    pNew = HeapAlloc(GetProcessHeap(), 0, sizeof(HSZNode));
    if (pNew != NULL)
    {
        pNew->hsz      = hsz;
        pNew->next     = pInstance->nodeList;
        pNew->refCount = 1;
        pInstance->nodeList = pNew;
    }
    else
    {
        ERR("Primary HSZ Node allocation failed - out of memory\n");
    }
    }
}

Referenced by WDML_CreateString().

WDML_InvokeCallback()

HDDEDATA WDML_InvokeCallback	(	WDML_INSTANCE *	pInstance,
		UINT	uType,
		UINT	uFmt,
		HCONV	hConv,
		HSZ	hsz1,
		HSZ	hsz2,
		HDDEDATA	hdata,
		ULONG_PTR	dwData1,
		ULONG_PTR	dwData2
	)

Definition at line 1206 of file ddemisc.c.

{
    HDDEDATA    ret;
 
    if (pInstance == NULL)
    return NULL;
 
    TRACE("invoking CB[%p] (%x %x %p %p %p %p %lx %lx)\n",
      pInstance->callback, uType, uFmt,
      hConv, hsz1, hsz2, hdata, dwData1, dwData2);
    ret = pInstance->callback(uType, uFmt, hConv, hsz1, hsz2, hdata, dwData1, dwData2);
    TRACE("done => %p\n", ret);
    return ret;
}

Referenced by DdePostAdvise(), WDML_EventProc(), WDML_HandleIncomingData(), WDML_HandleReply(), WDML_HandleTerminateReply(), WDML_ServerHandleAdvise(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), WDML_ServerHandleTerminate(), WDML_ServerHandleUnadvise(), and WDML_ServerNameProc().

WDML_IsAppOwned()

BOOL WDML_IsAppOwned

(

HDDEDATA

hData

)

Definition at line 1477 of file ddemisc.c.

{
    DDE_DATAHANDLE_HEAD*    pDdh;
    BOOL                        ret = FALSE;
 
    pDdh = GlobalLock(hData);
    if (pDdh != NULL)
    {
        ret = pDdh->bAppOwned;
        GlobalUnlock(hData);
    }
    return ret;
}

Referenced by DdePostAdvise(), and WDML_ServerNameProc().

WDML_MakeAtomFromHsz()

ATOM WDML_MakeAtomFromHsz

(

HSZ

hsz

)

Definition at line 325 of file ddemisc.c.

{
    WCHAR nameBuffer[MAX_BUFFER_LEN];
 
    if (GetAtomNameW(HSZ2ATOM(hsz), nameBuffer, MAX_BUFFER_LEN))
    return GlobalAddAtomW(nameBuffer);
    WARN("HSZ %p not found\n", hsz);
    return 0;
}

Referenced by DdeConnect(), DdePostAdvise(), DdeReconnect(), WDML_AddServer(), WDML_ClientQueueAdvise(), WDML_ClientQueuePoke(), WDML_ClientQueueRequest(), WDML_ClientQueueUnadvise(), and WDML_CreateServerConv().

WDML_MakeHszFromAtom()

HSZ WDML_MakeHszFromAtom	(	const WDML_INSTANCE *	pInstance,
		ATOM	atom
	)

Definition at line 342 of file ddemisc.c.

{
    WCHAR nameBuffer[MAX_BUFFER_LEN];
 
    if (!atom) return NULL;
 
    if (GlobalGetAtomNameW(atom, nameBuffer, MAX_BUFFER_LEN))
    {
    TRACE("%x => %s\n", atom, debugstr_w(nameBuffer));
    return DdeCreateStringHandleW(pInstance->instanceID, nameBuffer, CP_WINUNICODE);
    }
    WARN("ATOM 0x%x not found\n", atom);
    return 0;
}

Referenced by WDML_ClientProc(), WDML_EventProc(), WDML_HandleAdviseReply(), WDML_HandleIncomingData(), WDML_HandlePokeReply(), WDML_HandleRequestReply(), WDML_HandleUnadviseReply(), WDML_ServerNameProc(), WDML_ServerQueueAdvise(), WDML_ServerQueuePoke(), WDML_ServerQueueRequest(), and WDML_ServerQueueUnadvise().

WDML_NotifyThreadDetach()

void WDML_NotifyThreadDetach

(

void

)

Definition at line 1181 of file ddemisc.c.

{
    WDML_INSTANCE*  pInstance;
    WDML_INSTANCE*  next;
    DWORD       tid = GetCurrentThreadId();
 
    EnterCriticalSection(&WDML_CritSect);
    for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = next)
    {
    next = pInstance->next;
    if (pInstance->threadID == tid)
    {
            LeaveCriticalSection(&WDML_CritSect);
        DdeUninitialize(pInstance->instanceID);
            EnterCriticalSection(&WDML_CritSect);
    }
    }
    LeaveCriticalSection(&WDML_CritSect);
}

WDML_PostAck()

BOOL WDML_PostAck	(	WDML_CONV *	pConv,
		WDML_SIDE	side,
		WORD	appRetCode,
		BOOL	fBusy,
		BOOL	fAck,
		UINT_PTR	pmt,
		LPARAM	lParam,
		UINT	oldMsg
	)

Definition at line 2275 of file ddemisc.c.

{
    DDEACK  ddeAck;
    HWND    from, to;
 
    if (side == WDML_SERVER_SIDE)
    {
    from = pConv->hwndServer;
    to   = pConv->hwndClient;
    }
    else
    {
    to   = pConv->hwndServer;
    from = pConv->hwndClient;
    }
 
    ddeAck.bAppReturnCode = appRetCode;
    ddeAck.reserved       = 0;
    ddeAck.fBusy          = fBusy;
    ddeAck.fAck           = fAck;
 
    TRACE("Posting a %s ack\n", ddeAck.fAck ? "positive" : "negative");
 
    lParam = (lParam) ? ReuseDDElParam(lParam, oldMsg, WM_DDE_ACK, *(WORD*)&ddeAck, pmt) :
        PackDDElParam(WM_DDE_ACK, *(WORD*)&ddeAck, pmt);
    if (!PostMessageW(to, WM_DDE_ACK, (WPARAM)from, lParam))
    {
    pConv->wStatus &= ~ST_CONNECTED;
        pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
        FreeDDElParam(WM_DDE_ACK, lParam);
        return FALSE;
    }
    return TRUE;
}

Referenced by WDML_HandleIncomingData(), WDML_ServerHandleAdvise(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), and WDML_ServerHandleUnadvise().

WDML_QueryString()

static int WDML_QueryString ( WDML_INSTANCE *  pInstance, HSZ  hsz, LPVOID  ptr, DWORD  cchMax, int  codepage  )

static

Definition at line 461 of file ddemisc.c.

{
    WCHAR   pString[MAX_BUFFER_LEN];
    int     ret;
    /* If psz is null, we have to return only the length
     * of the string.
     */
    if (ptr == NULL)
    {
    ptr = pString;
    cchMax = MAX_BUFFER_LEN;
    }
 
    /* if there is no input windows returns a NULL string */
    if (hsz == NULL)
    {
    CHAR *t_ptr = ptr;
    *t_ptr = '\0';
    return 1;
    }
 
    switch (codepage)
    {
    case CP_WINANSI:
    ret = GetAtomNameA(HSZ2ATOM(hsz), ptr, cchMax);
    break;
    case CP_WINUNICODE:
    ret = GetAtomNameW(HSZ2ATOM(hsz), ptr, cchMax);
        break;
    default:
    ERR("Unknown code page %d\n", codepage);
    ret = 0;
    }
    return ret;
}

Referenced by DdeQueryStringA(), and DdeQueryStringW().

WDML_QueueTransaction()

void WDML_QueueTransaction	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct
	)

Definition at line 1933 of file ddemisc.c.

{
    WDML_XACT** pt;
 
    /* advance to last in queue */
    for (pt = &pConv->transactions; *pt != NULL; pt = &(*pt)->next);
    *pt = pXAct;
}

Referenced by DdeClientTransaction(), and WDML_ServerConvProc().

WDML_RemoveAllLinks()

static void WDML_RemoveAllLinks ( WDML_INSTANCE *  pInstance, WDML_CONV *  pConv, WDML_SIDE  side  )

static

Definition at line 1822 of file ddemisc.c.

{
    WDML_LINK* pPrev = NULL;
    WDML_LINK* pCurrent = NULL;
    WDML_LINK* pNext = NULL;
 
    pCurrent = pInstance->links[side];
 
    while (pCurrent != NULL)
    {
    if (pCurrent->hConv == (HCONV)pConv)
    {
        if (pCurrent == pInstance->links[side])
        {
        pInstance->links[side] = pCurrent->next;
        pNext = pCurrent->next;
        }
        else
        {
        pPrev->next = pCurrent->next;
        pNext = pCurrent->next;
        }
 
        WDML_DecHSZ(pInstance, pCurrent->hszItem);
 
        HeapFree(GetProcessHeap(), 0, pCurrent);
        pCurrent = NULL;
    }
 
    if (pCurrent)
    {
        pPrev = pCurrent;
        pCurrent = pCurrent->next;
    }
    else
    {
        pCurrent = pNext;
    }
    }
}

Referenced by WDML_RemoveConv().

WDML_RemoveConv()

void WDML_RemoveConv	(	WDML_CONV *	pRef,
		WDML_SIDE	side
	)

Definition at line 2070 of file ddemisc.c.

{
    WDML_CONV*  pPrev = NULL;
    WDML_CONV*  pCurrent;
    WDML_XACT*  pXAct;
    WDML_XACT*  pXActNext;
    HWND    hWnd;
 
    if (!pRef)
    return;
 
    /* remove any pending transaction */
    for (pXAct = pRef->transactions; pXAct != NULL; pXAct = pXActNext)
    {
    pXActNext = pXAct->next;
    WDML_FreeTransaction(pRef->instance, pXAct, TRUE);
    }
 
    WDML_RemoveAllLinks(pRef->instance, pRef, side);
 
    /* FIXME: should we keep the window around ? it seems so (at least on client side
     * to let QueryConvInfo work after conv termination, but also to implement
     * DdeReconnect...
     */
    /* destroy conversation window, but first remove pConv from hWnd.
     * this would help the wndProc do appropriate handling upon a WM_DESTROY message
     */
    hWnd = (side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer;
    SetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION, 0);
 
    DestroyWindow((side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer);
 
    WDML_DecHSZ(pRef->instance, pRef->hszService);
    WDML_DecHSZ(pRef->instance, pRef->hszTopic);
 
    for (pCurrent = pRef->instance->convs[side]; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
    {
    if (pCurrent == pRef)
    {
        if (pCurrent == pRef->instance->convs[side])
        {
        pRef->instance->convs[side] = pCurrent->next;
        }
        else
        {
        pPrev->next = pCurrent->next;
        }
        pCurrent->magic = 0;
        HeapFree(GetProcessHeap(), 0, pCurrent);
        break;
    }
    }
}

Referenced by DdeDisconnect(), WDML_HandleTerminateReply(), WDML_RemoveServer(), and WDML_ServerHandleTerminate().

WDML_RemoveLink()

void WDML_RemoveLink	(	WDML_INSTANCE *	pInstance,
		HCONV	hConv,
		WDML_SIDE	side,
		HSZ	hszItem,
		UINT	uFmt
	)

Definition at line 1780 of file ddemisc.c.

{
    WDML_LINK* pPrev = NULL;
    WDML_LINK* pCurrent = NULL;
 
    pCurrent = pInstance->links[side];
 
    while (pCurrent != NULL)
    {
    if (pCurrent->hConv == hConv &&
        DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
        pCurrent->uFmt == uFmt)
    {
        if (pCurrent == pInstance->links[side])
        {
        pInstance->links[side] = pCurrent->next;
        }
        else
        {
        pPrev->next = pCurrent->next;
        }
 
        WDML_DecHSZ(pInstance, pCurrent->hszItem);
        HeapFree(GetProcessHeap(), 0, pCurrent);
        break;
    }
 
    pPrev = pCurrent;
    pCurrent = pCurrent->next;
    }
}

Referenced by WDML_HandleUnadviseReply(), and WDML_ServerHandleUnadvise().

WDML_RemoveServer()

void WDML_RemoveServer	(	WDML_INSTANCE *	pInstance,
		HSZ	hszService,
		HSZ	hszTopic
	)

Definition at line 1670 of file ddemisc.c.

{
    WDML_SERVER*    pPrev = NULL;
    WDML_SERVER*    pServer = NULL;
    WDML_CONV*      pConv;
    WDML_CONV*      pConvNext;
 
    pServer = pInstance->servers;
 
    while (pServer != NULL)
    {
    if (DdeCmpStringHandles(pServer->hszService, hszService) == 0)
    {
        WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_UNREGISTER,
                     pServer->atomService, pServer->atomServiceSpec);
        /* terminate all conversations for given topic */
        for (pConv = pInstance->convs[WDML_SERVER_SIDE]; pConv != NULL; pConv = pConvNext)
        {
        pConvNext = pConv->next;
        if (DdeCmpStringHandles(pConv->hszService, hszService) == 0)
        {
                    HWND client = pConv->hwndClient, server = pConv->hwndServer;
            WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
            /* don't care about return code (whether client window is present or not) */
            PostMessageW(client, WM_DDE_TERMINATE, (WPARAM)server, 0);
        }
        }
        if (pServer == pInstance->servers)
        {
        pInstance->servers = pServer->next;
        }
        else
        {
        pPrev->next = pServer->next;
        }
 
        DestroyWindow(pServer->hwndServer);
        WDML_DecHSZ(pInstance, pServer->hszServiceSpec);
        WDML_DecHSZ(pInstance, pServer->hszService);
 
        GlobalDeleteAtom(pServer->atomService);
        GlobalDeleteAtom(pServer->atomServiceSpec);
 
        HeapFree(GetProcessHeap(), 0, pServer);
        break;
    }
 
    pPrev = pServer;
    pServer = pServer->next;
    }
}

Referenced by DdeNameService().

WDML_SetAllLastError()

static void WDML_SetAllLastError ( DWORD  lastError )

static

Definition at line 279 of file ddemisc.c.

{
    DWORD       threadID;
    WDML_INSTANCE*  pInstance;
    threadID = GetCurrentThreadId();
    pInstance = WDML_InstanceList;
    while (pInstance)
    {
    if (pInstance->threadID == threadID)
        pInstance->lastError = lastError;
    pInstance = pInstance->next;
    }
}

Referenced by DdeCreateDataHandle(), DdeCreateStringHandleA(), and DdeCreateStringHandleW().

WDML_UnQueueTransaction()

BOOL WDML_UnQueueTransaction	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct
	)

Definition at line 1947 of file ddemisc.c.

{
    WDML_XACT** pt;
 
    for (pt = &pConv->transactions; *pt; pt = &(*pt)->next)
    {
    if (*pt == pXAct)
    {
        *pt = pXAct->next;
        return TRUE;
    }
    }
    return FALSE;
}

Referenced by DdeAbandonTransaction(), DdeClientTransaction(), and WDML_EnableCallback().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ddeml

)

Variable Documentation

critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

=
{
    0, 0, &WDML_CritSect,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": WDML_CritSect") }
}

Definition at line 42 of file ddemisc.c.

WDML_CritSect

static CRITICAL_SECTION WDML_CritSect = { &critsect_debug, -1, 0, 0, 0, 0 }

static

Definition at line 41 of file ddemisc.c.

Referenced by WDML_GetInstance(), WDML_Initialize(), and WDML_NotifyThreadDetach().

WDML_InstanceList

WDML_INSTANCE* WDML_InstanceList = NULL

static

Definition at line 36 of file ddemisc.c.

Referenced by DdeUninitialize(), WDML_GetInstance(), WDML_Initialize(), WDML_NotifyThreadDetach(), and WDML_SetAllLastError().

WDML_MaxInstanceID

LONG WDML_MaxInstanceID = 0

static

Definition at line 37 of file ddemisc.c.

Referenced by WDML_IncrementInstanceId().

WDML_szEventClass

const WCHAR WDML_szEventClass[] = L"DDEMLEvent"

Definition at line 38 of file ddemisc.c.

Referenced by DdeNameService(), WDML_Initialize(), and WDML_RemoveServer().