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