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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
chxuuid.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：49k
源码类别：

Symbian

开发平台：

Visual C++

chxuuid.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: chxuuid.cpp,v 1.7.32.3 2004/07/09 01:48:15 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer and/or licensor of the Original Code and owns the
  34.  * copyrights in the portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. //
  51. // CHXuuid class implementation
  52. //
  53. //
  54. //  This code derives from uuid.c from OSF DCE source
  55. /*
  56.  * 
  57.  * (c) Copyright 1989 OPEN SOFTWARE FOUNDATION, INC.
  58.  * (c) Copyright 1989 HEWLETT-PACKARD COMPANY
  59.  * (c) Copyright 1989 DIGITAL EQUIPMENT CORPORATION
  60.  * To anyone who acknowledges that this file is provided "AS IS"
  61.  * without any express or implied warranty:
  62.  *                 permission to use, copy, modify, and distribute this
  63.  * file for any purpose is hereby granted without fee, provided that
  64.  * the above copyright notices and this notice appears in all source
  65.  * code copies, and that none of the names of Open Software
  66.  * Foundation, Inc., Hewlett-Packard Company, or Digital Equipment
  67.  * Corporation be used in advertising or publicity pertaining to
  68.  * distribution of the software without specific, written prior
  69.  * permission.  Neither Open Software Foundation, Inc., Hewlett-
  70.  * Packard Company, nor Digital Equipment Corporation makes any
  71.  * representations about the suitability of this software for any
  72.  * purpose.
  73.  * 
  74.  */
  75.  
  76. #include "hxtypes.h"
  77. #ifdef _WINDOWS
  78. #define WIN32_LEAN_AND_MEAN
  79. #include <windows.h> // for HX_GET_TICK_COUNT
  80. #endif
  82. #include "hlxclib/string.h"
  83. // #include "hlxclib/stdio.h"
  84. #include "safestring.h"
  86. #include "hxstring.h"
  87. #include "hxresult.h"
  88. #include "hxassert.h"
  89. #include "hxrand.h"
  90. #include "chxuuid.h"
  91. #include "hxtick.h"
  92. #include "hxtime.h"
  93. #include "netbyte.h"
  94. #include "md5.h"
  96. #include <ctype.h>
  97. #if !defined(_VXWORKS) && !defined(_SYMBIAN) && !defined(_OPENWAVE)
  98. #include <memory.h>
  99. #endif
  100. #include <stdarg.h>
  103. #ifdef _WIN16
  104. #include <ctype.h>
  105. #include <memory.h>
  106. #endif
  108. #ifdef _WIN32
  109. #include <objbase.h>
  110. #endif
  112. #include "hxheap.h"
  113. #ifdef _DEBUG
  114. #undef HX_THIS_FILE
  115. static const char HX_THIS_FILE[] = __FILE__;
  116. #endif
  118. #if defined(_WIN16)
  119. // global definitons (scope: wsscanf.c)
  121. #ifdef ALLOW_RANGE
  122.    char szSBrackSet[] = " t-r]" ;  // use range-style list
  123. #else
  124.    char szSBrackSet[] = "tnvfr]" ;  // chars defined by isspace 
  125. #endif
  127. char szCBrackSet[] = "]" ;
  129. // constant definitions
  130. #define ALLOW_RANGE                        // allow "%[a-z]" - style 
  131.                                            // scansets
  133. #define LEFT_BRACKET  ('[' | ('a' - 'A'))  // 'lowercase' version
  135. #define ASCII         32                   // # of bytes needed to 
  136.                                            // hold 256 bits
  137. // macro definitions
  138. #define INC()            (++nCharCount, Inc( (LPSTR FAR *) &lpPtrBuffer ))
  139. #define UN_INC( chr )    (--nCharCount, UnInc( chr, (LPSTR FAR *) &lpPtrBuffer ))
  140. #define EAT_WHITE()      WhiteOut( (int FAR *) &nCharCount, (LPSTR FAR *) &lpPtrBuffer )
  141. #define HEXTODEC( chr )  HexToDec( chr )
  143. #define MUL10(x)         ( (((x)<<2) + (x))<<1 )
  145. typedef char _far *wva_list ;
  147. #define wva_start( ap, v )  (ap = (wva_list) &v + sizeof( v ))
  148. #define wva_arg( ap, t )    (((t _far *)(ap += sizeof( t )))[-1])
  149. #define wva_end( ap )       (ap = NULL)
  151. /************************************************************************
  152.  *  char NEAR HexToDec( char chChar )
  153.  *
  154.  *  Description:
  155.  *     HexToDec() convert hexadecimal to decimal equivalent.
  156.  *
  157.  ************************************************************************/
  159. char NEAR HexToDec( char chChar )
  160. {
  161.    return (isdigit( chChar ) ? chChar : (char) ((chChar & ~('a' - 'A')) - 'A' + 10 + '0')) ;
  163. } /* end of HexToDec() */
  165. /************************************************************************
  166.  *  char NEAR Inc( LPSTR FAR *lpPtrBuffer )
  167.  *
  168.  *  Description:
  169.  *     "Pops" a character from the buffer.
  170.  *
  171.  ************************************************************************/
  173. char NEAR Inc( LPSTR FAR *lpPtrBuffer )
  174. {
  175.    char  ch ;
  177.    ch = *((LPSTR) *lpPtrBuffer) ;
  178.    ((LPSTR&)(*lpPtrBuffer))++ ;
  180.    return ( ch ) ;
  182. } /* end of Inc() */
  184. /************************************************************************
  185.  *  VOID NEAR UnInc( char chChar, LPSTR FAR *lpPtrBuffer )
  186.  *
  187.  *  Description:
  188.  *     "Pushes" a characters back into the buffer.
  189.  *
  190.  ************************************************************************/
  192. VOID NEAR UnInc( char chChar, LPSTR FAR *lpPtrBuffer )
  193. {
  194.    ((LPSTR&)(*lpPtrBuffer))-- ;
  195.    *((LPSTR) *lpPtrBuffer) = chChar ;
  196.    
  197. } /* end of UnInc() */
  199. /************************************************************************
  200.  *  char NEAR WhiteOut( int *lpnCounter, LPSTR FAR *lpPtrBuffer )
  201.  *
  202.  *  Description:
  203.  *     Increments the string pointer while in white space.
  204.  *
  205.  ************************************************************************/
  207. char NEAR WhiteOut( int FAR *lpnCounter, LPSTR FAR *lpPtrBuffer )
  208. {
  209.    char  ch ;
  211.    while (isspace(ch = (++*lpnCounter, Inc( lpPtrBuffer )))) ;
  212.    return ( ch ) ;
  214. } /* end of WhiteOut() */
  216. /************************************************************************
  217.  *  int FAR _cdecl wsscanf( LPSTR lpBuffer, LPSTR lpFormat,
  218.  *                          LPSTR lpParms, ... )
  219.  *
  220.  *  Description:
  221.  *     Replacement function for sscanf().   Useable in DLLs (all
  222.  *     parameters are passed as FAR pointers.
  223.  *
  224.  ************************************************************************/
  226. int FAR _cdecl wsscanf( char* lpBuffer, char* lpFormat, ... )
  227. {
  228.    BYTE          bCoerceShort, bDoneFlag, bLongOne, bMatch, bNegative,
  229.                  bReject, bSuppress ;
  230.    BYTE FAR *    lpPtrScan ;
  231.    DWORD         dwNumber ;
  232.    LPSTR         lpPtrFormat, lpPtrBuffer ;
  233.    LPVOID FAR *  lpArgList;
  234.    LPVOID        lpPointer, lpStart ;
  235.    WORD          wHoldSeg ;
  236.    char          ch, chCom, chLast, chPrev, chRange, szTable[ ASCII ] ; /* Flawfinder: ignore */
  237.    int           nCount, nCharCount, nWidth, nWidthSet, nStarted ;
  239.    wva_list  lpParms;
  240.    
  241.    wva_start(lpParms, lpFormat);
  243.    lpArgList = (LPVOID FAR *) &lpParms ;
  245.    nCount = nCharCount = 0 ;
  246.    bMatch = FALSE ;
  247.    lpPtrFormat = lpFormat ;
  248.    lpPtrBuffer = lpBuffer ;
  250.    while (*lpPtrFormat)
  251.    {
  252.       if (isspace( *lpPtrFormat ))
  253.       {
  254.          UN_INC( EAT_WHITE() ) ;  // put first non-space char back
  255.          while (isspace(*++lpPtrFormat)) ;
  256.       }
  257.       if ('%' == *lpPtrFormat)
  258.       {
  259.          bCoerceShort = bDoneFlag = bLongOne = bNegative =
  260.          bReject = bSuppress = FALSE ;
  261.          nWidth = nWidthSet = nStarted = 0 ;
  262.          dwNumber = 0 ;
  263.          chPrev = 0 ;
  264.    
  265.          while (!bDoneFlag)
  266.          {
  267.             if (isdigit( chCom = *++lpPtrFormat ))
  268.             {
  269.                ++nWidthSet ;
  270.                nWidth = MUL10( nWidth ) + (chCom - '0') ;
  271.             }
  272.             else
  273.                switch (chCom)
  274.                {
  275.                   case 'F':
  276.                   case 'N':
  277.                      // FAR is only type of pointer in DLLs
  278.                      break ;
  279.    
  280.                   case 'h':
  281.                      ++bCoerceShort ;
  282.                      break ;
  283.             
  284.                   case 'l':
  285.                      ++bLongOne ;
  286.                      break ;
  287.    
  288.                   case '*':
  289.                      ++bSuppress ;
  290.                      break ;
  291.    
  292.                   default:
  293.                      ++bDoneFlag ;
  294.                      break ;
  295.                }
  296.          }
  297.    
  298.          if (!bSuppress)
  299.             /* ALL pointers are pushed as FAR */
  300.             lpPointer = (LPVOID) *lpArgList++ ;
  301.    
  302.          bDoneFlag = FALSE ;
  303.    
  304.          if ('n' != (chCom = (char)(*lpPtrFormat | ('a' - 'A'))))
  305.          {
  306.             if ('c' != chCom && LEFT_BRACKET != chCom)
  307.                ch = EAT_WHITE() ;
  308.             else
  309.                ch = INC() ;
  310.          }
  311.    
  312.          if (!nWidthSet || nWidth)
  313.          {
  314.             switch (chCom)
  315.             {
  316.                case 'c':
  317.                   if (!nWidthSet)
  318.                   {
  319.                      ++nWidthSet ;
  320.                      ++nWidth ;
  321.                   }
  322.                   lpPtrScan = (BYTE FAR *) szCBrackSet  ;
  323.                   --bReject ;
  324.                   goto ScanIt2 ;
  325.    
  326.                case 's':
  327.                   lpPtrScan = (BYTE FAR *) szSBrackSet ;
  328.                   --bReject ;
  329.                   goto ScanIt2 ;
  330.    
  331.                case LEFT_BRACKET:
  332.                   lpPtrScan = (BYTE FAR *) (++lpPtrFormat) ;
  333.                   if ('^' == *lpPtrScan)
  334.                   {
  335.                      ++lpPtrScan ;
  336.                      --bReject ;
  337.                   }
  338. ScanIt2:
  339.                   _fmemset( szTable, 0, ASCII ) ;
  340.    
  341. #ifdef ALLOW_RANGE
  342.                   if (LEFT_BRACKET == chCom)
  343.                      if (']' == *lpPtrScan)
  344.                      {
  345.                         chPrev = ']' ;
  346.                         ++lpPtrScan ;
  347.                         szTable[ ']' >> 3 ] = 1 << (']' & 7 ) ;
  348.                      }
  349.                   while (']' != *lpPtrScan)
  350.                   {
  351.                      chRange = *lpPtrScan++ ;
  352.                      if ('-' != chRange || !chPrev || ']' == *lpPtrScan)
  353.                         szTable[(chPrev = chRange) >> 3] |= 1 << (chRange & 7) ;
  354.                      else
  355.                      {
  356.                         // handle a-z type set
  357.                         chRange = *lpPtrScan++ ;
  358.                         if (chPrev < chRange)
  359.                            chLast = chRange ;
  360.                         else
  361.                         {
  362.                            chLast = chPrev ;
  363.                            chPrev = chRange ;
  364.                         }
  365.                         for (chRange = chPrev; chRange <= chLast; ++chRange)
  366.                            szTable[chRange >> 3] |= 1 << (chRange & 7) ;
  367.                         chPrev = 0 ;
  368.                      }
  369.                   }
  370. #else
  371.                   if (LEFT_BRACKET == chCom)
  372.                      if (']'  == *lpPtrScan)
  373.                      {
  374.                         ++lpPtrScan;
  375.                         szTable[(chPrev = ']') >> 3] |= 1 << (']' & 7) ;
  376.                      }
  377.                   while (']' != *lpPtrScan)
  378.                      szTable[ *lpPtrScan >> 3] |= 1 << (*lpPtrScan & 7) ;
  379. #endif
  380.                   if (!*lpPtrScan)
  381.                      goto ErrorReturn ;
  382.          
  383.                   if (LEFT_BRACKET == chCom)
  384.                      lpPtrFormat = (LPSTR)lpPtrScan ;
  385.             
  386.                   lpStart = lpPointer ;
  387.                   while ((!nWidthSet || nWidth--) &&
  388.                          ((szTable[ ch >> 3 ] ^ bReject) & (1 << (ch & 7))))
  389.                   {
  390.                      if (!bSuppress)
  391.                      {
  392.                         *(LPSTR)lpPointer = (char) ch ;
  393.                         ++((LPSTR&)lpPointer) ;
  394.                      }
  395.                      else
  396.                         // just indicate a match
  397.                         ++((LPSTR&)lpStart) ;
  398.                      ch = INC() ;
  399.                   }
  400.                   UN_INC( ch )  ;
  402.                   // make sure something has been match and, if assignment
  403.                   // is not suppressed, null-terminate output string if
  404.                   // chCom != c
  406.                   if (lpStart != lpPointer)
  407.                   {
  408.                      if (!bSuppress)
  409.                      {
  410.                         nCount++ ;
  411.                         if ('c' != chCom)
  412.                            // NULL terminate strings
  413.                            *(LPSTR) lpPointer = NULL ;
  414.                      }
  415.                   }
  416.                   else
  417.                      goto ErrorReturn ;
  419.                   break ;
  421.                case 'i':
  422.                   chCom = 'd' ;  // use 'd' as default
  423.          
  424.                case 'x':
  425.                   if ('-' == ch)
  426.                   {
  427.                      ++bNegative ;
  428.                      goto XIncWidth ;
  429.                   }
  430.                   else if ('+' == ch)
  431.                   {
  432. XIncWidth:
  433.                      if (!--nWidth && nWidthSet)
  434.                         ++bDoneFlag ;
  435.                      else
  436.                         ch = INC() ;
  437.                   }
  438.                   if ('0' == ch)
  439.                   {
  440.                      if ('x' == ((char) (ch = INC())) || 'X' == (char) ch)
  441.                      {
  442.                         ch = INC() ;
  443.                         chCom = 'x' ;
  444.                      }
  445.                      else
  446.                      {
  447.                         // scanning a hex number that starts with 0
  448.                         // push back the character currently in ch
  449.                         // and restore the 0
  450.    
  451.                         UN_INC( ch ) ;
  452.                         ch = '0' ;
  453.                      }
  454.                   }
  455.                   goto GetNum ;
  456.    
  457.                case 'p':
  458.                   // ALL pointers are FAR
  459.                   if (!bCoerceShort)
  460.                   {
  461.                      ++bLongOne ;
  462.                      chCom = 'F' ;  // indicates FAR
  463.                   }
  464.    
  465.                case 'o':
  466.                case 'u':
  467.                case 'd':
  468.                   if ('-' == ch)
  469.                   {
  470.                      ++bNegative ;
  471.                      goto dIncWidth ;
  472.                   }
  473.                   else if ('+' == ch)
  474.                   {
  475. dIncWidth:
  476.                      if (!--nWidth && nWidthSet)
  477.                         ++bDoneFlag ;
  478.                      else
  479.                         ch = INC() ;
  480.                   }
  481. GetNum:
  482.                   while (!bDoneFlag)
  483.                   {
  484.                      if ('x' == chCom || 'p' == chCom || 'F' == chCom)
  485.                      {
  486.                         if (isxdigit(ch))
  487.                         {
  488.                            dwNumber = (dwNumber << 4) ;
  489.                            ch = HEXTODEC( ch ) ;
  490.                         }
  491.                         else if ('F' == chCom)
  492.                         {
  493.                            if (nStarted)
  494.                            {
  495.                               if (':' == ch)
  496.                               {
  497.                                  wHoldSeg = LOWORD( dwNumber ) ;
  498.                                  dwNumber = 0 ;
  499.                                  nStarted = -1 ;
  500.                                  chCom = 'p' ; // switch to offset
  501.                                  ch = '0' ; // don't add ':'
  502.                               }
  503.                               else
  504.                               {
  505.                                  nStarted = 0 ;
  506.                                  ++bDoneFlag ;
  507.                               }
  508.                            }
  509.                            else
  510.                               ++bDoneFlag ;
  511.                         }
  512.                         else
  513.                            ++bDoneFlag ;
  514.                      }
  515.                      else if (isdigit( ch ))
  516.                      {
  517.                         if ('o' == chCom)
  518.                         {
  519.                            if ('8' > ch)
  520.                               dwNumber = (dwNumber << 3) ;
  521.                            else
  522.                               ++bDoneFlag ;
  523.                         }
  524.                         else
  525.                            // 'd' == chCom
  526.                            dwNumber = MUL10( dwNumber ) ;
  527.                      } 
  528.                      else
  529.                         ++bDoneFlag ;
  531.                      if (!bDoneFlag)
  532.                      {
  533.                         ++nStarted ;
  534.                         dwNumber += ch - '0' ;
  535.                         if (nWidthSet && !--nWidth)
  536.                            ++bDoneFlag ;
  537.                         else
  538.                            ch = INC() ;
  539.                      }
  540.                      else
  541.                         UN_INC( ch ) ;
  543.                   } // end of while
  544.    
  545.                   if ('p' == chCom && bLongOne)
  546.                      dwNumber = (dwNumber & (DWORD) 0x0000FFFF) |
  547.                                  ((DWORD) wHoldSeg) << 16 ;
  548. #if _WIN16   
  549. #pragma warning(disable : 4146) 
  550. #endif   
  551.                   if (bNegative)
  552.                      dwNumber = -dwNumber ;
  553. #if _WIN16   
  554. #pragma warning(default : 4146) 
  555. #endif
  556.                   if ('F' == chCom)
  557.                      nStarted = 0 ;
  558.                   if (nStarted)
  559.                   {
  560.                      if (!bSuppress)
  561.                      {
  562.                         ++nCount ;
  563. AssignNum:
  564.                         if (bLongOne)
  565.                            *(DWORD FAR *)lpPointer = dwNumber ;
  566.                         else
  567.                            *(WORD FAR *)lpPointer = LOWORD( dwNumber ) ;
  568.                      }
  569.                   }
  570.                   else
  571.                      goto ErrorReturn ;
  572.    
  573.                   break ;
  574.    
  575.                case 'n':
  576.                   dwNumber = nCharCount ;
  577.                   goto AssignNum ;
  578.    
  579.                default:
  580.                   if ((char)*lpPtrFormat != ch)
  581.                   {
  582.                      UN_INC( ch ) ;
  583.                      goto ErrorReturn ;
  584.                   }
  585.                   else
  586.                      bMatch-- ;
  587.    
  588.                   if (!bSuppress)
  589.                      // ALL pointers are FAR pointers
  590.                      --lpArgList ;
  591.    
  592.             } // end of switch
  594.             bMatch++ ;
  596.          } // end of while
  597.          else
  598.          {
  599.             UN_INC( ch ) ;
  600.             goto ErrorReturn ;
  601.          }
  602.          ++lpPtrFormat ;
  603.       }
  604.       else
  605.       {
  606.          // ('%' != *lpPtrFormat)
  607.          if ((char) *lpPtrFormat++ != (ch = INC()))
  608.          {
  609.             UN_INC( ch ) ;
  610.             goto ErrorReturn ;
  611.          }
  612.       }
  614.    } // end while (*lpPtrFormat)
  616. ErrorReturn:
  618.    wva_end(lpParms);
  620.    return nCount ;
  622. } /* end of wsscanf() */
  624. #endif // _WIN16
  626.  /*
  627.  * Internal structure of universal unique IDs (UUIDs).
  628.  *
  629.  * There are three "variants" of UUIDs that this code knows about.  The
  630.  * variant #0 is what was defined in the 1989 HP/Apollo Network Computing
  631.  * Architecture (NCA) specification and implemented in NCS 1.x and DECrpc
  632.  * v1.  Variant #1 is what was defined for the joint HP/DEC specification
  633.  * for the OSF (in DEC's "UID Architecture Functional Specification Version
  634.  * X1.0.4") and implemented in NCS 2.0, DECrpc v2, and OSF 1.0 DCE RPC.
  635.  * Variant #2 is defined by Microsoft.
  636.  *
  637.  * This code creates only variant #1 UUIDs.
  638.  * 
  639.  * The three UUID variants can exist on the same wire because they have
  640.  * distinct values in the 3 MSB bits of octet 8 (see table below).  Do
  641.  * NOT confuse the version number with these 3 bits.  (Note the distinct
  642.  * use of the terms "version" and "variant".) Variant #0 had no version
  643.  * field in it.  Changes to variant #1 (should any ever need to be made)
  644.  * can be accomodated using the current form's 4 bit version field.
  645.  * 
  646.  * The UUID record structure MUST NOT contain padding between fields.
  647.  * The total size = 128 bits.
  648.  *
  649.  * To minimize confusion about bit assignment within octets, the UUID
  650.  * record definition is defined only in terms of fields that are integral
  651.  * numbers of octets.
  652.  *
  653.  * Depending on the network data representation, the multi-octet unsigned
  654.  * integer fields are subject to byte swapping when communicated between
  655.  * dissimilar endian machines.  Note that all three UUID variants have
  656.  * the same record structure; this allows this byte swapping to occur.
  657.  * (The ways in which the contents of the fields are generated can and
  658.  * do vary.)
  659.  *
  660.  * The following information applies to variant #1 UUIDs:
  661.  *
  662.  * The lowest addressed octet contains the global/local bit and the
  663.  * unicast/multicast bit, and is the first octet of the address transmitted
  664.  * on an 802.3 LAN.
  665.  *
  666.  *  NOTE:  In the PN version the node field may not be the 802.3 NIC ID
  667.  * But is a machine ID generated on construction if not specified.
  668.  * The method for generating the machine ID may vary and is documented
  669.  * in the GenerateMachineID method.
  670.  *
  671.  * The adjusted time stamp is split into three fields, and the clockSeq
  672.  * is split into two fields.
  673.  *
  674.  * |<------------------------- 32 bits -------------------------->|
  675.  *
  676.  * +--------------------------------------------------------------+
  677.  * |                     low 32 bits of time                      |  0-3  .time_low
  678.  * +-------------------------------+-------------------------------
  679.  * |     mid 16 bits of time       |  4-5               .time_mid
  680.  * +-------+-----------------------+
  681.  * | vers. |   hi 12 bits of time  |  6-7               .time_hi_and_version
  682.  * +-------+-------+---------------+
  683.  * |Res|  clkSeqHi |  8                                 .clock_seq_hi_and_reserved
  684.  * +---------------+
  685.  * |   clkSeqLow   |  9                                 .clock_seq_low
  686.  * +---------------+----------...-----+
  687.  * |            node ID               |  8-16           .node
  688.  * +--------------------------...-----+
  689.  *
  690.  * --------------------------------------------------------------------------
  691.  *
  692.  * The structure layout of all three UUID variants is fixed for all time.
  693.  * I.e., the layout consists of a 32 bit int, 2 16 bit ints, and 8 8
  694.  * bit ints.  The current form version field does NOT determine/affect
  695.  * the layout.  This enables us to do certain operations safely on the
  696.  * variants of UUIDs without regard to variant; this increases the utility
  697.  * of this code even as the version number changes (i.e., this code does
  698.  * NOT need to check the version field).
  699.  *
  700.  * The "Res" field in the octet #8 is the so-called "reserved" bit-field
  701.  * and determines whether or not the uuid is a old, current or other
  702.  * UUID as follows:
  703.  *
  704.  *      MS-bit  2MS-bit  3MS-bit      Variant
  705.  *      ---------------------------------------------
  706.  *         0       x        x       0 (NCS 1.5)
  707.  *         1       0        x       1 (DCE 1.0 RPC)
  708.  *         1       1        0       2 (Microsoft)
  709.  *         1       1        1       unspecified
  710.  *
  711.  *  NOTE:   To identify the PN version from other versions we use the 
  712.  * 111 unspecified variant.
  713.  *
  714.  * --------------------------------------------------------------------------
  715.  *
  716.  */
  717. /****************************************************************************
  718.  *
  719.  * global data declarations
  720.  *
  721.  ****************************************************************************/
  723. static const uuid_tt uuid_g_nil_uuid = { 0, 0, 0, 0, 0, 0 };
  724. static const uuid_tt uuid_nil = { 0, 0, 0, 0, 0, 0 };
  726. /*
  727.  * Check the reserved bits to make sure the UUID is of the known structure.
  728.  */
  730. /*
  731.  * defines for time calculations
  732.  */
  733. #ifndef UUID_C_100NS_PER_SEC
  734. #define UUID_C_100NS_PER_SEC            10000000
  735. #endif
  737. #ifndef UUID_C_100NS_PER_MSEC
  738. #define UUID_C_100NS_PER_MSEC           10000
  739. #endif
  741. #define HX_GET_PID() 0xC0C0
  743.  /*
  744.  * UADD_UVLW_2_UVLW - macro to add two unsigned 64-bit long integers
  745.  *                      (ie. add two unsigned 'very' long words)
  746.  *
  747.  * Important note: It is important that this macro accommodate (and it does)
  748.  *                 invocations where one of the addends is also the sum.
  749.  *
  750.  * This macro was snarfed from the DTSS group and was originally:
  751.  *
  752.  * UTCadd - macro to add two UTC times
  753.  *
  754.  * add lo and high order longword separately, using sign bits of the low-order
  755.  * longwords to determine carry.  sign bits are tested before addition in two
  756.  * cases - where sign bits match. when the addend sign bits differ the sign of
  757.  * the result is also tested:
  758.  *
  759.  *        sign            sign
  760.  *      addend 1        addend 2        carry?
  761.  *
  762.  *          1               1            TRUE
  763.  *          1               0            TRUE if sign of sum clear
  764.  *          0               1            TRUE if sign of sum clear
  765.  *          0               0            FALSE
  766.  */
  767. #define UADD_UVLW_2_UVLW(add1, add2, sum)                               
  768.     if (!(((add1)->lo&0x80000000UL) ^ ((add2)->lo&0x80000000UL)))           
  769.     {                                                                   
  770.         if (((add1)->lo&0x80000000UL))                                    
  771.         {                                                               
  772.             (sum)->lo = (add1)->lo + (add2)->lo ;                       
  773.             (sum)->hi = (add1)->hi + (add2)->hi+1 ;                     
  774.         }                                                               
  775.         else                                                            
  776.         {                                                               
  777.             (sum)->lo  = (add1)->lo + (add2)->lo ;                      
  778.             (sum)->hi = (add1)->hi + (add2)->hi ;                       
  779.         }                                                               
  780.     }                                                                   
  781.     else                                                                
  782.     {                                                                   
  783.         (sum)->lo = (add1)->lo + (add2)->lo ;                           
  784.         (sum)->hi = (add1)->hi + (add2)->hi ;                           
  785.         if (!((sum)->lo&0x80000000UL))                                    
  786.             (sum)->hi++ ;                                               
  787.     }
  790. /*
  791.  * UADD_ULW_2_UVLW - macro to add a 32-bit unsigned integer to
  792.  *                   a 64-bit unsigned integer
  793.  *
  794.  * Note: see the UADD_UVLW_2_UVLW() macro
  795.  *
  796.  */
  797. #define UADD_ULW_2_UVLW(add1, add2, sum)                                
  798. {                                                                       
  799.     (sum)->hi = (add2)->hi;                                             
  800.     if ((*add1) & (add2)->lo & 0x80000000UL)                              
  801.     {                                                                   
  802.         (sum)->lo = (*add1) + (add2)->lo;                               
  803.         (sum)->hi++;                                                    
  804.     }                                                                   
  805.     else                                                                
  806.     {                                                                   
  807.         (sum)->lo = (*add1) + (add2)->lo;                               
  808.         if (!((sum)->lo & 0x80000000UL))                                  
  809.         {                                                               
  810.             (sum)->hi++;                                                
  811.         }                                                               
  812.     }                                                                   
  813. }
  816. /*
  817.  * UADD_UW_2_UVLW - macro to add a 16-bit unsigned integer to
  818.  *                   a 64-bit unsigned integer
  819.  *
  820.  * Note: see the UADD_UVLW_2_UVLW() macro
  821.  *
  822.  */
  823. #define UADD_UW_2_UVLW(add1, add2, sum)                                 
  824. {                                                                       
  825.     (sum)->hi = (add2)->hi;                                             
  826.     if ((add2)->lo & 0x80000000UL)                                        
  827.     {                                                                   
  828.         (sum)->lo = (*add1) + (add2)->lo;                               
  829.         if (!((sum)->lo & 0x80000000UL))                                  
  830.         {                                                               
  831.             (sum)->hi++;                                                
  832.         }                                                               
  833.     }                                                                   
  834.     else                                                                
  835.     {                                                                   
  836.         (sum)->lo = (*add1) + (add2)->lo;                               
  837.     }                                                                   
  838. }
  840. CHXuuid::CHXuuid()
  841. {
  842.     uuid_ttime_t         t;
  843.     UINT16          *seedp, seed=0;
  844.     /*
  845.      * Generating our 'seed' value
  846.      *
  847.      * We start with the current time, but, since the resolution of clocks is
  848.      * system hardware dependent (eg. Ultrix is 10 msec.) and most likely
  849.      * coarser than our resolution (10 usec) we 'mixup' the bits by xor'ing
  850.      * all the bits together.  This will have the effect of involving all of
  851.      * the bits in the determination of the seed value while remaining system
  852.      * independent.  Then for good measure to ensure a unique seed when there
  853.      * are multiple processes creating UUID's on a system, we add in the PID.
  854.      */
  855.     GetOSTime(&t);
  856.     seedp = (UINT16 *)(&t);
  857.     seed ^= *seedp++;
  858.     seed ^= *seedp++;
  859.     seed ^= *seedp++;
  860.     seed ^= *seedp++;
  861.     seed += HX_GET_PID();
  862.     /*
  863.      * init the random number generator
  864.      */
  865.     m_pRand = new CMultiplePrimeRandom(seed);
  867.     GetOSTime (&m_time_last);
  869.     m_time_adjust = 0;
  870.     m_clock_seq = TrueRandom();
  872.     GenerateMachineID();
  873. }
  875. CHXuuid::CHXuuid(UCHAR machineID[MACHINEID_SIZE])
  876. {
  877.     uuid_ttime_t         t;
  878.     UINT16          *seedp, seed=0;
  879.     /*
  880.      * Generating our 'seed' value
  881.      *
  882.      * We start with the current time, but, since the resolution of clocks is
  883.      * system hardware dependent (eg. Ultrix is 10 msec.) and most likely
  884.      * coarser than our resolution (10 usec) we 'mixup' the bits by xor'ing
  885.      * all the bits together.  This will have the effect of involving all of
  886.      * the bits in the determination of the seed value while remaining system
  887.      * independent.  Then for good measure to ensure a unique seed when there
  888.      * are multiple processes creating UUID's on a system, we add in the PID.
  889.      */
  890.     GetOSTime(&t);
  891.     seedp = (UINT16 *)(&t);
  892.     seed ^= *seedp++;
  893.     seed ^= *seedp++;
  894.     seed ^= *seedp++;
  895.     seed ^= *seedp++;
  896.     seed += HX_GET_PID();
  897.     /*
  898.      * init the random number generator
  899.      */
  900.     m_pRand = new CMultiplePrimeRandom(seed);
  902.     GetOSTime (&m_time_last);
  904.     m_time_adjust = 0;
  905.     m_clock_seq = TrueRandom();
  907.     memcpy(m_machineID, machineID, sizeof(machineID)); /* Flawfinder: ignore */
  908. }
  910. CHXuuid::~CHXuuid()
  911. {
  912.     if (m_pRand != NULL)
  913.     {
  914. delete m_pRand;
  915.     }
  916. }
  919. //
  920. // Changed this routine to avoid unaligned access errors on RISC
  921. // processors. -dbrumley 10-15-98 
  922. //
  923. void CHXuuid::GenerateMachineID()
  924. {
  925.     ULONG32 rand;
  926.     UINT16  tick;
  928.     rand = m_pRand->GetRandomNumber();
  929.     tick = (UINT16)HX_GET_TICKCOUNT();
  930.     memcpy(m_machineID, (UCHAR*)&rand, sizeof rand); /* Flawfinder: ignore */
  931.     memcpy(&m_machineID[4], (UCHAR*)&tick, sizeof tick); /* Flawfinder: ignore */
  932. }
  935. /////////////////////////////////////////////////////////////////////////
  936. // Method:
  937. // CHXuuid::GetUuid
  938. // Purpose:
  939. //      Loose implementation of version 3 UUID (creation of name-based UUID).  This
  940. //      algorithm outputs the result of an MD5 hash of an internally generated 
  941. //      namespace (GUID) and a name (input buffer).  Unlike the version 3 UUID algorithm, 
  942. //      the namespace is essentially generated at random, so UUIDs created from 
  943. //      the same name at any point of time have a very high probability of being different.
  945. HX_RESULT CHXuuid::GetUuid(uuid_tt* pUuid, const UCHAR* pBuffer, UINT32 ulBufferSize)
  946. {
  947.     // Validate params
  948.     HX_ASSERT(pUuid && pBuffer && ulBufferSize);
  949.     if (!pUuid || !pBuffer || !ulBufferSize)
  950.         return HXR_INVALID_PARAMETER;
  951.     
  952.     // Get a UUID to use as a namespace ID
  953.     HX_RESULT res = GetUuid(pUuid);
  954.     
  955.     if (SUCCEEDED(res))
  956.     {
  957.         md5_state_t ctx;
  958.         md5_init(&ctx);
  959.         UCHAR aHashBuffer[20];
  960.         memset(aHashBuffer, 0, 20);
  962.         // MD5-hash the namespace ID with the name buffer
  963.         md5_append(&ctx, (const UCHAR*)pUuid, sizeof(uuid_tt));
  964.         md5_append(&ctx, (const UCHAR*)pBuffer, ulBufferSize);                
  965.         md5_finish(aHashBuffer, &ctx);
  967.         // Copy the 128-bit hash result into the UUID.  Memcpy one var at a time
  968.         // in case the struct is padded.
  969.         memcpy(&pUuid->time_low, aHashBuffer, sizeof(pUuid->time_low)); /* Flawfinder: ignore */
  970.         memcpy(&pUuid->time_mid, aHashBuffer+4, sizeof(pUuid->time_mid)); /* Flawfinder: ignore */
  971.         memcpy(&pUuid->time_hi_and_version, aHashBuffer+6, sizeof(pUuid->time_hi_and_version)); /* Flawfinder: ignore */
  972.         memcpy(&pUuid->clock_seq_hi_and_reserved, aHashBuffer+8, sizeof(pUuid->clock_seq_hi_and_reserved)); /* Flawfinder: ignore */
  973.         memcpy(&pUuid->clock_seq_low, aHashBuffer+9, sizeof(pUuid->clock_seq_low)); /* Flawfinder: ignore */
  974.         memcpy(&pUuid->node, aHashBuffer+10, sizeof(pUuid->node)); /* Flawfinder: ignore */
  975.     }
  977.     return res;
  978. }
  980. HX_RESULT CHXuuid::GetUuid(uuid_tt* uuid)
  981. {
  982.     HX_RESULT theErr = HXR_OK;
  984. #if defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC)
  985.     if(CoCreateGuid((GUID*)uuid) != S_OK)
  986. theErr = HXR_FAILED;
  987. #else
  989.     BOOL got_no_time = FALSE;
  991.     do
  992.     {
  993.         /*
  994.          * get the current time
  995.          */
  996.         GetOSTime (&m_time_now);
  998.         /*
  999.          * do stuff like:
  1000.          *
  1001.          *  o check that our clock hasn't gone backwards and handle it
  1002.          *    accordingly with clock_seq
  1003.          *  o check that we're not generating uuid's faster than we
  1004.          *    can accommodate with our time_adjust fudge factor
  1005.          */
  1006.         switch (TimeCmp(&m_time_now, &m_time_last))
  1007.         {
  1008.             case uuid_e_less_than:
  1009.                 NewClockSeq(m_clock_seq);
  1010.                 m_time_adjust = 0;
  1011. got_no_time = FALSE;
  1012.                 break;
  1013.             case uuid_e_greater_than:
  1014.                 m_time_adjust = 0;
  1015. got_no_time = FALSE;
  1016.                 break;
  1017.             case uuid_e_equal_to:
  1018.                 if (m_time_adjust == MAX_TIME_ADJUST)
  1019.                 {
  1020.                     /*
  1021.                      * spin your wheels while we wait for the clock to tick
  1022.                      */
  1023.                     got_no_time = TRUE;
  1024.                 }
  1025.                 else
  1026.                 {
  1027.                     m_time_adjust++;
  1028.     got_no_time = FALSE;
  1029.                 }
  1030.                 break;
  1031.             default:
  1032.                 theErr = HXR_FAILED;
  1033.                 return theErr;
  1034.         }
  1035.     } while (got_no_time);
  1037.     m_time_last.lo = m_time_now.lo;
  1038.     m_time_last.hi = m_time_now.hi;
  1040.     if (m_time_adjust != 0)
  1041.     {
  1042.         UADD_UW_2_UVLW (&m_time_adjust, &m_time_now, &m_time_now);
  1043.     }
  1045.     /*
  1046.      * now construct a uuid with the information we've gathered
  1047.      * plus a few constants
  1048.      */
  1049.     uuid->time_low = m_time_now.lo;
  1050.     uuid->time_mid = (UINT16)(m_time_now.hi & TIME_MID_MASK);
  1052.     uuid->time_hi_and_version = (UINT16)
  1053.         ((m_time_now.hi & TIME_HIGH_MASK) >> TIME_HIGH_SHIFT_COUNT);
  1054.     uuid->time_hi_and_version |= UUID_VERSION_BITS;
  1056.     uuid->clock_seq_low = HX_SAFEINT(m_clock_seq & CLOCK_SEQ_LOW_MASK);
  1057.     uuid->clock_seq_hi_and_reserved =
  1058.         HX_SAFEINT((m_clock_seq & CLOCK_SEQ_HIGH_MASK) >> CLOCK_SEQ_HIGH_SHIFT_COUNT);
  1060.     uuid->clock_seq_hi_and_reserved |= UUID_RESERVED_BITS;
  1062.     memcpy (uuid->node, m_machineID, sizeof (m_machineID)); /* Flawfinder: ignore */
  1064. #endif // _WIN32
  1066.     return theErr;
  1067. }
  1069. /*
  1070. **++
  1071. **
  1072. **  ROUTINE NAME:       uuid_to_string
  1073. **
  1074. **--
  1075. **/
  1077. HX_RESULT CHXuuid::HXUuidToString(const uuid_tt* uuid, CHXString* uuid_string)
  1078. {
  1079.     HX_RESULT theErr = HXR_OK;
  1081.     /*
  1082.      * don't do anything if the output argument is NULL
  1083.      */
  1084.     if (uuid_string == NULL)
  1085.     {
  1086.         return theErr;
  1087.     }
  1089.     char *theBuff = uuid_string->GetBuffer(UUID_C_UUID_STRING_MAX);
  1091.     SafeSprintf(theBuff, UUID_C_UUID_STRING_MAX,
  1092.                 "%.4x%.4x-%.4x-%.4x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x",
  1093. HIWORD(uuid->time_low), LOWORD(uuid->time_low), uuid->time_mid, 
  1094. uuid->time_hi_and_version, uuid->clock_seq_hi_and_reserved, uuid->clock_seq_low,
  1095. (UCHAR) uuid->node[0], (UCHAR) uuid->node[1],
  1096. (UCHAR) uuid->node[2], (UCHAR) uuid->node[3],
  1097. (UCHAR) uuid->node[4], (UCHAR) uuid->node[5]);
  1099.     uuid_string->ReleaseBuffer();
  1101.     return theErr;
  1102. }
  1104. /*
  1105. **++
  1106. **
  1107. **  ROUTINE NAME:       uuid_from_string
  1108. **
  1109. **--
  1110. **/
  1112. static int ParseIIDString(
  1113.     const char* uuid_string,
  1114.     long&       time_low,
  1115.     int&        time_mid,
  1116.     int&        time_hi_and_version,
  1117.     int&        clock_seq_hi_and_reserved,
  1118.     int&        clock_seq_low,
  1119.     int*        node /*[6]*/)
  1120. {
  1121.     int count = 0;
  1122. #if defined(_OPENWAVE)
  1123. // XXXSAB Untested...
  1125.     // No sscanf()...
  1126.     const char* pCur = uuid_string;
  1127.     char* pEnd = NULL;
  1128.     unsigned long curVal;
  1130.     // Skip leading white space
  1131.     pCur += strspn(pCur, " t");
  1133.     curVal = strtoul(pCur, &pEnd, 16);
  1134.     if (pEnd == (pCur + 8) && *pEnd == '-') time_low = curVal;
  1135.     else return count;
  1136.     pCur += 8; ++count;
  1138.     curVal = strtoul(pCur, &pEnd, 16);
  1139.     if (pEnd == (pCur + 4) && *pEnd == '-') time_mid = curVal;
  1140.     else return count;
  1141.     pCur += 4; ++count;
  1143.     curVal = strtoul(pCur, &pEnd, 16);
  1144.     if (pEnd == (pCur + 4) && *pEnd == '-') time_hi_and_version = curVal;
  1145.     else return count;
  1146.     pCur += 4; ++count;
  1148.     curVal = strtoul(pCur, &pEnd, 16);
  1149.     if (pEnd == (pCur + 4) && *pEnd == '-')
  1150.     {
  1151.         clock_seq_hi_and_reserved = (curVal & 0xff00) >> 8;
  1152.         clock_seq_low = curVal & 0xff;
  1153.     }
  1154.     else return count;
  1155.     pCur += 4; count += 2;
  1157.     curVal = strtoul(pCur, &pEnd, 16);
  1158.     if (pEnd == (pCur + 6) && *(pEnd+strspn(pEnd, " t")) == 0)
  1159.     {
  1160.         for (int i = 5; i >= 0; ++i, curVal = curVal >> 8)
  1161.         {
  1162.             node[i] = curVal & 0xff;
  1163.         }
  1164.     }
  1165.     else return count;
  1166.     pCur += 4; count += 6;
  1168. #else
  1169.     count = sscanf(uuid_string, "%8lx-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x",
  1170.                    &time_low,
  1171.                    &time_mid,
  1172.                    &time_hi_and_version,
  1173.                    &clock_seq_hi_and_reserved,
  1174.                    &clock_seq_low,
  1175.                    &node[0], &node[1], &node[2], &node[3], &node[4], &node[5]);
  1176. #endif
  1177.     return count;
  1178. }
  1180. HX_RESULT CHXuuid::HXUuidFromString(const char* uuid_string, uuid_tt* uuid)
  1181. {
  1182.     HX_RESULT theErr = HXR_OK;
  1184.     uuid_tt             uuid_new;       /* used for sscanf for new uuid's */
  1185.     uuid_p_t            uuid_ptr=0;     /* pointer to correct uuid (old/new) */
  1186.     int                 i;
  1188.     /*
  1189.      * If a NULL pointer or empty string, give the nil UUID.
  1190.      */
  1191.     if (uuid_string == NULL || *uuid_string == '')
  1192.     {
  1193. memcpy (uuid, &uuid_g_nil_uuid, sizeof *uuid); /* Flawfinder: ignore */
  1194. return theErr;
  1195.     }
  1197.     /*
  1198.      * check to see that the string length is right at least
  1199.      */
  1200.     if (strlen ((char *) uuid_string) != UUID_C_UUID_STRING_MAX - 1)
  1201.     {
  1202.         theErr = HXR_FAILED;
  1203.         return theErr;
  1204.     }
  1206.     /*
  1207.      * check for a new uuid
  1208.      */
  1209.     if (uuid_string[8] == '-')
  1210.     {
  1211.         long    time_low;
  1212.         int     time_mid;
  1213.         int     time_hi_and_version;
  1214.         int     clock_seq_hi_and_reserved;
  1215.         int     clock_seq_low;
  1216.         int     node[6];
  1218. // VC1.5's runtime library(lddcew.lib) doesn't have sscanf()!!
  1219. #if defined(_WIN16)
  1220. i = wsscanf((char *) uuid_string, "%8lx-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x",
  1221.     (long FAR *)&time_low,
  1222.     (int FAR *)&time_mid,
  1223.     (int FAR *)&time_hi_and_version,
  1224.     (int FAR *)&clock_seq_hi_and_reserved,
  1225.     (int FAR *)&clock_seq_low,
  1226.     (int FAR *)&node[0], (int FAR *)&node[1], (int FAR *)&node[2], 
  1227.     (int FAR *)&node[3], (int FAR *)&node[4], (int FAR *)&node[5]);
  1228. #else
  1229.         i = ParseIIDString(
  1230.             uuid_string,
  1231.             time_low,
  1232.             time_mid,
  1233.             time_hi_and_version,
  1234.             clock_seq_hi_and_reserved,
  1235.             clock_seq_low,
  1236.             node);
  1238. #ifdef Commented_out_code_20030421_114057
  1239.         i = sscanf((char *) uuid_string, "%8lx-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x",
  1240.             &time_low,
  1241.             &time_mid,
  1242.             &time_hi_and_version,
  1243.             &clock_seq_hi_and_reserved,
  1244.             &clock_seq_low,
  1245.             &node[0], &node[1], &node[2], &node[3], &node[4], &node[5]);
  1246. #endif /* Commented_out_code_20030421_114057 */
  1247. #endif
  1249.         /*
  1250.          * check that sscanf worked
  1251.          */
  1252.         if (i != UUID_ELEMENTS_NUM)
  1253.         {
  1254.             theErr = HXR_FAILED;
  1255.             return theErr;
  1256.         }
  1258.         /*
  1259.          * note that we're going through this agony because scanf is defined to
  1260.          * know only to scan into "int"s or "long"s.
  1261.          */
  1262.         uuid_new.time_low                   = time_low;
  1263.         uuid_new.time_mid                   = time_mid;
  1264.         uuid_new.time_hi_and_version        = time_hi_and_version;
  1265.         uuid_new.clock_seq_hi_and_reserved  = clock_seq_hi_and_reserved;
  1266.         uuid_new.clock_seq_low              = clock_seq_low;
  1267.         uuid_new.node[0]                    = node[0];
  1268.         uuid_new.node[1]                    = node[1];
  1269.         uuid_new.node[2]                    = node[2];
  1270.         uuid_new.node[3]                    = node[3];
  1271.         uuid_new.node[4]                    = node[4];
  1272.         uuid_new.node[5]                    = node[5];
  1274.         /*
  1275.          * point to the correct uuid
  1276.          */
  1277.         uuid_ptr = &uuid_new;
  1278.     }
  1280.     /*
  1281.      * copy the uuid to user
  1282.      */
  1283.     memcpy(uuid, uuid_ptr, sizeof (uuid_tt)); /* Flawfinder: ignore */
  1285.     return theErr;
  1286. }
  1289. /*
  1290. **++
  1291. **
  1292. **  ROUTINE NAME:       uuid_from_string
  1293. **
  1294. **--
  1295. **/
  1297. HX_RESULT CHXuuid::HXPack(UINT8* pBuffer, uuid_p_t uuid)
  1298. {
  1299.     uuid_p_t uuidPacket = (uuid_p_t) pBuffer;
  1301.     *uuidPacket = *uuid;
  1302.     uuidPacket->time_low = DwToNet(uuid->time_low);
  1303.     uuidPacket->time_mid = WToNet(uuid->time_mid);
  1304.     uuidPacket->time_hi_and_version = WToNet(uuid->time_hi_and_version);
  1306.     return HXR_OK;
  1307. }
  1310. /*
  1311. **++
  1312. **
  1313. **  ROUTINE NAME:       uuid_from_string
  1314. **
  1315. **--
  1316. **/
  1318. HX_RESULT CHXuuid::HXUnpack(uuid_p_t uuid, UINT8* pBuffer)
  1319. {
  1320.     uuid_p_t uuidPacket = (uuid_p_t) pBuffer;
  1322.     *uuid = *uuidPacket;
  1323.     uuid->time_low = DwToHost(uuidPacket->time_low);
  1324.     uuid->time_mid = WToHost(uuidPacket->time_mid);
  1325.     uuid->time_hi_and_version = WToHost(uuidPacket->time_hi_and_version);
  1327.     return HXR_OK;
  1328. }
  1330. /*
  1331. **++
  1332. **
  1333. **  ROUTINE NAME:       uuid_equal
  1334. **
  1335. **--
  1336. **/
  1338. BOOL CHXuuid::HXIsEqual(uuid_p_t uuid1, uuid_p_t uuid2)
  1339. {
  1340.     /*
  1341.      * Note: This used to be a memcmp(), but changed to a field-by-field compare
  1342.      * because of portability problems with alignment and garbage in a UUID.
  1343.      */
  1344.     if ((uuid1->time_low == uuid2->time_low) && 
  1345. (uuid1->time_mid == uuid2->time_mid) &&
  1346. (uuid1->time_hi_and_version == uuid2->time_hi_and_version) && 
  1347. (uuid1->clock_seq_hi_and_reserved == uuid2->clock_seq_hi_and_reserved) &&
  1348. (uuid1->clock_seq_low == uuid2->clock_seq_low) &&
  1349. (memcmp(uuid1->node, uuid2->node, 6) == 0))
  1350.     {
  1351. return ( TRUE );
  1352.     }
  1353.     else
  1354.     {
  1355.         return (FALSE);
  1356.     }
  1357. }
  1360. /*****************************************************************************
  1361.  *
  1362.  *  LOCAL MATH PROCEDURES - math procedures used internally by the UUID module
  1363.  *
  1364.  ****************************************************************************/
  1366. /*
  1367. ** T I M E _ C M P
  1368. **
  1369. ** Compares two UUID times (64-bit UTC values)
  1370. **/
  1371. uuid_compval_t CHXuuid::TimeCmp(uuid_ttime_p_t time1, uuid_ttime_p_t time2)
  1372. {
  1373.     /*
  1374.      * first check the hi parts
  1375.      */
  1376.     if (time1->hi < time2->hi) return (uuid_e_less_than);
  1377.     if (time1->hi > time2->hi) return (uuid_e_greater_than);
  1379.     /*
  1380.      * hi parts are equal, check the lo parts
  1381.      */
  1382.     if (time1->lo < time2->lo) return (uuid_e_less_than);
  1383.     if (time1->lo > time2->lo) return (uuid_e_greater_than);
  1385.     return (uuid_e_equal_to);
  1386. }
  1388. /*
  1389. **  UnsignedExtendedMultiply
  1390. **
  1391. **  Functional Description:
  1392. **        32-bit unsigned quantity * 32-bit unsigned quantity
  1393. **        producing 64-bit unsigned result. This routine assumes
  1394. **        long's contain at least 32 bits. It makes no assumptions
  1395. **        about byte orderings.
  1396. **
  1397. **  Inputs:
  1398. **
  1399. **        u, v       Are the numbers to be multiplied passed by value
  1400. **
  1401. **  Outputs:
  1402. **
  1403. **        prodPtr    is a pointer to the 64-bit result
  1404. **
  1405. **  Note:
  1406. **        This algorithm is taken from: "The Art of Computer
  1407. **        Programming", by Donald E. Knuth. Vol 2. Section 4.3.1
  1408. **        Pages: 253-255.
  1409. **--
  1410. **/
  1411. void CHXuuid::UnsignedExtendedMultiply(ULONG32 u,ULONG32 v, unsigned64_t* prodPtr)
  1412. {
  1413.     /*
  1414.      * following the notation in Knuth, Vol. 2
  1415.      */
  1416.     ULONG32      uuid1, uuid2, v1, v2, temp;
  1418.     uuid1 = u >> 16;
  1419.     uuid2 = u & 0xffff;
  1420.     v1 = v >> 16;
  1421.     v2 = v & 0xffff;
  1423.     temp = uuid2 * v2;
  1424.     prodPtr->lo = temp & 0xffff;
  1425.     temp = uuid1 * v2 + (temp >> 16);
  1426.     prodPtr->hi = temp >> 16;
  1427.     temp = uuid2 * v1 + (temp & 0xffff);
  1428.     prodPtr->lo += (temp & 0xffff) << 16;
  1429.     prodPtr->hi += uuid1 * v1 + (temp >> 16);
  1430. }
  1432. UINT16 CHXuuid::TrueRandom()
  1433. {
  1434.     ULONG32 nRand = m_pRand->GetRandomNumber(); 
  1435.     return (UINT16)(HI_WORD(nRand) ^ (nRand & RAND_MASK));
  1436. }
  1439. /*****************************************************************************
  1440.  *
  1441.  *  LOCAL PROCEDURES - procedures used staticly by the UUID module
  1442.  *
  1443.  ****************************************************************************/
  1445. /*
  1446. ** N E W _ C L O C K _ S E Q
  1447. **
  1448. ** Ensure *clkseq is up-to-date
  1449. **
  1450. ** Note: clock_seq is architected to be 14-bits (unsigned) but
  1451. **       I've put it in here as 16-bits since there isn't a
  1452. **       14-bit unsigned integer type (yet)
  1453. **/
  1455. void CHXuuid::NewClockSeq(UINT16& clkseq)
  1456. {
  1457.     /*
  1458.      * A clkseq value of 0 indicates that it hasn't been initialized.
  1459.      */
  1460.     if (clkseq == 0)
  1461.     {
  1462.         /*
  1463.          * with a volatile clock, we always init to a random number
  1464.          */
  1465.         clkseq = (UINT16) m_pRand->GetRandomNumber();
  1466.     }
  1468.     CLOCK_SEQ_BUMP (&clkseq);
  1469.     if (clkseq == 0)
  1470.     {
  1471.         clkseq = clkseq + 1;
  1472.     }
  1473. }
  1476. /*
  1477.  *  Define constant designation difference in Unix and DTSS base times:
  1478.  *  DTSS UTC base time is October 15, 1582.
  1479.  *  Unix base time is January 1, 1970.
  1480.  */
  1481. #define uuid_c_os_base_time_diff_lo     0x13814000
  1482. #define uuid_c_os_base_time_diff_hi     0x01B21DD2
  1484. /*
  1485.  * U U I D _ _ G E T _ O S _ T I M E
  1486.  *
  1487.  * Get OS time - contains platform-specific code.
  1488.  */
  1489.  
  1490. void CHXuuid::GetOSTime(uuid_ttime_t * uuid_ttime)
  1491. {
  1492.     HXTime tv;
  1493.     unsigned64_t        utc,
  1494.                         usecs,
  1495.                         os_basetime_diff;
  1497.     /*
  1498.      * Fill out the HXTime struct with the current time
  1499.      */
  1500.     gettimeofday(&tv, NULL);
  1502.     /*
  1503.      * Multiply the number of seconds by the number clunks 
  1504.      */
  1505.     UnsignedExtendedMultiply ((long) tv.tv_sec, UUID_C_100NS_PER_SEC, &utc);
  1507.     /*
  1508.      * Multiply the number of milliseconds by the number clunks 
  1509.      * and add to the seconds
  1510.      */
  1511.     UnsignedExtendedMultiply ((long) tv.tv_usec / 1000, UUID_C_100NS_PER_MSEC, &usecs);
  1512.     UADD_UVLW_2_UVLW (&usecs, &utc, &utc);
  1514.     /*
  1515.      * Offset between DTSS formatted times and Unix formatted times.
  1516.      */
  1517.     os_basetime_diff.lo = uuid_c_os_base_time_diff_lo;
  1518.     os_basetime_diff.hi = uuid_c_os_base_time_diff_hi;
  1519.     UADD_UVLW_2_UVLW (&utc, &os_basetime_diff, uuid_ttime);
  1520. }