3ea41d46fb4d3038d100815f68d991ce039afe51
[jelmer/samba4-debian.git] / source / scripting / ejs / smbcalls_data.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    provide access to data blobs
5
6    Copyright (C) Andrew Tridgell 2005
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "scripting/ejs/smbcalls.h"
24 #include "lib/appweb/ejs/ejs.h"
25 #include "librpc/gen_ndr/winreg.h"
26
27 /*
28   create a data blob object from a ejs array of integers
29 */
30 static int ejs_blobFromArray(MprVarHandle eid, int argc, struct MprVar **argv)
31 {
32         struct MprVar *array, *v;
33         unsigned length, i;
34         DATA_BLOB blob;
35
36         if (argc != 1) {
37                 ejsSetErrorMsg(eid, "blobFromArray invalid arguments");
38                 return -1;              
39         }
40         array = argv[0];
41
42         v = mprGetProperty(array, "length", NULL);
43         if (v == NULL) {
44                 goto failed;
45         }
46         length = mprToInt(v);
47
48         blob = data_blob_talloc(mprMemCtx(), NULL, length);
49         if (length != 0 && blob.data == NULL) {
50                 goto failed;
51         }
52
53         for (i=0;i<length;i++) {
54                 struct MprVar *vs;
55                 char idx[16];
56                 mprItoa(i, idx, sizeof(idx));           
57                 vs = mprGetProperty(array, idx, NULL);
58                 if (vs == NULL) {
59                         goto failed;
60                 }
61                 blob.data[i] = mprVarToNumber(vs);
62         }
63
64         mpr_Return(eid, mprDataBlob(blob));
65         return 0;
66
67 failed:
68         mpr_Return(eid, mprCreateUndefinedVar());
69         return 0;
70 }
71
72 /*
73   create a ejs array of integers from a data blob
74 */
75 static int ejs_blobToArray(MprVarHandle eid, int argc, struct MprVar **argv)
76 {
77         DATA_BLOB *blob;
78         struct MprVar array;
79         int i;
80
81         if (argc != 1) {
82                 ejsSetErrorMsg(eid, "blobToArray invalid arguments");
83                 return -1;              
84         }
85         blob = mprToDataBlob(argv[0]);
86         if (blob == NULL) {
87                 goto failed;
88         }
89
90         array = mprArray("array");
91         
92         for (i=0;i<blob->length;i++) {
93                 mprAddArray(&array, i, mprCreateNumberVar(blob->data[i]));
94         }
95         mpr_Return(eid, array);
96         return 0;
97
98 failed:
99         mpr_Return(eid, mprCreateUndefinedVar());
100         return 0;
101 }
102
103
104 /*
105   compare two data blobs
106 */
107 static int ejs_blobCompare(MprVarHandle eid, int argc, struct MprVar **argv)
108 {
109         DATA_BLOB *blob1, *blob2;
110         bool ret = false;
111
112         if (argc != 2) {
113                 ejsSetErrorMsg(eid, "blobCompare invalid arguments");
114                 return -1;              
115         }
116         
117         blob1 = mprToDataBlob(argv[0]);
118         blob2 = mprToDataBlob(argv[1]);
119
120         if (blob1 == blob2) {
121                 ret = true;
122                 goto done;
123         }
124         if (blob1 == NULL || blob2 == NULL) {
125                 ret = false;
126                 goto done;
127         }
128
129         if (blob1->length != blob2->length) {
130                 ret = false;
131                 goto done;
132         }
133
134         if (memcmp(blob1->data, blob2->data, blob1->length) != 0) {
135                 ret = false;
136                 goto done;
137         }
138         ret = true;
139
140 done:
141         mpr_Return(eid, mprCreateBoolVar(ret));
142         return 0;
143 }
144
145
146 /*
147   convert a blob in winreg format to a mpr variable
148   
149   usage:
150      v = data.regToVar(blob, type);
151 */
152 static int ejs_regToVar(MprVarHandle eid, int argc, struct MprVar **argv)
153 {
154         DATA_BLOB *blob;
155         enum winreg_Type type;
156         struct MprVar v;
157
158         if (argc != 2) {
159                 ejsSetErrorMsg(eid, "regToVar invalid arguments");
160                 return -1;              
161         }
162         
163         blob = mprToDataBlob(argv[0]);
164         type = mprToInt(argv[1]);
165
166         if (blob == NULL) {
167                 ejsSetErrorMsg(eid, "regToVar null data");
168                 return -1;
169         }
170
171         switch (type) {
172         case REG_NONE:
173                 v = mprCreateUndefinedVar();
174                 break;
175
176         case REG_SZ:
177         case REG_EXPAND_SZ: {
178                 char *s;
179                 ssize_t len;
180                 len = convert_string_talloc(mprMemCtx(), lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX, 
181                                             blob->data, blob->length, (void **)&s);
182                 if (len == -1) {
183                         ejsSetErrorMsg(eid, "regToVar invalid REG_SZ string");
184                         return -1;
185                 }
186                 v = mprString(s);
187                 talloc_free(s);
188                 break;
189         }
190
191         case REG_DWORD: {
192                 if (blob->length != 4) {
193                         ejsSetErrorMsg(eid, "regToVar invalid REG_DWORD length %ld", (long)blob->length);
194                         return -1;
195                 }
196                 v = mprCreateNumberVar(IVAL(blob->data, 0));
197                 break;
198         }
199
200         case REG_DWORD_BIG_ENDIAN: {
201                 if (blob->length != 4) {
202                         ejsSetErrorMsg(eid, "regToVar invalid REG_DWORD_BIG_ENDIAN length %ld", (long)blob->length);
203                         return -1;
204                 }
205                 v = mprCreateNumberVar(RIVAL(blob->data, 0));
206                 break;
207         }
208
209         case REG_QWORD: {
210                 if (blob->length != 8) {
211                         ejsSetErrorMsg(eid, "regToVar invalid REG_QWORD length %ld", (long)blob->length);
212                         return -1;
213                 }
214                 v = mprCreateNumberVar(BVAL(blob->data, 0));
215                 break;
216         }
217
218         case REG_MULTI_SZ: {
219                 DATA_BLOB b = *blob;
220                 const char **list = NULL;
221                 while (b.length > 0) {
222                         char *s;
223                         ssize_t len;
224                         size_t slen = utf16_len_n(b.data, b.length);
225                         if (slen == 2 && b.length == 2 && SVAL(b.data, 0) == 0) {
226                                 break;
227                         }
228                         len = convert_string_talloc(mprMemCtx(), lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX, 
229                                                     b.data, slen, (void **)&s);
230                         if (len == -1) {
231                                 ejsSetErrorMsg(eid, "regToVar invalid REG_MULTI_SZ string");
232                                 return -1;
233                         }
234                         list = str_list_add(list, s);
235                         talloc_free(s);
236                         talloc_steal(mprMemCtx(), list);
237                         b.data += slen;
238                         b.length -= slen;
239                 }
240                 v = mprList("REG_MULTI_SZ", list);
241                 talloc_free(list);
242                 break;
243         }
244                 
245
246         case REG_FULL_RESOURCE_DESCRIPTOR:
247         case REG_RESOURCE_LIST:
248         case REG_BINARY:
249         case REG_RESOURCE_REQUIREMENTS_LIST:
250         case REG_LINK:
251                 return ejs_blobToArray(eid, 1, argv);
252
253         default:
254                 ejsSetErrorMsg(eid, "regToVar invalid type %d", type);
255                 return -1;              
256         }
257         
258         mpr_Return(eid, v);
259         return 0;
260 }
261
262 /*
263   initialise datablob ejs subsystem
264 */
265 static int ejs_datablob_init(MprVarHandle eid, int argc, struct MprVar **argv)
266 {
267         struct MprVar *obj = mprInitObject(eid, "datablob", argc, argv);
268
269         mprSetCFunction(obj, "blobFromArray", ejs_blobFromArray);
270         mprSetCFunction(obj, "blobToArray", ejs_blobToArray);
271         mprSetCFunction(obj, "blobCompare", ejs_blobCompare);
272         mprSetCFunction(obj, "regToVar", ejs_regToVar);
273
274         return 0;
275 }
276
277 /*
278   setup C functions that be called from ejs
279 */
280 NTSTATUS smb_setup_ejs_datablob(void)
281 {
282         ejsDefineCFunction(-1, "datablob_init", ejs_datablob_init, NULL, MPR_VAR_SCRIPT_HANDLE);
283         return NT_STATUS_OK;
284 }