ddeserver.c File Reference

#include <user32.h>

Include dependency graph for ddeserver.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ddeml)
static LRESULT CALLBACK	WDML_ServerNameProc (HWND, UINT, WPARAM, LPARAM)
static LRESULT CALLBACK	WDML_ServerConvProc (HWND, UINT, WPARAM, LPARAM)
BOOL WINAPI	DdePostAdvise (DWORD idInst, HSZ hszTopic, HSZ hszItem)
HDDEDATA WINAPI	DdeNameService (DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
static WDML_CONV *	WDML_CreateServerConv (WDML_INSTANCE *pInstance, HWND hwndClient, HWND hwndServerName, HSZ hszApp, HSZ hszTopic)
static WDML_XACT *	WDML_ServerQueueRequest (WDML_CONV *pConv, LPARAM lParam)
static WDML_QUEUE_STATE	WDML_ServerHandleRequest (WDML_CONV *pConv, WDML_XACT *pXAct)
static WDML_XACT *	WDML_ServerQueueAdvise (WDML_CONV *pConv, LPARAM lParam)
static WDML_QUEUE_STATE	WDML_ServerHandleAdvise (WDML_CONV *pConv, WDML_XACT *pXAct)
static WDML_XACT *	WDML_ServerQueueUnadvise (WDML_CONV *pConv, LPARAM lParam)
static WDML_QUEUE_STATE	WDML_ServerHandleUnadvise (WDML_CONV *pConv, WDML_XACT *pXAct)
static WDML_XACT *	WDML_ServerQueueExecute (WDML_CONV *pConv, LPARAM lParam)
static BOOL	data_looks_unicode (const WCHAR *data, DWORD size)
static HDDEDATA	map_A_to_W (DWORD instance, void *ptr, DWORD size)
static HDDEDATA	map_W_to_A (DWORD instance, void *ptr, DWORD size)
static WDML_QUEUE_STATE	WDML_ServerHandleExecute (WDML_CONV *pConv, WDML_XACT *pXAct)
static WDML_XACT *	WDML_ServerQueuePoke (WDML_CONV *pConv, LPARAM lParam)
static WDML_QUEUE_STATE	WDML_ServerHandlePoke (WDML_CONV *pConv, WDML_XACT *pXAct)
static WDML_XACT *	WDML_ServerQueueTerminate (WDML_CONV *pConv, LPARAM lParam)
static WDML_QUEUE_STATE	WDML_ServerHandleTerminate (WDML_CONV *pConv, WDML_XACT *pXAct)
WDML_QUEUE_STATE	WDML_ServerHandle (WDML_CONV *pConv, WDML_XACT *pXAct)

Variables
const char	WDML_szServerConvClassA [] = "WineDdeServerConvA"
const WCHAR	WDML_szServerConvClassW [] = L"WineDdeServerConvW"

Function Documentation

data_looks_unicode()

static BOOL data_looks_unicode ( const WCHAR *  data, DWORD  size  )

static

Definition at line 759 of file ddeserver.c.

{
    DWORD i;
 
    if (size % sizeof(WCHAR)) return FALSE;
    for (i = 0; i < size / sizeof(WCHAR); i++) if (data[i] > 255) return FALSE;
    return TRUE;
}

Referenced by map_A_to_W(), and map_W_to_A().

DdeNameService()

HDDEDATA WINAPI DdeNameService	(	DWORD	idInst,
		HSZ	hsz1,
		HSZ	hsz2,
		UINT	afCmd
	)

Definition at line 159 of file ddeserver.c.

{
    WDML_SERVER*    pServer;
    WDML_INSTANCE*  pInstance;
    HWND        hwndServer;
    WNDCLASSEXW     wndclass;
 
    TRACE("(%ld,%p,%p,%x)\n", idInst, hsz1, hsz2, afCmd);
 
    /*  First check instance
     */
    pInstance = WDML_GetInstance(idInst);
    if  (pInstance == NULL)
    {
    TRACE("Instance not found as initialised\n");
    /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
        return NULL;
    }
 
    if (hsz2 != 0L)
    {
    /*  Illegal, reserved parameter
     */
    pInstance->lastError = DMLERR_INVALIDPARAMETER;
    WARN("Reserved parameter no-zero !!\n");
        return NULL;
    }
    if (hsz1 == 0 && !(afCmd & DNS_UNREGISTER))
    {
    /*  don't know if we should check this but it makes sense
     *  why supply REGISTER or filter flags if de-registering all
     */
    TRACE("General unregister unexpected flags\n");
    pInstance->lastError = DMLERR_INVALIDPARAMETER;
        return NULL;
    }
 
    switch (afCmd & (DNS_REGISTER | DNS_UNREGISTER))
    {
    case DNS_REGISTER:
    pServer = WDML_FindServer(pInstance, hsz1, 0);
    if (pServer)
    {
        ERR("Trying to register already registered service!\n");
        pInstance->lastError = DMLERR_DLL_USAGE;
            return NULL;
    }
 
    TRACE("Adding service name\n");
 
    WDML_IncHSZ(pInstance, hsz1);
 
    pServer = WDML_AddServer(pInstance, hsz1, 0);
 
    WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_REGISTER,
                 pServer->atomService, pServer->atomServiceSpec);
 
    wndclass.cbSize        = sizeof(wndclass);
    wndclass.style         = 0;
    wndclass.lpfnWndProc   = WDML_ServerNameProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = 2 * sizeof(ULONG_PTR);
    wndclass.hInstance     = 0;
    wndclass.hIcon         = 0;
    wndclass.hCursor       = 0;
    wndclass.hbrBackground = 0;
    wndclass.lpszMenuName  = NULL;
#ifdef __REACTOS__
    wndclass.lpszClassName = szServerNameClass;
#else
    wndclass.lpszClassName = L"WineDdeServerName";
#endif
    wndclass.hIconSm       = 0;
 
    RegisterClassExW(&wndclass);
 
#ifdef __REACTOS__
    hwndServer = CreateWindowW(szServerNameClass, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
#else
    hwndServer = CreateWindowW(L"WineDdeServerName", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    SetWindowLongPtrW(hwndServer, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
    SetWindowLongPtrW(hwndServer, GWL_WDML_SERVER, (ULONG_PTR)pServer);
    TRACE("Created nameServer=%p for instance=%08lx\n", hwndServer, idInst);
 
    pServer->hwndServer = hwndServer;
    break;
 
    case DNS_UNREGISTER:
    if (hsz1 == 0L)
    {
        /* General unregister situation
         * terminate all server side pending conversations
         */
        while (pInstance->servers)
        WDML_RemoveServer(pInstance, pInstance->servers->hszService, 0);
        pInstance->servers = NULL;
        TRACE("General de-register - finished\n");
    }
    else
    {
        WDML_RemoveServer(pInstance, hsz1, 0L);
    }
    break;
    }
 
    if (afCmd & (DNS_FILTERON | DNS_FILTEROFF))
    {
    /*  Set filter flags on to hold notifications of connection
     */
    pServer = WDML_FindServer(pInstance, hsz1, 0);
    if (!pServer)
    {
        /*  trying to filter where no service names !!
         */
        pInstance->lastError = DMLERR_DLL_USAGE;
            return NULL;
    }
    else
    {
        pServer->filterOn = (afCmd & DNS_FILTERON) != 0;
    }
    }
    return (HDDEDATA)TRUE;
}

Referenced by DdeUninitialize(), doChild(), init_dde(), release_dde(), ShellDDEInit(), test_dde_default_app(), test_ddeml_server(), and test_end_to_end_server().

DdePostAdvise()

BOOL WINAPI DdePostAdvise	(	DWORD	idInst,
		HSZ	hszTopic,
		HSZ	hszItem
	)

Definition at line 54 of file ddeserver.c.

{
    WDML_INSTANCE*  pInstance;
    WDML_LINK*      pLink;
    HDDEDATA        hDdeData;
    HGLOBAL     hItemData;
    WDML_CONV*      pConv;
    ATOM        atom;
    UINT        count;
 
    TRACE("(%ld,%p,%p)\n", idInst, hszTopic, hszItem);
 
    pInstance = WDML_GetInstance(idInst);
 
    if (pInstance == NULL)
        return FALSE;
 
    atom = WDML_MakeAtomFromHsz(hszItem);
    if (!atom) return FALSE;
 
    /* first compute the number of links which will trigger a message */
    count = 0;
    for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
    {
    if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
    {
        count++;
    }
    }
    if (count >= CADV_LATEACK)
    {
    FIXME("too high value for count\n");
    count &= 0xFFFF;
    }
 
    for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
    {
    if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
    {
        hDdeData = WDML_InvokeCallback(pInstance, XTYP_ADVREQ, pLink->uFmt, pLink->hConv,
                       hszTopic, hszItem, 0, --count, 0);
 
        if (hDdeData == CBR_BLOCK)
        {
        /* MS doc is not consistent here */
        FIXME("CBR_BLOCK returned for ADVREQ\n");
        continue;
        }
        if (hDdeData)
        {
        if (pLink->transactionType & XTYPF_NODATA)
        {
            TRACE("no data\n");
            hItemData = 0;
        }
        else
        {
            TRACE("with data\n");
 
            hItemData = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
        }
 
        pConv = WDML_GetConv(pLink->hConv, TRUE);
 
        if (pConv == NULL)
        {
            if (!WDML_IsAppOwned(hDdeData))  DdeFreeDataHandle(hDdeData);
            goto theError;
        }
 
        if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
                  PackDDElParam(WM_DDE_DATA, (UINT_PTR)hItemData, atom)))
        {
            ERR("post message failed\n");
                    pConv->wStatus &= ~ST_CONNECTED;
                    pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
            if (!WDML_IsAppOwned(hDdeData))  DdeFreeDataHandle(hDdeData);
            GlobalFree(hItemData);
            goto theError;
        }
                if (!WDML_IsAppOwned(hDdeData))  DdeFreeDataHandle(hDdeData);
        }
    }
    }
    return TRUE;
 
 theError:
    GlobalDeleteAtom(atom);
    return FALSE;
}

map_A_to_W()

static HDDEDATA map_A_to_W ( DWORD  instance, void *  ptr, DWORD  size  )

static

Definition at line 769 of file ddeserver.c.

{
    HDDEDATA ret;
    DWORD len;
    const char *end;
 
    if (!data_looks_unicode( ptr, size ))
    {
        if ((end = memchr( ptr, 0, size ))) size = end + 1 - (const char *)ptr;
        len = MultiByteToWideChar( CP_ACP, 0, ptr, size, NULL, 0 );
        ret = DdeCreateDataHandle( instance, NULL, len * sizeof(WCHAR), 0, 0, CF_TEXT, 0);
        MultiByteToWideChar( CP_ACP, 0, ptr, size, (WCHAR *)DdeAccessData(ret, NULL), len );
    }
    else ret = DdeCreateDataHandle( instance, ptr, size, 0, 0, CF_TEXT, 0 );
 
    return ret;
}

Referenced by WDML_ServerHandleExecute().

map_W_to_A()

static HDDEDATA map_W_to_A ( DWORD  instance, void *  ptr, DWORD  size  )

static

Definition at line 788 of file ddeserver.c.

{
    HDDEDATA ret;
    DWORD len;
    const WCHAR *end;
 
    if (data_looks_unicode( ptr, size ))
    {
        size /= sizeof(WCHAR);
        if ((end = wmemchr( ptr, 0, size ))) size = end + 1 - (const WCHAR *)ptr;
        len = WideCharToMultiByte( CP_ACP, 0, ptr, size, NULL, 0, NULL, NULL );
        ret = DdeCreateDataHandle( instance, NULL, len, 0, 0, CF_TEXT, 0);
        WideCharToMultiByte( CP_ACP, 0, ptr, size, (char *)DdeAccessData(ret, NULL), len, NULL, NULL );
    }
    else ret = DdeCreateDataHandle( instance, ptr, size, 0, 0, CF_TEXT, 0 );
 
    return ret;
}

Referenced by WDML_ServerHandleExecute().

WDML_CreateServerConv()

static WDML_CONV * WDML_CreateServerConv ( WDML_INSTANCE *  pInstance, HWND  hwndClient, HWND  hwndServerName, HSZ  hszApp, HSZ  hszTopic  )

static

Definition at line 290 of file ddeserver.c.

{
    HWND    hwndServerConv;
    WDML_CONV*  pConv;
 
    if (pInstance->unicode)
    {
        WNDCLASSEXW wndclass;
 
        wndclass.cbSize        = sizeof(wndclass);
        wndclass.style         = 0;
        wndclass.lpfnWndProc   = WDML_ServerConvProc;
        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_szServerConvClassW;
        wndclass.hIconSm       = 0;
 
        RegisterClassExW(&wndclass);
 
        hwndServerConv = CreateWindowW(WDML_szServerConvClassW, 0,
                       WS_CHILD, 0, 0, 0, 0,
                       hwndServerName, 0, 0, 0);
    }
    else
    {
        WNDCLASSEXA wndclass;
 
        wndclass.cbSize        = sizeof(wndclass);
        wndclass.style         = 0;
        wndclass.lpfnWndProc   = WDML_ServerConvProc;
        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_szServerConvClassA;
        wndclass.hIconSm       = 0;
 
        RegisterClassExA(&wndclass);
 
        hwndServerConv = CreateWindowA(WDML_szServerConvClassA, 0,
                                      WS_CHILD, 0, 0, 0, 0,
                                      hwndServerName, 0, 0, 0);
    }
 
    TRACE("Created convServer=%p (nameServer=%p) for instance=%08lx unicode=%d\n",
      hwndServerConv, hwndServerName, pInstance->instanceID, pInstance->unicode);
 
    pConv = WDML_AddConv(pInstance, WDML_SERVER_SIDE, hszApp, hszTopic,
             hwndClient, hwndServerConv);
    if (pConv)
    {
    SetWindowLongPtrW(hwndServerConv, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
    SetWindowLongPtrW(hwndServerConv, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
 
    /* this should be the only place using SendMessage for WM_DDE_ACK */
        /* note: sent messages shall not use packing */
    SendMessageW(hwndClient, WM_DDE_ACK, (WPARAM)hwndServerConv,
             MAKELPARAM(WDML_MakeAtomFromHsz(hszApp), WDML_MakeAtomFromHsz(hszTopic)));
    /* we assume we're connected since we've sent an answer...
     * I'm not sure what we can do... it doesn't look like the return value
     * of SendMessage is used... sigh...
     */
    pConv->wStatus |= ST_CONNECTED;
    }
    else
    {
    NtUserDestroyWindow(hwndServerConv);
    }
    return pConv;
}

Referenced by WDML_ServerNameProc().

WDML_ServerConvProc()

static LRESULT CALLBACK WDML_ServerConvProc ( HWND  hwndServer, UINT  iMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1026 of file ddeserver.c.

{
    WDML_INSTANCE*  pInstance;
    WDML_CONV*      pConv;
    WDML_XACT*      pXAct = NULL;
 
    TRACE("%p %04x %08Ix %08Ix\n", hwndServer, iMsg, wParam, lParam);
 
    if (iMsg == WM_DESTROY)
    {
    pConv = WDML_GetConvFromWnd(hwndServer);
    if (pConv && !(pConv->wStatus & ST_TERMINATED))
    {
        WDML_ServerHandleTerminate(pConv, NULL);
    }
    }
    if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
    {
        return IsWindowUnicode(hwndServer) ? DefWindowProcW(hwndServer, iMsg, wParam, lParam) :
                                             DefWindowProcA(hwndServer, iMsg, wParam, lParam);
    }
 
    pInstance = WDML_GetInstanceFromWnd(hwndServer);
    pConv = WDML_GetConvFromWnd(hwndServer);
 
    if (!pConv)
    {
    ERR("Got a message (%x) on a not known conversation, dropping request\n", iMsg);
        return 0;
    }
    if (pConv->hwndClient != WIN_GetFullHandle( (HWND)wParam ) || pConv->hwndServer != hwndServer)
    {
    ERR("mismatch between C/S windows and conversation\n");
        return 0;
    }
    if (pConv->instance != pInstance || pConv->instance == NULL)
    {
    ERR("mismatch in instances\n");
        return 0;
    }
 
    switch (iMsg)
    {
    case WM_DDE_INITIATE:
    FIXME("WM_DDE_INITIATE message received!\n");
    break;
 
    case WM_DDE_REQUEST:
    pXAct = WDML_ServerQueueRequest(pConv, lParam);
    break;
 
    case WM_DDE_ADVISE:
    pXAct = WDML_ServerQueueAdvise(pConv, lParam);
    break;
 
    case WM_DDE_UNADVISE:
    pXAct = WDML_ServerQueueUnadvise(pConv, lParam);
    break;
 
    case WM_DDE_EXECUTE:
    pXAct = WDML_ServerQueueExecute(pConv, lParam);
    break;
 
    case WM_DDE_POKE:
    pXAct = WDML_ServerQueuePoke(pConv, lParam);
    break;
 
    case WM_DDE_TERMINATE:
    pXAct = WDML_ServerQueueTerminate(pConv, lParam);
    break;
 
    case WM_DDE_ACK:
    WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
    break;
 
    default:
    FIXME("Unsupported message %x\n", iMsg);
        break;
    }
 
    if (pXAct)
    {
    pXAct->lParam = lParam;
 
    if ((pConv->wStatus & ST_BLOCKED) || WDML_ServerHandle(pConv, pXAct) == WDML_QS_BLOCK)
    {
            TRACE("Transactions are blocked, add to the queue and exit\n");
        WDML_QueueTransaction(pConv, pXAct);
    }
    else
    {
        WDML_FreeTransaction(pInstance, pXAct, TRUE);
    }
    }
    else
        pConv->instance->lastError = DMLERR_MEMORY_ERROR;
 
    return 0;
}

Referenced by WDML_CreateServerConv().

WDML_ServerHandle()

WDML_QUEUE_STATE WDML_ServerHandle	(	WDML_CONV *	pConv,
		WDML_XACT *	pXAct
	)

Definition at line 978 of file ddeserver.c.

{
    WDML_QUEUE_STATE    qs = WDML_QS_ERROR;
 
    switch (pXAct->ddeMsg)
    {
    case WM_DDE_INITIATE:
    FIXME("WM_DDE_INITIATE shouldn't be there!\n");
    break;
    case WM_DDE_REQUEST:
    qs = WDML_ServerHandleRequest(pConv, pXAct);
    break;
 
    case WM_DDE_ADVISE:
    qs = WDML_ServerHandleAdvise(pConv, pXAct);
    break;
 
    case WM_DDE_UNADVISE:
    qs = WDML_ServerHandleUnadvise(pConv, pXAct);
    break;
 
    case WM_DDE_EXECUTE:
    qs = WDML_ServerHandleExecute(pConv, pXAct);
    break;
 
    case WM_DDE_POKE:
    qs = WDML_ServerHandlePoke(pConv, pXAct);
    break;
 
    case WM_DDE_TERMINATE:
    qs = WDML_ServerHandleTerminate(pConv, pXAct);
    break;
 
    case WM_DDE_ACK:
    WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
    break;
 
    default:
    FIXME("Unsupported message %d\n", pXAct->ddeMsg);
    }
    return qs;
}

Referenced by WDML_EnableCallback(), and WDML_ServerConvProc().

WDML_ServerHandleAdvise()

static WDML_QUEUE_STATE WDML_ServerHandleAdvise ( WDML_CONV *  pConv, WDML_XACT *  pXAct  )

static

Definition at line 620 of file ddeserver.c.

{
    UINT        uType;
    WDML_LINK*      pLink;
    DDEADVISE*      pDdeAdvise;
    HDDEDATA        hDdeData = 0;
    BOOL        fAck = TRUE;
 
    pDdeAdvise = GlobalLock(pXAct->hMem);
    uType = XTYP_ADVSTART |
        (pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
        (pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
 
    if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
    {
    hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_ADVSTART, pDdeAdvise->cfFormat,
                       (HCONV)pConv, pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
    }
 
    switch ((ULONG_PTR)hDdeData)
    {
    case 0:
    TRACE("No data returned from the Callback\n");
    fAck = FALSE;
    break;
 
    case (ULONG_PTR)CBR_BLOCK:
    return WDML_QS_BLOCK;
 
    default:
    /* billx: first to see if the link is already created. */
    pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
                  pXAct->hszItem, TRUE, pDdeAdvise->cfFormat);
 
    if (pLink != NULL)
    {
        /* we found a link, and only need to modify it in case it changes */
        pLink->transactionType = uType;
    }
    else
    {
        TRACE("Adding Link with hConv %p\n", pConv);
        WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
             uType, pXAct->hszItem, pDdeAdvise->cfFormat);
    }
    break;
    }
 
    GlobalUnlock(pXAct->hMem);
    if (fAck)
    {
    GlobalFree(pXAct->hMem);
    }
    pXAct->hMem = 0;
 
    WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_ADVISE);
 
    WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_ServerHandle().

WDML_ServerHandleExecute()

static WDML_QUEUE_STATE WDML_ServerHandleExecute ( WDML_CONV *  pConv, WDML_XACT *  pXAct  )

static

Definition at line 812 of file ddeserver.c.

{
    HDDEDATA    hDdeData = DDE_FNOTPROCESSED;
    BOOL    fAck = FALSE, fBusy = FALSE;
 
    if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
    {
    LPVOID  ptr = GlobalLock(pXAct->hMem);
        DWORD size = GlobalSize(pXAct->hMem);
 
    if (ptr)
    {
            if (pConv->instance->unicode)  /* Unicode server, try to map A->W */
                hDdeData = map_A_to_W( pConv->instance->instanceID, ptr, size );
            else if (!IsWindowUnicode( pConv->hwndClient )) /* ANSI server and client, try to map W->A */
                hDdeData = map_W_to_A( pConv->instance->instanceID, ptr, size );
            else
                hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, ptr, size, 0, 0, CF_TEXT, 0);
        GlobalUnlock(pXAct->hMem);
    }
    hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
                       pConv->hszTopic, 0, hDdeData, 0L, 0L);
    }
 
    switch ((ULONG_PTR)hDdeData)
    {
    case (ULONG_PTR)CBR_BLOCK:
    return WDML_QS_BLOCK;
 
    case DDE_FACK:
    fAck = TRUE;
    break;
    case DDE_FBUSY:
    fBusy = TRUE;
    break;
    default:
    FIXME("Unsupported returned value %p\n", hDdeData);
    /* fall through */
    case DDE_FNOTPROCESSED:
    break;
    }
    WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, (UINT_PTR)pXAct->hMem, 0, 0);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_ServerHandle().

WDML_ServerHandlePoke()

static WDML_QUEUE_STATE WDML_ServerHandlePoke ( WDML_CONV *  pConv, WDML_XACT *  pXAct  )

static

Definition at line 885 of file ddeserver.c.

{
    DDEPOKE*        pDdePoke;
    HDDEDATA        hDdeData;
    BOOL        fBusy = FALSE, fAck = FALSE;
 
    pDdePoke = GlobalLock(pXAct->hMem);
    if (!pDdePoke)
    {
    return WDML_QS_ERROR;
    }
 
    if (!(pConv->instance->CBFflags & CBF_FAIL_POKES))
    {
    hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, pDdePoke->Value,
                       GlobalSize(pXAct->hMem) - FIELD_OFFSET(DDEPOKE, Value),
                       0, 0, pDdePoke->cfFormat, 0);
    if (hDdeData)
    {
        HDDEDATA    hDdeDataOut;
 
        hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_POKE, pDdePoke->cfFormat,
                          (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
                          hDdeData, 0, 0);
        switch ((ULONG_PTR)hDdeDataOut)
        {
        case DDE_FACK:
        fAck = TRUE;
        break;
        case DDE_FBUSY:
        fBusy = TRUE;
        break;
        default:
        FIXME("Unsupported returned value %p\n", hDdeDataOut);
        /* fal through */
        case DDE_FNOTPROCESSED:
        break;
        }
        DdeFreeDataHandle(hDdeData);
    }
    }
    GlobalUnlock(pXAct->hMem);
 
    if (!fAck)
    {
    GlobalFree(pXAct->hMem);
    }
    WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->atom, pXAct->lParam, WM_DDE_POKE);
 
    WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_ServerHandle().

WDML_ServerHandleRequest()

static WDML_QUEUE_STATE WDML_ServerHandleRequest ( WDML_CONV *  pConv, WDML_XACT *  pXAct  )

static

Definition at line 544 of file ddeserver.c.

{
    HDDEDATA        hDdeData = 0;
    BOOL        fAck = TRUE;
 
    if (!(pConv->instance->CBFflags & CBF_FAIL_REQUESTS))
    {
 
    hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_REQUEST, pXAct->wFmt, (HCONV)pConv,
                       pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
    }
 
    switch ((ULONG_PTR)hDdeData)
    {
    case 0:
    TRACE("No data returned from the Callback\n");
    fAck = FALSE;
    break;
 
    case (ULONG_PTR)CBR_BLOCK:
    return WDML_QS_BLOCK;
 
    default:
        {
        HGLOBAL hMem = WDML_DataHandle2Global(hDdeData, TRUE, FALSE, FALSE, FALSE);
        if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
                  ReuseDDElParam(pXAct->lParam, WM_DDE_REQUEST, WM_DDE_DATA,
                         (UINT_PTR)hMem, (UINT_PTR)pXAct->atom)))
        {
                pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
        DdeFreeDataHandle(hDdeData);
        GlobalFree(hMem);
        fAck = FALSE;
        }
    }
    break;
    }
 
    WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_REQUEST);
 
    WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_ServerHandle().

WDML_ServerHandleTerminate()

static WDML_QUEUE_STATE WDML_ServerHandleTerminate ( WDML_CONV *  pConv, WDML_XACT *  pXAct  )

static

Definition at line 957 of file ddeserver.c.

{
    /* billx: two things to remove: the conv, and associated links.
     * Respond with another WM_DDE_TERMINATE iMsg.
     */
    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);
    }
    PostMessageW(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
    WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_ServerConvProc(), and WDML_ServerHandle().

WDML_ServerHandleUnadvise()

static WDML_QUEUE_STATE WDML_ServerHandleUnadvise ( WDML_CONV *  pConv, WDML_XACT *  pXAct  )

static

Definition at line 705 of file ddeserver.c.

{
    WDML_LINK*  pLink;
 
    if (pXAct->hszItem == NULL || pXAct->wFmt == 0)
    {
    ERR("Unsupported yet options (null item or clipboard format)\n");
    return WDML_QS_ERROR;
    }
 
    pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
              pXAct->hszItem, TRUE, pXAct->wFmt);
    if (pLink == NULL)
    {
    ERR("Couldn't find link for %p, dropping request\n", pXAct->hszItem);
    FreeDDElParam(WM_DDE_UNADVISE, pXAct->lParam);
    return WDML_QS_ERROR;
    }
 
    if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
    {
    WDML_InvokeCallback(pConv->instance, XTYP_ADVSTOP, pXAct->wFmt, (HCONV)pConv,
                pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
    }
 
    WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
            pXAct->hszItem, pXAct->wFmt);
 
    /* send back ack */
    WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, TRUE, pXAct->atom,
                 pXAct->lParam, WM_DDE_UNADVISE);
 
    WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 
    return WDML_QS_HANDLED;
}

Referenced by WDML_ServerHandle().

WDML_ServerNameProc()

static LRESULT CALLBACK WDML_ServerNameProc ( HWND  hwndServer, UINT  iMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 375 of file ddeserver.c.

{
    HWND        hwndClient;
    HSZ         hszApp, hszTop;
    HDDEDATA        hDdeData;
    WDML_INSTANCE*  pInstance;
    UINT_PTR        uiLo, uiHi;
 
    switch (iMsg)
    {
    case WM_DDE_INITIATE:
 
    /* wParam         -- sending window handle
       LOWORD(lParam) -- application atom
       HIWORD(lParam) -- topic atom */
 
    TRACE("WM_DDE_INITIATE message received!\n");
    hwndClient = (HWND)wParam;
 
    pInstance = WDML_GetInstanceFromWnd(hwndServer);
    if (!pInstance) return 0;
    TRACE("idInst=%ld, threadID=0x%lx\n", pInstance->instanceID, GetCurrentThreadId());
 
    /* don't free DDEParams, since this is a broadcast */
    UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
 
    hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
    hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
 
    if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
    {
        BOOL        self = FALSE;
        CONVCONTEXT     cc;
        CONVCONTEXT*    pcc = NULL;
        WDML_CONV*      pConv;
        char        buf[256];
 
        if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
        WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
        {
        self = TRUE;
        }
        /* FIXME: so far, we don't grab distant convcontext, so only check if remote is
         * handled under DDEML, and if so build a default context
         */
           if ((GetClassNameA(hwndClient, buf, sizeof(buf)) &&
                lstrcmpiA(buf, WDML_szClientConvClassA) == 0) ||
               (GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
                lstrcmpiW((LPWSTR)buf, WDML_szClientConvClassW) == 0))
        {
        pcc = &cc;
        memset(pcc, 0, sizeof(*pcc));
        pcc->cb = sizeof(*pcc);
        pcc->iCodePage = IsWindowUnicode(hwndClient) ? CP_WINUNICODE : CP_WINANSI;
        }
        if ((pInstance->CBFflags & CBF_FAIL_SELFCONNECTIONS) && self)
        {
        TRACE("Don't do self connection as requested\n");
        }
        else if (hszApp && hszTop)
        {
        WDML_SERVER*    pServer = (WDML_SERVER*)GetWindowLongPtrW(hwndServer, GWL_WDML_SERVER);
 
        /* check filters for name service */
        if (!pServer->filterOn || DdeCmpStringHandles(pServer->hszService, hszApp) == 0)
        {
            /* pass on to the callback  */
            hDdeData = WDML_InvokeCallback(pInstance, XTYP_CONNECT,
                           0, 0, hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
            if ((ULONG_PTR)hDdeData)
            {
            pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
                              hszApp, hszTop);
                        if (pConv)
                        {
                            if (pcc) pConv->wStatus |= ST_ISLOCAL;
                            WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
                                                hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
                        }
            }
        }
        }
        else if (pInstance->servers)
        {
        /* pass on to the callback  */
        hDdeData = WDML_InvokeCallback(pInstance, XTYP_WILDCONNECT,
                           0, 0, hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
 
        if (hDdeData == CBR_BLOCK)
        {
            /* MS doc is not consistent here */
            FIXME("CBR_BLOCK returned for WILDCONNECT\n");
        }
        else if ((ULONG_PTR)hDdeData != 0)
        {
            HSZPAIR*    hszp;
 
            hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
            if (hszp)
            {
            int i;
            for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
            {
                pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
                              hszp[i].hszSvc, hszp[i].hszTopic);
                            if (pConv)
                            {
                                if (pcc) pConv->wStatus |= ST_ISLOCAL;
                                WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
                                                    hszp[i].hszTopic, hszp[i].hszSvc, 0, (ULONG_PTR)pcc, self);
                            }
            }
            DdeUnaccessData(hDdeData);
            }
                    if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
        }
        }
    }
 
    return 0;
 
    case WM_DDE_REQUEST:
    FIXME("WM_DDE_REQUEST message received!\n");
    return 0;
    case WM_DDE_ADVISE:
    FIXME("WM_DDE_ADVISE message received!\n");
    return 0;
    case WM_DDE_UNADVISE:
    FIXME("WM_DDE_UNADVISE message received!\n");
    return 0;
    case WM_DDE_EXECUTE:
    FIXME("WM_DDE_EXECUTE message received!\n");
    return 0;
    case WM_DDE_POKE:
    FIXME("WM_DDE_POKE message received!\n");
    return 0;
    case WM_DDE_TERMINATE:
    FIXME("WM_DDE_TERMINATE message received!\n");
    return 0;
    default:
    break;
    }
 
    return DefWindowProcW(hwndServer, iMsg, wParam, lParam);
}

Referenced by DdeNameService().

WDML_ServerQueueAdvise()

static WDML_XACT * WDML_ServerQueueAdvise ( WDML_CONV *  pConv, LPARAM  lParam  )

static

Definition at line 594 of file ddeserver.c.

{
    UINT_PTR        uiLo, uiHi;
    WDML_XACT*      pXAct;
 
    /* XTYP_ADVSTART transaction:
       establish link and save link info to InstanceInfoTable */
 
    if (!UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi))
    return NULL;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE,
                  0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
    if (pXAct)
    {
    pXAct->hMem = (HGLOBAL)uiLo;
    pXAct->atom = uiHi;
    }
    return pXAct;
}

Referenced by WDML_ServerConvProc().

WDML_ServerQueueExecute()

static WDML_XACT * WDML_ServerQueueExecute ( WDML_CONV *  pConv, LPARAM  lParam  )

static

Definition at line 747 of file ddeserver.c.

{
    WDML_XACT*  pXAct;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
    if (pXAct)
    {
    pXAct->hMem    = (HGLOBAL)lParam;
    }
    return pXAct;
}

Referenced by WDML_ServerConvProc().

WDML_ServerQueuePoke()

static WDML_XACT * WDML_ServerQueuePoke ( WDML_CONV *  pConv, LPARAM  lParam  )

static

Definition at line 863 of file ddeserver.c.

{
    UINT_PTR        uiLo, uiHi;
    WDML_XACT*      pXAct;
 
    UnpackDDElParam(WM_DDE_POKE, lParam, &uiLo, &uiHi);
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE,
                  0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
    if (pXAct)
    {
    pXAct->atom = uiHi;
    pXAct->hMem = (HGLOBAL)uiLo;
    }
    return pXAct;
}

Referenced by WDML_ServerConvProc().

WDML_ServerQueueRequest()

static WDML_XACT * WDML_ServerQueueRequest ( WDML_CONV *  pConv, LPARAM  lParam  )

static

Definition at line 526 of file ddeserver.c.

{
    UINT_PTR        uiLo, uiHi;
    WDML_XACT*      pXAct;
 
    UnpackDDElParam(WM_DDE_REQUEST, lParam, &uiLo, &uiHi);
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST,
                  uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
    if (pXAct) pXAct->atom = uiHi;
    return pXAct;
}

Referenced by WDML_ServerConvProc().

WDML_ServerQueueTerminate()

static WDML_XACT * WDML_ServerQueueTerminate ( WDML_CONV *  pConv, LPARAM  lParam  )

static

Definition at line 944 of file ddeserver.c.

{
    WDML_XACT*  pXAct;
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
    return pXAct;
}

Referenced by WDML_ServerConvProc().

WDML_ServerQueueUnadvise()

static WDML_XACT * WDML_ServerQueueUnadvise ( WDML_CONV *  pConv, LPARAM  lParam  )

static

Definition at line 687 of file ddeserver.c.

{
    UINT_PTR        uiLo, uiHi;
    WDML_XACT*      pXAct;
 
    UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
 
    pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE,
                  uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
    if (pXAct) pXAct->atom = uiHi;
    return pXAct;
}

Referenced by WDML_ServerConvProc().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ddeml

)

Variable Documentation

WDML_szServerConvClassA

const char WDML_szServerConvClassA[] = "WineDdeServerConvA"

Definition at line 35 of file ddeserver.c.

Referenced by WDML_ClientProc(), and WDML_CreateServerConv().

WDML_szServerConvClassW

const WCHAR WDML_szServerConvClassW[] = L"WineDdeServerConvW"

Definition at line 36 of file ddeserver.c.

Referenced by WDML_ClientProc(), and WDML_CreateServerConv().