source3/rpc_parse/parse_lsa.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1997,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   7  *  Copyright (C) Paul Ashton                       1997.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include "includes.h"
  25
  26 extern int DEBUGLEVEL;
  27
  28 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn, prs_struct *ps, int depth);
  29
  30 /*******************************************************************
  31  Inits a LSA_TRANS_NAME structure.
  32 ********************************************************************/
  33
  34 void init_lsa_trans_name(LSA_TRANS_NAME *trn, UNISTR2 *uni_name,
  35                         uint16 sid_name_use, char *name, uint32 idx)
  36 {
  37         int len_name = strlen(name);
  38
  39         if(len_name == 0)
  40                 len_name = 1;
  41
  42         trn->sid_name_use = sid_name_use;
  43         init_uni_hdr(&trn->hdr_name, len_name);
  44         init_unistr2(uni_name, name, len_name);
  45         trn->domain_idx = idx;
  46 }
  47
  48 /*******************************************************************
  49  Reads or writes a LSA_TRANS_NAME structure.
  50 ********************************************************************/
  51
  52 static BOOL lsa_io_trans_name(char *desc, LSA_TRANS_NAME *trn, prs_struct *ps, int depth)
  53 {
  54         if (trn == NULL)
  55                 return False;
  56
  57         prs_debug(ps, depth, desc, "lsa_io_trans_name");
  58         depth++;
  59
  60         if(!prs_align(ps))
  61                 return False;
  62
  63         if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
  64                 return False;
  65         if(!prs_align(ps))
  66                 return False;
  67
  68         if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
  69                 return False;
  70         if(!prs_uint32("domain_idx  ", ps, depth, &trn->domain_idx))
  71                 return False;
  72
  73         return True;
  74 }
  75
  76 /*******************************************************************
  77  Reads or writes a DOM_R_REF structure.
  78 ********************************************************************/
  79
  80 static BOOL lsa_io_dom_r_ref(char *desc, DOM_R_REF *r_r, prs_struct *ps, int depth)
  81 {
  82         int i;
  83
  84         prs_debug(ps, depth, desc, "lsa_io_dom_r_ref");
  85         depth++;
  86
  87         if (r_r == NULL)
  88                 return False;
  89
  90         if(!prs_align(ps))
  91                 return False;
  92
  93         if(!prs_uint32("num_ref_doms_1", ps, depth, &r_r->num_ref_doms_1)) /* num referenced domains? */
  94                 return False;
  95         if(!prs_uint32("ptr_ref_dom   ", ps, depth, &r_r->ptr_ref_dom)) /* undocumented buffer pointer. */
  96                 return False;
  97         if(!prs_uint32("max_entries   ", ps, depth, &r_r->max_entries)) /* 32 - max number of entries */
  98                 return False;
  99
 100         SMB_ASSERT_ARRAY(r_r->hdr_ref_dom, r_r->num_ref_doms_1);
 101
 102         if (r_r->ptr_ref_dom != 0) {
 103
 104                 if(!prs_uint32("num_ref_doms_2", ps, depth, &r_r->num_ref_doms_2)) /* 4 - num referenced domains? */
 105                         return False;
 106
 107                 SMB_ASSERT_ARRAY(r_r->ref_dom, r_r->num_ref_doms_2);
 108
 109                 for (i = 0; i < r_r->num_ref_doms_1; i++) {
 110                         fstring t;
 111
 112                         slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 113                         if(!smb_io_unihdr(t, &r_r->hdr_ref_dom[i].hdr_dom_name, ps, depth))
 114                                 return False;
 115
 116                         slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 117                         if(!prs_uint32(t, ps, depth, &r_r->hdr_ref_dom[i].ptr_dom_sid))
 118                                 return False;
 119                 }
 120
 121                 for (i = 0; i < r_r->num_ref_doms_2; i++) {
 122                         fstring t;
 123
 124                         if (r_r->hdr_ref_dom[i].hdr_dom_name.buffer != 0) {
 125                                 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 126                                 if(!smb_io_unistr2(t, &r_r->ref_dom[i].uni_dom_name, True, ps, depth)) /* domain name unicode string */
 127                                         return False;
 128                                 if(!prs_align(ps))
 129                                         return False;
 130                         }
 131
 132                         if (r_r->hdr_ref_dom[i].ptr_dom_sid != 0) {
 133                                 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 134                                 if(!smb_io_dom_sid2(t, &r_r->ref_dom[i].ref_dom, ps, depth)) /* referenced domain SIDs */
 135                                         return False;
 136                         }
 137                 }
 138         }
 139
 140         return True;
 141 }
 142
 143 /*******************************************************************
 144  Inits an LSA_SEC_QOS structure.
 145 ********************************************************************/
 146
 147 void init_lsa_sec_qos(LSA_SEC_QOS *qos, uint16 imp_lev, uint8 ctxt, uint8 eff,
 148                                 uint32 unknown)
 149 {
 150         DEBUG(5,("init_lsa_sec_qos\n"));
 151
 152         qos->len = 0x0c; /* length of quality of service block, in bytes */
 153         qos->sec_imp_level = imp_lev;
 154         qos->sec_ctxt_mode = ctxt;
 155         qos->effective_only = eff;
 156         qos->unknown = unknown;
 157 }
 158
 159 /*******************************************************************
 160  Reads or writes an LSA_SEC_QOS structure.
 161 ********************************************************************/
 162
 163 static BOOL lsa_io_sec_qos(char *desc,  LSA_SEC_QOS *qos, prs_struct *ps, int depth)
 164 {
 165         uint32 start;
 166
 167         if (qos == NULL)
 168                 return False;
 169
 170         prs_debug(ps, depth, desc, "lsa_io_obj_qos");
 171         depth++;
 172
 173         if(!prs_align(ps))
 174                 return False;
 175
 176         start = prs_offset(ps);
 177
 178         /* these pointers had _better_ be zero, because we don't know
 179            what they point to!
 180          */
 181         if(!prs_uint32("len           ", ps, depth, &qos->len)) /* 0x18 - length (in bytes) inc. the length field. */
 182                 return False;
 183         if(!prs_uint16("sec_imp_level ", ps, depth, &qos->sec_imp_level ))
 184                 return False;
 185         if(!prs_uint8 ("sec_ctxt_mode ", ps, depth, &qos->sec_ctxt_mode ))
 186                 return False;
 187         if(!prs_uint8 ("effective_only", ps, depth, &qos->effective_only))
 188                 return False;
 189         if(!prs_uint32("unknown       ", ps, depth, &qos->unknown))
 190                 return False;
 191
 192         if (qos->len != prs_offset(ps) - start) {
 193                 DEBUG(3,("lsa_io_sec_qos: length %x does not match size %x\n",
 194                          qos->len, prs_offset(ps) - start));
 195                 return False;
 196         }
 197
 198         return True;
 199 }
 200
 201
 202 /*******************************************************************
 203  Inits an LSA_OBJ_ATTR structure.
 204 ********************************************************************/
 205
 206 void init_lsa_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, LSA_SEC_QOS *qos)
 207 {
 208         DEBUG(5,("make_lsa_obj_attr\n"));
 209
 210         attr->len = 0x18; /* length of object attribute block, in bytes */
 211         attr->ptr_root_dir = 0;
 212         attr->ptr_obj_name = 0;
 213         attr->attributes = attributes;
 214         attr->ptr_sec_desc = 0;
 215
 216         if (qos != NULL) {
 217                 attr->ptr_sec_qos = 1;
 218                 attr->sec_qos = qos;
 219         } else {
 220                 attr->ptr_sec_qos = 0;
 221                 attr->sec_qos = NULL;
 222         }
 223 }
 224
 225 /*******************************************************************
 226  Reads or writes an LSA_OBJ_ATTR structure.
 227 ********************************************************************/
 228
 229 static BOOL lsa_io_obj_attr(char *desc, LSA_OBJ_ATTR *attr, prs_struct *ps, int depth)
 230 {
 231         uint32 start;
 232
 233         if (attr == NULL)
 234                 return False;
 235
 236         prs_debug(ps, depth, desc, "lsa_io_obj_attr");
 237         depth++;
 238
 239         if(!prs_align(ps))
 240                 return False;
 241
 242         start = prs_offset(ps);
 243
 244         /* these pointers had _better_ be zero, because we don't know
 245            what they point to!
 246          */
 247         if(!prs_uint32("len         ", ps, depth, &attr->len)) /* 0x18 - length (in bytes) inc. the length field. */
 248                 return False;
 249         if(!prs_uint32("ptr_root_dir", ps, depth, &attr->ptr_root_dir)) /* 0 - root directory (pointer) */
 250                 return False;
 251         if(!prs_uint32("ptr_obj_name", ps, depth, &attr->ptr_obj_name)) /* 0 - object name (pointer) */
 252                 return False;
 253         if(!prs_uint32("attributes  ", ps, depth, &attr->attributes)) /* 0 - attributes (undocumented) */
 254                 return False;
 255         if(!prs_uint32("ptr_sec_desc", ps, depth, &attr->ptr_sec_desc)) /* 0 - security descriptior (pointer) */
 256                 return False;
 257         if(!prs_uint32("ptr_sec_qos ", ps, depth, &attr->ptr_sec_qos )) /* security quality of service (pointer) */
 258                 return False;
 259
 260         if (attr->len != prs_offset(ps) - start) {
 261                 DEBUG(3,("lsa_io_obj_attr: length %x does not match size %x\n",
 262                          attr->len, prs_offset(ps) - start));
 263                 return False;
 264         }
 265
 266         if (attr->ptr_sec_qos != 0 && attr->sec_qos != NULL) {
 267                 if(!lsa_io_sec_qos("sec_qos", attr->sec_qos, ps, depth))
 268                         return False;
 269         }
 270
 271         return True;
 272 }
 273
 274
 275 /*******************************************************************
 276  Inits an LSA_Q_OPEN_POL structure.
 277 ********************************************************************/
 278
 279 void init_q_open_pol(LSA_Q_OPEN_POL *r_q, uint16 system_name,
 280                         uint32 attributes,
 281                         uint32 desired_access,
 282                         LSA_SEC_QOS *qos)
 283 {
 284         DEBUG(5,("make_open_pol: attr:%d da:%d\n", attributes, desired_access));
 285
 286         r_q->ptr = 1; /* undocumented pointer */
 287
 288         if (qos == NULL)
 289                 r_q->des_access = desired_access;
 290
 291         r_q->system_name = system_name;
 292         init_lsa_obj_attr(&r_q->attr, attributes, qos);
 293 }
 294
 295 /*******************************************************************
 296  Reads or writes an LSA_Q_OPEN_POL structure.
 297 ********************************************************************/
 298
 299 BOOL lsa_io_q_open_pol(char *desc, LSA_Q_OPEN_POL *r_q, prs_struct *ps, int depth)
 300 {
 301         if (r_q == NULL)
 302                 return False;
 303
 304         prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
 305         depth++;
 306
 307         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
 308                 return False;
 309         if(!prs_uint16("system_name", ps, depth, &r_q->system_name))
 310                 return False;
 311         if(!prs_align( ps ))
 312                 return False;
 313
 314         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
 315                 return False;
 316
 317         if (r_q->attr.ptr_sec_qos == 0) {
 318                 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
 319                         return False;
 320         }
 321
 322         return True;
 323 }
 324
 325 /*******************************************************************
 326  Reads or writes an LSA_R_OPEN_POL structure.
 327 ********************************************************************/
 328
 329 BOOL lsa_io_r_open_pol(char *desc, LSA_R_OPEN_POL *r_p, prs_struct *ps, int depth)
 330 {
 331         if (r_p == NULL)
 332                 return False;
 333
 334         prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
 335         depth++;
 336
 337         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
 338                 return False;
 339
 340         if(!prs_uint32("status", ps, depth, &r_p->status))
 341                 return False;
 342
 343         return True;
 344 }
 345
 346 /*******************************************************************
 347  Inits an LSA_Q_OPEN_POL2 structure.
 348 ********************************************************************/
 349
 350 void init_q_open_pol2(LSA_Q_OPEN_POL2 *r_q, char *server_name,
 351                         uint32 attributes,
 352                         uint32 desired_access,
 353                         LSA_SEC_QOS *qos)
 354 {
 355         DEBUG(5,("make_open_pol2: attr:%d da:%d\n", attributes, desired_access));
 356
 357         r_q->ptr = 1; /* undocumented pointer */
 358
 359         if (qos == NULL)
 360                 r_q->des_access = desired_access;
 361
 362         init_unistr2(&r_q->uni_server_name, server_name, strlen(server_name));
 363         init_lsa_obj_attr(&r_q->attr, attributes, qos);
 364 }
 365
 366 /*******************************************************************
 367  Reads or writes an LSA_Q_OPEN_POL2 structure.
 368 ********************************************************************/
 369
 370 BOOL lsa_io_q_open_pol2(char *desc, LSA_Q_OPEN_POL2 *r_q, prs_struct *ps, int depth)
 371 {
 372         if (r_q == NULL)
 373                 return False;
 374
 375         prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
 376         depth++;
 377
 378         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
 379                 return False;
 380
 381         if(!smb_io_unistr2 ("", &r_q->uni_server_name, r_q->ptr, ps, depth))
 382                 return False;
 383         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
 384                 return False;
 385
 386         if (r_q->attr.ptr_sec_qos == 0) {
 387                 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
 388                         return False;
 389         }
 390
 391         return True;
 392 }
 393
 394 /*******************************************************************
 395  Reads or writes an LSA_R_OPEN_POL2 structure.
 396 ********************************************************************/
 397
 398 BOOL lsa_io_r_open_pol2(char *desc, LSA_R_OPEN_POL2 *r_p, prs_struct *ps, int depth)
 399 {
 400         if (r_p == NULL)
 401                 return False;
 402
 403         prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
 404         depth++;
 405
 406         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
 407                 return False;
 408
 409         if(!prs_uint32("status", ps, depth, &r_p->status))
 410                 return False;
 411
 412         return True;
 413 }
 414
 415 /*******************************************************************
 416 makes an LSA_Q_QUERY_SEC_OBJ structure.
 417 ********************************************************************/
 418
 419 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *q_q, const POLICY_HND *hnd, uint32 sec_info)
 420 {
 421         if (q_q == NULL || hnd == NULL)
 422                 return;
 423
 424         DEBUG(5, ("init_q_query_sec_obj\n"));
 425
 426         q_q->pol = *hnd;
 427         q_q->sec_info = sec_info;
 428
 429         return;
 430 }
 431
 432 /*******************************************************************
 433  Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
 434 ********************************************************************/
 435
 436 BOOL lsa_io_q_query_sec_obj(char *desc, LSA_Q_QUERY_SEC_OBJ *q_q, prs_struct *ps, int depth)
 437 {
 438         if (q_q == NULL)
 439                 return False;
 440
 441         prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
 442         depth++;
 443
 444         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
 445                 return False;
 446
 447         if (!prs_uint32("sec_info", ps, depth, &q_q->sec_info))
 448                 return False;
 449
 450     return True;
 451 }
 452
 453 /*******************************************************************
 454  Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
 455 ********************************************************************/
 456
 457 BOOL lsa_io_r_query_sec_obj(char *desc, LSA_R_QUERY_SEC_OBJ *r_u, prs_struct *ps, int depth)
 458 {
 459         if (r_u == NULL)
 460                 return False;
 461
 462         prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
 463         depth++;
 464
 465         if (!prs_align(ps))
 466                 return False;
 467
 468         if (!prs_uint32("ptr", ps, depth, &r_u->ptr))
 469                 return False;
 470
 471         if (r_u->ptr != 0) {
 472                 if (!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
 473                         return False;
 474     }
 475         if (!prs_uint32("status", ps, depth, &r_u->status))
 476                 return False;
 477
 478     return True;
 479 }
 480
 481 /*******************************************************************
 482  Inits an LSA_Q_QUERY_INFO structure.
 483 ********************************************************************/
 484
 485 void init_q_query(LSA_Q_QUERY_INFO *q_q, POLICY_HND *hnd, uint16 info_class)
 486 {
 487         DEBUG(5,("make_q_query\n"));
 488
 489         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
 490
 491         q_q->info_class = info_class;
 492 }
 493
 494 /*******************************************************************
 495  Reads or writes an LSA_Q_QUERY_INFO structure.
 496 ********************************************************************/
 497
 498 BOOL lsa_io_q_query(char *desc, LSA_Q_QUERY_INFO *q_q, prs_struct *ps, int depth)
 499 {
 500         if (q_q == NULL)
 501                 return False;
 502
 503         prs_debug(ps, depth, desc, "lsa_io_q_query");
 504         depth++;
 505
 506         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
 507                 return False;
 508
 509         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
 510                 return False;
 511
 512         return True;
 513 }
 514
 515 /*******************************************************************
 516  Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
 517 ********************************************************************/
 518
 519 BOOL lsa_io_q_enum_trust_dom(char *desc, LSA_Q_ENUM_TRUST_DOM *q_e, prs_struct *ps, int depth)
 520 {
 521         if (q_e == NULL)
 522                 return False;
 523
 524         prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
 525         depth++;
 526
 527
 528         if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
 529                 return False;
 530
 531         if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
 532                 return False;
 533         if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
 534                 return False;
 535
 536         return True;
 537 }
 538
 539 /*******************************************************************
 540  Inits an LSA_R_ENUM_TRUST_DOM structure.
 541 ********************************************************************/
 542
 543 void init_r_enum_trust_dom(LSA_R_ENUM_TRUST_DOM *r_e,
 544                            uint32 enum_context, char *domain_name, DOM_SID *domain_sid,
 545                            uint32 status)
 546 {
 547         DEBUG(5,("make_r_enum_trust_dom\n"));
 548
 549         r_e->enum_context = enum_context;
 550
 551         if (status == 0) {
 552                 int len_domain_name = strlen(domain_name);
 553
 554                 r_e->num_domains  = 1;
 555                 r_e->ptr_enum_domains = 1;
 556                 r_e->num_domains2 = 1;
 557
 558                 init_uni_hdr2(&r_e->hdr_domain_name, len_domain_name);
 559                 init_unistr2 (&r_e->uni_domain_name, domain_name, len_domain_name);
 560                 init_dom_sid2(&r_e->other_domain_sid, domain_sid);
 561         } else {
 562                 r_e->num_domains = 0;
 563                 r_e->ptr_enum_domains = 0;
 564         }
 565
 566         r_e->status = status;
 567 }
 568
 569 /*******************************************************************
 570  Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
 571 ********************************************************************/
 572
 573 BOOL lsa_io_r_enum_trust_dom(char *desc,  LSA_R_ENUM_TRUST_DOM *r_e, prs_struct *ps, int depth)
 574 {
 575         if (r_e == NULL)
 576                 return False;
 577
 578         prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
 579         depth++;
 580
 581         if(!prs_uint32("enum_context    ", ps, depth, &r_e->enum_context))
 582                 return False;
 583         if(!prs_uint32("num_domains     ", ps, depth, &r_e->num_domains))
 584                 return False;
 585         if(!prs_uint32("ptr_enum_domains", ps, depth, &r_e->ptr_enum_domains))
 586                 return False;
 587
 588         if (r_e->ptr_enum_domains != 0) {
 589                 if(!prs_uint32("num_domains2", ps, depth, &r_e->num_domains2))
 590                         return False;
 591                 if(!smb_io_unihdr2 ("", &r_e->hdr_domain_name, ps, depth))
 592                         return False;
 593                 if(!smb_io_unistr2 ("", &r_e->uni_domain_name, r_e->hdr_domain_name.buffer, ps, depth))
 594                         return False;
 595                 if(!smb_io_dom_sid2("", &r_e->other_domain_sid, ps, depth))
 596                         return False;
 597         }
 598
 599         if(!prs_uint32("status", ps, depth, &r_e->status))
 600                 return False;
 601
 602         return True;
 603 }
 604
 605 /*******************************************************************
 606  Reads or writes an LSA_Q_QUERY_INFO structure.
 607 ********************************************************************/
 608
 609 BOOL lsa_io_r_query(char *desc, LSA_R_QUERY_INFO *r_q, prs_struct *ps, int depth)
 610 {
 611         if (r_q == NULL)
 612                 return False;
 613
 614         prs_debug(ps, depth, desc, "lsa_io_r_query");
 615         depth++;
 616
 617         if(!prs_uint32("undoc_buffer", ps, depth, &r_q->undoc_buffer))
 618                 return False;
 619
 620         if (r_q->undoc_buffer != 0) {
 621                 if(!prs_uint16("info_class", ps, depth, &r_q->info_class))
 622                         return False;
 623
 624                 switch (r_q->info_class) {
 625                 case 3:
 626                         if(!smb_io_dom_query_3("", &r_q->dom.id3, ps, depth))
 627                                 return False;
 628                         break;
 629                 case 5:
 630                         if(!smb_io_dom_query_5("", &r_q->dom.id3, ps, depth))
 631                                 return False;
 632                         break;
 633                 default:
 634                         /* PANIC! */
 635                         break;
 636                 }
 637         }
 638
 639         if(!prs_uint32("status", ps, depth, &r_q->status))
 640                 return False;
 641
 642         return True;
 643 }
 644
 645 /*******************************************************************
 646  Inits a LSA_SID_ENUM structure.
 647 ********************************************************************/
 648
 649 void init_lsa_sid_enum(LSA_SID_ENUM *sen, int num_entries, DOM_SID **sids)
 650 {
 651         int i, i2;
 652
 653         DEBUG(5,("make_lsa_sid_enum\n"));
 654
 655         sen->num_entries  = num_entries;
 656         sen->ptr_sid_enum = (num_entries != 0) ? 1 : 0;
 657         sen->num_entries2 = num_entries;
 658
 659         SMB_ASSERT_ARRAY(sen->sid, sen->num_entries);
 660
 661         for (i = 0, i2 = 0; i < num_entries; i++) {
 662                 if (sids[i] != NULL) {
 663                         sen->ptr_sid[i] = 1;
 664                         init_dom_sid2(&sen->sid[i2], sids[i]);
 665                         i2++;
 666                 } else {
 667                         sen->ptr_sid[i] = 0;
 668                 }
 669         }
 670 }
 671
 672 /*******************************************************************
 673  Reads or writes a LSA_SID_ENUM structure.
 674 ********************************************************************/
 675
 676 static BOOL lsa_io_sid_enum(char *desc, LSA_SID_ENUM *sen,
 677                                 prs_struct *ps, int depth)
 678 {
 679         int i;
 680
 681         if (sen == NULL)
 682                 return False;
 683
 684         prs_debug(ps, depth, desc, "lsa_io_sid_enum");
 685         depth++;
 686
 687         if(!prs_align(ps))
 688                 return False;
 689
 690         if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
 691                 return False;
 692         if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
 693                 return False;
 694         if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
 695                 return False;
 696
 697         SMB_ASSERT_ARRAY(sen->ptr_sid, sen->num_entries);
 698
 699         for (i = 0; i < sen->num_entries; i++) {
 700                 fstring temp;
 701                 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
 702                 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) /* domain SID pointers to be looked up. */
 703                         return False;
 704         }
 705
 706         SMB_ASSERT_ARRAY(sen->sid, sen->num_entries);
 707
 708         for (i = 0; i < sen->num_entries; i++) {
 709                 fstring temp;
 710                 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
 711                 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) /* domain SIDs to be looked up. */
 712                         return False;
 713         }
 714
 715         return True;
 716 }
 717
 718 /*******************************************************************
 719  Inits an LSA_R_ENUM_TRUST_DOM structure.
 720 ********************************************************************/
 721
 722 void init_q_lookup_sids(LSA_Q_LOOKUP_SIDS *q_l, POLICY_HND *hnd,
 723                                 int num_sids, DOM_SID **sids,
 724                                 uint16 level)
 725 {
 726         DEBUG(5,("make_r_enum_trust_dom\n"));
 727
 728         memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
 729         init_lsa_sid_enum(&q_l->sids, num_sids, sids);
 730
 731         q_l->names.num_entries     = 0;
 732         q_l->names.ptr_trans_names = 0;
 733         q_l->names.num_entries2    = 0;
 734
 735         q_l->level.value = level;
 736 }
 737
 738 /*******************************************************************
 739  Reads or writes a LSA_Q_LOOKUP_SIDS structure.
 740 ********************************************************************/
 741
 742 BOOL lsa_io_q_lookup_sids(char *desc, LSA_Q_LOOKUP_SIDS *q_s, prs_struct *ps, int depth)
 743 {
 744         if (q_s == NULL)
 745                 return False;
 746
 747         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
 748         depth++;
 749
 750         if(!prs_align(ps))
 751                 return False;
 752
 753         if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
 754                 return False;
 755         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
 756                 return False;
 757         if(!lsa_io_trans_names("names  ", &q_s->names, ps, depth)) /* translated names */
 758                 return False;
 759         if(!smb_io_lookup_level("switch ", &q_s->level, ps, depth)) /* lookup level */
 760                 return False;
 761
 762         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
 763                 return False;
 764
 765         return True;
 766 }
 767
 768 /*******************************************************************
 769  Reads or writes a structure.
 770 ********************************************************************/
 771
 772 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn,
 773                 prs_struct *ps, int depth)
 774 {
 775         int i;
 776
 777         if (trn == NULL)
 778                 return False;
 779
 780         prs_debug(ps, depth, desc, "lsa_io_trans_names");
 781         depth++;
 782
 783         if(!prs_align(ps))
 784                 return False;
 785
 786         if(!prs_uint32("num_entries    ", ps, depth, &trn->num_entries))
 787                 return False;
 788         if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
 789                 return False;
 790
 791         if (trn->ptr_trans_names != 0) {
 792                 if(!prs_uint32("num_entries2   ", ps, depth, &trn->num_entries2))
 793                         return False;
 794                 SMB_ASSERT_ARRAY(trn->name, trn->num_entries);
 795
 796                 for (i = 0; i < trn->num_entries2; i++) {
 797                         fstring t;
 798                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
 799
 800                         if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
 801                                 return False;
 802                 }
 803
 804                 for (i = 0; i < trn->num_entries2; i++) {
 805                         fstring t;
 806                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
 807
 808                         if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
 809                                 return False;
 810                         if(!prs_align(ps))
 811                                 return False;
 812                 }
 813         }
 814
 815         return True;
 816 }
 817
 818 /*******************************************************************
 819  Reads or writes a structure.
 820 ********************************************************************/
 821
 822 BOOL lsa_io_r_lookup_sids(char *desc, LSA_R_LOOKUP_SIDS *r_s, prs_struct *ps, int depth)
 823 {
 824         if (r_s == NULL)
 825                 return False;
 826
 827         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
 828         depth++;
 829
 830         if(!prs_align(ps))
 831                 return False;
 832
 833         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
 834                 return False;
 835
 836         if (r_s->ptr_dom_ref != 0)
 837                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
 838                         return False;
 839
 840         if(!lsa_io_trans_names("names  ", r_s->names, ps, depth)) /* translated names */
 841                 return False;
 842
 843         if(!prs_align(ps))
 844                 return False;
 845
 846         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
 847                 return False;
 848
 849         if(!prs_uint32("status      ", ps, depth, &r_s->status))
 850                 return False;
 851
 852         return True;
 853 }
 854
 855 /*******************************************************************
 856 makes a structure.
 857 ********************************************************************/
 858
 859 void init_q_lookup_names(LSA_Q_LOOKUP_NAMES *q_l, POLICY_HND *hnd,
 860                 int num_names, char **names)
 861 {
 862         int i;
 863
 864         DEBUG(5,("init_q_lookup_names\n"));
 865
 866         memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
 867
 868         q_l->num_entries = num_names;
 869         q_l->num_entries2 = num_names;
 870
 871         SMB_ASSERT_ARRAY(q_l->uni_name, q_l->num_entries);
 872
 873         for (i = 0; i < num_names; i++) {
 874                 char* name = names[i];
 875                 int len = strlen(name);
 876                 init_uni_hdr(&q_l->hdr_name[i], len);
 877                 init_unistr2(&q_l->uni_name[i], name, len);
 878         }
 879
 880         q_l->num_trans_entries  = 0;
 881         q_l->ptr_trans_sids  = 0;
 882         q_l->lookup_level = 1;
 883         q_l->mapped_count = 0;
 884 }
 885
 886 /*******************************************************************
 887 reads or writes a structure.
 888 ********************************************************************/
 889
 890 BOOL lsa_io_q_lookup_names(char *desc, LSA_Q_LOOKUP_NAMES *q_r, prs_struct *ps, int depth)
 891 {
 892         int i;
 893
 894         if (q_r == NULL)
 895                 return False;
 896
 897         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
 898         depth++;
 899
 900         if(!prs_align(ps))
 901                 return False;
 902
 903         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
 904                 return False;
 905
 906         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
 907                 return False;
 908         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
 909                 return False;
 910
 911         SMB_ASSERT_ARRAY(q_r->uni_name, q_r->num_entries);
 912
 913         for (i = 0; i < q_r->num_entries; i++) {
 914                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
 915                         return False;
 916         }
 917
 918         for (i = 0; i < q_r->num_entries; i++) {
 919                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
 920                         return False;
 921                 if(!prs_align(ps))
 922                         return False;
 923         }
 924
 925         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
 926                 return False;
 927         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
 928                 return False;
 929         if(!prs_uint32("lookup_level   ", ps, depth, &q_r->lookup_level))
 930                 return False;
 931         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
 932                 return False;
 933
 934         return True;
 935 }
 936
 937 /*******************************************************************
 938 reads or writes a structure.
 939 ********************************************************************/
 940
 941 BOOL lsa_io_r_lookup_names(char *desc, LSA_R_LOOKUP_NAMES *r_r, prs_struct *ps, int depth)
 942 {
 943         int i;
 944
 945         if (r_r == NULL)
 946                 return False;
 947
 948         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
 949         depth++;
 950
 951         if(!prs_align(ps))
 952                 return False;
 953
 954         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_r->ptr_dom_ref))
 955                 return False;
 956
 957         if (r_r->ptr_dom_ref != 0)
 958                 if(!lsa_io_dom_r_ref("", r_r->dom_ref, ps, depth))
 959                         return False;
 960
 961         if(!prs_uint32("num_entries", ps, depth, &r_r->num_entries))
 962                 return False;
 963         if(!prs_uint32("ptr_entries", ps, depth, &r_r->ptr_entries))
 964                 return False;
 965
 966         if (r_r->ptr_entries != 0) {
 967                 if(!prs_uint32("num_entries2", ps, depth, &r_r->num_entries2))
 968                         return False;
 969
 970                 if (r_r->num_entries2 != r_r->num_entries) {
 971                         /* RPC fault */
 972                         return False;
 973                 }
 974
 975                 for (i = 0; i < r_r->num_entries2; i++)
 976                         if(!smb_io_dom_rid2("", &r_r->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
 977                                 return False;
 978         }
 979
 980         if(!prs_uint32("mapped_count", ps, depth, &r_r->mapped_count))
 981                 return False;
 982
 983         if(!prs_uint32("status      ", ps, depth, &r_r->status))
 984                 return False;
 985
 986         return True;
 987 }
 988
 989
 990 /*******************************************************************
 991  Inits an LSA_Q_CLOSE structure.
 992 ********************************************************************/
 993
 994 void init_lsa_q_close(LSA_Q_CLOSE *q_c, POLICY_HND *hnd)
 995 {
 996         DEBUG(5,("make_lsa_q_close\n"));
 997
 998         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
 999 }
1000
1001 /*******************************************************************
1002  Reads or writes an LSA_Q_CLOSE structure.
1003 ********************************************************************/
1004
1005 BOOL lsa_io_q_close(char *desc, LSA_Q_CLOSE *q_c, prs_struct *ps, int depth)
1006 {
1007         if (q_c == NULL)
1008                 return False;
1009
1010         prs_debug(ps, depth, desc, "lsa_io_q_close");
1011         depth++;
1012
1013         if(!smb_io_pol_hnd("", &q_c->pol, ps, depth))
1014                 return False;
1015
1016         return True;
1017 }
1018
1019 /*******************************************************************
1020  Reads or writes an LSA_R_CLOSE structure.
1021 ********************************************************************/
1022
1023 BOOL lsa_io_r_close(char *desc,  LSA_R_CLOSE *r_c, prs_struct *ps, int depth)
1024 {
1025         if (r_c == NULL)
1026                 return False;
1027
1028         prs_debug(ps, depth, desc, "lsa_io_r_close");
1029         depth++;
1030
1031         if(!smb_io_pol_hnd("", &r_c->pol, ps, depth))
1032                 return False;
1033
1034         if(!prs_uint32("status", ps, depth, &r_c->status))
1035                 return False;
1036
1037         return True;
1038 }