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