![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to regdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / regmpad|
Return to regdb.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / regmpad |
1.1 ! root 1: // RegDB.c -- Implements the semantics of the registry interface for this ! 2: // application. The visible interfaces and data structures are ! 3: // defined in RegDB.h. ! 4: ! 5: /* ! 6: * ! 7: Overview ! 8: -------- ! 9: ! 10: The NT Registry is an object database consisting of keys and values. Keys ! 11: have names and may contain other keys and values. A value is a name paired ! 12: with a data object and a data type. The keys in the registry are analogous ! 13: to the directories in a file system. In that vein the values are analogous ! 14: to files. ! 15: ! 16: Access to a key and its associated set of values is mediated by a key handle. ! 17: Four key handles are given as predefined constants. Those handles correspond ! 18: to the roots of key trees which have special signifigance. Handles for the ! 19: other keys in the registry database may be constructed via the Registry's ! 20: Open and Create interfaces using an existing key handle and a relative path ! 21: string. ! 22: ! 23: The predefined key handles are: ! 24: ! 25: ! 26: HKEY_LOCAL_MACHINE -- This handle refers to a tree of keys and values ! 27: which characterize the state of the local machine. ! 28: It contains state information global to everyone ! 29: who uses the machine. ! 30: ! 31: HKEY_CLASSES_ROOT -- This handle refers to a subtree within ! 32: HKEY_LOCAL_MACHINE. It defines the associations ! 33: between file extensions and document types as well ! 34: as the command strings for shell and DDE/OLE actions. ! 35: ! 36: HKEY_USERS -- This handle refers to a tree of information about ! 37: the people who use this machine. The top level of ! 38: the tree consists of a .DEFAULT key and one or more ! 39: entries for specific people. The specific entries ! 40: are created dynamically and are initially based on ! 41: the content of the .DEFAULT key. The key names for ! 42: the specific entries are SIDs which define the ! 43: permissions given to the corresponding people. ! 44: ! 45: HKEY_CURRENT_USER -- This handle refers to a specific user key within ! 46: HKEY_USERS. It denotes the information tree for ! 47: the currently active user id. ! 48: ! 49: ! 50: Application Conventions ! 51: ----------------------- ! 52: ! 53: Applications need to manipulate three of the above key trees. At installation ! 54: time an application should adjust HKEY_CLASSES_ROOT to define the documents ! 55: which it handles together with their file extensions and its shell and ! 56: DDE/OLE command strings. At the same time it needs to add information global ! 57: to all users to the HKEY_USERS\.DEFAULT key. ! 58: ! 59: Subsequently an application will need to place per-user information in the ! 60: HKEY_CURRENT_USER subtree. That information will include preferences as well ! 61: as historical information such as lists of recently opened files. ! 62: ! 63: The conventions appropriate to the HKEY_CLASSES_ROOT will not be described ! 64: or demonstrated in this sample application. The focus here will be on ! 65: HKEY_USERS\.DEFAULT and HKEY_CURRENT_USER subtrees. ! 66: ! 67: Within both of those subtrees information related to version 2.5 of the ! 68: Bazooka application published by Trey Software will be clustered in the ! 69: subkey: ! 70: ! 71: software\"Trey Software"\Bazooka\2.5 ! 72: ! 73: and in general applications will use a path with the structure ! 74: ! 75: software \ <company name> \ <application name> \ <version number> ! 76: ! 77: to access their state information. ! 78: ! 79: After an application has been installed almost all registry changes will ! 80: involve HKEY_CURRENT_USER and will concern a specific user's preferences ! 81: or history. ! 82: ! 83: */ ! 84: ! 85: #include "multipad.h" ! 86: ! 87: // #include <windows.H> ! 88: // #include <winbase.h> ! 89: #include <malloc.h> ! 90: #include "regdb.h" ! 91: ! 92: HKEY hkGlobal = NULL; // Key Handle for global registry data ! 93: HKEY hkPerUser = NULL; // Key Handle for per-user registry data ! 94: ! 95: BOOL fTextWrapDefault = FALSE; // Set from registry data. ! 96: ! 97: HANDLE hmtxRegGlobal = NULL; // Mutex for serializing Local Machine Data. ! 98: HANDLE hmtxRegPerUser = NULL; // Mutex for serializing Current User Data ! 99: ! 100: BOOL RunningAsAdministrator() ! 101: { ! 102: BOOL fAdmin; ! 103: HANDLE htkThread; ! 104: TOKEN_GROUPS *ptg = NULL; ! 105: DWORD cbTokenGroups; ! 106: DWORD iGroup; ! 107: SID_IDENTIFIER_AUTHORITY SystemSidAuthority= SECURITY_NT_AUTHORITY; ! 108: PSID psidAdmin; ! 109: ! 110: // This function returns TRUE if the user identifier associated with this ! 111: // process is a member of the the Administrators group. ! 112: ! 113: // First we must open a handle to the access token for this thread. ! 114: ! 115: if (!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &htkThread)) ! 116: if (GetLastError() == ERROR_NO_TOKEN) ! 117: { ! 118: // If the thread does not have an access token, we'll examine the ! 119: // access token associated with the process. ! 120: ! 121: if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &htkThread)) ! 122: return FALSE; ! 123: } ! 124: else return FALSE; ! 125: ! 126: // Then we must query the size of the group information associated with ! 127: // the token. Note that we expect a FALSE result from GetTokenInformation ! 128: // because we've given it a NULL buffer. On exit cbTokenGroups will tell ! 129: // the size of the group information. ! 130: ! 131: if (GetTokenInformation(htkThread, TokenGroups, NULL, 0, &cbTokenGroups)) ! 132: return FALSE; ! 133: ! 134: // Here we verify that GetTokenInformation failed for lack of a large ! 135: // enough buffer. ! 136: ! 137: if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) ! 138: return FALSE; ! 139: ! 140: // Now we allocate a buffer for the group information. ! 141: // Since _alloca allocates on the stack, we don't have ! 142: // to explicitly deallocate it. That happens automatically ! 143: // when we exit this function. ! 144: ! 145: if (!(ptg= _alloca(cbTokenGroups))) return FALSE; ! 146: ! 147: // Now we ask for the group information again. ! 148: // This may fail if an administrator has added this account ! 149: // to an additional group between our first call to ! 150: // GetTokenInformation and this one. ! 151: ! 152: if (!GetTokenInformation(htkThread, TokenGroups, ptg, cbTokenGroups, ! 153: &cbTokenGroups ! 154: ) ! 155: ) ! 156: return FALSE; ! 157: ! 158: // Now we must create a System Identifier for the Admin group. ! 159: ! 160: if (!AllocateAndInitializeSid ! 161: (&SystemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, ! 162: DOMAIN_ALIAS_RID_ADMINS, ! 163: 0, 0, 0, 0, 0, 0, ! 164: &psidAdmin ! 165: ) ! 166: ) ! 167: return FALSE; ! 168: ! 169: // Finally we'll iterate through the list of groups for this access ! 170: // token looking for a match against the SID we created above. ! 171: ! 172: fAdmin= FALSE; ! 173: ! 174: for (iGroup= 0; iGroup < ptg->GroupCount; iGroup++) ! 175: if (EqualSid(ptg->Groups[iGroup].Sid, psidAdmin)) ! 176: { ! 177: fAdmin= TRUE; ! 178: ! 179: break; ! 180: } ! 181: ! 182: // Before we exit we must explicity deallocate the SID ! 183: // we created. ! 184: ! 185: FreeSid(psidAdmin); ! 186: ! 187: return(fAdmin); ! 188: } ! 189: ! 190: ! 191: BOOL InstallApp(PSZ pszPathBuff) ! 192: { ! 193: // This function attempts to install global data for this ! 194: // application in the HKEY_LOCAL_MACHINE portion of the ! 195: // registry database. ! 196: ! 197: // The parameter pszPathBuff refers to a null terminated ! 198: // string which defines where the new key should be located ! 199: // in the LOCAL_MACHINE tree. ! 200: ! 201: // We requires that the current user have administrative ! 202: // privileges. That requirement insures that the owner ! 203: // tag for the global registry entries will be the ! 204: // Administrator group and not a particular user id. ! 205: ! 206: // We also assume that hmtxRegGlobal is held when this function is called. ! 207: ! 208: // First we'll see whether this user has admin privileges... ! 209: // Only administrators can install this application... ! 210: ! 211: if (!RunningAsAdministrator()) ! 212: { ! 213: MPError(hwndFrame, MB_OK | MB_ICONHAND, IDS_CANTINSTALL, NULL); ! 214: ! 215: return FALSE; ! 216: } ! 217: ! 218: // Then we bring up a dialog to get the global configuration information ! 219: // we'll be storing in the HKEY_LOCAL_MACHINE tree. The dialog proc ! 220: // will call StoreAppConfig with that configuration data. ! 221: ! 222: if (!DialogBoxParam(hInst, MAKEINTRESOURCE(DLG_INSTALL), ! 223: hwndFrame, InstallDlgProc, ! 224: (LPARAM) pszPathBuff ! 225: ) ! 226: ) return FALSE; ! 227: } ! 228: ! 229: BOOL StoreAppConfig(HWND hwnd, PSZ pszPathBuff, PSZ pszInstallName, ! 230: PSZ pszInstallOrg, BOOL fTextWrapDefault ! 231: ) ! 232: { ! 233: // This function attempts to install global data for this ! 234: // application in the HKEY_LOCAL_MACHINE portion of the ! 235: // registry database. It is called from InstallDlgProc. ! 236: ! 237: // The parameter hwnd denotes the window associated with this ! 238: // call to StoreAppConfig. It's used with the calls to MPError ! 239: // below. ! 240: ! 241: // The parameter pszPathBuff refers to a null terminated ! 242: // string which defines where the new key should be located ! 243: // in the LOCAL_MACHINE tree. ! 244: ! 245: // The pszInstallName and pszInstallOrg parameters are text strings ! 246: // which denote the person and the organization which has installed ! 247: // this app in the HKEY_LOCAL_MACHINE portion of the registry. ! 248: ! 249: // The fTextWrapDefault is a boolean value which will be stored ! 250: // in the DEFAULT subkey. Values in the DEFAULT subkey are copied ! 251: // into the HKEY_PER_USER area during user initialization. (See ! 252: // the InitUser function below.) ! 253: ! 254: // We assume that hmtxRegGlobal is held when this function is called. ! 255: ! 256: HKEY hkGlobal = NULL; ! 257: HKEY hkDefaults = NULL; ! 258: PSID psidAdmins = NULL; ! 259: PSID psidEveryone = NULL; ! 260: PACL paclKey = NULL; ! 261: ! 262: BOOL fInstalled = FALSE; ! 263: ! 264: long lResult; ! 265: DWORD dwDisposition; ! 266: ! 267: BYTE abEmptyStringSet[2]; ! 268: ! 269: SID_IDENTIFIER_AUTHORITY SystemSidAuthority= SECURITY_NT_AUTHORITY; ! 270: SID_IDENTIFIER_AUTHORITY WorldSidAuthority= SECURITY_WORLD_SID_AUTHORITY; ! 271: ! 272: SECURITY_ATTRIBUTES sa; ! 273: SECURITY_DESCRIPTOR sdPermissions; ! 274: // Next we'll setup the security attributes we're going to ! 275: // use with the application's global key. ! 276: ! 277: sa.nLength = sizeof(SECURITY_ATTRIBUTES); ! 278: sa.bInheritHandle = FALSE; ! 279: sa.lpSecurityDescriptor = &sdPermissions; ! 280: ! 281: // Here we're creating a System Identifier (SID) to represent ! 282: // the Admin group. ! 283: ! 284: if (!AllocateAndInitializeSid ! 285: (&SystemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, ! 286: DOMAIN_ALIAS_RID_ADMINS, ! 287: 0, 0, 0, 0, 0, 0, ! 288: &psidAdmins ! 289: ) ! 290: ) ! 291: goto security_failure; ! 292: ! 293: // Now we'll construct a System Identifier which represents ! 294: // all users. ! 295: ! 296: if (!AllocateAndInitializeSid ! 297: (&WorldSidAuthority, 1, SECURITY_WORLD_RID, ! 298: 0, 0, 0, 0, 0, 0, 0, ! 299: &psidEveryone ! 300: ) ! 301: ) ! 302: goto security_failure; ! 303: ! 304: if (!InitializeSecurityDescriptor(&sdPermissions, ! 305: SECURITY_DESCRIPTOR_REVISION1 ! 306: ) ! 307: ) ! 308: goto security_failure; ! 309: ! 310: // We want the admin group to own this key. ! 311: ! 312: if (!SetSecurityDescriptorOwner(&sdPermissions, psidAdmins, 0)) ! 313: goto security_failure; ! 314: ! 315: // Finally we must allocate and construct the discretionary ! 316: // access control list (DACL) for the key. ! 317: ! 318: // Note that _alloca allocates memory on the stack frame ! 319: // which will automatically be deallocated when this routine ! 320: // exits. ! 321: ! 322: if (!(paclKey= (PACL) _alloca(ACL_BUFFER_SIZE))) ! 323: goto memory_limited; ! 324: ! 325: if (!InitializeAcl(paclKey, ACL_BUFFER_SIZE, ACL_REVISION2)) ! 326: goto security_failure; ! 327: ! 328: // Our DACL will contain two access control entries (ACEs). One which allows ! 329: // members of the Admin group complete access to the key, and one which gives ! 330: // read-only access to everyone. ! 331: ! 332: if (!AddAccessAllowedAce(paclKey, ACL_REVISION2, KEY_ALL_ACCESS, psidAdmins)) ! 333: goto security_failure; ! 334: ! 335: if (!AddAccessAllowedAce(paclKey, ACL_REVISION2, KEY_READ, psidEveryone)) ! 336: goto security_failure; ! 337: ! 338: // We must bind this DACL to the security descriptor... ! 339: ! 340: if (!SetSecurityDescriptorDacl(&sdPermissions, TRUE, paclKey, FALSE)) ! 341: goto security_failure; ! 342: ! 343: // Now we'll attempt to create the key with the security attributes... ! 344: ! 345: lResult= RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszPathBuff, 0, ! 346: "Application Global Data", REG_OPTION_NON_VOLATILE, ! 347: KEY_ALL_ACCESS, ! 348: &sa, &hkGlobal, &dwDisposition ! 349: ); ! 350: ! 351: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 352: ! 353: // Usually the disposition value will indicate that we've created a ! 354: // new key. Sometimes it may instead state that we've opened an existing ! 355: // key. This can happen when installation is incomplete and interrupted, ! 356: // say by loss of electrical power. ! 357: ! 358: if ( dwDisposition != REG_CREATED_NEW_KEY ! 359: && dwDisposition != REG_OPENED_EXISTING_KEY ! 360: ) goto registry_access_error; ! 361: ! 362: // Now we'll add two values to the global key. ! 363: ! 364: // These values are simple strings which identify the name and ! 365: // organization associated with this installation. ! 366: ! 367: lResult= RegSetValueEx(hkGlobal, KEY_VALUE_INSTALL_NAME, 0, REG_SZ, ! 368: pszInstallName, strlen(pszInstallName)+1 ! 369: ); ! 370: ! 371: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 372: ! 373: lResult= RegSetValueEx(hkGlobal, KEY_VALUE_INSTALL_ORG, 0, REG_SZ, ! 374: pszInstallOrg, strlen(pszInstallOrg)+1 ! 375: ); ! 376: ! 377: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 378: ! 379: // We've created the global key. Now we must create the "Defaults" subkey ! 380: // and set its value(s). ! 381: ! 382: lResult= RegCreateKeyEx(hkGlobal, DEFAULTS_PATH, 0, ! 383: "Defaults for Per-User Data", ! 384: REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, ! 385: &sa, &hkDefaults, &dwDisposition ! 386: ); ! 387: ! 388: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 389: ! 390: // Usually the disposition value will indicate that we've created a ! 391: // new key. Sometimes it may instead state that we've opened an existing ! 392: // key. This can happen when installation is incomplete and interrupted, ! 393: // say by loss of electrical power. ! 394: ! 395: if ( dwDisposition != REG_CREATED_NEW_KEY ! 396: && dwDisposition != REG_OPENED_EXISTING_KEY ! 397: ) goto registry_access_error; ! 398: ! 399: // Now we'll add a collection of values to the Defaults subkey. ! 400: // When per-user data is constructed for a particular userid, these ! 401: // values will define the initial state of the per-user data. ! 402: ! 403: // In this demo application we store two items -- a word-wrap flag ! 404: // and a file name set. ! 405: ! 406: lResult= RegSetValueEx(hkDefaults, WORD_WRAP_DEFAULT, 0, REG_DWORD, ! 407: (LPBYTE) &fTextWrapDefault, ! 408: sizeof(fTextWrapDefault) ! 409: ); ! 410: ! 411: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 412: ! 413: abEmptyStringSet[0]= '\0'; ! 414: abEmptyStringSet[1]= '\0'; ! 415: ! 416: lResult= RegSetValueEx(hkDefaults, LAST_FILE_SET, 0, REG_MULTI_SZ, ! 417: (LPBYTE) &abEmptyStringSet, 2 ! 418: ); ! 419: ! 420: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 421: ! 422: // Finally, we'll force our registry data out to disk via the ! 423: // flush key api: ! 424: ! 425: lResult= RegFlushKey(hkGlobal); ! 426: ! 427: // Then we'll write out the REG_INSTALLED flag. Note that its ! 428: // value is unimportant. Only its existence matters. ! 429: ! 430: fInstalled= TRUE; ! 431: ! 432: lResult= RegSetValueEx(hkGlobal, REG_INSTALLED, 0, REG_DWORD, ! 433: (LPBYTE) &fInstalled, sizeof(fInstalled) ! 434: ); ! 435: ! 436: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 437: ! 438: RegCloseKey(hkGlobal); ! 439: ! 440: RegCloseKey(hkDefaults); ! 441: ! 442: FreeSid(psidAdmins); ! 443: ! 444: return TRUE; ! 445: ! 446: registry_access_error: ! 447: ! 448: MPError(hwnd, MB_OK | MB_ICONHAND, IDS_REG_ACCESS_ERROR, NULL); ! 449: ! 450: // We've constructed some, but not all of the global key state. ! 451: // So we must remove any keys we created. The Defaults key must ! 452: // be deleted first before the Global key can be deleted. ! 453: ! 454: if (hkDefaults) RegDeleteKey(hkGlobal, DEFAULTS_PATH); ! 455: ! 456: if (hkGlobal) RegDeleteKey(HKEY_LOCAL_MACHINE, pszPathBuff); ! 457: ! 458: goto clean_up_after_failure; ! 459: ! 460: memory_limited: ! 461: ! 462: MPError(hwnd, MB_OK | MB_ICONHAND, IDS_MEMORY_LIMITED, NULL); ! 463: goto clean_up_after_failure; ! 464: ! 465: security_failure: ! 466: ! 467: MPError(hwnd, MB_OK | MB_ICONHAND, IDS_SECURITY_FAIL_I, NULL); ! 468: ! 469: clean_up_after_failure: ! 470: ! 471: if (psidAdmins ) FreeSid(psidAdmins ); ! 472: if (psidEveryone) FreeSid(psidEveryone); ! 473: ! 474: return FALSE; ! 475: } ! 476: ! 477: PSID GetCurrentUserInfo() ! 478: { ! 479: // This function returns security information about the person who owns ! 480: // this thread. ! 481: ! 482: HANDLE htkThread; ! 483: ! 484: TOKEN_USER *ptu; ! 485: DWORD cbtu; ! 486: ! 487: TOKEN_GROUPS *ptg = NULL; ! 488: SID_IDENTIFIER_AUTHORITY SystemSidAuthority= SECURITY_NT_AUTHORITY; ! 489: ! 490: // First we must open a handle to the access token for this thread. ! 491: ! 492: if (!OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &htkThread)) ! 493: if (GetLastError() == ERROR_NO_TOKEN) ! 494: { ! 495: // If the thread does not have an access token, we'll examine the ! 496: // access token associated with the process. ! 497: ! 498: if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &htkThread)) ! 499: return NULL; ! 500: } ! 501: else return NULL; ! 502: ! 503: ! 504: if (GetTokenInformation(htkThread, TokenUser, NULL, 0, &cbtu)) ! 505: return NULL; ! 506: ! 507: // Here we verify that GetTokenInformation failed for lack of a large ! 508: // enough buffer. ! 509: ! 510: if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) ! 511: return NULL; ! 512: ! 513: // Now we allocate a buffer for the group information. ! 514: // Since _alloca allocates on the stack, we don't have ! 515: // to explicitly deallocate it. That happens automatically ! 516: // when we exit this function. ! 517: ! 518: if (!(ptu= LocalAlloc(LPTR, cbtu))) return NULL; ! 519: ! 520: // Now we ask for the user information again. ! 521: // This may fail if an administrator has changed SID information ! 522: // for this user. ! 523: ! 524: if (!GetTokenInformation(htkThread, TokenUser, ptu, cbtu, &cbtu)) ! 525: return FALSE; ! 526: ! 527: // if (GetTokenInformation(htkThread, TokenUser, &tu, sizeof(tu), &cbtu)) ! 528: // return NULL; ! 529: ! 530: return ptu; ! 531: } ! 532: ! 533: BOOL InitUser(HKEY hkGlobal, PSZ pszPathBuff) ! 534: { ! 535: // This function sets up the per-user key area for a new user. ! 536: // It will be called the very first time a user runs the application. ! 537: ! 538: // The initial per-user information is copied over from a set of defaults ! 539: // stored in the global key area. ! 540: ! 541: // We assume that hkGlobal is a registry key for the global area ! 542: // used by this application. We assume pszPathBuff defines where ! 543: // the per-user data should be stored in the CURRENT_USER tree. ! 544: ! 545: // We also assume that hmtxRegPerUser is held when this function is called. ! 546: ! 547: HANDLE hkPerUser = NULL; ! 548: HANDLE hkDefaults = NULL; ! 549: ! 550: BOOL fInstalled= FALSE; ! 551: ! 552: LONG lResult; ! 553: ! 554: DWORD dwType, cbData; ! 555: ! 556: PSZ pszFileList; ! 557: ! 558: DWORD dwDisposition; ! 559: ! 560: TOKEN_USER *ptu = NULL; ! 561: ! 562: PSID psidUser = NULL, ! 563: psidAdmins = NULL; ! 564: ! 565: PACL paclKey = NULL; ! 566: ! 567: BOOL fWordWrap; ! 568: PSZ pszFileSet = NULL; ! 569: ! 570: SID_IDENTIFIER_AUTHORITY SystemSidAuthority= SECURITY_NT_AUTHORITY; ! 571: ! 572: SECURITY_ATTRIBUTES sa; ! 573: SECURITY_DESCRIPTOR sdPermissions; ! 574: ! 575: ! 576: // First we'll setup the security attributes we're going to ! 577: // use with the application's global key. ! 578: ! 579: sa.nLength = sizeof(SECURITY_ATTRIBUTES); ! 580: sa.bInheritHandle = FALSE; ! 581: sa.lpSecurityDescriptor = &sdPermissions; ! 582: ! 583: // Here we're creating a System Identifier (SID) to represent ! 584: // the Admin group. ! 585: ! 586: if (!AllocateAndInitializeSid ! 587: (&SystemSidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, ! 588: DOMAIN_ALIAS_RID_ADMINS, ! 589: 0, 0, 0, 0, 0, 0, ! 590: &psidAdmins ! 591: ) ! 592: ) ! 593: goto security_failure; ! 594: ! 595: // We also need a SID for the current user. ! 596: ! 597: if ( !(ptu= GetCurrentUserInfo()) ! 598: || !(psidUser= ptu->User.Sid) ! 599: ) goto security_failure; ! 600: ! 601: if (!InitializeSecurityDescriptor(&sdPermissions, ! 602: SECURITY_DESCRIPTOR_REVISION1 ! 603: ) ! 604: ) ! 605: goto security_failure; ! 606: ! 607: // We want the current user to own this key. ! 608: ! 609: if (!SetSecurityDescriptorOwner(&sdPermissions, psidUser, 0)) ! 610: goto security_failure; ! 611: ! 612: // Finally we must allocate and construct the discretionary ! 613: // access control list (DACL) for the key. ! 614: ! 615: // Note that _alloca allocates memory on the stack frame ! 616: // which will automatically be deallocated when this routine ! 617: // exits. ! 618: ! 619: if (!(paclKey= (PACL) _alloca(ACL_BUFFER_SIZE))) ! 620: goto memory_limited; ! 621: ! 622: if (!InitializeAcl(paclKey, ACL_BUFFER_SIZE, ACL_REVISION2)) ! 623: goto security_failure; ! 624: ! 625: // Our DACL will two access control entries (ACEs). The first ACE ! 626: // provides full access to the current user. The second ACE gives ! 627: // the Admin group full access. By default all other users will have ! 628: // no access to the key. ! 629: ! 630: // The reason for admin access is to allow an administrator to ! 631: // run special utilties to cleanup inconsistencies and disasters ! 632: // in the per-user data area. ! 633: ! 634: if (!AddAccessAllowedAce(paclKey, ACL_REVISION2, KEY_ALL_ACCESS, psidUser)) ! 635: goto security_failure; ! 636: ! 637: if (!AddAccessAllowedAce(paclKey, ACL_REVISION2, KEY_ALL_ACCESS, psidAdmins)) ! 638: goto security_failure; ! 639: ! 640: // We must bind this DACL to the security descriptor... ! 641: ! 642: if (!SetSecurityDescriptorDacl(&sdPermissions, TRUE, paclKey, FALSE)) ! 643: goto security_failure; ! 644: ! 645: // Now we'll attempt to create the key with the security attributes... ! 646: ! 647: lResult= RegCreateKeyEx(HKEY_CURRENT_USER, pszPathBuff, 0, ! 648: "Application Per-User Data", REG_OPTION_NON_VOLATILE, ! 649: KEY_ALL_ACCESS, ! 650: &sa, &hkPerUser, &dwDisposition ! 651: ); ! 652: ! 653: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 654: ! 655: // Usually the disposition value will indicate that we've created a ! 656: // new key. Sometimes it may instead state that we've opened an existing ! 657: // key. This can happen when installation is incomplete and interrupted, ! 658: // say by loss of electrical power. ! 659: ! 660: if ( dwDisposition != REG_CREATED_NEW_KEY ! 661: && dwDisposition != REG_OPENED_EXISTING_KEY ! 662: ) goto registry_access_error; ! 663: ! 664: // Now we must open the Defaults subkey in the global area. ! 665: ! 666: lResult= RegOpenKeyEx(hkGlobal, DEFAULTS_PATH, 0, KEY_READ, &hkDefaults); ! 667: ! 668: if (lResult != ERROR_SUCCESS) ! 669: { ! 670: // Can't open the "Defaults" subkey for read access. ! 671: // This shouldn't happen normally. The algorithmic sequence for ! 672: // installing this application and then creating user profile ! 673: // data should prevent it. ! 674: ! 675: // It is possible for someone running RegEdit32 to delete the key, ! 676: // however. ! 677: ! 678: goto registry_damage_error; ! 679: } ! 680: ! 681: // Now we'll copy two default values to the per-user key: ! 682: // ! 683: // -- a word-wrap flag ! 684: // -- a list of file names ! 685: ! 686: cbData= sizeof(fWordWrap); ! 687: ! 688: lResult= RegQueryValueEx(hkDefaults, WORD_WRAP_DEFAULT, NULL, ! 689: &dwType, (LPBYTE) &fWordWrap, &cbData ! 690: ); ! 691: ! 692: if ( lResult != ERROR_SUCCESS ! 693: || dwType != REG_DWORD ! 694: ) goto registry_damage_error; ! 695: ! 696: ! 697: lResult= RegSetValueEx(hkPerUser, WORD_WRAP_DEFAULT, 0, REG_DWORD, ! 698: (LPBYTE) &fWordWrap, sizeof(fWordWrap) ! 699: ); ! 700: ! 701: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 702: ! 703: cbData= 0; ! 704: ! 705: lResult= RegQueryValueEx(hkDefaults, LAST_FILE_SET, NULL, &dwType, ! 706: NULL, &cbData ! 707: ); ! 708: ! 709: if ( lResult != ERROR_SUCCESS ! 710: || dwType != REG_MULTI_SZ ! 711: ) ! 712: goto registry_damage_error; ! 713: ! 714: pszFileList= (PSZ) _alloca(cbData); ! 715: ! 716: if (!pszFileList) goto memory_limited; ! 717: ! 718: lResult= RegQueryValueEx(hkDefaults, LAST_FILE_SET, NULL, &dwType, ! 719: (LPBYTE) pszFileList, &cbData ! 720: ); ! 721: ! 722: if (lResult != ERROR_SUCCESS) goto registry_damage_error; ! 723: ! 724: lResult= RegSetValueEx(hkPerUser, LAST_FILE_SET, 0, REG_MULTI_SZ, ! 725: (LPBYTE) pszFileList, cbData ! 726: ); ! 727: ! 728: if (lResult != ERROR_SUCCESS) goto registry_access_error; ! 729: ! 730: // Now we force our registry subtree out to disk ! 731: // via the flush key api: ! 732: ! 733: lResult= RegFlushKey(hkPerUser); ! 734: ! 735: // Finally we store the REG_INSTALLED value in the registry to ! 736: // indicate that installation has completed. Note that its value ! 737: // is irrelevant. Only its presence or absence is meaningful. ! 738: ! 739: fInstalled= TRUE; ! 740: ! 741: lResult= RegSetValueEx(hkPerUser, REG_INSTALLED, 0, REG_DWORD, ! 742: (LPBYTE) &fInstalled, sizeof(fInstalled) ! 743: ); ! 744: ! 745: RegCloseKey(hkPerUser); ! 746: RegCloseKey(hkDefaults); ! 747: ! 748: FreeSid(psidAdmins); ! 749: ! 750: LocalFree(ptu); ! 751: ! 752: return(TRUE); ! 753: ! 754: registry_damage_error: ! 755: ! 756: // We'll display a warning that the registry info has ! 757: // been damaged. ! 758: ! 759: MPError(hwndFrame, MB_OK | MB_ICONHAND, IDS_MUTEX_LOGIC_ERR, NULL); ! 760: ! 761: // Then we discard the REG_INSTALLED flag to insure that a reinstallation ! 762: // can proceed. ! 763: ! 764: RegDeleteValue(hkGlobal, REG_INSTALLED); ! 765: ! 766: goto clean_up_registry_keys; ! 767: ! 768: registry_access_error: ! 769: ! 770: MPError(hwndFrame, MB_OK | MB_ICONHAND, IDS_REG_ACCESS_ERROR, NULL); ! 771: ! 772: clean_up_registry_keys: ! 773: ! 774: // We've constructed some, but not all of the global key state. ! 775: // So we must remove any keys we created. The Defaults key must ! 776: // be deleted first before the Global key can be deleted. ! 777: ! 778: if (hkPerUser) RegDeleteKey(HKEY_CURRENT_USER, pszPathBuff); ! 779: ! 780: if (hkDefaults) RegCloseKey(hkDefaults); ! 781: ! 782: goto clean_up_after_failure; ! 783: ! 784: memory_limited: ! 785: ! 786: MPError(hwndFrame, MB_OK | MB_ICONHAND, IDS_MEMORY_LIMITED, NULL); ! 787: goto clean_up_after_failure; ! 788: ! 789: security_failure: ! 790: ! 791: MPError(hwndFrame, MB_OK | MB_ICONHAND, IDS_SECURITY_FAIL_I, NULL); ! 792: ! 793: clean_up_after_failure: ! 794: ! 795: if (psidAdmins) FreeSid(psidAdmins ); ! 796: if (ptu ) LocalFree(psidUser); ! 797: ! 798: return FALSE; ! 799: } ! 800: ! 801: BOOL CreateAppKeys() ! 802: { ! 803: long lResult; ! 804: BOOL fSuccess; ! 805: BYTE abPathBuffer[MAX_PATH]; ! 806: BYTE abMutexName [MAX_PATH]; ! 807: ! 808: BOOL fInstalled= FALSE; ! 809: DWORD dwType, cbData; ! 810: ! 811: // Here we're constructing registry key handles for global data and ! 812: // per-user data. The global data is kept in the HKEY_LOCAL_MACHINE ! 813: // tree, and the per-user data is kept in the HKEY_CURRENT_USER tree. ! 814: // For both trees the data for this program is kept in the same ! 815: // relative location. ! 816: ! 817: // The registry handles are returned in the global variables hkGlobal ! 818: // and hkPerUser. In addition two global mutex handles (hmtxRegGlobal ! 819: // and hmtxRegPerUser are created. The mutexes are used to serialize ! 820: // registry accesses among instances of this application at start-up. ! 821: // That serialization is necessary to insure that a complete registry ! 822: // environment is present when the application starts. ! 823: ! 824: // Note that individual registry reads and writes do not need to be ! 825: // serialized -- only collections of reads and writes which must be ! 826: // consistent with each other. ! 827: ! 828: // Note all so the use of the registry value REG_INSTALLED. It is the ! 829: // last value written to the HKEY_LOCAL_MACHINE and HKEY_CURRENT_USER ! 830: // registry tree during the installation sequence. Whenever this application ! 831: // starts, it looks for REG_INSTALLED as a sign that the registry has ! 832: // been properly setup. If it doesn't find it, we assume that either ! 833: // setup hasn't been done or has been done incompletely. ! 834: ! 835: // First we'll construct a relative path to the keys we're going to ! 836: // open. The path has the structure: ! 837: ! 838: // Software \ <Company Name> \ <Application Name> \ <Version Number> ! 839: ! 840: wsprintf(abPathBuffer, "Software\\%s\\%s\\%s", ! 841: COMPANY_NAME, APPLICATION_NAME, VERSION_NUMBER ! 842: ); ! 843: ! 844: // Since two instance of this application could be running simultaneously, ! 845: // we use a named mutext to serialize registry accesses. ! 846: ! 847: wsprintf(abMutexName, "Software/%s/%s/%s/Globals", ! 848: COMPANY_NAME, APPLICATION_NAME, VERSION_NUMBER ! 849: ); ! 850: ! 851: if (!(hmtxRegGlobal= CreateMutex(NULL, FALSE, abMutexName))) goto failure_exit; ! 852: ! 853: wsprintf(abMutexName, "Software/%s/%s/%s/PerUser", ! 854: COMPANY_NAME, APPLICATION_NAME, VERSION_NUMBER ! 855: ); ! 856: ! 857: if (!(hmtxRegPerUser= CreateMutex(NULL, FALSE, abMutexName))) goto failure_exit; ! 858: ! 859: ! 860: // First we'll attempt to open a key to the global data... ! 861: ! 862: for (lResult= ~ERROR_SUCCESS; lResult != ERROR_SUCCESS; ) ! 863: { ! 864: // We serialize the code in this loop via hmtxRegGlobal. ! 865: ! 866: lResult= WaitForSingleObject(hmtxRegGlobal, 0xFFFFFFFF); ! 867: ! 868: if ( lResult != WAIT_ABANDONED ! 869: && lResult != WAIT_OBJECT_0 ! 870: ) goto failure_exit; ! 871: ! 872: lResult= RegOpenKeyEx(HKEY_LOCAL_MACHINE, abPathBuffer, 0, KEY_READ, ! 873: &hkGlobal ! 874: ); ! 875: ! 876: // Note that we also look for the REG_INSTALLED flag. ! 877: ! 878: cbData= sizeof(fInstalled); ! 879: ! 880: if ( ERROR_SUCCESS != lResult ! 881: || ERROR_SUCCESS != RegQueryValueEx(hkGlobal, REG_INSTALLED, 0, ! 882: &dwType, (LPBYTE) &fInstalled, ! 883: &cbData ! 884: ) ! 885: ) ! 886: { ! 887: hkGlobal= NULL; ! 888: ! 889: // If we can't open the global key, this probably means that the ! 890: // application hasn't been installed yet. So we'll try to install it. ! 891: ! 892: // If the installation succeeds, we'll try opening the global key ! 893: // again. Otherwise we'll just fail. ! 894: ! 895: fSuccess= InstallApp(abPathBuffer); ! 896: ! 897: ReleaseMutex(hmtxRegGlobal); ! 898: ! 899: if (fSuccess) continue; ! 900: else goto failure_exit; ! 901: } ! 902: ! 903: ReleaseMutex(hmtxRegGlobal); ! 904: } ! 905: ! 906: for (lResult= ~ERROR_SUCCESS; lResult != ERROR_SUCCESS; ) ! 907: { ! 908: // We serialize the code in this loop via hmtxRegPerUser. ! 909: ! 910: lResult= WaitForSingleObject(hmtxRegPerUser, 0xFFFFFFFF); ! 911: ! 912: if ( lResult != WAIT_ABANDONED ! 913: && lResult != WAIT_OBJECT_0 ! 914: ) goto failure_exit; ! 915: ! 916: // Now we'll try to open an handle to the per-user key for this user and ! 917: // this application. ! 918: ! 919: lResult= RegOpenKeyEx(HKEY_CURRENT_USER, abPathBuffer, 0, KEY_ALL_ACCESS, ! 920: &hkPerUser ! 921: ); ! 922: ! 923: // Note that we also look for the REG_INSTALLED flag. ! 924: ! 925: cbData= sizeof(fInstalled); ! 926: ! 927: if ( ERROR_SUCCESS != lResult ! 928: || ERROR_SUCCESS != RegQueryValueEx(hkPerUser, REG_INSTALLED, 0, ! 929: &dwType, (LPBYTE) &fInstalled, ! 930: &cbData ! 931: ) ! 932: ) ! 933: { ! 934: // The per-user open call failed. We infer that this is the first ! 935: // time this user has invoked this application. So next we'll try ! 936: // to initial a per-user area for them. ! 937: ! 938: hkPerUser= NULL; ! 939: ! 940: fSuccess= InitUser(hkGlobal, abPathBuffer); ! 941: ! 942: ReleaseMutex(hmtxRegPerUser); ! 943: ! 944: if (fSuccess) continue; ! 945: else goto failure_exit; ! 946: } ! 947: ! 948: ReleaseMutex(hmtxRegPerUser); ! 949: } ! 950: ! 951: return TRUE; ! 952: ! 953: failure_exit: ! 954: ! 955: // When we're exiting because of a failure, we must clean up ! 956: // by closing any handles we've created along the way. ! 957: ! 958: if (hmtxRegGlobal) CloseHandle(hmtxRegGlobal); ! 959: ! 960: if (hmtxRegPerUser) CloseHandle(hmtxRegPerUser); ! 961: ! 962: if (hkGlobal) RegCloseKey(hkGlobal); ! 963: ! 964: return FALSE; ! 965: } ! 966: ! 967: BOOL LoadConfiguration() ! 968: { ! 969: // This routine loads the per-user configuration data. ! 970: ! 971: // Two items are kept as configuration data: ! 972: // ! 973: // fTextWrapDefault -- a BOOL which defines whether the text windows ! 974: // fold text at the right edge of the window. ! 975: // ! 976: // A REG_MULTI_SZ list of file names. ! 977: // ! 978: // This list represents the files which were open at the end of the ! 979: // last RegMPad session. We'll attempt to reopen those files. ! 980: ! 981: LONG lResult, cbData; ! 982: DWORD dwType; ! 983: PSZ pszFileList= NULL; ! 984: ! 985: CHAR *pc; ! 986: ! 987: cbData= sizeof(fTextWrapDefault); ! 988: ! 989: lResult= RegQueryValueEx(hkPerUser, WORD_WRAP_DEFAULT, NULL, ! 990: &dwType, (LPBYTE) &fTextWrapDefault, &cbData ! 991: ); ! 992: ! 993: if (lResult != ERROR_SUCCESS) return FALSE; ! 994: ! 995: cbData= 0; ! 996: ! 997: lResult= RegQueryValueEx(hkPerUser, LAST_FILE_SET, NULL, &dwType, ! 998: NULL, &cbData ! 999: ); ! 1000: ! 1001: if ( lResult != ERROR_SUCCESS ! 1002: || dwType != REG_MULTI_SZ ! 1003: ) return FALSE; ! 1004: ! 1005: pszFileList= (PSZ) _alloca(cbData); ! 1006: ! 1007: if (!pszFileList) return FALSE; ! 1008: ! 1009: lResult= RegQueryValueEx(hkPerUser, LAST_FILE_SET, NULL, &dwType, ! 1010: (LPBYTE) pszFileList, &cbData ! 1011: ); ! 1012: ! 1013: if (lResult != ERROR_SUCCESS) return FALSE; ! 1014: ! 1015: for (pc= pszFileList; *pc; ) ! 1016: { ! 1017: if (!AlreadyOpen(pc)) AddFile(pc); ! 1018: ! 1019: for (; *pc++; ); ! 1020: } ! 1021: ! 1022: return TRUE; ! 1023: } ! 1024: ! 1025: BOOL SaveConfiguration() ! 1026: { ! 1027: // This routine saves the per-user configuration data to the registry. ! 1028: // That data consists of two items: ! 1029: // ! 1030: // fTextWrapDefault -- a BOOL which defines whether the text windows ! 1031: // fold text at the right edge of the window. ! 1032: // ! 1033: // A REG_MULTI_SZ list of file names. ! 1034: // ! 1035: // This list represents the files which were open at the end of the ! 1036: // last RegMPad session. ! 1037: ! 1038: LONG lResult; ! 1039: HWND hwnd; ! 1040: PBYTE pb, pbNext; ! 1041: LONG cb, cbTotal; ! 1042: ! 1043: lResult= RegSetValueEx(hkPerUser, WORD_WRAP_DEFAULT, 0, REG_DWORD, ! 1044: (CONST LPBYTE) &fTextWrapDefault, ! 1045: sizeof(fTextWrapDefault) ! 1046: ); ! 1047: ! 1048: if (lResult != ERROR_SUCCESS) return FALSE; ! 1049: ! 1050: for (hwnd= GetWindow(hwndMDIClient, GW_CHILD), cbTotal= 1; ! 1051: hwnd; ! 1052: hwnd= GetWindow(hwnd, GW_HWNDNEXT) ! 1053: ) ! 1054: { ! 1055: // Skip if this is an icon title window... ! 1056: ! 1057: if (GetWindow(hwnd, GW_OWNER)) continue; ! 1058: ! 1059: if (GetWindowWord(hwnd, GWW_UNTITLED)) continue; ! 1060: ! 1061: cbTotal += GetWindowTextLength(hwnd) + 1; ! 1062: } ! 1063: ! 1064: pb= (PBYTE) _alloca(cbTotal); ! 1065: ! 1066: if (!pb) return FALSE; ! 1067: ! 1068: for (hwnd= GetWindow(hwndMDIClient, GW_CHILD), pbNext= pb; ! 1069: hwnd; ! 1070: hwnd= GetWindow(hwnd, GW_HWNDNEXT) ! 1071: ) ! 1072: { ! 1073: // Skip if this is an icon title window... ! 1074: ! 1075: if (GetWindow(hwnd, GW_OWNER)) continue; ! 1076: ! 1077: if (GetWindowWord(hwnd, GWW_UNTITLED)) continue; ! 1078: ! 1079: cb= GetWindowTextLength(hwnd); ! 1080: ! 1081: GetWindowText(hwnd, pbNext, cb+1); ! 1082: ! 1083: pbNext+= cb+1; ! 1084: } ! 1085: ! 1086: *pbNext= 0; ! 1087: ! 1088: lResult= RegSetValueEx(hkPerUser, LAST_FILE_SET, 0, REG_MULTI_SZ, ! 1089: pb, cbTotal ! 1090: ); ! 1091: ! 1092: return (lResult == ERROR_SUCCESS)? TRUE : FALSE; ! 1093: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.