/* 
 * Copyright 2003-2007, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include <pthread.h>
#include "pthread_private.h"

#include <stdlib.h>


int 
pthread_mutexattr_init(pthread_mutexattr_t *_mutexAttr)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL)
                return B_BAD_VALUE;

        attr = (pthread_mutexattr *)malloc(sizeof(pthread_mutexattr));
        if (attr == NULL)
                return B_NO_MEMORY;

        attr->type = PTHREAD_MUTEX_DEFAULT;
        attr->process_shared = false;

        *_mutexAttr = attr;
        return B_OK;
}


int 
pthread_mutexattr_destroy(pthread_mutexattr_t *_mutexAttr)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL)
                return B_BAD_VALUE;

        *_mutexAttr = NULL;
        free(attr);

        return B_OK;
}


int 
pthread_mutexattr_gettype(const pthread_mutexattr_t *_mutexAttr, int *_type)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL || _type == NULL)
                return B_BAD_VALUE;

        *_type = attr->type;
        return B_OK;
}


int 
pthread_mutexattr_settype(pthread_mutexattr_t *_mutexAttr, int type)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL
                || type < PTHREAD_MUTEX_DEFAULT
                || type > PTHREAD_MUTEX_RECURSIVE)
                return B_BAD_VALUE;

        attr->type = type;
        return B_OK;
}


int 
pthread_mutexattr_getpshared(const pthread_mutexattr_t *_mutexAttr,
        int *_processShared)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL
                || _processShared == NULL) {
                return B_BAD_VALUE;
        }

        *_processShared = attr->process_shared ? PTHREAD_PROCESS_SHARED
                : PTHREAD_PROCESS_PRIVATE;
        return B_OK;
}


int 
pthread_mutexattr_setpshared(pthread_mutexattr_t *_mutexAttr,
        int processShared)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL
                || processShared < PTHREAD_PROCESS_PRIVATE
                || processShared > PTHREAD_PROCESS_SHARED) {
                return B_BAD_VALUE;
        }

        attr->process_shared = processShared == PTHREAD_PROCESS_SHARED;
        return B_OK;
}


int 
pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *_mutexAttr,
        int *_priorityCeiling)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL
                || _priorityCeiling == NULL) {
                return B_BAD_VALUE;
        }

        *_priorityCeiling = 0;
                // not implemented

        return B_OK;
}


int 
pthread_mutexattr_setprioceiling(pthread_mutexattr_t *_mutexAttr,
        int priorityCeiling)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL)
                return B_BAD_VALUE;

        // not implemented
        return B_NOT_ALLOWED;
}


int 
pthread_mutexattr_getprotocol(const pthread_mutexattr_t *_mutexAttr,
        int *_protocol)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL
                || _protocol == NULL) {
                return B_BAD_VALUE;
        }

        *_protocol = 0;
                // not implemented

        return B_OK;
}


int 
pthread_mutexattr_setprotocol(pthread_mutexattr_t *_mutexAttr, int protocol)
{
        pthread_mutexattr *attr;

        if (_mutexAttr == NULL || (attr = *_mutexAttr) == NULL)
                return B_BAD_VALUE;

        // not implemented
        return B_NOT_ALLOWED;
}