git.oblomov.eu Git - wine/blob - 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 "debugtools.h"
  19 #include "tchar.h"
  20 #include "winnt.h"
  21
  22 DEFAULT_DEBUG_CHANNEL(ddeml)
  23
  24 /* Has defined in atom.c file.
  25  */
  26 #define MAX_ATOM_LEN              255
  27
  28 /* Maximum buffer size ( including the '\0' ).
  29  */
  30 #define MAX_BUFFER_LEN            (MAX_ATOM_LEN + 1)
  31
  32 /*  typedef struct {
  33         DWORD           nLength;
  34         LPVOID          lpSecurityDescriptor;
  35         BOOL            bInheritHandle;
  36 }       SECURITY_ATTRIBUTES; */
  37
  38 /* This is a simple list to keep track of the strings created
  39  * by DdeCreateStringHandle.  The list is used to free
  40  * the strings whenever DdeUninitialize is called.
  41  * This mechanism is not complete and does not handle multiple instances.
  42  * Most of the DDE API use a DWORD parameter indicating which instance
  43  * of a given program is calling them.  The API are supposed to
  44  * associate the data to the instance that created it.
  45  */
  46 typedef struct tagHSZNode HSZNode;
  47 struct tagHSZNode
  48 {
  49     HSZNode* next;
  50     HSZ hsz;
  51 };
  52
  53
  54 typedef struct tagServiceNode ServiceNode;
  55 struct tagServiceNode
  56 {
  57     ServiceNode* next;
  58     HSZ hsz;
  59     BOOL16              FilterOn;
  60 };
  61 typedef struct DDE_HANDLE_ENTRY {
  62     BOOL16              Monitor;        /* have these two as full Booleans cos they'll be tested frequently */
  63     BOOL16              Client_only;    /* bit wasteful of space but it will be faster */
  64     BOOL16              Unicode;        /* Flag to indicate Win32 API used to initialise */
  65     BOOL16              Win16;          /* flag to indicate Win16 API used to initialize */
  66     DWORD               Instance_id;  /* needed to track monitor usage */
  67     struct DDE_HANDLE_ENTRY    *Next_Entry;
  68     HSZNode     *Node_list;
  69     PFNCALLBACK         CallBack;
  70     DWORD               CBF_Flags;
  71     DWORD               Monitor_flags;
  72     UINT              Txn_count;      /* count transactions open to simplify closure */
  73     DWORD               Last_Error;
  74     ServiceNode*                ServiceNames;
  75 } DDE_HANDLE_ENTRY;
  76
  77 static DDE_HANDLE_ENTRY *DDE_Handle_Table_Base = NULL;
  78 static DWORD            DDE_Max_Assigned_Instance = 0;  /* OK for present, may have to worry about wrap-around later */
  79 static const char       *DDEInstanceAccess = "DDEMaxInstance";
  80 static const char       *DDEHandleAccess = "DDEHandleAccess";
  81 static HANDLE           inst_count_mutex = 0;
  82 static HANDLE           handle_mutex = 0;
  83
  84 #define TRUE    1
  85 #define FALSE   0
  86
  87
  88 /******************************************************************************
  89  *            RemoveHSZNodes    (INTERNAL)
  90  *
  91  * Remove a node from the list of HSZ nodes.
  92  *
  93  ******************************************************************************
  94  *
  95  *      Change History
  96  *
  97  *  Vn       Date       Author                  Comment
  98  *
  99  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 100  *  1.1      Mar 1999  Keith Matthews      Added multiple instance handling
 101  *
 102  */
 103 static void RemoveHSZNode( HSZ hsz, DDE_HANDLE_ENTRY * reference_inst )
 104 {
 105     HSZNode* pPrev = NULL;
 106     HSZNode* pCurrent = NULL;
 107
 108     /* Set the current node at the start of the list.
 109      */
 110     pCurrent = reference_inst->Node_list;
 111     /* While we have more nodes.
 112      */
 113     while( pCurrent != NULL )
 114     {
 115         /* If we found the node we were looking for.
 116          */
 117         if( pCurrent->hsz == hsz )
 118         {
 119             /* Remove the node.
 120              */
 121             /* If the first node in the list is to to be removed.
 122              * Set the global list pointer to the next node.
 123              */
 124             if( pCurrent == reference_inst->Node_list )
 125             {
 126                 reference_inst->Node_list = pCurrent->next;
 127             }
 128             /* Just fix the pointers has to skip the current
 129              * node so we can delete it.
 130              */
 131             else
 132             {
 133                 pPrev->next = pCurrent->next;
 134             }
 135             /* Destroy this node.
 136              */
 137             free( pCurrent );
 138             break;
 139         }
 140         /* Save the previous node pointer.
 141          */
 142         pPrev = pCurrent;
 143         /* Move on to the next node.
 144          */
 145         pCurrent = pCurrent->next;
 146     }
 147 }
 148
 149 /******************************************************************************
 150  *            FreeAndRemoveHSZNodes    (INTERNAL)
 151  *
 152  * Frees up all the strings still allocated in the list and
 153  * remove all the nodes from the list of HSZ nodes.
 154  *
 155  ******************************************************************************
 156  *
 157  *      Change History
 158  *
 159  *  Vn       Date       Author                  Comment
 160  *
 161  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 162  *  1.1      Mar 1999  Keith Matthews      Added multiple instance handling
 163  *
 164  */
 165 static void FreeAndRemoveHSZNodes( DWORD idInst, DDE_HANDLE_ENTRY * reference_inst )
 166 {
 167     /* Free any strings created in this instance.
 168      */
 169     while( reference_inst->Node_list != NULL )
 170     {
 171         DdeFreeStringHandle( idInst, reference_inst->Node_list->hsz );
 172     }
 173 }
 174
 175 /******************************************************************************
 176  *            InsertHSZNode    (INTERNAL)
 177  *
 178  * Insert a node to the head of the list.
 179  *
 180  ******************************************************************************
 181  *
 182  *      Change History
 183  *
 184  *  Vn       Date       Author                  Comment
 185  *
 186  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 187  *  1.1      Mar 1999  Keith Matthews      Added instance handling
 188  *  1.2      Jun 1999  Keith Matthews      Added Usage count handling
 189  *
 190  */
 191 static void InsertHSZNode( HSZ hsz, DDE_HANDLE_ENTRY * reference_inst )
 192 {
 193     if( hsz != 0 )
 194     {
 195         HSZNode* pNew = NULL;
 196         /* Create a new node for this HSZ.
 197          */
 198         pNew = (HSZNode*) malloc( sizeof( HSZNode ) );
 199         if( pNew != NULL )
 200         {
 201             /* Set the handle value.
 202              */
 203             pNew->hsz = hsz;
 204             /* Attach the node to the head of the list. i.e most recently added is first
 205              */
 206             pNew->next = reference_inst->Node_list;
 207
 208             /* The new node is now at the head of the list
 209              * so set the global list pointer to it.
 210              */
 211             reference_inst->Node_list = pNew;
 212             TRACE("HSZ node list entry added\n");
 213         }
 214     }
 215 }
 216
 217 /*****************************************************************************
 218  *      Find_Instance_Entry
 219  *
 220  *      generic routine to return a pointer to the relevant DDE_HANDLE_ENTRY
 221  *      for an instance Id, or NULL if the entry does not exist
 222  *
 223  *      ASSUMES the mutex protecting the handle entry list is reserved before calling
 224  *
 225  ******************************************************************************
 226  *
 227  *      Change History
 228  *
 229  *  Vn       Date       Author                  Comment
 230  *
 231  *  1.0      March 1999  Keith Matthews      1st implementation
 232              */
 233  DDE_HANDLE_ENTRY *Find_Instance_Entry (DWORD InstId)
 234 {
 235         DDE_HANDLE_ENTRY * reference_inst;
 236         reference_inst =  DDE_Handle_Table_Base;
 237         while ( reference_inst != NULL )
 238         {
 239                 if ( reference_inst->Instance_id == InstId )
 240                 {
 241                         TRACE("Instance entry found\n");
 242                         return reference_inst;
 243         }
 244                 reference_inst = reference_inst->Next_Entry;
 245     }
 246         TRACE("Instance entry missing\n");
 247         return NULL;
 248 }
 249
 250 /*****************************************************************************
 251  *      Find_Service_Name
 252  *
 253  *      generic routine to return a pointer to the relevant ServiceNode
 254  *      for a given service name, or NULL if the entry does not exist
 255  *
 256  *      ASSUMES the mutex protecting the handle entry list is reserved before calling
 257  *
 258  ******************************************************************************
 259  *
 260  *      Change History
 261  *
 262  *  Vn       Date       Author                  Comment
 263  *
 264  *  1.0      May 1999  Keith Matthews      1st implementation
 265              */
 266  ServiceNode *Find_Service_Name (HSZ Service_Name, DDE_HANDLE_ENTRY* this_instance)
 267 {
 268         ServiceNode * reference_name=  this_instance->ServiceNames;
 269         while ( reference_name != NULL )
 270         {
 271                 if ( reference_name->hsz == Service_Name )
 272                 {
 273                         TRACE("Service Name found\n");
 274                         return reference_name;
 275         }
 276                 reference_name = reference_name->next;
 277     }
 278         TRACE("Service name missing\n");
 279         return NULL;
 280 }
 281
 282
 283 /******************************************************************************
 284  *      Release_reserved_mutex
 285  *
 286  *      generic routine to release a reserved mutex
 287  *
 288  *
 289  ******************************************************************************
 290  *
 291  *      Change History
 292  *
 293  *  Vn       Date       Author                  Comment
 294  *
 295  *  1.0      Jan 1999  Keith Matthews        Initial version
 296  *  1.1      Mar 1999  Keith Matthews        Corrected Heap handling. Corrected re-initialisation handling
 297  *  1.2      Aug 1999  Jürgen Schmied        Corrected error handling
 298  *
 299  */
 300 static DWORD Release_reserved_mutex (HANDLE mutex, LPSTR mutex_name, BOOL release_handle_m, BOOL release_this_i ,
 301     DDE_HANDLE_ENTRY *this_instance)
 302 {
 303         if (!ReleaseMutex(mutex))
 304         {
 305                 ERR("ReleaseMutex failed - %s mutex %li\n",mutex_name,GetLastError());
 306                 HeapFree(SystemHeap, 0, this_instance);
 307                 if ( release_handle_m )
 308                 {
 309                         ReleaseMutex(handle_mutex);
 310                 }
 311                 return DMLERR_SYS_ERROR;
 312          }
 313         if ( release_this_i )
 314         {
 315                 HeapFree(SystemHeap, 0, this_instance);
 316         }
 317         return DMLERR_NO_ERROR;
 318 }
 319
 320 /******************************************************************************
 321  *      WaitForMutex
 322  *
 323  *      generic routine to wait for the mutex
 324  *
 325  *
 326  ******************************************************************************
 327  *
 328  *      Change History
 329  *
 330  *  Vn       Date       Author                  Comment
 331  *
 332  *  1.0      Aug 1999  Juergen Schmied       Initial version
 333  *
 334  */
 335 static BOOL WaitForMutex (HANDLE mutex)
 336 {
 337         DWORD result;
 338
 339         result = WaitForSingleObject(mutex,1000);
 340
 341         /* both errors should never occur */
 342         if (WAIT_TIMEOUT == result)
 343         {
 344                 ERR("WaitForSingleObject timed out\n");
 345                 return FALSE;
 346         }
 347
 348         if (WAIT_FAILED == result)
 349         {
 350                 ERR("WaitForSingleObject failed - error %li\n", GetLastError());
 351                 return FALSE;
 352         }
 353         return TRUE;
 354 }
 355 /******************************************************************************
 356  *              IncrementInstanceId
 357  *
 358  *      generic routine to increment the max instance Id and allocate a new application instance
 359  *
 360  ******************************************************************************
 361  *
 362  *      Change History
 363  *
 364  *  Vn       Date       Author                  Comment
 365  *
 366  *  1.0      Jan 1999  Keith Matthews        Initial version
 367  *
 368  */
 369 DWORD IncrementInstanceId( DDE_HANDLE_ENTRY *this_instance)
 370 {
 371         SECURITY_ATTRIBUTES s_attrib;
 372
 373         /*  Need to set up Mutex in case it is not already present */
 374         /* increment handle count & get value */
 375         if ( !inst_count_mutex )
 376         {
 377                 s_attrib.bInheritHandle = TRUE;
 378                 s_attrib.lpSecurityDescriptor = NULL;
 379                 s_attrib.nLength = sizeof(s_attrib);
 380                 inst_count_mutex = CreateMutexA(&s_attrib,1,DDEInstanceAccess); /* 1st time through */
 381                 inst_count_mutex = ConvertToGlobalHandle(inst_count_mutex); /* fixme when having seperate adresspaces*/
 382         } else {
 383                 if ( !WaitForMutex(inst_count_mutex) )
 384                 {
 385                         return DMLERR_SYS_ERROR;
 386                 }
 387         }
 388         if ( !inst_count_mutex )
 389         {
 390                 ERR("CreateMutex failed - inst_count %li\n",GetLastError());
 391                 Release_reserved_mutex (handle_mutex,"handle_mutex",0,1,this_instance);
 392                 return DMLERR_SYS_ERROR;
 393         }
 394         DDE_Max_Assigned_Instance++;
 395         this_instance->Instance_id = DDE_Max_Assigned_Instance;
 396         TRACE("New instance id %ld allocated\n",DDE_Max_Assigned_Instance);
 397         if (Release_reserved_mutex(inst_count_mutex,"instance_count",1,0,this_instance)) return DMLERR_SYS_ERROR;
 398         return DMLERR_NO_ERROR;
 399 }
 400
 401 /******************************************************************************
 402  *              FindNotifyMonitorCallbacks
 403  *
 404  *      Routine to find instances that need to be notified via their callback
 405  *      of some event they are monitoring
 406  *
 407  ******************************************************************************
 408  *
 409  *      Change History
 410  *
 411  *  Vn       Date       Author                  Comment
 412  *
 413  *  1.0    May 1999    Keith Matthews       Initial Version
 414  *
 415  */
 416
 417 void FindNotifyMonitorCallbacks(DWORD ThisInstance, DWORD DdeEvent )
 418 {
 419         DDE_HANDLE_ENTRY *InstanceHandle;
 420         InstanceHandle = DDE_Handle_Table_Base;
 421         while ( InstanceHandle != NULL )
 422         {
 423                 if (  (InstanceHandle->Monitor ) && InstanceHandle->Instance_id == ThisInstance )
 424                 {
 425                         /*   Found an instance registered as monitor and is not ourselves
 426                          *      use callback to notify where appropriate
 427                          */
 428                 }
 429                 InstanceHandle = InstanceHandle->Next_Entry;
 430         }
 431 }
 432
 433 /******************************************************************************
 434  *              DdeReserveAtom
 435  *
 436  *      Routine to make an extra Add on an atom to reserve it a bit longer
 437  *
 438  ******************************************************************************
 439  *
 440  *      Change History
 441  *
 442  *  Vn       Date       Author                  Comment
 443  *
 444  *  1.0    Jun 1999    Keith Matthews       Initial Version
 445  *
 446  */
 447
 448 void DdeReserveAtom( DDE_HANDLE_ENTRY * reference_inst,HSZ hsz)
 449 {
 450   CHAR SNameBuffer[MAX_BUFFER_LEN];
 451   UINT rcode;
 452   if ( reference_inst->Unicode)
 453   {
 454         rcode=GlobalGetAtomNameW(hsz,(LPWSTR)&SNameBuffer,MAX_ATOM_LEN);
 455         GlobalAddAtomW((LPWSTR)SNameBuffer);
 456   } else {
 457         rcode=GlobalGetAtomNameA(hsz,SNameBuffer,MAX_ATOM_LEN);
 458         GlobalAddAtomA(SNameBuffer);
 459   }
 460 }
 461
 462
 463 /******************************************************************************
 464  *              DdeReleaseAtom
 465  *
 466  *      Routine to make a delete on an atom to release it a bit sooner
 467  *
 468  ******************************************************************************
 469  *
 470  *      Change History
 471  *
 472  *  Vn       Date       Author                  Comment
 473  *
 474  *  1.0    Jun 1999    Keith Matthews       Initial Version
 475  *
 476  */
 477
 478 void DdeReleaseAtom( DDE_HANDLE_ENTRY * reference_inst,HSZ hsz)
 479 {
 480   CHAR SNameBuffer[MAX_BUFFER_LEN];
 481   UINT rcode;
 482   if ( reference_inst->Unicode)
 483   {
 484         rcode=GlobalGetAtomNameW(hsz,(LPWSTR)&SNameBuffer,MAX_ATOM_LEN);
 485         GlobalAddAtomW((LPWSTR)SNameBuffer);
 486   } else {
 487         rcode=GlobalGetAtomNameA(hsz,SNameBuffer,MAX_ATOM_LEN);
 488         GlobalAddAtomA(SNameBuffer);
 489   }
 490 }
 491
 492 /******************************************************************************
 493  *            DdeInitialize16   (DDEML.2)
 494  */
 495 UINT16 WINAPI DdeInitialize16( LPDWORD pidInst, PFNCALLBACK16 pfnCallback,
 496                                DWORD afCmd, DWORD ulRes)
 497 {
 498     TRACE("DdeInitialize16 called - calling DdeInitializeA\n");
 499     return (UINT16)DdeInitializeA(pidInst,(PFNCALLBACK)pfnCallback,
 500                                     afCmd, ulRes);
 501 }
 502
 503
 504 /******************************************************************************
 505  *            DdeInitializeA   (USER32.106)
 506  */
 507 UINT WINAPI DdeInitializeA( LPDWORD pidInst, PFNCALLBACK pfnCallback,
 508                                 DWORD afCmd, DWORD ulRes )
 509 {
 510     TRACE("DdeInitializeA called - calling DdeInitializeW\n");
 511     return DdeInitializeW(pidInst,pfnCallback,afCmd,ulRes);
 512 }
 513
 514
 515 /******************************************************************************
 516  * DdeInitializeW [USER32.107]
 517  * Registers an application with the DDEML
 518  *
 519  * PARAMS
 520  *    pidInst     [I] Pointer to instance identifier
 521  *    pfnCallback [I] Pointer to callback function
 522  *    afCmd       [I] Set of command and filter flags
 523  *    ulRes       [I] Reserved
 524  *
 525  * RETURNS
 526  *    Success: DMLERR_NO_ERROR
 527  *    Failure: DMLERR_DLL_USAGE, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR
 528  *
 529  ******************************************************************************
 530  *
 531  *      Change History
 532  *
 533  *  Vn       Date       Author                  Comment
 534  *
 535  *  1.0      Pre 1998  Alexandre/Len         Initial Stub
 536  *  1.1      Jan 1999  Keith Matthews        Initial (near-)complete version
 537  *  1.2      Mar 1999  Keith Matthews        Corrected Heap handling, CreateMutex failure handling
 538  *
 539  */
 540 UINT WINAPI DdeInitializeW( LPDWORD pidInst, PFNCALLBACK pfnCallback,
 541                                 DWORD afCmd, DWORD ulRes )
 542 {
 543
 544 /*  probably not really capable of handling mutliple processes, but should handle
 545  *      multiple instances within one process */
 546
 547     SECURITY_ATTRIBUTES *s_att= NULL;
 548     SECURITY_ATTRIBUTES s_attrib;
 549     DWORD               err_no = 0;
 550     DDE_HANDLE_ENTRY *this_instance;
 551     DDE_HANDLE_ENTRY *reference_inst;
 552     s_att = &s_attrib;
 553
 554     if( ulRes )
 555     {
 556         ERR("Reserved value not zero?  What does this mean?\n");
 557         FIXME("(%p,%p,0x%lx,%ld): stub\n", pidInst, pfnCallback,
 558               afCmd,ulRes);
 559         /* trap this and no more until we know more */
 560         return DMLERR_NO_ERROR;
 561     }
 562     if (!pfnCallback )
 563     {
 564         /*  this one may be wrong - MS dll seems to accept the condition,
 565             leave this until we find out more !! */
 566
 567
 568         /* can't set up the instance with nothing to act as a callback */
 569         TRACE("No callback provided\n");
 570         return DMLERR_INVALIDPARAMETER; /* might be DMLERR_DLL_USAGE */
 571      }
 572
 573      /* grab enough heap for one control struct - not really necessary for re-initialise
 574       * but allows us to use same validation routines */
 575      this_instance= (DDE_HANDLE_ENTRY*)HeapAlloc( SystemHeap, 0, sizeof(DDE_HANDLE_ENTRY) );
 576      if ( this_instance == NULL )
 577      {
 578         /* catastrophe !! warn user & abort */
 579         ERR("Instance create failed - out of memory\n");
 580         return DMLERR_SYS_ERROR;
 581      }
 582      this_instance->Next_Entry = NULL;
 583      this_instance->Monitor=(afCmd|APPCLASS_MONITOR);
 584
 585      /* messy bit, spec implies that 'Client Only' can be set in 2 different ways, catch 1 here */
 586
 587      this_instance->Client_only=afCmd&APPCMD_CLIENTONLY;
 588      this_instance->Instance_id = *pidInst; /* May need to add calling proc Id */
 589      this_instance->CallBack=*pfnCallback;
 590      this_instance->Txn_count=0;
 591      this_instance->Unicode = TRUE;
 592      this_instance->Win16 = FALSE;
 593      this_instance->Node_list = NULL; /* node will be added later */
 594      this_instance->Monitor_flags = afCmd & MF_MASK;
 595      this_instance->ServiceNames = NULL;
 596
 597      /* isolate CBF flags in one go, expect this will go the way of all attempts to be clever !! */
 598
 599      this_instance->CBF_Flags=afCmd^((afCmd&MF_MASK)|((afCmd&APPCMD_MASK)|(afCmd&APPCLASS_MASK)));
 600
 601      if ( ! this_instance->Client_only )
 602      {
 603
 604         /* Check for other way of setting Client-only !! */
 605
 606         this_instance->Client_only=(this_instance->CBF_Flags&CBF_FAIL_ALLSVRXACTIONS)
 607                         ==CBF_FAIL_ALLSVRXACTIONS;
 608      }
 609
 610      TRACE("instance created - checking validity \n");
 611
 612     if( *pidInst == 0 ) {
 613         /*  Initialisation of new Instance Identifier */
 614         TRACE("new instance, callback %p flags %lX\n",pfnCallback,afCmd);
 615         if ( DDE_Max_Assigned_Instance == 0 )
 616         {
 617                 /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
 618         /*  Need to set up Mutex in case it is not already present */
 619         s_att->bInheritHandle = TRUE;
 620         s_att->lpSecurityDescriptor = NULL;
 621         s_att->nLength = sizeof(s_att);
 622         handle_mutex = CreateMutexA(s_att,1,DDEHandleAccess);
 623         handle_mutex = ConvertToGlobalHandle(handle_mutex); /* fixme when having seperate adresspaces*/
 624         if ( !handle_mutex ) {
 625                 ERR("CreateMutex failed - handle list  %li\n",GetLastError());
 626                 HeapFree(SystemHeap, 0, this_instance);
 627                 return DMLERR_SYS_ERROR;
 628         }
 629     } else {
 630         if ( !WaitForMutex(handle_mutex) )
 631         {
 632                 return DMLERR_SYS_ERROR;
 633         }
 634     }
 635
 636         TRACE("Handle Mutex created/reserved\n");
 637         if (DDE_Handle_Table_Base == NULL )
 638         {
 639                 /* can't be another instance in this case, assign to the base pointer */
 640                 DDE_Handle_Table_Base= this_instance;
 641
 642                 /* since first must force filter of XTYP_CONNECT and XTYP_WILDCONNECT for
 643                  *              present
 644                  *      -------------------------------      NOTE NOTE NOTE    --------------------------
 645                  *
 646                  *      the manual is not clear if this condition
 647                  *      applies to the first call to DdeInitialize from an application, or the
 648                  *      first call for a given callback !!!
 649                 */
 650
 651                 this_instance->CBF_Flags=this_instance->CBF_Flags|APPCMD_FILTERINITS;
 652                 TRACE("First application instance detected OK\n");
 653                 /*      allocate new instance ID */
 654                 if ((err_no = IncrementInstanceId( this_instance)) ) return err_no;
 655
 656         } else {
 657                 /* really need to chain the new one in to the latest here, but after checking conditions
 658                  *      such as trying to start a conversation from an application trying to monitor */
 659                 reference_inst =  DDE_Handle_Table_Base;
 660                 TRACE("Subsequent application instance - starting checks\n");
 661                 while ( reference_inst->Next_Entry != NULL )
 662                 {
 663                         /*
 664                         *       This set of tests will work if application uses same instance Id
 665                         *       at application level once allocated - which is what manual implies
 666                         *       should happen. If someone tries to be
 667                         *       clever (lazy ?) it will fail to pick up that later calls are for
 668                         *       the same application - should we trust them ?
 669                         */
 670                         if ( this_instance->Instance_id == reference_inst->Instance_id)
 671                         {
 672                                 /* Check 1 - must be same Client-only state */
 673
 674                                 if ( this_instance->Client_only != reference_inst->Client_only)
 675                                 {
 676                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 677                                                 return DMLERR_SYS_ERROR;
 678                                         return DMLERR_DLL_USAGE;
 679                                 }
 680
 681                                 /* Check 2 - cannot use 'Monitor' with any non-monitor modes */
 682
 683                                 if ( this_instance->Monitor != reference_inst->Monitor)
 684                                 {
 685                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 686                                                 return DMLERR_SYS_ERROR;
 687                                         return DMLERR_INVALIDPARAMETER;
 688                                 }
 689
 690                                 /* Check 3 - must supply different callback address */
 691
 692                                 if ( this_instance->CallBack == reference_inst->CallBack)
 693                                 {
 694                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 695                                                 return DMLERR_SYS_ERROR;
 696                                         return DMLERR_DLL_USAGE;
 697                                 }
 698                         }
 699                         reference_inst = reference_inst->Next_Entry;
 700                 }
 701                 /*  All cleared, add to chain */
 702
 703                 TRACE("Application Instance checks finished\n");
 704                 if ((err_no = IncrementInstanceId( this_instance)) ) return err_no;
 705                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,0,this_instance)) return DMLERR_SYS_ERROR;
 706                 reference_inst->Next_Entry = this_instance;
 707         }
 708         *pidInst = this_instance->Instance_id;
 709         TRACE("New application instance processing finished OK\n");
 710      } else {
 711         /* Reinitialisation situation   --- FIX  */
 712         TRACE("reinitialisation of (%p,%p,0x%lx,%ld): stub\n",pidInst,pfnCallback,afCmd,ulRes);
 713
 714         if ( !WaitForMutex(handle_mutex)  )
 715         {
 716                 HeapFree(SystemHeap, 0, this_instance);
 717                 return DMLERR_SYS_ERROR;
 718         }
 719
 720         if (DDE_Handle_Table_Base == NULL )
 721         {
 722                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance)) return DMLERR_SYS_ERROR;
 723                 return DMLERR_DLL_USAGE;
 724         }
 725         HeapFree(SystemHeap, 0, this_instance); /* finished - release heap space used as work store */
 726         /* can't reinitialise if we have initialised nothing !! */
 727         reference_inst =  DDE_Handle_Table_Base;
 728         /* must first check if we have been given a valid instance to re-initialise !!  how do we do that ? */
 729         /*
 730         *       MS allows initialisation without specifying a callback, should we allow addition of the
 731         *       callback by a later call to initialise ? - if so this lot will have to change
 732         */
 733         while ( reference_inst->Next_Entry != NULL )
 734         {
 735                 if ( *pidInst == reference_inst->Instance_id && pfnCallback == reference_inst->CallBack )
 736                 {
 737                         /* Check 1 - cannot change client-only mode if set via APPCMD_CLIENTONLY */
 738
 739                         if (  reference_inst->Client_only )
 740                         {
 741                            if  ((reference_inst->CBF_Flags & CBF_FAIL_ALLSVRXACTIONS) != CBF_FAIL_ALLSVRXACTIONS)
 742                            {
 743                                 /* i.e. Was set to Client-only and through APPCMD_CLIENTONLY */
 744
 745                                 if ( ! ( afCmd & APPCMD_CLIENTONLY))
 746                                 {
 747                                         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 748                                                 return DMLERR_SYS_ERROR;
 749                                         return DMLERR_DLL_USAGE;
 750                                 }
 751                            }
 752                         }
 753                         /* Check 2 - cannot change monitor modes */
 754
 755                         if ( this_instance->Monitor != reference_inst->Monitor)
 756                         {
 757                                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 758                                         return DMLERR_SYS_ERROR;
 759                                 return DMLERR_DLL_USAGE;
 760                         }
 761
 762                         /* Check 3 - trying to set Client-only via APPCMD when not set so previously */
 763
 764                         if (( afCmd&APPCMD_CLIENTONLY) && ! reference_inst->Client_only )
 765                         {
 766                                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 767                                         return DMLERR_SYS_ERROR;
 768                                 return DMLERR_DLL_USAGE;
 769                         }
 770                         break;
 771                 }
 772                 reference_inst = reference_inst->Next_Entry;
 773         }
 774         if ( reference_inst->Next_Entry == NULL )
 775         {
 776                 /* Crazy situation - trying to re-initialize something that has not beeen initialized !!
 777                 *
 778                 *       Manual does not say what we do, cannot return DMLERR_NOT_INITIALIZED so what ?
 779                 */
 780                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 781                         return DMLERR_SYS_ERROR;
 782                 return DMLERR_INVALIDPARAMETER;
 783         }
 784         /*              All checked - change relevant flags */
 785
 786         reference_inst->CBF_Flags = this_instance->CBF_Flags;
 787         reference_inst->Client_only = this_instance->Client_only;
 788         reference_inst->Monitor_flags = this_instance->Monitor_flags;
 789         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",0,1,this_instance))
 790                 return DMLERR_SYS_ERROR;
 791      }
 792
 793     return DMLERR_NO_ERROR;
 794 }
 795
 796
 797 /*****************************************************************
 798  *            DdeUninitialize16   (DDEML.3)
 799  */
 800 BOOL16 WINAPI DdeUninitialize16( DWORD idInst )
 801 {
 802     FIXME(" stub calling DdeUninitialize\n");
 803     return (BOOL16)DdeUninitialize( idInst );
 804 }
 805
 806
 807 /*****************************************************************
 808  * DdeUninitialize [USER32.119]  Frees DDEML resources
 809  *
 810  * PARAMS
 811  *    idInst [I] Instance identifier
 812  *
 813  * RETURNS
 814  *    Success: TRUE
 815  *    Failure: FALSE
 816  */
 817
 818 BOOL WINAPI DdeUninitialize( DWORD idInst )
 819 {
 820         /*  Stage one - check if we have a handle for this instance
 821                                                                         */
 822         SECURITY_ATTRIBUTES *s_att= NULL;
 823         SECURITY_ATTRIBUTES s_attrib;
 824         DDE_HANDLE_ENTRY *this_instance;
 825         DDE_HANDLE_ENTRY *reference_inst;
 826         s_att = &s_attrib;
 827
 828         if ( DDE_Max_Assigned_Instance == 0 )
 829         {
 830                 /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
 831                 return TRUE;
 832         }
 833
 834         if ( !WaitForMutex(handle_mutex) )
 835         {
 836                 return DMLERR_SYS_ERROR;
 837         }
 838         TRACE("Handle Mutex created/reserved\n");
 839         /*  First check instance
 840         */
 841         this_instance = Find_Instance_Entry(idInst);
 842         if ( this_instance == NULL )
 843         {
 844                 if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance)) return FALSE;
 845                 /*
 846                   *     Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
 847                 */
 848                 return FALSE;
 849         }
 850         FIXME("(%ld): partial stub\n", idInst);
 851
 852         /*   FIXME      ++++++++++++++++++++++++++++++++++++++++++
 853          *      Needs to de-register all service names
 854          *
 855          */
 856     /* Free the nodes that were not freed by this instance
 857      * and remove the nodes from the list of HSZ nodes.
 858      */
 859         FreeAndRemoveHSZNodes( idInst, this_instance );
 860
 861         /* OK now delete the instance handle itself */
 862
 863         if ( DDE_Handle_Table_Base == this_instance )
 864         {
 865                 /* special case - the first/only entry
 866                 */
 867                 DDE_Handle_Table_Base = this_instance->Next_Entry;
 868         } else
 869         {
 870                 /* general case
 871                 */
 872                 reference_inst = DDE_Handle_Table_Base;
 873                 while ( reference_inst->Next_Entry != this_instance )
 874                 {
 875                         reference_inst = this_instance->Next_Entry;
 876                 }
 877                 reference_inst->Next_Entry = this_instance->Next_Entry;
 878         }
 879         /* release the mutex and the heap entry
 880         */
 881         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,TRUE,this_instance))
 882         {
 883                 /* should record something here, but nothing left to hang it from !!
 884                 */
 885                 return FALSE;
 886         }
 887     return TRUE;
 888 }
 889
 890
 891 /*****************************************************************
 892  * DdeConnectList16 [DDEML.4]
 893  */
 894
 895 HCONVLIST WINAPI DdeConnectList16( DWORD idInst, HSZ hszService, HSZ hszTopic,
 896                  HCONVLIST hConvList, LPCONVCONTEXT16 pCC )
 897 {
 898     return DdeConnectList(idInst, hszService, hszTopic, hConvList,
 899                             (LPCONVCONTEXT)pCC);
 900 }
 901
 902
 903 /******************************************************************************
 904  * DdeConnectList [USER32.93]  Establishes conversation with DDE servers
 905  *
 906  * PARAMS
 907  *    idInst     [I] Instance identifier
 908  *    hszService [I] Handle to service name string
 909  *    hszTopic   [I] Handle to topic name string
 910  *    hConvList  [I] Handle to conversation list
 911  *    pCC        [I] Pointer to structure with context data
 912  *
 913  * RETURNS
 914  *    Success: Handle to new conversation list
 915  *    Failure: 0
 916  */
 917 HCONVLIST WINAPI DdeConnectList( DWORD idInst, HSZ hszService, HSZ hszTopic,
 918                  HCONVLIST hConvList, LPCONVCONTEXT pCC )
 919 {
 920     FIXME("(%ld,%ld,%ld,%ld,%p): stub\n", idInst, hszService, hszTopic,
 921           hConvList,pCC);
 922     return 1;
 923 }
 924
 925
 926 /*****************************************************************
 927  * DdeQueryNextServer16 [DDEML.5]
 928  */
 929 HCONV WINAPI DdeQueryNextServer16( HCONVLIST hConvList, HCONV hConvPrev )
 930 {
 931     return DdeQueryNextServer(hConvList, hConvPrev);
 932 }
 933
 934
 935 /*****************************************************************
 936  * DdeQueryNextServer [USER32.112]
 937  */
 938 HCONV WINAPI DdeQueryNextServer( HCONVLIST hConvList, HCONV hConvPrev )
 939 {
 940     FIXME("(%ld,%ld): stub\n",hConvList,hConvPrev);
 941     return 0;
 942 }
 943
 944 /*****************************************************************
 945  * DdeQueryStringA [USER32.113]
 946  *
 947  *****************************************************************
 948  *
 949  *      Change History
 950  *
 951  *  Vn       Date       Author                  Comment
 952  *
 953  *  1.0      Dec 1998  Corel/Macadamian    Initial version
 954  *  1.1      Mar 1999  Keith Matthews      Added links to instance table and related processing
 955  *
 956  */
 957 DWORD WINAPI DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT iCodePage)
 958 {
 959     DWORD ret = 0;
 960     CHAR pString[MAX_BUFFER_LEN];
 961     DDE_HANDLE_ENTRY *reference_inst;
 962
 963     FIXME(
 964          "(%ld, 0x%lx, %p, %ld, %d): partial stub\n",
 965          idInst,
 966          hsz,
 967          psz,
 968          cchMax,
 969          iCodePage);
 970   if ( DDE_Max_Assigned_Instance == 0 )
 971   {
 972           /*  Nothing has been initialised - exit now ! */
 973           /*  needs something for DdeGetLAstError even if the manual doesn't say so */
 974           return FALSE;
 975   }
 976
 977         if ( !WaitForMutex(handle_mutex) )
 978         {
 979                 return FALSE;
 980         }
 981
 982   TRACE("Handle Mutex created/reserved\n");
 983
 984   /*  First check instance
 985   */
 986   reference_inst = Find_Instance_Entry(idInst);
 987   if ( reference_inst == NULL )
 988   {
 989         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return FALSE;
 990         /*
 991         Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
 992         */
 993         return FALSE;
 994   }
 995
 996     if( iCodePage == CP_WINANSI )
 997     {
 998         /* If psz is null, we have to return only the length
 999          * of the string.
1000          */
1001         if( psz == NULL )
1002         {
1003             psz = pString;
1004             cchMax = MAX_BUFFER_LEN;
1005 }
1006
1007         ret = GlobalGetAtomNameA( hsz, (LPSTR)psz, cchMax );
1008   } else {
1009         Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
1010     }
1011    TRACE("returning pointer\n");
1012     return ret;
1013 }
1014
1015 /*****************************************************************
1016  * DdeQueryStringW [USER32.114]
1017  *
1018  *****************************************************************
1019  *
1020  *      Change History
1021  *
1022  *  Vn       Date       Author                  Comment
1023  *
1024  *  1.0      Dec 1998  Corel/Macadamian    Initial version
1025  *
1026  */
1027
1028 DWORD WINAPI DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT iCodePage)
1029 {
1030     DWORD ret = 0;
1031     WCHAR pString[MAX_BUFFER_LEN];
1032     int factor = 1;
1033
1034     FIXME(
1035          "(%ld, 0x%lx, %p, %ld, %d): stub\n",
1036          idInst,
1037          hsz,
1038          psz,
1039          cchMax,
1040          iCodePage);
1041
1042     if( iCodePage == CP_WINUNICODE )
1043     {
1044         /* If psz is null, we have to return only the length
1045          * of the string.
1046          */
1047         if( psz == NULL )
1048         {
1049             psz = pString;
1050             cchMax = MAX_BUFFER_LEN;
1051             /* Note: According to documentation if the psz parameter
1052              * was NULL this API must return the length of the string in bytes.
1053              */
1054             factor = (int) sizeof(WCHAR)/sizeof(BYTE);
1055         }
1056         ret = GlobalGetAtomNameW( hsz, (LPWSTR)psz, cchMax ) * factor;
1057     }
1058     return ret;
1059 }
1060
1061 /*****************************************************************
1062 *
1063 *               DdeQueryString16 (DDEML.23)
1064 *
1065 ******************************************************************
1066  *
1067  *      Change History
1068  *
1069  *  Vn       Date       Author                  Comment
1070  *
1071  *  1.0      March 1999 K Matthews              stub only
1072  */
1073
1074 DWORD WINAPI DdeQueryString16(DWORD idInst, HSZ hsz, LPSTR lpsz, DWORD cchMax, int codepage)
1075 {
1076         FIXME("(%ld, 0x%lx, %p, %ld, %d): stub \n",
1077          idInst,
1078          hsz,
1079          lpsz,
1080          cchMax,
1081          codepage);
1082         return 0;
1083 }
1084
1085
1086 /*****************************************************************
1087  *            DdeDisconnectList (DDEML.6)
1088  */
1089 BOOL16 WINAPI DdeDisconnectList16( HCONVLIST hConvList )
1090 {
1091     return (BOOL16)DdeDisconnectList(hConvList);
1092 }
1093
1094
1095 /******************************************************************************
1096  * DdeDisconnectList [USER32.98]  Destroys list and terminates conversations
1097  *
1098  * RETURNS
1099  *    Success: TRUE
1100  *    Failure: FALSE
1101  */
1102 BOOL WINAPI DdeDisconnectList(
1103     HCONVLIST hConvList) /* [in] Handle to conversation list */
1104 {
1105     FIXME("(%ld): stub\n", hConvList);
1106     return TRUE;
1107 }
1108
1109
1110 /*****************************************************************
1111  *            DdeConnect16   (DDEML.7)
1112  */
1113 HCONV WINAPI DdeConnect16( DWORD idInst, HSZ hszService, HSZ hszTopic,
1114                            LPCONVCONTEXT16 pCC )
1115 {
1116     FIXME("empty stub\n" );
1117     return 0;
1118 }
1119
1120
1121 /*****************************************************************
1122  *            DdeConnect   (USER32.92)
1123  */
1124 HCONV WINAPI DdeConnect( DWORD idInst, HSZ hszService, HSZ hszTopic,
1125                            LPCONVCONTEXT pCC )
1126 {
1127     FIXME("(0x%lx,%ld,%ld,%p): stub\n",idInst,hszService,hszTopic,
1128           pCC);
1129     return 0;
1130 }
1131
1132
1133 /*****************************************************************
1134  *            DdeDisconnect16   (DDEML.8)
1135  */
1136 BOOL16 WINAPI DdeDisconnect16( HCONV hConv )
1137 {
1138     return (BOOL16)DdeDisconnect( hConv );
1139 }
1140
1141 /*****************************************************************
1142  *            DdeSetUserHandle16 (DDEML.10)
1143  */
1144 BOOL16 WINAPI DdeSetUserHandle16( HCONV hConv, DWORD id, DWORD hUser )
1145 {
1146     FIXME("(%ld,%ld,%ld): stub\n",hConv,id, hUser );
1147     return 0;
1148 }
1149
1150 /*****************************************************************
1151  *            DdeCreateDataHandle16 (DDEML.14)
1152  */
1153 HDDEDATA WINAPI DdeCreateDataHandle16( DWORD idInst, LPBYTE pSrc, DWORD cb,
1154                                      DWORD cbOff, HSZ hszItem, UINT16 wFmt,
1155                                      UINT16 afCmd )
1156 {
1157     return DdeCreateDataHandle(idInst,
1158                                 pSrc,
1159                                 cb,
1160                                 cbOff,
1161                                 hszItem,
1162                                 wFmt,
1163                                 afCmd);
1164 }
1165
1166 /*****************************************************************
1167  *            DdeCreateDataHandle (USER32.94)
1168  */
1169 HDDEDATA WINAPI DdeCreateDataHandle( DWORD idInst, LPBYTE pSrc, DWORD cb,
1170                                        DWORD cbOff, HSZ hszItem, UINT wFmt,
1171                                        UINT afCmd )
1172 {
1173     FIXME(
1174           "(%ld,%p,%ld,%ld,0x%lx,%d,%d): stub\n",
1175           idInst,
1176           pSrc,
1177           cb,
1178           cbOff,
1179            hszItem,
1180           wFmt,
1181           afCmd );
1182
1183     return 0;
1184 }
1185
1186 /*****************************************************************
1187  *            DdeDisconnect   (USER32.97)
1188  */
1189 BOOL WINAPI DdeDisconnect( HCONV hConv )
1190 {
1191     FIXME("empty stub\n" );
1192     return 0;
1193 }
1194
1195
1196 /*****************************************************************
1197  *            DdeReconnect   (DDEML.37) (USER32.115)
1198  */
1199 HCONV WINAPI DdeReconnect( HCONV hConv )
1200 {
1201     FIXME("empty stub\n" );
1202     return 0;
1203 }
1204
1205
1206 /*****************************************************************
1207  *            DdeCreateStringHandle16   (DDEML.21)
1208  *
1209  *****************************************************************
1210  *
1211  *      Change History
1212  *
1213  *  Vn       Date       Author                  Comment
1214  *
1215  *  1.0      ?          ?                       basic stub
1216  *  1.1      June 1999  Keith Matthews          amended onward call to supply default
1217  *                                              code page if none supplied by caller
1218  */
1219 HSZ WINAPI DdeCreateStringHandle16( DWORD idInst, LPCSTR str, INT16 codepage )
1220 {
1221     if  ( codepage )
1222     {
1223     return DdeCreateStringHandleA( idInst, str, codepage );
1224      } else {
1225         TRACE("Default codepage supplied\n");
1226          return DdeCreateStringHandleA( idInst, str, CP_WINANSI);
1227      }
1228 }
1229
1230
1231 /*****************************************************************
1232  * DdeCreateStringHandleA [USER32.95]
1233  *
1234  * RETURNS
1235  *    Success: String handle
1236  *    Failure: 0
1237  *
1238  *****************************************************************
1239  *
1240  *      Change History
1241  *
1242  *  Vn       Date       Author                  Comment
1243  *
1244  *  1.0      Dec 1998  Corel/Macadamian    Initial version
1245  *  1.1      Mar 1999  Keith Matthews      Added links to instance table and related processing
1246  *
1247  */
1248 HSZ WINAPI DdeCreateStringHandleA( DWORD idInst, LPCSTR psz, INT codepage )
1249 {
1250   HSZ hsz = 0;
1251   DDE_HANDLE_ENTRY *reference_inst;
1252   TRACE("(%ld,%s,%d): partial stub\n",idInst,debugstr_a(psz),codepage);
1253
1254
1255   if ( DDE_Max_Assigned_Instance == 0 )
1256   {
1257           /*  Nothing has been initialised - exit now ! can return FALSE since effect is the same */
1258           return FALSE;
1259   }
1260
1261         if ( !WaitForMutex(handle_mutex) )
1262         {
1263                 return DMLERR_SYS_ERROR;
1264         }
1265
1266   TRACE("Handle Mutex created/reserved\n");
1267
1268   /*  First check instance
1269   */
1270   reference_inst = Find_Instance_Entry(idInst);
1271   if ( reference_inst == NULL )
1272   {
1273         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return 0;
1274         /*
1275         Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
1276         */
1277         return 0;
1278   }
1279
1280   if (codepage==CP_WINANSI)
1281   {
1282       hsz = GlobalAddAtomA (psz);
1283       /* Save the handle so we know to clean it when
1284        * uninitialize is called.
1285        */
1286       TRACE("added atom %s with HSZ 0x%lx, \n",debugstr_a(psz),hsz);
1287       InsertHSZNode( hsz, reference_inst );
1288       if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst))
1289         {
1290                 reference_inst->Last_Error = DMLERR_SYS_ERROR;
1291                 return 0;
1292         }
1293       TRACE("Returning pointer\n");
1294       return hsz;
1295   } else {
1296         Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
1297   }
1298     TRACE("Returning error\n");
1299     return 0;
1300 }
1301
1302
1303 /******************************************************************************
1304  * DdeCreateStringHandleW [USER32.96]  Creates handle to identify string
1305  *
1306  * RETURNS
1307  *    Success: String handle
1308  *    Failure: 0
1309  *
1310  *****************************************************************
1311  *
1312  *      Change History
1313  *
1314  *  Vn       Date       Author                  Comment
1315  *
1316  *  1.0      Dec 1998  Corel/Macadamian    Initial version
1317  *  1.1      Mar 1999  Keith Matthews      Added links to instance table and related processing
1318  *
1319  */
1320 HSZ WINAPI DdeCreateStringHandleW(
1321     DWORD idInst,   /* [in] Instance identifier */
1322     LPCWSTR psz,    /* [in] Pointer to string */
1323     INT codepage) /* [in] Code page identifier */
1324 {
1325    DDE_HANDLE_ENTRY *reference_inst;
1326    HSZ hsz = 0;
1327
1328    TRACE("(%ld,%s,%d): partial stub\n",idInst,debugstr_w(psz),codepage);
1329
1330
1331   if ( DDE_Max_Assigned_Instance == 0 )
1332   {
1333           /*  Nothing has been initialised - exit now ! can return FALSE since effect is the same */
1334           return FALSE;
1335   }
1336
1337         if ( !WaitForMutex(handle_mutex) )
1338         {
1339                 return DMLERR_SYS_ERROR;
1340         }
1341
1342   TRACE("CreateString - Handle Mutex created/reserved\n");
1343
1344   /*  First check instance
1345   */
1346   reference_inst = Find_Instance_Entry(idInst);
1347   if ( reference_inst == NULL )
1348   {
1349         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return 0;
1350         /*
1351         Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
1352         */
1353         return 0;
1354   }
1355
1356     FIXME("(%ld,%s,%d): partial stub\n",idInst,debugstr_w(psz),codepage);
1357
1358   if (codepage==CP_WINUNICODE)
1359   /*
1360   Should we be checking this against the unicode/ascii nature of the call to DdeInitialize ?
1361   */
1362   {
1363       hsz = GlobalAddAtomW (psz);
1364       /* Save the handle so we know to clean it when
1365        * uninitialize is called.
1366        */
1367       InsertHSZNode( hsz, reference_inst );
1368       if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst))
1369         {
1370                 reference_inst->Last_Error = DMLERR_SYS_ERROR;
1371                 return 0;
1372         }
1373       TRACE("Returning pointer\n");
1374       return hsz;
1375    } else {
1376         Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
1377 }
1378     TRACE("Returning error\n");
1379   return 0;
1380 }
1381
1382
1383 /*****************************************************************
1384  *            DdeFreeStringHandle16   (DDEML.22)
1385  */
1386 BOOL16 WINAPI DdeFreeStringHandle16( DWORD idInst, HSZ hsz )
1387 {
1388         FIXME("idInst %ld hsz 0x%lx\n",idInst,hsz);
1389     return (BOOL)DdeFreeStringHandle( idInst, hsz );
1390 }
1391
1392
1393 /*****************************************************************
1394  *            DdeFreeStringHandle   (USER32.101)
1395  * RETURNS: success: nonzero
1396  *          fail:    zero
1397  *
1398  *****************************************************************
1399  *
1400  *      Change History
1401  *
1402  *  Vn       Date       Author                  Comment
1403  *
1404  *  1.0      Dec 1998  Corel/Macadamian    Initial version
1405  *  1.1      Apr 1999  Keith Matthews      Added links to instance table and related processing
1406  *
1407  */
1408 BOOL WINAPI DdeFreeStringHandle( DWORD idInst, HSZ hsz )
1409 {
1410     DDE_HANDLE_ENTRY *reference_inst;
1411     TRACE("(%ld,%ld): \n",idInst,hsz);
1412   if ( DDE_Max_Assigned_Instance == 0 )
1413 {
1414           /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
1415           return TRUE;
1416   }
1417
1418         if ( !WaitForMutex(handle_mutex) )
1419         {
1420                 return DMLERR_SYS_ERROR;
1421         }
1422
1423   TRACE("Handle Mutex created/reserved\n");
1424
1425   /*  First check instance
1426   */
1427   reference_inst = Find_Instance_Entry(idInst);
1428   if ( (reference_inst == NULL) || (reference_inst->Node_list == NULL))
1429   {
1430         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return TRUE;
1431           /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
1432           return TRUE;
1433
1434   }
1435
1436     /* Remove the node associated with this HSZ.
1437      */
1438     RemoveHSZNode( hsz , reference_inst);
1439     /* Free the string associated with this HSZ.
1440      */
1441   Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
1442     return GlobalDeleteAtom (hsz) ? 0 : hsz;
1443 }
1444
1445
1446 /*****************************************************************
1447  *            DdeFreeDataHandle16   (DDEML.19)
1448  */
1449 BOOL16 WINAPI DdeFreeDataHandle16( HDDEDATA hData )
1450 {
1451     return (BOOL)DdeFreeDataHandle( hData );
1452 }
1453
1454
1455 /*****************************************************************
1456  *            DdeFreeDataHandle   (USER32.100)
1457  */
1458 BOOL WINAPI DdeFreeDataHandle( HDDEDATA hData )
1459 {
1460     FIXME("empty stub\n" );
1461     return TRUE;
1462 }
1463
1464
1465
1466
1467 /*****************************************************************
1468  *            DdeKeepStringHandle16   (DDEML.24)
1469  */
1470 BOOL16 WINAPI DdeKeepStringHandle16( DWORD idInst, HSZ hsz )
1471 {
1472     return (BOOL)DdeKeepStringHandle( idInst, hsz );
1473 }
1474
1475
1476 /*****************************************************************
1477  *            DdeKeepStringHandle  (USER32.108)
1478  *
1479  * RETURNS: success: nonzero
1480  *          fail:    zero
1481  *
1482  *****************************************************************
1483  *
1484  *      Change History
1485  *
1486  *  Vn       Date       Author                  Comment
1487  *
1488  *  1.0      ?           ?                 Stub only
1489  *  1.1      Jun 1999  Keith Matthews      First cut implementation
1490  *
1491  */
1492 BOOL WINAPI DdeKeepStringHandle( DWORD idInst, HSZ hsz )
1493 {
1494
1495   DDE_HANDLE_ENTRY *reference_inst;
1496   TRACE("(%ld,%ld): \n",idInst,hsz);
1497   if ( DDE_Max_Assigned_Instance == 0 )
1498   {
1499           /*  Nothing has been initialised - exit now ! can return FALSE since effect is the same */
1500           return FALSE;
1501   }
1502
1503
1504         if ( !WaitForMutex(handle_mutex) )
1505         {
1506                 return FALSE;
1507         }
1508
1509   TRACE("Handle Mutex created/reserved\n");
1510
1511   /*  First check instance
1512   */
1513   reference_inst = Find_Instance_Entry(idInst);
1514   if ( (reference_inst == NULL) || (reference_inst->Node_list == NULL))
1515   {
1516         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return FALSE;
1517           /*  Nothing has been initialised - exit now ! can return FALSE since effect is the same */
1518           return FALSE;
1519     return FALSE;
1520    }
1521   DdeReserveAtom(reference_inst,hsz);
1522   Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
1523     return TRUE;
1524 }
1525
1526
1527 /*****************************************************************
1528  *            DdeClientTransaction16  (DDEML.11)
1529  */
1530 HDDEDATA WINAPI DdeClientTransaction16( LPVOID pData, DWORD cbData,
1531                                         HCONV hConv, HSZ hszItem, UINT16 wFmt,
1532                                         UINT16 wType, DWORD dwTimeout,
1533                                         LPDWORD pdwResult )
1534 {
1535     return DdeClientTransaction( (LPBYTE)pData, cbData, hConv, hszItem,
1536                                    wFmt, wType, dwTimeout, pdwResult );
1537 }
1538
1539
1540 /*****************************************************************
1541  *            DdeClientTransaction  (USER32.90)
1542  */
1543 HDDEDATA WINAPI DdeClientTransaction( LPBYTE pData, DWORD cbData,
1544                                         HCONV hConv, HSZ hszItem, UINT wFmt,
1545                                         UINT wType, DWORD dwTimeout,
1546                                         LPDWORD pdwResult )
1547 {
1548     FIXME("empty stub\n" );
1549     return 0;
1550 }
1551
1552 /*****************************************************************
1553  *
1554  *            DdeAbandonTransaction16 (DDEML.12)
1555  *
1556  */
1557 BOOL16 WINAPI DdeAbandonTransaction16( DWORD idInst, HCONV hConv,
1558                                      DWORD idTransaction )
1559 {
1560     FIXME("empty stub\n" );
1561     return TRUE;
1562 }
1563
1564
1565 /*****************************************************************
1566  *
1567  *            DdeAbandonTransaction (USER32.87)
1568  *
1569 ******************************************************************
1570  *
1571  *      Change History
1572  *
1573  *  Vn       Date       Author                  Comment
1574  *
1575  *  1.0      March 1999 K Matthews              stub only
1576  */
1577 BOOL WINAPI DdeAbandonTransaction( DWORD idInst, HCONV hConv,
1578                                      DWORD idTransaction )
1579 {
1580     FIXME("empty stub\n" );
1581     return TRUE;
1582 }
1583
1584 /*****************************************************************
1585  * DdePostAdvise16 [DDEML.13]
1586  */
1587 BOOL16 WINAPI DdePostAdvise16( DWORD idInst, HSZ hszTopic, HSZ hszItem )
1588 {
1589     return (BOOL16)DdePostAdvise(idInst, hszTopic, hszItem);
1590 }
1591
1592
1593 /******************************************************************************
1594  * DdePostAdvise [USER32.110]  Send transaction to DDE callback function.
1595  *
1596  * RETURNS
1597  *    Success: TRUE
1598  *    Failure: FALSE
1599  */
1600 BOOL WINAPI DdePostAdvise(
1601     DWORD idInst, /* [in] Instance identifier */
1602     HSZ hszTopic, /* [in] Handle to topic name string */
1603     HSZ hszItem)  /* [in] Handle to item name string */
1604 {
1605     FIXME("(%ld,%ld,%ld): stub\n",idInst,hszTopic,hszItem);
1606     return TRUE;
1607 }
1608
1609
1610 /*****************************************************************
1611  *            DdeAddData16 (DDEML.15)
1612  */
1613 HDDEDATA WINAPI DdeAddData16( HDDEDATA hData, LPBYTE pSrc, DWORD cb,
1614                             DWORD cbOff )
1615 {
1616     FIXME("empty stub\n" );
1617     return 0;
1618 }
1619
1620 /*****************************************************************
1621  *
1622  *            DdeAddData (USER32.89)
1623  *
1624 ******************************************************************
1625  *
1626  *      Change History
1627  *
1628  *  Vn       Date       Author                  Comment
1629  *
1630  *  1.0      March 1999 K Matthews              stub only
1631  */
1632 HDDEDATA WINAPI DdeAddData( HDDEDATA hData, LPBYTE pSrc, DWORD cb,
1633                             DWORD cbOff )
1634 {
1635     FIXME("empty stub\n" );
1636     return 0;
1637 }
1638
1639
1640 /*****************************************************************
1641  *
1642  *            DdeImpersonateClient (USER32.105)
1643  *
1644 ******************************************************************
1645  *
1646  *      Change History
1647  *
1648  *  Vn       Date       Author                  Comment
1649  *
1650  *  1.0      March 1999 K Matthews              stub only
1651  */
1652
1653 BOOL WINAPI DdeImpersonateClient( HCONV hConv)
1654 {
1655     FIXME("empty stub\n" );
1656     return TRUE;
1657 }
1658
1659
1660 /*****************************************************************
1661  *
1662  *            DdeSetQualityOfService (USER32.116)
1663  *
1664 ******************************************************************
1665  *
1666  *      Change History
1667  *
1668  *  Vn       Date       Author                  Comment
1669  *
1670  *  1.0      March 1999 K Matthews              stub only
1671  */
1672
1673 BOOL WINAPI DdeSetQualityOfService( HWND hwndClient, CONST SECURITY_QUALITY_OF_SERVICE *pqosNew,
1674                                         PSECURITY_QUALITY_OF_SERVICE pqosPrev)
1675 {
1676     FIXME("empty stub\n" );
1677     return TRUE;
1678 }
1679
1680 /*****************************************************************
1681  *
1682  *            DdeSetUserHandle (USER32.117)
1683  *
1684 ******************************************************************
1685  *
1686  *      Change History
1687  *
1688  *  Vn       Date       Author                  Comment
1689  *
1690  *  1.0      March 1999 K Matthews              stub only
1691  */
1692
1693 BOOL WINAPI DdeSetUserHandle( HCONV hConv, DWORD id, DWORD hUser)
1694 {
1695     FIXME("empty stub\n" );
1696     return TRUE;
1697 }
1698
1699 /******************************************************************************
1700  * DdeGetData [USER32.102]  Copies data from DDE object ot local buffer
1701  *
1702  * RETURNS
1703  *    Size of memory object associated with handle
1704  */
1705 DWORD WINAPI DdeGetData(
1706     HDDEDATA hData, /* [in] Handle to DDE object */
1707     LPBYTE pDst,    /* [in] Pointer to destination buffer */
1708     DWORD cbMax,    /* [in] Amount of data to copy */
1709     DWORD cbOff)    /* [in] Offset to beginning of data */
1710 {
1711     FIXME("(%ld,%p,%ld,%ld): stub\n",hData,pDst,cbMax,cbOff);
1712     return cbMax;
1713 }
1714
1715
1716 /*****************************************************************
1717  * DdeGetData16 [DDEML.16]
1718  */
1719 DWORD WINAPI DdeGetData16(
1720     HDDEDATA hData,
1721     LPBYTE pDst,
1722     DWORD cbMax,
1723     DWORD cbOff)
1724 {
1725     return DdeGetData(hData, pDst, cbMax, cbOff);
1726 }
1727
1728
1729 /*****************************************************************
1730  *            DdeAccessData16 (DDEML.17)
1731  */
1732 LPBYTE WINAPI DdeAccessData16( HDDEDATA hData, LPDWORD pcbDataSize )
1733 {
1734      return DdeAccessData(hData, pcbDataSize);
1735 }
1736
1737 /*****************************************************************
1738  *            DdeAccessData (USER32.88)
1739  */
1740 LPBYTE WINAPI DdeAccessData( HDDEDATA hData, LPDWORD pcbDataSize )
1741 {
1742      FIXME("(%ld,%p): stub\n", hData, pcbDataSize);
1743      return 0;
1744 }
1745
1746 /*****************************************************************
1747  *            DdeUnaccessData16 (DDEML.18)
1748  */
1749 BOOL16 WINAPI DdeUnaccessData16( HDDEDATA hData )
1750 {
1751      return DdeUnaccessData(hData);
1752 }
1753
1754 /*****************************************************************
1755  *            DdeUnaccessData (USER32.118)
1756  */
1757 BOOL WINAPI DdeUnaccessData( HDDEDATA hData )
1758 {
1759      FIXME("(0x%lx): stub\n", hData);
1760
1761      return 0;
1762 }
1763
1764 /*****************************************************************
1765  *            DdeEnableCallback16 (DDEML.26)
1766  */
1767 BOOL16 WINAPI DdeEnableCallback16( DWORD idInst, HCONV hConv, UINT16 wCmd )
1768 {
1769      return DdeEnableCallback(idInst, hConv, wCmd);
1770 }
1771
1772 /*****************************************************************
1773  *            DdeEnableCallback (USER32.99)
1774  */
1775 BOOL WINAPI DdeEnableCallback( DWORD idInst, HCONV hConv, UINT wCmd )
1776 {
1777      FIXME("(%ld, 0x%lx, %d) stub\n", idInst, hConv, wCmd);
1778
1779      return 0;
1780 }
1781
1782 /*****************************************************************
1783  *            DdeNameService16  (DDEML.27)
1784  */
1785 HDDEDATA WINAPI DdeNameService16( DWORD idInst, HSZ hsz1, HSZ hsz2,
1786                                   UINT16 afCmd )
1787 {
1788     return DdeNameService( idInst, hsz1, hsz2, afCmd );
1789 }
1790
1791
1792 /******************************************************************************
1793  * DdeNameService [USER32.109]  {Un}registers service name of DDE server
1794  *
1795  * PARAMS
1796  *    idInst [I] Instance identifier
1797  *    hsz1   [I] Handle to service name string
1798  *    hsz2   [I] Reserved
1799  *    afCmd  [I] Service name flags
1800  *
1801  * RETURNS
1802  *    Success: Non-zero
1803  *    Failure: 0
1804  *
1805  *****************************************************************
1806  *
1807  *      Change History
1808  *
1809  *  Vn       Date       Author                  Comment
1810  *
1811  *  1.0      ?            ?                Stub
1812  *  1.1      Apr 1999  Keith Matthews      Added trap for non-existent instance (uninitialised instance 0
1813  *                                              used by some MS programs for unfathomable reasons)
1814  *  1.2      May 1999  Keith Matthews      Added parameter validation and basic service name handling.
1815  *                                         Still needs callback parts
1816  *
1817  */
1818 HDDEDATA WINAPI DdeNameService( DWORD idInst, HSZ hsz1, HSZ hsz2,
1819                 UINT afCmd )
1820 {
1821   ServiceNode* this_service, *reference_service ;
1822   DDE_HANDLE_ENTRY *this_instance;
1823   DDE_HANDLE_ENTRY *reference_inst;
1824   this_service = NULL;
1825
1826   FIXME("(%ld,%ld,%ld,%d): stub\n",idInst,hsz1,hsz2,afCmd);
1827
1828   if ( DDE_Max_Assigned_Instance == 0 )
1829   {
1830           /*  Nothing has been initialised - exit now !
1831            *    needs something for DdeGetLastError */
1832           return 0L;
1833   }
1834
1835         if ( !WaitForMutex(handle_mutex) )
1836         {
1837                 return DMLERR_SYS_ERROR;
1838         }
1839
1840    TRACE("Handle Mutex created/reserved\n");
1841
1842    /*  First check instance
1843    */
1844    reference_inst = Find_Instance_Entry(idInst);
1845    this_instance = reference_inst;
1846    if  (reference_inst == NULL)
1847    {
1848         TRACE("Instance not found as initialised\n");
1849         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance)) return TRUE;
1850           /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
1851           return FALSE;
1852
1853    }
1854
1855   if ( hsz2 != 0L )
1856   {
1857         /*      Illegal, reserved parameter
1858          */
1859         reference_inst->Last_Error = DMLERR_INVALIDPARAMETER;
1860         Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1861         FIXME("Reserved parameter no-zero !!\n");
1862         return FALSE;
1863   }
1864   if ( hsz1 == 0L )
1865   {
1866         /*
1867          *      General unregister situation
1868          */
1869         if ( afCmd != DNS_UNREGISTER )
1870         {
1871                 /*      don't know if we should check this but it makes sense
1872                  *      why supply REGISTER or filter flags if de-registering all
1873                  */
1874                 TRACE("General unregister unexpected flags\n");
1875                 reference_inst->Last_Error = DMLERR_DLL_USAGE;
1876                 Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1877                 return FALSE;
1878         }
1879         /*      Loop to find all registered service and de-register them
1880          */
1881         if ( reference_inst->ServiceNames == NULL )
1882         {
1883                 /*  None to unregister !!
1884                  */
1885                 TRACE("General de-register - nothing registered\n");
1886                 reference_inst->Last_Error = DMLERR_DLL_USAGE;
1887                 Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1888                 return FALSE;
1889         }  else
1890         {
1891                 this_service = reference_inst->ServiceNames;
1892                 while ( this_service->next != NULL)
1893                 {
1894                         TRACE("general deregister - iteration\n");
1895                         reference_service = this_service;
1896                         this_service = this_service->next;
1897                         DdeReleaseAtom(reference_inst,reference_service->hsz);
1898                         HeapFree(SystemHeap, 0, reference_service); /* finished - release heap space used as work store */
1899                 }
1900                 DdeReleaseAtom(reference_inst,this_service->hsz);
1901                 HeapFree(SystemHeap, 0, this_service); /* finished - release heap space used as work store */
1902                 reference_inst->ServiceNames = NULL;
1903                 TRACE("General de-register - finished\n");
1904         }
1905         Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1906         return TRUE;
1907   }
1908   TRACE("Specific name action detected\n");
1909   if ( afCmd & DNS_REGISTER )
1910   {
1911         /* Register new service name
1912          */
1913
1914         this_service = Find_Service_Name( hsz1, reference_inst );
1915         if ( this_service )
1916                 ERR("Trying to register already registered service!\n");
1917         else
1918         {
1919                 TRACE("Adding service name\n");
1920
1921                 DdeReserveAtom(reference_inst, hsz1);
1922
1923                 this_service = (ServiceNode*)HeapAlloc( SystemHeap, 0, sizeof(ServiceNode) );
1924                 this_service->hsz = hsz1;
1925                 this_service->FilterOn = TRUE;
1926
1927                 this_service->next = reference_inst->ServiceNames;
1928                 reference_inst->ServiceNames = this_service;
1929         }
1930   }
1931   if ( afCmd & DNS_UNREGISTER )
1932   {
1933         /*      De-register service name
1934          */
1935
1936         ServiceNode **pServiceNode = &reference_inst->ServiceNames;
1937         while ( *pServiceNode && (*pServiceNode)->hsz != hsz1 )
1938                 pServiceNode = &(*pServiceNode)->next;
1939
1940         this_service = *pServiceNode;
1941         if ( !this_service )
1942                 ERR("Trying to de-register unregistered service!\n");
1943         else
1944         {
1945                 *pServiceNode = this_service->next;
1946                 DdeReleaseAtom(reference_inst,this_service->hsz);
1947                 HeapFree(SystemHeap, 0, this_service);
1948         }
1949   }
1950   if ( afCmd & DNS_FILTERON )
1951   {
1952         /*      Set filter flags on to hold notifications of connection
1953          *
1954          *      test coded this way as this is the default setting
1955          */
1956         this_service = Find_Service_Name( hsz1, reference_inst );
1957         if ( !this_service )
1958         {
1959                 /*  trying to filter where no service names !!
1960                  */
1961                 reference_inst->Last_Error = DMLERR_DLL_USAGE;
1962                 Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1963                 return FALSE;
1964         } else
1965         {
1966                 this_service->FilterOn = TRUE;
1967         }
1968   }
1969   if ( afCmd & DNS_FILTEROFF )
1970   {
1971         /*      Set filter flags on to hold notifications of connection
1972          */
1973         this_service = Find_Service_Name( hsz1, reference_inst );
1974         if ( !this_service )
1975         {
1976                 /*  trying to filter where no service names !!
1977                  */
1978                 reference_inst->Last_Error = DMLERR_DLL_USAGE;
1979                 Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1980                 return FALSE;
1981         } else
1982         {
1983                 this_service->FilterOn = FALSE;
1984         }
1985   }
1986   Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,this_instance);
1987   return TRUE;
1988 }
1989
1990
1991 /*****************************************************************
1992  *            DdeGetLastError16  (DDEML.20)
1993  */
1994 UINT16 WINAPI DdeGetLastError16( DWORD idInst )
1995 {
1996     return (UINT16)DdeGetLastError( idInst );
1997 }
1998
1999
2000 /******************************************************************************
2001  * DdeGetLastError [USER32.103]  Gets most recent error code
2002  *
2003  * PARAMS
2004  *    idInst [I] Instance identifier
2005  *
2006  * RETURNS
2007  *    Last error code
2008  *
2009  *****************************************************************
2010  *
2011  *      Change History
2012  *
2013  *  Vn       Date       Author                  Comment
2014  *
2015  *  1.0      ?            ?                Stub
2016  *  1.1      Apr 1999  Keith Matthews      Added response for non-existent instance (uninitialised instance 0
2017  *                                              used by some MS programs for unfathomable reasons)
2018  *  1.2      May 1999  Keith Matthews      Added interrogation of Last_Error for instance handle where found.
2019  *
2020  */
2021 UINT WINAPI DdeGetLastError( DWORD idInst )
2022 {
2023     DWORD       error_code;
2024     DDE_HANDLE_ENTRY *reference_inst;
2025
2026     FIXME("(%ld): stub\n",idInst);
2027
2028     if ( DDE_Max_Assigned_Instance == 0 )
2029     {
2030           /*  Nothing has been initialised - exit now ! */
2031           return DMLERR_DLL_NOT_INITIALIZED;
2032     }
2033
2034         if ( !WaitForMutex(handle_mutex) )
2035         {
2036                 return DMLERR_SYS_ERROR;
2037         }
2038
2039    TRACE("Handle Mutex created/reserved\n");
2040
2041    /*  First check instance
2042    */
2043    reference_inst = Find_Instance_Entry(idInst);
2044    if  (reference_inst == NULL)
2045    {
2046         if ( Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst)) return TRUE;
2047           /*  Nothing has been initialised - exit now ! can return TRUE since effect is the same */
2048           return DMLERR_DLL_NOT_INITIALIZED;
2049
2050    }
2051     error_code = reference_inst->Last_Error;
2052     reference_inst->Last_Error = 0;
2053     Release_reserved_mutex(handle_mutex,"handle_mutex",FALSE,FALSE,reference_inst);
2054    return error_code;
2055 }
2056
2057
2058 /*****************************************************************
2059  *            DdeCmpStringHandles16 (DDEML.36)
2060  */
2061 int WINAPI DdeCmpStringHandles16( HSZ hsz1, HSZ hsz2 )
2062 {
2063      return DdeCmpStringHandles(hsz1, hsz2);
2064 }
2065
2066 /*****************************************************************
2067  *            DdeCmpStringHandles (USER32.91)
2068  *
2069  * Compares the value of two string handles.  This comparison is
2070  * not case sensitive.
2071  *
2072  * Returns:
2073  * -1 The value of hsz1 is zero or less than hsz2
2074  * 0  The values of hsz 1 and 2 are the same or both zero.
2075  * 1  The value of hsz2 is zero of less than hsz1
2076  */
2077 int WINAPI DdeCmpStringHandles( HSZ hsz1, HSZ hsz2 )
2078 {
2079     CHAR psz1[MAX_BUFFER_LEN];
2080     CHAR psz2[MAX_BUFFER_LEN];
2081     int ret = 0;
2082     int ret1, ret2;
2083
2084     TRACE("handle 1, handle 2\n" );
2085
2086     ret1 = GlobalGetAtomNameA( hsz1, psz1, MAX_BUFFER_LEN );
2087     ret2 = GlobalGetAtomNameA( hsz2, psz2, MAX_BUFFER_LEN );
2088     /* Make sure we found both strings.
2089      */
2090     if( ret1 == 0 && ret2 == 0 )
2091     {
2092         /* If both are not found, return both  "zero strings".
2093          */
2094         ret = 0;
2095     }
2096     else if( ret1 == 0 )
2097     {
2098         /* If hsz1 is a not found, return hsz1 is "zero string".
2099          */
2100         ret = -1;
2101     }
2102     else if( ret2 == 0 )
2103     {
2104         /* If hsz2 is a not found, return hsz2 is "zero string".
2105          */
2106         ret = 1;
2107     }
2108     else
2109     {
2110         /* Compare the two strings we got ( case insensitive ).
2111          */
2112         ret = strcasecmp( psz1, psz2 );
2113         /* Since strcmp returns any number smaller than
2114          * 0 when the first string is found to be less than
2115          * the second one we must make sure we are returning
2116          * the proper values.
2117          */
2118         if( ret < 0 )
2119         {
2120             ret = -1;
2121         }
2122         else if( ret > 0 )
2123         {
2124             ret = 1;
2125         }
2126     }
2127
2128     return ret;
2129 }
2130
2131 /*****************************************************************
2132  *            PackDDElParam (USER32.414)
2133  *
2134  * RETURNS
2135  *   success: nonzero
2136  *   failure: zero
2137  */
2138 UINT WINAPI PackDDElParam(UINT msg, UINT uiLo, UINT uiHi)
2139 {
2140     FIXME("stub.\n");
2141     return 0;
2142 }
2143
2144
2145 /*****************************************************************
2146  *            UnpackDDElParam (USER32.562)
2147  *
2148  * RETURNS
2149  *   success: nonzero
2150  *   failure: zero
2151  */
2152 UINT WINAPI UnpackDDElParam(UINT msg, UINT lParam,
2153                               UINT *uiLo, UINT *uiHi)
2154 {
2155     FIXME("stub.\n");
2156     return 0;
2157 }
2158
2159
2160 /*****************************************************************
2161  *            FreeDDElParam (USER32.204)
2162  *
2163  * RETURNS
2164  *   success: nonzero
2165  *   failure: zero
2166  */
2167 UINT WINAPI FreeDDElParam(UINT msg, UINT lParam)
2168 {
2169     FIXME("stub.\n");
2170     return 0;
2171 }
2172
2173 /*****************************************************************
2174  *            ReuseDDElParam (USER32.446)
2175  *
2176  */
2177 UINT WINAPI ReuseDDElParam(UINT lParam, UINT msgIn, UINT msgOut,
2178                              UINT uiLi, UINT uiHi)
2179 {
2180     FIXME("stub.\n");
2181     return 0;
2182 }
2183
2184 /******************************************************************
2185  *              DdeQueryConvInfo16 (DDEML.9)
2186  *
2187  */
2188 UINT16 WINAPI DdeQueryConvInfo16( HCONV hconv, DWORD idTransaction , LPCONVINFO16 lpConvInfo)
2189 {
2190         FIXME("stub.\n");
2191         return 0;
2192 }
2193
2194
2195 /******************************************************************
2196  *              DdeQueryConvInfo (USER32.111)
2197  *
2198  */
2199 UINT WINAPI DdeQueryConvInfo( HCONV hconv, DWORD idTransaction , LPCONVINFO lpConvInfo)
2200 {
2201         FIXME("stub.\n");
2202         return 0;
2203 }