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         if (t->name)
 162             free(t->name);
 163         t=t->prev;
 164         free(f);
 165     }
 166     head = 0;
 167     if (regs)
 168     {
 169         int i;
 170         for(i=0; i<reg_size; i++)
 171         {
 172             free(regs[i].name);
 173             free(regs[i].value);
 174         }
 175         free(regs);
 176         regs = 0;
 177     }
 178
 179     if (localregpathname && localregpathname != regpathname)
 180         free(localregpathname);
 181     localregpathname = 0;
 182 }
 183
 184
 185 #if 0
 186 static reg_handle_t* find_handle_by_name(const char* name)
 187 {
 188         reg_handle_t* t;
 189         for(t=head; t; t=t->prev)
 190         {
 191                 if(!strcmp(t->name, name))
 192                 {
 193                         return t;
 194                 }
 195         }
 196         return 0;
 197 }
 198 #endif
 199 static struct reg_value* find_value_by_name(const char* name)
 200 {
 201         int i;
 202         for(i=0; i<reg_size; i++)
 203                 if(!strcmp(regs[i].name, name))
 204                         return regs+i;
 205         return 0;
 206 }
 207 static reg_handle_t* find_handle(int handle)
 208 {
 209         reg_handle_t* t;
 210         for(t=head; t; t=t->prev)
 211         {
 212                 if(t->handle==handle)
 213                 {
 214                         return t;
 215                 }
 216         }
 217         return 0;
 218 }
 219 static int generate_handle(void)
 220 {
 221         static unsigned int zz=249;
 222         zz++;
 223         while((zz==HKEY_LOCAL_MACHINE) || (zz==HKEY_CURRENT_USER))
 224                 zz++;
 225         return zz;
 226 }
 227
 228 static reg_handle_t* insert_handle(long handle, const char* name)
 229 {
 230         reg_handle_t* t;
 231         t=malloc(sizeof(reg_handle_t));
 232         if(head==0)
 233         {
 234                 t->prev=0;
 235         }
 236         else
 237         {
 238                 head->next=t;
 239                 t->prev=head;
 240         }
 241         t->next=0;
 242         t->name=malloc(strlen(name)+1);
 243         strcpy(t->name, name);
 244         t->handle=handle;
 245         head=t;
 246         return t;
 247 }
 248 static char* build_keyname(long key, const char* subkey)
 249 {
 250         char* full_name;
 251         reg_handle_t* t;
 252         if((t=find_handle(key))==0)
 253         {
 254                 TRACE("Invalid key\n");
 255                 return NULL;
 256         }
 257         if(subkey==NULL)
 258                 subkey="<default>";
 259         full_name=malloc(strlen(t->name)+strlen(subkey)+10);
 260         strcpy(full_name, t->name);
 261         strcat(full_name, "\\");
 262         strcat(full_name, subkey);
 263         return full_name;
 264 }
 265 static struct reg_value* insert_reg_value(int handle, const char* name, int type, const void* value, int len)
 266 {
 267         struct reg_value* v;
 268         char* fullname;
 269         if((fullname=build_keyname(handle, name))==NULL)
 270         {
 271                 TRACE("Invalid handle\n");
 272                 return NULL;
 273         }
 274
 275         if((v=find_value_by_name(fullname))==0)
 276         //creating new value in registry
 277         {
 278                 if(regs==0)
 279                     create_registry();
 280                 regs = realloc(regs, sizeof(struct reg_value) * (reg_size +1 ));
 281                 //regs=(struct reg_value*)my_realloc(regs, sizeof(struct reg_value)*(reg_size+1));
 282                 v=regs+reg_size;
 283                 reg_size++;
 284         }
 285         else
 286         //replacing old one
 287         {
 288             free(v->value);
 289             free(v->name);
 290         }
 291         TRACE("RegInsert '%s'  %p  v:%d  len:%d\n", name, value, *(int*)value, len);
 292         v->type=type;
 293         v->len=len;
 294         v->value=malloc(len);
 295         memcpy(v->value, value, len);
 296         v->name=malloc(strlen(fullname)+1);
 297         strcpy(v->name, fullname);
 298         free(fullname);
 299         save_registry();
 300         return v;
 301 }
 302
 303 static void init_registry(void)
 304 {
 305         TRACE("Initializing registry\n");
 306         // can't be free-ed - it's static and probably thread
 307         // unsafe structure which is stored in glibc
 308
 309         regpathname = get_path("registry");
 310         localregpathname = regpathname;
 311
 312         open_registry();
 313         insert_handle(HKEY_LOCAL_MACHINE, "HKLM");
 314         insert_handle(HKEY_CURRENT_USER, "HKCU");
 315 }
 316
 317 #if 0
 318 static reg_handle_t* find_handle_2(long key, const char* subkey)
 319 {
 320         char* full_name;
 321         reg_handle_t* t;
 322         if((t=find_handle(key))==0)
 323         {
 324                 TRACE("Invalid key\n");
 325                 return (reg_handle_t*)-1;
 326         }
 327         if(subkey==NULL)
 328                 return t;
 329         full_name=malloc(strlen(t->name)+strlen(subkey)+10);
 330         strcpy(full_name, t->name);
 331         strcat(full_name, "\\");
 332         strcat(full_name, subkey);
 333         t=find_handle_by_name(full_name);
 334         free(full_name);
 335         return t;
 336 }
 337 #endif
 338
 339 long __stdcall RegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey)
 340 {
 341     char* full_name;
 342     reg_handle_t* t;
 343     struct reg_value* v;
 344     TRACE("Opening key %s\n", subkey);
 345
 346     if(!regs)
 347         init_registry()
 348 ;
 349 /*      t=find_handle_2(key, subkey);
 350
 351         if(t==0)
 352                 return -1;
 353
 354         if(t==(reg_handle_t*)-1)
 355                 return -1;
 356 */
 357     full_name=build_keyname(key, subkey);
 358     if(!full_name)
 359         return -1;
 360     TRACE("Opening key Fullname %s\n", full_name);
 361     v=find_value_by_name(full_name);
 362
 363     t=insert_handle(generate_handle(), full_name);
 364     *newkey=t->handle;
 365     free(full_name);
 366
 367     return 0;
 368 }
 369 long __stdcall RegCloseKey(long key)
 370 {
 371     reg_handle_t *handle;
 372     if(key==(long)HKEY_LOCAL_MACHINE)
 373         return 0;
 374     if(key==(long)HKEY_CURRENT_USER)
 375         return 0;
 376     handle=find_handle(key);
 377     if(handle==0)
 378         return 0;
 379     if(handle->prev)
 380         handle->prev->next=handle->next;
 381     if(handle->next)
 382         handle->next->prev=handle->prev;
 383     if(handle->name)
 384         free(handle->name);
 385     if(handle==head)
 386         head=head->prev;
 387     free(handle);
 388     return 0;
 389 }
 390
 391 long __stdcall RegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
 392 {
 393     struct reg_value* t;
 394     char* c;
 395     TRACE("Querying value %s\n", value);
 396     if(!regs)
 397         init_registry();
 398
 399     c=build_keyname(key, value);
 400     if (!c)
 401         return 1;
 402     t=find_value_by_name(c);
 403     if (t==0) {
 404         // Hacks for CineForm.
 405         if (strcmp(c, "HKCU\\SOFTWARE\\CineForm\\DecoderProperties\\Resolution") == 0) {
 406             if (data)
 407                 *data = 1000;
 408             if (type)
 409                 *type = REG_DWORD;
 410             if (count)
 411                 *count = sizeof(DWORD);
 412             free(c);
 413             return ERROR_SUCCESS;
 414         }
 415         if (strcmp(c, "HKCU\\SOFTWARE\\CineForm\\DecoderProperties\\PixelFormats") == 0) {
 416             if (data)
 417                 *data = 0xffff;
 418             if (type)
 419                 *type = REG_DWORD;
 420             if (count)
 421                 *count = sizeof(DWORD);
 422             free(c);
 423             return ERROR_SUCCESS;
 424         }
 425         free(c);
 426         return ERROR_FILE_NOT_FOUND;
 427     }
 428     free(c);
 429     if (type)
 430         *type=t->type;
 431     if (data)
 432     {
 433         memcpy(data, t->value, (t->len<*count)?t->len:*count);
 434         TRACE("returning %d bytes: %d\n", t->len, *(int*)data);
 435     }
 436     if(*count<t->len)
 437     {
 438         *count=t->len;
 439         return ERROR_MORE_DATA;
 440     }
 441     else
 442     {
 443         *count=t->len;
 444     }
 445     return ERROR_SUCCESS;
 446 }
 447 long __stdcall RegCreateKeyExA(long key, const char* name, long reserved,
 448                      void* classs, long options, long security,
 449                      void* sec_attr, int* newkey, int* status)
 450 {
 451     reg_handle_t* t;
 452     char* fullname;
 453     struct reg_value* v;
 454     //        TRACE("Creating/Opening key %s\n", name);
 455     if(!regs)
 456         init_registry();
 457
 458     fullname=build_keyname(key, name);
 459     if (!fullname)
 460         return 1;
 461     TRACE("Creating/Opening key %s\n", fullname);
 462     v=find_value_by_name(fullname);
 463     if(v==0)
 464     {
 465         int qw=45708;
 466         v=insert_reg_value(key, name, DIR, &qw, 4);
 467         if (status) *status=REG_CREATED_NEW_KEY;
 468         //              return 0;
 469     }
 470
 471     t=insert_handle(generate_handle(), fullname);
 472     *newkey=t->handle;
 473     free(fullname);
 474     return 0;
 475 }
 476
 477 /*
 478 LONG RegEnumValue(
 479   HKEY hKey,              // handle to key to query
 480   DWORD dwIndex,          // index of value to query
 481   LPTSTR lpValueName,     // address of buffer for value string
 482   LPDWORD lpcbValueName,  // address for size of value buffer
 483   LPDWORD lpReserved,     // reserved
 484   LPDWORD lpType,         // address of buffer for type code
 485   LPBYTE lpData,          // address of buffer for value data
 486   LPDWORD lpcbData        // address for size of data buffer
 487 );
 488 */
 489
 490 long __stdcall RegEnumValueA(HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
 491                    LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count)
 492 {
 493     // currenly just made to support MSZH & ZLIB
 494     //printf("Reg Enum 0x%x %d  %s %d   data: %p %d  %d >%s<\n", hkey, index,
 495     //       value, *val_count, data, *count, reg_size, data);
 496     reg_handle_t* t = find_handle(hkey);
 497     if (t && index < 10)
 498     {
 499         struct reg_value* v=find_value_by_name(t->name);
 500         if (v)
 501         {
 502             memcpy(data, v->value, (v->len < *count) ? v->len : *count);
 503             if(*count < v->len)
 504                 *count = v->len;
 505             if (type)
 506                 *type = v->type;
 507             //printf("Found handle  %s\n", v->name);
 508             return 0;
 509         }
 510     }
 511     return ERROR_NO_MORE_ITEMS;
 512 }
 513
 514 long __stdcall RegSetValueExA(long key, const char* name, long v1, long v2, const void* data, long size)
 515 {
 516     char* c;
 517     TRACE("Request to set value %s %d\n", name, *(const int*)data);
 518     if(!regs)
 519         init_registry();
 520
 521     c=build_keyname(key, name);
 522     if(c==NULL)
 523         return 1;
 524     insert_reg_value(key, name, v2, data, size);
 525     free(c);
 526     return 0;
 527 }
 528
 529 long __stdcall RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName,
 530                    LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass,
 531                    LPFILETIME lpftLastWriteTime)
 532 {
 533     return ERROR_NO_MORE_ITEMS;
 534 }