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                                 0x00000010, 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 BOOL samr_enum_dom_groups(struct cli_state *cli, uint16 fnum,
 550                                 POLICY_HND *pol, uint32 size,
 551                                 struct acct_info **sam,
 552                                 int *num_sam_groups)
 553 {
 554         prs_struct data;
 555         prs_struct rdata;
 556
 557         SAMR_Q_ENUM_DOM_GROUPS q_e;
 558         BOOL valid_pol = False;
 559
 560         DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
 561
 562         if (pol == NULL || num_sam_groups == NULL) return False;
 563
 564         /* create and send a MSRPC command with api SAMR_ENUM_DOM_GROUPS */
 565
 566         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 567         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 568
 569         /* store the parameters */
 570         make_samr_q_enum_dom_groups(&q_e, pol, size);
 571
 572         /* turn parameters into data stream */
 573         samr_io_q_enum_dom_groups("", &q_e, &data, 0);
 574
 575         /* send the data on \PIPE\ */
 576         if (rpc_api_pipe_req(cli, fnum, SAMR_ENUM_DOM_GROUPS, &data, &rdata))
 577         {
 578                 SAMR_R_ENUM_DOM_GROUPS r_e;
 579                 BOOL p;
 580
 581                 samr_io_r_enum_dom_groups("", &r_e, &rdata, 0);
 582
 583                 p = rdata.offset != 0;
 584                 if (p && r_e.status != 0)
 585                 {
 586                         /* report error code */
 587                         DEBUG(4,("SAMR_R_ENUM_DOM_GROUPS: %s\n", get_nt_error_msg(r_e.status)));
 588                         p = False;
 589                 }
 590
 591                 if (p)
 592                 {
 593                         int i;
 594                         int name_idx = 0;
 595
 596                         *num_sam_groups = r_e.num_entries2;
 597                         if (*num_sam_groups > MAX_SAM_ENTRIES)
 598                         {
 599                                 *num_sam_groups = MAX_SAM_ENTRIES;
 600                                 DEBUG(2,("samr_enum_dom_groups: sam group entries limited to %d\n",
 601                                           *num_sam_groups));
 602                         }
 603
 604                         *sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_groups));
 605
 606                         if ((*sam) == NULL)
 607                         {
 608                                 *num_sam_groups = 0;
 609                         }
 610
 611                         for (i = 0; i < *num_sam_groups; i++)
 612                         {
 613                                 (*sam)[i].rid = r_e.sam[i].rid;
 614                                 (*sam)[i].acct_name[0] = 0;
 615                                 (*sam)[i].acct_desc[0] = 0;
 616                                 if (r_e.sam[i].hdr_name.buffer)
 617                                 {
 618                                         unistr2_to_ascii((*sam)[i].acct_name, &r_e.uni_grp_name[name_idx], sizeof((*sam)[i].acct_name)-1);
 619                                         name_idx++;
 620                                 }
 621                                 DEBUG(5,("samr_enum_dom_groups: idx: %4d rid: %8x acct: %s\n",
 622                                           i, (*sam)[i].rid, (*sam)[i].acct_name));
 623                         }
 624                         valid_pol = True;
 625                 }
 626         }
 627
 628         prs_mem_free(&data   );
 629         prs_mem_free(&rdata  );
 630
 631         return valid_pol;
 632 }
 633
 634 /****************************************************************************
 635 do a SAMR enumerate aliases
 636 ****************************************************************************/
 637 BOOL samr_enum_dom_aliases(struct cli_state *cli, uint16 fnum,
 638                                 POLICY_HND *pol, uint32 size,
 639                                 struct acct_info **sam,
 640                                 int *num_sam_aliases)
 641 {
 642         prs_struct data;
 643         prs_struct rdata;
 644
 645         SAMR_Q_ENUM_DOM_ALIASES q_e;
 646         BOOL valid_pol = False;
 647
 648         DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
 649
 650         if (pol == NULL || num_sam_aliases == NULL) return False;
 651
 652         /* create and send a MSRPC command with api SAMR_ENUM_DOM_ALIASES */
 653
 654         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 655         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 656
 657         /* store the parameters */
 658         make_samr_q_enum_dom_aliases(&q_e, pol, size);
 659
 660         /* turn parameters into data stream */
 661         samr_io_q_enum_dom_aliases("", &q_e, &data, 0);
 662
 663         /* send the data on \PIPE\ */
 664         if (rpc_api_pipe_req(cli, fnum, SAMR_ENUM_DOM_ALIASES, &data, &rdata))
 665         {
 666                 SAMR_R_ENUM_DOM_ALIASES r_e;
 667                 BOOL p;
 668
 669                 samr_io_r_enum_dom_aliases("", &r_e, &rdata, 0);
 670
 671                 p = rdata.offset != 0;
 672                 if (p && r_e.status != 0)
 673                 {
 674                         /* report error code */
 675                         DEBUG(4,("SAMR_R_ENUM_DOM_ALIASES: %s\n", get_nt_error_msg(r_e.status)));
 676                         p = False;
 677                 }
 678
 679                 if (p)
 680                 {
 681                         int i;
 682                         int name_idx = 0;
 683
 684                         *num_sam_aliases = r_e.num_entries2;
 685                         if (*num_sam_aliases > MAX_SAM_ENTRIES)
 686                         {
 687                                 *num_sam_aliases = MAX_SAM_ENTRIES;
 688                                 DEBUG(2,("samr_enum_dom_aliases: sam user entries limited to %d\n",
 689                                           *num_sam_aliases));
 690                         }
 691
 692                         *sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_aliases));
 693
 694                         if ((*sam) == NULL)
 695                         {
 696                                 *num_sam_aliases = 0;
 697                         }
 698
 699                         for (i = 0; i < *num_sam_aliases; i++)
 700                         {
 701                                 (*sam)[i].rid = r_e.sam[i].rid;
 702                                 (*sam)[i].acct_name[0] = 0;
 703                                 (*sam)[i].acct_desc[0] = 0;
 704                                 if (r_e.sam[i].hdr_name.buffer)
 705                                 {
 706                                         unistr2_to_ascii((*sam)[i].acct_name, &r_e.uni_grp_name[name_idx], sizeof((*sam)[i].acct_name)-1);
 707                                         name_idx++;
 708                                 }
 709                                 DEBUG(5,("samr_enum_dom_aliases: idx: %4d rid: %8x acct: %s\n",
 710                                           i, (*sam)[i].rid, (*sam)[i].acct_name));
 711                         }
 712                         valid_pol = True;
 713                 }
 714         }
 715
 716         prs_mem_free(&data   );
 717         prs_mem_free(&rdata  );
 718
 719         return valid_pol;
 720 }
 721
 722 /****************************************************************************
 723 do a SAMR enumerate users
 724 ****************************************************************************/
 725 BOOL samr_enum_dom_users(struct cli_state *cli, uint16 fnum,
 726                                 POLICY_HND *pol, uint32 start_idx,
 727                                 uint16 acb_mask, uint16 unk_1, uint32 size,
 728                                 struct acct_info **sam,
 729                                 int *num_sam_users)
 730 {
 731         prs_struct data;
 732         prs_struct rdata;
 733
 734         SAMR_Q_ENUM_DOM_USERS q_e;
 735         BOOL valid_pol = False;
 736
 737         DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
 738
 739         if (pol == NULL || num_sam_users == NULL) return False;
 740
 741         /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
 742
 743         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 744         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 745
 746         /* store the parameters */
 747         make_samr_q_enum_dom_users(&q_e, pol, start_idx, acb_mask, unk_1, size);
 748
 749         /* turn parameters into data stream */
 750         samr_io_q_enum_dom_users("", &q_e, &data, 0);
 751
 752         /* send the data on \PIPE\ */
 753         if (rpc_api_pipe_req(cli, fnum, SAMR_ENUM_DOM_USERS, &data, &rdata))
 754         {
 755                 SAMR_R_ENUM_DOM_USERS r_e;
 756                 BOOL p;
 757
 758                 samr_io_r_enum_dom_users("", &r_e, &rdata, 0);
 759
 760                 p = rdata.offset != 0;
 761                 if (p && r_e.status != 0)
 762                 {
 763                         /* report error code */
 764                         DEBUG(4,("SAMR_R_ENUM_DOM_USERS: %s\n", get_nt_error_msg(r_e.status)));
 765                         p = False;
 766                 }
 767
 768                 if (p)
 769                 {
 770                         int i;
 771                         int name_idx = 0;
 772
 773                         *num_sam_users = r_e.num_entries2;
 774                         *sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_users));
 775
 776                         if ((*sam) == NULL)
 777                         {
 778                                 *num_sam_users = 0;
 779                         }
 780
 781                         for (i = 0; i < *num_sam_users; i++)
 782                         {
 783                                 (*sam)[i].rid = r_e.sam[i].rid;
 784                                 (*sam)[i].acct_name[0] = 0;
 785                                 (*sam)[i].acct_desc[0] = 0;
 786                                 if (r_e.sam[i].hdr_name.buffer)
 787                                 {
 788                                         unistr2_to_ascii((*sam)[i].acct_name, &r_e.uni_acct_name[name_idx], sizeof((*sam)[i].acct_name)-1);
 789                                         name_idx++;
 790                                 }
 791                                 DEBUG(5,("samr_enum_dom_users: idx: %4d rid: %8x acct: %s\n",
 792                                           i, (*sam)[i].rid, (*sam)[i].acct_name));
 793                         }
 794                         valid_pol = True;
 795                 }
 796
 797                 if (r_e.sam != NULL)
 798                 {
 799                         free(r_e.sam);
 800                 }
 801                 if (r_e.uni_acct_name != NULL)
 802                 {
 803                         free(r_e.uni_acct_name);
 804                 }
 805         }
 806
 807         prs_mem_free(&data   );
 808         prs_mem_free(&rdata  );
 809
 810         return valid_pol;
 811 }
 812
 813 /****************************************************************************
 814 do a SAMR Connect
 815 ****************************************************************************/
 816 BOOL samr_connect(struct cli_state *cli, uint16 fnum,
 817                                 char *srv_name, uint32 unknown_0,
 818                                 POLICY_HND *connect_pol)
 819 {
 820         prs_struct data;
 821         prs_struct rdata;
 822
 823         SAMR_Q_CONNECT q_o;
 824         BOOL valid_pol = False;
 825
 826         DEBUG(4,("SAMR Open Policy server:%s undoc value:%x\n",
 827                                 srv_name, unknown_0));
 828
 829         if (srv_name == NULL || connect_pol == NULL) return False;
 830
 831         /* create and send a MSRPC command with api SAMR_CONNECT */
 832
 833         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 834         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 835
 836         /* store the parameters */
 837         make_samr_q_connect(&q_o, srv_name, unknown_0);
 838
 839         /* turn parameters into data stream */
 840         samr_io_q_connect("", &q_o,  &data, 0);
 841
 842         /* send the data on \PIPE\ */
 843         if (rpc_api_pipe_req(cli, fnum, SAMR_CONNECT, &data, &rdata))
 844         {
 845                 SAMR_R_CONNECT r_o;
 846                 BOOL p;
 847
 848                 samr_io_r_connect("", &r_o, &rdata, 0);
 849                 p = rdata.offset != 0;
 850
 851                 if (p && r_o.status != 0)
 852                 {
 853                         /* report error code */
 854                         DEBUG(4,("SAMR_R_CONNECT: %s\n", get_nt_error_msg(r_o.status)));
 855                         p = False;
 856                 }
 857
 858                 if (p)
 859                 {
 860                         memcpy(connect_pol, &r_o.connect_pol, sizeof(r_o.connect_pol));
 861                         valid_pol = True;
 862                 }
 863         }
 864
 865         prs_mem_free(&data   );
 866         prs_mem_free(&rdata  );
 867
 868         return valid_pol;
 869 }
 870
 871 /****************************************************************************
 872 do a SAMR Open User
 873 ****************************************************************************/
 874 BOOL samr_open_user(struct cli_state *cli, uint16 fnum,
 875                                 POLICY_HND *pol, uint32 unk_0, uint32 rid,
 876                                 POLICY_HND *user_pol)
 877 {
 878         prs_struct data;
 879         prs_struct rdata;
 880
 881         SAMR_Q_OPEN_USER q_o;
 882         BOOL valid_pol = False;
 883
 884         DEBUG(4,("SAMR Open User.  unk_0: %08x RID:%x\n",
 885                   unk_0, rid));
 886
 887         if (pol == NULL || user_pol == NULL) return False;
 888
 889         /* create and send a MSRPC command with api SAMR_OPEN_USER */
 890
 891         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 892         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 893
 894         /* store the parameters */
 895         make_samr_q_open_user(&q_o, pol, unk_0, rid);
 896
 897         /* turn parameters into data stream */
 898         samr_io_q_open_user("", &q_o,  &data, 0);
 899
 900         /* send the data on \PIPE\ */
 901         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_USER, &data, &rdata))
 902         {
 903                 SAMR_R_OPEN_USER r_o;
 904                 BOOL p;
 905
 906                 samr_io_r_open_user("", &r_o, &rdata, 0);
 907                 p = rdata.offset != 0;
 908
 909                 if (p && r_o.status != 0)
 910                 {
 911                         /* report error code */
 912                         DEBUG(4,("SAMR_R_OPEN_USER: %s\n", get_nt_error_msg(r_o.status)));
 913                         p = False;
 914                 }
 915
 916                 if (p)
 917                 {
 918                         memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
 919                         valid_pol = True;
 920                 }
 921         }
 922
 923         prs_mem_free(&data   );
 924         prs_mem_free(&rdata  );
 925
 926         return valid_pol;
 927 }
 928
 929 /****************************************************************************
 930 do a SAMR Open Alias
 931 ****************************************************************************/
 932 BOOL samr_open_alias(struct cli_state *cli, uint16 fnum,
 933                                 POLICY_HND *domain_pol,
 934                                 uint32 flags, uint32 rid,
 935                                 POLICY_HND *alias_pol)
 936 {
 937         prs_struct data;
 938         prs_struct rdata;
 939
 940         SAMR_Q_OPEN_ALIAS q_o;
 941         BOOL valid_pol = False;
 942
 943         DEBUG(4,("SAMR Open Alias. RID:%x\n", rid));
 944
 945         if (alias_pol == NULL || domain_pol == NULL) return False;
 946
 947         /* create and send a MSRPC command with api SAMR_OPEN_ALIAS */
 948
 949         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
 950         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
 951
 952         /* store the parameters */
 953         make_samr_q_open_alias(&q_o, domain_pol, flags, rid);
 954
 955         /* turn parameters into data stream */
 956         samr_io_q_open_alias("", &q_o,  &data, 0);
 957
 958         /* send the data on \PIPE\ */
 959         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_ALIAS, &data, &rdata))
 960         {
 961                 SAMR_R_OPEN_ALIAS r_o;
 962                 BOOL p;
 963
 964                 samr_io_r_open_alias("", &r_o, &rdata, 0);
 965                 p = rdata.offset != 0;
 966
 967                 if (p && r_o.status != 0)
 968                 {
 969                         /* report error code */
 970                         DEBUG(4,("SAMR_R_OPEN_ALIAS: %s\n", get_nt_error_msg(r_o.status)));
 971                         p = False;
 972                 }
 973
 974                 if (p)
 975                 {
 976                         memcpy(alias_pol, &r_o.pol, sizeof(r_o.pol));
 977                         valid_pol = True;
 978                 }
 979         }
 980
 981         prs_mem_free(&data   );
 982         prs_mem_free(&rdata  );
 983
 984         return valid_pol;
 985 }
 986
 987 /****************************************************************************
 988 do a SAMR Delete Alias Member
 989 ****************************************************************************/
 990 BOOL samr_del_aliasmem(struct cli_state *cli, uint16 fnum,
 991                                 POLICY_HND *alias_pol, DOM_SID *sid)
 992 {
 993         prs_struct data;
 994         prs_struct rdata;
 995
 996         SAMR_Q_DEL_ALIASMEM q_o;
 997         BOOL valid_pol = False;
 998
 999         if (alias_pol == NULL || sid == NULL) return False;
1000
1001         /* create and send a MSRPC command with api SAMR_DEL_ALIASMEM */
1002
1003         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1004         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1005
1006         DEBUG(4,("SAMR Delete Alias Member.\n"));
1007
1008         /* store the parameters */
1009         make_samr_q_del_aliasmem(&q_o, alias_pol, sid);
1010
1011         /* turn parameters into data stream */
1012         samr_io_q_del_aliasmem("", &q_o,  &data, 0);
1013
1014         /* send the data on \PIPE\ */
1015         if (rpc_api_pipe_req(cli, fnum, SAMR_DEL_ALIASMEM, &data, &rdata))
1016         {
1017                 SAMR_R_DEL_ALIASMEM r_o;
1018                 BOOL p;
1019
1020                 samr_io_r_del_aliasmem("", &r_o, &rdata, 0);
1021                 p = rdata.offset != 0;
1022
1023                 if (p && r_o.status != 0)
1024                 {
1025                         /* report error code */
1026                         DEBUG(4,("SAMR_R_DEL_ALIASMEM: %s\n", get_nt_error_msg(r_o.status)));
1027                         p = False;
1028                 }
1029
1030                 if (p)
1031                 {
1032                         valid_pol = True;
1033                 }
1034         }
1035
1036         prs_mem_free(&data   );
1037         prs_mem_free(&rdata  );
1038
1039         return valid_pol;
1040 }
1041
1042 /****************************************************************************
1043 do a SAMR Add Alias Member
1044 ****************************************************************************/
1045 BOOL samr_add_aliasmem(struct cli_state *cli, uint16 fnum,
1046                                 POLICY_HND *alias_pol, DOM_SID *sid)
1047 {
1048         prs_struct data;
1049         prs_struct rdata;
1050
1051         SAMR_Q_ADD_ALIASMEM q_o;
1052         BOOL valid_pol = False;
1053
1054         if (alias_pol == NULL || sid == NULL) return False;
1055
1056         /* create and send a MSRPC command with api SAMR_ADD_ALIASMEM */
1057
1058         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1059         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1060
1061         DEBUG(4,("SAMR Add Alias Member.\n"));
1062
1063         /* store the parameters */
1064         make_samr_q_add_aliasmem(&q_o, alias_pol, sid);
1065
1066         /* turn parameters into data stream */
1067         samr_io_q_add_aliasmem("", &q_o,  &data, 0);
1068
1069         /* send the data on \PIPE\ */
1070         if (rpc_api_pipe_req(cli, fnum, SAMR_ADD_ALIASMEM, &data, &rdata))
1071         {
1072                 SAMR_R_ADD_ALIASMEM r_o;
1073                 BOOL p;
1074
1075                 samr_io_r_add_aliasmem("", &r_o, &rdata, 0);
1076                 p = rdata.offset != 0;
1077
1078                 if (p && r_o.status != 0)
1079                 {
1080                         /* report error code */
1081                         DEBUG(4,("SAMR_R_ADD_ALIASMEM: %s\n", get_nt_error_msg(r_o.status)));
1082                         p = False;
1083                 }
1084
1085                 if (p)
1086                 {
1087                         valid_pol = True;
1088                 }
1089         }
1090
1091         prs_mem_free(&data   );
1092         prs_mem_free(&rdata  );
1093
1094         return valid_pol;
1095 }
1096
1097 /****************************************************************************
1098 do a SAMR Delete Domain Alias
1099 ****************************************************************************/
1100 BOOL samr_delete_dom_alias(struct cli_state *cli, uint16 fnum,
1101                                 POLICY_HND *alias_pol)
1102 {
1103         prs_struct data;
1104         prs_struct rdata;
1105
1106         SAMR_Q_DELETE_DOM_ALIAS q_o;
1107         BOOL valid_pol = False;
1108
1109         if (alias_pol == NULL) return False;
1110
1111         /* delete and send a MSRPC command with api SAMR_DELETE_DOM_ALIAS */
1112
1113         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1114         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1115
1116         DEBUG(4,("SAMR Delete Domain Alias.\n"));
1117
1118         /* store the parameters */
1119         make_samr_q_delete_dom_alias(&q_o, alias_pol);
1120
1121         /* turn parameters into data stream */
1122         samr_io_q_delete_dom_alias("", &q_o,  &data, 0);
1123
1124         /* send the data on \PIPE\ */
1125         if (rpc_api_pipe_req(cli, fnum, SAMR_DELETE_DOM_ALIAS, &data, &rdata))
1126         {
1127                 SAMR_R_DELETE_DOM_ALIAS r_o;
1128                 BOOL p;
1129
1130                 samr_io_r_delete_dom_alias("", &r_o, &rdata, 0);
1131                 p = rdata.offset != 0;
1132
1133                 if (p && r_o.status != 0)
1134                 {
1135                         /* report error code */
1136                         DEBUG(4,("SAMR_R_DELETE_DOM_ALIAS: %s\n", get_nt_error_msg(r_o.status)));
1137                         p = False;
1138                 }
1139
1140                 if (p)
1141                 {
1142                         valid_pol = True;
1143                 }
1144         }
1145
1146         prs_mem_free(&data   );
1147         prs_mem_free(&rdata  );
1148
1149         return valid_pol;
1150 }
1151
1152 /****************************************************************************
1153 do a SAMR Create Domain User
1154 ****************************************************************************/
1155 BOOL samr_create_dom_user(struct cli_state *cli, uint16 fnum,
1156                                 POLICY_HND *domain_pol, const char *acct_name,
1157                                 uint32 unk_0, uint32 unk_1,
1158                                 POLICY_HND *user_pol, uint32 *rid)
1159 {
1160         prs_struct data;
1161         prs_struct rdata;
1162
1163         SAMR_Q_CREATE_USER q_o;
1164         BOOL valid_pol = False;
1165
1166         if (user_pol == NULL || domain_pol == NULL || acct_name == NULL || rid == NULL) return False;
1167
1168         /* create and send a MSRPC command with api SAMR_CREATE_USER */
1169
1170         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1171         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1172
1173         DEBUG(4,("SAMR Create Domain User. Name:%s\n", acct_name));
1174
1175         /* store the parameters */
1176         make_samr_q_create_user(&q_o, domain_pol, acct_name, unk_0, unk_1);
1177
1178         /* turn parameters into data stream */
1179         samr_io_q_create_user("", &q_o,  &data, 0);
1180
1181         /* send the data on \PIPE\ */
1182         if (rpc_api_pipe_req(cli, fnum, SAMR_CREATE_USER, &data, &rdata))
1183         {
1184                 SAMR_R_CREATE_USER r_o;
1185                 BOOL p;
1186
1187                 samr_io_r_create_user("", &r_o, &rdata, 0);
1188                 p = rdata.offset != 0;
1189
1190                 if (p && r_o.status != 0)
1191                 {
1192                         /* report error code */
1193                         DEBUG(4,("SAMR_R_CREATE_USER: %s\n", get_nt_error_msg(r_o.status)));
1194                         p = False;
1195                 }
1196
1197                 if (p)
1198                 {
1199                         memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
1200                         *rid = r_o.user_rid;
1201                         valid_pol = True;
1202                 }
1203         }
1204
1205         prs_mem_free(&data   );
1206         prs_mem_free(&rdata  );
1207
1208         return valid_pol;
1209 }
1210
1211 /****************************************************************************
1212 do a SAMR Create Domain Alias
1213 ****************************************************************************/
1214 BOOL samr_create_dom_alias(struct cli_state *cli, uint16 fnum,
1215                                 POLICY_HND *domain_pol, const char *acct_name,
1216                                 POLICY_HND *alias_pol, uint32 *rid)
1217 {
1218         prs_struct data;
1219         prs_struct rdata;
1220
1221         SAMR_Q_CREATE_DOM_ALIAS q_o;
1222         BOOL valid_pol = False;
1223
1224         if (alias_pol == NULL || domain_pol == NULL || acct_name == NULL || rid == NULL) return False;
1225
1226         /* create and send a MSRPC command with api SAMR_CREATE_DOM_ALIAS */
1227
1228         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1229         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1230
1231         DEBUG(4,("SAMR Create Domain Alias. Name:%s\n", acct_name));
1232
1233         /* store the parameters */
1234         make_samr_q_create_dom_alias(&q_o, domain_pol, acct_name);
1235
1236         /* turn parameters into data stream */
1237         samr_io_q_create_dom_alias("", &q_o,  &data, 0);
1238
1239         /* send the data on \PIPE\ */
1240         if (rpc_api_pipe_req(cli, fnum, SAMR_CREATE_DOM_ALIAS, &data, &rdata))
1241         {
1242                 SAMR_R_CREATE_DOM_ALIAS r_o;
1243                 BOOL p;
1244
1245                 samr_io_r_create_dom_alias("", &r_o, &rdata, 0);
1246                 p = rdata.offset != 0;
1247
1248                 if (p && r_o.status != 0)
1249                 {
1250                         /* report error code */
1251                         DEBUG(4,("SAMR_R_CREATE_DOM_ALIAS: %s\n", get_nt_error_msg(r_o.status)));
1252                         p = False;
1253                 }
1254
1255                 if (p)
1256                 {
1257                         memcpy(alias_pol, &r_o.alias_pol, sizeof(r_o.alias_pol));
1258                         *rid = r_o.rid;
1259                         valid_pol = True;
1260                 }
1261         }
1262
1263         prs_mem_free(&data   );
1264         prs_mem_free(&rdata  );
1265
1266         return valid_pol;
1267 }
1268
1269 #if 0
1270 /****************************************************************************
1271 do a SAMR Get Alias Info
1272 ****************************************************************************/
1273 BOOL samr_get_aliasinfo(struct cli_state *cli, uint16 fnum,
1274                                 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
1275 {
1276         prs_struct data;
1277         prs_struct rdata;
1278
1279         SAMR_Q_GET_ALIASINFO q_o;
1280         BOOL valid_pol = False;
1281
1282         if (alias_pol == NULL || ctr == NULL) return False;
1283
1284         /* create and send a MSRPC command with api SAMR_GET_ALIASINFO */
1285
1286         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1287         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1288
1289         DEBUG(4,("SAMR Get Alias Info\n"));
1290
1291         /* store the parameters */
1292         make_samr_q_get_aliasinfo(&q_o, alias_pol, ctr);
1293
1294         /* turn parameters into data stream */
1295         samr_io_q_get_aliasinfo("", &q_o,  &data, 0);
1296
1297         /* send the data on \PIPE\ */
1298         if (rpc_api_pipe_req(cli, fnum, SAMR_GET_ALIASINFO, &data, &rdata))
1299         {
1300                 SAMR_R_GET_ALIASINFO r_o;
1301                 BOOL p;
1302
1303                 samr_io_r_get_aliasinfo("", &r_o, &rdata, 0);
1304                 p = rdata.offset != 0;
1305
1306                 if (p && r_o.status != 0)
1307                 {
1308                         /* report error code */
1309                         DEBUG(4,("SAMR_R_GET_ALIASINFO: %s\n", get_nt_error_msg(r_o.status)));
1310                         p = False;
1311                 }
1312
1313                 if (p)
1314                 {
1315                         valid_pol = True;
1316                 }
1317         }
1318
1319         prs_mem_free(&data   );
1320         prs_mem_free(&rdata  );
1321
1322         return valid_pol;
1323 }
1324 #endif
1325
1326 /****************************************************************************
1327 do a SAMR Set Alias Info
1328 ****************************************************************************/
1329 BOOL samr_set_aliasinfo(struct cli_state *cli, uint16 fnum,
1330                                 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
1331 {
1332         prs_struct data;
1333         prs_struct rdata;
1334
1335         SAMR_Q_SET_ALIASINFO q_o;
1336         BOOL valid_pol = False;
1337
1338         if (alias_pol == NULL || ctr == NULL) return False;
1339
1340         /* create and send a MSRPC command with api SAMR_SET_ALIASINFO */
1341
1342         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1343         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1344
1345         DEBUG(4,("SAMR Set Alias Info\n"));
1346
1347         /* store the parameters */
1348         make_samr_q_set_aliasinfo(&q_o, alias_pol, ctr);
1349
1350         /* turn parameters into data stream */
1351         samr_io_q_set_aliasinfo("", &q_o,  &data, 0);
1352
1353         /* send the data on \PIPE\ */
1354         if (rpc_api_pipe_req(cli, fnum, SAMR_SET_ALIASINFO, &data, &rdata))
1355         {
1356                 SAMR_R_SET_ALIASINFO r_o;
1357                 BOOL p;
1358
1359                 samr_io_r_set_aliasinfo("", &r_o, &rdata, 0);
1360                 p = rdata.offset != 0;
1361
1362                 if (p && r_o.status != 0)
1363                 {
1364                         /* report error code */
1365                         DEBUG(4,("SAMR_R_SET_ALIASINFO: %s\n", get_nt_error_msg(r_o.status)));
1366                         p = False;
1367                 }
1368
1369                 if (p)
1370                 {
1371                         valid_pol = True;
1372                 }
1373         }
1374
1375         prs_mem_free(&data   );
1376         prs_mem_free(&rdata  );
1377
1378         return valid_pol;
1379 }
1380
1381 /****************************************************************************
1382 do a SAMR Open Group
1383 ****************************************************************************/
1384 BOOL samr_open_group(struct cli_state *cli, uint16 fnum,
1385                                 POLICY_HND *domain_pol,
1386                                 uint32 flags, uint32 rid,
1387                                 POLICY_HND *group_pol)
1388 {
1389         prs_struct data;
1390         prs_struct rdata;
1391
1392         SAMR_Q_OPEN_GROUP q_o;
1393         BOOL valid_pol = False;
1394
1395         DEBUG(4,("SAMR Open Group. RID:%x\n", rid));
1396
1397         if (group_pol == NULL || domain_pol == NULL) return False;
1398
1399         /* create and send a MSRPC command with api SAMR_OPEN_GROUP */
1400
1401         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1402         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1403
1404         /* store the parameters */
1405         make_samr_q_open_group(&q_o, domain_pol, flags, rid);
1406
1407         /* turn parameters into data stream */
1408         samr_io_q_open_group("", &q_o,  &data, 0);
1409
1410         /* send the data on \PIPE\ */
1411         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_GROUP, &data, &rdata))
1412         {
1413                 SAMR_R_OPEN_GROUP r_o;
1414                 BOOL p;
1415
1416                 samr_io_r_open_group("", &r_o, &rdata, 0);
1417                 p = rdata.offset != 0;
1418
1419                 if (p && r_o.status != 0)
1420                 {
1421                         /* report error code */
1422                         DEBUG(4,("SAMR_R_OPEN_GROUP: %s\n", get_nt_error_msg(r_o.status)));
1423                         p = False;
1424                 }
1425
1426                 if (p)
1427                 {
1428                         memcpy(group_pol, &r_o.pol, sizeof(r_o.pol));
1429                         valid_pol = True;
1430                 }
1431         }
1432
1433         prs_mem_free(&data   );
1434         prs_mem_free(&rdata  );
1435
1436         return valid_pol;
1437 }
1438
1439 /****************************************************************************
1440 do a SAMR Delete Group Member
1441 ****************************************************************************/
1442 BOOL samr_del_groupmem(struct cli_state *cli, uint16 fnum,
1443                                 POLICY_HND *group_pol, uint32 rid)
1444 {
1445         prs_struct data;
1446         prs_struct rdata;
1447
1448         SAMR_Q_DEL_GROUPMEM q_o;
1449         BOOL valid_pol = False;
1450
1451         if (group_pol == NULL) return False;
1452
1453         /* create and send a MSRPC command with api SAMR_DEL_GROUPMEM */
1454
1455         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1456         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1457
1458         DEBUG(4,("SAMR Delete Group Member.\n"));
1459
1460         /* store the parameters */
1461         make_samr_q_del_groupmem(&q_o, group_pol, rid);
1462
1463         /* turn parameters into data stream */
1464         samr_io_q_del_groupmem("", &q_o,  &data, 0);
1465
1466         /* send the data on \PIPE\ */
1467         if (rpc_api_pipe_req(cli, fnum, SAMR_DEL_GROUPMEM, &data, &rdata))
1468         {
1469                 SAMR_R_DEL_GROUPMEM r_o;
1470                 BOOL p;
1471
1472                 samr_io_r_del_groupmem("", &r_o, &rdata, 0);
1473                 p = rdata.offset != 0;
1474
1475                 if (p && r_o.status != 0)
1476                 {
1477                         /* report error code */
1478                         DEBUG(4,("SAMR_R_DEL_GROUPMEM: %s\n", get_nt_error_msg(r_o.status)));
1479                         p = False;
1480                 }
1481
1482                 if (p)
1483                 {
1484                         valid_pol = True;
1485                 }
1486         }
1487
1488         prs_mem_free(&data   );
1489         prs_mem_free(&rdata  );
1490
1491         return valid_pol;
1492 }
1493
1494 /****************************************************************************
1495 do a SAMR Add Group Member
1496 ****************************************************************************/
1497 BOOL samr_add_groupmem(struct cli_state *cli, uint16 fnum,
1498                                 POLICY_HND *group_pol, uint32 rid)
1499 {
1500         prs_struct data;
1501         prs_struct rdata;
1502
1503         SAMR_Q_ADD_GROUPMEM q_o;
1504         BOOL valid_pol = False;
1505
1506         if (group_pol == NULL) return False;
1507
1508         /* create and send a MSRPC command with api SAMR_ADD_GROUPMEM */
1509
1510         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1511         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1512
1513         DEBUG(4,("SAMR Add Group Member.\n"));
1514
1515         /* store the parameters */
1516         make_samr_q_add_groupmem(&q_o, group_pol, rid);
1517
1518         /* turn parameters into data stream */
1519         samr_io_q_add_groupmem("", &q_o,  &data, 0);
1520
1521         /* send the data on \PIPE\ */
1522         if (rpc_api_pipe_req(cli, fnum, SAMR_ADD_GROUPMEM, &data, &rdata))
1523         {
1524                 SAMR_R_ADD_GROUPMEM r_o;
1525                 BOOL p;
1526
1527                 samr_io_r_add_groupmem("", &r_o, &rdata, 0);
1528                 p = rdata.offset != 0;
1529
1530                 if (p && r_o.status != 0)
1531                 {
1532                         /* report error code */
1533                         DEBUG(4,("SAMR_R_ADD_GROUPMEM: %s\n", get_nt_error_msg(r_o.status)));
1534                         p = False;
1535                 }
1536
1537                 if (p)
1538                 {
1539                         valid_pol = True;
1540                 }
1541         }
1542
1543         prs_mem_free(&data   );
1544         prs_mem_free(&rdata  );
1545
1546         return valid_pol;
1547 }
1548
1549 /****************************************************************************
1550 do a SAMR Delete Domain Group
1551 ****************************************************************************/
1552 BOOL samr_delete_dom_group(struct cli_state *cli, uint16 fnum, POLICY_HND *group_pol)
1553 {
1554         prs_struct data;
1555         prs_struct rdata;
1556
1557         SAMR_Q_DELETE_DOM_GROUP q_o;
1558         BOOL valid_pol = False;
1559
1560         if (group_pol == NULL) return False;
1561
1562         /* delete and send a MSRPC command with api SAMR_DELETE_DOM_GROUP */
1563
1564         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1565         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1566
1567         DEBUG(4,("SAMR Delete Domain Group.\n"));
1568
1569         /* store the parameters */
1570         make_samr_q_delete_dom_group(&q_o, group_pol);
1571
1572         /* turn parameters into data stream */
1573         samr_io_q_delete_dom_group("", &q_o,  &data, 0);
1574
1575         /* send the data on \PIPE\ */
1576         if (rpc_api_pipe_req(cli, fnum, SAMR_DELETE_DOM_GROUP, &data, &rdata))
1577         {
1578                 SAMR_R_DELETE_DOM_GROUP r_o;
1579                 BOOL p;
1580
1581                 samr_io_r_delete_dom_group("", &r_o, &rdata, 0);
1582                 p = rdata.offset != 0;
1583
1584                 if (p && r_o.status != 0)
1585                 {
1586                         /* report error code */
1587                         DEBUG(4,("SAMR_R_DELETE_DOM_GROUP: %s\n", get_nt_error_msg(r_o.status)));
1588                         p = False;
1589                 }
1590
1591                 if (p)
1592                 {
1593                         valid_pol = True;
1594                 }
1595         }
1596
1597         prs_mem_free(&data   );
1598         prs_mem_free(&rdata  );
1599
1600         return valid_pol;
1601 }
1602
1603 /****************************************************************************
1604 do a SAMR Create Domain Group
1605 ****************************************************************************/
1606 BOOL samr_create_dom_group(struct cli_state *cli, uint16 fnum,
1607                                 POLICY_HND *domain_pol, const char *acct_name,
1608                                 POLICY_HND *group_pol, uint32 *rid)
1609 {
1610         prs_struct data;
1611         prs_struct rdata;
1612
1613         SAMR_Q_CREATE_DOM_GROUP q_o;
1614         BOOL valid_pol = False;
1615
1616         if (group_pol == NULL || domain_pol == NULL || acct_name == NULL || rid == NULL) return False;
1617
1618         /* create and send a MSRPC command with api SAMR_CREATE_DOM_GROUP */
1619
1620         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1621         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1622
1623         DEBUG(4,("SAMR Create Domain Group. Name:%s\n", acct_name));
1624
1625         /* store the parameters */
1626         make_samr_q_create_dom_group(&q_o, domain_pol, acct_name);
1627
1628         /* turn parameters into data stream */
1629         samr_io_q_create_dom_group("", &q_o,  &data, 0);
1630
1631         /* send the data on \PIPE\ */
1632         if (rpc_api_pipe_req(cli, fnum, SAMR_CREATE_DOM_GROUP, &data, &rdata))
1633         {
1634                 SAMR_R_CREATE_DOM_GROUP r_o;
1635                 BOOL p;
1636
1637                 samr_io_r_create_dom_group("", &r_o, &rdata, 0);
1638                 p = rdata.offset != 0;
1639
1640                 if (p && r_o.status != 0)
1641                 {
1642                         /* report error code */
1643                         DEBUG(4,("SAMR_R_CREATE_DOM_GROUP: %s\n", get_nt_error_msg(r_o.status)));
1644                         p = False;
1645                 }
1646
1647                 if (p)
1648                 {
1649                         memcpy(group_pol, &r_o.pol, sizeof(r_o.pol));
1650                         *rid = r_o.rid;
1651                         valid_pol = True;
1652                 }
1653         }
1654
1655         prs_mem_free(&data   );
1656         prs_mem_free(&rdata  );
1657
1658         return valid_pol;
1659 }
1660
1661 /****************************************************************************
1662 do a SAMR Set Group Info
1663 ****************************************************************************/
1664 BOOL samr_set_groupinfo(struct cli_state *cli, uint16 fnum,
1665                                 POLICY_HND *group_pol, GROUP_INFO_CTR *ctr)
1666 {
1667         prs_struct data;
1668         prs_struct rdata;
1669
1670         SAMR_Q_SET_GROUPINFO q_o;
1671         BOOL valid_pol = False;
1672
1673         if (group_pol == NULL || ctr == NULL) return False;
1674
1675         /* create and send a MSRPC command with api SAMR_SET_GROUPINFO */
1676
1677         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1678         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1679
1680         DEBUG(4,("SAMR Set Group Info\n"));
1681
1682         /* store the parameters */
1683         make_samr_q_set_groupinfo(&q_o, group_pol, ctr);
1684
1685         /* turn parameters into data stream */
1686         samr_io_q_set_groupinfo("", &q_o,  &data, 0);
1687
1688         /* send the data on \PIPE\ */
1689         if (rpc_api_pipe_req(cli, fnum, SAMR_SET_GROUPINFO, &data, &rdata))
1690         {
1691                 SAMR_R_SET_GROUPINFO r_o;
1692                 BOOL p;
1693
1694                 samr_io_r_set_groupinfo("", &r_o, &rdata, 0);
1695                 p = rdata.offset != 0;
1696
1697                 if (p && r_o.status != 0)
1698                 {
1699                         /* report error code */
1700                         DEBUG(4,("SAMR_R_SET_GROUPINFO: %s\n", get_nt_error_msg(r_o.status)));
1701                         p = False;
1702                 }
1703
1704                 if (p)
1705                 {
1706                         valid_pol = True;
1707                 }
1708         }
1709
1710         prs_mem_free(&data   );
1711         prs_mem_free(&rdata  );
1712
1713         return valid_pol;
1714 }
1715
1716 /****************************************************************************
1717 do a SAMR Open Domain
1718 ****************************************************************************/
1719 BOOL samr_open_domain(struct cli_state *cli, uint16 fnum,
1720                                 POLICY_HND *connect_pol, uint32 ace_perms,
1721                                 DOM_SID *sid,
1722                                 POLICY_HND *domain_pol)
1723 {
1724         pstring sid_str;
1725         prs_struct data;
1726         prs_struct rdata;
1727
1728         SAMR_Q_OPEN_DOMAIN q_o;
1729         BOOL valid_pol = False;
1730
1731         if (DEBUGLEVEL >= 4)
1732         {
1733                 sid_to_string(sid_str, sid);
1734                 DEBUG(4,("SAMR Open Domain.  SID:%s Permissions:%x\n",
1735                                         sid_str, ace_perms));
1736         }
1737
1738         if (connect_pol == NULL || sid == NULL || domain_pol == NULL) return False;
1739
1740         /* create and send a MSRPC command with api SAMR_OPEN_DOMAIN */
1741
1742         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1743         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1744
1745         /* store the parameters */
1746         make_samr_q_open_domain(&q_o, connect_pol, ace_perms, sid);
1747
1748         /* turn parameters into data stream */
1749         samr_io_q_open_domain("", &q_o,  &data, 0);
1750
1751         /* send the data on \PIPE\ */
1752         if (rpc_api_pipe_req(cli, fnum, SAMR_OPEN_DOMAIN, &data, &rdata))
1753         {
1754                 SAMR_R_OPEN_DOMAIN r_o;
1755                 BOOL p;
1756
1757                 samr_io_r_open_domain("", &r_o, &rdata, 0);
1758                 p = rdata.offset != 0;
1759
1760                 if (p && r_o.status != 0)
1761                 {
1762                         /* report error code */
1763                         DEBUG(4,("SAMR_R_OPEN_DOMAIN: %s\n", get_nt_error_msg(r_o.status)));
1764                         p = False;
1765                 }
1766
1767                 if (p)
1768                 {
1769                         memcpy(domain_pol, &r_o.domain_pol, sizeof(r_o.domain_pol));
1770                         valid_pol = True;
1771                 }
1772         }
1773
1774         prs_mem_free(&data   );
1775         prs_mem_free(&rdata  );
1776
1777         return valid_pol;
1778 }
1779
1780 /****************************************************************************
1781 do a SAMR Query Lookup Domain
1782 ****************************************************************************/
1783 BOOL samr_query_lookup_domain(struct cli_state *cli, uint16 fnum,
1784                               POLICY_HND *pol, const char *dom_name,
1785                               DOM_SID *dom_sid)
1786 {
1787         prs_struct data;
1788         prs_struct rdata;
1789
1790         SAMR_Q_LOOKUP_DOMAIN q_o;
1791         BOOL valid_query = False;
1792
1793         if (pol == NULL || dom_name == NULL || dom_sid == NULL) return False;
1794
1795         /* create and send a MSRPC command with api SAMR_LOOKUP_DOMAIN */
1796
1797         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1798         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1799
1800         DEBUG(4,("SAMR Query Lookup Domain.\n"));
1801
1802         /* store the parameters */
1803         make_samr_q_lookup_domain(&q_o, pol, dom_name);
1804
1805         /* turn parameters into data stream */
1806         samr_io_q_lookup_domain("", &q_o, &data, 0);
1807
1808         /* send the data on \PIPE\ */
1809         if (rpc_api_pipe_req(cli, fnum, SAMR_LOOKUP_DOMAIN, &data, &rdata))
1810         {
1811                 SAMR_R_LOOKUP_DOMAIN r_o;
1812                 BOOL p;
1813
1814                 samr_io_r_lookup_domain("", &r_o, &rdata, 0);
1815                 p = rdata.offset != 0;
1816
1817                 if (p && r_o.status != 0)
1818                 {
1819                         /* report error code */
1820                         DEBUG(4,("SAMR_R_LOOKUP_DOMAIN: %s\n", get_nt_error_msg(r_o.status)));
1821                         p = False;
1822                 }
1823
1824                 if (p && r_o.ptr_sid != 0)
1825                 {
1826                         sid_copy(dom_sid, &r_o.dom_sid.sid);
1827                         valid_query = True;
1828                 }
1829         }
1830
1831         prs_mem_free(&data   );
1832         prs_mem_free(&rdata  );
1833
1834         return valid_query;
1835 }
1836
1837 /****************************************************************************
1838 do a SAMR Query Lookup Names
1839 ****************************************************************************/
1840 BOOL samr_query_lookup_names(struct cli_state *cli, uint16 fnum,
1841                                 POLICY_HND *pol, uint32 flags,
1842                                 uint32 num_names, char **names,
1843                                 uint32 *num_rids,
1844                                 uint32 rid[MAX_LOOKUP_SIDS],
1845                                 uint32 type[MAX_LOOKUP_SIDS])
1846 {
1847         prs_struct data;
1848         prs_struct rdata;
1849
1850         SAMR_Q_LOOKUP_NAMES q_o;
1851         BOOL valid_query = False;
1852
1853         if (pol == NULL || flags == 0 || num_names == 0 || names == NULL ||
1854             num_rids == NULL || rid == NULL || type == NULL ) return False;
1855
1856         /* create and send a MSRPC command with api SAMR_LOOKUP_NAMES */
1857
1858         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1859         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1860
1861         DEBUG(4,("SAMR Query Lookup NAMES.\n"));
1862
1863         /* store the parameters */
1864         make_samr_q_lookup_names(&q_o, pol, flags, num_names, names);
1865
1866         /* turn parameters into data stream */
1867         samr_io_q_lookup_names("", &q_o, &data, 0);
1868
1869         /* send the data on \PIPE\ */
1870         if (rpc_api_pipe_req(cli, fnum, SAMR_LOOKUP_NAMES, &data, &rdata))
1871         {
1872                 SAMR_R_LOOKUP_NAMES r_o;
1873                 BOOL p;
1874
1875                 samr_io_r_lookup_names("", &r_o, &rdata, 0);
1876                 p = rdata.offset != 0;
1877
1878                 if (p && r_o.status != 0)
1879                 {
1880                         /* report error code */
1881                         DEBUG(4,("SAMR_R_LOOKUP_NAMES: %s\n", get_nt_error_msg(r_o.status)));
1882                         p = False;
1883                 }
1884
1885                 if (p)
1886                 {
1887                         if (r_o.ptr_rids != 0 && r_o.ptr_types != 0 &&
1888                             r_o.num_types1 == r_o.num_rids1)
1889                         {
1890                                 int i;
1891
1892                                 valid_query = True;
1893                                 *num_rids = r_o.num_rids1;
1894
1895                                 for (i = 0; i < r_o.num_rids1; i++)
1896                                 {
1897                                         rid[i] = r_o.rid[i];
1898                                 }
1899                                 for (i = 0; i < r_o.num_types1; i++)
1900                                 {
1901                                         type[i] = r_o.type[i];
1902                                 }
1903                         }
1904                         else if (r_o.ptr_rids == 0 && r_o.ptr_types == 0)
1905                         {
1906                                 valid_query = True;
1907                                 *num_rids = 0;
1908                         }
1909                         else
1910                         {
1911                                 p = False;
1912                         }
1913                 }
1914         }
1915
1916         prs_mem_free(&data   );
1917         prs_mem_free(&rdata  );
1918
1919         return valid_query;
1920 }
1921
1922 /****************************************************************************
1923 do a SAMR Query Lookup RIDS
1924 ****************************************************************************/
1925 BOOL samr_query_lookup_rids(struct cli_state *cli, uint16 fnum,
1926                                 POLICY_HND *pol, uint32 flags,
1927                                 uint32 num_rids, uint32 *rids,
1928                                 uint32 *num_names,
1929                                 char   ***names,
1930                                 uint32 **type)
1931 {
1932         prs_struct data;
1933         prs_struct rdata;
1934
1935         SAMR_Q_LOOKUP_RIDS q_o;
1936         BOOL valid_query = False;
1937
1938         if (pol == NULL || flags == 0 || num_rids == 0 || rids == NULL ||
1939             num_names == NULL || names == NULL || type == NULL ) return False;
1940
1941         /* create and send a MSRPC command with api SAMR_LOOKUP_RIDS */
1942
1943         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
1944         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
1945
1946         DEBUG(4,("SAMR Query Lookup RIDs.\n"));
1947
1948         /* store the parameters */
1949         make_samr_q_lookup_rids(&q_o, pol, flags, num_rids, rids);
1950
1951         /* turn parameters into data stream */
1952         samr_io_q_lookup_rids("", &q_o,  &data, 0);
1953
1954         /* send the data on \PIPE\ */
1955         if (rpc_api_pipe_req(cli, fnum, SAMR_LOOKUP_RIDS, &data, &rdata))
1956         {
1957                 SAMR_R_LOOKUP_RIDS r_o;
1958                 BOOL p;
1959                 ZERO_STRUCT(r_o);
1960
1961                 samr_io_r_lookup_rids("", &r_o, &rdata, 0);
1962                 p = rdata.offset != 0;
1963
1964                 if (p && r_o.status != 0)
1965                 {
1966                         /* report error code */
1967                         DEBUG(4,("SAMR_R_LOOKUP_RIDS: %s\n", get_nt_error_msg(r_o.status)));
1968                         p = False;
1969                 }
1970
1971                 if (p)
1972                 {
1973                         if (r_o.ptr_names != 0 && r_o.ptr_types != 0 &&
1974                             r_o.num_types1 == r_o.num_names1)
1975                         {
1976                                 int i;
1977
1978                                 valid_query = True;
1979                                 *num_names = r_o.num_names1;
1980
1981                                 (*names) = malloc((*num_names) * sizeof(**names));
1982                                 for (i = 0; (*names) != NULL && i < r_o.num_names1; i++)
1983                                 {
1984                                         fstring tmp;
1985                                         unistr2_to_ascii(tmp, &r_o.uni_name[i], sizeof(tmp)-1);
1986                                         (*names)[i] = strdup(tmp);
1987                                 }
1988
1989                                 (*type) = malloc((*num_names) * sizeof(**type));
1990                                 for (i = 0; (*type) != NULL && i < r_o.num_types1; i++)
1991                                 {
1992                                         (*type)[i] = r_o.type[i];
1993                                 }
1994                         }
1995                         else if (r_o.ptr_names == 0 && r_o.ptr_types == 0)
1996                         {
1997                                 valid_query = True;
1998                                 *num_names = 0;
1999                                 *names = NULL;
2000                                 *type = NULL;
2001                         }
2002                         else
2003                         {
2004                                 p = False;
2005                         }
2006                 }
2007
2008                 samr_free_r_lookup_rids(&r_o);
2009         }
2010
2011         prs_mem_free(&data   );
2012         prs_mem_free(&rdata  );
2013
2014         return valid_query;
2015 }
2016
2017 /****************************************************************************
2018 do a SAMR Query Alias Members
2019 ****************************************************************************/
2020 BOOL samr_query_aliasmem(struct cli_state *cli, uint16 fnum,
2021                                 POLICY_HND *alias_pol,
2022                                 uint32 *num_mem, DOM_SID2 *sid)
2023 {
2024         prs_struct data;
2025         prs_struct rdata;
2026
2027         SAMR_Q_QUERY_ALIASMEM q_o;
2028         BOOL valid_query = False;
2029
2030         DEBUG(4,("SAMR Query Alias Members.\n"));
2031
2032         if (alias_pol == NULL || sid == NULL || num_mem == NULL) return False;
2033
2034         /* create and send a MSRPC command with api SAMR_QUERY_ALIASMEM */
2035
2036         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2037         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2038
2039         /* store the parameters */
2040         make_samr_q_query_aliasmem(&q_o, alias_pol);
2041
2042         /* turn parameters into data stream */
2043         samr_io_q_query_aliasmem("", &q_o,  &data, 0);
2044
2045         /* send the data on \PIPE\ */
2046         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_ALIASMEM, &data, &rdata))
2047         {
2048                 SAMR_R_QUERY_ALIASMEM r_o;
2049                 BOOL p;
2050
2051                 /* get user info */
2052                 r_o.sid = sid;
2053
2054                 samr_io_r_query_aliasmem("", &r_o, &rdata, 0);
2055                 p = rdata.offset != 0;
2056
2057                 if (p && r_o.status != 0)
2058                 {
2059                         /* report error code */
2060                         DEBUG(4,("SAMR_R_QUERY_ALIASMEM: %s\n", get_nt_error_msg(r_o.status)));
2061                         p = False;
2062                 }
2063
2064                 if (p && r_o.ptr != 0)
2065                 {
2066                         valid_query = True;
2067                         *num_mem = r_o.num_sids;
2068                 }
2069
2070         }
2071
2072         prs_mem_free(&data   );
2073         prs_mem_free(&rdata  );
2074
2075         return valid_query;
2076 }
2077
2078 /****************************************************************************
2079 do a SAMR Query User Aliases
2080 ****************************************************************************/
2081 BOOL samr_query_useraliases(struct cli_state *cli, uint16 fnum,
2082                                 POLICY_HND *pol, uint32 *ptr_sid, DOM_SID2 *sid,
2083                                 uint32 *num_aliases, uint32 **rid)
2084 {
2085         prs_struct data;
2086         prs_struct rdata;
2087
2088         SAMR_Q_QUERY_USERALIASES q_o;
2089         BOOL valid_query = False;
2090         ZERO_STRUCT(q_o);
2091
2092         DEBUG(4,("SAMR Query User Aliases.\n"));
2093
2094         if (pol == NULL || sid == NULL || rid == NULL || num_aliases == 0) return False;
2095
2096         /* create and send a MSRPC command with api SAMR_QUERY_USERALIASES */
2097
2098         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2099         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2100
2101         /* store the parameters */
2102         make_samr_q_query_useraliases(&q_o, pol, ptr_sid, sid);
2103
2104         /* turn parameters into data stream */
2105         samr_io_q_query_useraliases("", &q_o,  &data, 0);
2106
2107         /* send the data on \PIPE\ */
2108         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_USERALIASES, &data, &rdata))
2109         {
2110                 SAMR_R_QUERY_USERALIASES r_o;
2111                 BOOL p;
2112
2113                 r_o.rid = NULL;
2114
2115                 samr_io_r_query_useraliases("", &r_o, &rdata, 0);
2116                 *rid = r_o.rid;
2117                 p = rdata.offset != 0;
2118
2119                 if (p && r_o.status != 0)
2120                 {
2121                         /* report error code */
2122                         DEBUG(4,("SAMR_R_QUERY_USERALIASES: %s\n", get_nt_error_msg(r_o.status)));
2123                         p = False;
2124                 }
2125
2126                 if (p && r_o.ptr != 0)
2127                 {
2128                         valid_query = True;
2129                         *num_aliases = r_o.num_entries;
2130                 }
2131
2132         }
2133
2134         prs_mem_free(&data   );
2135         prs_mem_free(&rdata  );
2136
2137         return valid_query;
2138 }
2139
2140 /****************************************************************************
2141 do a SAMR Query Group Members
2142 ****************************************************************************/
2143 BOOL samr_query_groupmem(struct cli_state *cli, uint16 fnum,
2144                                 POLICY_HND *group_pol,
2145                                 uint32 *num_mem, uint32 **rid, uint32 **attr)
2146 {
2147         prs_struct data;
2148         prs_struct rdata;
2149
2150         SAMR_Q_QUERY_GROUPMEM q_o;
2151         BOOL valid_query = False;
2152
2153         DEBUG(4,("SAMR Query Group Members.\n"));
2154
2155         if (group_pol == NULL || rid == NULL || attr == NULL || num_mem == NULL) return False;
2156
2157         /* create and send a MSRPC command with api SAMR_QUERY_GROUPMEM */
2158
2159         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2160         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2161
2162         /* store the parameters */
2163         make_samr_q_query_groupmem(&q_o, group_pol);
2164
2165         /* turn parameters into data stream */
2166         samr_io_q_query_groupmem("", &q_o,  &data, 0);
2167
2168         /* send the data on \PIPE\ */
2169         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_GROUPMEM, &data, &rdata))
2170         {
2171                 SAMR_R_QUERY_GROUPMEM r_o;
2172                 BOOL p;
2173
2174                 r_o.rid  = NULL;
2175                 r_o.attr = NULL;
2176
2177                 samr_io_r_query_groupmem("", &r_o, &rdata, 0);
2178                 *rid  = r_o.rid ;
2179                 *attr = r_o.attr;
2180                 p = rdata.offset != 0;
2181
2182                 if (p && r_o.status != 0)
2183                 {
2184                         /* report error code */
2185                         DEBUG(4,("SAMR_R_QUERY_GROUPMEM: %s\n", get_nt_error_msg(r_o.status)));
2186                         p = False;
2187                 }
2188
2189                 if (p && r_o.ptr != 0 &&
2190                     r_o.ptr_rids != 0 && r_o.ptr_attrs != 0 &&
2191                     r_o.num_rids == r_o.num_attrs)
2192                 {
2193                         valid_query = True;
2194                         *num_mem = r_o.num_rids;
2195                 }
2196
2197         }
2198
2199         prs_mem_free(&data   );
2200         prs_mem_free(&rdata  );
2201
2202         return valid_query;
2203 }
2204
2205 /****************************************************************************
2206 do a SAMR Query User Groups
2207 ****************************************************************************/
2208 BOOL samr_query_usergroups(struct cli_state *cli, uint16 fnum,
2209                                 POLICY_HND *pol, uint32 *num_groups,
2210                                 DOM_GID **gid)
2211 {
2212         prs_struct data;
2213         prs_struct rdata;
2214
2215         SAMR_Q_QUERY_USERGROUPS q_o;
2216         BOOL valid_query = False;
2217
2218         DEBUG(4,("SAMR Query User Groups.\n"));
2219
2220         if (pol == NULL || gid == NULL || num_groups == 0) return False;
2221
2222         /* create and send a MSRPC command with api SAMR_QUERY_USERGROUPS */
2223
2224         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2225         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2226
2227         /* store the parameters */
2228         make_samr_q_query_usergroups(&q_o, pol);
2229
2230         /* turn parameters into data stream */
2231         samr_io_q_query_usergroups("", &q_o,  &data, 0);
2232
2233         /* send the data on \PIPE\ */
2234         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_USERGROUPS, &data, &rdata))
2235         {
2236                 SAMR_R_QUERY_USERGROUPS r_o;
2237                 BOOL p;
2238
2239                 /* get user info */
2240                 r_o.gid = NULL;
2241
2242                 samr_io_r_query_usergroups("", &r_o, &rdata, 0);
2243                 *gid = r_o.gid;
2244                 p = rdata.offset != 0;
2245
2246                 if (p && r_o.status != 0)
2247                 {
2248                         /* report error code */
2249                         DEBUG(4,("SAMR_R_QUERY_USERGROUPS: %s\n", get_nt_error_msg(r_o.status)));
2250                         p = False;
2251                 }
2252
2253                 if (p && r_o.ptr_0 != 0)
2254                 {
2255                         valid_query = True;
2256                         *num_groups = r_o.num_entries;
2257                 }
2258
2259         }
2260
2261         prs_mem_free(&data   );
2262         prs_mem_free(&rdata  );
2263
2264         return valid_query;
2265 }
2266
2267 /****************************************************************************
2268 do a SAMR Query Group Info
2269 ****************************************************************************/
2270 BOOL samr_query_groupinfo(struct cli_state *cli, uint16 fnum,
2271                                 POLICY_HND *pol,
2272                                 uint16 switch_value, GROUP_INFO_CTR* ctr)
2273 {
2274         prs_struct data;
2275         prs_struct rdata;
2276
2277         SAMR_Q_QUERY_GROUPINFO q_o;
2278         BOOL valid_query = False;
2279
2280         DEBUG(4,("SAMR Query Group Info.  level: %d\n", switch_value));
2281
2282         if (pol == NULL || ctr == NULL || switch_value == 0) return False;
2283
2284         /* create and send a MSRPC command with api SAMR_QUERY_GROUPINFO */
2285
2286         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2287         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2288
2289         /* store the parameters */
2290         make_samr_q_query_groupinfo(&q_o, pol, switch_value);
2291
2292         /* turn parameters into data stream */
2293         samr_io_q_query_groupinfo("", &q_o,  &data, 0);
2294
2295         /* send the data on \PIPE\ */
2296         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_GROUPINFO, &data, &rdata))
2297         {
2298                 SAMR_R_QUERY_GROUPINFO r_o;
2299                 BOOL p;
2300
2301                 /* get user info */
2302                 r_o.ctr = ctr;
2303
2304                 samr_io_r_query_groupinfo("", &r_o, &rdata, 0);
2305                 p = rdata.offset != 0;
2306
2307                 if (p && r_o.status != 0)
2308                 {
2309                         /* report error code */
2310                         DEBUG(4,("SAMR_R_QUERY_GROUPINFO: %s\n", get_nt_error_msg(r_o.status)));
2311                         p = False;
2312                 }
2313
2314                 if (p && r_o.ctr->switch_value1 != switch_value)
2315                 {
2316                         DEBUG(4,("SAMR_R_QUERY_GROUPINFO: received incorrect level %d\n",
2317                                   r_o.ctr->switch_value1));
2318                 }
2319
2320                 if (p && r_o.ptr != 0)
2321                 {
2322                         valid_query = True;
2323                 }
2324         }
2325
2326         prs_mem_free(&data   );
2327         prs_mem_free(&rdata  );
2328
2329         return valid_query;
2330 }
2331
2332 /****************************************************************************
2333 do a SAMR Query User Info
2334 ****************************************************************************/
2335 BOOL samr_query_userinfo(struct cli_state *cli, uint16 fnum,
2336                                 POLICY_HND *pol, uint16 switch_value, void* usr)
2337 {
2338         prs_struct data;
2339         prs_struct rdata;
2340
2341         SAMR_Q_QUERY_USERINFO q_o;
2342         BOOL valid_query = False;
2343
2344         DEBUG(4,("SAMR Query User Info.  level: %d\n", switch_value));
2345
2346         if (pol == NULL || usr == NULL || switch_value == 0) return False;
2347
2348         /* create and send a MSRPC command with api SAMR_QUERY_USERINFO */
2349
2350         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2351         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2352
2353         /* store the parameters */
2354         make_samr_q_query_userinfo(&q_o, pol, switch_value);
2355
2356         /* turn parameters into data stream */
2357         samr_io_q_query_userinfo("", &q_o,  &data, 0);
2358
2359         /* send the data on \PIPE\ */
2360         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_USERINFO, &data, &rdata))
2361         {
2362                 SAMR_R_QUERY_USERINFO r_o;
2363                 BOOL p;
2364
2365                 /* get user info */
2366                 r_o.info.id = usr;
2367
2368                 samr_io_r_query_userinfo("", &r_o, &rdata, 0);
2369                 p = rdata.offset != 0;
2370
2371                 if (p && r_o.status != 0)
2372                 {
2373                         /* report error code */
2374                         DEBUG(4,("SAMR_R_QUERY_USERINFO: %s\n", get_nt_error_msg(r_o.status)));
2375                         p = False;
2376                 }
2377
2378                 if (p && r_o.switch_value != switch_value)
2379                 {
2380                         DEBUG(4,("SAMR_R_QUERY_USERINFO: received incorrect level %d\n",
2381                                   r_o.switch_value));
2382                 }
2383
2384                 if (p && r_o.ptr != 0)
2385                 {
2386                         valid_query = True;
2387                 }
2388         }
2389
2390         prs_mem_free(&data   );
2391         prs_mem_free(&rdata  );
2392
2393         return valid_query;
2394 }
2395
2396 /****************************************************************************
2397 do a SAMR Close
2398 ****************************************************************************/
2399 BOOL samr_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd)
2400 {
2401         prs_struct data;
2402         prs_struct rdata;
2403
2404         SAMR_Q_CLOSE_HND q_c;
2405         BOOL valid_close = False;
2406
2407         DEBUG(4,("SAMR Close\n"));
2408
2409         if (hnd == NULL) return False;
2410
2411         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2412         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2413
2414         /* create and send a MSRPC command with api SAMR_CLOSE_HND */
2415
2416         /* store the parameters */
2417         make_samr_q_close_hnd(&q_c, hnd);
2418
2419         /* turn parameters into data stream */
2420         samr_io_q_close_hnd("", &q_c,  &data, 0);
2421
2422         /* send the data on \PIPE\ */
2423         if (rpc_api_pipe_req(cli, fnum, SAMR_CLOSE_HND, &data, &rdata))
2424         {
2425                 SAMR_R_CLOSE_HND r_c;
2426                 BOOL p;
2427
2428                 samr_io_r_close_hnd("", &r_c, &rdata, 0);
2429                 p = rdata.offset != 0;
2430
2431                 if (p && r_c.status != 0)
2432                 {
2433                         /* report error code */
2434                         DEBUG(4,("SAMR_CLOSE_HND: %s\n", get_nt_error_msg(r_c.status)));
2435                         p = False;
2436                 }
2437
2438                 if (p)
2439                 {
2440                         /* check that the returned policy handle is all zeros */
2441                         int i;
2442                         valid_close = True;
2443
2444                         for (i = 0; i < sizeof(r_c.pol.data); i++)
2445                         {
2446                                 if (r_c.pol.data[i] != 0)
2447                                 {
2448                                         valid_close = False;
2449                                         break;
2450                                 }
2451                         }
2452                         if (!valid_close)
2453                         {
2454                                 DEBUG(4,("SAMR_CLOSE_HND: non-zero handle returned\n"));
2455                         }
2456                 }
2457         }
2458
2459         prs_mem_free(&data   );
2460         prs_mem_free(&rdata  );
2461
2462         return valid_close;
2463 }
2464
2465 /****************************************************************************
2466 do a SAMR query display info
2467 ****************************************************************************/
2468 BOOL samr_query_dispinfo(struct cli_state *cli, uint16 fnum,
2469                                 POLICY_HND *pol_open_domain, uint16 level,
2470                                 uint32 *num_entries,
2471                                 SAM_DISPINFO_CTR *ctr)
2472 {
2473         prs_struct data;
2474         prs_struct rdata;
2475
2476         SAMR_Q_QUERY_DISPINFO q_o;
2477         BOOL valid_query = False;
2478
2479         DEBUG(4,("SAMR Query Display Info.  level: %d\n", level));
2480
2481         if (pol_open_domain == NULL || num_entries == NULL || ctr == NULL ||
2482             level == 0)
2483         {
2484                 return False;
2485         }
2486
2487         /* create and send a MSRPC command with api SAMR_QUERY_DISPINFO */
2488
2489         prs_init(&data , 1024, 4, SAFETY_MARGIN, False);
2490         prs_init(&rdata, 0   , 4, SAFETY_MARGIN, True );
2491
2492         /* store the parameters */
2493         make_samr_q_query_dispinfo(&q_o, pol_open_domain, level, 0, 0xffffffff);
2494
2495         /* turn parameters into data stream */
2496         samr_io_q_query_dispinfo("", &q_o,  &data, 0);
2497
2498         /* send the data on \PIPE\ */
2499         if (rpc_api_pipe_req(cli, fnum, SAMR_QUERY_DISPINFO, &data, &rdata))
2500         {
2501                 SAMR_R_QUERY_DISPINFO r_o;
2502                 BOOL p;
2503
2504                 /* get user info */
2505                 r_o.ctr = ctr;
2506
2507                 samr_io_r_query_dispinfo("", &r_o, &rdata, 0);
2508                 p = rdata.offset != 0;
2509
2510                 if (p && r_o.status != 0)
2511                 {
2512                         /* report error code */
2513                         DEBUG(4,("SAMR_R_QUERY_DISPINFO: %s\n", get_nt_error_msg(r_o.status)));
2514                         p = False;
2515                 }
2516
2517                 if (p && r_o.switch_level != level)
2518                 {
2519                         DEBUG(4,("SAMR_R_QUERY_DISPINFO: received incorrect level %d\n",
2520                                   r_o.switch_level));
2521                 }
2522
2523                 if (p && r_o.ptr_entries != 0)
2524                 {
2525                         valid_query = True;
2526                 }
2527         }
2528
2529         prs_mem_free(&data   );
2530         prs_mem_free(&rdata  );
2531
2532         return valid_query;
2533 }
2534