dde.c File Reference

#include <user32.h>

Include dependency graph for dde.c:

Go to the source code of this file.

Classes
struct	packed_message

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ddeml)
BOOL FASTCALL	DdeAddPair (HGLOBAL ClientMem, HGLOBAL ServerMem)
HGLOBAL FASTCALL	DdeGetPair (HGLOBAL ServerMem)
static void	push_data (struct packed_message *data, const void *ptr, int size)
static ULONGLONG	pack_ptr (const void *ptr)
static void *	unpack_ptr (ULONGLONG ptr64)
BOOL	post_dde_message (struct packed_message *data, UINT message, LPARAM lParam, LPARAM *lp)
BOOL	unpack_dde_message (HWND hwnd, UINT message, LPARAM *lparam, PVOID buffer, int size)
NTSTATUS WINAPI	User32CallDDEPostFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallDDEGetFromKernel (PVOID Arguments, ULONG ArgumentLength)
BOOL WINAPI	DdeGetQualityOfService (HWND hWnd, DWORD Reserved, PSECURITY_QUALITY_OF_SERVICE pqosPrev)

Function Documentation

DdeAddPair()

BOOL FASTCALL DdeAddPair	(	HGLOBAL	ClientMem,
		HGLOBAL	ServerMem
	)

Definition at line 180 of file message.c.

{
  unsigned i;

  EnterCriticalSection(&DdeCrst);

  /* now remember the pair of hMem on both sides */
  if (DdeNumUsed == DdeNumAlloc)
    {
#define GROWBY  4
      PDDEPAIR New;
      if (NULL != DdePairs)
        {
          New = HeapReAlloc(GetProcessHeap(), 0, DdePairs,
                            (DdeNumAlloc + GROWBY) * sizeof(DDEPAIR));
        }
      else
        {
          New = HeapAlloc(GetProcessHeap(), 0,
                          (DdeNumAlloc + GROWBY) * sizeof(DDEPAIR));
        }

      if (NULL == New)
        {
          LeaveCriticalSection(&DdeCrst);
          return FALSE;
        }
      DdePairs = New;
      /* zero out newly allocated part */
      memset(&DdePairs[DdeNumAlloc], 0, GROWBY * sizeof(DDEPAIR));
      DdeNumAlloc += GROWBY;
#undef GROWBY
    }

  for (i = 0; i < DdeNumAlloc; i++)
    {
      if (NULL == DdePairs[i].ServerMem)
        {
          DdePairs[i].ClientMem = ClientMem;
          DdePairs[i].ServerMem = ServerMem;
          DdeNumUsed++;
          break;
        }
    }
  LeaveCriticalSection(&DdeCrst);

  return TRUE;
}

Referenced by unpack_dde_message().

DdeGetPair()

HGLOBAL FASTCALL DdeGetPair

(

HGLOBAL

ServerMem

)

Definition at line 230 of file message.c.

{
  unsigned i;
  HGLOBAL Ret = NULL;

  EnterCriticalSection(&DdeCrst);
  for (i = 0; i < DdeNumAlloc; i++)
    {
      if (DdePairs[i].ServerMem == ServerMem)
        {
          /* free this pair */
          DdePairs[i].ServerMem = 0;
          DdeNumUsed--;
          Ret = DdePairs[i].ClientMem;
          break;
        }
    }
  LeaveCriticalSection(&DdeCrst);

  return Ret;
}

Referenced by post_dde_message().

DdeGetQualityOfService()

BOOL WINAPI DdeGetQualityOfService	(	HWND	hWnd,
		DWORD	Reserved,
		PSECURITY_QUALITY_OF_SERVICE	pqosPrev
	)

Definition at line 310 of file dde.c.

{
  UNIMPLEMENTED;
  return FALSE;
}

pack_ptr()

static ULONGLONG pack_ptr ( const void *  ptr )

inlinestatic

Definition at line 35 of file dde.c.

{
    return (ULONG_PTR)ptr;
}

Referenced by post_dde_message().

post_dde_message()

BOOL post_dde_message	(	struct packed_message *	data,
		UINT	message,
		LPARAM	lParam,
		LPARAM *	lp
	)

Definition at line 53 of file dde.c.

{
    void*       ptr = NULL;
    int         size = 0;
    UINT_PTR    uiLo, uiHi;
    HGLOBAL     hunlock = 0;
    ULONGLONG   hpack;

    if (!UnpackDDElParam( message, lParam, &uiLo, &uiHi ))
    {
        ERR("Unpack failed %x\n",message);
        return FALSE;
    }

    *lp = lParam;
    switch (message)
    {
        /* DDE messages which don't require packing are:
         * WM_DDE_INITIATE
         * WM_DDE_TERMINATE
         * WM_DDE_REQUEST
         * WM_DDE_UNADVISE
         */
    case WM_DDE_ACK:
        if (HIWORD(uiHi))
        {
            /* uiHi should contain a hMem from WM_DDE_EXECUTE */
            HGLOBAL h = DdeGetPair( (HANDLE)uiHi );
            if (h)
            {
                hpack = pack_ptr( h );
                /* send back the value of h on the other side */
                push_data( data, &hpack, sizeof(hpack) );
                *lp = uiLo;
                TRACE( "send dde-ack %lx %08lx => %p\n", uiLo, uiHi, h );
            }
        }
        else
        {
            /* uiHi should contain either an atom or 0 */
            TRACE( "send dde-ack %lx atom=%lx\n", uiLo, uiHi );
            *lp = MAKELONG( uiLo, uiHi );
        }
        break;
    case WM_DDE_ADVISE:
    case WM_DDE_DATA:
    case WM_DDE_POKE:
        size = 0;
        if (uiLo)
        {
            size = GlobalSize( (HGLOBAL)uiLo ) ;
            TRACE("WM_DDE_A D P size %d\n",size);
            if ( (message == WM_DDE_ADVISE && size < sizeof(DDEADVISE)) ||
                 (message == WM_DDE_DATA   && size < FIELD_OFFSET(DDEDATA, Value)) ||
                 (message == WM_DDE_POKE   && size < FIELD_OFFSET(DDEPOKE, Value)) )
            return FALSE;
        }
        else if (message != WM_DDE_DATA)
        {
            TRACE("WM_DDE uiLo 0\n");
            return FALSE;
        }

        *lp = uiHi;
        if (uiLo)
        {
            if ((ptr = GlobalLock( (HGLOBAL)uiLo) ))
            {
                DDEDATA *dde_data = ptr;
                TRACE("unused %d, fResponse %d, fRelease %d, fDeferUpd %d, fAckReq %d, cfFormat %d\n",
                       dde_data->unused, dde_data->fResponse, dde_data->fRelease,
                       dde_data->reserved, dde_data->fAckReq, dde_data->cfFormat);
                push_data( data, ptr, size );
                hunlock = (HGLOBAL)uiLo;
            }
        }
        TRACE( "send ddepack %u %lx\n", size, uiHi );
        break;
    case WM_DDE_EXECUTE:
        if (lParam)
        {
            if ((ptr = GlobalLock( (HGLOBAL)lParam) ))
            {
                size = GlobalSize( (HGLOBAL)lParam );
                push_data(data, ptr, size);
                /* so that the other side can send it back on ACK */
                *lp = lParam;
                hunlock = (HGLOBAL)lParam;
                TRACE("WM_DDE_EXECUTE text size %d\n",GlobalSize( (HGLOBAL)lParam ));
            }
        }
        break;
    }

    FreeDDElParam(message, lParam);

    if (hunlock) GlobalUnlock(hunlock);

    return TRUE;
}

Referenced by User32CallDDEPostFromKernel().

push_data()

static void push_data ( struct packed_message *  data, const void *  ptr, int  size  )

inlinestatic

Definition at line 27 of file dde.c.

{
    data->data = ptr;
    data->size = size;
    data->count++;
}

Referenced by post_dde_message().

unpack_dde_message()

BOOL unpack_dde_message	(	HWND	hwnd,
		UINT	message,
		LPARAM *	lparam,
		PVOID	buffer,
		int	size
	)

Definition at line 159 of file dde.c.

{
    UINT_PTR    uiLo, uiHi;
    HGLOBAL hMem = 0;
    void*   ptr;

    TRACE("udm : Size %d\n",size);

    switch (message)
    {
    case WM_DDE_ACK:
        if (size)
        {
            ULONGLONG hpack;
            /* hMem is being passed */
            if (size != sizeof(hpack)) return FALSE;
            if (!buffer) return FALSE;
            uiLo = *lparam;
            memcpy( &hpack, buffer, size );
            hMem = unpack_ptr( hpack );
            uiHi = (UINT_PTR)hMem;
            TRACE("recv dde-ack %lx mem=%lx[%lx]\n", uiLo, uiHi, GlobalSize( hMem ));
        }
        else
        {
            uiLo = LOWORD( *lparam );
            uiHi = HIWORD( *lparam );
            TRACE("recv dde-ack %lx atom=%lx\n", uiLo, uiHi);
        }
    *lparam = PackDDElParam( WM_DDE_ACK, uiLo, uiHi );
    break;
    case WM_DDE_ADVISE:
    case WM_DDE_DATA:
    case WM_DDE_POKE:
    if ((!buffer) && message != WM_DDE_DATA) return FALSE;
    uiHi = *lparam;
        if (size)
        {
            if (!(hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size )))
                return FALSE;
            if ((ptr = GlobalLock( hMem )))
            {
                memcpy( ptr, buffer, size );
                GlobalUnlock( hMem );
            }
            else
            {
                GlobalFree( hMem );
                return FALSE;
            }
        }
        uiLo = (UINT_PTR)hMem;

    *lparam = PackDDElParam( message, uiLo, uiHi );
    break;
    case WM_DDE_EXECUTE:
    if (size)
    {
        if (!buffer) return FALSE;
            if (!(hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size ))) return FALSE;
            if ((ptr = GlobalLock( hMem )))
        {
        memcpy( ptr, buffer, size );
        GlobalUnlock( hMem );
                TRACE( "exec: pairing c=%08lx s=%p\n", *lparam, hMem );
                if (!DdeAddPair( (HGLOBAL)*lparam, hMem ))
                {
                    GlobalFree( hMem );
                    TRACE("udm exec: GF 1\n");
                    return FALSE;
                }
            }
            else
            {
                GlobalFree( hMem );
                TRACE("udm exec: GF 2\n");
                return FALSE;
            }
    }
    else
        {
        TRACE("udm exec: No Size\n");
        return FALSE;
        }

        TRACE( "exec: exit c=%08lx s=%p\n", *lparam, hMem );
        *lparam = (LPARAM)hMem;
        break;
    }
    return TRUE;
}

Referenced by User32CallDDEGetFromKernel().

unpack_ptr()

static void* unpack_ptr ( ULONGLONG  ptr64 )

inlinestatic

Definition at line 41 of file dde.c.

{
    if ((ULONG_PTR)ptr64 != ptr64) return 0;
       return (void *)(ULONG_PTR)ptr64;
}

Referenced by unpack_dde_message().

User32CallDDEGetFromKernel()

NTSTATUS WINAPI User32CallDDEGetFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 288 of file dde.c.

{
  BOOL Ret;
  NTSTATUS Status = STATUS_SUCCESS;
  PDDEPOSTGET_CALLBACK_ARGUMENTS Common = Arguments;

  TRACE("DDE Get CB size %d\n",Common->size);

  Ret = unpack_dde_message( Common->hwnd, Common->message, &Common->lParam, Common->buffer, Common->size );

  if (!Ret)
  {
     ERR("DDE Get CB Return bad msg 0x%x\n",Common->message);
     Status = STATUS_UNSUCCESSFUL;
  }
  return ZwCallbackReturn(Arguments, ArgumentLength, Status);
}

User32CallDDEPostFromKernel()

NTSTATUS WINAPI User32CallDDEPostFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 256 of file dde.c.

{
  struct packed_message data;
  BOOL Ret;
  NTSTATUS Status = STATUS_SUCCESS;
  PDDEPOSTGET_CALLBACK_ARGUMENTS Common = Arguments;

  data.data = 0;
  data.size = 0;
  TRACE("DDE Post CB\n");
  Ret = post_dde_message( &data, Common->message, Common->lParam, &Common->lParam);

  if (Ret)
  {
     Common->pvData = (PVOID)data.data;
     Common->size = data.size;
     TRACE("DDE Post CB size %d\n",data.size);
  }
  else
  {
     ERR("DDE Post CB Return bad msg 0x%x Size %d\n",Common->message,Common->size);
     Status = STATUS_UNSUCCESSFUL;
  }

  return ZwCallbackReturn(Arguments, ArgumentLength, Status);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ddeml

)