r23668: When creating a new string value, win2k regedit delivers
[ira/wip.git] / source3 / lib / util_reg_api.c
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 2 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, write to the Free Software Foundation, Inc., 675
18  * Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include "includes.h"
22
23 WERROR registry_pull_value(TALLOC_CTX *mem_ctx,
24                            struct registry_value **pvalue,
25                            enum winreg_Type type, uint8 *data,
26                            uint32 size, uint32 length)
27 {
28         struct registry_value *value;
29         WERROR err;
30
31         if (!(value = TALLOC_ZERO_P(mem_ctx, struct registry_value))) {
32                 return WERR_NOMEM;
33         }
34
35         value->type = type;
36
37         switch (type) {
38         case REG_DWORD:
39                 if ((size != 4) || (length != 4)) {
40                         err = WERR_INVALID_PARAM;
41                         goto error;
42                 }
43                 value->v.dword = IVAL(data, 0);
44                 break;
45         case REG_SZ:
46         case REG_EXPAND_SZ:
47         {
48                 /*
49                  * Make sure we get a NULL terminated string for
50                  * convert_string_talloc().
51                  */
52
53                 smb_ucs2_t *tmp;
54                 uint32 num_ucs2 = length / 2;
55
56                 if (length == 1) {
57                         /* win2k regedit gives us a string of 1 byte when
58                          * creating a new value of type REG_SZ. this workaround
59                          * replaces the input by using the same string as
60                          * winxp delivers. */
61                         length = 2;
62                         if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, 2))) {
63                                 err = WERR_NOMEM;
64                                 goto error;
65                         }
66                         tmp[0] = 2;
67                         tmp[1] = 0;
68                 }
69                 else if ((length % 2) != 0) {
70                         err = WERR_INVALID_PARAM;
71                         goto error;
72                 }
73                 else {
74                         if (!(tmp = SMB_MALLOC_ARRAY(smb_ucs2_t, num_ucs2+1))) {
75                                 err = WERR_NOMEM;
76                                 goto error;
77                         }
78
79                         memcpy((void *)tmp, (const void *)data, length);
80                         tmp[num_ucs2] = 0;
81                 }
82
83                 value->v.sz.len = convert_string_talloc(
84                         value, CH_UTF16LE, CH_UNIX, tmp, length+2,
85                         &value->v.sz.str, False);
86
87                 SAFE_FREE(tmp);
88
89                 if (value->v.sz.len == (size_t)-1) {
90                         err = WERR_INVALID_PARAM;
91                         goto error;
92                 }
93                 break;
94         }
95         case REG_MULTI_SZ:
96                 err = reg_pull_multi_sz(value, (void *)data, length,
97                                         &value->v.multi_sz.num_strings,
98                                         &value->v.multi_sz.strings);
99                 if (!(W_ERROR_IS_OK(err))) {
100                         goto error;
101                 }
102                 break;
103         case REG_BINARY:
104                 value->v.binary.data = talloc_move(value, &data);
105                 value->v.binary.length = length;
106                 break;
107         default:
108                 err = WERR_INVALID_PARAM;
109                 goto error;
110         }
111
112         *pvalue = value;
113         return WERR_OK;
114
115  error:
116         TALLOC_FREE(value);
117         return err;
118 }
119
120 WERROR registry_push_value(TALLOC_CTX *mem_ctx,
121                            const struct registry_value *value,
122                            DATA_BLOB *presult)
123 {
124         switch (value->type) {
125         case REG_DWORD: {
126                 char buf[4];
127                 SIVAL(buf, 0, value->v.dword);
128                 *presult = data_blob_talloc(mem_ctx, (void *)buf, 4);
129                 if (presult->data == NULL) {
130                         return WERR_NOMEM;
131                 }
132                 break;
133         }
134         case REG_SZ:
135         case REG_EXPAND_SZ: {
136                 presult->length = convert_string_talloc(
137                         mem_ctx, CH_UNIX, CH_UTF16LE, value->v.sz.str,
138                         MIN(value->v.sz.len, strlen(value->v.sz.str)+1),
139                         (void *)&(presult->data), False);
140                 if (presult->length == (size_t)-1) {
141                         return WERR_NOMEM;
142                 }
143                 break;
144         }
145         default:
146                 return WERR_INVALID_PARAM;
147         }
148
149         return WERR_OK;
150 }