source3/rpc_parse/parse_misc.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25
  26 #include "includes.h"
  27
  28 extern int DEBUGLEVEL;
  29
  30
  31
  32 /*******************************************************************
  33 reads or writes a UTIME type.
  34 ********************************************************************/
  35 static void smb_io_utime(char *desc,  UTIME *t, prs_struct *ps, int depth)
  36 {
  37         if (t == NULL) return;
  38
  39         prs_debug(ps, depth, desc, "smb_io_utime");
  40         depth++;
  41
  42         prs_align(ps);
  43
  44         prs_uint32 ("time", ps, depth, &(t->time));
  45 }
  46
  47 /*******************************************************************
  48 reads or writes an NTTIME structure.
  49 ********************************************************************/
  50 void smb_io_time(char *desc,  NTTIME *nttime, prs_struct *ps, int depth)
  51 {
  52         if (nttime == NULL) return;
  53
  54         prs_debug(ps, depth, desc, "smb_io_time");
  55         depth++;
  56
  57         prs_align(ps);
  58
  59         prs_uint32("low ", ps, depth, &(nttime->low )); /* low part */
  60         prs_uint32("high", ps, depth, &(nttime->high)); /* high part */
  61 }
  62
  63 /*******************************************************************
  64 reads or writes a LOOKUP_LEVEL structure.
  65 ********************************************************************/
  66 void smb_io_lookup_level(char *desc, LOOKUP_LEVEL *level, prs_struct *ps, int depth)
  67 {
  68         if (level == NULL) return;
  69
  70         prs_debug(ps, depth, desc, "smb_io_lookup_level");
  71         depth++;
  72
  73         prs_align(ps);
  74         prs_uint16("value", ps, depth, &(level->value));
  75         prs_align(ps);
  76 }
  77
  78 /*******************************************************************
  79 gets an enumeration handle from an ENUM_HND structure.
  80 ********************************************************************/
  81 uint32 get_enum_hnd(ENUM_HND *enh)
  82 {
  83         return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
  84 }
  85
  86 /*******************************************************************
  87 makes an ENUM_HND structure.
  88 ********************************************************************/
  89 void make_enum_hnd(ENUM_HND *enh, uint32 hnd)
  90 {
  91         if (enh == NULL) return;
  92
  93         DEBUG(5,("smb_io_enum_hnd\n"));
  94
  95         enh->ptr_hnd = (hnd != 0) ? 1 : 0;
  96         enh->handle = hnd;
  97 }
  98
  99 /*******************************************************************
 100 reads or writes an ENUM_HND structure.
 101 ********************************************************************/
 102 void smb_io_enum_hnd(char *desc,  ENUM_HND *hnd, prs_struct *ps, int depth)
 103 {
 104         if (hnd == NULL) return;
 105
 106         prs_debug(ps, depth, desc, "smb_io_enum_hnd");
 107         depth++;
 108
 109         prs_align(ps);
 110
 111         prs_uint32("ptr_hnd", ps, depth, &(hnd->ptr_hnd)); /* pointer */
 112         if (hnd->ptr_hnd != 0)
 113         {
 114                 prs_uint32("handle ", ps, depth, &(hnd->handle )); /* enum handle */
 115         }
 116 }
 117
 118 /*******************************************************************
 119 reads or writes a DOM_SID structure.
 120 ********************************************************************/
 121 void smb_io_dom_sid(char *desc,  DOM_SID *sid, prs_struct *ps, int depth)
 122 {
 123         int i;
 124
 125         if (sid == NULL) return;
 126
 127         prs_debug(ps, depth, desc, "smb_io_dom_sid");
 128         depth++;
 129
 130         prs_align(ps);
 131
 132         prs_uint8 ("sid_rev_num", ps, depth, &(sid->sid_rev_num));
 133         prs_uint8 ("num_auths  ", ps, depth, &(sid->num_auths));
 134
 135         for (i = 0; i < 6; i++)
 136         {
 137                 fstring tmp;
 138                 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
 139                 prs_uint8 (tmp, ps, depth, &(sid->id_auth[i]));
 140         }
 141
 142         /* oops! XXXX should really issue a warning here... */
 143         if (sid->num_auths > MAXSUBAUTHS) sid->num_auths = MAXSUBAUTHS;
 144
 145         prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths);
 146 }
 147
 148 /*******************************************************************
 149 creates a DOM_SID2 structure.
 150 ********************************************************************/
 151 void make_dom_sid2(DOM_SID2 *sid2, DOM_SID *sid)
 152 {
 153         sid_copy(&sid2->sid, sid);
 154         sid2->num_auths = sid2->sid.num_auths;
 155 }
 156
 157 /*******************************************************************
 158 reads or writes a DOM_SID2 structure.
 159 ********************************************************************/
 160 void smb_io_dom_sid2(char *desc,  DOM_SID2 *sid, prs_struct *ps, int depth)
 161 {
 162         if (sid == NULL) return;
 163
 164         prs_debug(ps, depth, desc, "smb_io_dom_sid2");
 165         depth++;
 166
 167         prs_align(ps);
 168
 169         prs_uint32("num_auths", ps, depth, &(sid->num_auths));
 170
 171         smb_io_dom_sid("sid", &(sid->sid), ps, depth);
 172 }
 173
 174 /*******************************************************************
 175 creates a STRHDR structure.
 176 ********************************************************************/
 177 void make_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
 178 {
 179         hdr->str_max_len = max_len;
 180         hdr->str_str_len = len;
 181         hdr->buffer      = buffer;
 182 }
 183
 184 /*******************************************************************
 185 reads or writes a STRHDR structure.
 186 ********************************************************************/
 187 void smb_io_strhdr(char *desc,  STRHDR *hdr, prs_struct *ps, int depth)
 188 {
 189         if (hdr == NULL) return;
 190
 191         prs_debug(ps, depth, desc, "smb_io_strhdr");
 192         depth++;
 193
 194         prs_align(ps);
 195
 196         prs_uint16("str_str_len", ps, depth, &(hdr->str_str_len));
 197         prs_uint16("str_max_len", ps, depth, &(hdr->str_max_len));
 198         prs_uint32("buffer     ", ps, depth, &(hdr->buffer     ));
 199
 200         /* oops! XXXX maybe issue a warning that this is happening... */
 201         if (hdr->str_max_len > MAX_STRINGLEN) hdr->str_max_len = MAX_STRINGLEN;
 202         if (hdr->str_str_len > MAX_STRINGLEN) hdr->str_str_len = MAX_STRINGLEN;
 203 }
 204
 205 /*******************************************************************
 206 creates a UNIHDR structure.
 207 ********************************************************************/
 208 void make_uni_hdr(UNIHDR *hdr, int max_len, int len, uint32 buffer)
 209 {
 210         hdr->uni_str_len = 2 * len;
 211         hdr->uni_max_len = 2 * max_len;
 212         hdr->buffer      = buffer;
 213 }
 214
 215 /*******************************************************************
 216 reads or writes a UNIHDR structure.
 217 ********************************************************************/
 218 void smb_io_unihdr(char *desc,  UNIHDR *hdr, prs_struct *ps, int depth)
 219 {
 220         if (hdr == NULL) return;
 221
 222         prs_debug(ps, depth, desc, "smb_io_unihdr");
 223         depth++;
 224
 225         prs_align(ps);
 226
 227         prs_uint16("uni_str_len", ps, depth, &(hdr->uni_str_len));
 228         prs_uint16("uni_max_len", ps, depth, &(hdr->uni_max_len));
 229         prs_uint32("buffer     ", ps, depth, &(hdr->buffer     ));
 230
 231         /* oops! XXXX maybe issue a warning that this is happening... */
 232         if (hdr->uni_max_len > MAX_UNISTRLEN) hdr->uni_max_len = MAX_UNISTRLEN;
 233         if (hdr->uni_str_len > MAX_UNISTRLEN) hdr->uni_str_len = MAX_UNISTRLEN;
 234 }
 235
 236 /*******************************************************************
 237 creates a BUFHDR structure.
 238 ********************************************************************/
 239 void make_buf_hdr(BUFHDR *hdr, int max_len, int len)
 240 {
 241         hdr->buf_max_len = max_len;
 242         hdr->buf_len     = len;
 243 }
 244
 245 /*******************************************************************
 246  prs_uint16 wrapper.  call this and it sets up a pointer to where the
 247  uint16 should be stored, or gets the size if reading
 248  ********************************************************************/
 249 void smb_io_hdrbuf_pre(char *desc,  BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
 250 {
 251         (*offset) = ps->offset;
 252         if (ps->io)
 253         {
 254                 /* reading. */
 255                 smb_io_hdrbuf(desc, hdr, ps, depth);
 256         }
 257         else
 258         {
 259                 ps->offset += sizeof(uint32) * 2;
 260         }
 261 }
 262
 263 /*******************************************************************
 264  smb_io_hdrbuf wrapper.  call this and it retrospectively stores the size.
 265  does nothing on reading, as that is already handled by ...._pre()
 266  ********************************************************************/
 267 void smb_io_hdrbuf_post(char *desc,  BUFHDR *hdr, prs_struct *ps, int depth,
 268                                 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
 269 {
 270         if (!ps->io)
 271         {
 272                 /* storing: go back and do a retrospective job.  i hate this */
 273                 uint32 old_offset = ps->offset;
 274
 275                 make_buf_hdr(hdr, max_len, len);
 276                 ps->offset = ptr_hdrbuf;
 277                 smb_io_hdrbuf(desc, hdr, ps, depth);
 278                 ps->offset = old_offset;
 279         }
 280 }
 281 /*******************************************************************
 282 reads or writes a BUFHDR structure.
 283 ********************************************************************/
 284 void smb_io_hdrbuf(char *desc,  BUFHDR *hdr, prs_struct *ps, int depth)
 285 {
 286         if (hdr == NULL) return;
 287
 288         prs_debug(ps, depth, desc, "smb_io_hdrbuf");
 289         depth++;
 290
 291         prs_align(ps);
 292
 293         prs_uint32("buf_max_len", ps, depth, &(hdr->buf_max_len));
 294         prs_uint32("buf_len    ", ps, depth, &(hdr->buf_len    ));
 295
 296         /* oops! XXXX maybe issue a warning that this is happening... */
 297         if (hdr->buf_max_len > MAX_BUFFERLEN) hdr->buf_max_len = MAX_BUFFERLEN;
 298         if (hdr->buf_len     > MAX_BUFFERLEN) hdr->buf_len     = MAX_BUFFERLEN;
 299 }
 300
 301 /*******************************************************************
 302 creates a UNIHDR2 structure.
 303 ********************************************************************/
 304 void make_uni_hdr2(UNIHDR2 *hdr, int max_len, int len, uint16 terminate)
 305 {
 306         make_uni_hdr(&(hdr->unihdr), max_len, len, terminate);
 307         hdr->buffer = len > 0 ? 1 : 0;
 308 }
 309
 310 /*******************************************************************
 311 reads or writes a UNIHDR2 structure.
 312 ********************************************************************/
 313 void smb_io_unihdr2(char *desc,  UNIHDR2 *hdr2, prs_struct *ps, int depth)
 314 {
 315         if (hdr2 == NULL) return;
 316
 317         prs_debug(ps, depth, desc, "smb_io_unihdr2");
 318         depth++;
 319
 320         prs_align(ps);
 321
 322         smb_io_unihdr("hdr", &(hdr2->unihdr), ps, depth);
 323         prs_uint32("buffer", ps, depth, &(hdr2->buffer));
 324 }
 325
 326 /*******************************************************************
 327 creates a UNISTR structure.
 328 ********************************************************************/
 329 void make_unistr(UNISTR *str, char *buf)
 330 {
 331         ascii_to_unistr(str->buffer, buf, sizeof(str->buffer));
 332 }
 333
 334 /*******************************************************************
 335 reads or writes a UNISTR structure.
 336 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 337 ********************************************************************/
 338 void smb_io_unistr(char *desc,  UNISTR *uni, prs_struct *ps, int depth)
 339 {
 340         if (uni == NULL) return;
 341
 342         prs_debug(ps, depth, desc, "smb_io_unistr");
 343         depth++;
 344
 345         prs_unistr("unistr", ps, depth, uni);
 346 }
 347
 348 /*******************************************************************
 349 creates a BUFFER3 structure from a uint32
 350 ********************************************************************/
 351 void make_buffer3_uint32(BUFFER3 *str, uint32 val)
 352 {
 353         ZERO_STRUCTP(str);
 354
 355         /* set up string lengths. */
 356         str->buf_max_len = sizeof(uint32);
 357         str->buf_len     = sizeof(uint32);
 358
 359         SIVAL(str->buffer, 0, val);
 360 }
 361
 362 /*******************************************************************
 363 creates a BUFFER3 structure.
 364 ********************************************************************/
 365 void make_buffer3_str(BUFFER3 *str, char *buf, int len)
 366 {
 367         ZERO_STRUCTP(str);
 368
 369         /* set up string lengths. */
 370         str->buf_max_len = len * 2;
 371         str->buf_len     = len * 2;
 372
 373         /* store the string (little endian buffer) */
 374         ascii_to_unibuf(str->buffer, buf, str->buf_len);
 375 }
 376
 377 /*******************************************************************
 378 creates a BUFFER3 structure from a hex string.
 379 ********************************************************************/
 380 void make_buffer3_hex(BUFFER3 *str, char *buf)
 381 {
 382         ZERO_STRUCTP(str);
 383         str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
 384 }
 385
 386 /*******************************************************************
 387 creates a BUFFER3 structure.
 388 ********************************************************************/
 389 void make_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
 390 {
 391         ZERO_STRUCTP(str);
 392
 393         /* max buffer size (allocated size) */
 394         str->buf_max_len = len;
 395         if (buf != NULL)
 396         {
 397                 memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
 398         }
 399         str->buf_len = buf != NULL ? len : 0;
 400 }
 401
 402 /*******************************************************************
 403 reads or writes a BUFFER3 structure.
 404      the uni_max_len member tells you how large the buffer is.
 405      the uni_str_len member tells you how much of the buffer is really used.
 406 ********************************************************************/
 407 void smb_io_buffer3(char *desc,  BUFFER3 *buf3, prs_struct *ps, int depth)
 408 {
 409         if (buf3 == NULL) return;
 410
 411         prs_debug(ps, depth, desc, "smb_io_buffer3");
 412         depth++;
 413
 414         prs_align(ps);
 415
 416         prs_uint32("uni_max_len", ps, depth, &(buf3->buf_max_len));
 417         if (buf3->buf_max_len > MAX_UNISTRLEN) buf3->buf_max_len = MAX_UNISTRLEN;
 418
 419         prs_uint8s(True, "buffer     ", ps, depth, buf3->buffer, buf3->buf_max_len);
 420
 421         prs_uint32("buf_len    ", ps, depth, &(buf3->buf_len));
 422         if (buf3->buf_len     > MAX_UNISTRLEN) buf3->buf_len     = MAX_UNISTRLEN;
 423 }
 424
 425 /*******************************************************************
 426 creates a BUFFER2 structure.
 427 ********************************************************************/
 428 void make_buffer2(BUFFER2 *str, uint8 *buf, int len)
 429 {
 430         ZERO_STRUCTP(str);
 431
 432         /* max buffer size (allocated size) */
 433         str->buf_max_len = len;
 434         str->undoc       = 0;
 435         str->buf_len = buf != NULL ? len : 0;
 436
 437         if (buf != NULL)
 438         {
 439                 memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
 440         }
 441 }
 442
 443 /*******************************************************************
 444 reads or writes a BUFFER2 structure.
 445      the uni_max_len member tells you how large the buffer is.
 446      the uni_str_len member tells you how much of the buffer is really used.
 447 ********************************************************************/
 448 void smb_io_buffer2(char *desc,  BUFFER2 *buf2, uint32 buffer, prs_struct *ps, int depth)
 449 {
 450         if (buf2 == NULL) return;
 451
 452         if (buffer)
 453         {
 454                 prs_debug(ps, depth, desc, "smb_io_buffer2");
 455                 depth++;
 456
 457                 prs_align(ps);
 458
 459                 prs_uint32("buf_max_len", ps, depth, &(buf2->buf_max_len));
 460                 prs_uint32("undoc      ", ps, depth, &(buf2->undoc      ));
 461                 prs_uint32("buf_len    ", ps, depth, &(buf2->buf_len));
 462
 463                 /* oops! XXXX maybe issue a warning that this is happening... */
 464                 if (buf2->buf_max_len > MAX_UNISTRLEN) buf2->buf_max_len = MAX_UNISTRLEN;
 465                 if (buf2->buf_len     > MAX_UNISTRLEN) buf2->buf_len     = MAX_UNISTRLEN;
 466
 467                 /* buffer advanced by indicated length of string
 468                    NOT by searching for null-termination */
 469                 prs_buffer2(True, "buffer     ", ps, depth, buf2);
 470         }
 471         else
 472         {
 473                 prs_debug(ps, depth, desc, "smb_io_buffer2 - NULL");
 474                 depth++;
 475                 bzero(buf2, sizeof(*buf2));
 476         }
 477 }
 478
 479 /*******************************************************************
 480 creates a UNISTR2 structure: sets up the buffer, too
 481 ********************************************************************/
 482 void make_buf_unistr2(UNISTR2 *str, uint32 *ptr, char *buf)
 483 {
 484         if (buf != NULL)
 485         {
 486                 *ptr = 1;
 487                 make_unistr2(str, buf, strlen(buf)+1);
 488         }
 489         else
 490         {
 491                 *ptr = 0;
 492                 make_unistr2(str, "", 0);
 493         }
 494 }
 495
 496 /*******************************************************************
 497 copies a UNISTR2 structure.
 498 ********************************************************************/
 499 void copy_unistr2(UNISTR2 *str, UNISTR2 *from)
 500 {
 501         /* set up string lengths. add one if string is not null-terminated */
 502         str->uni_max_len = from->uni_max_len;
 503         str->undoc       = from->undoc;
 504         str->uni_str_len = from->uni_str_len;
 505
 506         /* copy the string */
 507         memcpy(str->buffer, from->buffer, sizeof(from->buffer));
 508 }
 509
 510 /*******************************************************************
 511 creates a STRING2 structure.
 512 ********************************************************************/
 513 void make_string2(STRING2 *str, char *buf, int len)
 514 {
 515   /* set up string lengths. */
 516   str->str_max_len = len;
 517   str->undoc       = 0;
 518   str->str_str_len = len;
 519
 520   /* store the string */
 521   if(len != 0)
 522     memcpy(str->buffer, buf, len);
 523 }
 524
 525 /*******************************************************************
 526 reads or writes a STRING2 structure.
 527 XXXX NOTE: STRING2 structures need NOT be null-terminated.
 528      the str_str_len member tells you how long the string is;
 529      the str_max_len member tells you how large the buffer is.
 530 ********************************************************************/
 531 void smb_io_string2(char *desc,  STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
 532 {
 533         if (str2 == NULL) return;
 534
 535         if (buffer)
 536         {
 537                 prs_debug(ps, depth, desc, "smb_io_string2");
 538                 depth++;
 539
 540                 prs_align(ps);
 541
 542                 prs_uint32("str_max_len", ps, depth, &(str2->str_max_len));
 543                 prs_uint32("undoc      ", ps, depth, &(str2->undoc      ));
 544                 prs_uint32("str_str_len", ps, depth, &(str2->str_str_len));
 545
 546                 /* oops! XXXX maybe issue a warning that this is happening... */
 547                 if (str2->str_max_len > MAX_STRINGLEN) str2->str_max_len = MAX_STRINGLEN;
 548                 if (str2->str_str_len > MAX_STRINGLEN) str2->str_str_len = MAX_STRINGLEN;
 549
 550                 /* buffer advanced by indicated length of string
 551                    NOT by searching for null-termination */
 552                 prs_string2(True, "buffer     ", ps, depth, str2);
 553         }
 554         else
 555         {
 556                 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
 557                 depth++;
 558                 bzero(str2, sizeof(*str2));
 559         }
 560 }
 561
 562 /*******************************************************************
 563 creates a UNISTR2 structure.
 564 ********************************************************************/
 565 void make_unistr2(UNISTR2 *str, const char *buf, int len)
 566 {
 567         ZERO_STRUCTP(str);
 568
 569         /* set up string lengths. */
 570         str->uni_max_len = len;
 571         str->undoc       = 0;
 572         str->uni_str_len = len;
 573
 574         /* store the string (wide chars) */
 575         ascii_to_unistr(str->buffer, buf, len);
 576 }
 577
 578 /*******************************************************************
 579 reads or writes a UNISTR2 structure.
 580 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
 581      the uni_str_len member tells you how long the string is;
 582      the uni_max_len member tells you how large the buffer is.
 583 ********************************************************************/
 584 void smb_io_unistr2(char *desc,  UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
 585 {
 586         if (uni2 == NULL) return;
 587
 588         if (buffer)
 589         {
 590                 prs_debug(ps, depth, desc, "smb_io_unistr2");
 591                 depth++;
 592
 593                 prs_align(ps);
 594
 595                 prs_uint32("uni_max_len", ps, depth, &(uni2->uni_max_len));
 596                 prs_uint32("undoc      ", ps, depth, &(uni2->undoc      ));
 597                 prs_uint32("uni_str_len", ps, depth, &(uni2->uni_str_len));
 598
 599                 /* oops! XXXX maybe issue a warning that this is happening... */
 600                 if (uni2->uni_max_len > MAX_UNISTRLEN) uni2->uni_max_len = MAX_UNISTRLEN;
 601                 if (uni2->uni_str_len > MAX_UNISTRLEN) uni2->uni_str_len = MAX_UNISTRLEN;
 602
 603                 /* buffer advanced by indicated length of string
 604                    NOT by searching for null-termination */
 605                 prs_unistr2(True, "buffer     ", ps, depth, uni2);
 606         }
 607         else
 608         {
 609                 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
 610                 depth++;
 611                 bzero(uni2, sizeof(*uni2));
 612         }
 613 }
 614
 615 /*******************************************************************
 616 creates a DOM_RID2 structure.
 617 ********************************************************************/
 618 void make_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
 619 {
 620         rid2->type    = type;
 621         rid2->rid     = rid;
 622         rid2->rid_idx = idx;
 623 }
 624
 625 /*******************************************************************
 626 reads or writes a DOM_RID2 structure.
 627 ********************************************************************/
 628 void smb_io_dom_rid2(char *desc,  DOM_RID2 *rid2, prs_struct *ps, int depth)
 629 {
 630         if (rid2 == NULL) return;
 631
 632         prs_debug(ps, depth, desc, "smb_io_dom_rid2");
 633         depth++;
 634
 635         prs_align(ps);
 636
 637         prs_uint8("type   ", ps, depth, &(rid2->type));
 638         prs_align(ps);
 639         prs_uint32("rid    ", ps, depth, &(rid2->rid     ));
 640         prs_uint32("rid_idx", ps, depth, &(rid2->rid_idx ));
 641 }
 642
 643 /*******************************************************************
 644 creates a DOM_RID3 structure.
 645 ********************************************************************/
 646 void make_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
 647 {
 648         rid3->rid      = rid;
 649         rid3->type1    = type;
 650         rid3->ptr_type = 0x1; /* non-zero, basically. */
 651         rid3->type2    = 0x1;
 652         rid3->unk      = type;
 653 }
 654
 655 /*******************************************************************
 656 reads or writes a DOM_RID3 structure.
 657 ********************************************************************/
 658 void smb_io_dom_rid3(char *desc,  DOM_RID3 *rid3, prs_struct *ps, int depth)
 659 {
 660         if (rid3 == NULL) return;
 661
 662         prs_debug(ps, depth, desc, "smb_io_dom_rid3");
 663         depth++;
 664
 665         prs_align(ps);
 666
 667         prs_uint32("rid     ", ps, depth, &(rid3->rid     ));
 668         prs_uint32("type1   ", ps, depth, &(rid3->type1   ));
 669         prs_uint32("ptr_type", ps, depth, &(rid3->ptr_type));
 670         prs_uint32("type2   ", ps, depth, &(rid3->type2   ));
 671         prs_uint32("unk     ", ps, depth, &(rid3->unk     ));
 672 }
 673
 674 /*******************************************************************
 675 creates a DOM_RID4 structure.
 676 ********************************************************************/
 677 void make_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
 678 {
 679         rid4->unknown = unknown;
 680         rid4->attr    = attr;
 681         rid4->rid     = rid;
 682 }
 683
 684 /*******************************************************************
 685 makes a DOM_CLNT_SRV structure.
 686 ********************************************************************/
 687 static void make_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
 688 {
 689         if (log == NULL) return;
 690
 691         DEBUG(5,("make_clnt_srv: %d\n", __LINE__));
 692
 693         if (logon_srv != NULL)
 694         {
 695                 log->undoc_buffer = 1;
 696                 make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
 697         }
 698         else
 699         {
 700                 log->undoc_buffer = 0;
 701         }
 702
 703         if (comp_name != NULL)
 704         {
 705                 log->undoc_buffer2 = 1;
 706                 make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
 707         }
 708         else
 709         {
 710                 log->undoc_buffer2 = 0;
 711         }
 712 }
 713
 714 /*******************************************************************
 715 reads or writes a DOM_CLNT_SRV structure.
 716 ********************************************************************/
 717 static void smb_io_clnt_srv(char *desc,  DOM_CLNT_SRV *log, prs_struct *ps, int depth)
 718 {
 719         if (log == NULL) return;
 720
 721         prs_debug(ps, depth, desc, "smb_io_clnt_srv");
 722         depth++;
 723
 724         prs_align(ps);
 725
 726         prs_uint32("undoc_buffer ", ps, depth, &(log->undoc_buffer ));
 727         if (log->undoc_buffer != 0)
 728         {
 729                 smb_io_unistr2("unistr2", &(log->uni_logon_srv), log->undoc_buffer, ps, depth);
 730         }
 731
 732         prs_align(ps);
 733
 734         prs_uint32("undoc_buffer2", ps, depth, &(log->undoc_buffer2));
 735         if (log->undoc_buffer2 != 0)
 736         {
 737                 smb_io_unistr2("unistr2", &(log->uni_comp_name), log->undoc_buffer2, ps, depth);
 738         }
 739 }
 740
 741 /*******************************************************************
 742 makes a DOM_LOG_INFO structure.
 743 ********************************************************************/
 744 void make_log_info(DOM_LOG_INFO *log, char *logon_srv, char *acct_name,
 745                 uint16 sec_chan, char *comp_name)
 746 {
 747         if (log == NULL) return;
 748
 749         DEBUG(5,("make_log_info %d\n", __LINE__));
 750
 751         log->undoc_buffer = 1;
 752
 753         make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
 754         make_unistr2(&(log->uni_acct_name), acct_name, strlen(acct_name)+1);
 755
 756         log->sec_chan = sec_chan;
 757
 758         make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
 759 }
 760
 761 /*******************************************************************
 762 reads or writes a DOM_LOG_INFO structure.
 763 ********************************************************************/
 764 void smb_io_log_info(char *desc,  DOM_LOG_INFO *log, prs_struct *ps, int depth)
 765 {
 766         if (log == NULL) return;
 767
 768         prs_debug(ps, depth, desc, "smb_io_log_info");
 769         depth++;
 770
 771         prs_align(ps);
 772
 773         prs_uint32("undoc_buffer", ps, depth, &(log->undoc_buffer));
 774
 775         smb_io_unistr2("unistr2", &(log->uni_logon_srv), True, ps, depth);
 776         smb_io_unistr2("unistr2", &(log->uni_acct_name), True, ps, depth);
 777
 778         prs_uint16("sec_chan", ps, depth, &(log->sec_chan));
 779
 780         smb_io_unistr2("unistr2", &(log->uni_comp_name), True, ps, depth);
 781 }
 782
 783 /*******************************************************************
 784 reads or writes a DOM_CHAL structure.
 785 ********************************************************************/
 786 void smb_io_chal(char *desc,  DOM_CHAL *chal, prs_struct *ps, int depth)
 787 {
 788         if (chal == NULL) return;
 789
 790         prs_debug(ps, depth, desc, "smb_io_chal");
 791         depth++;
 792
 793         prs_align(ps);
 794
 795         prs_uint8s (False, "data", ps, depth, chal->data, 8);
 796 }
 797
 798 /*******************************************************************
 799 reads or writes a DOM_CRED structure.
 800 ********************************************************************/
 801 void smb_io_cred(char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
 802 {
 803         if (cred == NULL) return;
 804
 805         prs_debug(ps, depth, desc, "smb_io_cred");
 806         depth++;
 807
 808         prs_align(ps);
 809
 810         smb_io_chal ("", &(cred->challenge), ps, depth);
 811         smb_io_utime("", &(cred->timestamp), ps, depth);
 812 }
 813
 814 /*******************************************************************
 815 makes a DOM_CLNT_INFO2 structure.
 816 ********************************************************************/
 817 void make_clnt_info2(DOM_CLNT_INFO2 *clnt,
 818                                 char *logon_srv, char *comp_name,
 819                                 DOM_CRED *clnt_cred)
 820 {
 821         if (clnt == NULL) return;
 822
 823         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
 824
 825         make_clnt_srv(&(clnt->login), logon_srv, comp_name);
 826
 827         if (clnt_cred != NULL)
 828         {
 829                 clnt->ptr_cred = 1;
 830                 memcpy(&(clnt->cred), clnt_cred, sizeof(clnt->cred));
 831         }
 832         else
 833         {
 834                 clnt->ptr_cred = 0;
 835         }
 836 }
 837
 838 /*******************************************************************
 839 reads or writes a DOM_CLNT_INFO2 structure.
 840 ********************************************************************/
 841 void smb_io_clnt_info2(char *desc,  DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
 842 {
 843         if (clnt == NULL) return;
 844
 845         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
 846         depth++;
 847
 848         prs_align(ps);
 849
 850         smb_io_clnt_srv("", &(clnt->login), ps, depth);
 851
 852         prs_align(ps);
 853
 854         prs_uint32("ptr_cred", ps, depth, &(clnt->ptr_cred));
 855         smb_io_cred    ("", &(clnt->cred ), ps, depth);
 856 }
 857
 858 /*******************************************************************
 859 makes a DOM_CLNT_INFO structure.
 860 ********************************************************************/
 861 void make_clnt_info(DOM_CLNT_INFO *clnt,
 862                 char *logon_srv, char *acct_name,
 863                 uint16 sec_chan, char *comp_name,
 864                                 DOM_CRED *cred)
 865 {
 866         if (clnt == NULL || cred == NULL) return;
 867
 868         DEBUG(5,("make_clnt_info\n"));
 869
 870         make_log_info(&(clnt->login), logon_srv, acct_name, sec_chan, comp_name);
 871         memcpy(&(clnt->cred), cred, sizeof(clnt->cred));
 872 }
 873
 874 /*******************************************************************
 875 reads or writes a DOM_CLNT_INFO structure.
 876 ********************************************************************/
 877 void smb_io_clnt_info(char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
 878 {
 879         if (clnt == NULL) return;
 880
 881         prs_debug(ps, depth, desc, "smb_io_clnt_info");
 882         depth++;
 883
 884         prs_align(ps);
 885
 886         smb_io_log_info("", &(clnt->login), ps, depth);
 887         smb_io_cred    ("", &(clnt->cred ), ps, depth);
 888 }
 889
 890 /*******************************************************************
 891 makes a DOM_LOGON_ID structure.
 892 ********************************************************************/
 893 void make_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
 894 {
 895         if (log == NULL) return;
 896
 897         DEBUG(5,("make_logon_id: %d\n", __LINE__));
 898
 899         log->low  = log_id_low;
 900         log->high = log_id_high;
 901 }
 902
 903 /*******************************************************************
 904 reads or writes a DOM_LOGON_ID structure.
 905 ********************************************************************/
 906 void smb_io_logon_id(char *desc,  DOM_LOGON_ID *log, prs_struct *ps, int depth)
 907 {
 908         if (log == NULL) return;
 909
 910         prs_debug(ps, depth, desc, "smb_io_logon_id");
 911         depth++;
 912
 913         prs_align(ps);
 914
 915         prs_uint32("low ", ps, depth, &(log->low ));
 916         prs_uint32("high", ps, depth, &(log->high));
 917 }
 918
 919 /*******************************************************************
 920 makes an OWF_INFO structure.
 921 ********************************************************************/
 922 void make_owf_info(OWF_INFO *hash, uint8 data[16])
 923 {
 924         if (hash == NULL) return;
 925
 926         DEBUG(5,("make_owf_info: %d\n", __LINE__));
 927
 928         if (data != NULL)
 929         {
 930                 memcpy(hash->data, data, sizeof(hash->data));
 931         }
 932         else
 933         {
 934                 bzero(hash->data, sizeof(hash->data));
 935         }
 936 }
 937
 938 /*******************************************************************
 939 reads or writes an OWF_INFO structure.
 940 ********************************************************************/
 941 void smb_io_owf_info(char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
 942 {
 943         if (hash == NULL) return;
 944
 945         prs_debug(ps, depth, desc, "smb_io_owf_info");
 946         depth++;
 947
 948         prs_align(ps);
 949
 950         prs_uint8s (False, "data", ps, depth, hash->data, 16);
 951 }
 952
 953 /*******************************************************************
 954 reads or writes a DOM_GID structure.
 955 ********************************************************************/
 956 void smb_io_gid(char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
 957 {
 958         if (gid == NULL) return;
 959
 960         prs_debug(ps, depth, desc, "smb_io_gid");
 961         depth++;
 962
 963         prs_align(ps);
 964
 965         prs_uint32("g_rid", ps, depth, &(gid->g_rid));
 966         prs_uint32("attr ", ps, depth, &(gid->attr ));
 967 }
 968
 969 /*******************************************************************
 970 reads or writes an POLICY_HND structure.
 971 ********************************************************************/
 972 void smb_io_pol_hnd(char *desc,  POLICY_HND *pol, prs_struct *ps, int depth)
 973 {
 974         if (pol == NULL) return;
 975
 976         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
 977         depth++;
 978
 979         prs_align(ps);
 980
 981         prs_uint8s (False, "data", ps, depth, pol->data, POL_HND_SIZE);
 982 }
 983
 984 /*******************************************************************
 985 reads or writes a dom query structure.
 986 ********************************************************************/
 987 static void smb_io_dom_query(char *desc,  DOM_QUERY *d_q, prs_struct *ps, int depth)
 988 {
 989         if (d_q == NULL) return;
 990
 991         prs_debug(ps, depth, desc, "smb_io_dom_query");
 992         depth++;
 993
 994         prs_align(ps);
 995
 996         prs_uint16("uni_dom_max_len", ps, depth, &(d_q->uni_dom_max_len)); /* domain name string length * 2 */
 997         prs_uint16("uni_dom_str_len", ps, depth, &(d_q->uni_dom_str_len)); /* domain name string length * 2 */
 998
 999         prs_uint32("buffer_dom_name", ps, depth, &(d_q->buffer_dom_name)); /* undocumented domain name string buffer pointer */
1000         prs_uint32("buffer_dom_sid ", ps, depth, &(d_q->buffer_dom_sid )); /* undocumented domain SID string buffer pointer */
1001
1002         smb_io_unistr2("unistr2", &(d_q->uni_domain_name), d_q->buffer_dom_name, ps, depth); /* domain name (unicode string) */
1003
1004         if (d_q->buffer_dom_sid != 0)
1005         {
1006                 smb_io_dom_sid2("", &(d_q->dom_sid), ps, depth); /* domain SID */
1007         }
1008         else
1009         {
1010                 bzero(&(d_q->dom_sid), sizeof(d_q->dom_sid));
1011         }
1012 }
1013
1014 /*******************************************************************
1015 reads or writes a dom query structure.
1016 ********************************************************************/
1017 void smb_io_dom_query_3(char *desc,  DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1018 {
1019         smb_io_dom_query("", d_q, ps, depth);
1020 }
1021
1022 /*******************************************************************
1023 reads or writes a dom query structure.
1024 ********************************************************************/
1025 void smb_io_dom_query_5(char *desc,  DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1026 {
1027         smb_io_dom_query("", d_q, ps, depth);
1028 }
1029
1030
1031 /*******************************************************************
1032 reads or writes a UNISTR3 structure.
1033 ********************************************************************/
1034 void smb_io_unistr3(char *desc,  UNISTR3 *name, prs_struct *ps, int depth)
1035 {
1036         if (name == NULL) return;
1037
1038         prs_debug(ps, depth, desc, "smb_io_unistr3");
1039         depth++;
1040
1041         prs_align(ps);
1042
1043         prs_uint32("uni_str_len", ps, depth, &(name->uni_str_len));
1044
1045         /* don't know if len is specified by uni_str_len member... */
1046         /* assume unicode string is unicode-null-terminated, instead */
1047
1048         prs_unistr3(True, "unistr", name, ps, depth);
1049 }
1050
1051