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