src/osapi/osregistry.cpp

   1 #include <windows.h>
   2 #include <string.h>
   3 #include "pstypes.h"
   4 #include "osregistry.h"
   5
   6 // NEVER ADD ANY OTHER INCLUDES HERE - YOU'LL LIKELY BREAK THE LAUNCHER!!!!!!!!!!!!!
   7
   8 // ------------------------------------------------------------------------------------------------------------
   9 // REGISTRY DEFINES/VARS
  10 //
  11
  12 static char                     szCompanyName[128];
  13 static char                     szAppName[128];
  14 static char                     szAppVersion[128];
  15
  16 char *Osreg_company_name = "Volition";
  17 char *Osreg_class_name = "Freespace2Class";
  18 #if defined(FS2_DEMO)
  19 char *Osreg_app_name = "FreeSpace2Demo";
  20 char *Osreg_title = "Freespace 2 Demo";
  21 #elif defined(OEM_BUILD)
  22 char *Osreg_app_name = "FreeSpace2OEM";
  23 char *Osreg_title = "Freespace 2 OEM";
  24 #else
  25 char *Osreg_app_name = "FreeSpace2";
  26 char *Osreg_title = "Freespace 2";
  27 #endif
  28
  29 int Os_reg_inited = 0;
  30
  31
  32 // ------------------------------------------------------------------------------------------------------------
  33 // REGISTRY FUNCTIONS
  34 //
  35
  36 // os registry functions -------------------------------------------------------------
  37
  38 // initialize the registry. setup default keys to use
  39 void os_init_registry_stuff(char *company, char *app, char *version)
  40 {
  41         if(company){
  42                 strcpy( szCompanyName, company );
  43         } else {
  44                 strcpy( szCompanyName, Osreg_company_name);
  45         }
  46
  47         if(app){
  48                 strcpy( szAppName, app );
  49         } else {
  50                 strcpy( szAppName, Osreg_app_name);
  51         }
  52
  53         if(version){
  54                 strcpy( szAppVersion, version);
  55         } else {
  56                 strcpy( szAppVersion, "1.0");
  57         }
  58
  59         Os_reg_inited = 1;
  60 }
  61
  62 // Removes a value from to the INI file.  Passing
  63 // name=NULL will delete the section.
  64 void os_config_remove( char *section, char *name )
  65 {
  66         HKEY hKey = NULL;
  67         DWORD dwDisposition;
  68         char keyname[1024];
  69         LONG lResult;
  70
  71         if(!Os_reg_inited){
  72                 return;
  73         }
  74
  75         if ( section )  {
  76                 sprintf( keyname, "Software\\%s\\%s\\%s", szCompanyName, szAppName, section );
  77         } else {
  78                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, szAppName );
  79         }
  80
  81         // remove the value
  82         if ( !name )    {
  83                 if ( !section ) {
  84                         goto Cleanup;
  85                 }
  86                 lResult = RegDeleteKey( HKEY_LOCAL_MACHINE, keyname );
  87                 if ( lResult != ERROR_SUCCESS ) {
  88                         goto Cleanup;
  89                 }
  90         } else  {
  91                 lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE,                                           // Where to add it
  92                                                                                                  keyname,                                                               // name of key
  93                                                                                                  NULL,                                                                  // DWORD reserved
  94                                                                                                  "",                                                                            // Object class
  95                                                                                                  REG_OPTION_NON_VOLATILE,                       // Save to disk
  96                                                                                                  KEY_ALL_ACCESS,                                                // Allows all changes
  97                                                                                                  NULL,                                                                  // Default security attributes
  98                                                                                                  &hKey,                                                 // Location to store key
  99                                                                                                  &dwDisposition );                                      // Location to store status of key
 100
 101                 if ( lResult != ERROR_SUCCESS ) {
 102                         goto Cleanup;
 103                 }
 104
 105                 lResult = RegDeleteValue( hKey, name );
 106                 if ( lResult != ERROR_SUCCESS ) {
 107                         goto Cleanup;
 108                 }
 109         }
 110
 111 Cleanup:
 112         if ( hKey )
 113                 RegCloseKey(hKey);
 114 }
 115
 116 // Writes a string to the INI file.  If value is NULL,
 117 // removes the string. Writing a NULL value to a NULL name will delete
 118 // the section.
 119 void os_config_write_string( char *section, char *name, char *value )
 120 {
 121         HKEY hKey = NULL;
 122         DWORD dwDisposition;
 123         char keyname[1024];
 124         LONG lResult;
 125
 126         if(!Os_reg_inited){
 127                 return;
 128         }
 129
 130         if ( section )  {
 131                 sprintf( keyname, "Software\\%s\\%s\\%s", szCompanyName, szAppName, section );
 132         } else {
 133                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, szAppName );
 134         }
 135
 136         lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE,                                   // Where to add it
 137                                                                                          keyname,                                                       // name of key
 138                                                                                          NULL,                                                          // DWORD reserved
 139                                                                                          "",                                                                    // Object class
 140                                                                                          REG_OPTION_NON_VOLATILE,               // Save to disk
 141                                                                                          KEY_ALL_ACCESS,                                        // Allows all changes
 142                                                                                          NULL,                                                          // Default security attributes
 143                                                                                          &hKey,                                                         // Location to store key
 144                                                                                          &dwDisposition );                              // Location to store status of key
 145
 146         if ( lResult != ERROR_SUCCESS ) {
 147                 goto Cleanup;
 148         }
 149
 150         if ( !name )     {
 151                 goto Cleanup;
 152         }
 153
 154         lResult = RegSetValueEx( hKey,                                                                  // Handle to key
 155                                                                          name,                                                                  // The values name
 156                                                                          NULL,                                                                  // DWORD reserved
 157                                                                          REG_SZ,                                                                        // null terminated string
 158                                                                          (CONST BYTE *)value,                           // value to set
 159                                                                          strlen(value) + 1 );                           // How many bytes to set
 160
 161         if ( lResult != ERROR_SUCCESS ) {
 162                 goto Cleanup;
 163         }
 164
 165
 166 Cleanup:
 167         if ( hKey )
 168                 RegCloseKey(hKey);
 169 }
 170
 171 // same as previous function except we don't use the application name to build up the keyname
 172 void os_config_write_string2( char *section, char *name, char *value )
 173 {
 174         HKEY hKey = NULL;
 175         DWORD dwDisposition;
 176         char keyname[1024];
 177         LONG lResult;
 178
 179         if(!Os_reg_inited){
 180                 return;
 181         }
 182
 183         if ( section )  {
 184                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, section );
 185         } else {
 186                 sprintf( keyname, "Software\\%s", szCompanyName );
 187         }
 188
 189         lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE,                                   // Where to add it
 190                                                                                          keyname,                                                       // name of key
 191                                                                                          NULL,                                                          // DWORD reserved
 192                                                                                          "",                                                                    // Object class
 193                                                                                          REG_OPTION_NON_VOLATILE,               // Save to disk
 194                                                                                          KEY_ALL_ACCESS,                                        // Allows all changes
 195                                                                                          NULL,                                                          // Default security attributes
 196                                                                                          &hKey,                                                         // Location to store key
 197                                                                                          &dwDisposition );                              // Location to store status of key
 198
 199         if ( lResult != ERROR_SUCCESS ) {
 200                 goto Cleanup;
 201         }
 202
 203         if ( !name )     {
 204                 goto Cleanup;
 205         }
 206
 207         lResult = RegSetValueEx( hKey,                                                                  // Handle to key
 208                                                                          name,                                                                  // The values name
 209                                                                          NULL,                                                                  // DWORD reserved
 210                                                                          REG_SZ,                                                                        // null terminated string
 211                                                                          (CONST BYTE *)value,                           // value to set
 212                                                                          strlen(value) + 1 );                           // How many bytes to set
 213
 214         if ( lResult != ERROR_SUCCESS ) {
 215                 goto Cleanup;
 216         }
 217
 218
 219 Cleanup:
 220         if ( hKey )
 221                 RegCloseKey(hKey);
 222 }
 223
 224 // Writes an unsigned int to the INI file.
 225 void os_config_write_uint( char *section, char *name, uint value )
 226 {
 227         HKEY hKey = NULL;
 228         DWORD dwDisposition;
 229         char keyname[1024];
 230         LONG lResult;
 231
 232         if(!Os_reg_inited){
 233                 return;
 234         }
 235
 236         if ( section )  {
 237                 sprintf( keyname, "Software\\%s\\%s\\%s", szCompanyName, szAppName, section );
 238         } else {
 239                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, szAppName );
 240         }
 241
 242         lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE,                                           // Where to add it
 243                                                                                          keyname,                                                               // name of key
 244                                                                                          NULL,                                                                  // DWORD reserved
 245                                                                                          "",                                                                            // Object class
 246                                                                                          REG_OPTION_NON_VOLATILE,                       // Save to disk
 247                                                                                          KEY_ALL_ACCESS,                                                // Allows all changes
 248                                                                                          NULL,                                                                  // Default security attributes
 249                                                                                          &hKey,                                                 // Location to store key
 250                                                                                          &dwDisposition );                                      // Location to store status of key
 251
 252         if ( lResult != ERROR_SUCCESS ) {
 253                 goto Cleanup;
 254         }
 255
 256         if ( !name )     {
 257                 goto Cleanup;
 258         }
 259
 260         lResult = RegSetValueEx( hKey,                                                                  // Handle to key
 261                                                                          name,                                                                                  // The values name
 262                                                                          NULL,                                                                                  // DWORD reserved
 263                                                                          REG_DWORD,                                                                             // null terminated string
 264                                                                          (CONST BYTE *)&value,                                          // value to set
 265                                                                          4 );                                                           // How many bytes to set
 266
 267         if ( lResult != ERROR_SUCCESS ) {
 268                 goto Cleanup;
 269         }
 270
 271 Cleanup:
 272         if ( hKey )
 273                 RegCloseKey(hKey);
 274
 275 }
 276
 277
 278 // Reads a string from the INI file.  If default is passed,
 279 // and the string isn't found, returns ptr to default otherwise
 280 // returns NULL;    Copy the return value somewhere before
 281 // calling os_read_string again, because it might reuse the
 282 // same buffer.
 283 static char tmp_string_data[1024];
 284 char * os_config_read_string( char *section, char *name, char *default_value )
 285 {
 286         HKEY hKey = NULL;
 287         DWORD dwType, dwLen;
 288         char keyname[1024];
 289         LONG lResult;
 290
 291         if(!Os_reg_inited){
 292                 return NULL;
 293         }
 294
 295         if ( section )  {
 296                 sprintf( keyname, "Software\\%s\\%s\\%s", szCompanyName, szAppName, section );
 297         } else {
 298                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, szAppName );
 299         }
 300
 301         lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,                                                     // Where it is
 302                                                                                          keyname,                                                               // name of key
 303                                                                                          NULL,                                                                  // DWORD reserved
 304                                                                                          KEY_QUERY_VALUE,                                               // Allows all changes
 305                                                                                          &hKey );                                                               // Location to store key
 306
 307         if ( lResult != ERROR_SUCCESS ) {
 308                 goto Cleanup;
 309         }
 310
 311         if ( !name )     {
 312                 goto Cleanup;
 313         }
 314
 315         dwLen = 1024;
 316         lResult = RegQueryValueEx( hKey,                                                                        // Handle to key
 317                                                                          name,                                                                                  // The values name
 318                                                                          NULL,                                                                                  // DWORD reserved
 319                                  &dwType,                                                                               // What kind it is
 320                                                                          (ubyte *)&tmp_string_data,                                             // value to set
 321                                                                          &dwLen );                                                              // How many bytes to set
 322
 323         if ( lResult != ERROR_SUCCESS ) {
 324                 goto Cleanup;
 325         }
 326
 327         default_value = tmp_string_data;
 328
 329 Cleanup:
 330         if ( hKey )
 331                 RegCloseKey(hKey);
 332
 333         return default_value;
 334 }
 335
 336 // same as previous function except we don't use the application name to build up the keyname
 337 char * os_config_read_string2( char *section, char *name, char *default_value )
 338 {
 339         HKEY hKey = NULL;
 340         DWORD dwType, dwLen;
 341         char keyname[1024];
 342         LONG lResult;
 343
 344         if(!Os_reg_inited){
 345                 return NULL;
 346         }
 347
 348         if ( section )  {
 349                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, section );
 350         } else {
 351                 sprintf( keyname, "Software\\%s", szCompanyName );
 352         }
 353
 354         lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,                                                     // Where it is
 355                                                                                          keyname,                                                               // name of key
 356                                                                                          NULL,                                                                  // DWORD reserved
 357                                                                                          KEY_QUERY_VALUE,                                               // Allows all changes
 358                                                                                          &hKey );                                                               // Location to store key
 359
 360         if ( lResult != ERROR_SUCCESS ) {
 361                 goto Cleanup;
 362         }
 363
 364         if ( !name )     {
 365                 goto Cleanup;
 366         }
 367
 368         dwLen = 1024;
 369         lResult = RegQueryValueEx( hKey,                                                                        // Handle to key
 370                                                                          name,                                                                                  // The values name
 371                                                                          NULL,                                                                                  // DWORD reserved
 372                                  &dwType,                                                                               // What kind it is
 373                                                                          (ubyte *)&tmp_string_data,                                             // value to set
 374                                                                          &dwLen );                                                              // How many bytes to set
 375
 376         if ( lResult != ERROR_SUCCESS ) {
 377                 goto Cleanup;
 378         }
 379
 380         default_value = tmp_string_data;
 381
 382 Cleanup:
 383         if ( hKey )
 384                 RegCloseKey(hKey);
 385
 386         return default_value;
 387 }
 388
 389 // Reads a string from the INI file.  Default_value must
 390 // be passed, and if 'name' isn't found, then returns default_value
 391 uint  os_config_read_uint( char *section, char *name, uint default_value )
 392 {
 393         HKEY hKey = NULL;
 394         DWORD dwType, dwLen;
 395         char keyname[1024];
 396         LONG lResult;
 397         uint tmp_val;
 398
 399         if(!Os_reg_inited){
 400                 return NULL;
 401         }
 402
 403         if ( section )  {
 404                 sprintf( keyname, "Software\\%s\\%s\\%s", szCompanyName, szAppName, section );
 405         } else {
 406                 sprintf( keyname, "Software\\%s\\%s", szCompanyName, szAppName );
 407         }
 408
 409         lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,                                                     // Where it is
 410                                                                                          keyname,                                                               // name of key
 411                                                                                          NULL,                                                                  // DWORD reserved
 412                                                                                          KEY_QUERY_VALUE,                                               // Allows all changes
 413                                                                                          &hKey );                                                               // Location to store key
 414
 415         if ( lResult != ERROR_SUCCESS ) {
 416                 goto Cleanup;
 417         }
 418
 419         if ( !name )     {
 420                 goto Cleanup;
 421         }
 422
 423         dwLen = 4;
 424         lResult = RegQueryValueEx( hKey,                                                                        // Handle to key
 425                                                                          name,                                                                                  // The values name
 426                                                                          NULL,                                                                                  // DWORD reserved
 427                                  &dwType,                                                                               // What kind it is
 428                                                                          (ubyte *)&tmp_val,                                             // value to set
 429                                                                          &dwLen );                                                              // How many bytes to set
 430
 431         if ( lResult != ERROR_SUCCESS ) {
 432                 goto Cleanup;
 433         }
 434
 435         default_value = tmp_val;
 436
 437 Cleanup:
 438         if ( hKey )
 439                 RegCloseKey(hKey);
 440
 441         return default_value;
 442 }
 443
 444 // uses Ex versions of Windows registry functions
 445 static char tmp_string_data_ex[1024];
 446 char * os_config_read_string_ex( char *keyname, char *name, char *default_value )
 447 {
 448         HKEY hKey = NULL;
 449         DWORD dwType, dwLen;
 450         LONG lResult;
 451
 452         lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,                                                     // Where it is
 453                                                                                          keyname,                                                               // name of key
 454                                                                                          NULL,                                                                  // DWORD reserved
 455                                                                                          KEY_QUERY_VALUE,                                               // Allows all changes
 456                                                                                          &hKey );                                                               // Location to store key
 457
 458         if ( lResult != ERROR_SUCCESS ) {
 459                 //mprintf(( "Error opening registry key '%s'\n", keyname ));
 460                 goto Cleanup;
 461         }
 462
 463         if ( !name )     {
 464                 //mprintf(( "No variable name passed\n" ));
 465                 goto Cleanup;
 466         }
 467
 468         dwLen = 1024;
 469         lResult = RegQueryValueEx( hKey,                                                                        // Handle to key
 470                                                                          name,                                                                                  // The values name
 471                                                                          NULL,                                                                                  // DWORD reserved
 472                                  &dwType,                                                                               // What kind it is
 473                                                                          (ubyte *)&tmp_string_data_ex,                                          // value to set
 474                                                                          &dwLen );                                                              // How many bytes to set
 475
 476         if ( lResult != ERROR_SUCCESS ) {
 477                 //mprintf(( "Error reading registry key '%s'\n", name ));
 478                 goto Cleanup;
 479         }
 480
 481         default_value = tmp_string_data_ex;
 482
 483 Cleanup:
 484         if ( hKey )
 485                 RegCloseKey(hKey);
 486
 487         return default_value;
 488 }