r25026: Move param/param.h out of includes.h
[gd/samba-autobuild/.git] / source4 / scripting / ejs / smbcalls_cli.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    provide hooks into smbd C calls from ejs scripts
5
6    Copyright (C) Tim Potter 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 "libcli/raw/libcliraw.h"
26 #include "libcli/composite/composite.h"
27 #include "libcli/smb_composite/smb_composite.h"
28 #include "libcli/libcli.h"
29 #include "auth/credentials/credentials.h"
30 #include "param/param.h"
31
32 #if 0
33
34 #include "librpc/gen_ndr/ndr_nbt.h"
35
36 /* Connect to a server */
37
38 static int ejs_cli_connect(MprVarHandle eid, int argc, char **argv)
39 {
40         struct smbcli_socket *sock;
41         struct smbcli_transport *transport;
42         struct nbt_name calling, called;
43         NTSTATUS result;
44
45         if (argc != 1) {
46                 ejsSetErrorMsg(eid, "connect invalid arguments");
47                 return -1;
48         }
49
50         /* Socket connect */
51
52         sock = smbcli_sock_init(NULL, NULL);
53
54         if (!sock) {
55                 ejsSetErrorMsg(eid, "socket initialisation failed");
56                 return -1;
57         }
58
59         if (!smbcli_sock_connect_byname(sock, argv[0], 0)) {
60                 ejsSetErrorMsg(eid, "socket connect failed");
61                 return -1;
62         }
63
64         transport = smbcli_transport_init(sock, sock, False);
65
66         if (!transport) {
67                 ejsSetErrorMsg(eid, "transport init failed");
68                 return -1;
69         }
70
71         /* Send a netbios session request */
72
73         make_nbt_name_client(&calling, lp_netbios_name());
74
75         nbt_choose_called_name(NULL, &called, argv[0], NBT_NAME_SERVER);
76                 
77         if (!smbcli_transport_connect(transport, &calling, &called)) {
78                 ejsSetErrorMsg(eid, "transport establishment failed");
79                 return -1;
80         }
81
82         result = smb_raw_negotiate(transport, lp_maxprotocol());
83
84         if (!NT_STATUS_IS_OK(result)) {
85                 mpr_Return(eid, mprNTSTATUS(result));
86                 return 0;
87         }
88
89         /* Return a socket object */
90
91         mpr_Return(eid, mprCreatePtrVar(transport));
92
93         return 0;
94 }
95
96 /* Perform a session setup:
97    
98      session_setup(conn, "DOMAIN\\USERNAME%PASSWORD");
99      session_setup(conn, USERNAME, PASSWORD);
100      session_setup(conn, DOMAIN, USERNAME, PASSWORD);
101      session_setup(conn);  // anonymous
102
103  */
104
105 static int ejs_cli_ssetup(MprVarHandle eid, int argc, MprVar **argv)
106 {
107         struct smbcli_transport *transport;
108         struct smbcli_session *session;
109         struct smb_composite_sesssetup setup;
110         struct cli_credentials *creds;
111         NTSTATUS status;
112         int result = -1;
113
114         /* Argument parsing */
115
116         if (argc < 1 || argc > 4) {
117                 ejsSetErrorMsg(eid, "session_setup invalid arguments");
118                 return -1;
119         }
120
121         if (!mprVarIsPtr(argv[0]->type)) {
122                 ejsSetErrorMsg(eid, "first arg is not a connect handle");
123                 return -1;
124         }
125
126         transport = argv[0]->ptr;
127         creds = cli_credentials_init(transport);
128         cli_credentials_set_conf(creds);
129
130         if (argc == 4) {
131
132                 /* DOMAIN, USERNAME, PASSWORD form */
133
134                 if (!mprVarIsString(argv[1]->type)) {
135                         ejsSetErrorMsg(eid, "arg 1 must be a string");
136                         goto done;
137                 }
138
139                 cli_credentials_set_domain(creds, argv[1]->string, 
140                                            CRED_SPECIFIED);
141
142                 if (!mprVarIsString(argv[2]->type)) {
143                         ejsSetErrorMsg(eid, "arg 2 must be a string");
144                         goto done;
145                 }
146
147                 cli_credentials_set_username(creds, argv[2]->string, 
148                                              CRED_SPECIFIED);
149
150                 if (!mprVarIsString(argv[3]->type)) {
151                         ejsSetErrorMsg(eid, "arg 3 must be a string");
152                         goto done;
153                 }
154
155                 cli_credentials_set_password(creds, argv[3]->string,
156                                              CRED_SPECIFIED);
157
158         } else if (argc == 3) {
159
160                 /* USERNAME, PASSWORD form */
161
162                 if (!mprVarIsString(argv[1]->type)) {
163                         ejsSetErrorMsg(eid, "arg1 must be a string");
164                         goto done;
165                 }
166
167                 cli_credentials_set_username(creds, argv[1]->string,
168                                              CRED_SPECIFIED);
169
170                 if (!mprVarIsString(argv[2]->type)) {
171
172                         ejsSetErrorMsg(eid, "arg2 must be a string");
173                         goto done;
174                 }
175
176                 cli_credentials_set_password(creds, argv[2]->string,
177                                              CRED_SPECIFIED);
178
179         } else if (argc == 2) {
180
181                 /* DOMAIN/USERNAME%PASSWORD form */
182
183                 cli_credentials_parse_string(creds, argv[1]->string,
184                                              CRED_SPECIFIED);
185
186         } else {
187
188                 /* Anonymous connection */
189
190                 cli_credentials_set_anonymous(creds);
191         }
192
193         /* Do session setup */
194
195         session = smbcli_session_init(transport, transport, False);
196
197         if (!session) {
198                 ejsSetErrorMsg(eid, "session init failed");
199                 return -1;
200         }
201
202         setup.in.sesskey = transport->negotiate.sesskey;
203         setup.in.capabilities = transport->negotiate.capabilities;
204         setup.in.credentials = creds;
205         setup.in.workgroup = lp_workgroup();
206
207         status = smb_composite_sesssetup(session, &setup);
208
209         if (!NT_STATUS_IS_OK(status)) {
210                 ejsSetErrorMsg(eid, "session_setup: %s", nt_errstr(status));
211                 return -1;
212         }
213
214         session->vuid = setup.out.vuid; 
215
216         /* Return a session object */
217
218         mpr_Return(eid, mprCreatePtrVar(session));
219
220         result = 0;
221
222  done:
223         talloc_free(creds);
224         return result;
225 }
226
227 /* Perform a tree connect
228    
229      tree_connect(session, SHARE);
230
231  */
232
233 static int ejs_cli_tree_connect(MprVarHandle eid, int argc, MprVar **argv)
234 {
235         struct smbcli_session *session;
236         struct smbcli_tree *tree;
237         union smb_tcon tcon;
238         TALLOC_CTX *mem_ctx;
239         NTSTATUS status;
240         const char *password = "";
241
242         /* Argument parsing */
243
244         if (argc != 2) {
245                 ejsSetErrorMsg(eid, "tree_connect invalid arguments");
246                 return -1;
247         }
248
249         if (!mprVarIsPtr(argv[0]->type)) {
250                 ejsSetErrorMsg(eid, "first arg is not a session handle");
251                 return -1;
252         }
253
254         session = argv[0]->ptr;
255         tree = smbcli_tree_init(session, session, False);
256
257         if (!tree) {
258                 ejsSetErrorMsg(eid, "tree init failed");
259                 return -1;
260         }
261
262         mem_ctx = talloc_init("tcon");
263         if (!mem_ctx) {
264                 ejsSetErrorMsg(eid, "talloc_init failed");
265                 return -1;
266         }
267
268         /* Do tree connect */
269
270         tcon.generic.level = RAW_TCON_TCONX;
271         tcon.tconx.in.flags = 0;
272
273         if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) {
274                 tcon.tconx.in.password = data_blob(NULL, 0);
275         } else if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
276                 tcon.tconx.in.password = data_blob_talloc(mem_ctx, NULL, 24);
277                 if (session->transport->negotiate.secblob.length < 8) {
278                         ejsSetErrorMsg(eid, "invalid security blob");
279                         return -1;
280                 }
281                 SMBencrypt(password, session->transport->negotiate.secblob.data, tcon.tconx.in.password.data);
282         } else {
283                 tcon.tconx.in.password = data_blob_talloc(mem_ctx, password, strlen(password)+1);
284         }
285
286         tcon.tconx.in.path = argv[1]->string;
287         tcon.tconx.in.device = "?????";
288         
289         status = smb_tree_connect(tree, mem_ctx, &tcon);
290
291         if (!NT_STATUS_IS_OK(status)) {
292                 ejsSetErrorMsg(eid, "tree_connect: %s", nt_errstr(status));
293                 return -1;
294         }
295
296         tree->tid = tcon.tconx.out.tid;
297
298         talloc_free(mem_ctx);   
299
300         mpr_Return(eid, mprCreatePtrVar(tree));
301
302         return 0;
303 }
304
305 /* Perform a tree disconnect
306    
307      tree_disconnect(tree);
308
309  */
310 static int ejs_cli_tree_disconnect(MprVarHandle eid, int argc, MprVar **argv)
311 {
312         struct smbcli_tree *tree;
313         NTSTATUS status;
314
315         /* Argument parsing */
316
317         if (argc != 1) {
318                 ejsSetErrorMsg(eid, "tree_disconnect invalid arguments");
319                 return -1;
320         }
321
322         if (!mprVarIsPtr(argv[0]->type)) {
323                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
324                 return -1;
325         }       
326
327         tree = argv[0]->ptr;
328
329         status = smb_tree_disconnect(tree);
330
331         if (!NT_STATUS_IS_OK(status)) {
332                 ejsSetErrorMsg(eid, "tree_disconnect: %s", nt_errstr(status));
333                 return -1;
334         }
335
336         talloc_free(tree);
337
338         return 0;
339 }
340
341 /* Perform a ulogoff
342    
343      session_logoff(session);
344
345  */
346 static int ejs_cli_session_logoff(MprVarHandle eid, int argc, MprVar **argv)
347 {
348         struct smbcli_session *session;
349         NTSTATUS status;
350
351         /* Argument parsing */
352
353         if (argc != 1) {
354                 ejsSetErrorMsg(eid, "session_logoff invalid arguments");
355                 return -1;
356         }
357
358         if (!mprVarIsPtr(argv[0]->type)) {
359                 ejsSetErrorMsg(eid, "first arg is not a session handle");
360                 return -1;
361         }       
362
363         session = argv[0]->ptr;
364
365         status = smb_raw_ulogoff(session);
366
367         if (!NT_STATUS_IS_OK(status)) {
368                 ejsSetErrorMsg(eid, "session_logoff: %s", nt_errstr(status));
369                 return -1;
370         }
371
372         talloc_free(session);
373
374         return 0;
375 }
376
377 /* Perform a connection close
378    
379      disconnect(conn);
380
381  */
382 static int ejs_cli_disconnect(MprVarHandle eid, int argc, MprVar **argv)
383 {
384         struct smbcli_sock *sock;
385
386         /* Argument parsing */
387
388         if (argc != 1) {
389                 ejsSetErrorMsg(eid, "disconnect invalid arguments");
390                 return -1;
391         }
392
393         if (!mprVarIsPtr(argv[0]->type)) {
394                 ejsSetErrorMsg(eid, "first arg is not a connect handle");
395                 return -1;
396         }       
397
398         sock = argv[0]->ptr;
399
400         talloc_free(sock);
401
402         return 0;
403 }
404
405 #endif
406
407 /* Perform a tree connect:
408
409      tree_handle = tree_connect("\\\\frogurt\\homes", "user%pass");
410  */
411
412 static int ejs_tree_connect(MprVarHandle eid, int argc, char **argv)
413 {
414         struct cli_credentials *creds;
415         struct smb_composite_connect io;
416         struct smbcli_tree *tree;
417         char *hostname, *sharename;
418         NTSTATUS result;
419         TALLOC_CTX *mem_ctx;
420
421         if (argc != 2) {
422                 ejsSetErrorMsg(eid, "tree_connect(): invalid number of args");
423                 return -1;
424         }
425
426         /* Set up host, share destination */
427
428         mem_ctx = talloc_new(mprMemCtx());
429         smbcli_parse_unc(argv[0], mem_ctx, &hostname, &sharename);
430
431         /* Set up credentials */
432
433         creds = cli_credentials_init(NULL);
434         cli_credentials_set_conf(creds);
435         cli_credentials_parse_string(creds, argv[1], CRED_SPECIFIED);
436
437         /* Do connect */
438
439         io.in.dest_host              = hostname;
440         io.in.port                   = 0;
441         io.in.called_name            = strupper_talloc(mem_ctx, hostname);
442         io.in.service                = sharename;
443         io.in.service_type           = "?????";
444         io.in.credentials            = creds;
445         io.in.fallback_to_anonymous  = False;
446         io.in.workgroup              = lp_workgroup();
447
448         result = smb_composite_connect(&io, mem_ctx, NULL);
449         tree = io.out.tree;
450
451         talloc_free(mem_ctx);
452
453         if (!NT_STATUS_IS_OK(result)) {
454                 mpr_Return(eid, mprNTSTATUS(result));
455                 return 0;
456         }
457
458         mpr_Return(eid, mprCreatePtrVar(tree));
459
460         return 0;
461 }
462
463 #define IS_TREE_HANDLE(x) (mprVarIsPtr((x)->type) && \
464                            talloc_check_name((x)->ptr, "struct smbcli_tree"))
465
466 /* Perform a tree disconnect:
467
468      tree_disconnect(tree_handle);
469  */
470
471 static int ejs_tree_disconnect(MprVarHandle eid, int argc, MprVar **argv)
472 {
473         struct smbcli_tree *tree;
474         NTSTATUS result;
475
476         if (argc != 1) {
477                 ejsSetErrorMsg(eid, 
478                                "tree_disconnect(): invalid number of args");
479                 return -1;
480         }
481
482         if (!IS_TREE_HANDLE(argv[0])) {
483                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
484                 return -1;
485         }
486
487         tree = talloc_get_type(argv[0]->ptr, struct smbcli_tree);
488
489         result = smb_tree_disconnect(tree);
490
491         mpr_Return(eid, mprNTSTATUS(result));
492
493         return 0;
494 }
495
496 /* Create a directory:
497
498      result = mkdir(tree_handle, DIRNAME);
499  */
500
501 static int ejs_mkdir(MprVarHandle eid, int argc, MprVar **argv)
502 {
503         struct smbcli_tree *tree;
504         NTSTATUS result;
505
506         if (argc != 2) {
507                 ejsSetErrorMsg(eid, "mkdir(): invalid number of args");
508                 return -1;
509         }
510
511         if (!IS_TREE_HANDLE(argv[0])) {
512                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
513                 return -1;
514         }
515
516         tree = (struct smbcli_tree *)argv[0]->ptr;
517
518         if (!mprVarIsString(argv[1]->type)) {
519                 ejsSetErrorMsg(eid, "arg 2 must be a string");
520                 return -1;
521         }
522
523         result = smbcli_mkdir(tree, argv[1]->string);
524
525         mpr_Return(eid, mprNTSTATUS(result));
526
527         return 0;
528 }
529
530 /* Remove a directory:
531
532      result = rmdir(tree_handle, DIRNAME);
533  */
534
535 static int ejs_rmdir(MprVarHandle eid, int argc, MprVar **argv)
536 {
537         struct smbcli_tree *tree;
538         NTSTATUS result;
539
540         if (argc != 2) {
541                 ejsSetErrorMsg(eid, "rmdir(): invalid number of args");
542                 return -1;
543         }
544
545         if (!IS_TREE_HANDLE(argv[0])) {
546                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
547                 return -1;
548         }
549
550         tree = (struct smbcli_tree *)argv[0]->ptr;
551
552         if (!mprVarIsString(argv[1]->type)) {
553                 ejsSetErrorMsg(eid, "arg 2 must be a string");
554                 return -1;
555         }
556         
557         result = smbcli_rmdir(tree, argv[1]->string);
558
559         mpr_Return(eid, mprNTSTATUS(result));
560
561         return 0;
562 }
563
564 /* Rename a file or directory:
565
566      result = rename(tree_handle, SRCFILE, DESTFILE);
567  */
568
569 static int ejs_rename(MprVarHandle eid, int argc, MprVar **argv)
570 {
571         struct smbcli_tree *tree;
572         NTSTATUS result;
573
574         if (argc != 3) {
575                 ejsSetErrorMsg(eid, "rename(): invalid number of args");
576                 return -1;
577         }
578
579         if (!IS_TREE_HANDLE(argv[0])) {
580                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
581                 return -1;
582         }
583
584         tree = (struct smbcli_tree *)argv[0]->ptr;
585
586         if (!mprVarIsString(argv[1]->type)) {
587                 ejsSetErrorMsg(eid, "arg 2 must be a string");
588                 return -1;
589         }
590         
591         if (!mprVarIsString(argv[2]->type)) {
592                 ejsSetErrorMsg(eid, "arg 3 must be a string");
593                 return -1;
594         }
595         
596         result = smbcli_rename(tree, argv[1]->string, argv[2]->string);
597
598         mpr_Return(eid, mprNTSTATUS(result));
599
600         return 0;
601 }
602
603 /* Unlink a file or directory:
604
605      result = unlink(tree_handle, FILENAME);
606  */
607
608 static int ejs_unlink(MprVarHandle eid, int argc, MprVar **argv)
609 {
610         struct smbcli_tree *tree;
611         NTSTATUS result;
612
613         if (argc != 2) {
614                 ejsSetErrorMsg(eid, "unlink(): invalid number of args");
615                 return -1;
616         }
617
618         if (!IS_TREE_HANDLE(argv[0])) {
619                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
620                 return -1;
621         }
622
623         tree = (struct smbcli_tree *)argv[0]->ptr;
624
625         if (!mprVarIsString(argv[1]->type)) {
626                 ejsSetErrorMsg(eid, "arg 2 must be a string");
627                 return -1;
628         }
629         
630         result = smbcli_unlink(tree, argv[1]->string);
631
632         mpr_Return(eid, mprNTSTATUS(result));
633
634         return 0;
635 }
636
637 /* List directory contents
638
639      result = list(tree_handle, ARG1, ...);
640  */
641
642 static void ejs_list_helper(struct clilist_file_info *info, const char *mask, 
643                             void *state)
644
645 {
646         MprVar *result = (MprVar *)state;
647         char idx[16];
648
649         mprItoa(result->properties->numDataItems, idx, sizeof(idx));
650         mprSetVar(result, idx, mprString(info->name));
651 }
652
653 static int ejs_list(MprVarHandle eid, int argc, MprVar **argv)
654 {
655         struct smbcli_tree *tree;
656         char *mask;
657         uint16_t attribute;
658         MprVar result;
659
660         if (argc != 3) {
661                 ejsSetErrorMsg(eid, "list(): invalid number of args");
662                 return -1;
663         }
664
665         if (!IS_TREE_HANDLE(argv[0])) {
666                 ejsSetErrorMsg(eid, "first arg is not a tree handle");
667                 return -1;
668         }
669
670         tree = (struct smbcli_tree *)argv[0]->ptr;
671
672         if (!mprVarIsString(argv[1]->type)) {
673                 ejsSetErrorMsg(eid, "arg 2 must be a string");
674                 return -1;
675         }
676         
677         mask = argv[1]->string;
678
679         if (!mprVarIsNumber(argv[2]->type)) {
680                 ejsSetErrorMsg(eid, "arg 3 must be a number");
681                 return -1;
682         }
683
684         attribute = mprVarToInteger(argv[2]);
685
686         result = mprObject("list");
687
688         smbcli_list(tree, mask, attribute, ejs_list_helper, &result);
689
690         mpr_Return(eid, result);
691
692         return 0;
693 }
694
695 /*
696   setup C functions that be called from ejs
697 */
698 void smb_setup_ejs_cli(void)
699 {
700         ejsDefineStringCFunction(-1, "tree_connect", ejs_tree_connect, NULL, MPR_VAR_SCRIPT_HANDLE);
701         ejsDefineCFunction(-1, "tree_disconnect", ejs_tree_disconnect, NULL, MPR_VAR_SCRIPT_HANDLE);
702
703         ejsDefineCFunction(-1, "mkdir", ejs_mkdir, NULL, MPR_VAR_SCRIPT_HANDLE);
704         ejsDefineCFunction(-1, "rmdir", ejs_rmdir, NULL, MPR_VAR_SCRIPT_HANDLE);
705         ejsDefineCFunction(-1, "rename", ejs_rename, NULL, MPR_VAR_SCRIPT_HANDLE);
706         ejsDefineCFunction(-1, "unlink", ejs_unlink, NULL, MPR_VAR_SCRIPT_HANDLE);
707         ejsDefineCFunction(-1, "list", ejs_list, NULL, MPR_VAR_SCRIPT_HANDLE);
708         
709
710 #if 0
711         ejsDefineStringCFunction(-1, "connect", ejs_cli_connect, NULL, MPR_VAR_SCRIPT_HANDLE);
712         ejsDefineCFunction(-1, "session_setup", ejs_cli_ssetup, NULL, MPR_VAR_SCRIPT_HANDLE);
713         ejsDefineCFunction(-1, "tree_connect", ejs_cli_tree_connect, NULL, MPR_VAR_SCRIPT_HANDLE);
714         ejsDefineCFunction(-1, "tree_disconnect", ejs_cli_tree_disconnect, NULL, MPR_VAR_SCRIPT_HANDLE);
715         ejsDefineCFunction(-1, "session_logoff", ejs_cli_session_logoff, NULL, MPR_VAR_SCRIPT_HANDLE);
716         ejsDefineCFunction(-1, "disconnect", ejs_cli_disconnect, NULL, MPR_VAR_SCRIPT_HANDLE);  
717 #endif
718 }