test: perform.c File Reference

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

# perform.c File Reference

`#include <stdio.h>`
`#include <stdlib.h>`
`#include <string.h>`
`#include <memory.h>`
`#include <wchar.h>`
`#include "windows.h"`
`#include "winreg.h"`

Go to the source code of this file.

## Defines

#define | TEST_STRING "Test String"
#define | TEST_STRING_W L"Test String"
#define | ENVIRONMENT_NAME L"Environment"
#define | TESTKEY_NAME L"TestKey"
#define | TESTKEY_FULL_NAME L"Environment\\TestKey"
#define | KEY1_NAME L"Key1"
#define | KEY1_FULL_NAME L"Environment\\TestKey\\Key1"
#define | KEY2_NAME L"Key2"
#define | KEY2_FULL_NAME L"Environment\\TestKey\\Key2"
#define | VALUE_NAME L"123"
#define | VALUE_DATA L"This is a string"

## Functions

BOOLEAN | AdjustPrivilege (PSTR SecurityNameString)
INT __cdecl | main ()

## Define Documentation

#define ENVIRONMENT_NAME L"Environment"

| Definition at line 67 of file perform.c. Referenced by main().

#define KEY1_FULL_NAME L"Environment\\TestKey\\Key1"

| Definition at line 71 of file perform.c.

#define KEY1_NAME L"Key1"

| Definition at line 70 of file perform.c. Referenced by main().

#define KEY2_FULL_NAME L"Environment\\TestKey\\Key2"

| Definition at line 73 of file perform.c.

#define KEY2_NAME L"Key2"

| Definition at line 72 of file perform.c. Referenced by main().

#define TEST_STRING "Test String"

| Definition at line 9 of file perform.c.

#define TEST_STRING_W L"Test String"

| Definition at line 10 of file perform.c.

#define TESTKEY_FULL_NAME L"Environment\\TestKey"

| Definition at line 69 of file perform.c. Referenced by main().

#define TESTKEY_NAME L"TestKey"

| Definition at line 68 of file perform.c.

#define VALUE_DATA L"This is a string"

| Definition at line 75 of file perform.c. Referenced by main().

#define VALUE_NAME L"123"

| Definition at line 74 of file perform.c. Referenced by main().

## Function Documentation

BOOLEAN AdjustPrivilege | ( | PSTR | SecurityNameString | ) |

Definition at line 15 of file perform.c.

References DWORD, FALSE, NULL, and TRUE.

    00018 {
    00019     HANDLE              TokenHandle;
    00020     LUID_AND_ATTRIBUTES LuidAndAttributes;
    00021 //    PSTR                SecurityNameString;
    00022
    00023     TOKEN_PRIVILEGES    TokenPrivileges;
    00024     TOKEN_PRIVILEGES    PreviousTokenPrivileges;
    00025     DWORD               ReturnLength;
    00026
    00027     if( !OpenProcessToken( GetCurrentProcess(),
    00028                            TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
    00029                            &TokenHandle ) ) {
    00030         printf( "OpenProcessToken failed \n" );
    00031         return( FALSE );
    00032     }
    00033
    00034 //    SecurityNameString = SE_RESTORE_NAME; // SE_SECURITY_NAME;
    00035
    00036     if( !LookupPrivilegeValue( NULL,
    00037                                SecurityNameString,
    00038                                &( LuidAndAttributes.Luid ) ) ) {
    00039         printf( "LookupPrivilegeValue failed, Error = %#x \n", GetLastError() );
    00040         return( FALSE );
    00041     }
    00042
    00043     LuidAndAttributes.Attributes = SE_PRIVILEGE_ENABLED;
    00044     TokenPrivileges.PrivilegeCount = 1;
    00045     TokenPrivileges.Privileges[0] = LuidAndAttributes;
    00046
    00047     if( !AdjustTokenPrivileges( TokenHandle,
    00048                                 FALSE,
    00049                                 &TokenPrivileges,
    00050                                 0,
    00051                                 NULL,
    00052                                 NULL ) ) {
    00053         printf( "AdjustTokenPrivileges failed, Error = %#x \n", GetLastError() );
    00054         return( FALSE );
    00055     }
    00056
    00057
    00058     if( GetLastError() != NO_ERROR ) {
    00059         return( FALSE );
    00060     }
    00061
    00062     return( TRUE );
    00063 }

INT __cdecl main | ( |  | ) |

Definition at line 80 of file perform.c.

References BYTE, DWORD, ENVIRONMENT_NAME, FALSE, KEY1_NAME, KEY2_NAME, L, NULL, Status, TESTKEY_FULL_NAME, TRUE, VALUE_DATA, and VALUE_NAME.

    00081 {
    00082     DWORD       Status;
    00083
    00084     HKEY        TestKeyHandle;
    00085     HKEY        Key1Handle;
    00086     HKEY        Key2Handle;
    00087     HKEY        EnvironmentHandle;
    00088
    00089     WCHAR       ValueData[] = VALUE_DATA;
    00090
    00091     WCHAR       BufferForKeyName[100];
    00092     WCHAR       BufferForKeyClass[100];
    00093     WCHAR       BufferForValueEntryName[100];
    00094     BYTE        BufferForValueEntryData[100];
    00095
    00096
    00097     DWORD       DataType;
    00098     DWORD       DataSize;
    00099     DWORD       NameSize;
    00100     DWORD       ClassSize;
    00101
    00102
    00103     DWORD       cSubKeys;
    00104     DWORD       cbMaxSubkey;
    00105     DWORD       cbMaxClass;
    00106     DWORD       cValues;
    00107     DWORD       vbMaxValueName;
    00108     DWORD       cbMaxValueData;
    00109     DWORD       cbSecurityDescriptor;
    00110     FILETIME    ftLastWriteTime;
    00111
    00112
    00113     BYTE        BufferForSecurityDescriptor[2048];
    00114
    00115     HANDLE      NotificationEvent;
    00116
    00117     PWSTR       File1 = L"d:\\File1";
    00118     PWSTR       File2 = L"d:\\File2";
    00119     DWORD       Disposition;
    00120
    00121
    00122
    00123 /*
    00124     Key = NULL;
    00125     Status = RegOpenKeyExW( HKEY_CURRENT_USER,
    00126                             L"",
    00127                             0,
    00128                             MAXIMUM_ALLOWED,
    00129                             &Key );
    00130 */
    00131
    00132
    00133
    00134
    00135
    00136
    00137
    00138
    00139 //    AdjustPrivilege( SE_BACKUP_NAME );
    00140 //    AdjustPrivilege( SE_RESTORE_NAME );
    00141
    00142
    00143     NotificationEvent = CreateEvent( NULL,
    00144                                      FALSE,
    00145                                      FALSE,
    00146                                      NULL );
    00147
    00148     if( NotificationEvent == NULL ) {
    00149         printf( "CreateEvent failed, ErrorCode = %d \n", GetLastError() );
    00150     }
    00151
    00152
    00153
    00154     Status = RegOpenKeyExW( HKEY_CURRENT_USER,
    00155                             TESTKEY_FULL_NAME,
    00156                             0,
    00157                             MAXIMUM_ALLOWED,
    00158                             &TestKeyHandle );
    00159
    00160     if( Status != 0 ) {
    00161         printf( "RegOpenKeyExW failed, Status = %d \n", Status );
    00162     } else {
    00163         printf( "RegOpenKeyExW succeeded \n" );
    00164     }
    00165
    00166
    00167     Status = RegOpenKeyW( HKEY_CURRENT_USER,
    00168                           ENVIRONMENT_NAME,
    00169                           &EnvironmentHandle );
    00170
    00171     if( Status != 0 ) {
    00172         printf( "RegOpenKeyW failed, Status = %d \n", Status );
    00173     } else {
    00174         printf( "RegOpenKeyW succeeded \n" );
    00175     }
    00176
    00177
    00178
    00179
    00180
    00181
    00182     Status = RegCreateKeyExW( TestKeyHandle,
    00183                               KEY1_NAME,
    00184                               NULL,
    00185                               NULL,
    00186                               REG_OPTION_NON_VOLATILE,
    00187                               MAXIMUM_ALLOWED,
    00188                               NULL,
    00189                               &Key1Handle,
    00190                               &Disposition );
    00191
    00192     if( Status != 0 ) {
    00193         printf( "RegCreateKeyExW failed, Status = %d \n", Status );
    00194     } else {
    00195         printf( "RegCreateKeyExW succeeded \n" );
    00196     }
    00197
    00198
    00199
    00200     Status = RegCreateKeyW( TestKeyHandle,
    00201                             KEY2_NAME,
    00202                             &Key2Handle );
    00203
    00204
    00205     if( Status != 0 ) {
    00206         printf( "RegCreateKeyW failed, Status = %d \n", Status );
    00207     } else {
    00208         printf( "RegCreateKeyW succeeded \n" );
    00209     }
    00210
    00211
    00212     Status = RegSetValueExW( Key1Handle,
    00213                              VALUE_NAME,
    00214                              NULL,
    00215                              REG_SZ,
    00216                              ValueData,
    00217                              sizeof( ValueData ) );
    00218
    00219     if( Status != 0 ) {
    00220         printf( "RegSetValueExW failed, Status = %d \n", Status );
    00221     } else {
    00222         printf( "RegSetValueExW succeeded \n" );
    00223     }
    00224
    00225
    00226     Status = RegSetValueW( Key1Handle,
    00227                              NULL,
    00228                              REG_SZ,
    00229                              ValueData,
    00230                              sizeof( ValueData ) );
    00231
    00232     if( Status != 0 ) {
    00233         printf( "RegSetValueW failed, Status = %d \n", Status );
    00234     } else {
    00235         printf( "RegSetValueW succeeded \n" );
    00236     }
    00237
    00238
    00239
    00240     Status = RegFlushKey( Key1Handle );
    00241     if( Status != 0 ) {
    00242         printf( "RegFlushKey failed, Status = %d \n", Status );
    00243     } else {
    00244         printf( "RegFlushKey succeeded \n" );
    00245     }
    00246
    00247
    00248
    00249
    00250     DataSize = sizeof( BufferForValueEntryData );
    00251     memset( BufferForValueEntryData, '\0', DataSize );
    00252     Status = RegQueryValueExW( Key1Handle,
    00253                                VALUE_NAME,
    00254                                NULL,
    00255                                &DataType,
    00256                                BufferForValueEntryData,
    00257                                &DataSize );
    00258
    00259     if( Status != 0 ) {
    00260         printf( "RegQueryValueExW failed, Status = %d \n", Status );
    00261     } else {
    00262         printf( "RegQueryValueExW succeeded \n" );
    00263     }
    00264
    00265
    00266
    00267     DataSize = sizeof( BufferForValueEntryData );
    00268     memset( BufferForValueEntryData, '\0', DataSize );
    00269     Status = RegQueryValueW( Key1Handle,
    00270                              NULL,
    00271                              BufferForValueEntryData,
    00272                              &DataSize );
    00273
    00274
    00275     if( Status != 0 ) {
    00276         printf( "RegQueryValueW failed, Status = %d \n", Status );
    00277     } else {
    00278         printf( "RegQueryValueW succeeded \n" );
    00279     }
    00280
    00281
    00282     DataSize = sizeof( BufferForValueEntryData );
    00283     memset( BufferForValueEntryData, 'X', DataSize );
    00284     NameSize = sizeof( BufferForValueEntryName );
    00285     memset( BufferForValueEntryName, 'X', NameSize );
    00286
    00287     Status = RegEnumValueW( Key1Handle,
    00288                             0,
    00289                             BufferForValueEntryName,
    00290                             &NameSize,
    00291                             NULL,
    00292                             &DataType,
    00293                             BufferForValueEntryData,
    00294                             &DataSize );
    00295
    00296
    00297     if( Status != 0 ) {
    00298         printf( "RegEnumValueW failed, Status = %d \n", Status );
    00299     } else {
    00300         printf( "RegEnumValueW succeeded \n" );
    00301     }
    00302
    00303
    00304     NameSize = sizeof( BufferForKeyName );
    00305     ClassSize = sizeof( BufferForKeyClass );
    00306     Status = RegEnumKeyExW( TestKeyHandle,
    00307                             0,
    00308                             BufferForKeyName,
    00309                             &NameSize,
    00310                             NULL,
    00311                             BufferForKeyClass,
    00312                             &ClassSize,
    00313                             &ftLastWriteTime );
    00314
    00315     if( Status != 0 ) {
    00316         printf( "RegEnumKeyExW failed, Status = %d \n", Status );
    00317     } else {
    00318         printf( "RegEnumKeyExW succeeded \n" );
    00319     }
    00320
    00321
    00322     NameSize = sizeof( BufferForKeyName );
    00323     Status = RegEnumKeyW( TestKeyHandle,
    00324                           0,
    00325                           BufferForKeyName,
    00326                           &NameSize );
    00327
    00328     if( Status != 0 ) {
    00329         printf( "RegEnumKeyW failed, Status = %d \n", Status );
    00330     } else {
    00331         printf( "RegEnumKeyW succeeded \n" );
    00332     }
    00333
    00334
    00335     ClassSize = sizeof( BufferForKeyClass );
    00336     Status = RegQueryInfoKeyW( Key1Handle,
    00337                                BufferForKeyClass,
    00338                                &ClassSize,
    00339                                NULL,
    00340                                &cSubKeys,
    00341                                &cbMaxSubkey,
    00342                                &cbMaxClass,
    00343                                &cValues,
    00344                                &vbMaxValueName,
    00345                                &cbMaxValueData,
    00346                                &cbSecurityDescriptor,
    00347                                &ftLastWriteTime );
    00348
    00349
    00350
    00351     if( Status != 0 ) {
    00352         printf( "RegQueryInfoKeyW failed, Status = %d \n", Status );
    00353     } else {
    00354         printf( "RegQueryInfoKeyW succeeded \n" );
    00355     }
    00356
    00357
    00358     Status = RegGetKeySecurity( Key1Handle,
    00359                                 DACL_SECURITY_INFORMATION,
    00360                                 ( PSECURITY_DESCRIPTOR )BufferForSecurityDescriptor,
    00361                                 &cbSecurityDescriptor );
    00362
    00363     if( Status != 0 ) {
    00364         printf( "RegGetKeySecurity failed, Status = %d \n", Status );
    00365     } else {
    00366         printf( "RegGetKeySecurity succeeded \n" );
    00367     }
    00368
    00369
    00370
    00371     Status = RegSetKeySecurity( Key1Handle,
    00372                                 DACL_SECURITY_INFORMATION,
    00373                                 ( PSECURITY_DESCRIPTOR )BufferForSecurityDescriptor );
    00374
    00375     if( Status != 0 ) {
    00376         printf( "RegSetKeySecurity failed, Status = %d \n", Status );
    00377     } else {
    00378         printf( "RegSetKeySecurity succeeded \n" );
    00379     }
    00380
    00381 /*
    00382     Status = RegSaveKeyW( Key1Handle,
    00383                           File1,
    00384                           NULL );
    00385
    00386
    00387     if( Status != 0 ) {
    00388         printf( "RegSaveKeyW failed, Status = %d \n", Status );
    00389     } else {
    00390         printf( "RegSaveKeyW succeeded \n" );
    00391     }
    00392
    00393
    00394
    00395     Status = RegRestoreKeyW( Key2Handle,
    00396                              File1,
    00397                              0 );
    00398
    00399
    00400     if( Status != 0 ) {
    00401         printf( "RegRestoreKeyW failed, Status = %d \n", Status );
    00402     } else {
    00403         printf( "RegRestoreKeyW succeeded \n" );
    00404     }
    00405 */
    00406
    00407     Status = RegDeleteValueW( Key1Handle,
    00408                               VALUE_NAME );
    00409
    00410
    00411     if( Status != 0 ) {
    00412         printf( "RegDeleteValueW failed, Status = %d \n", Status );
    00413     } else {
    00414         printf( "RegDeleteValueW succeeded \n" );
    00415     }
    00416
    00417
    00418     Status = RegCloseKey( Key1Handle );
    00419
    00420     if( Status != 0 ) {
    00421         printf( "RegCloseKey failed, Status = %d \n", Status );
    00422     } else {
    00423         printf( "RegCloseKey succeeded \n" );
    00424     }
    00425
    00426     Status = RegDeleteKeyW( TestKeyHandle,
    00427                             KEY1_NAME );
    00428
    00429     if( Status != 0 ) {
    00430         printf( "RegCloseKey failed, Status = %d \n", Status );
    00431     } else {
    00432         printf( "RegCloseKey succeeded \n" );
    00433     }
    00434
    00435
    00436     Status = RegNotifyChangeKeyValue( HKEY_CURRENT_USER,
    00437                                       TRUE,
    00438                                       REG_NOTIFY_CHANGE_NAME |
    00439                                       REG_NOTIFY_CHANGE_ATTRIBUTES |
    00440                                       REG_NOTIFY_CHANGE_LAST_SET |
    00441                                       REG_NOTIFY_CHANGE_SECURITY,
    00442                                       NotificationEvent,
    00443                                       TRUE );
    00444
    00445     if( Status != 0 ) {
    00446         printf( "RegNotifyChangeKeyValue failed, Status = %d \n", Status );
    00447     } else {
    00448         printf( "RegNotifyChangeKeyValue succeeded \n" );
    00449     }
    00450
    00451
    00452     //
    00453     //  Cleanup
    00454     //
    00455
    00456     CloseHandle( NotificationEvent );
    00457 //    DeleteFileW( File1 );
    00458     RegCloseKey( Key2Handle );
    00459     RegDeleteKeyW( TestKeyHandle,
    00460                    KEY2_NAME );
    00461
    00462
    00463 }