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