1 //
2 // C++ Implementation: GUIDData
3 //
4 // Description: GUIDData class header
5 // Implements the GUIDData data structure and support methods
6 //
7 //
8 // Author: Rod Smith <rodsmith@rodsbooks.com>, (C) 2010-2011
9 //
10 // Copyright: See COPYING file that comes with this distribution
11 //
12 //
13
14 #define __STDC_LIMIT_MACROS
15 #ifndef __STDC_CONSTANT_MACROS
16 #define __STDC_CONSTANT_MACROS
17 #endif
18
19 #include <stdio.h>
20 #include <time.h>
21 #include <string.h>
22 #include <string>
23 #include <iostream>
24 #include "guid.h"
25 #include "support.h"
26
27 using namespace std;
28
29 bool GUIDData::firstInstance = 1;
30
GUIDData(void)31 GUIDData::GUIDData(void) {
32 if (firstInstance) {
33 srand((unsigned int) time(0));
34 firstInstance = 0;
35 } // if
36 Zero();
37 } // constructor
38
GUIDData(const GUIDData & orig)39 GUIDData::GUIDData(const GUIDData & orig) {
40 memcpy(uuidData, orig.uuidData, sizeof(uuidData));
41 } // copy constructor
42
GUIDData(const string & orig)43 GUIDData::GUIDData(const string & orig) {
44 operator=(orig);
45 } // copy (from string) constructor
46
GUIDData(const char * orig)47 GUIDData::GUIDData(const char * orig) {
48 operator=(orig);
49 } // copy (from char*) constructor
50
~GUIDData(void)51 GUIDData::~GUIDData(void) {
52 } // destructor
53
operator =(const GUIDData & orig)54 GUIDData & GUIDData::operator=(const GUIDData & orig) {
55 memcpy(uuidData, orig.uuidData, sizeof(uuidData));
56 return *this;
57 } // GUIDData::operator=(const GUIDData & orig)
58
59 // Assign the GUID from a string input value. A GUID is normally formatted
60 // with four dashes as element separators, for a total length of 36
61 // characters. If the input string is this long or longer, this function
62 // assumes standard separator positioning; if the input string is less
63 // than 36 characters long, this function assumes the input GUID has
64 // been compressed by removal of separators. In either event, there's
65 // little in the way of sanity checking, so garbage in = garbage out!
66 // One special case: If the first character is 'r' or 'R', a random
67 // GUID is assigned.
operator =(const string & orig)68 GUIDData & GUIDData::operator=(const string & orig) {
69 string copy, fragment;
70 size_t len;
71 // Break points for segments, either with or without characters separating the segments....
72 size_t longSegs[6] = {0, 9, 14, 19, 24, 36};
73 size_t shortSegs[6] = {0, 8, 12, 16, 20, 32};
74 size_t *segStart = longSegs; // Assume there are separators between segments
75
76 // If first character is an 'R' or 'r', set a random GUID; otherwise,
77 // try to parse it as a real GUID
78 if ((orig[0] == 'R') || (orig[0] == 'r')) {
79 Randomize();
80 } else {
81 Zero();
82
83 // Delete stray spaces....
84 copy = DeleteSpaces(orig);
85
86 // If length is too short, assume there are no separators between segments
87 len = copy.length();
88 if (len < 36) {
89 segStart = shortSegs;
90 };
91
92 // Extract data fragments at fixed locations and convert to
93 // integral types....
94 if (len >= segStart[1]) {
95 uuidData[3] = StrToHex(copy, 0);
96 uuidData[2] = StrToHex(copy, 2);
97 uuidData[1] = StrToHex(copy, 4);
98 uuidData[0] = StrToHex(copy, 6);
99 } // if
100 if (len >= segStart[2]) {
101 uuidData[5] = StrToHex(copy, (unsigned int) segStart[1]);
102 uuidData[4] = StrToHex(copy, (unsigned int) segStart[1] + 2);
103 } // if
104 if (len >= segStart[3]) {
105 uuidData[7] = StrToHex(copy, (unsigned int) segStart[2]);
106 uuidData[6] = StrToHex(copy, (unsigned int) segStart[2] + 2);
107 } // if
108 if (len >= segStart[4]) {
109 uuidData[8] = StrToHex(copy, (unsigned int) segStart[3]);
110 uuidData[9] = StrToHex(copy, (unsigned int) segStart[3] + 2);
111 } // if
112 if (len >= segStart[5]) {
113 uuidData[10] = StrToHex(copy, (unsigned int) segStart[4]);
114 uuidData[11] = StrToHex(copy, (unsigned int) segStart[4] + 2);
115 uuidData[12] = StrToHex(copy, (unsigned int) segStart[4] + 4);
116 uuidData[13] = StrToHex(copy, (unsigned int) segStart[4] + 6);
117 uuidData[14] = StrToHex(copy, (unsigned int) segStart[4] + 8);
118 uuidData[15] = StrToHex(copy, (unsigned int) segStart[4] + 10);
119 } // if
120 } // if/else randomize/set value
121
122 return *this;
123 } // GUIDData::operator=(const string & orig)
124
125 // Assignment from C-style string; rely on C++ casting....
operator =(const char * orig)126 GUIDData & GUIDData::operator=(const char * orig) {
127 return operator=((string) orig);
128 } // GUIDData::operator=(const char * orig)
129
130 // Erase the contents of the GUID
Zero(void)131 void GUIDData::Zero(void) {
132 memset(uuidData, 0, sizeof(uuidData));
133 } // GUIDData::Zero()
134
135 // Set a completely random GUID value....
136 // The uuid_generate() function returns a value that needs to have its
137 // first three fields byte-reversed to conform to Intel's GUID layout.
138 // The Windows UuidCreate() function doesn't need this adjustment. If
139 // neither function is defined, or if UuidCreate() fails, set a completely
140 // random GUID -- not completely kosher, but it works on most platforms
141 // (immediately after creating the UUID on Windows 7 being an important
142 // exception).
Randomize(void)143 void GUIDData::Randomize(void) {
144 int i, uuidGenerated = 0;
145
146 #ifdef _UUID_UUID_H
147 uuid_generate(uuidData);
148 ReverseBytes(&uuidData[0], 4);
149 ReverseBytes(&uuidData[4], 2);
150 ReverseBytes(&uuidData[6], 2);
151 uuidGenerated = 1;
152 #endif
153 #if defined (_RPC_H) || defined (__RPC_H__)
154 UUID MsUuid;
155 if (UuidCreate(&MsUuid) == RPC_S_OK) {
156 memcpy(uuidData, &MsUuid, 16);
157 uuidGenerated = 1;
158 } // if
159 #endif
160
161 if (!uuidGenerated) {
162 cerr << "Warning! Unable to generate a proper UUID! Creating an improper one as a last\n"
163 << "resort! Windows 7 may crash if you save this partition table!\a\n";
164 for (i = 0; i < 16; i++)
165 uuidData[i] = (unsigned char) (256.0 * (rand() / (RAND_MAX + 1.0)));
166 } // if
167 } // GUIDData::Randomize
168
169 // Equality operator; returns 1 if the GUIDs are equal, 0 if they're unequal
operator ==(const GUIDData & orig) const170 int GUIDData::operator==(const GUIDData & orig) const {
171 return !memcmp(uuidData, orig.uuidData, sizeof(uuidData));
172 } // GUIDData::operator==
173
174 // Inequality operator; returns 1 if the GUIDs are unequal, 0 if they're equal
operator !=(const GUIDData & orig) const175 int GUIDData::operator!=(const GUIDData & orig) const {
176 return !operator==(orig);
177 } // GUIDData::operator!=
178
179 // Return the GUID as a string, suitable for display to the user.
AsString(void) const180 string GUIDData::AsString(void) const {
181 char theString[40];
182
183 sprintf(theString,
184 "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
185 uuidData[3], uuidData[2], uuidData[1], uuidData[0], uuidData[5],
186 uuidData[4], uuidData[7], uuidData[6], uuidData[8], uuidData[9],
187 uuidData[10], uuidData[11], uuidData[12], uuidData[13], uuidData[14],
188 uuidData[15]);
189 return theString;
190 } // GUIDData::AsString(void)
191
192 // Delete spaces or braces (which often enclose GUIDs) from the orig string,
193 // returning modified string.
DeleteSpaces(string s)194 string GUIDData::DeleteSpaces(string s) {
195 size_t position;
196
197 if (s.length() > 0) {
198 for (position = s.length(); position > 0; position--) {
199 if ((s[position - 1] == ' ') || (s[position - 1] == '{') || (s[position - 1] == '}')) {
200 s.erase(position - 1, 1);
201 } // if
202 } // for
203 } // if
204 return s;
205 } // GUIDData::DeleteSpaces()
206
207 /*******************************
208 * *
209 * Non-class support functions *
210 * *
211 *******************************/
212
213 // Display a GUID as a string....
operator <<(ostream & os,const GUIDData & data)214 ostream & operator<<(ostream & os, const GUIDData & data) {
215 // string asString;
216
217 os << data.AsString();
218 return os;
219 } // GUIDData::operator<<()
220