Return to registry.c CVS log

Up to [truecrypt] / truecrypt / common

Annotation of truecrypt/common/registry.c, revision 1.1.1.6

1.1.1.4   root        1: /* 
1.1.1.5   root        2: Copyright (c) 2004-2006 TrueCrypt Foundation. All rights reserved. 
1.1.1.4   root        3: Copyright (c) 2004 TrueCrypt Team. All rights reserved. 
                      4: 
1.1.1.6 ! root        5: Covered by TrueCrypt License 2.1 the full text of which is contained in the file
1.1.1.4   root        6: License.txt included in TrueCrypt binary and source code distribution archives. 
                      7: */
1.1       root        8: 
1.1.1.4   root        9: #include "Tcdefs.h"
                     10: #include "Registry.h"
1.1       root       11: 
1.1.1.4   root       12: int ReadRegistryInt (char *subKey, char *name, int defaultValue)
1.1       root       13: {
                     14:        HKEY hkey = 0;
                     15:        DWORD value, size = sizeof (DWORD);
                     16: 
1.1.1.4   root       17:        if (RegOpenKeyEx (HKEY_CURRENT_USER, subKey,
1.1       root       18:                0, KEY_READ, &hkey) != ERROR_SUCCESS)
                     19:                return defaultValue;
                     20: 
                     21:        if (RegQueryValueEx (hkey, name, 0,     0, (LPBYTE) &value, &size) != ERROR_SUCCESS)
                     22:                value = defaultValue;
                     23: 
                     24:        RegCloseKey (hkey);
                     25:        return value;
                     26: }
                     27: 
1.1.1.4   root       28: char *ReadRegistryString (char *subKey, char *name, char *defaultValue, char *str, int maxLen)
1.1       root       29: {
                     30:        HKEY hkey = 0;
1.1.1.4   root       31:        char value[MAX_PATH*4];
1.1       root       32:        DWORD size = sizeof (value);
                     33: 
                     34:        strncpy (str, defaultValue, maxLen-1);
                     35: 
                     36:        ZeroMemory (value, sizeof value);
1.1.1.4   root       37:        if (RegOpenKeyEx (HKEY_CURRENT_USER, subKey,
1.1       root       38:                0, KEY_READ, &hkey) == ERROR_SUCCESS)
                     39:                if (RegQueryValueEx (hkey, name, 0,     0, (LPBYTE) &value,     &size) == ERROR_SUCCESS)
                     40:                        strncpy (str, value, maxLen-1);
                     41: 
                     42:        RegCloseKey (hkey);
                     43:        return str;
                     44: }
                     45: 
1.1.1.4   root       46: DWORD ReadRegistryBytes (char *path, char *name, char *value, int maxLen)
                     47: {
                     48:        HKEY hkey = 0;
                     49:        DWORD size = maxLen;
                     50:        BOOL success = FALSE;
                     51: 
                     52:        if (RegOpenKeyEx (HKEY_CURRENT_USER, path, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
                     53:                return 0;
                     54: 
                     55:        success = (RegQueryValueEx (hkey, name, 0,      0, (LPBYTE) value,      &size) == ERROR_SUCCESS);
                     56:        RegCloseKey (hkey);
                     57: 
                     58:        return success ? size : 0;
                     59: }
                     60: 
                     61: void WriteRegistryInt (char *subKey, char *name, int value)
1.1       root       62: {
                     63:        HKEY hkey = 0;
                     64:        DWORD disp;
                     65: 
1.1.1.4   root       66:        if (RegCreateKeyEx (HKEY_CURRENT_USER, subKey,
1.1       root       67:                0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, &disp) != ERROR_SUCCESS)
                     68:                return;
                     69: 
                     70:        RegSetValueEx (hkey, name, 0, REG_DWORD, (BYTE *) &value, sizeof value);
                     71:        RegCloseKey (hkey);
                     72: }
                     73: 
1.1.1.4   root       74: void WriteRegistryString (char *subKey, char *name, char *str)
1.1       root       75: {
                     76:        HKEY hkey = 0;
                     77:        DWORD disp;
                     78: 
1.1.1.4   root       79:        if (RegCreateKeyEx (HKEY_CURRENT_USER, subKey,
1.1       root       80:                0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, &disp) != ERROR_SUCCESS)
                     81:                return;
                     82: 
                     83:        RegSetValueEx (hkey, name, 0, REG_SZ, (BYTE *) str, strlen (str) + 1);
                     84:        RegCloseKey (hkey);
                     85: }
1.1.1.4   root       86: 
                     87: BOOL WriteRegistryBytes (char *path, char *name, char *str, DWORD size)
                     88: {
                     89:        HKEY hkey = 0;
                     90:        DWORD disp;
                     91:        BOOL res;
                     92: 
                     93:        if (RegCreateKeyEx (HKEY_CURRENT_USER, path,
                     94:                0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, &disp) != ERROR_SUCCESS)
                     95:                return FALSE;
                     96: 
                     97:        res = RegSetValueEx (hkey, name, 0, REG_BINARY, (BYTE *) str, size);
                     98:        RegCloseKey (hkey);
                     99:        return res == ERROR_SUCCESS;
                    100: }
                    101: 
                    102: void DeleteRegistryValue (char *subKey, char *name)
                    103: {
                    104:        HKEY hkey = 0;
                    105: 
                    106:        if (RegOpenKeyEx (HKEY_CURRENT_USER, subKey, 0, KEY_WRITE, &hkey) != ERROR_SUCCESS)
                    107:                return;
                    108: 
                    109:        RegDeleteValue (hkey, name);
                    110:        RegCloseKey (hkey);
                    111: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.