git.sesse.net Git - vlc/blob - libs/loader/registry.c

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