diff options
Diffstat (limited to 'app-mobilephone/kannel/files/kannel-1.4.3-external-libuuid.patch')
-rw-r--r-- | app-mobilephone/kannel/files/kannel-1.4.3-external-libuuid.patch | 849 |
1 files changed, 849 insertions, 0 deletions
diff --git a/app-mobilephone/kannel/files/kannel-1.4.3-external-libuuid.patch b/app-mobilephone/kannel/files/kannel-1.4.3-external-libuuid.patch new file mode 100644 index 000000000000..a29f2c3a8333 --- /dev/null +++ b/app-mobilephone/kannel/files/kannel-1.4.3-external-libuuid.patch @@ -0,0 +1,849 @@ +diff -Nru gateway-1.4.3.orig/configure.in gateway-1.4.3/configure.in +--- gateway-1.4.3.orig/configure.in 2009-03-01 14:42:03.000000000 +0000 ++++ gateway-1.4.3/configure.in 2009-03-01 15:06:37.000000000 +0000 +@@ -173,6 +173,9 @@ + AC_ARG_WITH(libs, + [ --with-libs=FLAGS use FLAGS for extra libraries], + LIBS="$LIBS $withval") ++CFLAGS="$CFLAGS -I/usr/include/uuid" ++LIBS="$LIBS -luuid" ++ + + dnl Check whether compiler supports inline + AC_C_INLINE +@@ -1226,7 +1229,7 @@ + dnl Final Output + + AC_CONFIG_SECTION([Generating output files]) +-AC_OUTPUT(gwlib/gw_uuid_types.h Makefile) ++AC_OUTPUT(Makefile) + + + dnl LICENSE notice +diff -Nru gateway-1.4.3.orig/gwlib/gwlib.c gateway-1.4.3/gwlib/gwlib.c +--- gateway-1.4.3.orig/gwlib/gwlib.c 2009-01-12 16:46:54.000000000 +0000 ++++ gateway-1.4.3/gwlib/gwlib.c 2009-03-01 15:01:36.000000000 +0000 +@@ -79,7 +79,6 @@ + { + gw_assert(!init); + gw_init_mem(); +- uuid_init(); + octstr_init(); + gwlib_protected_init(); + gwthread_init(); +@@ -100,7 +99,6 @@ + gwthread_shutdown(); + octstr_shutdown(); + gwlib_protected_shutdown(); +- uuid_shutdown(); + cfg_shutdown(); + gw_check_leaks(); + log_shutdown(); +diff -Nru gateway-1.4.3.orig/gwlib/gwlib.h gateway-1.4.3/gwlib/gwlib.h +--- gateway-1.4.3.orig/gwlib/gwlib.h 2009-01-12 16:46:55.000000000 +0000 ++++ gateway-1.4.3/gwlib/gwlib.h 2009-03-01 15:01:56.000000000 +0000 +@@ -100,10 +100,12 @@ + #include "semaphore.h" + #include "xmlrpc.h" + #include "md5.h" +-#include "gw_uuid.h" ++#include <uuid.h> + #include "gw-rwlock.h" + #include "gw-prioqueue.h" + ++#define UUID_STR_LEN 36 ++ + void gwlib_assert_init(void); + void gwlib_init(void); + void gwlib_shutdown(void); +diff -Nru gateway-1.4.3.orig/gwlib/gw_uuid.c gateway-1.4.3/gwlib/gw_uuid.c +--- gateway-1.4.3.orig/gwlib/gw_uuid.c 2004-01-05 16:37:10.000000000 +0000 ++++ gateway-1.4.3/gwlib/gw_uuid.c 1970-01-01 00:00:00.000000000 +0000 +@@ -1,632 +0,0 @@ +-/* +- * clear.c -- Clear a UUID +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +- +-/* +- * Force inclusion of SVID stuff since we need it if we're compiling in +- * gcc-wall wall mode +- */ +-#ifndef _SVID_SOURCE +-#define _SVID_SOURCE +-#endif +- +-#include "gw-config.h" +- +-#ifdef HAVE_UNISTD_H +-#include <unistd.h> +-#endif +-#ifdef HAVE_STDLIB_H +-#include <stdlib.h> +-#endif +-#include <string.h> +-#include <ctype.h> +-#include <fcntl.h> +-#include <errno.h> +-#include <sys/types.h> +-#include <sys/time.h> +-#include <sys/stat.h> +-#include <sys/file.h> +-#ifdef HAVE_SYS_IOCTL_H +-#include <sys/ioctl.h> +-#endif +-#ifdef HAVE_SYS_SOCKET_H +-#include <sys/socket.h> +-#endif +-#ifdef HAVE_SYS_SOCKIO_H +-#include <sys/sockio.h> +-#endif +-#ifdef HAVE_NET_IF_H +-#include <net/if.h> +-#endif +-#ifdef HAVE_NETINET_IN_H +-#include <netinet/in.h> +-#endif +-#include <stdio.h> +- +-#include "gwlib/gw_uuid_types.h" +-#include "gwlib/gw_uuid.h" +- +-/* +- * Offset between 15-Oct-1582 and 1-Jan-70 +- */ +-#define TIME_OFFSET_HIGH 0x01B21DD2 +-#define TIME_OFFSET_LOW 0x13814000 +- +-struct uuid { +- __u32 time_low; +- __u16 time_mid; +- __u16 time_hi_and_version; +- __u16 clock_seq; +- __u8 node[6]; +-}; +- +- +-/* +- * prototypes +- */ +-static void uuid_pack(const struct uuid *uu, uuid_t ptr); +-static void uuid_unpack(const uuid_t in, struct uuid *uu); +-static int get_random_fd(void); +- +- +-#ifdef HAVE_SRANDOM +-#define srand(x) srandom(x) +-#define rand() random() +-#endif +- +- +- +-void uuid_init(void) +-{ +- /* +- * open random device if any. +- * We should do it here because otherwise it's +- * possible that we open device twice. +- */ +- get_random_fd(); +-} +- +- +-void uuid_shutdown(void) +-{ +- int fd = get_random_fd(); +- +- if (fd > 0) +- close(fd); +-} +- +-void uuid_clear(uuid_t uu) +-{ +- memset(uu, 0, 16); +-} +- +-/* +- * compare.c --- compare whether or not two UUID's are the same +- * +- * Returns an integer less than, equal to, or greater than zero if +- * uu1 respectively, to be less than, to match, or be greater than +- * uu2. +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-#define UUCMP(u1,u2) if (u1 != u2) return((u1 < u2) ? -1 : 1); +- +-int uuid_compare(const uuid_t uu1, const uuid_t uu2) +-{ +- struct uuid uuid1, uuid2; +- +- uuid_unpack(uu1, &uuid1); +- uuid_unpack(uu2, &uuid2); +- +- UUCMP(uuid1.time_low, uuid2.time_low); +- UUCMP(uuid1.time_mid, uuid2.time_mid); +- UUCMP(uuid1.time_hi_and_version, uuid2.time_hi_and_version); +- UUCMP(uuid1.clock_seq, uuid2.clock_seq); +- return memcmp(uuid1.node, uuid2.node, 6); +-} +- +-/* +- * copy.c --- copy UUIDs +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-void uuid_copy(uuid_t dst, const uuid_t src) +-{ +- unsigned char *cp1; +- const unsigned char *cp2; +- int i; +- +- for (i=0, cp1 = dst, cp2 = src; i < 16; i++) +- *cp1++ = *cp2++; +-} +- +- +-/* +- * gen_uuid.c --- generate a DCE-compatible uuid +- * +- * Copyright (C) 1996, 1997, 1998, 1999 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-static int get_random_fd(void) +-{ +- struct timeval tv; +- static int fd = -2; +- int i; +- +- if (fd == -2) { +- gettimeofday(&tv, 0); +- fd = open("/dev/urandom", O_RDONLY); +- if (fd == -1) +- fd = open("/dev/random", O_RDONLY | O_NONBLOCK); +- srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec); +- } +- /* Crank the random number generator a few times */ +- gettimeofday(&tv, 0); +- for (i = (tv.tv_sec ^ tv.tv_usec) & 0x1F; i > 0; i--) +- rand(); +- +- return fd; +-} +- +- +-/* +- * Generate a series of random bytes. Use /dev/urandom if possible, +- * and if not, use srandom/random. +- */ +-static void get_random_bytes(void *buf, int nbytes) +-{ +- int i, n = nbytes, fd = get_random_fd(); +- int lose_counter = 0; +- unsigned char *cp = (unsigned char *) buf; +- +- if (fd >= 0) { +- while (n > 0) { +- i = read(fd, cp, n); +- if (i <= 0) { +- if (lose_counter++ > 16) +- break; +- continue; +- } +- n -= i; +- cp += i; +- lose_counter = 0; +- } +- } +- +- /* +- * We do this all the time, but this is the only source of +- * randomness if /dev/random/urandom is out to lunch. +- */ +- for (cp = buf, i = 0; i < nbytes; i++) +- *cp++ ^= (rand() >> 7) & 0xFF; +- return; +-} +- +-/* +- * Get the ethernet hardware address, if we can find it... +- */ +-static int get_node_id(unsigned char *node_id) +-{ +-#ifdef HAVE_NET_IF_H +- int sd; +- struct ifreq ifr, *ifrp; +- struct ifconf ifc; +- char buf[1024]; +- int n, i; +- unsigned char *a; +- +-/* +- * BSD 4.4 defines the size of an ifreq to be +- * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len +- * However, under earlier systems, sa_len isn't present, so the size is +- * just sizeof(struct ifreq) +- */ +-#ifdef HAVE_SA_LEN +-#ifndef max +-#define max(a,b) ((a) > (b) ? (a) : (b)) +-#endif +-#define ifreq_size(i) max(sizeof(struct ifreq),\ +- sizeof((i).ifr_name)+(i).ifr_addr.sa_len) +-#else +-#define ifreq_size(i) sizeof(struct ifreq) +-#endif /* HAVE_SA_LEN*/ +- +- sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); +- if (sd < 0) { +- return -1; +- } +- memset(buf, 0, sizeof(buf)); +- ifc.ifc_len = sizeof(buf); +- ifc.ifc_buf = buf; +- if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) { +- close(sd); +- return -1; +- } +- n = ifc.ifc_len; +- for (i = 0; i < n; i+= ifreq_size(*ifr) ) { +- ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i); +- strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ); +-#ifdef SIOCGIFHWADDR +- if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0) +- continue; +- a = (unsigned char *) &ifr.ifr_hwaddr.sa_data; +-#else +-#ifdef SIOCGENADDR +- if (ioctl(sd, SIOCGENADDR, &ifr) < 0) +- continue; +- a = (unsigned char *) ifr.ifr_enaddr; +-#else +- /* +- * XXX we don't have a way of getting the hardware +- * address +- */ +- close(sd); +- return 0; +-#endif /* SIOCGENADDR */ +-#endif /* SIOCGIFHWADDR */ +- if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5]) +- continue; +- if (node_id) { +- memcpy(node_id, a, 6); +- close(sd); +- return 1; +- } +- } +- close(sd); +-#endif +- return 0; +-} +- +-/* Assume that the gettimeofday() has microsecond granularity */ +-#define MAX_ADJUSTMENT 10 +- +-static int get_clock(__u32 *clock_high, __u32 *clock_low, __u16 *ret_clock_seq) +-{ +- static int adjustment = 0; +- static struct timeval last = {0, 0}; +- static __u16 clock_seq; +- struct timeval tv; +- unsigned long long clock_reg; +- +-try_again: +- gettimeofday(&tv, 0); +- if ((last.tv_sec == 0) && (last.tv_usec == 0)) { +- get_random_bytes(&clock_seq, sizeof(clock_seq)); +- clock_seq &= 0x1FFF; +- last = tv; +- last.tv_sec--; +- } +- if ((tv.tv_sec < last.tv_sec) || +- ((tv.tv_sec == last.tv_sec) && +- (tv.tv_usec < last.tv_usec))) { +- clock_seq = (clock_seq+1) & 0x1FFF; +- adjustment = 0; +- last = tv; +- } else if ((tv.tv_sec == last.tv_sec) && +- (tv.tv_usec == last.tv_usec)) { +- if (adjustment >= MAX_ADJUSTMENT) +- goto try_again; +- adjustment++; +- } else { +- adjustment = 0; +- last = tv; +- } +- +- clock_reg = tv.tv_usec*10 + adjustment; +- clock_reg += ((unsigned long long) tv.tv_sec)*10000000; +- clock_reg += (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000; +- +- *clock_high = clock_reg >> 32; +- *clock_low = clock_reg; +- *ret_clock_seq = clock_seq; +- return 0; +-} +- +-void uuid_generate_time(uuid_t out) +-{ +- static unsigned char node_id[6]; +- static int has_init = 0; +- struct uuid uu; +- __u32 clock_mid; +- +- if (!has_init) { +- if (get_node_id(node_id) <= 0) { +- get_random_bytes(node_id, 6); +- /* +- * Set multicast bit, to prevent conflicts +- * with IEEE 802 addresses obtained from +- * network cards +- */ +- node_id[0] |= 0x80; +- } +- has_init = 1; +- } +- get_clock(&clock_mid, &uu.time_low, &uu.clock_seq); +- uu.clock_seq |= 0x8000; +- uu.time_mid = (__u16) clock_mid; +- uu.time_hi_and_version = (clock_mid >> 16) | 0x1000; +- memcpy(uu.node, node_id, 6); +- uuid_pack(&uu, out); +-} +- +-void uuid_generate_random(uuid_t out) +-{ +- uuid_t buf; +- struct uuid uu; +- +- get_random_bytes(buf, sizeof(buf)); +- uuid_unpack(buf, &uu); +- +- uu.clock_seq = (uu.clock_seq & 0x3FFF) | 0x8000; +- uu.time_hi_and_version = (uu.time_hi_and_version & 0x0FFF) | 0x4000; +- uuid_pack(&uu, out); +-} +- +-/* +- * This is the generic front-end to uuid_generate_random and +- * uuid_generate_time. It uses uuid_generate_random only if +- * /dev/urandom is available, since otherwise we won't have +- * high-quality randomness. +- */ +-void uuid_generate(uuid_t out) +-{ +- if (get_random_fd() >= 0) { +- uuid_generate_random(out); +- } +- else +- uuid_generate_time(out); +-} +- +-/* +- * isnull.c --- Check whether or not the UUID is null +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-/* Returns 1 if the uuid is the NULL uuid */ +-int uuid_is_null(const uuid_t uu) +-{ +- const unsigned char *cp; +- int i; +- +- for (i=0, cp = uu; i < 16; i++) +- if (*cp++) +- return 0; +- return 1; +-} +- +-/* +- * Internal routine for packing UUID's +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-void uuid_pack(const struct uuid *uu, uuid_t ptr) +-{ +- __u32 tmp; +- unsigned char *out = ptr; +- +- tmp = uu->time_low; +- out[3] = (unsigned char) tmp; +- tmp >>= 8; +- out[2] = (unsigned char) tmp; +- tmp >>= 8; +- out[1] = (unsigned char) tmp; +- tmp >>= 8; +- out[0] = (unsigned char) tmp; +- +- tmp = uu->time_mid; +- out[5] = (unsigned char) tmp; +- tmp >>= 8; +- out[4] = (unsigned char) tmp; +- +- tmp = uu->time_hi_and_version; +- out[7] = (unsigned char) tmp; +- tmp >>= 8; +- out[6] = (unsigned char) tmp; +- +- tmp = uu->clock_seq; +- out[9] = (unsigned char) tmp; +- tmp >>= 8; +- out[8] = (unsigned char) tmp; +- +- memcpy(out+10, uu->node, 6); +-} +- +-/* +- * parse.c --- UUID parsing +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-int uuid_parse(const char *in, uuid_t uu) +-{ +- struct uuid uuid; +- int i; +- const char *cp; +- char buf[3]; +- +- if (strlen(in) != 36) +- return -1; +- for (i=0, cp = in; i <= 36; i++,cp++) { +- if ((i == 8) || (i == 13) || (i == 18) || +- (i == 23)) { +- if (*cp == '-') +- continue; +- else +- return -1; +- } +- if (i== 36) +- if (*cp == 0) +- continue; +- if (!isxdigit(*cp)) +- return -1; +- } +- uuid.time_low = strtoul(in, NULL, 16); +- uuid.time_mid = strtoul(in+9, NULL, 16); +- uuid.time_hi_and_version = strtoul(in+14, NULL, 16); +- uuid.clock_seq = strtoul(in+19, NULL, 16); +- cp = in+24; +- buf[2] = 0; +- for (i=0; i < 6; i++) { +- buf[0] = *cp++; +- buf[1] = *cp++; +- uuid.node[i] = strtoul(buf, NULL, 16); +- } +- +- uuid_pack(&uuid, uu); +- return 0; +-} +- +- +-/* +- * Internal routine for unpacking UUID +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-void uuid_unpack(const uuid_t in, struct uuid *uu) +-{ +- const __u8 *ptr = in; +- __u32 tmp; +- +- tmp = *ptr++; +- tmp = (tmp << 8) | *ptr++; +- tmp = (tmp << 8) | *ptr++; +- tmp = (tmp << 8) | *ptr++; +- uu->time_low = tmp; +- +- tmp = *ptr++; +- tmp = (tmp << 8) | *ptr++; +- uu->time_mid = tmp; +- +- tmp = *ptr++; +- tmp = (tmp << 8) | *ptr++; +- uu->time_hi_and_version = tmp; +- +- tmp = *ptr++; +- tmp = (tmp << 8) | *ptr++; +- uu->clock_seq = tmp; +- +- memcpy(uu->node, ptr, 6); +-} +- +-/* +- * unparse.c -- convert a UUID to string +- * +- * Copyright (C) 1996, 1997 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-void uuid_unparse(const uuid_t uu, char *out) +-{ +- struct uuid uuid; +- +- uuid_unpack(uu, &uuid); +- sprintf(out, +- "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", +- uuid.time_low, uuid.time_mid, uuid.time_hi_and_version, +- uuid.clock_seq >> 8, uuid.clock_seq & 0xFF, +- uuid.node[0], uuid.node[1], uuid.node[2], +- uuid.node[3], uuid.node[4], uuid.node[5]); +-} +- +-/* +- * uuid_time.c --- Interpret the time field from a uuid. This program +- * violates the UUID abstraction barrier by reaching into the guts +- * of a UUID and interpreting it. +- * +- * Copyright (C) 1998, 1999 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +-time_t uuid_time(const uuid_t uu, struct timeval *ret_tv) +-{ +- struct uuid uuid; +- __u32 high; +- struct timeval tv; +- unsigned long long clock_reg; +- +- uuid_unpack(uu, &uuid); +- +- high = uuid.time_mid | ((uuid.time_hi_and_version & 0xFFF) << 16); +- clock_reg = uuid.time_low | ((unsigned long long) high << 32); +- +- clock_reg -= (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000; +- tv.tv_sec = clock_reg / 10000000; +- tv.tv_usec = (clock_reg % 10000000) / 10; +- +- if (ret_tv) +- *ret_tv = tv; +- +- return tv.tv_sec; +-} +- +-int uuid_type(const uuid_t uu) +-{ +- struct uuid uuid; +- +- uuid_unpack(uu, &uuid); +- return ((uuid.time_hi_and_version >> 12) & 0xF); +-} +- +-int uuid_variant(const uuid_t uu) +-{ +- struct uuid uuid; +- int var; +- +- uuid_unpack(uu, &uuid); +- var = uuid.clock_seq; +- +- if ((var & 0x8000) == 0) +- return UUID_VARIANT_NCS; +- if ((var & 0x4000) == 0) +- return UUID_VARIANT_DCE; +- if ((var & 0x2000) == 0) +- return UUID_VARIANT_MICROSOFT; +- return UUID_VARIANT_OTHER; +-} +- +diff -Nru gateway-1.4.3.orig/gwlib/gw_uuid.h gateway-1.4.3/gwlib/gw_uuid.h +--- gateway-1.4.3.orig/gwlib/gw_uuid.h 2005-06-14 09:31:34.000000000 +0000 ++++ gateway-1.4.3/gwlib/gw_uuid.h 1970-01-01 00:00:00.000000000 +0000 +@@ -1,84 +0,0 @@ +-/* +- * Public include file for the UUID library +- * +- * Copyright (C) 1996, 1997, 1998 Theodore Ts'o. +- * +- * %Begin-Header% +- * This file may be redistributed under the terms of the GNU +- * Library General Public License. +- * %End-Header% +- */ +- +-#ifndef _UUID_UUID_H +-#define _UUID_UUID_H +- +-#include <sys/types.h> +-#include <sys/time.h> +-#include <time.h> +- +-#define UUID_STR_LEN 36 +- +-#ifdef DARWIN +- +-#ifndef _POSIX_C_SOURCE +-#ifndef _UUID_T +-#define _UUID_T +-typedef __darwin_uuid_t uuid_t; +-#endif /* _UUID_T */ +-#endif /* _POSIX_C_SOURCE */ +- +-#else +- +-typedef unsigned char uuid_t[16]; +- +-#endif +- +-/* UUID Variant definitions */ +-#define UUID_VARIANT_NCS 0 +-#define UUID_VARIANT_DCE 1 +-#define UUID_VARIANT_MICROSOFT 2 +-#define UUID_VARIANT_OTHER 3 +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/* initialize uuid library */ +-void uuid_init(void); +- +-/* shutdown uuid library */ +-void uuid_shutdown(void); +- +-/* clear.c */ +-void uuid_clear(uuid_t uu); +- +-/* compare.c */ +-int uuid_compare(const uuid_t uu1, const uuid_t uu2); +- +-/* copy.c */ +-void uuid_copy(uuid_t dst, const uuid_t src); +- +-/* gen_uuid.c */ +-void uuid_generate(uuid_t out); +-void uuid_generate_random(uuid_t out); +-void uuid_generate_time(uuid_t out); +- +-/* isnull.c */ +-int uuid_is_null(const uuid_t uu); +- +-/* parse.c */ +-int uuid_parse(const char *in, uuid_t uu); +- +-/* unparse.c */ +-void uuid_unparse(const uuid_t uu, char *out); +- +-/* uuid_time.c */ +-time_t uuid_time(const uuid_t uu, struct timeval *ret_tv); +-int uuid_type(const uuid_t uu); +-int uuid_variant(const uuid_t uu); +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* _UUID_UUID_H */ +diff -Nru gateway-1.4.3.orig/gwlib/gw_uuid_types.h.in gateway-1.4.3/gwlib/gw_uuid_types.h.in +--- gateway-1.4.3.orig/gwlib/gw_uuid_types.h.in 2003-12-08 11:25:44.000000000 +0000 ++++ gateway-1.4.3/gwlib/gw_uuid_types.h.in 1970-01-01 00:00:00.000000000 +0000 +@@ -1,51 +0,0 @@ +-/* +- * If linux/types.h is already been included, assume it has defined +- * everything we need. (cross fingers) Other header files may have +- * also defined the types that we need. +- */ +-#if (!defined(_LINUX_TYPES_H) && !defined(_BLKID_TYPES_H) && \ +- !defined(_UUID_TYPES) && !defined(_EXT2_TYPES_H)) +-#define _UUID_TYPES_H +- +-typedef unsigned char __u8; +-typedef signed char __s8; +- +-#if (@SIZEOF_INT@ == 8) +-typedef int __s64; +-typedef unsigned int __u64; +-#elif (@SIZEOF_LONG@ == 8) +-typedef long __s64; +-typedef unsigned long __u64; +-#elif (@SIZEOF_LONG_LONG@ == 8) +-#if defined(__GNUC__) +-typedef __signed__ long long __s64; +-#else +-typedef signed long long __s64; +-#endif +-typedef unsigned long long __u64; +-#endif +- +-#if (@SIZEOF_INT@ == 2) +-typedef int __s16; +-typedef unsigned int __u16; +-#elif (@SIZEOF_SHORT@ == 2) +-typedef short __s16; +-typedef unsigned short __u16; +-#else +- ?==error: undefined 16 bit type +-#endif +- +-#if (@SIZEOF_INT@ == 4) +-typedef int __s32; +-typedef unsigned int __u32; +-#elif (@SIZEOF_LONG@ == 4) +-typedef long __s32; +-typedef unsigned long __u32; +-#elif (@SIZEOF_SHORT@ == 4) +-typedef short __s32; +-typedef unsigned short __u32; +-#else +- ?== error: undefined 32 bit type +-#endif +- +-#endif /* _*_TYPES_H */ +diff -Nru gateway-1.4.3.orig/Makefile.in gateway-1.4.3/Makefile.in +--- gateway-1.4.3.orig/Makefile.in 2009-03-01 14:42:03.000000000 +0000 ++++ gateway-1.4.3/Makefile.in 2009-03-01 15:03:45.000000000 +0000 +@@ -322,7 +322,7 @@ + rm -f $(benchoutputs) + + distclean: clean +- rm -f Makefile gw-config.h config.cache config.log config.status config.nice .depend gwlib/gw_uuid_types.h ++ rm -f Makefile gw-config.h config.cache config.log config.status config.nice .depend + + nag: + utils/find-long-lines |