Line data Source code
1 : /*
2 : * Unix SMB/CIFS implementation.
3 : * Virtual Windows Registry Layer
4 : * Copyright (C) Gerald Carter 2002.
5 : * Copyright (C) Michael Adam 2008
6 : *
7 : * This program is free software; you can redistribute it and/or modify
8 : * it under the terms of the GNU General Public License as published by
9 : * the Free Software Foundation; either version 3 of the License, or
10 : * (at your option) any later version.
11 : *
12 : * This program is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : * GNU General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU General Public License
18 : * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : /* Implementation of registry hook cache tree */
22 :
23 : #include "includes.h"
24 : #include "adt_tree.h"
25 : #include "registry.h"
26 : #include "reg_cachehook.h"
27 :
28 : #undef DBGC_CLASS
29 : #define DBGC_CLASS DBGC_REGISTRY
30 :
31 : static struct sorted_tree *cache_tree = NULL;
32 : extern struct registry_ops regdb_ops; /* these are the default */
33 :
34 2414485 : static WERROR keyname_to_path(TALLOC_CTX *mem_ctx, const char *keyname,
35 : char **path)
36 : {
37 2414485 : char *tmp_path = NULL;
38 :
39 2414485 : if ((keyname == NULL) || (path == NULL)) {
40 0 : return WERR_INVALID_PARAMETER;
41 : }
42 :
43 2414485 : tmp_path = talloc_asprintf(mem_ctx, "\\%s", keyname);
44 2414485 : if (tmp_path == NULL) {
45 0 : DEBUG(0, ("talloc_asprintf failed!\n"));
46 0 : return WERR_NOT_ENOUGH_MEMORY;
47 : }
48 :
49 2414485 : *path = tmp_path;
50 :
51 2414485 : return WERR_OK;
52 : }
53 :
54 : /**********************************************************************
55 : Initialize the cache tree if it has not been initialized yet.
56 : *********************************************************************/
57 :
58 963 : WERROR reghook_cache_init(void)
59 : {
60 963 : if (cache_tree != NULL) {
61 72 : return WERR_OK;
62 : }
63 :
64 891 : cache_tree = pathtree_init(®db_ops);
65 891 : if (cache_tree == NULL) {
66 0 : return WERR_NOT_ENOUGH_MEMORY;
67 : }
68 891 : DEBUG(10, ("reghook_cache_init: new tree with default "
69 : "ops %p for key [%s]\n", (void *)®db_ops,
70 : KEY_TREE_ROOT));
71 891 : return WERR_OK;
72 : }
73 :
74 : /**********************************************************************
75 : Add a new registry hook to the cache. Note that the keyname
76 : is not in the exact format that a struct sorted_tree expects.
77 : *********************************************************************/
78 :
79 1493 : WERROR reghook_cache_add(const char *keyname, struct registry_ops *ops)
80 : {
81 : WERROR werr;
82 1493 : char *key = NULL;
83 :
84 1493 : if ((keyname == NULL) || (ops == NULL)) {
85 0 : return WERR_INVALID_PARAMETER;
86 : }
87 :
88 1493 : werr = keyname_to_path(talloc_tos(), keyname, &key);
89 1493 : if (!W_ERROR_IS_OK(werr)) {
90 0 : goto done;
91 : }
92 :
93 1493 : DEBUG(10, ("reghook_cache_add: Adding ops %p for key [%s]\n",
94 : (void *)ops, key));
95 :
96 1493 : if (!pathtree_add(cache_tree, key, ops))
97 0 : werr = WERR_NOT_ENOUGH_MEMORY;
98 : else
99 1493 : werr = WERR_OK;
100 :
101 1493 : done:
102 1493 : TALLOC_FREE(key);
103 1493 : return werr;
104 : }
105 :
106 : /**********************************************************************
107 : Find a key in the cache.
108 : *********************************************************************/
109 :
110 2412992 : struct registry_ops *reghook_cache_find(const char *keyname)
111 : {
112 : WERROR werr;
113 2412992 : char *key = NULL;
114 2412992 : struct registry_ops *ops = NULL;
115 :
116 2412992 : if (keyname == NULL) {
117 0 : return NULL;
118 : }
119 :
120 2412992 : werr = keyname_to_path(talloc_tos(), keyname, &key);
121 2412992 : if (!W_ERROR_IS_OK(werr)) {
122 0 : goto done;
123 : }
124 :
125 2412992 : DEBUG(10,("reghook_cache_find: Searching for keyname [%s]\n", key));
126 :
127 2412992 : ops = (struct registry_ops *)pathtree_find(cache_tree, key);
128 :
129 2412992 : DEBUG(10, ("reghook_cache_find: found ops %p for key [%s]\n",
130 : ops ? (void *)ops : 0, key));
131 :
132 2412992 : done:
133 2412992 : TALLOC_FREE(key);
134 :
135 2412888 : return ops;
136 : }
137 :
138 : /**********************************************************************
139 : Print out the cache tree structure for debugging.
140 : *********************************************************************/
141 :
142 0 : void reghook_dump_cache( int debuglevel )
143 : {
144 0 : DEBUG(debuglevel,("reghook_dump_cache: Starting cache dump now...\n"));
145 :
146 0 : pathtree_print_keys( cache_tree, debuglevel );
147 0 : }
|