s3: remove unused regval_convert_multi_sz().
[ira/wip.git] / source3 / registry / reg_util.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  Virtual Windows Registry Layer (utility functions)
4  *  Copyright (C) Gerald Carter                     2002-2005
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* Implementation of registry frontend view functions. */
21
22 #include "includes.h"
23
24 #undef DBGC_CLASS
25 #define DBGC_CLASS DBGC_REGISTRY
26
27 /***********************************************************************
28  Utility function for splitting the base path of a registry path off
29  by setting base and new_path to the apprapriate offsets withing the
30  path.
31
32  WARNING!!  Does modify the original string!
33  ***********************************************************************/
34
35 bool reg_split_path(char *path, char **base, char **new_path)
36 {
37         char *p;
38
39         *new_path = *base = NULL;
40
41         if (!path) {
42                 return false;
43         }
44         *base = path;
45
46         p = strchr(path, '\\');
47
48         if ( p ) {
49                 *p = '\0';
50                 *new_path = p+1;
51         }
52
53         return true;
54 }
55
56 /***********************************************************************
57  Utility function for splitting the base path of a registry path off
58  by setting base and new_path to the appropriate offsets withing the
59  path.
60
61  WARNING!!  Does modify the original string!
62  ***********************************************************************/
63
64 bool reg_split_key(char *path, char **base, char **key)
65 {
66         char *p;
67
68         *key = *base = NULL;
69
70         if (!path) {
71                 return false;
72         }
73
74         *base = path;
75
76         p = strrchr(path, '\\');
77
78         if (p) {
79                 *p = '\0';
80                 *key = p+1;
81         }
82
83         return true;
84 }
85
86 /**
87  * The full path to the registry key is used as database key
88  * after the \'s are converted to /'s.
89  * Leading and trailing '/' and '\' characters are stripped.
90  * Key string is also normalized to UPPER case.
91  */
92
93 char *normalize_reg_path(TALLOC_CTX *ctx, const char *keyname )
94 {
95         char *p;
96         char *nkeyname;
97
98         /* skip leading '/' and '\' chars */
99         p = (char *)keyname;
100         while ((*p == '/') || (*p == '\\')) {
101                 p++;
102         }
103
104         nkeyname = talloc_string_sub(ctx, p, "\\", "/");
105         if (nkeyname == NULL) {
106                 return NULL;
107         }
108
109         /* strip trailing '/' chars */
110         p = strrchr(nkeyname, '/');
111         while ((p != NULL) && (p[1] == '\0')) {
112                 *p = '\0';
113                 p = strrchr(nkeyname, '/');
114         }
115
116         strupper_m(nkeyname);
117
118         return nkeyname;
119 }
120
121 /**
122  * normalize ther registry path in place.
123  */
124 void normalize_dbkey(char *key)
125 {
126         size_t len = strlen(key);
127         string_sub(key, "\\", "/", len+1);
128         strupper_m(key);
129 }
130
131 /**********************************************************************
132  move to next non-delimter character
133 *********************************************************************/
134
135 char *reg_remaining_path(TALLOC_CTX *ctx, const char *key)
136 {
137         char *new_path = NULL;
138         char *p = NULL;
139
140         if (!key || !*key) {
141                 return NULL;
142         }
143
144         new_path = talloc_strdup(ctx, key);
145         if (!new_path) {
146                 return NULL;
147         }
148         /* normalize_reg_path( new_path ); */
149         if (!(p = strchr(new_path, '\\')) ) {
150                 if (!(p = strchr( new_path, '/'))) {
151                         p = new_path;
152                 } else {
153                         p++;
154                 }
155         } else {
156                 p++;
157         }
158
159         return p;
160 }