[babeltrace.git] / include / babeltrace / compat / uuid.h

#ifndef _BABELTRACE_COMPAT_UUID_H
#define _BABELTRACE_COMPAT_UUID_H

/*
 * babeltrace/compat/uuid.h
 *
 * Copyright (C) 2011   Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <config.h>

/* Includes final \0. */
#define BABELTRACE_UUID_STR_LEN		37
#define BABELTRACE_UUID_LEN		16

#ifdef BABELTRACE_HAVE_LIBUUID
#include <uuid/uuid.h>

static inline
int bt_uuid_generate(unsigned char *uuid_out)
{
	uuid_generate(uuid_out);
	return 0;
}

/* Sun's libuuid lacks const qualifiers */
#if defined(__sun__)
static inline
int bt_uuid_unparse(const unsigned char *uuid_in, char *str_out)
{
	uuid_unparse((unsigned char *) uuid_in, str_out);
	return 0;
}

static inline
int bt_uuid_parse(const char *str_in, unsigned char *uuid_out)
{
	return uuid_parse((char *) str_in, uuid_out);
}

static inline
int bt_uuid_compare(const unsigned char *uuid_a,
		const unsigned char *uuid_b)
{
	return uuid_compare((unsigned char *) uuid_a,
		(unsigned char *) uuid_b);
}
#else
static inline
int bt_uuid_unparse(const unsigned char *uuid_in, char *str_out)
{
	uuid_unparse(uuid_in, str_out);
	return 0;
}

static inline
int bt_uuid_parse(const char *str_in, unsigned char *uuid_out)
{
	return uuid_parse(str_in, uuid_out);
}

static inline
int bt_uuid_compare(const unsigned char *uuid_a,
		const unsigned char *uuid_b)
{
	return uuid_compare(uuid_a, uuid_b);
}
#endif

#elif defined(BT_HAVE_LIBC_UUID)
#include <uuid.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>

static inline
int bt_uuid_generate(unsigned char *uuid_out)
{
	uint32_t status;

	uuid_create((uuid_t *) uuid_out, &status);
	if (status == uuid_s_ok)
		return 0;
	else
		return -1;
}

static inline
int bt_uuid_unparse(const unsigned char *uuid_in, char *str_out)
{
	uint32_t status;
	char *alloc_str;
	int ret;

	uuid_to_string((uuid_t *) uuid_in, &alloc_str, &status);
	if (status == uuid_s_ok) {
		strcpy(str_out, alloc_str);
		ret = 0;
	} else {
		ret = -1;
	}
	free(alloc_str);
	return ret;
}

static inline
int bt_uuid_parse(const char *str_in, unsigned char *uuid_out)
{
	uint32_t status;

	uuid_from_string(str_in, (uuid_t *) uuid_out, &status);
	if (status == uuid_s_ok)
		return 0;
	else
		return -1;
}

static inline
int bt_uuid_compare(const unsigned char *uuid_a,
		const unsigned char *uuid_b)
{
	uint32_t status;

	uuid_compare((uuid_t *) uuid_a, (uuid_t *) uuid_b, &status);
	if (status == uuid_s_ok)
		return 0;
	else
		return -1;
}

#elif defined(__MINGW32__)

int bt_uuid_generate(unsigned char *uuid_out);
int bt_uuid_unparse(const unsigned char *uuid_in, char *str_out);
int bt_uuid_parse(const char *str_in, unsigned char *uuid_out);
int bt_uuid_compare(const unsigned char *uuid_a,
		const unsigned char *uuid_b);

#else
#error "Babeltrace needs to have a UUID generator configured."
#endif

#endif /* _BABELTRACE_COMPAT_UUID_H */
Commit	Line	Data
	1	#ifndef _BABELTRACE_COMPAT_UUID_H
	2	#define _BABELTRACE_COMPAT_UUID_H
	3
	4	/*
	5	* babeltrace/compat/uuid.h
	6	*
	7	* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a copy
	10	* of this software and associated documentation files (the "Software"), to deal
	11	* in the Software without restriction, including without limitation the rights
	12	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	* copies of the Software, and to permit persons to whom the Software is
	14	* furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included in
	17	* all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	25	* SOFTWARE.
	26	*/
	27
	28	#include <config.h>
	29
	30	/* Includes final \0. */
	31	#define BABELTRACE_UUID_STR_LEN 37
	32	#define BABELTRACE_UUID_LEN 16
	33
	34	#ifdef BABELTRACE_HAVE_LIBUUID
	35	#include <uuid/uuid.h>
	36
	37	static inline
	38	int bt_uuid_generate(unsigned char *uuid_out)
	39	{
	40	uuid_generate(uuid_out);
	41	return 0;
	42	}
	43
	44	/* Sun's libuuid lacks const qualifiers */
	45	#if defined(__sun__)
	46	static inline
	47	int bt_uuid_unparse(const unsigned char uuid_in, char str_out)
	48	{
	49	uuid_unparse((unsigned char *) uuid_in, str_out);
	50	return 0;
	51	}
	52
	53	static inline
	54	int bt_uuid_parse(const char str_in, unsigned char uuid_out)
	55	{
	56	return uuid_parse((char *) str_in, uuid_out);
	57	}
	58
	59	static inline
	60	int bt_uuid_compare(const unsigned char *uuid_a,
	61	const unsigned char *uuid_b)
	62	{
	63	return uuid_compare((unsigned char *) uuid_a,
	64	(unsigned char *) uuid_b);
	65	}
	66	#else
	67	static inline
	68	int bt_uuid_unparse(const unsigned char uuid_in, char str_out)
	69	{
	70	uuid_unparse(uuid_in, str_out);
	71	return 0;
	72	}
	73
	74	static inline
	75	int bt_uuid_parse(const char str_in, unsigned char uuid_out)
	76	{
	77	return uuid_parse(str_in, uuid_out);
	78	}
	79
	80	static inline
	81	int bt_uuid_compare(const unsigned char *uuid_a,
	82	const unsigned char *uuid_b)
	83	{
	84	return uuid_compare(uuid_a, uuid_b);
	85	}
	86	#endif
	87
	88	#elif defined(BT_HAVE_LIBC_UUID)
	89	#include <uuid.h>
	90	#include <stdint.h>
	91	#include <string.h>
	92	#include <stdlib.h>
	93
	94	static inline
	95	int bt_uuid_generate(unsigned char *uuid_out)
	96	{
	97	uint32_t status;
	98
	99	uuid_create((uuid_t *) uuid_out, &status);
	100	if (status == uuid_s_ok)
	101	return 0;
	102	else
	103	return -1;
	104	}
	105
	106	static inline
	107	int bt_uuid_unparse(const unsigned char uuid_in, char str_out)
	108	{
	109	uint32_t status;
	110	char *alloc_str;
	111	int ret;
	112
	113	uuid_to_string((uuid_t *) uuid_in, &alloc_str, &status);
	114	if (status == uuid_s_ok) {
	115	strcpy(str_out, alloc_str);
	116	ret = 0;
	117	} else {
	118	ret = -1;
	119	}
	120	free(alloc_str);
	121	return ret;
	122	}
	123
	124	static inline
	125	int bt_uuid_parse(const char str_in, unsigned char uuid_out)
	126	{
	127	uint32_t status;
	128
	129	uuid_from_string(str_in, (uuid_t *) uuid_out, &status);
	130	if (status == uuid_s_ok)
	131	return 0;
	132	else
	133	return -1;
	134	}
	135
	136	static inline
	137	int bt_uuid_compare(const unsigned char *uuid_a,
	138	const unsigned char *uuid_b)
	139	{
	140	uint32_t status;
	141
	142	uuid_compare((uuid_t ) uuid_a, (uuid_t ) uuid_b, &status);
	143	if (status == uuid_s_ok)
	144	return 0;
	145	else
	146	return -1;
	147	}
	148
	149	#elif defined(__MINGW32__)
	150
	151	int bt_uuid_generate(unsigned char *uuid_out);
	152	int bt_uuid_unparse(const unsigned char uuid_in, char str_out);
	153	int bt_uuid_parse(const char str_in, unsigned char uuid_out);
	154	int bt_uuid_compare(const unsigned char *uuid_a,
	155	const unsigned char *uuid_b);
	156
	157	#else
	158	#error "Babeltrace needs to have a UUID generator configured."
	159	#endif
	160
	161	#endif /* _BABELTRACE_COMPAT_UUID_H */