dde.c File Reference

#include <win32k.h>
#include <dde.h>

Include dependency graph for dde.c:

Go to the source code of this file.

Classes
struct	_DDEIMP
struct	_DDE_DATA
struct	_DDE_PROP

Typedefs
typedef struct _DDEIMP	DDEIMP
typedef struct _DDEIMP *	PDDEIMP
typedef struct _DDE_DATA	DDE_DATA
typedef struct _DDE_DATA *	PDDE_DATA
typedef struct _DDE_PROP	DDE_PROP
typedef struct _DDE_PROP *	PDDE_PROP

Functions
	DBG_DEFAULT_CHANNEL (UserMisc)
int APIENTRY	IntDDEPostCallback (IN PWND pWnd, IN UINT Msg, IN WPARAM wParam, IN OUT LPARAM *lParam, IN OUT PVOID *Buffer)
BOOL APIENTRY	IntDDEGetCallback (IN PWND pWnd, IN OUT PMSG pMsg, IN PVOID Buffer, IN int size)
BOOL APIENTRY	IntDdePostMessageHook (IN PWND pWnd, IN UINT Msg, IN WPARAM wParam, IN OUT LPARAM *lParam, IN OUT LONG_PTR *ExtraInfo)
BOOL APIENTRY	IntDdeGetMessageHook (PMSG pMsg, LONG_PTR ExtraInfo)
BOOL FASTCALL	IntDdeSendMessageHook (PWND pWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL APIENTRY	NtUserDdeGetQualityOfService (IN HWND hwndClient, IN HWND hWndServer, OUT PSECURITY_QUALITY_OF_SERVICE pqosPrev)
BOOL APIENTRY	NtUserDdeSetQualityOfService (IN HWND hwndClient, IN PSECURITY_QUALITY_OF_SERVICE pqosNew, OUT PSECURITY_QUALITY_OF_SERVICE pqosPrev)
BOOL APIENTRY	NtUserImpersonateDdeClientWindow (HWND hWndClient, HWND hWndServer)
DWORD APIENTRY	NtUserDdeInitialize (DWORD Unknown0, DWORD Unknown1, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4)

Variables
SECURITY_QUALITY_OF_SERVICE	gqosDefault = {sizeof(SECURITY_QUALITY_OF_SERVICE),SecurityImpersonation,SECURITY_STATIC_TRACKING,TRUE}

Typedef Documentation

DDE_DATA

typedef struct _DDE_DATA DDE_DATA

DDE_PROP

typedef struct _DDE_PROP DDE_PROP

DDEIMP

typedef struct _DDEIMP DDEIMP

PDDE_DATA

typedef struct _DDE_DATA * PDDE_DATA

PDDE_PROP

typedef struct _DDE_PROP * PDDE_PROP

PDDEIMP

typedef struct _DDEIMP * PDDEIMP

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserMisc

)

IntDDEGetCallback()

BOOL APIENTRY IntDDEGetCallback	(	IN PWND	pWnd,
		IN OUT PMSG	pMsg,
		IN PVOID	Buffer,
		IN int	size
	)

Definition at line 111 of file dde.c.

{
   NTSTATUS Status;
   ULONG ArgumentLength, ResultLength;
   PVOID Argument, ResultPointer;
   PDDEPOSTGET_CALLBACK_ARGUMENTS Common;
 
   ResultPointer = NULL;
   ResultLength = ArgumentLength = sizeof(DDEPOSTGET_CALLBACK_ARGUMENTS)+size;
 
   Argument = IntCbAllocateMemory(ArgumentLength);
   if (NULL == Argument)
   {
      return FALSE;
   }
 
   Common = (PDDEPOSTGET_CALLBACK_ARGUMENTS) Argument;
 
   Common->size    = size;
   Common->hwnd    = pMsg->hwnd;
   Common->message = pMsg->message;
   Common->wParam  = pMsg->wParam;
   Common->lParam  = pMsg->lParam;
 
   if (size && Buffer) RtlCopyMemory(&Common->buffer, Buffer, size);
 
   UserLeaveCo();
 
   Status = KeUserModeCallback(USER32_CALLBACK_DDEGET,
                               Argument,
                               ArgumentLength,
                               &ResultPointer,
                               &ResultLength);
 
   UserEnterCo();
 
   if (!NT_SUCCESS(Status) || ResultPointer == NULL )
   {
      ERR("DDE Get callback failed!\n");
      IntCbFreeMemory(Argument);
      return FALSE;
   }
 
   RtlMoveMemory(Common, ResultPointer, ArgumentLength);
 
   pMsg->lParam = Common->lParam;
 
   IntCbFreeMemory(Argument);
 
   return TRUE;
}

Referenced by IntDdeGetMessageHook().

IntDdeGetMessageHook()

BOOL APIENTRY IntDdeGetMessageHook	(	PMSG	pMsg,
		LONG_PTR	ExtraInfo
	)

Definition at line 326 of file dde.c.

{
   PWND pWnd, pWndClient;
   PDDE_DATA pddeData;
   PDDE_PROP pddeProp;
   BOOL Ret;
 
   pWnd = UserGetWindowObject(pMsg->hwnd);
   if (pWnd == NULL)
   {
      ERR("DDE Get Window is dead. %p\n", pMsg->hwnd);
      return TRUE;
   }
 
   if (pMsg->message == WM_DDE_TERMINATE)
   {
      pddeProp = (PDDE_PROP)UserGetProp(pWnd, AtomDDETrack, TRUE);
      if (pddeProp)
      {
         pWndClient = UserGetWindowObject((HWND)pMsg->wParam);
         if (pWndClient == NULL)
         {
            ERR("DDE Get Client WM_DDE_TERMINATE\n");
         }
 
         UserRemoveProp(pWnd, AtomDDETrack, TRUE);
         ExFreePoolWithTag(pddeProp, USERTAG_DDE1);
      }
      return TRUE;
   }
 
   TRACE("DDE Get Msg 0x%x\n",pMsg->message);
 
   pddeData = (PDDE_DATA)ExtraInfo;
 
   if ( pddeData )
   {
      TRACE("DDE Get size %d lParam c=%08lx lp c=%08lx\n",pddeData->cbSize, pMsg->lParam, pddeData->lParam);
 
      // Callback.
      Ret = IntDDEGetCallback( pWnd, pMsg, pddeData->pvBuffer, pddeData->cbSize);
      if (!Ret)
      {
         ERR("DDE Get CB failed\n");
      }
 
      if (pddeData->pvBuffer) ExFreePoolWithTag(pddeData->pvBuffer, USERTAG_DDE);
 
      ExFreePoolWithTag(pddeData, USERTAG_DDE5);
 
      return Ret;
   }
   TRACE("DDE Get No DDE Data found!\n");
   return TRUE;
}

Referenced by co_IntGetPeekMessage().

IntDDEPostCallback()

int APIENTRY IntDDEPostCallback	(	IN PWND	pWnd,
		IN UINT	Msg,
		IN WPARAM	wParam,
		IN OUT LPARAM *	lParam,
		IN OUT PVOID *	Buffer
	)

Definition at line 48 of file dde.c.

{
   NTSTATUS Status;
   ULONG ArgumentLength, ResultLength;
   PVOID Argument, ResultPointer;
   PDDEPOSTGET_CALLBACK_ARGUMENTS Common;
   int size = 0;
   ResultPointer = NULL;
   ResultLength = ArgumentLength = sizeof(DDEPOSTGET_CALLBACK_ARGUMENTS);
 
   Argument = IntCbAllocateMemory(ArgumentLength);
   if (NULL == Argument)
   {
      return FALSE;
   }
 
   Common = (PDDEPOSTGET_CALLBACK_ARGUMENTS) Argument;
 
   Common->pvData  = 0;
   Common->size    = 0;
   Common->hwnd    = UserHMGetHandle(pWnd);
   Common->message = Msg;
   Common->wParam  = wParam;
   Common->lParam  = *lParam;
 
   UserLeaveCo();
 
   Status = KeUserModeCallback(USER32_CALLBACK_DDEPOST,
                               Argument,
                               ArgumentLength,
                               &ResultPointer,
                               &ResultLength);
 
   UserEnterCo();
 
   if (!NT_SUCCESS(Status) || ResultPointer == NULL )
   {
      ERR("DDE Post callback failed!\n");
      IntCbFreeMemory(Argument);
      return 0;
   }
 
   RtlCopyMemory(Common, ResultPointer, ArgumentLength);
 
   size    = Common->size;
   *lParam = Common->lParam;
   *Buffer = Common->pvData;
 
   IntCbFreeMemory(Argument);
 
   return size ? size : -1;
}

Referenced by IntDdePostMessageHook().

IntDdePostMessageHook()

BOOL APIENTRY IntDdePostMessageHook	(	IN PWND	pWnd,
		IN UINT	Msg,
		IN WPARAM	wParam,
		IN OUT LPARAM *	lParam,
		IN OUT LONG_PTR *	ExtraInfo
	)

Definition at line 172 of file dde.c.

{
   PWND pWndClient;
   PDDE_DATA pddeData;
   int size;
   HGDIOBJ Object = NULL;
   PVOID userBuf = NULL;
   PVOID Buffer = NULL;
   LPARAM lp = *lParam;
 
   if (pWnd->head.pti->ppi != gptiCurrent->ppi)
   {
      TRACE("Posting long DDE 0x%x\n",Msg);
      // Initiate is sent only across borders.
      if (Msg == WM_DDE_INITIATE)
      {
         return FALSE;
      }
 
      pWndClient = UserGetWindowObject((HWND)wParam);
      if (pWndClient == NULL)
      {
         // This is terminating so post it.
         if ( Msg == WM_DDE_TERMINATE)
         {
            TRACE("DDE Posted WM_DDE_TERMINATE\n");
            return TRUE;
         }
         TRACE("Invalid DDE Client Window handle\n");
         return FALSE;
      }
 
      if ( Msg == WM_DDE_REQUEST || Msg == WM_DDE_UNADVISE )
      {
         // Do not bother to callback after validation.
         return TRUE;
      }
 
      if ( Msg == WM_DDE_TERMINATE )
      {
 
         // Do not bother to callback.
         return TRUE;
      }
 
      if ( Msg == WM_DDE_EXECUTE && *lParam == 0)
      {
         // Do not bother to do a callback.
         TRACE("DDE Post EXECUTE lParam 0\n");
         return FALSE;
      }
 
      // Callback.
      if ((size = IntDDEPostCallback(pWnd, Msg, wParam, &lp, &userBuf)) == 0)
      {
         ERR("DDE Post Callback return 0 0x%x\n", Msg);
         return FALSE;
      }
 
      // No error HACK.
      if (size == -1)
      {
         size = 0;
      }
      else
      {
         // Set buffer with users data size.
         Buffer = ExAllocatePoolWithTag(PagedPool, size, USERTAG_DDE);
         if (Buffer == NULL)
         {
             ERR("Failed to allocate %i bytes.\n", size);
             return FALSE;
         }
         // No SEH? Yes, the user memory is freed after the Acknowledgment or at Termination.
         RtlCopyMemory(Buffer, userBuf, size);
      }
 
      TRACE("DDE Post size %d 0x%x\n",size, Msg);
 
      switch(Msg)
      {
          case WM_DDE_POKE:
          {
              DDEPOKE *pddePoke = Buffer;
              NT_ASSERT(pddePoke != NULL);
              switch(pddePoke->cfFormat)
              {
                 case CF_BITMAP:
                 case CF_DIB:
                 case CF_PALETTE:
                    RtlCopyMemory(&Object, pddePoke->Value, sizeof(HGDIOBJ));
                    break;
                 default:
                    break;
              }
              break;
          }
          case WM_DDE_DATA:
          {
              DDEDATA *pddeData2 = Buffer;
              NT_ASSERT(pddeData2 != NULL);
              switch(pddeData2->cfFormat)
              {
                 case CF_BITMAP:
                 case CF_DIB:
                 case CF_PALETTE:
                    RtlCopyMemory(&Object, pddeData2->Value, sizeof(HGDIOBJ));
                    break;
                 default:
                    break;
              }
              break;
          }
          default:
              break;
      }
 
      if (Object)
      {
         // Give gdi object to the other process.
         GreSetObjectOwner(Object, pWnd->head.pti->ppi->W32Pid);
      }
 
      pddeData = ExAllocatePoolWithTag(PagedPool, sizeof(DDE_DATA), USERTAG_DDE5);
      if (pddeData == NULL)
      {
         ERR("Failed to allocate DDE_DATA\n");
         ExFreePoolWithTag(Buffer, USERTAG_DDE);
         return FALSE;
      }
 
      pddeData->cbSize       = size;
      pddeData->pvBuffer     = Buffer;
      pddeData->lParam       = lp;
 
      TRACE("DDE Post lParam c=%08lx\n",lp);
      *lParam = lp;
 
      // Attach this data packet to the user message.
      *ExtraInfo = (LONG_PTR)pddeData;
   }
   return TRUE;
}

Referenced by UserPostMessage().

IntDdeSendMessageHook()

BOOL FASTCALL IntDdeSendMessageHook	(	PWND	pWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 386 of file dde.c.

{
   PWND pWndServer;
   PDDE_PROP pddeProp;
 
   if (pWnd->head.pti->ppi != gptiCurrent->ppi)
   {
      TRACE("Sending long DDE 0x%x\n",Msg);
 
      // Allow only Acknowledge and Initiate to be sent across borders.
      if (Msg != WM_DDE_ACK )
      {
         if (Msg == WM_DDE_INITIATE) return TRUE;
         return FALSE;
      }
 
      TRACE("Sending long WM_DDE_ACK\n");
 
      pWndServer = UserGetWindowObject((HWND)wParam);
      if (pWndServer == NULL)
      {
         ERR("Invalid DDE Server Window handle\n");
         return FALSE;
      }
 
      // Setup property so this conversation can be tracked.
      pddeProp = ExAllocatePoolWithTag(PagedPool, sizeof(DDE_PROP), USERTAG_DDE1);
      if (pddeProp == NULL)
      {
         ERR("failed to allocate DDE_PROP\n");
         return FALSE;
      }
 
      pddeProp->spwnd        = pWndServer;
      pddeProp->spwndPartner = pWnd;
 
      UserSetProp(pWndServer, AtomDDETrack, (HANDLE)pddeProp, TRUE);
   }
   return TRUE;
}

Referenced by co_IntSendMessageTimeoutSingle().

NtUserDdeGetQualityOfService()

BOOL APIENTRY NtUserDdeGetQualityOfService	(	IN HWND	hwndClient,
		IN HWND	hWndServer,
		OUT PSECURITY_QUALITY_OF_SERVICE	pqosPrev
	)

Definition at line 430 of file dde.c.

{
   STUB
 
   return 0;
}

NtUserDdeInitialize()

DWORD APIENTRY NtUserDdeInitialize	(	DWORD	Unknown0,
		DWORD	Unknown1,
		DWORD	Unknown2,
		DWORD	Unknown3,
		DWORD	Unknown4
	)

Definition at line 465 of file dde.c.

{
   STUB
 
   return 0;
}

NtUserDdeSetQualityOfService()

BOOL APIENTRY NtUserDdeSetQualityOfService	(	IN HWND	hwndClient,
		IN PSECURITY_QUALITY_OF_SERVICE	pqosNew,
		OUT PSECURITY_QUALITY_OF_SERVICE	pqosPrev
	)

Definition at line 442 of file dde.c.

{
   STUB
 
   return 0;
}

NtUserImpersonateDdeClientWindow()

BOOL APIENTRY NtUserImpersonateDdeClientWindow	(	HWND	hWndClient,
		HWND	hWndServer
	)

Definition at line 454 of file dde.c.

{
   STUB
 
   return 0;
}

Variable Documentation

gqosDefault

SECURITY_QUALITY_OF_SERVICE gqosDefault = {sizeof(SECURITY_QUALITY_OF_SERVICE),SecurityImpersonation,SECURITY_STATIC_TRACKING,TRUE}

Definition at line 18 of file dde.c.