2 * Unix SMB/CIFS implementation.
3 * Registry helper routines
4 * Copyright (C) Volker Lendecke 2006
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)
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
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/>.
23 #define DBGC_CLASS DBGC_REGISTRY
25 WERROR registry_pull_value(TALLOC_CTX *mem_ctx,
26 struct registry_value **pvalue,
27 enum winreg_Type type, uint8 *data,
28 uint32 size, uint32 length)
30 struct registry_value *value;
33 if (!(value = TALLOC_ZERO_P(mem_ctx, struct registry_value))) {
41 if ((size != 4) || (length != 4)) {
42 err = WERR_INVALID_PARAM;
45 value->v.dword = IVAL(data, 0);
51 * Make sure we get a NULL terminated string for
52 * convert_string_talloc().
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
63 if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, 2))) {
69 DEBUG(10, ("got REG_SZ value of length 1 - workaround "
72 else if ((length % 2) != 0) {
73 err = WERR_INVALID_PARAM;
77 uint32 num_ucs2 = length / 2;
78 if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, num_ucs2+1))) {
83 memcpy((void *)tmp, (const void *)data, length);
87 if (length + 2 < length) {
90 err = WERR_INVALID_PARAM;
94 if (!convert_string_talloc(value, CH_UTF16LE, CH_UNIX, tmp,
95 length+2, &value->v.sz.str,
96 &value->v.sz.len, False)) {
98 err = WERR_INVALID_PARAM;
106 err = reg_pull_multi_sz(value, (void *)data, length,
107 &value->v.multi_sz.num_strings,
108 &value->v.multi_sz.strings);
109 if (!(W_ERROR_IS_OK(err))) {
114 value->v.binary = data_blob_talloc(mem_ctx, data, length);
117 err = WERR_INVALID_PARAM;
129 WERROR registry_push_value(TALLOC_CTX *mem_ctx,
130 const struct registry_value *value,
133 switch (value->type) {
136 SIVAL(buf, 0, value->v.dword);
137 *presult = data_blob_talloc(mem_ctx, (void *)buf, 4);
138 if (presult->data == NULL) {
144 case REG_EXPAND_SZ: {
145 if (!convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16LE,
148 strlen(value->v.sz.str)+1),
149 (void *)&(presult->data),
150 &presult->length, False))
160 size_t *string_lengths;
162 TALLOC_CTX *tmp_ctx = talloc_stackframe();
164 strings = TALLOC_ARRAY(tmp_ctx, char *,
165 value->v.multi_sz.num_strings);
166 if (strings == NULL) {
170 string_lengths = TALLOC_ARRAY(tmp_ctx, size_t,
171 value->v.multi_sz.num_strings);
172 if (string_lengths == NULL) {
173 TALLOC_FREE(tmp_ctx);
177 /* convert the single strings */
178 for (count = 0; count < value->v.multi_sz.num_strings; count++)
180 if (!convert_string_talloc(strings, CH_UNIX,
181 CH_UTF16LE, value->v.multi_sz.strings[count],
182 strlen(value->v.multi_sz.strings[count])+1,
183 (void *)&strings[count],
184 &string_lengths[count], false))
187 TALLOC_FREE(tmp_ctx);
190 len += string_lengths[count];
193 /* now concatenate all into the data blob */
194 presult->data = TALLOC_ARRAY(mem_ctx, uint8_t, len);
195 if (presult->data == NULL) {
196 TALLOC_FREE(tmp_ctx);
199 for (count = 0, ofs = 0;
200 count < value->v.multi_sz.num_strings;
203 memcpy(presult->data + ofs, strings[count],
204 string_lengths[count]);
205 ofs += string_lengths[count];
207 presult->length = len;
209 TALLOC_FREE(tmp_ctx);
214 *presult = data_blob_talloc(mem_ctx,
215 value->v.binary.data,
216 value->v.binary.length);
219 return WERR_INVALID_PARAM;