开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
lluuid.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：21k
源码类别：

游戏引擎

开发平台：

C++ Builder

lluuid.cpp：源码内容
  1. /** 
  2.  * @file lluuid.cpp
  3.  *
  4.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2000-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  32. #include "linden_common.h"
  34. // We can't use WIN32_LEAN_AND_MEAN here, needs lots of includes.
  35. #if LL_WINDOWS
  36. # undef WIN32_LEAN_AND_MEAN
  37. # include <winsock2.h>
  38. # include <windows.h>
  39. #endif
  41. #include "lldefs.h"
  42. #include "llerror.h"
  44. #include "lluuid.h"
  45. #include "llerror.h"
  46. #include "llrand.h"
  47. #include "llmd5.h"
  48. #include "llstring.h"
  49. #include "lltimer.h"
  51. const LLUUID LLUUID::null;
  52. const LLTransactionID LLTransactionID::tnull;
  54. /*
  56. NOT DONE YET!!!
  58. static char BASE85_TABLE[] = {
  59. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  60. 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  61. 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  62. 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  63. 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  64. 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
  65. 'y', 'z', '!', '#', '$', '%', '&', '(', ')', '*',
  66. '+', '-', ';', '[', '=', '>', '?', '@', '^', '_',
  67. '`', '{', '|', '}', '~', ''
  68. };
  71. void encode( char * fiveChars, unsigned int word ) throw( )
  72. {
  73. for( int ix = 0; ix < 5; ++ix ) {
  74. fiveChars[4-ix] = encodeTable[ word % 85];
  75. word /= 85;
  76. }
  77. }
  79. To decode:
  80. unsigned int decode( char const * fiveChars ) throw( bad_input_data )
  81. {
  82. unsigned int ret = 0;
  83. for( int ix = 0; ix < 5; ++ix ) {
  84. char * s = strchr( encodeTable, fiveChars[ ix ] );
  85. if( s == 0 ) throw bad_input_data();
  86. ret = ret * 85 + (s-encodeTable);
  87. }
  88. return ret;
  89. }
  91. void LLUUID::toBase85(char* out)
  92. {
  93. U32* me = (U32*)&(mData[0]);
  94. for(S32 i = 0; i < 4; ++i)
  95. {
  96. char* o = &out[i*i];
  97. for(S32 j = 0; j < 5; ++j)
  98. {
  99. o[4-j] = BASE85_TABLE[ me[i] % 85];
  100. word /= 85;
  101. }
  102. }
  103. }
  105. unsigned int decode( char const * fiveChars ) throw( bad_input_data )
  106. {
  107. unsigned int ret = 0;
  108. for( S32 ix = 0; ix < 5; ++ix )
  109. {
  110. char * s = strchr( encodeTable, fiveChars[ ix ] );
  111. ret = ret * 85 + (s-encodeTable);
  112. }
  113. return ret;
  114. } 
  115. */
  117. #define LL_USE_JANKY_RANDOM_NUMBER_GENERATOR 0
  118. #if LL_USE_JANKY_RANDOM_NUMBER_GENERATOR
  119. /**
  120.  * @brief a global for
  121.  */
  122. static U64 sJankyRandomSeed(LLUUID::getRandomSeed());
  124. /**
  125.  * @brief generate a random U32.
  126.  */
  127. U32 janky_fast_random_bytes()
  128. {
  129. sJankyRandomSeed = U64L(1664525) * sJankyRandomSeed + U64L(1013904223); 
  130. return (U32)sJankyRandomSeed;
  131. }
  133. /**
  134.  * @brief generate a random U32 from [0, val)
  135.  */
  136. U32 janky_fast_random_byes_range(U32 val)
  137. {
  138. sJankyRandomSeed = U64L(1664525) * sJankyRandomSeed + U64L(1013904223); 
  139. return (U32)(sJankyRandomSeed) % val; 
  140. }
  142. /**
  143.  * @brief generate a random U32 from [0, val)
  144.  */
  145. U32 janky_fast_random_seeded_bytes(U32 seed, U32 val)
  146. {
  147. seed = U64L(1664525) * (U64)(seed) + U64L(1013904223); 
  148. return (U32)(seed) % val; 
  149. }
  150. #endif
  152. // Common to all UUID implementations
  153. void LLUUID::toString(std::string& out) const
  154. {
  155. out = llformat(
  156. "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
  157. (U8)(mData[0]),
  158. (U8)(mData[1]),
  159. (U8)(mData[2]),
  160. (U8)(mData[3]),
  161. (U8)(mData[4]),
  162. (U8)(mData[5]),
  163. (U8)(mData[6]),
  164. (U8)(mData[7]),
  165. (U8)(mData[8]),
  166. (U8)(mData[9]),
  167. (U8)(mData[10]),
  168. (U8)(mData[11]),
  169. (U8)(mData[12]),
  170. (U8)(mData[13]),
  171. (U8)(mData[14]),
  172. (U8)(mData[15]));
  173. }
  175. // *TODO: deprecate
  176. void LLUUID::toString(char *out) const
  177. {
  178. std::string buffer;
  179. toString(buffer);
  180. strcpy(out,buffer.c_str()); /* Flawfinder: ignore */
  181. }
  183. void LLUUID::toCompressedString(std::string& out) const
  184. {
  185. char bytes[UUID_BYTES+1];
  186. memcpy(bytes, mData, UUID_BYTES); /* Flawfinder: ignore */
  187. bytes[UUID_BYTES] = '';
  188. out.assign(bytes, UUID_BYTES);
  189. }
  191. // *TODO: deprecate
  192. void LLUUID::toCompressedString(char *out) const
  193. {
  194. memcpy(out, mData, UUID_BYTES); /* Flawfinder: ignore */
  195. out[UUID_BYTES] = '';
  196. }
  198. std::string LLUUID::getString() const
  199. {
  200. return asString();
  201. }
  203. std::string LLUUID::asString() const
  204. {
  205. std::string str;
  206. toString(str);
  207. return str;
  208. }
  210. BOOL LLUUID::set(const char* in_string, BOOL emit)
  211. {
  212. return set(ll_safe_string(in_string),emit);
  213. }
  215. BOOL LLUUID::set(const std::string& in_string, BOOL emit)
  216. {
  217. BOOL broken_format = FALSE;
  219. // empty strings should make NULL uuid
  220. if (in_string.empty())
  221. {
  222. setNull();
  223. return TRUE;
  224. }
  226. if (in_string.length() != (UUID_STR_LENGTH - 1)) /* Flawfinder: ignore */
  227. {
  228. // I'm a moron.  First implementation didn't have the right UUID format.
  229. // Shouldn't see any of these any more
  230. if (in_string.length() == (UUID_STR_LENGTH - 2)) /* Flawfinder: ignore */
  231. {
  232. if(emit)
  233. {
  234. llwarns << "Warning! Using broken UUID string format" << llendl;
  235. }
  236. broken_format = TRUE;
  237. }
  238. else
  239. {
  240. // Bad UUID string.  Spam as INFO, as most cases we don't care.
  241. if(emit)
  242. {
  243. //don't spam the logs because a resident can't spell.
  244. llwarns << "Bad UUID string: " << in_string << llendl;
  245. }
  246. setNull();
  247. return FALSE;
  248. }
  249. }
  251. U8 cur_pos = 0;
  252. S32 i;
  253. for (i = 0; i < UUID_BYTES; i++)
  254. {
  255. if ((i == 4) || (i == 6) || (i == 8) || (i == 10))
  256. {
  257. cur_pos++;
  258. if (broken_format && (i==10))
  259. {
  260. // Missing - in the broken format
  261. cur_pos--;
  262. }
  263. }
  265. mData[i] = 0;
  267. if ((in_string[cur_pos] >= '0') && (in_string[cur_pos] <= '9'))
  268. {
  269. mData[i] += (U8)(in_string[cur_pos] - '0');
  270. }
  271. else if ((in_string[cur_pos] >= 'a') && (in_string[cur_pos] <='f'))
  272. {
  273. mData[i] += (U8)(10 + in_string[cur_pos] - 'a');
  274. }
  275. else if ((in_string[cur_pos] >= 'A') && (in_string[cur_pos] <='F'))
  276. {
  277. mData[i] += (U8)(10 + in_string[cur_pos] - 'A');
  278. }
  279. else
  280. {
  281. if(emit)
  282. {
  283. llwarns << "Invalid UUID string character" << llendl;
  284. }
  285. setNull();
  286. return FALSE;
  287. }
  289. mData[i] = mData[i] << 4;
  290. cur_pos++;
  292. if ((in_string[cur_pos] >= '0') && (in_string[cur_pos] <= '9'))
  293. {
  294. mData[i] += (U8)(in_string[cur_pos] - '0');
  295. }
  296. else if ((in_string[cur_pos] >= 'a') && (in_string[cur_pos] <='f'))
  297. {
  298. mData[i] += (U8)(10 + in_string[cur_pos] - 'a');
  299. }
  300. else if ((in_string[cur_pos] >= 'A') && (in_string[cur_pos] <='F'))
  301. {
  302. mData[i] += (U8)(10 + in_string[cur_pos] - 'A');
  303. }
  304. else
  305. {
  306. if(emit)
  307. {
  308. llwarns << "Invalid UUID string character" << llendl;
  309. }
  310. setNull();
  311. return FALSE;
  312. }
  313. cur_pos++;
  314. }
  316. return TRUE;
  317. }
  319. BOOL LLUUID::validate(const std::string& in_string)
  320. {
  321. BOOL broken_format = FALSE;
  322. if (in_string.length() != (UUID_STR_LENGTH - 1)) /* Flawfinder: ignore */
  323. {
  324. // I'm a moron.  First implementation didn't have the right UUID format.
  325. if (in_string.length() == (UUID_STR_LENGTH - 2)) /* Flawfinder: ignore */
  326. {
  327. broken_format = TRUE;
  328. }
  329. else
  330. {
  331. return FALSE;
  332. }
  333. }
  335. U8 cur_pos = 0;
  336. for (U32 i = 0; i < 16; i++)
  337. {
  338. if ((i == 4) || (i == 6) || (i == 8) || (i == 10))
  339. {
  340. cur_pos++;
  341. if (broken_format && (i==10))
  342. {
  343. // Missing - in the broken format
  344. cur_pos--;
  345. }
  346. }
  348. if ((in_string[cur_pos] >= '0') && (in_string[cur_pos] <= '9'))
  349. {
  350. }
  351. else if ((in_string[cur_pos] >= 'a') && (in_string[cur_pos] <='f'))
  352. {
  353. }
  354. else if ((in_string[cur_pos] >= 'A') && (in_string[cur_pos] <='F'))
  355. {
  356. }
  357. else
  358. {
  359. return FALSE;
  360. }
  362. cur_pos++;
  364. if ((in_string[cur_pos] >= '0') && (in_string[cur_pos] <= '9'))
  365. {
  366. }
  367. else if ((in_string[cur_pos] >= 'a') && (in_string[cur_pos] <='f'))
  368. {
  369. }
  370. else if ((in_string[cur_pos] >= 'A') && (in_string[cur_pos] <='F'))
  371. {
  372. }
  373. else
  374. {
  375. return FALSE;
  376. }
  377. cur_pos++;
  378. }
  379. return TRUE;
  380. }
  382. const LLUUID& LLUUID::operator^=(const LLUUID& rhs)
  383. {
  384. U32* me = (U32*)&(mData[0]);
  385. const U32* other = (U32*)&(rhs.mData[0]);
  386. for(S32 i = 0; i < 4; ++i)
  387. {
  388. me[i] = me[i] ^ other[i];
  389. }
  390. return *this;
  391. }
  393. LLUUID LLUUID::operator^(const LLUUID& rhs) const
  394. {
  395. LLUUID id(*this);
  396. id ^= rhs;
  397. return id;
  398. }
  400. void LLUUID::combine(const LLUUID& other, LLUUID& result) const
  401. {
  402. LLMD5 md5_uuid;
  403. md5_uuid.update((unsigned char*)mData, 16);
  404. md5_uuid.update((unsigned char*)other.mData, 16);
  405. md5_uuid.finalize();
  406. md5_uuid.raw_digest(result.mData);
  407. }
  409. LLUUID LLUUID::combine(const LLUUID &other) const
  410. {
  411. LLUUID combination;
  412. combine(other, combination);
  413. return combination;
  414. }
  416. std::ostream& operator<<(std::ostream& s, const LLUUID &uuid)
  417. {
  418. std::string uuid_str;
  419. uuid.toString(uuid_str);
  420. s << uuid_str;
  421. return s;
  422. }
  424. std::istream& operator>>(std::istream &s, LLUUID &uuid)
  425. {
  426. U32 i;
  427. char uuid_str[UUID_STR_LENGTH]; /* Flawfinder: ignore */
  428. for (i = 0; i < UUID_STR_LENGTH-1; i++)
  429. {
  430. s >> uuid_str[i];
  431. }
  432. uuid_str[i] = '';
  433. uuid.set(std::string(uuid_str));
  434. return s;
  435. }
  437. static void get_random_bytes(void *buf, int nbytes)
  438. {
  439. int i;
  440. char *cp = (char *) buf;
  442. // *NOTE: If we are not using the janky generator ll_rand()
  443. // generates at least 3 good bytes of data since it is 0 to
  444. // RAND_MAX. This could be made more efficient by copying all the
  445. // bytes.
  446. for (i=0; i < nbytes; i++)
  447. #if LL_USE_JANKY_RANDOM_NUMBER_GENERATOR
  448. *cp++ = janky_fast_random_bytes() & 0xFF;
  449. #else
  450. *cp++ = ll_rand() & 0xFF;
  451. #endif
  452. return;
  453. }
  455. #if LL_WINDOWS
  456. typedef struct _ASTAT_
  457. {
  458. ADAPTER_STATUS adapt;
  459. NAME_BUFFER    NameBuff [30];
  460. }ASTAT, * PASTAT;
  462. // static
  463. S32 LLUUID::getNodeID(unsigned char * node_id)
  464. {
  465.   ASTAT Adapter;
  466.       NCB Ncb;
  467.       UCHAR uRetCode;
  468.       LANA_ENUM   lenum;
  469.       int      i;
  470.   int retval = 0;
  472.       memset( &Ncb, 0, sizeof(Ncb) );
  473.       Ncb.ncb_command = NCBENUM;
  474.       Ncb.ncb_buffer = (UCHAR *)&lenum;
  475.       Ncb.ncb_length = sizeof(lenum);
  476.       uRetCode = Netbios( &Ncb );
  477.  //     printf( "The NCBENUM return code is: 0x%x n", uRetCode );
  479.       for(i=0; i < lenum.length ;i++)
  480.       {
  481.           memset( &Ncb, 0, sizeof(Ncb) );
  482.           Ncb.ncb_command = NCBRESET;
  483.           Ncb.ncb_lana_num = lenum.lana[i];
  485.           uRetCode = Netbios( &Ncb );
  486.  //         printf( "The NCBRESET on LANA %d return code is: 0x%x n",
  487.  //                 lenum.lana[i], uRetCode );
  489.           memset( &Ncb, 0, sizeof (Ncb) );
  490.           Ncb.ncb_command = NCBASTAT;
  491.           Ncb.ncb_lana_num = lenum.lana[i];
  493.           strcpy( (char *)Ncb.ncb_callname,  "*              " ); /* Flawfinder: ignore */
  494.           Ncb.ncb_buffer = (unsigned char *)&Adapter;
  495.           Ncb.ncb_length = sizeof(Adapter);
  497.           uRetCode = Netbios( &Ncb );
  498. //          printf( "The NCBASTAT on LANA %d return code is: 0x%x n",
  499. //                 lenum.lana[i], uRetCode );
  500.           if ( uRetCode == 0 )
  501.           {
  502. //            printf( "The Ethernet Number on LANA %d is: %02x%02x%02x%02x%02x%02xn",
  503. //     lenum.lana[i],
  504. //                  Adapter.adapt.adapter_address[0],
  505. //                  Adapter.adapt.adapter_address[1],
  506. //                  Adapter.adapt.adapter_address[2],
  507. //                  Adapter.adapt.adapter_address[3],
  508. //                  Adapter.adapt.adapter_address[4],
  509. //                  Adapter.adapt.adapter_address[5] );
  510. memcpy(node_id,Adapter.adapt.adapter_address,6); /* Flawfinder: ignore */
  511. retval = 1;
  513.           }
  514.   }
  515. return retval;
  516. }
  518. #elif LL_DARWIN
  519. // Mac OS X version of the UUID generation code...
  520. /*
  521.  * Get an ethernet hardware address, if we can find it...
  522.  */
  523. #include <unistd.h>
  524. #include <sys/types.h>
  525. #include <sys/time.h>
  526. #include <sys/socket.h>
  527. #include <sys/ioctl.h>
  528. #include <net/if.h>
  529. #include <net/if_types.h>
  530. #include <net/if_dl.h>
  531. #include <net/route.h>
  532. #include <ifaddrs.h>
  534. // static
  535. S32 LLUUID::getNodeID(unsigned char *node_id)
  536. {
  537. int i;
  538. unsigned char  *a = NULL;
  539. struct ifaddrs *ifap, *ifa;
  540. int rv;
  541. S32 result = 0;
  543. if ((rv=getifaddrs(&ifap))==-1)
  544. {       
  545. return -1;
  546. }
  547. if (ifap == NULL)
  548. {
  549. return -1;
  550. }
  552. for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next)
  553. {       
  554. // printf("Interface %s, address family %d, ", ifa->ifa_name, ifa->ifa_addr->sa_family);
  555. for(i=0; i< ifa->ifa_addr->sa_len; i++)
  556. {
  557. // printf("%02X ", (unsigned char)ifa->ifa_addr->sa_data[i]);
  558. }
  559. // printf("n");
  561. if(ifa->ifa_addr->sa_family == AF_LINK)
  562. {
  563. // This is a link-level address
  564. struct sockaddr_dl *lla = (struct sockaddr_dl *)ifa->ifa_addr;
  566. // printf("tLink level address, type %02Xn", lla->sdl_type);
  568. if(lla->sdl_type == IFT_ETHER)
  569. {
  570. // Use the first ethernet MAC in the list.
  571. // For some reason, the macro LLADDR() defined in net/if_dl.h doesn't expand correctly.  This is what it would do.
  572. a = (unsigned char *)&((lla)->sdl_data);
  573. a += (lla)->sdl_nlen;
  575. if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
  576. {
  577. continue;
  578. }
  580. if (node_id) 
  581. {
  582. memcpy(node_id, a, 6);
  583. result = 1;
  584. }
  586. // We found one.
  587. break;
  588. }
  589. }
  590. }
  591. freeifaddrs(ifap);
  593. return result;
  594. }
  596. #else
  598. // Linux version of the UUID generation code...
  599. /*
  600.  * Get the ethernet hardware address, if we can find it...
  601.  */
  602. #include <unistd.h>
  603. #include <fcntl.h>
  604. #include <errno.h>
  605. #include <sys/types.h>
  606. #include <sys/time.h>
  607. #include <sys/stat.h>
  608. #include <sys/file.h>
  609. #include <sys/ioctl.h>
  610. #include <sys/socket.h>
  611. #include <net/if.h>
  612. #define HAVE_NETINET_IN_H
  613. #ifdef HAVE_NETINET_IN_H
  614. #include <netinet/in.h>
  615. #if LL_SOLARIS
  616. #include <sys/sockio.h>
  617. #elif !LL_DARWIN
  618. #include <linux/sockios.h>
  619. #endif
  620. #endif
  622. // static
  623. S32 LLUUID::getNodeID(unsigned char *node_id)
  624. {
  625. int  sd;
  626. struct ifreq  ifr, *ifrp;
  627. struct ifconf  ifc;
  628. char buf[1024];
  629. int n, i;
  630. unsigned char  *a;
  632. /*
  633.  * BSD 4.4 defines the size of an ifreq to be
  634.  * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
  635.  * However, under earlier systems, sa_len isn't present, so the size is 
  636.  * just sizeof(struct ifreq)
  637.  */
  638. #ifdef HAVE_SA_LEN
  639. #ifndef max
  640. #define max(a,b) ((a) > (b) ? (a) : (b))
  641. #endif
  642. #define ifreq_size(i) max(sizeof(struct ifreq),
  643.      sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
  644. #else
  645. #define ifreq_size(i) sizeof(struct ifreq)
  646. #endif /* HAVE_SA_LEN*/
  648. sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
  649. if (sd < 0) {
  650. return -1;
  651. }
  652. memset(buf, 0, sizeof(buf));
  653. ifc.ifc_len = sizeof(buf);
  654. ifc.ifc_buf = buf;
  655. if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) {
  656. close(sd);
  657. return -1;
  658. }
  659. n = ifc.ifc_len;
  660. for (i = 0; i < n; i+= ifreq_size(*ifr) ) {
  661. ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
  662. strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ); /* Flawfinder: ignore */
  663. #ifdef SIOCGIFHWADDR
  664. if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
  665. continue;
  666. a = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
  667. #else
  668. #ifdef SIOCGENADDR
  669. if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
  670. continue;
  671. a = (unsigned char *) ifr.ifr_enaddr;
  672. #else
  673. /*
  674.  * XXX we don't have a way of getting the hardware
  675.  * address
  676.  */
  677. close(sd);
  678. return 0;
  679. #endif /* SIOCGENADDR */
  680. #endif /* SIOCGIFHWADDR */
  681. if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
  682. continue;
  683. if (node_id) {
  684. memcpy(node_id, a, 6); /* Flawfinder: ignore */
  685. close(sd);
  686. return 1;
  687. }
  688. }
  689. close(sd);
  690. return 0;
  691. }
  693. #endif
  695. S32 LLUUID::cmpTime(uuid_time_t *t1, uuid_time_t *t2)
  696. {
  697.    // Compare two time values.
  699.    if (t1->high < t2->high) return -1;
  700.    if (t1->high > t2->high) return 1;
  701.    if (t1->low  < t2->low)  return -1;
  702.    if (t1->low  > t2->low)  return 1;
  703.    return 0;
  704. }
  706. void LLUUID::getSystemTime(uuid_time_t *timestamp)
  707. {
  708.    // Get system time with 100ns precision. Time is since Oct 15, 1582.
  709. #if LL_WINDOWS
  710.    ULARGE_INTEGER time;
  711.    GetSystemTimeAsFileTime((FILETIME *)&time);
  712.    // NT keeps time in FILETIME format which is 100ns ticks since
  713.    // Jan 1, 1601. UUIDs use time in 100ns ticks since Oct 15, 1582.
  714.    // The difference is 17 Days in Oct + 30 (Nov) + 31 (Dec)
  715.    // + 18 years and 5 leap days.
  716.    time.QuadPart +=
  717.             (unsigned __int64) (1000*1000*10)       // seconds
  718.           * (unsigned __int64) (60 * 60 * 24)       // days
  719.           * (unsigned __int64) (17+30+31+365*18+5); // # of days
  721.    timestamp->high = time.HighPart;
  722.    timestamp->low  = time.LowPart;
  723. #else
  724.    struct timeval tp;
  725.    gettimeofday(&tp, 0);
  727.    // Offset between UUID formatted times and Unix formatted times.
  728.    // UUID UTC base time is October 15, 1582.
  729.    // Unix base time is January 1, 1970.
  730.    U64 uuid_time = ((U64)tp.tv_sec * 10000000) + (tp.tv_usec * 10) +
  731.                            U64L(0x01B21DD213814000);
  732.    timestamp->high = (U32) (uuid_time >> 32);
  733.    timestamp->low  = (U32) (uuid_time & 0xFFFFFFFF);
  734. #endif
  735. }
  737. void LLUUID::getCurrentTime(uuid_time_t *timestamp)
  738. {
  739.    // Get current time as 60 bit 100ns ticks since whenever.
  740.    // Compensate for the fact that real clock resolution is less
  741.    // than 100ns.
  743.    const U32 uuids_per_tick = 1024;
  745.    static uuid_time_t time_last;
  746.    static U32    uuids_this_tick;
  747.    static BOOL     init = FALSE;
  749.    if (!init) {
  750.       getSystemTime(&time_last);
  751.       uuids_this_tick = uuids_per_tick;
  752.       init = TRUE;
  753.    }
  755.    uuid_time_t time_now = {0,0};
  757.    while (1) {
  758.       getSystemTime(&time_now);
  760.       // if clock reading changed since last UUID generated
  761.       if (cmpTime(&time_last, &time_now))  {
  762.          // reset count of uuid's generated with this clock reading
  763.          uuids_this_tick = 0;
  764.          break;
  765.       }
  766.       if (uuids_this_tick < uuids_per_tick) {
  767.          uuids_this_tick++;
  768.          break;
  769.       }
  770.       // going too fast for our clock; spin
  771.    }
  773.    time_last = time_now;
  775.    if (uuids_this_tick != 0) {
  776.       if (time_now.low & 0x80000000) {
  777.          time_now.low += uuids_this_tick;
  778.          if (!(time_now.low & 0x80000000))
  779.             time_now.high++;
  780.       } else
  781.          time_now.low += uuids_this_tick;
  782.    }
  784.    timestamp->high = time_now.high;
  785.    timestamp->low  = time_now.low;
  786. }
  788. void LLUUID::generate()
  789. {
  790. // Create a UUID.
  791. uuid_time_t timestamp;
  793. static unsigned char node_id[6]; /* Flawfinder: ignore */
  794. static int has_init = 0;
  795.    
  796. // Create a UUID.
  797. static uuid_time_t time_last = {0,0};
  798. static U16 clock_seq = 0;
  799. #if LL_USE_JANKY_RANDOM_NUMBER_GENERATOR
  800. static U32 seed = 0L; // dummy seed.  reset it below
  801. #endif
  802. if (!has_init) 
  803. {
  804. if (getNodeID(node_id) <= 0) 
  805. {
  806. get_random_bytes(node_id, 6);
  807. /*
  808.  * Set multicast bit, to prevent conflicts
  809.  * with IEEE 802 addresses obtained from
  810.  * network cards
  811.  */
  812. node_id[0] |= 0x80;
  813. }
  815. getCurrentTime(&time_last);
  816. #if LL_USE_JANKY_RANDOM_NUMBER_GENERATOR
  817. seed = time_last.low;
  818. #endif
  820. #if LL_USE_JANKY_RANDOM_NUMBER_GENERATOR
  821. clock_seq = (U16)janky_fast_random_seeded_bytes(seed, 65536);
  822. #else
  823. clock_seq = (U16)ll_rand(65536);
  824. #endif
  825. has_init = 1;
  826. }
  828. // get current time
  829. getCurrentTime(&timestamp);
  831. // if clock went backward change clockseq
  832. if (cmpTime(&timestamp, &time_last) == -1) {
  833. clock_seq = (clock_seq + 1) & 0x3FFF;
  834. if (clock_seq == 0) clock_seq++;
  835. }
  837. memcpy(mData+10, node_id, 6); /* Flawfinder: ignore */
  838. U32 tmp;
  839. tmp = timestamp.low;
  840. mData[3] = (unsigned char) tmp;
  841. tmp >>= 8;
  842. mData[2] = (unsigned char) tmp;
  843. tmp >>= 8;
  844. mData[1] = (unsigned char) tmp;
  845. tmp >>= 8;
  846. mData[0] = (unsigned char) tmp;
  848. tmp = (U16) timestamp.high;
  849. mData[5] = (unsigned char) tmp;
  850. tmp >>= 8;
  851. mData[4] = (unsigned char) tmp;
  853. tmp = (timestamp.high >> 16) | 0x1000;
  854. mData[7] = (unsigned char) tmp;
  855. tmp >>= 8;
  856. mData[6] = (unsigned char) tmp;
  858. tmp = clock_seq;
  859. mData[9] = (unsigned char) tmp;
  860. tmp >>= 8;
  861. mData[8] = (unsigned char) tmp;
  863. LLMD5 md5_uuid;
  865. md5_uuid.update(mData,16);
  866. md5_uuid.finalize();
  867. md5_uuid.raw_digest(mData);
  869.     time_last = timestamp;
  870. }
  872. void LLUUID::generate(const std::string& hash_string)
  873. {
  874. LLMD5 md5_uuid((U8*)hash_string.c_str());
  875. md5_uuid.raw_digest(mData);
  876. }
  878. U32 LLUUID::getRandomSeed()
  879. {
  880.    static unsigned char seed[16]; /* Flawfinder: ignore */
  881.    
  882.    getNodeID(&seed[0]);
  883.    seed[6]='';
  884.    seed[7]='';
  885.    getSystemTime((uuid_time_t *)(&seed[8]));
  887.    LLMD5 md5_seed;
  889.    md5_seed.update(seed,16);
  890.    md5_seed.finalize();
  891.    md5_seed.raw_digest(seed);
  892.    
  893.    return(*(U32 *)seed);
  894. }
  896. BOOL LLUUID::parseUUID(const std::string& buf, LLUUID* value)
  897. {
  898. if( buf.empty() || value == NULL)
  899. {
  900. return FALSE;
  901. }
  903. std::string temp( buf );
  904. LLStringUtil::trim(temp);
  905. if( LLUUID::validate( temp ) )
  906. {
  907. value->set( temp );
  908. return TRUE;
  909. }
  910. return FALSE;
  911. }
  913. //static
  914. LLUUID LLUUID::generateNewID(std::string hash_string)
  915. {
  916. LLUUID new_id;
  917. if (hash_string.empty())
  918. {
  919. new_id.generate();
  920. }
  921. else
  922. {
  923. new_id.generate(hash_string);
  924. }
  925. return new_id;
  926. }
  928. LLAssetID LLTransactionID::makeAssetID(const LLUUID& session) const
  929. {
  930. LLAssetID result;
  931. if (isNull())
  932. {
  933. result.setNull();
  934. }
  935. else
  936. {
  937. combine(session, result);
  938. }
  939. return result;
  940. }