?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Revert "s3-printing: update parent smbd pcap cache""
[Samba.git] / source4 / rpc_server / samr / dcesrv_samr.c
blobdf23e11a67b553ae2f5d3217797a507d8981047a
1 /*
2 Unix SMB/CIFS implementation.
3
4 endpoint server for the samr pipe
5
6 Copyright (C) Andrew Tridgell 2004
7 Copyright (C) Volker Lendecke 2004
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "librpc/gen_ndr/ndr_samr.h"
26 #include "rpc_server/dcerpc_server.h"
27 #include "rpc_server/common/common.h"
28 #include "rpc_server/samr/dcesrv_samr.h"
29 #include "system/time.h"
30 #include "lib/ldb/include/ldb.h"
31 #include "lib/ldb/include/ldb_errors.h"
32 #include "dsdb/common/flags.h"
33 #include "dsdb/samdb/samdb.h"
34 #include "libcli/ldap/ldap_ndr.h"
35 #include "libcli/security/security.h"
36 #include "rpc_server/samr/proto.h"
37 #include "../lib/util/util_ldb.h"
38 #include "param/param.h"
39
40 /* these query macros make samr_Query[User|Group|Alias]Info a bit easier to read */
41
42 #define QUERY_STRING(msg, field, attr) \
43 info->field.string = samdb_result_string(msg, attr, "");
44 #define QUERY_UINT(msg, field, attr) \
45 info->field = samdb_result_uint(msg, attr, 0);
46 #define QUERY_RID(msg, field, attr) \
47 info->field = samdb_result_rid_from_sid(mem_ctx, msg, attr, 0);
48 #define QUERY_UINT64(msg, field, attr) \
49 info->field = samdb_result_uint64(msg, attr, 0);
50 #define QUERY_APASSC(msg, field, attr) \
51 info->field = samdb_result_allow_password_change(sam_ctx, mem_ctx, \
52 a_state->domain_state->domain_dn, msg, attr);
53 #define QUERY_FPASSC(msg, field, attr) \
54 info->field = samdb_result_force_password_change(sam_ctx, mem_ctx, \
55 a_state->domain_state->domain_dn, msg);
56 #define QUERY_LHOURS(msg, field, attr) \
57 info->field = samdb_result_logon_hours(mem_ctx, msg, attr);
58 #define QUERY_AFLAGS(msg, field, attr) \
59 info->field = samdb_result_acct_flags(sam_ctx, mem_ctx, msg, a_state->domain_state->domain_dn);
60 #define QUERY_PARAMETERS(msg, field, attr) \
61 info->field = samdb_result_parameters(mem_ctx, msg, attr);
62
63
64 /* these are used to make the Set[User|Group]Info code easier to follow */
65
66 #define SET_STRING(msg, field, attr) do { \
67 struct ldb_message_element *set_el; \
68 if (r->in.info->field.string == NULL) return NT_STATUS_INVALID_PARAMETER; \
69 if (r->in.info->field.string[0] == '\0') { \
70 if (ldb_msg_add_empty(msg, attr, LDB_FLAG_MOD_DELETE, NULL)) { \
71 return NT_STATUS_NO_MEMORY; \
72 } \
73 } \
74 if (ldb_msg_add_string(msg, attr, r->in.info->field.string) != 0) { \
75 return NT_STATUS_NO_MEMORY; \
76 } \
77 set_el = ldb_msg_find_element(msg, attr); \
78 set_el->flags = LDB_FLAG_MOD_REPLACE; \
79 } while (0)
80
81 #define SET_UINT(msg, field, attr) do { \
82 struct ldb_message_element *set_el; \
83 if (samdb_msg_add_uint(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
84 return NT_STATUS_NO_MEMORY; \
85 } \
86 set_el = ldb_msg_find_element(msg, attr); \
87 set_el->flags = LDB_FLAG_MOD_REPLACE; \
88 } while (0)
89
90 #define SET_INT64(msg, field, attr) do { \
91 struct ldb_message_element *set_el; \
92 if (samdb_msg_add_int64(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
93 return NT_STATUS_NO_MEMORY; \
94 } \
95 set_el = ldb_msg_find_element(msg, attr); \
96 set_el->flags = LDB_FLAG_MOD_REPLACE; \
97 } while (0)
98
99 #define SET_UINT64(msg, field, attr) do { \
100 struct ldb_message_element *set_el; \
101 if (samdb_msg_add_uint64(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
102 return NT_STATUS_NO_MEMORY; \
103 } \
104 set_el = ldb_msg_find_element(msg, attr); \
105 set_el->flags = LDB_FLAG_MOD_REPLACE; \
106 } while (0)
107
108 #define CHECK_FOR_MULTIPLES(value, flag, poss_flags) \
109 do { \
110 if ((value & flag) && ((value & flag) != (value & (poss_flags)))) { \
111 return NT_STATUS_INVALID_PARAMETER; \
112 } \
113 } while (0) \
114
115 /* Set account flags, discarding flags that cannot be set with SAMR */
116 #define SET_AFLAGS(msg, field, attr) do { \
117 struct ldb_message_element *set_el; \
118 if ((r->in.info->field & (ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST)) == 0) { \
119 return NT_STATUS_INVALID_PARAMETER; \
120 } \
121 CHECK_FOR_MULTIPLES(r->in.info->field, ACB_NORMAL, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
122 CHECK_FOR_MULTIPLES(r->in.info->field, ACB_DOMTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
123 CHECK_FOR_MULTIPLES(r->in.info->field, ACB_WSTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
124 CHECK_FOR_MULTIPLES(r->in.info->field, ACB_SVRTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
125 if (samdb_msg_add_acct_flags(sam_ctx, mem_ctx, msg, attr, (r->in.info->field & ~(ACB_AUTOLOCK|ACB_PW_EXPIRED))) != 0) { \
126 return NT_STATUS_NO_MEMORY; \
127 } \
128 set_el = ldb_msg_find_element(msg, attr); \
129 set_el->flags = LDB_FLAG_MOD_REPLACE; \
130 } while (0)
131
132 #define SET_LHOURS(msg, field, attr) do { \
133 struct ldb_message_element *set_el; \
134 if (samdb_msg_add_logon_hours(sam_ctx, mem_ctx, msg, attr, &r->in.info->field) != 0) { \
135 return NT_STATUS_NO_MEMORY; \
136 } \
137 set_el = ldb_msg_find_element(msg, attr); \
138 set_el->flags = LDB_FLAG_MOD_REPLACE; \
139 } while (0)
140
141 #define SET_PARAMETERS(msg, field, attr) do { \
142 struct ldb_message_element *set_el; \
143 if (r->in.info->field.length != 0) { \
144 if (samdb_msg_add_parameters(sam_ctx, mem_ctx, msg, attr, &r->in.info->field) != 0) { \
145 return NT_STATUS_NO_MEMORY; \
146 } \
147 set_el = ldb_msg_find_element(msg, attr); \
148 set_el->flags = LDB_FLAG_MOD_REPLACE; \
149 } \
150 } while (0)
151
152
153
154 /*
155 samr_Connect
156
157 create a connection to the SAM database
158 */
159 static NTSTATUS dcesrv_samr_Connect(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
160 struct samr_Connect *r)
161 {
162 struct samr_connect_state *c_state;
163 struct dcesrv_handle *handle;
164
165 ZERO_STRUCTP(r->out.connect_handle);
166
167 c_state = talloc(dce_call->conn, struct samr_connect_state);
168 if (!c_state) {
169 return NT_STATUS_NO_MEMORY;
170 }
171
172 /* make sure the sam database is accessible */
173 c_state->sam_ctx = samdb_connect(c_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
174 if (c_state->sam_ctx == NULL) {
175 talloc_free(c_state);
176 return NT_STATUS_INVALID_SYSTEM_SERVICE;
177 }
178
179
180 handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_CONNECT);
181 if (!handle) {
182 talloc_free(c_state);
183 return NT_STATUS_NO_MEMORY;
184 }
185
186 handle->data = talloc_steal(handle, c_state);
187
188 c_state->access_mask = r->in.access_mask;
189 *r->out.connect_handle = handle->wire_handle;
190
191 return NT_STATUS_OK;
192 }
193
194
195 /*
196 samr_Close
197 */
198 static NTSTATUS dcesrv_samr_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
199 struct samr_Close *r)
200 {
201 struct dcesrv_handle *h;
202
203 *r->out.handle = *r->in.handle;
204
205 DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
206
207 talloc_free(h);
208
209 ZERO_STRUCTP(r->out.handle);
210
211 return NT_STATUS_OK;
212 }
213
214
215 /*
216 samr_SetSecurity
217 */
218 static NTSTATUS dcesrv_samr_SetSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
219 struct samr_SetSecurity *r)
220 {
221 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
222 }
223
224
225 /*
226 samr_QuerySecurity
227 */
228 static NTSTATUS dcesrv_samr_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
229 struct samr_QuerySecurity *r)
230 {
231 struct dcesrv_handle *h;
232 struct sec_desc_buf *sd;
233
234 *r->out.sdbuf = NULL;
235
236 DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
237
238 sd = talloc(mem_ctx, struct sec_desc_buf);
239 if (sd == NULL) {
240 return NT_STATUS_NO_MEMORY;
241 }
242
243 sd->sd = samdb_default_security_descriptor(mem_ctx);
244
245 *r->out.sdbuf = sd;
246
247 return NT_STATUS_OK;
248 }
249
250
251 /*
252 samr_Shutdown
253
254 we refuse this operation completely. If a admin wants to shutdown samr
255 in Samba then they should use the samba admin tools to disable the samr pipe
256 */
257 static NTSTATUS dcesrv_samr_Shutdown(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
258 struct samr_Shutdown *r)
259 {
260 return NT_STATUS_ACCESS_DENIED;
261 }
262
263
264 /*
265 samr_LookupDomain
266
267 this maps from a domain name to a SID
268 */
269 static NTSTATUS dcesrv_samr_LookupDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
270 struct samr_LookupDomain *r)
271 {
272 struct samr_connect_state *c_state;
273 struct dcesrv_handle *h;
274 struct dom_sid *sid;
275 const char * const dom_attrs[] = { "objectSid", NULL};
276 const char * const ref_attrs[] = { "ncName", NULL};
277 struct ldb_message **dom_msgs;
278 struct ldb_message **ref_msgs;
279 int ret;
280 struct ldb_dn *partitions_basedn;
281
282 *r->out.sid = NULL;
283
284 DCESRV_PULL_HANDLE(h, r->in.connect_handle, SAMR_HANDLE_CONNECT);
285
286 c_state = h->data;
287
288 if (r->in.domain_name->string == NULL) {
289 return NT_STATUS_INVALID_PARAMETER;
290 }
291
292 partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
293
294 if (strcasecmp(r->in.domain_name->string, "BUILTIN") == 0) {
295 ret = gendb_search(c_state->sam_ctx,
296 mem_ctx, NULL, &dom_msgs, dom_attrs,
297 "(objectClass=builtinDomain)");
298 } else {
299 ret = gendb_search(c_state->sam_ctx,
300 mem_ctx, partitions_basedn, &ref_msgs, ref_attrs,
301 "(&(&(nETBIOSName=%s)(objectclass=crossRef))(ncName=*))",
302 ldb_binary_encode_string(mem_ctx, r->in.domain_name->string));
303 if (ret != 1) {
304 return NT_STATUS_NO_SUCH_DOMAIN;
305 }
306
307 ret = gendb_search_dn(c_state->sam_ctx, mem_ctx,
308 samdb_result_dn(c_state->sam_ctx, mem_ctx,
309 ref_msgs[0], "ncName", NULL),
310 &dom_msgs, dom_attrs);
311 }
312
313 if (ret != 1) {
314 return NT_STATUS_NO_SUCH_DOMAIN;
315 }
316
317 sid = samdb_result_dom_sid(mem_ctx, dom_msgs[0],
318 "objectSid");
319
320 if (sid == NULL) {
321 return NT_STATUS_NO_SUCH_DOMAIN;
322 }
323
324 *r->out.sid = sid;
325
326 return NT_STATUS_OK;
327 }
328
329
330 /*
331 samr_EnumDomains
332
333 list the domains in the SAM
334 */
335 static NTSTATUS dcesrv_samr_EnumDomains(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
336 struct samr_EnumDomains *r)
337 {
338 struct samr_connect_state *c_state;
339 struct dcesrv_handle *h;
340 struct samr_SamArray *array;
341 int i, start_i, ret;
342 const char * const dom_attrs[] = { "cn", NULL};
343 const char * const ref_attrs[] = { "nETBIOSName", NULL};
344 struct ldb_result *dom_res;
345 struct ldb_result *ref_res;
346 struct ldb_dn *partitions_basedn;
347
348 *r->out.resume_handle = 0;
349 *r->out.sam = NULL;
350 *r->out.num_entries = 0;
351
352 DCESRV_PULL_HANDLE(h, r->in.connect_handle, SAMR_HANDLE_CONNECT);
353
354 c_state = h->data;
355
356 partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
357
358 ret = ldb_search(c_state->sam_ctx, mem_ctx, &dom_res, ldb_get_default_basedn(c_state->sam_ctx),
359 LDB_SCOPE_SUBTREE, dom_attrs, "(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain))");
360 if (ret != LDB_SUCCESS) {
361 DEBUG(0,("samdb: unable to find domains: %s\n", ldb_errstring(c_state->sam_ctx)));
362 return NT_STATUS_INTERNAL_DB_CORRUPTION;
363 }
364
365 *r->out.resume_handle = dom_res->count;
366
367 start_i = *r->in.resume_handle;
368
369 if (start_i >= dom_res->count) {
370 /* search past end of list is not an error for this call */
371 return NT_STATUS_OK;
372 }
373
374 array = talloc(mem_ctx, struct samr_SamArray);
375 if (array == NULL) {
376 return NT_STATUS_NO_MEMORY;
377 }
378
379 array->count = 0;
380 array->entries = NULL;
381
382 array->entries = talloc_array(mem_ctx, struct samr_SamEntry, dom_res->count - start_i);
383 if (array->entries == NULL) {
384 return NT_STATUS_NO_MEMORY;
385 }
386
387 for (i=0;i<dom_res->count-start_i;i++) {
388 array->entries[i].idx = start_i + i;
389 /* try and find the domain */
390 ret = ldb_search(c_state->sam_ctx, mem_ctx, &ref_res, partitions_basedn,
391 LDB_SCOPE_SUBTREE, ref_attrs, "(&(objectClass=crossRef)(ncName=%s))",
392 ldb_dn_get_linearized(dom_res->msgs[i]->dn));
393
394 if (ret != LDB_SUCCESS) {
395 DEBUG(0,("samdb: unable to find domains: %s\n", ldb_errstring(c_state->sam_ctx)));
396 return NT_STATUS_INTERNAL_DB_CORRUPTION;
397 }
398
399 if (ref_res->count == 1) {
400 array->entries[i].name.string = samdb_result_string(ref_res->msgs[0], "nETBIOSName", NULL);
401 } else {
402 array->entries[i].name.string = samdb_result_string(dom_res->msgs[i], "cn", NULL);
403 }
404 }
405
406 *r->out.sam = array;
407 *r->out.num_entries = i;
408 array->count = *r->out.num_entries;
409
410 return NT_STATUS_OK;
411 }
412
413
414 /*
415 samr_OpenDomain
416 */
417 static NTSTATUS dcesrv_samr_OpenDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
418 struct samr_OpenDomain *r)
419 {
420 struct dcesrv_handle *h_conn, *h_domain;
421 const char *domain_name;
422 struct samr_connect_state *c_state;
423 struct samr_domain_state *d_state;
424 const char * const dom_attrs[] = { "cn", NULL};
425 const char * const ref_attrs[] = { "nETBIOSName", NULL};
426 struct ldb_message **dom_msgs;
427 struct ldb_message **ref_msgs;
428 int ret;
429 struct ldb_dn *partitions_basedn;
430
431 ZERO_STRUCTP(r->out.domain_handle);
432
433 DCESRV_PULL_HANDLE(h_conn, r->in.connect_handle, SAMR_HANDLE_CONNECT);
434
435 c_state = h_conn->data;
436
437 if (r->in.sid == NULL) {
438 return NT_STATUS_INVALID_PARAMETER;
439 }
440
441 partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
442
443 ret = gendb_search(c_state->sam_ctx,
444 mem_ctx, NULL, &dom_msgs, dom_attrs,
445 "(&(objectSid=%s)(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain)))",
446 ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
447 if (ret == 0) {
448 return NT_STATUS_NO_SUCH_DOMAIN;
449 } else if (ret > 1) {
450 return NT_STATUS_INTERNAL_DB_CORRUPTION;
451 } else if (ret == -1) {
452 DEBUG(1, ("Failed to open domain %s: %s\n", dom_sid_string(mem_ctx, r->in.sid), ldb_errstring(c_state->sam_ctx)));
453 return NT_STATUS_INTERNAL_DB_CORRUPTION;
454 } else {
455 ret = gendb_search(c_state->sam_ctx,
456 mem_ctx, partitions_basedn, &ref_msgs, ref_attrs,
457 "(&(&(nETBIOSName=*)(objectclass=crossRef))(ncName=%s))",
458 ldb_dn_get_linearized(dom_msgs[0]->dn));
459 if (ret == 0) {
460 domain_name = ldb_msg_find_attr_as_string(dom_msgs[0], "cn", NULL);
461 if (domain_name == NULL) {
462 return NT_STATUS_NO_SUCH_DOMAIN;
463 }
464 } else if (ret == 1) {
465
466 domain_name = ldb_msg_find_attr_as_string(ref_msgs[0], "nETBIOSName", NULL);
467 if (domain_name == NULL) {
468 return NT_STATUS_NO_SUCH_DOMAIN;
469 }
470 } else {
471 return NT_STATUS_NO_SUCH_DOMAIN;
472 }
473 }
474
475 d_state = talloc(c_state, struct samr_domain_state);
476 if (!d_state) {
477 return NT_STATUS_NO_MEMORY;
478 }
479
480 d_state->role = lp_server_role(dce_call->conn->dce_ctx->lp_ctx);
481 d_state->connect_state = talloc_reference(d_state, c_state);
482 d_state->sam_ctx = c_state->sam_ctx;
483 d_state->domain_sid = dom_sid_dup(d_state, r->in.sid);
484 d_state->domain_name = talloc_strdup(d_state, domain_name);
485 d_state->domain_dn = ldb_dn_copy(d_state, dom_msgs[0]->dn);
486 if (!d_state->domain_sid || !d_state->domain_name || !d_state->domain_dn) {
487 talloc_free(d_state);
488 return NT_STATUS_NO_MEMORY;
489 }
490 d_state->access_mask = r->in.access_mask;
491
492 if (dom_sid_equal(d_state->domain_sid, dom_sid_parse_talloc(mem_ctx, SID_BUILTIN))) {
493 d_state->builtin = true;
494 } else {
495 d_state->builtin = false;
496 }
497
498 d_state->lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
499
500 h_domain = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_DOMAIN);
501 if (!h_domain) {
502 talloc_free(d_state);
503 return NT_STATUS_NO_MEMORY;
504 }
505
506 h_domain->data = talloc_steal(h_domain, d_state);
507
508 *r->out.domain_handle = h_domain->wire_handle;
509
510 return NT_STATUS_OK;
511 }
512
513 /*
514 return DomInfo1
515 */
516 static NTSTATUS dcesrv_samr_info_DomInfo1(struct samr_domain_state *state,
517 TALLOC_CTX *mem_ctx,
518 struct ldb_message **dom_msgs,
519 struct samr_DomInfo1 *info)
520 {
521 info->min_password_length =
522 samdb_result_uint(dom_msgs[0], "minPwdLength", 0);
523 info->password_history_length =
524 samdb_result_uint(dom_msgs[0], "pwdHistoryLength", 0);
525 info->password_properties =
526 samdb_result_uint(dom_msgs[0], "pwdProperties", 0);
527 info->max_password_age =
528 samdb_result_int64(dom_msgs[0], "maxPwdAge", 0);
529 info->min_password_age =
530 samdb_result_int64(dom_msgs[0], "minPwdAge", 0);
531
532 return NT_STATUS_OK;
533 }
534
535 /*
536 return DomInfo2
537 */
538 static NTSTATUS dcesrv_samr_info_DomGeneralInformation(struct samr_domain_state *state,
539 TALLOC_CTX *mem_ctx,
540 struct ldb_message **dom_msgs,
541 struct samr_DomGeneralInformation *info)
542 {
543 /* This pulls the NetBIOS name from the
544 cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
545 string */
546 info->primary.string = samdb_result_fsmo_name(state->sam_ctx, mem_ctx, dom_msgs[0], "fSMORoleOwner");
547
548 if (!info->primary.string) {
549 info->primary.string = lp_netbios_name(state->lp_ctx);
550 }
551
552 info->force_logoff_time = ldb_msg_find_attr_as_uint64(dom_msgs[0], "forceLogoff",
553 0x8000000000000000LL);
554
555 info->oem_information.string = samdb_result_string(dom_msgs[0], "oEMInformation", NULL);
556 info->domain_name.string = state->domain_name;
557
558 info->sequence_num = ldb_msg_find_attr_as_uint64(dom_msgs[0], "modifiedCount",
559 0);
560 switch (state->role) {
561 case ROLE_DOMAIN_CONTROLLER:
562 /* This pulls the NetBIOS name from the
563 cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
564 string */
565 if (samdb_is_pdc(state->sam_ctx)) {
566 info->role = SAMR_ROLE_DOMAIN_PDC;
567 } else {
568 info->role = SAMR_ROLE_DOMAIN_BDC;
569 }
570 break;
571 case ROLE_DOMAIN_MEMBER:
572 info->role = SAMR_ROLE_DOMAIN_MEMBER;
573 break;
574 case ROLE_STANDALONE:
575 info->role = SAMR_ROLE_STANDALONE;
576 break;
577 }
578
579 /* No users in BUILTIN, and the LOCAL group types are only in builtin, and the global group type is never in BUILTIN */
580 info->num_users = samdb_search_count(state->sam_ctx, mem_ctx, state->domain_dn,
581 "(objectClass=user)");
582 info->num_groups = samdb_search_count(state->sam_ctx, mem_ctx, state->domain_dn,
583 "(&(objectClass=group)(sAMAccountType=%u))",
584 ATYPE_GLOBAL_GROUP);
585 info->num_aliases = samdb_search_count(state->sam_ctx, mem_ctx, state->domain_dn,
586 "(&(objectClass=group)(sAMAccountType=%u))",
587 ATYPE_LOCAL_GROUP);
588
589 return NT_STATUS_OK;
590 }
591
592 /*
593 return DomInfo3
594 */
595 static NTSTATUS dcesrv_samr_info_DomInfo3(struct samr_domain_state *state,
596 TALLOC_CTX *mem_ctx,
597 struct ldb_message **dom_msgs,
598 struct samr_DomInfo3 *info)
599 {
600 info->force_logoff_time = ldb_msg_find_attr_as_uint64(dom_msgs[0], "forceLogoff",
601 0x8000000000000000LL);
602
603 return NT_STATUS_OK;
604 }
605
606 /*
607 return DomInfo4
608 */
609 static NTSTATUS dcesrv_samr_info_DomOEMInformation(struct samr_domain_state *state,
610 TALLOC_CTX *mem_ctx,
611 struct ldb_message **dom_msgs,
612 struct samr_DomOEMInformation *info)
613 {
614 info->oem_information.string = samdb_result_string(dom_msgs[0], "oEMInformation", NULL);
615
616 return NT_STATUS_OK;
617 }
618
619 /*
620 return DomInfo5
621 */
622 static NTSTATUS dcesrv_samr_info_DomInfo5(struct samr_domain_state *state,
623 TALLOC_CTX *mem_ctx,
624 struct ldb_message **dom_msgs,
625 struct samr_DomInfo5 *info)
626 {
627 info->domain_name.string = state->domain_name;
628
629 return NT_STATUS_OK;
630 }
631
632 /*
633 return DomInfo6
634 */
635 static NTSTATUS dcesrv_samr_info_DomInfo6(struct samr_domain_state *state,
636 TALLOC_CTX *mem_ctx,
637 struct ldb_message **dom_msgs,
638 struct samr_DomInfo6 *info)
639 {
640 /* This pulls the NetBIOS name from the
641 cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
642 string */
643 info->primary.string = samdb_result_fsmo_name(state->sam_ctx, mem_ctx,
644 dom_msgs[0], "fSMORoleOwner");
645
646 if (!info->primary.string) {
647 info->primary.string = lp_netbios_name(state->lp_ctx);
648 }
649
650 return NT_STATUS_OK;
651 }
652
653 /*
654 return DomInfo7
655 */
656 static NTSTATUS dcesrv_samr_info_DomInfo7(struct samr_domain_state *state,
657 TALLOC_CTX *mem_ctx,
658 struct ldb_message **dom_msgs,
659 struct samr_DomInfo7 *info)
660 {
661
662 switch (state->role) {
663 case ROLE_DOMAIN_CONTROLLER:
664 /* This pulls the NetBIOS name from the
665 cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
666 string */
667 if (samdb_is_pdc(state->sam_ctx)) {
668 info->role = SAMR_ROLE_DOMAIN_PDC;
669 } else {
670 info->role = SAMR_ROLE_DOMAIN_BDC;
671 }
672 break;
673 case ROLE_DOMAIN_MEMBER:
674 info->role = SAMR_ROLE_DOMAIN_MEMBER;
675 break;
676 case ROLE_STANDALONE:
677 info->role = SAMR_ROLE_STANDALONE;
678 break;
679 }
680
681 return NT_STATUS_OK;
682 }
683
684 /*
685 return DomInfo8
686 */
687 static NTSTATUS dcesrv_samr_info_DomInfo8(struct samr_domain_state *state,
688 TALLOC_CTX *mem_ctx,
689 struct ldb_message **dom_msgs,
690 struct samr_DomInfo8 *info)
691 {
692 info->sequence_num = ldb_msg_find_attr_as_uint64(dom_msgs[0], "modifiedCount",
693 time(NULL));
694
695 info->domain_create_time = ldb_msg_find_attr_as_uint(dom_msgs[0], "creationTime",
696 0x0LL);
697
698 return NT_STATUS_OK;
699 }
700
701 /*
702 return DomInfo9
703 */
704 static NTSTATUS dcesrv_samr_info_DomInfo9(struct samr_domain_state *state,
705 TALLOC_CTX *mem_ctx,
706 struct ldb_message **dom_msgs,
707 struct samr_DomInfo9 *info)
708 {
709 info->domain_server_state = DOMAIN_SERVER_ENABLED;
710
711 return NT_STATUS_OK;
712 }
713
714 /*
715 return DomInfo11
716 */
717 static NTSTATUS dcesrv_samr_info_DomGeneralInformation2(struct samr_domain_state *state,
718 TALLOC_CTX *mem_ctx,
719 struct ldb_message **dom_msgs,
720 struct samr_DomGeneralInformation2 *info)
721 {
722 NTSTATUS status;
723 status = dcesrv_samr_info_DomGeneralInformation(state, mem_ctx, dom_msgs, &info->general);
724 if (!NT_STATUS_IS_OK(status)) {
725 return status;
726 }
727
728 info->lockout_duration = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutDuration",
729 -18000000000LL);
730 info->lockout_window = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockOutObservationWindow",
731 -18000000000LL);
732 info->lockout_threshold = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutThreshold", 0);
733
734 return NT_STATUS_OK;
735 }
736
737 /*
738 return DomInfo12
739 */
740 static NTSTATUS dcesrv_samr_info_DomInfo12(struct samr_domain_state *state,
741 TALLOC_CTX *mem_ctx,
742 struct ldb_message **dom_msgs,
743 struct samr_DomInfo12 *info)
744 {
745 info->lockout_duration = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutDuration",
746 -18000000000LL);
747 info->lockout_window = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockOutObservationWindow",
748 -18000000000LL);
749 info->lockout_threshold = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutThreshold", 0);
750
751 return NT_STATUS_OK;
752 }
753
754 /*
755 return DomInfo13
756 */
757 static NTSTATUS dcesrv_samr_info_DomInfo13(struct samr_domain_state *state,
758 TALLOC_CTX *mem_ctx,
759 struct ldb_message **dom_msgs,
760 struct samr_DomInfo13 *info)
761 {
762 info->sequence_num = ldb_msg_find_attr_as_uint64(dom_msgs[0], "modifiedCount",
763 time(NULL));
764
765 info->domain_create_time = ldb_msg_find_attr_as_uint(dom_msgs[0], "creationTime",
766 0x0LL);
767
768 info->modified_count_at_last_promotion = 0;
769
770 return NT_STATUS_OK;
771 }
772
773 /*
774 samr_QueryDomainInfo
775 */
776 static NTSTATUS dcesrv_samr_QueryDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
777 struct samr_QueryDomainInfo *r)
778 {
779 struct dcesrv_handle *h;
780 struct samr_domain_state *d_state;
781 union samr_DomainInfo *info;
782
783 struct ldb_message **dom_msgs;
784 const char * const *attrs = NULL;
785
786 *r->out.info = NULL;
787
788 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
789
790 d_state = h->data;
791
792 info = talloc(mem_ctx, union samr_DomainInfo);
793 if (!info) {
794 return NT_STATUS_NO_MEMORY;
795 }
796
797 switch (r->in.level) {
798 case 1:
799 {
800 static const char * const attrs2[] = { "minPwdLength", "pwdHistoryLength",
801 "pwdProperties", "maxPwdAge",
802 "minPwdAge", NULL };
803 attrs = attrs2;
804 break;
805 }
806 case 2:
807 {
808 static const char * const attrs2[] = {"forceLogoff",
809 "oEMInformation",
810 "modifiedCount",
811 "fSMORoleOwner",
812 NULL};
813 attrs = attrs2;
814 break;
815 }
816 case 3:
817 {
818 static const char * const attrs2[] = {"forceLogoff",
819 NULL};
820 attrs = attrs2;
821 break;
822 }
823 case 4:
824 {
825 static const char * const attrs2[] = {"oEMInformation",
826 NULL};
827 attrs = attrs2;
828 break;
829 }
830 case 5:
831 {
832 attrs = NULL;
833 break;
834 }
835 case 6:
836 {
837 static const char * const attrs2[] = {"fSMORoleOwner",
838 NULL};
839 attrs = attrs2;
840 break;
841 }
842 case 7:
843 {
844 attrs = NULL;
845 break;
846 }
847 case 8:
848 {
849 static const char * const attrs2[] = { "modifiedCount",
850 "creationTime",
851 NULL };
852 attrs = attrs2;
853 break;
854 }
855 case 9:
856 attrs = NULL;
857 break;
858 case 11:
859 {
860 static const char * const attrs2[] = { "oEMInformation", "forceLogoff",
861 "modifiedCount",
862 "lockoutDuration",
863 "lockOutObservationWindow",
864 "lockoutThreshold",
865 NULL};
866 attrs = attrs2;
867 break;
868 }
869 case 12:
870 {
871 static const char * const attrs2[] = { "lockoutDuration",
872 "lockOutObservationWindow",
873 "lockoutThreshold",
874 NULL};
875 attrs = attrs2;
876 break;
877 }
878 case 13:
879 {
880 static const char * const attrs2[] = { "modifiedCount",
881 "creationTime",
882 NULL };
883 attrs = attrs2;
884 break;
885 }
886 }
887
888 /* some levels don't need a search */
889 if (attrs) {
890 int ret;
891 ret = gendb_search_dn(d_state->sam_ctx, mem_ctx,
892 d_state->domain_dn, &dom_msgs, attrs);
893 if (ret != 1) {
894 return NT_STATUS_INTERNAL_DB_CORRUPTION;
895 }
896 }
897
898 *r->out.info = info;
899
900 ZERO_STRUCTP(info);
901
902 switch (r->in.level) {
903 case 1:
904 return dcesrv_samr_info_DomInfo1(d_state, mem_ctx, dom_msgs,
905 &info->info1);
906 case 2:
907 return dcesrv_samr_info_DomGeneralInformation(d_state, mem_ctx, dom_msgs,
908 &info->general);
909 case 3:
910 return dcesrv_samr_info_DomInfo3(d_state, mem_ctx, dom_msgs,
911 &info->info3);
912 case 4:
913 return dcesrv_samr_info_DomOEMInformation(d_state, mem_ctx, dom_msgs,
914 &info->oem);
915 case 5:
916 return dcesrv_samr_info_DomInfo5(d_state, mem_ctx, dom_msgs,
917 &info->info5);
918 case 6:
919 return dcesrv_samr_info_DomInfo6(d_state, mem_ctx, dom_msgs,
920 &info->info6);
921 case 7:
922 return dcesrv_samr_info_DomInfo7(d_state, mem_ctx, dom_msgs,
923 &info->info7);
924 case 8:
925 return dcesrv_samr_info_DomInfo8(d_state, mem_ctx, dom_msgs,
926 &info->info8);
927 case 9:
928 return dcesrv_samr_info_DomInfo9(d_state, mem_ctx, dom_msgs,
929 &info->info9);
930 case 11:
931 return dcesrv_samr_info_DomGeneralInformation2(d_state, mem_ctx, dom_msgs,
932 &info->general2);
933 case 12:
934 return dcesrv_samr_info_DomInfo12(d_state, mem_ctx, dom_msgs,
935 &info->info12);
936 case 13:
937 return dcesrv_samr_info_DomInfo13(d_state, mem_ctx, dom_msgs,
938 &info->info13);
939 }
940
941 return NT_STATUS_INVALID_INFO_CLASS;
942 }
943
944
945 /*
946 samr_SetDomainInfo
947 */
948 static NTSTATUS dcesrv_samr_SetDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
949 struct samr_SetDomainInfo *r)
950 {
951 struct dcesrv_handle *h;
952 struct samr_domain_state *d_state;
953 struct ldb_message *msg;
954 int ret;
955 struct ldb_context *sam_ctx;
956
957 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
958
959 d_state = h->data;
960 sam_ctx = d_state->sam_ctx;
961
962 msg = ldb_msg_new(mem_ctx);
963 if (msg == NULL) {
964 return NT_STATUS_NO_MEMORY;
965 }
966
967 msg->dn = talloc_reference(mem_ctx, d_state->domain_dn);
968 if (!msg->dn) {
969 return NT_STATUS_NO_MEMORY;
970 }
971
972 switch (r->in.level) {
973 case 1:
974 SET_UINT (msg, info1.min_password_length, "minPwdLength");
975 SET_UINT (msg, info1.password_history_length, "pwdHistoryLength");
976 SET_UINT (msg, info1.password_properties, "pwdProperties");
977 SET_INT64 (msg, info1.max_password_age, "maxPwdAge");
978 SET_INT64 (msg, info1.min_password_age, "minPwdAge");
979 break;
980 case 3:
981 SET_UINT64 (msg, info3.force_logoff_time, "forceLogoff");
982 break;
983 case 4:
984 SET_STRING(msg, oem.oem_information, "oEMInformation");
985 break;
986
987 case 6:
988 case 7:
989 case 9:
990 /* No op, we don't know where to set these */
991 return NT_STATUS_OK;
992
993 case 12:
994
995 SET_INT64 (msg, info12.lockout_duration, "lockoutDuration");
996 SET_INT64 (msg, info12.lockout_window, "lockOutObservationWindow");
997 SET_INT64 (msg, info12.lockout_threshold, "lockoutThreshold");
998 break;
999
1000 default:
1001 /* many info classes are not valid for SetDomainInfo */
1002 return NT_STATUS_INVALID_INFO_CLASS;
1003 }
1004
1005 /* modify the samdb record */
1006 ret = ldb_modify(sam_ctx, msg);
1007 if (ret != 0) {
1008 DEBUG(1,("Failed to modify record %s: %s\n",
1009 ldb_dn_get_linearized(d_state->domain_dn),
1010 ldb_errstring(sam_ctx)));
1011
1012 /* we really need samdb.c to return NTSTATUS */
1013 return NT_STATUS_UNSUCCESSFUL;
1014 }
1015
1016 return NT_STATUS_OK;
1017 }
1018
1019 /*
1020 samr_CreateDomainGroup
1021 */
1022 static NTSTATUS dcesrv_samr_CreateDomainGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1023 struct samr_CreateDomainGroup *r)
1024 {
1025 struct samr_domain_state *d_state;
1026 struct samr_account_state *a_state;
1027 struct dcesrv_handle *h;
1028 const char *name;
1029 struct ldb_message *msg;
1030 struct dom_sid *sid;
1031 const char *groupname;
1032 struct dcesrv_handle *g_handle;
1033 int ret;
1034
1035 ZERO_STRUCTP(r->out.group_handle);
1036 *r->out.rid = 0;
1037
1038 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1039
1040 d_state = h->data;
1041
1042 if (d_state->builtin) {
1043 DEBUG(5, ("Cannot create a domain group in the BUILTIN domain"));
1044 return NT_STATUS_ACCESS_DENIED;
1045 }
1046
1047 groupname = r->in.name->string;
1048
1049 if (groupname == NULL) {
1050 return NT_STATUS_INVALID_PARAMETER;
1051 }
1052
1053 /* check if the group already exists */
1054 name = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
1055 "sAMAccountName",
1056 "(&(sAMAccountName=%s)(objectclass=group))",
1057 ldb_binary_encode_string(mem_ctx, groupname));
1058 if (name != NULL) {
1059 return NT_STATUS_GROUP_EXISTS;
1060 }
1061
1062 msg = ldb_msg_new(mem_ctx);
1063 if (msg == NULL) {
1064 return NT_STATUS_NO_MEMORY;
1065 }
1066
1067 /* add core elements to the ldb_message for the user */
1068 msg->dn = ldb_dn_copy(mem_ctx, d_state->domain_dn);
1069 ldb_dn_add_child_fmt(msg->dn, "CN=%s,CN=Users", groupname);
1070 if (!msg->dn) {
1071 return NT_STATUS_NO_MEMORY;
1072 }
1073 samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "sAMAccountName", groupname);
1074 samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "objectClass", "group");
1075
1076 /* create the group */
1077 ret = ldb_add(d_state->sam_ctx, msg);
1078 switch (ret) {
1079 case LDB_SUCCESS:
1080 break;
1081 case LDB_ERR_ENTRY_ALREADY_EXISTS:
1082 DEBUG(0,("Failed to create group record %s: %s\n",
1083 ldb_dn_get_linearized(msg->dn),
1084 ldb_errstring(d_state->sam_ctx)));
1085 return NT_STATUS_GROUP_EXISTS;
1086 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1087 DEBUG(0,("Failed to create group record %s: %s\n",
1088 ldb_dn_get_linearized(msg->dn),
1089 ldb_errstring(d_state->sam_ctx)));
1090 return NT_STATUS_ACCESS_DENIED;
1091 default:
1092 DEBUG(0,("Failed to create group record %s: %s\n",
1093 ldb_dn_get_linearized(msg->dn),
1094 ldb_errstring(d_state->sam_ctx)));
1095 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1096 }
1097
1098 a_state = talloc(d_state, struct samr_account_state);
1099 if (!a_state) {
1100 return NT_STATUS_NO_MEMORY;
1101 }
1102 a_state->sam_ctx = d_state->sam_ctx;
1103 a_state->access_mask = r->in.access_mask;
1104 a_state->domain_state = talloc_reference(a_state, d_state);
1105 a_state->account_dn = talloc_steal(a_state, msg->dn);
1106
1107 /* retrieve the sid for the group just created */
1108 sid = samdb_search_dom_sid(d_state->sam_ctx, a_state,
1109 msg->dn, "objectSid", NULL);
1110 if (sid == NULL) {
1111 return NT_STATUS_UNSUCCESSFUL;
1112 }
1113
1114 a_state->account_name = talloc_strdup(a_state, groupname);
1115 if (!a_state->account_name) {
1116 return NT_STATUS_NO_MEMORY;
1117 }
1118
1119 /* create the policy handle */
1120 g_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_GROUP);
1121 if (!g_handle) {
1122 return NT_STATUS_NO_MEMORY;
1123 }
1124
1125 g_handle->data = talloc_steal(g_handle, a_state);
1126
1127 *r->out.group_handle = g_handle->wire_handle;
1128 *r->out.rid = sid->sub_auths[sid->num_auths-1];
1129
1130 return NT_STATUS_OK;
1131 }
1132
1133
1134 /*
1135 comparison function for sorting SamEntry array
1136 */
1137 static int compare_SamEntry(struct samr_SamEntry *e1, struct samr_SamEntry *e2)
1138 {
1139 return e1->idx - e2->idx;
1140 }
1141
1142 /*
1143 samr_EnumDomainGroups
1144 */
1145 static NTSTATUS dcesrv_samr_EnumDomainGroups(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1146 struct samr_EnumDomainGroups *r)
1147 {
1148 struct dcesrv_handle *h;
1149 struct samr_domain_state *d_state;
1150 struct ldb_message **res;
1151 int ldb_cnt, count, i, first;
1152 struct samr_SamEntry *entries;
1153 const char * const attrs[3] = { "objectSid", "sAMAccountName", NULL };
1154 struct samr_SamArray *sam;
1155
1156 *r->out.resume_handle = 0;
1157 *r->out.sam = NULL;
1158 *r->out.num_entries = 0;
1159
1160 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1161
1162 d_state = h->data;
1163
1164 /* search for all domain groups in this domain. This could possibly be
1165 cached and resumed based on resume_key */
1166 ldb_cnt = samdb_search_domain(d_state->sam_ctx, mem_ctx,
1167 d_state->domain_dn, &res, attrs,
1168 d_state->domain_sid,
1169 "(&(grouptype=%d)(objectclass=group))",
1170 GTYPE_SECURITY_GLOBAL_GROUP);
1171 if (ldb_cnt == -1) {
1172 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1173 }
1174
1175 /* convert to SamEntry format */
1176 entries = talloc_array(mem_ctx, struct samr_SamEntry, ldb_cnt);
1177 if (!entries) {
1178 return NT_STATUS_NO_MEMORY;
1179 }
1180
1181 count = 0;
1182
1183 for (i=0;i<ldb_cnt;i++) {
1184 struct dom_sid *group_sid;
1185
1186 group_sid = samdb_result_dom_sid(mem_ctx, res[i],
1187 "objectSid");
1188 if (group_sid == NULL)
1189 continue;
1190
1191 entries[count].idx =
1192 group_sid->sub_auths[group_sid->num_auths-1];
1193 entries[count].name.string =
1194 samdb_result_string(res[i], "sAMAccountName", "");
1195 count += 1;
1196 }
1197
1198 /* sort the results by rid */
1199 qsort(entries, count, sizeof(struct samr_SamEntry),
1200 (comparison_fn_t)compare_SamEntry);
1201
1202 /* find the first entry to return */
1203 for (first=0;
1204 first<count && entries[first].idx <= *r->in.resume_handle;
1205 first++) ;
1206
1207 /* return the rest, limit by max_size. Note that we
1208 use the w2k3 element size value of 54 */
1209 *r->out.num_entries = count - first;
1210 *r->out.num_entries = MIN(*r->out.num_entries,
1211 1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
1212
1213 sam = talloc(mem_ctx, struct samr_SamArray);
1214 if (!sam) {
1215 return NT_STATUS_NO_MEMORY;
1216 }
1217
1218 sam->entries = entries+first;
1219 sam->count = *r->out.num_entries;
1220
1221 *r->out.sam = sam;
1222
1223 if (*r->out.num_entries < count - first) {
1224 *r->out.resume_handle = entries[first+*r->out.num_entries-1].idx;
1225 return STATUS_MORE_ENTRIES;
1226 }
1227
1228 return NT_STATUS_OK;
1229 }
1230
1231
1232 /*
1233 samr_CreateUser2
1234
1235 This call uses transactions to ensure we don't get a new conflicting
1236 user while we are processing this, and to ensure the user either
1237 completly exists, or does not.
1238 */
1239 static NTSTATUS dcesrv_samr_CreateUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1240 struct samr_CreateUser2 *r)
1241 {
1242 struct samr_domain_state *d_state;
1243 struct samr_account_state *a_state;
1244 struct dcesrv_handle *h;
1245 const char *name;
1246 struct ldb_message *msg;
1247 struct dom_sid *sid;
1248 const char *account_name;
1249 struct dcesrv_handle *u_handle;
1250 int ret;
1251 const char *container, *obj_class=NULL;
1252 char *cn_name;
1253 int cn_name_len;
1254
1255 const char *attrs[] = {
1256 "objectSid",
1257 "userAccountControl",
1258 NULL
1259 };
1260
1261 uint32_t user_account_control;
1262
1263 struct ldb_message **msgs;
1264
1265 ZERO_STRUCTP(r->out.user_handle);
1266 *r->out.access_granted = 0;
1267 *r->out.rid = 0;
1268
1269 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1270
1271 d_state = h->data;
1272
1273 if (d_state->builtin) {
1274 DEBUG(5, ("Cannot create a user in the BUILTIN domain"));
1275 return NT_STATUS_ACCESS_DENIED;
1276 }
1277 account_name = r->in.account_name->string;
1278
1279 if (account_name == NULL) {
1280 return NT_STATUS_INVALID_PARAMETER;
1281 }
1282
1283 ret = ldb_transaction_start(d_state->sam_ctx);
1284 if (ret != 0) {
1285 DEBUG(0,("Failed to start a transaction for user creation: %s\n",
1286 ldb_errstring(d_state->sam_ctx)));
1287 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1288 }
1289
1290 /* check if the user already exists */
1291 name = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
1292 "sAMAccountName",
1293 "(&(sAMAccountName=%s)(objectclass=user))",
1294 ldb_binary_encode_string(mem_ctx, account_name));
1295 if (name != NULL) {
1296 ldb_transaction_cancel(d_state->sam_ctx);
1297 return NT_STATUS_USER_EXISTS;
1298 }
1299
1300 msg = ldb_msg_new(mem_ctx);
1301 if (msg == NULL) {
1302 ldb_transaction_cancel(d_state->sam_ctx);
1303 return NT_STATUS_NO_MEMORY;
1304 }
1305
1306 cn_name = talloc_strdup(mem_ctx, account_name);
1307 if (!cn_name) {
1308 ldb_transaction_cancel(d_state->sam_ctx);
1309 return NT_STATUS_NO_MEMORY;
1310 }
1311
1312 cn_name_len = strlen(cn_name);
1313
1314 /* This must be one of these values *only* */
1315 if (r->in.acct_flags == ACB_NORMAL) {
1316 container = "CN=Users";
1317 obj_class = "user";
1318
1319 } else if (r->in.acct_flags == ACB_WSTRUST) {
1320 if (cn_name[cn_name_len - 1] != '$') {
1321 return NT_STATUS_FOOBAR;
1322 }
1323 cn_name[cn_name_len - 1] = '\0';
1324 container = "CN=Computers";
1325 obj_class = "computer";
1326 samdb_msg_add_int(d_state->sam_ctx, mem_ctx, msg, "primaryGroupID", DOMAIN_RID_DOMAIN_MEMBERS);
1327
1328 } else if (r->in.acct_flags == ACB_SVRTRUST) {
1329 if (cn_name[cn_name_len - 1] != '$') {
1330 return NT_STATUS_FOOBAR;
1331 }
1332 cn_name[cn_name_len - 1] = '\0';
1333 container = "OU=Domain Controllers";
1334 obj_class = "computer";
1335 samdb_msg_add_int(d_state->sam_ctx, mem_ctx, msg, "primaryGroupID", DOMAIN_RID_DCS);
1336
1337 } else if (r->in.acct_flags == ACB_DOMTRUST) {
1338 container = "CN=Users";
1339 obj_class = "user";
1340
1341 } else {
1342 ldb_transaction_cancel(d_state->sam_ctx);
1343 return NT_STATUS_INVALID_PARAMETER;
1344 }
1345
1346 /* add core elements to the ldb_message for the user */
1347 msg->dn = ldb_dn_copy(mem_ctx, d_state->domain_dn);
1348 if ( ! ldb_dn_add_child_fmt(msg->dn, "CN=%s,%s", cn_name, container)) {
1349 ldb_transaction_cancel(d_state->sam_ctx);
1350 return NT_STATUS_FOOBAR;
1351 }
1352
1353 samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "sAMAccountName", account_name);
1354 samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "objectClass", obj_class);
1355
1356 /* Start a transaction, so we can query and do a subsequent atomic modify */
1357
1358 /* create the user */
1359 ret = ldb_add(d_state->sam_ctx, msg);
1360 switch (ret) {
1361 case LDB_SUCCESS:
1362 break;
1363 case LDB_ERR_ENTRY_ALREADY_EXISTS:
1364 ldb_transaction_cancel(d_state->sam_ctx);
1365 DEBUG(0,("Failed to create user record %s: %s\n",
1366 ldb_dn_get_linearized(msg->dn),
1367 ldb_errstring(d_state->sam_ctx)));
1368 return NT_STATUS_USER_EXISTS;
1369 case LDB_ERR_UNWILLING_TO_PERFORM:
1370 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1371 ldb_transaction_cancel(d_state->sam_ctx);
1372 DEBUG(0,("Failed to create user record %s: %s\n",
1373 ldb_dn_get_linearized(msg->dn),
1374 ldb_errstring(d_state->sam_ctx)));
1375 return NT_STATUS_ACCESS_DENIED;
1376 default:
1377 ldb_transaction_cancel(d_state->sam_ctx);
1378 DEBUG(0,("Failed to create user record %s: %s\n",
1379 ldb_dn_get_linearized(msg->dn),
1380 ldb_errstring(d_state->sam_ctx)));
1381 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1382 }
1383
1384 a_state = talloc(d_state, struct samr_account_state);
1385 if (!a_state) {
1386 ldb_transaction_cancel(d_state->sam_ctx);
1387 return NT_STATUS_NO_MEMORY;
1388 }
1389 a_state->sam_ctx = d_state->sam_ctx;
1390 a_state->access_mask = r->in.access_mask;
1391 a_state->domain_state = talloc_reference(a_state, d_state);
1392 a_state->account_dn = talloc_steal(a_state, msg->dn);
1393
1394 /* retrieve the sid and account control bits for the user just created */
1395 ret = gendb_search_dn(d_state->sam_ctx, a_state,
1396 msg->dn, &msgs, attrs);
1397
1398 if (ret != 1) {
1399 ldb_transaction_cancel(d_state->sam_ctx);
1400 DEBUG(0,("Apparently we failed to create an account record, as %s now doesn't exist\n",
1401 ldb_dn_get_linearized(msg->dn)));
1402 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1403 }
1404 sid = samdb_result_dom_sid(mem_ctx, msgs[0], "objectSid");
1405 if (sid == NULL) {
1406 ldb_transaction_cancel(d_state->sam_ctx);
1407 DEBUG(0,("Apparently we failed to get the objectSid of the just created account record %s\n",
1408 ldb_dn_get_linearized(msg->dn)));
1409 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1410 }
1411
1412 /* Change the account control to be the correct account type.
1413 * The default is for a workstation account */
1414 user_account_control = samdb_result_uint(msgs[0], "userAccountControl", 0);
1415 user_account_control = (user_account_control &
1416 ~(UF_NORMAL_ACCOUNT |
1417 UF_INTERDOMAIN_TRUST_ACCOUNT |
1418 UF_WORKSTATION_TRUST_ACCOUNT |
1419 UF_SERVER_TRUST_ACCOUNT));
1420 user_account_control |= samdb_acb2uf(r->in.acct_flags);
1421
1422 talloc_free(msg);
1423 msg = ldb_msg_new(mem_ctx);
1424 if (msg == NULL) {
1425 ldb_transaction_cancel(d_state->sam_ctx);
1426 return NT_STATUS_NO_MEMORY;
1427 }
1428
1429 msg->dn = ldb_dn_copy(msg, a_state->account_dn);
1430
1431 if (samdb_msg_add_uint(a_state->sam_ctx, mem_ctx, msg,
1432 "userAccountControl",
1433 user_account_control) != 0) {
1434 ldb_transaction_cancel(d_state->sam_ctx);
1435 return NT_STATUS_NO_MEMORY;
1436 }
1437
1438 /* modify the samdb record */
1439 ret = samdb_replace(a_state->sam_ctx, mem_ctx, msg);
1440 if (ret != 0) {
1441 DEBUG(0,("Failed to modify account record %s to set userAccountControl: %s\n",
1442 ldb_dn_get_linearized(msg->dn),
1443 ldb_errstring(d_state->sam_ctx)));
1444 ldb_transaction_cancel(d_state->sam_ctx);
1445
1446 /* we really need samdb.c to return NTSTATUS */
1447 return NT_STATUS_UNSUCCESSFUL;
1448 }
1449
1450 ret = ldb_transaction_commit(d_state->sam_ctx);
1451 if (ret != 0) {
1452 DEBUG(0,("Failed to commit transaction to add and modify account record %s: %s\n",
1453 ldb_dn_get_linearized(msg->dn),
1454 ldb_errstring(d_state->sam_ctx)));
1455 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1456 }
1457
1458 a_state->account_name = talloc_steal(a_state, account_name);
1459 if (!a_state->account_name) {
1460 return NT_STATUS_NO_MEMORY;
1461 }
1462
1463 /* create the policy handle */
1464 u_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_USER);
1465 if (!u_handle) {
1466 return NT_STATUS_NO_MEMORY;
1467 }
1468
1469 u_handle->data = talloc_steal(u_handle, a_state);
1470
1471 *r->out.user_handle = u_handle->wire_handle;
1472 *r->out.access_granted = 0xf07ff; /* TODO: fix access mask calculations */
1473
1474 *r->out.rid = sid->sub_auths[sid->num_auths-1];
1475
1476 return NT_STATUS_OK;
1477 }
1478
1479
1480 /*
1481 samr_CreateUser
1482 */
1483 static NTSTATUS dcesrv_samr_CreateUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1484 struct samr_CreateUser *r)
1485 {
1486 struct samr_CreateUser2 r2;
1487 uint32_t access_granted = 0;
1488
1489
1490 /* a simple wrapper around samr_CreateUser2 works nicely */
1491 r2.in.domain_handle = r->in.domain_handle;
1492 r2.in.account_name = r->in.account_name;
1493 r2.in.acct_flags = ACB_NORMAL;
1494 r2.in.access_mask = r->in.access_mask;
1495 r2.out.user_handle = r->out.user_handle;
1496 r2.out.access_granted = &access_granted;
1497 r2.out.rid = r->out.rid;
1498
1499 return dcesrv_samr_CreateUser2(dce_call, mem_ctx, &r2);
1500 }
1501
1502 /*
1503 samr_EnumDomainUsers
1504 */
1505 static NTSTATUS dcesrv_samr_EnumDomainUsers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1506 struct samr_EnumDomainUsers *r)
1507 {
1508 struct dcesrv_handle *h;
1509 struct samr_domain_state *d_state;
1510 struct ldb_result *res;
1511 int ret, num_filtered_entries, i, first;
1512 struct samr_SamEntry *entries;
1513 const char * const attrs[] = { "objectSid", "sAMAccountName", "userAccountControl", NULL };
1514 struct samr_SamArray *sam;
1515
1516 *r->out.resume_handle = 0;
1517 *r->out.sam = NULL;
1518 *r->out.num_entries = 0;
1519
1520 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1521
1522 d_state = h->data;
1523
1524 /* don't have to worry about users in the builtin domain, as there are none */
1525 ret = ldb_search(d_state->sam_ctx, mem_ctx, &res, d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=user");
1526
1527 if (ret != LDB_SUCCESS) {
1528 DEBUG(3, ("Failed to search for Domain Users in %s: %s\n",
1529 ldb_dn_get_linearized(d_state->domain_dn), ldb_errstring(d_state->sam_ctx)));
1530 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1531 }
1532
1533 /* convert to SamEntry format */
1534 entries = talloc_array(mem_ctx, struct samr_SamEntry, res->count);
1535 if (!entries) {
1536 return NT_STATUS_NO_MEMORY;
1537 }
1538 num_filtered_entries = 0;
1539 for (i=0;i<res->count;i++) {
1540 /* Check if a mask has been requested */
1541 if (r->in.acct_flags
1542 && ((samdb_result_acct_flags(d_state->sam_ctx, mem_ctx, res->msgs[i],
1543 d_state->domain_dn) & r->in.acct_flags) == 0)) {
1544 continue;
1545 }
1546 entries[num_filtered_entries].idx = samdb_result_rid_from_sid(mem_ctx, res->msgs[i], "objectSid", 0);
1547 entries[num_filtered_entries].name.string = samdb_result_string(res->msgs[i], "sAMAccountName", "");
1548 num_filtered_entries++;
1549 }
1550
1551 /* sort the results by rid */
1552 qsort(entries, num_filtered_entries, sizeof(struct samr_SamEntry),
1553 (comparison_fn_t)compare_SamEntry);
1554
1555 /* find the first entry to return */
1556 for (first=0;
1557 first<num_filtered_entries && entries[first].idx <= *r->in.resume_handle;
1558 first++) ;
1559
1560 /* return the rest, limit by max_size. Note that we
1561 use the w2k3 element size value of 54 */
1562 *r->out.num_entries = num_filtered_entries - first;
1563 *r->out.num_entries = MIN(*r->out.num_entries,
1564 1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
1565
1566 sam = talloc(mem_ctx, struct samr_SamArray);
1567 if (!sam) {
1568 return NT_STATUS_NO_MEMORY;
1569 }
1570
1571 sam->entries = entries+first;
1572 sam->count = *r->out.num_entries;
1573
1574 *r->out.sam = sam;
1575
1576 if (first == num_filtered_entries) {
1577 return NT_STATUS_OK;
1578 }
1579
1580 if (*r->out.num_entries < num_filtered_entries - first) {
1581 *r->out.resume_handle = entries[first+*r->out.num_entries-1].idx;
1582 return STATUS_MORE_ENTRIES;
1583 }
1584
1585 return NT_STATUS_OK;
1586 }
1587
1588
1589 /*
1590 samr_CreateDomAlias
1591 */
1592 static NTSTATUS dcesrv_samr_CreateDomAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1593 struct samr_CreateDomAlias *r)
1594 {
1595 struct samr_domain_state *d_state;
1596 struct samr_account_state *a_state;
1597 struct dcesrv_handle *h;
1598 const char *alias_name, *name;
1599 struct ldb_message *msg;
1600 struct dom_sid *sid;
1601 struct dcesrv_handle *a_handle;
1602 int ret;
1603
1604 ZERO_STRUCTP(r->out.alias_handle);
1605 *r->out.rid = 0;
1606
1607 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1608
1609 d_state = h->data;
1610
1611 if (d_state->builtin) {
1612 DEBUG(5, ("Cannot create a domain alias in the BUILTIN domain"));
1613 return NT_STATUS_ACCESS_DENIED;
1614 }
1615
1616 alias_name = r->in.alias_name->string;
1617
1618 if (alias_name == NULL) {
1619 return NT_STATUS_INVALID_PARAMETER;
1620 }
1621
1622 /* Check if alias already exists */
1623 name = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
1624 "sAMAccountName",
1625 "(sAMAccountName=%s)(objectclass=group))",
1626 ldb_binary_encode_string(mem_ctx, alias_name));
1627
1628 if (name != NULL) {
1629 return NT_STATUS_ALIAS_EXISTS;
1630 }
1631
1632 msg = ldb_msg_new(mem_ctx);
1633 if (msg == NULL) {
1634 return NT_STATUS_NO_MEMORY;
1635 }
1636
1637 /* add core elements to the ldb_message for the alias */
1638 msg->dn = ldb_dn_copy(mem_ctx, d_state->domain_dn);
1639 ldb_dn_add_child_fmt(msg->dn, "CN=%s,CN=Users", alias_name);
1640 if (!msg->dn) {
1641 return NT_STATUS_NO_MEMORY;
1642 }
1643
1644 samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "sAMAccountName", alias_name);
1645 samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "objectClass", "group");
1646 samdb_msg_add_int(d_state->sam_ctx, mem_ctx, msg, "groupType", GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1647
1648 /* create the alias */
1649 ret = ldb_add(d_state->sam_ctx, msg);
1650 switch (ret) {
1651 case LDB_SUCCESS:
1652 break;
1653 case LDB_ERR_ENTRY_ALREADY_EXISTS:
1654 return NT_STATUS_ALIAS_EXISTS;
1655 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1656 return NT_STATUS_ACCESS_DENIED;
1657 default:
1658 DEBUG(0,("Failed to create alias record %s: %s\n",
1659 ldb_dn_get_linearized(msg->dn),
1660 ldb_errstring(d_state->sam_ctx)));
1661 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1662 }
1663
1664 a_state = talloc(d_state, struct samr_account_state);
1665 if (!a_state) {
1666 return NT_STATUS_NO_MEMORY;
1667 }
1668
1669 a_state->sam_ctx = d_state->sam_ctx;
1670 a_state->access_mask = r->in.access_mask;
1671 a_state->domain_state = talloc_reference(a_state, d_state);
1672 a_state->account_dn = talloc_steal(a_state, msg->dn);
1673
1674 /* retrieve the sid for the alias just created */
1675 sid = samdb_search_dom_sid(d_state->sam_ctx, a_state,
1676 msg->dn, "objectSid", NULL);
1677
1678 a_state->account_name = talloc_strdup(a_state, alias_name);
1679 if (!a_state->account_name) {
1680 return NT_STATUS_NO_MEMORY;
1681 }
1682
1683 /* create the policy handle */
1684 a_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_ALIAS);
1685 if (a_handle == NULL)
1686 return NT_STATUS_NO_MEMORY;
1687
1688 a_handle->data = talloc_steal(a_handle, a_state);
1689
1690 *r->out.alias_handle = a_handle->wire_handle;
1691
1692 *r->out.rid = sid->sub_auths[sid->num_auths-1];
1693
1694 return NT_STATUS_OK;
1695 }
1696
1697
1698 /*
1699 samr_EnumDomainAliases
1700 */
1701 static NTSTATUS dcesrv_samr_EnumDomainAliases(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1702 struct samr_EnumDomainAliases *r)
1703 {
1704 struct dcesrv_handle *h;
1705 struct samr_domain_state *d_state;
1706 struct ldb_message **res;
1707 int ldb_cnt, count, i, first;
1708 struct samr_SamEntry *entries;
1709 const char * const attrs[3] = { "objectSid", "sAMAccountName", NULL };
1710 struct samr_SamArray *sam;
1711
1712 *r->out.resume_handle = 0;
1713 *r->out.sam = NULL;
1714 *r->out.num_entries = 0;
1715
1716 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1717
1718 d_state = h->data;
1719
1720 /* search for all domain groups in this domain. This could possibly be
1721 cached and resumed based on resume_key */
1722 ldb_cnt = samdb_search_domain(d_state->sam_ctx, mem_ctx,
1723 d_state->domain_dn,
1724 &res, attrs,
1725 d_state->domain_sid,
1726 "(&(|(grouptype=%d)(grouptype=%d)))"
1727 "(objectclass=group))",
1728 GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
1729 GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1730 if (ldb_cnt == -1) {
1731 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1732 }
1733 if (ldb_cnt == 0) {
1734 return NT_STATUS_OK;
1735 }
1736
1737 /* convert to SamEntry format */
1738 entries = talloc_array(mem_ctx, struct samr_SamEntry, ldb_cnt);
1739 if (!entries) {
1740 return NT_STATUS_NO_MEMORY;
1741 }
1742
1743 count = 0;
1744
1745 for (i=0;i<ldb_cnt;i++) {
1746 struct dom_sid *alias_sid;
1747
1748 alias_sid = samdb_result_dom_sid(mem_ctx, res[i],
1749 "objectSid");
1750
1751 if (alias_sid == NULL)
1752 continue;
1753
1754 entries[count].idx =
1755 alias_sid->sub_auths[alias_sid->num_auths-1];
1756 entries[count].name.string =
1757 samdb_result_string(res[i], "sAMAccountName", "");
1758 count += 1;
1759 }
1760
1761 /* sort the results by rid */
1762 qsort(entries, count, sizeof(struct samr_SamEntry),
1763 (comparison_fn_t)compare_SamEntry);
1764
1765 /* find the first entry to return */
1766 for (first=0;
1767 first<count && entries[first].idx <= *r->in.resume_handle;
1768 first++) ;
1769
1770 if (first == count) {
1771 return NT_STATUS_OK;
1772 }
1773
1774 *r->out.num_entries = count - first;
1775 *r->out.num_entries = MIN(*r->out.num_entries, 1000);
1776
1777 sam = talloc(mem_ctx, struct samr_SamArray);
1778 if (!sam) {
1779 return NT_STATUS_NO_MEMORY;
1780 }
1781
1782 sam->entries = entries+first;
1783 sam->count = *r->out.num_entries;
1784
1785 *r->out.sam = sam;
1786
1787 if (*r->out.num_entries < count - first) {
1788 *r->out.resume_handle =
1789 entries[first+*r->out.num_entries-1].idx;
1790 return STATUS_MORE_ENTRIES;
1791 }
1792
1793 return NT_STATUS_OK;
1794 }
1795
1796
1797 /*
1798 samr_GetAliasMembership
1799 */
1800 static NTSTATUS dcesrv_samr_GetAliasMembership(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1801 struct samr_GetAliasMembership *r)
1802 {
1803 struct dcesrv_handle *h;
1804 struct samr_domain_state *d_state;
1805 struct ldb_message **res;
1806 int i, count = 0;
1807
1808 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1809
1810 d_state = h->data;
1811
1812 if (r->in.sids->num_sids > 0) {
1813 const char *filter;
1814 const char * const attrs[2] = { "objectSid", NULL };
1815
1816 filter = talloc_asprintf(mem_ctx,
1817 "(&(|(grouptype=%d)(grouptype=%d))"
1818 "(objectclass=group)(|",
1819 GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
1820 GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1821 if (filter == NULL)
1822 return NT_STATUS_NO_MEMORY;
1823
1824 for (i=0; i<r->in.sids->num_sids; i++) {
1825 const char *memberdn;
1826
1827 memberdn =
1828 samdb_search_string(d_state->sam_ctx,
1829 mem_ctx, NULL, "distinguishedName",
1830 "(objectSid=%s)",
1831 ldap_encode_ndr_dom_sid(mem_ctx,
1832 r->in.sids->sids[i].sid));
1833
1834 if (memberdn == NULL)
1835 continue;
1836
1837 filter = talloc_asprintf(mem_ctx, "%s(member=%s)",
1838 filter, memberdn);
1839 if (filter == NULL)
1840 return NT_STATUS_NO_MEMORY;
1841 }
1842
1843 count = samdb_search_domain(d_state->sam_ctx, mem_ctx,
1844 d_state->domain_dn, &res, attrs,
1845 d_state->domain_sid, "%s))", filter);
1846 if (count < 0)
1847 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1848 }
1849
1850 r->out.rids->count = 0;
1851 r->out.rids->ids = talloc_array(mem_ctx, uint32_t, count);
1852 if (r->out.rids->ids == NULL)
1853 return NT_STATUS_NO_MEMORY;
1854
1855 for (i=0; i<count; i++) {
1856 struct dom_sid *alias_sid;
1857
1858 alias_sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
1859
1860 if (alias_sid == NULL) {
1861 DEBUG(0, ("Could not find objectSid\n"));
1862 continue;
1863 }
1864
1865 r->out.rids->ids[r->out.rids->count] =
1866 alias_sid->sub_auths[alias_sid->num_auths-1];
1867 r->out.rids->count += 1;
1868 }
1869
1870 return NT_STATUS_OK;
1871 }
1872
1873
1874 /*
1875 samr_LookupNames
1876 */
1877 static NTSTATUS dcesrv_samr_LookupNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1878 struct samr_LookupNames *r)
1879 {
1880 struct dcesrv_handle *h;
1881 struct samr_domain_state *d_state;
1882 int i, num_mapped;
1883 NTSTATUS status = NT_STATUS_OK;
1884 const char * const attrs[] = { "sAMAccountType", "objectSid", NULL };
1885 int count;
1886
1887 ZERO_STRUCTP(r->out.rids);
1888 ZERO_STRUCTP(r->out.types);
1889
1890 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1891
1892 d_state = h->data;
1893
1894 if (r->in.num_names == 0) {
1895 return NT_STATUS_OK;
1896 }
1897
1898 r->out.rids->ids = talloc_array(mem_ctx, uint32_t, r->in.num_names);
1899 r->out.types->ids = talloc_array(mem_ctx, uint32_t, r->in.num_names);
1900 if (!r->out.rids->ids || !r->out.types->ids) {
1901 return NT_STATUS_NO_MEMORY;
1902 }
1903 r->out.rids->count = r->in.num_names;
1904 r->out.types->count = r->in.num_names;
1905
1906 num_mapped = 0;
1907
1908 for (i=0;i<r->in.num_names;i++) {
1909 struct ldb_message **res;
1910 struct dom_sid *sid;
1911 uint32_t atype, rtype;
1912
1913 r->out.rids->ids[i] = 0;
1914 r->out.types->ids[i] = SID_NAME_UNKNOWN;
1915
1916 count = gendb_search(d_state->sam_ctx, mem_ctx, d_state->domain_dn, &res, attrs,
1917 "sAMAccountName=%s",
1918 ldb_binary_encode_string(mem_ctx, r->in.names[i].string));
1919 if (count != 1) {
1920 status = STATUS_SOME_UNMAPPED;
1921 continue;
1922 }
1923
1924 sid = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
1925 if (sid == NULL) {
1926 status = STATUS_SOME_UNMAPPED;
1927 continue;
1928 }
1929
1930 atype = samdb_result_uint(res[0], "sAMAccountType", 0);
1931 if (atype == 0) {
1932 status = STATUS_SOME_UNMAPPED;
1933 continue;
1934 }
1935
1936 rtype = samdb_atype_map(atype);
1937
1938 if (rtype == SID_NAME_UNKNOWN) {
1939 status = STATUS_SOME_UNMAPPED;
1940 continue;
1941 }
1942
1943 r->out.rids->ids[i] = sid->sub_auths[sid->num_auths-1];
1944 r->out.types->ids[i] = rtype;
1945 num_mapped++;
1946 }
1947
1948 if (num_mapped == 0) {
1949 return NT_STATUS_NONE_MAPPED;
1950 }
1951 return status;
1952 }
1953
1954
1955 /*
1956 samr_LookupRids
1957 */
1958 static NTSTATUS dcesrv_samr_LookupRids(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1959 struct samr_LookupRids *r)
1960 {
1961 struct dcesrv_handle *h;
1962 struct samr_domain_state *d_state;
1963 int i, total;
1964 NTSTATUS status = NT_STATUS_OK;
1965 struct lsa_String *names;
1966 uint32_t *ids;
1967
1968 ZERO_STRUCTP(r->out.names);
1969 ZERO_STRUCTP(r->out.types);
1970
1971 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1972
1973 d_state = h->data;
1974
1975 if (r->in.num_rids == 0)
1976 return NT_STATUS_OK;
1977
1978 names = talloc_array(mem_ctx, struct lsa_String, r->in.num_rids);
1979 ids = talloc_array(mem_ctx, uint32_t, r->in.num_rids);
1980
1981 if ((names == NULL) || (ids == NULL))
1982 return NT_STATUS_NO_MEMORY;
1983
1984 total = 0;
1985
1986 for (i=0; i<r->in.num_rids; i++) {
1987 struct ldb_message **res;
1988 int count;
1989 const char * const attrs[] = { "sAMAccountType",
1990 "sAMAccountName", NULL };
1991 uint32_t atype;
1992 struct dom_sid *sid;
1993
1994 ids[i] = SID_NAME_UNKNOWN;
1995
1996 sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rids[i]);
1997 if (sid == NULL) {
1998 names[i].string = NULL;
1999 status = STATUS_SOME_UNMAPPED;
2000 continue;
2001 }
2002
2003 count = gendb_search(d_state->sam_ctx, mem_ctx,
2004 d_state->domain_dn, &res, attrs,
2005 "(objectSid=%s)",
2006 ldap_encode_ndr_dom_sid(mem_ctx, sid));
2007 if (count != 1) {
2008 names[i].string = NULL;
2009 status = STATUS_SOME_UNMAPPED;
2010 continue;
2011 }
2012
2013 names[i].string = samdb_result_string(res[0], "sAMAccountName",
2014 NULL);
2015
2016 atype = samdb_result_uint(res[0], "sAMAccountType", 0);
2017 if (atype == 0) {
2018 status = STATUS_SOME_UNMAPPED;
2019 continue;
2020 }
2021
2022 ids[i] = samdb_atype_map(atype);
2023
2024 if (ids[i] == SID_NAME_UNKNOWN) {
2025 status = STATUS_SOME_UNMAPPED;
2026 continue;
2027 }
2028 }
2029
2030 r->out.names->names = names;
2031 r->out.names->count = r->in.num_rids;
2032
2033 r->out.types->ids = ids;
2034 r->out.types->count = r->in.num_rids;
2035
2036 return status;
2037 }
2038
2039
2040 /*
2041 samr_OpenGroup
2042 */
2043 static NTSTATUS dcesrv_samr_OpenGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2044 struct samr_OpenGroup *r)
2045 {
2046 struct samr_domain_state *d_state;
2047 struct samr_account_state *a_state;
2048 struct dcesrv_handle *h;
2049 const char *groupname;
2050 struct dom_sid *sid;
2051 struct ldb_message **msgs;
2052 struct dcesrv_handle *g_handle;
2053 const char * const attrs[2] = { "sAMAccountName", NULL };
2054 int ret;
2055
2056 ZERO_STRUCTP(r->out.group_handle);
2057
2058 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
2059
2060 d_state = h->data;
2061
2062 /* form the group SID */
2063 sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2064 if (!sid) {
2065 return NT_STATUS_NO_MEMORY;
2066 }
2067
2068 /* search for the group record */
2069 ret = gendb_search(d_state->sam_ctx,
2070 mem_ctx, d_state->domain_dn, &msgs, attrs,
2071 "(&(objectSid=%s)(objectclass=group)"
2072 "(grouptype=%d))",
2073 ldap_encode_ndr_dom_sid(mem_ctx, sid),
2074 GTYPE_SECURITY_GLOBAL_GROUP);
2075 if (ret == 0) {
2076 return NT_STATUS_NO_SUCH_GROUP;
2077 }
2078 if (ret != 1) {
2079 DEBUG(0,("Found %d records matching sid %s\n",
2080 ret, dom_sid_string(mem_ctx, sid)));
2081 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2082 }
2083
2084 groupname = samdb_result_string(msgs[0], "sAMAccountName", NULL);
2085 if (groupname == NULL) {
2086 DEBUG(0,("sAMAccountName field missing for sid %s\n",
2087 dom_sid_string(mem_ctx, sid)));
2088 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2089 }
2090
2091 a_state = talloc(d_state, struct samr_account_state);
2092 if (!a_state) {
2093 return NT_STATUS_NO_MEMORY;
2094 }
2095 a_state->sam_ctx = d_state->sam_ctx;
2096 a_state->access_mask = r->in.access_mask;
2097 a_state->domain_state = talloc_reference(a_state, d_state);
2098 a_state->account_dn = talloc_steal(a_state, msgs[0]->dn);
2099 a_state->account_sid = talloc_steal(a_state, sid);
2100 a_state->account_name = talloc_strdup(a_state, groupname);
2101 if (!a_state->account_name) {
2102 return NT_STATUS_NO_MEMORY;
2103 }
2104
2105 /* create the policy handle */
2106 g_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_GROUP);
2107 if (!g_handle) {
2108 return NT_STATUS_NO_MEMORY;
2109 }
2110
2111 g_handle->data = talloc_steal(g_handle, a_state);
2112
2113 *r->out.group_handle = g_handle->wire_handle;
2114
2115 return NT_STATUS_OK;
2116 }
2117
2118 /*
2119 samr_QueryGroupInfo
2120 */
2121 static NTSTATUS dcesrv_samr_QueryGroupInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2122 struct samr_QueryGroupInfo *r)
2123 {
2124 struct dcesrv_handle *h;
2125 struct samr_account_state *a_state;
2126 struct ldb_message *msg;
2127 struct ldb_result *res;
2128 const char * const attrs[4] = { "sAMAccountName", "description",
2129 "numMembers", NULL };
2130 int ret;
2131 union samr_GroupInfo *info;
2132
2133 *r->out.info = NULL;
2134
2135 DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2136
2137 a_state = h->data;
2138
2139 ret = ldb_search(a_state->sam_ctx, mem_ctx, &res, a_state->account_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=*");
2140
2141 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
2142 return NT_STATUS_NO_SUCH_GROUP;
2143 } else if (ret != LDB_SUCCESS) {
2144 DEBUG(2, ("Error reading group info: %s\n", ldb_errstring(a_state->sam_ctx)));
2145 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2146 }
2147
2148 if (res->count != 1) {
2149 DEBUG(2, ("Error finding group info, got %d entries\n", res->count));
2150
2151 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2152 }
2153 msg = res->msgs[0];
2154
2155 /* allocate the info structure */
2156 info = talloc_zero(mem_ctx, union samr_GroupInfo);
2157 if (info == NULL) {
2158 return NT_STATUS_NO_MEMORY;
2159 }
2160
2161 /* Fill in the level */
2162 switch (r->in.level) {
2163 case GROUPINFOALL:
2164 QUERY_STRING(msg, all.name, "sAMAccountName");
2165 info->all.attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED; /* Do like w2k3 */
2166 QUERY_UINT (msg, all.num_members, "numMembers")
2167 QUERY_STRING(msg, all.description, "description");
2168 break;
2169 case GROUPINFONAME:
2170 QUERY_STRING(msg, name, "sAMAccountName");
2171 break;
2172 case GROUPINFOATTRIBUTES:
2173 info->attributes.attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED; /* Do like w2k3 */
2174 break;
2175 case GROUPINFODESCRIPTION:
2176 QUERY_STRING(msg, description, "description");
2177 break;
2178 case GROUPINFOALL2:
2179 QUERY_STRING(msg, all2.name, "sAMAccountName");
2180 info->all.attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED; /* Do like w2k3 */
2181 QUERY_UINT (msg, all2.num_members, "numMembers")
2182 QUERY_STRING(msg, all2.description, "description");
2183 break;
2184 default:
2185 talloc_free(info);
2186 return NT_STATUS_INVALID_INFO_CLASS;
2187 }
2188
2189 *r->out.info = info;
2190
2191 return NT_STATUS_OK;
2192 }
2193
2194
2195 /*
2196 samr_SetGroupInfo
2197 */
2198 static NTSTATUS dcesrv_samr_SetGroupInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2199 struct samr_SetGroupInfo *r)
2200 {
2201 struct dcesrv_handle *h;
2202 struct samr_account_state *g_state;
2203 struct ldb_message *msg;
2204 struct ldb_context *sam_ctx;
2205 int ret;
2206
2207 DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2208
2209 g_state = h->data;
2210 sam_ctx = g_state->sam_ctx;
2211
2212 msg = ldb_msg_new(mem_ctx);
2213 if (msg == NULL) {
2214 return NT_STATUS_NO_MEMORY;
2215 }
2216
2217 msg->dn = ldb_dn_copy(mem_ctx, g_state->account_dn);
2218 if (!msg->dn) {
2219 return NT_STATUS_NO_MEMORY;
2220 }
2221
2222 switch (r->in.level) {
2223 case GROUPINFODESCRIPTION:
2224 SET_STRING(msg, description, "description");
2225 break;
2226 case GROUPINFONAME:
2227 /* On W2k3 this does not change the name, it changes the
2228 * sAMAccountName attribute */
2229 SET_STRING(msg, name, "sAMAccountName");
2230 break;
2231 case GROUPINFOATTRIBUTES:
2232 /* This does not do anything obviously visible in W2k3 LDAP */
2233 return NT_STATUS_OK;
2234 default:
2235 return NT_STATUS_INVALID_INFO_CLASS;
2236 }
2237
2238 /* modify the samdb record */
2239 ret = ldb_modify(g_state->sam_ctx, msg);
2240 if (ret != 0) {
2241 /* we really need samdb.c to return NTSTATUS */
2242 return NT_STATUS_UNSUCCESSFUL;
2243 }
2244
2245 return NT_STATUS_OK;
2246 }
2247
2248
2249 /*
2250 samr_AddGroupMember
2251 */
2252 static NTSTATUS dcesrv_samr_AddGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2253 struct samr_AddGroupMember *r)
2254 {
2255 struct dcesrv_handle *h;
2256 struct samr_account_state *a_state;
2257 struct samr_domain_state *d_state;
2258 struct ldb_message *mod;
2259 struct dom_sid *membersid;
2260 const char *memberdn;
2261 struct ldb_result *res;
2262 const char * const attrs[] = { NULL };
2263 int ret;
2264
2265 DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2266
2267 a_state = h->data;
2268 d_state = a_state->domain_state;
2269
2270 membersid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2271 if (membersid == NULL)
2272 return NT_STATUS_NO_MEMORY;
2273
2274 /* In native mode, AD can also nest domain groups. Not sure yet
2275 * whether this is also available via RPC. */
2276 ret = ldb_search(d_state->sam_ctx, mem_ctx, &res,
2277 d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs,
2278 "(&(objectSid=%s)(objectclass=user))",
2279 ldap_encode_ndr_dom_sid(mem_ctx, membersid));
2280
2281 if (ret != 0) {
2282 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2283 }
2284
2285 if (res->count == 0) {
2286 return NT_STATUS_NO_SUCH_USER;
2287 }
2288
2289 if (res->count > 1) {
2290 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2291 }
2292
2293 memberdn = ldb_dn_alloc_linearized(mem_ctx, res->msgs[0]->dn);
2294
2295 if (memberdn == NULL)
2296 return NT_STATUS_NO_MEMORY;
2297
2298 mod = ldb_msg_new(mem_ctx);
2299 if (mod == NULL) {
2300 return NT_STATUS_NO_MEMORY;
2301 }
2302
2303 mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2304
2305 if (samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
2306 memberdn) != 0)
2307 return NT_STATUS_UNSUCCESSFUL;
2308
2309 ret = ldb_modify(a_state->sam_ctx, mod);
2310 switch (ret) {
2311 case LDB_SUCCESS:
2312 return NT_STATUS_OK;
2313 case LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS:
2314 return NT_STATUS_MEMBER_IN_GROUP;
2315 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
2316 return NT_STATUS_ACCESS_DENIED;
2317 default:
2318 return NT_STATUS_UNSUCCESSFUL;
2319 }
2320
2321 }
2322
2323
2324 /*
2325 samr_DeleteDomainGroup
2326 */
2327 static NTSTATUS dcesrv_samr_DeleteDomainGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2328 struct samr_DeleteDomainGroup *r)
2329 {
2330 struct dcesrv_handle *h;
2331 struct samr_account_state *a_state;
2332 int ret;
2333
2334 *r->out.group_handle = *r->in.group_handle;
2335
2336 DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2337
2338 a_state = h->data;
2339
2340 ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
2341 if (ret != 0) {
2342 return NT_STATUS_UNSUCCESSFUL;
2343 }
2344
2345 ZERO_STRUCTP(r->out.group_handle);
2346
2347 return NT_STATUS_OK;
2348 }
2349
2350
2351 /*
2352 samr_DeleteGroupMember
2353 */
2354 static NTSTATUS dcesrv_samr_DeleteGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2355 struct samr_DeleteGroupMember *r)
2356 {
2357 struct dcesrv_handle *h;
2358 struct samr_account_state *a_state;
2359 struct samr_domain_state *d_state;
2360 struct ldb_message *mod;
2361 struct dom_sid *membersid;
2362 const char *memberdn;
2363 struct ldb_result *res;
2364 const char * const attrs[] = { NULL };
2365 int ret;
2366
2367 DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2368
2369 a_state = h->data;
2370 d_state = a_state->domain_state;
2371
2372 membersid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2373 if (membersid == NULL)
2374 return NT_STATUS_NO_MEMORY;
2375
2376 /* In native mode, AD can also nest domain groups. Not sure yet
2377 * whether this is also available via RPC. */
2378 ret = ldb_search(d_state->sam_ctx, mem_ctx, &res,
2379 d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs,
2380 "(&(objectSid=%s)(objectclass=user))",
2381 ldap_encode_ndr_dom_sid(mem_ctx, membersid));
2382
2383 if (ret != 0) {
2384 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2385 }
2386
2387 if (res->count == 0) {
2388 return NT_STATUS_NO_SUCH_USER;
2389 }
2390
2391 if (res->count > 1) {
2392 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2393 }
2394
2395 memberdn = ldb_dn_alloc_linearized(mem_ctx, res->msgs[0]->dn);
2396
2397 if (memberdn == NULL)
2398 return NT_STATUS_NO_MEMORY;
2399
2400 mod = ldb_msg_new(mem_ctx);
2401 if (mod == NULL) {
2402 return NT_STATUS_NO_MEMORY;
2403 }
2404
2405 mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2406
2407 if (samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
2408 memberdn) != 0) {
2409 return NT_STATUS_NO_MEMORY;
2410 }
2411
2412 ret = ldb_modify(a_state->sam_ctx, mod);
2413 switch (ret) {
2414 case LDB_SUCCESS:
2415 return NT_STATUS_OK;
2416 case LDB_ERR_NO_SUCH_ATTRIBUTE:
2417 return NT_STATUS_MEMBER_NOT_IN_GROUP;
2418 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
2419 return NT_STATUS_ACCESS_DENIED;
2420 default:
2421 return NT_STATUS_UNSUCCESSFUL;
2422 }
2423
2424 }
2425
2426
2427 /*
2428 samr_QueryGroupMember
2429 */
2430 static NTSTATUS dcesrv_samr_QueryGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2431 struct samr_QueryGroupMember *r)
2432 {
2433 struct dcesrv_handle *h;
2434 struct samr_account_state *a_state;
2435 struct ldb_message **res;
2436 struct ldb_message_element *el;
2437 struct samr_RidTypeArray *array;
2438 const char * const attrs[2] = { "member", NULL };
2439 int ret;
2440
2441 DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2442
2443 a_state = h->data;
2444
2445 /* pull the member attribute */
2446 ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2447 a_state->account_dn, &res, attrs);
2448
2449 if (ret != 1) {
2450 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2451 }
2452
2453 array = talloc(mem_ctx, struct samr_RidTypeArray);
2454
2455 if (array == NULL)
2456 return NT_STATUS_NO_MEMORY;
2457
2458 ZERO_STRUCTP(array);
2459
2460 el = ldb_msg_find_element(res[0], "member");
2461
2462 if (el != NULL) {
2463 int i;
2464
2465 array->count = el->num_values;
2466
2467 array->rids = talloc_array(mem_ctx, uint32_t,
2468 el->num_values);
2469 if (array->rids == NULL)
2470 return NT_STATUS_NO_MEMORY;
2471
2472 array->types = talloc_array(mem_ctx, uint32_t,
2473 el->num_values);
2474 if (array->types == NULL)
2475 return NT_STATUS_NO_MEMORY;
2476
2477 for (i=0; i<el->num_values; i++) {
2478 struct ldb_message **res2;
2479 const char * const attrs2[2] = { "objectSid", NULL };
2480 ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2481 ldb_dn_from_ldb_val(mem_ctx, a_state->sam_ctx, &el->values[i]),
2482 &res2, attrs2);
2483 if (ret != 1)
2484 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2485
2486 array->rids[i] =
2487 samdb_result_rid_from_sid(mem_ctx, res2[0],
2488 "objectSid", 0);
2489
2490 if (array->rids[i] == 0)
2491 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2492
2493 array->types[i] = 7; /* RID type of some kind, not sure what the value means. */
2494 }
2495 }
2496
2497 *r->out.rids = array;
2498
2499 return NT_STATUS_OK;
2500 }
2501
2502
2503 /*
2504 samr_SetMemberAttributesOfGroup
2505 */
2506 static NTSTATUS dcesrv_samr_SetMemberAttributesOfGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2507 struct samr_SetMemberAttributesOfGroup *r)
2508 {
2509 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2510 }
2511
2512
2513 /*
2514 samr_OpenAlias
2515 */
2516 static NTSTATUS dcesrv_samr_OpenAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2517 struct samr_OpenAlias *r)
2518 {
2519 struct samr_domain_state *d_state;
2520 struct samr_account_state *a_state;
2521 struct dcesrv_handle *h;
2522 const char *alias_name;
2523 struct dom_sid *sid;
2524 struct ldb_message **msgs;
2525 struct dcesrv_handle *g_handle;
2526 const char * const attrs[2] = { "sAMAccountName", NULL };
2527 int ret;
2528
2529 ZERO_STRUCTP(r->out.alias_handle);
2530
2531 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
2532
2533 d_state = h->data;
2534
2535 /* form the alias SID */
2536 sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2537 if (sid == NULL)
2538 return NT_STATUS_NO_MEMORY;
2539
2540 /* search for the group record */
2541 ret = gendb_search(d_state->sam_ctx,
2542 mem_ctx, d_state->domain_dn, &msgs, attrs,
2543 "(&(objectSid=%s)(objectclass=group)"
2544 "(|(grouptype=%d)(grouptype=%d)))",
2545 ldap_encode_ndr_dom_sid(mem_ctx, sid),
2546 GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
2547 GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
2548 if (ret == 0) {
2549 return NT_STATUS_NO_SUCH_ALIAS;
2550 }
2551 if (ret != 1) {
2552 DEBUG(0,("Found %d records matching sid %s\n",
2553 ret, dom_sid_string(mem_ctx, sid)));
2554 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2555 }
2556
2557 alias_name = samdb_result_string(msgs[0], "sAMAccountName", NULL);
2558 if (alias_name == NULL) {
2559 DEBUG(0,("sAMAccountName field missing for sid %s\n",
2560 dom_sid_string(mem_ctx, sid)));
2561 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2562 }
2563
2564 a_state = talloc(d_state, struct samr_account_state);
2565 if (!a_state) {
2566 return NT_STATUS_NO_MEMORY;
2567 }
2568 a_state->sam_ctx = d_state->sam_ctx;
2569 a_state->access_mask = r->in.access_mask;
2570 a_state->domain_state = talloc_reference(a_state, d_state);
2571 a_state->account_dn = talloc_steal(a_state, msgs[0]->dn);
2572 a_state->account_sid = talloc_steal(a_state, sid);
2573 a_state->account_name = talloc_strdup(a_state, alias_name);
2574 if (!a_state->account_name) {
2575 return NT_STATUS_NO_MEMORY;
2576 }
2577
2578 /* create the policy handle */
2579 g_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_ALIAS);
2580 if (!g_handle) {
2581 return NT_STATUS_NO_MEMORY;
2582 }
2583
2584 g_handle->data = talloc_steal(g_handle, a_state);
2585
2586 *r->out.alias_handle = g_handle->wire_handle;
2587
2588 return NT_STATUS_OK;
2589 }
2590
2591
2592 /*
2593 samr_QueryAliasInfo
2594 */
2595 static NTSTATUS dcesrv_samr_QueryAliasInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2596 struct samr_QueryAliasInfo *r)
2597 {
2598 struct dcesrv_handle *h;
2599 struct samr_account_state *a_state;
2600 struct ldb_message *msg, **res;
2601 const char * const attrs[4] = { "sAMAccountName", "description",
2602 "numMembers", NULL };
2603 int ret;
2604 union samr_AliasInfo *info;
2605
2606 *r->out.info = NULL;
2607
2608 DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2609
2610 a_state = h->data;
2611
2612 /* pull all the alias attributes */
2613 ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2614 a_state->account_dn ,&res, attrs);
2615 if (ret != 1) {
2616 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2617 }
2618 msg = res[0];
2619
2620 /* allocate the info structure */
2621 info = talloc_zero(mem_ctx, union samr_AliasInfo);
2622 if (info == NULL) {
2623 return NT_STATUS_NO_MEMORY;
2624 }
2625
2626 switch(r->in.level) {
2627 case ALIASINFOALL:
2628 QUERY_STRING(msg, all.name, "sAMAccountName");
2629 QUERY_UINT (msg, all.num_members, "numMembers");
2630 QUERY_STRING(msg, all.description, "description");
2631 break;
2632 case ALIASINFONAME:
2633 QUERY_STRING(msg, name, "sAMAccountName");
2634 break;
2635 case ALIASINFODESCRIPTION:
2636 QUERY_STRING(msg, description, "description");
2637 break;
2638 default:
2639 talloc_free(info);
2640 return NT_STATUS_INVALID_INFO_CLASS;
2641 }
2642
2643 *r->out.info = info;
2644
2645 return NT_STATUS_OK;
2646 }
2647
2648
2649 /*
2650 samr_SetAliasInfo
2651 */
2652 static NTSTATUS dcesrv_samr_SetAliasInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2653 struct samr_SetAliasInfo *r)
2654 {
2655 struct dcesrv_handle *h;
2656 struct samr_account_state *a_state;
2657 struct ldb_message *msg;
2658 struct ldb_context *sam_ctx;
2659 int ret;
2660
2661 DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2662
2663 a_state = h->data;
2664 sam_ctx = a_state->sam_ctx;
2665
2666 msg = ldb_msg_new(mem_ctx);
2667 if (msg == NULL) {
2668 return NT_STATUS_NO_MEMORY;
2669 }
2670
2671 msg->dn = ldb_dn_copy(mem_ctx, a_state->account_dn);
2672 if (!msg->dn) {
2673 return NT_STATUS_NO_MEMORY;
2674 }
2675
2676 switch (r->in.level) {
2677 case ALIASINFODESCRIPTION:
2678 SET_STRING(msg, description, "description");
2679 break;
2680 case ALIASINFONAME:
2681 /* On W2k3 this does not change the name, it changes the
2682 * sAMAccountName attribute */
2683 SET_STRING(msg, name, "sAMAccountName");
2684 break;
2685 default:
2686 return NT_STATUS_INVALID_INFO_CLASS;
2687 }
2688
2689 /* modify the samdb record */
2690 ret = ldb_modify(a_state->sam_ctx, msg);
2691 if (ret != 0) {
2692 /* we really need samdb.c to return NTSTATUS */
2693 return NT_STATUS_UNSUCCESSFUL;
2694 }
2695
2696 return NT_STATUS_OK;
2697 }
2698
2699
2700 /*
2701 samr_DeleteDomAlias
2702 */
2703 static NTSTATUS dcesrv_samr_DeleteDomAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2704 struct samr_DeleteDomAlias *r)
2705 {
2706 struct dcesrv_handle *h;
2707 struct samr_account_state *a_state;
2708 int ret;
2709
2710 *r->out.alias_handle = *r->in.alias_handle;
2711
2712 DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2713
2714 a_state = h->data;
2715
2716 ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
2717 if (ret != 0) {
2718 return NT_STATUS_UNSUCCESSFUL;
2719 }
2720
2721 ZERO_STRUCTP(r->out.alias_handle);
2722
2723 return NT_STATUS_OK;
2724 }
2725
2726
2727 /*
2728 samr_AddAliasMember
2729 */
2730 static NTSTATUS dcesrv_samr_AddAliasMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2731 struct samr_AddAliasMember *r)
2732 {
2733 struct dcesrv_handle *h;
2734 struct samr_account_state *a_state;
2735 struct samr_domain_state *d_state;
2736 struct ldb_message *mod;
2737 struct ldb_message **msgs;
2738 const char * const attrs[] = { NULL };
2739 struct ldb_dn *memberdn = NULL;
2740 int ret;
2741 NTSTATUS status;
2742
2743 DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2744
2745 a_state = h->data;
2746 d_state = a_state->domain_state;
2747
2748 ret = gendb_search(d_state->sam_ctx, mem_ctx, NULL,
2749 &msgs, attrs, "(objectsid=%s)",
2750 ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
2751
2752 if (ret == 1) {
2753 memberdn = msgs[0]->dn;
2754 } else if (ret > 1) {
2755 DEBUG(0,("Found %d records matching sid %s\n",
2756 ret, dom_sid_string(mem_ctx, r->in.sid)));
2757 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2758 } else if (ret == 0) {
2759 status = samdb_create_foreign_security_principal(d_state->sam_ctx, mem_ctx,
2760 r->in.sid, &memberdn);
2761 if (!NT_STATUS_IS_OK(status)) {
2762 return status;
2763 }
2764 } else {
2765 DEBUG(0, ("samdb_search returned %d: %s\n", ret, ldb_errstring(d_state->sam_ctx)));
2766 }
2767
2768 if (memberdn == NULL) {
2769 DEBUG(0, ("Could not find memberdn\n"));
2770 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2771 }
2772
2773 mod = ldb_msg_new(mem_ctx);
2774 if (mod == NULL) {
2775 return NT_STATUS_NO_MEMORY;
2776 }
2777
2778 mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2779
2780 if (samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
2781 ldb_dn_alloc_linearized(mem_ctx, memberdn)) != 0)
2782 return NT_STATUS_UNSUCCESSFUL;
2783
2784 if (ldb_modify(a_state->sam_ctx, mod) != 0)
2785 return NT_STATUS_UNSUCCESSFUL;
2786
2787 return NT_STATUS_OK;
2788 }
2789
2790
2791 /*
2792 samr_DeleteAliasMember
2793 */
2794 static NTSTATUS dcesrv_samr_DeleteAliasMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2795 struct samr_DeleteAliasMember *r)
2796 {
2797 struct dcesrv_handle *h;
2798 struct samr_account_state *a_state;
2799 struct samr_domain_state *d_state;
2800 struct ldb_message *mod;
2801 const char *memberdn;
2802
2803 DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2804
2805 a_state = h->data;
2806 d_state = a_state->domain_state;
2807
2808 memberdn = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
2809 "distinguishedName", "(objectSid=%s)",
2810 ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
2811
2812 if (memberdn == NULL)
2813 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2814
2815 mod = ldb_msg_new(mem_ctx);
2816 if (mod == NULL) {
2817 return NT_STATUS_NO_MEMORY;
2818 }
2819
2820 mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2821
2822 if (samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
2823 memberdn) != 0)
2824 return NT_STATUS_UNSUCCESSFUL;
2825
2826 if (ldb_modify(a_state->sam_ctx, mod) != 0)
2827 return NT_STATUS_UNSUCCESSFUL;
2828
2829 return NT_STATUS_OK;
2830 }
2831
2832
2833 /*
2834 samr_GetMembersInAlias
2835 */
2836 static NTSTATUS dcesrv_samr_GetMembersInAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2837 struct samr_GetMembersInAlias *r)
2838 {
2839 struct dcesrv_handle *h;
2840 struct samr_account_state *a_state;
2841 struct samr_domain_state *d_state;
2842 struct ldb_message **msgs;
2843 struct lsa_SidPtr *sids;
2844 struct ldb_message_element *el;
2845 const char * const attrs[2] = { "member", NULL};
2846 int ret;
2847
2848 DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2849
2850 a_state = h->data;
2851 d_state = a_state->domain_state;
2852
2853 ret = gendb_search_dn(d_state->sam_ctx, mem_ctx,
2854 a_state->account_dn, &msgs, attrs);
2855
2856 if (ret == -1) {
2857 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2858 } else if (ret == 0) {
2859 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2860 } else if (ret != 1) {
2861 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2862 }
2863
2864 r->out.sids->num_sids = 0;
2865 r->out.sids->sids = NULL;
2866
2867 el = ldb_msg_find_element(msgs[0], "member");
2868
2869 if (el != NULL) {
2870 int i;
2871
2872 sids = talloc_array(mem_ctx, struct lsa_SidPtr,
2873 el->num_values);
2874
2875 if (sids == NULL)
2876 return NT_STATUS_NO_MEMORY;
2877
2878 for (i=0; i<el->num_values; i++) {
2879 struct ldb_message **msgs2;
2880 const char * const attrs2[2] = { "objectSid", NULL };
2881 ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2882 ldb_dn_from_ldb_val(mem_ctx, a_state->sam_ctx, &el->values[i]),
2883 &msgs2, attrs2);
2884 if (ret != 1)
2885 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2886
2887 sids[i].sid = samdb_result_dom_sid(mem_ctx, msgs2[0],
2888 "objectSid");
2889
2890 if (sids[i].sid == NULL)
2891 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2892 }
2893 r->out.sids->num_sids = el->num_values;
2894 r->out.sids->sids = sids;
2895 }
2896
2897 return NT_STATUS_OK;
2898 }
2899
2900 /*
2901 samr_OpenUser
2902 */
2903 static NTSTATUS dcesrv_samr_OpenUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2904 struct samr_OpenUser *r)
2905 {
2906 struct samr_domain_state *d_state;
2907 struct samr_account_state *a_state;
2908 struct dcesrv_handle *h;
2909 const char *account_name;
2910 struct dom_sid *sid;
2911 struct ldb_message **msgs;
2912 struct dcesrv_handle *u_handle;
2913 const char * const attrs[2] = { "sAMAccountName", NULL };
2914 int ret;
2915
2916 ZERO_STRUCTP(r->out.user_handle);
2917
2918 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
2919
2920 d_state = h->data;
2921
2922 /* form the users SID */
2923 sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2924 if (!sid) {
2925 return NT_STATUS_NO_MEMORY;
2926 }
2927
2928 /* search for the user record */
2929 ret = gendb_search(d_state->sam_ctx,
2930 mem_ctx, d_state->domain_dn, &msgs, attrs,
2931 "(&(objectSid=%s)(objectclass=user))",
2932 ldap_encode_ndr_dom_sid(mem_ctx, sid));
2933 if (ret == 0) {
2934 return NT_STATUS_NO_SUCH_USER;
2935 }
2936 if (ret != 1) {
2937 DEBUG(0,("Found %d records matching sid %s\n", ret,
2938 dom_sid_string(mem_ctx, sid)));
2939 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2940 }
2941
2942 account_name = samdb_result_string(msgs[0], "sAMAccountName", NULL);
2943 if (account_name == NULL) {
2944 DEBUG(0,("sAMAccountName field missing for sid %s\n",
2945 dom_sid_string(mem_ctx, sid)));
2946 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2947 }
2948
2949 a_state = talloc(mem_ctx, struct samr_account_state);
2950 if (!a_state) {
2951 return NT_STATUS_NO_MEMORY;
2952 }
2953 a_state->sam_ctx = d_state->sam_ctx;
2954 a_state->access_mask = r->in.access_mask;
2955 a_state->domain_state = talloc_reference(a_state, d_state);
2956 a_state->account_dn = talloc_steal(a_state, msgs[0]->dn);
2957 a_state->account_sid = talloc_steal(a_state, sid);
2958 a_state->account_name = talloc_strdup(a_state, account_name);
2959 if (!a_state->account_name) {
2960 return NT_STATUS_NO_MEMORY;
2961 }
2962
2963 /* create the policy handle */
2964 u_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_USER);
2965 if (!u_handle) {
2966 return NT_STATUS_NO_MEMORY;
2967 }
2968
2969 u_handle->data = talloc_steal(u_handle, a_state);
2970
2971 *r->out.user_handle = u_handle->wire_handle;
2972
2973 return NT_STATUS_OK;
2974
2975 }
2976
2977
2978 /*
2979 samr_DeleteUser
2980 */
2981 static NTSTATUS dcesrv_samr_DeleteUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2982 struct samr_DeleteUser *r)
2983 {
2984 struct dcesrv_handle *h;
2985 struct samr_account_state *a_state;
2986 int ret;
2987
2988 *r->out.user_handle = *r->in.user_handle;
2989
2990 DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
2991
2992 a_state = h->data;
2993
2994 ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
2995 if (ret != 0) {
2996 DEBUG(1, ("Failed to delete user: %s: %s\n",
2997 ldb_dn_get_linearized(a_state->account_dn),
2998 ldb_errstring(a_state->sam_ctx)));
2999 return NT_STATUS_UNSUCCESSFUL;
3000 }
3001
3002 ZERO_STRUCTP(r->out.user_handle);
3003
3004 return NT_STATUS_OK;
3005 }
3006
3007
3008 /*
3009 samr_QueryUserInfo
3010 */
3011 static NTSTATUS dcesrv_samr_QueryUserInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3012 struct samr_QueryUserInfo *r)
3013 {
3014 struct dcesrv_handle *h;
3015 struct samr_account_state *a_state;
3016 struct ldb_message *msg, **res;
3017 int ret;
3018 struct ldb_context *sam_ctx;
3019
3020 const char * const *attrs = NULL;
3021 union samr_UserInfo *info;
3022
3023 *r->out.info = NULL;
3024
3025 DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3026
3027 a_state = h->data;
3028 sam_ctx = a_state->sam_ctx;
3029
3030 /* fill in the reply */
3031 switch (r->in.level) {
3032 case 1:
3033 {
3034 static const char * const attrs2[] = {"sAMAccountName", "displayName",
3035 "primaryroupID", "description",
3036 "comment", NULL};
3037 attrs = attrs2;
3038 break;
3039 }
3040 case 2:
3041 {
3042 static const char * const attrs2[] = {"comment", "countryCode", "codePage", NULL};
3043 attrs = attrs2;
3044 break;
3045 }
3046 case 3:
3047 {
3048 static const char * const attrs2[] = {"sAMAccountName",
3049 "displayName",
3050 "objectSid",
3051 "primaryGroupID",
3052 "homeDirectory",
3053 "homeDrive",
3054 "scriptPath",
3055 "profilePath",
3056 "userWorkstations",
3057 "lastLogon",
3058 "lastLogoff",
3059 "pwdLastSet",
3060 "logonHours",
3061 "badPwdCount",
3062 "logonCount",
3063 "userAccountControl", NULL};
3064 attrs = attrs2;
3065 break;
3066 }
3067 case 4:
3068 {
3069 static const char * const attrs2[] = {"logonHours", NULL};
3070 attrs = attrs2;
3071 break;
3072 }
3073 case 5:
3074 {
3075 static const char * const attrs2[] = {"sAMAccountName",
3076 "displayName",
3077 "objectSid",
3078 "primaryGroupID",
3079 "homeDirectory",
3080 "homeDrive",
3081 "scriptPath",
3082 "profilePath",
3083 "description",
3084 "userWorkstations",
3085 "lastLogon",
3086 "lastLogoff",
3087 "logonHours",
3088 "badPwdCount",
3089 "logonCount",
3090 "pwdLastSet",
3091 "accountExpires",
3092 "userAccountControl",
3093 NULL};
3094 attrs = attrs2;
3095 break;
3096 }
3097 case 6:
3098 {
3099 static const char * const attrs2[] = {"sAMAccountName", "displayName", NULL};
3100 attrs = attrs2;
3101 break;
3102 }
3103 case 7:
3104 {
3105 static const char * const attrs2[] = {"sAMAccountName", NULL};
3106 attrs = attrs2;
3107 break;
3108 }
3109 case 8:
3110 {
3111 static const char * const attrs2[] = {"displayName", NULL};
3112 attrs = attrs2;
3113 break;
3114 }
3115 case 9:
3116 {
3117 static const char * const attrs2[] = {"primaryGroupID", NULL};
3118 attrs = attrs2;
3119 break;
3120 }
3121 case 10:
3122 {
3123 static const char * const attrs2[] = {"homeDirectory", "homeDrive", NULL};
3124 attrs = attrs2;
3125 break;
3126 }
3127 case 11:
3128 {
3129 static const char * const attrs2[] = {"scriptPath", NULL};
3130 attrs = attrs2;
3131 break;
3132 }
3133 case 12:
3134 {
3135 static const char * const attrs2[] = {"profilePath", NULL};
3136 attrs = attrs2;
3137 break;
3138 }
3139 case 13:
3140 {
3141 static const char * const attrs2[] = {"description", NULL};
3142 attrs = attrs2;
3143 break;
3144 }
3145 case 14:
3146 {
3147 static const char * const attrs2[] = {"userWorkstations", NULL};
3148 attrs = attrs2;
3149 break;
3150 }
3151 case 16:
3152 {
3153 static const char * const attrs2[] = {"userAccountControl", "pwdLastSet", NULL};
3154 attrs = attrs2;
3155 break;
3156 }
3157 case 17:
3158 {
3159 static const char * const attrs2[] = {"accountExpires", NULL};
3160 attrs = attrs2;
3161 break;
3162 }
3163 case 20:
3164 {
3165 static const char * const attrs2[] = {"userParameters", NULL};
3166 attrs = attrs2;
3167 break;
3168 }
3169 case 21:
3170 {
3171 static const char * const attrs2[] = {"lastLogon",
3172 "lastLogoff",
3173 "pwdLastSet",
3174 "accountExpires",
3175 "sAMAccountName",
3176 "displayName",
3177 "homeDirectory",
3178 "homeDrive",
3179 "scriptPath",
3180 "profilePath",
3181 "description",
3182 "userWorkstations",
3183 "comment",
3184 "userParameters",
3185 "objectSid",
3186 "primaryGroupID",
3187 "userAccountControl",
3188 "logonHours",
3189 "badPwdCount",
3190 "logonCount",
3191 "countryCode",
3192 "codePage",
3193 NULL};
3194 attrs = attrs2;
3195 break;
3196 }
3197 }
3198
3199 /* pull all the user attributes */
3200 ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
3201 a_state->account_dn ,&res, attrs);
3202 if (ret != 1) {
3203 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3204 }
3205 msg = res[0];
3206
3207 /* allocate the info structure */
3208 info = talloc_zero(mem_ctx, union samr_UserInfo);
3209 if (info == NULL) {
3210 return NT_STATUS_NO_MEMORY;
3211 }
3212
3213 /* fill in the reply */
3214 switch (r->in.level) {
3215 case 1:
3216 QUERY_STRING(msg, info1.account_name, "sAMAccountName");
3217 QUERY_STRING(msg, info1.full_name, "displayName");
3218 QUERY_UINT (msg, info1.primary_gid, "primaryGroupID");
3219 QUERY_STRING(msg, info1.description, "description");
3220 QUERY_STRING(msg, info1.comment, "comment");
3221 break;
3222
3223 case 2:
3224 QUERY_STRING(msg, info2.comment, "comment");
3225 QUERY_UINT (msg, info2.country_code, "countryCode");
3226 QUERY_UINT (msg, info2.code_page, "codePage");
3227 break;
3228
3229 case 3:
3230 QUERY_STRING(msg, info3.account_name, "sAMAccountName");
3231 QUERY_STRING(msg, info3.full_name, "displayName");
3232 QUERY_RID (msg, info3.rid, "objectSid");
3233 QUERY_UINT (msg, info3.primary_gid, "primaryGroupID");
3234 QUERY_STRING(msg, info3.home_directory, "homeDirectory");
3235 QUERY_STRING(msg, info3.home_drive, "homeDrive");
3236 QUERY_STRING(msg, info3.logon_script, "scriptPath");
3237 QUERY_STRING(msg, info3.profile_path, "profilePath");
3238 QUERY_STRING(msg, info3.workstations, "userWorkstations");
3239 QUERY_UINT64(msg, info3.last_logon, "lastLogon");
3240 QUERY_UINT64(msg, info3.last_logoff, "lastLogoff");
3241 QUERY_UINT64(msg, info3.last_password_change, "pwdLastSet");
3242 QUERY_APASSC(msg, info3.allow_password_change, "pwdLastSet");
3243 QUERY_FPASSC(msg, info3.force_password_change, "pwdLastSet");
3244 QUERY_LHOURS(msg, info3.logon_hours, "logonHours");
3245 QUERY_UINT (msg, info3.bad_password_count, "badPwdCount");
3246 QUERY_UINT (msg, info3.logon_count, "logonCount");
3247 QUERY_AFLAGS(msg, info3.acct_flags, "userAccountControl");
3248 break;
3249
3250 case 4:
3251 QUERY_LHOURS(msg, info4.logon_hours, "logonHours");
3252 break;
3253
3254 case 5:
3255 QUERY_STRING(msg, info5.account_name, "sAMAccountName");
3256 QUERY_STRING(msg, info5.full_name, "displayName");
3257 QUERY_RID (msg, info5.rid, "objectSid");
3258 QUERY_UINT (msg, info5.primary_gid, "primaryGroupID");
3259 QUERY_STRING(msg, info5.home_directory, "homeDirectory");
3260 QUERY_STRING(msg, info5.home_drive, "homeDrive");
3261 QUERY_STRING(msg, info5.logon_script, "scriptPath");
3262 QUERY_STRING(msg, info5.profile_path, "profilePath");
3263 QUERY_STRING(msg, info5.description, "description");
3264 QUERY_STRING(msg, info5.workstations, "userWorkstations");
3265 QUERY_UINT64(msg, info5.last_logon, "lastLogon");
3266 QUERY_UINT64(msg, info5.last_logoff, "lastLogoff");
3267 QUERY_LHOURS(msg, info5.logon_hours, "logonHours");
3268 QUERY_UINT (msg, info5.bad_password_count, "badPwdCount");
3269 QUERY_UINT (msg, info5.logon_count, "logonCount");
3270 QUERY_UINT64(msg, info5.last_password_change, "pwdLastSet");
3271 QUERY_UINT64(msg, info5.acct_expiry, "accountExpires");
3272 QUERY_AFLAGS(msg, info5.acct_flags, "userAccountControl");
3273 break;
3274
3275 case 6:
3276 QUERY_STRING(msg, info6.account_name, "sAMAccountName");
3277 QUERY_STRING(msg, info6.full_name, "displayName");
3278 break;
3279
3280 case 7:
3281 QUERY_STRING(msg, info7.account_name, "sAMAccountName");
3282 break;
3283
3284 case 8:
3285 QUERY_STRING(msg, info8.full_name, "displayName");
3286 break;
3287
3288 case 9:
3289 QUERY_UINT (msg, info9.primary_gid, "primaryGroupID");
3290 break;
3291
3292 case 10:
3293 QUERY_STRING(msg, info10.home_directory,"homeDirectory");
3294 QUERY_STRING(msg, info10.home_drive, "homeDrive");
3295 break;
3296
3297 case 11:
3298 QUERY_STRING(msg, info11.logon_script, "scriptPath");
3299 break;
3300
3301 case 12:
3302 QUERY_STRING(msg, info12.profile_path, "profilePath");
3303 break;
3304
3305 case 13:
3306 QUERY_STRING(msg, info13.description, "description");
3307 break;
3308
3309 case 14:
3310 QUERY_STRING(msg, info14.workstations, "userWorkstations");
3311 break;
3312
3313 case 16:
3314 QUERY_AFLAGS(msg, info16.acct_flags, "userAccountControl");
3315 break;
3316
3317 case 17:
3318 QUERY_UINT64(msg, info17.acct_expiry, "accountExpires");
3319 break;
3320
3321 case 20:
3322 QUERY_PARAMETERS(msg, info20.parameters, "userParameters");
3323 break;
3324
3325 case 21:
3326 QUERY_UINT64(msg, info21.last_logon, "lastLogon");
3327 QUERY_UINT64(msg, info21.last_logoff, "lastLogoff");
3328 QUERY_UINT64(msg, info21.last_password_change, "pwdLastSet");
3329 QUERY_UINT64(msg, info21.acct_expiry, "accountExpires");
3330 QUERY_APASSC(msg, info21.allow_password_change,"pwdLastSet");
3331 QUERY_FPASSC(msg, info21.force_password_change,"pwdLastSet");
3332 QUERY_STRING(msg, info21.account_name, "sAMAccountName");
3333 QUERY_STRING(msg, info21.full_name, "displayName");
3334 QUERY_STRING(msg, info21.home_directory, "homeDirectory");
3335 QUERY_STRING(msg, info21.home_drive, "homeDrive");
3336 QUERY_STRING(msg, info21.logon_script, "scriptPath");
3337 QUERY_STRING(msg, info21.profile_path, "profilePath");
3338 QUERY_STRING(msg, info21.description, "description");
3339 QUERY_STRING(msg, info21.workstations, "userWorkstations");
3340 QUERY_STRING(msg, info21.comment, "comment");
3341 QUERY_PARAMETERS(msg, info21.parameters, "userParameters");
3342 QUERY_RID (msg, info21.rid, "objectSid");
3343 QUERY_UINT (msg, info21.primary_gid, "primaryGroupID");
3344 QUERY_AFLAGS(msg, info21.acct_flags, "userAccountControl");
3345 info->info21.fields_present = 0x00FFFFFF;
3346 QUERY_LHOURS(msg, info21.logon_hours, "logonHours");
3347 QUERY_UINT (msg, info21.bad_password_count, "badPwdCount");
3348 QUERY_UINT (msg, info21.logon_count, "logonCount");
3349 QUERY_UINT (msg, info21.country_code, "countryCode");
3350 QUERY_UINT (msg, info21.code_page, "codePage");
3351 break;
3352
3353
3354 default:
3355 talloc_free(info);
3356 return NT_STATUS_INVALID_INFO_CLASS;
3357 }
3358
3359 *r->out.info = info;
3360
3361 return NT_STATUS_OK;
3362 }
3363
3364
3365 /*
3366 samr_SetUserInfo
3367 */
3368 static NTSTATUS dcesrv_samr_SetUserInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3369 struct samr_SetUserInfo *r)
3370 {
3371 struct dcesrv_handle *h;
3372 struct samr_account_state *a_state;
3373 struct ldb_message *msg;
3374 int ret;
3375 NTSTATUS status = NT_STATUS_OK;
3376 struct ldb_context *sam_ctx;
3377
3378 DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3379
3380 a_state = h->data;
3381 sam_ctx = a_state->sam_ctx;
3382
3383 msg = ldb_msg_new(mem_ctx);
3384 if (msg == NULL) {
3385 return NT_STATUS_NO_MEMORY;
3386 }
3387
3388 msg->dn = talloc_reference(mem_ctx, a_state->account_dn);
3389 if (!msg->dn) {
3390 return NT_STATUS_NO_MEMORY;
3391 }
3392
3393 switch (r->in.level) {
3394 case 2:
3395 SET_STRING(msg, info2.comment, "comment");
3396 SET_UINT (msg, info2.country_code, "countryCode");
3397 SET_UINT (msg, info2.code_page, "codePage");
3398 break;
3399
3400 case 4:
3401 SET_LHOURS(msg, info4.logon_hours, "logonHours");
3402 break;
3403
3404 case 6:
3405 SET_STRING(msg, info6.full_name, "displayName");
3406 break;
3407
3408 case 7:
3409 SET_STRING(msg, info7.account_name, "samAccountName");
3410 break;
3411
3412 case 8:
3413 SET_STRING(msg, info8.full_name, "displayName");
3414 break;
3415
3416 case 9:
3417 SET_UINT(msg, info9.primary_gid, "primaryGroupID");
3418 break;
3419
3420 case 10:
3421 SET_STRING(msg, info10.home_directory, "homeDirectory");
3422 SET_STRING(msg, info10.home_drive, "homeDrive");
3423 break;
3424
3425 case 11:
3426 SET_STRING(msg, info11.logon_script, "scriptPath");
3427 break;
3428
3429 case 12:
3430 SET_STRING(msg, info12.profile_path, "profilePath");
3431 break;
3432
3433 case 13:
3434 SET_STRING(msg, info13.description, "description");
3435 break;
3436
3437 case 14:
3438 SET_STRING(msg, info14.workstations, "userWorkstations");
3439 break;
3440
3441 case 16:
3442 SET_AFLAGS(msg, info16.acct_flags, "userAccountControl");
3443 break;
3444
3445 case 17:
3446 SET_UINT64(msg, info17.acct_expiry, "accountExpires");
3447 break;
3448
3449 case 20:
3450 SET_PARAMETERS(msg, info20.parameters, "userParameters");
3451 break;
3452
3453 case 21:
3454 #define IFSET(bit) if (bit & r->in.info->info21.fields_present)
3455 IFSET(SAMR_FIELD_ACCT_EXPIRY)
3456 SET_UINT64(msg, info21.acct_expiry, "accountExpires");
3457 IFSET(SAMR_FIELD_ACCOUNT_NAME)
3458 SET_STRING(msg, info21.account_name, "samAccountName");
3459 IFSET(SAMR_FIELD_FULL_NAME)
3460 SET_STRING(msg, info21.full_name, "displayName");
3461 IFSET(SAMR_FIELD_DESCRIPTION)
3462 SET_STRING(msg, info21.description, "description");
3463 IFSET(SAMR_FIELD_COMMENT)
3464 SET_STRING(msg, info21.comment, "comment");
3465 IFSET(SAMR_FIELD_LOGON_SCRIPT)
3466 SET_STRING(msg, info21.logon_script, "scriptPath");
3467 IFSET(SAMR_FIELD_PROFILE_PATH)
3468 SET_STRING(msg, info21.profile_path, "profilePath");
3469 IFSET(SAMR_FIELD_HOME_DIRECTORY)
3470 SET_STRING(msg, info21.home_directory, "homeDirectory");
3471 IFSET(SAMR_FIELD_HOME_DRIVE)
3472 SET_STRING(msg, info21.home_drive, "homeDrive");
3473 IFSET(SAMR_FIELD_WORKSTATIONS)
3474 SET_STRING(msg, info21.workstations, "userWorkstations");
3475 IFSET(SAMR_FIELD_LOGON_HOURS)
3476 SET_LHOURS(msg, info21.logon_hours, "logonHours");
3477 IFSET(SAMR_FIELD_ACCT_FLAGS)
3478 SET_AFLAGS(msg, info21.acct_flags, "userAccountControl");
3479 IFSET(SAMR_FIELD_PARAMETERS)
3480 SET_PARAMETERS(msg, info21.parameters, "userParameters");
3481 IFSET(SAMR_FIELD_COUNTRY_CODE)
3482 SET_UINT (msg, info21.country_code, "countryCode");
3483 IFSET(SAMR_FIELD_CODE_PAGE)
3484 SET_UINT (msg, info21.code_page, "codePage");
3485 #undef IFSET
3486 break;
3487
3488 case 23:
3489 #define IFSET(bit) if (bit & r->in.info->info23.info.fields_present)
3490 IFSET(SAMR_FIELD_ACCT_EXPIRY)
3491 SET_UINT64(msg, info23.info.acct_expiry, "accountExpires");
3492 IFSET(SAMR_FIELD_ACCOUNT_NAME)
3493 SET_STRING(msg, info23.info.account_name, "samAccountName");
3494 IFSET(SAMR_FIELD_FULL_NAME)
3495 SET_STRING(msg, info23.info.full_name, "displayName");
3496 IFSET(SAMR_FIELD_DESCRIPTION)
3497 SET_STRING(msg, info23.info.description, "description");
3498 IFSET(SAMR_FIELD_COMMENT)
3499 SET_STRING(msg, info23.info.comment, "comment");
3500 IFSET(SAMR_FIELD_LOGON_SCRIPT)
3501 SET_STRING(msg, info23.info.logon_script, "scriptPath");
3502 IFSET(SAMR_FIELD_PROFILE_PATH)
3503 SET_STRING(msg, info23.info.profile_path, "profilePath");
3504 IFSET(SAMR_FIELD_WORKSTATIONS)
3505 SET_STRING(msg, info23.info.workstations, "userWorkstations");
3506 IFSET(SAMR_FIELD_LOGON_HOURS)
3507 SET_LHOURS(msg, info23.info.logon_hours, "logonHours");
3508 IFSET(SAMR_FIELD_ACCT_FLAGS)
3509 SET_AFLAGS(msg, info23.info.acct_flags, "userAccountControl");
3510 IFSET(SAMR_FIELD_PARAMETERS)
3511 SET_PARAMETERS(msg, info23.info.parameters, "userParameters");
3512 IFSET(SAMR_FIELD_COUNTRY_CODE)
3513 SET_UINT (msg, info23.info.country_code, "countryCode");
3514 IFSET(SAMR_FIELD_CODE_PAGE)
3515 SET_UINT (msg, info23.info.code_page, "codePage");
3516 IFSET(SAMR_FIELD_NT_PASSWORD_PRESENT) {
3517 status = samr_set_password(dce_call,
3518 a_state->sam_ctx,
3519 a_state->account_dn,
3520 a_state->domain_state->domain_dn,
3521 mem_ctx, msg,
3522 &r->in.info->info23.password);
3523 } else IFSET(SAMR_FIELD_LM_PASSWORD_PRESENT) {
3524 status = samr_set_password(dce_call,
3525 a_state->sam_ctx,
3526 a_state->account_dn,
3527 a_state->domain_state->domain_dn,
3528 mem_ctx, msg,
3529 &r->in.info->info23.password);
3530 }
3531 #undef IFSET
3532 break;
3533
3534 /* the set password levels are handled separately */
3535 case 24:
3536 status = samr_set_password(dce_call,
3537 a_state->sam_ctx,
3538 a_state->account_dn,
3539 a_state->domain_state->domain_dn,
3540 mem_ctx, msg,
3541 &r->in.info->info24.password);
3542 break;
3543
3544 case 25:
3545 #define IFSET(bit) if (bit & r->in.info->info25.info.fields_present)
3546 IFSET(SAMR_FIELD_ACCT_EXPIRY)
3547 SET_UINT64(msg, info25.info.acct_expiry, "accountExpires");
3548 IFSET(SAMR_FIELD_ACCOUNT_NAME)
3549 SET_STRING(msg, info25.info.account_name, "samAccountName");
3550 IFSET(SAMR_FIELD_FULL_NAME)
3551 SET_STRING(msg, info25.info.full_name, "displayName");
3552 IFSET(SAMR_FIELD_DESCRIPTION)
3553 SET_STRING(msg, info25.info.description, "description");
3554 IFSET(SAMR_FIELD_COMMENT)
3555 SET_STRING(msg, info25.info.comment, "comment");
3556 IFSET(SAMR_FIELD_LOGON_SCRIPT)
3557 SET_STRING(msg, info25.info.logon_script, "scriptPath");
3558 IFSET(SAMR_FIELD_PROFILE_PATH)
3559 SET_STRING(msg, info25.info.profile_path, "profilePath");
3560 IFSET(SAMR_FIELD_WORKSTATIONS)
3561 SET_STRING(msg, info25.info.workstations, "userWorkstations");
3562 IFSET(SAMR_FIELD_LOGON_HOURS)
3563 SET_LHOURS(msg, info25.info.logon_hours, "logonHours");
3564 IFSET(SAMR_FIELD_ACCT_FLAGS)
3565 SET_AFLAGS(msg, info25.info.acct_flags, "userAccountControl");
3566 IFSET(SAMR_FIELD_PARAMETERS)
3567 SET_PARAMETERS(msg, info25.info.parameters, "userParameters");
3568 IFSET(SAMR_FIELD_COUNTRY_CODE)
3569 SET_UINT (msg, info25.info.country_code, "countryCode");
3570 IFSET(SAMR_FIELD_CODE_PAGE)
3571 SET_UINT (msg, info25.info.code_page, "codePage");
3572 IFSET(SAMR_FIELD_NT_PASSWORD_PRESENT) {
3573 status = samr_set_password_ex(dce_call,
3574 a_state->sam_ctx,
3575 a_state->account_dn,
3576 a_state->domain_state->domain_dn,
3577 mem_ctx, msg,
3578 &r->in.info->info25.password);
3579 } else IFSET(SAMR_FIELD_LM_PASSWORD_PRESENT) {
3580 status = samr_set_password_ex(dce_call,
3581 a_state->sam_ctx,
3582 a_state->account_dn,
3583 a_state->domain_state->domain_dn,
3584 mem_ctx, msg,
3585 &r->in.info->info25.password);
3586 }
3587 #undef IFSET
3588 break;
3589
3590 /* the set password levels are handled separately */
3591 case 26:
3592 status = samr_set_password_ex(dce_call,
3593 a_state->sam_ctx,
3594 a_state->account_dn,
3595 a_state->domain_state->domain_dn,
3596 mem_ctx, msg,
3597 &r->in.info->info26.password);
3598 break;
3599
3600
3601 default:
3602 /* many info classes are not valid for SetUserInfo */
3603 return NT_STATUS_INVALID_INFO_CLASS;
3604 }
3605
3606 if (!NT_STATUS_IS_OK(status)) {
3607 return status;
3608 }
3609
3610 /* modify the samdb record */
3611 ret = ldb_modify(a_state->sam_ctx, msg);
3612 if (ret != 0) {
3613 DEBUG(1,("Failed to modify record %s: %s\n",
3614 ldb_dn_get_linearized(a_state->account_dn),
3615 ldb_errstring(a_state->sam_ctx)));
3616
3617 /* we really need samdb.c to return NTSTATUS */
3618 return NT_STATUS_UNSUCCESSFUL;
3619 }
3620
3621 return NT_STATUS_OK;
3622 }
3623
3624
3625 /*
3626 samr_GetGroupsForUser
3627 */
3628 static NTSTATUS dcesrv_samr_GetGroupsForUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3629 struct samr_GetGroupsForUser *r)
3630 {
3631 struct dcesrv_handle *h;
3632 struct samr_account_state *a_state;
3633 struct samr_domain_state *d_state;
3634 struct ldb_message **res;
3635 const char * const attrs[2] = { "objectSid", NULL };
3636 struct samr_RidWithAttributeArray *array;
3637 int count;
3638
3639 DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3640
3641 a_state = h->data;
3642 d_state = a_state->domain_state;
3643
3644 count = samdb_search_domain(a_state->sam_ctx, mem_ctx, d_state->domain_dn, &res,
3645 attrs, d_state->domain_sid,
3646 "(&(member=%s)(grouptype=%d)(objectclass=group))",
3647 ldb_dn_get_linearized(a_state->account_dn),
3648 GTYPE_SECURITY_GLOBAL_GROUP);
3649 if (count < 0)
3650 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3651
3652 array = talloc(mem_ctx, struct samr_RidWithAttributeArray);
3653 if (array == NULL)
3654 return NT_STATUS_NO_MEMORY;
3655
3656 array->count = 0;
3657 array->rids = NULL;
3658
3659 if (count > 0) {
3660 int i;
3661 array->rids = talloc_array(mem_ctx, struct samr_RidWithAttribute,
3662 count);
3663
3664 if (array->rids == NULL)
3665 return NT_STATUS_NO_MEMORY;
3666
3667 for (i=0; i<count; i++) {
3668 struct dom_sid *group_sid;
3669
3670 group_sid = samdb_result_dom_sid(mem_ctx, res[i],
3671 "objectSid");
3672 if (group_sid == NULL) {
3673 DEBUG(0, ("Couldn't find objectSid attrib\n"));
3674 continue;
3675 }
3676
3677 array->rids[array->count].rid =
3678 group_sid->sub_auths[group_sid->num_auths-1];
3679 array->rids[array->count].attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED;
3680 array->count += 1;
3681 }
3682 }
3683
3684 *r->out.rids = array;
3685
3686 return NT_STATUS_OK;
3687 }
3688
3689
3690 /*
3691 samr_QueryDisplayInfo
3692 */
3693 static NTSTATUS dcesrv_samr_QueryDisplayInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3694 struct samr_QueryDisplayInfo *r)
3695 {
3696 struct dcesrv_handle *h;
3697 struct samr_domain_state *d_state;
3698 struct ldb_message **res;
3699 int ldb_cnt, count, i;
3700 const char * const attrs[] = { "objectSid", "sAMAccountName", "displayName",
3701 "description", "userAccountControl", "pwdLastSet", NULL };
3702 struct samr_DispEntryFull *entriesFull = NULL;
3703 struct samr_DispEntryFullGroup *entriesFullGroup = NULL;
3704 struct samr_DispEntryAscii *entriesAscii = NULL;
3705 struct samr_DispEntryGeneral * entriesGeneral = NULL;
3706 const char *filter;
3707
3708 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
3709
3710 d_state = h->data;
3711
3712 switch (r->in.level) {
3713 case 1:
3714 case 4:
3715 filter = talloc_asprintf(mem_ctx, "(&(objectclass=user)"
3716 "(sAMAccountType=%u))",
3717 ATYPE_NORMAL_ACCOUNT);
3718 break;
3719 case 2:
3720 filter = talloc_asprintf(mem_ctx, "(&(objectclass=user)"
3721 "(sAMAccountType=%u))",
3722 ATYPE_WORKSTATION_TRUST);
3723 break;
3724 case 3:
3725 case 5:
3726 filter = talloc_asprintf(mem_ctx, "(&(grouptype=%d)"
3727 "(objectclass=group))",
3728 GTYPE_SECURITY_GLOBAL_GROUP);
3729 break;
3730 default:
3731 return NT_STATUS_INVALID_INFO_CLASS;
3732 }
3733
3734 /* search for all requested objects in this domain. This could
3735 possibly be cached and resumed based on resume_key */
3736 ldb_cnt = samdb_search_domain(d_state->sam_ctx, mem_ctx,
3737 d_state->domain_dn, &res, attrs,
3738 d_state->domain_sid, "%s", filter);
3739 if (ldb_cnt == -1) {
3740 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3741 }
3742 if (ldb_cnt == 0 || r->in.max_entries == 0) {
3743 return NT_STATUS_OK;
3744 }
3745
3746 switch (r->in.level) {
3747 case 1:
3748 entriesGeneral = talloc_array(mem_ctx,
3749 struct samr_DispEntryGeneral,
3750 ldb_cnt);
3751 break;
3752 case 2:
3753 entriesFull = talloc_array(mem_ctx,
3754 struct samr_DispEntryFull,
3755 ldb_cnt);
3756 break;
3757 case 3:
3758 entriesFullGroup = talloc_array(mem_ctx,
3759 struct samr_DispEntryFullGroup,
3760 ldb_cnt);
3761 break;
3762 case 4:
3763 case 5:
3764 entriesAscii = talloc_array(mem_ctx,
3765 struct samr_DispEntryAscii,
3766 ldb_cnt);
3767 break;
3768 }
3769
3770 if ((entriesGeneral == NULL) && (entriesFull == NULL) &&
3771 (entriesAscii == NULL) && (entriesFullGroup == NULL))
3772 return NT_STATUS_NO_MEMORY;
3773
3774 count = 0;
3775
3776 for (i=0; i<ldb_cnt; i++) {
3777 struct dom_sid *objectsid;
3778
3779 objectsid = samdb_result_dom_sid(mem_ctx, res[i],
3780 "objectSid");
3781 if (objectsid == NULL)
3782 continue;
3783
3784 switch(r->in.level) {
3785 case 1:
3786 entriesGeneral[count].idx = count + 1;
3787 entriesGeneral[count].rid =
3788 objectsid->sub_auths[objectsid->num_auths-1];
3789 entriesGeneral[count].acct_flags =
3790 samdb_result_acct_flags(d_state->sam_ctx, mem_ctx,
3791 res[i],
3792 d_state->domain_dn);
3793 entriesGeneral[count].account_name.string =
3794 samdb_result_string(res[i],
3795 "sAMAccountName", "");
3796 entriesGeneral[count].full_name.string =
3797 samdb_result_string(res[i], "displayName", "");
3798 entriesGeneral[count].description.string =
3799 samdb_result_string(res[i], "description", "");
3800 break;
3801 case 2:
3802 entriesFull[count].idx = count + 1;
3803 entriesFull[count].rid =
3804 objectsid->sub_auths[objectsid->num_auths-1];
3805
3806 /* No idea why we need to or in ACB_NORMAL here, but this is what Win2k3 seems to do... */
3807 entriesFull[count].acct_flags =
3808 samdb_result_acct_flags(d_state->sam_ctx, mem_ctx,
3809 res[i],
3810 d_state->domain_dn) | ACB_NORMAL;
3811 entriesFull[count].account_name.string =
3812 samdb_result_string(res[i], "sAMAccountName",
3813 "");
3814 entriesFull[count].description.string =
3815 samdb_result_string(res[i], "description", "");
3816 break;
3817 case 3:
3818 entriesFullGroup[count].idx = count + 1;
3819 entriesFullGroup[count].rid =
3820 objectsid->sub_auths[objectsid->num_auths-1];
3821 /* We get a "7" here for groups */
3822 entriesFullGroup[count].acct_flags
3823 = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED;
3824 entriesFullGroup[count].account_name.string =
3825 samdb_result_string(res[i], "sAMAccountName",
3826 "");
3827 entriesFullGroup[count].description.string =
3828 samdb_result_string(res[i], "description", "");
3829 break;
3830 case 4:
3831 case 5:
3832 entriesAscii[count].idx = count + 1;
3833 entriesAscii[count].account_name.string =
3834 samdb_result_string(res[i], "sAMAccountName",
3835 "");
3836 break;
3837 }
3838
3839 count += 1;
3840 }
3841
3842 *r->out.total_size = count;
3843
3844 if (r->in.start_idx >= count) {
3845 *r->out.returned_size = 0;
3846 switch(r->in.level) {
3847 case 1:
3848 r->out.info->info1.count = *r->out.returned_size;
3849 r->out.info->info1.entries = NULL;
3850 break;
3851 case 2:
3852 r->out.info->info2.count = *r->out.returned_size;
3853 r->out.info->info2.entries = NULL;
3854 break;
3855 case 3:
3856 r->out.info->info3.count = *r->out.returned_size;
3857 r->out.info->info3.entries = NULL;
3858 break;
3859 case 4:
3860 r->out.info->info4.count = *r->out.returned_size;
3861 r->out.info->info4.entries = NULL;
3862 break;
3863 case 5:
3864 r->out.info->info5.count = *r->out.returned_size;
3865 r->out.info->info5.entries = NULL;
3866 break;
3867 }
3868 } else {
3869 *r->out.returned_size = MIN(count - r->in.start_idx,
3870 r->in.max_entries);
3871 switch(r->in.level) {
3872 case 1:
3873 r->out.info->info1.count = *r->out.returned_size;
3874 r->out.info->info1.entries =
3875 &(entriesGeneral[r->in.start_idx]);
3876 break;
3877 case 2:
3878 r->out.info->info2.count = *r->out.returned_size;
3879 r->out.info->info2.entries =
3880 &(entriesFull[r->in.start_idx]);
3881 break;
3882 case 3:
3883 r->out.info->info3.count = *r->out.returned_size;
3884 r->out.info->info3.entries =
3885 &(entriesFullGroup[r->in.start_idx]);
3886 break;
3887 case 4:
3888 r->out.info->info4.count = *r->out.returned_size;
3889 r->out.info->info4.entries =
3890 &(entriesAscii[r->in.start_idx]);
3891 break;
3892 case 5:
3893 r->out.info->info5.count = *r->out.returned_size;
3894 r->out.info->info5.entries =
3895 &(entriesAscii[r->in.start_idx]);
3896 break;
3897 }
3898 }
3899
3900 return (*r->out.returned_size < (count - r->in.start_idx)) ?
3901 STATUS_MORE_ENTRIES : NT_STATUS_OK;
3902 }
3903
3904
3905 /*
3906 samr_GetDisplayEnumerationIndex
3907 */
3908 static NTSTATUS dcesrv_samr_GetDisplayEnumerationIndex(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3909 struct samr_GetDisplayEnumerationIndex *r)
3910 {
3911 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3912 }
3913
3914
3915 /*
3916 samr_TestPrivateFunctionsDomain
3917 */
3918 static NTSTATUS dcesrv_samr_TestPrivateFunctionsDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3919 struct samr_TestPrivateFunctionsDomain *r)
3920 {
3921 return NT_STATUS_NOT_IMPLEMENTED;
3922 }
3923
3924
3925 /*
3926 samr_TestPrivateFunctionsUser
3927 */
3928 static NTSTATUS dcesrv_samr_TestPrivateFunctionsUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3929 struct samr_TestPrivateFunctionsUser *r)
3930 {
3931 return NT_STATUS_NOT_IMPLEMENTED;
3932 }
3933
3934
3935 /*
3936 samr_GetUserPwInfo
3937 */
3938 static NTSTATUS dcesrv_samr_GetUserPwInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3939 struct samr_GetUserPwInfo *r)
3940 {
3941 struct dcesrv_handle *h;
3942 struct samr_account_state *a_state;
3943
3944 ZERO_STRUCTP(r->out.info);
3945
3946 DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3947
3948 a_state = h->data;
3949
3950 r->out.info->min_password_length = samdb_search_uint(a_state->sam_ctx, mem_ctx, 0,
3951 a_state->domain_state->domain_dn, "minPwdLength",
3952 NULL);
3953 r->out.info->password_properties = samdb_search_uint(a_state->sam_ctx, mem_ctx, 0,
3954 a_state->account_dn,
3955 "pwdProperties", NULL);
3956 return NT_STATUS_OK;
3957 }
3958
3959
3960 /*
3961 samr_RemoveMemberFromForeignDomain
3962 */
3963 static NTSTATUS dcesrv_samr_RemoveMemberFromForeignDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3964 struct samr_RemoveMemberFromForeignDomain *r)
3965 {
3966 struct dcesrv_handle *h;
3967 struct samr_domain_state *d_state;
3968 const char *memberdn;
3969 struct ldb_message **res;
3970 const char * const attrs[3] = { "distinguishedName", "objectSid", NULL };
3971 int i, count;
3972
3973 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
3974
3975 d_state = h->data;
3976
3977 memberdn = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
3978 "distinguishedName", "(objectSid=%s)",
3979 ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
3980 /* Nothing to do */
3981 if (memberdn == NULL) {
3982 return NT_STATUS_OK;
3983 }
3984
3985 /* TODO: Does this call only remove alias members, or does it do this
3986 * for domain groups as well? */
3987
3988 count = samdb_search_domain(d_state->sam_ctx, mem_ctx,
3989 d_state->domain_dn, &res, attrs,
3990 d_state->domain_sid,
3991 "(&(member=%s)(objectClass=group)"
3992 "(|(groupType=%d)(groupType=%d)))",
3993 memberdn,
3994 GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
3995 GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
3996
3997 if (count < 0)
3998 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3999
4000 for (i=0; i<count; i++) {
4001 struct ldb_message *mod;
4002
4003 mod = ldb_msg_new(mem_ctx);
4004 if (mod == NULL) {
4005 return NT_STATUS_NO_MEMORY;
4006 }
4007
4008 mod->dn = samdb_result_dn(d_state->sam_ctx, mod, res[i], "distinguishedName", NULL);
4009 if (mod->dn == NULL) {
4010 talloc_free(mod);
4011 continue;
4012 }
4013
4014 if (samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod,
4015 "member", memberdn) != 0)
4016 return NT_STATUS_NO_MEMORY;
4017
4018 if (ldb_modify(d_state->sam_ctx, mod) != 0)
4019 return NT_STATUS_UNSUCCESSFUL;
4020
4021 talloc_free(mod);
4022 }
4023
4024 return NT_STATUS_OK;
4025 }
4026
4027
4028 /*
4029 samr_QueryDomainInfo2
4030
4031 just an alias for samr_QueryDomainInfo
4032 */
4033 static NTSTATUS dcesrv_samr_QueryDomainInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4034 struct samr_QueryDomainInfo2 *r)
4035 {
4036 struct samr_QueryDomainInfo r1;
4037 NTSTATUS status;
4038
4039 ZERO_STRUCT(r1.out);
4040 r1.in.domain_handle = r->in.domain_handle;
4041 r1.in.level = r->in.level;
4042 r1.out.info = r->out.info;
4043
4044 status = dcesrv_samr_QueryDomainInfo(dce_call, mem_ctx, &r1);
4045
4046 return status;
4047 }
4048
4049
4050 /*
4051 samr_QueryUserInfo2
4052
4053 just an alias for samr_QueryUserInfo
4054 */
4055 static NTSTATUS dcesrv_samr_QueryUserInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4056 struct samr_QueryUserInfo2 *r)
4057 {
4058 struct samr_QueryUserInfo r1;
4059 NTSTATUS status;
4060
4061 r1.in.user_handle = r->in.user_handle;
4062 r1.in.level = r->in.level;
4063 r1.out.info = r->out.info;
4064
4065 status = dcesrv_samr_QueryUserInfo(dce_call, mem_ctx, &r1);
4066
4067 return status;
4068 }
4069
4070
4071 /*
4072 samr_QueryDisplayInfo2
4073 */
4074 static NTSTATUS dcesrv_samr_QueryDisplayInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4075 struct samr_QueryDisplayInfo2 *r)
4076 {
4077 struct samr_QueryDisplayInfo q;
4078 NTSTATUS result;
4079
4080 q.in.domain_handle = r->in.domain_handle;
4081 q.in.level = r->in.level;
4082 q.in.start_idx = r->in.start_idx;
4083 q.in.max_entries = r->in.max_entries;
4084 q.in.buf_size = r->in.buf_size;
4085 q.out.total_size = r->out.total_size;
4086 q.out.returned_size = r->out.returned_size;
4087 q.out.info = r->out.info;
4088
4089 result = dcesrv_samr_QueryDisplayInfo(dce_call, mem_ctx, &q);
4090
4091 return result;
4092 }
4093
4094
4095 /*
4096 samr_GetDisplayEnumerationIndex2
4097 */
4098 static NTSTATUS dcesrv_samr_GetDisplayEnumerationIndex2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4099 struct samr_GetDisplayEnumerationIndex2 *r)
4100 {
4101 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4102 }
4103
4104
4105 /*
4106 samr_QueryDisplayInfo3
4107 */
4108 static NTSTATUS dcesrv_samr_QueryDisplayInfo3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4109 struct samr_QueryDisplayInfo3 *r)
4110 {
4111 struct samr_QueryDisplayInfo q;
4112 NTSTATUS result;
4113
4114 q.in.domain_handle = r->in.domain_handle;
4115 q.in.level = r->in.level;
4116 q.in.start_idx = r->in.start_idx;
4117 q.in.max_entries = r->in.max_entries;
4118 q.in.buf_size = r->in.buf_size;
4119 q.out.total_size = r->out.total_size;
4120 q.out.returned_size = r->out.returned_size;
4121 q.out.info = r->out.info;
4122
4123 result = dcesrv_samr_QueryDisplayInfo(dce_call, mem_ctx, &q);
4124
4125 return result;
4126 }
4127
4128
4129 /*
4130 samr_AddMultipleMembersToAlias
4131 */
4132 static NTSTATUS dcesrv_samr_AddMultipleMembersToAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4133 struct samr_AddMultipleMembersToAlias *r)
4134 {
4135 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4136 }
4137
4138
4139 /*
4140 samr_RemoveMultipleMembersFromAlias
4141 */
4142 static NTSTATUS dcesrv_samr_RemoveMultipleMembersFromAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4143 struct samr_RemoveMultipleMembersFromAlias *r)
4144 {
4145 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4146 }
4147
4148
4149 /*
4150 samr_GetDomPwInfo
4151
4152 this fetches the default password properties for a domain
4153
4154 note that w2k3 completely ignores the domain name in this call, and
4155 always returns the information for the servers primary domain
4156 */
4157 static NTSTATUS dcesrv_samr_GetDomPwInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4158 struct samr_GetDomPwInfo *r)
4159 {
4160 struct ldb_message **msgs;
4161 int ret;
4162 const char * const attrs[] = {"minPwdLength", "pwdProperties", NULL };
4163 struct ldb_context *sam_ctx;
4164
4165 ZERO_STRUCTP(r->out.info);
4166
4167 sam_ctx = samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
4168 if (sam_ctx == NULL) {
4169 return NT_STATUS_INVALID_SYSTEM_SERVICE;
4170 }
4171
4172 /* The domain name in this call is ignored */
4173 ret = gendb_search_dn(sam_ctx,
4174 mem_ctx, NULL, &msgs, attrs);
4175 if (ret <= 0) {
4176 return NT_STATUS_NO_SUCH_DOMAIN;
4177 }
4178 if (ret > 1) {
4179 talloc_free(msgs);
4180 return NT_STATUS_INTERNAL_DB_CORRUPTION;
4181 }
4182
4183 r->out.info->min_password_length = samdb_result_uint(msgs[0], "minPwdLength", 0);
4184 r->out.info->password_properties = samdb_result_uint(msgs[0], "pwdProperties", 1);
4185
4186 talloc_free(msgs);
4187
4188 talloc_free(sam_ctx);
4189 return NT_STATUS_OK;
4190 }
4191
4192
4193 /*
4194 samr_Connect2
4195 */
4196 static NTSTATUS dcesrv_samr_Connect2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4197 struct samr_Connect2 *r)
4198 {
4199 struct samr_Connect c;
4200
4201 c.in.system_name = NULL;
4202 c.in.access_mask = r->in.access_mask;
4203 c.out.connect_handle = r->out.connect_handle;
4204
4205 return dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4206 }
4207
4208
4209 /*
4210 samr_SetUserInfo2
4211
4212 just an alias for samr_SetUserInfo
4213 */
4214 static NTSTATUS dcesrv_samr_SetUserInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4215 struct samr_SetUserInfo2 *r)
4216 {
4217 struct samr_SetUserInfo r2;
4218
4219 r2.in.user_handle = r->in.user_handle;
4220 r2.in.level = r->in.level;
4221 r2.in.info = r->in.info;
4222
4223 return dcesrv_samr_SetUserInfo(dce_call, mem_ctx, &r2);
4224 }
4225
4226
4227 /*
4228 samr_SetBootKeyInformation
4229 */
4230 static NTSTATUS dcesrv_samr_SetBootKeyInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4231 struct samr_SetBootKeyInformation *r)
4232 {
4233 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4234 }
4235
4236
4237 /*
4238 samr_GetBootKeyInformation
4239 */
4240 static NTSTATUS dcesrv_samr_GetBootKeyInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4241 struct samr_GetBootKeyInformation *r)
4242 {
4243 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4244 }
4245
4246
4247 /*
4248 samr_Connect3
4249 */
4250 static NTSTATUS dcesrv_samr_Connect3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4251 struct samr_Connect3 *r)
4252 {
4253 struct samr_Connect c;
4254
4255 c.in.system_name = NULL;
4256 c.in.access_mask = r->in.access_mask;
4257 c.out.connect_handle = r->out.connect_handle;
4258
4259 return dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4260 }
4261
4262
4263 /*
4264 samr_Connect4
4265 */
4266 static NTSTATUS dcesrv_samr_Connect4(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4267 struct samr_Connect4 *r)
4268 {
4269 struct samr_Connect c;
4270
4271 c.in.system_name = NULL;
4272 c.in.access_mask = r->in.access_mask;
4273 c.out.connect_handle = r->out.connect_handle;
4274
4275 return dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4276 }
4277
4278
4279 /*
4280 samr_Connect5
4281 */
4282 static NTSTATUS dcesrv_samr_Connect5(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4283 struct samr_Connect5 *r)
4284 {
4285 struct samr_Connect c;
4286 NTSTATUS status;
4287
4288 c.in.system_name = NULL;
4289 c.in.access_mask = r->in.access_mask;
4290 c.out.connect_handle = r->out.connect_handle;
4291
4292 status = dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4293
4294 r->out.info_out->info1.client_version = SAMR_CONNECT_AFTER_W2K;
4295 r->out.info_out->info1.unknown2 = 0;
4296 *r->out.level_out = r->in.level_in;
4297
4298 return status;
4299 }
4300
4301
4302 /*
4303 samr_RidToSid
4304 */
4305 static NTSTATUS dcesrv_samr_RidToSid(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4306 struct samr_RidToSid *r)
4307 {
4308 struct samr_domain_state *d_state;
4309 struct dcesrv_handle *h;
4310
4311 DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
4312
4313 d_state = h->data;
4314
4315 /* form the users SID */
4316 *r->out.sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
4317 if (!*r->out.sid) {
4318 return NT_STATUS_NO_MEMORY;
4319 }
4320
4321 return NT_STATUS_OK;
4322 }
4323
4324
4325 /*
4326 samr_SetDsrmPassword
4327 */
4328 static NTSTATUS dcesrv_samr_SetDsrmPassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4329 struct samr_SetDsrmPassword *r)
4330 {
4331 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4332 }
4333
4334
4335 /*
4336 samr_ValidatePassword
4337 */
4338 static NTSTATUS dcesrv_samr_ValidatePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4339 struct samr_ValidatePassword *r)
4340 {
4341 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4342 }
4343
4344
4345 /* include the generated boilerplate */
4346 #include "librpc/gen_ndr/ndr_samr_s.c"
Samba GIT mirror