loader/registry.c

   1 /*
   2  * Modified for use with MPlayer, detailed changelog at
   3  * http://svn.mplayerhq.hu/mplayer/trunk/
   4  */
   5
   6 #include "config.h"
   7 #include "debug.h"
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <fcntl.h>
  12 #include <unistd.h>
  13 #include <pwd.h>
  14 #include <sys/types.h>
  15
  16 #include "wine/winbase.h"
  17 #include "wine/winreg.h"
  18 #include "wine/winnt.h"
  19 #include "wine/winerror.h"
  20
  21 #include "ext.h"
  22 #include "registry.h"
  23
  24 #include "path.h"
  25
  26 //#undef TRACE
  27 //#define TRACE printf
  28
  29 // ...can be set before init_registry() call
  30 char* regpathname = NULL;
  31
  32 static char* localregpathname = NULL;
  33
  34 typedef struct reg_handle_s
  35 {
  36         int handle;
  37         char* name;
  38         struct reg_handle_s* next;
  39         struct reg_handle_s* prev;
  40 } reg_handle_t;
  41
  42 struct reg_value
  43 {
  44         int type;
  45         char* name;
  46         int len;
  47         char* value;
  48 };
  49
  50 static struct reg_value* regs = NULL;
  51 static int reg_size;
  52 static reg_handle_t* head = NULL;
  53
  54 #define DIR -25
  55
  56 static void create_registry(void);
  57 static void open_registry(void);
  58 static void save_registry(void);
  59 static void init_registry(void);
  60
  61
  62 static void create_registry(void){
  63     if(regs)
  64     {
  65         printf("Logic error: create_registry() called with existing registry\n");
  66         save_registry();
  67         return;
  68     }
  69     regs=malloc(3*sizeof(struct reg_value));
  70     regs[0].type=regs[1].type=DIR;
  71     regs[0].name=malloc(5);
  72     strcpy(regs[0].name, "HKLM");
  73     regs[1].name=malloc(5);
  74     strcpy(regs[1].name, "HKCU");
  75     regs[0].value=regs[1].value=NULL;
  76     regs[0].len=regs[1].len=0;
  77     reg_size=2;
  78     head = 0;
  79     save_registry();
  80 }
  81
  82 static void open_registry(void)
  83 {
  84         int fd;
  85         int i;
  86         unsigned int len;
  87         if(regs)
  88         {
  89                 printf("Multiple open_registry(>\n");
  90                 return;
  91         }
  92         fd = open(localregpathname, O_RDONLY);
  93         if (fd == -1)
  94         {
  95             printf("Creating new registry\n");
  96             create_registry();
  97             return;
  98         }
  99         read(fd, &reg_size, 4);
 100         regs=malloc(reg_size*sizeof(struct reg_value));
 101         head = 0;
 102         for(i=0; i<reg_size; i++)
 103         {
 104                 read(fd,&regs[i].type,4);
 105                 read(fd,&len,4);
 106                 regs[i].name=malloc(len+1);
 107                 if(regs[i].name==0)
 108                 {
 109                         reg_size=i+1;
 110                         goto error;
 111                 }
 112                 read(fd, regs[i].name, len);
 113                 regs[i].name[len]=0;
 114                 read(fd,&regs[i].len,4);
 115                 regs[i].value=malloc(regs[i].len+1);
 116                 if(regs[i].value==0)
 117                 {
 118                         free(regs[i].name);
 119                         reg_size=i+1;
 120                         goto error;
 121                 }
 122                 read(fd, regs[i].value, regs[i].len);
 123                 regs[i].value[regs[i].len]=0;
 124         }
 125 error:
 126         close(fd);
 127         return;
 128 }
 129
 130 static void save_registry(void)
 131 {
 132         int fd, i;
 133         if (!regs)
 134                 init_registry();
 135         fd = open(localregpathname, O_WRONLY | O_CREAT, 00666);
 136         if (fd == -1)
 137         {
 138             printf("Failed to open registry file '%s' for writing.\n",
 139                    localregpathname);
 140             return;
 141         }
 142         write(fd, &reg_size, 4);
 143         for(i=0; i<reg_size; i++)
 144         {
 145                 unsigned len=strlen(regs[i].name);
 146                 write(fd, &regs[i].type, 4);
 147                 write(fd, &len, 4);
 148                 write(fd, regs[i].name, len);
 149                 write(fd, &regs[i].len, 4);
 150                 write(fd, regs[i].value, regs[i].len);
 151         }
 152         close(fd);
 153 }
 154
 155 void free_registry(void)
 156 {
 157     reg_handle_t* t = head;
 158     while (t)
 159     {
 160         reg_handle_t* f = t;
 161         free(t->name);
 162         t=t->prev;
 163         free(f);
 164     }
 165     head = 0;
 166     if (regs)
 167     {
 168         int i;
 169         for(i=0; i<reg_size; i++)
 170         {
 171             free(regs[i].name);
 172             free(regs[i].value);
 173         }
 174         free(regs);
 175         regs = 0;
 176     }
 177
 178     if (localregpathname && localregpathname != regpathname)
 179         free(localregpathname);
 180     localregpathname = 0;
 181 }
 182
 183
 184 #if 0
 185 static reg_handle_t* find_handle_by_name(const char* name)
 186 {
 187         reg_handle_t* t;
 188         for(t=head; t; t=t->prev)
 189         {
 190                 if(!strcmp(t->name, name))
 191                 {
 192                         return t;
 193                 }
 194         }
 195         return 0;
 196 }
 197 #endif
 198 static struct reg_value* find_value_by_name(const char* name)
 199 {
 200         int i;
 201         for(i=0; i<reg_size; i++)
 202                 if(!strcmp(regs[i].name, name))
 203                         return regs+i;
 204         return 0;
 205 }
 206 static reg_handle_t* find_handle(int handle)
 207 {
 208         reg_handle_t* t;
 209         for(t=head; t; t=t->prev)
 210         {
 211                 if(t->handle==handle)
 212                 {
 213                         return t;
 214                 }
 215         }
 216         return 0;
 217 }
 218 static int generate_handle(void)
 219 {
 220         static unsigned int zz=249;
 221         zz++;
 222         while((zz==HKEY_LOCAL_MACHINE) || (zz==HKEY_CURRENT_USER))
 223                 zz++;
 224         return zz;
 225 }
 226
 227 static reg_handle_t* insert_handle(long handle, const char* name)
 228 {
 229         reg_handle_t* t;
 230         t=malloc(sizeof(reg_handle_t));
 231         if(head==0)
 232         {
 233                 t->prev=0;
 234         }
 235         else
 236         {
 237                 head->next=t;
 238                 t->prev=head;
 239         }
 240         t->next=0;
 241         t->name=malloc(strlen(name)+1);
 242         strcpy(t->name, name);
 243         t->handle=handle;
 244         head=t;
 245         return t;
 246 }
 247 static char* build_keyname(long key, const char* subkey)
 248 {
 249         char* full_name;
 250         reg_handle_t* t;
 251         if((t=find_handle(key))==0)
 252         {
 253                 TRACE("Invalid key\n");
 254                 return NULL;
 255         }
 256         if(subkey==NULL)
 257                 subkey="<default>";
 258         full_name=malloc(strlen(t->name)+strlen(subkey)+10);
 259         strcpy(full_name, t->name);
 260         strcat(full_name, "\\");
 261         strcat(full_name, subkey);
 262         return full_name;
 263 }
 264 static struct reg_value* insert_reg_value(int handle, const char* name, int type, const void* value, int len)
 265 {
 266         struct reg_value* v;
 267         char* fullname;
 268         if((fullname=build_keyname(handle, name))==NULL)
 269         {
 270                 TRACE("Invalid handle\n");
 271                 return NULL;
 272         }
 273
 274         if((v=find_value_by_name(fullname))==0)
 275         //creating new value in registry
 276         {
 277                 if(regs==0)
 278                     create_registry();
 279                 regs = realloc(regs, sizeof(struct reg_value) * (reg_size +1 ));
 280                 //regs=(struct reg_value*)my_realloc(regs, sizeof(struct reg_value)*(reg_size+1));
 281                 v=regs+reg_size;
 282                 reg_size++;
 283         }
 284         else
 285         //replacing old one
 286         {
 287             free(v->value);
 288             free(v->name);
 289         }
 290         TRACE("RegInsert '%s'  %p  v:%d  len:%d\n", name, value, *(int*)value, len);
 291         v->type=type;
 292         v->len=len;
 293         v->value=malloc(len);
 294         memcpy(v->value, value, len);
 295         v->name=malloc(strlen(fullname)+1);
 296         strcpy(v->name, fullname);
 297         free(fullname);
 298         save_registry();
 299         return v;
 300 }
 301
 302 static void init_registry(void)
 303 {
 304         TRACE("Initializing registry\n");
 305         // can't be free-ed - it's static and probably thread
 306         // unsafe structure which is stored in glibc
 307
 308         regpathname = get_path("registry");
 309         localregpathname = regpathname;
 310
 311         open_registry();
 312         insert_handle(HKEY_LOCAL_MACHINE, "HKLM");
 313         insert_handle(HKEY_CURRENT_USER, "HKCU");
 314 }
 315
 316 #if 0
 317 static reg_handle_t* find_handle_2(long key, const char* subkey)
 318 {
 319         char* full_name;
 320         reg_handle_t* t;
 321         if((t=find_handle(key))==0)
 322         {
 323                 TRACE("Invalid key\n");
 324                 return (reg_handle_t*)-1;
 325         }
 326         if(subkey==NULL)
 327                 return t;
 328         full_name=malloc(strlen(t->name)+strlen(subkey)+10);
 329         strcpy(full_name, t->name);
 330         strcat(full_name, "\\");
 331         strcat(full_name, subkey);
 332         t=find_handle_by_name(full_name);
 333         free(full_name);
 334         return t;
 335 }
 336 #endif
 337
 338 long __stdcall RegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey)
 339 {
 340     char* full_name;
 341     reg_handle_t* t;
 342     TRACE("Opening key %s\n", subkey);
 343
 344     if(!regs)
 345         init_registry()
 346 ;
 347 /*      t=find_handle_2(key, subkey);
 348
 349         if(t==0)
 350                 return -1;
 351
 352         if(t==(reg_handle_t*)-1)
 353                 return -1;
 354 */
 355     full_name=build_keyname(key, subkey);
 356     if(!full_name)
 357         return -1;
 358     TRACE("Opening key Fullname %s\n", full_name);
 359     find_value_by_name(full_name);
 360
 361     t=insert_handle(generate_handle(), full_name);
 362     *newkey=t->handle;
 363     free(full_name);
 364
 365     return 0;
 366 }
 367 long __stdcall RegCloseKey(long key)
 368 {
 369     reg_handle_t *handle;
 370     if(key==(long)HKEY_LOCAL_MACHINE)
 371         return 0;
 372     if(key==(long)HKEY_CURRENT_USER)
 373         return 0;
 374     handle=find_handle(key);
 375     if(handle==0)
 376         return 0;
 377     if(handle->prev)
 378         handle->prev->next=handle->next;
 379     if(handle->next)
 380         handle->next->prev=handle->prev;
 381     free(handle->name);
 382     if(handle==head)
 383         head=head->prev;
 384     free(handle);
 385     return 0;
 386 }
 387
 388 long __stdcall RegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
 389 {
 390     struct reg_value* t;
 391     char* c;
 392     TRACE("Querying value %s\n", value);
 393     if(!regs)
 394         init_registry();
 395
 396     c=build_keyname(key, value);
 397     if (!c)
 398         return 1;
 399     t=find_value_by_name(c);
 400     if (t==0) {
 401         // Hacks for CineForm.
 402         if (strcmp(c, "HKCU\\SOFTWARE\\CineForm\\DecoderProperties\\Resolution") == 0) {
 403             if (data)
 404                 *data = 1000;
 405             if (type)
 406                 *type = REG_DWORD;
 407             if (count)
 408                 *count = sizeof(DWORD);
 409             free(c);
 410             return ERROR_SUCCESS;
 411         }
 412         if (strcmp(c, "HKCU\\SOFTWARE\\CineForm\\DecoderProperties\\PixelFormats") == 0) {
 413             if (data)
 414                 *data = 0xffff;
 415             if (type)
 416                 *type = REG_DWORD;
 417             if (count)
 418                 *count = sizeof(DWORD);
 419             free(c);
 420             return ERROR_SUCCESS;
 421         }
 422         free(c);
 423         return ERROR_FILE_NOT_FOUND;
 424     }
 425     free(c);
 426     if (type)
 427         *type=t->type;
 428     if (data)
 429     {
 430         memcpy(data, t->value, (t->len<*count)?t->len:*count);
 431         TRACE("returning %d bytes: %d\n", t->len, *(int*)data);
 432     }
 433     if(*count<t->len)
 434     {
 435         *count=t->len;
 436         return ERROR_MORE_DATA;
 437     }
 438     else
 439     {
 440         *count=t->len;
 441     }
 442     return ERROR_SUCCESS;
 443 }
 444 long __stdcall RegCreateKeyExA(long key, const char* name, long reserved,
 445                      void* classs, long options, long security,
 446                      void* sec_attr, int* newkey, int* status)
 447 {
 448     reg_handle_t* t;
 449     char* fullname;
 450     struct reg_value* v;
 451     //        TRACE("Creating/Opening key %s\n", name);
 452     if(!regs)
 453         init_registry();
 454
 455     fullname=build_keyname(key, name);
 456     if (!fullname)
 457         return 1;
 458     TRACE("Creating/Opening key %s\n", fullname);
 459     v=find_value_by_name(fullname);
 460     if(v==0)
 461     {
 462         int qw=45708;
 463         v=insert_reg_value(key, name, DIR, &qw, 4);
 464         if (status) *status=REG_CREATED_NEW_KEY;
 465         //              return 0;
 466     }
 467
 468     t=insert_handle(generate_handle(), fullname);
 469     *newkey=t->handle;
 470     free(fullname);
 471     return 0;
 472 }
 473
 474 /*
 475 LONG RegEnumValue(
 476   HKEY hKey,              // handle to key to query
 477   DWORD dwIndex,          // index of value to query
 478   LPTSTR lpValueName,     // address of buffer for value string
 479   LPDWORD lpcbValueName,  // address for size of value buffer
 480   LPDWORD lpReserved,     // reserved
 481   LPDWORD lpType,         // address of buffer for type code
 482   LPBYTE lpData,          // address of buffer for value data
 483   LPDWORD lpcbData        // address for size of data buffer
 484 );
 485 */
 486
 487 long __stdcall RegEnumValueA(HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
 488                    LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count)
 489 {
 490     // currenly just made to support MSZH & ZLIB
 491     //printf("Reg Enum 0x%x %d  %s %d   data: %p %d  %d >%s<\n", hkey, index,
 492     //       value, *val_count, data, *count, reg_size, data);
 493     reg_handle_t* t = find_handle(hkey);
 494     if (t && index < 10)
 495     {
 496         struct reg_value* v=find_value_by_name(t->name);
 497         if (v)
 498         {
 499             memcpy(data, v->value, (v->len < *count) ? v->len : *count);
 500             if(*count < v->len)
 501                 *count = v->len;
 502             if (type)
 503                 *type = v->type;
 504             //printf("Found handle  %s\n", v->name);
 505             return 0;
 506         }
 507     }
 508     return ERROR_NO_MORE_ITEMS;
 509 }
 510
 511 long __stdcall RegSetValueExA(long key, const char* name, long v1, long v2, const void* data, long size)
 512 {
 513     char* c;
 514     TRACE("Request to set value %s %d\n", name, *(const int*)data);
 515     if(!regs)
 516         init_registry();
 517
 518     c=build_keyname(key, name);
 519     if(c==NULL)
 520         return 1;
 521     insert_reg_value(key, name, v2, data, size);
 522     free(c);
 523     return 0;
 524 }
 525
 526 long __stdcall RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName,
 527                    LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass,
 528                    LPFILETIME lpftLastWriteTime)
 529 {
 530     return ERROR_NO_MORE_ITEMS;
 531 }