ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/user/dde/server.c

926 lines
25 KiB
C
Raw Blame History

/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* DDEML library
*
* Copyright 1997 Alexandre Julliard
* Copyright 1997 Len White
* Copyright 1999 Keith Matthews
* Copyright 2000 Corel
* Copyright 2001 Eric Pouech
*/
#include <string.h>
#include "winbase.h"
#include "windef.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "dde.h"
#include "ddeml.h"
#include "debugtools.h"
#include "dde/dde_private.h"
DEFAULT_DEBUG_CHANNEL(ddeml);
static const char szServerNameClassA[] = "DdeServerNameAnsi";
static const char szServerConvClassA[] = "DdeServerConvAnsi";
static LRESULT CALLBACK WDML_ServerNameProc(HWND, UINT, WPARAM, LPARAM);
static LRESULT CALLBACK WDML_ServerConvProc(HWND, UINT, WPARAM, LPARAM);
/******************************************************************************
* DdePostAdvise [USER32.@] Send transaction to DDE callback function.
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
BOOL WINAPI DdePostAdvise(
DWORD idInst, /* [in] Instance identifier */
HSZ hszTopic, /* [in] Handle to topic name string */
HSZ hszItem) /* [in] Handle to item name string */
{
WDML_INSTANCE* thisInstance = NULL;
WDML_LINK* pLink = NULL;
HDDEDATA hDdeData = 0, hItemData = 0;
WDML_CONV* pConv = NULL;
CHAR pszTopic[MAX_BUFFER_LEN];
CHAR pszItem[MAX_BUFFER_LEN];
TRACE("(%ld,%ld,%ld)\n",idInst,(DWORD)hszTopic,(DWORD)hszItem);
if (idInst == 0)
{
return FALSE;
}
thisInstance = WDML_FindInstance(idInst);
if (thisInstance == NULL || thisInstance->links == NULL)
{
return FALSE;
}
GlobalGetAtomNameA(hszTopic, (LPSTR)pszTopic, MAX_BUFFER_LEN);
GlobalGetAtomNameA(hszItem, (LPSTR)pszItem, MAX_BUFFER_LEN);
for (pLink = thisInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
{
if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
{
hDdeData = 0;
if (thisInstance->callback != NULL /* && thisInstance->Process_id == GetCurrentProcessId()*/)
{
TRACE("Calling the callback, type=XTYP_ADVREQ, CB=0x%lx, hConv=0x%lx, Topic=%s, Item=%s\n",
(DWORD)thisInstance->callback, (DWORD)pLink->hConv, pszTopic, pszItem);
hDdeData = (thisInstance->callback)(XTYP_ADVREQ,
pLink->uFmt,
pLink->hConv,
hszTopic,
hszItem,
0, 0, 0);
TRACE("Callback was called\n");
}
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);
if (pConv == NULL ||
!PostMessageA(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
PackDDElParam(WM_DDE_DATA, (UINT)hItemData, (DWORD)hszItem)))
{
ERR("post message failed\n");
DdeFreeDataHandle(hDdeData);
return FALSE;
}
}
}
}
return TRUE;
}
/******************************************************************************
* DdeNameService [USER32.@] {Un}registers service name of DDE server
*
* PARAMS
* idInst [I] Instance identifier
* hsz1 [I] Handle to service name string
* hsz2 [I] Reserved
* afCmd [I] Service name flags
*
* RETURNS
* Success: Non-zero
* Failure: 0
*/
HDDEDATA WINAPI DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
{
WDML_SERVER* pServer;
WDML_SERVER* pServerTmp;
WDML_INSTANCE* thisInstance;
HDDEDATA hDdeData;
HSZ hsz2nd = 0;
HWND hwndServer;
WNDCLASSEXA wndclass;
hDdeData = (HDDEDATA)NULL;
TRACE("(%ld,%d,%d,%d): stub\n",idInst,hsz1,hsz2,afCmd);
if (WDML_MaxInstanceID == 0)
{
/* Nothing has been initialised - exit now !
* needs something for DdeGetLastError */
return 0;
}
if (!WDML_WaitForMutex(handle_mutex))
{
/* FIXME: setError DMLERR_SYS_ERROR; */
return 0;
}
/* First check instance
*/
thisInstance = WDML_FindInstance(idInst);
if (thisInstance == NULL)
{
TRACE("Instance not found as initialised\n");
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
return FALSE;
}
if (hsz2 != 0L)
{
/* Illegal, reserved parameter
*/
thisInstance->lastError = DMLERR_INVALIDPARAMETER;
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
FIXME("Reserved parameter no-zero !!\n");
return FALSE;
}
if (hsz1 == 0L)
{
/*
* General unregister situation
*/
if (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");
thisInstance->lastError = DMLERR_DLL_USAGE;
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return FALSE;
}
/* Loop to find all registered service and de-register them
*/
if (thisInstance->servers == NULL)
{
/* None to unregister !!
*/
TRACE("General de-register - nothing registered\n");
thisInstance->lastError = DMLERR_DLL_USAGE;
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return FALSE;
}
else
{
pServer = thisInstance->servers;
while (pServer != NULL)
{
TRACE("general deregister - iteration\n");
pServerTmp = pServer;
pServer = pServer->next;
WDML_ReleaseAtom(thisInstance, pServerTmp->hszService);
/* finished - release heap space used as work store */
HeapFree(GetProcessHeap(), 0, pServerTmp);
}
thisInstance->servers = NULL;
TRACE("General de-register - finished\n");
}
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return (HDDEDATA)TRUE;
}
TRACE("Specific name action detected\n");
if (afCmd & DNS_REGISTER)
{
/* Register new service name
*/
pServer = WDML_FindServer(thisInstance, hsz1, 0);
if (pServer)
ERR("Trying to register already registered service!\n");
else
{
TRACE("Adding service name\n");
WDML_ReserveAtom(thisInstance, hsz1);
pServer = WDML_AddServer(thisInstance, hsz1, 0);
WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_REGISTER, hsz1, hsz2nd);
}
wndclass.cbSize = sizeof(wndclass);
wndclass.style = 0;
wndclass.lpfnWndProc = WDML_ServerNameProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 2 * sizeof(DWORD);
wndclass.hInstance = 0;
wndclass.hIcon = 0;
wndclass.hCursor = 0;
wndclass.hbrBackground = 0;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = szServerNameClassA;
wndclass.hIconSm = 0;
RegisterClassExA(&wndclass);
hwndServer = CreateWindowA(szServerNameClassA, NULL,
WS_POPUP, 0, 0, 0, 0,
0, 0, 0, 0);
SetWindowLongA(hwndServer, 0, (DWORD)thisInstance);
TRACE("Created nameServer=%04x for instance=%08lx\n", hwndServer, idInst);
pServer->hwndServer = hwndServer;
}
if (afCmd & DNS_UNREGISTER)
{
TRACE("Broadcasting WM_DDE_TERMINATE message\n");
SendMessageA(HWND_BROADCAST, WM_DDE_TERMINATE, (WPARAM)NULL,
PackDDElParam(WM_DDE_TERMINATE, (UINT)hsz1, (UINT)hsz2));
WDML_RemoveServer(thisInstance, hsz1, hsz2);
}
if (afCmd & DNS_FILTERON)
{
/* Set filter flags on to hold notifications of connection
*
* test coded this way as this is the default setting
*/
pServer = WDML_FindServer(thisInstance, hsz1, 0);
if (!pServer)
{
/* trying to filter where no service names !!
*/
thisInstance->lastError = DMLERR_DLL_USAGE;
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return FALSE;
}
else
{
pServer->filterOn = TRUE;
}
}
if (afCmd & DNS_FILTEROFF)
{
/* Set filter flags on to hold notifications of connection
*/
pServer = WDML_FindServer(thisInstance, hsz1, 0);
if (!pServer)
{
/* trying to filter where no service names !!
*/
thisInstance->lastError = DMLERR_DLL_USAGE;
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return FALSE;
}
else
{
pServer->filterOn = FALSE;
}
}
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return (HDDEDATA)TRUE;
}
/******************************************************************
* WDML_CreateServerConv
*
*
*/
static BOOL WDML_CreateServerConv(WDML_INSTANCE* thisInstance, HWND hwndClient, HWND hwndServerName,
HSZ hszApp, HSZ hszTopic)
{
WNDCLASSEXA wndclass;
HWND hwndServerConv;
WDML_CONV* pConv;
wndclass.cbSize = sizeof(wndclass);
wndclass.style = 0;
wndclass.lpfnWndProc = WDML_ServerConvProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 2 * sizeof(DWORD);
wndclass.hInstance = 0;
wndclass.hIcon = 0;
wndclass.hCursor = 0;
wndclass.hbrBackground = 0;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = szServerConvClassA;
wndclass.hIconSm = 0;
RegisterClassExA(&wndclass);
hwndServerConv = CreateWindowA(szServerConvClassA, 0,
WS_CHILD, 0, 0, 0, 0,
hwndServerName, 0, 0, 0);
TRACE("Created convServer=%04x (nameServer=%04x) for instance=%08lx\n",
hwndServerConv, hwndServerName, thisInstance->instanceID);
pConv = WDML_AddConv(thisInstance, WDML_SERVER_SIDE, hszApp, hszTopic, hwndClient, hwndServerConv);
SetWindowLongA(hwndServerConv, 0, (DWORD)thisInstance);
SetWindowLongA(hwndServerConv, 4, (DWORD)pConv);
/* this should be the only place using SendMessage for WM_DDE_ACK */
SendMessageA(hwndClient, WM_DDE_ACK, (WPARAM)hwndServerConv,
PackDDElParam(WM_DDE_ACK, (UINT)hszApp, (UINT)hszTopic));
#if 0
if (thisInstance && thisInstance->callback != NULL /*&& thisInstance->Process_id == GetCurrentProcessId()*/)
{
/* confirm connection...
* FIXME: a better way would be to check for any incoming message if the conversation
* exists (and/or) has been confirmed...
* Anyway, always pretend we use a connection from a different instance...
*/
(thisInstance->callback)(XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv, hszApp, hszTopic, 0, 0, 0);
}
#endif
return TRUE;
}
/******************************************************************
* WDML_ServerNameProc
*
*
*/
static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
HWND hwndClient;
HSZ hszApp, hszTop;
HDDEDATA hDdeData = 0;
WDML_INSTANCE* thisInstance;
UINT uiLow, 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 in the Server Proc!\n");
hwndClient = (HWND)wParam;
/* don't free DDEParams, since this is a broadcast */
UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLow, &uiHi);
hszApp = (HSZ)uiLow;
hszTop = (HSZ)uiHi;
thisInstance = (WDML_INSTANCE*)GetWindowLongA(hwndServer, 0);
TRACE("idInst=%ld, ProcessID=0x%lx\n", thisInstance->instanceID, GetCurrentProcessId());
if (hszApp && hszTop)
{
/* pass on to the callback */
if (thisInstance && thisInstance->callback != NULL /*&& thisInstance->Process_id == GetCurrentProcessId()*/)
{
TRACE("calling the Callback, type = XTYP_CONNECT, CB=0x%lx\n",
(DWORD)thisInstance->callback);
hDdeData = (thisInstance->callback)(XTYP_CONNECT,
0, 0,
hszTop,
hszApp,
0, 0, 0);
if ((UINT)hDdeData)
{
WDML_CreateServerConv(thisInstance, hwndClient, hwndServer, hszApp, hszTop);
}
}
}
else
{
/* pass on to the callback */
if (thisInstance && thisInstance->callback != NULL /*&& thisInstance->Process_id == GetCurrentProcessId()*/)
{
TRACE("calling the Callback, type=XTYP_WILDCONNECT, CB=0x%lx\n",
(DWORD)thisInstance->callback);
hDdeData = (thisInstance->callback)(XTYP_WILDCONNECT,
0, 0,
hszTop,
hszApp,
0, 0, 0);
if ((UINT)hDdeData)
{
HSZPAIR* hszp;
hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
if (hszp)
{
int i;
for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
{
WDML_CreateServerConv(thisInstance, hwndClient, hwndServer,
hszp[i].hszSvc, hszp[i].hszTopic);
}
DdeUnaccessData(hDdeData);
}
}
}
}
/*
billx: make a conv and add it to the server list -
this can be delayed when link is created for the conv. NO NEED !!!
*/
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;
}
return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
}
/******************************************************************
* WDML_ServerHandleRequest
*
*
*/
static LRESULT WDML_ServerHandleRequest(WDML_INSTANCE* thisInstance, WDML_CONV* pConv,
HWND hwndServer, HWND hwndClient, LPARAM lParam)
{
UINT uiLow, uiHi;
HSZ hszItem;
HDDEDATA hDdeData;
TRACE("(%04x %04x %08lx)!\n", hwndServer, hwndClient, lParam);
UnpackDDElParam(WM_DDE_REQUEST, lParam, &uiLow, &uiHi);
hszItem = (HSZ)uiHi;
hDdeData = 0;
if (thisInstance && thisInstance->callback != NULL /* && thisInstance->Process_id == GetCurrentProcessId() */)
{
TRACE("calling the Callback, idInst=%ld, CB=0x%lx, uType=0x%x\n",
thisInstance->instanceID, (DWORD)thisInstance->callback, XTYP_REQUEST);
hDdeData = (thisInstance->callback)(XTYP_REQUEST, uiLow, (HCONV)pConv,
pConv->hszTopic, hszItem, 0, 0, 0);
}
if (hDdeData)
{
HGLOBAL hMem = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
if (!PostMessageA(hwndClient, WM_DDE_DATA, (WPARAM)hwndServer,
ReuseDDElParam(lParam, WM_DDE_REQUEST, WM_DDE_DATA, (UINT)hMem, (UINT)hszItem)))
{
DdeFreeDataHandle(hDdeData);
GlobalFree(hMem);
}
}
else
{
DDEACK ddeAck;
ddeAck.bAppReturnCode = 0;
ddeAck.reserved = 0;
ddeAck.fBusy = FALSE;
ddeAck.fAck = FALSE;
TRACE("Posting a %s ack\n", ddeAck.fAck ? "positive" : "negative");
PostMessageA(hwndClient, WM_DDE_ACK, (WPARAM)hwndServer,
ReuseDDElParam(lParam, WM_DDE_REQUEST, WM_DDE_ACK, *((WORD*)&ddeAck), (UINT)hszItem));
}
return 0;
}
/******************************************************************
* WDML_ServerHandleAdvise
*
*
*/
static LRESULT WDML_ServerHandleAdvise(WDML_INSTANCE* thisInstance, WDML_CONV* pConv,
HWND hwndServer, HWND hwndClient, LPARAM lParam)
{
UINT uiLo, uiHi, uType;
HGLOBAL hDdeAdvise;
HSZ hszItem;
WDML_LINK* pLink;
DDEADVISE* pDdeAdvise;
HDDEDATA hDdeData;
DDEACK ddeAck;
/* XTYP_ADVSTART transaction:
establish link and save link info to InstanceInfoTable */
TRACE("(%04x %04x %08lx)!\n", hwndServer, hwndClient, lParam);
UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi);
hDdeAdvise = (HGLOBAL)uiLo;
hszItem = (HSZ)uiHi; /* FIXME: it should be a global atom */
if (!pConv)
{
ERR("Got an advise on a not known conversation, dropping request\n");
FreeDDElParam(WM_DDE_ADVISE, lParam);
return 0;
}
pDdeAdvise = (DDEADVISE*)GlobalLock(hDdeAdvise);
uType = XTYP_ADVSTART |
(pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
(pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
hDdeData = 0;
if (thisInstance && thisInstance->callback != NULL /* && thisInstance->Process_id == GetCurrentProcessId() */)
{
TRACE("calling the Callback, idInst=%ld, CB=0x%lx, uType=0x%x, uFmt=%x\n",
thisInstance->instanceID, (DWORD)thisInstance->callback,
uType, pDdeAdvise->cfFormat);
hDdeData = (thisInstance->callback)(XTYP_ADVSTART, pDdeAdvise->cfFormat, (HCONV)pConv,
pConv->hszTopic, hszItem, 0, 0, 0);
}
ddeAck.bAppReturnCode = 0;
ddeAck.reserved = 0;
ddeAck.fBusy = FALSE;
if ((UINT)hDdeData || TRUE) /* FIXME (from Corel ?) some apps don't return this value */
{
ddeAck.fAck = TRUE;
/* billx: first to see if the link is already created. */
pLink = WDML_FindLink(thisInstance, (HCONV)pConv, WDML_SERVER_SIDE,
hszItem, 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=0x%lx\n", (DWORD)pConv);
WDML_AddLink(thisInstance, (HCONV)pConv, WDML_SERVER_SIDE,
uType, hszItem, pDdeAdvise->cfFormat);
}
}
else
{
TRACE("No data returned from the Callback\n");
ddeAck.fAck = FALSE;
}
GlobalUnlock(hDdeAdvise);
if (ddeAck.fAck)
GlobalFree(hDdeAdvise);
TRACE("Posting a %s ack\n", ddeAck.fAck ? "positive" : "negative");
PostMessageA(hwndClient, WM_DDE_ACK, (WPARAM)hwndServer,
ReuseDDElParam(lParam, WM_DDE_ADVISE, WM_DDE_ACK, *((WORD*)&ddeAck), (UINT)hszItem));
return 0L;
}
/******************************************************************
* WDML_ServerHandleUnadvise
*
*
*/
static LRESULT WDML_ServerHandleUnadvise(WDML_INSTANCE* thisInstance, WDML_CONV* pConv,
HWND hwndServer, HWND hwndClient, LPARAM lParam)
{
UINT uiLo, uiHi;
HSZ hszItem;
WDML_LINK* pLink;
DDEACK ddeAck;
TRACE("(%04x %04x %08lx)!\n", hwndServer, hwndClient, lParam);
/* billx: XTYP_ADVSTOP transaction */
UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
/* uiLow: wFmt */
hszItem = (HSZ)uiHi; /* FIXME: it should be a global atom */
if (hszItem == (HSZ)0 || uiLo == 0)
{
ERR("Unsupported yet options (null item or clipboard format\n");
}
pLink = WDML_FindLink(thisInstance, (HCONV)pConv, WDML_SERVER_SIDE, hszItem, uiLo);
if (pLink == NULL)
{
ERR("Couln'd find link for %08lx, dropping request\n", (DWORD)hszItem);
FreeDDElParam(WM_DDE_UNADVISE, lParam);
return 0;
}
/* callback shouldn't be invoked if CBF_FAIL_ADVISES is on. */
if (thisInstance && thisInstance->callback != NULL &&
!(thisInstance->CBFflags & CBF_SKIP_DISCONNECTS) /* && thisInstance->Process_id == GetCurrentProcessId() */)
{
TRACE("calling the Callback, idInst=%ld, CB=0x%lx, uType=0x%x\n",
thisInstance->instanceID, (DWORD)thisInstance->callback, XTYP_ADVSTOP);
(thisInstance->callback)(XTYP_ADVSTOP, uiLo, (HCONV)pConv, pConv->hszTopic,
hszItem, 0, 0, 0);
}
WDML_RemoveLink(thisInstance, (HCONV)pConv, WDML_SERVER_SIDE, hszItem, uiLo);
/* send back ack */
ddeAck.bAppReturnCode = 0;
ddeAck.reserved = 0;
ddeAck.fBusy = FALSE;
ddeAck.fAck = TRUE;
PostMessageA(hwndClient, WM_DDE_ACK, (WPARAM)hwndServer,
ReuseDDElParam(lParam, WM_DDE_UNADVISE, WM_DDE_ACK, *((WORD*)&ddeAck), (UINT)hszItem));
return 0;
}
/******************************************************************
* WDML_ServerHandleExecute
*
*
*/
static LRESULT WDML_ServerHandleExecute(WDML_INSTANCE* thisInstance, WDML_CONV* pConv,
HWND hwndServer, HWND hwndClient, LPARAM lParam)
{
DDEACK ddeAck;
HDDEDATA hDdeData;
TRACE("(%04x %04x %08lx)!\n", hwndServer, hwndClient, lParam);
if (hwndClient != pConv->hwndClient)
WARN("hmmm source window (%04x)\n", hwndClient);
hDdeData = 0;
if (thisInstance && thisInstance->callback != NULL /* && thisInstance->Process_id == GetCurrentProcessId() */)
{
LPVOID ptr = GlobalLock((HGLOBAL)lParam);
if (ptr)
{
hDdeData = DdeCreateDataHandle(0, ptr, GlobalSize((HGLOBAL)lParam),
0, 0, CF_TEXT, 0);
GlobalUnlock((HGLOBAL)lParam);
}
TRACE("calling the Callback, idInst=%ld, CB=0x%lx, uType=0x%x\n",
thisInstance->instanceID, (DWORD)thisInstance->callback, XTYP_EXECUTE);
hDdeData = (thisInstance->callback)(XTYP_EXECUTE, 0, (HCONV)pConv, pConv->hszTopic, 0,
hDdeData, 0L, 0L);
}
ddeAck.bAppReturnCode = 0;
ddeAck.reserved = 0;
ddeAck.fBusy = FALSE;
ddeAck.fAck = FALSE;
switch ((UINT)hDdeData)
{
case DDE_FACK:
ddeAck.fAck = TRUE;
break;
case DDE_FBUSY:
ddeAck.fBusy = TRUE;
break;
default:
WARN("Bad result code\n");
/* fall thru */
case DDE_FNOTPROCESSED:
break;
}
PostMessageA(pConv->hwndClient, WM_DDE_ACK, (WPARAM)hwndServer,
PackDDElParam(WM_DDE_ACK, *((WORD*)&ddeAck), lParam));
return 0;
}
/******************************************************************
* WDML_ServerHandlePoke
*
*
*/
static LRESULT WDML_ServerHandlePoke(WDML_INSTANCE* thisInstance, WDML_CONV* pConv,
HWND hwndServer, HWND hwndClient, LPARAM lParam)
{
UINT uiLo, uiHi;
HSZ hszItem;
DDEACK ddeAck;
DDEPOKE* pDdePoke;
HDDEDATA hDdeData;
TRACE("(%04x %04x %08lx)!\n", hwndServer, hwndClient, lParam);
UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
hszItem = (HSZ)uiHi;
pDdePoke = (DDEPOKE*)GlobalLock((HGLOBAL)uiLo);
if (!pDdePoke)
{
return 0;
}
ddeAck.bAppReturnCode = 0;
ddeAck.reserved = 0;
ddeAck.fBusy = FALSE;
ddeAck.fAck = FALSE;
if (thisInstance && thisInstance->callback != NULL)
{
hDdeData = DdeCreateDataHandle(thisInstance->instanceID, pDdePoke->Value,
GlobalSize((HGLOBAL)uiLo) - sizeof(DDEPOKE) + 1,
0, 0, pDdePoke->cfFormat, 0);
if (hDdeData)
{
HDDEDATA hDdeDataOut;
TRACE("calling callback XTYP_POKE, idInst=%ld\n",
thisInstance->instanceID);
hDdeDataOut = (thisInstance->callback)(XTYP_POKE,
pDdePoke->cfFormat, (HCONV)pConv,
pConv->hszTopic, (HSZ)uiHi,
hDdeData, 0, 0);
switch ((UINT)hDdeDataOut)
{
case DDE_FACK:
ddeAck.fAck = TRUE;
break;
case DDE_FBUSY:
ddeAck.fBusy = TRUE;
break;
default:
FIXME("Unsupported returned value %08lx\n", (DWORD)hDdeDataOut);
/* fal thru */
case DDE_FNOTPROCESSED:
break;
}
DdeFreeDataHandle(hDdeData);
}
}
GlobalUnlock((HGLOBAL)uiLo);
if (!ddeAck.fAck)
GlobalFree((HGLOBAL)uiHi);
PostMessageA(hwndClient, WM_DDE_ACK, (WPARAM)hwndServer,
ReuseDDElParam(lParam, WM_DDE_POKE, WM_DDE_ACK, *((WORD*)&ddeAck), (UINT)hszItem));
return 0L;
}
/******************************************************************
* WDML_ServerHandleTerminate
*
*
*/
static LRESULT WDML_ServerHandleTerminate(WDML_INSTANCE* thisInstance, WDML_CONV* pConv,
HWND hwndServer, HWND hwndClient, LPARAM lParam)
{
UINT uiLo, uiHi;
HSZ hszApp, hszTop;
TRACE("(%04x %04x %08lx)!\n", hwndServer, hwndClient, lParam);
TRACE("WM_DDE_TERMINATE!\n");
/* XTYP_DISCONNECT transaction */
/* billx: two things to remove: the conv, and associated links.
callback shouldn't be called if CBF_SKIP_DISCONNECTS is on.
Respond with another WM_DDE_TERMINATE iMsg.*/
/* don't free DDEParams, since this is a broadcast */
UnpackDDElParam(WM_DDE_TERMINATE, lParam, &uiLo, &uiHi);
hszApp = (HSZ)uiLo;
hszTop = (HSZ)uiHi;
WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_UNREGISTER, hszApp, hszTop);
/* PostMessageA(hwndClient, WM_DDE_TERMINATE, (WPARAM)hwndServer, (LPARAM)hConv); */
WDML_RemoveAllLinks(thisInstance, (HCONV)pConv, WDML_SERVER_SIDE);
WDML_RemoveConv(thisInstance, WDML_SERVER_SIDE, (HCONV)pConv);
/* DestroyWindow(hwnd); don't destroy it now, we may still need it. */
return 0;
}
/******************************************************************
* WDML_ServerConvProc
*
*
*/
static LRESULT CALLBACK WDML_ServerConvProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
WDML_INSTANCE* thisInstance;
WDML_CONV* pConv;
if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
{
return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
}
TRACE("About to wait... \n");
if (!WDML_WaitForMutex(handle_mutex))
{
return 0;
}
thisInstance = (WDML_INSTANCE*)GetWindowLongA(hwndServer, 0);
pConv = (WDML_CONV*)GetWindowLongA(hwndServer, 4);
switch (iMsg)
{
case WM_DDE_INITIATE:
FIXME("WM_DDE_INITIATE message received in the ServerConv Proc!\n");
break;
case WM_DDE_REQUEST:
WDML_ServerHandleRequest(thisInstance, pConv, hwndServer, (HWND)wParam, lParam);
break;
case WM_DDE_ADVISE:
WDML_ServerHandleAdvise(thisInstance, pConv, hwndServer, (HWND)wParam, lParam);
break;
case WM_DDE_UNADVISE:
WDML_ServerHandleUnadvise(thisInstance, pConv, hwndServer, (HWND)wParam, lParam);
break;
case WM_DDE_EXECUTE:
WDML_ServerHandleExecute(thisInstance, pConv, hwndServer, (HWND)wParam, lParam);
break;
case WM_DDE_POKE:
WDML_ServerHandlePoke(thisInstance, pConv, hwndServer, (HWND)wParam, lParam);
break;
case WM_DDE_TERMINATE:
WDML_ServerHandleTerminate(thisInstance, pConv, hwndServer, (HWND)wParam, lParam);
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", iMsg);
}
WDML_ReleaseMutex(handle_mutex, "handle_mutex", FALSE);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink