215ce77b77e163e20f4beaeaea3428dc4be95609
[jelmer/samba4-debian.git] / source / scripting / ejs / smbcalls_string.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    provide access to string functions
5
6    Copyright (C) Andrew Tridgell 2005
7    Copyright (C) Jelmer Vernooij 2005 (substr)
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "scripting/ejs/smbcalls.h"
25 #include "lib/appweb/ejs/ejs.h"
26
27 /*
28   usage:
29       var len = strlen(str);
30 */
31 static int ejs_strlen(MprVarHandle eid, int argc, char **argv)
32 {
33         if (argc != 1) {
34                 ejsSetErrorMsg(eid, "strlen invalid arguments");
35                 return -1;
36         }
37         mpr_Return(eid, mprCreateIntegerVar(strlen_m(argv[0])));
38         return 0;
39 }
40
41 /*
42   usage:
43       var s = strlower("UPPER");
44 */
45 static int ejs_strlower(MprVarHandle eid, int argc, char **argv)
46 {
47         char *s;
48         if (argc != 1) {
49                 ejsSetErrorMsg(eid, "strlower invalid arguments");
50                 return -1;
51         }
52         s = strlower_talloc(mprMemCtx(), argv[0]);
53         mpr_Return(eid, mprString(s));
54         talloc_free(s);
55         return 0;
56 }
57
58 /*
59   usage:
60       var s = strupper("lower");
61 */
62 static int ejs_strupper(MprVarHandle eid, int argc, char **argv)
63 {
64         char *s;
65         if (argc != 1) {
66                 ejsSetErrorMsg(eid, "strupper invalid arguments");
67                 return -1;
68         }
69         s = strupper_talloc(mprMemCtx(), argv[0]);
70         mpr_Return(eid, mprString(s));
71         talloc_free(s);
72         return 0;
73 }
74
75 /*
76   usage:
77       var s = strstr(string, substring);
78 */
79 static int ejs_strstr(MprVarHandle eid, int argc, char **argv)
80 {
81         char *s;
82         if (argc != 2) {
83                 ejsSetErrorMsg(eid, "strstr invalid arguments");
84                 return -1;
85         }
86         s = strstr(argv[0], argv[1]);
87         mpr_Return(eid, mprString(s));
88         return 0;
89 }
90
91 /*
92   usage:
93       var s = strspn(string, legal_chars_string);
94 */
95 static int ejs_strspn(MprVarHandle eid, int argc, char **argv)
96 {
97         int len;
98         if (argc != 2) {
99                 ejsSetErrorMsg(eid, "strspn invalid arguments");
100                 return -1;
101         }
102         len = strspn(argv[0], argv[1]);
103         mpr_Return(eid, mprCreateIntegerVar(len));
104         return 0;
105 }
106
107 /*
108   usage:
109      list = split(".", "a.foo.bar");
110      list = split(".", "a.foo.bar", count);
111
112   count is an optional count of how many splits to make
113
114   NOTE: does not take a regular expression, unlike perl split()
115 */
116 static int ejs_split(MprVarHandle eid, int argc, struct MprVar **argv)
117 {
118         const char *separator, *s;
119         char *p;
120         struct MprVar ret;
121         int count = 0, maxcount=0;
122         TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
123         if (argc < 2 ||
124             argv[0]->type != MPR_TYPE_STRING ||
125             argv[1]->type != MPR_TYPE_STRING) {
126                 ejsSetErrorMsg(eid, "split invalid arguments");
127                 return -1;
128         }
129         separator = mprToString(argv[0]);
130         s         = mprToString(argv[1]);
131         if (argc == 3) {
132                 maxcount = mprToInt(argv[2]);
133         }
134
135         ret = mprArray("list");
136
137         while ((p = strstr(s, separator))) {
138                 char *s2 = talloc_strndup(tmp_ctx, s, (int)(p-s));
139                 mprAddArray(&ret, count++, mprString(s2));
140                 talloc_free(s2);
141                 s = p + strlen(separator);
142                 if (maxcount != 0 && count >= maxcount) {
143                         break;
144                 }
145         }
146         if (*s) {
147                 mprAddArray(&ret, count++, mprString(s));
148         }
149         talloc_free(tmp_ctx);
150         mpr_Return(eid, ret);
151         return 0;
152 }
153
154 /*
155   usage:
156     str = substr(orig[, start_offset[, length]]);
157
158         special cases:
159                 if start_offset < 0 then start_offset+=strlen(orig)
160                 if length < 0 then length+=strlen(orig)-start_offset
161
162         (as found in many other languages)
163 */
164 static int ejs_substr(MprVarHandle eid, int argc, struct MprVar **argv)
165 {
166         int start_offset = 0;
167         int length = 0;
168         const char *orig;
169         char *target;
170         
171         if (argc < 1 || argc > 3 ||
172             argv[0]->type != MPR_TYPE_STRING) {
173                 ejsSetErrorMsg(eid, "substr invalid arguments");
174                 return -1;
175         }
176
177         if (argc == 1) {
178                 mpr_Return(eid, *argv[0]);
179                 return 0;
180         }
181
182         orig = mprToString(argv[0]);
183         start_offset = mprToInt(argv[1]);
184         length = strlen(orig);
185         if (start_offset < 0) start_offset += strlen(orig);
186         if (start_offset < 0 || start_offset > strlen(orig)) {
187                 ejsSetErrorMsg(eid, "substr arg 2 out of bounds ([%s], %d)", orig, start_offset);
188                 return -1;
189         }
190
191         if (argc == 3) {
192                 length = mprToInt(argv[2]);
193                 if (length < 0) length += strlen(orig) - start_offset;
194                 if (length < 0 || length+start_offset > strlen(orig)) {
195                         ejsSetErrorMsg(eid, "substr arg 3 out of bounds ([%s], %d, %d)", orig, start_offset, length);
196                         return -1;
197                 }
198         }
199
200         target = talloc_strndup(mprMemCtx(), orig+start_offset, length);
201         
202         mpr_Return(eid, mprString(target));
203
204         talloc_free(target);
205
206         return 0;
207 }
208
209 /*
210   usage:
211      str = join("DC=", list);
212 */
213 static int ejs_join(MprVarHandle eid, int argc, struct MprVar **argv)
214 {
215         int i;
216         const char *separator;
217         char *ret = NULL;
218         const char **list;
219         TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
220         if (argc != 2 ||
221             argv[0]->type != MPR_TYPE_STRING ||
222             argv[1]->type != MPR_TYPE_OBJECT) {
223                 ejsSetErrorMsg(eid, "join invalid arguments");
224                 return -1;
225         }
226
227         separator = mprToString(argv[0]);
228         list      = mprToArray(tmp_ctx, argv[1]);
229
230         if (list == NULL || list[0] == NULL) {
231                 talloc_free(tmp_ctx);
232                 mpr_Return(eid, mprString(NULL));
233                 return 0;
234         }
235         
236         ret = talloc_strdup(tmp_ctx, list[0]);
237         if (ret == NULL) {
238                 goto failed;
239         }
240         for (i=1;list[i];i++) {
241                 ret = talloc_asprintf_append(ret, "%s%s", separator, list[i]);
242                 if (ret == NULL) {
243                         goto failed;
244                 }
245         }
246         mpr_Return(eid, mprString(ret));
247         talloc_free(tmp_ctx);
248         return 0;
249 failed:
250         ejsSetErrorMsg(eid, "out of memory");
251         return -1;
252 }
253
254
255 /*
256   blergh, C certainly makes this hard!
257   usage:
258      str = sprintf("i=%d s=%7s", 7, "foo");
259 */
260 typedef char *(*_asprintf_append_t)(char *, const char *, ...);
261 static int ejs_sprintf(MprVarHandle eid, int argc, struct MprVar **argv)
262 {
263         const char *format;
264         const char *p;
265         char *ret;
266         int a = 1;
267         _asprintf_append_t _asprintf_append;
268         TALLOC_CTX *tmp_ctx;
269         if (argc < 1 || argv[0]->type != MPR_TYPE_STRING) {
270                 ejsSetErrorMsg(eid, "sprintf invalid arguments");
271                 return -1;
272         }
273         format = mprToString(argv[0]);
274         tmp_ctx = talloc_new(mprMemCtx());
275         ret = talloc_strdup(tmp_ctx, "");
276
277         /* avoid all the format string warnings */
278         _asprintf_append = (_asprintf_append_t)talloc_asprintf_append;
279
280         /*
281           hackity hack ...
282         */
283         while ((p = strchr(format, '%'))) {
284                 char *fmt2;
285                 int len, len_count=0;
286                 char *tstr;
287                 ret = talloc_asprintf_append(ret, "%*.*s", 
288                                              (int)(p-format), (int)(p-format), 
289                                              format);
290                 if (ret == NULL) goto failed;
291                 format += (int)(p-format);
292                 len = strcspn(p+1, "dxuiofgGpXeEFcs%") + 1;
293                 fmt2 = talloc_strndup(tmp_ctx, p, len+1);
294                 if (fmt2 == NULL) goto failed;
295                 len_count = count_chars(fmt2, '*');
296                 /* find the type string */
297                 tstr = &fmt2[len];
298                 while (tstr > fmt2 && isalpha((unsigned char)tstr[-1])) {
299                         tstr--;
300                 }
301                 if (strcmp(tstr, "%") == 0) {
302                         ret = talloc_asprintf_append(ret, "%%");
303                         if (ret == NULL) {
304                                 goto failed;
305                         }
306                         format += len+1;
307                         continue;
308                 }
309                 if (len_count > 2 || 
310                     argc < a + len_count + 1) {
311                         ejsSetErrorMsg(eid, "sprintf: not enough arguments for format");
312                         goto failed;
313                 }
314 #define FMT_ARG(fn, type) do { \
315                         switch (len_count) { \
316                         case 0: \
317                                 ret = _asprintf_append(ret, fmt2, \
318                                                              (type)fn(argv[a])); \
319                                 break; \
320                         case 1: \
321                                 ret = _asprintf_append(ret, fmt2, \
322                                                              (int)mprVarToNumber(argv[a]), \
323                                                              (type)fn(argv[a+1])); \
324                                 break; \
325                         case 2: \
326                                 ret = _asprintf_append(ret, fmt2, \
327                                                              (int)mprVarToNumber(argv[a]), \
328                                                              (int)mprVarToNumber(argv[a+1]), \
329                                                              (type)fn(argv[a+2])); \
330                                 break; \
331                         } \
332                         a += len_count + 1; \
333                         if (ret == NULL) { \
334                                 goto failed; \
335                         } \
336 } while (0)
337
338                 if (strcmp(tstr, "s")==0)        FMT_ARG(mprToString,    const char *);
339                 else if (strcmp(tstr, "c")==0)   FMT_ARG(*mprToString,   char);
340                 else if (strcmp(tstr, "d")==0)   FMT_ARG(mprVarToNumber, int);
341                 else if (strcmp(tstr, "ld")==0)  FMT_ARG(mprVarToNumber, long);
342                 else if (strcmp(tstr, "lld")==0) FMT_ARG(mprVarToNumber, long long);
343                 else if (strcmp(tstr, "x")==0)   FMT_ARG(mprVarToNumber, int);
344                 else if (strcmp(tstr, "lx")==0)  FMT_ARG(mprVarToNumber, long);
345                 else if (strcmp(tstr, "llx")==0) FMT_ARG(mprVarToNumber, long long);
346                 else if (strcmp(tstr, "X")==0)   FMT_ARG(mprVarToNumber, int);
347                 else if (strcmp(tstr, "lX")==0)  FMT_ARG(mprVarToNumber, long);
348                 else if (strcmp(tstr, "llX")==0) FMT_ARG(mprVarToNumber, long long);
349                 else if (strcmp(tstr, "u")==0)   FMT_ARG(mprVarToNumber, int);
350                 else if (strcmp(tstr, "lu")==0)  FMT_ARG(mprVarToNumber, long);
351                 else if (strcmp(tstr, "llu")==0) FMT_ARG(mprVarToNumber, long long);
352                 else if (strcmp(tstr, "i")==0)   FMT_ARG(mprVarToNumber, int);
353                 else if (strcmp(tstr, "li")==0)  FMT_ARG(mprVarToNumber, long);
354                 else if (strcmp(tstr, "lli")==0) FMT_ARG(mprVarToNumber, long long);
355                 else if (strcmp(tstr, "o")==0)   FMT_ARG(mprVarToNumber, int);
356                 else if (strcmp(tstr, "lo")==0)  FMT_ARG(mprVarToNumber, long);
357                 else if (strcmp(tstr, "llo")==0) FMT_ARG(mprVarToNumber, long long);
358                 else if (strcmp(tstr, "f")==0)   FMT_ARG(mprVarToFloat,  double);
359                 else if (strcmp(tstr, "lf")==0)  FMT_ARG(mprVarToFloat,  double);
360                 else if (strcmp(tstr, "g")==0)   FMT_ARG(mprVarToFloat,  double);
361                 else if (strcmp(tstr, "lg")==0)  FMT_ARG(mprVarToFloat,  double);
362                 else if (strcmp(tstr, "e")==0)   FMT_ARG(mprVarToFloat,  double);
363                 else if (strcmp(tstr, "le")==0)  FMT_ARG(mprVarToFloat,  double);
364                 else if (strcmp(tstr, "E")==0)   FMT_ARG(mprVarToFloat,  double);
365                 else if (strcmp(tstr, "lE")==0)  FMT_ARG(mprVarToFloat,  double);
366                 else if (strcmp(tstr, "F")==0)   FMT_ARG(mprVarToFloat,  double);
367                 else if (strcmp(tstr, "lF")==0)  FMT_ARG(mprVarToFloat,  double);
368                 else {
369                         ejsSetErrorMsg(eid, "sprintf: unknown format string '%s'", fmt2);
370                         goto failed;
371                 }
372                 format += len+1;
373         }
374
375         ret = talloc_asprintf_append(ret, "%s", format);
376         mpr_Return(eid, mprString(ret));
377         talloc_free(tmp_ctx);
378         return 0;          
379         
380 failed:
381         talloc_free(tmp_ctx);
382         return -1;
383 }
384
385 /*
386   used to build your own print function
387      str = vsprintf(args);
388 */
389 static int ejs_vsprintf(MprVarHandle eid, int argc, struct MprVar **argv)
390 {
391         struct MprVar **args, *len, *v;
392         int i, ret, length;
393         if (argc != 1 || argv[0]->type != MPR_TYPE_OBJECT) {
394                 ejsSetErrorMsg(eid, "vsprintf invalid arguments");
395                 return -1;
396         }
397         v = argv[0];
398         len = mprGetProperty(v, "length", NULL);
399         if (len == NULL) {
400                 ejsSetErrorMsg(eid, "vsprintf takes an array");
401                 return -1;
402         }
403         length = mprToInt(len);
404         args = talloc_array(mprMemCtx(), struct MprVar *, length);
405         if (args == NULL) {
406                 return -1;
407         }
408
409         for (i=0;i<length;i++) {
410                 char idx[16];
411                 mprItoa(i, idx, sizeof(idx));
412                 args[i] = mprGetProperty(v, idx, NULL);
413         }
414         
415         ret = ejs_sprintf(eid, length, args);
416         talloc_free(args);
417         return ret;
418 }
419
420
421 /*
422   encode a string, replacing all non-alpha with %02x form
423 */
424 static int ejs_encodeURIComponent(MprVarHandle eid, int argc, char **argv)
425 {
426         int i, j, count=0;
427         const char *s;
428         char *ret;
429         if (argc != 1) {
430                 ejsSetErrorMsg(eid, "encodeURIComponent invalid arguments");
431                 return -1;
432         }
433         
434         s = argv[0];
435
436         for (i=0;s[i];i++) {
437                 if (!isalnum(s[i])) count++;
438         }
439         
440         ret = talloc_array(mprMemCtx(), char, i + count*2 + 1);
441         if (ret == NULL) {
442                 return -1;
443         }
444         for (i=j=0;s[i];i++,j++) {
445                 if (!isalnum(s[i])) {
446                         snprintf(ret+j, 4, "%%%02X", (unsigned)s[i]);
447                         j += 2;
448                 } else {
449                         ret[j] = s[i];
450                 }
451         }
452         ret[j] = 0;
453         mpr_Return(eid, mprString(ret));
454         talloc_free(ret);
455         return 0;
456 }
457
458 /*
459   encode a string, replacing all non-alpha of %02x form
460 */
461 static int ejs_decodeURIComponent(MprVarHandle eid, int argc, char **argv)
462 {
463         int i, j, count=0;
464         const char *s;
465         char *ret;
466         if (argc != 1) {
467                 ejsSetErrorMsg(eid, "decodeURIComponent invalid arguments");
468                 return -1;
469         }
470         
471         s = argv[0];
472
473         ret = talloc_array(mprMemCtx(), char, strlen(s) + 1);
474         if (ret == NULL) {
475                 return -1;
476         }
477
478         for (i=j=0;s[i];i++,j++) {
479                 if (s[i] == '%') {
480                         unsigned c;
481                         if (sscanf(s+i+1, "%02X", &c) != 1) {
482                                 ejsSetErrorMsg(eid, "decodeURIComponent bad format");
483                                 return -1;
484                         }
485                         ret[j] = c;
486                         i += 2;
487                 } else {
488                         ret[j] = s[i];
489                 }
490                 if (!isalnum(s[i])) count++;
491         }
492         
493         ret[j] = 0;
494         mpr_Return(eid, mprString(ret));
495         talloc_free(ret);
496         return 0;
497 }
498
499 /*
500   initialise string ejs subsystem
501 */
502 static int ejs_string_init(MprVarHandle eid, int argc, struct MprVar **argv)
503 {
504         struct MprVar *obj = mprInitObject(eid, "string", argc, argv);
505
506         mprSetCFunction(obj, "substr", ejs_substr);
507         mprSetStringCFunction(obj, "strlen", ejs_strlen);
508         mprSetStringCFunction(obj, "strlower", ejs_strlower);
509         mprSetStringCFunction(obj, "strupper", ejs_strupper);
510         mprSetStringCFunction(obj, "strstr", ejs_strstr);
511         mprSetStringCFunction(obj, "strspn", ejs_strspn);
512         mprSetCFunction(obj, "split", ejs_split);
513         mprSetCFunction(obj, "join", ejs_join);
514         mprSetCFunction(obj, "sprintf", ejs_sprintf);
515         mprSetCFunction(obj, "vsprintf", ejs_vsprintf);
516         mprSetStringCFunction(obj, "encodeURIComponent", ejs_encodeURIComponent);
517         mprSetStringCFunction(obj, "decodeURIComponent", ejs_decodeURIComponent);
518
519         return 0;
520 }
521
522 /*
523   setup C functions that be called from ejs
524 */
525 NTSTATUS smb_setup_ejs_string(void)
526 {
527         ejsDefineCFunction(-1, "string_init", ejs_string_init, NULL, MPR_VAR_SCRIPT_HANDLE);
528         return NT_STATUS_OK;
529 }