ddeclient.c File Reference

#include <user32.h>

Include dependency graph for ddeclient.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ddeml)
static LRESULT CALLBACK	WDML_ClientProc (HWND, UINT, WPARAM, LPARAM)
HCONVLIST WINAPI	DdeConnectList (DWORD idInst, HSZ hszService, HSZ hszTopic, HCONVLIST hConvList, PCONVCONTEXT pCC)
HCONV WINAPI	DdeQueryNextServer (HCONVLIST hConvList, HCONV hConvPrev)
BOOL WINAPI	DdeDisconnectList (HCONVLIST hConvList)
HCONV WINAPI	DdeConnect (DWORD idInst, HSZ hszService, HSZ hszTopic, PCONVCONTEXT pCC)
HCONV WINAPI	DdeReconnect (HCONV hConv)
static WDML_XACT *	WDML_ClientQueueAdvise (WDML_CONV *pConv, UINT wType, UINT wFmt, HSZ hszItem)
static WDML_QUEUE_STATE	WDML_HandleAdviseReply (WDML_CONV *pConv, MSG *msg, WDML_XACT *pXAct, DWORD *ack)
static WDML_XACT *	WDML_ClientQueueUnadvise (WDML_CONV *pConv, UINT wFmt, HSZ hszItem)
static WDML_QUEUE_STATE	WDML_HandleUnadviseReply (WDML_CONV *pConv, MSG *msg, WDML_XACT *pXAct, DWORD *ack)
static WDML_XACT *	WDML_ClientQueueRequest (WDML_CONV *pConv, UINT wFmt, HSZ hszItem)
static WDML_QUEUE_STATE	WDML_HandleRequestReply (WDML_CONV *pConv, MSG *msg, WDML_XACT *pXAct, DWORD *ack)
static HGLOBAL	WDML_BuildExecuteCommand (WDML_CONV *pConv, LPCVOID pData, DWORD cbData)
static WDML_XACT *	WDML_ClientQueueExecute (WDML_CONV *pConv, LPVOID pData, DWORD cbData)
static WDML_QUEUE_STATE	WDML_HandleExecuteReply (WDML_CONV *pConv, MSG *msg, WDML_XACT *pXAct, DWORD *ack)
static WDML_XACT *	WDML_ClientQueuePoke (WDML_CONV *pConv, LPVOID pData, DWORD cbData, UINT wFmt, HSZ hszItem)
static WDML_QUEUE_STATE	WDML_HandlePokeReply (WDML_CONV *pConv, MSG *msg, WDML_XACT *pXAct, DWORD *ack)
static WDML_XACT *	WDML_ClientQueueTerminate (WDML_CONV *pConv)
static WDML_QUEUE_STATE	WDML_HandleTerminateReply (WDML_CONV *pConv, MSG *msg)
static WDML_QUEUE_STATE	WDML_HandleIncomingData (WDML_CONV *pConv, MSG *msg, HDDEDATA *hdd)
static WDML_QUEUE_STATE	WDML_HandleIncomingTerminate (WDML_CONV *pConv, MSG *msg, HDDEDATA *hdd)
static WDML_QUEUE_STATE	WDML_HandleReply (WDML_CONV *pConv, MSG *msg, HDDEDATA *hdd, DWORD *ack)
static HDDEDATA	WDML_SyncWaitTransactionReply (HCONV hConv, DWORD dwTimeout, const WDML_XACT *pXAct, DWORD *ack)
HDDEDATA	WDML_ClientHandle (WDML_CONV *pConv, WDML_XACT *pXAct, DWORD dwTimeout, LPDWORD pdwResult)
HDDEDATA WINAPI	DdeClientTransaction (LPBYTE pData, DWORD cbData, HCONV hConv, HSZ hszItem, UINT wFmt, UINT wType, DWORD dwTimeout, LPDWORD pdwResult)
BOOL WINAPI	DdeAbandonTransaction (DWORD idInst, HCONV hConv, DWORD idTransaction)
BOOL WINAPI	DdeDisconnect (HCONV hConv)
BOOL WINAPI	DdeImpersonateClient (HCONV hConv)

Variables
const char	WDML_szClientConvClassA [] = "WineDdeClientA"
const WCHAR	WDML_szClientConvClassW [] = L"WineDdeClientW"

Function Documentation

DdeAbandonTransaction()

BOOL WINAPI DdeAbandonTransaction	(	DWORD	idInst,
		HCONV	hConv,
		DWORD	idTransaction
	)

Definition at line 1229 of file ddeclient.c.

{
    WDML_INSTANCE*  pInstance;
    WDML_CONV*      pConv;
    WDML_XACT*          pXAct;
 
    if ((pInstance = WDML_GetInstance(idInst)))
    {
        if (hConv)
        {
            if ((pConv = WDML_GetConv(hConv, TRUE)) && pConv->instance == pInstance)
            {
 
                pXAct = pConv->transactions;
                while (pXAct) {
                    WDML_XACT *nextXAct = pXAct->next;
 
                    if (pXAct->dwTimeout == TIMEOUT_ASYNC &&
                        (idTransaction == 0 || pXAct->xActID == idTransaction))
                    {
                        WDML_UnQueueTransaction(pConv, pXAct);
                        WDML_FreeTransaction(pInstance, pXAct, TRUE);
                    }
                    pXAct = nextXAct;
                }
            }
        }
        else
        {
            for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv; pConv = pConv->next)
            {
                if (!(pConv->wStatus & ST_CONNECTED)) continue;
                pXAct = pConv->transactions;
                while (pXAct) {
                    WDML_XACT *nextXAct = pXAct->next;
 
                    if (pXAct->dwTimeout == TIMEOUT_ASYNC)
                    {
                        WDML_UnQueueTransaction(pConv, pXAct);
                        WDML_FreeTransaction(pInstance, pXAct, TRUE);
                    }
                    pXAct = nextXAct;
                }
            }
        }
    }
 
    return TRUE;
}

DdeClientTransaction()

HDDEDATA WINAPI DdeClientTransaction	(	LPBYTE	pData,
		DWORD	cbData,
		HCONV	hConv,
		HSZ	hszItem,
		UINT	wFmt,
		UINT	wType,
		DWORD	dwTimeout,
		LPDWORD	pdwResult
	)

Definition at line 1127 of file ddeclient.c.

{
    WDML_CONV*      pConv;
    WDML_XACT*      pXAct;
    HDDEDATA        hDdeData;
 
    TRACE("(%p,%ld,%p,%p,%x,%x,%ld,%p)\n",
      pData, cbData, hConv, hszItem, wFmt, wType, dwTimeout, pdwResult);
 
    if (hConv == 0)
    {
    WARN("Invalid conversation handle NULL\n");
    return 0;
    }
 
    pConv = WDML_GetConv(hConv, TRUE);
    if (pConv == NULL)
    {
    /* cannot set error... cannot get back to DDE instance */
        return 0;
    }
 
    switch (wType)
    {
    case XTYP_EXECUTE:
    /* Windows simply ignores hszItem and wFmt in this case */
    pXAct = WDML_ClientQueueExecute(pConv, pData, cbData);
    if (pXAct == NULL)
        return 0;
    break;
    case XTYP_POKE:
        if (!hszItem)
        {
            pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
            return 0;
        }
        pXAct = WDML_ClientQueuePoke(pConv, pData, cbData, wFmt, hszItem);
        break;
    case XTYP_ADVSTART|XTYPF_NODATA:
    case XTYP_ADVSTART|XTYPF_NODATA|XTYPF_ACKREQ:
    case XTYP_ADVSTART:
    case XTYP_ADVSTART|XTYPF_ACKREQ:
    if (pData)
    {
        pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
            return 0;
    }
    pXAct = WDML_ClientQueueAdvise(pConv, wType, wFmt, hszItem);
    break;
    case XTYP_ADVSTOP:
    if (pData)
    {
        pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
            return 0;
    }
    pXAct = WDML_ClientQueueUnadvise(pConv, wFmt, hszItem);
    break;
    case XTYP_REQUEST:
    if (pData || !hszItem)
    {
        pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
            return 0;
    }
    pXAct = WDML_ClientQueueRequest(pConv, wFmt, hszItem);
    break;
    default:
        FIXME("Unknown transaction type %04x\n", wType);
    /* unknown transaction type */
    pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
        return 0;
    }
 
    if (pXAct == NULL)
    {
    pConv->instance->lastError = DMLERR_MEMORY_ERROR;
        return 0;
    }
 
    WDML_QueueTransaction(pConv, pXAct);
 
    TRACE("pConv->wStatus %04lx\n", pConv->wStatus);
 
    if (pConv->wStatus & ST_BLOCKED)
    {
        TRACE("Transactions are blocked, add to the queue and exit\n");
        return (HDDEDATA)1;
    }
 
    hDdeData = WDML_ClientHandle(pConv, pXAct, dwTimeout, pdwResult);
    if (dwTimeout != TIMEOUT_ASYNC)
    {
        WDML_UnQueueTransaction(pConv, pXAct);
        WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
    }
 
    return hDdeData;
}

Referenced by dde_connect(), dde_execute(), dde_request(), DdeReconnect(), test_dde_aw_transaction(), test_ddeml_client(), test_end_to_end_client(), and test_initialisation().

DdeConnect()

HCONV WINAPI DdeConnect	(	DWORD	idInst,
		HSZ	hszService,
		HSZ	hszTopic,
		PCONVCONTEXT	pCC
	)

Definition at line 89 of file ddeclient.c.

{
    HWND        hwndClient;
    WDML_INSTANCE*  pInstance;
    WDML_CONV*      pConv;
    ATOM        aSrv = 0, aTpc = 0;
 
    TRACE("(0x%lx,%p,%p,%p)\n", idInst, hszService, hszTopic, pCC);
 
    pInstance = WDML_GetInstance(idInst);
    if (!pInstance)
        return NULL;
 
    /* make sure this conv is never created */
    pConv = WDML_FindConv(pInstance, WDML_CLIENT_SIDE, hszService, hszTopic);
    if (pConv != NULL)
    {
    ERR("This Conv already exists: (%p)\n", pConv);
    return NULL;
    }
 
    /* we need to establish a conversation with
       server, so create a window for it       */
 
    if (pInstance->unicode)
    {
        WNDCLASSEXW wndclass;
 
        wndclass.cbSize        = sizeof(wndclass);
        wndclass.style         = 0;
        wndclass.lpfnWndProc   = WDML_ClientProc;
        wndclass.cbClsExtra    = 0;
        wndclass.cbWndExtra    = 2 * sizeof(ULONG_PTR);
        wndclass.hInstance     = 0;
        wndclass.hIcon         = 0;
        wndclass.hCursor       = 0;
        wndclass.hbrBackground = 0;
        wndclass.lpszMenuName  = NULL;
        wndclass.lpszClassName = WDML_szClientConvClassW;
        wndclass.hIconSm       = 0;
 
        RegisterClassExW(&wndclass);
 
        hwndClient = CreateWindowW(WDML_szClientConvClassW, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
    }
    else
    {
        WNDCLASSEXA wndclass;
 
        wndclass.cbSize        = sizeof(wndclass);
        wndclass.style         = 0;
        wndclass.lpfnWndProc   = WDML_ClientProc;
        wndclass.cbClsExtra    = 0;
        wndclass.cbWndExtra    = 2 * sizeof(ULONG_PTR);
        wndclass.hInstance     = 0;
        wndclass.hIcon         = 0;
        wndclass.hCursor       = 0;
        wndclass.hbrBackground = 0;
        wndclass.lpszMenuName  = NULL;
        wndclass.lpszClassName = WDML_szClientConvClassA;
        wndclass.hIconSm       = 0;
 
        RegisterClassExA(&wndclass);
 
        hwndClient = CreateWindowA(WDML_szClientConvClassA, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
    }
 
    SetWindowLongPtrW(hwndClient, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
 
    if (hszService)
    {
    aSrv = WDML_MakeAtomFromHsz(hszService);
    if (!aSrv) goto theEnd;
    }
    if (hszTopic)
    {
    aTpc = WDML_MakeAtomFromHsz(hszTopic);
    if (!aTpc) goto theEnd;
    }
 
    /* note: sent messages shall not use packing */
    SendMessageTimeoutW( HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndClient, MAKELPARAM(aSrv, aTpc),
                         SMTO_ABORTIFHUNG, 0, NULL );
 
    pInstance = WDML_GetInstance(idInst);
    if (!pInstance)
    {
    goto theEnd;
    }
 
    /* At this point, Client WM_DDE_ACK should have saved hwndServer
       for this instance id and hwndClient if server responds.
       So get HCONV and return it. And add it to conv list */
    pConv = WDML_GetConvFromWnd(hwndClient);
    if (pConv == NULL || pConv->hwndServer == 0)
    {
    WARN("Done with INITIATE, but no Server window available\n");
    pConv = NULL;
    pInstance->lastError = DMLERR_NO_CONV_ESTABLISHED;
    goto theEnd;
    }
    TRACE("Connected to Server window (%p)\n", pConv->hwndServer);
    pConv->wConvst = XST_CONNECTED;
 
    /* finish init of pConv */
    if (pCC != NULL)
    {
    pConv->convContext = *pCC;
    }
    else
    {
    memset(&pConv->convContext, 0, sizeof(pConv->convContext));
    pConv->convContext.cb = sizeof(pConv->convContext);
    pConv->convContext.iCodePage = (pInstance->unicode) ? CP_WINUNICODE : CP_WINANSI;
    }
 
 theEnd:
 
    if (aSrv) GlobalDeleteAtom(aSrv);
    if (aTpc) GlobalDeleteAtom(aTpc);
    return (HCONV)pConv;
}

Referenced by dde_connect(), START_TEST(), test_dde_aw_transaction(), test_ddeml_client(), test_end_to_end_client(), and test_initialisation().

DdeConnectList()

HCONVLIST WINAPI DdeConnectList	(	DWORD	idInst,
		HSZ	hszService,
		HSZ	hszTopic,
		HCONVLIST	hConvList,
		PCONVCONTEXT	pCC
	)

Definition at line 53 of file ddeclient.c.

{
    FIXME("(%ld,%p,%p,%p,%p): stub\n", idInst, hszService, hszTopic, hConvList, pCC);
    return (HCONVLIST)1;
}

DdeDisconnect()

BOOL WINAPI DdeDisconnect

(

HCONV

hConv

)

Definition at line 1368 of file ddeclient.c.

{
    WDML_CONV*  pConv;
    WDML_XACT*  pXAct;
    BOOL    ret = FALSE;
 
    TRACE("(%p)\n", hConv);
 
    if (hConv == 0)
    {
    WARN("DdeDisconnect(): hConv = 0\n");
    return FALSE;
    }
 
    pConv = WDML_GetConv(hConv, TRUE);
    if (pConv != NULL)
    {
        if (pConv->wStatus & ST_CLIENT)
        {
            /* FIXME: should abandon all pending transactions */
            pXAct = WDML_ClientQueueTerminate(pConv);
            if (pXAct != NULL)
            {
                if (PostMessageW(pConv->hwndServer, pXAct->ddeMsg,
                                 (WPARAM)pConv->hwndClient, pXAct->lParam))
                {
                    WDML_SyncWaitTransactionReply(hConv, 10000, pXAct, NULL);
                    ret = TRUE;
                }
                else
                    pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
 
                WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
                /* still have to destroy data associated with conversation */
                WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
            }
            else
            {
                FIXME("Not implemented yet for a server side conversation\n");
            }
        }
    }
 
    return ret;
}

Referenced by dde_connect(), DdeUninitialize(), START_TEST(), test_dde_aw_transaction(), test_ddeml_client(), test_end_to_end_client(), and test_initialisation().

DdeDisconnectList()

BOOL WINAPI DdeDisconnectList

(

HCONVLIST

hConvList

)

Definition at line 80 of file ddeclient.c.

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

DdeImpersonateClient()

BOOL WINAPI DdeImpersonateClient

(

HCONV

hConv

)

Definition at line 1417 of file ddeclient.c.

{
    WDML_CONV*  pConv;
    BOOL    ret = FALSE;
 
    TRACE("(%p)\n", hConv);
 
    pConv = WDML_GetConv(hConv, TRUE);
    if (pConv)
    {
    ret = ImpersonateDdeClientWindow(pConv->hwndClient, pConv->hwndServer);
    }
    return ret;
}

DdeQueryNextServer()

HCONV WINAPI DdeQueryNextServer	(	HCONVLIST	hConvList,
		HCONV	hConvPrev
	)

Definition at line 63 of file ddeclient.c.

{
    FIXME("(%p,%p): stub\n", hConvList, hConvPrev);
    return 0;
}

DdeReconnect()

HCONV WINAPI DdeReconnect

(

HCONV

hConv

)

Definition at line 217 of file ddeclient.c.

{
    WDML_CONV*  pConv;
    WDML_CONV*  pNewConv = NULL;
    ATOM    aSrv = 0, aTpc = 0;
 
    TRACE("(%p)\n", hConv);
 
    pConv = WDML_GetConv(hConv, FALSE);
    if (pConv != NULL && (pConv->wStatus & ST_CLIENT))
    {
    BOOL    ret;
 
    /* to reestablish a connection, we have to make sure that:
     * 1/ pConv is the conversation attached to the client window (it wouldn't be
     *    if a call to DdeReconnect would have already been done...)
     *    FIXME: is this really an error ???
     * 2/ the pConv conversation had really been deconnected
     */
    if (pConv == WDML_GetConvFromWnd(pConv->hwndClient) &&
        (pConv->wStatus & ST_TERMINATED) && !(pConv->wStatus & ST_CONNECTED))
    {
        HWND    hwndClient = pConv->hwndClient;
        HWND    hwndServer = pConv->hwndServer;
 
        SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, 0);
 
        aSrv = WDML_MakeAtomFromHsz(pConv->hszService);
        aTpc = WDML_MakeAtomFromHsz(pConv->hszTopic);
        if (!aSrv || !aTpc) goto theEnd;
 
            /* note: sent messages shall not use packing */
        ret = SendMessageW(hwndServer, WM_DDE_INITIATE, (WPARAM)hwndClient,
                               MAKELPARAM(aSrv, aTpc));
 
        pConv = WDML_GetConv(hConv, FALSE);
        if (pConv == NULL)
        {
        FIXME("Should fail reconnection\n");
        goto theEnd;
        }
 
        if (ret && (pNewConv = WDML_GetConvFromWnd(pConv->hwndClient)) != NULL)
        {
        /* re-establish all links... */
        WDML_LINK* pLink;
 
        for (pLink = pConv->instance->links[WDML_CLIENT_SIDE]; pLink; pLink = pLink->next)
        {
            if (pLink->hConv == hConv)
            {
            /* try to reestablish the links... */
            DdeClientTransaction(NULL, 0, (HCONV)pNewConv, pLink->hszItem, pLink->uFmt,
                         pLink->transactionType, 1000, NULL);
            }
        }
        }
        else
        {
        /* reset the conversation as it was */
        SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
        }
    }
    }
 
 theEnd:
 
    if (aSrv) GlobalDeleteAtom(aSrv);
    if (aTpc) GlobalDeleteAtom(aTpc);
    return (HCONV)pNewConv;
}

WDML_BuildExecuteCommand()

static HGLOBAL WDML_BuildExecuteCommand ( WDML_CONV *  pConv, LPCVOID  pData, DWORD  cbData  )

static

Definition at line 554 of file ddeclient.c.

{
    HGLOBAL hMem;
    BOOL    clientUnicode, serverUnicode;
    DWORD   memSize;
 
    clientUnicode = pConv->instance->unicode;
    TRACE("client %p uses unicode = %d\n", pConv->hwndClient, clientUnicode);
    /* FIXME: how exactly Windows determines what to use for the server side? */
    serverUnicode = IsWindowUnicode(pConv->hwndServer) && IsWindowUnicode(pConv->hwndClient);
    TRACE("server %p uses unicode = %d\n", pConv->hwndServer, serverUnicode);
 
    if (clientUnicode == serverUnicode)
    {
    memSize = cbData;
    }
    else
    {
    if (clientUnicode)
    {
        memSize = WideCharToMultiByte( CP_ACP, 0, pData, cbData / sizeof(WCHAR), NULL, 0, NULL, NULL);
    }
    else
    {
        memSize = MultiByteToWideChar( CP_ACP, 0, pData, cbData, NULL, 0) * sizeof(WCHAR);
    }
    }
 
    hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, memSize);
 
    if (hMem)
    {
    LPSTR   pDst;
 
    pDst = GlobalLock(hMem);
    if (pDst)
    {
        if (clientUnicode == serverUnicode)
        {
        memcpy(pDst, pData, cbData);
        }
        else
        {
        if (clientUnicode)
        {
            WideCharToMultiByte( CP_ACP, 0, pData, cbData / sizeof(WCHAR), pDst, memSize, NULL, NULL);
        }
        else
        {
            MultiByteToWideChar( CP_ACP, 0, pData, cbData, (LPWSTR)pDst, memSize/sizeof(WCHAR));
        }
        }
 
        GlobalUnlock(hMem);
    }
    else
    {
        GlobalFree(hMem);
        hMem = 0;
    }
    }
    return hMem;
}

Referenced by WDML_ClientQueueExecute().

WDML_ClientHandle()

HDDEDATA WDML_ClientHandle	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct,
		DWORD	dwTimeout,
		LPDWORD	pdwResult
	)

Definition at line 1095 of file ddeclient.c.

{
    HDDEDATA hDdeData;
 
    if (!PostMessageW(pConv->hwndServer, pXAct->ddeMsg, (WPARAM)pConv->hwndClient, pXAct->lParam))
    {
        WARN("Failed posting message %x to %p (error=0x%lx)\n",
              pXAct->ddeMsg, pConv->hwndServer, GetLastError());
        pConv->wStatus &= ~ST_CONNECTED;
        pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
        return 0;
    }
    pXAct->dwTimeout = dwTimeout;
    /* FIXME: should set the app bits on *pdwResult */
 
    if (dwTimeout == TIMEOUT_ASYNC)
    {
        if (pdwResult)
            *pdwResult = MAKELONG(0, pXAct->xActID);
 
        hDdeData = (HDDEDATA)1;
    }
    else
        hDdeData = WDML_SyncWaitTransactionReply((HCONV)pConv, dwTimeout, pXAct, pdwResult);
 
    return hDdeData;
}

Referenced by DdeClientTransaction(), and WDML_EnableCallback().

WDML_ClientProc()

static LRESULT CALLBACK WDML_ClientProc ( HWND  hwnd, UINT  iMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1284 of file ddeclient.c.

{
    UINT    uiLo, uiHi;
    WDML_CONV*  pConv = NULL;
    HSZ     hszSrv, hszTpc;
 
    TRACE("%p %04x %08Ix %08Ix\n", hwnd, iMsg, wParam, lParam);
 
    if (iMsg == WM_DDE_ACK &&
    /* in the initial WM_INITIATE sendmessage */
    ((pConv = WDML_GetConvFromWnd(hwnd)) == NULL || pConv->wStatus == XST_INIT1))
    {
    /* In response to WM_DDE_INITIATE, save server window  */
    char        buf[256];
    WDML_INSTANCE*  pInstance;
 
        /* note: sent messages do not need packing */
    uiLo = LOWORD(lParam);
        uiHi = HIWORD(lParam);
 
    /* FIXME: convlist should be handled here */
    if (pConv)
    {
        /* we already have started the conv with a server, drop other replies */
        GlobalDeleteAtom(uiLo);
        GlobalDeleteAtom(uiHi);
            PostMessageW((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
        return 0;
    }
 
    pInstance = WDML_GetInstanceFromWnd(hwnd);
 
    hszSrv = WDML_MakeHszFromAtom(pInstance, uiLo);
    hszTpc = WDML_MakeHszFromAtom(pInstance, uiHi);
 
    pConv = WDML_AddConv(pInstance, WDML_CLIENT_SIDE, hszSrv, hszTpc, hwnd, (HWND)wParam);
 
    SetWindowLongPtrW(hwnd, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
    pConv->wStatus |= ST_CONNECTED;
    pConv->wConvst = XST_INIT1;
 
    /* check if server is handled by DDEML */
    if ((GetClassNameA((HWND)wParam, buf, sizeof(buf)) &&
         lstrcmpiA(buf, WDML_szServerConvClassA) == 0) ||
        (GetClassNameW((HWND)wParam, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
         lstrcmpiW((LPWSTR)buf, WDML_szServerConvClassW) == 0))
    {
        pConv->wStatus |= ST_ISLOCAL;
    }
 
    GlobalDeleteAtom(uiLo);
    GlobalDeleteAtom(uiHi);
 
    /* accept conversation */
    return 1;
    }
 
    if (iMsg >= WM_DDE_FIRST && iMsg <= WM_DDE_LAST)
    {
    pConv = WDML_GetConvFromWnd(hwnd);
 
    if (pConv)
    {
        MSG     msg;
        HDDEDATA    hdd;
 
        msg.hwnd = hwnd;
        msg.message = iMsg;
        msg.wParam = wParam;
        msg.lParam = lParam;
 
        WDML_HandleReply(pConv, &msg, &hdd, NULL);
    }
 
    return 0;
    }
 
    return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, iMsg, wParam, lParam) :
                                   DefWindowProcA(hwnd, iMsg, wParam, lParam);
}

Referenced by DdeConnect().

WDML_ClientQueueAdvise()

static WDML_XACT * WDML_ClientQueueAdvise ( WDML_CONV *  pConv, UINT  wType, UINT  wFmt, HSZ  hszItem  )

static

Definition at line 294 of file ddeclient.c.

{
    DDEADVISE*      pDdeAdvise;
    WDML_XACT*      pXAct;
    ATOM        atom;
 
    TRACE("XTYP_ADVSTART (with%s data) transaction\n", (wType & XTYPF_NODATA) ? "out" : "");
 
    atom = WDML_MakeAtomFromHsz(hszItem);
    if (!atom) return NULL;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE, wFmt, hszItem);
    if (!pXAct)
    {
    GlobalDeleteAtom(atom);
    return NULL;
    }
 
    pXAct->wType = wType & ~0x0F;
    pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEADVISE));
    /* FIXME: hMem is unfreed for now... should be deleted in server */
 
    /* pack DdeAdvise   */
    pDdeAdvise = GlobalLock(pXAct->hMem);
    pDdeAdvise->fAckReq   = (wType & XTYPF_ACKREQ) != 0;
    pDdeAdvise->fDeferUpd = (wType & XTYPF_NODATA) != 0;
    pDdeAdvise->cfFormat  = wFmt;
    GlobalUnlock(pXAct->hMem);
 
    pXAct->lParam = PackDDElParam(WM_DDE_ADVISE, (UINT_PTR)pXAct->hMem, atom);
 
    return pXAct;
}

Referenced by DdeClientTransaction().

WDML_ClientQueueExecute()

static WDML_XACT * WDML_ClientQueueExecute ( WDML_CONV *  pConv, LPVOID  pData, DWORD  cbData  )

static

Definition at line 623 of file ddeclient.c.

{
    WDML_XACT*  pXAct;
 
    TRACE("XTYP_EXECUTE transaction\n");
 
    if (pData == NULL)
    {
        if (cbData == (DWORD)-1)
            pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
        else
            pConv->instance->lastError = DMLERR_MEMORY_ERROR;
        return NULL;
    }
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
    if (!pXAct)
    return NULL;
 
    if (cbData == (DWORD)-1)
    {
    HDDEDATA    hDdeData = pData;
 
    pData = DdeAccessData(hDdeData, &cbData);
    if (pData)
    {
        pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
        DdeUnaccessData(hDdeData);
    }
    }
    else
    {
    pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
    }
 
    pXAct->lParam = (LPARAM)pXAct->hMem;
 
    return pXAct;
}

Referenced by DdeClientTransaction().

WDML_ClientQueuePoke()

static WDML_XACT * WDML_ClientQueuePoke ( WDML_CONV *  pConv, LPVOID  pData, DWORD  cbData, UINT  wFmt, HSZ  hszItem  )

static

Definition at line 701 of file ddeclient.c.

{
    DDE_DATAHANDLE_HEAD *dh;
    WDML_XACT *pXAct;
    DDEPOKE *ddePoke;
    HGLOBAL hglobal;
    ATOM atom;
 
    TRACE("XTYP_POKE transaction\n");
 
    atom = WDML_MakeAtomFromHsz(hszItem);
    if (!atom) return NULL;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE, wFmt, hszItem);
    if (!pXAct)
    {
        GlobalDeleteAtom(atom);
        return NULL;
    }
 
    if (cbData == (DWORD)-1)
    {
        hglobal = pData;
        dh = GlobalLock(hglobal);
        cbData = GlobalSize(hglobal) - sizeof(DDE_DATAHANDLE_HEAD);
        pData = dh + 1;
        GlobalUnlock(hglobal);
    }
 
    pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, FIELD_OFFSET(DDEPOKE, Value[cbData]));
    ddePoke = GlobalLock(pXAct->hMem);
    if (!ddePoke)
    {
        pConv->instance->lastError = DMLERR_MEMORY_ERROR;
        return NULL;
    }
 
    ddePoke->unused = 0;
    ddePoke->fRelease = TRUE;
    ddePoke->cfFormat = wFmt;
    memcpy(ddePoke->Value, pData, cbData);
    GlobalUnlock(pXAct->hMem);
 
    pXAct->lParam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)pXAct->hMem, atom);
 
    return pXAct;
}

Referenced by DdeClientTransaction().

WDML_ClientQueueRequest()

static WDML_XACT * WDML_ClientQueueRequest ( WDML_CONV *  pConv, UINT  wFmt, HSZ  hszItem  )

static

Definition at line 464 of file ddeclient.c.

{
    WDML_XACT*  pXAct;
    ATOM    atom;
 
    TRACE("XTYP_REQUEST transaction\n");
 
    atom = WDML_MakeAtomFromHsz(hszItem);
    if (!atom) return NULL;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST, wFmt, hszItem);
    if (!pXAct)
    {
    GlobalDeleteAtom(atom);
    return NULL;
    }
 
    pXAct->lParam = PackDDElParam(WM_DDE_REQUEST, wFmt, atom);
 
    return pXAct;
}

Referenced by DdeClientTransaction().

WDML_ClientQueueTerminate()

static WDML_XACT * WDML_ClientQueueTerminate ( WDML_CONV *  pConv )

static

Definition at line 786 of file ddeclient.c.

{
    WDML_XACT*      pXAct;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
    if (!pXAct)
    return NULL;
 
    pXAct->lParam = 0;
    pConv->wStatus &= ~ST_CONNECTED;
 
    return pXAct;
}

Referenced by DdeDisconnect().

WDML_ClientQueueUnadvise()

static WDML_XACT * WDML_ClientQueueUnadvise ( WDML_CONV *  pConv, UINT  wFmt, HSZ  hszItem  )

static

Definition at line 390 of file ddeclient.c.

{
    WDML_XACT*  pXAct;
    ATOM    atom;
 
    TRACE("XTYP_ADVSTOP transaction\n");
 
    atom = WDML_MakeAtomFromHsz(hszItem);
    if (!atom) return NULL;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE, wFmt, hszItem);
    if (!pXAct)
    {
    GlobalDeleteAtom(atom);
    return NULL;
    }
 
    /* end advise loop: post WM_DDE_UNADVISE to server to terminate link
     * on the specified item.
     */
    pXAct->lParam = PackDDElParam(WM_DDE_UNADVISE, wFmt, atom);
    return pXAct;
}

Referenced by DdeClientTransaction().

WDML_HandleAdviseReply()

static WDML_QUEUE_STATE WDML_HandleAdviseReply ( WDML_CONV *  pConv, MSG *  msg, WDML_XACT *  pXAct, DWORD *  ack  )

static

Definition at line 333 of file ddeclient.c.

{
    DDEACK      ddeAck;
    UINT_PTR        uiLo, uiHi;
    HSZ         hsz;
 
    if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
    {
    return WDML_QS_PASS;
    }
 
    UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
    hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 
    if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
    return WDML_QS_PASS;
 
    GlobalDeleteAtom(uiHi);
    FreeDDElParam(WM_DDE_ACK, msg->lParam);
 
    if (ack) *ack = uiLo;
    WDML_ExtractAck(uiLo, &ddeAck);
 
    if (ddeAck.fAck)
    {
    WDML_LINK*  pLink;
 
    /* billx: first to see if the link is already created. */
    pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
                  pXAct->hszItem, TRUE, pXAct->wFmt);
    if (pLink != NULL)
    {
        /* we found a link, and only need to modify it in case it changes */
        pLink->transactionType = pXAct->wType;
    }
    else
    {
        WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
             pXAct->wType, pXAct->hszItem, pXAct->wFmt);
    }
        pXAct->hDdeData = (HDDEDATA)1;
    }
    else
    {
    TRACE("Returning FALSE on XTYP_ADVSTART - fAck was FALSE\n");
    GlobalFree(pXAct->hMem);
        pXAct->hDdeData = NULL;
    }
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_HandleExecuteReply()

static WDML_QUEUE_STATE WDML_HandleExecuteReply ( WDML_CONV *  pConv, MSG *  msg, WDML_XACT *  pXAct, DWORD *  ack  )

static

Definition at line 668 of file ddeclient.c.

{
    DDEACK  ddeAck;
    UINT_PTR    uiLo, uiHi;
 
    if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
    {
    return WDML_QS_PASS;
    }
 
    UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
    FreeDDElParam(WM_DDE_ACK, msg->lParam);
 
    if ((HANDLE)uiHi != pXAct->hMem)
    {
        return WDML_QS_PASS;
    }
 
    if (ack) *ack = uiLo;
    WDML_ExtractAck(uiLo, &ddeAck);
    pXAct->hDdeData = (HDDEDATA)(UINT_PTR)ddeAck.fAck;
 
    TRACE("hDdeData = %p\n", pXAct->hDdeData);
    pConv->instance->lastError = (pXAct->hDdeData != 0) ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_HandleIncomingData()

static WDML_QUEUE_STATE WDML_HandleIncomingData ( WDML_CONV *  pConv, MSG *  msg, HDDEDATA *  hdd  )

static

Definition at line 832 of file ddeclient.c.

{
    UINT_PTR        uiLo, uiHi;
    HDDEDATA        hDdeDataIn, hDdeDataOut;
    WDML_LINK*      pLink;
    WINE_DDEHEAD    wdh;
    HSZ         hsz;
 
    TRACE("WM_DDE_DATA message received in the Client Proc!\n");
    /* wParam -- sending window handle  */
    /* lParam -- hDdeData & item HSZ    */
 
    UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
    hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 
    hDdeDataIn = WDML_Global2DataHandle(pConv, (HGLOBAL)uiLo, &wdh);
 
    /* billx:
     *  For hot link, data should be passed to its callback with
     * XTYP_ADVDATA and callback should return the proper status.
     */
    pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE, hsz,
                          uiLo != 0, wdh.cfFormat);
    if (!pLink)
    {
    WDML_DecHSZ(pConv->instance, hsz);
        DdeFreeDataHandle(hDdeDataIn);
    return WDML_QS_PASS;
    }
 
    if (hDdeDataIn != 0 && wdh.fAckReq)
    {
    WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
    if (msg->lParam)
        msg->lParam = 0;
    }
    else
    {
    GlobalDeleteAtom(uiHi);
    }
 
    hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_ADVDATA, pLink->uFmt, pLink->hConv,
                      pConv->hszTopic, pLink->hszItem, hDdeDataIn, 0, 0);
 
    if (hDdeDataOut != (HDDEDATA)DDE_FACK || wdh.fRelease)
    {
        if (uiLo) GlobalFree((HANDLE)uiLo);
    }
 
    DdeFreeDataHandle(hDdeDataIn);
 
    WDML_DecHSZ(pConv->instance, hsz);
    if (msg->lParam)
    FreeDDElParam(WM_DDE_DATA, msg->lParam);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_HandleIncomingTerminate()

static WDML_QUEUE_STATE WDML_HandleIncomingTerminate ( WDML_CONV *  pConv, MSG *  msg, HDDEDATA *  hdd  )

static

Definition at line 895 of file ddeclient.c.

{
    if (pConv->hwndServer != WIN_GetFullHandle((HWND)msg->wParam))
    return WDML_QS_PASS;
 
    pConv->wStatus |= ST_TERMINATED;
    if (pConv->wStatus & ST_CONNECTED)
    {
    /* don't care about result code (if server exists or not) */
    PostMessageW(pConv->hwndServer, WM_DDE_TERMINATE, (WPARAM)pConv->hwndClient, 0L);
    pConv->wStatus &= ~ST_CONNECTED;
    }
    /* have to keep connection around to allow reconnection */
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_HandlePokeReply()

static WDML_QUEUE_STATE WDML_HandlePokeReply ( WDML_CONV *  pConv, MSG *  msg, WDML_XACT *  pXAct, DWORD *  ack  )

static

Definition at line 755 of file ddeclient.c.

{
    UINT_PTR    uiLo, uiHi;
    HSZ     hsz;
 
    if (msg->message != WM_DDE_ACK && WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
    {
    return WDML_QS_PASS;
    }
 
    UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
    hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
    if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
    {
    return WDML_QS_PASS;
    }
    FreeDDElParam(WM_DDE_ACK, msg->lParam);
    GlobalDeleteAtom(uiHi);
 
    if (ack) *ack = uiLo;
    pXAct->hMem = GlobalFree(pXAct->hMem);
 
    pXAct->hDdeData = (HDDEDATA)TRUE;
    return TRUE;
}

Referenced by WDML_HandleReply().

WDML_HandleReply()

static WDML_QUEUE_STATE WDML_HandleReply ( WDML_CONV *  pConv, MSG *  msg, HDDEDATA *  hdd, DWORD *  ack  )

static

Definition at line 916 of file ddeclient.c.

{
    WDML_XACT*      pXAct = pConv->transactions;
    WDML_QUEUE_STATE    qs;
 
    if (pConv->transactions)
    {
    if (ack) *ack = DDE_FNOTPROCESSED;
    /* first check message against a pending transaction, if any */
    switch (pXAct->ddeMsg)
    {
    case WM_DDE_ADVISE:
        qs = WDML_HandleAdviseReply(pConv, msg, pXAct, ack);
        break;
    case WM_DDE_UNADVISE:
        qs = WDML_HandleUnadviseReply(pConv, msg, pXAct, ack);
        break;
    case WM_DDE_EXECUTE:
        qs = WDML_HandleExecuteReply(pConv, msg, pXAct, ack);
        break;
    case WM_DDE_REQUEST:
        qs = WDML_HandleRequestReply(pConv, msg, pXAct, ack);
        break;
    case WM_DDE_POKE:
        qs = WDML_HandlePokeReply(pConv, msg, pXAct, ack);
        break;
    case WM_DDE_TERMINATE:
        qs = WDML_HandleTerminateReply(pConv, msg);
        break;
    default:
        qs = WDML_QS_ERROR;
        FIXME("oooch\n");
    }
    }
    else
    {
    qs = WDML_QS_PASS;
    }
 
    /* now check the results */
    switch (qs)
    {
    case WDML_QS_ERROR:
    case WDML_QS_SWALLOWED:
    *hdd = 0;
    break;
    case WDML_QS_HANDLED:
    /* ok, we have resolved a pending transaction
     * notify callback if asynchronous.
     */
    if (pXAct->dwTimeout == TIMEOUT_ASYNC && pXAct->ddeMsg != WM_DDE_TERMINATE)
    {
        WDML_InvokeCallback(pConv->instance, XTYP_XACT_COMPLETE, pXAct->wFmt,
                (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
                pXAct->hDdeData, MAKELONG(0, pXAct->xActID), 0 /* FIXME */);
        qs = WDML_QS_PASS;
    }
    else
    {
        *hdd = pXAct->hDdeData;
    }
    break;
    case WDML_QS_PASS:
    /* no pending transaction found, try a warm/hot link or a termination request */
    switch (msg->message)
    {
    case WM_DDE_DATA:
        qs = WDML_HandleIncomingData(pConv, msg, hdd);
        break;
    case WM_DDE_TERMINATE:
        qs = WDML_HandleIncomingTerminate(pConv, msg, hdd);
        break;
        case WM_DDE_ACK:
            /* This happens at end of DdeClientTransaction XTYP_EXECUTE
             * Without this assignment, DdeClientTransaction's return value is undefined
             */
            *hdd = (HDDEDATA)TRUE;
            if (ack)
                *ack = DDE_FACK;
        break;
    }
    break;
    case WDML_QS_BLOCK:
    FIXME("shouldn't be used on client side\n");
    break;
    }
 
    return qs;
}

Referenced by WDML_ClientProc(), and WDML_SyncWaitTransactionReply().

WDML_HandleRequestReply()

static WDML_QUEUE_STATE WDML_HandleRequestReply ( WDML_CONV *  pConv, MSG *  msg, WDML_XACT *  pXAct, DWORD *  ack  )

static

Definition at line 491 of file ddeclient.c.

{
    DDEACK      ddeAck;
    WINE_DDEHEAD    wdh;
    UINT_PTR        uiLo, uiHi;
    HSZ         hsz;
 
    if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
    return WDML_QS_PASS;
 
    switch (msg->message)
    {
    case WM_DDE_ACK:
        UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
        FreeDDElParam(WM_DDE_ACK, msg->lParam);
    GlobalDeleteAtom(uiHi);
       if (ack) *ack = uiLo;
    WDML_ExtractAck(uiLo, &ddeAck);
    pXAct->hDdeData = 0;
    if (ddeAck.fAck)
        ERR("Positive answer should appear in NACK for a request, assuming negative\n");
    TRACE("Negative answer...\n");
    break;
 
    case WM_DDE_DATA:
        UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
    TRACE("Got the result (%08Ix)\n", uiLo);
 
    hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 
    if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
        return WDML_QS_PASS;
 
    pXAct->hDdeData = WDML_Global2DataHandle(pConv, (HGLOBAL)uiLo, &wdh);
    if (wdh.fRelease)
    {
        GlobalFree((HGLOBAL)uiLo);
    }
    if (wdh.fAckReq)
    {
        pConv->instance->lastError = DMLERR_MEMORY_ERROR;
    }
    else
    {
        GlobalDeleteAtom(uiHi);
            FreeDDElParam(WM_DDE_ACK, msg->lParam);
    }
    break;
 
    default:
        FreeDDElParam(msg->message, msg->lParam);
    return WDML_QS_PASS;
    }
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_HandleTerminateReply()

static WDML_QUEUE_STATE WDML_HandleTerminateReply ( WDML_CONV *  pConv, MSG *  msg  )

static

Definition at line 805 of file ddeclient.c.

{
    if (msg->message != WM_DDE_TERMINATE)
    {
    /* FIXME: should delete data passed here */
    return WDML_QS_SWALLOWED;
    }
 
    if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
    {
    FIXME("hmmm shouldn't happen\n");
    return WDML_QS_PASS;
    }
    if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
    {
    WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
                0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
    }
    WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_HandleUnadviseReply()

static WDML_QUEUE_STATE WDML_HandleUnadviseReply ( WDML_CONV *  pConv, MSG *  msg, WDML_XACT *  pXAct, DWORD *  ack  )

static

Definition at line 419 of file ddeclient.c.

{
    DDEACK  ddeAck;
    UINT_PTR    uiLo, uiHi;
    HSZ     hsz;
 
    if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
    {
    return WDML_QS_PASS;
    }
 
    UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
    hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 
    if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
    return WDML_QS_PASS;
 
    FreeDDElParam(WM_DDE_ACK, msg->lParam);
    GlobalDeleteAtom(uiHi);
 
    if (ack) *ack = uiLo;
    WDML_ExtractAck(uiLo, &ddeAck);
 
    TRACE("WM_DDE_ACK received while waiting for a timeout\n");
 
    if (!ddeAck.fAck)
    {
    TRACE("Returning FALSE on XTYP_ADVSTOP - fAck was FALSE\n");
        pXAct->hDdeData = NULL;
    }
    else
    {
    /* billx: remove the link */
    WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
            pXAct->hszItem, pXAct->wFmt);
        pXAct->hDdeData = (HDDEDATA)1;
    }
    return WDML_QS_HANDLED;
}

Referenced by WDML_HandleReply().

WDML_SyncWaitTransactionReply()

static HDDEDATA WDML_SyncWaitTransactionReply ( HCONV  hConv, DWORD  dwTimeout, const WDML_XACT *  pXAct, DWORD *  ack  )

static

Definition at line 1012 of file ddeclient.c.

{
    DWORD   start, elapsed;
    DWORD   err;
    WDML_CONV*  pConv;
 
    TRACE("Starting wait for a timeout of %ld ms\n", dwTimeout);
 
    start = GetTickCount();
    while ((elapsed = GetTickCount() - start) < dwTimeout)
    {
    /* we cannot be in the crit sect all the time because when client and server run in a
     * single process they need to share the access to the internal data
     */
    if (MsgWaitForMultipleObjects(0, NULL, FALSE,
                      dwTimeout - elapsed, QS_POSTMESSAGE) == WAIT_OBJECT_0)
    {
        MSG     msg;
 
        while (PeekMessageW(&msg, 0, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE))
        {
                HDDEDATA hdd = NULL;
 
                pConv = WDML_GetConv(hConv, FALSE);
                if (pConv == NULL)
                {
                    /* conversation no longer available... return failure */
                    return 0;
                }
                if (msg.hwnd == pConv->hwndClient)
                {
                    /* check that either pXAct has been processed or no more xActions are pending */
                    BOOL ret = (pConv->transactions == pXAct);
                    if (WDML_HandleReply(pConv, &msg, &hdd, ack) == WDML_QS_HANDLED)
                    {
                        TRACE("WDML_HandleReply returned WDML_QS_HANDLED\n");
                        ret = TRUE;
                    }
                    else
                        ret = (pConv->transactions == NULL || ret);
 
                    if (ret)
                    {
                        pConv->instance->lastError = hdd ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
                        return hdd;
                    }
                }
                else
                {
                    DispatchMessageW(&msg);
                }
            }
    }
    }
 
    TRACE("Timeout !!\n");
 
    pConv = WDML_GetConv(hConv, FALSE);
    if (pConv != NULL)
    {
    if (pConv->transactions)
    {
        switch (pConv->transactions->ddeMsg)
        {
        case WM_DDE_ADVISE:     err = DMLERR_ADVACKTIMEOUT; break;
        case WM_DDE_REQUEST:    err = DMLERR_DATAACKTIMEOUT;    break;
        case WM_DDE_EXECUTE:    err = DMLERR_EXECACKTIMEOUT;    break;
        case WM_DDE_POKE:       err = DMLERR_POKEACKTIMEOUT;    break;
        case WM_DDE_UNADVISE:   err = DMLERR_UNADVACKTIMEOUT;   break;
        default:            err = DMLERR_INVALIDPARAMETER;  break;
        }
 
        pConv->instance->lastError = err;
    }
    }
 
    return 0;
}

Referenced by DdeDisconnect(), and WDML_ClientHandle().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ddeml

)

Variable Documentation

WDML_szClientConvClassA

const char WDML_szClientConvClassA[] = "WineDdeClientA"

Definition at line 35 of file ddeclient.c.

Referenced by DdeConnect(), and WDML_ServerNameProc().

WDML_szClientConvClassW

const WCHAR WDML_szClientConvClassW[] = L"WineDdeClientW"

Definition at line 36 of file ddeclient.c.

Referenced by DdeConnect(), and WDML_ServerNameProc().