contrib/uuid-ossp/uuid-ossp.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * UUID generation functions using the OSSP UUID library
   4  *
   5  * Copyright (c) 2007-2008 PostgreSQL Global Development Group
   6  *
   7  * $PostgreSQL$
   8  *
   9  *-------------------------------------------------------------------------
  10  */
  11
  12 #include "postgres.h"
  13 #include "fmgr.h"
  14 #include "utils/builtins.h"
  15 #include "utils/uuid.h"
  16
  17 /*
  18  * There's some confusion over the location of the uuid.h header file.
  19  * On Debian, it's installed as ossp/uuid.h, while on Fedora, or if you
  20  * install ossp-uuid from a tarball, it's installed as uuid.h. Don't know
  21  * what other systems do.
  22  */
  23 #ifdef HAVE_OSSP_UUID_H
  24 #include <ossp/uuid.h>
  25 #else
  26 #ifdef HAVE_UUID_H
  27 #include <uuid.h>
  28 #else
  29 #error OSSP uuid.h not found
  30 #endif
  31 #endif
  32
  33 /* better both be 16 */
  34 #if (UUID_LEN != UUID_LEN_BIN)
  35 #error UUID length mismatch
  36 #endif
  37
  38
  39 PG_MODULE_MAGIC;
  40
  41
  42 Datum           uuid_nil(PG_FUNCTION_ARGS);
  43 Datum           uuid_ns_dns(PG_FUNCTION_ARGS);
  44 Datum           uuid_ns_url(PG_FUNCTION_ARGS);
  45 Datum           uuid_ns_oid(PG_FUNCTION_ARGS);
  46 Datum           uuid_ns_x500(PG_FUNCTION_ARGS);
  47
  48 Datum           uuid_generate_v1(PG_FUNCTION_ARGS);
  49 Datum           uuid_generate_v1mc(PG_FUNCTION_ARGS);
  50 Datum           uuid_generate_v3(PG_FUNCTION_ARGS);
  51 Datum           uuid_generate_v4(PG_FUNCTION_ARGS);
  52 Datum           uuid_generate_v5(PG_FUNCTION_ARGS);
  53
  54
  55 PG_FUNCTION_INFO_V1(uuid_nil);
  56 PG_FUNCTION_INFO_V1(uuid_ns_dns);
  57 PG_FUNCTION_INFO_V1(uuid_ns_url);
  58 PG_FUNCTION_INFO_V1(uuid_ns_oid);
  59 PG_FUNCTION_INFO_V1(uuid_ns_x500);
  60
  61 PG_FUNCTION_INFO_V1(uuid_generate_v1);
  62 PG_FUNCTION_INFO_V1(uuid_generate_v1mc);
  63 PG_FUNCTION_INFO_V1(uuid_generate_v3);
  64 PG_FUNCTION_INFO_V1(uuid_generate_v4);
  65 PG_FUNCTION_INFO_V1(uuid_generate_v5);
  66
  67 static void
  68 pguuid_complain(uuid_rc_t rc)
  69 {
  70         char    *err = uuid_error(rc);
  71
  72         if (err != NULL)
  73                 ereport(ERROR,
  74                                 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
  75                                  errmsg("OSSP uuid library failure: %s", err)));
  76         else
  77                 ereport(ERROR,
  78                                 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
  79                                  errmsg("OSSP uuid library failure: error code %d", rc)));
  80 }
  81
  82 static char *
  83 uuid_to_string(const uuid_t * uuid)
  84 {
  85         char       *buf = palloc(UUID_LEN_STR + 1);
  86         void       *ptr = buf;
  87         size_t          len = UUID_LEN_STR + 1;
  88         uuid_rc_t       rc;
  89
  90         rc = uuid_export(uuid, UUID_FMT_STR, &ptr, &len);
  91         if (rc != UUID_RC_OK)
  92                 pguuid_complain(rc);
  93
  94         return buf;
  95 }
  96
  97
  98 static void
  99 string_to_uuid(const char *str, uuid_t * uuid)
 100 {
 101         uuid_rc_t       rc;
 102
 103         rc = uuid_import(uuid, UUID_FMT_STR, str, UUID_LEN_STR + 1);
 104         if (rc != UUID_RC_OK)
 105                 pguuid_complain(rc);
 106 }
 107
 108
 109 static Datum
 110 special_uuid_value(const char *name)
 111 {
 112         uuid_t     *uuid;
 113         char       *str;
 114         uuid_rc_t       rc;
 115
 116         rc = uuid_create(&uuid);
 117         if (rc != UUID_RC_OK)
 118                 pguuid_complain(rc);
 119         rc = uuid_load(uuid, name);
 120         if (rc != UUID_RC_OK)
 121                 pguuid_complain(rc);
 122         str = uuid_to_string(uuid);
 123         rc = uuid_destroy(uuid);
 124         if (rc != UUID_RC_OK)
 125                 pguuid_complain(rc);
 126
 127         return DirectFunctionCall1(uuid_in, CStringGetDatum(str));
 128 }
 129
 130
 131 Datum
 132 uuid_nil(PG_FUNCTION_ARGS)
 133 {
 134         return special_uuid_value("nil");
 135 }
 136
 137
 138 Datum
 139 uuid_ns_dns(PG_FUNCTION_ARGS)
 140 {
 141         return special_uuid_value("ns:DNS");
 142 }
 143
 144
 145 Datum
 146 uuid_ns_url(PG_FUNCTION_ARGS)
 147 {
 148         return special_uuid_value("ns:URL");
 149 }
 150
 151
 152 Datum
 153 uuid_ns_oid(PG_FUNCTION_ARGS)
 154 {
 155         return special_uuid_value("ns:OID");
 156 }
 157
 158
 159 Datum
 160 uuid_ns_x500(PG_FUNCTION_ARGS)
 161 {
 162         return special_uuid_value("ns:X500");
 163 }
 164
 165
 166 static Datum
 167 uuid_generate_internal(int mode, const uuid_t * ns, const char *name)
 168 {
 169         uuid_t     *uuid;
 170         char       *str;
 171         uuid_rc_t       rc;
 172
 173         rc = uuid_create(&uuid);
 174         if (rc != UUID_RC_OK)
 175                 pguuid_complain(rc);
 176         rc = uuid_make(uuid, mode, ns, name);
 177         if (rc != UUID_RC_OK)
 178                 pguuid_complain(rc);
 179         str = uuid_to_string(uuid);
 180         rc = uuid_destroy(uuid);
 181         if (rc != UUID_RC_OK)
 182                 pguuid_complain(rc);
 183
 184         return DirectFunctionCall1(uuid_in, CStringGetDatum(str));
 185 }
 186
 187
 188 Datum
 189 uuid_generate_v1(PG_FUNCTION_ARGS)
 190 {
 191         return uuid_generate_internal(UUID_MAKE_V1, NULL, NULL);
 192 }
 193
 194
 195 Datum
 196 uuid_generate_v1mc(PG_FUNCTION_ARGS)
 197 {
 198         return uuid_generate_internal(UUID_MAKE_V1 | UUID_MAKE_MC, NULL, NULL);
 199 }
 200
 201
 202 static Datum
 203 uuid_generate_v35_internal(int mode, pg_uuid_t *ns, text *name)
 204 {
 205         uuid_t     *ns_uuid;
 206         Datum           result;
 207         uuid_rc_t       rc;
 208
 209         rc = uuid_create(&ns_uuid);
 210         if (rc != UUID_RC_OK)
 211                 pguuid_complain(rc);
 212         string_to_uuid(DatumGetCString(DirectFunctionCall1(uuid_out, UUIDPGetDatum(ns))),
 213                                    ns_uuid);
 214
 215         result = uuid_generate_internal(mode,
 216                                                                         ns_uuid,
 217                                                                         text_to_cstring(name));
 218
 219         rc = uuid_destroy(ns_uuid);
 220         if (rc != UUID_RC_OK)
 221                 pguuid_complain(rc);
 222
 223         return result;
 224 }
 225
 226
 227 Datum
 228 uuid_generate_v3(PG_FUNCTION_ARGS)
 229 {
 230         pg_uuid_t  *ns = PG_GETARG_UUID_P(0);
 231         text       *name = PG_GETARG_TEXT_P(1);
 232
 233         return uuid_generate_v35_internal(UUID_MAKE_V3, ns, name);
 234 }
 235
 236
 237 Datum
 238 uuid_generate_v4(PG_FUNCTION_ARGS)
 239 {
 240         return uuid_generate_internal(UUID_MAKE_V4, NULL, NULL);
 241 }
 242
 243
 244 Datum
 245 uuid_generate_v5(PG_FUNCTION_ARGS)
 246 {
 247         pg_uuid_t  *ns = PG_GETARG_UUID_P(0);
 248         text       *name = PG_GETARG_TEXT_P(1);
 249
 250         return uuid_generate_v35_internal(UUID_MAKE_V5, ns, name);
 251 }