source/rpc_server/srv_samr.c

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