#include "stdafx.h"#include <accctrl.h>#include "dumpacl.h"Include dependency graph for dumpacl.cpp:
Go to the source code of this file.
Defines | |
| #define | lenof(a) (sizeof(a) / sizeof((a)[0]) ) |
Functions | |
| const TCHAR* | sidToText ( PSID psid ) |
| bool | getSecurityPriv ( void ) |
| const TCHAR* | indent ( int nBlanks ) |
| void | printSid ( PSID psid ) |
| void | printAce ( int ind, bool isSacl, int index, PACL acl ) |
| void | printAcl ( int ind, bool isSacl, PACL acl ) |
| void | printSD ( int ind, SECURITY_DESCRIPTOR *psd ) |
|
|
Definition at line 7 of file dumpacl.cpp. Referenced by fksec::sid::ConvertFromStringSid(), fksec::sid::ConvertToStringSid(), fksec::sid::LookupName(), fksec::sid::LookupSidType(), fksec::sid::SnuToText(), fksec::ace::operator<(), fksec::sid::operator=(), printAce(), printSD(), and fksec::sid::sid(). |
|
|
Definition at line 50 of file dumpacl.cpp. 00051 {
00052 HANDLE hToken;
00053 LUID privValue;
00054 TOKEN_PRIVILEGES tkp;
00055 DWORD rc = 0;
00056
00057 if ( OpenProcessToken( GetCurrentProcess(),
00058 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken ) )
00059 {
00060 if ( LookupPrivilegeValue( NULL, SE_SECURITY_NAME, &privValue ) )
00061 {
00062 tkp.PrivilegeCount = 1;
00063 tkp.Privileges[0].Luid = privValue;
00064 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
00065
00066 if ( ! AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof tkp, NULL, NULL ) )
00067 rc = GetLastError();
00068 }
00069 else
00070 rc = GetLastError();
00071 }
00072 else
00073 {
00074 rc = GetLastError();
00075 hToken = INVALID_HANDLE_VALUE;
00076 }
00077
00078 if ( hToken != INVALID_HANDLE_VALUE )
00079 CloseHandle( hToken );
00080
00081 if ( rc )
00082 SetLastError( rc );
00083
00084 return rc == 0;
00085 }
|
|
|
Definition at line 89 of file dumpacl.cpp. Referenced by printAce(), printAcl(), and printSD(). 00090 {
00091 static const int maxBlanks = 80;
00092 static TCHAR blanks[maxBlanks + 1] = _T( "" );
00093
00094 if ( blanks[0] == _T( '\0' ) )
00095 {
00096 for ( int i = 0; i < maxBlanks; ++ i )
00097 blanks[i] = _T( ' ' );
00098 blanks[maxBlanks] = _T( '\0' );
00099 }
00100
00101 if ( nBlanks > maxBlanks )
00102 nBlanks = maxBlanks;
00103 if ( nBlanks < 0 )
00104 nBlanks = 0;
00105
00106 return &blanks[maxBlanks - nBlanks];
00107 }
|
|
|
Definition at line 145 of file dumpacl.cpp. 00146 {
00147 ACE_HEADER *ace;
00148 TCHAR *type;
00149 int i;
00150 bool first;
00151 DWORD j;
00152 PSID psid;
00153
00154 static struct {
00155 DWORD flag;
00156 TCHAR *txt;
00157 } inheritflags[] = {
00158 { CONTAINER_INHERIT_ACE, _T( "CONTAINER_INHERIT_ACE" ) },
00159 { INHERIT_ONLY_ACE, _T( "INHERIT_ONLY_ACE" ) },
00160 { NO_PROPAGATE_INHERIT_ACE, _T( "NO_PROPAGATE_INHERIT_ACE" ) },
00161 { OBJECT_INHERIT_ACE, _T( "OBJECT_INHERIT_ACE" ) },
00162 { SUB_CONTAINERS_ONLY_INHERIT, _T( "SUB_CONTAINERS_ONLY_INHERIT" ) },
00163 { SUB_OBJECTS_ONLY_INHERIT, _T( "SUB_OBJECTS_ONLY_INHERIT" ) },
00164 { SUB_CONTAINERS_AND_OBJECTS_INHERIT, _T( "SUB_CONTAINERS_AND_OBJECTS_INHERIT" ) },
00165 { FAILED_ACCESS_ACE_FLAG, _T( "FAILED_ACCESS_ACE_FLAG" ) },
00166 { SUCCESSFUL_ACCESS_ACE_FLAG, _T( "SUCCESSFUL_ACCESS_ACE_FLAG" ) },
00167 { INHERITED_ACE, _T( "INHERITED_ACE" ) }
00168 };
00169 static struct {
00170 DWORD flag;
00171 TCHAR *txt;
00172 } permflags[] = {
00173 { /* 0x00000001 */ FILE_READ_DATA, _T( "file: FILE_READ_DATA, dir: FILE_LIST_DIRECTORY" ) },
00174 { /* 0x00000002 */ FILE_WRITE_DATA, _T( "file: FILE_WRITE_DATA, dir: FILE_ADD_FILE" ) },
00175 { /* 0x00000004 */ FILE_APPEND_DATA, _T( "file: FILE_APPEND_DATA, dir: FILE_ADD_SUBDIRECTORY" ) },
00176 { /* 0x00000008 */ FILE_READ_EA, _T( "FILE_READ_EA" ) },
00177 { /* 0x00000010 */ FILE_WRITE_EA, _T( "FILE_WRITE_EA" ) },
00178 { /* 0x00000020 */ FILE_EXECUTE, _T( "file: FILE_EXECUTE, dir: FILE_TRAVERSE" ) },
00179 { /* 0x00000040 */ FILE_DELETE_CHILD, _T( "FILE_DELETE_CHILD" ) },
00180 { /* 0x00000080 */ FILE_READ_ATTRIBUTES, _T( "FILE_READ_ATTRIBUTES" ) },
00181 { /* 0x00000100 */ FILE_WRITE_ATTRIBUTES, _T( "FILE_WRITE_ATTRIBUTES" ) },
00182 { /* 0x00000200 */ 0x00000200, _T( "unknown" ) },
00183 { /* 0x00000400 */ 0x00000400, _T( "unknown" ) },
00184 { /* 0x00000800 */ 0x00000800, _T( "unknown" ) },
00185 { /* 0x00001000 */ 0x00001000, _T( "unknown" ) },
00186 { /* 0x00002000 */ 0x00002000, _T( "unknown" ) },
00187 { /* 0x00004000 */ 0x00004000, _T( "unknown" ) },
00188 { /* 0x00008000 */ 0x00008000, _T( "unknown" ) },
00189 { /* 0x001f01ff */ FILE_ALL_ACCESS, _T( "FILE_ALL_ACCESS" ) },
00190 { /* */ FILE_GENERIC_READ, _T( "FILE_GENERIC_READ" ) },
00191 { /* */ FILE_GENERIC_WRITE, _T( "FILE_GENERIC_WRITE" ) },
00192 { /* */ FILE_GENERIC_EXECUTE, _T( "FILE_GENERIC_EXECUTE" ) },
00193 { /* 0x00010000 */ DELETE, _T( "DELETE" ) },
00194 { /* 0x00020000 */ READ_CONTROL, _T( "READ_CONTROL" ) },
00195 { /* 0x00040000 */ WRITE_DAC, _T( "WRITE_DAC" ) },
00196 { /* 0x00080000 */ WRITE_OWNER, _T( "WRITE_OWNER" ) },
00197 { /* 0x00100000 */ SYNCHRONIZE, _T( "SYNCHRONIZE" ) },
00198 { /* 0x00200000 */ 0x00200000, _T( "unknown" ) },
00199 { /* 0x00400000 */ 0x00400000, _T( "unknown" ) },
00200 { /* 0x00800000 */ 0x00800000, _T( "unknown" ) },
00201 { /* 0x01000000 */ ACCESS_SYSTEM_SECURITY, _T( "ACCESS_SYSTEM_SECURITY" ) },
00202 { /* 0x02000000 */ MAXIMUM_ALLOWED, _T( "MAXIMUM_ALLOWED" ) },
00203 { /* 0x04000000 */ 0x04000000, _T( "unknown" ) },
00204 { /* 0x08000000 */ 0x08000000, _T( "unknown" ) },
00205 { /* 0x10000000 */ GENERIC_ALL, _T( "GENERIC_ALL" ) },
00206 { /* 0x20000000 */ GENERIC_EXECUTE, _T( "GENERIC_EXECUTE" ) },
00207 { /* 0x40000000 */ GENERIC_WRITE, _T( "GENERIC_WRITE" ) },
00208 { /* 0x80000000 */ GENERIC_READ, _T( "GENERIC_READ" ) },
00209 { /* 0x0000ffff */ SPECIFIC_RIGHTS_ALL, _T( "SPECIFIC_RIGHTS_ALL" ) },
00210 { /* 0x000f0000 */ STANDARD_RIGHTS_REQUIRED, _T( "STANDARD_RIGHTS_REQUIRED" ) },
00211 { /* 0x001f0000 */ STANDARD_RIGHTS_ALL, _T( "STANDARD_RIGHTS_ALL" ) }
00212 };
00213
00214 if ( ! GetAce( acl, index, (void **) &ace ) )
00215 {
00216 _tprintf( _T( "%s%cACL, entry %d: GetAce() failed, gle == %lu\n" ),
00217 indent( ind ), isSacl? 'S': 'D', index, GetLastError() );
00218 return;
00219 }
00220
00221 switch ( ace->AceType )
00222 {
00223 case ACCESS_ALLOWED_ACE_TYPE:
00224 type = _T( "ACCESS_ALLOWED_ACE_TYPE" );
00225 psid = &( (ACCESS_ALLOWED_ACE *) ace )->SidStart;
00226 break;
00227 case ACCESS_DENIED_ACE_TYPE:
00228 type = _T( "ACCESS_DENIED_ACE_TYPE" );
00229 psid = &( (ACCESS_DENIED_ACE *) ace )->SidStart;
00230 break;
00231 case SYSTEM_AUDIT_ACE_TYPE:
00232 type = _T( "SYSTEM_AUDIT_ACE_TYPE" );
00233 psid = &( (SYSTEM_AUDIT_ACE *) ace )->SidStart;
00234 break;
00235 case SYSTEM_ALARM_ACE_TYPE:
00236 type = _T( "SYSTEM_ALARM_ACE_TYPE" );
00237 psid = &( (SYSTEM_ALARM_ACE *) ace )->SidStart;
00238 break;
00239 #if 0
00240 case ACCESS_ALLOWED_COMPOUND_ACE_TYPE:
00241 type = _T( "ACCESS_ALLOWED_COMPOUND_ACE_TYPE" );
00242 psid = &( (ACCESS_ALLOWED_COMPOUND_ACE *) ace )->SidStart;
00243 break;
00244 #endif
00245 case ACCESS_ALLOWED_OBJECT_ACE_TYPE:
00246 type = _T( "ACCESS_ALLOWED_OBJECT_ACE_TYPE" );
00247 psid = &( (ACCESS_ALLOWED_OBJECT_ACE *) ace )->SidStart;
00248 break;
00249 case ACCESS_DENIED_OBJECT_ACE_TYPE:
00250 type = _T( "ACCESS_DENIED_OBJECT_ACE_TYPE" );
00251 psid = &( (ACCESS_DENIED_OBJECT_ACE *) ace )->SidStart;
00252 break;
00253 case SYSTEM_AUDIT_OBJECT_ACE_TYPE:
00254 type = _T( "SYSTEM_AUDIT_OBJECT_ACE_TYPE" );
00255 psid = &( (SYSTEM_AUDIT_OBJECT_ACE *) ace )->SidStart;
00256 break;
00257 case SYSTEM_ALARM_OBJECT_ACE_TYPE:
00258 type = _T( "SYSTEM_ALARM_OBJECT_ACE_TYPE" );
00259 psid = &( (SYSTEM_ALARM_OBJECT_ACE *) ace )->SidStart;
00260 break;
00261 default:
00262 type = _T( "invalid-ACE-type" );
00263 psid = &( (ACCESS_ALLOWED_ACE *) ace )->SidStart;
00264 break;
00265 }
00266 _tprintf( _T( "%s%cACL entry %d\n" ), indent( ind ), isSacl? 'S': 'D', index );
00267
00268 _tprintf( _T( "%sACE type: %s (%lu)\n" ), indent( ind + 2 ), type, (DWORD) ace->AceType );
00269
00270 _tprintf( _T( "%sTrustee: " ), indent( ind + 2 ) );
00271 printSid( psid );
00272
00273 _tprintf( _T( "%sInheritance/auditing: " ), indent( ind + 2 ) );
00274 for ( j = ace->AceFlags, i = 0; i < 8; i ++ )
00275 {
00276 if ( i != 0 && i % 4 == 0 )
00277 putchar( ' ' );
00278 putchar( ( j & 0x80 )? '1': '0' );
00279 j <<= 1;
00280 }
00281 putchar( '\n' );
00282 for ( i = 0, first = true; i < lenof( inheritflags ); i ++ )
00283 {
00284 if ( inheritflags[i].flag == ( inheritflags[i].flag & ace->AceFlags ) )
00285 {
00286 _tprintf( _T( "%s%s\n" ), indent( ind + 4 ), inheritflags[i].txt );
00287 first = false;
00288 }
00289 }
00290 if ( first )
00291 {
00292 _tprintf( _T( "%sNO_INHERITANCE\n" ), indent( ind + 4 ) );
00293 }
00294
00295 _tprintf( _T( "%sPermissions: " ), indent( ind + 2 ) );
00296 for ( j = ( (ACCESS_ALLOWED_ACE *) ace )->Mask, i = 0; i < 32; i ++ )
00297 {
00298 if ( i != 0 && i % 4 == 0 )
00299 putchar( ' ' );
00300 if ( i != 0 && i % 16 == 0 )
00301 putchar( '-' );
00302 if ( i != 0 && i % 8 == 0 )
00303 putchar( ' ' );
00304 putchar( ( j & 0x80000000 )? '1': '0' );
00305 j <<= 1;
00306 }
00307 putchar( '\n' );
00308 j = ( (ACCESS_ALLOWED_ACE *) ace )->Mask;
00309 for ( i = 0, first = true; i < lenof( permflags ); i ++ )
00310 {
00311 if ( permflags[i].flag == ( permflags[i].flag & j ) )
00312 {
00313 _tprintf( _T( "%s%08lXh %s\n" ), indent( ind + 4 ), permflags[i].flag, permflags[i].txt );
00314 first = false;
00315 }
00316 }
00317 if ( first )
00318 {
00319 indent( ind + 4 );
00320 _tprintf( _T( "%s(none)\n" ), indent( ind + 4 ) );
00321 }
00322 }
|
|
|
Definition at line 326 of file dumpacl.cpp. Referenced by printSD(). 00327 {
00328 DWORD i;
00329 ACL_SIZE_INFORMATION aci;
00330
00331 if ( acl == 0 )
00332 return;
00333
00334 if ( ! GetAclInformation( acl, &aci, sizeof aci, AclSizeInformation ) )
00335 {
00336 _tprintf( _T( "%sGAI(): gle == %lu\n" ), indent( ind ), GetLastError() );
00337 return;
00338 }
00339
00340 _tprintf( _T( "%s%cACL header: %lu ACEs, %lu bytes used, %lu bytes free\n" ),
00341 indent( ind ), isSacl? 'S': 'D', aci.AceCount, aci.AclBytesInUse, aci.AclBytesFree );
00342
00343 for ( i = 0; i < aci.AceCount; ++ i )
00344 printAce( ind + 2, isSacl, i, acl );
00345
00346 }
|
|
|
Definition at line 350 of file dumpacl.cpp. Referenced by _tmain(). 00351 {
00352 SECURITY_DESCRIPTOR_CONTROL sdc;
00353 DWORD rev;
00354 PSID psidOwner, psidGroup;
00355 int ownerDefaulted, groupDefaulted;
00356 PACL dacl, sacl;
00357 int daclPresent, daclDefaulted;
00358 int saclPresent, saclDefaulted;
00359 int i;
00360 bool first;
00361 WORD j;
00362
00363 static struct {
00364 WORD flag;
00365 TCHAR *txt;
00366 } ctlflags[] = {
00367 { /* 0x0001 */ SE_OWNER_DEFAULTED, _T( "SE_OWNER_DEFAULTED" ) },
00368 { /* 0x0002 */ SE_GROUP_DEFAULTED, _T( "SE_GROUP_DEFAULTED" ) },
00369 { /* 0x0004 */ SE_DACL_PRESENT, _T( "SE_DACL_PRESENT" ) },
00370 { /* 0x0008 */ SE_DACL_DEFAULTED, _T( "SE_DACL_DEFAULTED" ) },
00371 { /* 0x0010 */ SE_SACL_PRESENT, _T( "SE_SACL_PRESENT" ) },
00372 { /* 0x0020 */ SE_SACL_DEFAULTED, _T( "SE_SACL_DEFAULTED" ) },
00373 { /* 0x0040 */ 0x0040, _T( "unknown" ) },
00374 { /* 0x0080 */ 0x0080, _T( "unknown" ) },
00375 { /* 0x0100 */ SE_DACL_AUTO_INHERIT_REQ, _T( "SE_DACL_AUTO_INHERIT_REQ" ) },
00376 { /* 0x0200 */ SE_SACL_AUTO_INHERIT_REQ, _T( "SE_SACL_AUTO_INHERIT_REQ" ) },
00377 { /* 0x0400 */ SE_DACL_AUTO_INHERITED, _T( "SE_DACL_AUTO_INHERITED" ) },
00378 { /* 0x0800 */ SE_SACL_AUTO_INHERITED, _T( "SE_SACL_AUTO_INHERITED" ) },
00379 { /* 0x1000 */ SE_DACL_PROTECTED, _T( "SE_DACL_PROTECTED" ) },
00380 { /* 0x2000 */ SE_SACL_PROTECTED, _T( "SE_SACL_PROTECTED" ) },
00381 { /* 0x4000 */ 0x4000, _T( "unknown" ) },
00382 { /* 0x8000 */ SE_SELF_RELATIVE, _T( "SE_SELF_RELATIVE" ) },
00383 };
00384
00385 if ( ! GetSecurityDescriptorControl( psd, &sdc, &rev ) )
00386 {
00387 _tprintf( _T( "%sSECURITY_DESCRIPTOR: *** GSDC() failed, gle = %lu\n" ),
00388 indent( ind ), GetLastError() );
00389 return;
00390 }
00391
00392 _tprintf( _T( "%sSECURITY_DESCRIPTOR: rev = %lu, length = %lu bytes\n" ),
00393 indent( ind ), rev, GetSecurityDescriptorLength( psd ) );
00394
00395 _tprintf( _T( "%sSD control: " ), indent( ind + 2 ) );
00396 for ( j = sdc, i = 0; i < 8 * sizeof WORD; ++ i )
00397 {
00398 if ( i != 0 && i % 4 == 0 )
00399 putchar( ' ' );
00400 if ( i != 0 && i % 16 == 0 )
00401 putchar( '-' );
00402 if ( i != 0 && i % 8 == 0 )
00403 putchar( ' ' );
00404 putchar( ( j & 0x8000 )? '1': '0' );
00405 j <<= 1;
00406 }
00407 putchar( '\n' );
00408 j = sdc;
00409 for ( i = 0, first = true; i < lenof( ctlflags ); i ++ )
00410 {
00411 if ( ctlflags[i].flag == ( ctlflags[i].flag & j ) )
00412 {
00413 _tprintf( _T( "%s%04hXh %s\n" ), indent( ind + 4 ), ctlflags[i].flag, ctlflags[i].txt );
00414 first = false;
00415 }
00416 }
00417 if ( first )
00418 {
00419 indent( ind + 4 );
00420 _tprintf( _T( "%s(none)\n" ), indent( ind + 4 ) );
00421 }
00422
00423 ind += 2;
00424
00425 if ( ! GetSecurityDescriptorOwner( psd, &psidOwner, &ownerDefaulted ) )
00426 {
00427 _tprintf( _T( "%sOwner: *** GSDO() failed, gle == %lu\n" ), indent( ind ), GetLastError() );
00428 }
00429 else
00430 {
00431 _tprintf( _T( "%sOwner: %s" ), indent( ind ), ownerDefaulted? _T( "[def] " ): _T( "" ) );
00432 printSid( psidOwner );
00433 }
00434
00435 if ( ! GetSecurityDescriptorGroup( psd, &psidGroup, &groupDefaulted ) )
00436 {
00437 _tprintf( _T( "%sGroup: *** GSDG() failed, gle == %lu" ), indent( ind ), GetLastError() );
00438 }
00439 else
00440 {
00441 _tprintf( _T( "%sGroup: %s" ), indent( ind ), groupDefaulted? _T( "[def] " ): _T( "" ) );
00442 printSid( psidGroup );
00443 }
00444
00445 dacl = 0;
00446 if ( ! GetSecurityDescriptorDacl( psd, &daclPresent, &dacl, &daclDefaulted ) )
00447 {
00448 _tprintf( _T( "%sDACL: *** GSDD() failed, gle == %lu" ), indent( ind ), GetLastError() );
00449 }
00450 else
00451 {
00452 _tprintf( _T( "%sDACL: %s%s%s\n" ), indent( ind ), daclPresent? _T( "[present]" ): _T( "[absent]" ),
00453 daclDefaulted? _T( "[defaulted]" ): _T( "[specified]" ), dacl == 0? _T( "[NULL DACL]" ): _T( "" ) );
00454 if ( dacl != 0 )
00455 printAcl( ind + 2, false, dacl );
00456 }
00457
00458 sacl = 0;
00459 if ( ! GetSecurityDescriptorSacl( psd, &saclPresent, &sacl, &saclDefaulted ) )
00460 {
00461 _tprintf( _T( "%sSACL: *** GSDD() failed, gle == %lu" ), indent( ind ), GetLastError() );
00462 }
00463 else
00464 {
00465 _tprintf( _T( "%sSACL: %s%s%s\n" ), indent( ind ), saclPresent? _T( "[present]" ): _T( "[absent]" ),
00466 saclDefaulted? _T( "[defaulted]" ): _T( "[specified]" ), sacl == 0? _T( "[NULL SACL]" ): _T( "" ) );
00467 if ( sacl != 0 )
00468 printAcl( ind + 2, true, sacl );
00469 }
00470 }
|
|
|
Definition at line 111 of file dumpacl.cpp. Referenced by printAce(), and printSD(). 00112 {
00113 TCHAR name[256], domain[256];
00114 TCHAR *type;
00115 DWORD cbname = sizeof name, cbdomain = sizeof domain, rc;
00116 SID_NAME_USE sidUse;
00117
00119 // NULL server name is usually appropriate, though.
00120 if ( LookupAccountSid( NULL, psid, name, &cbname, domain, &cbdomain, &sidUse ) )
00121 {
00122 switch ( sidUse )
00123 {
00124 case SidTypeUser: type = _T( "user" ); break;
00125 case SidTypeGroup: type = _T( "group" ); break;
00126 case SidTypeDomain: type = _T( "domain" ); break;
00127 case SidTypeAlias: type = _T( "alias" ); break;
00128 case SidTypeWellKnownGroup: type = _T( "well-known group" ); break;
00129 case SidTypeDeletedAccount: type = _T( "deleted account" ); break;
00130 case SidTypeInvalid: type = _T( "invalid type" ); break;
00131 case SidTypeUnknown: type = _T( "unknown type" ); break;
00132 default: type = _T( "bad sidUse value" ); break;
00133 }
00134 _tprintf( _T( "%s%s%s (%s)\n" ), domain, ( domain == 0 || *domain == '\0' )? _T( "" ): _T( "\\" ), name, type );
00135 }
00136 else
00137 {
00138 rc = GetLastError();
00139 _tprintf( _T( "[%s] *** error %lu\n" ), sidToText( psid ), rc );
00140 }
00141 }
|
|
|
Definition at line 11 of file dumpacl.cpp. Referenced by printSid(). 00012 {
00013 // S-rev- + SIA + subauthlen*maxsubauth + terminator
00014 static TCHAR buf[15 + 12 + 12*SID_MAX_SUB_AUTHORITIES + 1];
00015 TCHAR *p = &buf[0];
00016 PSID_IDENTIFIER_AUTHORITY psia;
00017 DWORD numSubAuths, i;
00018
00019 // Validate the binary SID.
00020
00021 if ( ! IsValidSid( psid ) )
00022 return FALSE;
00023
00024 psia = GetSidIdentifierAuthority( psid );
00025
00026 p = buf;
00027 p += _sntprintf( p, &buf[sizeof buf] - p, _T( "S-%lu-" ), 0x0f & *( (byte *) psid ) );
00028
00029 if ( ( psia->Value[0] != 0 ) || ( psia->Value[1] != 0 ) )
00030 p += _sntprintf( p, &buf[sizeof buf] - p, _T( "0x%02hx%02hx%02hx%02hx%02hx%02hx" ),
00031 (USHORT) psia->Value[0], (USHORT) psia->Value[1],
00032 (USHORT) psia->Value[2], (USHORT) psia->Value[3],
00033 (USHORT) psia->Value[4], (USHORT) psia->Value[5] );
00034 else
00035 p += _sntprintf( p, &buf[sizeof buf] - p, _T( "%lu" ), (ULONG) ( psia->Value[5] ) +
00036 (ULONG) ( psia->Value[4] << 8 ) + (ULONG) ( psia->Value[3] << 16 ) +
00037 (ULONG) ( psia->Value[2] << 24 ) );
00038
00039 // Add SID subauthorities to the string.
00040
00041 numSubAuths = *GetSidSubAuthorityCount( psid );
00042 for ( i = 0; i < numSubAuths; ++ i )
00043 p += _sntprintf( p, &buf[sizeof buf] - p, _T( "-%lu" ), *GetSidSubAuthority( psid, i ) );
00044
00045 return buf;
00046 }
|
1.2.2 written by Dimitri van Heesch,
© 1997-2000