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         /* store the string (null-terminated copy) */
 332         struni2(str->buffer, buf);
 333 }
 334
 335 /*******************************************************************
 336 reads or writes a UNISTR structure.
 337 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 338 ********************************************************************/
 339 void smb_io_unistr(char *desc,  UNISTR *uni, prs_struct *ps, int depth)
 340 {
 341         if (uni == NULL) return;
 342
 343         prs_debug(ps, depth, desc, "smb_io_unistr");
 344         depth++;
 345
 346         prs_align(ps);
 347         prs_unistr("unistr", ps, depth, uni);
 348 }
 349
 350 /*******************************************************************
 351 creates a BUFFER3 structure from a uint32
 352 ********************************************************************/
 353 void make_buffer3_uint32(BUFFER3 *str, uint32 val)
 354 {
 355         ZERO_STRUCTP(str);
 356
 357         /* set up string lengths. */
 358         str->buf_max_len = sizeof(uint32);
 359         str->buf_len     = sizeof(uint32);
 360
 361         SIVAL(str->buffer, 0, val);
 362 }
 363
 364 /*******************************************************************
 365 creates a BUFFER3 structure.
 366 ********************************************************************/
 367 void make_buffer3_str(BUFFER3 *str, char *buf, int len)
 368 {
 369         ZERO_STRUCTP(str);
 370
 371         /* set up string lengths. */
 372         str->buf_max_len = len * 2;
 373         str->buf_len     = len * 2;
 374
 375         /* store the string (null-terminated 8 bit chars into 16 bit chars) */
 376         struni2((uint16*)str->buffer, buf);
 377 }
 378
 379 /*******************************************************************
 380 creates a BUFFER3 structure from a hex string.
 381 ********************************************************************/
 382 void make_buffer3_hex(BUFFER3 *str, char *buf)
 383 {
 384         ZERO_STRUCTP(str);
 385         str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
 386 }
 387
 388 /*******************************************************************
 389 creates a BUFFER3 structure.
 390 ********************************************************************/
 391 void make_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
 392 {
 393         ZERO_STRUCTP(str);
 394
 395         /* max buffer size (allocated size) */
 396         str->buf_max_len = len;
 397         if (buf != NULL)
 398         {
 399                 memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
 400         }
 401         str->buf_len = buf != NULL ? len : 0;
 402 }
 403
 404 /*******************************************************************
 405 reads or writes a BUFFER3 structure.
 406      the uni_max_len member tells you how large the buffer is.
 407      the uni_str_len member tells you how much of the buffer is really used.
 408 ********************************************************************/
 409 void smb_io_buffer3(char *desc,  BUFFER3 *buf3, prs_struct *ps, int depth)
 410 {
 411         if (buf3 == NULL) return;
 412
 413         prs_debug(ps, depth, desc, "smb_io_buffer3");
 414         depth++;
 415
 416         prs_align(ps);
 417
 418         prs_uint32("uni_max_len", ps, depth, &(buf3->buf_max_len));
 419         if (buf3->buf_max_len > MAX_UNISTRLEN) buf3->buf_max_len = MAX_UNISTRLEN;
 420
 421         prs_uint8s(True, "buffer     ", ps, depth, buf3->buffer, buf3->buf_max_len);
 422
 423         prs_uint32("buf_len    ", ps, depth, &(buf3->buf_len));
 424         if (buf3->buf_len     > MAX_UNISTRLEN) buf3->buf_len     = MAX_UNISTRLEN;
 425 }
 426
 427 /*******************************************************************
 428 creates a BUFFER2 structure.
 429 ********************************************************************/
 430 void make_buffer2(BUFFER2 *str, uint8 *buf, int len)
 431 {
 432         ZERO_STRUCTP(str);
 433
 434         /* max buffer size (allocated size) */
 435         str->buf_max_len = len;
 436         str->undoc       = 0;
 437         str->buf_len = buf != NULL ? len : 0;
 438
 439         if (buf != NULL)
 440         {
 441                 memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
 442         }
 443 }
 444
 445 /*******************************************************************
 446 reads or writes a BUFFER2 structure.
 447      the uni_max_len member tells you how large the buffer is.
 448      the uni_str_len member tells you how much of the buffer is really used.
 449 ********************************************************************/
 450 void smb_io_buffer2(char *desc,  BUFFER2 *buf2, uint32 buffer, prs_struct *ps, int depth)
 451 {
 452         if (buf2 == NULL) return;
 453
 454         if (buffer)
 455         {
 456                 prs_debug(ps, depth, desc, "smb_io_buffer2");
 457                 depth++;
 458
 459                 prs_align(ps);
 460
 461                 prs_uint32("uni_max_len", ps, depth, &(buf2->buf_max_len));
 462                 prs_uint32("undoc      ", ps, depth, &(buf2->undoc      ));
 463                 prs_uint32("buf_len    ", ps, depth, &(buf2->buf_len));
 464
 465                 /* oops! XXXX maybe issue a warning that this is happening... */
 466                 if (buf2->buf_max_len > MAX_UNISTRLEN) buf2->buf_max_len = MAX_UNISTRLEN;
 467                 if (buf2->buf_len     > MAX_UNISTRLEN) buf2->buf_len     = MAX_UNISTRLEN;
 468
 469                 /* buffer advanced by indicated length of string
 470                    NOT by searching for null-termination */
 471                 prs_buffer2(True, "buffer     ", ps, depth, buf2);
 472         }
 473         else
 474         {
 475                 prs_debug(ps, depth, desc, "smb_io_buffer2 - NULL");
 476                 depth++;
 477                 bzero(buf2, sizeof(*buf2));
 478         }
 479 }
 480
 481 /*******************************************************************
 482 creates a UNISTR2 structure: sets up the buffer, too
 483 ********************************************************************/
 484 void make_buf_unistr2(UNISTR2 *str, uint32 *ptr, char *buf)
 485 {
 486         if (buf != NULL)
 487         {
 488                 *ptr = 1;
 489                 make_unistr2(str, buf, strlen(buf)+1);
 490         }
 491         else
 492         {
 493                 *ptr = 0;
 494                 make_unistr2(str, "", 0);
 495         }
 496 }
 497
 498 /*******************************************************************
 499 copies a UNISTR2 structure.
 500 ********************************************************************/
 501 void copy_unistr2(UNISTR2 *str, UNISTR2 *from)
 502 {
 503         /* set up string lengths. add one if string is not null-terminated */
 504         str->uni_max_len = from->uni_max_len;
 505         str->undoc       = from->undoc;
 506         str->uni_str_len = from->uni_str_len;
 507
 508         /* copy the string */
 509         memcpy(str->buffer, from->buffer, sizeof(from->buffer));
 510 }
 511
 512 /*******************************************************************
 513 creates a STRING2 structure.
 514 ********************************************************************/
 515 void make_string2(STRING2 *str, char *buf, int len)
 516 {
 517   /* set up string lengths. */
 518   str->str_max_len = len;
 519   str->undoc       = 0;
 520   str->str_str_len = len;
 521
 522   /* store the string */
 523   if(len != 0)
 524     memcpy(str->buffer, buf, len);
 525 }
 526
 527 /*******************************************************************
 528 reads or writes a STRING2 structure.
 529 XXXX NOTE: STRING2 structures need NOT be null-terminated.
 530      the str_str_len member tells you how long the string is;
 531      the str_max_len member tells you how large the buffer is.
 532 ********************************************************************/
 533 void smb_io_string2(char *desc,  STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
 534 {
 535         if (str2 == NULL) return;
 536
 537         if (buffer)
 538         {
 539                 prs_debug(ps, depth, desc, "smb_io_string2");
 540                 depth++;
 541
 542                 prs_align(ps);
 543
 544                 prs_uint32("str_max_len", ps, depth, &(str2->str_max_len));
 545                 prs_uint32("undoc      ", ps, depth, &(str2->undoc      ));
 546                 prs_uint32("str_str_len", ps, depth, &(str2->str_str_len));
 547
 548                 /* oops! XXXX maybe issue a warning that this is happening... */
 549                 if (str2->str_max_len > MAX_STRINGLEN) str2->str_max_len = MAX_STRINGLEN;
 550                 if (str2->str_str_len > MAX_STRINGLEN) str2->str_str_len = MAX_STRINGLEN;
 551
 552                 /* buffer advanced by indicated length of string
 553                    NOT by searching for null-termination */
 554                 prs_string2(True, "buffer     ", ps, depth, str2);
 555         }
 556         else
 557         {
 558                 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
 559                 depth++;
 560                 bzero(str2, sizeof(*str2));
 561         }
 562 }
 563
 564 /*******************************************************************
 565 creates a UNISTR2 structure.
 566 ********************************************************************/
 567 void make_unistr2(UNISTR2 *str, char *buf, int len)
 568 {
 569         ZERO_STRUCTP(str);
 570
 571         /* set up string lengths. */
 572         str->uni_max_len = len;
 573         str->undoc       = 0;
 574         str->uni_str_len = len;
 575
 576         /* store the string (null-terminated 8 bit chars into 16 bit chars) */
 577         struni2(str->buffer, buf);
 578 }
 579
 580 /*******************************************************************
 581 reads or writes a UNISTR2 structure.
 582 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
 583      the uni_str_len member tells you how long the string is;
 584      the uni_max_len member tells you how large the buffer is.
 585 ********************************************************************/
 586 void smb_io_unistr2(char *desc,  UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
 587 {
 588         if (uni2 == NULL) return;
 589
 590         if (buffer)
 591         {
 592                 prs_debug(ps, depth, desc, "smb_io_unistr2");
 593                 depth++;
 594
 595                 prs_align(ps);
 596
 597                 prs_uint32("uni_max_len", ps, depth, &(uni2->uni_max_len));
 598                 prs_uint32("undoc      ", ps, depth, &(uni2->undoc      ));
 599                 prs_uint32("uni_str_len", ps, depth, &(uni2->uni_str_len));
 600
 601                 /* oops! XXXX maybe issue a warning that this is happening... */
 602                 if (uni2->uni_max_len > MAX_UNISTRLEN) uni2->uni_max_len = MAX_UNISTRLEN;
 603                 if (uni2->uni_str_len > MAX_UNISTRLEN) uni2->uni_str_len = MAX_UNISTRLEN;
 604
 605                 /* buffer advanced by indicated length of string
 606                    NOT by searching for null-termination */
 607                 prs_unistr2(True, "buffer     ", ps, depth, uni2);
 608         }
 609         else
 610         {
 611                 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
 612                 depth++;
 613                 bzero(uni2, sizeof(*uni2));
 614         }
 615 }
 616
 617 /*******************************************************************
 618 creates a DOM_RID2 structure.
 619 ********************************************************************/
 620 void make_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type)
 621 {
 622         rid2->type    = type;
 623         rid2->rid     = rid;
 624         rid2->rid_idx = 0;
 625 }
 626
 627 /*******************************************************************
 628 reads or writes a DOM_RID2 structure.
 629 ********************************************************************/
 630 void smb_io_dom_rid2(char *desc,  DOM_RID2 *rid2, prs_struct *ps, int depth)
 631 {
 632         if (rid2 == NULL) return;
 633
 634         prs_debug(ps, depth, desc, "smb_io_dom_rid2");
 635         depth++;
 636
 637         prs_align(ps);
 638
 639         prs_uint8("type   ", ps, depth, &(rid2->type));
 640         prs_align(ps);
 641         prs_uint32("rid    ", ps, depth, &(rid2->rid     ));
 642         prs_uint32("rid_idx", ps, depth, &(rid2->rid_idx ));
 643 }
 644
 645 /*******************************************************************
 646 creates a DOM_RID3 structure.
 647 ********************************************************************/
 648 void make_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
 649 {
 650         rid3->rid      = rid;
 651         rid3->type1    = type;
 652         rid3->ptr_type = 0x1; /* non-zero, basically. */
 653         rid3->type2    = 0x1;
 654 }
 655
 656 /*******************************************************************
 657 reads or writes a DOM_RID3 structure.
 658 ********************************************************************/
 659 void smb_io_dom_rid3(char *desc,  DOM_RID3 *rid3, prs_struct *ps, int depth)
 660 {
 661         if (rid3 == NULL) return;
 662
 663         prs_debug(ps, depth, desc, "smb_io_dom_rid3");
 664         depth++;
 665
 666         prs_align(ps);
 667
 668         prs_uint32("rid     ", ps, depth, &(rid3->rid     ));
 669         prs_uint32("type1   ", ps, depth, &(rid3->type1   ));
 670         prs_uint32("ptr_type", ps, depth, &(rid3->ptr_type));
 671         prs_uint32("type2   ", ps, depth, &(rid3->type2   ));
 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 /*******************************************************************
 686 makes a DOM_CLNT_SRV structure.
 687 ********************************************************************/
 688 static void make_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
 689 {
 690         if (log == NULL) return;
 691
 692         DEBUG(5,("make_clnt_srv: %d\n", __LINE__));
 693
 694         if (logon_srv != NULL)
 695         {
 696                 log->undoc_buffer = 1;
 697                 make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
 698         }
 699         else
 700         {
 701                 log->undoc_buffer = 0;
 702         }
 703
 704         if (comp_name != NULL)
 705         {
 706                 log->undoc_buffer2 = 1;
 707                 make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
 708         }
 709         else
 710         {
 711                 log->undoc_buffer2 = 0;
 712         }
 713 }
 714
 715 /*******************************************************************
 716 reads or writes a DOM_CLNT_SRV structure.
 717 ********************************************************************/
 718 static void smb_io_clnt_srv(char *desc,  DOM_CLNT_SRV *log, prs_struct *ps, int depth)
 719 {
 720         if (log == NULL) return;
 721
 722         prs_debug(ps, depth, desc, "smb_io_clnt_srv");
 723         depth++;
 724
 725         prs_align(ps);
 726
 727         prs_uint32("undoc_buffer ", ps, depth, &(log->undoc_buffer ));
 728         if (log->undoc_buffer != 0)
 729         {
 730                 smb_io_unistr2("unistr2", &(log->uni_logon_srv), log->undoc_buffer, ps, depth);
 731         }
 732
 733         prs_align(ps);
 734
 735         prs_uint32("undoc_buffer2", ps, depth, &(log->undoc_buffer2));
 736         if (log->undoc_buffer2 != 0)
 737         {
 738                 smb_io_unistr2("unistr2", &(log->uni_comp_name), log->undoc_buffer2, ps, depth);
 739         }
 740 }
 741
 742 /*******************************************************************
 743 makes a DOM_LOG_INFO structure.
 744 ********************************************************************/
 745 void make_log_info(DOM_LOG_INFO *log, char *logon_srv, char *acct_name,
 746                 uint16 sec_chan, char *comp_name)
 747 {
 748         if (log == NULL) return;
 749
 750         DEBUG(5,("make_log_info %d\n", __LINE__));
 751
 752         log->undoc_buffer = 1;
 753
 754         make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
 755         make_unistr2(&(log->uni_acct_name), acct_name, strlen(acct_name)+1);
 756
 757         log->sec_chan = sec_chan;
 758
 759         make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
 760 }
 761
 762 /*******************************************************************
 763 reads or writes a DOM_LOG_INFO structure.
 764 ********************************************************************/
 765 void smb_io_log_info(char *desc,  DOM_LOG_INFO *log, prs_struct *ps, int depth)
 766 {
 767         if (log == NULL) return;
 768
 769         prs_debug(ps, depth, desc, "smb_io_log_info");
 770         depth++;
 771
 772         prs_align(ps);
 773
 774         prs_uint32("undoc_buffer", ps, depth, &(log->undoc_buffer));
 775
 776         smb_io_unistr2("unistr2", &(log->uni_logon_srv), True, ps, depth);
 777         smb_io_unistr2("unistr2", &(log->uni_acct_name), True, ps, depth);
 778
 779         prs_uint16("sec_chan", ps, depth, &(log->sec_chan));
 780
 781         smb_io_unistr2("unistr2", &(log->uni_comp_name), True, ps, depth);
 782 }
 783
 784 /*******************************************************************
 785 reads or writes a DOM_CHAL structure.
 786 ********************************************************************/
 787 void smb_io_chal(char *desc,  DOM_CHAL *chal, prs_struct *ps, int depth)
 788 {
 789         if (chal == NULL) return;
 790
 791         prs_debug(ps, depth, desc, "smb_io_chal");
 792         depth++;
 793
 794         prs_align(ps);
 795
 796         prs_uint8s (False, "data", ps, depth, chal->data, 8);
 797 }
 798
 799 /*******************************************************************
 800 reads or writes a DOM_CRED structure.
 801 ********************************************************************/
 802 void smb_io_cred(char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
 803 {
 804         if (cred == NULL) return;
 805
 806         prs_debug(ps, depth, desc, "smb_io_cred");
 807         depth++;
 808
 809         prs_align(ps);
 810
 811         smb_io_chal ("", &(cred->challenge), ps, depth);
 812         smb_io_utime("", &(cred->timestamp), ps, depth);
 813 }
 814
 815 /*******************************************************************
 816 makes a DOM_CLNT_INFO2 structure.
 817 ********************************************************************/
 818 void make_clnt_info2(DOM_CLNT_INFO2 *clnt,
 819                                 char *logon_srv, char *comp_name,
 820                                 DOM_CRED *clnt_cred)
 821 {
 822         if (clnt == NULL) return;
 823
 824         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
 825
 826         make_clnt_srv(&(clnt->login), logon_srv, comp_name);
 827
 828         if (clnt_cred != NULL)
 829         {
 830                 clnt->ptr_cred = 1;
 831                 memcpy(&(clnt->cred), clnt_cred, sizeof(clnt->cred));
 832         }
 833         else
 834         {
 835                 clnt->ptr_cred = 0;
 836         }
 837 }
 838
 839 /*******************************************************************
 840 reads or writes a DOM_CLNT_INFO2 structure.
 841 ********************************************************************/
 842 void smb_io_clnt_info2(char *desc,  DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
 843 {
 844         if (clnt == NULL) return;
 845
 846         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
 847         depth++;
 848
 849         prs_align(ps);
 850
 851         smb_io_clnt_srv("", &(clnt->login), ps, depth);
 852
 853         prs_align(ps);
 854
 855         prs_uint32("ptr_cred", ps, depth, &(clnt->ptr_cred));
 856         smb_io_cred    ("", &(clnt->cred ), ps, depth);
 857 }
 858
 859 /*******************************************************************
 860 makes a DOM_CLNT_INFO structure.
 861 ********************************************************************/
 862 void make_clnt_info(DOM_CLNT_INFO *clnt,
 863                 char *logon_srv, char *acct_name,
 864                 uint16 sec_chan, char *comp_name,
 865                                 DOM_CRED *cred)
 866 {
 867         if (clnt == NULL || cred == NULL) return;
 868
 869         DEBUG(5,("make_clnt_info\n"));
 870
 871         make_log_info(&(clnt->login), logon_srv, acct_name, sec_chan, comp_name);
 872         memcpy(&(clnt->cred), cred, sizeof(clnt->cred));
 873 }
 874
 875 /*******************************************************************
 876 reads or writes a DOM_CLNT_INFO structure.
 877 ********************************************************************/
 878 void smb_io_clnt_info(char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
 879 {
 880         if (clnt == NULL) return;
 881
 882         prs_debug(ps, depth, desc, "smb_io_clnt_info");
 883         depth++;
 884
 885         prs_align(ps);
 886
 887         smb_io_log_info("", &(clnt->login), ps, depth);
 888         smb_io_cred    ("", &(clnt->cred ), ps, depth);
 889 }
 890
 891 /*******************************************************************
 892 makes a DOM_LOGON_ID structure.
 893 ********************************************************************/
 894 void make_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
 895 {
 896         if (log == NULL) return;
 897
 898         DEBUG(5,("make_logon_id: %d\n", __LINE__));
 899
 900         log->low  = log_id_low;
 901         log->high = log_id_high;
 902 }
 903
 904 /*******************************************************************
 905 reads or writes a DOM_LOGON_ID structure.
 906 ********************************************************************/
 907 void smb_io_logon_id(char *desc,  DOM_LOGON_ID *log, prs_struct *ps, int depth)
 908 {
 909         if (log == NULL) return;
 910
 911         prs_debug(ps, depth, desc, "smb_io_logon_id");
 912         depth++;
 913
 914         prs_align(ps);
 915
 916         prs_uint32("low ", ps, depth, &(log->low ));
 917         prs_uint32("high", ps, depth, &(log->high));
 918 }
 919
 920 /*******************************************************************
 921 makes an OWF_INFO structure.
 922 ********************************************************************/
 923 void make_owf_info(OWF_INFO *hash, uint8 data[16])
 924 {
 925         if (hash == NULL) return;
 926
 927         DEBUG(5,("make_owf_info: %d\n", __LINE__));
 928
 929         if (data != NULL)
 930         {
 931                 memcpy(hash->data, data, sizeof(hash->data));
 932         }
 933         else
 934         {
 935                 bzero(hash->data, sizeof(hash->data));
 936         }
 937 }
 938
 939 /*******************************************************************
 940 reads or writes an OWF_INFO structure.
 941 ********************************************************************/
 942 void smb_io_owf_info(char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
 943 {
 944         if (hash == NULL) return;
 945
 946         prs_debug(ps, depth, desc, "smb_io_owf_info");
 947         depth++;
 948
 949         prs_align(ps);
 950
 951         prs_uint8s (False, "data", ps, depth, hash->data, 16);
 952 }
 953
 954 /*******************************************************************
 955 reads or writes a DOM_GID structure.
 956 ********************************************************************/
 957 void smb_io_gid(char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
 958 {
 959         if (gid == NULL) return;
 960
 961         prs_debug(ps, depth, desc, "smb_io_gid");
 962         depth++;
 963
 964         prs_align(ps);
 965
 966         prs_uint32("g_rid", ps, depth, &(gid->g_rid));
 967         prs_uint32("attr ", ps, depth, &(gid->attr ));
 968 }
 969
 970 /*******************************************************************
 971 reads or writes an POLICY_HND structure.
 972 ********************************************************************/
 973 void smb_io_pol_hnd(char *desc,  POLICY_HND *pol, prs_struct *ps, int depth)
 974 {
 975         if (pol == NULL) return;
 976
 977         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
 978         depth++;
 979
 980         prs_align(ps);
 981
 982         prs_uint8s (False, "data", ps, depth, pol->data, POL_HND_SIZE);
 983 }
 984
 985 /*******************************************************************
 986 reads or writes a dom query structure.
 987 ********************************************************************/
 988 static void smb_io_dom_query(char *desc,  DOM_QUERY *d_q, prs_struct *ps, int depth)
 989 {
 990         if (d_q == NULL) return;
 991
 992         prs_debug(ps, depth, desc, "smb_io_dom_query");
 993         depth++;
 994
 995         prs_align(ps);
 996
 997         prs_uint16("uni_dom_max_len", ps, depth, &(d_q->uni_dom_max_len)); /* domain name string length * 2 */
 998         prs_uint16("uni_dom_str_len", ps, depth, &(d_q->uni_dom_str_len)); /* domain name string length * 2 */
 999
1000         prs_uint32("buffer_dom_name", ps, depth, &(d_q->buffer_dom_name)); /* undocumented domain name string buffer pointer */
1001         prs_uint32("buffer_dom_sid ", ps, depth, &(d_q->buffer_dom_sid )); /* undocumented domain SID string buffer pointer */
1002
1003         smb_io_unistr2("unistr2", &(d_q->uni_domain_name), d_q->buffer_dom_name, ps, depth); /* domain name (unicode string) */
1004
1005         if (d_q->buffer_dom_sid != 0)
1006         {
1007                 smb_io_dom_sid2("", &(d_q->dom_sid), ps, depth); /* domain SID */
1008         }
1009         else
1010         {
1011                 bzero(&(d_q->dom_sid), sizeof(d_q->dom_sid));
1012         }
1013 }
1014
1015 /*******************************************************************
1016 reads or writes a dom query structure.
1017 ********************************************************************/
1018 void smb_io_dom_query_3(char *desc,  DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1019 {
1020         smb_io_dom_query("", d_q, ps, depth);
1021 }
1022
1023 /*******************************************************************
1024 reads or writes a dom query structure.
1025 ********************************************************************/
1026 void smb_io_dom_query_5(char *desc,  DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1027 {
1028         smb_io_dom_query("", d_q, ps, depth);
1029 }
1030
1031
1032 /*******************************************************************
1033 reads or writes a UNISTR3 structure.
1034 ********************************************************************/
1035 void smb_io_unistr3(char *desc,  UNISTR3 *name, prs_struct *ps, int depth)
1036 {
1037         if (name == NULL) return;
1038
1039         prs_debug(ps, depth, desc, "smb_io_unistr3");
1040         depth++;
1041
1042         prs_align(ps);
1043
1044         prs_uint32("uni_str_len", ps, depth, &(name->uni_str_len));
1045
1046         /* don't know if len is specified by uni_str_len member... */
1047         /* assume unicode string is unicode-null-terminated, instead */
1048
1049         prs_unistr3(True, "unistr", name, ps, depth);
1050 }
1051
1052