/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    dllmuxwt.c

Abstract:

    This module implements the OS/2 V2.0 MuxWait Semaphore API Calls.

Author:

    Steve Wood (stevewo) 07-Feb-1990

Revision History:

--*/

#define INCL_OS2V20_SEMAPHORES
#define INCL_OS2V20_ERRORS
#include "os2dll.h"


APIRET
Od2AddMuxWait(
    IN POD2_MUXWAIT_SEMAPHORE MuxWait,
    IN PSEMRECORD MuxWaitEntry
    )
{
    POD2_MUXWAIT_RECORD MuxWaitRecord;
    APIRET rc;
    BOOLEAN SharedSem;
    POR2_HANDLE_TABLE SemaphoreTable;
    POD2_SEMAPHORE Semaphore;
    ULONG Handle;
    USHORT i;

    if (MuxWait->CountMuxWaitRecords == DCMW_MAX_SEMRECORDS) {
        return( ERROR_TOO_MANY_SEMAPHORES );
        }

    //
    // Validate the passed OS/2 2.0 semaphore handle and extract the
    // shared/private flag and the index field.  Return an error if not a
    // valid handle.
    //

    rc = Od2ValidateSemaphoreHandle( MuxWaitEntry->hsemCur,
                                     &SharedSem,
                                     &Handle
                                   );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Table must exist.  Return an error if it does not.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, FALSE );
    if (!SemaphoreTable) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Map the semaphore handle into a pointer to the semaphore structure
    // contained in the table.  Return an error if the handle is outside the
    // current limits of the table.  If the mapping is successful then the
    // semaphore table is left locked while we use the pointer.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       Handle,
                                                       TRUE
                                                     );
    if (Semaphore == NULL) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Now see if this semaphore is already in the MuxWait semaphore.
    // Return an error if it is.
    //

    MuxWaitRecord = &MuxWait->MuxWaitRecords[ 0 ];
    for (i=0; i<MuxWait->CountMuxWaitRecords; i++) {
        if (MuxWaitRecord->Semaphore == Semaphore) {
            return( ERROR_DUPLICATE_HANDLE );
            }

        MuxWaitRecord++;
        }


    //
    // Entry in semaphore table exists, so make sure it is not a MuxWait
    // semaphore.  Also make sure it is that same type of semaphore as the
    // first semaphore.  Also make sure if the MuxWait semaphore that all
    // the component semaphores are also shared.  Return an error if any
    // of these conditions are not met.
    //

    if (Semaphore->Type == Od2MuxWaitSem) {
        return( ERROR_WRONG_TYPE );
        }

    if (MuxWait->CountMuxWaitRecords == 0) {
        MuxWait->Type = Semaphore->Type;
        }
    else
    if (Semaphore->Type != MuxWait->Type) {
        return( ERROR_WRONG_TYPE );
        }

    //
    // At this point everything is copasetic, so fill in the next available
    // record in the MuxWait semaphore.
    //

    MuxWaitRecord->SemHandle = MuxWaitEntry->hsemCur;
    MuxWaitRecord->UserKey = MuxWaitEntry->ulUser;
    MuxWaitRecord->Semaphore = Od2ReferenceSemaphore( Semaphore );
    MuxWait->CountMuxWaitRecords++;

    return( NO_ERROR );
}


APIRET
Od2DeleteMuxWait(
    IN POD2_MUXWAIT_SEMAPHORE MuxWait,
    IN ULONG MuxWaitEntryIndex,
    IN HSEM MuxWaitEntrySem OPTIONAL
    )
{
    POD2_MUXWAIT_RECORD MuxWaitRecord;
    USHORT i;

    if (MuxWait->CountMuxWaitRecords == 0) {
        return( ERROR_EMPTY_MUXWAIT );
        }

    MuxWaitRecord = &MuxWait->MuxWaitRecords[ 0 ];
    for (i=0; i<MuxWait->CountMuxWaitRecords; i++) {
        if (ARGUMENT_PRESENT( MuxWaitEntrySem )) {
            if (MuxWaitRecord->SemHandle == MuxWaitEntrySem) {
                break;
                }
            }
        else
        if (i == (USHORT)MuxWaitEntryIndex) {
            break;
            }

        MuxWaitRecord++;
        }

    if (i == MuxWait->CountMuxWaitRecords) {
        return( ERROR_INVALID_HANDLE );
        }

    Od2DereferenceSemaphore( MuxWaitRecord->Semaphore );

    MuxWait->CountMuxWaitRecords -= 1;
    for (; i<MuxWait->CountMuxWaitRecords; i++) {
        *MuxWaitRecord = *(MuxWaitRecord+1);
        MuxWaitRecord++;
        }
    MuxWaitRecord->Semaphore = NULL;
    MuxWaitRecord->SemHandle = 0;
    MuxWaitRecord->UserKey = 0;

    return( NO_ERROR );
}



APIRET
DosCreateMuxWaitSem(
    IN PSZ ObjectName,
    IN OUT PHMUX MuxWaitHandle,
    IN ULONG CountMuxWaitEntries,
    IN SEMRECORD MuxWaitEntries[],
    IN ULONG CreateAttributes
    )
{
    OS2_API_MSG m;
    POS2_DOSCREATEMUXWAITSEM_MSG a = &m.u.DosCreateMuxWaitSem;
    POS2_DOSCLOSEMUXWAITSEM_MSG a1 = &m.u.DosCloseMuxWaitSem;
    POS2_CAPTURE_HEADER CaptureBuffer;
    PSEMRECORD CapturedMuxWaitEntries;
    APIRET rc;
    ULONG i;
    BOOLEAN SharedSem;
    ULONG MuxWaitType;
    POR2_HANDLE_TABLE SemaphoreTable;
    OD2_SEMAPHORE Semaphore;
    POD2_MUXWAIT_SEMAPHORE MuxWait;

    //
    // Validate the simple parameters
    //

    MuxWaitType = CreateAttributes & (DCMW_WAIT_ANY | DCMW_WAIT_ALL);
    if (MuxWaitType == 0 ||
        !(MuxWaitType ^ (DCMW_WAIT_ANY | DCMW_WAIT_ALL)) ||
        CreateAttributes & ~(DC_SEM_SHARED | DCMW_WAIT_ANY | DCMW_WAIT_ALL)
       ) {
        return( ERROR_INVALID_PARAMETER );
        }

    if (CountMuxWaitEntries > DCMW_MAX_SEMRECORDS) {
        return( ERROR_TOO_MANY_SEMAPHORES );
        }

    //
    // probe handle pointer and MuxWaitEntries buffer
    //

    try {
        Od2ProbeForWrite( (PVOID)MuxWaitHandle, sizeof( MuxWaitHandle ), 1 );
        Od2ProbeForRead(MuxWaitEntries,sizeof(SEMRECORD)*CountMuxWaitEntries,1);
    } except( EXCEPTION_EXECUTE_HANDLER ) {
       Od2ExitGP();
        }

    //
    // Capture and validate any semaphore name.
    //

    rc = Od2CaptureObjectName( ObjectName,
                               CANONICALIZE_SEMAPHORE,
                               sizeof( OD2_MUXWAIT_SEMAPHORE ),
                               &CaptureBuffer,
                               &a->ObjectName
                             );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Determine if a shared or private semaphore.
    //

    if (CaptureBuffer != NULL || CreateAttributes & DC_SEM_SHARED) {
        SharedSem = TRUE;
        }
    else {
        SharedSem = FALSE;
        }

    //
    // Get the pointer to either the shared or private semaphore table,
    // creating it if necessary.  Lock the table for the duration of this
    // API call.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, TRUE );
    if (!SemaphoreTable) {
        if (CaptureBuffer != NULL) {
            Od2FreeCaptureBuffer( CaptureBuffer );
            }
        return( ERROR_NOT_ENOUGH_MEMORY );
        }


    //
    // Initialize the Client OS/2 Semaphore Structure
    //

    Semaphore.Type = Od2MuxWaitSem;
    Semaphore.Shared = SharedSem;
    Semaphore.PointerCount = 0;
    Semaphore.OpenCount = 1;
    Semaphore.u.MuxWait = MuxWait = NULL;


    //
    // Mark the fact that we are creating a semaphore handle.
    //

    a->HandleIndex = 0xFFFFFFFF;

    if (SharedSem) {
        //
        // For shared semaphores, we need to pass the create to OS/2 Subsystem
        // so that it can manager adds and deletes.
        //

        //
        // If one or more SEMRECORDs then allocate space for a copy in the
        // CaptureBuffer so we can pass the array to the server.
        //

        if (CountMuxWaitEntries != 0) {
            if (CaptureBuffer == NULL) {
                CaptureBuffer = Od2AllocateCaptureBuffer(
                                    1,
                                    0,
                                    (sizeof( OD2_MUXWAIT_SEMAPHORE ) + 3) & ~3
                                    );
                if (CaptureBuffer == NULL) {
                    return( ERROR_NOT_ENOUGH_MEMORY );
                    }
                }

            Od2AllocateMessagePointer( CaptureBuffer,
                                       CountMuxWaitEntries * sizeof( SEMRECORD ),
                                       (PVOID *)&(a->MuxWaitEntries)
                                     );
            CapturedMuxWaitEntries = a->MuxWaitEntries;
            for (i=0; i<CountMuxWaitEntries; i++) {
                CapturedMuxWaitEntries->ulUser = MuxWaitEntries->ulUser;
                rc = Od2ValidateSemaphoreHandle(
                         MuxWaitEntries->hsemCur,
                         &SharedSem,
                         (PULONG)&CapturedMuxWaitEntries->hsemCur
                         );
                if (rc != NO_ERROR) {
                    break;
                    }
                else
                if (!SharedSem) {
                    rc = ERROR_WRONG_TYPE;
                    break;
                    }
                else {
                    MuxWaitEntries++;
                    CapturedMuxWaitEntries++;
                    }
                }
            }
        else {
            a->MuxWaitEntries = NULL;
            }

        if (rc != NO_ERROR) {
            if (CaptureBuffer != NULL) {
                Od2FreeCaptureBuffer( CaptureBuffer );
                }

            return( rc );
            }


        //
        // Pass the call to the OS/2 subsystem to create the system wide
        // semaphore handle value.
        //

        a->CreateAttributes = CreateAttributes | DC_SEM_SHARED;
        a->CountMuxWaitEntries = CountMuxWaitEntries;

        rc = Od2CallSubsystem( &m,
                               CaptureBuffer,
                               Os2CreateMuxWaitSem,
                               sizeof( *a )
                             );

        //
        // Free any capture buffer, since the subsystem has saved away any
        // semaphore name in its table.
        //

        if (CaptureBuffer != NULL) {
            Od2FreeCaptureBuffer( CaptureBuffer );
            }

        //
        // At this point, the semaphore handle index has been stored in
        // a->HandleIndex by the OS/2 subsystem, if rc is NO_ERROR
        //

        }
    else {
        //
        // Private semaphore.  Allocate the muxwait semaphore structure.
        // Return an error if not enough memory to allocate the structure.
        //

        MuxWait = RtlAllocateHeap( Od2Heap, 0, sizeof( *MuxWait ) );
        if (MuxWait == NULL) {
            return( ERROR_NOT_ENOUGH_MEMORY );
            }

        //
        // Initialize the muxwait semaphore sturcture to contain zero records.
        //

        MuxWait->CountMuxWaitRecords = 0;
        MuxWait->Type = 0;
        MuxWait->WaitAll = (BOOLEAN)((CreateAttributes & DCMW_WAIT_ALL) != 0);
        MuxWait->Reserved = 0;


        //
        // Loop over the input array of SEMRECORDs adding them one at a time
        // to the muxwait semaphore.  Bail out of loop if any errors occur.
        // Lock the semaphore table prior to entering the loop so that things
        // change change out from under us.
        //

        AcquireHandleTableLock( SemaphoreTable );
        for (i=0; i<CountMuxWaitEntries; i++) {
            rc = Od2AddMuxWait( MuxWait,
                                MuxWaitEntries
                              );
            if (rc != NO_ERROR) {
                break;
                }
            else {
                MuxWaitEntries++;
                }
            }

        //
        // All done.  If successful, store the address of the muxwait structure
        // in the semaphore structure.
        //

        if (rc == NO_ERROR) {
            Semaphore.u.MuxWait = MuxWait;
            }
        }

    //
    // Create an entry in the appropriate semaphore table, which will copy
    // the semaphore structure into the table entry and return an index to
    // the entry in a->HandleIndex
    //

    if (rc != NO_ERROR ||
        !Or2CreateHandle( SemaphoreTable,
                                   &a->HandleIndex,
                                   (PVOID)&Semaphore
                                 )
       ) {
        //
        // Error occurred. Cleanup any partial results.
        //

        if (!SharedSem) {
            if (MuxWait != NULL) {
                //
                // For a private muxwait semaphore, deconstruct whatever
                // portion of the muxwait semaphore that was successfully
                // constructed and then free the allocated memory and release
                // the lock we acquired at the beginning of the construction
                // process.
                //

                while (Od2DeleteMuxWait( MuxWait, 0, 0 ) == NO_ERROR) {
                    ;
                    }

                RtlFreeHeap( Od2Heap, 0, MuxWait );
                }

            ReleaseHandleTableLock( SemaphoreTable );
            }
        else
        if (a->HandleIndex != -1) {
            //
            // If this is a shared semaphore that successfully created the
            // handle in the OS/2 subsystem, then call the subsystem to
            // close our reference to this shared OS/2 semaphore.
            //

            a1->HandleIndex = a->HandleIndex;
            Od2CallSubsystem( &m, NULL, Os2CloseMuxWaitSem, sizeof( *a1 ) );
            }


        //
        // Return the error code to the caller.
        //

        if (rc == NO_ERROR) {
            return( ERROR_NOT_ENOUGH_MEMORY );
            }
        else {
            return( rc );
            }
        }


    //
    // Okay to release the lock we held while building the private muxwait
    // semaphore.
    //

    if (!SharedSem) {
        ReleaseHandleTableLock( SemaphoreTable );
        }


    //
    // Success.  Store a valid OS/2 2.0 Semaphore handle in the location
    // specified by the caller and return success to the caller.
    //

    *MuxWaitHandle = Od2ConstructSemaphoreHandle( SharedSem,
                                                  a->HandleIndex
                                                );
    return( NO_ERROR );
}


APIRET
DosOpenMuxWaitSem(
    IN PSZ ObjectName,
    IN OUT PHMUX MuxWaitHandle
    )
{
    OS2_API_MSG m;
    POS2_DOSOPENMUXWAITSEM_MSG a = &m.u.DosOpenMuxWaitSem;
    POS2_DOSCLOSEMUXWAITSEM_MSG a1 = &m.u.DosCloseMuxWaitSem;
    POS2_CAPTURE_HEADER CaptureBuffer;
    POR2_HANDLE_TABLE SemaphoreTable;
    OD2_SEMAPHORE NewSemaphore;
    POD2_SEMAPHORE Semaphore;
    BOOLEAN SharedSem;
    APIRET rc;


    //
    // probe handle pointer
    //

    try {
        Od2ProbeForWrite( (PVOID)MuxWaitHandle, sizeof( MuxWaitHandle ), 1 );
    } except( EXCEPTION_EXECUTE_HANDLER ) {
       Od2ExitGP();
        }

    //
    // Capture and validate any semaphore name.
    //

    rc = Od2CaptureObjectName( ObjectName,
                               CANONICALIZE_SEMAPHORE,
                               0,
                               &CaptureBuffer,
                               &a->ObjectName
                             );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Determine if opening the semaphore by name or by handle.
    //

    if (CaptureBuffer != NULL) {
        //
        // If a semaphore name was given, then we are opening the semaphore
        // by name, so call the OS/2 Subsystem to do the name lookup.
        //

        a->HandleIndex = 0xFFFFFFFF;
        rc = Od2CallSubsystem( &m,
                               CaptureBuffer,
                               Os2OpenMuxWaitSem,
                               sizeof( *a )
                             );

        //
        // Free any capture buffer, since the name has served its purpose
        // at this point.
        //

        if (CaptureBuffer != NULL) {
            Od2FreeCaptureBuffer( CaptureBuffer );
            RtlZeroMemory( &a->ObjectName, sizeof( a->ObjectName ) );
            }

        //
        // Return if an error was discovered.
        //

        if (rc != NO_ERROR) {
            return( rc );
            }

        //
        // At this point, the semaphore handle index has been stored in
        // a->HandleIndex by the OS/2 subsystem.  Set the shared semaphore
        // flag.
        //

        SharedSem = TRUE;


        //
        // If the caller specified both the name and the handle, make sure
        // the named mapped to the same handle value that they specified.
        //

        if (*MuxWaitHandle != NULL &&
            *MuxWaitHandle != Od2ConstructSemaphoreHandle( SharedSem,
                                                           a->HandleIndex
                                                         )
           ) {
            return( ERROR_INVALID_PARAMETER );
            }
        }
    else {
        //
        // Opening by handle.  Validate the handle and get the shared/private
        // flag.
        //

        rc = Od2ValidateSemaphoreHandle( *MuxWaitHandle,
                                         &SharedSem,
                                         &a->HandleIndex
                                       );

        //
        // Return if invalid handle.
        //

        if (rc != NO_ERROR) {
            return( rc );
            }
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Creating is okay if this is a shared semaphore open.  Return the
    // appropriate error code if table does not exist or cant be created.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, SharedSem );
    if (!SemaphoreTable) {
        return( SharedSem ? ERROR_NOT_ENOUGH_MEMORY : ERROR_INVALID_HANDLE );
        }

    //
    // Now lock the semaphore table while we figure out what we are doing and
    // do it.
    //

    AcquireHandleTableLock( SemaphoreTable );

    //
    // See if the semaphore handle maps to an allocated entry in the table.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       a->HandleIndex,
                                                       TRUE
                                                     );
    if (Semaphore == NULL || *(PULONG)Semaphore == 0) {
        //
        // No entry in the table for this semaphore handle.  Error if not
        // a shared semaphore.
        //

        if (!SharedSem) {
            rc = ERROR_INVALID_HANDLE;
            }
        else {

            //
            // This is the first usage of this shared semaphore handle by
            // the calling process, so call the OS/2 subsystem so that it
            // can bump its reference count.
            //

            rc = Od2CallSubsystem( &m,
                                   NULL,
                                   Os2OpenMuxWaitSem,
                                   sizeof( *a )
                                 );
            if (rc == NO_ERROR) {
                //
                // If we succeeded, then the semaphore was not deleted
                // in between the two calls to the subsystem, so add an
                // entry for this handle in the semaphore table.
                //

                NewSemaphore.Type = Od2MuxWaitSem;
                NewSemaphore.Shared = TRUE;
                NewSemaphore.PointerCount = 0;
                NewSemaphore.OpenCount = 1;
                NewSemaphore.u.MuxWait = 0;

                if (!Or2CreateHandle( SemaphoreTable,
                                               &a->HandleIndex,
                                               (PVOID)&NewSemaphore
                                             )
                   ) {
                    //
                    // Unable to create the entry.  Call the OS/2 subsystem
                    // to close our reference to this shared OS/2 semaphore.
                    // Set the appropriate error code.
                    //

                    a1->HandleIndex = a->HandleIndex;
                    Od2CallSubsystem( &m,
                                      NULL,
                                      Os2CloseMuxWaitSem,
                                      sizeof( *a1 )
                                    );
                    rc = ERROR_NOT_ENOUGH_MEMORY;
                    }
                }
            }
        }

    //
    // Entry in semaphore table exists, so make sure it is a MuxWait semaphore.
    // Set the appropriate error code if not.
    //

    else
    if (Semaphore->Type != Od2MuxWaitSem) {
        rc = ERROR_INVALID_HANDLE;
        }

    //
    // Entry in semaphore table is for a MuxWait semaphore, see if the
    // OpenCount is about to overflow, and set the appropriate error code
    // if it is.
    //

    else
    if (Semaphore->OpenCount == 0xFFFF) {
        rc = ERROR_TOO_MANY_OPENS;
        }

    //
    // Everything is okay, so bump the open count in the semaphore table entry.
    //

    else {
        Semaphore->OpenCount++;
        }

    //
    // All done mucking about, so release the semaphore table lock.
    //

    ReleaseHandleTableLock( SemaphoreTable );

    //
    // If no errors, store a valid OS/2 2.0 Semaphore handle in the location
    // specified by the caller and return success to the caller.
    //

    if (rc == NO_ERROR) {
        *MuxWaitHandle = Od2ConstructSemaphoreHandle( SharedSem,
                                                      a->HandleIndex
                                                    );
        }

    //
    // Return an error code to the caller.
    //

    return( rc );
}


APIRET
DosCloseMuxWaitSem(
    IN HMUX MuxWaitHandle
    )
{
    OS2_API_MSG m;
    POS2_DOSCLOSEMUXWAITSEM_MSG a = &m.u.DosCloseMuxWaitSem;
    POD2_MUXWAIT_SEMAPHORE MuxWait;
    POR2_HANDLE_TABLE SemaphoreTable;
    POD2_SEMAPHORE Semaphore;
    BOOLEAN SharedSem;
    APIRET rc;

    //
    // Validate the passed OS/2 2.0 semaphore handle and extract the
    // shared/private flag and the index field.  Return an error if
    // not a valid handle.
    //

    rc = Od2ValidateSemaphoreHandle( MuxWaitHandle,
                                     &SharedSem,
                                     &a->HandleIndex
                                   );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Table must exist.  Return an error if it does not.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, FALSE );
    if (!SemaphoreTable) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Map the semaphore handle into a pointer to the semaphore structure
    // contained in the table.  Return an error if the handle is outside
    // the current limits of the table.  If the mapping is successful then
    // the semaphore table is left locked while we use the pointer.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       a->HandleIndex,
                                                       FALSE
                                                     );
    if (Semaphore == NULL) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Entry in semaphore table exists, so make sure it is a MuxWait semaphore.
    // Return an error if not, after unlock the table first.
    //

    if (Semaphore->Type != Od2MuxWaitSem) {
        ReleaseHandleTableLock( SemaphoreTable );
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Entry in semaphore table is for a MuxWait semaphore, so decrement the
    // OpenCount and see if it has gone to zero.
    //

    if (--Semaphore->OpenCount == 0) {
        //
        // OpenCount is now zero, so we can really close the semaphore
        // and delete the entry in the semaphore table.
        //

        //
        // First make sure that no thread in this process is waiting on this
        // muxwait semaphore.  If there is one waiting on it, increment the
        // open count and return an error.
        //

        if (Od2SearchForWaitingThread( Semaphore )) {
            Semaphore->OpenCount++;
            ReleaseHandleTableLock( SemaphoreTable );
            rc = ERROR_SEM_BUSY;
            }
        else {
            //
            // Okay to really close this muxwait semaphore.  First destroy
            // the handle, which will unlock the handle table.
            //

            MuxWait = Semaphore->u.MuxWait;
            Or2DestroyHandle( SemaphoreTable, a->HandleIndex );

            if (!SharedSem) {
                //
                // If not a shared semaphore, free the muxwait structure
                // associated with this muxwait semaphore.
                //

                if (MuxWait != NULL) {
                    while (Od2DeleteMuxWait( MuxWait, 0, 0 ) == NO_ERROR) {
                        ;
                        }

                    RtlFreeHeap( Od2Heap, 0, MuxWait );
                    }
                }
            else {

                //
                // If this is a shared semaphore, call the subsystem so that it
                // can decrement its open count, as this process is no longer
                // using the shared semaphore handle.
                //

                rc = Od2CallSubsystem( &m,
                                       NULL,
                                       Os2CloseMuxWaitSem,
                                       sizeof( *a )
                                     );
                }
            }
        }
    else {
        //
        // OpenCount is still non-zero, so just release the semaphore table
        // lock.
        //

        ReleaseHandleTableLock( SemaphoreTable );
        }

    //
    // Return any error code to the caller.
    //

    return( rc );
}


APIRET
DosWaitMuxWaitSem(
    IN HMUX MuxWaitHandle,
    IN ULONG Timeout,
    OUT PULONG UserValue
    )
{
    NTSTATUS Status;
    OS2_API_MSG m;
    POS2_DOSWAITMUXWAITSEM_MSG a = &m.u.DosWaitMuxWaitSem;
    POD2_MUXWAIT_SEMAPHORE MuxWait;
    POD2_MUXWAIT_RECORD MuxWaitRecord;
    POR2_HANDLE_TABLE SemaphoreTable;
    POD2_SEMAPHORE Semaphore;
    OD2_SEMAPHORE_TYPE MuxWaitType;
    BOOLEAN SharedSem;
    APIRET rc;
    USHORT i;
    HANDLE NtHandles[ MAXIMUM_WAIT_OBJECTS ];
    PLARGE_INTEGER NtTimeout;

    try {
        *UserValue = 0;
        }
    except( EXCEPTION_EXECUTE_HANDLER ) {
       Od2ExitGP();
        }

    //
    // Capture the timeout value and convert it into an NT timeout value.
    //

    NtTimeout = Od2CaptureTimeout( Timeout, (PLARGE_INTEGER)&a->Timeout );


    //
    // Validate the passed OS/2 2.0 semaphore handle and extract the
    // shared/private flag and the index field.  Return an error if
    // not a valid handle.
    //
retry:
    rc = Od2ValidateSemaphoreHandle( MuxWaitHandle,
                                     &SharedSem,
                                     &a->HandleIndex
                                   );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Table must exist.  Return an error if it does not.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, FALSE );
    if (!SemaphoreTable) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Map the semaphore handle into a pointer to the semaphore structure
    // contained in the table.  Return an error if the handle is outside
    // the current limits of the table.  If the mapping is successful then
    // the semaphore table is left locked while we use the pointer.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       a->HandleIndex,
                                                       FALSE
                                                     );
    if (Semaphore == NULL) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Entry in semaphore table exists, so make sure it is a MuxWait semaphore.
    // Return an error if not, after unlock the table first.
    //

    if (Semaphore->Type != Od2MuxWaitSem) {
        ReleaseHandleTableLock( SemaphoreTable );
        return( ERROR_INVALID_HANDLE );
        }

    if (SharedSem) {
        Od2ThreadWaitingOnSemaphore( SemaphoreTable, Semaphore, TRUE );

        rc = Od2CallSubsystem( &m,
                               NULL,
                               Os2WaitMuxWaitSem,
                               sizeof( *a )
                             );

        Od2ThreadWaitingOnSemaphore( SemaphoreTable, Semaphore, FALSE );
        }
    else {
        MuxWait = Semaphore->u.MuxWait;
        if (MuxWait->CountMuxWaitRecords == 0) {
            ReleaseHandleTableLock( SemaphoreTable );
            return( ERROR_EMPTY_MUXWAIT );
            }

        MuxWaitRecord = &MuxWait->MuxWaitRecords[ 0 ];
        MuxWaitType = MuxWait->Type;
        for (i=0; i<MuxWait->CountMuxWaitRecords; i++) {
            if (MuxWaitType == Od2EventSem) {
                NtHandles[ i ] = MuxWaitRecord->Semaphore->u.EventHandle;
                }
            else
            if (MuxWaitType == Od2MutexSem) {
                NtHandles[ i ] = MuxWaitRecord->Semaphore->u.Mutex->MutantHandle;
                }
            else {
                ReleaseHandleTableLock( SemaphoreTable );
                return( ERROR_INVALID_HANDLE );
                }

            MuxWaitRecord++;
            }

        Od2ThreadWaitingOnSemaphore( SemaphoreTable, Semaphore, TRUE );

        Status = NtWaitForMultipleObjects(
                     (CHAR)i,
                     NtHandles,
                     MuxWait->WaitAll ? WaitAll : WaitAny,
                     TRUE,
                     NtTimeout
                     );
        if (NT_SUCCESS( Status )) {
            if (Status <= STATUS_WAIT_63) {
                *UserValue = MuxWait->MuxWaitRecords[ (ULONG)(Status & 0x3F)
                                                    ].UserKey;
                rc = NO_ERROR;
                }
            else
            if (Status == STATUS_ABANDONED) {
                rc = ERROR_SEM_OWNER_DIED;
                }
            else
            if (Status == STATUS_TIMEOUT) {
                rc = ERROR_TIMEOUT;
                }
            else
            if (Status == STATUS_USER_APC || Status == STATUS_ALERTED) {
                rc = ERROR_SS_RETRY;
                }
            else {
                rc = Or2MapStatus( Status );
                }
            }
        else {
            rc = Or2MapStatus( Status );
            }

        Od2ThreadWaitingOnSemaphore( SemaphoreTable, Semaphore, FALSE );

        if (rc == ERROR_SS_RETRY) {
            goto retry;
            }
        }

    return( rc );
}


APIRET
DosAddMuxWaitSem(
    IN HMUX MuxWaitHandle,
    IN PSEMRECORD MuxWaitEntry
    )
{
    OS2_API_MSG m, m1;
    POS2_DOSADDMUXWAITSEM_MSG a = &m.u.DosAddMuxWaitSem;
    POS2_ALERTMUXWAITER_MSG a1 = &m1.u.AlertMuxWaiter;
    POR2_HANDLE_TABLE SemaphoreTable;
    POD2_SEMAPHORE Semaphore;
    POD2_THREAD Thread;
    BOOLEAN SharedSem;
    APIRET rc;


    //
    // probe MuxWaitEntry buffer
    //

    try {
        Od2ProbeForRead(MuxWaitEntry,sizeof(SEMRECORD),1);
    } except( EXCEPTION_EXECUTE_HANDLER ) {
       Od2ExitGP();
        }

    //
    // Validate the passed OS/2 2.0 semaphore handle and extract the
    // shared/private flag and the index field.  Return an error if
    // not a valid handle.
    //

    rc = Od2ValidateSemaphoreHandle( MuxWaitHandle,
                                     &SharedSem,
                                     &a->HandleIndex
                                   );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Table must exist.  Return an error if it does not.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, FALSE );
    if (!SemaphoreTable) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Map the semaphore handle into a pointer to the semaphore structure
    // contained in the table.  Return an error if the handle is outside
    // the current limits of the table.  If the mapping is successful then
    // the semaphore table is left locked while we use the pointer.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       a->HandleIndex,
                                                       FALSE
                                                     );
    if (Semaphore == NULL) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Entry in semaphore table exists, so make sure it is a MuxWait semaphore.
    // Return an error if not, after unlock the table first.
    //

    if (Semaphore->Type != Od2MuxWaitSem) {
        ReleaseHandleTableLock( SemaphoreTable );
        return( ERROR_INVALID_HANDLE );
        }

    if (SharedSem) {
        a->MuxWaitEntry.ulUser = MuxWaitEntry->ulUser;
        rc = Od2ValidateSemaphoreHandle( MuxWaitEntry->hsemCur,
                                         &SharedSem,
                                         (PULONG)&a->MuxWaitEntry.hsemCur
                                       );
        if (rc == NO_ERROR && !SharedSem) {
            rc = ERROR_WRONG_TYPE;
            }

        if (rc == NO_ERROR) {
            rc = Od2CallSubsystem( &m,
                                   NULL,
                                   Os2AddMuxWaitSem,
                                   sizeof( *a )
                                 );
            }
        }
    else {
        rc = Od2AddMuxWait( Semaphore->u.MuxWait, MuxWaitEntry );
        if (rc == NO_ERROR &&
            (Thread = Od2SearchForWaitingThread( Semaphore ))
           ) {
            rc = Od2CallSubsystem( &m1,
                                   NULL,
                                   Oi2AlertMuxWaiter,
                                   sizeof( *a1 )
                                 );
            }
        }

    ReleaseHandleTableLock( SemaphoreTable );

    return( rc );
}


APIRET
DosDeleteMuxWaitSem(
    IN HMUX MuxWaitHandle,
    IN HSEM MuxWaitEntrySem
    )
{
    OS2_API_MSG m;
    POS2_DOSDELETEMUXWAITSEM_MSG a = &m.u.DosDeleteMuxWaitSem;
    POR2_HANDLE_TABLE SemaphoreTable;
    POD2_SEMAPHORE Semaphore;
    BOOLEAN SharedSem;
    APIRET rc;


    //
    // Validate the passed OS/2 2.0 semaphore handle and extract the
    // shared/private flag and the index field.  Return an error if
    // not a valid handle.
    //

    rc = Od2ValidateSemaphoreHandle( MuxWaitHandle,
                                     &SharedSem,
                                     &a->HandleIndex
                                   );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Table must exist.  Return an error if it does not.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, FALSE );
    if (!SemaphoreTable) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Map the semaphore handle into a pointer to the semaphore structure
    // contained in the table.  Return an error if the handle is outside
    // the current limits of the table.  If the mapping is successful then
    // the semaphore table is left locked while we use the pointer.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       a->HandleIndex,
                                                       FALSE
                                                     );
    if (Semaphore == NULL) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Entry in semaphore table exists, so make sure it is a MuxWait semaphore.
    // Return an error if not, after unlock the table first.
    //

    if (Semaphore->Type != Od2MuxWaitSem) {
        ReleaseHandleTableLock( SemaphoreTable );
        return( ERROR_INVALID_HANDLE );
        }

    if (SharedSem) {
        rc = Od2ValidateSemaphoreHandle( MuxWaitEntrySem,
                                         &SharedSem,
                                         &a->EntryHandleIndex
                                       );
        if (!SharedSem) {
            rc = ERROR_INVALID_HANDLE;
            }

        if (rc == NO_ERROR) {
            rc = Od2CallSubsystem( &m,
                                   NULL,
                                   Os2DeleteMuxWaitSem,
                                   sizeof( *a )
                                 );
            }
        }
    else {
        rc = Od2DeleteMuxWait( Semaphore->u.MuxWait, 0, MuxWaitEntrySem );
        }

    ReleaseHandleTableLock( SemaphoreTable );
    return( rc );
}


APIRET
DosQueryMuxWaitSem(
    IN HMUX MuxWaitHandle,
    IN OUT PULONG CountMuxWaitEntries,
    OUT SEMRECORD MuxWaitEntries[],
    OUT PULONG CreateAttributes
    )
{
    OS2_API_MSG m;
    POS2_DOSQUERYMUXWAITSEM_MSG a = &m.u.DosQueryMuxWaitSem;
    POS2_CAPTURE_HEADER CaptureBuffer;
    PSEMRECORD CapturedMuxWaitEntries;
    POD2_MUXWAIT_SEMAPHORE MuxWait;
    POD2_MUXWAIT_RECORD MuxWaitRecord;
    POR2_HANDLE_TABLE SemaphoreTable;
    POD2_SEMAPHORE Semaphore;
    BOOLEAN SharedSem;
    APIRET rc;
    USHORT i;

    //
    // probe CreateAttributes, CountMuxWaitEntries, and MuxWaitEntries buffer
    //

    try {
        Od2ProbeForWrite( CountMuxWaitEntries, sizeof( CountMuxWaitEntries ), 1 );
        Od2ProbeForWrite( CreateAttributes, sizeof( CreateAttributes ), 1 );
        Od2ProbeForWrite(MuxWaitEntries,*CountMuxWaitEntries * sizeof(SEMRECORD),1);
    } except( EXCEPTION_EXECUTE_HANDLER ) {
       Od2ExitGP();
        }

    //
    // Validate the passed OS/2 2.0 semaphore handle and extract the
    // shared/private flag and the index field.  Return an error if
    // not a valid handle.
    //

    rc = Od2ValidateSemaphoreHandle( MuxWaitHandle,
                                     &SharedSem,
                                     &a->HandleIndex
                                   );
    if (rc != NO_ERROR) {
        return( rc );
        }

    //
    // Get the pointer to either the shared or private semaphore table.
    // Table must exist.  Return an error if it does not.
    //

    SemaphoreTable = Od2GetSemaphoreTable( SharedSem, FALSE );
    if (!SemaphoreTable) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Map the semaphore handle into a pointer to the semaphore structure
    // contained in the table.  Return an error if the handle is outside
    // the current limits of the table.  If the mapping is successful then
    // the semaphore table is left locked while we use the pointer.
    //

    Semaphore = (POD2_SEMAPHORE)Or2MapHandle( SemaphoreTable,
                                                       a->HandleIndex,
                                                       FALSE
                                                     );
    if (Semaphore == NULL) {
        return( ERROR_INVALID_HANDLE );
        }

    //
    // Entry in semaphore table exists, so make sure it is a MuxWait semaphore.
    // Return an error if not, after unlock the table first.
    //

    if (Semaphore->Type != Od2MuxWaitSem) {
        ReleaseHandleTableLock( SemaphoreTable );
        return( ERROR_INVALID_HANDLE );
        }

    if (SharedSem) {
        a->CountMuxWaitEntries = *CountMuxWaitEntries;
        i = (USHORT)(((a->CountMuxWaitEntries * sizeof( SEMRECORD )) + 3) & ~3);

        CaptureBuffer = Od2AllocateCaptureBuffer( 1, 0, i );
        if (CaptureBuffer == NULL) {
            rc = ERROR_NOT_ENOUGH_MEMORY;
            }
        else {
            Od2AllocateMessagePointer( CaptureBuffer,
                                       i,
                                       &(PVOID)(a->MuxWaitEntries)
                                     );

            rc = Od2CallSubsystem( &m,
                                   CaptureBuffer,
                                   Os2QueryMuxWaitSem,
                                   sizeof( *a )
                                 );
            if (rc == NO_ERROR) {
                *CreateAttributes = a->CreateAttributes;
                *CountMuxWaitEntries = a->CountMuxWaitEntries;
                CapturedMuxWaitEntries = a->MuxWaitEntries;
                for (i=0; i<(USHORT)a->CountMuxWaitEntries; i++) {
                    MuxWaitEntries->hsemCur =
                        Od2ConstructSemaphoreHandle(
                            TRUE, (ULONG)CapturedMuxWaitEntries->hsemCur
                            );
                    MuxWaitEntries->ulUser = CapturedMuxWaitEntries->ulUser;
                    MuxWaitEntries++;
                    CapturedMuxWaitEntries++;
                    }
                }
            else
            if (rc == ERROR_PARAM_TOO_SMALL) {
                *CountMuxWaitEntries = a->CountMuxWaitEntries;
                }

            Od2FreeCaptureBuffer( CaptureBuffer );
            }
        }
    else {
        MuxWait = Semaphore->u.MuxWait;
        if (*CountMuxWaitEntries < (ULONG)MuxWait->CountMuxWaitRecords) {
            rc = ERROR_PARAM_TOO_SMALL;
            }
        else {
            *CreateAttributes =
                (Semaphore->Shared ? DC_SEM_SHARED : 0) |
                (MuxWait->WaitAll ? DCMW_WAIT_ALL : DCMW_WAIT_ANY);
            MuxWaitRecord = &MuxWait->MuxWaitRecords[ 0 ];
            for (i=0; i<MuxWait->CountMuxWaitRecords; i++) {
                MuxWaitEntries->hsemCur = MuxWaitRecord->SemHandle;
                MuxWaitEntries->ulUser = MuxWaitRecord->UserKey;
                MuxWaitEntries++;
                MuxWaitRecord++;
                }

            rc = NO_ERROR;
            }

        *CountMuxWaitEntries = (ULONG)MuxWait->CountMuxWaitRecords;
        }

    ReleaseHandleTableLock( SemaphoreTable );

    return( rc );
}