misc/ddeml.c

   1 /*
   2  * DDEML library
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  * Copyright 1997 Len White
   6  * Copyright 1999 Keith Matthews
   7  */
   8
   9 /* Only empty stubs for now */
  10
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include "winbase.h"
  14 #include "winuser.h"
  15 #include "ddeml.h"
  16 #include "winerror.h"
  17 #include "heap.h"
  18 #include "shm_semaph.h"
  19 #include "debug.h"
  20 #include "winnt.h"
  21
  22 /* Has defined in atom.c file.
  23  */
  24 #define MAX_ATOM_LEN              255
  25
  26 /* Maximum buffer size ( including the '\0' ).
  27  */
  28 #define MAX_BUFFER_LEN            (MAX_ATOM_LEN + 1)
  29
  30 /*  typedef struct {
  31         DWORD           nLength;
  32         LPVOID          lpSecurityDescriptor;
  33         BOOL            bInheritHandle;
  34 }       SECURITY_ATTRIBUTES; */
  35
  36 /* This is a simple list to keep track of the strings created
  37  * by DdeCreateStringHandle.  The list is used to free
  38  * the strings whenever DdeUninitialize is called.
  39  * This mechanism is not complete and does not handle multiple instances.
  40  * Most of the DDE API use a DWORD parameter indicating which instance
  41  * of a given program is calling them.  The API are supposed to
  42  * associate the data to the instance that created it.
  43  */
  44 typedef struct tagHSZNode HSZNode;
  45 struct tagHSZNode
  46 {
  47     HSZNode* next;
  48     HSZ hsz;
  49 };
  50
  51
  52 typedef struct DDE_HANDLE_ENTRY {
  53     BOOL16              Monitor;        /* have these two as full Booleans cos they'll be tested frequently */
  54     BOOL16              Client_only;    /* bit wasteful of space but it will be faster */
  55     BOOL16              Unicode;        /* Flag to indicate Win32 API used to initialise */
  56     BOOL16              Win16;          /* flag to indicate Win16 API used to initialize */
  57     DWORD               Instance_id;  /* needed to track monitor usage */
  58     struct DDE_HANDLE_ENTRY    *Next_Entry;
  59     HSZNode     *Node_list;
  60     PFNCALLBACK         CallBack;
  61     DWORD               CBF_Flags;
  62     DWORD               Monitor_flags;
  63     UINT              Txn_count;      /* count transactions open to simplify closure */
  64     DWORD               Last_Error;
  65 } DDE_HANDLE_ENTRY;
  66
  67 static DDE_HANDLE_ENTRY *DDE_Handle_Table_Base = NULL;
  68 static DWORD            DDE_Max_Assigned_Instance = 0;  /* OK for present, may have to worry about wrap-around later */
  69 static const char       inst_string[]= "DDEMaxInstance";
  70 static LPCWSTR          DDEInstanceAccess = (LPCWSTR)&inst_string;
  71 static const char       handle_string[] = "DDEHandleAccess";
  72 static LPCWSTR          DDEHandleAccess = (LPCWSTR)&handle_string;
  73 static HANDLE           inst_count_mutex = 0;
  74 static HANDLE           handle_mutex = 0;
  75        DDE_HANDLE_ENTRY *this_instance;
  76        SECURITY_ATTRIBUTES *s_att= NULL;
  77        DWORD            err_no = 0;
  78        DDE_HANDLE_ENTRY *reference_inst;
  79
  80 #define TRUE    1
  81 #define FALSE   0
  82
  83
  84
  85
  86
  87 /******************************************************************************
  88  *            RemoveHSZNodes    (INTERNAL)
  89  *
  90  * Remove a node from the list of HSZ nodes.
  91  *
  92  ******************************************************************************
  93  *
  94  *      Change History
  95  *
  96  *  Vn       Date       Author                  Comment
  97  *
  98  *  1.0      Dec 1998  Corel/Macadamian    Initial version
  99  *  1.1      Mar 1999  Keith Matthews      Added multiple instance handling
 100  *
 101  */
 102 static void RemoveHSZNode( HSZ hsz )
 103 {
 104     HSZNode* pPrev = NULL;
 105     HSZNode* pCurrent = NULL;
 106
 107     /* Set the current node at the start of the list.
 108      */
 109     pCurrent = reference_inst->Node_list;
 110     /* While we have more nodes.
 111      */
 112     while( pCurrent != NULL )
 113     {
 114         /* If we found the node we were looking for.
 115          */
 116         if( pCurrent->hsz == hsz )
 117         {
 118             /* Remove the node.
 119              */
 120             /* If the first node in the list is to to be removed.
 121              * Set the global list pointer to the next node.
 122              */
 123             if( pCurrent == reference_inst->Node_list )
 124             {
 125                 reference_inst->Node_list = pCurrent->next;
 126             }
 127             /* Just fix the pointers has to skip the current
 128              * node so we can delete it.
 129              */
 130             else
 131             {
 132                 pPrev->next = pCurrent->next;
 133             }
 134             /* Destroy this node.
 135              */
 136             free( pCurrent );
 137             break;
 138         }
 139         /* Save the previous node pointer.
 140          */
 141         pPrev = pCurrent;
 142         /* Move on to the next node.
 143          */
 144         pCurrent = pCurrent->next;
 145     }
 146 }
 147
 148 /******************************************************************************
 149  *            FreeAndRemoveHSZNodes    (INTERNAL)
 150  *
 151  * Frees up all the strings still allocated in the list and
 152  * remove all the nodes from the list of HSZ nodes.
 153  *
 154  ******************************************************************************
 155  *
 156  *      Change History
 157  *
 158  *  Vn       Date       Author                  Comment
 159  *
 160  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 161  *  1.1      Mar 1999  Keith Matthews      Added multiple instance handling
 162  *
 163  */
 164 static void FreeAndRemoveHSZNodes( DWORD idInst )
 165 {
 166     /* Free any strings created in this instance.
 167      */
 168     while( reference_inst->Node_list != NULL )
 169     {
 170         DdeFreeStringHandle( idInst, reference_inst->Node_list->hsz );
 171     }
 172 }
 173
 174 /******************************************************************************
 175  *            InsertHSZNode    (INTERNAL)
 176  *
 177  * Insert a node to the head of the list.
 178  *
 179  ******************************************************************************
 180  *
 181  *      Change History
 182  *
 183  *  Vn       Date       Author                  Comment
 184  *
 185  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 186  *  1.1      Mar 1999  Keith Matthews      Added instance handling
 187  *
 188  */
 189 static void InsertHSZNode( HSZ hsz )
 190 {
 191     if( hsz != 0 )
 192     {
 193         HSZNode* pNew = NULL;
 194         /* Create a new node for this HSZ.
 195          */
 196         pNew = (HSZNode*) malloc( sizeof( HSZNode ) );
 197         if( pNew != NULL )
 198         {
 199             /* Set the handle value.
 200              */
 201             pNew->hsz = hsz;
 202             /* Attach the node to the head of the list. i.e most recently added is first
 203              */
 204             pNew->next = reference_inst->Node_list;
 205             /* The new node is now at the head of the list
 206              * so set the global list pointer to it.
 207              */
 208             reference_inst->Node_list = pNew;
 209             TRACE(ddeml,"HSZ node list entry added\n");
 210         }
 211     }
 212 }
 213
 214 /*****************************************************************************
 215  *      Find_Instance_Entry
 216  *
 217  *      generic routine to return a pointer to the relevant DDE_HANDLE_ENTRY
 218  *      for an instance Id, or NULL if the entry does not exist
 219  *
 220  *      ASSUMES the mutex protecting the handle entry list is reserved before calling
 221  *
 222  ******************************************************************************
 223  *
 224  *      Change History
 225  *
 226  *  Vn       Date       Author                  Comment
 227  *
 228  *  1.0      March 1999  Keith Matthews      1st implementation
 229              */
 230  DDE_HANDLE_ENTRY *Find_Instance_Entry (DWORD InstId)
 231 {
 232         reference_inst =  DDE_Handle_Table_Base;
 233         while ( reference_inst != NULL )
 234         {
 235                 if ( reference_inst->Instance_id == InstId )
 236                 {
 237                         TRACE(ddeml,"Instance entry found\n");
 238                         return reference_inst;
 239         }
 240                 reference_inst = reference_inst->Next_Entry;
 241     }
 242         TRACE(ddeml,"Instance entry missing\n");
 243         return NULL;
 244 }
 245
 246 /******************************************************************************
 247  *      Release_reserved_mutex
 248  *
 249  *      generic routine to release a reserved mutex
 250  *
 251  *
 252  ******************************************************************************
 253  *
 254  *      Change History
 255  *
 256  *  Vn       Date       Author                  Comment
 257  *
 258  *  1.0      Jan 1999  Keith Matthews        Initial version
 259  *  1.1      Mar 1999  Keith Matthews        Corrected Heap handling. Corrected re-initialisation handling
 260  *
 261  */
 262  DWORD Release_reserved_mutex (HANDLE mutex, LPTSTR mutex_name, BOOL release_handle_m, BOOL release_this_i )
 263 {
 264         ReleaseMutex(mutex);
 265         if ( (err_no=GetLastError()) != 0 )
 266         {
 267                 ERR(ddeml,"ReleaseMutex failed - %s mutex %li\n",mutex_name,err_no);
 268                 HeapFree(SystemHeap, 0, this_instance);
 269                 if ( release_handle_m )
 270                 {
 271                         ReleaseMutex(handle_mutex);
 272                 }
 273                 return DMLERR_SYS_ERROR;
 274          }
 275         if ( release_this_i )
 276         {
 277                 HeapFree(SystemHeap, 0, this_instance);
 278         }
 279         return DMLERR_NO_ERROR;
 280 }
 281
 282 /******************************************************************************
 283  *              IncrementInstanceId
 284  *
 285  *      generic routine to increment the max instance Id and allocate a new application instance
 286  *
 287  ******************************************************************************
 288  *
 289  *      Change History
 290  *
 291  *  Vn       Date       Author                  Comment
 292  *
 293  *  1.0      Jan 1999  Keith Matthews        Initial version
 294  *
 295  */
 296 DWORD IncrementInstanceId()
 297 {
 298         SECURITY_ATTRIBUTES s_attrib;
 299         /*  Need to set up Mutex in case it is not already present */
 300         /* increment handle count & get value */
 301         if ( !inst_count_mutex )
 302         {
 303                 s_attrib.bInheritHandle = TRUE;
 304                 s_attrib.lpSecurityDescriptor = NULL;
 305                 s_attrib.nLength = sizeof(s_attrib);
 306                 inst_count_mutex = CreateMutexW(&s_attrib,1,DDEInstanceAccess); /* 1st time through */
 307         } else {
 308                 WaitForSingleObject(inst_count_mutex,1000); /* subsequent calls */
 309                 /*  FIXME  - needs refinement with popup for timeout, also is timeout interval OK */
 310         }
 311         if ( (err_no=GetLastError()) != 0 )
 312         {
 313                 ERR(ddeml,"CreateMutex failed - inst_count %li\n",err_no);
 314                 err_no=Release_reserved_mutex (handle_mutex,"handle_mutex",0,1);
 315                 return DMLERR_SYS_ERROR;
 316         }
 317         DDE_Max_Assigned_Instance++;
 318         this_instance->Instance_id = DDE_Max_Assigned_Instance;
 319         TRACE(ddeml,"New instance id %ld allocated\n",DDE_Max_Assigned_Instance);
 320         if (Release_reserved_mutex(inst_count_mutex,"instance_count",1,0)) return DMLERR_SYS_ERROR;
 321         return DMLERR_NO_ERROR;
 322 }
 323
 324 /******************************************************************************
 325  *            DdeInitialize16   (DDEML.2)
 326  */
 327 UINT16 WINAPI DdeInitialize16( LPDWORD pidInst, PFNCALLBACK16 pfnCallback,
 328                                DWORD afCmd, DWORD ulRes)
 329 {
 330     TRACE(ddeml,"DdeInitialize16 called - calling DdeInitializeA\n");
 331     return (UINT16)DdeInitializeA(pidInst,(PFNCALLBACK)pfnCallback,
 332                                     afCmd, ulRes);
 333 }
 334
 335
 336 /******************************************************************************
 337  *            DdeInitializeA   (USER32.106)
 338  */
 339 UINT WINAPI DdeInitializeA( LPDWORD pidInst, PFNCALLBACK pfnCallback,
 340                                 DWORD afCmd, DWORD ulRes )
 341 {
 342     TRACE(ddeml,"DdeInitializeA called - calling DdeInitializeW\n");
 343     return DdeInitializeW(pidInst,pfnCallback,afCmd,ulRes);
 344 }
 345
 346
 347 /******************************************************************************
 348  * DdeInitializeW [USER32.107]
 349  * Registers an application with the DDEML
 350  *
 351  * PARAMS
 352  *    pidInst     [I] Pointer to instance identifier
 353  *    pfnCallback [I] Pointer to callback function
 354  *    afCmd       [I] Set of command and filter flags
 355  *    ulRes       [I] Reserved
 356  *
 357  * RETURNS
 358  *    Success: DMLERR_NO_ERROR
 359  *    Failure: DMLERR_DLL_USAGE, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR
 360  *
 361  ******************************************************************************
 362  *
 363  *      Change History
 364  *
 365  *  Vn       Date       Author                  Comment
 366  *
 367  *  1.0      Pre 1998  Alexandre/Len         Initial Stub
 368  *  1.1      Jan 1999  Keith Matthews        Initial (near-)complete version
 369  *  1.2      Mar 1999  Keith Matthews        Corrected Heap handling, CreateMutex failure handling
 370  *
 371  */
 372 UINT WINAPI DdeInitializeW( LPDWORD pidInst, PFNCALLBACK pfnCallback,
 373                                 DWORD afCmd, DWORD ulRes )
 374 {
 375
 376 /*  probably not really capable of handling mutliple processes, but should handle
 377  *      multiple instances within one process */
 378
 379     SECURITY_ATTRIBUTES s_attrib;
 380     s_att = &s_attrib;
 381
 382     if( ulRes )
 383     {
 384         ERR(ddeml, "Reserved value not zero?  What does this mean?\n");
 385         FIXME(ddeml, "(%p,%p,0x%lx,%ld): stub\n", pidInst, pfnCallback,
 386               afCmd,ulRes);
 387         /* trap this and no more until we know more */
 388         return DMLERR_NO_ERROR;
 389     }
 390     if (!pfnCallback )
 391     {
 392         /*  this one may be wrong - MS dll seems to accept the condition,
 393             leave this until we find out more !! */
 394
 395
 396         /* can't set up the instance with nothing to act as a callback */
 397         TRACE(ddeml,"No callback provided\n");
 398         return DMLERR_INVALIDPARAMETER; /* might be DMLERR_DLL_USAGE */
 399      }
 400
 401      /* grab enough heap for one control struct - not really necessary for re-initialise
 402       * but allows us to use same validation routines */
 403      this_instance= (DDE_HANDLE_ENTRY*)HeapAlloc( SystemHeap, 0, sizeof(DDE_HANDLE_ENTRY) );
 404      if ( this_instance == NULL )
 405      {
 406         /* catastrophe !! warn user & abort */
 407         ERR (ddeml, "Instance create failed - out of memory\n");
 408         return DMLERR_SYS_ERROR;
 409      }
 410      this_instance->Next_Entry = NULL;
 411      this_instance->Monitor=(afCmd|APPCLASS_MONITOR);
 412
 413      /* messy bit, spec implies that 'Client Only' can be set in 2 different ways, catch 1 here */
 414
 415      this_instance->Client_only=afCmd&APPCMD_CLIENTONLY;
 416      this_instance->Instance_id = *pidInst; /* May need to add calling proc Id */
 417      this_instance->CallBack=*pfnCallback;
 418      this_instance->Txn_count=0;
 419      this_instance->Unicode = TRUE;
 420      this_instance->Win16 = FALSE;
 421      this_instance->Node_list = NULL; /* node will be added later */
 422      this_instance->Monitor_flags = afCmd & MF_MASK;
 423
 424      /* isolate CBF flags in one go, expect this will go the way of all attempts to be clever !! */
 425
 426      this_instance->CBF_Flags=afCmd^((afCmd&MF_MASK)|((afCmd&APPCMD_MASK)|(afCmd&APPCLASS_MASK)));
 427
 428      if ( ! this_instance->Client_only )
 429      {
 430
 431         /* Check for other way of setting Client-only !! */
 432
 433         this_instance->Client_only=(this_instance->CBF_Flags&CBF_FAIL_ALLSVRXACTIONS)
 434                         ==CBF_FAIL_ALLSVRXACTIONS;
 435      }
 436
 437      TRACE(ddeml,"instance created - checking validity \n");
 438
 439     if( *pidInst == 0 ) {
 440         /*  Initialisation of new Instance Identifier */
 441         TRACE(ddeml,"new instance, callback %p flags %lX\n",pfnCallback,afCmd);
 442         if ( DDE_Max_Assigned_Instance == 0 )
 443         {
 444                 /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
 445         /*  Need to set up Mutex in case it is not already present */
 446         s_att->bInheritHandle = TRUE;
 447         s_att->lpSecurityDescriptor = NULL;
 448         s_att->nLength = sizeof(s_att);
 449         handle_mutex = CreateMutexW(s_att,1,DDEHandleAccess);
 450         if ( (err_no=GetLastError()) != 0 )
 451         {
 452                 ERR(ddeml,"CreateMutex failed - handle list  %li\n",err_no);
 453                 HeapFree(SystemHeap, 0, this_instance);
 454                 return DMLERR_SYS_ERROR;
 455         }
 456         } else
 457         {
 458                 WaitForSingleObject(handle_mutex,1000);
 459                 if ( (err_no=GetLastError()) != 0 )
 460                 {
 461                         /*  FIXME  - needs refinement with popup for timeout, also is timeout interval OK */
 462
 463                         ERR(ddeml,"WaitForSingleObject failed - handle list %li\n",err_no);
 464                         return DMLERR_SYS_ERROR;
 465                 }
 466         }
 467
 468         TRACE(ddeml,"Handle Mutex created/reserved\n");
 469         if (DDE_Handle_Table_Base == NULL )
 470         {
 471                 /* can't be another instance in this case, assign to the base pointer */
 472                 DDE_Handle_Table_Base= this_instance;
 473
 474                 /* since first must force filter of XTYP_CONNECT and XTYP_WILDCONNECT for
 475                  *              present
 476                  *      -------------------------------      NOTE NOTE NOTE    --------------------------
 477                  *
 478                  *      the manual is not clear if this condition
 479                  *      applies to the first call to DdeInitialize from an application, or the
 480                  *      first call for a given callback !!!
 481                 */
 482
 483                 this_instance->CBF_Flags=this_instance->CBF_Flags|APPCMD_FILTERINITS;
 484                 TRACE(ddeml,"First application instance detected OK\n");
 485                 /*      allocate new instance ID */
 486                 if ((err_no = IncrementInstanceId()) ) return err_no;
 487         } else {
 488                 /* really need to chain the new one in to the latest here, but after checking conditions
 489                  *      such as trying to start a conversation from an application trying to monitor */
 490                 reference_inst =  DDE_Handle_Table_Base;
 491                 TRACE(ddeml,"Subsequent application instance - starting checks\n");
 492                 while ( reference_inst->Next_Entry != NULL )
 493                 {
 494                         /*
 495                         *       This set of tests will work if application uses same instance Id
 496                         *       at application level once allocated - which is what manual implies
 497                         *       should happen. If someone tries to be
 498                         *       clever (lazy ?) it will fail to pick up that later calls are for
 499                         *       the same application - should we trust them ?
 500                         */
 501                         if ( this_instance->Instance_id == reference_inst->Instance_id)
 502                         {
 503                                 /* Check 1 - must be same Client-only state */
 504
 505                                 if ( this_instance->Client_only != reference_inst->Client_only)
 506                                 {
 507                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 508                                                 return DMLERR_SYS_ERROR;
 509                                         return DMLERR_DLL_USAGE;
 510                                 }
 511
 512                                 /* Check 2 - cannot use 'Monitor' with any non-monitor modes */
 513
 514                                 if ( this_instance->Monitor != reference_inst->Monitor)
 515                                 {
 516                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 517                                                 return DMLERR_SYS_ERROR;
 518                                         return DMLERR_INVALIDPARAMETER;
 519                                 }
 520
 521                                 /* Check 3 - must supply different callback address */
 522
 523                                 if ( this_instance->CallBack == reference_inst->CallBack)
 524                                 {
 525                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 526                                                 return DMLERR_SYS_ERROR;
 527                                         return DMLERR_DLL_USAGE;
 528                                 }
 529                         }
 530                         reference_inst = reference_inst->Next_Entry;
 531                 }
 532                 /*  All cleared, add to chain */
 533
 534                 TRACE(ddeml,"Application Instance checks finished\n");
 535                 if ((err_no = IncrementInstanceId())) return err_no;
 536                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,0)) return DMLERR_SYS_ERROR;
 537                 reference_inst->Next_Entry = this_instance;
 538         }
 539         *pidInst = this_instance->Instance_id;
 540         TRACE(ddeml,"New application instance processing finished OK\n");
 541      } else {
 542         /* Reinitialisation situation   --- FIX  */
 543         TRACE(ddeml,"reinitialisation of (%p,%p,0x%lx,%ld): stub\n",pidInst,pfnCallback,afCmd,ulRes);
 544         WaitForSingleObject(handle_mutex,1000);
 545         if ( (err_no=GetLastError()) != 0 )
 546             {
 547
 548              /*  FIXME  - needs refinement with popup for timeout, also is timeout interval OK */
 549
 550                     ERR(ddeml,"WaitForSingleObject failed - handle list %li\n",err_no);
 551                     HeapFree(SystemHeap, 0, this_instance);
 552                     return DMLERR_SYS_ERROR;
 553         }
 554         if (DDE_Handle_Table_Base == NULL )
 555         {
 556                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1)) return DMLERR_SYS_ERROR;
 557                 return DMLERR_DLL_USAGE;
 558         }
 559         HeapFree(SystemHeap, 0, this_instance); /* finished - release heap space used as work store */
 560         /* can't reinitialise if we have initialised nothing !! */
 561         reference_inst =  DDE_Handle_Table_Base;
 562         /* must first check if we have been given a valid instance to re-initialise !!  how do we do that ? */
 563         /*
 564         *       MS allows initialisation without specifying a callback, should we allow addition of the
 565         *       callback by a later call to initialise ? - if so this lot will have to change
 566         */
 567         while ( reference_inst->Next_Entry != NULL )
 568         {
 569                 if ( *pidInst == reference_inst->Instance_id && pfnCallback == reference_inst->CallBack )
 570                 {
 571                         /* Check 1 - cannot change client-only mode if set via APPCMD_CLIENTONLY */
 572
 573                         if (  reference_inst->Client_only )
 574                         {
 575                            if  ((reference_inst->CBF_Flags & CBF_FAIL_ALLSVRXACTIONS) != CBF_FAIL_ALLSVRXACTIONS)
 576                            {
 577                                 /* i.e. Was set to Client-only and through APPCMD_CLIENTONLY */
 578
 579                                 if ( ! ( afCmd & APPCMD_CLIENTONLY))
 580                                 {
 581                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 582                                                 return DMLERR_SYS_ERROR;
 583                                         return DMLERR_DLL_USAGE;
 584                                 }
 585                            }
 586                         }
 587                         /* Check 2 - cannot change monitor modes */
 588
 589                         if ( this_instance->Monitor != reference_inst->Monitor)
 590                         {
 591                                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 592                                         return DMLERR_SYS_ERROR;
 593                                 return DMLERR_DLL_USAGE;
 594                         }
 595
 596                         /* Check 3 - trying to set Client-only via APPCMD when not set so previously */
 597
 598                         if (( afCmd&APPCMD_CLIENTONLY) && ! reference_inst->Client_only )
 599                         {
 600                                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 601                                         return DMLERR_SYS_ERROR;
 602                                 return DMLERR_DLL_USAGE;
 603                         }
 604                         break;
 605                 }
 606                 reference_inst = reference_inst->Next_Entry;
 607         }
 608         if ( reference_inst->Next_Entry == NULL )
 609         {
 610                 /* Crazy situation - trying to re-initialize something that has not beeen initialized !!
 611                 *
 612                 *       Manual does not say what we do, cannot return DMLERR_NOT_INITIALIZED so what ?
 613                 */
 614                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 615                         return DMLERR_SYS_ERROR;
 616                 return DMLERR_INVALIDPARAMETER;
 617         }
 618         /*              All checked - change relevant flags */
 619
 620         reference_inst->CBF_Flags = this_instance->CBF_Flags;
 621         reference_inst->Client_only = this_instance->Client_only;
 622         reference_inst->Monitor_flags = this_instance->Monitor_flags;
 623         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1))
 624                 return DMLERR_SYS_ERROR;
 625      }
 626
 627     return DMLERR_NO_ERROR;
 628 }
 629
 630
 631 /*****************************************************************
 632  *            DdeUninitialize16   (DDEML.3)
 633  */
 634 BOOL16 WINAPI DdeUninitialize16( DWORD idInst )
 635 {
 636     FIXME(ddeml," stub calling DdeUninitialize\n");
 637     return (BOOL16)DdeUninitialize( idInst );
 638 }
 639
 640
 641 /*****************************************************************
 642  * DdeUninitialize [USER32.119]  Frees DDEML resources
 643  *
 644  * PARAMS
 645  *    idInst [I] Instance identifier
 646  *
 647  * RETURNS
 648  *    Success: TRUE
 649  *    Failure: FALSE
 650  */
 651
 652 BOOL WINAPI DdeUninitialize( DWORD idInst )
 653 {
 654         /*  Stage one - check if we have a handle for this instance
 655                                                                         */
 656         SECURITY_ATTRIBUTES s_attrib;
 657         s_att = &s_attrib;
 658
 659         if ( DDE_Max_Assigned_Instance == 0 )
 660         {
 661                 /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
 662                 return TRUE;
 663         }
 664         WaitForSingleObject(handle_mutex,1000);
 665         if ( (err_no=GetLastError()) != 0 )
 666         {
 667                 /*  FIXME  - needs refinement with popup for timeout, also is timeout interval OK */
 668
 669                 ERR(ddeml,"WaitForSingleObject failed - handle list %li\n",err_no);
 670                 return DMLERR_SYS_ERROR;
 671         }
 672         TRACE(ddeml,"Uninitialize - Handle Mutex created/reserved\n");
 673         /*  First check instance
 674         */
 675         this_instance = Find_Instance_Entry(idInst);
 676         if ( this_instance == NULL )
 677         {
 678                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE)) return FALSE;
 679                 /*
 680                   *     Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
 681                 */
 682                 return FALSE;
 683         }
 684         FIXME(ddeml, "(%ld): partial stub\n", idInst);
 685
 686     /* Free the nodes that were not freed by this instance
 687      * and remove the nodes from the list of HSZ nodes.
 688      */
 689     FreeAndRemoveHSZNodes( idInst );
 690
 691         /* OK now delete the instance handle itself */
 692
 693         if ( DDE_Handle_Table_Base == this_instance )
 694         {
 695                 /* special case - the first/only entry
 696                 */
 697                 DDE_Handle_Table_Base = this_instance->Next_Entry;
 698         } else
 699         {
 700                 /* general case
 701                 */
 702                 reference_inst->Next_Entry = DDE_Handle_Table_Base;
 703                 while ( reference_inst->Next_Entry != this_instance )
 704                 {
 705                         reference_inst = this_instance->Next_Entry;
 706                 }
 707                 reference_inst->Next_Entry = this_instance->Next_Entry;
 708         }
 709         /* release the mutex and the heap entry
 710         */
 711         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,TRUE))
 712         {
 713                 /* should record something here, but nothing left to hang it from !!
 714                 */
 715                 return FALSE;
 716         }
 717     return TRUE;
 718 }
 719
 720
 721 /*****************************************************************
 722  * DdeConnectList16 [DDEML.4]
 723  */
 724
 725 HCONVLIST WINAPI DdeConnectList16( DWORD idInst, HSZ hszService, HSZ hszTopic,
 726                  HCONVLIST hConvList, LPCONVCONTEXT16 pCC )
 727 {
 728     return DdeConnectList(idInst, hszService, hszTopic, hConvList,
 729                             (LPCONVCONTEXT)pCC);
 730 }
 731
 732
 733 /******************************************************************************
 734  * DdeConnectList [USER32.93]  Establishes conversation with DDE servers
 735  *
 736  * PARAMS
 737  *    idInst     [I] Instance identifier
 738  *    hszService [I] Handle to service name string
 739  *    hszTopic   [I] Handle to topic name string
 740  *    hConvList  [I] Handle to conversation list
 741  *    pCC        [I] Pointer to structure with context data
 742  *
 743  * RETURNS
 744  *    Success: Handle to new conversation list
 745  *    Failure: 0
 746  */
 747 HCONVLIST WINAPI DdeConnectList( DWORD idInst, HSZ hszService, HSZ hszTopic,
 748                  HCONVLIST hConvList, LPCONVCONTEXT pCC )
 749 {
 750     FIXME(ddeml, "(%ld,%ld,%ld,%ld,%p): stub\n", idInst, hszService, hszTopic,
 751           hConvList,pCC);
 752     return 1;
 753 }
 754
 755
 756 /*****************************************************************
 757  * DdeQueryNextServer16 [DDEML.5]
 758  */
 759 HCONV WINAPI DdeQueryNextServer16( HCONVLIST hConvList, HCONV hConvPrev )
 760 {
 761     return DdeQueryNextServer(hConvList, hConvPrev);
 762 }
 763
 764
 765 /*****************************************************************
 766  * DdeQueryNextServer [USER32.112]
 767  */
 768 HCONV WINAPI DdeQueryNextServer( HCONVLIST hConvList, HCONV hConvPrev )
 769 {
 770     FIXME(ddeml, "(%ld,%ld): stub\n",hConvList,hConvPrev);
 771     return 0;
 772 }
 773
 774 /*****************************************************************
 775  * DdeQueryStringA [USER32.113]
 776  *
 777  *****************************************************************
 778  *
 779  *      Change History
 780  *
 781  *  Vn       Date       Author                  Comment
 782  *
 783  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 784  *
 785  */
 786 DWORD WINAPI DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT iCodePage)
 787 {
 788     DWORD ret = 0;
 789     CHAR pString[MAX_BUFFER_LEN];
 790
 791     FIXME(ddeml,
 792          "(%ld, 0x%lx, %p, %ld, %d): stub\n",
 793          idInst,
 794          hsz,
 795          psz,
 796          cchMax,
 797          iCodePage);
 798
 799     if( iCodePage == CP_WINANSI )
 800     {
 801         /* If psz is null, we have to return only the length
 802          * of the string.
 803          */
 804         if( psz == NULL )
 805         {
 806             psz = pString;
 807             cchMax = MAX_BUFFER_LEN;
 808 }
 809
 810         ret = GlobalGetAtomNameA( hsz, (LPSTR)psz, cchMax );
 811     }
 812
 813     return ret;
 814 }
 815
 816 /*****************************************************************
 817  * DdeQueryStringW [USER32.114]
 818  *
 819  *****************************************************************
 820  *
 821  *      Change History
 822  *
 823  *  Vn       Date       Author                  Comment
 824  *
 825  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 826  *
 827  */
 828
 829 DWORD WINAPI DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT iCodePage)
 830 {
 831     DWORD ret = 0;
 832     WCHAR pString[MAX_BUFFER_LEN];
 833     int factor = 1;
 834
 835     FIXME(ddeml,
 836          "(%ld, 0x%lx, %p, %ld, %d): stub\n",
 837          idInst,
 838          hsz,
 839          psz,
 840          cchMax,
 841          iCodePage);
 842
 843     if( iCodePage == CP_WINUNICODE )
 844     {
 845         /* If psz is null, we have to return only the length
 846          * of the string.
 847          */
 848         if( psz == NULL )
 849         {
 850             psz = pString;
 851             cchMax = MAX_BUFFER_LEN;
 852             /* Note: According to documentation if the psz parameter
 853              * was NULL this API must return the length of the string in bytes.
 854              */
 855             factor = (int) sizeof(WCHAR)/sizeof(BYTE);
 856         }
 857         ret = GlobalGetAtomNameW( hsz, (LPWSTR)psz, cchMax ) * factor;
 858     }
 859     return ret;
 860 }
 861
 862 /*****************************************************************
 863 *
 864 *               DdeQueryString16 (DDEML.23)
 865 *
 866 ******************************************************************
 867  *
 868  *      Change History
 869  *
 870  *  Vn       Date       Author                  Comment
 871  *
 872  *  1.0      March 1999 K Matthews              stub only
 873  */
 874
 875 DWORD WINAPI DdeQueryString16(DWORD idInst, HSZ hsz, LPSTR lpsz, DWORD cchMax, int codepage)
 876 {
 877         FIXME(ddeml,"(%ld, 0x%lx, %p, %ld, %d): stub \n",
 878          idInst,
 879          hsz,
 880          lpsz,
 881          cchMax,
 882          codepage);
 883         return 0;
 884 }
 885
 886
 887 /*****************************************************************
 888  *            DdeDisconnectList (DDEML.6)
 889  */
 890 BOOL16 WINAPI DdeDisconnectList16( HCONVLIST hConvList )
 891 {
 892     return (BOOL16)DdeDisconnectList(hConvList);
 893 }
 894
 895
 896 /******************************************************************************
 897  * DdeDisconnectList [USER32.98]  Destroys list and terminates conversations
 898  *
 899  * RETURNS
 900  *    Success: TRUE
 901  *    Failure: FALSE
 902  */
 903 BOOL WINAPI DdeDisconnectList(
 904     HCONVLIST hConvList) /* [in] Handle to conversation list */
 905 {
 906     FIXME(ddeml, "(%ld): stub\n", hConvList);
 907     return TRUE;
 908 }
 909
 910
 911 /*****************************************************************
 912  *            DdeConnect16   (DDEML.7)
 913  */
 914 HCONV WINAPI DdeConnect16( DWORD idInst, HSZ hszService, HSZ hszTopic,
 915                            LPCONVCONTEXT16 pCC )
 916 {
 917     FIXME( ddeml, "empty stub\n" );
 918     return 0;
 919 }
 920
 921
 922 /*****************************************************************
 923  *            DdeConnect   (USER32.92)
 924  */
 925 HCONV WINAPI DdeConnect( DWORD idInst, HSZ hszService, HSZ hszTopic,
 926                            LPCONVCONTEXT pCC )
 927 {
 928     FIXME(ddeml, "(0x%lx,%ld,%ld,%p): stub\n",idInst,hszService,hszTopic,
 929           pCC);
 930     return 0;
 931 }
 932
 933
 934 /*****************************************************************
 935  *            DdeDisconnect16   (DDEML.8)
 936  */
 937 BOOL16 WINAPI DdeDisconnect16( HCONV hConv )
 938 {
 939     return (BOOL16)DdeDisconnect( hConv );
 940 }
 941
 942 /*****************************************************************
 943  *            DdeSetUserHandle16 (DDEML.10)
 944  */
 945 BOOL16 WINAPI DdeSetUserHandle16( HCONV hConv, DWORD id, DWORD hUser )
 946 {
 947     FIXME( ddeml, "(%ld,%ld,%ld): stub\n",hConv,id, hUser );
 948     return 0;
 949 }
 950
 951 /*****************************************************************
 952  *            DdeCreateDataHandle16 (DDEML.14)
 953  */
 954 HDDEDATA WINAPI DdeCreateDataHandle16( DWORD idInst, LPBYTE pSrc, DWORD cb,
 955                                      DWORD cbOff, HSZ hszItem, UINT16 wFmt,
 956                                      UINT16 afCmd )
 957 {
 958     return DdeCreateDataHandle(idInst,
 959                                 pSrc,
 960                                 cb,
 961                                 cbOff,
 962                                 hszItem,
 963                                 wFmt,
 964                                 afCmd);
 965 }
 966
 967 /*****************************************************************
 968  *            DdeCreateDataHandle (USER32.94)
 969  */
 970 HDDEDATA WINAPI DdeCreateDataHandle( DWORD idInst, LPBYTE pSrc, DWORD cb,
 971                                        DWORD cbOff, HSZ hszItem, UINT wFmt,
 972                                        UINT afCmd )
 973 {
 974     FIXME( ddeml,
 975           "(%ld,%p,%ld,%ld,0x%lx,%d,%d): stub\n",
 976           idInst,
 977           pSrc,
 978           cb,
 979           cbOff,
 980            hszItem,
 981           wFmt,
 982           afCmd );
 983
 984     return 0;
 985 }
 986
 987 /*****************************************************************
 988  *            DdeDisconnect   (USER32.97)
 989  */
 990 BOOL WINAPI DdeDisconnect( HCONV hConv )
 991 {
 992     FIXME( ddeml, "empty stub\n" );
 993     return 0;
 994 }
 995
 996
 997 /*****************************************************************
 998  *            DdeReconnect   (DDEML.37) (USER32.115)
 999  */
1000 HCONV WINAPI DdeReconnect( HCONV hConv )
1001 {
1002     FIXME( ddeml, "empty stub\n" );
1003     return 0;
1004 }
1005
1006
1007 /*****************************************************************
1008  *            DdeCreateStringHandle16   (DDEML.21)
1009  */
1010 HSZ WINAPI DdeCreateStringHandle16( DWORD idInst, LPCSTR str, INT16 codepage )
1011 {
1012     return DdeCreateStringHandleA( idInst, str, codepage );
1013 }
1014
1015
1016 /*****************************************************************
1017  * DdeCreateStringHandleA [USER32.95]
1018  *
1019  * RETURNS
1020  *    Success: String handle
1021  *    Failure: 1
1022  *
1023  *****************************************************************
1024  *
1025  *      Change History
1026  *
1027  *  Vn       Date       Author                  Comment
1028  *
1029  *  1.0      Dec 1998  Corel/Macadamian    Initial version
1030  *  1.1      Mar 1999  Keith Matthews      Added links to instance table and related processing
1031  *
1032  */
1033 HSZ WINAPI DdeCreateStringHandleA( DWORD idInst, LPCSTR psz, INT codepage )
1034 {
1035   HSZ hsz = 0;
1036   SECURITY_ATTRIBUTES s_attrib;
1037   s_att = &s_attrib;
1038   TRACE(ddeml, "(%ld,%s,%d): partial stub\n",idInst,debugstr_a(psz),codepage);
1039
1040
1041   if ( DDE_Max_Assigned_Instance == 0 )
1042   {
1043           /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
1044           return TRUE;
1045   }
1046   WaitForSingleObject(handle_mutex,1000);
1047   if ( (err_no=GetLastError()) != 0 )
1048   {
1049           /*  FIXME  - needs refinement with popup for timeout, also is timeout interval OK */
1050
1051           ERR(ddeml,"WaitForSingleObject failed - handle list %li\n",err_no);
1052           return DMLERR_SYS_ERROR;
1053   }
1054   TRACE(ddeml,"Handle Mutex created/reserved\n");
1055
1056   /*  First check instance
1057   */
1058   reference_inst = Find_Instance_Entry(idInst);
1059   if ( reference_inst == NULL )
1060   {
1061         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE)) return 0;
1062         /*
1063         Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
1064         */
1065         return 0;
1066   }
1067
1068   if (codepage==CP_WINANSI)
1069   {
1070       hsz = GlobalAddAtomA (psz);
1071       /* Save the handle so we know to clean it when
1072        * uninitialize is called.
1073        */
1074       InsertHSZNode( hsz );
1075       if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE))
1076         {
1077                 reference_inst->Last_Error = DMLERR_SYS_ERROR;
1078                 return 0;
1079         }
1080       TRACE(ddeml,"Returning pointer\n");
1081       return hsz;
1082   }
1083     TRACE(ddeml,"Returning error\n");
1084     return 0;
1085 }
1086
1087
1088 /******************************************************************************
1089  * DdeCreateStringHandleW [USER32.96]  Creates handle to identify string
1090  *
1091  * RETURNS
1092  *    Success: String handle
1093  *    Failure: 0
1094  *
1095  *****************************************************************
1096  *
1097  *      Change History
1098  *
1099  *  Vn       Date       Author                  Comment
1100  *
1101  *  1.0      Dec 1998  Corel/Macadamian    Initial version
1102  *  1.1      Mar 1999  Keith Matthews      Added links to instance table and related processing
1103  *
1104  */
1105 HSZ WINAPI DdeCreateStringHandleW(
1106     DWORD idInst,   /* [in] Instance identifier */
1107     LPCWSTR psz,    /* [in] Pointer to string */
1108     INT codepage) /* [in] Code page identifier */
1109 {
1110   HSZ hsz = 0;
1111   SECURITY_ATTRIBUTES s_attrib;
1112   s_att = &s_attrib;
1113
1114   /*  Need to set up Mutex in case it is not already present */
1115   s_att->bInheritHandle = TRUE;
1116   s_att->lpSecurityDescriptor = NULL;
1117   s_att->nLength = sizeof(s_att);
1118   handle_mutex = CreateMutexW(s_att,1,DDEHandleAccess);
1119   if ( (err_no=GetLastError()) != 0 )
1120   {
1121           ERR(ddeml,"CreateMutex failed - handle list  %li\n",err_no);
1122           return 0;
1123   }
1124   TRACE(ddeml,"CreateString - Handle Mutex created/reserved\n");
1125   /*  First check instance
1126   */
1127   reference_inst = Find_Instance_Entry(idInst);
1128   if ( reference_inst == NULL )
1129   {
1130         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE)) return 0;
1131         /*
1132         Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
1133         */
1134         return 0;
1135   }
1136
1137     FIXME(ddeml, "(%ld,%s,%d): partial stub\n",idInst,debugstr_w(psz),codepage);
1138
1139   if (codepage==CP_WINUNICODE)
1140   /*
1141   Should we be checking this against the unicode/ascii nature of the call to DdeInitialize ?
1142   */
1143   {
1144       hsz = GlobalAddAtomW (psz);
1145       /* Save the handle so we know to clean it when
1146        * uninitialize is called.
1147        */
1148       InsertHSZNode( hsz );
1149       if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE))
1150         {
1151                 reference_inst->Last_Error = DMLERR_SYS_ERROR;
1152                 return 0;
1153         }
1154       return hsz;
1155 }
1156   return 0;
1157 }
1158
1159
1160 /*****************************************************************
1161  *            DdeFreeStringHandle16   (DDEML.22)
1162  */
1163 BOOL16 WINAPI DdeFreeStringHandle16( DWORD idInst, HSZ hsz )
1164 {
1165         FIXME(ddeml,"idInst %ld hsz 0x%lx\n",idInst,hsz);
1166     return (BOOL)DdeFreeStringHandle( idInst, hsz );
1167 }
1168
1169
1170 /*****************************************************************
1171  *            DdeFreeStringHandle   (USER32.101)
1172  * RETURNS: success: nonzero
1173  *          fail:    zero
1174  */
1175 BOOL WINAPI DdeFreeStringHandle( DWORD idInst, HSZ hsz )
1176 {
1177     TRACE( ddeml, "(%ld,%ld): stub\n",idInst, hsz );
1178     /* Remove the node associated with this HSZ.
1179      */
1180     RemoveHSZNode( hsz );
1181     /* Free the string associated with this HSZ.
1182      */
1183     return GlobalDeleteAtom (hsz) ? 0 : hsz;
1184 }
1185
1186
1187 /*****************************************************************
1188  *            DdeFreeDataHandle16   (DDEML.19)
1189  */
1190 BOOL16 WINAPI DdeFreeDataHandle16( HDDEDATA hData )
1191 {
1192     return (BOOL)DdeFreeDataHandle( hData );
1193 }
1194
1195
1196 /*****************************************************************
1197  *            DdeFreeDataHandle   (USER32.100)
1198  */
1199 BOOL WINAPI DdeFreeDataHandle( HDDEDATA hData )
1200 {
1201     FIXME( ddeml, "empty stub\n" );
1202     return TRUE;
1203 }
1204
1205
1206
1207
1208 /*****************************************************************
1209  *            DdeKeepStringHandle16   (DDEML.24)
1210  */
1211 BOOL16 WINAPI DdeKeepStringHandle16( DWORD idInst, HSZ hsz )
1212 {
1213     return (BOOL)DdeKeepStringHandle( idInst, hsz );
1214 }
1215
1216
1217 /*****************************************************************
1218  *            DdeKeepStringHandle  (USER32.108)
1219  */
1220 BOOL WINAPI DdeKeepStringHandle( DWORD idInst, HSZ hsz )
1221 {
1222     FIXME( ddeml, "empty stub\n" );
1223     return TRUE;
1224 }
1225
1226
1227 /*****************************************************************
1228  *            DdeClientTransaction16  (DDEML.11)
1229  */
1230 HDDEDATA WINAPI DdeClientTransaction16( LPVOID pData, DWORD cbData,
1231                                         HCONV hConv, HSZ hszItem, UINT16 wFmt,
1232                                         UINT16 wType, DWORD dwTimeout,
1233                                         LPDWORD pdwResult )
1234 {
1235     return DdeClientTransaction( (LPBYTE)pData, cbData, hConv, hszItem,
1236                                    wFmt, wType, dwTimeout, pdwResult );
1237 }
1238
1239
1240 /*****************************************************************
1241  *            DdeClientTransaction  (USER32.90)
1242  */
1243 HDDEDATA WINAPI DdeClientTransaction( LPBYTE pData, DWORD cbData,
1244                                         HCONV hConv, HSZ hszItem, UINT wFmt,
1245                                         UINT wType, DWORD dwTimeout,
1246                                         LPDWORD pdwResult )
1247 {
1248     FIXME( ddeml, "empty stub\n" );
1249     return 0;
1250 }
1251
1252 /*****************************************************************
1253  *
1254  *            DdeAbandonTransaction16 (DDEML.12)
1255  *
1256  */
1257 BOOL16 WINAPI DdeAbandonTransaction16( DWORD idInst, HCONV hConv,
1258                                      DWORD idTransaction )
1259 {
1260     FIXME( ddeml, "empty stub\n" );
1261     return TRUE;
1262 }
1263
1264
1265 /*****************************************************************
1266  *
1267  *            DdeAbandonTransaction (USER32.87)
1268  *
1269 ******************************************************************
1270  *
1271  *      Change History
1272  *
1273  *  Vn       Date       Author                  Comment
1274  *
1275  *  1.0      March 1999 K Matthews              stub only
1276  */
1277 BOOL WINAPI DdeAbandonTransaction( DWORD idInst, HCONV hConv,
1278                                      DWORD idTransaction )
1279 {
1280     FIXME( ddeml, "empty stub\n" );
1281     return TRUE;
1282 }
1283
1284 /*****************************************************************
1285  * DdePostAdvise16 [DDEML.13]
1286  */
1287 BOOL16 WINAPI DdePostAdvise16( DWORD idInst, HSZ hszTopic, HSZ hszItem )
1288 {
1289     return (BOOL16)DdePostAdvise(idInst, hszTopic, hszItem);
1290 }
1291
1292
1293 /******************************************************************************
1294  * DdePostAdvise [USER32.110]  Send transaction to DDE callback function.
1295  *
1296  * RETURNS
1297  *    Success: TRUE
1298  *    Failure: FALSE
1299  */
1300 BOOL WINAPI DdePostAdvise(
1301     DWORD idInst, /* [in] Instance identifier */
1302     HSZ hszTopic, /* [in] Handle to topic name string */
1303     HSZ hszItem)  /* [in] Handle to item name string */
1304 {
1305     FIXME(ddeml, "(%ld,%ld,%ld): stub\n",idInst,hszTopic,hszItem);
1306     return TRUE;
1307 }
1308
1309
1310 /*****************************************************************
1311  *            DdeAddData16 (DDEML.15)
1312  */
1313 HDDEDATA WINAPI DdeAddData16( HDDEDATA hData, LPBYTE pSrc, DWORD cb,
1314                             DWORD cbOff )
1315 {
1316     FIXME( ddeml, "empty stub\n" );
1317     return 0;
1318 }
1319
1320 /*****************************************************************
1321  *
1322  *            DdeAddData (USER32.89)
1323  *
1324 ******************************************************************
1325  *
1326  *      Change History
1327  *
1328  *  Vn       Date       Author                  Comment
1329  *
1330  *  1.0      March 1999 K Matthews              stub only
1331  */
1332 HDDEDATA WINAPI DdeAddData( HDDEDATA hData, LPBYTE pSrc, DWORD cb,
1333                             DWORD cbOff )
1334 {
1335     FIXME( ddeml, "empty stub\n" );
1336     return 0;
1337 }
1338
1339
1340 /*****************************************************************
1341  *
1342  *            DdeImpersonateClient (USER32.105)
1343  *
1344 ******************************************************************
1345  *
1346  *      Change History
1347  *
1348  *  Vn       Date       Author                  Comment
1349  *
1350  *  1.0      March 1999 K Matthews              stub only
1351  */
1352
1353 BOOL WINAPI DdeImpersonateClient( HCONV hConv)
1354 {
1355     FIXME( ddeml, "empty stub\n" );
1356     return TRUE;
1357 }
1358
1359
1360 /*****************************************************************
1361  *
1362  *            DdeSetQualityOfService (USER32.116)
1363  *
1364 ******************************************************************
1365  *
1366  *      Change History
1367  *
1368  *  Vn       Date       Author                  Comment
1369  *
1370  *  1.0      March 1999 K Matthews              stub only
1371  */
1372
1373 BOOL WINAPI DdeSetQualityOfService( HWND hwndClient, CONST SECURITY_QUALITY_OF_SERVICE *pqosNew,
1374                                         PSECURITY_QUALITY_OF_SERVICE pqosPrev)
1375 {
1376     FIXME( ddeml, "empty stub\n" );
1377     return TRUE;
1378 }
1379
1380 /*****************************************************************
1381  *
1382  *            DdeSetUserHandle (USER32.117)
1383  *
1384 ******************************************************************
1385  *
1386  *      Change History
1387  *
1388  *  Vn       Date       Author                  Comment
1389  *
1390  *  1.0      March 1999 K Matthews              stub only
1391  */
1392
1393 BOOL WINAPI DdeSetUserHandle( HCONV hConv, DWORD id, DWORD hUser)
1394 {
1395     FIXME( ddeml, "empty stub\n" );
1396     return TRUE;
1397 }
1398
1399 /******************************************************************************
1400  * DdeGetData [USER32.102]  Copies data from DDE object ot local buffer
1401  *
1402  * RETURNS
1403  *    Size of memory object associated with handle
1404  */
1405 DWORD WINAPI DdeGetData(
1406     HDDEDATA hData, /* [in] Handle to DDE object */
1407     LPBYTE pDst,    /* [in] Pointer to destination buffer */
1408     DWORD cbMax,    /* [in] Amount of data to copy */
1409     DWORD cbOff)    /* [in] Offset to beginning of data */
1410 {
1411     FIXME(ddeml, "(%ld,%p,%ld,%ld): stub\n",hData,pDst,cbMax,cbOff);
1412     return cbMax;
1413 }
1414
1415
1416 /*****************************************************************
1417  * DdeGetData16 [DDEML.16]
1418  */
1419 DWORD WINAPI DdeGetData16(
1420     HDDEDATA hData,
1421     LPBYTE pDst,
1422     DWORD cbMax,
1423     DWORD cbOff)
1424 {
1425     return DdeGetData(hData, pDst, cbMax, cbOff);
1426 }
1427
1428
1429 /*****************************************************************
1430  *            DdeAccessData16 (DDEML.17)
1431  */
1432 LPBYTE WINAPI DdeAccessData16( HDDEDATA hData, LPDWORD pcbDataSize )
1433 {
1434      return DdeAccessData(hData, pcbDataSize);
1435 }
1436
1437 /*****************************************************************
1438  *            DdeAccessData (USER32.88)
1439  */
1440 LPBYTE WINAPI DdeAccessData( HDDEDATA hData, LPDWORD pcbDataSize )
1441 {
1442      FIXME( ddeml, "(%ld,%p): stub\n", hData, pcbDataSize);
1443      return 0;
1444 }
1445
1446 /*****************************************************************
1447  *            DdeUnaccessData16 (DDEML.18)
1448  */
1449 BOOL16 WINAPI DdeUnaccessData16( HDDEDATA hData )
1450 {
1451      return DdeUnaccessData(hData);
1452 }
1453
1454 /*****************************************************************
1455  *            DdeUnaccessData (USER32.118)
1456  */
1457 BOOL WINAPI DdeUnaccessData( HDDEDATA hData )
1458 {
1459      FIXME( ddeml, "(0x%lx): stub\n", hData);
1460
1461      return 0;
1462 }
1463
1464 /*****************************************************************
1465  *            DdeEnableCallback16 (DDEML.26)
1466  */
1467 BOOL16 WINAPI DdeEnableCallback16( DWORD idInst, HCONV hConv, UINT16 wCmd )
1468 {
1469      return DdeEnableCallback(idInst, hConv, wCmd);
1470 }
1471
1472 /*****************************************************************
1473  *            DdeEnableCallback (USER32.99)
1474  */
1475 BOOL WINAPI DdeEnableCallback( DWORD idInst, HCONV hConv, UINT wCmd )
1476 {
1477      FIXME( ddeml, "(%ld, 0x%lx, %d) stub\n", idInst, hConv, wCmd);
1478
1479      return 0;
1480 }
1481
1482 /*****************************************************************
1483  *            DdeNameService16  (DDEML.27)
1484  */
1485 HDDEDATA WINAPI DdeNameService16( DWORD idInst, HSZ hsz1, HSZ hsz2,
1486                                   UINT16 afCmd )
1487 {
1488     return DdeNameService( idInst, hsz1, hsz2, afCmd );
1489 }
1490
1491
1492 /******************************************************************************
1493  * DdeNameService [USER32.109]  {Un}registers service name of DDE server
1494  *
1495  * PARAMS
1496  *    idInst [I] Instance identifier
1497  *    hsz1   [I] Handle to service name string
1498  *    hsz2   [I] Reserved
1499  *    afCmd  [I] Service name flags
1500  *
1501  * RETURNS
1502  *    Success: Non-zero
1503  *    Failure: 0
1504  */
1505 HDDEDATA WINAPI DdeNameService( DWORD idInst, HSZ hsz1, HSZ hsz2,
1506                 UINT afCmd )
1507 {
1508     FIXME(ddeml, "(%ld,%ld,%ld,%d): stub\n",idInst,hsz1,hsz2,afCmd);
1509     return 1;
1510 }
1511
1512
1513 /*****************************************************************
1514  *            DdeGetLastError16  (DDEML.20)
1515  */
1516 UINT16 WINAPI DdeGetLastError16( DWORD idInst )
1517 {
1518     return (UINT16)DdeGetLastError( idInst );
1519 }
1520
1521
1522 /******************************************************************************
1523  * DdeGetLastError [USER32.103]  Gets most recent error code
1524  *
1525  * PARAMS
1526  *    idInst [I] Instance identifier
1527  *
1528  * RETURNS
1529  *    Last error code
1530  */
1531 UINT WINAPI DdeGetLastError( DWORD idInst )
1532 {
1533     FIXME(ddeml, "(%ld): stub\n",idInst);
1534     return 0;
1535 }
1536
1537
1538 /*****************************************************************
1539  *            DdeCmpStringHandles16 (DDEML.36)
1540  */
1541 int WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 )
1542 {
1543      return DdeCmpStringHandles(hsz1, hsz2);
1544 }
1545
1546 /*****************************************************************
1547  *            DdeCmpStringHandles (USER32.91)
1548  *
1549  * Compares the value of two string handles.  This comparison is
1550  * not case sensitive.
1551  *
1552  * Returns:
1553  * -1 The value of hsz1 is zero or less than hsz2
1554  * 0  The values of hsz 1 and 2 are the same or both zero.
1555  * 1  The value of hsz2 is zero of less than hsz1
1556  */
1557 int WINAPI DdeCmpStringHandles( HSZ hsz1, HSZ hsz2 )
1558 {
1559     CHAR psz1[MAX_BUFFER_LEN];
1560     CHAR psz2[MAX_BUFFER_LEN];
1561     int ret = 0;
1562     int ret1, ret2;
1563
1564     TRACE( ddeml, "handle 1, handle 2\n" );
1565
1566     ret1 = GlobalGetAtomNameA( hsz1, psz1, MAX_BUFFER_LEN );
1567     ret2 = GlobalGetAtomNameA( hsz2, psz2, MAX_BUFFER_LEN );
1568     /* Make sure we found both strings.
1569      */
1570     if( ret1 == 0 && ret2 == 0 )
1571     {
1572         /* If both are not found, return both  "zero strings".
1573          */
1574         ret = 0;
1575     }
1576     else if( ret1 == 0 )
1577     {
1578         /* If hsz1 is a not found, return hsz1 is "zero string".
1579          */
1580         ret = -1;
1581     }
1582     else if( ret2 == 0 )
1583     {
1584         /* If hsz2 is a not found, return hsz2 is "zero string".
1585          */
1586         ret = 1;
1587     }
1588     else
1589     {
1590         /* Compare the two strings we got ( case insensitive ).
1591          */
1592         ret = strcasecmp( psz1, psz2 );
1593         /* Since strcmp returns any number smaller than
1594          * 0 when the first string is found to be less than
1595          * the second one we must make sure we are returning
1596          * the proper values.
1597          */
1598         if( ret < 0 )
1599         {
1600             ret = -1;
1601         }
1602         else if( ret > 0 )
1603         {
1604             ret = 1;
1605         }
1606     }
1607
1608     return ret;
1609 }
1610
1611 /*****************************************************************
1612  *            PackDDElParam (USER32.414)
1613  *
1614  * RETURNS
1615  *   success: nonzero
1616  *   failure: zero
1617  */
1618 UINT WINAPI PackDDElParam(UINT msg, UINT uiLo, UINT uiHi)
1619 {
1620     FIXME(ddeml, "stub.\n");
1621     return 0;
1622 }
1623
1624
1625 /*****************************************************************
1626  *            UnpackDDElParam (USER32.562)
1627  *
1628  * RETURNS
1629  *   success: nonzero
1630  *   failure: zero
1631  */
1632 UINT WINAPI UnpackDDElParam(UINT msg, UINT lParam,
1633                               UINT *uiLo, UINT *uiHi)
1634 {
1635     FIXME(ddeml, "stub.\n");
1636     return 0;
1637 }
1638
1639
1640 /*****************************************************************
1641  *            FreeDDElParam (USER32.204)
1642  *
1643  * RETURNS
1644  *   success: nonzero
1645  *   failure: zero
1646  */
1647 UINT WINAPI FreeDDElParam(UINT msg, UINT lParam)
1648 {
1649     FIXME(ddeml, "stub.\n");
1650     return 0;
1651 }
1652
1653 /*****************************************************************
1654  *            ReuseDDElParam (USER32.446)
1655  *
1656  */
1657 UINT WINAPI ReuseDDElParam(UINT lParam, UINT msgIn, UINT msgOut,
1658                              UINT uiLi, UINT uiHi)
1659 {
1660     FIXME(ddeml, "stub.\n");
1661     return 0;
1662 }
1663
1664 /******************************************************************
1665  *              DdeQueryConvInfo16 (DDEML.9)
1666  *
1667  */
1668 UINT16 WINAPI DdeQueryConvInfo16( HCONV hconv, DWORD idTransaction , LPCONVINFO16 lpConvInfo)
1669 {
1670         FIXME(ddeml,"stub.\n");
1671         return 0;
1672 }
1673
1674
1675 /******************************************************************
1676  *              DdeQueryConvInfo (USER32.111)
1677  *
1678  */
1679 UINT WINAPI DdeQueryConvInfo( HCONV hconv, DWORD idTransaction , LPCONVINFO lpConvInfo)
1680 {
1681         FIXME(ddeml,"stub.\n");
1682         return 0;
1683 }