1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_tools.hxx" 26 27 #include <ctype.h> 28 #include <stdio.h> 29 #include <string.h> 30 31 #include <tools/stream.hxx> 32 #include <tools/globname.hxx> 33 34 /************** class ImpSvGlobalName ************************************/ 35 ImpSvGlobalName::ImpSvGlobalName( const ImpSvGlobalName & rObj ) 36 { 37 nRefCount = 0; 38 memcpy( szData, rObj.szData, sizeof( szData ) ); 39 } 40 41 /************** class ImpSvGlobalName ************************************/ 42 ImpSvGlobalName::ImpSvGlobalName( int ) 43 { 44 nRefCount = 1; 45 memset( szData, 0, sizeof( szData ) ); 46 } 47 48 /************************************************************************* 49 |* ImpSvGlobalName::operator ==() 50 *************************************************************************/ 51 sal_Bool ImpSvGlobalName::operator == ( const ImpSvGlobalName & rObj ) const 52 { 53 return !memcmp( szData, rObj.szData, sizeof( szData ) ); 54 } 55 56 /************************************************************************* 57 |* SvGlobalName::SvGlobalName() 58 *************************************************************************/ 59 SvGlobalName::SvGlobalName() 60 { 61 static ImpSvGlobalName aNoName( 0 ); 62 63 pImp = &aNoName; 64 pImp->nRefCount++; 65 } 66 67 // locker die Struktur von Windows kopiert 68 #ifdef WNT 69 struct _GUID 70 #else 71 struct GUID 72 #endif 73 { 74 sal_uInt32 Data1; 75 sal_uInt16 Data2; 76 sal_uInt16 Data3; 77 sal_uInt8 Data4[8]; 78 }; 79 SvGlobalName::SvGlobalName( const CLSID & rId ) 80 { 81 pImp = new ImpSvGlobalName(); 82 pImp->nRefCount++; 83 memcpy( pImp->szData, &rId, sizeof( pImp->szData ) ); 84 } 85 86 SvGlobalName::SvGlobalName( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3, 87 sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11, 88 sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 ) 89 { 90 pImp = new ImpSvGlobalName(); 91 pImp->nRefCount++; 92 93 *(sal_uInt32 *)pImp->szData = n1; 94 *(sal_uInt16 *)&pImp->szData[ 4 ] = n2; 95 *(sal_uInt16 *)&pImp->szData[ 6 ] = n3; 96 pImp->szData[ 8 ] = b8; 97 pImp->szData[ 9 ] = b9; 98 pImp->szData[ 10 ] = b10; 99 pImp->szData[ 11 ] = b11; 100 pImp->szData[ 12 ] = b12; 101 pImp->szData[ 13 ] = b13; 102 pImp->szData[ 14 ] = b14; 103 pImp->szData[ 15 ] = b15; 104 } 105 106 /************************************************************************* 107 |* SvGlobalName::~SvGlobalName() 108 *************************************************************************/ 109 SvGlobalName::~SvGlobalName() 110 { 111 pImp->nRefCount--; 112 if( !pImp->nRefCount ) 113 delete pImp; 114 } 115 116 /************************************************************************* 117 |* SvGlobalName::operator = () 118 *************************************************************************/ 119 SvGlobalName & SvGlobalName::operator = ( const SvGlobalName & rObj ) 120 { 121 rObj.pImp->nRefCount++; 122 pImp->nRefCount--; 123 if( !pImp->nRefCount ) 124 delete pImp; 125 pImp = rObj.pImp; 126 return *this; 127 } 128 129 /************************************************************************* 130 |* SvGlobalName::NewImp() 131 *************************************************************************/ 132 void SvGlobalName::NewImp() 133 { 134 if( pImp->nRefCount > 1 ) 135 { 136 pImp->nRefCount--; 137 pImp = new ImpSvGlobalName( *pImp ); 138 pImp->nRefCount++; 139 } 140 } 141 142 /************************************************************************* 143 |* SvGlobalName::operator << () 144 |* SvGlobalName::operator >> () 145 *************************************************************************/ 146 SvStream& operator << ( SvStream& rOStr, const SvGlobalName & rObj ) 147 { 148 rOStr << *(sal_uInt32 *)rObj.pImp->szData; 149 rOStr << *(sal_uInt16 *)&rObj.pImp->szData[ 4 ]; 150 rOStr << *(sal_uInt16 *)&rObj.pImp->szData[ 6 ]; 151 rOStr.Write( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 ); 152 return rOStr; 153 } 154 155 SvStream& operator >> ( SvStream& rStr, SvGlobalName & rObj ) 156 { 157 rObj.NewImp(); // kopieren, falls noetig 158 rStr >> *(sal_uInt32 *)rObj.pImp->szData; 159 rStr >> *(sal_uInt16 *)&rObj.pImp->szData[ 4 ]; 160 rStr >> *(sal_uInt16 *)&rObj.pImp->szData[ 6 ]; 161 rStr.Read( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 ); 162 return rStr; 163 } 164 165 166 /************************************************************************* 167 |* SvGlobalName::operator < () 168 *************************************************************************/ 169 sal_Bool SvGlobalName::operator < ( const SvGlobalName & rObj ) const 170 { 171 int n = memcmp( pImp->szData +6, rObj.pImp->szData +6, 172 sizeof( pImp->szData ) -6); 173 if( n < 0 ) 174 return sal_True; 175 else if( n > 0 ) 176 return sal_False; 177 else if( *(sal_uInt16 *)&pImp->szData[ 4 ] < *(sal_uInt16 *)&rObj.pImp->szData[ 4 ] ) 178 return sal_True; 179 else if( *(sal_uInt16 *)&pImp->szData[ 4 ] == *(sal_uInt16 *)&rObj.pImp->szData[ 4 ] ) 180 return *(sal_uInt32 *)pImp->szData < *(sal_uInt32 *)rObj.pImp->szData; 181 else 182 return sal_False; 183 184 } 185 186 /************************************************************************* 187 |* SvGlobalName::operator +=() 188 *************************************************************************/ 189 SvGlobalName & SvGlobalName::operator += ( sal_uInt32 n ) 190 { 191 NewImp(); 192 sal_uInt32 nOld = (*(sal_uInt32 *)pImp->szData); 193 (*(sal_uInt32 *)pImp->szData) += n; 194 if( nOld > *(sal_uInt32 *)pImp->szData ) 195 // ueberlauf 196 (*(sal_uInt16 *)&pImp->szData[ 4 ])++; 197 return *this; 198 } 199 200 /************************************************************************* 201 |* SvGlobalName::operator ==() 202 *************************************************************************/ 203 sal_Bool SvGlobalName::operator == ( const SvGlobalName & rObj ) const 204 { 205 return *pImp == *rObj.pImp; 206 } 207 208 void SvGlobalName::MakeFromMemory( void * pData ) 209 { 210 NewImp(); 211 memcpy( pImp->szData, pData, sizeof( pImp->szData ) ); 212 } 213 214 /************************************************************************* 215 |* SvGlobalName::MakeId() 216 *************************************************************************/ 217 sal_Bool SvGlobalName::MakeId( const String & rIdStr ) 218 { 219 ByteString aStr( rIdStr, RTL_TEXTENCODING_ASCII_US ); 220 sal_Char * pStr = (sal_Char *)aStr.GetBuffer(); 221 if( rIdStr.Len() == 36 222 && '-' == pStr[ 8 ] && '-' == pStr[ 13 ] 223 && '-' == pStr[ 18 ] && '-' == pStr[ 23 ] ) 224 { 225 sal_uInt32 nFirst = 0; 226 int i = 0; 227 for( i = 0; i < 8; i++ ) 228 { 229 if( isxdigit( *pStr ) ) 230 if( isdigit( *pStr ) ) 231 nFirst = nFirst * 16 + (*pStr - '0'); 232 else 233 nFirst = nFirst * 16 + (toupper( *pStr ) - 'A' + 10 ); 234 else 235 return sal_False; 236 pStr++; 237 } 238 239 sal_uInt16 nSec = 0; 240 pStr++; 241 for( i = 0; i < 4; i++ ) 242 { 243 if( isxdigit( *pStr ) ) 244 if( isdigit( *pStr ) ) 245 nSec = nSec * 16 + (*pStr - '0'); 246 else 247 nSec = nSec * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 ); 248 else 249 return sal_False; 250 pStr++; 251 } 252 253 sal_uInt16 nThird = 0; 254 pStr++; 255 for( i = 0; i < 4; i++ ) 256 { 257 if( isxdigit( *pStr ) ) 258 if( isdigit( *pStr ) ) 259 nThird = nThird * 16 + (*pStr - '0'); 260 else 261 nThird = nThird * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 ); 262 else 263 return sal_False; 264 pStr++; 265 } 266 267 sal_Int8 szRemain[ 8 ]; 268 memset( szRemain, 0, sizeof( szRemain ) ); 269 pStr++; 270 for( i = 0; i < 16; i++ ) 271 { 272 if( isxdigit( *pStr ) ) 273 if( isdigit( *pStr ) ) 274 szRemain[i/2] = szRemain[i/2] * 16 + (*pStr - '0'); 275 else 276 szRemain[i/2] = szRemain[i/2] * 16 + (sal_Int8)(toupper( *pStr ) - 'A' + 10 ); 277 else 278 return sal_False; 279 pStr++; 280 if( i == 3 ) 281 pStr++; 282 } 283 284 NewImp(); 285 *(sal_uInt32 *)pImp->szData = nFirst; 286 *(sal_uInt16 *)&pImp->szData[ 4 ] = nSec; 287 *(sal_uInt16 *)&pImp->szData[ 6 ] = nThird; 288 memcpy( &pImp->szData[ 8 ], szRemain, 8 ); 289 return sal_True; 290 } 291 return sal_False; 292 } 293 294 /************************************************************************* 295 |* SvGlobalName::GetctorName() 296 *************************************************************************/ 297 String SvGlobalName::GetctorName() const 298 { 299 ByteString aRet; 300 301 sal_Char buf[ 20 ]; 302 sprintf( buf, "0x%8.8lX", (sal_uIntPtr)*(sal_uInt32 *)pImp->szData ); 303 aRet += buf; 304 sal_uInt16 i; 305 for( i = 4; i < 8; i += 2 ) 306 { 307 aRet += ','; 308 sprintf( buf, "0x%4.4X", *(sal_uInt16 *)&pImp->szData[ i ] ); 309 aRet += buf; 310 } 311 for( i = 8; i < 16; i++ ) 312 { 313 aRet += ','; 314 sprintf( buf, "0x%2.2x", pImp->szData[ i ] ); 315 aRet += buf; 316 } 317 return String( aRet, RTL_TEXTENCODING_ASCII_US ); 318 } 319 320 /************************************************************************* 321 |* SvGlobalName::GetHexName() 322 *************************************************************************/ 323 String SvGlobalName::GetHexName() const 324 { 325 ByteString aRet; 326 327 sal_Char buf[ 10 ]; 328 sprintf( buf, "%8.8lX", (sal_uIntPtr)*(sal_uInt32 *)pImp->szData ); 329 aRet += buf; 330 aRet += '-'; 331 sal_uInt16 i ; 332 for( i = 4; i < 8; i += 2 ) 333 { 334 sprintf( buf, "%4.4X", *(sal_uInt16 *)&pImp->szData[ i ] ); 335 aRet += buf; 336 aRet += '-'; 337 } 338 for( i = 8; i < 10; i++ ) 339 { 340 sprintf( buf, "%2.2x", pImp->szData[ i ] ); 341 aRet += buf; 342 } 343 aRet += '-'; 344 for( i = 10; i < 16; i++ ) 345 { 346 sprintf( buf, "%2.2x", pImp->szData[ i ] ); 347 aRet += buf; 348 } 349 return String( aRet, RTL_TEXTENCODING_ASCII_US ); 350 } 351 352 /************** SvGlobalNameList ****************************************/ 353 /************************************************************************/ 354 /************************************************************************* 355 |* SvGlobalNameList::SvGlobalNameList() 356 *************************************************************************/ 357 SvGlobalNameList::SvGlobalNameList() 358 : aList( 1, 1 ) 359 { 360 } 361 362 /************************************************************************* 363 |* SvGlobalNameList::~SvGlobalNameList() 364 *************************************************************************/ 365 SvGlobalNameList::~SvGlobalNameList() 366 { 367 for( sal_uIntPtr i = Count(); i > 0; i-- ) 368 { 369 ImpSvGlobalName * pImp = (ImpSvGlobalName *)aList.GetObject( i -1 ); 370 pImp->nRefCount--; 371 if( !pImp->nRefCount ) 372 delete pImp; 373 } 374 } 375 376 /************************************************************************* 377 |* SvGlobalNameList::Append() 378 *************************************************************************/ 379 void SvGlobalNameList::Append( const SvGlobalName & rName ) 380 { 381 rName.pImp->nRefCount++; 382 aList.Insert( rName.pImp, LIST_APPEND ); 383 } 384 385 /************************************************************************* 386 |* SvGlobalNameList::GetObject() 387 *************************************************************************/ 388 SvGlobalName SvGlobalNameList::GetObject( sal_uLong nPos ) 389 { 390 return SvGlobalName( (ImpSvGlobalName *)aList.GetObject( nPos ) ); 391 } 392 393 /************************************************************************* 394 |* SvGlobalNameList::IsEntry() 395 *************************************************************************/ 396 sal_Bool SvGlobalNameList::IsEntry( const SvGlobalName & rName ) 397 { 398 for( sal_uIntPtr i = Count(); i > 0; i-- ) 399 { 400 if( *rName.pImp == *(ImpSvGlobalName *)aList.GetObject( i -1 ) ) 401 return sal_True; 402 } 403 return sal_False; 404 } 405 406 com::sun::star::uno::Sequence < sal_Int8 > SvGlobalName::GetByteSequence() const 407 { 408 // platform independent representation of a "GlobalName" 409 // maybe transported remotely 410 com::sun::star::uno::Sequence< sal_Int8 > aResult( 16 ); 411 412 aResult[0] = (sal_Int8) (*(sal_uInt32 *)pImp->szData >> 24); 413 aResult[1] = (sal_Int8) ((*(sal_uInt32 *)pImp->szData << 8 ) >> 24); 414 aResult[2] = (sal_Int8) ((*(sal_uInt32 *)pImp->szData << 16 ) >> 24); 415 aResult[3] = (sal_Int8) ((*(sal_uInt32 *)pImp->szData << 24 ) >> 24); 416 aResult[4] = (sal_Int8) (*(sal_uInt16 *)&pImp->szData[ 4 ] >> 8); 417 aResult[5] = (sal_Int8) ((*(sal_uInt16 *)&pImp->szData[ 4 ] << 8 ) >> 8); 418 aResult[6] = (sal_Int8) (*(sal_uInt16 *)&pImp->szData[ 6 ] >> 8); 419 aResult[7] = (sal_Int8) ((*(sal_uInt16 *)&pImp->szData[ 6 ] << 8 ) >> 8); 420 aResult[8] = pImp->szData[ 8 ]; 421 aResult[9] = pImp->szData[ 9 ]; 422 aResult[10] = pImp->szData[ 10 ]; 423 aResult[11] = pImp->szData[ 11 ]; 424 aResult[12] = pImp->szData[ 12 ]; 425 aResult[13] = pImp->szData[ 13 ]; 426 aResult[14] = pImp->szData[ 14 ]; 427 aResult[15] = pImp->szData[ 15 ]; 428 429 return aResult; 430 } 431 432 SvGlobalName::SvGlobalName( const com::sun::star::uno::Sequence < sal_Int8 >& aSeq ) 433 { 434 // create SvGlobalName from a platform independent representation 435 GUID aResult; 436 memset( &aResult, 0, sizeof( aResult ) ); 437 if ( aSeq.getLength() == 16 ) 438 { 439 aResult.Data1 = ( ( ( ( ( ( sal_uInt8 )aSeq[0] << 8 ) + ( sal_uInt8 )aSeq[1] ) << 8 ) + ( sal_uInt8 )aSeq[2] ) << 8 ) + ( sal_uInt8 )aSeq[3]; 440 aResult.Data2 = ( ( sal_uInt8 )aSeq[4] << 8 ) + ( sal_uInt8 )aSeq[5]; 441 aResult.Data3 = ( ( sal_uInt8 )aSeq[6] << 8 ) + ( sal_uInt8 )aSeq[7]; 442 for( int nInd = 0; nInd < 8; nInd++ ) 443 aResult.Data4[nInd] = ( sal_uInt8 )aSeq[nInd+8]; 444 } 445 446 pImp = new ImpSvGlobalName(); 447 pImp->nRefCount++; 448 memcpy( pImp->szData, &aResult, sizeof( pImp->szData ) ); 449 } 450