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

2197 lines
62 KiB
C
Raw Blame History

/*
* DDEML library
*
* Copyright 1997 Alexandre Julliard
* Copyright 1997 Len White
* Copyright 1999 Keith Matthews
*/
/* Only empty stubs for now */
#include <stdlib.h>
#include <string.h>
#include "winbase.h"
#include "windef.h"
#include "wingdi.h"
#include "winuser.h"
#include "ddeml.h"
#include "winerror.h"
#include "heap.h"
#include "debugtools.h"
#include "tchar.h"
#include "winnt.h"
DEFAULT_DEBUG_CHANNEL(ddeml)
/* Has defined in atom.c file.
*/
#define MAX_ATOM_LEN 255
/* Maximum buffer size ( including the '\0' ).
*/
#define MAX_BUFFER_LEN (MAX_ATOM_LEN + 1)
/* typedef struct {
DWORD nLength;
LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;
} SECURITY_ATTRIBUTES; */
/* This is a simple list to keep track of the strings created
* by DdeCreateStringHandle. The list is used to free
* the strings whenever DdeUninitialize is called.
* This mechanism is not complete and does not handle multiple instances.
* Most of the DDE API use a DWORD parameter indicating which instance
* of a given program is calling them. The API are supposed to
* associate the data to the instance that created it.
*/
typedef struct tagHSZNode HSZNode;
struct tagHSZNode
{
HSZNode* next;
HSZ hsz;
};
typedef struct tagServiceNode ServiceNode;
struct tagServiceNode
{
ServiceNode* next;
HSZ hsz;
BOOL16 FilterOn;
};
typedef struct DDE_HANDLE_ENTRY {
BOOL16 Monitor; /* have these two as full Booleans cos they'll be tested frequently */
BOOL16 Client_only; /* bit wasteful of space but it will be faster */
BOOL16 Unicode; /* Flag to indicate Win32 API used to initialise */
BOOL16 Win16; /* flag to indicate Win16 API used to initialize */
DWORD Instance_id; /* needed to track monitor usage */
struct DDE_HANDLE_ENTRY *Next_Entry;
HSZNode *Node_list;
PFNCALLBACK CallBack;
DWORD CBF_Flags;
DWORD Monitor_flags;
UINT Txn_count; /* count transactions open to simplify closure */
DWORD Last_Error;
ServiceNode* ServiceNames;
} DDE_HANDLE_ENTRY;
static DDE_HANDLE_ENTRY *DDE_Handle_Table_Base = NULL;
static DWORD DDE_Max_Assigned_Instance = 0; /* OK for present, may have to worry about wrap-around later */
static const char *DDEInstanceAccess = "DDEMaxInstance";
static const char *DDEHandleAccess = "DDEHandleAccess";
static HANDLE inst_count_mutex = 0;
static HANDLE handle_mutex = 0;
#define TRUE 1
#define FALSE 0
/******************************************************************************
* RemoveHSZNodes (INTERNAL)
*
* Remove a node from the list of HSZ nodes.
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Mar 1999 Keith Matthews Added multiple instance handling
*
*/
static void RemoveHSZNode( HSZ hsz, DDE_HANDLE_ENTRY * reference_inst )
{
HSZNode* pPrev = NULL;
HSZNode* pCurrent = NULL;
/* Set the current node at the start of the list.
*/
pCurrent = reference_inst->Node_list;
/* While we have more nodes.
*/
while( pCurrent != NULL )
{
/* If we found the node we were looking for.
*/
if( pCurrent->hsz == hsz )
{
/* Remove the node.
*/
/* If the first node in the list is to to be removed.
* Set the global list pointer to the next node.
*/
if( pCurrent == reference_inst->Node_list )
{
reference_inst->Node_list = pCurrent->next;
}
/* Just fix the pointers has to skip the current
* node so we can delete it.
*/
else
{
pPrev->next = pCurrent->next;
}
/* Destroy this node.
*/
free( pCurrent );
break;
}
/* Save the previous node pointer.
*/
pPrev = pCurrent;
/* Move on to the next node.
*/
pCurrent = pCurrent->next;
}
}
/******************************************************************************
* FreeAndRemoveHSZNodes (INTERNAL)
*
* Frees up all the strings still allocated in the list and
* remove all the nodes from the list of HSZ nodes.
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Mar 1999 Keith Matthews Added multiple instance handling
*
*/
static void FreeAndRemoveHSZNodes( DWORD idInst, DDE_HANDLE_ENTRY * reference_inst )
{
/* Free any strings created in this instance.
*/
while( reference_inst->Node_list != NULL )
{
DdeFreeStringHandle( idInst, reference_inst->Node_list->hsz );
}
}
/******************************************************************************
* InsertHSZNode (INTERNAL)
*
* Insert a node to the head of the list.
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Mar 1999 Keith Matthews Added instance handling
* 1.2 Jun 1999 Keith Matthews Added Usage count handling
*
*/
static void InsertHSZNode( HSZ hsz, DDE_HANDLE_ENTRY * reference_inst )
{
if( hsz != 0 )
{
HSZNode* pNew = NULL;
/* Create a new node for this HSZ.
*/
pNew = (HSZNode*) malloc( sizeof( HSZNode ) );
if( pNew != NULL )
{
/* Set the handle value.
*/
pNew->hsz = hsz;
/* Attach the node to the head of the list. i.e most recently added is first
*/
pNew->next = reference_inst->Node_list;
/* The new node is now at the head of the list
* so set the global list pointer to it.
*/
reference_inst->Node_list = pNew;
TRACE("HSZ node list entry added\n");
}
}
}
/*****************************************************************************
* Find_Instance_Entry
*
* generic routine to return a pointer to the relevant DDE_HANDLE_ENTRY
* for an instance Id, or NULL if the entry does not exist
*
* ASSUMES the mutex protecting the handle entry list is reserved before calling
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 Keith Matthews 1st implementation
*/
DDE_HANDLE_ENTRY *Find_Instance_Entry (DWORD InstId)
{
DDE_HANDLE_ENTRY * reference_inst;
reference_inst = DDE_Handle_Table_Base;
while ( reference_inst != NULL )
{
if ( reference_inst->Instance_id == InstId )
{
TRACE("Instance entry found\n");
return reference_inst;
}
reference_inst = reference_inst->Next_Entry;
}
TRACE("Instance entry missing\n");
return NULL;
}
/*****************************************************************************
* Find_Service_Name
*
* generic routine to return a pointer to the relevant ServiceNode
* for a given service name, or NULL if the entry does not exist
*
* ASSUMES the mutex protecting the handle entry list is reserved before calling
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 May 1999 Keith Matthews 1st implementation
*/
ServiceNode *Find_Service_Name (HSZ Service_Name, DDE_HANDLE_ENTRY* this_instance)
{
ServiceNode * reference_name= this_instance->ServiceNames;
while ( reference_name != NULL )
{
if ( reference_name->hsz == Service_Name )
{
TRACE("Service Name found\n");
return reference_name;
}
reference_name = reference_name->next;
}
TRACE("Service name missing\n");
return NULL;
}
/******************************************************************************
* Release_reserved_mutex
*
* generic routine to release a reserved mutex
*
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Jan 1999 Keith Matthews Initial version
* 1.1 Mar 1999 Keith Matthews Corrected Heap handling. Corrected re-initialisation handling
* 1.2 Aug 1999 J<>rgen Schmied Corrected error handling
*
*/
static DWORD Release_reserved_mutex (HANDLE mutex, LPSTR mutex_name, BOOL release_handle_m, BOOL release_this_i ,
DDE_HANDLE_ENTRY *this_instance)
{
if (!ReleaseMutex(mutex))
{
ERR("ReleaseMutex failed - %s mutex %li\n",mutex_name,GetLastError());
HeapFree(GetProcessHeap(), 0, this_instance);
if ( release_handle_m )
{
ReleaseMutex(handle_mutex);
}
return DMLERR_SYS_ERROR;
}
if ( release_this_i )
{
HeapFree(GetProcessHeap(), 0, this_instance);
}
return DMLERR_NO_ERROR;
}
/******************************************************************************
* WaitForMutex
*
* generic routine to wait for the mutex
*
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Aug 1999 Juergen Schmied Initial version
*
*/
static BOOL WaitForMutex (HANDLE mutex)
{
DWORD result;
result = WaitForSingleObject(mutex,1000);
/* both errors should never occur */
if (WAIT_TIMEOUT == result)
{
ERR("WaitForSingleObject timed out\n");
return FALSE;
}
if (WAIT_FAILED == result)
{
ERR("WaitForSingleObject failed - error %li\n", GetLastError());
return FALSE;
}
return TRUE;
}
/******************************************************************************
* IncrementInstanceId
*
* generic routine to increment the max instance Id and allocate a new application instance
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Jan 1999 Keith Matthews Initial version
*
*/
DWORD IncrementInstanceId( DDE_HANDLE_ENTRY *this_instance)
{
SECURITY_ATTRIBUTES s_attrib;
/* Need to set up Mutex in case it is not already present */
/* increment handle count & get value */
if ( !inst_count_mutex )
{
s_attrib.bInheritHandle = TRUE;
s_attrib.lpSecurityDescriptor = NULL;
s_attrib.nLength = sizeof(s_attrib);
inst_count_mutex = CreateMutexA(&s_attrib,1,DDEInstanceAccess); /* 1st time through */
inst_count_mutex = ConvertToGlobalHandle(inst_count_mutex); /* fixme when having seperate adresspaces*/
} else {
if ( !WaitForMutex(inst_count_mutex) )
{
return DMLERR_SYS_ERROR;
}
}
if ( !inst_count_mutex )
{
ERR("CreateMutex failed - inst_count %li\n",GetLastError());
Release_reserved_mutex (handle_mutex,"handle_mutex",0,1,this_instance);
return DMLERR_SYS_ERROR;
}
DDE_Max_Assigned_Instance++;
this_instance->Instance_id = DDE_Max_Assigned_Instance;
TRACE("New instance id %ld allocated\n",DDE_Max_Assigned_Instance);
if (Release_reserved_mutex(inst_count_mutex,"instance_count",1,0,this_instance)) return DMLERR_SYS_ERROR;
return DMLERR_NO_ERROR;
}
/******************************************************************************
* FindNotifyMonitorCallbacks
*
* Routine to find instances that need to be notified via their callback
* of some event they are monitoring
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 May 1999 Keith Matthews Initial Version
*
*/
void FindNotifyMonitorCallbacks(DWORD ThisInstance, DWORD DdeEvent )
{
DDE_HANDLE_ENTRY *InstanceHandle;
InstanceHandle = DDE_Handle_Table_Base;
while ( InstanceHandle != NULL )
{
if ( (InstanceHandle->Monitor ) && InstanceHandle->Instance_id == ThisInstance )
{
/* Found an instance registered as monitor and is not ourselves
* use callback to notify where appropriate
*/
}
InstanceHandle = InstanceHandle->Next_Entry;
}
}
/******************************************************************************
* DdeReserveAtom
*
* Routine to make an extra Add on an atom to reserve it a bit longer
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Jun 1999 Keith Matthews Initial Version
*
*/
static void DdeReserveAtom( DDE_HANDLE_ENTRY * reference_inst,HSZ hsz)
{
if ( reference_inst->Unicode)
{
WCHAR SNameBuffer[MAX_BUFFER_LEN];
GlobalGetAtomNameW(hsz,SNameBuffer,MAX_BUFFER_LEN);
GlobalAddAtomW(SNameBuffer);
} else {
CHAR SNameBuffer[MAX_BUFFER_LEN];
GlobalGetAtomNameA(hsz,SNameBuffer,MAX_BUFFER_LEN);
GlobalAddAtomA(SNameBuffer);
}
}
/******************************************************************************
* DdeReleaseAtom
*
* Routine to make a delete on an atom to release it a bit sooner
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Jun 1999 Keith Matthews Initial Version
*
*/
static void DdeReleaseAtom( DDE_HANDLE_ENTRY * reference_inst,HSZ hsz)
{
GlobalDeleteAtom( hsz );
}
/******************************************************************************
* DdeInitialize16 (DDEML.2)
*/
UINT16 WINAPI DdeInitialize16( LPDWORD pidInst, PFNCALLBACK16 pfnCallback,
DWORD afCmd, DWORD ulRes)
{
TRACE("DdeInitialize16 called - calling DdeInitializeA\n");
return (UINT16)DdeInitializeA(pidInst,(PFNCALLBACK)pfnCallback,
afCmd, ulRes);
}
/******************************************************************************
* DdeInitializeA (USER32.106)
*/
UINT WINAPI DdeInitializeA( LPDWORD pidInst, PFNCALLBACK pfnCallback,
DWORD afCmd, DWORD ulRes )
{
TRACE("DdeInitializeA called - calling DdeInitializeW\n");
return DdeInitializeW(pidInst,pfnCallback,afCmd,ulRes);
}
/******************************************************************************
* DdeInitializeW [USER32.107]
* Registers an application with the DDEML
*
* PARAMS
* pidInst [I] Pointer to instance identifier
* pfnCallback [I] Pointer to callback function
* afCmd [I] Set of command and filter flags
* ulRes [I] Reserved
*
* RETURNS
* Success: DMLERR_NO_ERROR
* Failure: DMLERR_DLL_USAGE, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR
*
******************************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Pre 1998 Alexandre/Len Initial Stub
* 1.1 Jan 1999 Keith Matthews Initial (near-)complete version
* 1.2 Mar 1999 Keith Matthews Corrected Heap handling, CreateMutex failure handling
*
*/
UINT WINAPI DdeInitializeW( LPDWORD pidInst, PFNCALLBACK pfnCallback,
DWORD afCmd, DWORD ulRes )
{
/* probably not really capable of handling multiple processes, but should handle
* multiple instances within one process */
SECURITY_ATTRIBUTES *s_att= NULL;
SECURITY_ATTRIBUTES s_attrib;
DWORD err_no = 0;
DDE_HANDLE_ENTRY *this_instance;
DDE_HANDLE_ENTRY *reference_inst;
s_att = &s_attrib;
if( ulRes )
{
ERR("Reserved value not zero? What does this mean?\n");
FIXME("(%p,%p,0x%lx,%ld): stub\n", pidInst, pfnCallback,
afCmd,ulRes);
/* trap this and no more until we know more */
return DMLERR_NO_ERROR;
}
if (!pfnCallback )
{
/* this one may be wrong - MS dll seems to accept the condition,
leave this until we find out more !! */
/* can't set up the instance with nothing to act as a callback */
TRACE("No callback provided\n");
return DMLERR_INVALIDPARAMETER; /* might be DMLERR_DLL_USAGE */
}
/* grab enough heap for one control struct - not really necessary for re-initialise
* but allows us to use same validation routines */
this_instance= (DDE_HANDLE_ENTRY*)HeapAlloc( GetProcessHeap(), 0, sizeof(DDE_HANDLE_ENTRY) );
if ( this_instance == NULL )
{
/* catastrophe !! warn user & abort */
ERR("Instance create failed - out of memory\n");
return DMLERR_SYS_ERROR;
}
this_instance->Next_Entry = NULL;
this_instance->Monitor=(afCmd|APPCLASS_MONITOR);
/* messy bit, spec implies that 'Client Only' can be set in 2 different ways, catch 1 here */
this_instance->Client_only=afCmd&APPCMD_CLIENTONLY;
this_instance->Instance_id = *pidInst; /* May need to add calling proc Id */
this_instance->CallBack=*pfnCallback;
this_instance->Txn_count=0;
this_instance->Unicode = TRUE;
this_instance->Win16 = FALSE;
this_instance->Node_list = NULL; /* node will be added later */
this_instance->Monitor_flags = afCmd & MF_MASK;
this_instance->ServiceNames = NULL;
/* isolate CBF flags in one go, expect this will go the way of all attempts to be clever !! */
this_instance->CBF_Flags=afCmd^((afCmd&MF_MASK)|((afCmd&APPCMD_MASK)|(afCmd&APPCLASS_MASK)));
if ( ! this_instance->Client_only )
{
/* Check for other way of setting Client-only !! */
this_instance->Client_only=(this_instance->CBF_Flags&CBF_FAIL_ALLSVRXACTIONS)
==CBF_FAIL_ALLSVRXACTIONS;
}
TRACE("instance created - checking validity \n");
if( *pidInst == 0 ) {
/* Initialisation of new Instance Identifier */
TRACE("new instance, callback %p flags %lX\n",pfnCallback,afCmd);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
/* Need to set up Mutex in case it is not already present */
s_att->bInheritHandle = TRUE;
s_att->lpSecurityDescriptor = NULL;
s_att->nLength = sizeof(s_att);
handle_mutex = CreateMutexA(s_att,1,DDEHandleAccess);
handle_mutex = ConvertToGlobalHandle(handle_mutex); /* fixme when having seperate adresspaces*/
if ( !handle_mutex ) {
ERR("CreateMutex failed - handle list %li\n",GetLastError());
HeapFree(GetProcessHeap(), 0, this_instance);
return DMLERR_SYS_ERROR;
}
} else {
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
}
TRACE("Handle Mutex created/reserved\n");
if (DDE_Handle_Table_Base == NULL )
{
/* can't be another instance in this case, assign to the base pointer */
DDE_Handle_Table_Base= this_instance;
/* since first must force filter of XTYP_CONNECT and XTYP_WILDCONNECT for
* present
* ------------------------------- NOTE NOTE NOTE --------------------------
*
* the manual is not clear if this condition
* applies to the first call to DdeInitialize from an application, or the
* first call for a given callback !!!
*/
this_instance->CBF_Flags=this_instance->CBF_Flags|APPCMD_FILTERINITS;
TRACE("First application instance detected OK\n");
/* allocate new instance ID */
if ((err_no = IncrementInstanceId( this_instance)) ) return err_no;
} else {
/* really need to chain the new one in to the latest here, but after checking conditions
* such as trying to start a conversation from an application trying to monitor */
reference_inst = DDE_Handle_Table_Base;
TRACE("Subsequent application instance - starting checks\n");
while ( reference_inst->Next_Entry != NULL )
{
/*
* This set of tests will work if application uses same instance Id
* at application level once allocated - which is what manual implies
* should happen. If someone tries to be
* clever (lazy ?) it will fail to pick up that later calls are for
* the same application - should we trust them ?
*/
if ( this_instance->Instance_id == reference_inst->Instance_id)
{
/* Check 1 - must be same Client-only state */
if ( this_instance->Client_only != reference_inst->Client_only)
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_DLL_USAGE;
}
/* Check 2 - cannot use 'Monitor' with any non-monitor modes */
if ( this_instance->Monitor != reference_inst->Monitor)
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_INVALIDPARAMETER;
}
/* Check 3 - must supply different callback address */
if ( this_instance->CallBack == reference_inst->CallBack)
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_DLL_USAGE;
}
}
reference_inst = reference_inst->Next_Entry;
}
/* All cleared, add to chain */
TRACE("Application Instance checks finished\n");
if ((err_no = IncrementInstanceId( this_instance)) ) return err_no;
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,0,this_instance)) return DMLERR_SYS_ERROR;
reference_inst->Next_Entry = this_instance;
}
*pidInst = this_instance->Instance_id;
TRACE("New application instance processing finished OK\n");
} else {
/* Reinitialisation situation --- FIX */
TRACE("reinitialisation of (%p,%p,0x%lx,%ld): stub\n",pidInst,pfnCallback,afCmd,ulRes);
if ( !WaitForMutex(handle_mutex) )
{
HeapFree(GetProcessHeap(), 0, this_instance);
return DMLERR_SYS_ERROR;
}
if (DDE_Handle_Table_Base == NULL )
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance)) return DMLERR_SYS_ERROR;
return DMLERR_DLL_USAGE;
}
HeapFree(GetProcessHeap(), 0, this_instance); /* finished - release heap space used as work store */
/* can't reinitialise if we have initialised nothing !! */
reference_inst = DDE_Handle_Table_Base;
/* must first check if we have been given a valid instance to re-initialise !! how do we do that ? */
/*
* MS allows initialisation without specifying a callback, should we allow addition of the
* callback by a later call to initialise ? - if so this lot will have to change
*/
while ( reference_inst->Next_Entry != NULL )
{
if ( *pidInst == reference_inst->Instance_id && pfnCallback == reference_inst->CallBack )
{
/* Check 1 - cannot change client-only mode if set via APPCMD_CLIENTONLY */
if ( reference_inst->Client_only )
{
if ((reference_inst->CBF_Flags & CBF_FAIL_ALLSVRXACTIONS) != CBF_FAIL_ALLSVRXACTIONS)
{
/* i.e. Was set to Client-only and through APPCMD_CLIENTONLY */
if ( ! ( afCmd & APPCMD_CLIENTONLY))
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_DLL_USAGE;
}
}
}
/* Check 2 - cannot change monitor modes */
if ( this_instance->Monitor != reference_inst->Monitor)
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_DLL_USAGE;
}
/* Check 3 - trying to set Client-only via APPCMD when not set so previously */
if (( afCmd&APPCMD_CLIENTONLY) && ! reference_inst->Client_only )
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_DLL_USAGE;
}
break;
}
reference_inst = reference_inst->Next_Entry;
}
if ( reference_inst->Next_Entry == NULL )
{
/* Crazy situation - trying to re-initialize something that has not beeen initialized !!
*
* Manual does not say what we do, cannot return DMLERR_NOT_INITIALIZED so what ?
*/
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
return DMLERR_INVALIDPARAMETER;
}
/* All checked - change relevant flags */
reference_inst->CBF_Flags = this_instance->CBF_Flags;
reference_inst->Client_only = this_instance->Client_only;
reference_inst->Monitor_flags = this_instance->Monitor_flags;
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
return DMLERR_SYS_ERROR;
}
return DMLERR_NO_ERROR;
}
/*****************************************************************
* DdeUninitialize16 (DDEML.3)
*/
BOOL16 WINAPI DdeUninitialize16( DWORD idInst )
{
FIXME(" stub calling DdeUninitialize\n");
return (BOOL16)DdeUninitialize( idInst );
}
/*****************************************************************
* DdeUninitialize [USER32.119] Frees DDEML resources
*
* PARAMS
* idInst [I] Instance identifier
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
BOOL WINAPI DdeUninitialize( DWORD idInst )
{
/* Stage one - check if we have a handle for this instance
*/
SECURITY_ATTRIBUTES *s_att= NULL;
SECURITY_ATTRIBUTES s_attrib;
DDE_HANDLE_ENTRY *this_instance;
DDE_HANDLE_ENTRY *reference_inst;
s_att = &s_attrib;
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
return TRUE;
}
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
this_instance = Find_Instance_Entry(idInst);
if ( this_instance == NULL )
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance)) return FALSE;
/*
* Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
*/
return FALSE;
}
FIXME("(%ld): partial stub\n", idInst);
/* FIXME ++++++++++++++++++++++++++++++++++++++++++
* Needs to de-register all service names
*
*/
/* Free the nodes that were not freed by this instance
* and remove the nodes from the list of HSZ nodes.
*/
FreeAndRemoveHSZNodes( idInst, this_instance );
/* OK now delete the instance handle itself */
if ( DDE_Handle_Table_Base == this_instance )
{
/* special case - the first/only entry
*/
DDE_Handle_Table_Base = this_instance->Next_Entry;
} else
{
/* general case
*/
reference_inst = DDE_Handle_Table_Base;
while ( reference_inst->Next_Entry != this_instance )
{
reference_inst = this_instance->Next_Entry;
}
reference_inst->Next_Entry = this_instance->Next_Entry;
}
/* release the mutex and the heap entry
*/
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,TRUE,this_instance))
{
/* should record something here, but nothing left to hang it from !!
*/
return FALSE;
}
return TRUE;
}
/*****************************************************************
* DdeConnectList16 [DDEML.4]
*/
HCONVLIST WINAPI DdeConnectList16( DWORD idInst, HSZ hszService, HSZ hszTopic,
HCONVLIST hConvList, LPCONVCONTEXT16 pCC )
{
return DdeConnectList(idInst, hszService, hszTopic, hConvList,
(LPCONVCONTEXT)pCC);
}
/******************************************************************************
* DdeConnectList [USER32.93] Establishes conversation with DDE servers
*
* PARAMS
* idInst [I] Instance identifier
* hszService [I] Handle to service name string
* hszTopic [I] Handle to topic name string
* hConvList [I] Handle to conversation list
* pCC [I] Pointer to structure with context data
*
* RETURNS
* Success: Handle to new conversation list
* Failure: 0
*/
HCONVLIST WINAPI DdeConnectList( DWORD idInst, HSZ hszService, HSZ hszTopic,
HCONVLIST hConvList, LPCONVCONTEXT pCC )
{
FIXME("(%ld,%d,%d,%d,%p): stub\n", idInst, hszService, hszTopic,
hConvList,pCC);
return 1;
}
/*****************************************************************
* DdeQueryNextServer16 [DDEML.5]
*/
HCONV WINAPI DdeQueryNextServer16( HCONVLIST hConvList, HCONV hConvPrev )
{
return DdeQueryNextServer(hConvList, hConvPrev);
}
/*****************************************************************
* DdeQueryNextServer [USER32.112]
*/
HCONV WINAPI DdeQueryNextServer( HCONVLIST hConvList, HCONV hConvPrev )
{
FIXME("(%d,%d): stub\n",hConvList,hConvPrev);
return 0;
}
/*****************************************************************
* DdeQueryStringA [USER32.113]
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Mar 1999 Keith Matthews Added links to instance table and related processing
*
*/
DWORD WINAPI DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT iCodePage)
{
DWORD ret = 0;
CHAR pString[MAX_BUFFER_LEN];
DDE_HANDLE_ENTRY *reference_inst;
FIXME(
"(%ld, 0x%x, %p, %ld, %d): partial stub\n",
idInst,
hsz,
psz,
cchMax,
iCodePage);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! */
/* needs something for DdeGetLAstError even if the manual doesn't say so */
return FALSE;
}
if ( !WaitForMutex(handle_mutex) )
{
return FALSE;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
if ( reference_inst == NULL )
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return FALSE;
/*
Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
*/
return FALSE;
}
if( iCodePage == CP_WINANSI )
{
/* If psz is null, we have to return only the length
* of the string.
*/
if( psz == NULL )
{
psz = pString;
cchMax = MAX_BUFFER_LEN;
}
ret = GlobalGetAtomNameA( hsz, (LPSTR)psz, cchMax );
} else {
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
}
TRACE("returning pointer\n");
return ret;
}
/*****************************************************************
* DdeQueryStringW [USER32.114]
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
*
*/
DWORD WINAPI DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT iCodePage)
{
DWORD ret = 0;
WCHAR pString[MAX_BUFFER_LEN];
int factor = 1;
FIXME(
"(%ld, 0x%x, %p, %ld, %d): stub\n",
idInst,
hsz,
psz,
cchMax,
iCodePage);
if( iCodePage == CP_WINUNICODE )
{
/* If psz is null, we have to return only the length
* of the string.
*/
if( psz == NULL )
{
psz = pString;
cchMax = MAX_BUFFER_LEN;
/* Note: According to documentation if the psz parameter
* was NULL this API must return the length of the string in bytes.
*/
factor = (int) sizeof(WCHAR)/sizeof(BYTE);
}
ret = GlobalGetAtomNameW( hsz, (LPWSTR)psz, cchMax ) * factor;
}
return ret;
}
/*****************************************************************
*
* DdeQueryString16 (DDEML.23)
*
******************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 K Matthews stub only
*/
DWORD WINAPI DdeQueryString16(DWORD idInst, HSZ hsz, LPSTR lpsz, DWORD cchMax, INT16 codepage)
{
FIXME("(%ld, 0x%x, %p, %ld, %d): stub \n",
idInst,
hsz,
lpsz,
cchMax,
codepage);
return 0;
}
/*****************************************************************
* DdeDisconnectList (DDEML.6)
*/
BOOL16 WINAPI DdeDisconnectList16( HCONVLIST hConvList )
{
return (BOOL16)DdeDisconnectList(hConvList);
}
/******************************************************************************
* DdeDisconnectList [USER32.98] Destroys list and terminates conversations
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
BOOL WINAPI DdeDisconnectList(
HCONVLIST hConvList) /* [in] Handle to conversation list */
{
FIXME("(%d): stub\n", hConvList);
return TRUE;
}
/*****************************************************************
* DdeConnect16 (DDEML.7)
*/
HCONV WINAPI DdeConnect16( DWORD idInst, HSZ hszService, HSZ hszTopic,
LPCONVCONTEXT16 pCC )
{
FIXME("empty stub\n" );
return 0;
}
/*****************************************************************
* DdeConnect (USER32.92)
*/
HCONV WINAPI DdeConnect( DWORD idInst, HSZ hszService, HSZ hszTopic,
LPCONVCONTEXT pCC )
{
FIXME("(0x%lx,%d,%d,%p): stub\n",idInst,hszService,hszTopic,
pCC);
return 0;
}
/*****************************************************************
* DdeDisconnect16 (DDEML.8)
*/
BOOL16 WINAPI DdeDisconnect16( HCONV hConv )
{
return (BOOL16)DdeDisconnect( hConv );
}
/*****************************************************************
* DdeSetUserHandle16 (DDEML.10)
*/
BOOL16 WINAPI DdeSetUserHandle16( HCONV hConv, DWORD id, DWORD hUser )
{
FIXME("(%d,%ld,%ld): stub\n",hConv,id, hUser );
return 0;
}
/*****************************************************************
* DdeCreateDataHandle16 (DDEML.14)
*/
HDDEDATA WINAPI DdeCreateDataHandle16( DWORD idInst, LPBYTE pSrc, DWORD cb,
DWORD cbOff, HSZ hszItem, UINT16 wFmt,
UINT16 afCmd )
{
return DdeCreateDataHandle(idInst,
pSrc,
cb,
cbOff,
hszItem,
wFmt,
afCmd);
}
/*****************************************************************
* DdeCreateDataHandle (USER32.94)
*/
HDDEDATA WINAPI DdeCreateDataHandle( DWORD idInst, LPBYTE pSrc, DWORD cb,
DWORD cbOff, HSZ hszItem, UINT wFmt,
UINT afCmd )
{
FIXME(
"(%ld,%p,%ld,%ld,0x%x,%d,%d): stub\n",
idInst,
pSrc,
cb,
cbOff,
hszItem,
wFmt,
afCmd );
return 0;
}
/*****************************************************************
* DdeDisconnect (USER32.97)
*/
BOOL WINAPI DdeDisconnect( HCONV hConv )
{
FIXME("empty stub\n" );
return 0;
}
/*****************************************************************
* DdeReconnect (DDEML.37) (USER32.115)
*/
HCONV WINAPI DdeReconnect( HCONV hConv )
{
FIXME("empty stub\n" );
return 0;
}
/*****************************************************************
* DdeCreateStringHandle16 (DDEML.21)
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 ? ? basic stub
* 1.1 June 1999 Keith Matthews amended onward call to supply default
* code page if none supplied by caller
*/
HSZ WINAPI DdeCreateStringHandle16( DWORD idInst, LPCSTR str, INT16 codepage )
{
if ( codepage )
{
return DdeCreateStringHandleA( idInst, str, codepage );
} else {
TRACE("Default codepage supplied\n");
return DdeCreateStringHandleA( idInst, str, CP_WINANSI);
}
}
/*****************************************************************
* DdeCreateStringHandleA [USER32.95]
*
* RETURNS
* Success: String handle
* Failure: 0
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Mar 1999 Keith Matthews Added links to instance table and related processing
*
*/
HSZ WINAPI DdeCreateStringHandleA( DWORD idInst, LPCSTR psz, INT codepage )
{
HSZ hsz = 0;
DDE_HANDLE_ENTRY *reference_inst;
TRACE("(%ld,%s,%d): partial stub\n",idInst,debugstr_a(psz),codepage);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! can return FALSE since effect is the same */
return FALSE;
}
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
if ( reference_inst == NULL )
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return 0;
/*
Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
*/
return 0;
}
if (codepage==CP_WINANSI)
{
hsz = GlobalAddAtomA (psz);
/* Save the handle so we know to clean it when
* uninitialize is called.
*/
TRACE("added atom %s with HSZ 0x%x, \n",debugstr_a(psz),hsz);
InsertHSZNode( hsz, reference_inst );
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst))
{
reference_inst->Last_Error = DMLERR_SYS_ERROR;
return 0;
}
TRACE("Returning pointer\n");
return hsz;
} else {
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
}
TRACE("Returning error\n");
return 0;
}
/******************************************************************************
* DdeCreateStringHandleW [USER32.96] Creates handle to identify string
*
* RETURNS
* Success: String handle
* Failure: 0
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Mar 1999 Keith Matthews Added links to instance table and related processing
*
*/
HSZ WINAPI DdeCreateStringHandleW(
DWORD idInst, /* [in] Instance identifier */
LPCWSTR psz, /* [in] Pointer to string */
INT codepage) /* [in] Code page identifier */
{
DDE_HANDLE_ENTRY *reference_inst;
HSZ hsz = 0;
TRACE("(%ld,%s,%d): partial stub\n",idInst,debugstr_w(psz),codepage);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! can return FALSE since effect is the same */
return FALSE;
}
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
TRACE("CreateString - Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
if ( reference_inst == NULL )
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return 0;
/*
Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
*/
return 0;
}
FIXME("(%ld,%s,%d): partial stub\n",idInst,debugstr_w(psz),codepage);
if (codepage==CP_WINUNICODE)
/*
Should we be checking this against the unicode/ascii nature of the call to DdeInitialize ?
*/
{
hsz = GlobalAddAtomW (psz);
/* Save the handle so we know to clean it when
* uninitialize is called.
*/
InsertHSZNode( hsz, reference_inst );
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst))
{
reference_inst->Last_Error = DMLERR_SYS_ERROR;
return 0;
}
TRACE("Returning pointer\n");
return hsz;
} else {
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
}
TRACE("Returning error\n");
return 0;
}
/*****************************************************************
* DdeFreeStringHandle16 (DDEML.22)
*/
BOOL16 WINAPI DdeFreeStringHandle16( DWORD idInst, HSZ hsz )
{
FIXME("idInst %ld hsz 0x%x\n",idInst,hsz);
return (BOOL)DdeFreeStringHandle( idInst, hsz );
}
/*****************************************************************
* DdeFreeStringHandle (USER32.101)
* RETURNS: success: nonzero
* fail: zero
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 Dec 1998 Corel/Macadamian Initial version
* 1.1 Apr 1999 Keith Matthews Added links to instance table and related processing
*
*/
BOOL WINAPI DdeFreeStringHandle( DWORD idInst, HSZ hsz )
{
DDE_HANDLE_ENTRY *reference_inst;
TRACE("(%ld,%d): \n",idInst,hsz);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
return TRUE;
}
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
if ( (reference_inst == NULL) || (reference_inst->Node_list == NULL))
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return TRUE;
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
return TRUE;
}
/* Remove the node associated with this HSZ.
*/
RemoveHSZNode( hsz , reference_inst);
/* Free the string associated with this HSZ.
*/
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
return GlobalDeleteAtom (hsz) ? 0 : hsz;
}
/*****************************************************************
* DdeFreeDataHandle16 (DDEML.19)
*/
BOOL16 WINAPI DdeFreeDataHandle16( HDDEDATA hData )
{
return (BOOL)DdeFreeDataHandle( hData );
}
/*****************************************************************
* DdeFreeDataHandle (USER32.100)
*/
BOOL WINAPI DdeFreeDataHandle( HDDEDATA hData )
{
FIXME("empty stub\n" );
return TRUE;
}
/*****************************************************************
* DdeKeepStringHandle16 (DDEML.24)
*/
BOOL16 WINAPI DdeKeepStringHandle16( DWORD idInst, HSZ hsz )
{
return (BOOL)DdeKeepStringHandle( idInst, hsz );
}
/*****************************************************************
* DdeKeepStringHandle (USER32.108)
*
* RETURNS: success: nonzero
* fail: zero
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 ? ? Stub only
* 1.1 Jun 1999 Keith Matthews First cut implementation
*
*/
BOOL WINAPI DdeKeepStringHandle( DWORD idInst, HSZ hsz )
{
DDE_HANDLE_ENTRY *reference_inst;
TRACE("(%ld,%d): \n",idInst,hsz);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! can return FALSE since effect is the same */
return FALSE;
}
if ( !WaitForMutex(handle_mutex) )
{
return FALSE;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
if ( (reference_inst == NULL) || (reference_inst->Node_list == NULL))
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return FALSE;
/* Nothing has been initialised - exit now ! can return FALSE since effect is the same */
return FALSE;
return FALSE;
}
DdeReserveAtom(reference_inst,hsz);
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
return TRUE;
}
/*****************************************************************
* DdeClientTransaction16 (DDEML.11)
*/
HDDEDATA WINAPI DdeClientTransaction16( LPVOID pData, DWORD cbData,
HCONV hConv, HSZ hszItem, UINT16 wFmt,
UINT16 wType, DWORD dwTimeout,
LPDWORD pdwResult )
{
return DdeClientTransaction( (LPBYTE)pData, cbData, hConv, hszItem,
wFmt, wType, dwTimeout, pdwResult );
}
/*****************************************************************
* DdeClientTransaction (USER32.90)
*/
HDDEDATA WINAPI DdeClientTransaction( LPBYTE pData, DWORD cbData,
HCONV hConv, HSZ hszItem, UINT wFmt,
UINT wType, DWORD dwTimeout,
LPDWORD pdwResult )
{
FIXME("empty stub\n" );
return 0;
}
/*****************************************************************
*
* DdeAbandonTransaction16 (DDEML.12)
*
*/
BOOL16 WINAPI DdeAbandonTransaction16( DWORD idInst, HCONV hConv,
DWORD idTransaction )
{
FIXME("empty stub\n" );
return TRUE;
}
/*****************************************************************
*
* DdeAbandonTransaction (USER32.87)
*
******************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 K Matthews stub only
*/
BOOL WINAPI DdeAbandonTransaction( DWORD idInst, HCONV hConv,
DWORD idTransaction )
{
FIXME("empty stub\n" );
return TRUE;
}
/*****************************************************************
* DdePostAdvise16 [DDEML.13]
*/
BOOL16 WINAPI DdePostAdvise16( DWORD idInst, HSZ hszTopic, HSZ hszItem )
{
return (BOOL16)DdePostAdvise(idInst, hszTopic, hszItem);
}
/******************************************************************************
* DdePostAdvise [USER32.110] 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 */
{
FIXME("(%ld,%d,%d): stub\n",idInst,hszTopic,hszItem);
return TRUE;
}
/*****************************************************************
* DdeAddData16 (DDEML.15)
*/
HDDEDATA WINAPI DdeAddData16( HDDEDATA hData, LPBYTE pSrc, DWORD cb,
DWORD cbOff )
{
FIXME("empty stub\n" );
return 0;
}
/*****************************************************************
*
* DdeAddData (USER32.89)
*
******************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 K Matthews stub only
*/
HDDEDATA WINAPI DdeAddData( HDDEDATA hData, LPBYTE pSrc, DWORD cb,
DWORD cbOff )
{
FIXME("empty stub\n" );
return 0;
}
/*****************************************************************
*
* DdeImpersonateClient (USER32.105)
*
******************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 K Matthews stub only
*/
BOOL WINAPI DdeImpersonateClient( HCONV hConv)
{
FIXME("empty stub\n" );
return TRUE;
}
/*****************************************************************
*
* DdeSetQualityOfService (USER32.116)
*
******************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 K Matthews stub only
*/
BOOL WINAPI DdeSetQualityOfService( HWND hwndClient, CONST SECURITY_QUALITY_OF_SERVICE *pqosNew,
PSECURITY_QUALITY_OF_SERVICE pqosPrev)
{
FIXME("empty stub\n" );
return TRUE;
}
/*****************************************************************
*
* DdeSetUserHandle (USER32.117)
*
******************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 March 1999 K Matthews stub only
*/
BOOL WINAPI DdeSetUserHandle( HCONV hConv, DWORD id, DWORD hUser)
{
FIXME("empty stub\n" );
return TRUE;
}
/******************************************************************************
* DdeGetData [USER32.102] Copies data from DDE object ot local buffer
*
* RETURNS
* Size of memory object associated with handle
*/
DWORD WINAPI DdeGetData(
HDDEDATA hData, /* [in] Handle to DDE object */
LPBYTE pDst, /* [in] Pointer to destination buffer */
DWORD cbMax, /* [in] Amount of data to copy */
DWORD cbOff) /* [in] Offset to beginning of data */
{
FIXME("(%d,%p,%ld,%ld): stub\n",hData,pDst,cbMax,cbOff);
return cbMax;
}
/*****************************************************************
* DdeGetData16 [DDEML.16]
*/
DWORD WINAPI DdeGetData16(
HDDEDATA hData,
LPBYTE pDst,
DWORD cbMax,
DWORD cbOff)
{
return DdeGetData(hData, pDst, cbMax, cbOff);
}
/*****************************************************************
* DdeAccessData16 (DDEML.17)
*/
LPBYTE WINAPI DdeAccessData16( HDDEDATA hData, LPDWORD pcbDataSize )
{
return DdeAccessData(hData, pcbDataSize);
}
/*****************************************************************
* DdeAccessData (USER32.88)
*/
LPBYTE WINAPI DdeAccessData( HDDEDATA hData, LPDWORD pcbDataSize )
{
FIXME("(%d,%p): stub\n", hData, pcbDataSize);
return 0;
}
/*****************************************************************
* DdeUnaccessData16 (DDEML.18)
*/
BOOL16 WINAPI DdeUnaccessData16( HDDEDATA hData )
{
return DdeUnaccessData(hData);
}
/*****************************************************************
* DdeUnaccessData (USER32.118)
*/
BOOL WINAPI DdeUnaccessData( HDDEDATA hData )
{
FIXME("(0x%x): stub\n", hData);
return 0;
}
/*****************************************************************
* DdeEnableCallback16 (DDEML.26)
*/
BOOL16 WINAPI DdeEnableCallback16( DWORD idInst, HCONV hConv, UINT16 wCmd )
{
return DdeEnableCallback(idInst, hConv, wCmd);
}
/*****************************************************************
* DdeEnableCallback (USER32.99)
*/
BOOL WINAPI DdeEnableCallback( DWORD idInst, HCONV hConv, UINT wCmd )
{
FIXME("(%ld, 0x%x, %d) stub\n", idInst, hConv, wCmd);
return 0;
}
/*****************************************************************
* DdeNameService16 (DDEML.27)
*/
HDDEDATA WINAPI DdeNameService16( DWORD idInst, HSZ hsz1, HSZ hsz2,
UINT16 afCmd )
{
return DdeNameService( idInst, hsz1, hsz2, afCmd );
}
/******************************************************************************
* DdeNameService [USER32.109] {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
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 ? ? Stub
* 1.1 Apr 1999 Keith Matthews Added trap for non-existent instance (uninitialised instance 0
* used by some MS programs for unfathomable reasons)
* 1.2 May 1999 Keith Matthews Added parameter validation and basic service name handling.
* Still needs callback parts
*
*/
HDDEDATA WINAPI DdeNameService( DWORD idInst, HSZ hsz1, HSZ hsz2,
UINT afCmd )
{
ServiceNode* this_service, *reference_service ;
DDE_HANDLE_ENTRY *this_instance;
DDE_HANDLE_ENTRY *reference_inst;
this_service = NULL;
FIXME("(%ld,%d,%d,%d): stub\n",idInst,hsz1,hsz2,afCmd);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now !
* needs something for DdeGetLastError */
return 0L;
}
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
this_instance = reference_inst;
if (reference_inst == NULL)
{
TRACE("Instance not found as initialised\n");
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance)) return TRUE;
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
return FALSE;
}
if ( hsz2 != 0L )
{
/* Illegal, reserved parameter
*/
reference_inst->Last_Error = DMLERR_INVALIDPARAMETER;
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
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");
reference_inst->Last_Error = DMLERR_DLL_USAGE;
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
return FALSE;
}
/* Loop to find all registered service and de-register them
*/
if ( reference_inst->ServiceNames == NULL )
{
/* None to unregister !!
*/
TRACE("General de-register - nothing registered\n");
reference_inst->Last_Error = DMLERR_DLL_USAGE;
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
return FALSE;
} else
{
this_service = reference_inst->ServiceNames;
while ( this_service->next != NULL)
{
TRACE("general deregister - iteration\n");
reference_service = this_service;
this_service = this_service->next;
DdeReleaseAtom(reference_inst,reference_service->hsz);
HeapFree(GetProcessHeap(), 0, reference_service); /* finished - release heap space used as work store */
}
DdeReleaseAtom(reference_inst,this_service->hsz);
HeapFree(GetProcessHeap(), 0, this_service); /* finished - release heap space used as work store */
reference_inst->ServiceNames = NULL;
TRACE("General de-register - finished\n");
}
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
return TRUE;
}
TRACE("Specific name action detected\n");
if ( afCmd & DNS_REGISTER )
{
/* Register new service name
*/
this_service = Find_Service_Name( hsz1, reference_inst );
if ( this_service )
ERR("Trying to register already registered service!\n");
else
{
TRACE("Adding service name\n");
DdeReserveAtom(reference_inst, hsz1);
this_service = (ServiceNode*)HeapAlloc( GetProcessHeap(), 0, sizeof(ServiceNode) );
this_service->hsz = hsz1;
this_service->FilterOn = TRUE;
this_service->next = reference_inst->ServiceNames;
reference_inst->ServiceNames = this_service;
}
}
if ( afCmd & DNS_UNREGISTER )
{
/* De-register service name
*/
ServiceNode **pServiceNode = &reference_inst->ServiceNames;
while ( *pServiceNode && (*pServiceNode)->hsz != hsz1 )
pServiceNode = &(*pServiceNode)->next;
this_service = *pServiceNode;
if ( !this_service )
ERR("Trying to de-register unregistered service!\n");
else
{
*pServiceNode = this_service->next;
DdeReleaseAtom(reference_inst,this_service->hsz);
HeapFree(GetProcessHeap(), 0, this_service);
}
}
if ( afCmd & DNS_FILTERON )
{
/* Set filter flags on to hold notifications of connection
*
* test coded this way as this is the default setting
*/
this_service = Find_Service_Name( hsz1, reference_inst );
if ( !this_service )
{
/* trying to filter where no service names !!
*/
reference_inst->Last_Error = DMLERR_DLL_USAGE;
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
return FALSE;
} else
{
this_service->FilterOn = TRUE;
}
}
if ( afCmd & DNS_FILTEROFF )
{
/* Set filter flags on to hold notifications of connection
*/
this_service = Find_Service_Name( hsz1, reference_inst );
if ( !this_service )
{
/* trying to filter where no service names !!
*/
reference_inst->Last_Error = DMLERR_DLL_USAGE;
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
return FALSE;
} else
{
this_service->FilterOn = FALSE;
}
}
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
return TRUE;
}
/*****************************************************************
* DdeGetLastError16 (DDEML.20)
*/
UINT16 WINAPI DdeGetLastError16( DWORD idInst )
{
return (UINT16)DdeGetLastError( idInst );
}
/******************************************************************************
* DdeGetLastError [USER32.103] Gets most recent error code
*
* PARAMS
* idInst [I] Instance identifier
*
* RETURNS
* Last error code
*
*****************************************************************
*
* Change History
*
* Vn Date Author Comment
*
* 1.0 ? ? Stub
* 1.1 Apr 1999 Keith Matthews Added response for non-existent instance (uninitialised instance 0
* used by some MS programs for unfathomable reasons)
* 1.2 May 1999 Keith Matthews Added interrogation of Last_Error for instance handle where found.
*
*/
UINT WINAPI DdeGetLastError( DWORD idInst )
{
DWORD error_code;
DDE_HANDLE_ENTRY *reference_inst;
FIXME("(%ld): stub\n",idInst);
if ( DDE_Max_Assigned_Instance == 0 )
{
/* Nothing has been initialised - exit now ! */
return DMLERR_DLL_NOT_INITIALIZED;
}
if ( !WaitForMutex(handle_mutex) )
{
return DMLERR_SYS_ERROR;
}
TRACE("Handle Mutex created/reserved\n");
/* First check instance
*/
reference_inst = Find_Instance_Entry(idInst);
if (reference_inst == NULL)
{
if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return TRUE;
/* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
return DMLERR_DLL_NOT_INITIALIZED;
}
error_code = reference_inst->Last_Error;
reference_inst->Last_Error = 0;
Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
return error_code;
}
/*****************************************************************
* DdeCmpStringHandles16 (DDEML.36)
*/
INT16 WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 )
{
return DdeCmpStringHandles(hsz1, hsz2);
}
/*****************************************************************
* DdeCmpStringHandles (USER32.91)
*
* Compares the value of two string handles. This comparison is
* not case sensitive.
*
* Returns:
* -1 The value of hsz1 is zero or less than hsz2
* 0 The values of hsz 1 and 2 are the same or both zero.
* 1 The value of hsz2 is zero of less than hsz1
*/
INT WINAPI DdeCmpStringHandles( HSZ hsz1, HSZ hsz2 )
{
CHAR psz1[MAX_BUFFER_LEN];
CHAR psz2[MAX_BUFFER_LEN];
int ret = 0;
int ret1, ret2;
TRACE("handle 1, handle 2\n" );
ret1 = GlobalGetAtomNameA( hsz1, psz1, MAX_BUFFER_LEN );
ret2 = GlobalGetAtomNameA( hsz2, psz2, MAX_BUFFER_LEN );
/* Make sure we found both strings.
*/
if( ret1 == 0 && ret2 == 0 )
{
/* If both are not found, return both "zero strings".
*/
ret = 0;
}
else if( ret1 == 0 )
{
/* If hsz1 is a not found, return hsz1 is "zero string".
*/
ret = -1;
}
else if( ret2 == 0 )
{
/* If hsz2 is a not found, return hsz2 is "zero string".
*/
ret = 1;
}
else
{
/* Compare the two strings we got ( case insensitive ).
*/
ret = strcasecmp( psz1, psz2 );
/* Since strcmp returns any number smaller than
* 0 when the first string is found to be less than
* the second one we must make sure we are returning
* the proper values.
*/
if( ret < 0 )
{
ret = -1;
}
else if( ret > 0 )
{
ret = 1;
}
}
return ret;
}
/*****************************************************************
* PackDDElParam (USER32.414)
*
* RETURNS
* success: nonzero
* failure: zero
*/
UINT WINAPI PackDDElParam(UINT msg, UINT uiLo, UINT uiHi)
{
FIXME("stub.\n");
return 0;
}
/*****************************************************************
* UnpackDDElParam (USER32.562)
*
* RETURNS
* success: nonzero
* failure: zero
*/
UINT WINAPI UnpackDDElParam(UINT msg, UINT lParam,
UINT *uiLo, UINT *uiHi)
{
FIXME("stub.\n");
return 0;
}
/*****************************************************************
* FreeDDElParam (USER32.204)
*
* RETURNS
* success: nonzero
* failure: zero
*/
UINT WINAPI FreeDDElParam(UINT msg, UINT lParam)
{
FIXME("stub.\n");
return 0;
}
/*****************************************************************
* ReuseDDElParam (USER32.446)
*
*/
UINT WINAPI ReuseDDElParam(UINT lParam, UINT msgIn, UINT msgOut,
UINT uiLi, UINT uiHi)
{
FIXME("stub.\n");
return 0;
}
/******************************************************************
* DdeQueryConvInfo16 (DDEML.9)
*
*/
UINT16 WINAPI DdeQueryConvInfo16( HCONV hconv, DWORD idTransaction , LPCONVINFO16 lpConvInfo)
{
FIXME("stub.\n");
return 0;
}
/******************************************************************
* DdeQueryConvInfo (USER32.111)
*
*/
UINT WINAPI DdeQueryConvInfo( HCONV hconv, DWORD idTransaction , LPCONVINFO lpConvInfo)
{
FIXME("stub.\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink