source: branches/samba-3.5.x/source3/lib/util_reg_api.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 4.2 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * Registry helper routines
4 * Copyright (C) Volker Lendecke 2006
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 3 of the License, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include "includes.h"
21
22#undef DBGC_CLASS
23#define DBGC_CLASS DBGC_REGISTRY
24
25WERROR registry_pull_value(TALLOC_CTX *mem_ctx,
26 struct registry_value **pvalue,
27 enum winreg_Type type, uint8 *data,
28 uint32 size, uint32 length)
29{
30 struct registry_value *value;
31 WERROR err;
32
33 if (!(value = TALLOC_ZERO_P(mem_ctx, struct registry_value))) {
34 return WERR_NOMEM;
35 }
36
37 value->type = type;
38
39 switch (type) {
40 case REG_DWORD:
41 if ((size != 4) || (length != 4)) {
42 err = WERR_INVALID_PARAM;
43 goto error;
44 }
45 value->v.dword = IVAL(data, 0);
46 break;
47 case REG_SZ:
48 case REG_EXPAND_SZ:
49 {
50 /*
51 * Make sure we get a NULL terminated string for
52 * convert_string_talloc().
53 */
54
55 smb_ucs2_t *tmp;
56
57 if (length == 1) {
58 /* win2k regedit gives us a string of 1 byte when
59 * creating a new value of type REG_SZ. this workaround
60 * replaces the input by using the same string as
61 * winxp delivers. */
62 length = 2;
63 if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, 2))) {
64 err = WERR_NOMEM;
65 goto error;
66 }
67 tmp[0] = 0;
68 tmp[1] = 0;
69 DEBUG(10, ("got REG_SZ value of length 1 - workaround "
70 "activated.\n"));
71 }
72 else if ((length % 2) != 0) {
73 err = WERR_INVALID_PARAM;
74 goto error;
75 }
76 else {
77 uint32 num_ucs2 = length / 2;
78 if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, num_ucs2+1))) {
79 err = WERR_NOMEM;
80 goto error;
81 }
82
83 memcpy((void *)tmp, (const void *)data, length);
84 tmp[num_ucs2] = 0;
85 }
86
87 if (length + 2 < length) {
88 /* Integer wrap. */
89 SAFE_FREE(tmp);
90 err = WERR_INVALID_PARAM;
91 goto error;
92 }
93
94 if (!convert_string_talloc(value, CH_UTF16LE, CH_UNIX, tmp,
95 length+2, (void *)&value->v.sz.str,
96 &value->v.sz.len, False)) {
97 SAFE_FREE(tmp);
98 err = WERR_INVALID_PARAM;
99 goto error;
100 }
101
102 SAFE_FREE(tmp);
103 break;
104 }
105 case REG_MULTI_SZ: {
106 int i;
107 const char **vals;
108 DATA_BLOB blob;
109
110 blob = data_blob_const(data, length);
111
112 if (!pull_reg_multi_sz(mem_ctx, &blob, &vals)) {
113 err = WERR_NOMEM;
114 goto error;
115 }
116
117 for (i=0; vals[i]; i++) {
118 ;;
119 }
120
121 value->v.multi_sz.num_strings = i;
122 value->v.multi_sz.strings = (char **)vals;
123
124 break;
125 }
126 case REG_BINARY:
127 value->v.binary = data_blob_talloc(mem_ctx, data, length);
128 break;
129 default:
130 err = WERR_INVALID_PARAM;
131 goto error;
132 }
133
134 *pvalue = value;
135 return WERR_OK;
136
137 error:
138 TALLOC_FREE(value);
139 return err;
140}
141
142WERROR registry_push_value(TALLOC_CTX *mem_ctx,
143 const struct registry_value *value,
144 DATA_BLOB *presult)
145{
146 switch (value->type) {
147 case REG_DWORD: {
148 char buf[4];
149 SIVAL(buf, 0, value->v.dword);
150 *presult = data_blob_talloc(mem_ctx, (void *)buf, 4);
151 if (presult->data == NULL) {
152 return WERR_NOMEM;
153 }
154 break;
155 }
156 case REG_SZ:
157 case REG_EXPAND_SZ: {
158 if (!push_reg_sz(mem_ctx, presult, value->v.sz.str))
159 {
160 return WERR_NOMEM;
161 }
162 break;
163 }
164 case REG_MULTI_SZ: {
165 /* handle the case where we don't get a NULL terminated array */
166 const char **array;
167 int i;
168
169 array = talloc_array(mem_ctx, const char *,
170 value->v.multi_sz.num_strings + 1);
171 if (!array) {
172 return WERR_NOMEM;
173 }
174
175 for (i=0; i < value->v.multi_sz.num_strings; i++) {
176 array[i] = value->v.multi_sz.strings[i];
177 }
178 array[i] = NULL;
179
180 if (!push_reg_multi_sz(mem_ctx, presult, array)) {
181 talloc_free(array);
182 return WERR_NOMEM;
183 }
184 talloc_free(array);
185 break;
186 }
187 case REG_BINARY:
188 *presult = data_blob_talloc(mem_ctx,
189 value->v.binary.data,
190 value->v.binary.length);
191 break;
192 default:
193 return WERR_INVALID_PARAM;
194 }
195
196 return WERR_OK;
197}
Note: See TracBrowser for help on using the repository browser.