← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to source/rpc_server/srv_samr.c

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/rpc_server/srv_samr.c
1
 
/* 
2
 
 *  Unix SMB/CIFS implementation.
3
 
 *  RPC Pipe client / server routines
4
 
 *  Copyright (C) Andrew Tridgell              1992-1997,
5
 
 *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6
 
 *  Copyright (C) Paul Ashton                       1997,
7
 
 *  Copyright (C) Marc Jacobsen                     1999,
8
 
 *  Copyright (C) Jean Fran�ois Micouleau      1998-2001,
9
 
 *  Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002-2003.
10
 
 *      
11
 
 *      Split into interface and implementation modules by, 
12
 
 *
13
 
 *  Copyright (C) Jeremy Allison                    2001.
14
 
 *  
15
 
 *  This program is free software; you can redistribute it and/or modify
16
 
 *  it under the terms of the GNU General Public License as published by
17
 
 *  the Free Software Foundation; either version 2 of the License, or
18
 
 *  (at your option) any later version.
19
 
 *  
20
 
 *  This program is distributed in the hope that it will be useful,
21
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
22
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23
 
 *  GNU General Public License for more details.
24
 
 *  
25
 
 *  You should have received a copy of the GNU General Public License
26
 
 *  along with this program; if not, write to the Free Software
27
 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28
 
 */
29
 
 
30
 
/*
31
 
 * This is the interface to the SAMR code.
32
 
 */
33
 
 
34
 
#include "includes.h"
35
 
 
36
 
#undef DBGC_CLASS
37
 
#define DBGC_CLASS DBGC_RPC_SRV
38
 
 
39
 
/*******************************************************************
40
 
 api_samr_close_hnd
41
 
 ********************************************************************/
42
 
 
43
 
static BOOL api_samr_close_hnd(pipes_struct *p)
44
 
{
45
 
        SAMR_Q_CLOSE_HND q_u;
46
 
        SAMR_R_CLOSE_HND r_u;
47
 
        prs_struct *data = &p->in_data.data;
48
 
        prs_struct *rdata = &p->out_data.rdata;
49
 
 
50
 
        ZERO_STRUCT(q_u);
51
 
        ZERO_STRUCT(r_u);
52
 
 
53
 
        if(!samr_io_q_close_hnd("", &q_u, data, 0)) {
54
 
                DEBUG(0,("api_samr_close_hnd: unable to unmarshall SAMR_Q_CLOSE_HND.\n"));
55
 
                return False;
56
 
        }
57
 
 
58
 
        r_u.status = _samr_close_hnd(p, &q_u, &r_u);
59
 
 
60
 
        /* store the response in the SMB stream */
61
 
        if(!samr_io_r_close_hnd("", &r_u, rdata, 0)) {
62
 
                DEBUG(0,("api_samr_close_hnd: unable to marshall SAMR_R_CLOSE_HND.\n"));
63
 
                return False;
64
 
        }
65
 
 
66
 
        return True;
67
 
}
68
 
 
69
 
/*******************************************************************
70
 
 api_samr_open_domain
71
 
 ********************************************************************/
72
 
 
73
 
static BOOL api_samr_open_domain(pipes_struct *p)
74
 
{
75
 
        SAMR_Q_OPEN_DOMAIN q_u;
76
 
        SAMR_R_OPEN_DOMAIN r_u;
77
 
 
78
 
        prs_struct *data = &p->in_data.data;
79
 
        prs_struct *rdata = &p->out_data.rdata;
80
 
 
81
 
        ZERO_STRUCT(q_u);
82
 
        ZERO_STRUCT(r_u);
83
 
 
84
 
        if(!samr_io_q_open_domain("", &q_u, data, 0)) {
85
 
                DEBUG(0,("api_samr_open_domain: unable to unmarshall SAMR_Q_OPEN_DOMAIN.\n"));
86
 
                return False;
87
 
        }
88
 
 
89
 
        r_u.status = _samr_open_domain(p, &q_u, &r_u);
90
 
 
91
 
        /* store the response in the SMB stream */
92
 
        if(!samr_io_r_open_domain("", &r_u, rdata, 0)) {
93
 
                DEBUG(0,("api_samr_open_domain: unable to marshall SAMR_R_OPEN_DOMAIN.\n"));
94
 
                return False;
95
 
        }
96
 
 
97
 
        return True;
98
 
}
99
 
 
100
 
/*******************************************************************
101
 
 api_samr_get_usrdom_pwinfo
102
 
 ********************************************************************/
103
 
 
104
 
static BOOL api_samr_get_usrdom_pwinfo(pipes_struct *p)
105
 
{
106
 
        SAMR_Q_GET_USRDOM_PWINFO q_u;
107
 
        SAMR_R_GET_USRDOM_PWINFO r_u;
108
 
 
109
 
        prs_struct *data = &p->in_data.data;
110
 
        prs_struct *rdata = &p->out_data.rdata;
111
 
 
112
 
        ZERO_STRUCT(q_u);
113
 
        ZERO_STRUCT(r_u);
114
 
 
115
 
        if(!samr_io_q_get_usrdom_pwinfo("", &q_u, data, 0)) {
116
 
                DEBUG(0,("api_samr_get_usrdom_pwinfo: unable to unmarshall SAMR_Q_GET_USRDOM_PWINFO.\n"));
117
 
                return False;
118
 
        }
119
 
 
120
 
        r_u.status = _samr_get_usrdom_pwinfo(p, &q_u, &r_u);
121
 
 
122
 
        if(!samr_io_r_get_usrdom_pwinfo("", &r_u, rdata, 0)) {
123
 
                DEBUG(0,("api_samr_get_usrdom_pwinfo: unable to marshall SAMR_R_GET_USRDOM_PWINFO.\n"));
124
 
                return False;
125
 
        }
126
 
 
127
 
        return True;
128
 
}
129
 
 
130
 
/*******************************************************************
131
 
 api_samr_set_sec_obj
132
 
 ********************************************************************/
133
 
 
134
 
static BOOL api_samr_set_sec_obj(pipes_struct *p)
135
 
{
136
 
        SAMR_Q_SET_SEC_OBJ q_u;
137
 
        SAMR_R_SET_SEC_OBJ r_u;
138
 
        
139
 
        prs_struct *data  = &p->in_data.data;
140
 
        prs_struct *rdata = &p->out_data.rdata;
141
 
        
142
 
        ZERO_STRUCT(q_u);
143
 
        ZERO_STRUCT(r_u);
144
 
        
145
 
        if(!samr_io_q_set_sec_obj("", &q_u, data, 0)) {
146
 
                DEBUG(0,("api_samr_set_sec_obj: unable to unmarshall SAMR_Q_SET_SEC_OBJ.\n"));
147
 
                return False;
148
 
        }
149
 
 
150
 
        r_u.status = _samr_set_sec_obj(p, &q_u, &r_u);
151
 
 
152
 
        if(!samr_io_r_set_sec_obj("", &r_u, rdata, 0)) {
153
 
                DEBUG(0,("api_samr_set_sec_obj: unable to marshall SAMR_R_SET_SEC_OBJ.\n"));
154
 
                return False;
155
 
        }
156
 
        
157
 
        return True;
158
 
}
159
 
 
160
 
/*******************************************************************
161
 
 api_samr_query_sec_obj
162
 
 ********************************************************************/
163
 
 
164
 
static BOOL api_samr_query_sec_obj(pipes_struct *p)
165
 
{
166
 
        SAMR_Q_QUERY_SEC_OBJ q_u;
167
 
        SAMR_R_QUERY_SEC_OBJ r_u;
168
 
 
169
 
        prs_struct *data = &p->in_data.data;
170
 
        prs_struct *rdata = &p->out_data.rdata;
171
 
 
172
 
        ZERO_STRUCT(q_u);
173
 
        ZERO_STRUCT(r_u);
174
 
 
175
 
        if(!samr_io_q_query_sec_obj("", &q_u, data, 0)) {
176
 
                DEBUG(0,("api_samr_query_sec_obj: unable to unmarshall SAMR_Q_QUERY_SEC_OBJ.\n"));
177
 
                return False;
178
 
        }
179
 
 
180
 
        r_u.status = _samr_query_sec_obj(p, &q_u, &r_u);
181
 
 
182
 
        if(!samr_io_r_query_sec_obj("", &r_u, rdata, 0)) {
183
 
                DEBUG(0,("api_samr_query_sec_obj: unable to marshall SAMR_R_QUERY_SEC_OBJ.\n"));
184
 
                return False;
185
 
        }
186
 
 
187
 
        return True;
188
 
}
189
 
 
190
 
/*******************************************************************
191
 
 api_samr_enum_dom_users
192
 
 ********************************************************************/
193
 
 
194
 
static BOOL api_samr_enum_dom_users(pipes_struct *p)
195
 
{
196
 
        SAMR_Q_ENUM_DOM_USERS q_u;
197
 
        SAMR_R_ENUM_DOM_USERS r_u;
198
 
        prs_struct *data = &p->in_data.data;
199
 
        prs_struct *rdata = &p->out_data.rdata;
200
 
 
201
 
        ZERO_STRUCT(q_u);
202
 
        ZERO_STRUCT(r_u);
203
 
 
204
 
        /* grab the samr open */
205
 
        if(!samr_io_q_enum_dom_users("", &q_u, data, 0)) {
206
 
                DEBUG(0,("api_samr_enum_dom_users: unable to unmarshall SAMR_Q_ENUM_DOM_USERS.\n"));
207
 
                return False;
208
 
        }
209
 
 
210
 
        r_u.status = _samr_enum_dom_users(p, &q_u, &r_u);
211
 
 
212
 
        /* store the response in the SMB stream */
213
 
        if(!samr_io_r_enum_dom_users("", &r_u, rdata, 0)) {
214
 
                DEBUG(0,("api_samr_enum_dom_users: unable to marshall SAMR_R_ENUM_DOM_USERS.\n"));
215
 
                return False;
216
 
        }
217
 
 
218
 
        return True;
219
 
}
220
 
 
221
 
/*******************************************************************
222
 
 api_samr_enum_dom_groups
223
 
 ********************************************************************/
224
 
 
225
 
static BOOL api_samr_enum_dom_groups(pipes_struct *p)
226
 
{
227
 
        SAMR_Q_ENUM_DOM_GROUPS q_u;
228
 
        SAMR_R_ENUM_DOM_GROUPS r_u;
229
 
        prs_struct *data = &p->in_data.data;
230
 
        prs_struct *rdata = &p->out_data.rdata;
231
 
 
232
 
        ZERO_STRUCT(q_u);
233
 
        ZERO_STRUCT(r_u);
234
 
 
235
 
        /* grab the samr open */
236
 
        if(!samr_io_q_enum_dom_groups("", &q_u, data, 0)) {
237
 
                DEBUG(0,("api_samr_enum_dom_groups: unable to unmarshall SAMR_Q_ENUM_DOM_GROUPS.\n"));
238
 
                return False;
239
 
        }
240
 
 
241
 
        r_u.status = _samr_enum_dom_groups(p, &q_u, &r_u);
242
 
 
243
 
        /* store the response in the SMB stream */
244
 
        if(!samr_io_r_enum_dom_groups("", &r_u, rdata, 0)) {
245
 
                DEBUG(0,("api_samr_enum_dom_groups: unable to marshall SAMR_R_ENUM_DOM_GROUPS.\n"));
246
 
                return False;
247
 
        }
248
 
 
249
 
        return True;
250
 
}
251
 
 
252
 
/*******************************************************************
253
 
 api_samr_enum_dom_aliases
254
 
 ********************************************************************/
255
 
 
256
 
static BOOL api_samr_enum_dom_aliases(pipes_struct *p)
257
 
{
258
 
        SAMR_Q_ENUM_DOM_ALIASES q_u;
259
 
        SAMR_R_ENUM_DOM_ALIASES r_u;
260
 
        prs_struct *data = &p->in_data.data;
261
 
        prs_struct *rdata = &p->out_data.rdata;
262
 
        
263
 
        ZERO_STRUCT(q_u);
264
 
        ZERO_STRUCT(r_u);
265
 
 
266
 
        /* grab the samr open */
267
 
        if(!samr_io_q_enum_dom_aliases("", &q_u, data, 0)) {
268
 
                DEBUG(0,("api_samr_enum_dom_aliases: unable to unmarshall SAMR_Q_ENUM_DOM_ALIASES.\n"));
269
 
                return False;
270
 
        }
271
 
 
272
 
        r_u.status = _samr_enum_dom_aliases(p, &q_u, &r_u);
273
 
 
274
 
        /* store the response in the SMB stream */
275
 
        if(!samr_io_r_enum_dom_aliases("", &r_u, rdata, 0)) {
276
 
                DEBUG(0,("api_samr_enum_dom_aliases: unable to marshall SAMR_R_ENUM_DOM_ALIASES.\n"));
277
 
                return False;
278
 
        }
279
 
 
280
 
        return True;
281
 
}
282
 
 
283
 
/*******************************************************************
284
 
 api_samr_query_dispinfo
285
 
 ********************************************************************/
286
 
 
287
 
static BOOL api_samr_query_dispinfo(pipes_struct *p)
288
 
{
289
 
        SAMR_Q_QUERY_DISPINFO q_u;
290
 
        SAMR_R_QUERY_DISPINFO r_u;
291
 
        prs_struct *data = &p->in_data.data;
292
 
        prs_struct *rdata = &p->out_data.rdata;
293
 
 
294
 
        ZERO_STRUCT(q_u);
295
 
        ZERO_STRUCT(r_u);
296
 
 
297
 
        if(!samr_io_q_query_dispinfo("", &q_u, data, 0)) {
298
 
                DEBUG(0,("api_samr_query_dispinfo: unable to unmarshall SAMR_Q_QUERY_DISPINFO.\n"));
299
 
                return False;
300
 
        }
301
 
 
302
 
        r_u.status = _samr_query_dispinfo(p, &q_u, &r_u);
303
 
 
304
 
        /* store the response in the SMB stream */
305
 
        if(!samr_io_r_query_dispinfo("", &r_u, rdata, 0)) {
306
 
                DEBUG(0,("api_samr_query_dispinfo: unable to marshall SAMR_R_QUERY_DISPINFO.\n"));
307
 
                return False;
308
 
        }
309
 
 
310
 
        return True;
311
 
}
312
 
 
313
 
/*******************************************************************
314
 
 api_samr_query_aliasinfo
315
 
 ********************************************************************/
316
 
 
317
 
static BOOL api_samr_query_aliasinfo(pipes_struct *p)
318
 
{
319
 
        SAMR_Q_QUERY_ALIASINFO q_u;
320
 
        SAMR_R_QUERY_ALIASINFO r_u;
321
 
        prs_struct *data = &p->in_data.data;
322
 
        prs_struct *rdata = &p->out_data.rdata;
323
 
 
324
 
        ZERO_STRUCT(q_u);
325
 
        ZERO_STRUCT(r_u);
326
 
 
327
 
        /* grab the samr open */
328
 
        if(!samr_io_q_query_aliasinfo("", &q_u, data, 0)) {
329
 
                DEBUG(0,("api_samr_query_aliasinfo: unable to unmarshall SAMR_Q_QUERY_ALIASINFO.\n"));
330
 
                return False;
331
 
        }
332
 
 
333
 
        r_u.status = _samr_query_aliasinfo(p, &q_u, &r_u);
334
 
 
335
 
        /* store the response in the SMB stream */
336
 
        if(!samr_io_r_query_aliasinfo("", &r_u, rdata, 0)) {
337
 
                DEBUG(0,("api_samr_query_aliasinfo: unable to marshall SAMR_R_QUERY_ALIASINFO.\n"));
338
 
                return False;
339
 
        }
340
 
  
341
 
        return True;
342
 
}
343
 
 
344
 
/*******************************************************************
345
 
 api_samr_lookup_names
346
 
 ********************************************************************/
347
 
 
348
 
static BOOL api_samr_lookup_names(pipes_struct *p)
349
 
{
350
 
        SAMR_Q_LOOKUP_NAMES q_u;
351
 
        SAMR_R_LOOKUP_NAMES r_u;
352
 
        prs_struct *data = &p->in_data.data;
353
 
        prs_struct *rdata = &p->out_data.rdata;
354
 
 
355
 
        ZERO_STRUCT(q_u);
356
 
        ZERO_STRUCT(r_u);
357
 
 
358
 
        /* grab the samr lookup names */
359
 
        if(!samr_io_q_lookup_names("", &q_u, data, 0)) {
360
 
                DEBUG(0,("api_samr_lookup_names: unable to unmarshall SAMR_Q_LOOKUP_NAMES.\n"));
361
 
                return False;
362
 
        }
363
 
 
364
 
        r_u.status = _samr_lookup_names(p, &q_u, &r_u);
365
 
 
366
 
        /* store the response in the SMB stream */
367
 
        if(!samr_io_r_lookup_names("", &r_u, rdata, 0)) {
368
 
                DEBUG(0,("api_samr_lookup_names: unable to marshall SAMR_R_LOOKUP_NAMES.\n"));
369
 
                return False;
370
 
        }
371
 
 
372
 
        return True;
373
 
}
374
 
 
375
 
/*******************************************************************
376
 
 api_samr_chgpasswd_user
377
 
 ********************************************************************/
378
 
 
379
 
static BOOL api_samr_chgpasswd_user(pipes_struct *p)
380
 
{
381
 
        SAMR_Q_CHGPASSWD_USER q_u;
382
 
        SAMR_R_CHGPASSWD_USER r_u;
383
 
        prs_struct *data = &p->in_data.data;
384
 
        prs_struct *rdata = &p->out_data.rdata;
385
 
 
386
 
        ZERO_STRUCT(q_u);
387
 
        ZERO_STRUCT(r_u);
388
 
 
389
 
        /* change password request */
390
 
        if (!samr_io_q_chgpasswd_user("", &q_u, data, 0)) {
391
 
                DEBUG(0,("api_samr_chgpasswd_user: Failed to unmarshall SAMR_Q_CHGPASSWD_USER.\n"));
392
 
                return False;
393
 
        }
394
 
 
395
 
        r_u.status = _samr_chgpasswd_user(p, &q_u, &r_u);
396
 
 
397
 
        /* store the response in the SMB stream */
398
 
        if(!samr_io_r_chgpasswd_user("", &r_u, rdata, 0)) {
399
 
                DEBUG(0,("api_samr_chgpasswd_user: Failed to marshall SAMR_R_CHGPASSWD_USER.\n" ));
400
 
                return False;
401
 
        }
402
 
 
403
 
        return True;
404
 
}
405
 
 
406
 
/*******************************************************************
407
 
 api_samr_lookup_rids
408
 
 ********************************************************************/
409
 
 
410
 
static BOOL api_samr_lookup_rids(pipes_struct *p)
411
 
{
412
 
        SAMR_Q_LOOKUP_RIDS q_u;
413
 
        SAMR_R_LOOKUP_RIDS r_u;
414
 
        prs_struct *data = &p->in_data.data;
415
 
        prs_struct *rdata = &p->out_data.rdata;
416
 
 
417
 
        ZERO_STRUCT(q_u);
418
 
        ZERO_STRUCT(r_u);
419
 
 
420
 
        /* grab the samr lookup names */
421
 
        if(!samr_io_q_lookup_rids("", &q_u, data, 0)) {
422
 
                DEBUG(0,("api_samr_lookup_rids: unable to unmarshall SAMR_Q_LOOKUP_RIDS.\n"));
423
 
                return False;
424
 
        }
425
 
 
426
 
        r_u.status = _samr_lookup_rids(p, &q_u, &r_u);
427
 
 
428
 
        /* store the response in the SMB stream */
429
 
        if(!samr_io_r_lookup_rids("", &r_u, rdata, 0)) {
430
 
                DEBUG(0,("api_samr_lookup_rids: unable to marshall SAMR_R_LOOKUP_RIDS.\n"));
431
 
                return False;
432
 
        }
433
 
 
434
 
        return True;
435
 
}
436
 
 
437
 
/*******************************************************************
438
 
 api_samr_open_user
439
 
 ********************************************************************/
440
 
 
441
 
static BOOL api_samr_open_user(pipes_struct *p)
442
 
{
443
 
        SAMR_Q_OPEN_USER q_u;
444
 
        SAMR_R_OPEN_USER r_u;
445
 
        prs_struct *data = &p->in_data.data;
446
 
        prs_struct *rdata = &p->out_data.rdata;
447
 
 
448
 
        ZERO_STRUCT(q_u);
449
 
        ZERO_STRUCT(r_u);
450
 
 
451
 
        if(!samr_io_q_open_user("", &q_u, data, 0)) {
452
 
                DEBUG(0,("api_samr_open_user: unable to unmarshall SAMR_Q_OPEN_USER.\n"));
453
 
                return False;
454
 
        }
455
 
 
456
 
        r_u.status = _samr_open_user(p, &q_u, &r_u);
457
 
 
458
 
        /* store the response in the SMB stream */
459
 
        if(!samr_io_r_open_user("", &r_u, rdata, 0)) {
460
 
                DEBUG(0,("api_samr_open_user: unable to marshall SAMR_R_OPEN_USER.\n"));
461
 
                return False;
462
 
        }
463
 
 
464
 
        return True;
465
 
}
466
 
 
467
 
/*******************************************************************
468
 
 api_samr_query_userinfo
469
 
 ********************************************************************/
470
 
 
471
 
static BOOL api_samr_query_userinfo(pipes_struct *p)
472
 
{
473
 
        SAMR_Q_QUERY_USERINFO q_u;
474
 
        SAMR_R_QUERY_USERINFO r_u;
475
 
        prs_struct *data = &p->in_data.data;
476
 
        prs_struct *rdata = &p->out_data.rdata;
477
 
 
478
 
        ZERO_STRUCT(q_u);
479
 
        ZERO_STRUCT(r_u);
480
 
 
481
 
        if(!samr_io_q_query_userinfo("", &q_u, data, 0)){
482
 
                DEBUG(0,("api_samr_query_userinfo: unable to unmarshall SAMR_Q_QUERY_USERINFO.\n"));
483
 
                return False;
484
 
        }
485
 
 
486
 
        r_u.status = _samr_query_userinfo(p, &q_u, &r_u);
487
 
 
488
 
        /* store the response in the SMB stream */
489
 
        if(!samr_io_r_query_userinfo("", &r_u, rdata, 0)) {
490
 
                DEBUG(0,("api_samr_query_userinfo: unable to marshall SAMR_R_QUERY_USERINFO.\n"));
491
 
                return False;
492
 
        }
493
 
 
494
 
        return True;
495
 
}
496
 
 
497
 
/*******************************************************************
498
 
 api_samr_query_usergroups
499
 
 ********************************************************************/
500
 
 
501
 
static BOOL api_samr_query_usergroups(pipes_struct *p)
502
 
{
503
 
        SAMR_Q_QUERY_USERGROUPS q_u;
504
 
        SAMR_R_QUERY_USERGROUPS r_u;
505
 
        prs_struct *data = &p->in_data.data;
506
 
        prs_struct *rdata = &p->out_data.rdata;
507
 
 
508
 
        ZERO_STRUCT(q_u);
509
 
        ZERO_STRUCT(r_u);
510
 
 
511
 
        if(!samr_io_q_query_usergroups("", &q_u, data, 0)) {
512
 
                DEBUG(0,("api_samr_query_usergroups: unable to unmarshall SAMR_Q_QUERY_USERGROUPS.\n"));
513
 
                return False;
514
 
        }
515
 
 
516
 
        r_u.status = _samr_query_usergroups(p, &q_u, &r_u);
517
 
 
518
 
        /* store the response in the SMB stream */
519
 
        if(!samr_io_r_query_usergroups("", &r_u, rdata, 0)) {
520
 
                DEBUG(0,("api_samr_query_usergroups: unable to marshall SAMR_R_QUERY_USERGROUPS.\n"));
521
 
                return False;
522
 
        }
523
 
 
524
 
        return True;
525
 
}
526
 
 
527
 
/*******************************************************************
528
 
 api_samr_query_domain_info
529
 
 ********************************************************************/
530
 
 
531
 
static BOOL api_samr_query_domain_info(pipes_struct *p)
532
 
{
533
 
        SAMR_Q_QUERY_DOMAIN_INFO q_u;
534
 
        SAMR_R_QUERY_DOMAIN_INFO r_u;
535
 
        prs_struct *data = &p->in_data.data;
536
 
        prs_struct *rdata = &p->out_data.rdata;
537
 
 
538
 
        ZERO_STRUCT(q_u);
539
 
        ZERO_STRUCT(r_u);
540
 
 
541
 
        if(!samr_io_q_query_domain_info("", &q_u, data, 0)) {
542
 
                DEBUG(0,("api_samr_query_domain_info: unable to unmarshall SAMR_Q_QUERY_DOMAIN_INFO.\n"));
543
 
                return False;
544
 
        }
545
 
 
546
 
        r_u.status = _samr_query_domain_info(p, &q_u, &r_u);
547
 
 
548
 
        /* store the response in the SMB stream */
549
 
        if(!samr_io_r_query_domain_info("", &r_u, rdata, 0)) {
550
 
                DEBUG(0,("api_samr_query_domain_info: unable to marshall SAMR_R_QUERY_DOMAIN_INFO.\n"));
551
 
                return False;
552
 
        }
553
 
 
554
 
        return True;
555
 
}
556
 
 
557
 
/*******************************************************************
558
 
 api_samr_create_user
559
 
 ********************************************************************/
560
 
 
561
 
static BOOL api_samr_create_user(pipes_struct *p)
562
 
{
563
 
        prs_struct *data = &p->in_data.data;
564
 
        prs_struct *rdata = &p->out_data.rdata;
565
 
 
566
 
        SAMR_Q_CREATE_USER q_u;
567
 
        SAMR_R_CREATE_USER r_u;
568
 
 
569
 
        ZERO_STRUCT(q_u);
570
 
        ZERO_STRUCT(r_u);
571
 
 
572
 
        /* grab the samr create user */
573
 
        if (!samr_io_q_create_user("", &q_u, data, 0)) {
574
 
                DEBUG(0,("api_samr_create_user: Unable to unmarshall SAMR_Q_CREATE_USER.\n"));
575
 
                return False;
576
 
        }
577
 
 
578
 
        r_u.status=_samr_create_user(p, &q_u, &r_u);
579
 
 
580
 
        /* store the response in the SMB stream */
581
 
        if(!samr_io_r_create_user("", &r_u, rdata, 0)) {
582
 
                DEBUG(0,("api_samr_create_user: Unable to marshall SAMR_R_CREATE_USER.\n"));
583
 
                return False;
584
 
        }
585
 
 
586
 
        return True;
587
 
}
588
 
 
589
 
/*******************************************************************
590
 
 api_samr_connect_anon
591
 
 ********************************************************************/
592
 
 
593
 
static BOOL api_samr_connect_anon(pipes_struct *p)
594
 
{
595
 
        SAMR_Q_CONNECT_ANON q_u;
596
 
        SAMR_R_CONNECT_ANON r_u;
597
 
        prs_struct *data = &p->in_data.data;
598
 
        prs_struct *rdata = &p->out_data.rdata;
599
 
 
600
 
        ZERO_STRUCT(q_u);
601
 
        ZERO_STRUCT(r_u);
602
 
 
603
 
        /* grab the samr open policy */
604
 
        if(!samr_io_q_connect_anon("", &q_u, data, 0)) {
605
 
                DEBUG(0,("api_samr_connect_anon: unable to unmarshall SAMR_Q_CONNECT_ANON.\n"));
606
 
                return False;
607
 
        }
608
 
 
609
 
        r_u.status = _samr_connect_anon(p, &q_u, &r_u);
610
 
 
611
 
        /* store the response in the SMB stream */
612
 
        if(!samr_io_r_connect_anon("", &r_u, rdata, 0)) {
613
 
                DEBUG(0,("api_samr_connect_anon: unable to marshall SAMR_R_CONNECT_ANON.\n"));
614
 
                return False;
615
 
        }
616
 
 
617
 
        return True;
618
 
}
619
 
 
620
 
/*******************************************************************
621
 
 api_samr_connect
622
 
 ********************************************************************/
623
 
 
624
 
static BOOL api_samr_connect(pipes_struct *p)
625
 
{
626
 
        SAMR_Q_CONNECT q_u;
627
 
        SAMR_R_CONNECT r_u;
628
 
        prs_struct *data = &p->in_data.data;
629
 
        prs_struct *rdata = &p->out_data.rdata;
630
 
 
631
 
        ZERO_STRUCT(q_u);
632
 
        ZERO_STRUCT(r_u);
633
 
 
634
 
        /* grab the samr open policy */
635
 
        if(!samr_io_q_connect("", &q_u, data, 0)) {
636
 
                DEBUG(0,("api_samr_connect: unable to unmarshall SAMR_Q_CONNECT.\n"));
637
 
                return False;
638
 
        }
639
 
 
640
 
        r_u.status = _samr_connect(p, &q_u, &r_u);
641
 
 
642
 
        /* store the response in the SMB stream */
643
 
        if(!samr_io_r_connect("", &r_u, rdata, 0)) {
644
 
                DEBUG(0,("api_samr_connect: unable to marshall SAMR_R_CONNECT.\n"));
645
 
                return False;
646
 
        }
647
 
 
648
 
        return True;
649
 
}
650
 
 
651
 
/*******************************************************************
652
 
 api_samr_connect4
653
 
 ********************************************************************/
654
 
 
655
 
static BOOL api_samr_connect4(pipes_struct *p)
656
 
{
657
 
        SAMR_Q_CONNECT4 q_u;
658
 
        SAMR_R_CONNECT4 r_u;
659
 
        prs_struct *data = &p->in_data.data;
660
 
        prs_struct *rdata = &p->out_data.rdata;
661
 
 
662
 
        ZERO_STRUCT(q_u);
663
 
        ZERO_STRUCT(r_u);
664
 
 
665
 
        /* grab the samr open policy */
666
 
        if(!samr_io_q_connect4("", &q_u, data, 0)) {
667
 
                DEBUG(0,("api_samr_connect4: unable to unmarshall SAMR_Q_CONNECT4.\n"));
668
 
                return False;
669
 
        }
670
 
 
671
 
        r_u.status = _samr_connect4(p, &q_u, &r_u);
672
 
 
673
 
        /* store the response in the SMB stream */
674
 
        if(!samr_io_r_connect4("", &r_u, rdata, 0)) {
675
 
                DEBUG(0,("api_samr_connect4: unable to marshall SAMR_R_CONNECT4.\n"));
676
 
                return False;
677
 
        }
678
 
 
679
 
        return True;
680
 
}
681
 
 
682
 
/*******************************************************************
683
 
 api_samr_chgpasswd_user3
684
 
 ********************************************************************/
685
 
 
686
 
static BOOL api_samr_chgpasswd_user3(pipes_struct *p)
687
 
{
688
 
        SAMR_Q_CHGPASSWD_USER3 q_u;
689
 
        SAMR_R_CHGPASSWD_USER3 r_u;
690
 
        prs_struct *data = &p->in_data.data;
691
 
        prs_struct *rdata = &p->out_data.rdata;
692
 
 
693
 
        ZERO_STRUCT(q_u);
694
 
        ZERO_STRUCT(r_u);
695
 
 
696
 
        /* change password request */
697
 
        if (!samr_io_q_chgpasswd_user3("", &q_u, data, 0)) {
698
 
                DEBUG(0,("api_samr_chgpasswd_user3: Failed to unmarshall SAMR_Q_CHGPASSWD_USER3.\n"));
699
 
                return False;
700
 
        }
701
 
 
702
 
        r_u.status = _samr_chgpasswd_user3(p, &q_u, &r_u);
703
 
 
704
 
        /* store the response in the SMB stream */
705
 
        if(!samr_io_r_chgpasswd_user3("", &r_u, rdata, 0)) {
706
 
                DEBUG(0,("api_samr_chgpasswd_user3: Failed to marshall SAMR_R_CHGPASSWD_USER3.\n" ));
707
 
                return False;
708
 
        }
709
 
 
710
 
        return True;
711
 
}
712
 
 
713
 
/*******************************************************************
714
 
 api_samr_connect5
715
 
 ********************************************************************/
716
 
 
717
 
static BOOL api_samr_connect5(pipes_struct *p)
718
 
{
719
 
        SAMR_Q_CONNECT5 q_u;
720
 
        SAMR_R_CONNECT5 r_u;
721
 
        prs_struct *data = &p->in_data.data;
722
 
        prs_struct *rdata = &p->out_data.rdata;
723
 
 
724
 
        ZERO_STRUCT(q_u);
725
 
        ZERO_STRUCT(r_u);
726
 
 
727
 
        /* grab the samr open policy */
728
 
        if(!samr_io_q_connect5("", &q_u, data, 0)) {
729
 
                DEBUG(0,("api_samr_connect5: unable to unmarshall SAMR_Q_CONNECT5.\n"));
730
 
                return False;
731
 
        }
732
 
 
733
 
        r_u.status = _samr_connect5(p, &q_u, &r_u);
734
 
 
735
 
        /* store the response in the SMB stream */
736
 
        if(!samr_io_r_connect5("", &r_u, rdata, 0)) {
737
 
                DEBUG(0,("api_samr_connect5: unable to marshall SAMR_R_CONNECT5.\n"));
738
 
                return False;
739
 
        }
740
 
 
741
 
        return True;
742
 
}
743
 
 
744
 
/**********************************************************************
745
 
 api_samr_lookup_domain
746
 
 **********************************************************************/
747
 
 
748
 
static BOOL api_samr_lookup_domain(pipes_struct *p)
749
 
{
750
 
        SAMR_Q_LOOKUP_DOMAIN q_u;
751
 
        SAMR_R_LOOKUP_DOMAIN r_u;
752
 
        prs_struct *data = &p->in_data.data;
753
 
        prs_struct *rdata = &p->out_data.rdata;
754
 
  
755
 
        ZERO_STRUCT(q_u);
756
 
        ZERO_STRUCT(r_u);
757
 
 
758
 
        if(!samr_io_q_lookup_domain("", &q_u, data, 0)) {
759
 
                DEBUG(0,("api_samr_lookup_domain: Unable to unmarshall SAMR_Q_LOOKUP_DOMAIN.\n"));
760
 
                return False;
761
 
        }
762
 
 
763
 
        r_u.status = _samr_lookup_domain(p, &q_u, &r_u);
764
 
        
765
 
        if(!samr_io_r_lookup_domain("", &r_u, rdata, 0)){
766
 
                DEBUG(0,("api_samr_lookup_domain: Unable to marshall SAMR_R_LOOKUP_DOMAIN.\n"));
767
 
                return False;
768
 
        }
769
 
        
770
 
        return True;
771
 
}
772
 
 
773
 
/**********************************************************************
774
 
 api_samr_enum_domains
775
 
 **********************************************************************/
776
 
 
777
 
static BOOL api_samr_enum_domains(pipes_struct *p)
778
 
{
779
 
        SAMR_Q_ENUM_DOMAINS q_u;
780
 
        SAMR_R_ENUM_DOMAINS r_u;
781
 
        prs_struct *data = &p->in_data.data;
782
 
        prs_struct *rdata = &p->out_data.rdata;
783
 
  
784
 
        ZERO_STRUCT(q_u);
785
 
        ZERO_STRUCT(r_u);
786
 
 
787
 
        if(!samr_io_q_enum_domains("", &q_u, data, 0)) {
788
 
                DEBUG(0,("api_samr_enum_domains: Unable to unmarshall SAMR_Q_ENUM_DOMAINS.\n"));
789
 
                return False;
790
 
        }
791
 
 
792
 
        r_u.status = _samr_enum_domains(p, &q_u, &r_u);
793
 
 
794
 
        if(!samr_io_r_enum_domains("", &r_u, rdata, 0)) {
795
 
                DEBUG(0,("api_samr_enum_domains: Unable to marshall SAMR_R_ENUM_DOMAINS.\n"));
796
 
                return False;
797
 
        }
798
 
        
799
 
        return True;
800
 
}
801
 
 
802
 
/*******************************************************************
803
 
 api_samr_open_alias
804
 
 ********************************************************************/
805
 
 
806
 
static BOOL api_samr_open_alias(pipes_struct *p)
807
 
{
808
 
        SAMR_Q_OPEN_ALIAS q_u;
809
 
        SAMR_R_OPEN_ALIAS r_u;
810
 
        prs_struct *data = &p->in_data.data;
811
 
        prs_struct *rdata = &p->out_data.rdata;
812
 
 
813
 
        ZERO_STRUCT(q_u);
814
 
        ZERO_STRUCT(r_u);
815
 
 
816
 
        /* grab the samr open policy */
817
 
        if(!samr_io_q_open_alias("", &q_u, data, 0)) {
818
 
                DEBUG(0,("api_samr_open_alias: Unable to unmarshall SAMR_Q_OPEN_ALIAS.\n"));
819
 
                return False;
820
 
        }
821
 
 
822
 
        r_u.status=_samr_open_alias(p, &q_u, &r_u);
823
 
 
824
 
        /* store the response in the SMB stream */
825
 
        if(!samr_io_r_open_alias("", &r_u, rdata, 0)) {
826
 
                DEBUG(0,("api_samr_open_alias: Unable to marshall SAMR_R_OPEN_ALIAS.\n"));
827
 
                return False;
828
 
        }
829
 
        
830
 
        return True;
831
 
}
832
 
 
833
 
/*******************************************************************
834
 
 api_samr_set_userinfo
835
 
 ********************************************************************/
836
 
 
837
 
static BOOL api_samr_set_userinfo(pipes_struct *p)
838
 
{
839
 
        SAMR_Q_SET_USERINFO q_u;
840
 
        SAMR_R_SET_USERINFO r_u;
841
 
        prs_struct *data = &p->in_data.data;
842
 
        prs_struct *rdata = &p->out_data.rdata;
843
 
 
844
 
        ZERO_STRUCT(q_u);
845
 
        ZERO_STRUCT(r_u);
846
 
 
847
 
        if (!samr_io_q_set_userinfo("", &q_u, data, 0)) {
848
 
                DEBUG(0,("api_samr_set_userinfo: Unable to unmarshall SAMR_Q_SET_USERINFO.\n"));
849
 
                /* Fix for W2K SP2 */
850
 
                /* what is that status-code ? - gd */
851
 
                if (q_u.switch_value == 0x1a) {
852
 
                        setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_INVALID_TAG));
853
 
                        return True;
854
 
                }
855
 
                return False;
856
 
        }
857
 
 
858
 
        r_u.status = _samr_set_userinfo(p, &q_u, &r_u);
859
 
 
860
 
        if(!samr_io_r_set_userinfo("", &r_u, rdata, 0)) {
861
 
                DEBUG(0,("api_samr_set_userinfo: Unable to marshall SAMR_R_SET_USERINFO.\n"));
862
 
                return False;
863
 
        }
864
 
 
865
 
        return True;
866
 
}
867
 
 
868
 
/*******************************************************************
869
 
 api_samr_set_userinfo2
870
 
 ********************************************************************/
871
 
 
872
 
static BOOL api_samr_set_userinfo2(pipes_struct *p)
873
 
{
874
 
        SAMR_Q_SET_USERINFO2 q_u;
875
 
        SAMR_R_SET_USERINFO2 r_u;
876
 
 
877
 
        prs_struct *data = &p->in_data.data;
878
 
        prs_struct *rdata = &p->out_data.rdata;
879
 
 
880
 
        ZERO_STRUCT(q_u);
881
 
        ZERO_STRUCT(r_u);
882
 
 
883
 
        if (!samr_io_q_set_userinfo2("", &q_u, data, 0)) {
884
 
                DEBUG(0,("api_samr_set_userinfo2: Unable to unmarshall SAMR_Q_SET_USERINFO2.\n"));
885
 
                return False;
886
 
        }
887
 
 
888
 
        r_u.status = _samr_set_userinfo2(p, &q_u, &r_u);
889
 
 
890
 
        if(!samr_io_r_set_userinfo2("", &r_u, rdata, 0)) {
891
 
                DEBUG(0,("api_samr_set_userinfo2: Unable to marshall SAMR_R_SET_USERINFO2.\n"));
892
 
                return False;
893
 
        }
894
 
 
895
 
        return True;
896
 
}
897
 
 
898
 
/*******************************************************************
899
 
 api_samr_query_useraliases
900
 
 ********************************************************************/
901
 
 
902
 
static BOOL api_samr_query_useraliases(pipes_struct *p)
903
 
{
904
 
        SAMR_Q_QUERY_USERALIASES q_u;
905
 
        SAMR_R_QUERY_USERALIASES r_u;
906
 
 
907
 
        prs_struct *data = &p->in_data.data;
908
 
        prs_struct *rdata = &p->out_data.rdata;
909
 
 
910
 
        ZERO_STRUCT(q_u);
911
 
        ZERO_STRUCT(r_u);
912
 
 
913
 
        if (!samr_io_q_query_useraliases("", &q_u, data, 0)) {
914
 
                DEBUG(0,("api_samr_query_useraliases:  Unable to unmarshall SAMR_Q_QUERY_USERALIASES.\n"));
915
 
                return False;
916
 
        }
917
 
 
918
 
        r_u.status = _samr_query_useraliases(p, &q_u, &r_u);
919
 
 
920
 
        if (! samr_io_r_query_useraliases("", &r_u, rdata, 0)) {
921
 
                DEBUG(0,("api_samr_query_useraliases:  Unable to nmarshall SAMR_R_QUERY_USERALIASES.\n"));
922
 
                return False;
923
 
        }
924
 
 
925
 
        return True;
926
 
}
927
 
 
928
 
/*******************************************************************
929
 
 api_samr_query_aliasmem
930
 
 ********************************************************************/
931
 
 
932
 
static BOOL api_samr_query_aliasmem(pipes_struct *p)
933
 
{
934
 
        SAMR_Q_QUERY_ALIASMEM q_u;
935
 
        SAMR_R_QUERY_ALIASMEM r_u;
936
 
 
937
 
        prs_struct *data = &p->in_data.data;
938
 
        prs_struct *rdata = &p->out_data.rdata;
939
 
 
940
 
        ZERO_STRUCT(q_u);
941
 
        ZERO_STRUCT(r_u);
942
 
 
943
 
        if (!samr_io_q_query_aliasmem("", &q_u, data, 0)) {
944
 
                DEBUG(0,("api_samr_query_aliasmem: unable to unmarshall SAMR_Q_QUERY_ALIASMEM.\n"));
945
 
                return False;
946
 
        }
947
 
 
948
 
        r_u.status = _samr_query_aliasmem(p, &q_u, &r_u);
949
 
 
950
 
        if (!samr_io_r_query_aliasmem("", &r_u, rdata, 0)) {
951
 
                DEBUG(0,("api_samr_query_aliasmem: unable to marshall SAMR_R_QUERY_ALIASMEM.\n"));
952
 
                return False;
953
 
        }
954
 
 
955
 
        return True;
956
 
}
957
 
 
958
 
/*******************************************************************
959
 
 api_samr_query_groupmem
960
 
 ********************************************************************/
961
 
 
962
 
static BOOL api_samr_query_groupmem(pipes_struct *p)
963
 
{
964
 
        SAMR_Q_QUERY_GROUPMEM q_u;
965
 
        SAMR_R_QUERY_GROUPMEM r_u;
966
 
 
967
 
        prs_struct *data = &p->in_data.data;
968
 
        prs_struct *rdata = &p->out_data.rdata;
969
 
 
970
 
        ZERO_STRUCT(q_u);
971
 
        ZERO_STRUCT(r_u);
972
 
 
973
 
        if (!samr_io_q_query_groupmem("", &q_u, data, 0)) {
974
 
                DEBUG(0,("api_samr_query_groupmem: unable to unmarshall SAMR_Q_QUERY_GROUPMEM.\n"));
975
 
                return False;
976
 
        }
977
 
 
978
 
        r_u.status = _samr_query_groupmem(p, &q_u, &r_u);
979
 
 
980
 
        if (!samr_io_r_query_groupmem("", &r_u, rdata, 0)) {
981
 
                DEBUG(0,("api_samr_query_groupmem: unable to marshall SAMR_R_QUERY_GROUPMEM.\n"));
982
 
                return False;
983
 
        }
984
 
 
985
 
        return True;
986
 
}
987
 
 
988
 
/*******************************************************************
989
 
 api_samr_add_aliasmem
990
 
 ********************************************************************/
991
 
 
992
 
static BOOL api_samr_add_aliasmem(pipes_struct *p)
993
 
{
994
 
        SAMR_Q_ADD_ALIASMEM q_u;
995
 
        SAMR_R_ADD_ALIASMEM r_u;
996
 
 
997
 
        prs_struct *data = &p->in_data.data;
998
 
        prs_struct *rdata = &p->out_data.rdata;
999
 
 
1000
 
        ZERO_STRUCT(q_u);
1001
 
        ZERO_STRUCT(r_u);
1002
 
 
1003
 
        if (!samr_io_q_add_aliasmem("", &q_u, data, 0)) {
1004
 
                DEBUG(0,("api_samr_add_aliasmem: unable to unmarshall SAMR_Q_ADD_ALIASMEM.\n"));
1005
 
                return False;
1006
 
        }
1007
 
 
1008
 
        r_u.status = _samr_add_aliasmem(p, &q_u, &r_u);
1009
 
 
1010
 
        if (!samr_io_r_add_aliasmem("", &r_u, rdata, 0)) {
1011
 
                DEBUG(0,("api_samr_add_aliasmem: unable to marshall SAMR_R_ADD_ALIASMEM.\n"));
1012
 
                return False;
1013
 
        }
1014
 
 
1015
 
        return True;
1016
 
}
1017
 
 
1018
 
/*******************************************************************
1019
 
 api_samr_del_aliasmem
1020
 
 ********************************************************************/
1021
 
 
1022
 
static BOOL api_samr_del_aliasmem(pipes_struct *p)
1023
 
{
1024
 
        SAMR_Q_DEL_ALIASMEM q_u;
1025
 
        SAMR_R_DEL_ALIASMEM r_u;
1026
 
 
1027
 
        prs_struct *data = &p->in_data.data;
1028
 
        prs_struct *rdata = &p->out_data.rdata;
1029
 
 
1030
 
        ZERO_STRUCT(q_u);
1031
 
        ZERO_STRUCT(r_u);
1032
 
 
1033
 
        if (!samr_io_q_del_aliasmem("", &q_u, data, 0)) {
1034
 
                DEBUG(0,("api_samr_del_aliasmem: unable to unmarshall SAMR_Q_DEL_ALIASMEM.\n"));
1035
 
                return False;
1036
 
        }
1037
 
 
1038
 
        r_u.status = _samr_del_aliasmem(p, &q_u, &r_u);
1039
 
 
1040
 
        if (!samr_io_r_del_aliasmem("", &r_u, rdata, 0)) {
1041
 
                DEBUG(0,("api_samr_del_aliasmem: unable to marshall SAMR_R_DEL_ALIASMEM.\n"));
1042
 
                return False;
1043
 
        }
1044
 
 
1045
 
        return True;
1046
 
}
1047
 
 
1048
 
/*******************************************************************
1049
 
 api_samr_add_groupmem
1050
 
 ********************************************************************/
1051
 
 
1052
 
static BOOL api_samr_add_groupmem(pipes_struct *p)
1053
 
{
1054
 
        SAMR_Q_ADD_GROUPMEM q_u;
1055
 
        SAMR_R_ADD_GROUPMEM r_u;
1056
 
 
1057
 
        prs_struct *data = &p->in_data.data;
1058
 
        prs_struct *rdata = &p->out_data.rdata;
1059
 
 
1060
 
        ZERO_STRUCT(q_u);
1061
 
        ZERO_STRUCT(r_u);
1062
 
 
1063
 
        if (!samr_io_q_add_groupmem("", &q_u, data, 0)) {
1064
 
                DEBUG(0,("api_samr_add_groupmem: unable to unmarshall SAMR_Q_ADD_GROUPMEM.\n"));
1065
 
                return False;
1066
 
        }
1067
 
 
1068
 
        r_u.status = _samr_add_groupmem(p, &q_u, &r_u);
1069
 
 
1070
 
        if (!samr_io_r_add_groupmem("", &r_u, rdata, 0)) {
1071
 
                DEBUG(0,("api_samr_add_groupmem: unable to marshall SAMR_R_ADD_GROUPMEM.\n"));
1072
 
                return False;
1073
 
        }
1074
 
 
1075
 
        return True;
1076
 
}
1077
 
 
1078
 
/*******************************************************************
1079
 
 api_samr_del_groupmem
1080
 
 ********************************************************************/
1081
 
 
1082
 
static BOOL api_samr_del_groupmem(pipes_struct *p)
1083
 
{
1084
 
        SAMR_Q_DEL_GROUPMEM q_u;
1085
 
        SAMR_R_DEL_GROUPMEM r_u;
1086
 
 
1087
 
        prs_struct *data = &p->in_data.data;
1088
 
        prs_struct *rdata = &p->out_data.rdata;
1089
 
 
1090
 
        ZERO_STRUCT(q_u);
1091
 
        ZERO_STRUCT(r_u);
1092
 
 
1093
 
        if (!samr_io_q_del_groupmem("", &q_u, data, 0)) {
1094
 
                DEBUG(0,("api_samr_del_groupmem: unable to unmarshall SAMR_Q_DEL_GROUPMEM.\n"));
1095
 
                return False;
1096
 
        }
1097
 
 
1098
 
        r_u.status = _samr_del_groupmem(p, &q_u, &r_u);
1099
 
 
1100
 
        if (!samr_io_r_del_groupmem("", &r_u, rdata, 0)) {
1101
 
                DEBUG(0,("api_samr_del_groupmem: unable to marshall SAMR_R_DEL_GROUPMEM.\n"));
1102
 
                return False;
1103
 
        }
1104
 
 
1105
 
        return True;
1106
 
}
1107
 
 
1108
 
/*******************************************************************
1109
 
 api_samr_delete_dom_user
1110
 
 ********************************************************************/
1111
 
 
1112
 
static BOOL api_samr_delete_dom_user(pipes_struct *p)
1113
 
{
1114
 
        SAMR_Q_DELETE_DOM_USER q_u;
1115
 
        SAMR_R_DELETE_DOM_USER r_u;
1116
 
 
1117
 
        prs_struct *data = &p->in_data.data;
1118
 
        prs_struct *rdata = &p->out_data.rdata;
1119
 
 
1120
 
        ZERO_STRUCT(q_u);
1121
 
        ZERO_STRUCT(r_u);
1122
 
 
1123
 
        if (!samr_io_q_delete_dom_user("", &q_u, data, 0)) {
1124
 
                DEBUG(0,("api_samr_delete_dom_user: unable to unmarshall SAMR_Q_DELETE_DOM_USER.\n"));
1125
 
                return False;
1126
 
        }
1127
 
 
1128
 
        r_u.status = _samr_delete_dom_user(p, &q_u, &r_u);
1129
 
 
1130
 
        if (!samr_io_r_delete_dom_user("", &r_u, rdata, 0)) {
1131
 
                DEBUG(0,("api_samr_delete_dom_user: unable to marshall SAMR_R_DELETE_DOM_USER.\n"));
1132
 
                return False;
1133
 
        }
1134
 
 
1135
 
        return True;
1136
 
}
1137
 
 
1138
 
/*******************************************************************
1139
 
 api_samr_delete_dom_group
1140
 
 ********************************************************************/
1141
 
 
1142
 
static BOOL api_samr_delete_dom_group(pipes_struct *p)
1143
 
{
1144
 
        SAMR_Q_DELETE_DOM_GROUP q_u;
1145
 
        SAMR_R_DELETE_DOM_GROUP r_u;
1146
 
 
1147
 
        prs_struct *data = &p->in_data.data;
1148
 
        prs_struct *rdata = &p->out_data.rdata;
1149
 
 
1150
 
        ZERO_STRUCT(q_u);
1151
 
        ZERO_STRUCT(r_u);
1152
 
 
1153
 
        if (!samr_io_q_delete_dom_group("", &q_u, data, 0)) {
1154
 
                DEBUG(0,("api_samr_delete_dom_group: unable to unmarshall SAMR_Q_DELETE_DOM_GROUP.\n"));
1155
 
                return False;
1156
 
        }
1157
 
 
1158
 
        r_u.status = _samr_delete_dom_group(p, &q_u, &r_u);
1159
 
 
1160
 
        if (!samr_io_r_delete_dom_group("", &r_u, rdata, 0)) {
1161
 
                DEBUG(0,("api_samr_delete_dom_group: unable to marshall SAMR_R_DELETE_DOM_GROUP.\n"));
1162
 
                return False;
1163
 
        }
1164
 
 
1165
 
        return True;
1166
 
}
1167
 
 
1168
 
/*******************************************************************
1169
 
 api_samr_delete_dom_alias
1170
 
 ********************************************************************/
1171
 
 
1172
 
static BOOL api_samr_delete_dom_alias(pipes_struct *p)
1173
 
{
1174
 
        SAMR_Q_DELETE_DOM_ALIAS q_u;
1175
 
        SAMR_R_DELETE_DOM_ALIAS r_u;
1176
 
 
1177
 
        prs_struct *data = &p->in_data.data;
1178
 
        prs_struct *rdata = &p->out_data.rdata;
1179
 
 
1180
 
        ZERO_STRUCT(q_u);
1181
 
        ZERO_STRUCT(r_u);
1182
 
 
1183
 
        if (!samr_io_q_delete_dom_alias("", &q_u, data, 0)) {
1184
 
                DEBUG(0,("api_samr_delete_dom_alias: unable to unmarshall SAMR_Q_DELETE_DOM_ALIAS.\n"));
1185
 
                return False;
1186
 
        }
1187
 
 
1188
 
        r_u.status = _samr_delete_dom_alias(p, &q_u, &r_u);
1189
 
 
1190
 
        if (!samr_io_r_delete_dom_alias("", &r_u, rdata, 0)) {
1191
 
                DEBUG(0,("api_samr_delete_dom_alias: unable to marshall SAMR_R_DELETE_DOM_ALIAS.\n"));
1192
 
                return False;
1193
 
        }
1194
 
 
1195
 
        return True;
1196
 
}
1197
 
 
1198
 
/*******************************************************************
1199
 
 api_samr_create_dom_group
1200
 
 ********************************************************************/
1201
 
 
1202
 
static BOOL api_samr_create_dom_group(pipes_struct *p)
1203
 
{
1204
 
        SAMR_Q_CREATE_DOM_GROUP q_u;
1205
 
        SAMR_R_CREATE_DOM_GROUP r_u;
1206
 
 
1207
 
        prs_struct *data = &p->in_data.data;
1208
 
        prs_struct *rdata = &p->out_data.rdata;
1209
 
 
1210
 
        ZERO_STRUCT(q_u);
1211
 
        ZERO_STRUCT(r_u);
1212
 
 
1213
 
        if (!samr_io_q_create_dom_group("", &q_u, data, 0)) {
1214
 
                DEBUG(0,("api_samr_create_dom_group: unable to unmarshall SAMR_Q_CREATE_DOM_GROUP.\n"));
1215
 
                return False;
1216
 
        }
1217
 
 
1218
 
        r_u.status = _samr_create_dom_group(p, &q_u, &r_u);
1219
 
 
1220
 
        if (!samr_io_r_create_dom_group("", &r_u, rdata, 0)) {
1221
 
                DEBUG(0,("api_samr_create_dom_group: unable to marshall SAMR_R_CREATE_DOM_GROUP.\n"));
1222
 
                return False;
1223
 
        }
1224
 
 
1225
 
        return True;
1226
 
}
1227
 
 
1228
 
/*******************************************************************
1229
 
 api_samr_create_dom_alias
1230
 
 ********************************************************************/
1231
 
 
1232
 
static BOOL api_samr_create_dom_alias(pipes_struct *p)
1233
 
{
1234
 
        SAMR_Q_CREATE_DOM_ALIAS q_u;
1235
 
        SAMR_R_CREATE_DOM_ALIAS r_u;
1236
 
 
1237
 
        prs_struct *data = &p->in_data.data;
1238
 
        prs_struct *rdata = &p->out_data.rdata;
1239
 
 
1240
 
        ZERO_STRUCT(q_u);
1241
 
        ZERO_STRUCT(r_u);
1242
 
 
1243
 
        if (!samr_io_q_create_dom_alias("", &q_u, data, 0)) {
1244
 
                DEBUG(0,("api_samr_create_dom_alias: unable to unmarshall SAMR_Q_CREATE_DOM_ALIAS.\n"));
1245
 
                return False;
1246
 
        }
1247
 
 
1248
 
        r_u.status = _samr_create_dom_alias(p, &q_u, &r_u);
1249
 
 
1250
 
        if (!samr_io_r_create_dom_alias("", &r_u, rdata, 0)) {
1251
 
                DEBUG(0,("api_samr_create_dom_alias: unable to marshall SAMR_R_CREATE_DOM_ALIAS.\n"));
1252
 
                return False;
1253
 
        }
1254
 
 
1255
 
        return True;
1256
 
}
1257
 
 
1258
 
/*******************************************************************
1259
 
 api_samr_query_groupinfo
1260
 
 ********************************************************************/
1261
 
 
1262
 
static BOOL api_samr_query_groupinfo(pipes_struct *p)
1263
 
{
1264
 
        SAMR_Q_QUERY_GROUPINFO q_u;
1265
 
        SAMR_R_QUERY_GROUPINFO r_u;
1266
 
 
1267
 
        prs_struct *data = &p->in_data.data;
1268
 
        prs_struct *rdata = &p->out_data.rdata;
1269
 
 
1270
 
        ZERO_STRUCT(q_u);
1271
 
        ZERO_STRUCT(r_u);
1272
 
 
1273
 
        if (!samr_io_q_query_groupinfo("", &q_u, data, 0)) {
1274
 
                DEBUG(0,("api_samr_query_groupinfo: unable to unmarshall SAMR_Q_QUERY_GROUPINFO.\n"));
1275
 
                return False;
1276
 
        }
1277
 
 
1278
 
        r_u.status = _samr_query_groupinfo(p, &q_u, &r_u);
1279
 
 
1280
 
        if (!samr_io_r_query_groupinfo("", &r_u, rdata, 0)) {
1281
 
                DEBUG(0,("api_samr_query_groupinfo: unable to marshall SAMR_R_QUERY_GROUPINFO.\n"));
1282
 
                return False;
1283
 
        }
1284
 
 
1285
 
        return True;
1286
 
}
1287
 
 
1288
 
/*******************************************************************
1289
 
 api_samr_set_groupinfo
1290
 
 ********************************************************************/
1291
 
 
1292
 
static BOOL api_samr_set_groupinfo(pipes_struct *p)
1293
 
{
1294
 
        SAMR_Q_SET_GROUPINFO q_u;
1295
 
        SAMR_R_SET_GROUPINFO r_u;
1296
 
 
1297
 
        prs_struct *data = &p->in_data.data;
1298
 
        prs_struct *rdata = &p->out_data.rdata;
1299
 
 
1300
 
        ZERO_STRUCT(q_u);
1301
 
        ZERO_STRUCT(r_u);
1302
 
 
1303
 
        if (!samr_io_q_set_groupinfo("", &q_u, data, 0)) {
1304
 
                DEBUG(0,("api_samr_set_groupinfo: unable to unmarshall SAMR_Q_SET_GROUPINFO.\n"));
1305
 
                return False;
1306
 
        }
1307
 
 
1308
 
        r_u.status = _samr_set_groupinfo(p, &q_u, &r_u);
1309
 
 
1310
 
        if (!samr_io_r_set_groupinfo("", &r_u, rdata, 0)) {
1311
 
                DEBUG(0,("api_samr_set_groupinfo: unable to marshall SAMR_R_SET_GROUPINFO.\n"));
1312
 
                return False;
1313
 
        }
1314
 
 
1315
 
        return True;
1316
 
}
1317
 
 
1318
 
/*******************************************************************
1319
 
 api_samr_set_aliasinfo
1320
 
 ********************************************************************/
1321
 
 
1322
 
static BOOL api_samr_set_aliasinfo(pipes_struct *p)
1323
 
{
1324
 
        SAMR_Q_SET_ALIASINFO q_u;
1325
 
        SAMR_R_SET_ALIASINFO r_u;
1326
 
 
1327
 
        prs_struct *data = &p->in_data.data;
1328
 
        prs_struct *rdata = &p->out_data.rdata;
1329
 
 
1330
 
        ZERO_STRUCT(q_u);
1331
 
        ZERO_STRUCT(r_u);
1332
 
 
1333
 
        if (!samr_io_q_set_aliasinfo("", &q_u, data, 0)) {
1334
 
                DEBUG(0,("api_samr_set_aliasinfo: unable to unmarshall SAMR_Q_SET_ALIASINFO.\n"));
1335
 
                return False;
1336
 
        }
1337
 
 
1338
 
        r_u.status = _samr_set_aliasinfo(p, &q_u, &r_u);
1339
 
 
1340
 
        if (!samr_io_r_set_aliasinfo("", &r_u, rdata, 0)) {
1341
 
                DEBUG(0,("api_samr_set_aliasinfo: unable to marshall SAMR_R_SET_ALIASINFO.\n"));
1342
 
                return False;
1343
 
        }
1344
 
 
1345
 
        return True;
1346
 
}
1347
 
 
1348
 
/*******************************************************************
1349
 
 api_samr_get_dom_pwinfo
1350
 
 ********************************************************************/
1351
 
 
1352
 
static BOOL api_samr_get_dom_pwinfo(pipes_struct *p)
1353
 
{
1354
 
        SAMR_Q_GET_DOM_PWINFO q_u;
1355
 
        SAMR_R_GET_DOM_PWINFO r_u;
1356
 
 
1357
 
        prs_struct *data = &p->in_data.data;
1358
 
        prs_struct *rdata = &p->out_data.rdata;
1359
 
 
1360
 
        ZERO_STRUCT(q_u);
1361
 
        ZERO_STRUCT(r_u);
1362
 
 
1363
 
        if (!samr_io_q_get_dom_pwinfo("", &q_u, data, 0)) {
1364
 
                DEBUG(0,("api_samr_get_dom_pwinfo: unable to unmarshall SAMR_Q_GET_DOM_PWINFO.\n"));
1365
 
                return False;
1366
 
        }
1367
 
 
1368
 
        r_u.status = _samr_get_dom_pwinfo(p, &q_u, &r_u);
1369
 
 
1370
 
        if (!samr_io_r_get_dom_pwinfo("", &r_u, rdata, 0)) {
1371
 
                DEBUG(0,("api_samr_get_dom_pwinfo: unable to marshall SAMR_R_GET_DOM_PWINFO.\n"));
1372
 
                return False;
1373
 
        }
1374
 
 
1375
 
        return True;
1376
 
}
1377
 
 
1378
 
/*******************************************************************
1379
 
 api_samr_open_group
1380
 
 ********************************************************************/
1381
 
 
1382
 
static BOOL api_samr_open_group(pipes_struct *p)
1383
 
{
1384
 
        SAMR_Q_OPEN_GROUP q_u;
1385
 
        SAMR_R_OPEN_GROUP r_u;
1386
 
 
1387
 
        prs_struct *data = &p->in_data.data;
1388
 
        prs_struct *rdata = &p->out_data.rdata;
1389
 
 
1390
 
        ZERO_STRUCT(q_u);
1391
 
        ZERO_STRUCT(r_u);
1392
 
 
1393
 
        if (!samr_io_q_open_group("", &q_u, data, 0)) {
1394
 
                DEBUG(0,("api_samr_open_group: unable to unmarshall SAMR_Q_OPEN_GROUP.\n"));
1395
 
                return False;
1396
 
        }
1397
 
 
1398
 
        r_u.status = _samr_open_group(p, &q_u, &r_u);
1399
 
 
1400
 
        if (!samr_io_r_open_group("", &r_u, rdata, 0)) {
1401
 
                DEBUG(0,("api_samr_open_group: unable to marshall SAMR_R_OPEN_GROUP.\n"));
1402
 
                return False;
1403
 
        }
1404
 
 
1405
 
        return True;
1406
 
}
1407
 
 
1408
 
/*******************************************************************
1409
 
 api_samr_remove_sid_foreign_domain
1410
 
 ********************************************************************/
1411
 
 
1412
 
static BOOL api_samr_remove_sid_foreign_domain(pipes_struct *p)
1413
 
{
1414
 
        SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN q_u;
1415
 
        SAMR_R_REMOVE_SID_FOREIGN_DOMAIN r_u;
1416
 
 
1417
 
        prs_struct *data = &p->in_data.data;
1418
 
        prs_struct *rdata = &p->out_data.rdata;
1419
 
 
1420
 
        ZERO_STRUCT(q_u);
1421
 
        ZERO_STRUCT(r_u);
1422
 
 
1423
 
        if (!samr_io_q_remove_sid_foreign_domain("", &q_u, data, 0)) {
1424
 
                DEBUG(0,("api_samr_remove_sid_foreign_domain: unable to unmarshall SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN.\n"));
1425
 
                return False;
1426
 
        }
1427
 
 
1428
 
        r_u.status = _samr_remove_sid_foreign_domain(p, &q_u, &r_u);
1429
 
 
1430
 
        if (!samr_io_r_remove_sid_foreign_domain("", &r_u, rdata, 0)) {
1431
 
                DEBUG(0,("api_samr_remove_sid_foreign_domain: unable to marshall SAMR_R_REMOVE_SID_FOREIGN_DOMAIN.\n"));
1432
 
                return False;
1433
 
        }
1434
 
 
1435
 
        return True;
1436
 
}
1437
 
 
1438
 
/*******************************************************************
1439
 
 api_samr_query_dom_info2
1440
 
 ********************************************************************/
1441
 
 
1442
 
static BOOL api_samr_query_domain_info2(pipes_struct *p)
1443
 
{
1444
 
        SAMR_Q_QUERY_DOMAIN_INFO2 q_u;
1445
 
        SAMR_R_QUERY_DOMAIN_INFO2 r_u;
1446
 
        prs_struct *data = &p->in_data.data;
1447
 
        prs_struct *rdata = &p->out_data.rdata;
1448
 
 
1449
 
        ZERO_STRUCT(q_u);
1450
 
        ZERO_STRUCT(r_u);
1451
 
 
1452
 
        if(!samr_io_q_query_domain_info2("", &q_u, data, 0)) {
1453
 
                DEBUG(0,("api_samr_query_domain_info2: unable to unmarshall SAMR_Q_QUERY_DOMAIN_INFO2.\n"));
1454
 
                return False;
1455
 
        }
1456
 
 
1457
 
        r_u.status = _samr_query_domain_info2(p, &q_u, &r_u);
1458
 
 
1459
 
        /* store the response in the SMB stream */
1460
 
        if(!samr_io_r_query_domain_info2("", &r_u, rdata, 0)) {
1461
 
                DEBUG(0,("api_samr_query_domain_info2: unable to marshall SAMR_R_QUERY_DOMAIN_INFO2.\n"));
1462
 
                return False;
1463
 
        }
1464
 
 
1465
 
        return True;
1466
 
}
1467
 
 
1468
 
/*******************************************************************
1469
 
 api_samr_set_dom_info
1470
 
 ********************************************************************/
1471
 
 
1472
 
static BOOL api_samr_set_dom_info(pipes_struct *p)
1473
 
{
1474
 
        SAMR_Q_SET_DOMAIN_INFO q_u;
1475
 
        SAMR_R_SET_DOMAIN_INFO r_u;
1476
 
        prs_struct *data = &p->in_data.data;
1477
 
        prs_struct *rdata = &p->out_data.rdata;
1478
 
 
1479
 
        ZERO_STRUCT(q_u);
1480
 
        ZERO_STRUCT(r_u);
1481
 
 
1482
 
        if(!samr_io_q_set_domain_info("", &q_u, data, 0)) {
1483
 
                DEBUG(0,("api_samr_set_dom_info: unable to unmarshall SAMR_Q_SET_DOMAIN_INFO.\n"));
1484
 
                return False;
1485
 
        }
1486
 
 
1487
 
        r_u.status = _samr_set_dom_info(p, &q_u, &r_u);
1488
 
 
1489
 
        /* store the response in the SMB stream */
1490
 
        if(!samr_io_r_set_domain_info("", &r_u, rdata, 0)) {
1491
 
                DEBUG(0,("api_samr_set_dom_info: unable to marshall SAMR_R_SET_DOMAIN_INFO.\n"));
1492
 
                return False;
1493
 
        }
1494
 
 
1495
 
        return True;
1496
 
}
1497
 
 
1498
 
/*******************************************************************
1499
 
 array of \PIPE\samr operations
1500
 
 ********************************************************************/
1501
 
 
1502
 
static struct api_struct api_samr_cmds [] =
1503
 
{
1504
 
      {"SAMR_CLOSE_HND"         , SAMR_CLOSE_HND        , api_samr_close_hnd        },
1505
 
      {"SAMR_CONNECT"           , SAMR_CONNECT          , api_samr_connect          },
1506
 
      {"SAMR_CONNECT_ANON"      , SAMR_CONNECT_ANON     , api_samr_connect_anon     },
1507
 
      {"SAMR_ENUM_DOMAINS"      , SAMR_ENUM_DOMAINS     , api_samr_enum_domains     },
1508
 
      {"SAMR_ENUM_DOM_USERS"    , SAMR_ENUM_DOM_USERS   , api_samr_enum_dom_users   },
1509
 
      
1510
 
      {"SAMR_ENUM_DOM_GROUPS"   , SAMR_ENUM_DOM_GROUPS  , api_samr_enum_dom_groups  },
1511
 
      {"SAMR_ENUM_DOM_ALIASES"  , SAMR_ENUM_DOM_ALIASES , api_samr_enum_dom_aliases },
1512
 
      {"SAMR_QUERY_USERALIASES" , SAMR_QUERY_USERALIASES, api_samr_query_useraliases},
1513
 
      {"SAMR_QUERY_ALIASMEM"    , SAMR_QUERY_ALIASMEM   , api_samr_query_aliasmem   },
1514
 
      {"SAMR_QUERY_GROUPMEM"    , SAMR_QUERY_GROUPMEM   , api_samr_query_groupmem   },
1515
 
      {"SAMR_ADD_ALIASMEM"      , SAMR_ADD_ALIASMEM     , api_samr_add_aliasmem     },
1516
 
      {"SAMR_DEL_ALIASMEM"      , SAMR_DEL_ALIASMEM     , api_samr_del_aliasmem     },
1517
 
      {"SAMR_ADD_GROUPMEM"      , SAMR_ADD_GROUPMEM     , api_samr_add_groupmem     },
1518
 
      {"SAMR_DEL_GROUPMEM"      , SAMR_DEL_GROUPMEM     , api_samr_del_groupmem     },
1519
 
      
1520
 
      {"SAMR_DELETE_DOM_USER"   , SAMR_DELETE_DOM_USER  , api_samr_delete_dom_user  },
1521
 
      {"SAMR_DELETE_DOM_GROUP"  , SAMR_DELETE_DOM_GROUP , api_samr_delete_dom_group },
1522
 
      {"SAMR_DELETE_DOM_ALIAS"  , SAMR_DELETE_DOM_ALIAS , api_samr_delete_dom_alias },
1523
 
      {"SAMR_CREATE_DOM_GROUP"  , SAMR_CREATE_DOM_GROUP , api_samr_create_dom_group },
1524
 
      {"SAMR_CREATE_DOM_ALIAS"  , SAMR_CREATE_DOM_ALIAS , api_samr_create_dom_alias },
1525
 
      {"SAMR_LOOKUP_NAMES"      , SAMR_LOOKUP_NAMES     , api_samr_lookup_names     },
1526
 
      {"SAMR_OPEN_USER"         , SAMR_OPEN_USER        , api_samr_open_user        },
1527
 
      {"SAMR_QUERY_USERINFO"    , SAMR_QUERY_USERINFO   , api_samr_query_userinfo   },
1528
 
      {"SAMR_SET_USERINFO"      , SAMR_SET_USERINFO     , api_samr_set_userinfo     },
1529
 
      {"SAMR_SET_USERINFO2"     , SAMR_SET_USERINFO2    , api_samr_set_userinfo2    },
1530
 
      
1531
 
      {"SAMR_QUERY_DOMAIN_INFO" , SAMR_QUERY_DOMAIN_INFO, api_samr_query_domain_info},
1532
 
      {"SAMR_QUERY_USERGROUPS"  , SAMR_QUERY_USERGROUPS , api_samr_query_usergroups },
1533
 
      {"SAMR_QUERY_DISPINFO"    , SAMR_QUERY_DISPINFO   , api_samr_query_dispinfo   },
1534
 
      {"SAMR_QUERY_DISPINFO3"   , SAMR_QUERY_DISPINFO3  , api_samr_query_dispinfo   },
1535
 
      {"SAMR_QUERY_DISPINFO4"   , SAMR_QUERY_DISPINFO4  , api_samr_query_dispinfo   },
1536
 
      
1537
 
      {"SAMR_QUERY_ALIASINFO"   , SAMR_QUERY_ALIASINFO  , api_samr_query_aliasinfo  },
1538
 
      {"SAMR_QUERY_GROUPINFO"   , SAMR_QUERY_GROUPINFO  , api_samr_query_groupinfo  },
1539
 
      {"SAMR_SET_GROUPINFO"     , SAMR_SET_GROUPINFO    , api_samr_set_groupinfo    },
1540
 
      {"SAMR_SET_ALIASINFO"     , SAMR_SET_ALIASINFO    , api_samr_set_aliasinfo    },
1541
 
      {"SAMR_CREATE_USER"       , SAMR_CREATE_USER      , api_samr_create_user      },
1542
 
      {"SAMR_LOOKUP_RIDS"       , SAMR_LOOKUP_RIDS      , api_samr_lookup_rids      },
1543
 
      {"SAMR_GET_DOM_PWINFO"    , SAMR_GET_DOM_PWINFO   , api_samr_get_dom_pwinfo   },
1544
 
      {"SAMR_CHGPASSWD_USER"    , SAMR_CHGPASSWD_USER   , api_samr_chgpasswd_user   },
1545
 
      {"SAMR_OPEN_ALIAS"        , SAMR_OPEN_ALIAS       , api_samr_open_alias       },
1546
 
      {"SAMR_OPEN_GROUP"        , SAMR_OPEN_GROUP       , api_samr_open_group       },
1547
 
      {"SAMR_OPEN_DOMAIN"       , SAMR_OPEN_DOMAIN      , api_samr_open_domain      },
1548
 
      {"SAMR_REMOVE_SID_FOREIGN_DOMAIN"       , SAMR_REMOVE_SID_FOREIGN_DOMAIN      , api_samr_remove_sid_foreign_domain      },
1549
 
      {"SAMR_LOOKUP_DOMAIN"     , SAMR_LOOKUP_DOMAIN    , api_samr_lookup_domain    },
1550
 
      
1551
 
      {"SAMR_QUERY_SEC_OBJECT"  , SAMR_QUERY_SEC_OBJECT , api_samr_query_sec_obj    },
1552
 
      {"SAMR_SET_SEC_OBJECT"    , SAMR_SET_SEC_OBJECT   , api_samr_set_sec_obj      },
1553
 
      {"SAMR_GET_USRDOM_PWINFO" , SAMR_GET_USRDOM_PWINFO, api_samr_get_usrdom_pwinfo},
1554
 
      {"SAMR_QUERY_DOMAIN_INFO2", SAMR_QUERY_DOMAIN_INFO2, api_samr_query_domain_info2},
1555
 
      {"SAMR_SET_DOMAIN_INFO"   , SAMR_SET_DOMAIN_INFO  , api_samr_set_dom_info     },
1556
 
      {"SAMR_CONNECT4"          , SAMR_CONNECT4         , api_samr_connect4         },
1557
 
      {"SAMR_CHGPASSWD_USER3"   , SAMR_CHGPASSWD_USER3  , api_samr_chgpasswd_user3  },
1558
 
      {"SAMR_CONNECT5"          , SAMR_CONNECT5         , api_samr_connect5         }
1559
 
};
1560
 
 
1561
 
void samr_get_pipe_fns( struct api_struct **fns, int *n_fns )
1562
 
{
1563
 
        *fns = api_samr_cmds;
1564
 
        *n_fns = sizeof(api_samr_cmds) / sizeof(struct api_struct);
1565
 
}
1566
 
 
1567
 
 
1568
 
NTSTATUS rpc_samr_init(void)
1569
 
{
1570
 
  return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "samr", "lsass", api_samr_cmds,
1571
 
                                    sizeof(api_samr_cmds) / sizeof(struct api_struct));
1572
 
}