source3/rpc_client/cli_samr.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NT Domain Authentication SMB / MSRPC client
   5    Copyright (C) Andrew Tridgell 1994-1997
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24
  25 #ifdef SYSLOG
  26 #undef SYSLOG
  27 #endif
  28
  29 #include "includes.h"
  30 #include "nterr.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34
  35
  36 /****************************************************************************
  37 do a SAMR create domain user
  38 ****************************************************************************/
  39 BOOL create_samr_domain_user(struct cli_state *cli, uint16 fnum,
  40                                 POLICY_HND *pol_open_domain,
  41                                 const char *acct_name, uint16 acb_info,
  42                                 uint32 *rid)
  43 {
  44         POLICY_HND pol_open_user;
  45         BOOL ret = True;
  46
  47         if (pol_open_domain == NULL || acct_name == NULL) return False;
  48
  49         /* send create user */
  50         if (!samr_create_dom_user(cli, fnum,
  51                                 pol_open_domain,
  52                                 acct_name, acb_info, 0xe005000b,
  53                                 &pol_open_user, rid))
  54         {
  55                 return False;
  56         }
  57
  58         DEBUG(5,("create_samr_domain_user: name: %s rid 0x%x\n",
  59                   acct_name, *rid));
  60
  61         return samr_close(cli, fnum, &pol_open_user) && ret;
  62 }
  63
  64 /****************************************************************************
  65 do a SAMR create domain alias
  66 ****************************************************************************/
  67 BOOL create_samr_domain_alias(struct cli_state *cli, uint16 fnum,
  68                                 POLICY_HND *pol_open_domain,
  69                                 const char *acct_name, const char *acct_desc,
  70                                 uint32 *rid)
  71 {
  72         POLICY_HND pol_open_alias;
  73         ALIAS_INFO_CTR ctr;
  74         BOOL ret = True;
  75
  76         if (pol_open_domain == NULL || acct_name == NULL || acct_desc == NULL) return False;
  77
  78         /* send create alias */
  79         if (!samr_create_dom_alias(cli, fnum,
  80                                 pol_open_domain,
  81                                 acct_name,
  82                                 &pol_open_alias, rid))
  83         {
  84                 return False;
  85         }
  86
  87         DEBUG(5,("create_samr_domain_alias: name: %s rid 0x%x\n",
  88                   acct_name, *rid));
  89
  90         ctr.switch_value1 = 3;
  91         make_samr_alias_info3(&ctr.alias.info3, acct_desc);
  92
  93         /* send set alias info */
  94         if (!samr_set_aliasinfo(cli, fnum,
  95                                 &pol_open_alias,
  96                                 &ctr))
  97         {
  98                 DEBUG(5,("create_samr_domain_alias: error in samr_set_aliasinfo\n"));
  99                 ret = False;
 100         }
 101
 102         return samr_close(cli, fnum,&pol_open_alias) && ret;
 103 }
 104
 105 /****************************************************************************
 106 do a SAMR create domain group
 107 ****************************************************************************/
 108 BOOL create_samr_domain_group(struct cli_state *cli, uint16 fnum,
 109                                 POLICY_HND *pol_open_domain,
 110                                 const char *acct_name, const char *acct_desc,
 111                                 uint32 *rid)
 112 {
 113         POLICY_HND pol_open_group;
 114         GROUP_INFO_CTR ctr;
 115         BOOL ret = True;
 116
 117         if (pol_open_domain == NULL || acct_name == NULL || acct_desc == NULL) return False;
 118
 119         /* send create group*/
 120         if (!samr_create_dom_group(cli, fnum,
 121                                 pol_open_domain,
 122                                 acct_name,
 123                                 &pol_open_group, rid))
 124         {
 125                 return False;
 126         }
 127
 128         DEBUG(5,("create_samr_domain_group: name: %s rid 0x%x\n",
 129                   acct_name, *rid));
 130
 131         ctr.switch_value1 = 4;
 132         ctr.switch_value2 = 4;
 133         make_samr_group_info4(&ctr.group.info4, acct_desc);
 134
 135         /* send user groups query */
 136         if (!samr_set_groupinfo(cli, fnum,
 137                                 &pol_open_group,
 138                                 &ctr))
 139         {
 140                 DEBUG(5,("create_samr_domain_group: error in samr_set_groupinfo\n"));
 141                 ret = False;
 142         }
 143
 144         return samr_close(cli, fnum,&pol_open_group) && ret;
 145 }
 146
 147 /****************************************************************************
 148 do a SAMR query user groups
 149 ****************************************************************************/
 150 BOOL get_samr_query_usergroups(struct cli_state *cli, uint16 fnum,
 151                                 POLICY_HND *pol_open_domain, uint32 user_rid,
 152                                 uint32 *num_groups, DOM_GID **gid)
 153 {
 154         POLICY_HND pol_open_user;
 155         BOOL ret = True;
 156
 157         if (pol_open_domain == NULL || num_groups == NULL || gid == NULL) return False;
 158
 159         /* send open domain (on user sid) */
 160         if (!samr_open_user(cli, fnum,
 161                                 pol_open_domain,
 162                                 0x02011b, user_rid,
 163                                 &pol_open_user))
 164         {
 165                 return False;
 166         }
 167
 168         /* send user groups query */
 169         if (!samr_query_usergroups(cli, fnum,
 170                                 &pol_open_user,
 171                                 num_groups, gid))
 172         {
 173                 DEBUG(5,("samr_query_usergroups: error in query user groups\n"));
 174                 ret = False;
 175         }
 176
 177         return samr_close(cli, fnum,&pol_open_user) && ret;
 178 }
 179
 180 /****************************************************************************
 181 do a SAMR delete group
 182 ****************************************************************************/
 183 BOOL delete_samr_dom_group(struct cli_state *cli, uint16 fnum,
 184                                 POLICY_HND *pol_open_domain,
 185                                 uint32 group_rid)
 186 {
 187         POLICY_HND pol_open_group;
 188
 189         if (pol_open_domain == NULL) return False;
 190
 191         /* send open domain (on group rid) */
 192         if (!samr_open_group(cli, fnum,pol_open_domain,
 193                                 0x00000010, group_rid,
 194                                 &pol_open_group))
 195         {
 196                 return False;
 197         }
 198
 199         /* send group delete */
 200         if (!samr_delete_dom_group(cli, fnum,&pol_open_group))
 201
 202         {
 203                 DEBUG(5,("delete_samr_dom_group: error in delete domain group\n"));
 204                 samr_close(cli, fnum,&pol_open_group);
 205                 return False;
 206         }
 207
 208         return True;
 209 }
 210
 211
 212 /****************************************************************************
 213 do a SAMR query group members
 214 ****************************************************************************/
 215 BOOL get_samr_query_groupmem(struct cli_state *cli, uint16 fnum,
 216                                 POLICY_HND *pol_open_domain,
 217                                 uint32 group_rid, uint32 *num_mem,
 218                                 uint32 **rid, uint32 **attr)
 219 {
 220         POLICY_HND pol_open_group;
 221         BOOL ret = True;
 222
 223         if (pol_open_domain == NULL || num_mem == NULL || rid == NULL || attr == NULL) return False;
 224
 225         /* send open domain (on group sid) */
 226         if (!samr_open_group(cli, fnum,pol_open_domain,
 227                                 0x00000010, group_rid,
 228                                 &pol_open_group))
 229         {
 230                 return False;
 231         }
 232
 233         /* send group info query */
 234         if (!samr_query_groupmem(cli, fnum,&pol_open_group, num_mem, rid, attr))
 235
 236         {
 237                 DEBUG(5,("samr_query_group: error in query group members\n"));
 238                 ret = False;
 239         }
 240
 241         return samr_close(cli, fnum,&pol_open_group) && ret;
 242 }
 243
 244 /****************************************************************************
 245 do a SAMR delete alias
 246 ****************************************************************************/
 247 BOOL delete_samr_dom_alias(struct cli_state *cli, uint16 fnum,
 248                                 POLICY_HND *pol_open_domain,
 249                                 uint32 alias_rid)
 250 {
 251         POLICY_HND pol_open_alias;
 252
 253         if (pol_open_domain == NULL) return False;
 254
 255         /* send open domain (on alias rid) */
 256         if (!samr_open_alias(cli, fnum,pol_open_domain,
 257                                 0x000f001f, alias_rid, &pol_open_alias))
 258         {
 259                 return False;
 260         }
 261
 262         /* send alias delete */
 263         if (!samr_delete_dom_alias(cli, fnum,&pol_open_alias))
 264
 265         {
 266                 DEBUG(5,("delete_samr_dom_alias: error in delete domain alias\n"));
 267                 samr_close(cli, fnum,&pol_open_alias);
 268                 return False;
 269         }
 270
 271         return True;
 272 }
 273
 274
 275 /****************************************************************************
 276 do a SAMR query alias members
 277 ****************************************************************************/
 278 BOOL get_samr_query_aliasmem(struct cli_state *cli, uint16 fnum,
 279                                 POLICY_HND *pol_open_domain,
 280                                 uint32 alias_rid, uint32 *num_mem, DOM_SID2 *sid)
 281 {
 282         POLICY_HND pol_open_alias;
 283         BOOL ret = True;
 284
 285         if (pol_open_domain == NULL || num_mem == NULL || sid == NULL) return False;
 286
 287         /* send open domain (on alias sid) */
 288         if (!samr_open_alias(cli, fnum, pol_open_domain,
 289                                 0x000f001f, alias_rid,
 290                                 &pol_open_alias))
 291         {
 292                 return False;
 293         }
 294
 295         /* send alias info query */
 296         if (!samr_query_aliasmem(cli, fnum, &pol_open_alias, num_mem, sid))
 297
 298         {
 299                 DEBUG(5,("samr_query_alias: error in query alias members\n"));
 300                 ret = False;
 301         }
 302
 303         return samr_close(cli, fnum,&pol_open_alias) && ret;
 304 }
 305
 306 /****************************************************************************
 307 do a SAMR query user info
 308 ****************************************************************************/
 309 BOOL get_samr_query_userinfo(struct cli_state *cli, uint16 fnum,
 310                                 POLICY_HND *pol_open_domain,
 311                                 uint32 info_level,
 312                                 uint32 user_rid, SAM_USER_INFO_21 *usr)
 313 {
 314         POLICY_HND pol_open_user;
 315         BOOL ret = True;
 316
 317         if (pol_open_domain == NULL || usr == NULL) return False;
 318
 319         bzero(usr, sizeof(*usr));
 320
 321         /* send open domain (on user sid) */
 322         if (!samr_open_user(cli, fnum,
 323                                 pol_open_domain,
 324                                 0x02011b, user_rid,
 325                                 &pol_open_user))
 326         {
 327                 return False;
 328         }
 329
 330         /* send user info query */
 331         if (!samr_query_userinfo(cli, fnum,
 332                                 &pol_open_user,
 333                                 info_level, (void*)usr))
 334         {
 335                 DEBUG(5,("samr_query_userinfo: error in query user info, level 0x%x\n",
 336                           info_level));
 337                 ret = False;
 338         }
 339
 340         return samr_close(cli, fnum,&pol_open_user) && ret;
 341 }
 342
 343 /****************************************************************************
 344 do a SAMR query group info
 345 ****************************************************************************/
 346 BOOL get_samr_query_groupinfo(struct cli_state *cli, uint16 fnum,
 347                                 POLICY_HND *pol_open_domain,
 348                                 uint32 info_level,
 349                                 uint32 group_rid, GROUP_INFO_CTR *ctr)
 350 {
 351         POLICY_HND pol_open_group;
 352         BOOL ret = True;
 353
 354         if (pol_open_domain == NULL || ctr == NULL) return False;
 355
 356         bzero(ctr, sizeof(*ctr));
 357
 358         /* send open domain (on group sid) */
 359         if (!samr_open_group(cli, fnum,
 360                                 pol_open_domain,
 361                                 0x02000000, group_rid, &pol_open_group))
 362         {
 363                 return False;
 364         }
 365
 366         /* send group info query */
 367         if (!samr_query_groupinfo(cli, fnum,
 368                                 &pol_open_group,
 369                                 info_level, ctr))
 370         {
 371                 DEBUG(5,("samr_query_groupinfo: error in query group info, level 0x%x\n",
 372                           info_level));
 373                 ret = False;
 374         }
 375
 376         return samr_close(cli, fnum,&pol_open_group) && ret;
 377 }
 378
 379 /****************************************************************************
 380 do a SAMR change user password command
 381 ****************************************************************************/
 382 BOOL samr_chgpasswd_user(struct cli_state *cli, uint16 fnum,
 383                 char *srv_name, char *user_name,
 384                 char nt_newpass[516], uchar nt_oldhash[16],
 385                 char lm_newpass[516], uchar lm_oldhash[16])
 386 {
 387         prs_struct data;
 388         prs_struct rdata;
 389
 390         SAMR_Q_CHGPASSWD_USER q_e;
 391         BOOL valid_pwc = False;
 392
 393         /* create and send a MSRPC command with api SAMR_CHGPASSWD_USER */
 394
 395         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 396         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 397
 398         DEBUG(4,("SAMR Change User Password. server:%s username:%s\n",
 399                 srv_name, user_name));
 400
 401         make_samr_q_chgpasswd_user(&q_e, srv_name, user_name,
 402                                    nt_newpass, nt_oldhash,
 403                                    lm_newpass, lm_oldhash);
 404
 405         /* turn parameters into data stream */
 406         samr_io_q_chgpasswd_user("", &q_e, &data, 0);
 407
 408         /* send the data on \PIPE\ */
 409         if (rpc_api_pipe_req(cli, fnum, SAMR_CHGPASSWD_USER, &data, &rdata))
 410         {
 411                 SAMR_R_CHGPASSWD_USER r_e;
 412                 BOOL p;
 413
 414                 samr_io_r_chgpasswd_user("", &r_e, &rdata, 0);
 415
 416                 p = rdata.offset != 0;
 417                 if (p && r_e.status != 0)
 418                 {
 419                         /* report error code */
 420                         DEBUG(4,("SAMR_R_CHGPASSWD_USER: %s\n", get_nt_error_msg(r_e.status)));
 421                         p = False;
 422                 }
 423
 424                 if (p)
 425                 {
 426                         valid_pwc = True;
 427                 }
 428         }
 429
 430         prs_mem_free(&data   );
 431         prs_mem_free(&rdata  );
 432
 433         return valid_pwc;
 434 }
 435
 436
 437 /****************************************************************************
 438 do a SAMR unknown 0x38 command
 439 ****************************************************************************/
 440 BOOL samr_unknown_38(struct cli_state *cli, uint16 fnum, char *srv_name)
 441 {
 442         prs_struct data;
 443         prs_struct rdata;
 444
 445         SAMR_Q_UNKNOWN_38 q_e;
 446         BOOL valid_un8 = False;
 447
 448         /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
 449
 450         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 451         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 452
 453         DEBUG(4,("SAMR Unknown 38 server:%s\n", srv_name));
 454
 455         make_samr_q_unknown_38(&q_e, srv_name);
 456
 457         /* turn parameters into data stream */
 458         samr_io_q_unknown_38("", &q_e, &data, 0);
 459
 460         /* send the data on \PIPE\ */
 461         if (rpc_api_pipe_req(cli, fnum, SAMR_GET_DOM_PWINFO, &data, &rdata))
 462         {
 463                 SAMR_R_UNKNOWN_38 r_e;
 464                 BOOL p;
 465
 466                 samr_io_r_unknown_38("", &r_e, &rdata, 0);
 467
 468                 p = rdata.offset != 0;
 469 #if 0
 470                 if (p && r_e.status != 0)
 471                 {
 472                         /* report error code */
 473                         DEBUG(4,("SAMR_R_UNKNOWN_38: %s\n", get_nt_error_msg(r_e.status)));
 474                         p = False;
 475                 }
 476 #endif
 477                 if (p)
 478                 {
 479                         valid_un8 = True;
 480                 }
 481         }
 482
 483         prs_mem_free(&data   );
 484         prs_mem_free(&rdata  );
 485
 486         return valid_un8;
 487 }
 488
 489 /****************************************************************************
 490 do a SAMR unknown 0x8 command
 491 ****************************************************************************/
 492 BOOL samr_query_dom_info(struct cli_state *cli, uint16 fnum,
 493                                 POLICY_HND *domain_pol, uint16 switch_value,
 494                                 SAM_UNK_CTR *ctr)
 495 {
 496         prs_struct data;
 497         prs_struct rdata;
 498
 499         SAMR_Q_QUERY_DOMAIN_INFO q_e;
 500         BOOL valid_un8 = False;
 501
 502         DEBUG(4,("SAMR Unknown 8 switch:%d\n", switch_value));
 503
 504         if (domain_pol == NULL) return False;
 505
 506         /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
 507
 508         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 509         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 510
 511         /* store the parameters */
 512         make_samr_q_query_dom_info(&q_e, domain_pol, switch_value);
 513
 514         /* turn parameters into data stream */
 515         samr_io_q_query_dom_info("", &q_e, &data, 0);
 516
 517         /* send the data on \PIPE\ */
 518         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_DOMAIN_INFO, &data, &rdata))
 519         {
 520                 SAMR_R_QUERY_DOMAIN_INFO r_e;
 521                 BOOL p;
 522
 523                 r_e.ctr = ctr;
 524                 samr_io_r_query_dom_info("", &r_e, &rdata, 0);
 525
 526                 p = rdata.offset != 0;
 527                 if (p && r_e.status != 0)
 528                 {
 529                         /* report error code */
 530                         DEBUG(4,("SAMR_R_QUERY_DOMAIN_INFO: %s\n", get_nt_error_msg(r_e.status)));
 531                         p = False;
 532                 }
 533
 534                 if (p)
 535                 {
 536                         valid_un8 = True;
 537                 }
 538         }
 539
 540         prs_mem_free(&data   );
 541         prs_mem_free(&rdata  );
 542
 543         return valid_un8;
 544 }
 545
 546 /****************************************************************************
 547 do a SAMR enumerate groups
 548 ****************************************************************************/
 549 uint32 samr_enum_dom_groups(struct cli_state *cli, uint16 fnum,
 550                                 POLICY_HND *pol,
 551                                 uint32 *start_idx, uint32 size,
 552                                 struct acct_info **sam,
 553                                 uint32 *num_sam_groups)
 554 {
 555         uint32 status = 0x0;
 556         prs_struct data;
 557         prs_struct rdata;
 558
 559         SAMR_Q_ENUM_DOM_GROUPS q_e;
 560
 561         DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
 562
 563         if (pol == NULL || num_sam_groups == NULL)
 564         {
 565                 return NT_STATUS_INVALID_PARAMETER | 0xC0000000;
 566         }
 567
 568         /* create and send a MSRPC command with api SAMR_ENUM_DOM_GROUPS */
 569
 570         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 571         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 572
 573         /* store the parameters */
 574         make_samr_q_enum_dom_groups(&q_e, pol, *start_idx, size);
 575
 576         /* turn parameters into data stream */
 577         samr_io_q_enum_dom_groups("", &q_e, &data, 0);
 578
 579         /* send the data on \PIPE\ */
 580         if (rpc_api_pipe_req(cli, fnum, SAMR_ENUM_DOM_GROUPS, &data, &rdata))
 581         {
 582                 SAMR_R_ENUM_DOM_GROUPS r_e;
 583                 BOOL p;
 584
 585                 samr_io_r_enum_dom_groups("", &r_e, &rdata, 0);
 586
 587                 status = r_e.status;
 588                 p = rdata.offset != 0;
 589                 if (p && r_e.status != 0)
 590                 {
 591                         /* report error code */
 592                         DEBUG(4,("SAMR_R_ENUM_DOM_GROUPS: %s\n", get_nt_error_msg(r_e.status)));
 593                         p = (r_e.status == STATUS_MORE_ENTRIES);
 594                 }
 595
 596                 if (p)
 597                 {
 598                         uint32 i = (*num_sam_groups);
 599                         uint32 j = 0;
 600                         uint32 name_idx = 0;
 601
 602                         (*num_sam_groups) += r_e.num_entries2;
 603                         (*sam) = (struct acct_info*) Realloc((*sam),
 604                                sizeof(struct acct_info) * (*num_sam_groups));
 605
 606                         if ((*sam) == NULL)
 607                         {
 608                                 (*num_sam_groups) = 0;
 609                                 i = 0;
 610                         }
 611
 612                         for (j = 0; i < (*num_sam_groups) && j < r_e.num_entries2; j++, i++)
 613                         {
 614                                 (*sam)[i].rid = r_e.sam[j].rid;
 615                                 (*sam)[i].acct_name[0] = 0;
 616                                 (*sam)[i].acct_desc[0] = 0;
 617                                 if (r_e.sam[j].hdr_name.buffer)
 618                                 {
 619                                         unistr2_to_ascii((*sam)[i].acct_name, &r_e.uni_grp_name[name_idx], sizeof((*sam)[i].acct_name)-1);
 620                                         name_idx++;
 621                                 }
 622                                 DEBUG(5,("samr_enum_dom_groups: idx: %4d rid: %8x acct: %s\n",
 623                                           i, (*sam)[i].rid, (*sam)[i].acct_name));
 624                         }
 625                         (*start_idx) = r_e.next_idx;
 626                 }
 627                 else if (status == 0x0)
 628                 {
 629                         status = NT_STATUS_INVALID_PARAMETER | 0xC0000000;
 630                 }
 631
 632         }
 633
 634         prs_mem_free(&data   );
 635         prs_mem_free(&rdata  );
 636
 637         return status;
 638 }
 639
 640 /****************************************************************************
 641 do a SAMR enumerate aliases
 642 ****************************************************************************/
 643 BOOL samr_enum_dom_aliases(struct cli_state *cli, uint16 fnum,
 644                                 POLICY_HND *pol,
 645                                 uint32 start_idx, uint32 size,
 646                                 struct acct_info **sam,
 647                                 uint32 *num_sam_aliases)
 648 {
 649         prs_struct data;
 650         prs_struct rdata;
 651
 652         SAMR_Q_ENUM_DOM_ALIASES q_e;
 653         BOOL valid_pol = False;
 654
 655         DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
 656
 657         if (pol == NULL || num_sam_aliases == NULL) return False;
 658
 659         /* create and send a MSRPC command with api SAMR_ENUM_DOM_ALIASES */
 660
 661         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 662         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 663
 664         /* store the parameters */
 665         make_samr_q_enum_dom_aliases(&q_e, pol, start_idx, size);
 666
 667         /* turn parameters into data stream */
 668         samr_io_q_enum_dom_aliases("", &q_e, &data, 0);
 669
 670         /* send the data on \PIPE\ */
 671         if (rpc_api_pipe_req(cli, fnum, SAMR_ENUM_DOM_ALIASES, &data, &rdata))
 672         {
 673                 SAMR_R_ENUM_DOM_ALIASES r_e;
 674                 BOOL p;
 675
 676                 samr_io_r_enum_dom_aliases("", &r_e, &rdata, 0);
 677
 678                 p = rdata.offset != 0;
 679                 if (p && r_e.status != 0)
 680                 {
 681                         /* report error code */
 682                         DEBUG(4,("SAMR_R_ENUM_DOM_ALIASES: %s\n", get_nt_error_msg(r_e.status)));
 683                         p = False;
 684                 }
 685
 686                 if (p)
 687                 {
 688                         uint32 i;
 689                         int name_idx = 0;
 690
 691                         *num_sam_aliases = r_e.num_entries2;
 692                         if (*num_sam_aliases > MAX_SAM_ENTRIES)
 693                         {
 694                                 *num_sam_aliases = MAX_SAM_ENTRIES;
 695                                 DEBUG(2,("samr_enum_dom_aliases: sam user entries limited to %d\n",
 696                                           *num_sam_aliases));
 697                         }
 698
 699                         *sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_aliases));
 700
 701                         if ((*sam) == NULL)
 702                         {
 703                                 *num_sam_aliases = 0;
 704                         }
 705
 706                         for (i = 0; i < *num_sam_aliases; i++)
 707                         {
 708                                 (*sam)[i].rid = r_e.sam[i].rid;
 709                                 (*sam)[i].acct_name[0] = 0;
 710                                 (*sam)[i].acct_desc[0] = 0;
 711                                 if (r_e.sam[i].hdr_name.buffer)
 712                                 {
 713                                         unistr2_to_ascii((*sam)[i].acct_name, &r_e.uni_grp_name[name_idx], sizeof((*sam)[i].acct_name)-1);
 714                                         name_idx++;
 715                                 }
 716                                 DEBUG(5,("samr_enum_dom_aliases: idx: %4d rid: %8x acct: %s\n",
 717                                           i, (*sam)[i].rid, (*sam)[i].acct_name));
 718                         }
 719                         valid_pol = True;
 720                 }
 721         }
 722
 723         prs_mem_free(&data   );
 724         prs_mem_free(&rdata  );
 725
 726         return valid_pol;
 727 }
 728
 729 /****************************************************************************
 730 do a SAMR enumerate users
 731 ****************************************************************************/
 732 uint32 samr_enum_dom_users(struct cli_state *cli, uint16 fnum,
 733                                 POLICY_HND *pol, uint32 *start_idx,
 734                                 uint16 acb_mask, uint16 unk_1, uint32 size,
 735                                 struct acct_info **sam,
 736                                 uint32 *num_sam_users)
 737 {
 738         uint32 status = 0x0;
 739         prs_struct data;
 740         prs_struct rdata;
 741
 742         SAMR_Q_ENUM_DOM_USERS q_e;
 743
 744         DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
 745
 746         if (pol == NULL || num_sam_users == NULL)
 747         {
 748                 return NT_STATUS_INVALID_PARAMETER | 0xC0000000;
 749         }
 750
 751         /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
 752
 753         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 754         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 755
 756         /* store the parameters */
 757         make_samr_q_enum_dom_users(&q_e, pol, *start_idx,
 758                                    acb_mask, unk_1, size);
 759
 760         /* turn parameters into data stream */
 761         samr_io_q_enum_dom_users("", &q_e, &data, 0);
 762
 763         /* send the data on \PIPE\ */
 764         if (rpc_api_pipe_req(cli, fnum, SAMR_ENUM_DOM_USERS, &data, &rdata))
 765         {
 766                 SAMR_R_ENUM_DOM_USERS r_e;
 767                 BOOL p;
 768
 769                 samr_io_r_enum_dom_users("", &r_e, &rdata, 0);
 770
 771                 status = r_e.status;
 772                 p = rdata.offset != 0;
 773
 774                 if (p && r_e.status != 0)
 775                 {
 776                         /* report error code */
 777                         DEBUG(4,("SAMR_R_ENUM_DOM_USERS: %s\n", get_nt_error_msg(r_e.status)));
 778                         p = (r_e.status == STATUS_MORE_ENTRIES);
 779                 }
 780
 781                 if (p)
 782                 {
 783                         uint32 i = (*num_sam_users);
 784                         uint32 j = 0;
 785                         uint32 name_idx = 0;
 786
 787                         (*num_sam_users) += r_e.num_entries2;
 788                         (*sam) = (struct acct_info*) Realloc((*sam),
 789                                sizeof(struct acct_info) * (*num_sam_users));
 790
 791                         if ((*sam) == NULL)
 792                         {
 793                                 (*num_sam_users) = 0;
 794                                 i = 0;
 795                         }
 796
 797                         for (j = 0; i < (*num_sam_users) && j < r_e.num_entries2; j++, i++)
 798                         {
 799                                 (*sam)[i].rid = r_e.sam[j].rid;
 800                                 (*sam)[i].acct_name[0] = 0;
 801                                 (*sam)[i].acct_desc[0] = 0;
 802                                 if (r_e.sam[j].hdr_name.buffer)
 803                                 {
 804                                         unistr2_to_ascii((*sam)[i].acct_name, &r_e.uni_acct_name[name_idx], sizeof((*sam)[i].acct_name)-1);
 805                                         name_idx++;
 806                                 }
 807                                 DEBUG(5,("samr_enum_dom_users: idx: %4d rid: %8x acct: %s\n",
 808                                           i, (*sam)[i].rid, (*sam)[i].acct_name));
 809                         }
 810                         (*start_idx) = r_e.next_idx;
 811                 }
 812                 else if (status == 0x0)
 813                 {
 814                         status = NT_STATUS_INVALID_PARAMETER | 0xC0000000;
 815                 }
 816
 817                 if (r_e.sam != NULL)
 818                 {
 819                         free(r_e.sam);
 820                 }
 821                 if (r_e.uni_acct_name != NULL)
 822                 {
 823                         free(r_e.uni_acct_name);
 824                 }
 825         }
 826         else
 827         {
 828                 status = NT_STATUS_ACCESS_DENIED | 0xC0000000;
 829         }
 830
 831         prs_mem_free(&data   );
 832         prs_mem_free(&rdata  );
 833
 834         return status;
 835 }
 836
 837 /****************************************************************************
 838 do a SAMR Connect
 839 ****************************************************************************/
 840 BOOL samr_connect(struct cli_state *cli, uint16 fnum,
 841                                 char *srv_name, uint32 unknown_0,
 842                                 POLICY_HND *connect_pol)
 843 {
 844         prs_struct data;
 845         prs_struct rdata;
 846
 847         SAMR_Q_CONNECT q_o;
 848         BOOL valid_pol = False;
 849
 850         DEBUG(4,("SAMR Open Policy server:%s undoc value:%x\n",
 851                                 srv_name, unknown_0));
 852
 853         if (srv_name == NULL || connect_pol == NULL) return False;
 854
 855         /* create and send a MSRPC command with api SAMR_CONNECT */
 856
 857         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 858         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 859
 860         /* store the parameters */
 861         make_samr_q_connect(&q_o, srv_name, unknown_0);
 862
 863         /* turn parameters into data stream */
 864         samr_io_q_connect("", &q_o,  &data, 0);
 865
 866         /* send the data on \PIPE\ */
 867         if (rpc_api_pipe_req(cli, fnum, SAMR_CONNECT, &data, &rdata))
 868         {
 869                 SAMR_R_CONNECT r_o;
 870                 BOOL p;
 871
 872                 samr_io_r_connect("", &r_o, &rdata, 0);
 873                 p = rdata.offset != 0;
 874
 875                 if (p && r_o.status != 0)
 876                 {
 877                         /* report error code */
 878                         DEBUG(4,("SAMR_R_CONNECT: %s\n", get_nt_error_msg(r_o.status)));
 879                         p = False;
 880                 }
 881
 882                 if (p)
 883                 {
 884                         memcpy(connect_pol, &r_o.connect_pol, sizeof(r_o.connect_pol));
 885                         valid_pol = True;
 886                 }
 887         }
 888
 889         prs_mem_free(&data   );
 890         prs_mem_free(&rdata  );
 891
 892         return valid_pol;
 893 }
 894
 895 /****************************************************************************
 896 do a SAMR Open User
 897 ****************************************************************************/
 898 BOOL samr_open_user(struct cli_state *cli, uint16 fnum,
 899                                 POLICY_HND *pol, uint32 unk_0, uint32 rid,
 900                                 POLICY_HND *user_pol)
 901 {
 902         prs_struct data;
 903         prs_struct rdata;
 904
 905         SAMR_Q_OPEN_USER q_o;
 906         BOOL valid_pol = False;
 907
 908         DEBUG(4,("SAMR Open User.  unk_0: %08x RID:%x\n",
 909                   unk_0, rid));
 910
 911         if (pol == NULL || user_pol == NULL) return False;
 912
 913         /* create and send a MSRPC command with api SAMR_OPEN_USER */
 914
 915         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 916         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 917
 918         /* store the parameters */
 919         make_samr_q_open_user(&q_o, pol, unk_0, rid);
 920
 921         /* turn parameters into data stream */
 922         samr_io_q_open_user("", &q_o,  &data, 0);
 923
 924         /* send the data on \PIPE\ */
 925         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_USER, &data, &rdata))
 926         {
 927                 SAMR_R_OPEN_USER r_o;
 928                 BOOL p;
 929
 930                 samr_io_r_open_user("", &r_o, &rdata, 0);
 931                 p = rdata.offset != 0;
 932
 933                 if (p && r_o.status != 0)
 934                 {
 935                         /* report error code */
 936                         DEBUG(4,("SAMR_R_OPEN_USER: %s\n", get_nt_error_msg(r_o.status)));
 937                         p = False;
 938                 }
 939
 940                 if (p)
 941                 {
 942                         memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
 943                         valid_pol = True;
 944                 }
 945         }
 946
 947         prs_mem_free(&data   );
 948         prs_mem_free(&rdata  );
 949
 950         return valid_pol;
 951 }
 952
 953 /****************************************************************************
 954 do a SAMR Open Alias
 955 ****************************************************************************/
 956 BOOL samr_open_alias(struct cli_state *cli, uint16 fnum,
 957                                 POLICY_HND *domain_pol,
 958                                 uint32 flags, uint32 rid,
 959                                 POLICY_HND *alias_pol)
 960 {
 961         prs_struct data;
 962         prs_struct rdata;
 963
 964         SAMR_Q_OPEN_ALIAS q_o;
 965         BOOL valid_pol = False;
 966
 967         DEBUG(4,("SAMR Open Alias. RID:%x\n", rid));
 968
 969         if (alias_pol == NULL || domain_pol == NULL) return False;
 970
 971         /* create and send a MSRPC command with api SAMR_OPEN_ALIAS */
 972
 973         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 974         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 975
 976         /* store the parameters */
 977         make_samr_q_open_alias(&q_o, domain_pol, flags, rid);
 978
 979         /* turn parameters into data stream */
 980         samr_io_q_open_alias("", &q_o,  &data, 0);
 981
 982         /* send the data on \PIPE\ */
 983         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_ALIAS, &data, &rdata))
 984         {
 985                 SAMR_R_OPEN_ALIAS r_o;
 986                 BOOL p;
 987
 988                 samr_io_r_open_alias("", &r_o, &rdata, 0);
 989                 p = rdata.offset != 0;
 990
 991                 if (p && r_o.status != 0)
 992                 {
 993                         /* report error code */
 994                         DEBUG(4,("SAMR_R_OPEN_ALIAS: %s\n", get_nt_error_msg(r_o.status)));
 995                         p = False;
 996                 }
 997
 998                 if (p)
 999                 {
1000                         memcpy(alias_pol, &r_o.pol, sizeof(r_o.pol));
1001                         valid_pol = True;
1002                 }
1003         }
1004
1005         prs_mem_free(&data   );
1006         prs_mem_free(&rdata  );
1007
1008         return valid_pol;
1009 }
1010
1011 /****************************************************************************
1012 do a SAMR Delete Alias Member
1013 ****************************************************************************/
1014 BOOL samr_del_aliasmem(struct cli_state *cli, uint16 fnum,
1015                                 POLICY_HND *alias_pol, DOM_SID *sid)
1016 {
1017         prs_struct data;
1018         prs_struct rdata;
1019
1020         SAMR_Q_DEL_ALIASMEM q_o;
1021         BOOL valid_pol = False;
1022
1023         if (alias_pol == NULL || sid == NULL) return False;
1024
1025         /* create and send a MSRPC command with api SAMR_DEL_ALIASMEM */
1026
1027         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1028         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1029
1030         DEBUG(4,("SAMR Delete Alias Member.\n"));
1031
1032         /* store the parameters */
1033         make_samr_q_del_aliasmem(&q_o, alias_pol, sid);
1034
1035         /* turn parameters into data stream */
1036         samr_io_q_del_aliasmem("", &q_o,  &data, 0);
1037
1038         /* send the data on \PIPE\ */
1039         if (rpc_api_pipe_req(cli, fnum, SAMR_DEL_ALIASMEM, &data, &rdata))
1040         {
1041                 SAMR_R_DEL_ALIASMEM r_o;
1042                 BOOL p;
1043
1044                 samr_io_r_del_aliasmem("", &r_o, &rdata, 0);
1045                 p = rdata.offset != 0;
1046
1047                 if (p && r_o.status != 0)
1048                 {
1049                         /* report error code */
1050                         DEBUG(4,("SAMR_R_DEL_ALIASMEM: %s\n", get_nt_error_msg(r_o.status)));
1051                         p = False;
1052                 }
1053
1054                 if (p)
1055                 {
1056                         valid_pol = True;
1057                 }
1058         }
1059
1060         prs_mem_free(&data   );
1061         prs_mem_free(&rdata  );
1062
1063         return valid_pol;
1064 }
1065
1066 /****************************************************************************
1067 do a SAMR Add Alias Member
1068 ****************************************************************************/
1069 BOOL samr_add_aliasmem(struct cli_state *cli, uint16 fnum,
1070                                 POLICY_HND *alias_pol, DOM_SID *sid)
1071 {
1072         prs_struct data;
1073         prs_struct rdata;
1074
1075         SAMR_Q_ADD_ALIASMEM q_o;
1076         BOOL valid_pol = False;
1077
1078         if (alias_pol == NULL || sid == NULL) return False;
1079
1080         /* create and send a MSRPC command with api SAMR_ADD_ALIASMEM */
1081
1082         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1083         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1084
1085         DEBUG(4,("SAMR Add Alias Member.\n"));
1086
1087         /* store the parameters */
1088         make_samr_q_add_aliasmem(&q_o, alias_pol, sid);
1089
1090         /* turn parameters into data stream */
1091         samr_io_q_add_aliasmem("", &q_o,  &data, 0);
1092
1093         /* send the data on \PIPE\ */
1094         if (rpc_api_pipe_req(cli, fnum, SAMR_ADD_ALIASMEM, &data, &rdata))
1095         {
1096                 SAMR_R_ADD_ALIASMEM r_o;
1097                 BOOL p;
1098
1099                 samr_io_r_add_aliasmem("", &r_o, &rdata, 0);
1100                 p = rdata.offset != 0;
1101
1102                 if (p && r_o.status != 0)
1103                 {
1104                         /* report error code */
1105                         DEBUG(4,("SAMR_R_ADD_ALIASMEM: %s\n", get_nt_error_msg(r_o.status)));
1106                         p = False;
1107                 }
1108
1109                 if (p)
1110                 {
1111                         valid_pol = True;
1112                 }
1113         }
1114
1115         prs_mem_free(&data   );
1116         prs_mem_free(&rdata  );
1117
1118         return valid_pol;
1119 }
1120
1121 /****************************************************************************
1122 do a SAMR Delete Domain Alias
1123 ****************************************************************************/
1124 BOOL samr_delete_dom_alias(struct cli_state *cli, uint16 fnum,
1125                                 POLICY_HND *alias_pol)
1126 {
1127         prs_struct data;
1128         prs_struct rdata;
1129
1130         SAMR_Q_DELETE_DOM_ALIAS q_o;
1131         BOOL valid_pol = False;
1132
1133         if (alias_pol == NULL) return False;
1134
1135         /* delete and send a MSRPC command with api SAMR_DELETE_DOM_ALIAS */
1136
1137         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1138         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1139
1140         DEBUG(4,("SAMR Delete Domain Alias.\n"));
1141
1142         /* store the parameters */
1143         make_samr_q_delete_dom_alias(&q_o, alias_pol);
1144
1145         /* turn parameters into data stream */
1146         samr_io_q_delete_dom_alias("", &q_o,  &data, 0);
1147
1148         /* send the data on \PIPE\ */
1149         if (rpc_api_pipe_req(cli, fnum, SAMR_DELETE_DOM_ALIAS, &data, &rdata))
1150         {
1151                 SAMR_R_DELETE_DOM_ALIAS r_o;
1152                 BOOL p;
1153
1154                 samr_io_r_delete_dom_alias("", &r_o, &rdata, 0);
1155                 p = rdata.offset != 0;
1156
1157                 if (p && r_o.status != 0)
1158                 {
1159                         /* report error code */
1160                         DEBUG(4,("SAMR_R_DELETE_DOM_ALIAS: %s\n", get_nt_error_msg(r_o.status)));
1161                         p = False;
1162                 }
1163
1164                 if (p)
1165                 {
1166                         valid_pol = True;
1167                 }
1168         }
1169
1170         prs_mem_free(&data   );
1171         prs_mem_free(&rdata  );
1172
1173         return valid_pol;
1174 }
1175
1176 /****************************************************************************
1177 do a SAMR Create Domain User
1178 ****************************************************************************/
1179 BOOL samr_create_dom_user(struct cli_state *cli, uint16 fnum,
1180                                 POLICY_HND *domain_pol, const char *acct_name,
1181                                 uint32 unk_0, uint32 unk_1,
1182                                 POLICY_HND *user_pol, uint32 *rid)
1183 {
1184         prs_struct data;
1185         prs_struct rdata;
1186
1187         SAMR_Q_CREATE_USER q_o;
1188         BOOL valid_pol = False;
1189
1190         if (user_pol == NULL || domain_pol == NULL || acct_name == NULL || rid == NULL) return False;
1191
1192         /* create and send a MSRPC command with api SAMR_CREATE_USER */
1193
1194         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1195         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1196
1197         DEBUG(4,("SAMR Create Domain User. Name:%s\n", acct_name));
1198
1199         /* store the parameters */
1200         make_samr_q_create_user(&q_o, domain_pol, acct_name, unk_0, unk_1);
1201
1202         /* turn parameters into data stream */
1203         samr_io_q_create_user("", &q_o,  &data, 0);
1204
1205         /* send the data on \PIPE\ */
1206         if (rpc_api_pipe_req(cli, fnum, SAMR_CREATE_USER, &data, &rdata))
1207         {
1208                 SAMR_R_CREATE_USER r_o;
1209                 BOOL p;
1210
1211                 samr_io_r_create_user("", &r_o, &rdata, 0);
1212                 p = rdata.offset != 0;
1213
1214                 if (p && r_o.status != 0)
1215                 {
1216                         /* report error code */
1217                         DEBUG(4,("SAMR_R_CREATE_USER: %s\n", get_nt_error_msg(r_o.status)));
1218                         p = False;
1219                 }
1220
1221                 if (p)
1222                 {
1223                         memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
1224                         *rid = r_o.user_rid;
1225                         valid_pol = True;
1226                 }
1227         }
1228
1229         prs_mem_free(&data   );
1230         prs_mem_free(&rdata  );
1231
1232         return valid_pol;
1233 }
1234
1235 /****************************************************************************
1236 do a SAMR Create Domain Alias
1237 ****************************************************************************/
1238 BOOL samr_create_dom_alias(struct cli_state *cli, uint16 fnum,
1239                                 POLICY_HND *domain_pol, const char *acct_name,
1240                                 POLICY_HND *alias_pol, uint32 *rid)
1241 {
1242         prs_struct data;
1243         prs_struct rdata;
1244
1245         SAMR_Q_CREATE_DOM_ALIAS q_o;
1246         BOOL valid_pol = False;
1247
1248         if (alias_pol == NULL || domain_pol == NULL || acct_name == NULL || rid == NULL) return False;
1249
1250         /* create and send a MSRPC command with api SAMR_CREATE_DOM_ALIAS */
1251
1252         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1253         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1254
1255         DEBUG(4,("SAMR Create Domain Alias. Name:%s\n", acct_name));
1256
1257         /* store the parameters */
1258         make_samr_q_create_dom_alias(&q_o, domain_pol, acct_name);
1259
1260         /* turn parameters into data stream */
1261         samr_io_q_create_dom_alias("", &q_o,  &data, 0);
1262
1263         /* send the data on \PIPE\ */
1264         if (rpc_api_pipe_req(cli, fnum, SAMR_CREATE_DOM_ALIAS, &data, &rdata))
1265         {
1266                 SAMR_R_CREATE_DOM_ALIAS r_o;
1267                 BOOL p;
1268
1269                 samr_io_r_create_dom_alias("", &r_o, &rdata, 0);
1270                 p = rdata.offset != 0;
1271
1272                 if (p && r_o.status != 0)
1273                 {
1274                         /* report error code */
1275                         DEBUG(4,("SAMR_R_CREATE_DOM_ALIAS: %s\n", get_nt_error_msg(r_o.status)));
1276                         p = False;
1277                 }
1278
1279                 if (p)
1280                 {
1281                         memcpy(alias_pol, &r_o.alias_pol, sizeof(r_o.alias_pol));
1282                         *rid = r_o.rid;
1283                         valid_pol = True;
1284                 }
1285         }
1286
1287         prs_mem_free(&data   );
1288         prs_mem_free(&rdata  );
1289
1290         return valid_pol;
1291 }
1292
1293 #if 0
1294 /****************************************************************************
1295 do a SAMR Get Alias Info
1296 ****************************************************************************/
1297 BOOL samr_get_aliasinfo(struct cli_state *cli, uint16 fnum,
1298                                 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
1299 {
1300         prs_struct data;
1301         prs_struct rdata;
1302
1303         SAMR_Q_GET_ALIASINFO q_o;
1304         BOOL valid_pol = False;
1305
1306         if (alias_pol == NULL || ctr == NULL) return False;
1307
1308         /* create and send a MSRPC command with api SAMR_GET_ALIASINFO */
1309
1310         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1311         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1312
1313         DEBUG(4,("SAMR Get Alias Info\n"));
1314
1315         /* store the parameters */
1316         make_samr_q_get_aliasinfo(&q_o, alias_pol, ctr);
1317
1318         /* turn parameters into data stream */
1319         samr_io_q_get_aliasinfo("", &q_o,  &data, 0);
1320
1321         /* send the data on \PIPE\ */
1322         if (rpc_api_pipe_req(cli, fnum, SAMR_GET_ALIASINFO, &data, &rdata))
1323         {
1324                 SAMR_R_GET_ALIASINFO r_o;
1325                 BOOL p;
1326
1327                 samr_io_r_get_aliasinfo("", &r_o, &rdata, 0);
1328                 p = rdata.offset != 0;
1329
1330                 if (p && r_o.status != 0)
1331                 {
1332                         /* report error code */
1333                         DEBUG(4,("SAMR_R_GET_ALIASINFO: %s\n", get_nt_error_msg(r_o.status)));
1334                         p = False;
1335                 }
1336
1337                 if (p)
1338                 {
1339                         valid_pol = True;
1340                 }
1341         }
1342
1343         prs_mem_free(&data   );
1344         prs_mem_free(&rdata  );
1345
1346         return valid_pol;
1347 }
1348 #endif
1349
1350 /****************************************************************************
1351 do a SAMR Set Alias Info
1352 ****************************************************************************/
1353 BOOL samr_set_aliasinfo(struct cli_state *cli, uint16 fnum,
1354                                 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
1355 {
1356         prs_struct data;
1357         prs_struct rdata;
1358
1359         SAMR_Q_SET_ALIASINFO q_o;
1360         BOOL valid_pol = False;
1361
1362         if (alias_pol == NULL || ctr == NULL) return False;
1363
1364         /* create and send a MSRPC command with api SAMR_SET_ALIASINFO */
1365
1366         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1367         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1368
1369         DEBUG(4,("SAMR Set Alias Info\n"));
1370
1371         /* store the parameters */
1372         make_samr_q_set_aliasinfo(&q_o, alias_pol, ctr);
1373
1374         /* turn parameters into data stream */
1375         samr_io_q_set_aliasinfo("", &q_o,  &data, 0);
1376
1377         /* send the data on \PIPE\ */
1378         if (rpc_api_pipe_req(cli, fnum, SAMR_SET_ALIASINFO, &data, &rdata))
1379         {
1380                 SAMR_R_SET_ALIASINFO r_o;
1381                 BOOL p;
1382
1383                 samr_io_r_set_aliasinfo("", &r_o, &rdata, 0);
1384                 p = rdata.offset != 0;
1385
1386                 if (p && r_o.status != 0)
1387                 {
1388                         /* report error code */
1389                         DEBUG(4,("SAMR_R_SET_ALIASINFO: %s\n", get_nt_error_msg(r_o.status)));
1390                         p = False;
1391                 }
1392
1393                 if (p)
1394                 {
1395                         valid_pol = True;
1396                 }
1397         }
1398
1399         prs_mem_free(&data   );
1400         prs_mem_free(&rdata  );
1401
1402         return valid_pol;
1403 }
1404
1405 /****************************************************************************
1406 do a SAMR Open Group
1407 ****************************************************************************/
1408 BOOL samr_open_group(struct cli_state *cli, uint16 fnum,
1409                                 POLICY_HND *domain_pol,
1410                                 uint32 flags, uint32 rid,
1411                                 POLICY_HND *group_pol)
1412 {
1413         prs_struct data;
1414         prs_struct rdata;
1415
1416         SAMR_Q_OPEN_GROUP q_o;
1417         BOOL valid_pol = False;
1418
1419         DEBUG(4,("SAMR Open Group. RID:%x\n", rid));
1420
1421         if (group_pol == NULL || domain_pol == NULL) return False;
1422
1423         /* create and send a MSRPC command with api SAMR_OPEN_GROUP */
1424
1425         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1426         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1427
1428         /* store the parameters */
1429         make_samr_q_open_group(&q_o, domain_pol, flags, rid);
1430
1431         /* turn parameters into data stream */
1432         samr_io_q_open_group("", &q_o,  &data, 0);
1433
1434         /* send the data on \PIPE\ */
1435         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_GROUP, &data, &rdata))
1436         {
1437                 SAMR_R_OPEN_GROUP r_o;
1438                 BOOL p;
1439
1440                 samr_io_r_open_group("", &r_o, &rdata, 0);
1441                 p = rdata.offset != 0;
1442
1443                 if (p && r_o.status != 0)
1444                 {
1445                         /* report error code */
1446                         DEBUG(4,("SAMR_R_OPEN_GROUP: %s\n", get_nt_error_msg(r_o.status)));
1447                         p = False;
1448                 }
1449
1450                 if (p)
1451                 {
1452                         memcpy(group_pol, &r_o.pol, sizeof(r_o.pol));
1453                         valid_pol = True;
1454                 }
1455         }
1456
1457         prs_mem_free(&data   );
1458         prs_mem_free(&rdata  );
1459
1460         return valid_pol;
1461 }
1462
1463 /****************************************************************************
1464 do a SAMR Delete Group Member
1465 ****************************************************************************/
1466 BOOL samr_del_groupmem(struct cli_state *cli, uint16 fnum,
1467                                 POLICY_HND *group_pol, uint32 rid)
1468 {
1469         prs_struct data;
1470         prs_struct rdata;
1471
1472         SAMR_Q_DEL_GROUPMEM q_o;
1473         BOOL valid_pol = False;
1474
1475         if (group_pol == NULL) return False;
1476
1477         /* create and send a MSRPC command with api SAMR_DEL_GROUPMEM */
1478
1479         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1480         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1481
1482         DEBUG(4,("SAMR Delete Group Member.\n"));
1483
1484         /* store the parameters */
1485         make_samr_q_del_groupmem(&q_o, group_pol, rid);
1486
1487         /* turn parameters into data stream */
1488         samr_io_q_del_groupmem("", &q_o,  &data, 0);
1489
1490         /* send the data on \PIPE\ */
1491         if (rpc_api_pipe_req(cli, fnum, SAMR_DEL_GROUPMEM, &data, &rdata))
1492         {
1493                 SAMR_R_DEL_GROUPMEM r_o;
1494                 BOOL p;
1495
1496                 samr_io_r_del_groupmem("", &r_o, &rdata, 0);
1497                 p = rdata.offset != 0;
1498
1499                 if (p && r_o.status != 0)
1500                 {
1501                         /* report error code */
1502                         DEBUG(4,("SAMR_R_DEL_GROUPMEM: %s\n", get_nt_error_msg(r_o.status)));
1503                         p = False;
1504                 }
1505
1506                 if (p)
1507                 {
1508                         valid_pol = True;
1509                 }
1510         }
1511
1512         prs_mem_free(&data   );
1513         prs_mem_free(&rdata  );
1514
1515         return valid_pol;
1516 }
1517
1518 /****************************************************************************
1519 do a SAMR Add Group Member
1520 ****************************************************************************/
1521 BOOL samr_add_groupmem(struct cli_state *cli, uint16 fnum,
1522                                 POLICY_HND *group_pol, uint32 rid)
1523 {
1524         prs_struct data;
1525         prs_struct rdata;
1526
1527         SAMR_Q_ADD_GROUPMEM q_o;
1528         BOOL valid_pol = False;
1529
1530         if (group_pol == NULL) return False;
1531
1532         /* create and send a MSRPC command with api SAMR_ADD_GROUPMEM */
1533
1534         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1535         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1536
1537         DEBUG(4,("SAMR Add Group Member.\n"));
1538
1539         /* store the parameters */
1540         make_samr_q_add_groupmem(&q_o, group_pol, rid);
1541
1542         /* turn parameters into data stream */
1543         samr_io_q_add_groupmem("", &q_o,  &data, 0);
1544
1545         /* send the data on \PIPE\ */
1546         if (rpc_api_pipe_req(cli, fnum, SAMR_ADD_GROUPMEM, &data, &rdata))
1547         {
1548                 SAMR_R_ADD_GROUPMEM r_o;
1549                 BOOL p;
1550
1551                 samr_io_r_add_groupmem("", &r_o, &rdata, 0);
1552                 p = rdata.offset != 0;
1553
1554                 if (p && r_o.status != 0)
1555                 {
1556                         /* report error code */
1557                         DEBUG(4,("SAMR_R_ADD_GROUPMEM: %s\n", get_nt_error_msg(r_o.status)));
1558                         p = False;
1559                 }
1560
1561                 if (p)
1562                 {
1563                         valid_pol = True;
1564                 }
1565         }
1566
1567         prs_mem_free(&data   );
1568         prs_mem_free(&rdata  );
1569
1570         return valid_pol;
1571 }
1572
1573 /****************************************************************************
1574 do a SAMR Delete Domain Group
1575 ****************************************************************************/
1576 BOOL samr_delete_dom_group(struct cli_state *cli, uint16 fnum, POLICY_HND *group_pol)
1577 {
1578         prs_struct data;
1579         prs_struct rdata;
1580
1581         SAMR_Q_DELETE_DOM_GROUP q_o;
1582         BOOL valid_pol = False;
1583
1584         if (group_pol == NULL) return False;
1585
1586         /* delete and send a MSRPC command with api SAMR_DELETE_DOM_GROUP */
1587
1588         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1589         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1590
1591         DEBUG(4,("SAMR Delete Domain Group.\n"));
1592
1593         /* store the parameters */
1594         make_samr_q_delete_dom_group(&q_o, group_pol);
1595
1596         /* turn parameters into data stream */
1597         samr_io_q_delete_dom_group("", &q_o,  &data, 0);
1598
1599         /* send the data on \PIPE\ */
1600         if (rpc_api_pipe_req(cli, fnum, SAMR_DELETE_DOM_GROUP, &data, &rdata))
1601         {
1602                 SAMR_R_DELETE_DOM_GROUP r_o;
1603                 BOOL p;
1604
1605                 samr_io_r_delete_dom_group("", &r_o, &rdata, 0);
1606                 p = rdata.offset != 0;
1607
1608                 if (p && r_o.status != 0)
1609                 {
1610                         /* report error code */
1611                         DEBUG(4,("SAMR_R_DELETE_DOM_GROUP: %s\n", get_nt_error_msg(r_o.status)));
1612                         p = False;
1613                 }
1614
1615                 if (p)
1616                 {
1617                         valid_pol = True;
1618                 }
1619         }
1620
1621         prs_mem_free(&data   );
1622         prs_mem_free(&rdata  );
1623
1624         return valid_pol;
1625 }
1626
1627 /****************************************************************************
1628 do a SAMR Create Domain Group
1629 ****************************************************************************/
1630 BOOL samr_create_dom_group(struct cli_state *cli, uint16 fnum,
1631                                 POLICY_HND *domain_pol, const char *acct_name,
1632                                 POLICY_HND *group_pol, uint32 *rid)
1633 {
1634         prs_struct data;
1635         prs_struct rdata;
1636
1637         SAMR_Q_CREATE_DOM_GROUP q_o;
1638         BOOL valid_pol = False;
1639
1640         if (group_pol == NULL || domain_pol == NULL || acct_name == NULL || rid == NULL) return False;
1641
1642         /* create and send a MSRPC command with api SAMR_CREATE_DOM_GROUP */
1643
1644         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1645         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1646
1647         DEBUG(4,("SAMR Create Domain Group. Name:%s\n", acct_name));
1648
1649         /* store the parameters */
1650         make_samr_q_create_dom_group(&q_o, domain_pol, acct_name);
1651
1652         /* turn parameters into data stream */
1653         samr_io_q_create_dom_group("", &q_o,  &data, 0);
1654
1655         /* send the data on \PIPE\ */
1656         if (rpc_api_pipe_req(cli, fnum, SAMR_CREATE_DOM_GROUP, &data, &rdata))
1657         {
1658                 SAMR_R_CREATE_DOM_GROUP r_o;
1659                 BOOL p;
1660
1661                 samr_io_r_create_dom_group("", &r_o, &rdata, 0);
1662                 p = rdata.offset != 0;
1663
1664                 if (p && r_o.status != 0)
1665                 {
1666                         /* report error code */
1667                         DEBUG(4,("SAMR_R_CREATE_DOM_GROUP: %s\n", get_nt_error_msg(r_o.status)));
1668                         p = False;
1669                 }
1670
1671                 if (p)
1672                 {
1673                         memcpy(group_pol, &r_o.pol, sizeof(r_o.pol));
1674                         *rid = r_o.rid;
1675                         valid_pol = True;
1676                 }
1677         }
1678
1679         prs_mem_free(&data   );
1680         prs_mem_free(&rdata  );
1681
1682         return valid_pol;
1683 }
1684
1685 /****************************************************************************
1686 do a SAMR Set Group Info
1687 ****************************************************************************/
1688 BOOL samr_set_groupinfo(struct cli_state *cli, uint16 fnum,
1689                                 POLICY_HND *group_pol, GROUP_INFO_CTR *ctr)
1690 {
1691         prs_struct data;
1692         prs_struct rdata;
1693
1694         SAMR_Q_SET_GROUPINFO q_o;
1695         BOOL valid_pol = False;
1696
1697         if (group_pol == NULL || ctr == NULL) return False;
1698
1699         /* create and send a MSRPC command with api SAMR_SET_GROUPINFO */
1700
1701         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1702         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1703
1704         DEBUG(4,("SAMR Set Group Info\n"));
1705
1706         /* store the parameters */
1707         make_samr_q_set_groupinfo(&q_o, group_pol, ctr);
1708
1709         /* turn parameters into data stream */
1710         samr_io_q_set_groupinfo("", &q_o,  &data, 0);
1711
1712         /* send the data on \PIPE\ */
1713         if (rpc_api_pipe_req(cli, fnum, SAMR_SET_GROUPINFO, &data, &rdata))
1714         {
1715                 SAMR_R_SET_GROUPINFO r_o;
1716                 BOOL p;
1717
1718                 samr_io_r_set_groupinfo("", &r_o, &rdata, 0);
1719                 p = rdata.offset != 0;
1720
1721                 if (p && r_o.status != 0)
1722                 {
1723                         /* report error code */
1724                         DEBUG(4,("SAMR_R_SET_GROUPINFO: %s\n", get_nt_error_msg(r_o.status)));
1725                         p = False;
1726                 }
1727
1728                 if (p)
1729                 {
1730                         valid_pol = True;
1731                 }
1732         }
1733
1734         prs_mem_free(&data   );
1735         prs_mem_free(&rdata  );
1736
1737         return valid_pol;
1738 }
1739
1740 /****************************************************************************
1741 do a SAMR Open Domain
1742 ****************************************************************************/
1743 BOOL samr_open_domain(struct cli_state *cli, uint16 fnum,
1744                                 POLICY_HND *connect_pol, uint32 ace_perms,
1745                                 DOM_SID *sid,
1746                                 POLICY_HND *domain_pol)
1747 {
1748         pstring sid_str;
1749         prs_struct data;
1750         prs_struct rdata;
1751
1752         SAMR_Q_OPEN_DOMAIN q_o;
1753         BOOL valid_pol = False;
1754
1755         if (DEBUGLEVEL >= 4)
1756         {
1757                 sid_to_string(sid_str, sid);
1758                 DEBUG(4,("SAMR Open Domain.  SID:%s Permissions:%x\n",
1759                                         sid_str, ace_perms));
1760         }
1761
1762         if (connect_pol == NULL || sid == NULL || domain_pol == NULL) return False;
1763
1764         /* create and send a MSRPC command with api SAMR_OPEN_DOMAIN */
1765
1766         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1767         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1768
1769         /* store the parameters */
1770         make_samr_q_open_domain(&q_o, connect_pol, ace_perms, sid);
1771
1772         /* turn parameters into data stream */
1773         samr_io_q_open_domain("", &q_o,  &data, 0);
1774
1775         /* send the data on \PIPE\ */
1776         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_DOMAIN, &data, &rdata))
1777         {
1778                 SAMR_R_OPEN_DOMAIN r_o;
1779                 BOOL p;
1780
1781                 samr_io_r_open_domain("", &r_o, &rdata, 0);
1782                 p = rdata.offset != 0;
1783
1784                 if (p && r_o.status != 0)
1785                 {
1786                         /* report error code */
1787                         DEBUG(4,("SAMR_R_OPEN_DOMAIN: %s\n", get_nt_error_msg(r_o.status)));
1788                         p = False;
1789                 }
1790
1791                 if (p)
1792                 {
1793                         memcpy(domain_pol, &r_o.domain_pol, sizeof(r_o.domain_pol));
1794                         valid_pol = True;
1795                 }
1796         }
1797
1798         prs_mem_free(&data   );
1799         prs_mem_free(&rdata  );
1800
1801         return valid_pol;
1802 }
1803
1804 /****************************************************************************
1805 do a SAMR Query Lookup Domain
1806 ****************************************************************************/
1807 BOOL samr_query_lookup_domain(struct cli_state *cli, uint16 fnum,
1808                               POLICY_HND *pol, const char *dom_name,
1809                               DOM_SID *dom_sid)
1810 {
1811         prs_struct data;
1812         prs_struct rdata;
1813
1814         SAMR_Q_LOOKUP_DOMAIN q_o;
1815         BOOL valid_query = False;
1816
1817         if (pol == NULL || dom_name == NULL || dom_sid == NULL) return False;
1818
1819         /* create and send a MSRPC command with api SAMR_LOOKUP_DOMAIN */
1820
1821         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1822         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1823
1824         DEBUG(4,("SAMR Query Lookup Domain.\n"));
1825
1826         /* store the parameters */
1827         make_samr_q_lookup_domain(&q_o, pol, dom_name);
1828
1829         /* turn parameters into data stream */
1830         samr_io_q_lookup_domain("", &q_o, &data, 0);
1831
1832         /* send the data on \PIPE\ */
1833         if (rpc_api_pipe_req(cli, fnum, SAMR_LOOKUP_DOMAIN, &data, &rdata))
1834         {
1835                 SAMR_R_LOOKUP_DOMAIN r_o;
1836                 BOOL p;
1837
1838                 samr_io_r_lookup_domain("", &r_o, &rdata, 0);
1839                 p = rdata.offset != 0;
1840
1841                 if (p && r_o.status != 0)
1842                 {
1843                         /* report error code */
1844                         DEBUG(4,("SAMR_R_LOOKUP_DOMAIN: %s\n", get_nt_error_msg(r_o.status)));
1845                         p = False;
1846                 }
1847
1848                 if (p && r_o.ptr_sid != 0)
1849                 {
1850                         sid_copy(dom_sid, &r_o.dom_sid.sid);
1851                         valid_query = True;
1852                 }
1853         }
1854
1855         prs_mem_free(&data   );
1856         prs_mem_free(&rdata  );
1857
1858         return valid_query;
1859 }
1860
1861 /****************************************************************************
1862 do a SAMR Query Lookup Names
1863 ****************************************************************************/
1864 BOOL samr_query_lookup_names(struct cli_state *cli, uint16 fnum,
1865                                 POLICY_HND *pol, uint32 flags,
1866                                 uint32 num_names, char **names,
1867                                 uint32 *num_rids,
1868                                 uint32 rid[MAX_LOOKUP_SIDS],
1869                                 uint32 type[MAX_LOOKUP_SIDS])
1870 {
1871         prs_struct data;
1872         prs_struct rdata;
1873
1874         SAMR_Q_LOOKUP_NAMES q_o;
1875         BOOL valid_query = False;
1876
1877         if (pol == NULL || flags == 0 || num_names == 0 || names == NULL ||
1878             num_rids == NULL || rid == NULL || type == NULL ) return False;
1879
1880         /* create and send a MSRPC command with api SAMR_LOOKUP_NAMES */
1881
1882         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1883         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1884
1885         DEBUG(4,("SAMR Query Lookup NAMES.\n"));
1886
1887         /* store the parameters */
1888         make_samr_q_lookup_names(&q_o, pol, flags, num_names, names);
1889
1890         /* turn parameters into data stream */
1891         samr_io_q_lookup_names("", &q_o, &data, 0);
1892
1893         /* send the data on \PIPE\ */
1894         if (rpc_api_pipe_req(cli, fnum, SAMR_LOOKUP_NAMES, &data, &rdata))
1895         {
1896                 SAMR_R_LOOKUP_NAMES r_o;
1897                 BOOL p;
1898
1899                 samr_io_r_lookup_names("", &r_o, &rdata, 0);
1900                 p = rdata.offset != 0;
1901
1902                 if (p && r_o.status != 0)
1903                 {
1904                         /* report error code */
1905                         DEBUG(4,("SAMR_R_LOOKUP_NAMES: %s\n", get_nt_error_msg(r_o.status)));
1906                         p = r_o.status == 0x107;
1907                 }
1908
1909                 if (p)
1910                 {
1911                         if (r_o.ptr_rids != 0 && r_o.ptr_types != 0 &&
1912                             r_o.num_types1 == r_o.num_rids1)
1913                         {
1914                                 uint32 i;
1915
1916                                 valid_query = True;
1917                                 *num_rids = r_o.num_rids1;
1918
1919                                 for (i = 0; i < r_o.num_rids1; i++)
1920                                 {
1921                                         rid[i] = r_o.rid[i];
1922                                 }
1923                                 for (i = 0; i < r_o.num_types1; i++)
1924                                 {
1925                                         type[i] = r_o.type[i];
1926                                 }
1927                         }
1928                         else if (r_o.ptr_rids == 0 && r_o.ptr_types == 0)
1929                         {
1930                                 valid_query = True;
1931                                 *num_rids = 0;
1932                         }
1933                         else
1934                         {
1935                                 p = False;
1936                         }
1937                 }
1938         }
1939
1940         prs_mem_free(&data   );
1941         prs_mem_free(&rdata  );
1942
1943         return valid_query;
1944 }
1945
1946 /****************************************************************************
1947 do a SAMR Query Lookup RIDS
1948 ****************************************************************************/
1949 BOOL samr_query_lookup_rids(struct cli_state *cli, uint16 fnum,
1950                                 POLICY_HND *pol, uint32 flags,
1951                                 uint32 num_rids, uint32 *rids,
1952                                 uint32 *num_names,
1953                                 char   ***names,
1954                                 uint32 **type)
1955 {
1956         prs_struct data;
1957         prs_struct rdata;
1958
1959         SAMR_Q_LOOKUP_RIDS q_o;
1960         BOOL valid_query = False;
1961
1962         if (pol == NULL || flags == 0 || num_rids == 0 || rids == NULL ||
1963             num_names == NULL || names == NULL || type == NULL ) return False;
1964
1965         /* create and send a MSRPC command with api SAMR_LOOKUP_RIDS */
1966
1967         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1968         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1969
1970         DEBUG(4,("SAMR Query Lookup RIDs.\n"));
1971
1972         /* store the parameters */
1973         make_samr_q_lookup_rids(&q_o, pol, flags, num_rids, rids);
1974
1975         /* turn parameters into data stream */
1976         samr_io_q_lookup_rids("", &q_o,  &data, 0);
1977
1978         /* send the data on \PIPE\ */
1979         if (rpc_api_pipe_req(cli, fnum, SAMR_LOOKUP_RIDS, &data, &rdata))
1980         {
1981                 SAMR_R_LOOKUP_RIDS r_o;
1982                 BOOL p;
1983                 ZERO_STRUCT(r_o);
1984
1985                 samr_io_r_lookup_rids("", &r_o, &rdata, 0);
1986                 p = rdata.offset != 0;
1987
1988                 if (p && r_o.status != 0)
1989                 {
1990                         /* report error code */
1991                         DEBUG(4,("SAMR_R_LOOKUP_RIDS: %s\n", get_nt_error_msg(r_o.status)));
1992                         p = False;
1993                 }
1994
1995                 if (p)
1996                 {
1997                         if (r_o.ptr_names != 0 && r_o.ptr_types != 0 &&
1998                             r_o.num_types1 == r_o.num_names1)
1999                         {
2000                                 uint32 i;
2001                                 valid_query = True;
2002
2003                                 (*num_names) = 0;
2004                                 (*names) = NULL;
2005
2006                                 for (i = 0; i < r_o.num_names1; i++)
2007                                 {
2008                                         fstring tmp;
2009                                         unistr2_to_ascii(tmp, &r_o.uni_name[i], sizeof(tmp)-1);
2010                                         add_chars_to_array(num_names, names, tmp);
2011                                 }
2012
2013                                 if ((*num_names) != 0)
2014                                 {
2015                                         (*type) = (uint32*)malloc((*num_names) * sizeof(**type));
2016                                 }
2017
2018                                 for (i = 0; (*type) != NULL && i < r_o.num_types1; i++)
2019                                 {
2020                                         (*type)[i] = r_o.type[i];
2021                                 }
2022                         }
2023                         else if (r_o.ptr_names == 0 && r_o.ptr_types == 0)
2024                         {
2025                                 valid_query = True;
2026                                 *num_names = 0;
2027                                 *names = NULL;
2028                                 *type = NULL;
2029                         }
2030                         else
2031                         {
2032                                 p = False;
2033                         }
2034                 }
2035
2036                 samr_free_r_lookup_rids(&r_o);
2037         }
2038
2039         prs_mem_free(&data   );
2040         prs_mem_free(&rdata  );
2041
2042         return valid_query;
2043 }
2044
2045 /****************************************************************************
2046 do a SAMR Query Alias Members
2047 ****************************************************************************/
2048 BOOL samr_query_aliasmem(struct cli_state *cli, uint16 fnum,
2049                                 POLICY_HND *alias_pol,
2050                                 uint32 *num_mem, DOM_SID2 *sid)
2051 {
2052         prs_struct data;
2053         prs_struct rdata;
2054
2055         SAMR_Q_QUERY_ALIASMEM q_o;
2056         BOOL valid_query = False;
2057
2058         DEBUG(4,("SAMR Query Alias Members.\n"));
2059
2060         if (alias_pol == NULL || sid == NULL || num_mem == NULL) return False;
2061
2062         /* create and send a MSRPC command with api SAMR_QUERY_ALIASMEM */
2063
2064         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2065         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2066
2067         /* store the parameters */
2068         make_samr_q_query_aliasmem(&q_o, alias_pol);
2069
2070         /* turn parameters into data stream */
2071         samr_io_q_query_aliasmem("", &q_o,  &data, 0);
2072
2073         /* send the data on \PIPE\ */
2074         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_ALIASMEM, &data, &rdata))
2075         {
2076                 SAMR_R_QUERY_ALIASMEM r_o;
2077                 BOOL p;
2078
2079                 /* get user info */
2080                 r_o.sid = sid;
2081
2082                 samr_io_r_query_aliasmem("", &r_o, &rdata, 0);
2083                 p = rdata.offset != 0;
2084
2085                 if (p && r_o.status != 0)
2086                 {
2087                         /* report error code */
2088                         DEBUG(4,("SAMR_R_QUERY_ALIASMEM: %s\n", get_nt_error_msg(r_o.status)));
2089                         p = False;
2090                 }
2091
2092                 if (p && r_o.ptr != 0)
2093                 {
2094                         valid_query = True;
2095                         *num_mem = r_o.num_sids;
2096                 }
2097
2098         }
2099
2100         prs_mem_free(&data   );
2101         prs_mem_free(&rdata  );
2102
2103         return valid_query;
2104 }
2105
2106 /****************************************************************************
2107 do a SAMR Query User Aliases
2108 ****************************************************************************/
2109 BOOL samr_query_useraliases(struct cli_state *cli, uint16 fnum,
2110                                 POLICY_HND *pol, uint32 *ptr_sid, DOM_SID2 *sid,
2111                                 uint32 *num_aliases, uint32 **rid)
2112 {
2113         prs_struct data;
2114         prs_struct rdata;
2115
2116         SAMR_Q_QUERY_USERALIASES q_o;
2117         BOOL valid_query = False;
2118         ZERO_STRUCT(q_o);
2119
2120         DEBUG(4,("SAMR Query User Aliases.\n"));
2121
2122         if (pol == NULL || sid == NULL || rid == NULL || num_aliases == 0) return False;
2123
2124         /* create and send a MSRPC command with api SAMR_QUERY_USERALIASES */
2125
2126         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2127         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2128
2129         /* store the parameters */
2130         make_samr_q_query_useraliases(&q_o, pol, ptr_sid, sid);
2131
2132         /* turn parameters into data stream */
2133         samr_io_q_query_useraliases("", &q_o,  &data, 0);
2134
2135         /* send the data on \PIPE\ */
2136         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_USERALIASES, &data, &rdata))
2137         {
2138                 SAMR_R_QUERY_USERALIASES r_o;
2139                 BOOL p;
2140
2141                 r_o.rid = NULL;
2142
2143                 samr_io_r_query_useraliases("", &r_o, &rdata, 0);
2144                 *rid = r_o.rid;
2145                 p = rdata.offset != 0;
2146
2147                 if (p && r_o.status != 0)
2148                 {
2149                         /* report error code */
2150                         DEBUG(4,("SAMR_R_QUERY_USERALIASES: %s\n", get_nt_error_msg(r_o.status)));
2151                         p = False;
2152                 }
2153
2154                 if (p && r_o.ptr != 0)
2155                 {
2156                         valid_query = True;
2157                         *num_aliases = r_o.num_entries;
2158                 }
2159
2160         }
2161
2162         prs_mem_free(&data   );
2163         prs_mem_free(&rdata  );
2164
2165         return valid_query;
2166 }
2167
2168 /****************************************************************************
2169 do a SAMR Query Group Members
2170 ****************************************************************************/
2171 BOOL samr_query_groupmem(struct cli_state *cli, uint16 fnum,
2172                                 POLICY_HND *group_pol,
2173                                 uint32 *num_mem, uint32 **rid, uint32 **attr)
2174 {
2175         prs_struct data;
2176         prs_struct rdata;
2177
2178         SAMR_Q_QUERY_GROUPMEM q_o;
2179         BOOL valid_query = False;
2180
2181         DEBUG(4,("SAMR Query Group Members.\n"));
2182
2183         if (group_pol == NULL || rid == NULL || attr == NULL || num_mem == NULL) return False;
2184
2185         /* create and send a MSRPC command with api SAMR_QUERY_GROUPMEM */
2186
2187         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2188         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2189
2190         /* store the parameters */
2191         make_samr_q_query_groupmem(&q_o, group_pol);
2192
2193         /* turn parameters into data stream */
2194         samr_io_q_query_groupmem("", &q_o,  &data, 0);
2195
2196         /* send the data on \PIPE\ */
2197         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_GROUPMEM, &data, &rdata))
2198         {
2199                 SAMR_R_QUERY_GROUPMEM r_o;
2200                 BOOL p;
2201
2202                 r_o.rid  = NULL;
2203                 r_o.attr = NULL;
2204
2205                 samr_io_r_query_groupmem("", &r_o, &rdata, 0);
2206                 *rid  = r_o.rid ;
2207                 *attr = r_o.attr;
2208                 p = rdata.offset != 0;
2209
2210                 if (p && r_o.status != 0)
2211                 {
2212                         /* report error code */
2213                         DEBUG(4,("SAMR_R_QUERY_GROUPMEM: %s\n", get_nt_error_msg(r_o.status)));
2214                         p = False;
2215                 }
2216
2217                 if (p && r_o.ptr != 0 &&
2218                     r_o.ptr_rids != 0 && r_o.ptr_attrs != 0 &&
2219                     r_o.num_rids == r_o.num_attrs)
2220                 {
2221                         valid_query = True;
2222                         *num_mem = r_o.num_rids;
2223                 }
2224
2225         }
2226
2227         prs_mem_free(&data   );
2228         prs_mem_free(&rdata  );
2229
2230         return valid_query;
2231 }
2232
2233 /****************************************************************************
2234 do a SAMR Query User Groups
2235 ****************************************************************************/
2236 BOOL samr_query_usergroups(struct cli_state *cli, uint16 fnum,
2237                                 POLICY_HND *pol, uint32 *num_groups,
2238                                 DOM_GID **gid)
2239 {
2240         prs_struct data;
2241         prs_struct rdata;
2242
2243         SAMR_Q_QUERY_USERGROUPS q_o;
2244         BOOL valid_query = False;
2245
2246         DEBUG(4,("SAMR Query User Groups.\n"));
2247
2248         if (pol == NULL || gid == NULL || num_groups == 0) return False;
2249
2250         /* create and send a MSRPC command with api SAMR_QUERY_USERGROUPS */
2251
2252         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2253         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2254
2255         /* store the parameters */
2256         make_samr_q_query_usergroups(&q_o, pol);
2257
2258         /* turn parameters into data stream */
2259         samr_io_q_query_usergroups("", &q_o,  &data, 0);
2260
2261         /* send the data on \PIPE\ */
2262         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_USERGROUPS, &data, &rdata))
2263         {
2264                 SAMR_R_QUERY_USERGROUPS r_o;
2265                 BOOL p;
2266
2267                 /* get user info */
2268                 r_o.gid = NULL;
2269
2270                 samr_io_r_query_usergroups("", &r_o, &rdata, 0);
2271                 *gid = r_o.gid;
2272                 p = rdata.offset != 0;
2273
2274                 if (p && r_o.status != 0)
2275                 {
2276                         /* report error code */
2277                         DEBUG(4,("SAMR_R_QUERY_USERGROUPS: %s\n", get_nt_error_msg(r_o.status)));
2278                         p = False;
2279                 }
2280
2281                 if (p && r_o.ptr_0 != 0)
2282                 {
2283                         valid_query = True;
2284                         *num_groups = r_o.num_entries;
2285                 }
2286
2287         }
2288
2289         prs_mem_free(&data   );
2290         prs_mem_free(&rdata  );
2291
2292         return valid_query;
2293 }
2294
2295 /****************************************************************************
2296 do a SAMR Query Group Info
2297 ****************************************************************************/
2298 BOOL samr_query_groupinfo(struct cli_state *cli, uint16 fnum,
2299                                 POLICY_HND *pol,
2300                                 uint16 switch_value, GROUP_INFO_CTR* ctr)
2301 {
2302         prs_struct data;
2303         prs_struct rdata;
2304
2305         SAMR_Q_QUERY_GROUPINFO q_o;
2306         BOOL valid_query = False;
2307
2308         DEBUG(4,("SAMR Query Group Info.  level: %d\n", switch_value));
2309
2310         if (pol == NULL || ctr == NULL || switch_value == 0) return False;
2311
2312         /* create and send a MSRPC command with api SAMR_QUERY_GROUPINFO */
2313
2314         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2315         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2316
2317         /* store the parameters */
2318         make_samr_q_query_groupinfo(&q_o, pol, switch_value);
2319
2320         /* turn parameters into data stream */
2321         samr_io_q_query_groupinfo("", &q_o,  &data, 0);
2322
2323         /* send the data on \PIPE\ */
2324         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_GROUPINFO, &data, &rdata))
2325         {
2326                 SAMR_R_QUERY_GROUPINFO r_o;
2327                 BOOL p;
2328
2329                 /* get user info */
2330                 r_o.ctr = ctr;
2331
2332                 samr_io_r_query_groupinfo("", &r_o, &rdata, 0);
2333                 p = rdata.offset != 0;
2334
2335                 if (p && r_o.status != 0)
2336                 {
2337                         /* report error code */
2338                         DEBUG(4,("SAMR_R_QUERY_GROUPINFO: %s\n", get_nt_error_msg(r_o.status)));
2339                         p = False;
2340                 }
2341
2342                 if (p && r_o.ctr->switch_value1 != switch_value)
2343                 {
2344                         DEBUG(4,("SAMR_R_QUERY_GROUPINFO: received incorrect level %d\n",
2345                                   r_o.ctr->switch_value1));
2346                 }
2347
2348                 if (p && r_o.ptr != 0)
2349                 {
2350                         valid_query = True;
2351                 }
2352         }
2353
2354         prs_mem_free(&data   );
2355         prs_mem_free(&rdata  );
2356
2357         return valid_query;
2358 }
2359
2360 /****************************************************************************
2361 do a SAMR Query User Info
2362 ****************************************************************************/
2363 BOOL samr_query_userinfo(struct cli_state *cli, uint16 fnum,
2364                                 POLICY_HND *pol, uint16 switch_value, void* usr)
2365 {
2366         prs_struct data;
2367         prs_struct rdata;
2368
2369         SAMR_Q_QUERY_USERINFO q_o;
2370         BOOL valid_query = False;
2371
2372         DEBUG(4,("SAMR Query User Info.  level: %d\n", switch_value));
2373
2374         if (pol == NULL || usr == NULL || switch_value == 0) return False;
2375
2376         /* create and send a MSRPC command with api SAMR_QUERY_USERINFO */
2377
2378         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2379         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2380
2381         /* store the parameters */
2382         make_samr_q_query_userinfo(&q_o, pol, switch_value);
2383
2384         /* turn parameters into data stream */
2385         samr_io_q_query_userinfo("", &q_o,  &data, 0);
2386
2387         /* send the data on \PIPE\ */
2388         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_USERINFO, &data, &rdata))
2389         {
2390                 SAMR_R_QUERY_USERINFO r_o;
2391                 BOOL p;
2392
2393                 /* get user info */
2394                 r_o.info.id = usr;
2395
2396                 samr_io_r_query_userinfo("", &r_o, &rdata, 0);
2397                 p = rdata.offset != 0;
2398
2399                 if (p && r_o.status != 0)
2400                 {
2401                         /* report error code */
2402                         DEBUG(4,("SAMR_R_QUERY_USERINFO: %s\n", get_nt_error_msg(r_o.status)));
2403                         p = False;
2404                 }
2405
2406                 if (p && r_o.switch_value != switch_value)
2407                 {
2408                         DEBUG(4,("SAMR_R_QUERY_USERINFO: received incorrect level %d\n",
2409                                   r_o.switch_value));
2410                 }
2411
2412                 if (p && r_o.ptr != 0)
2413                 {
2414                         valid_query = True;
2415                 }
2416         }
2417
2418         prs_mem_free(&data   );
2419         prs_mem_free(&rdata  );
2420
2421         return valid_query;
2422 }
2423
2424 /****************************************************************************
2425 do a SAMR Close
2426 ****************************************************************************/
2427 BOOL samr_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd)
2428 {
2429         prs_struct data;
2430         prs_struct rdata;
2431
2432         SAMR_Q_CLOSE_HND q_c;
2433         BOOL valid_close = False;
2434
2435         DEBUG(4,("SAMR Close\n"));
2436
2437         if (hnd == NULL) return False;
2438
2439         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2440         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2441
2442         /* create and send a MSRPC command with api SAMR_CLOSE_HND */
2443
2444         /* store the parameters */
2445         make_samr_q_close_hnd(&q_c, hnd);
2446
2447         /* turn parameters into data stream */
2448         samr_io_q_close_hnd("", &q_c,  &data, 0);
2449
2450         /* send the data on \PIPE\ */
2451         if (rpc_api_pipe_req(cli, fnum, SAMR_CLOSE_HND, &data, &rdata))
2452         {
2453                 SAMR_R_CLOSE_HND r_c;
2454                 BOOL p;
2455
2456                 samr_io_r_close_hnd("", &r_c, &rdata, 0);
2457                 p = rdata.offset != 0;
2458
2459                 if (p && r_c.status != 0)
2460                 {
2461                         /* report error code */
2462                         DEBUG(4,("SAMR_CLOSE_HND: %s\n", get_nt_error_msg(r_c.status)));
2463                         p = False;
2464                 }
2465
2466                 if (p)
2467                 {
2468                         /* check that the returned policy handle is all zeros */
2469                         uint32 i;
2470                         valid_close = True;
2471
2472                         for (i = 0; i < sizeof(r_c.pol.data); i++)
2473                         {
2474                                 if (r_c.pol.data[i] != 0)
2475                                 {
2476                                         valid_close = False;
2477                                         break;
2478                                 }
2479                         }
2480                         if (!valid_close)
2481                         {
2482                                 DEBUG(4,("SAMR_CLOSE_HND: non-zero handle returned\n"));
2483                         }
2484                 }
2485         }
2486
2487         prs_mem_free(&data   );
2488         prs_mem_free(&rdata  );
2489
2490         return valid_close;
2491 }
2492
2493 /****************************************************************************
2494 do a SAMR query display info
2495 ****************************************************************************/
2496 BOOL samr_query_dispinfo(struct cli_state *cli, uint16 fnum,
2497                                 POLICY_HND *pol_open_domain, uint16 level,
2498                                 uint32 *num_entries,
2499                                 SAM_DISPINFO_CTR *ctr)
2500 {
2501         prs_struct data;
2502         prs_struct rdata;
2503
2504         SAMR_Q_QUERY_DISPINFO q_o;
2505         BOOL valid_query = False;
2506
2507         DEBUG(4,("SAMR Query Display Info.  level: %d\n", level));
2508
2509         if (pol_open_domain == NULL || num_entries == NULL || ctr == NULL ||
2510             level == 0)
2511         {
2512                 return False;
2513         }
2514
2515         /* create and send a MSRPC command with api SAMR_QUERY_DISPINFO */
2516
2517         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2518         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2519
2520         /* store the parameters */
2521         make_samr_q_query_dispinfo(&q_o, pol_open_domain, level, 0, 0xffffffff);
2522
2523         /* turn parameters into data stream */
2524         samr_io_q_query_dispinfo("", &q_o,  &data, 0);
2525
2526         /* send the data on \PIPE\ */
2527         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_DISPINFO, &data, &rdata))
2528         {
2529                 SAMR_R_QUERY_DISPINFO r_o;
2530                 BOOL p;
2531
2532                 /* get user info */
2533                 r_o.ctr = ctr;
2534
2535                 samr_io_r_query_dispinfo("", &r_o, &rdata, 0);
2536                 p = rdata.offset != 0;
2537
2538                 if (p && r_o.status != 0)
2539                 {
2540                         /* report error code */
2541                         DEBUG(4,("SAMR_R_QUERY_DISPINFO: %s\n", get_nt_error_msg(r_o.status)));
2542                         p = False;
2543                 }
2544
2545                 if (p && r_o.switch_level != level)
2546                 {
2547                         DEBUG(4,("SAMR_R_QUERY_DISPINFO: received incorrect level %d\n",
2548                                   r_o.switch_level));
2549                 }
2550
2551                 if (p && r_o.ptr_entries != 0)
2552                 {
2553                         valid_query = True;
2554                 }
2555         }
2556
2557         prs_mem_free(&data   );
2558         prs_mem_free(&rdata  );
2559
2560         return valid_query;
2561 }
2562