开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
registry.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：12k
源码类别：

midi

开发平台：

Unix_Linux

registry.c：源码内容
  1. /*
  2.  * $Id: 5bc802ff84d51169df6508f41d2df50d7efef27f $
  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.  */
  28. #include "config.h"
  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>
  37. #include "wine/winbase.h"
  38. #include "wine/winreg.h"
  39. #include "wine/winnt.h"
  40. #include "wine/winerror.h"
  42. #include "ext.h"
  43. #include "registry.h"
  45. //#undef TRACE
  46. //#define TRACE printf
  48. extern char *get_path ( char * );
  50. // ...can be set before init_registry() call
  51. char* regpathname = NULL;
  53. static char* localregpathname = NULL;
  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;
  63. struct reg_value
  64. {
  65. int type;
  66. char* name;
  67. int len;
  68. char* value;
  69. };
  71. static struct reg_value* regs = NULL;
  72. static int reg_size;
  73. static reg_handle_t* head = NULL;
  75. #define DIR -25
  77. static void create_registry(void);
  78. static void open_registry(void);
  79. static void save_registry(void);
  80. static void init_registry(void);
  83. static void create_registry(void){
  84.     if(regs)
  85.     {
  86. printf("Logic error: create_registry() called with existing registryn");
  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. }
  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 registryn");
  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==NULL)
  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==NULL)
  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. }
  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. }
  176. void free_registry(void)
  177. {
  178.     reg_handle_t* t = head;
  179.     while (t)
  180.     {
  181. reg_handle_t* f = t;
  182. free(t->name);
  183. t=t->prev;
  184.         free(f);
  185.     }
  186.     head = 0;
  187.     if (regs)
  188.     {
  189.         int i;
  190. for(i=0; i<reg_size; i++)
  191. {
  192.     free(regs[i].name);
  193.     free(regs[i].value);
  194. }
  195. free(regs);
  196. regs = 0;
  197.     }
  199.     if (localregpathname != regpathname)
  200. free(localregpathname);
  201.     localregpathname = 0;
  202. }
  205. static reg_handle_t* find_handle_by_name(const char* name)
  206. {
  207. reg_handle_t* t;
  208. for(t=head; t; t=t->prev)
  209. {
  210. if(!strcmp(t->name, name))
  211. {
  212. return t;
  213. }
  214. }
  215. return 0;
  216. }
  217. static struct reg_value* find_value_by_name(const char* name)
  218. {
  219. int i;
  220. for(i=0; i<reg_size; i++)
  221. if(!strcmp(regs[i].name, name))
  222. return regs+i;
  223. return 0;
  224. }
  225. static reg_handle_t* find_handle(int handle)
  226. {
  227. reg_handle_t* t;
  228. for(t=head; t; t=t->prev)
  229. {
  230. if(t->handle==handle)
  231. {
  232. return t;
  233. }
  234. }
  235. return 0;
  236. }
  237. static int generate_handle()
  238. {
  239. static unsigned int zz=249;
  240. zz++;
  241. while((zz==HKEY_LOCAL_MACHINE) || (zz==HKEY_CURRENT_USER))
  242. zz++;
  243. return zz;
  244. }
  246. static reg_handle_t* insert_handle(long handle, const char* name)
  247. {
  248. reg_handle_t* t;
  249. t=(reg_handle_t*)malloc(sizeof(reg_handle_t));
  250. if(head==NULL)
  251. {
  252. t->prev=0;
  253. }
  254. else
  255. {
  256. head->next=t;
  257. t->prev=head;
  258. }
  259. t->next=0;
  260. t->name=(char*)malloc(strlen(name)+1);
  261. strcpy(t->name, name);
  262. t->handle=handle;
  263. head=t;
  264. return t;
  265. }
  266. static char* build_keyname(long key, const char* subkey)
  267. {
  268. char* full_name;
  269. reg_handle_t* t;
  270.         if((t=find_handle(key))==NULL)
  271. {
  272. TRACE("Invalid keyn");
  273. return NULL;
  274. }
  275. if(subkey==NULL)
  276. subkey="<default>";
  277. full_name=(char*)malloc(strlen(t->name)+strlen(subkey)+10);
  278. strcpy(full_name, t->name);
  279. strcat(full_name, "\");
  280. strcat(full_name, subkey);
  281. return full_name;
  282. }
  283. static struct reg_value* insert_reg_value(int handle, const char* name, int type, const void* value, int len)
  284. {
  285. reg_handle_t* t;
  286. struct reg_value* v;
  287. char* fullname;
  288. if((fullname=build_keyname(handle, name))==NULL)
  289. {
  290. TRACE("Invalid handlen");
  291. return NULL;
  292. }
  294. if((v=find_value_by_name(fullname))==NULL)
  295. //creating new value in registry
  296. {
  297. if(regs==NULL)
  298.     create_registry();
  299. regs=(struct reg_value*)realloc(regs, sizeof(struct reg_value)*(reg_size+1));
  300. //regs=(struct reg_value*)my_realloc(regs, sizeof(struct reg_value)*(reg_size+1));
  301. v=regs+reg_size;
  302. reg_size++;
  303. }
  304. else
  305. //replacing old one
  306. {
  307.     free(v->value);
  308.     free(v->name);
  309. }
  310. TRACE("RegInsert '%s'  %p  v:%d  len:%dn", name, value, *(int*)value, len);
  311. v->type=type;
  312. v->len=len;
  313. v->value=(char*)malloc(len);
  314. memcpy(v->value, value, len);
  315. v->name=(char*)malloc(strlen(fullname)+1);
  316. strcpy(v->name, fullname);
  317.         free(fullname);
  318. save_registry();
  319. return v;
  320. }
  322. static void init_registry(void)
  323. {
  324. TRACE("Initializing registryn");
  325. // can't be free-ed - it's static and probably thread
  326. // unsafe structure which is stored in glibc
  328. #ifdef MPLAYER
  329. regpathname = get_path("registry");
  330. localregpathname = regpathname;
  331. #else
  332. // regpathname is an external pointer
  333.         //
  334. // registry.c is holding its own internal pointer
  335. // localregpathname  - which is being allocate/deallocated
  337. if (localregpathname == NULL)
  338. {
  339.             const char* pthn = regpathname;
  340.     if (!regpathname)
  341.     {
  342. // avifile - for now reading data from user's home
  343. struct passwd* pwent;
  344. pwent = getpwuid(geteuid());
  345.                 pthn = pwent->pw_dir;
  346.     }
  348.     localregpathname = (char*)malloc(strlen(pthn)+20);
  349.     strcpy(localregpathname, pthn);
  350.     strcat(localregpathname, "/.registry");
  351. }
  352. #endif
  354. open_registry();
  355. insert_handle(HKEY_LOCAL_MACHINE, "HKLM");
  356. insert_handle(HKEY_CURRENT_USER, "HKCU");
  357. }
  359. static reg_handle_t* find_handle_2(long key, const char* subkey)
  360. {
  361. char* full_name;
  362. reg_handle_t* t;
  363.         if((t=find_handle(key))==NULL)
  364. {
  365. TRACE("Invalid keyn");
  366. return (reg_handle_t*)-1;
  367. }
  368. if(subkey==NULL)
  369. return t;
  370. full_name=(char*)malloc(strlen(t->name)+strlen(subkey)+10);
  371. strcpy(full_name, t->name);
  372. strcat(full_name, "\");
  373. strcat(full_name, subkey);
  374. t=find_handle_by_name(full_name);
  375. free(full_name);
  376. return t;
  377. }
  379. long __stdcall RegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey)
  380. {
  381.     char* full_name;
  382.     reg_handle_t* t;
  383.     struct reg_value* v;
  384.     TRACE("Opening key %sn", subkey);
  386.     if(!regs)
  387.         init_registry()
  388. ;
  389. /* t=find_handle_2(key, subkey);
  391. if(t==0)
  392. return -1;
  394. if(t==(reg_handle_t*)-1)
  395. return -1;
  396. */
  397.     full_name=build_keyname(key, subkey);
  398.     if(!full_name)
  399.         return -1;
  400.     TRACE("Opening key Fullname %sn", full_name);
  401.     v=find_value_by_name(full_name);
  403.     t=insert_handle(generate_handle(), full_name);
  404.     *newkey=t->handle;
  405.     free(full_name);
  407.     return 0;
  408. }
  409. long __stdcall RegCloseKey(long key)
  410. {
  411.     reg_handle_t *handle;
  412.     if(key==(long)HKEY_LOCAL_MACHINE)
  413. return 0;
  414.     if(key==(long)HKEY_CURRENT_USER)
  415. return 0;
  416.     handle=find_handle(key);
  417.     if(handle==NULL)
  418. return 0;
  419.     if(handle->prev)
  420. handle->prev->next=handle->next;
  421.     if(handle->next)
  422. handle->next->prev=handle->prev;
  423.     free(handle->name);
  424.     if(handle==head)
  425. head=head->prev;
  426.     free(handle);
  427.     return 1;
  428. }
  430. long __stdcall RegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
  431. {
  432.     struct reg_value* t;
  433.     char* c;
  434.     TRACE("Querying value %sn", value);
  435.     if(!regs)
  436. init_registry();
  438.     c=build_keyname(key, value);
  439.     if (!c)
  440. return 1;
  441.     t=find_value_by_name(c);
  442.     free(c);
  443.     if (t==NULL)
  444. return 2;
  445.     if (type)
  446. *type=t->type;
  447.     if (data)
  448.     {
  449. memcpy(data, t->value, (t->len<*count)?t->len:*count);
  450. TRACE("returning %d bytes: %dn", t->len, *(int*)data);
  451.     }
  452.     if(*count<t->len)
  453.     {
  454. *count=t->len;
  455. return ERROR_MORE_DATA;
  456.     }
  457.     else
  458.     {
  459. *count=t->len;
  460.     }
  461.     return 0;
  462. }
  463. long __stdcall RegCreateKeyExA(long key, const char* name, long reserved,
  464.      void* classs, long options, long security,
  465.      void* sec_attr, int* newkey, int* status)
  466. {
  467.     reg_handle_t* t;
  468.     char* fullname;
  469.     struct reg_value* v;
  470.     //        TRACE("Creating/Opening key %sn", name);
  471.     if(!regs)
  472. init_registry();
  474.     fullname=build_keyname(key, name);
  475.     if (!fullname)
  476. return 1;
  477.     TRACE("Creating/Opening key %sn", fullname);
  478.     v=find_value_by_name(fullname);
  479.     if(v==NULL)
  480.     {
  481. int qw=45708;
  482. v=insert_reg_value(key, name, DIR, &qw, 4);
  483. if (status) *status=REG_CREATED_NEW_KEY;
  484. // return 0;
  485.     }
  487.     t=insert_handle(generate_handle(), fullname);
  488.     *newkey=t->handle;
  489.     free(fullname);
  490.     return 0;
  491. }
  493. /*
  494. LONG RegEnumValue(
  495.   HKEY hKey,              // handle to key to query
  496.   DWORD dwIndex,          // index of value to query
  497.   LPTSTR lpValueName,     // address of buffer for value string
  498.   LPDWORD lpcbValueName,  // address for size of value buffer
  499.   LPDWORD lpReserved,     // reserved
  500.   LPDWORD lpType,         // address of buffer for type code
  501.   LPBYTE lpData,          // address of buffer for value data
  502.   LPDWORD lpcbData        // address for size of data buffer
  503. );
  504. */
  506. long __stdcall RegEnumValueA(HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
  507.    LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count)
  508. {
  509.     // currenly just made to support MSZH & ZLIB
  510.     //printf("Reg Enum 0x%x %d  %s %d   data: %p %d  %d >%s<n", hkey, index,
  511.     //       value, *val_count, data, *count, reg_size, data);
  512.     reg_handle_t* t = find_handle(hkey);
  513.     if (t && index < 10)
  514.     {
  515. struct reg_value* v=find_value_by_name(t->name);
  516. if (v)
  517. {
  518.     memcpy(data, v->value, (v->len < *count) ? v->len : *count);
  519.     if(*count < v->len)
  520. *count = v->len;
  521.     if (type)
  522. *type = v->type;
  523.     //printf("Found handle  %sn", v->name);
  524.     return 0;
  525. }
  526.     }
  527.     return ERROR_NO_MORE_ITEMS;
  528. }
  530. long __stdcall RegSetValueExA(long key, const char* name, long v1, long v2, const void* data, long size)
  531. {
  532.     struct reg_value* t;
  533.     char* c;
  534.     TRACE("Request to set value %s %dn", name, *(const int*)data);
  535.     if(!regs)
  536. init_registry();
  538.     c=build_keyname(key, name);
  539.     if(c==NULL)
  540. return 1;
  541.     insert_reg_value(key, name, v2, data, size);
  542.     free(c);
  543.     return 0;
  544. }
  546. long __stdcall RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName,
  547.    LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass,
  548.    LPFILETIME lpftLastWriteTime)
  549. {
  550.     return ERROR_NO_MORE_ITEMS;
  551. }