r25027: Fix more warnings.
[jelmer/samba4-debian.git] / source / scripting / ejs / ejsnet / net_user.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    provides interfaces to libnet calls from ejs scripts
5
6    Copyright (C) Rafal Szczesniak  2005-2007
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 "lib/appweb/ejs/ejs.h"
24 #include "libnet/libnet.h"
25 #include "scripting/ejs/ejsnet/proto.h"
26 #include "scripting/ejs/smbcalls.h"
27 #include "events/events.h"
28 #include "auth/credentials/credentials.h"
29
30
31 static int ejs_net_createuser(MprVarHandle eid, int argc, char **argv);
32 static int ejs_net_deleteuser(MprVarHandle eid, int argc, char **argv);
33 static int ejs_net_userinfo(MprVarHandle eid, int argc, char **argv);
34 static int ejs_net_userlist(MprVarHandle eid, int argc, struct MprVar **argv);
35
36
37 /*
38   Usage:
39   usrCtx = net.UserMgr(domain = <default from credentials>);
40 */
41 int ejs_net_userman(MprVarHandle eid, int argc, struct MprVar **argv)
42 {
43         struct libnet_context *ctx;
44         const char *userman_domain = NULL;
45         struct MprVar obj;
46
47         /* libnet context */
48         ctx = (struct libnet_context *)mprGetThisPtr(eid, "ctx");
49         if (ctx == NULL) {
50                 ejsSetErrorMsg(eid, "ctx property returns null pointer");
51                 return 0;
52         }
53
54         /* fetch the arguments: domain name */
55         if (argc == 0) {
56                 /* default domain name is supplied in credentials */
57                 userman_domain = cli_credentials_get_domain(ctx->cred);
58
59         } else if (argc == 1 && mprVarIsString(argv[0]->type)) {
60                 /* domain name can also be specified explicitly 
61                    (e.g. to connect BUILTIN domain) */
62                 userman_domain = mprToString(argv[0]);
63
64         } else {
65                 ejsSetErrorMsg(eid, "too many arguments");
66                 return 0;
67         }
68
69         /* any domain name must be specified anyway */
70         if (userman_domain == NULL) {
71                 ejsSetErrorMsg(eid, "a domain must be specified for user management");
72                 return 0;
73         }
74
75         /* create 'net user' subcontext */
76         obj = mprObject("NetUsrCtx");
77
78         /* we need to make a copy of the string for this object */
79         userman_domain = talloc_strdup(ctx, userman_domain);
80
81         /* add properties */
82         mprSetPtrChild(&obj, "ctx", ctx);
83         mprSetPtrChild(&obj, "domain", userman_domain);
84
85         /* add methods */
86         mprSetStringCFunction(&obj, "Create", ejs_net_createuser);
87         mprSetStringCFunction(&obj, "Delete", ejs_net_deleteuser);
88         mprSetStringCFunction(&obj, "Info", ejs_net_userinfo);
89         mprSetCFunction(&obj, "List", ejs_net_userlist);
90
91         /* set the object returned by this function */
92         mpr_Return(eid, obj);
93
94         return 0;
95 }
96
97
98 /*
99   Usage:
100   NTSTATUS = NetUsrCtx.Create(Username)
101 */
102 static int ejs_net_createuser(MprVarHandle eid, int argc, char **argv)
103 {
104         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
105         TALLOC_CTX *mem_ctx;
106         struct libnet_context *ctx;
107         const char *userman_domain = NULL;
108         const char *username = NULL;
109         struct libnet_CreateUser req;
110
111         mem_ctx = talloc_new(mprMemCtx());
112         if (mem_ctx == NULL) {
113                 ejsSetErrorMsg(eid, "could not create memory context - out of memory");
114                 goto done;
115         }
116
117         /* fetch the arguments: username */
118         if (argc == 0) {
119                 ejsSetErrorMsg(eid, "too little arguments");
120                 goto done;
121
122         } else if (argc == 1) {
123                 username = argv[0];
124
125         } else {
126                 ejsSetErrorMsg(eid, "too many arguments");
127                 goto done;
128         }
129         
130         /* libnet context */
131         ctx = (struct libnet_context *)mprGetThisPtr(eid, "ctx");
132         if (ctx == NULL) {
133                 ejsSetErrorMsg(eid, "ctx property returns null pointer");
134                 goto done;
135         }
136
137         /* domain where the account is to be created */
138         userman_domain = (const char *)mprGetThisPtr(eid, "domain");
139         if (userman_domain == NULL) {
140                 ejsSetErrorMsg(eid, "domain property returns null pointer");
141                 goto done;
142         }
143         
144         /* call the libnet function */
145         req.in.domain_name = userman_domain;
146         req.in.user_name   = argv[0];
147
148         status = libnet_CreateUser(ctx, mem_ctx, &req);
149         if (!NT_STATUS_IS_OK(status)) {
150                 ejsSetErrorMsg(eid, "%s", req.out.error_string);
151         }
152
153 done:
154         talloc_free(mem_ctx);
155         mpr_Return(eid, mprNTSTATUS(status));
156         return 0;
157 }
158
159
160 /*
161   Usage:
162   NTSTATUS = NetUsrCtx.Delete(Username)
163 */
164 static int ejs_net_deleteuser(MprVarHandle eid, int argc, char **argv)
165 {
166         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
167         TALLOC_CTX *mem_ctx;
168         struct libnet_context *ctx;
169         const char *userman_domain = NULL;
170         const char *username = NULL;
171         struct libnet_DeleteUser req;
172
173         mem_ctx = talloc_new(mprMemCtx());
174         if (mem_ctx == NULL) {
175                 ejsSetErrorMsg(eid, "could not create memory context - out of memory");
176                 goto done;
177         }
178
179         /* fetch the arguments: username */
180         if (argc == 0) {
181                 ejsSetErrorMsg(eid, "too little arguments");
182                 goto done;
183
184         } else if (argc == 1) {
185                 username = argv[0];
186
187         } else {
188                 ejsSetErrorMsg(eid, "too many arguments");
189                 goto done;
190         }
191
192         /* libnet context */
193         ctx = mprGetThisPtr(eid, "ctx");
194         if (ctx == NULL) {
195                 ejsSetErrorMsg(eid, "ctx property returns null pointer");
196                 goto done;
197         }
198         
199         /* domain where the account is to be deleted */
200         userman_domain = (struct libnet_context *)mprGetThisPtr(eid, "domain");
201         if (!userman_domain) {
202                 ejsSetErrorMsg(eid, "domain property returns null pointer");
203                 goto done;
204         }
205         
206         /* call the libnet function */
207         req.in.domain_name = userman_domain;
208         req.in.user_name   = username;
209
210         status = libnet_DeleteUser(ctx, mem_ctx, &req);
211         if (!NT_STATUS_IS_OK(status)) {
212                 ejsSetErrorMsg(eid, "%s", req.out.error_string);
213         }
214
215 done:
216         talloc_free(mem_ctx);
217         mpr_Return(eid, mprNTSTATUS(status));
218         return 0;
219 }
220
221
222 /*
223   Usage:
224   UserInfo = NetUsrCtx.Info(Username)
225 */
226 static int ejs_net_userinfo(MprVarHandle eid, int argc, char **argv)
227 {
228         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
229         TALLOC_CTX *mem_ctx;
230         struct libnet_context *ctx;
231         const char *userman_domain = NULL;
232         const char *username = NULL;
233         struct libnet_UserInfo req;
234         struct MprVar mprUserInfo;
235
236         mem_ctx = talloc_new(mprMemCtx());
237         if (mem_ctx == NULL) {
238                 ejsSetErrorMsg(eid, "could not create memory context - out of memory");
239                 goto done;
240         }
241         
242         /* fetch the arguments: username */
243         if (argc == 0) {
244                 ejsSetErrorMsg(eid, "too little arguments");
245                 goto done;
246
247         } else if (argc == 1) {
248                 username = argv[0];
249
250         } else {
251                 ejsSetErrorMsg(eid, "too many arguments");
252                 goto done;
253         }
254
255         /* libnet context */
256         ctx = (struct libnet_context *)mprGetThisPtr(eid, "ctx");
257         if (ctx == NULL) {
258                 ejsSetErrorMsg(eid, "ctx property returns null pointer");
259                 goto done;
260         }
261         
262         /* domain where the user account is to be queried */
263         userman_domain = (struct libnet_context *)mprGetThisPtr(eid, "domain");
264         if (userman_domain == NULL) {
265                 ejsSetErrorMsg(eid, "domain property returns null pointer");
266                 return -1;
267         }
268
269         /* call the libnet function */
270         req.in.domain_name = userman_domain;
271         req.in.user_name   = username;
272         
273         status = libnet_UserInfo(ctx, mem_ctx, &req);
274         if (!NT_STATUS_IS_OK(status)) {
275                 ejsSetErrorMsg(eid, "%s", req.out.error_string);
276                 
277                 /* create null object to return */
278                 mprUserInfo = mprCreateNullVar();
279                 goto done;
280         }
281
282         /* create UserInfo object */
283         mprUserInfo = mprCreateUserInfo(ctx, &req);
284
285 done:
286         talloc_free(mem_ctx);
287         mpr_Return(eid, mprUserInfo);
288         return 0;
289 }
290
291
292 /*
293   Usage:
294   UserListCtx = NetUsrCtx.List(UserListCtx)
295 */
296 static int ejs_net_userlist(MprVarHandle eid, int argc, struct MprVar **argv)
297 {
298         TALLOC_CTX *mem_ctx;
299         NTSTATUS status;
300         struct libnet_context *ctx;
301         const char *userlist_domain;
302         int page_size = 512;         /* TODO: this should be specified in a nicer way */
303         struct libnet_UserList req;
304         struct MprVar mprListCtx, *mprInListCtx;
305         
306         mem_ctx = talloc_new(mprMemCtx());
307         if (mem_ctx == NULL) {
308                 ejsSetErrorMsg(eid, "could not create memory context - out of memory");
309                 goto done;
310         }
311         
312         /* fetch the arguments */
313         if (argc == 0) {
314                 ejsSetErrorMsg(eid, "too little arguments");
315                 goto done;
316
317         } else if (argc == 1) {
318                 if (mprVarIsObject(argv[0]->type)) {
319                         /* this is a continuation call */
320                         mprInListCtx = argv[0];
321                         req.in.resume_index = mprListGetResumeIndex(mprInListCtx);
322
323                 } else {
324                         /* this is a first call */
325                         req.in.resume_index = 0;
326                 }
327
328         } else {
329                 ejsSetErrorMsg(eid, "too many arguments");
330                 goto done;
331         }
332
333         /* libnet context */
334         ctx = (struct libnet_context *)mprGetThisPtr(eid, "ctx");
335         if (ctx == NULL) {
336                 ejsSetErrorMsg(eid, "ctx property returns null pointer");
337                 goto done;
338         }
339         
340         /* domain where user accounts are to be enumerated */
341         userlist_domain = mprGetThisPtr(eid, "domain");
342         if (userlist_domain == NULL) {
343                 ejsSetErrorMsg(eid, "domain property returns null pointer");
344                 goto done;
345         }
346
347         /* call the libnet function */
348         req.in.domain_name   = userlist_domain;
349         req.in.page_size     = page_size;
350         
351         status = libnet_UserList(ctx, mem_ctx, &req);
352         mprListCtx = mprUserListCtx(mem_ctx, &req, status);
353
354 done:
355         talloc_free(mem_ctx);
356         mpr_Return(eid, mprListCtx);
357         return 0;
358 }