1 //===-- StringExtractor.cpp -------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "Utility/StringExtractor.h"
11 
12 // C Includes
13 #include <stdlib.h>
14 
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 
19 static const uint8_t
20 g_hex_ascii_to_hex_integer[256] = {
21 
22     255, 255, 255, 255, 255, 255, 255, 255,
23     255, 255, 255, 255, 255, 255, 255, 255,
24     255, 255, 255, 255, 255, 255, 255, 255,
25     255, 255, 255, 255, 255, 255, 255, 255,
26     255, 255, 255, 255, 255, 255, 255, 255,
27     255, 255, 255, 255, 255, 255, 255, 255,
28     0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
29     0x8, 0x9, 255, 255, 255, 255, 255, 255,
30     255, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 255,
31     255, 255, 255, 255, 255, 255, 255, 255,
32     255, 255, 255, 255, 255, 255, 255, 255,
33     255, 255, 255, 255, 255, 255, 255, 255,
34     255, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 255,
35     255, 255, 255, 255, 255, 255, 255, 255,
36     255, 255, 255, 255, 255, 255, 255, 255,
37     255, 255, 255, 255, 255, 255, 255, 255,
38     255, 255, 255, 255, 255, 255, 255, 255,
39     255, 255, 255, 255, 255, 255, 255, 255,
40     255, 255, 255, 255, 255, 255, 255, 255,
41     255, 255, 255, 255, 255, 255, 255, 255,
42     255, 255, 255, 255, 255, 255, 255, 255,
43     255, 255, 255, 255, 255, 255, 255, 255,
44     255, 255, 255, 255, 255, 255, 255, 255,
45     255, 255, 255, 255, 255, 255, 255, 255,
46     255, 255, 255, 255, 255, 255, 255, 255,
47     255, 255, 255, 255, 255, 255, 255, 255,
48     255, 255, 255, 255, 255, 255, 255, 255,
49     255, 255, 255, 255, 255, 255, 255, 255,
50     255, 255, 255, 255, 255, 255, 255, 255,
51     255, 255, 255, 255, 255, 255, 255, 255,
52     255, 255, 255, 255, 255, 255, 255, 255,
53     255, 255, 255, 255, 255, 255, 255, 255,
54 };
55 
56 static inline int
57 xdigit_to_sint (char ch)
58 {
59     if (ch >= 'a' && ch <= 'f')
60         return 10 + ch - 'a';
61     if (ch >= 'A' && ch <= 'F')
62         return 10 + ch - 'A';
63     return ch - '0';
64 }
65 
66 static inline unsigned int
67 xdigit_to_uint (uint8_t ch)
68 {
69     if (ch >= 'a' && ch <= 'f')
70         return 10u + ch - 'a';
71     if (ch >= 'A' && ch <= 'F')
72         return 10u + ch - 'A';
73     return ch - '0';
74 }
75 
76 //----------------------------------------------------------------------
77 // StringExtractor constructor
78 //----------------------------------------------------------------------
79 StringExtractor::StringExtractor() :
80     m_packet(),
81     m_index (0)
82 {
83 }
84 
85 
86 StringExtractor::StringExtractor(const char *packet_cstr) :
87     m_packet(),
88     m_index (0)
89 {
90     if (packet_cstr)
91         m_packet.assign (packet_cstr);
92 }
93 
94 
95 //----------------------------------------------------------------------
96 // StringExtractor copy constructor
97 //----------------------------------------------------------------------
98 StringExtractor::StringExtractor(const StringExtractor& rhs) :
99     m_packet (rhs.m_packet),
100     m_index (rhs.m_index)
101 {
102 
103 }
104 
105 //----------------------------------------------------------------------
106 // StringExtractor assignment operator
107 //----------------------------------------------------------------------
108 const StringExtractor&
109 StringExtractor::operator=(const StringExtractor& rhs)
110 {
111     if (this != &rhs)
112     {
113         m_packet = rhs.m_packet;
114         m_index = rhs.m_index;
115 
116     }
117     return *this;
118 }
119 
120 //----------------------------------------------------------------------
121 // Destructor
122 //----------------------------------------------------------------------
123 StringExtractor::~StringExtractor()
124 {
125 }
126 
127 
128 char
129 StringExtractor::GetChar (char fail_value)
130 {
131     if (m_index < m_packet.size())
132     {
133         char ch = m_packet[m_index];
134         ++m_index;
135         return ch;
136     }
137     m_index = UINT64_MAX;
138     return fail_value;
139 }
140 
141 //----------------------------------------------------------------------
142 // Extract an unsigned character from two hex ASCII chars in the packet
143 // string
144 //----------------------------------------------------------------------
145 uint8_t
146 StringExtractor::GetHexU8 (uint8_t fail_value, bool set_eof_on_fail)
147 {
148     if (GetBytesLeft() >= 2)
149     {
150         const uint8_t hi_nibble = g_hex_ascii_to_hex_integer[static_cast<uint8_t>(m_packet[m_index])];
151         const uint8_t lo_nibble = g_hex_ascii_to_hex_integer[static_cast<uint8_t>(m_packet[m_index+1])];
152         if (hi_nibble < 16 && lo_nibble < 16)
153         {
154             m_index += 2;
155             return (hi_nibble << 4) + lo_nibble;
156         }
157     }
158     if (set_eof_on_fail || m_index >= m_packet.size())
159         m_index = UINT64_MAX;
160     return fail_value;
161 }
162 
163 uint32_t
164 StringExtractor::GetU32 (uint32_t fail_value, int base)
165 {
166     if (m_index < m_packet.size())
167     {
168         char *end = NULL;
169         const char *start = m_packet.c_str();
170         const char *cstr = start + m_index;
171         uint32_t result = ::strtoul (cstr, &end, base);
172 
173         if (end && end != cstr)
174         {
175             m_index = end - start;
176             return result;
177         }
178     }
179     return fail_value;
180 }
181 
182 int32_t
183 StringExtractor::GetS32 (int32_t fail_value, int base)
184 {
185     if (m_index < m_packet.size())
186     {
187         char *end = NULL;
188         const char *start = m_packet.c_str();
189         const char *cstr = start + m_index;
190         int32_t result = ::strtol (cstr, &end, base);
191 
192         if (end && end != cstr)
193         {
194             m_index = end - start;
195             return result;
196         }
197     }
198     return fail_value;
199 }
200 
201 
202 uint64_t
203 StringExtractor::GetU64 (uint64_t fail_value, int base)
204 {
205     if (m_index < m_packet.size())
206     {
207         char *end = NULL;
208         const char *start = m_packet.c_str();
209         const char *cstr = start + m_index;
210         uint64_t result = ::strtoull (cstr, &end, base);
211 
212         if (end && end != cstr)
213         {
214             m_index = end - start;
215             return result;
216         }
217     }
218     return fail_value;
219 }
220 
221 int64_t
222 StringExtractor::GetS64 (int64_t fail_value, int base)
223 {
224     if (m_index < m_packet.size())
225     {
226         char *end = NULL;
227         const char *start = m_packet.c_str();
228         const char *cstr = start + m_index;
229         int64_t result = ::strtoll (cstr, &end, base);
230 
231         if (end && end != cstr)
232         {
233             m_index = end - start;
234             return result;
235         }
236     }
237     return fail_value;
238 }
239 
240 
241 uint32_t
242 StringExtractor::GetHexMaxU32 (bool little_endian, uint32_t fail_value)
243 {
244     uint32_t result = 0;
245     uint32_t nibble_count = 0;
246 
247     if (little_endian)
248     {
249         uint32_t shift_amount = 0;
250         while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
251         {
252             // Make sure we don't exceed the size of a uint32_t...
253             if (nibble_count >= (sizeof(uint32_t) * 2))
254             {
255                 m_index = UINT64_MAX;
256                 return fail_value;
257             }
258 
259             uint8_t nibble_lo;
260             uint8_t nibble_hi = xdigit_to_sint (m_packet[m_index]);
261             ++m_index;
262             if (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
263             {
264                 nibble_lo = xdigit_to_sint (m_packet[m_index]);
265                 ++m_index;
266                 result |= ((uint32_t)nibble_hi << (shift_amount + 4));
267                 result |= ((uint32_t)nibble_lo << shift_amount);
268                 nibble_count += 2;
269                 shift_amount += 8;
270             }
271             else
272             {
273                 result |= ((uint32_t)nibble_hi << shift_amount);
274                 nibble_count += 1;
275                 shift_amount += 4;
276             }
277 
278         }
279     }
280     else
281     {
282         while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
283         {
284             // Make sure we don't exceed the size of a uint32_t...
285             if (nibble_count >= (sizeof(uint32_t) * 2))
286             {
287                 m_index = UINT64_MAX;
288                 return fail_value;
289             }
290 
291             uint8_t nibble = xdigit_to_sint (m_packet[m_index]);
292             // Big Endian
293             result <<= 4;
294             result |= nibble;
295 
296             ++m_index;
297             ++nibble_count;
298         }
299     }
300     return result;
301 }
302 
303 uint64_t
304 StringExtractor::GetHexMaxU64 (bool little_endian, uint64_t fail_value)
305 {
306     uint64_t result = 0;
307     uint32_t nibble_count = 0;
308 
309     if (little_endian)
310     {
311         uint32_t shift_amount = 0;
312         while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
313         {
314             // Make sure we don't exceed the size of a uint64_t...
315             if (nibble_count >= (sizeof(uint64_t) * 2))
316             {
317                 m_index = UINT64_MAX;
318                 return fail_value;
319             }
320 
321             uint8_t nibble_lo;
322             uint8_t nibble_hi = xdigit_to_sint (m_packet[m_index]);
323             ++m_index;
324             if (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
325             {
326                 nibble_lo = xdigit_to_sint (m_packet[m_index]);
327                 ++m_index;
328                 result |= ((uint64_t)nibble_hi << (shift_amount + 4));
329                 result |= ((uint64_t)nibble_lo << shift_amount);
330                 nibble_count += 2;
331                 shift_amount += 8;
332             }
333             else
334             {
335                 result |= ((uint64_t)nibble_hi << shift_amount);
336                 nibble_count += 1;
337                 shift_amount += 4;
338             }
339 
340         }
341     }
342     else
343     {
344         while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
345         {
346             // Make sure we don't exceed the size of a uint64_t...
347             if (nibble_count >= (sizeof(uint64_t) * 2))
348             {
349                 m_index = UINT64_MAX;
350                 return fail_value;
351             }
352 
353             uint8_t nibble = xdigit_to_sint (m_packet[m_index]);
354             // Big Endian
355             result <<= 4;
356             result |= nibble;
357 
358             ++m_index;
359             ++nibble_count;
360         }
361     }
362     return result;
363 }
364 
365 size_t
366 StringExtractor::GetHexBytes (void *dst_void, size_t dst_len, uint8_t fail_fill_value)
367 {
368     uint8_t *dst = (uint8_t*)dst_void;
369     size_t bytes_extracted = 0;
370     while (bytes_extracted < dst_len && GetBytesLeft ())
371     {
372         dst[bytes_extracted] = GetHexU8 (fail_fill_value);
373         if (IsGood())
374             ++bytes_extracted;
375         else
376             break;
377     }
378 
379     for (size_t i = bytes_extracted; i < dst_len; ++i)
380         dst[i] = fail_fill_value;
381 
382     return bytes_extracted;
383 }
384 
385 
386 // Consume ASCII hex nibble character pairs until we have decoded byte_size
387 // bytes of data.
388 
389 uint64_t
390 StringExtractor::GetHexWithFixedSize (uint32_t byte_size, bool little_endian, uint64_t fail_value)
391 {
392     if (byte_size <= 8 && GetBytesLeft() >= byte_size * 2)
393     {
394         uint64_t result = 0;
395         uint32_t i;
396         if (little_endian)
397         {
398             // Little Endian
399             uint32_t shift_amount;
400             for (i = 0, shift_amount = 0;
401                  i < byte_size && IsGood();
402                  ++i, shift_amount += 8)
403             {
404                 result |= ((uint64_t)GetHexU8() << shift_amount);
405             }
406         }
407         else
408         {
409             // Big Endian
410             for (i = 0; i < byte_size && IsGood(); ++i)
411             {
412                 result <<= 8;
413                 result |= GetHexU8();
414             }
415         }
416     }
417     m_index = UINT64_MAX;
418     return fail_value;
419 }
420 
421 size_t
422 StringExtractor::GetHexByteString (std::string &str)
423 {
424     str.clear();
425     char ch;
426     while ((ch = GetHexU8()) != '\0')
427         str.append(1, ch);
428     return str.size();
429 }
430 
431 size_t
432 StringExtractor::GetHexByteStringTerminatedBy (std::string &str,
433                                                char terminator)
434 {
435     str.clear();
436     char ch;
437     while ((ch = GetHexU8(0,false)) != '\0')
438         str.append(1, ch);
439     if (Peek() && *Peek() == terminator)
440         return str.size();
441     str.clear();
442     return str.size();
443 }
444 
445 bool
446 StringExtractor::GetNameColonValue (std::string &name, std::string &value)
447 {
448     // Read something in the form of NNNN:VVVV; where NNNN is any character
449     // that is not a colon, followed by a ':' character, then a value (one or
450     // more ';' chars), followed by a ';'
451     if (m_index < m_packet.size())
452     {
453         const size_t colon_idx = m_packet.find (':', m_index);
454         if (colon_idx != std::string::npos)
455         {
456             const size_t semicolon_idx = m_packet.find (';', colon_idx);
457             if (semicolon_idx != std::string::npos)
458             {
459                 name.assign (m_packet, m_index, colon_idx - m_index);
460                 value.assign (m_packet, colon_idx + 1, semicolon_idx - (colon_idx + 1));
461                 m_index = semicolon_idx + 1;
462                 return true;
463             }
464         }
465     }
466     m_index = UINT64_MAX;
467     return false;
468 }
469