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)+1;
  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, ("init_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, ("init_open_pol: attr:%d da:%d\n", attributes,
 285                   desired_access));
 286
 287         r_q->ptr = 1; /* undocumented pointer */
 288
 289         if (qos == NULL)
 290                 r_q->des_access = desired_access;
 291
 292         r_q->system_name = system_name;
 293         init_lsa_obj_attr(&r_q->attr, attributes, qos);
 294 }
 295
 296 /*******************************************************************
 297  Reads or writes an LSA_Q_OPEN_POL structure.
 298 ********************************************************************/
 299
 300 BOOL lsa_io_q_open_pol(char *desc, LSA_Q_OPEN_POL *r_q, prs_struct *ps,
 301                        int depth)
 302 {
 303         if (r_q == NULL) return False;
 304
 305         prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
 306         depth++;
 307
 308         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
 309                 return False;
 310         if(!prs_uint16("system_name", ps, depth, &r_q->system_name))
 311                 return False;
 312         if(!prs_align(ps))
 313                 return False;
 314
 315         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
 316                 return False;
 317
 318         if (r_q->attr.ptr_sec_qos == 0) {
 319                 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
 320                         return False;
 321         }
 322
 323         return True;
 324 }
 325
 326 /*******************************************************************
 327  Reads or writes an LSA_R_OPEN_POL structure.
 328 ********************************************************************/
 329
 330 BOOL lsa_io_r_open_pol(char *desc, LSA_R_OPEN_POL *r_p, prs_struct *ps, int depth)
 331 {
 332         if (r_p == NULL)
 333                 return False;
 334
 335         prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
 336         depth++;
 337
 338         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
 339                 return False;
 340
 341         if(!prs_uint32("status", ps, depth, &r_p->status))
 342                 return False;
 343
 344         return True;
 345 }
 346
 347 /*******************************************************************
 348  Inits an LSA_Q_OPEN_POL2 structure.
 349 ********************************************************************/
 350
 351 void init_q_open_pol2(LSA_Q_OPEN_POL2 *r_q, char *server_name,
 352                         uint32 attributes,
 353                         uint32 desired_access,
 354                         LSA_SEC_QOS *qos)
 355 {
 356         DEBUG(5, ("init_open_pol2: attr:%d da:%d\n", attributes,
 357                   desired_access));
 358
 359         r_q->ptr = 1; /* undocumented pointer */
 360
 361         if (qos == NULL)
 362                 r_q->des_access = desired_access;
 363
 364         init_unistr2(&r_q->uni_server_name, server_name, strlen(server_name)+1);
 365         init_lsa_obj_attr(&r_q->attr, attributes, qos);
 366 }
 367
 368 /*******************************************************************
 369  Reads or writes an LSA_Q_OPEN_POL2 structure.
 370 ********************************************************************/
 371
 372 BOOL lsa_io_q_open_pol2(char *desc, LSA_Q_OPEN_POL2 *r_q, prs_struct *ps, int depth)
 373 {
 374         if (r_q == NULL)
 375                 return False;
 376
 377         prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
 378         depth++;
 379
 380         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
 381                 return False;
 382
 383         if(!smb_io_unistr2 ("", &r_q->uni_server_name, r_q->ptr, ps, depth))
 384                 return False;
 385         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
 386                 return False;
 387
 388         if (r_q->attr.ptr_sec_qos == 0) {
 389                 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
 390                         return False;
 391         }
 392
 393         return True;
 394 }
 395
 396 /*******************************************************************
 397  Reads or writes an LSA_R_OPEN_POL2 structure.
 398 ********************************************************************/
 399
 400 BOOL lsa_io_r_open_pol2(char *desc, LSA_R_OPEN_POL2 *r_p, prs_struct *ps, int depth)
 401 {
 402         if (r_p == NULL)
 403                 return False;
 404
 405         prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
 406         depth++;
 407
 408         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
 409                 return False;
 410
 411         if(!prs_uint32("status", ps, depth, &r_p->status))
 412                 return False;
 413
 414         return True;
 415 }
 416
 417 /*******************************************************************
 418 makes an LSA_Q_QUERY_SEC_OBJ structure.
 419 ********************************************************************/
 420
 421 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *q_q, const POLICY_HND *hnd, uint32 sec_info)
 422 {
 423         if (q_q == NULL || hnd == NULL)
 424                 return;
 425
 426         DEBUG(5, ("init_q_query_sec_obj\n"));
 427
 428         q_q->pol = *hnd;
 429         q_q->sec_info = sec_info;
 430
 431         return;
 432 }
 433
 434 /*******************************************************************
 435  Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
 436 ********************************************************************/
 437
 438 BOOL lsa_io_q_query_sec_obj(char *desc, LSA_Q_QUERY_SEC_OBJ *q_q, prs_struct *ps, int depth)
 439 {
 440         if (q_q == NULL)
 441                 return False;
 442
 443         prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
 444         depth++;
 445
 446         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
 447                 return False;
 448
 449         if (!prs_uint32("sec_info", ps, depth, &q_q->sec_info))
 450                 return False;
 451
 452     return True;
 453 }
 454
 455 /*******************************************************************
 456  Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
 457 ********************************************************************/
 458
 459 BOOL lsa_io_r_query_sec_obj(char *desc, LSA_R_QUERY_SEC_OBJ *r_u, prs_struct *ps, int depth)
 460 {
 461         if (r_u == NULL)
 462                 return False;
 463
 464         prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
 465         depth++;
 466
 467         if (!prs_align(ps))
 468                 return False;
 469
 470         if (!prs_uint32("ptr", ps, depth, &r_u->ptr))
 471                 return False;
 472
 473         if (r_u->ptr != 0) {
 474                 if (!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
 475                         return False;
 476     }
 477         if (!prs_uint32("status", ps, depth, &r_u->status))
 478                 return False;
 479
 480     return True;
 481 }
 482
 483 /*******************************************************************
 484  Inits an LSA_Q_QUERY_INFO structure.
 485 ********************************************************************/
 486
 487 void init_q_query(LSA_Q_QUERY_INFO *q_q, POLICY_HND *hnd, uint16 info_class)
 488 {
 489         DEBUG(5, ("init_q_query\n"));
 490
 491         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
 492
 493         q_q->info_class = info_class;
 494 }
 495
 496 /*******************************************************************
 497  Reads or writes an LSA_Q_QUERY_INFO structure.
 498 ********************************************************************/
 499
 500 BOOL lsa_io_q_query(char *desc, LSA_Q_QUERY_INFO *q_q, prs_struct *ps, int depth)
 501 {
 502         if (q_q == NULL)
 503                 return False;
 504
 505         prs_debug(ps, depth, desc, "lsa_io_q_query");
 506         depth++;
 507
 508         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
 509                 return False;
 510
 511         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
 512                 return False;
 513
 514         return True;
 515 }
 516
 517 /*******************************************************************
 518  Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
 519 ********************************************************************/
 520
 521 BOOL lsa_io_q_enum_trust_dom(char *desc, LSA_Q_ENUM_TRUST_DOM *q_e, prs_struct *ps, int depth)
 522 {
 523         if (q_e == NULL)
 524                 return False;
 525
 526         prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
 527         depth++;
 528
 529
 530         if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
 531                 return False;
 532
 533         if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
 534                 return False;
 535         if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
 536                 return False;
 537
 538         return True;
 539 }
 540
 541 /*******************************************************************
 542  Inits an LSA_R_ENUM_TRUST_DOM structure.
 543 ********************************************************************/
 544
 545 void init_r_enum_trust_dom(LSA_R_ENUM_TRUST_DOM *r_e,
 546                            uint32 enum_context, char *domain_name, DOM_SID *domain_sid,
 547                            uint32 status)
 548 {
 549         DEBUG(5, ("init_r_enum_trust_dom\n"));
 550
 551         r_e->enum_context = enum_context;
 552
 553         if (status == 0) {
 554                 int len_domain_name = strlen(domain_name)+1;
 555
 556                 r_e->num_domains  = 1;
 557                 r_e->ptr_enum_domains = 1;
 558                 r_e->num_domains2 = 1;
 559
 560                 init_uni_hdr2(&r_e->hdr_domain_name, len_domain_name);
 561                 init_unistr2 (&r_e->uni_domain_name, domain_name, len_domain_name);
 562                 init_dom_sid2(&r_e->other_domain_sid, domain_sid);
 563         } else {
 564                 r_e->num_domains = 0;
 565                 r_e->ptr_enum_domains = 0;
 566         }
 567
 568         r_e->status = status;
 569 }
 570
 571 /*******************************************************************
 572  Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
 573 ********************************************************************/
 574
 575 BOOL lsa_io_r_enum_trust_dom(char *desc,  LSA_R_ENUM_TRUST_DOM *r_e, prs_struct *ps, int depth)
 576 {
 577         if (r_e == NULL)
 578                 return False;
 579
 580         prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
 581         depth++;
 582
 583         if(!prs_uint32("enum_context    ", ps, depth, &r_e->enum_context))
 584                 return False;
 585         if(!prs_uint32("num_domains     ", ps, depth, &r_e->num_domains))
 586                 return False;
 587         if(!prs_uint32("ptr_enum_domains", ps, depth, &r_e->ptr_enum_domains))
 588                 return False;
 589
 590         if (r_e->ptr_enum_domains != 0) {
 591                 if(!prs_uint32("num_domains2", ps, depth, &r_e->num_domains2))
 592                         return False;
 593                 if(!smb_io_unihdr2 ("", &r_e->hdr_domain_name, ps, depth))
 594                         return False;
 595                 if(!smb_io_unistr2 ("", &r_e->uni_domain_name, r_e->hdr_domain_name.buffer, ps, depth))
 596                         return False;
 597                 if(!smb_io_dom_sid2("", &r_e->other_domain_sid, ps, depth))
 598                         return False;
 599         }
 600
 601         if(!prs_uint32("status", ps, depth, &r_e->status))
 602                 return False;
 603
 604         return True;
 605 }
 606
 607 /*******************************************************************
 608  Reads or writes an LSA_Q_QUERY_INFO structure.
 609 ********************************************************************/
 610
 611 BOOL lsa_io_r_query(char *desc, LSA_R_QUERY_INFO *r_q, prs_struct *ps, int depth)
 612 {
 613         if (r_q == NULL)
 614                 return False;
 615
 616         prs_debug(ps, depth, desc, "lsa_io_r_query");
 617         depth++;
 618
 619         if(!prs_uint32("undoc_buffer", ps, depth, &r_q->undoc_buffer))
 620                 return False;
 621
 622         if (r_q->undoc_buffer != 0) {
 623                 if(!prs_uint16("info_class", ps, depth, &r_q->info_class))
 624                         return False;
 625
 626                 switch (r_q->info_class) {
 627                 case 3:
 628                         if(!smb_io_dom_query_3("", &r_q->dom.id3, ps, depth))
 629                                 return False;
 630                         break;
 631                 case 5:
 632                         if(!smb_io_dom_query_5("", &r_q->dom.id3, ps, depth))
 633                                 return False;
 634                         break;
 635                 default:
 636                         /* PANIC! */
 637                         break;
 638                 }
 639         }
 640
 641         if(!prs_uint32("status", ps, depth, &r_q->status))
 642                 return False;
 643
 644         return True;
 645 }
 646
 647 /*******************************************************************
 648  Inits a LSA_SID_ENUM structure.
 649 ********************************************************************/
 650
 651 void init_lsa_sid_enum(LSA_SID_ENUM *sen, int num_entries, DOM_SID *sids)
 652 {
 653         int i;
 654
 655         DEBUG(5, ("init_lsa_sid_enum\n"));
 656
 657         sen->num_entries  = num_entries;
 658         sen->ptr_sid_enum = num_entries != 0;
 659         sen->num_entries2 = num_entries;
 660
 661         SMB_ASSERT_ARRAY(sen->sid, sen->num_entries);
 662
 663         for (i = 0; i < num_entries; i++) {
 664                 sen->ptr_sid[i] = 1;
 665                 init_dom_sid2(&sen->sid[i], &sids[i]);
 666         }
 667 }
 668
 669 /*******************************************************************
 670  Reads or writes a LSA_SID_ENUM structure.
 671 ********************************************************************/
 672
 673 static BOOL lsa_io_sid_enum(char *desc, LSA_SID_ENUM *sen,
 674                                 prs_struct *ps, int depth)
 675 {
 676         int i;
 677
 678         if (sen == NULL)
 679                 return False;
 680
 681         prs_debug(ps, depth, desc, "lsa_io_sid_enum");
 682         depth++;
 683
 684         if(!prs_align(ps))
 685                 return False;
 686
 687         if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
 688                 return False;
 689         if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
 690                 return False;
 691         if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
 692                 return False;
 693
 694         SMB_ASSERT_ARRAY(sen->ptr_sid, sen->num_entries);
 695
 696         for (i = 0; i < sen->num_entries; i++) {
 697                 fstring temp;
 698                 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
 699                 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) /* domain SID pointers to be looked up. */
 700                         return False;
 701         }
 702
 703         SMB_ASSERT_ARRAY(sen->sid, sen->num_entries);
 704
 705         for (i = 0; i < sen->num_entries; i++) {
 706                 fstring temp;
 707                 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
 708                 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) /* domain SIDs to be looked up. */
 709                         return False;
 710         }
 711
 712         return True;
 713 }
 714
 715 /*******************************************************************
 716  Inits an LSA_R_ENUM_TRUST_DOM structure.
 717 ********************************************************************/
 718
 719 void init_q_lookup_sids(LSA_Q_LOOKUP_SIDS *q_l, POLICY_HND *hnd,
 720                         int num_sids, DOM_SID *sids, uint16 level)
 721 {
 722         DEBUG(5, ("init_q_lookup_sids\n"));
 723
 724         q_l->pol = *hnd;
 725
 726         init_lsa_sid_enum(&q_l->sids, num_sids, sids);
 727
 728         q_l->names.num_entries     = 0;
 729         q_l->names.ptr_trans_names = 0;
 730         q_l->names.num_entries2    = 0;
 731
 732         q_l->level.value = level;
 733 }
 734
 735 /*******************************************************************
 736  Reads or writes a LSA_Q_LOOKUP_SIDS structure.
 737 ********************************************************************/
 738
 739 BOOL lsa_io_q_lookup_sids(char *desc, LSA_Q_LOOKUP_SIDS *q_s,
 740                           prs_struct *ps, int depth)
 741 {
 742         if (q_s == NULL)
 743                 return False;
 744
 745         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
 746         depth++;
 747
 748         if(!prs_align(ps))
 749                 return False;
 750
 751         if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
 752                 return False;
 753         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
 754                 return False;
 755         if(!lsa_io_trans_names("names  ", &q_s->names, ps, depth)) /* translated names */
 756                 return False;
 757         if(!smb_io_lookup_level("switch ", &q_s->level, ps, depth)) /* lookup level */
 758                 return False;
 759
 760         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
 761                 return False;
 762
 763         return True;
 764 }
 765
 766 /*******************************************************************
 767  Reads or writes a structure.
 768 ********************************************************************/
 769
 770 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn,
 771                 prs_struct *ps, int depth)
 772 {
 773         int i;
 774
 775         if (trn == NULL)
 776                 return False;
 777
 778         prs_debug(ps, depth, desc, "lsa_io_trans_names");
 779         depth++;
 780
 781         if(!prs_align(ps))
 782                 return False;
 783
 784         if(!prs_uint32("num_entries    ", ps, depth, &trn->num_entries))
 785                 return False;
 786         if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
 787                 return False;
 788
 789         if (trn->ptr_trans_names != 0) {
 790                 if(!prs_uint32("num_entries2   ", ps, depth, &trn->num_entries2))
 791                         return False;
 792                 SMB_ASSERT_ARRAY(trn->name, trn->num_entries);
 793
 794                 for (i = 0; i < trn->num_entries2; i++) {
 795                         fstring t;
 796                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
 797
 798                         if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
 799                                 return False;
 800                 }
 801
 802                 for (i = 0; i < trn->num_entries2; i++) {
 803                         fstring t;
 804                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
 805
 806                         if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
 807                                 return False;
 808                         if(!prs_align(ps))
 809                                 return False;
 810                 }
 811         }
 812
 813         return True;
 814 }
 815
 816 /*******************************************************************
 817  Reads or writes a structure.
 818 ********************************************************************/
 819
 820 BOOL lsa_io_r_lookup_sids(char *desc, LSA_R_LOOKUP_SIDS *r_s, prs_struct *ps, int depth)
 821 {
 822         if (r_s == NULL)
 823                 return False;
 824
 825         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
 826         depth++;
 827
 828         if(!prs_align(ps))
 829                 return False;
 830
 831         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
 832                 return False;
 833
 834         if (r_s->ptr_dom_ref != 0)
 835                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
 836                         return False;
 837
 838         if(!lsa_io_trans_names("names  ", r_s->names, ps, depth)) /* translated names */
 839                 return False;
 840
 841         if(!prs_align(ps))
 842                 return False;
 843
 844         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
 845                 return False;
 846
 847         if(!prs_uint32("status      ", ps, depth, &r_s->status))
 848                 return False;
 849
 850         return True;
 851 }
 852
 853 /*******************************************************************
 854 makes a structure.
 855 ********************************************************************/
 856
 857 void init_q_lookup_names(LSA_Q_LOOKUP_NAMES *q_l, POLICY_HND *hnd,
 858                          int num_names, char **names)
 859 {
 860         int i;
 861
 862         DEBUG(5,("init_q_lookup_names\n"));
 863
 864         q_l->pol = *hnd;
 865         q_l->num_entries = num_names;
 866         q_l->num_entries2 = num_names;
 867
 868         SMB_ASSERT_ARRAY(q_l->uni_name, q_l->num_entries);
 869
 870         for (i = 0; i < num_names; i++) {
 871                 char *name = names[i];
 872                 int len = strlen(name);
 873
 874                 init_uni_hdr(&q_l->hdr_name[i], len);
 875                 init_unistr2(&q_l->uni_name[i], name, len);
 876         }
 877
 878         q_l->num_trans_entries  = 0;
 879         q_l->ptr_trans_sids  = 0;
 880         q_l->lookup_level = 1;
 881         q_l->mapped_count = 0;
 882 }
 883
 884 /*******************************************************************
 885 reads or writes a structure.
 886 ********************************************************************/
 887
 888 BOOL lsa_io_q_lookup_names(char *desc, LSA_Q_LOOKUP_NAMES *q_r, prs_struct *ps, int depth)
 889 {
 890         int i;
 891
 892         if (q_r == NULL)
 893                 return False;
 894
 895         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
 896         depth++;
 897
 898         if(!prs_align(ps))
 899                 return False;
 900
 901         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
 902                 return False;
 903
 904         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
 905                 return False;
 906         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
 907                 return False;
 908
 909         SMB_ASSERT_ARRAY(q_r->uni_name, q_r->num_entries);
 910
 911         for (i = 0; i < q_r->num_entries; i++) {
 912                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
 913                         return False;
 914         }
 915
 916         for (i = 0; i < q_r->num_entries; i++) {
 917                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
 918                         return False;
 919                 if(!prs_align(ps))
 920                         return False;
 921         }
 922
 923         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
 924                 return False;
 925         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
 926                 return False;
 927         if(!prs_uint32("lookup_level   ", ps, depth, &q_r->lookup_level))
 928                 return False;
 929         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
 930                 return False;
 931
 932         return True;
 933 }
 934
 935 /*******************************************************************
 936 reads or writes a structure.
 937 ********************************************************************/
 938
 939 BOOL lsa_io_r_lookup_names(char *desc, LSA_R_LOOKUP_NAMES *r_r, prs_struct *ps, int depth)
 940 {
 941         int i;
 942
 943         if (r_r == NULL)
 944                 return False;
 945
 946         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
 947         depth++;
 948
 949         if(!prs_align(ps))
 950                 return False;
 951
 952         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_r->ptr_dom_ref))
 953                 return False;
 954
 955         if (r_r->ptr_dom_ref != 0)
 956                 if(!lsa_io_dom_r_ref("", r_r->dom_ref, ps, depth))
 957                         return False;
 958
 959         if(!prs_uint32("num_entries", ps, depth, &r_r->num_entries))
 960                 return False;
 961         if(!prs_uint32("ptr_entries", ps, depth, &r_r->ptr_entries))
 962                 return False;
 963
 964         if (r_r->ptr_entries != 0) {
 965                 if(!prs_uint32("num_entries2", ps, depth, &r_r->num_entries2))
 966                         return False;
 967
 968                 if (r_r->num_entries2 != r_r->num_entries) {
 969                         /* RPC fault */
 970                         return False;
 971                 }
 972
 973                 for (i = 0; i < r_r->num_entries2; i++)
 974                         if(!smb_io_dom_rid2("", &r_r->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
 975                                 return False;
 976         }
 977
 978         if(!prs_uint32("mapped_count", ps, depth, &r_r->mapped_count))
 979                 return False;
 980
 981         if(!prs_uint32("status      ", ps, depth, &r_r->status))
 982                 return False;
 983
 984         return True;
 985 }
 986
 987
 988 /*******************************************************************
 989  Inits an LSA_Q_CLOSE structure.
 990 ********************************************************************/
 991
 992 void init_lsa_q_close(LSA_Q_CLOSE *q_c, POLICY_HND *hnd)
 993 {
 994         DEBUG(5, ("init_lsa_q_close\n"));
 995
 996         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
 997 }
 998
 999 /*******************************************************************
1000  Reads or writes an LSA_Q_CLOSE structure.
1001 ********************************************************************/
1002
1003 BOOL lsa_io_q_close(char *desc, LSA_Q_CLOSE *q_c, prs_struct *ps, int depth)
1004 {
1005         if (q_c == NULL)
1006                 return False;
1007
1008         prs_debug(ps, depth, desc, "lsa_io_q_close");
1009         depth++;
1010
1011         if(!smb_io_pol_hnd("", &q_c->pol, ps, depth))
1012                 return False;
1013
1014         return True;
1015 }
1016
1017 /*******************************************************************
1018  Reads or writes an LSA_R_CLOSE structure.
1019 ********************************************************************/
1020
1021 BOOL lsa_io_r_close(char *desc,  LSA_R_CLOSE *r_c, prs_struct *ps, int depth)
1022 {
1023         if (r_c == NULL)
1024                 return False;
1025
1026         prs_debug(ps, depth, desc, "lsa_io_r_close");
1027         depth++;
1028
1029         if(!smb_io_pol_hnd("", &r_c->pol, ps, depth))
1030                 return False;
1031
1032         if(!prs_uint32("status", ps, depth, &r_c->status))
1033                 return False;
1034
1035         return True;
1036 }