source3/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         /* unknown 38 command */
 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         /* grab the samr unknown 22 */
 452         if(!samr_io_q_open_user("", &q_u, data, 0)) {
 453                 DEBUG(0,("api_samr_open_user: unable to unmarshall SAMR_Q_OPEN_USER.\n"));
 454                 return False;
 455         }
 456
 457         r_u.status = _api_samr_open_user(p, &q_u, &r_u);
 458
 459         /* store the response in the SMB stream */
 460         if(!samr_io_r_open_user("", &r_u, rdata, 0)) {
 461                 DEBUG(0,("api_samr_open_user: unable to marshall SAMR_R_OPEN_USER.\n"));
 462                 return False;
 463         }
 464
 465         return True;
 466 }
 467
 468 /*******************************************************************
 469  api_samr_query_userinfo
 470  ********************************************************************/
 471
 472 static BOOL api_samr_query_userinfo(pipes_struct *p)
 473 {
 474         SAMR_Q_QUERY_USERINFO q_u;
 475         SAMR_R_QUERY_USERINFO r_u;
 476         prs_struct *data = &p->in_data.data;
 477         prs_struct *rdata = &p->out_data.rdata;
 478
 479         ZERO_STRUCT(q_u);
 480         ZERO_STRUCT(r_u);
 481
 482         /* grab the samr unknown 24 */
 483         if(!samr_io_q_query_userinfo("", &q_u, data, 0)){
 484                 DEBUG(0,("api_samr_query_userinfo: unable to unmarshall SAMR_Q_QUERY_USERINFO.\n"));
 485                 return False;
 486         }
 487
 488         r_u.status = _samr_query_userinfo(p, &q_u, &r_u);
 489
 490         /* store the response in the SMB stream */
 491         if(!samr_io_r_query_userinfo("", &r_u, rdata, 0)) {
 492                 DEBUG(0,("api_samr_query_userinfo: unable to marshall SAMR_R_QUERY_USERINFO.\n"));
 493                 return False;
 494         }
 495
 496         return True;
 497 }
 498
 499 /*******************************************************************
 500  api_samr_query_usergroups
 501  ********************************************************************/
 502
 503 static BOOL api_samr_query_usergroups(pipes_struct *p)
 504 {
 505         SAMR_Q_QUERY_USERGROUPS q_u;
 506         SAMR_R_QUERY_USERGROUPS r_u;
 507         prs_struct *data = &p->in_data.data;
 508         prs_struct *rdata = &p->out_data.rdata;
 509
 510         ZERO_STRUCT(q_u);
 511         ZERO_STRUCT(r_u);
 512
 513         /* grab the samr unknown 32 */
 514         if(!samr_io_q_query_usergroups("", &q_u, data, 0)) {
 515                 DEBUG(0,("api_samr_query_usergroups: unable to unmarshall SAMR_Q_QUERY_USERGROUPS.\n"));
 516                 return False;
 517         }
 518
 519         r_u.status = _samr_query_usergroups(p, &q_u, &r_u);
 520
 521         /* store the response in the SMB stream */
 522         if(!samr_io_r_query_usergroups("", &r_u, rdata, 0)) {
 523                 DEBUG(0,("api_samr_query_usergroups: unable to marshall SAMR_R_QUERY_USERGROUPS.\n"));
 524                 return False;
 525         }
 526
 527         return True;
 528 }
 529
 530 /*******************************************************************
 531  api_samr_query_dom_info
 532  ********************************************************************/
 533
 534 static BOOL api_samr_query_dom_info(pipes_struct *p)
 535 {
 536         SAMR_Q_QUERY_DOMAIN_INFO q_u;
 537         SAMR_R_QUERY_DOMAIN_INFO r_u;
 538         prs_struct *data = &p->in_data.data;
 539         prs_struct *rdata = &p->out_data.rdata;
 540
 541         ZERO_STRUCT(q_u);
 542         ZERO_STRUCT(r_u);
 543
 544         /* grab the samr unknown 8 command */
 545         if(!samr_io_q_query_dom_info("", &q_u, data, 0)) {
 546                 DEBUG(0,("api_samr_query_dom_info: unable to unmarshall SAMR_Q_QUERY_DOMAIN_INFO.\n"));
 547                 return False;
 548         }
 549
 550         r_u.status = _samr_query_dom_info(p, &q_u, &r_u);
 551
 552         /* store the response in the SMB stream */
 553         if(!samr_io_r_query_dom_info("", &r_u, rdata, 0)) {
 554                 DEBUG(0,("api_samr_query_dom_info: unable to marshall SAMR_R_QUERY_DOMAIN_INFO.\n"));
 555                 return False;
 556         }
 557
 558         return True;
 559 }
 560
 561 /*******************************************************************
 562  api_samr_create_user
 563  ********************************************************************/
 564
 565 static BOOL api_samr_create_user(pipes_struct *p)
 566 {
 567         prs_struct *data = &p->in_data.data;
 568         prs_struct *rdata = &p->out_data.rdata;
 569
 570         SAMR_Q_CREATE_USER q_u;
 571         SAMR_R_CREATE_USER r_u;
 572
 573         ZERO_STRUCT(q_u);
 574         ZERO_STRUCT(r_u);
 575
 576         /* grab the samr create user */
 577         if (!samr_io_q_create_user("", &q_u, data, 0)) {
 578                 DEBUG(0,("api_samr_create_user: Unable to unmarshall SAMR_Q_CREATE_USER.\n"));
 579                 return False;
 580         }
 581
 582         r_u.status=_api_samr_create_user(p, &q_u, &r_u);
 583
 584         /* store the response in the SMB stream */
 585         if(!samr_io_r_create_user("", &r_u, rdata, 0)) {
 586                 DEBUG(0,("api_samr_create_user: Unable to marshall SAMR_R_CREATE_USER.\n"));
 587                 return False;
 588         }
 589
 590         return True;
 591 }
 592
 593 /*******************************************************************
 594  api_samr_connect_anon
 595  ********************************************************************/
 596
 597 static BOOL api_samr_connect_anon(pipes_struct *p)
 598 {
 599         SAMR_Q_CONNECT_ANON q_u;
 600         SAMR_R_CONNECT_ANON r_u;
 601         prs_struct *data = &p->in_data.data;
 602         prs_struct *rdata = &p->out_data.rdata;
 603
 604         ZERO_STRUCT(q_u);
 605         ZERO_STRUCT(r_u);
 606
 607         /* grab the samr open policy */
 608         if(!samr_io_q_connect_anon("", &q_u, data, 0)) {
 609                 DEBUG(0,("api_samr_connect_anon: unable to unmarshall SAMR_Q_CONNECT_ANON.\n"));
 610                 return False;
 611         }
 612
 613         r_u.status = _samr_connect_anon(p, &q_u, &r_u);
 614
 615         /* store the response in the SMB stream */
 616         if(!samr_io_r_connect_anon("", &r_u, rdata, 0)) {
 617                 DEBUG(0,("api_samr_connect_anon: unable to marshall SAMR_R_CONNECT_ANON.\n"));
 618                 return False;
 619         }
 620
 621         return True;
 622 }
 623
 624 /*******************************************************************
 625  api_samr_connect
 626  ********************************************************************/
 627
 628 static BOOL api_samr_connect(pipes_struct *p)
 629 {
 630         SAMR_Q_CONNECT q_u;
 631         SAMR_R_CONNECT r_u;
 632         prs_struct *data = &p->in_data.data;
 633         prs_struct *rdata = &p->out_data.rdata;
 634
 635         ZERO_STRUCT(q_u);
 636         ZERO_STRUCT(r_u);
 637
 638         /* grab the samr open policy */
 639         if(!samr_io_q_connect("", &q_u, data, 0)) {
 640                 DEBUG(0,("api_samr_connect: unable to unmarshall SAMR_Q_CONNECT.\n"));
 641                 return False;
 642         }
 643
 644         r_u.status = _samr_connect(p, &q_u, &r_u);
 645
 646         /* store the response in the SMB stream */
 647         if(!samr_io_r_connect("", &r_u, rdata, 0)) {
 648                 DEBUG(0,("api_samr_connect: unable to marshall SAMR_R_CONNECT.\n"));
 649                 return False;
 650         }
 651
 652         return True;
 653 }
 654
 655 /*******************************************************************
 656  api_samr_connect4
 657  ********************************************************************/
 658
 659 static BOOL api_samr_connect4(pipes_struct *p)
 660 {
 661         SAMR_Q_CONNECT4 q_u;
 662         SAMR_R_CONNECT4 r_u;
 663         prs_struct *data = &p->in_data.data;
 664         prs_struct *rdata = &p->out_data.rdata;
 665
 666         ZERO_STRUCT(q_u);
 667         ZERO_STRUCT(r_u);
 668
 669         /* grab the samr open policy */
 670         if(!samr_io_q_connect4("", &q_u, data, 0)) {
 671                 DEBUG(0,("api_samr_connect4: unable to unmarshall SAMR_Q_CONNECT4.\n"));
 672                 return False;
 673         }
 674
 675         r_u.status = _samr_connect4(p, &q_u, &r_u);
 676
 677         /* store the response in the SMB stream */
 678         if(!samr_io_r_connect4("", &r_u, rdata, 0)) {
 679                 DEBUG(0,("api_samr_connect4: unable to marshall SAMR_R_CONNECT4.\n"));
 680                 return False;
 681         }
 682
 683         return True;
 684 }
 685
 686 /**********************************************************************
 687  api_samr_lookup_domain
 688  **********************************************************************/
 689
 690 static BOOL api_samr_lookup_domain(pipes_struct *p)
 691 {
 692         SAMR_Q_LOOKUP_DOMAIN q_u;
 693         SAMR_R_LOOKUP_DOMAIN r_u;
 694         prs_struct *data = &p->in_data.data;
 695         prs_struct *rdata = &p->out_data.rdata;
 696
 697         ZERO_STRUCT(q_u);
 698         ZERO_STRUCT(r_u);
 699
 700         if(!samr_io_q_lookup_domain("", &q_u, data, 0)) {
 701                 DEBUG(0,("api_samr_lookup_domain: Unable to unmarshall SAMR_Q_LOOKUP_DOMAIN.\n"));
 702                 return False;
 703         }
 704
 705         r_u.status = _samr_lookup_domain(p, &q_u, &r_u);
 706
 707         if(!samr_io_r_lookup_domain("", &r_u, rdata, 0)){
 708                 DEBUG(0,("api_samr_lookup_domain: Unable to marshall SAMR_R_LOOKUP_DOMAIN.\n"));
 709                 return False;
 710         }
 711
 712         return True;
 713 }
 714
 715 /**********************************************************************
 716  api_samr_enum_domains
 717  **********************************************************************/
 718
 719 static BOOL api_samr_enum_domains(pipes_struct *p)
 720 {
 721         SAMR_Q_ENUM_DOMAINS q_u;
 722         SAMR_R_ENUM_DOMAINS r_u;
 723         prs_struct *data = &p->in_data.data;
 724         prs_struct *rdata = &p->out_data.rdata;
 725
 726         ZERO_STRUCT(q_u);
 727         ZERO_STRUCT(r_u);
 728
 729         if(!samr_io_q_enum_domains("", &q_u, data, 0)) {
 730                 DEBUG(0,("api_samr_enum_domains: Unable to unmarshall SAMR_Q_ENUM_DOMAINS.\n"));
 731                 return False;
 732         }
 733
 734         r_u.status = _samr_enum_domains(p, &q_u, &r_u);
 735
 736         if(!samr_io_r_enum_domains("", &r_u, rdata, 0)) {
 737                 DEBUG(0,("api_samr_enum_domains: Unable to marshall SAMR_R_ENUM_DOMAINS.\n"));
 738                 return False;
 739         }
 740
 741         return True;
 742 }
 743
 744 /*******************************************************************
 745  api_samr_open_alias
 746  ********************************************************************/
 747
 748 static BOOL api_samr_open_alias(pipes_struct *p)
 749 {
 750         SAMR_Q_OPEN_ALIAS q_u;
 751         SAMR_R_OPEN_ALIAS 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         /* grab the samr open policy */
 759         if(!samr_io_q_open_alias("", &q_u, data, 0)) {
 760                 DEBUG(0,("api_samr_open_alias: Unable to unmarshall SAMR_Q_OPEN_ALIAS.\n"));
 761                 return False;
 762         }
 763
 764         r_u.status=_api_samr_open_alias(p, &q_u, &r_u);
 765
 766         /* store the response in the SMB stream */
 767         if(!samr_io_r_open_alias("", &r_u, rdata, 0)) {
 768                 DEBUG(0,("api_samr_open_alias: Unable to marshall SAMR_R_OPEN_ALIAS.\n"));
 769                 return False;
 770         }
 771
 772         return True;
 773 }
 774
 775 /*******************************************************************
 776  api_samr_set_userinfo
 777  ********************************************************************/
 778
 779 static BOOL api_samr_set_userinfo(pipes_struct *p)
 780 {
 781         SAMR_Q_SET_USERINFO q_u;
 782         SAMR_R_SET_USERINFO r_u;
 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_set_userinfo("", &q_u, data, 0)) {
 790                 DEBUG(0,("api_samr_set_userinfo: Unable to unmarshall SAMR_Q_SET_USERINFO.\n"));
 791                 /* Fix for W2K SP2 */
 792                 if (q_u.switch_value == 0x1a) {
 793                         setup_fault_pdu(p, NT_STATUS(0x1c000006));
 794                         return True;
 795                 }
 796                 return False;
 797         }
 798
 799         r_u.status = _samr_set_userinfo(p, &q_u, &r_u);
 800
 801         if(!samr_io_r_set_userinfo("", &r_u, rdata, 0)) {
 802                 DEBUG(0,("api_samr_set_userinfo: Unable to marshall SAMR_R_SET_USERINFO.\n"));
 803                 return False;
 804         }
 805
 806         return True;
 807 }
 808
 809 /*******************************************************************
 810  api_samr_set_userinfo2
 811  ********************************************************************/
 812
 813 static BOOL api_samr_set_userinfo2(pipes_struct *p)
 814 {
 815         SAMR_Q_SET_USERINFO2 q_u;
 816         SAMR_R_SET_USERINFO2 r_u;
 817
 818         prs_struct *data = &p->in_data.data;
 819         prs_struct *rdata = &p->out_data.rdata;
 820
 821         ZERO_STRUCT(q_u);
 822         ZERO_STRUCT(r_u);
 823
 824         if (!samr_io_q_set_userinfo2("", &q_u, data, 0)) {
 825                 DEBUG(0,("api_samr_set_userinfo2: Unable to unmarshall SAMR_Q_SET_USERINFO2.\n"));
 826                 return False;
 827         }
 828
 829         r_u.status = _samr_set_userinfo2(p, &q_u, &r_u);
 830
 831         if(!samr_io_r_set_userinfo2("", &r_u, rdata, 0)) {
 832                 DEBUG(0,("api_samr_set_userinfo2: Unable to marshall SAMR_R_SET_USERINFO2.\n"));
 833                 return False;
 834         }
 835
 836         return True;
 837 }
 838
 839 /*******************************************************************
 840  api_samr_query_useraliases
 841  ********************************************************************/
 842
 843 static BOOL api_samr_query_useraliases(pipes_struct *p)
 844 {
 845         SAMR_Q_QUERY_USERALIASES q_u;
 846         SAMR_R_QUERY_USERALIASES r_u;
 847
 848         prs_struct *data = &p->in_data.data;
 849         prs_struct *rdata = &p->out_data.rdata;
 850
 851         ZERO_STRUCT(q_u);
 852         ZERO_STRUCT(r_u);
 853
 854         if (!samr_io_q_query_useraliases("", &q_u, data, 0)) {
 855                 DEBUG(0,("api_samr_query_useraliases:  Unable to unmarshall SAMR_Q_QUERY_USERALIASES.\n"));
 856                 return False;
 857         }
 858
 859         r_u.status = _samr_query_useraliases(p, &q_u, &r_u);
 860
 861         if (! samr_io_r_query_useraliases("", &r_u, rdata, 0)) {
 862                 DEBUG(0,("api_samr_query_useraliases:  Unable to nmarshall SAMR_R_QUERY_USERALIASES.\n"));
 863                 return False;
 864         }
 865
 866         return True;
 867 }
 868
 869 /*******************************************************************
 870  api_samr_query_aliasmem
 871  ********************************************************************/
 872
 873 static BOOL api_samr_query_aliasmem(pipes_struct *p)
 874 {
 875         SAMR_Q_QUERY_ALIASMEM q_u;
 876         SAMR_R_QUERY_ALIASMEM r_u;
 877
 878         prs_struct *data = &p->in_data.data;
 879         prs_struct *rdata = &p->out_data.rdata;
 880
 881         ZERO_STRUCT(q_u);
 882         ZERO_STRUCT(r_u);
 883
 884         if (!samr_io_q_query_aliasmem("", &q_u, data, 0)) {
 885                 DEBUG(0,("api_samr_query_aliasmem: unable to unmarshall SAMR_Q_QUERY_ALIASMEM.\n"));
 886                 return False;
 887         }
 888
 889         r_u.status = _samr_query_aliasmem(p, &q_u, &r_u);
 890
 891         if (!samr_io_r_query_aliasmem("", &r_u, rdata, 0)) {
 892                 DEBUG(0,("api_samr_query_aliasmem: unable to marshall SAMR_R_QUERY_ALIASMEM.\n"));
 893                 return False;
 894         }
 895
 896         return True;
 897 }
 898
 899 /*******************************************************************
 900  api_samr_query_groupmem
 901  ********************************************************************/
 902
 903 static BOOL api_samr_query_groupmem(pipes_struct *p)
 904 {
 905         SAMR_Q_QUERY_GROUPMEM q_u;
 906         SAMR_R_QUERY_GROUPMEM r_u;
 907
 908         prs_struct *data = &p->in_data.data;
 909         prs_struct *rdata = &p->out_data.rdata;
 910
 911         ZERO_STRUCT(q_u);
 912         ZERO_STRUCT(r_u);
 913
 914         if (!samr_io_q_query_groupmem("", &q_u, data, 0)) {
 915                 DEBUG(0,("api_samr_query_groupmem: unable to unmarshall SAMR_Q_QUERY_GROUPMEM.\n"));
 916                 return False;
 917         }
 918
 919         r_u.status = _samr_query_groupmem(p, &q_u, &r_u);
 920
 921         if (!samr_io_r_query_groupmem("", &r_u, rdata, 0)) {
 922                 DEBUG(0,("api_samr_query_groupmem: unable to marshall SAMR_R_QUERY_GROUPMEM.\n"));
 923                 return False;
 924         }
 925
 926         return True;
 927 }
 928
 929 /*******************************************************************
 930  api_samr_add_aliasmem
 931  ********************************************************************/
 932
 933 static BOOL api_samr_add_aliasmem(pipes_struct *p)
 934 {
 935         SAMR_Q_ADD_ALIASMEM q_u;
 936         SAMR_R_ADD_ALIASMEM r_u;
 937
 938         prs_struct *data = &p->in_data.data;
 939         prs_struct *rdata = &p->out_data.rdata;
 940
 941         ZERO_STRUCT(q_u);
 942         ZERO_STRUCT(r_u);
 943
 944         if (!samr_io_q_add_aliasmem("", &q_u, data, 0)) {
 945                 DEBUG(0,("api_samr_add_aliasmem: unable to unmarshall SAMR_Q_ADD_ALIASMEM.\n"));
 946                 return False;
 947         }
 948
 949         r_u.status = _samr_add_aliasmem(p, &q_u, &r_u);
 950
 951         if (!samr_io_r_add_aliasmem("", &r_u, rdata, 0)) {
 952                 DEBUG(0,("api_samr_add_aliasmem: unable to marshall SAMR_R_ADD_ALIASMEM.\n"));
 953                 return False;
 954         }
 955
 956         return True;
 957 }
 958
 959 /*******************************************************************
 960  api_samr_del_aliasmem
 961  ********************************************************************/
 962
 963 static BOOL api_samr_del_aliasmem(pipes_struct *p)
 964 {
 965         SAMR_Q_DEL_ALIASMEM q_u;
 966         SAMR_R_DEL_ALIASMEM r_u;
 967
 968         prs_struct *data = &p->in_data.data;
 969         prs_struct *rdata = &p->out_data.rdata;
 970
 971         ZERO_STRUCT(q_u);
 972         ZERO_STRUCT(r_u);
 973
 974         if (!samr_io_q_del_aliasmem("", &q_u, data, 0)) {
 975                 DEBUG(0,("api_samr_del_aliasmem: unable to unmarshall SAMR_Q_DEL_ALIASMEM.\n"));
 976                 return False;
 977         }
 978
 979         r_u.status = _samr_del_aliasmem(p, &q_u, &r_u);
 980
 981         if (!samr_io_r_del_aliasmem("", &r_u, rdata, 0)) {
 982                 DEBUG(0,("api_samr_del_aliasmem: unable to marshall SAMR_R_DEL_ALIASMEM.\n"));
 983                 return False;
 984         }
 985
 986         return True;
 987 }
 988
 989 /*******************************************************************
 990  api_samr_add_groupmem
 991  ********************************************************************/
 992
 993 static BOOL api_samr_add_groupmem(pipes_struct *p)
 994 {
 995         SAMR_Q_ADD_GROUPMEM q_u;
 996         SAMR_R_ADD_GROUPMEM r_u;
 997
 998         prs_struct *data = &p->in_data.data;
 999         prs_struct *rdata = &p->out_data.rdata;
1000
1001         ZERO_STRUCT(q_u);
1002         ZERO_STRUCT(r_u);
1003
1004         if (!samr_io_q_add_groupmem("", &q_u, data, 0)) {
1005                 DEBUG(0,("api_samr_add_groupmem: unable to unmarshall SAMR_Q_ADD_GROUPMEM.\n"));
1006                 return False;
1007         }
1008
1009         r_u.status = _samr_add_groupmem(p, &q_u, &r_u);
1010
1011         if (!samr_io_r_add_groupmem("", &r_u, rdata, 0)) {
1012                 DEBUG(0,("api_samr_add_groupmem: unable to marshall SAMR_R_ADD_GROUPMEM.\n"));
1013                 return False;
1014         }
1015
1016         return True;
1017 }
1018
1019 /*******************************************************************
1020  api_samr_del_groupmem
1021  ********************************************************************/
1022
1023 static BOOL api_samr_del_groupmem(pipes_struct *p)
1024 {
1025         SAMR_Q_DEL_GROUPMEM q_u;
1026         SAMR_R_DEL_GROUPMEM r_u;
1027
1028         prs_struct *data = &p->in_data.data;
1029         prs_struct *rdata = &p->out_data.rdata;
1030
1031         ZERO_STRUCT(q_u);
1032         ZERO_STRUCT(r_u);
1033
1034         if (!samr_io_q_del_groupmem("", &q_u, data, 0)) {
1035                 DEBUG(0,("api_samr_del_groupmem: unable to unmarshall SAMR_Q_DEL_GROUPMEM.\n"));
1036                 return False;
1037         }
1038
1039         r_u.status = _samr_del_groupmem(p, &q_u, &r_u);
1040
1041         if (!samr_io_r_del_groupmem("", &r_u, rdata, 0)) {
1042                 DEBUG(0,("api_samr_del_groupmem: unable to marshall SAMR_R_DEL_GROUPMEM.\n"));
1043                 return False;
1044         }
1045
1046         return True;
1047 }
1048
1049 /*******************************************************************
1050  api_samr_delete_dom_user
1051  ********************************************************************/
1052
1053 static BOOL api_samr_delete_dom_user(pipes_struct *p)
1054 {
1055         SAMR_Q_DELETE_DOM_USER q_u;
1056         SAMR_R_DELETE_DOM_USER r_u;
1057
1058         prs_struct *data = &p->in_data.data;
1059         prs_struct *rdata = &p->out_data.rdata;
1060
1061         ZERO_STRUCT(q_u);
1062         ZERO_STRUCT(r_u);
1063
1064         if (!samr_io_q_delete_dom_user("", &q_u, data, 0)) {
1065                 DEBUG(0,("api_samr_delete_dom_user: unable to unmarshall SAMR_Q_DELETE_DOM_USER.\n"));
1066                 return False;
1067         }
1068
1069         r_u.status = _samr_delete_dom_user(p, &q_u, &r_u);
1070
1071         if (!samr_io_r_delete_dom_user("", &r_u, rdata, 0)) {
1072                 DEBUG(0,("api_samr_delete_dom_user: unable to marshall SAMR_R_DELETE_DOM_USER.\n"));
1073                 return False;
1074         }
1075
1076         return True;
1077 }
1078
1079 /*******************************************************************
1080  api_samr_delete_dom_group
1081  ********************************************************************/
1082
1083 static BOOL api_samr_delete_dom_group(pipes_struct *p)
1084 {
1085         SAMR_Q_DELETE_DOM_GROUP q_u;
1086         SAMR_R_DELETE_DOM_GROUP r_u;
1087
1088         prs_struct *data = &p->in_data.data;
1089         prs_struct *rdata = &p->out_data.rdata;
1090
1091         ZERO_STRUCT(q_u);
1092         ZERO_STRUCT(r_u);
1093
1094         if (!samr_io_q_delete_dom_group("", &q_u, data, 0)) {
1095                 DEBUG(0,("api_samr_delete_dom_group: unable to unmarshall SAMR_Q_DELETE_DOM_GROUP.\n"));
1096                 return False;
1097         }
1098
1099         r_u.status = _samr_delete_dom_group(p, &q_u, &r_u);
1100
1101         if (!samr_io_r_delete_dom_group("", &r_u, rdata, 0)) {
1102                 DEBUG(0,("api_samr_delete_dom_group: unable to marshall SAMR_R_DELETE_DOM_GROUP.\n"));
1103                 return False;
1104         }
1105
1106         return True;
1107 }
1108
1109 /*******************************************************************
1110  api_samr_delete_dom_alias
1111  ********************************************************************/
1112
1113 static BOOL api_samr_delete_dom_alias(pipes_struct *p)
1114 {
1115         SAMR_Q_DELETE_DOM_ALIAS q_u;
1116         SAMR_R_DELETE_DOM_ALIAS r_u;
1117
1118         prs_struct *data = &p->in_data.data;
1119         prs_struct *rdata = &p->out_data.rdata;
1120
1121         ZERO_STRUCT(q_u);
1122         ZERO_STRUCT(r_u);
1123
1124         if (!samr_io_q_delete_dom_alias("", &q_u, data, 0)) {
1125                 DEBUG(0,("api_samr_delete_dom_alias: unable to unmarshall SAMR_Q_DELETE_DOM_ALIAS.\n"));
1126                 return False;
1127         }
1128
1129         r_u.status = _samr_delete_dom_alias(p, &q_u, &r_u);
1130
1131         if (!samr_io_r_delete_dom_alias("", &r_u, rdata, 0)) {
1132                 DEBUG(0,("api_samr_delete_dom_alias: unable to marshall SAMR_R_DELETE_DOM_ALIAS.\n"));
1133                 return False;
1134         }
1135
1136         return True;
1137 }
1138
1139 /*******************************************************************
1140  api_samr_create_dom_group
1141  ********************************************************************/
1142
1143 static BOOL api_samr_create_dom_group(pipes_struct *p)
1144 {
1145         SAMR_Q_CREATE_DOM_GROUP q_u;
1146         SAMR_R_CREATE_DOM_GROUP r_u;
1147
1148         prs_struct *data = &p->in_data.data;
1149         prs_struct *rdata = &p->out_data.rdata;
1150
1151         ZERO_STRUCT(q_u);
1152         ZERO_STRUCT(r_u);
1153
1154         if (!samr_io_q_create_dom_group("", &q_u, data, 0)) {
1155                 DEBUG(0,("api_samr_create_dom_group: unable to unmarshall SAMR_Q_CREATE_DOM_GROUP.\n"));
1156                 return False;
1157         }
1158
1159         r_u.status = _samr_create_dom_group(p, &q_u, &r_u);
1160
1161         if (!samr_io_r_create_dom_group("", &r_u, rdata, 0)) {
1162                 DEBUG(0,("api_samr_create_dom_group: unable to marshall SAMR_R_CREATE_DOM_GROUP.\n"));
1163                 return False;
1164         }
1165
1166         return True;
1167 }
1168
1169 /*******************************************************************
1170  api_samr_create_dom_alias
1171  ********************************************************************/
1172
1173 static BOOL api_samr_create_dom_alias(pipes_struct *p)
1174 {
1175         SAMR_Q_CREATE_DOM_ALIAS q_u;
1176         SAMR_R_CREATE_DOM_ALIAS r_u;
1177
1178         prs_struct *data = &p->in_data.data;
1179         prs_struct *rdata = &p->out_data.rdata;
1180
1181         ZERO_STRUCT(q_u);
1182         ZERO_STRUCT(r_u);
1183
1184         if (!samr_io_q_create_dom_alias("", &q_u, data, 0)) {
1185                 DEBUG(0,("api_samr_create_dom_alias: unable to unmarshall SAMR_Q_CREATE_DOM_ALIAS.\n"));
1186                 return False;
1187         }
1188
1189         r_u.status = _samr_create_dom_alias(p, &q_u, &r_u);
1190
1191         if (!samr_io_r_create_dom_alias("", &r_u, rdata, 0)) {
1192                 DEBUG(0,("api_samr_create_dom_alias: unable to marshall SAMR_R_CREATE_DOM_ALIAS.\n"));
1193                 return False;
1194         }
1195
1196         return True;
1197 }
1198
1199 /*******************************************************************
1200  api_samr_query_groupinfo
1201  ********************************************************************/
1202
1203 static BOOL api_samr_query_groupinfo(pipes_struct *p)
1204 {
1205         SAMR_Q_QUERY_GROUPINFO q_u;
1206         SAMR_R_QUERY_GROUPINFO r_u;
1207
1208         prs_struct *data = &p->in_data.data;
1209         prs_struct *rdata = &p->out_data.rdata;
1210
1211         ZERO_STRUCT(q_u);
1212         ZERO_STRUCT(r_u);
1213
1214         if (!samr_io_q_query_groupinfo("", &q_u, data, 0)) {
1215                 DEBUG(0,("api_samr_query_groupinfo: unable to unmarshall SAMR_Q_QUERY_GROUPINFO.\n"));
1216                 return False;
1217         }
1218
1219         r_u.status = _samr_query_groupinfo(p, &q_u, &r_u);
1220
1221         if (!samr_io_r_query_groupinfo("", &r_u, rdata, 0)) {
1222                 DEBUG(0,("api_samr_query_groupinfo: unable to marshall SAMR_R_QUERY_GROUPINFO.\n"));
1223                 return False;
1224         }
1225
1226         return True;
1227 }
1228
1229 /*******************************************************************
1230  api_samr_set_groupinfo
1231  ********************************************************************/
1232
1233 static BOOL api_samr_set_groupinfo(pipes_struct *p)
1234 {
1235         SAMR_Q_SET_GROUPINFO q_u;
1236         SAMR_R_SET_GROUPINFO r_u;
1237
1238         prs_struct *data = &p->in_data.data;
1239         prs_struct *rdata = &p->out_data.rdata;
1240
1241         ZERO_STRUCT(q_u);
1242         ZERO_STRUCT(r_u);
1243
1244         if (!samr_io_q_set_groupinfo("", &q_u, data, 0)) {
1245                 DEBUG(0,("api_samr_set_groupinfo: unable to unmarshall SAMR_Q_SET_GROUPINFO.\n"));
1246                 return False;
1247         }
1248
1249         r_u.status = _samr_set_groupinfo(p, &q_u, &r_u);
1250
1251         if (!samr_io_r_set_groupinfo("", &r_u, rdata, 0)) {
1252                 DEBUG(0,("api_samr_set_groupinfo: unable to marshall SAMR_R_SET_GROUPINFO.\n"));
1253                 return False;
1254         }
1255
1256         return True;
1257 }
1258
1259 /*******************************************************************
1260  api_samr_set_aliasinfo
1261  ********************************************************************/
1262
1263 static BOOL api_samr_set_aliasinfo(pipes_struct *p)
1264 {
1265         SAMR_Q_SET_ALIASINFO q_u;
1266         SAMR_R_SET_ALIASINFO r_u;
1267
1268         prs_struct *data = &p->in_data.data;
1269         prs_struct *rdata = &p->out_data.rdata;
1270
1271         ZERO_STRUCT(q_u);
1272         ZERO_STRUCT(r_u);
1273
1274         if (!samr_io_q_set_aliasinfo("", &q_u, data, 0)) {
1275                 DEBUG(0,("api_samr_set_aliasinfo: unable to unmarshall SAMR_Q_SET_ALIASINFO.\n"));
1276                 return False;
1277         }
1278
1279         r_u.status = _samr_set_aliasinfo(p, &q_u, &r_u);
1280
1281         if (!samr_io_r_set_aliasinfo("", &r_u, rdata, 0)) {
1282                 DEBUG(0,("api_samr_set_aliasinfo: unable to marshall SAMR_R_SET_ALIASINFO.\n"));
1283                 return False;
1284         }
1285
1286         return True;
1287 }
1288
1289 /*******************************************************************
1290  api_samr_get_dom_pwinfo
1291  ********************************************************************/
1292
1293 static BOOL api_samr_get_dom_pwinfo(pipes_struct *p)
1294 {
1295         SAMR_Q_GET_DOM_PWINFO q_u;
1296         SAMR_R_GET_DOM_PWINFO r_u;
1297
1298         prs_struct *data = &p->in_data.data;
1299         prs_struct *rdata = &p->out_data.rdata;
1300
1301         ZERO_STRUCT(q_u);
1302         ZERO_STRUCT(r_u);
1303
1304         if (!samr_io_q_get_dom_pwinfo("", &q_u, data, 0)) {
1305                 DEBUG(0,("api_samr_get_dom_pwinfo: unable to unmarshall SAMR_Q_GET_DOM_PWINFO.\n"));
1306                 return False;
1307         }
1308
1309         r_u.status = _samr_get_dom_pwinfo(p, &q_u, &r_u);
1310
1311         if (!samr_io_r_get_dom_pwinfo("", &r_u, rdata, 0)) {
1312                 DEBUG(0,("api_samr_get_dom_pwinfo: unable to marshall SAMR_R_GET_DOM_PWINFO.\n"));
1313                 return False;
1314         }
1315
1316         return True;
1317 }
1318
1319 /*******************************************************************
1320  api_samr_open_group
1321  ********************************************************************/
1322
1323 static BOOL api_samr_open_group(pipes_struct *p)
1324 {
1325         SAMR_Q_OPEN_GROUP q_u;
1326         SAMR_R_OPEN_GROUP r_u;
1327
1328         prs_struct *data = &p->in_data.data;
1329         prs_struct *rdata = &p->out_data.rdata;
1330
1331         ZERO_STRUCT(q_u);
1332         ZERO_STRUCT(r_u);
1333
1334         if (!samr_io_q_open_group("", &q_u, data, 0)) {
1335                 DEBUG(0,("api_samr_open_group: unable to unmarshall SAMR_Q_OPEN_GROUP.\n"));
1336                 return False;
1337         }
1338
1339         r_u.status = _samr_open_group(p, &q_u, &r_u);
1340
1341         if (!samr_io_r_open_group("", &r_u, rdata, 0)) {
1342                 DEBUG(0,("api_samr_open_group: unable to marshall SAMR_R_OPEN_GROUP.\n"));
1343                 return False;
1344         }
1345
1346         return True;
1347 }
1348
1349 /*******************************************************************
1350  api_samr_unknown_2d
1351  ********************************************************************/
1352
1353 static BOOL api_samr_unknown_2d(pipes_struct *p)
1354 {
1355         SAMR_Q_UNKNOWN_2D q_u;
1356         SAMR_R_UNKNOWN_2D r_u;
1357
1358         prs_struct *data = &p->in_data.data;
1359         prs_struct *rdata = &p->out_data.rdata;
1360
1361         ZERO_STRUCT(q_u);
1362         ZERO_STRUCT(r_u);
1363
1364         if (!samr_io_q_unknown_2d("", &q_u, data, 0)) {
1365                 DEBUG(0,("api_samr_unknown_2d: unable to unmarshall SAMR_Q_UNKNOWN_2D.\n"));
1366                 return False;
1367         }
1368
1369         r_u.status = _samr_unknown_2d(p, &q_u, &r_u);
1370
1371         if (!samr_io_r_unknown_2d("", &r_u, rdata, 0)) {
1372                 DEBUG(0,("api_samr_unknown_2d: unable to marshall SAMR_R_UNKNOWN_2D.\n"));
1373                 return False;
1374         }
1375
1376         return True;
1377 }
1378
1379 /*******************************************************************
1380  api_samr_query_dom_info
1381  ********************************************************************/
1382
1383 static BOOL api_samr_unknown_2e(pipes_struct *p)
1384 {
1385         SAMR_Q_UNKNOWN_2E q_u;
1386         SAMR_R_UNKNOWN_2E r_u;
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         /* grab the samr unknown 8 command */
1394         if(!samr_io_q_unknown_2e("", &q_u, data, 0)) {
1395                 DEBUG(0,("api_samr_unknown_2e: unable to unmarshall SAMR_Q_UNKNOWN_2E.\n"));
1396                 return False;
1397         }
1398
1399         r_u.status = _samr_unknown_2e(p, &q_u, &r_u);
1400
1401         /* store the response in the SMB stream */
1402         if(!samr_io_r_samr_unknown_2e("", &r_u, rdata, 0)) {
1403                 DEBUG(0,("api_samr_unknown_2e: unable to marshall SAMR_R_UNKNOWN_2E.\n"));
1404                 return False;
1405         }
1406
1407         return True;
1408 }
1409
1410 /*******************************************************************
1411  api_samr_set_dom_info
1412  ********************************************************************/
1413
1414 static BOOL api_samr_set_dom_info(pipes_struct *p)
1415 {
1416         SAMR_Q_SET_DOMAIN_INFO q_u;
1417         SAMR_R_SET_DOMAIN_INFO r_u;
1418         prs_struct *data = &p->in_data.data;
1419         prs_struct *rdata = &p->out_data.rdata;
1420
1421         ZERO_STRUCT(q_u);
1422         ZERO_STRUCT(r_u);
1423
1424         /* grab the samr unknown 8 command */
1425         if(!samr_io_q_set_domain_info("", &q_u, data, 0)) {
1426                 DEBUG(0,("api_samr_set_dom_info: unable to unmarshall SAMR_Q_SET_DOMAIN_INFO.\n"));
1427                 return False;
1428         }
1429
1430         r_u.status = _samr_set_dom_info(p, &q_u, &r_u);
1431
1432         /* store the response in the SMB stream */
1433         if(!samr_io_r_set_domain_info("", &r_u, rdata, 0)) {
1434                 DEBUG(0,("api_samr_set_dom_info: unable to marshall SAMR_R_SET_DOMAIN_INFO.\n"));
1435                 return False;
1436         }
1437
1438         return True;
1439 }
1440
1441 /*******************************************************************
1442  array of \PIPE\samr operations
1443  ********************************************************************/
1444
1445 NTSTATUS rpc_samr_init(void)
1446 {
1447   static struct api_struct api_samr_cmds [] =
1448     {
1449       {"SAMR_CLOSE_HND"         , SAMR_CLOSE_HND        , api_samr_close_hnd        },
1450       {"SAMR_CONNECT"           , SAMR_CONNECT          , api_samr_connect          },
1451       {"SAMR_CONNECT_ANON"      , SAMR_CONNECT_ANON     , api_samr_connect_anon     },
1452       {"SAMR_ENUM_DOMAINS"      , SAMR_ENUM_DOMAINS     , api_samr_enum_domains     },
1453       {"SAMR_ENUM_DOM_USERS"    , SAMR_ENUM_DOM_USERS   , api_samr_enum_dom_users   },
1454
1455       {"SAMR_ENUM_DOM_GROUPS"   , SAMR_ENUM_DOM_GROUPS  , api_samr_enum_dom_groups  },
1456       {"SAMR_ENUM_DOM_ALIASES"  , SAMR_ENUM_DOM_ALIASES , api_samr_enum_dom_aliases },
1457       {"SAMR_QUERY_USERALIASES" , SAMR_QUERY_USERALIASES, api_samr_query_useraliases},
1458       {"SAMR_QUERY_ALIASMEM"    , SAMR_QUERY_ALIASMEM   , api_samr_query_aliasmem   },
1459       {"SAMR_QUERY_GROUPMEM"    , SAMR_QUERY_GROUPMEM   , api_samr_query_groupmem   },
1460       {"SAMR_ADD_ALIASMEM"      , SAMR_ADD_ALIASMEM     , api_samr_add_aliasmem     },
1461       {"SAMR_DEL_ALIASMEM"      , SAMR_DEL_ALIASMEM     , api_samr_del_aliasmem     },
1462       {"SAMR_ADD_GROUPMEM"      , SAMR_ADD_GROUPMEM     , api_samr_add_groupmem     },
1463       {"SAMR_DEL_GROUPMEM"      , SAMR_DEL_GROUPMEM     , api_samr_del_groupmem     },
1464
1465       {"SAMR_DELETE_DOM_USER"   , SAMR_DELETE_DOM_USER  , api_samr_delete_dom_user  },
1466       {"SAMR_DELETE_DOM_GROUP"  , SAMR_DELETE_DOM_GROUP , api_samr_delete_dom_group },
1467       {"SAMR_DELETE_DOM_ALIAS"  , SAMR_DELETE_DOM_ALIAS , api_samr_delete_dom_alias },
1468       {"SAMR_CREATE_DOM_GROUP"  , SAMR_CREATE_DOM_GROUP , api_samr_create_dom_group },
1469       {"SAMR_CREATE_DOM_ALIAS"  , SAMR_CREATE_DOM_ALIAS , api_samr_create_dom_alias },
1470       {"SAMR_LOOKUP_NAMES"      , SAMR_LOOKUP_NAMES     , api_samr_lookup_names     },
1471       {"SAMR_OPEN_USER"         , SAMR_OPEN_USER        , api_samr_open_user        },
1472       {"SAMR_QUERY_USERINFO"    , SAMR_QUERY_USERINFO   , api_samr_query_userinfo   },
1473       {"SAMR_SET_USERINFO"      , SAMR_SET_USERINFO     , api_samr_set_userinfo     },
1474       {"SAMR_SET_USERINFO2"     , SAMR_SET_USERINFO2    , api_samr_set_userinfo2    },
1475
1476       {"SAMR_QUERY_DOMAIN_INFO" , SAMR_QUERY_DOMAIN_INFO, api_samr_query_dom_info   },
1477       {"SAMR_QUERY_USERGROUPS"  , SAMR_QUERY_USERGROUPS , api_samr_query_usergroups },
1478       {"SAMR_QUERY_DISPINFO"    , SAMR_QUERY_DISPINFO   , api_samr_query_dispinfo   },
1479       {"SAMR_QUERY_DISPINFO3"   , SAMR_QUERY_DISPINFO3  , api_samr_query_dispinfo   },
1480       {"SAMR_QUERY_DISPINFO4"   , SAMR_QUERY_DISPINFO4  , api_samr_query_dispinfo   },
1481
1482       {"SAMR_QUERY_ALIASINFO"   , SAMR_QUERY_ALIASINFO  , api_samr_query_aliasinfo  },
1483       {"SAMR_QUERY_GROUPINFO"   , SAMR_QUERY_GROUPINFO  , api_samr_query_groupinfo  },
1484       {"SAMR_SET_GROUPINFO"     , SAMR_SET_GROUPINFO    , api_samr_set_groupinfo    },
1485       {"SAMR_SET_ALIASINFO"     , SAMR_SET_ALIASINFO    , api_samr_set_aliasinfo    },
1486       {"SAMR_CREATE_USER"       , SAMR_CREATE_USER      , api_samr_create_user      },
1487       {"SAMR_LOOKUP_RIDS"       , SAMR_LOOKUP_RIDS      , api_samr_lookup_rids      },
1488       {"SAMR_GET_DOM_PWINFO"    , SAMR_GET_DOM_PWINFO   , api_samr_get_dom_pwinfo   },
1489       {"SAMR_CHGPASSWD_USER"    , SAMR_CHGPASSWD_USER   , api_samr_chgpasswd_user   },
1490       {"SAMR_OPEN_ALIAS"        , SAMR_OPEN_ALIAS       , api_samr_open_alias       },
1491       {"SAMR_OPEN_GROUP"        , SAMR_OPEN_GROUP       , api_samr_open_group       },
1492       {"SAMR_OPEN_DOMAIN"       , SAMR_OPEN_DOMAIN      , api_samr_open_domain      },
1493       {"SAMR_UNKNOWN_2D"        , SAMR_UNKNOWN_2D       , api_samr_unknown_2d       },
1494       {"SAMR_LOOKUP_DOMAIN"     , SAMR_LOOKUP_DOMAIN    , api_samr_lookup_domain    },
1495
1496       {"SAMR_QUERY_SEC_OBJECT"  , SAMR_QUERY_SEC_OBJECT , api_samr_query_sec_obj    },
1497       {"SAMR_SET_SEC_OBJECT"    , SAMR_SET_SEC_OBJECT   , api_samr_set_sec_obj      },
1498       {"SAMR_GET_USRDOM_PWINFO" , SAMR_GET_USRDOM_PWINFO, api_samr_get_usrdom_pwinfo},
1499       {"SAMR_UNKNOWN_2E"        , SAMR_UNKNOWN_2E       , api_samr_unknown_2e       },
1500       {"SAMR_SET_DOMAIN_INFO"   , SAMR_SET_DOMAIN_INFO  , api_samr_set_dom_info     },
1501       {"SAMR_CONNECT4"          , SAMR_CONNECT4         , api_samr_connect4         }
1502     };
1503   return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "samr", "lsass", api_samr_cmds,
1504                                     sizeof(api_samr_cmds) / sizeof(struct api_struct));
1505 }