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