Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

ctsertl.c

Go to the documentation of this file.
00001 /*++
00002 
00003 Copyright (c) 1989  Microsoft Corporation
00004 
00005 Module Name:
00006 
00007     ctsertl.c
00008 
00009 Abstract:
00010 
00011     Common security RTL test routines.
00012 
00013     These routines are used in both the kernel and user mode RTL tests.
00014 
00015 
00016 
00017 Author:
00018 
00019     Jim Kelly       (JimK)     23-Mar-1990
00020 
00021 Environment:
00022 
00023     Test of security.
00024 
00025 Revision History:
00026 
00027 --*/
00028 
00029 #include "tsecomm.c"
00030 
00031 
00032 
00033 
00035 //                                                            //
00036 // Test routines                                              //
00037 //                                                            //
00039 
00040 
00041 BOOLEAN
00042 TestSeSid()
00043 {
00044 
00045 #define TARGET_SID_ARRAY_LENGTH   1024
00046 
00047 typedef struct _TALT_SID1 {
00048     ULONG Value[3];
00049 } TALT_SID1;
00050 typedef TALT_SID1 *PTALT_SID1;
00051 
00052     NTSTATUS Status;
00053 
00054     PVOID Ignore;
00055 
00056     PSID TFredSid;
00057     PSID TBarneySid;
00058     PSID TWilmaSid;
00059     PSID TWilmaSubSid;
00060     PSID TNoSubSid;
00061     PSID TTempSid;
00062 
00063     PSID_AND_ATTRIBUTES SourceArray;
00064     PSID_AND_ATTRIBUTES TargetArray;
00065     ULONG TargetLength;
00066     ULONG OriginalTargetLength;
00067 
00068     ULONG NormalGroupAttributes;
00069     ULONG OwnerGroupAttributes;
00070 
00071     // Temporary Hack ...
00072     NormalGroupAttributes = 7;
00073     OwnerGroupAttributes = 15;
00074     // End Temporary Hack...
00075 
00076 
00077     TFredSid     = (PSID)TstAllocatePool( PagedPool, 256 );
00078     TBarneySid   = (PSID)TstAllocatePool( PagedPool, 256 );
00079     TWilmaSid    = (PSID)TstAllocatePool( PagedPool, 256 );
00080     TWilmaSubSid = (PSID)TstAllocatePool( PagedPool, 256 );
00081     TNoSubSid    = (PSID)TstAllocatePool( PagedPool, 256 );
00082     TTempSid     = (PSID)TstAllocatePool( PagedPool, 256 );
00083 
00084 
00085     //
00086     // Valid SID structure test
00087     //
00088 
00089     if (!RtlValidSid( TFredSid )) {
00090         DbgPrint("**** Failed **** \n");
00091         DbgPrint("*Se**     Failure: RtlValidSid, TFredSid\n");
00092         return FALSE;
00093     }
00094 
00095     if (!RtlValidSid( TBarneySid )) {
00096         DbgPrint("**** Failed **** \n");
00097         DbgPrint("*Se**     Failure: RtlValidSid, TBarneySid\n");
00098         return FALSE;
00099     }
00100 
00101     if (!RtlValidSid( TWilmaSid )) {
00102         DbgPrint("**** Failed **** \n");
00103         DbgPrint("*Se**     Failure: RtlValidSid, TWilmaSid\n");
00104         return FALSE;
00105     }
00106 
00107     if (!RtlValidSid( TWilmaSubSid )) {
00108         DbgPrint("**** Failed **** \n");
00109         DbgPrint("*Se**     Failure: RtlValidSid, TWilmaSubSid\n");
00110         return FALSE;
00111     }
00112 
00113     if (!RtlValidSid( TNoSubSid )) {
00114         DbgPrint("**** Failed **** \n");
00115         DbgPrint("*Se**     Failure: RtlValidSid, TNoSubSid\n");
00116         return FALSE;
00117     }
00118 
00119 
00120     //
00121     // Equal SIDs Test
00122     //
00123 
00124     if (RtlEqualSid( TFredSid, TBarneySid )) {
00125         DbgPrint("*Se**     Failure: RtlEqualSid, TFredSid - TBarneySid\n");
00126         DbgPrint("**** Failed **** \n");
00127         return FALSE;
00128     }
00129 
00130     if (!RtlEqualSid( TFredSid, TFredSid )) {
00131         DbgPrint("*Se**     Failure: RtlEqualSid, TFredSid - TFredSid\n");
00132         return FALSE;
00133     }
00134 
00135     if (RtlEqualSid( TWilmaSid, TWilmaSubSid )) {
00136         DbgPrint("**** Failed **** \n");
00137         DbgPrint("*Se**     Failure: RtlEqualSid, TWilmaSid - TWilmaSubSid\n");
00138         return FALSE;
00139     }
00140 
00141     if (RtlEqualSid( TWilmaSid, TNoSubSid )) {
00142         DbgPrint("**** Failed **** \n");
00143         DbgPrint("*Se**     Failure: RtlEqualSid, TWilmaSid - TNoSubSid\n");
00144         return FALSE;
00145     }
00146 
00147 
00148     //
00149     // Length Required test
00150     //
00151 
00152     if (RtlLengthRequiredSid( 0 ) != 8) {
00153         DbgPrint("**** Failed **** \n");
00154         DbgPrint("*Se**     Failure: RtlLengthRequiredSid, 0 SubAuthorities\n");
00155         return FALSE;
00156     }
00157 
00158     if (RtlLengthRequiredSid( 1 ) != 12) {
00159         DbgPrint("**** Failed **** \n");
00160         DbgPrint("*Se**     Failure: RtlLengthRequiredSid, 1 SubAuthorities\n");
00161         return FALSE;
00162     }
00163 
00164     if (RtlLengthRequiredSid( 2 ) != 16) {
00165         DbgPrint("**** Failed **** \n");
00166         DbgPrint("*Se**     Failure: RtlLengthRequiredSid, 2 SubAuthorities\n");
00167         return FALSE;
00168     }
00169 
00170 
00171     //
00172     // Length of SID test
00173     //
00174 
00175     if (SeLengthSid( TNoSubSid ) != 8) {
00176         DbgPrint("**** Failed **** \n");
00177         DbgPrint("*Se**     Failure: SeLengthSid, TNoSubSid\n");
00178         return FALSE;
00179     }
00180 
00181     if (SeLengthSid( TFredSid ) != 12) {
00182         DbgPrint("**** Failed **** \n");
00183         DbgPrint("*Se**     Failure: SeLengthSid, TFredSid\n");
00184         return FALSE;
00185     }
00186 
00187     if (SeLengthSid( TWilmaSubSid ) != 16) {
00188         DbgPrint("**** Failed **** \n");
00189         DbgPrint("*Se**     Failure: SeLengthSid, TWilmaSubSid\n");
00190         return FALSE;
00191     }
00192 
00193 
00194     //
00195     // Copy SID Test
00196     //
00197 
00198     if (NT_SUCCESS(RtlCopySid( 7, TTempSid, TNoSubSid ))) {
00199         DbgPrint("**** Failed **** \n");
00200         DbgPrint("*Se**     Failure: RtlCopySid, insufficient TNoSubSid\n");
00201         return FALSE;
00202     }
00203 
00204 
00205     if (!NT_SUCCESS(RtlCopySid( 256, TTempSid, TNoSubSid ))) {
00206         DbgPrint("**** Failed **** \n");
00207         DbgPrint("*Se**     Failure: RtlCopySid, TNoSubSid\n");
00208         return FALSE;
00209     }
00210 
00211     if (!RtlEqualSid( TTempSid, TNoSubSid )) {
00212         DbgPrint("**** Failed **** \n");
00213         DbgPrint("*Se**     Failure: RtlCopySid compare, TNoSubSid\n");
00214         return FALSE;
00215     }
00216 
00217 
00218     if (NT_SUCCESS(RtlCopySid( 11, TTempSid, TBarneySid ))) {
00219         DbgPrint("**** Failed **** \n");
00220         DbgPrint("*Se**     Failure: RtlCopySid, insufficient TBarneySid\n");
00221         return FALSE;
00222     }
00223 
00224 
00225     if (!NT_SUCCESS(RtlCopySid( 256, TTempSid, TBarneySid ))) {
00226         DbgPrint("**** Failed **** \n");
00227         DbgPrint("*Se**     Failure: RtlCopySid, TBarneySid\n");
00228         return FALSE;
00229     }
00230 
00231     if (!RtlEqualSid( TTempSid, TBarneySid )) {
00232         DbgPrint("**** Failed **** \n");
00233         DbgPrint("*Se**     Failure: RtlCopySid compare, TBarneySid\n");
00234         return FALSE;
00235     }
00236 
00237     if (NT_SUCCESS(RtlCopySid( 15, TTempSid, TWilmaSubSid ))) {
00238         DbgPrint("**** Failed **** \n");
00239         DbgPrint("*Se**     Failure: RtlCopySid, insufficient TWilmaSubSid\n");
00240         return FALSE;
00241     }
00242 
00243     if (!NT_SUCCESS(RtlCopySid( 256, TTempSid, TWilmaSubSid ))) {
00244         DbgPrint("**** Failed **** \n");
00245         DbgPrint("*Se**     Failure: RtlCopySid, TNoSubSid\n");
00246         return FALSE;
00247     }
00248 
00249     if (!RtlEqualSid( TTempSid, TWilmaSubSid )) {
00250         DbgPrint("**** Failed **** \n");
00251         DbgPrint("*Se**     Failure: RtlCopySid compare, TWilmaSubSid\n");
00252         return FALSE;
00253     }
00254 
00255 
00256     //
00257     // Validate all the tsevars SIDs
00258     //
00259 
00260     //
00261     //  Bedrock SIDs
00262     //
00263 
00264 
00265     if (!RtlValidSid( BedrockDomainSid )) {
00266         DbgPrint("**** Failed **** \n");
00267         DbgPrint("*Se**     Failure: RtlValidSid, BedrockDomainSid\n");
00268         return FALSE;
00269     }
00270 
00271     if (!RtlValidSid( FredSid )) {
00272         DbgPrint("**** Failed **** \n");
00273         DbgPrint("*Se**     Failure: RtlValidSid, FredSid\n");
00274         return FALSE;
00275     }
00276 
00277     if (!RtlValidSid( WilmaSid )) {
00278         DbgPrint("**** Failed **** \n");
00279         DbgPrint("*Se**     Failure: RtlValidSid, WilmaSid\n");
00280         return FALSE;
00281     }
00282 
00283     if (!RtlValidSid( PebblesSid )) {
00284         DbgPrint("**** Failed **** \n");
00285         DbgPrint("*Se**     Failure: RtlValidSid, PebblesSid\n");
00286         return FALSE;
00287     }
00288 
00289     if (!RtlValidSid( DinoSid )) {
00290         DbgPrint("**** Failed **** \n");
00291         DbgPrint("*Se**     Failure: RtlValidSid, DinoSid\n");
00292         return FALSE;
00293     }
00294 
00295     if (!RtlValidSid( BarneySid )) {
00296         DbgPrint("**** Failed **** \n");
00297         DbgPrint("*Se**     Failure: RtlValidSid, BarneySid\n");
00298         return FALSE;
00299     }
00300 
00301     if (!RtlValidSid( BettySid )) {
00302         DbgPrint("**** Failed **** \n");
00303         DbgPrint("*Se**     Failure: RtlValidSid, BettySid\n");
00304         return FALSE;
00305     }
00306 
00307     if (!RtlValidSid( BambamSid )) {
00308         DbgPrint("**** Failed **** \n");
00309         DbgPrint("*Se**     Failure: RtlValidSid, BambamSid\n");
00310         return FALSE;
00311     }
00312 
00313     if (!RtlValidSid( FlintstoneSid )) {
00314         DbgPrint("**** Failed **** \n");
00315         DbgPrint("*Se**     Failure: RtlValidSid, FlintstoneSid\n");
00316         return FALSE;
00317     }
00318 
00319     if (!RtlValidSid( RubbleSid )) {
00320         DbgPrint("**** Failed **** \n");
00321         DbgPrint("*Se**     Failure: RtlValidSid, RubbleSid\n");
00322         return FALSE;
00323     }
00324 
00325     if (!RtlValidSid( AdultSid )) {
00326         DbgPrint("**** Failed **** \n");
00327         DbgPrint("*Se**     Failure: RtlValidSid, AdultSid\n");
00328         return FALSE;
00329     }
00330 
00331     if (!RtlValidSid( ChildSid )) {
00332         DbgPrint("**** Failed **** \n");
00333         DbgPrint("*Se**     Failure: RtlValidSid, ChildSid\n");
00334         return FALSE;
00335     }
00336 
00337     if (!RtlValidSid( NeandertholSid )) {
00338         DbgPrint("**** Failed **** \n");
00339         DbgPrint("*Se**     Failure: RtlValidSid, NeandertholSid\n");
00340         return FALSE;
00341     }
00342 
00343     //
00344     //  Well known SIDs
00345     //
00346 
00347     if (!RtlValidSid( NullSid )) {
00348         DbgPrint("**** Failed **** \n");
00349         DbgPrint("*Se**     Failure: RtlValidSid, NullSid\n");
00350         return FALSE;
00351     }
00352 
00353     if (!RtlValidSid( WorldSid )) {
00354         DbgPrint("**** Failed **** \n");
00355         DbgPrint("*Se**     Failure: RtlValidSid, WorldSid\n");
00356         return FALSE;
00357     }
00358 
00359     if (!RtlValidSid( LocalSid )) {
00360         DbgPrint("**** Failed **** \n");
00361         DbgPrint("*Se**     Failure: RtlValidSid, CreatorSid\n");
00362         return FALSE;
00363     }
00364 
00365     if (!RtlValidSid( NtAuthoritySid )) {
00366         DbgPrint("**** Failed **** \n");
00367         DbgPrint("*Se**     Failure: RtlValidSid, NtAuthoritySid\n");
00368         return FALSE;
00369     }
00370 
00371     if (!RtlValidSid( DialupSid )) {
00372         DbgPrint("**** Failed **** \n");
00373         DbgPrint("*Se**     Failure: RtlValidSid, DialupSid\n");
00374         return FALSE;
00375     }
00376 
00377     if (!RtlValidSid( NetworkSid )) {
00378         DbgPrint("**** Failed **** \n");
00379         DbgPrint("*Se**     Failure: RtlValidSid, NetworkSid\n");
00380         return FALSE;
00381     }
00382 
00383     if (!RtlValidSid( BatchSid )) {
00384         DbgPrint("**** Failed **** \n");
00385         DbgPrint("*Se**     Failure: RtlValidSid, BatchSid\n");
00386         return FALSE;
00387     }
00388 
00389     if (!RtlValidSid( InteractiveSid )) {
00390         DbgPrint("**** Failed **** \n");
00391         DbgPrint("*Se**     Failure: RtlValidSid, InteractiveSid\n");
00392         return FALSE;
00393     }
00394 
00395 
00396     if (!RtlValidSid( LocalSystemSid )) {
00397         DbgPrint("**** Failed **** \n");
00398         DbgPrint("*Se**     Failure: RtlValidSid, LocalSystemSid\n");
00399         return FALSE;
00400     }
00401 
00402 
00403 
00404 
00405     //
00406     //  Test SidAndAttributesArray copy routine
00407     //
00408 
00409     SourceArray = (PSID_AND_ATTRIBUTES)TstAllocatePool( PagedPool, 100 );
00410     TargetArray = (PSID_AND_ATTRIBUTES)TstAllocatePool( PagedPool,
00411                                                         TARGET_SID_ARRAY_LENGTH
00412                                                         );
00413     TargetLength = TARGET_SID_ARRAY_LENGTH - (5 * sizeof(PSID_AND_ATTRIBUTES));
00414     OriginalTargetLength = TargetLength;
00415 
00416     SourceArray[0].Sid = &PebblesSid;
00417     SourceArray[0].Attributes = 0;
00418     SourceArray[1].Sid = &FlintstoneSid;
00419     SourceArray[1].Attributes = OwnerGroupAttributes;
00420     SourceArray[2].Sid = &ChildSid;
00421     SourceArray[2].Attributes = NormalGroupAttributes;
00422     SourceArray[3].Sid = &NeandertholSid;
00423     SourceArray[3].Attributes = NormalGroupAttributes;
00424     SourceArray[4].Sid = &WorldSid;
00425     SourceArray[4].Attributes = NormalGroupAttributes;
00426 
00427     Status = RtlCopySidAndAttributesArray(
00428                  0,
00429                  SourceArray,
00430                  TargetLength,
00431                  TargetArray,
00432                  &(TargetArray[5]),
00433                  &(PSID)Ignore,
00434                  &TargetLength
00435                  );
00436 
00437     if (!NT_SUCCESS(Status) || TargetLength != OriginalTargetLength ) {
00438         DbgPrint("**** Failed **** \n");
00439         DbgPrint("*Se**     Failure: RtLCopySidAndAttributesArray, Zero length.\n");
00440         return FALSE;
00441     }
00442 
00443 
00444 
00445     Status = RtlCopySidAndAttributesArray(
00446                  1,
00447                  SourceArray,
00448                  1,                 // too short buffer
00449                  TargetArray,
00450                  &(TargetArray[1]),
00451                  &(PSID)Ignore,
00452                  &TargetLength
00453                  );
00454 
00455     if (NT_SUCCESS(Status)) {
00456         DbgPrint("**** Failed **** \n");
00457         DbgPrint("*Se**     Failure: RtLCopySidAndAttributesArray,\n");
00458         DbgPrint("*Se**              Buffer Too Short Test.\n");
00459         return FALSE;
00460     }
00461 
00462 
00463     TargetLength = TARGET_SID_ARRAY_LENGTH - (5 * sizeof(PSID_AND_ATTRIBUTES));
00464     OriginalTargetLength = TargetLength;
00465 
00466     Status = RtlCopySidAndAttributesArray(
00467                  5,
00468                  SourceArray,
00469                  TargetLength,
00470                  TargetArray,
00471                  &(TargetArray[5]),
00472                  &(PSID)Ignore,
00473                  &TargetLength
00474                  );
00475 
00476     if (!NT_SUCCESS(Status) ||
00477         !RtlEqualSid( SourceArray[0].Sid, TargetArray[0].Sid ) ||
00478         !RtlEqualSid( SourceArray[1].Sid, TargetArray[1].Sid ) ||
00479         !RtlEqualSid( SourceArray[2].Sid, TargetArray[2].Sid ) ||
00480         !RtlEqualSid( SourceArray[3].Sid, TargetArray[3].Sid ) ||
00481         !RtlEqualSid( SourceArray[4].Sid, TargetArray[4].Sid ) ||
00482         ( SourceArray[0].Attributes != TargetArray[0].Attributes )  ||
00483         ( SourceArray[1].Attributes != TargetArray[1].Attributes )  ||
00484         ( SourceArray[2].Attributes != TargetArray[2].Attributes )  ||
00485         ( SourceArray[3].Attributes != TargetArray[3].Attributes )  ||
00486         ( SourceArray[4].Attributes != TargetArray[4].Attributes ) ) {
00487 
00488         DbgPrint("**** Failed **** \n");
00489         DbgPrint("*Se**     Failure: RtLCopySidAndAttributesArray,\n");
00490         DbgPrint("*Se**              Valid copy of 5 SIDs test.\n");
00491         return FALSE;
00492     }
00493 
00494 
00495 
00496     return TRUE;
00497 
00498 
00499 }
00500 
00501 
00502 BOOLEAN
00503 TestSeSecurityDescriptor()
00504 {
00505     NTSTATUS Status;
00506     PSECURITY_DESCRIPTOR TFredDescriptor;
00507     PSECURITY_DESCRIPTOR TBarneyDescriptor;
00508     PSECURITY_DESCRIPTOR TWilmaDescriptor;
00509 
00510     PSECURITY_DESCRIPTOR TTempDescriptor;
00511 
00512     SECURITY_DESCRIPTOR_CONTROL Control;
00513     ULONG Revision;
00514 
00515     PACL TDacl;
00516     BOOLEAN TDaclPresent;
00517     BOOLEAN TDaclDefaulted;
00518 
00519     PACL TSacl;
00520     BOOLEAN TSaclPresent;
00521     BOOLEAN TSaclDefaulted;
00522 
00523     PSID TOwner;
00524     BOOLEAN TOwnerDefaulted;
00525     PSID TGroup;
00526     BOOLEAN TGroupDefaulted;
00527 
00528 
00529     PSID TFredSid;
00530     PSID TBarneySid;
00531     PSID TWilmaSid;
00532     PSID TWilmaSubSid;
00533     PSID TNoSubSid;
00534     PSID TTempSid;
00535 
00536 
00537     TFredDescriptor   = (PSECURITY_DESCRIPTOR)TstAllocatePool( PagedPool, 1024 );
00538     TBarneyDescriptor = (PSECURITY_DESCRIPTOR)TstAllocatePool( PagedPool, 1024 );
00539     TWilmaDescriptor  = (PSECURITY_DESCRIPTOR)TstAllocatePool( PagedPool, 1024 );
00540     TTempDescriptor   = (PSECURITY_DESCRIPTOR)TstAllocatePool( PagedPool, 1024 );
00541 
00542 
00543     TFredSid     = (PSID)TstAllocatePool( PagedPool, 256 );
00544     TBarneySid   = (PSID)TstAllocatePool( PagedPool, 256 );
00545     TWilmaSid    = (PSID)TstAllocatePool( PagedPool, 256 );
00546     TWilmaSubSid = (PSID)TstAllocatePool( PagedPool, 256 );
00547     TNoSubSid    = (PSID)TstAllocatePool( PagedPool, 256 );
00548     TTempSid     = (PSID)TstAllocatePool( PagedPool, 256 );
00549 
00550 
00551     //
00552     // Build an ACL or two for use.
00553 
00554     TDacl        = (PACL)TstAllocatePool( PagedPool, 256 );
00555     TSacl        = (PACL)TstAllocatePool( PagedPool, 256 );
00556 
00557     TDacl->AclRevision=TSacl->AclRevision=ACL_REVISION;
00558     TDacl->Sbz1=TSacl->Sbz1=0;
00559     TDacl->Sbz2=TSacl->Sbz2=0;
00560     TDacl->AclSize=256;
00561     TSacl->AclSize=8;
00562     TDacl->AceCount=TSacl->AceCount=0;
00563 
00564 
00565     //
00566     // Create Security Descriptor test
00567     //
00568 
00569     if (NT_SUCCESS(RtlCreateSecurityDescriptor( TTempDescriptor, 0 ))) {
00570         DbgPrint("**** Failed **** \n");
00571         DbgPrint("*Se**     Failure: RtlCreateSecurityDescriptor, Rev=0\n");
00572         return FALSE;
00573     }
00574 
00575     if (NT_SUCCESS(RtlCreateSecurityDescriptor( TTempDescriptor, 2 ))) {
00576         DbgPrint("**** Failed **** \n");
00577         DbgPrint("*Se**     Failure: RtlCreateSecurityDescriptor, Rev=2\n");
00578         return FALSE;
00579     }
00580 
00581     if (!NT_SUCCESS(RtlCreateSecurityDescriptor( TTempDescriptor, 1 ))) {
00582         DbgPrint("**** Failed **** \n");
00583         DbgPrint("*Se**     Failure: RtlCreateSecurityDescriptor, Rev=1\n");
00584         return FALSE;
00585     }
00586 
00587 #ifdef NOT_YET_DEBUGGED
00588     //
00589     // Make sure fields have been set properly
00590     //
00591 
00592     if (!NT_SUCCESS(RtlGetControlSecurityDescriptor( TTempDescriptor,
00593                                                &Control,
00594                                                &Revision))) {
00595         DbgPrint("**** Failed **** \n");
00596         DbgPrint("*Se**     Failure: RtlGetControlSecurityDescriptor\n");
00597         DbgPrint("*Se**     Call failed.  Status = 0x%lx\n", Status);
00598         return FALSE;
00599     }
00600 
00601     if ( (Control != 0) || (Revision != 1) ) {
00602         DbgPrint("**** Failed **** \n");
00603         DbgPrint("*Se**     Failure: RtlGetControlSecurityDescriptor\n");
00604         DbgPrint("*Se**     Bad Control or Revision value. \n");
00605         DbgPrint("*Se**     Status = 0x%lx\n", Status);
00606         DbgPrint("*Se**     Returned Revision = 0x%lx\n",Revision );
00607         DbgPrint("*Se**     Returned Control  = 0x%lx\n", (ULONG)Control);
00608         return FALSE;
00609     }
00610 #else
00611     DBG_UNREFERENCED_LOCAL_VARIABLE( Status );
00612     DBG_UNREFERENCED_LOCAL_VARIABLE( Revision );
00613     DBG_UNREFERENCED_LOCAL_VARIABLE( Control );
00614 #endif //NOT_YET_DEFINED
00615 
00616     if (!NT_SUCCESS(RtlGetDaclSecurityDescriptor( TTempDescriptor,
00617                                                &TDaclPresent,
00618                                                &TDacl,
00619                                                &TDaclDefaulted))) {
00620         DbgPrint("**** Failed **** \n");
00621         DbgPrint("*Se**     Failure: RtlGetDaclSecurityDescriptor, Empty\n");
00622         return FALSE;
00623     }
00624 
00625     if (TDaclPresent) {
00626         DbgPrint("**** Failed **** \n");
00627         DbgPrint("*Se**     Failure: RtlGetDaclSecurityDescriptor, Empty-TDaclPresent\n");
00628         return FALSE;
00629     }
00630 
00631     if (!NT_SUCCESS(RtlGetSaclSecurityDescriptor( TTempDescriptor,
00632                                                &TSaclPresent,
00633                                                &TSacl,
00634                                                &TSaclDefaulted))) {
00635         DbgPrint("**** Failed **** \n");
00636         DbgPrint("*Se**     Failure: RtlGetSaclSecurityDescriptor, Empty\n");
00637         return FALSE;
00638     }
00639 
00640     if (TSaclPresent) {
00641         DbgPrint("**** Failed **** \n");
00642         DbgPrint("*Se**     Failure: RtlGetSaclSecurityDescriptor, Empty-TSaclPresent\n");
00643         return FALSE;
00644     }
00645 
00646     if (!NT_SUCCESS(RtlGetOwnerSecurityDescriptor( TTempDescriptor,
00647                                                 &TOwner,
00648                                                 &TOwnerDefaulted))) {
00649         DbgPrint("**** Failed **** \n");
00650         DbgPrint("*Se**     Failure: RtlGetOwnerSecurityDescriptor, Empty\n");
00651         return FALSE;
00652     }
00653 
00654     if (TOwner != NULL) {
00655         DbgPrint("**** Failed **** \n");
00656         DbgPrint("*Se**     Failure: RtlGetOwnerSecurityDescriptor, Empty-TOwner\n");
00657         return FALSE;
00658     }
00659 
00660     if (!NT_SUCCESS(RtlGetGroupSecurityDescriptor( TTempDescriptor,
00661                                                 &TGroup,
00662                                                 &TGroupDefaulted))) {
00663         DbgPrint("**** Failed **** \n");
00664         DbgPrint("*Se**     Failure: RtlGetGroupSecurityDescriptor, Empty\n");
00665         return FALSE;
00666     }
00667 
00668     if (TGroup != NULL) {
00669         DbgPrint("**** Failed **** \n");
00670         DbgPrint("*Se**     Failure: RtlGetGroupSecurityDescriptor, Empty-TGroup\n");
00671         return FALSE;
00672     }
00673 
00674     //
00675     // Valid Security Descriptor test
00676     //
00677 
00678     ((SECURITY_DESCRIPTOR *)TTempDescriptor)->Revision=0;
00679     if (RtlValidSecurityDescriptor( TTempDescriptor )) {
00680         DbgPrint("**** Failed **** \n");
00681         DbgPrint("*Se**     Failure: RtlValidSecurityDescriptor, Rev=0\n");
00682         return FALSE;
00683     }
00684     ((SECURITY_DESCRIPTOR *)TTempDescriptor)->Revision=1;
00685 
00686     if (!RtlValidSecurityDescriptor( TTempDescriptor )) {
00687         DbgPrint("**** Failed **** \n");
00688         DbgPrint("*Se**     Failure: RtlValidSecurityDescriptor, Empty\n");
00689         return FALSE;
00690     }
00691 
00692 
00693     //
00694     // Length test
00695     //
00696 
00697     if (RtlLengthSecurityDescriptor( TTempDescriptor ) != 20) {
00698         DbgPrint("**** Failed **** \n");
00699         DbgPrint("*Se**     Failure: RtlLengthSecurityDescriptor, Empty\n");
00700         return FALSE;
00701     }
00702 
00703     //
00704     // Add in an owner
00705     //
00706 
00707     if (!NT_SUCCESS(RtlSetOwnerSecurityDescriptor( TTempDescriptor, TWilmaSid, FALSE ))) {
00708         DbgPrint("**** Failed **** \n");
00709         DbgPrint("*Se**     Failure: RtlSetOwnerSecurityDescriptor, TWilmaSid\n");
00710         return FALSE;
00711     }
00712     if (RtlLengthSecurityDescriptor( TTempDescriptor ) != 32) {
00713         DbgPrint("**** Failed **** \n");
00714         DbgPrint("*Se**     Failure: RtlLengthSecurityDescriptor, Wilma Owner\n");
00715         return FALSE;
00716     }
00717 
00718     //
00719     // Add in a Dacl
00720     //
00721 
00722     if (!NT_SUCCESS(RtlSetDaclSecurityDescriptor( TTempDescriptor, TRUE,
00723                                               TDacl, FALSE ))) {
00724         DbgPrint("**** Failed **** \n");
00725         DbgPrint("*Se**     Failure: RtlSetDaclSecurityDescriptor, TDacl\n");
00726         return FALSE;
00727     }
00728     if (RtlLengthSecurityDescriptor( TTempDescriptor ) != 40) {
00729         DbgPrint("**** Failed **** \n");
00730         DbgPrint("*Se**     Failure: RtlLengthSecurityDescriptor, TDacl Dacl\n");
00731         return FALSE;
00732     }
00733 
00734     //
00735     // Add in a Sacl
00736     //
00737 
00738     if (!NT_SUCCESS(RtlSetSaclSecurityDescriptor( TTempDescriptor, TRUE,
00739                                               TSacl, FALSE ))) {
00740         DbgPrint("**** Failed **** \n");
00741         DbgPrint("*Se**     Failure: RtlSetSaclSecurityDescriptor, TSacl\n");
00742         return FALSE;
00743     }
00744     if (RtlLengthSecurityDescriptor( TTempDescriptor ) != 48) {
00745         DbgPrint("**** Failed **** \n");
00746         DbgPrint("*Se**     Failure: RtlLengthSecurityDescriptor, TSacl Sacl\n");
00747         return FALSE;
00748     }
00749 
00750     //
00751     // Add in a Group (with 2 sub-authorities)
00752     //
00753 
00754     if (!NT_SUCCESS(RtlSetGroupSecurityDescriptor( TTempDescriptor, TWilmaSubSid, FALSE ))) {
00755         DbgPrint("**** Failed **** \n");
00756         DbgPrint("*Se**     Failure: RtlSetGroupSecurityDescriptor, TWilmaSubSid\n");
00757         return FALSE;
00758     }
00759     if (RtlLengthSecurityDescriptor( TTempDescriptor ) != 64) {
00760         DbgPrint("**** Failed **** \n");
00761         DbgPrint("*Se**     Failure: RtlLengthSecurityDescriptor, WilmaSub Group\n");
00762         return FALSE;
00763     }
00764 
00765 
00766     return TRUE;
00767 
00768 }
00769 
00770 
00771 BOOLEAN
00772 TestSeAccessMask()
00773 {
00774     return TRUE;
00775 }
00776 
00777 
00778 
00779 
00780 VOID
00781 DumpAclSizeInfo(PACL_SIZE_INFORMATION AclSizeInfo)
00782 {
00783     DbgPrint("\n");
00784     DbgPrint("Acl size info:\n");
00785     DbgPrint("AceCount = %d\n",AclSizeInfo->AceCount);
00786     DbgPrint("AclBytesInUse = %d\n",AclSizeInfo->AclBytesInUse);
00787     DbgPrint("AclBytesFree = %d\n",AclSizeInfo->AclBytesFree);
00788     return;
00789 }
00790 
00791 #define NUM_ACE 6
00792 
00793 typedef struct _SIMPLE_ACE {
00794     ACE_HEADER Header;
00795     ACCESS_MASK Mask;
00796     SID Sid;
00797     } SIMPLE_ACE, *PSIMPLE_ACE;
00798 
00799 
00800 BOOLEAN
00801 TestSeAclRtl()
00802 {
00803 
00804     PACL    TDacl;
00805     NTSTATUS Status;
00806 
00807     ACL_REVISION_INFORMATION AclInformation;
00808     ACL_REVISION_INFORMATION AclInformationOut;
00809 
00810     ACL_SIZE_INFORMATION AclSizeInfo;
00811 
00812     PVOID AceList;
00813     PVOID Ace;
00814 
00815     ULONG AceSize;
00816 
00817 //
00818 // Define the Dead domain
00819 //
00820 //     Dead Domain         S-1-54399-23-18-02
00821 //     Bobby               S-1-54399-23-18-02-2
00822 //     Jerry               S-1-54399-23-18-02-3
00823 //     Phil                S-1-54399-23-18-02-4
00824 //     Kreutzman           S-1-54399-23-18-02-5
00825 //     Brent               S-1-54399-23-18-02-6
00826 //     Micky               S-1-54399-23-18-02-7
00827 //
00828 
00829 #define DEAD_AUTHORITY               {0,0,0,0,212,127}
00830 #define DEAD_SUBAUTHORITY_0          0x00000017L
00831 #define DEAD_SUBAUTHORITY_1          0x00000012L
00832 #define DEAD_SUBAUTHORITY_2          0x00000002L
00833 
00834 #define BOBBY_RID               0x00000002
00835 #define JERRY_RID               0x00000003
00836 #define PHIL_RID                0x00000004
00837 #define KREUTZMAN_RID           0x00000005
00838 #define BRENT_RID               0x00000006
00839 #define MICKY_RID               0x00000007
00840 
00841     PSID DeadDomainSid;
00842 
00843     PSID BobbySid;
00844     PSID JerrySid;
00845     PSID PhilSid;
00846     PSID KreutzmanSid;
00847     PSID BrentSid;
00848     PSID MickySid;
00849 
00850     ULONG SidWithZeroSubAuthorities;
00851     ULONG SidWithOneSubAuthority;
00852     ULONG SidWithThreeSubAuthorities;
00853     ULONG SidWithFourSubAuthorities;
00854 
00855     SID_IDENTIFIER_AUTHORITY DeadAuthority = DEAD_AUTHORITY;
00856 
00857 
00858     //
00859     //  The following SID sizes need to be allocated
00860     //
00861 
00862     SidWithZeroSubAuthorities  = RtlLengthRequiredSid( 0 );
00863     SidWithOneSubAuthority     = RtlLengthRequiredSid( 1 );
00864     SidWithThreeSubAuthorities = RtlLengthRequiredSid( 3 );
00865     SidWithFourSubAuthorities  = RtlLengthRequiredSid( 4 );
00866 
00867     DeadDomainSid   = (PSID)TstAllocatePool(PagedPool,SidWithThreeSubAuthorities);
00868 
00869     BobbySid    = (PSID)TstAllocatePool(PagedPool,SidWithFourSubAuthorities);
00870     JerrySid    = (PSID)TstAllocatePool(PagedPool,SidWithFourSubAuthorities);
00871     PhilSid     = (PSID)TstAllocatePool(PagedPool,SidWithFourSubAuthorities);
00872     KreutzmanSid    = (PSID)TstAllocatePool(PagedPool,SidWithFourSubAuthorities);
00873 
00874     BrentSid    = (PSID)TstAllocatePool(PagedPool,SidWithFourSubAuthorities);
00875     MickySid    = (PSID)TstAllocatePool(PagedPool,SidWithFourSubAuthorities);
00876 
00877     RtlInitializeSid( DeadDomainSid,   &DeadAuthority, 3 );
00878     *(RtlSubAuthoritySid( DeadDomainSid, 0)) = DEAD_SUBAUTHORITY_0;
00879     *(RtlSubAuthoritySid( DeadDomainSid, 1)) = DEAD_SUBAUTHORITY_1;
00880     *(RtlSubAuthoritySid( DeadDomainSid, 2)) = DEAD_SUBAUTHORITY_2;
00881 
00882     RtlCopySid( SidWithFourSubAuthorities, BobbySid, DeadDomainSid);
00883     *(RtlSubAuthorityCountSid( BobbySid )) += 1;
00884     *(RtlSubAuthoritySid( BobbySid, 3)) = BOBBY_RID;
00885 
00886     RtlCopySid( SidWithFourSubAuthorities, JerrySid, DeadDomainSid);
00887     *(RtlSubAuthorityCountSid( JerrySid )) += 1;
00888     *(RtlSubAuthoritySid( JerrySid, 3)) = JERRY_RID;
00889 
00890     RtlCopySid( SidWithFourSubAuthorities, PhilSid, DeadDomainSid);
00891     *(RtlSubAuthorityCountSid( PhilSid )) += 1;
00892     *(RtlSubAuthoritySid( PhilSid, 3)) = PHIL_RID;
00893 
00894     RtlCopySid( SidWithFourSubAuthorities, KreutzmanSid, DeadDomainSid);
00895     *(RtlSubAuthorityCountSid( KreutzmanSid )) += 1;
00896     *(RtlSubAuthoritySid( KreutzmanSid, 3)) = KREUTZMAN_RID;
00897 
00898     RtlCopySid( SidWithFourSubAuthorities, BrentSid, DeadDomainSid);
00899     *(RtlSubAuthorityCountSid( BrentSid )) += 1;
00900     *(RtlSubAuthoritySid( BrentSid, 3)) = BRENT_RID;
00901 
00902     RtlCopySid( SidWithFourSubAuthorities, MickySid, DeadDomainSid);
00903     *(RtlSubAuthorityCountSid( MickySid )) += 1;
00904     *(RtlSubAuthoritySid( MickySid, 3)) = MICKY_RID;
00905 
00906     TDacl = (PACL)TstAllocatePool( PagedPool, 256 );
00907 
00908     //DbgBreakPoint();
00909 
00910     if (!NT_SUCCESS(Status = RtlCreateAcl( TDacl, 256, ACL_REVISION ))) {
00911         DbgPrint("**** Failed **** \n");
00912         DbgPrint("RtlCreateAcl returned %X \n",Status);
00913         return(FALSE);
00914     }
00915 
00916     //DbgBreakPoint();
00917 
00918     if (!NT_SUCCESS( Status = RtlValidAcl( TDacl ) )) {
00919         DbgPrint("**** Failed **** \n");
00920         DbgPrint("RtlValidAcl returned %X \n",Status);
00921         return(FALSE);
00922     }
00923 
00924     //DbgBreakPoint();
00925 
00926     AclInformation.AclRevision = ACL_REVISION;
00927 
00928     if (!NT_SUCCESS( Status = RtlSetInformationAcl( TDacl, &AclInformation,
00929                 sizeof(AclInformation), AclRevisionInformation ) )) {
00930         DbgPrint("**** Failed **** \n");
00931         DbgPrint("RtlSetInformation returned %X \n",Status);
00932         return(FALSE);
00933     }
00934 
00935     if (!NT_SUCCESS( Status = RtlQueryInformationAcl( TDacl, (PVOID)&AclInformationOut,
00936                 sizeof(AclInformationOut), AclRevisionInformation ) )) {
00937         DbgPrint("**** Failed **** \n");
00938         DbgPrint("RtlQueryInformation returned %X during revision query \n",Status);
00939         return(FALSE);
00940     }
00941 
00942     if (AclInformationOut.AclRevision != ACL_REVISION) {
00943         DbgPrint("**** Failed **** \n");
00944         DbgPrint("RtlQueryInformation returned incorrect revision \n");
00945         return(FALSE);
00946     }
00947 
00948     if (!NT_SUCCESS( Status = RtlQueryInformationAcl( TDacl, (PVOID)&AclSizeInfo,
00949                 sizeof(AclSizeInfo), AclSizeInformation ) )) {
00950         DbgPrint("**** Failed **** \n");
00951         DbgPrint("RtlQueryInformation returned %X during size query \n",Status);
00952         return(FALSE);
00953     }
00954 
00955     // DumpAclSizeInfo(&AclSizeInfo);
00956 
00957     AceSize = 6 * SidWithFourSubAuthorities + 1 * SidWithThreeSubAuthorities
00958                     + 7 * (sizeof( ACE_HEADER ) + sizeof( ACCESS_MASK ));
00959 
00960     AceList = (PVOID)TstAllocatePool(PagedPool, AceSize);
00961 
00962     Ace = AceList;
00963 
00964     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
00965     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithThreeSubAuthorities +
00966                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
00967     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
00968     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
00969     RtlCopySid(SidWithThreeSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,DeadDomainSid);
00970 
00971     (ULONG)Ace += ((PSIMPLE_ACE)Ace)->Header.AceSize;
00972 
00973     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
00974     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithFourSubAuthorities +
00975                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
00976     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
00977     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
00978     RtlCopySid(SidWithFourSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,BobbySid);
00979 
00980     (ULONG)Ace += ((PSIMPLE_ACE)Ace)->Header.AceSize;
00981 
00982     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
00983     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithFourSubAuthorities +
00984                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
00985     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
00986     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
00987     RtlCopySid(SidWithFourSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,JerrySid);
00988 
00989     (ULONG)Ace += ((PSIMPLE_ACE)Ace)->Header.AceSize;
00990 
00991     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
00992     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithFourSubAuthorities +
00993                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
00994     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
00995     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
00996     RtlCopySid(SidWithFourSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,PhilSid);
00997 
00998     (ULONG)Ace += ((PSIMPLE_ACE)Ace)->Header.AceSize;
00999 
01000     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
01001     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithFourSubAuthorities +
01002                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
01003     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
01004     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
01005     RtlCopySid(SidWithFourSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,KreutzmanSid);
01006 
01007     (ULONG)Ace += ((PSIMPLE_ACE)Ace)->Header.AceSize;
01008 
01009     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
01010     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithFourSubAuthorities +
01011                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
01012     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
01013     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
01014     RtlCopySid(SidWithFourSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,BrentSid);
01015 
01016     (ULONG)Ace += ((PSIMPLE_ACE)Ace)->Header.AceSize;
01017 
01018     ((PSIMPLE_ACE)Ace)->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
01019     ((PSIMPLE_ACE)Ace)->Header.AceSize = (USHORT)SidWithFourSubAuthorities +
01020                   (USHORT)sizeof(ACE_HEADER) + (USHORT)sizeof( ACCESS_MASK );
01021     ((PSIMPLE_ACE)Ace)->Header.AceFlags = OBJECT_INHERIT_ACE;
01022     ((PSIMPLE_ACE)Ace)->Mask = DELETE;
01023     RtlCopySid(SidWithFourSubAuthorities,&((PSIMPLE_ACE)Ace)->Sid,MickySid);
01024 
01025     //DbgBreakPoint();
01026 
01027     RtlAddAce(TDacl, ACL_REVISION, 0, AceList, AceSize);
01028 
01029     if (!NT_SUCCESS( Status = RtlQueryInformationAcl( TDacl, (PVOID)&AclSizeInfo,
01030                 sizeof(AclSizeInfo), AclSizeInformation ) )) {
01031         DbgPrint("**** Failed **** \n");
01032         DbgPrint("RtlQueryInformation returned %X during size query \n",Status);
01033         return(FALSE);
01034     }
01035 
01036 #if 0
01037     RtlDumpAcl(TDacl);
01038 #endif
01039 
01040     RtlGetAce( TDacl, 5, &Ace );
01041 
01042     if ( !RtlEqualSid( &((PSIMPLE_ACE)Ace)->Sid, BrentSid) ) {
01043         DbgPrint("\n **** Failed **** \n");
01044         DbgPrint("RtlGetAce returned wrong Ace\n");
01045         return(FALSE);
01046     }
01047 
01048     if (!NT_SUCCESS(RtlDeleteAce (TDacl, 5))) {
01049         DbgPrint("\n **** Failed **** \n");
01050         DbgPrint("RtlDeleteAce failed\n");
01051         return(FALSE);
01052     }
01053 
01054 #if 0
01055     RtlDumpAcl(TDacl);
01056 #endif
01057 
01058     return(TRUE);
01059 }
01060 
01061 
01062 BOOLEAN
01063 TestSeRtl()
01064 {
01065 
01066     BOOLEAN Result = TRUE;
01067 
01068     DbgPrint("Se:   Global Variable Initialization...                        ");
01069     if (TSeVariableInitialization()) {
01070         DbgPrint("Succeeded.\n");
01071     } else {
01072         Result = FALSE;
01073     }
01074 
01075     DbgPrint("Se:   SID test...                                              ");
01076     if (TestSeSid()) {
01077         DbgPrint("Succeeded.\n");
01078     } else {
01079         Result = FALSE;
01080     }
01081 
01082     DbgPrint("Se:   SECURITY_DESCRIPTOR test...                              ");
01083     if (TestSeSecurityDescriptor()) {
01084         DbgPrint("Succeeded.\n");
01085     } else {
01086         Result = FALSE;
01087     }
01088 
01089     DbgPrint("Se:   ACCESS_MASK test...                                      ");
01090     if (TestSeAccessMask()) {
01091         DbgPrint("Succeeded.\n");
01092     } else {
01093         Result = FALSE;
01094     }
01095 
01096     DbgPrint("Se:   ACL test...                                              ");
01097     if (TestSeAclRtl()) {
01098         DbgPrint("Succeeded.\n");
01099     } else {
01100         Result = FALSE;
01101     }
01102 
01103     DbgPrint("\n");
01104     DbgPrint("\n");
01105     DbgPrint("    ********************\n");
01106     DbgPrint("    **                **\n");
01107 
01108     if (Result = TRUE) {
01109         DbgPrint("    ** Test Succeeded **\n");
01110     } else {
01111         DbgPrint("    **  Test Failed   **\n");
01112     }
01113 
01114     DbgPrint("    **                **\n");
01115     DbgPrint("    ********************\n");
01116     DbgPrint("\n");
01117     DbgPrint("\n");
01118 
01119     return Result;
01120 }
Generated on Sat May 15 19:39:37 2004 for test by doxygen 1.3.7