#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#include "porting.h"


/* ---------- mutexes ----------- */
pthread_mutex_t  mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t  mutex2;
pthread_mutex_t  mutex3;
pthread_mutex_t  mutex4;
pthread_mutex_t  mutex5;


NTSTATUS
NtCreateMutant( IN pthread_mutex_t  *mutex,
                IN ACCESS_MASK  DesiredAccess,
                IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
                IN BOOLEAN  InitialOwner )
{
    pthread_mutexattr_t  attr;
    int                  rc;

    /* NT mutexes are recursive */
    pthread_mutexattr_init( &attr );
    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );

    rc = pthread_mutex_init( mutex, &attr );
    if ( rc != 0 ) {
       fprintf(stderr, "NTCREATEMUTANT pthread_mutex_init failed\n");
    }

    pthread_mutexattr_destroy(&attr);

    return (rc);
}

NTSTATUS
NtReleaseMutant( IN  pthread_mutex_t mutex,
                 OUT PLONG PreviousCount OPTIONAL )
{
    int rc;

    rc = pthread_mutex_unlock( &mutex );
    if ( rc != 0 ) {
       fprintf(stderr, "NTRELEASEMUTANT pthread_mutex_unlock failed\n");
    }

    return (rc);
}


PVOID
CreateMutex( IN PVOID   mutex,
             IN BOOL    InitialOwner,
             IN LPCTSTR Name  OPTIONAL )
{
    pthread_mutexattr_t  attr;
    int                  rc;

    /* NT mutexes are recursive */
    pthread_mutexattr_init( &attr );
    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );

    rc = pthread_mutex_init( (pthread_mutex_t *)mutex, &attr );
    if ( rc != 0 ) {
       fprintf(stderr, "CREATEMUTEX pthread_mutex_init failed\n");
       pthread_mutexattr_destroy(&attr);
       return (NULL);
    }

    pthread_mutexattr_destroy(&attr);

    return ( mutex );
}

int
ReleaseMutex( IN  pthread_mutex_t mutex )
{
    int rc;

    rc = pthread_mutex_unlock( &mutex );
    if (rc != 0 ) {
       fprintf(stderr, "RELEASEMUTEX pthread_mutex_unlock failed\n");
    }

    return (rc);
}


int
main( int argc,
      char *argv[] )
{
    pthread_mutexattr_t  attr;
    pthread_mutex_t *mp;
    NTSTATUS Status;
    int rc = 0;

    pthread_mutexattr_init( &attr );
    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );

    printf("Creating all mutexes ......\n");

    printf("mutex1 created by PTHREAD_MUTEX_INITIALIZER\n");

    printf("mutex2 created by pthread_mutex_init without attributes object\n");
    rc = pthread_mutex_init( &mutex2, NULL );
    if (rc != 0 ) {
        fprintf(stderr, "pthread_mutex_init NULL\n");   
    }

    printf("mutex3 created by pthread_mutex_init using attributes object\n");
    rc = pthread_mutex_init( &mutex3, &attr );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_init ATTR\n");
       exit(2);
    }
    pthread_mutexattr_destroy(&attr);

    printf("mutex4 created using NtCreateMutant\n");
    Status = NtCreateMutant( &mutex4, 0, NULL, 0 );
    if (Status != 0 ) {
       fprintf(stderr, "NtCreateMutant failed\n");
       exit(3);
    }

    printf("mutex5 created using CreateMutex\n");
    mp = CreateMutex( (void *) &mutex5, 0, NULL );
    if ( mp == (pthread_mutex_t *) NULL ) {
       fprintf(stderr, "CreateMutex failed\n");
       exit(4);
    }

    printf("Locking all mutexes using pthread_mutex_lock\n");

    rc = pthread_mutex_lock( &mutex1 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_lock failed\n");
       exit(5);
    }

    rc = pthread_mutex_lock( &mutex2 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_lock failed\n");
       exit(6);
    }

    rc = pthread_mutex_lock( &mutex3 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_lock failed\n");
       exit(7);
    }
    rc = pthread_mutex_lock( &mutex4 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_lock failed\n");
       exit(8);
    }

    rc = pthread_mutex_lock( &mutex5 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_lock failed\n");
       exit(9);
    }

    printf("Unlocking all mutexes ..... \n");

    rc = pthread_mutex_unlock( &mutex1 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_unlock failed\n");
       exit(10);
    }
    fprintf(stderr, "mutex1 unlocked using pthread_mutex_unlock\n");

    rc = pthread_mutex_unlock( &mutex2 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_unlock failed\n");
       exit(11);
    }
    fprintf(stderr, "mutex2 unlocked using pthread_mutex_unlock\n");

    rc = pthread_mutex_unlock( &mutex3 );
    if (rc != 0 ) {
       fprintf(stderr, "pthread_mutex_unlock failed\n");
       exit(12);
    }
    fprintf(stderr, "mutex3 unlocked using pthread_mutex_unlock\n");

    Status = NtReleaseMutant( mutex4, NULL );
    if (Status != 0 ) {
       fprintf(stderr, "NTReleaseMutant failed\n");
       exit(13);
    }
    fprintf(stderr, "mutex4 unlocked using NtReleaseMutant\n");
    rc = ReleaseMutex( mutex5 );
    if (rc != 0 ) {
       fprintf(stderr, "ReleaseMutex failed\n");
       exit(14);
    }
    fprintf(stderr, "mutex5 unlocked using ReleaseMutex\n");

    printf("Destroying all mutexes ......\n");
    pthread_mutex_destroy( &mutex1 );
    pthread_mutex_destroy( &mutex2 );
    pthread_mutex_destroy( &mutex3 );
    pthread_mutex_destroy( &mutex4 );
    pthread_mutex_destroy( &mutex5 );

    return 0;
}