cpp/src/IceUtil/UUID.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <IceUtil/UUID.h>
  11
  12 // On Windows, we use Windows's RPC UUID generator.
  13 // On other platforms, we use a high quality random number generator
  14 // (/dev/random) to generate "version 4" UUIDs, as described in
  15 // http://www.ietf.org/internet-drafts/draft-mealling-uuid-urn-00.txt
  16
  17 #ifdef _WIN32
  18 #   include <rpc.h>
  19 #else
  20 #   include <IceUtil/Random.h>
  21 #   include <sys/types.h>
  22 #   include <unistd.h>
  23 #endif
  24
  25 using namespace std;
  26
  27 #ifndef _WIN32
  28
  29 namespace
  30 {
  31
  32 char myPid[2];
  33
  34 }
  35
  36 namespace IceUtilInternal
  37 {
  38
  39 //
  40 // Initialize the pid.
  41 //
  42 class PidInitializer
  43 {
  44 public:
  45
  46     PidInitializer()
  47     {
  48         pid_t p = getpid();
  49         myPid[0] = (p >> 8) & 0x7F;
  50         myPid[1] = p & 0xFF;
  51     }
  52 };
  53
  54 PidInitializer pidInitializer;
  55
  56 };
  57 #endif
  58
  59 namespace
  60 {
  61
  62 // Helper char to hex functions
  63 //
  64 inline void halfByteToHex(unsigned char hb, char*& hexBuffer)
  65 {
  66     if(hb < 10)
  67     {
  68         *hexBuffer++ = '0' + hb;
  69     }
  70     else
  71     {
  72         *hexBuffer++ = 'A' + (hb - 10);
  73     }
  74 }
  75
  76 inline void bytesToHex(unsigned char* bytes, size_t len, char*& hexBuffer)
  77 {
  78     for(size_t i = 0; i < len; i++)
  79     {
  80         halfByteToHex((bytes[i] & 0xF0) >> 4, hexBuffer);
  81         halfByteToHex((bytes[i] & 0x0F), hexBuffer);
  82     }
  83 }
  84
  85 }
  86
  87 string
  88 IceUtil::generateUUID()
  89 {
  90 #ifdef _WIN32
  91
  92     UUID uuid;
  93     UuidCreate(&uuid);
  94
  95     unsigned char* str;
  96
  97     UuidToString(&uuid, &str);
  98
  99     string result = reinterpret_cast<char*>(str);
 100
 101     RpcStringFree(&str);
 102     return result;
 103
 104 #else
 105     struct UUID
 106     {
 107         unsigned char timeLow[4];
 108         unsigned char timeMid[2];
 109         unsigned char timeHighAndVersion[2];
 110         unsigned char clockSeqHiAndReserved;
 111         unsigned char clockSeqLow;
 112         unsigned char node[6];
 113     };
 114     UUID uuid;
 115
 116     assert(sizeof(UUID) == 16);
 117
 118     //
 119     // Get a random sequence of bytes. Instead of using 122 random
 120     // bits that could be duplicated (because of a bug with some Linux
 121     // kernels and potentially other Unix platforms -- see comment in
 122     // Random.cpp), we replace the last 15 bits of all "random"
 123     // Randoms by the last 15 bits of the process id.
 124     //
 125     char* buffer = reinterpret_cast<char*>(&uuid);
 126     IceUtilInternal::generateRandom(buffer, static_cast<int>(sizeof(UUID)));
 127
 128     //
 129     // Adjust the bits that say "version 4" UUID
 130     //
 131     uuid.timeHighAndVersion[0] &= 0x0F;
 132     uuid.timeHighAndVersion[0] |= (4 << 4);
 133     uuid.clockSeqHiAndReserved &= 0x3F;
 134     uuid.clockSeqHiAndReserved |= 0x80;
 135
 136     //
 137     // Replace the end of the node by myPid (15 bits)
 138     //
 139     uuid.node[4] = (uuid.node[4] & 0x80) | myPid[0];
 140     uuid.node[5] = myPid[1];
 141
 142     //
 143     // Convert to a UUID string
 144     //
 145     char uuidString[16 * 2 + 4 + 1]; // 16 bytes, 4 '-' and a final '\0'
 146     char* uuidIndex = uuidString;
 147     bytesToHex(uuid.timeLow, sizeof(uuid.timeLow), uuidIndex);
 148     *uuidIndex++ = '-';
 149     bytesToHex(uuid.timeMid, sizeof(uuid.timeMid), uuidIndex);
 150     *uuidIndex++ = '-';
 151     bytesToHex(uuid.timeHighAndVersion, sizeof(uuid.timeHighAndVersion), uuidIndex);
 152     *uuidIndex++ = '-';
 153     bytesToHex(&uuid.clockSeqHiAndReserved, sizeof(uuid.clockSeqHiAndReserved), uuidIndex);
 154     bytesToHex(&uuid.clockSeqLow, sizeof(uuid.clockSeqLow), uuidIndex);
 155     *uuidIndex++ = '-';
 156     bytesToHex(uuid.node, sizeof(uuid.node), uuidIndex);
 157     *uuidIndex = '\0';
 158
 159     return uuidString;
 160
 161 #endif
 162 }