source/smbparse.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Luke Leighton 1996 - 1997  Paul Ashton 1997
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25
  26 /*******************************************************************
  27 reads or writes a UTIME type.
  28 ********************************************************************/
  29 char* smb_io_utime(BOOL io, UTIME *t, char *q, char *base, int align, int depth)
  30 {
  31         if (t == NULL) return NULL;
  32
  33         DEBUG(5,("%s%04x smb_io_utime\n",  tab_depth(depth), PTR_DIFF(q, base)));
  34         depth++;
  35
  36         q = align_offset(q, base, align);
  37
  38         DBG_RW_IVAL ("time", depth, base, io, q, t->time); q += 4;
  39
  40         return q;
  41 }
  42
  43 /*******************************************************************
  44 reads or writes an NTTIME structure.
  45 ********************************************************************/
  46 char* smb_io_time(BOOL io, NTTIME *nttime, char *q, char *base, int align, int depth)
  47 {
  48         if (nttime == NULL) return NULL;
  49
  50         DEBUG(5,("%s%04x smb_io_time\n",  tab_depth(depth), PTR_DIFF(q, base)));
  51         depth++;
  52
  53         q = align_offset(q, base, align);
  54
  55         DBG_RW_IVAL("low ", depth, base, io, q, nttime->low ); q += 4; /* low part */
  56         DBG_RW_IVAL("high", depth, base, io, q, nttime->high); q += 4; /* high part */
  57
  58         return q;
  59 }
  60
  61 /*******************************************************************
  62 creates a DOM_SID structure.
  63
  64 BIG NOTE: this function only does SIDS where the identauth is not >= 2^32
  65 identauth >= 2^32 can be detected because it will be specified in hex
  66
  67 ********************************************************************/
  68 void make_dom_sid(DOM_SID *sid, char *domsid)
  69 {
  70         int identauth;
  71         char *p;
  72
  73         if (sid == NULL) return;
  74
  75         if (domsid == NULL)
  76         {
  77                 DEBUG(4,("netlogon domain SID: none\n"));
  78                 sid->sid_rev_num = 0;
  79                 sid->num_auths = 0;
  80                 return;
  81         }
  82
  83         DEBUG(4,("netlogon domain SID: %s\n", domsid));
  84
  85         /* assume, but should check, that domsid starts "S-" */
  86         p = strtok(domsid+2,"-");
  87         sid->sid_rev_num = atoi(p);
  88
  89         /* identauth in decimal should be <  2^32 */
  90         /* identauth in hex     should be >= 2^32 */
  91         identauth = atoi(strtok(0,"-"));
  92
  93         DEBUG(4,("netlogon rev %d\n", sid->sid_rev_num));
  94         DEBUG(4,("netlogon %s ia %d\n", p, identauth));
  95
  96         sid->id_auth[0] = 0;
  97         sid->id_auth[1] = 0;
  98         sid->id_auth[2] = (identauth & 0xff000000) >> 24;
  99         sid->id_auth[3] = (identauth & 0x00ff0000) >> 16;
 100         sid->id_auth[4] = (identauth & 0x0000ff00) >> 8;
 101         sid->id_auth[5] = (identauth & 0x000000ff);
 102
 103         sid->num_auths = 0;
 104
 105         while ((p = strtok(0, "-")) != NULL)
 106         {
 107                 sid->sub_auths[sid->num_auths++] = atoi(p);
 108         }
 109 }
 110
 111 /*******************************************************************
 112 reads or writes a DOM_SID structure.
 113 ********************************************************************/
 114 char* smb_io_dom_sid(BOOL io, DOM_SID *sid, char *q, char *base, int align, int depth)
 115 {
 116         int i;
 117
 118         if (sid == NULL) return NULL;
 119
 120         DEBUG(5,("%s%04x smb_io_dom_sid\n",  tab_depth(depth), PTR_DIFF(q, base)));
 121         depth++;
 122
 123         q = align_offset(q, base, align);
 124
 125         DBG_RW_IVAL("num_auths  ", depth, base, io, q, sid->num_auths); q += 4;
 126         DBG_RW_CVAL("sid_rev_num", depth, base, io, q, sid->sid_rev_num); q++;
 127         DBG_RW_CVAL("num_auths  ", depth, base, io, q, sid->num_auths); q++;
 128
 129         for (i = 0; i < 6; i++)
 130         {
 131                 fstring tmp;
 132                 sprintf(tmp, "id_auth[%d] ", i);
 133                 DBG_RW_CVAL(tmp, depth, base, io, q, sid->id_auth[i]); q++;
 134         }
 135
 136         /* oops! XXXX should really issue a warning here... */
 137         if (sid->num_auths > MAXSUBAUTHS) sid->num_auths = MAXSUBAUTHS;
 138
 139         DBG_RW_PIVAL(False, "sub_auths ", depth, base, io, q, sid->sub_auths, sid->num_auths); q += sid->num_auths * 4;
 140
 141         return q;
 142 }
 143
 144 /*******************************************************************
 145 creates a UNIHDR structure.
 146 ********************************************************************/
 147 void make_uni_hdr(UNIHDR *hdr, int max_len, int len, uint16 terminate)
 148 {
 149         hdr->uni_max_len = 2 * max_len;
 150         hdr->uni_str_len = 2 * len;
 151         hdr->undoc       = terminate;
 152 }
 153
 154 /*******************************************************************
 155 reads or writes a UNIHDR structure.
 156 ********************************************************************/
 157 char* smb_io_unihdr(BOOL io, UNIHDR *hdr, char *q, char *base, int align, int depth)
 158 {
 159         if (hdr == NULL) return NULL;
 160
 161         DEBUG(5,("%s%04x smb_io_unihdr\n",  tab_depth(depth), PTR_DIFF(q, base)));
 162         depth++;
 163
 164         q = align_offset(q, base, align);
 165
 166         DBG_RW_SVAL("uni_str_len", depth, base, io, q, hdr->uni_str_len); q += 2;
 167         DBG_RW_SVAL("uni_max_len", depth, base, io, q, hdr->uni_max_len); q += 2;
 168         DBG_RW_IVAL("undoc      ", depth, base, io, q, hdr->undoc      ); q += 4;
 169
 170         /* oops! XXXX maybe issue a warning that this is happening... */
 171         if (hdr->uni_max_len > MAX_UNISTRLEN) hdr->uni_max_len = MAX_UNISTRLEN;
 172         if (hdr->uni_str_len > MAX_UNISTRLEN) hdr->uni_str_len = MAX_UNISTRLEN;
 173
 174         return q;
 175 }
 176
 177 /*******************************************************************
 178 creates a UNIHDR2 structure.
 179 ********************************************************************/
 180 void make_uni_hdr2(UNIHDR2 *hdr, int max_len, int len, uint16 terminate)
 181 {
 182         make_uni_hdr(&(hdr->unihdr), max_len, len, terminate);
 183         hdr->undoc_buffer = len > 0 ? 1 : 0;
 184 }
 185
 186 /*******************************************************************
 187 reads or writes a UNIHDR2 structure.
 188 ********************************************************************/
 189 char* smb_io_unihdr2(BOOL io, UNIHDR2 *hdr2, char *q, char *base, int align, int depth)
 190 {
 191         if (hdr2 == NULL) return NULL;
 192
 193         DEBUG(5,("%s%04x smb_io_unihdr2\n",  tab_depth(depth), PTR_DIFF(q, base)));
 194         depth++;
 195
 196         q = align_offset(q, base, align);
 197
 198         q = smb_io_unihdr(io, &(hdr2->unihdr), q, base, align, depth);
 199         DBG_RW_IVAL("undoc_buffer", depth, base, io, q, hdr2->undoc_buffer); q += 4;
 200
 201         return q;
 202 }
 203
 204 /*******************************************************************
 205 creates a UNISTR structure.
 206 ********************************************************************/
 207 void make_unistr(UNISTR *str, char *buf)
 208 {
 209         /* store the string (null-terminated copy) */
 210         PutUniCode((char *)(str->buffer), buf);
 211 }
 212
 213 /*******************************************************************
 214 reads or writes a UNISTR structure.
 215 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 216 ********************************************************************/
 217 char* smb_io_unistr(BOOL io, UNISTR *uni, char *q, char *base, int align, int depth)
 218 {
 219         if (uni == NULL) return NULL;
 220
 221         DEBUG(5,("%s%04x smb_io_unistr\n",  tab_depth(depth), PTR_DIFF(q, base)));
 222         depth++;
 223
 224         q = align_offset(q, base, align);
 225
 226         if (io)
 227         {
 228                 /* io True indicates read _from_ the SMB buffer into the string */
 229                 q += 2 * unistrcpy((char*)uni->buffer, q);
 230         }
 231         else
 232         {
 233                 /* io True indicates copy _from_ the string into SMB buffer */
 234                 q += 2 * unistrcpy(q, (char*)uni->buffer);
 235         }
 236         return q;
 237 }
 238
 239 /*******************************************************************
 240 creates a UNISTR2 structure.
 241 ********************************************************************/
 242 void make_unistr2(UNISTR2 *str, char *buf, int len)
 243 {
 244         /* set up string lengths. add one if string is not null-terminated */
 245         str->uni_max_len = len;
 246         str->undoc       = 0;
 247         str->uni_str_len = len;
 248
 249         /* store the string (null-terminated copy) */
 250         PutUniCode((char *)str->buffer, buf);
 251 }
 252
 253 /*******************************************************************
 254 reads or writes a UNISTR2 structure.
 255 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
 256      the uni_str_len member tells you how long the string is;
 257      the uni_max_len member tells you how large the buffer is.
 258 ********************************************************************/
 259 char* smb_io_unistr2(BOOL io, UNISTR2 *uni2, char *q, char *base, int align, int depth)
 260 {
 261         if (uni2 == NULL) return NULL;
 262
 263         DEBUG(5,("%s%04x smb_io_unistr2\n",  tab_depth(depth), PTR_DIFF(q, base)));
 264         depth++;
 265
 266         q = align_offset(q, base, align);
 267
 268         /* should be value 0, so enforce it. */
 269         uni2->undoc = 0;
 270
 271         DBG_RW_IVAL("uni_max_len", depth, base, io, q, uni2->uni_max_len); q += 4;
 272         DBG_RW_IVAL("undoc      ", depth, base, io, q, uni2->undoc      ); q += 4;
 273         DBG_RW_IVAL("uni_str_len", depth, base, io, q, uni2->uni_str_len); q += 4;
 274
 275         /* oops! XXXX maybe issue a warning that this is happening... */
 276         if (uni2->uni_max_len > MAX_UNISTRLEN) uni2->uni_max_len = MAX_UNISTRLEN;
 277         if (uni2->uni_str_len > MAX_UNISTRLEN) uni2->uni_str_len = MAX_UNISTRLEN;
 278
 279         /* buffer advanced by indicated length of string
 280        NOT by searching for null-termination */
 281         DBG_RW_PSVAL(True, "buffer     ", depth, base, io, q, uni2->buffer, uni2->uni_max_len); q += uni2->uni_max_len * 2;
 282
 283         return q;
 284 }
 285
 286 /*******************************************************************
 287 creates a DOM_SID2 structure.
 288 ********************************************************************/
 289 void make_dom_sid2(DOM_SID2 *sid2, char *sid_str)
 290 {
 291         int len_sid_str = strlen(sid_str);
 292
 293         sid2->type = 0x5;
 294         sid2->undoc = 0;
 295         make_uni_hdr2(&(sid2->hdr), len_sid_str, len_sid_str, 0);
 296         make_unistr  (&(sid2->str), sid_str);
 297 }
 298
 299 /*******************************************************************
 300 reads or writes a DOM_SID2 structure.
 301 ********************************************************************/
 302 char* smb_io_dom_sid2(BOOL io, DOM_SID2 *sid2, char *q, char *base, int align, int depth)
 303 {
 304         if (sid2 == NULL) return NULL;
 305
 306         DEBUG(5,("%s%04x smb_io_dom_sid2\n",  tab_depth(depth), PTR_DIFF(q, base)));
 307         depth++;
 308
 309         q = align_offset(q, base, align);
 310
 311         /* should be value 5, so enforce it */
 312         sid2->type = 5;
 313
 314         /* should be value 0, so enforce it */
 315         sid2->undoc = 0;
 316
 317         DBG_RW_IVAL("type ", depth, base, io, q, sid2->type ); q += 4;
 318         DBG_RW_IVAL("undoc", depth, base, io, q, sid2->undoc); q += 4;
 319
 320         q = smb_io_unihdr2(io, &(sid2->hdr), q, base, align, depth);
 321         q = smb_io_unistr (io, &(sid2->str), q, base, align, depth);
 322
 323         return q;
 324 }
 325
 326 /*******************************************************************
 327 creates a DOM_RID2 structure.
 328 ********************************************************************/
 329 void make_dom_rid2(DOM_RID2 *rid2, uint32 rid)
 330 {
 331         rid2->type    = 0x5;
 332         rid2->undoc   = 0x5;
 333         rid2->rid     = rid;
 334         rid2->rid_idx = 0;
 335 }
 336
 337 /*******************************************************************
 338 reads or writes a DOM_RID2 structure.
 339 ********************************************************************/
 340 char* smb_io_dom_rid2(BOOL io, DOM_RID2 *rid2, char *q, char *base, int align, int depth)
 341 {
 342         if (rid2 == NULL) return NULL;
 343
 344         DEBUG(5,("%s%04x smb_io_dom_rid2\n",  tab_depth(depth), PTR_DIFF(q, base)));
 345         depth++;
 346
 347         q = align_offset(q, base, align);
 348
 349         /* should be value 5, so enforce it */
 350         rid2->type = 5;
 351
 352         /* should be value 5, so enforce it */
 353         rid2->undoc = 5;
 354
 355         DBG_RW_IVAL("type   ", depth, base, io, q, rid2->type); q += 4;
 356         DBG_RW_IVAL("undoc  ", depth, base, io, q, rid2->undoc   ); q += 4;
 357         DBG_RW_IVAL("rid    ", depth, base, io, q, rid2->rid     ); q += 4;
 358         DBG_RW_IVAL("rid_idx", depth, base, io, q, rid2->rid_idx ); q += 4;
 359
 360         return q;
 361 }
 362
 363 /*******************************************************************
 364 makes a DOM_CLNT_SRV structure.
 365 ********************************************************************/
 366 void make_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
 367 {
 368         if (log == NULL) return;
 369
 370         DEBUG(5,("make_clnt_srv: %d\n", __LINE__));
 371
 372         if (logon_srv != NULL)
 373         {
 374                 log->undoc_buffer = 1;
 375                 make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv));
 376         }
 377         else
 378         {
 379                 log->undoc_buffer = 1;
 380         }
 381
 382         if (comp_name != NULL)
 383         {
 384                 log->undoc_buffer2 = 1;
 385                 make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name));
 386         }
 387         else
 388         {
 389                 log->undoc_buffer2 = 1;
 390         }
 391 }
 392
 393 /*******************************************************************
 394 reads or writes a DOM_CLNT_SRV structure.
 395 ********************************************************************/
 396 char* smb_io_clnt_srv(BOOL io, DOM_CLNT_SRV *log, char *q, char *base, int align, int depth)
 397 {
 398         if (log == NULL) return NULL;
 399
 400         DEBUG(5,("%s%04x smb_io_clnt_srv\n",  tab_depth(depth), PTR_DIFF(q, base)));
 401         depth++;
 402
 403         q = align_offset(q, base, align);
 404
 405         DBG_RW_IVAL("undoc_buffer ", depth, base, io, q, log->undoc_buffer ); q += 4;
 406         q = smb_io_unistr2(io, &(log->uni_logon_srv), q, base, align, depth);
 407
 408         DBG_RW_IVAL("undoc_buffer2", depth, base, io, q, log->undoc_buffer2); q += 4;
 409         q = smb_io_unistr2(io, &(log->uni_comp_name), q, base, align, depth);
 410
 411         return q;
 412 }
 413
 414 /*******************************************************************
 415 makes a DOM_LOG_INFO structure.
 416 ********************************************************************/
 417 void make_log_info(DOM_LOG_INFO *log, char *logon_srv, char *acct_name,
 418                 uint16 sec_chan, char *comp_name)
 419 {
 420         if (log == NULL) return;
 421
 422         DEBUG(5,("make_log_info %d\n", __LINE__));
 423
 424         log->undoc_buffer = 1;
 425
 426         make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv));
 427         make_unistr2(&(log->uni_acct_name), acct_name, strlen(acct_name));
 428
 429         log->sec_chan = sec_chan;
 430
 431         make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name));
 432 }
 433
 434 /*******************************************************************
 435 reads or writes a DOM_LOG_INFO structure.
 436 ********************************************************************/
 437 char* smb_io_log_info(BOOL io, DOM_LOG_INFO *log, char *q, char *base, int align, int depth)
 438 {
 439         if (log == NULL) return NULL;
 440
 441         DEBUG(5,("%s%04x smb_io_log_info\n",  tab_depth(depth), PTR_DIFF(q, base)));
 442         depth++;
 443
 444         q = align_offset(q, base, align);
 445
 446         DBG_RW_IVAL("undoc_buffer", depth, base, io, q, log->undoc_buffer); q += 4;
 447
 448         q = smb_io_unistr2(io, &(log->uni_logon_srv), q, base, align, depth);
 449         q = smb_io_unistr2(io, &(log->uni_acct_name), q, base, align, depth);
 450
 451         DBG_RW_SVAL("sec_chan", depth, base, io, q, log->sec_chan); q += 2;
 452
 453         q = smb_io_unistr2(io, &(log->uni_comp_name), q, base, align, depth);
 454
 455         return q;
 456 }
 457
 458 /*******************************************************************
 459 reads or writes a DOM_CHAL structure.
 460 ********************************************************************/
 461 char* smb_io_chal(BOOL io, DOM_CHAL *chal, char *q, char *base, int align, int depth)
 462 {
 463         if (chal == NULL) return NULL;
 464
 465         DEBUG(5,("%s%04x smb_io_chal\n",  tab_depth(depth), PTR_DIFF(q, base)));
 466         depth++;
 467
 468         q = align_offset(q, base, align);
 469
 470         DBG_RW_IVAL("data[0]", depth, base, io, q, chal->data[0]); q += 4;
 471         DBG_RW_IVAL("data[1]", depth, base, io, q, chal->data[1]); q += 4;
 472 /*
 473         DBG_RW_PCVAL(False, "data", depth, base, io, q, chal->data, 8); q += 8;
 474 */
 475         return q;
 476 }
 477
 478 /*******************************************************************
 479 reads or writes a DOM_CRED structure.
 480 ********************************************************************/
 481 char* smb_io_cred(BOOL io, DOM_CRED *cred, char *q, char *base, int align, int depth)
 482 {
 483         if (cred == NULL) return NULL;
 484
 485         DEBUG(5,("%s%04x smb_io_cred\n",  tab_depth(depth), PTR_DIFF(q, base)));
 486         depth++;
 487
 488         q = align_offset(q, base, align);
 489
 490         q = smb_io_chal (io, &(cred->challenge), q, base, align, depth);
 491         q = smb_io_utime(io, &(cred->timestamp), q, base, align, depth);
 492
 493         return q;
 494 }
 495
 496 /*******************************************************************
 497 makes a DOM_CLNT_INFO2 structure.
 498 ********************************************************************/
 499 void make_clnt_info2(DOM_CLNT_INFO2 *clnt,
 500                                 char *logon_srv, char *comp_name,
 501                                 DOM_CRED *clnt_cred)
 502 {
 503         if (clnt == NULL) return;
 504
 505         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
 506
 507         make_clnt_srv(&(clnt->login), logon_srv, comp_name);
 508
 509         if (clnt_cred != NULL)
 510         {
 511                 clnt->ptr_cred = 1;
 512                 memcpy(&(clnt->cred), clnt_cred, sizeof(clnt->cred));
 513         }
 514         else
 515         {
 516                 clnt->ptr_cred = 0;
 517         }
 518 }
 519
 520 /*******************************************************************
 521 reads or writes a DOM_CLNT_INFO2 structure.
 522 ********************************************************************/
 523 char* smb_io_clnt_info2(BOOL io, DOM_CLNT_INFO2 *clnt, char *q, char *base, int align, int depth)
 524 {
 525         if (clnt == NULL) return NULL;
 526
 527         DEBUG(5,("%s%04x smb_io_clnt_info2\n",  tab_depth(depth), PTR_DIFF(q, base)));
 528         depth++;
 529
 530         q = align_offset(q, base, align);
 531
 532         q = smb_io_clnt_srv(io, &(clnt->login), q, base, align, depth);
 533
 534         q = align_offset(q, base, align);
 535
 536         DBG_RW_IVAL("ptr_cred", depth, base, io, q, clnt->ptr_cred); q += 4;
 537         q = smb_io_cred    (io, &(clnt->cred ), q, base, align, depth);
 538
 539         return q;
 540 }
 541
 542 /*******************************************************************
 543 reads or writes a DOM_CLNT_INFO structure.
 544 ********************************************************************/
 545 char* smb_io_clnt_info(BOOL io, DOM_CLNT_INFO *clnt, char *q, char *base, int align, int depth)
 546 {
 547         if (clnt == NULL) return NULL;
 548
 549         DEBUG(5,("%s%04x smb_io_clnt_info\n",  tab_depth(depth), PTR_DIFF(q, base)));
 550         depth++;
 551
 552         q = align_offset(q, base, align);
 553
 554         q = smb_io_log_info(io, &(clnt->login), q, base, align, depth);
 555         q = smb_io_cred    (io, &(clnt->cred ), q, base, align, depth);
 556
 557         return q;
 558 }
 559
 560 /*******************************************************************
 561 makes a DOM_LOGON_ID structure.
 562 ********************************************************************/
 563 void make_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
 564 {
 565         if (log == NULL) return;
 566
 567         DEBUG(5,("make_logon_id: %d\n", __LINE__));
 568
 569         log->low  = log_id_low;
 570         log->high = log_id_high;
 571 }
 572
 573 /*******************************************************************
 574 reads or writes a DOM_LOGON_ID structure.
 575 ********************************************************************/
 576 char* smb_io_logon_id(BOOL io, DOM_LOGON_ID *log, char *q, char *base, int align, int depth)
 577 {
 578         if (log == NULL) return NULL;
 579
 580         DEBUG(5,("%s%04x smb_io_logon_id\n",  tab_depth(depth), PTR_DIFF(q, base)));
 581         depth++;
 582
 583         q = align_offset(q, base, align);
 584
 585         DBG_RW_IVAL("low ", depth, base, io, q, log->low ); q += 4;
 586         DBG_RW_IVAL("high", depth, base, io, q, log->high); q += 4;
 587
 588         return q;
 589 }
 590
 591 /*******************************************************************
 592 makes an ARC4_OWF structure.
 593 ********************************************************************/
 594 void make_arc4_owf(ARC4_OWF *hash, char data[16])
 595 {
 596         if (hash == NULL) return;
 597
 598         DEBUG(5,("make_arc4_owf: %d\n", __LINE__));
 599
 600         if (data != NULL)
 601         {
 602                 memcpy(hash->data, data, sizeof(hash->data));
 603         }
 604         else
 605         {
 606                 bzero(hash->data, sizeof(hash->data));
 607         }
 608 }
 609
 610 /*******************************************************************
 611 reads or writes an ARC4_OWF structure.
 612 ********************************************************************/
 613 char* smb_io_arc4_owf(BOOL io, ARC4_OWF *hash, char *q, char *base, int align, int depth)
 614 {
 615         if (hash == NULL) return NULL;
 616
 617         DEBUG(5,("%s%04x smb_io_arc4_owf\n",  tab_depth(depth), PTR_DIFF(q, base)));
 618         depth++;
 619
 620         q = align_offset(q, base, align);
 621
 622         DBG_RW_PCVAL(False, "data", depth, base, io, q, hash->data, 16); q += 16;
 623
 624         return q;
 625 }
 626
 627 /*******************************************************************
 628 makes a DOM_ID_INFO_1 structure.
 629 ********************************************************************/
 630 void make_id_info1(DOM_ID_INFO_1 *id, char *domain_name,
 631                                 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
 632                                 char *user_name, char *wksta_name,
 633                                 char arc4_lm_owf[16], char arc4_nt_owf[16])
 634 {
 635         int len_domain_name = strlen(domain_name);
 636         int len_user_name   = strlen(user_name  );
 637         int len_wksta_name  = strlen(wksta_name );
 638
 639         if (id == NULL) return;
 640
 641         DEBUG(5,("make_id_info1: %d\n", __LINE__));
 642
 643         id->ptr_id_info1 = 1;
 644
 645         make_uni_hdr(&(id->hdr_domain_name), len_domain_name, len_domain_name, 4);
 646
 647         id->param_ctrl = param_ctrl;
 648         make_logon_id(&(id->logon_id), log_id_low, log_id_high);
 649
 650         make_uni_hdr(&(id->hdr_user_name  ), len_user_name  , len_user_name  , 4);
 651         make_uni_hdr(&(id->hdr_wksta_name ), len_wksta_name , len_wksta_name , 4);
 652
 653         make_arc4_owf(&(id->arc4_lm_owf), arc4_lm_owf);
 654         make_arc4_owf(&(id->arc4_nt_owf), arc4_nt_owf);
 655
 656         make_unistr2(&(id->uni_domain_name), domain_name, len_domain_name);
 657         make_unistr2(&(id->uni_user_name  ), user_name  , len_user_name  );
 658         make_unistr2(&(id->uni_wksta_name ), wksta_name , len_wksta_name );
 659 }
 660
 661 /*******************************************************************
 662 reads or writes an DOM_ID_INFO_1 structure.
 663 ********************************************************************/
 664 char* smb_io_id_info1(BOOL io, DOM_ID_INFO_1 *id, char *q, char *base, int align, int depth)
 665 {
 666         if (id == NULL) return NULL;
 667
 668         DEBUG(5,("%s%04x smb_io_id_info1\n",  tab_depth(depth), PTR_DIFF(q, base)));
 669         depth++;
 670
 671         q = align_offset(q, base, align);
 672
 673         DBG_RW_IVAL("ptr_id_info1", depth, base, io, q, id->ptr_id_info1); q += 4;
 674
 675         if (id->ptr_id_info1 != 0)
 676         {
 677                 q = smb_io_unihdr(io, &(id->hdr_domain_name), q, base, align, depth);
 678
 679                 DBG_RW_IVAL("param_ctrl", depth, base, io, q, id->param_ctrl); q += 4;
 680                 q = smb_io_logon_id(io, &(id->logon_id), q, base, align, depth);
 681
 682                 q = smb_io_unihdr(io, &(id->hdr_user_name  ), q, base, align, depth);
 683                 q = smb_io_unihdr(io, &(id->hdr_wksta_name ), q, base, align, depth);
 684
 685                 q = smb_io_arc4_owf(io, &(id->arc4_lm_owf), q, base, align, depth);
 686                 q = smb_io_arc4_owf(io, &(id->arc4_nt_owf), q, base, align, depth);
 687
 688                 q = smb_io_unistr2(io, &(id->uni_domain_name), q, base, align, depth);
 689                 q = smb_io_unistr2(io, &(id->uni_user_name  ), q, base, align, depth);
 690                 q = smb_io_unistr2(io, &(id->uni_wksta_name ), q, base, align, depth);
 691         }
 692
 693         return q;
 694 }
 695
 696 /*******************************************************************
 697 makes a DOM_SAM_INFO structure.
 698 ********************************************************************/
 699 void make_sam_info(DOM_SAM_INFO *sam,
 700                                 char *logon_srv, char *comp_name, DOM_CRED *clnt_cred,
 701                                 DOM_CRED *rtn_cred, uint16 logon_level, uint16 switch_value,
 702                                 DOM_ID_INFO_1 *id1)
 703 {
 704         if (sam == NULL) return;
 705
 706         DEBUG(5,("make_sam_info: %d\n", __LINE__));
 707
 708         make_clnt_info2(&(sam->client), logon_srv, comp_name, clnt_cred);
 709
 710         if (rtn_cred != NULL)
 711         {
 712                 sam->ptr_rtn_cred = 1;
 713                 memcpy(&(sam->rtn_cred), rtn_cred, sizeof(sam->rtn_cred));
 714         }
 715         else
 716         {
 717                 sam->ptr_rtn_cred = 0;
 718         }
 719
 720         sam->logon_level  = logon_level;
 721         sam->switch_value = switch_value;
 722
 723         switch (sam->switch_value)
 724         {
 725                 case 1:
 726                 {
 727                         sam->auth.id1 = id1;
 728                         break;
 729                 }
 730                 default:
 731                 {
 732                         /* PANIC! */
 733                         DEBUG(4,("make_sam_info: unknown switch_value!\n"));
 734                         break;
 735                 }
 736         }
 737 }
 738
 739 /*******************************************************************
 740 reads or writes a DOM_SAM_INFO structure.
 741 ********************************************************************/
 742 char* smb_io_sam_info(BOOL io, DOM_SAM_INFO *sam, char *q, char *base, int align, int depth)
 743 {
 744         if (sam == NULL) return NULL;
 745
 746         DEBUG(5,("%s%04x smb_io_sam_info\n",  tab_depth(depth), PTR_DIFF(q, base)));
 747         depth++;
 748
 749         q = align_offset(q, base, align);
 750
 751         q = smb_io_clnt_info2(io, &(sam->client  ), q, base, align, depth);
 752
 753         DBG_RW_IVAL("ptr_rtn_cred", depth, base, io, q, sam->ptr_rtn_cred); q += 4;
 754         q = smb_io_cred      (io, &(sam->rtn_cred), q, base, align, depth);
 755
 756         DBG_RW_SVAL("logon_level ", depth, base, io, q, sam->logon_level); q += 2;
 757         DBG_RW_SVAL("switch_value", depth, base, io, q, sam->switch_value); q += 2;
 758
 759         switch (sam->switch_value)
 760         {
 761                 case 1:
 762                 {
 763                         q = smb_io_id_info1(io, sam->auth.id1, q, base, align, depth);
 764                         break;
 765                 }
 766                 default:
 767                 {
 768                         /* PANIC! */
 769                         DEBUG(4,("smb_io_sam_info: unknown switch_value!\n"));
 770                         break;
 771                 }
 772         }
 773         return q;
 774 }
 775
 776 /*******************************************************************
 777 reads or writes a DOM_GID structure.
 778 ********************************************************************/
 779 char* smb_io_gid(BOOL io, DOM_GID *gid, char *q, char *base, int align, int depth)
 780 {
 781         if (gid == NULL) return NULL;
 782
 783         DEBUG(5,("%s%04x smb_io_gid\n",  tab_depth(depth), PTR_DIFF(q, base)));
 784         depth++;
 785
 786         q = align_offset(q, base, align);
 787
 788         DBG_RW_IVAL("g_rid", depth, base, io, q, gid->g_rid); q += 4;
 789         DBG_RW_IVAL("attr ", depth, base, io, q, gid->attr ); q += 4;
 790
 791         return q;
 792 }
 793
 794 /*******************************************************************
 795 creates an RPC_HDR structure.
 796 ********************************************************************/
 797 void make_rpc_hdr(RPC_HDR *hdr, enum RPC_PKT_TYPE pkt_type, uint8 frag,
 798                                 uint32 call_id, int data_len)
 799 {
 800         if (hdr == NULL) return;
 801
 802         hdr->major        = 5;               /* RPC version 5 */
 803         hdr->minor        = 0;               /* minor version 0 */
 804         hdr->pkt_type     = pkt_type;        /* RPC packet type */
 805         hdr->frag         = frag;            /* first frag + last frag */
 806         hdr->pack_type    = 0x10;            /* packed data representation */
 807         hdr->frag_len     = data_len;        /* fragment length, fill in later */
 808         hdr->auth_len     = 0;               /* authentication length */
 809         hdr->call_id      = call_id;         /* call identifier - match incoming RPC */
 810 }
 811
 812 /*******************************************************************
 813 reads or writes an RPC_HDR structure.
 814 ********************************************************************/
 815 char* smb_io_rpc_hdr(BOOL io, RPC_HDR *rpc, char *q, char *base, int align, int depth)
 816 {
 817         if (rpc == NULL) return NULL;
 818
 819         DEBUG(5,("%s%04x smb_io_rpc_hdr\n",  tab_depth(depth), PTR_DIFF(q, base)));
 820         depth++;
 821
 822         DBG_RW_CVAL("major     ", depth, base, io, q, rpc->major); q++;
 823         DBG_RW_CVAL("minor     ", depth, base, io, q, rpc->minor); q++;
 824         DBG_RW_CVAL("pkt_type  ", depth, base, io, q, rpc->pkt_type); q++;
 825         DBG_RW_CVAL("frag      ", depth, base, io, q, rpc->frag); q++;
 826         DBG_RW_IVAL("pack_type ", depth, base, io, q, rpc->pack_type); q += 4;
 827         DBG_RW_SVAL("frag_len  ", depth, base, io, q, rpc->frag_len); q += 2;
 828         DBG_RW_SVAL("auth_len  ", depth, base, io, q, rpc->auth_len); q += 2;
 829         DBG_RW_IVAL("call_id   ", depth, base, io, q, rpc->call_id); q += 4;
 830
 831         return q;
 832 }
 833
 834 /*******************************************************************
 835 creates an RPC_IFACE structure.
 836 ********************************************************************/
 837 void make_rpc_iface(RPC_IFACE *ifc, char data[16], uint32 version)
 838 {
 839         if (ifc == NULL || data == NULL) return;
 840
 841         memcpy(ifc->data, data, sizeof(ifc->data)); /* 16 bytes of number */
 842         ifc->version = version; /* the interface number */
 843 }
 844
 845 /*******************************************************************
 846 reads or writes an RPC_IFACE structure.
 847 ********************************************************************/
 848 char* smb_io_rpc_iface(BOOL io, RPC_IFACE *ifc, char *q, char *base, int align, int depth)
 849 {
 850         if (ifc == NULL) return NULL;
 851
 852         DEBUG(5,("%s%04x smb_io_rpc_iface\n", tab_depth(depth), PTR_DIFF(q, base)));
 853         depth++;
 854
 855         q = align_offset(q, base, align);
 856
 857         DBG_RW_PCVAL(False, "data   ", depth, base, io, q, ifc->data, sizeof(ifc->data)); q += sizeof(ifc->data);
 858         DBG_RW_IVAL (       "version", depth, base, io, q, ifc->version); q += 4;
 859
 860         return q;
 861 }
 862
 863 /*******************************************************************
 864 creates an RPC_ADDR_STR structure.
 865 ********************************************************************/
 866 void make_rpc_addr_str(RPC_ADDR_STR *str, char *name)
 867 {
 868         if (str == NULL || name == NULL) return;
 869
 870         str->len = strlen(name) + 1;
 871         fstrcpy(str->addr, name);
 872 }
 873
 874 /*******************************************************************
 875 reads or writes an RPC_ADDR_STR structure.
 876 ********************************************************************/
 877 char* smb_io_rpc_addr_str(BOOL io, RPC_ADDR_STR *str, char *q, char *base, int align, int depth)
 878 {
 879         if (str == NULL) return NULL;
 880
 881         DEBUG(5,("%s%04x smb_io_rpc_addr_str\n", tab_depth(depth), PTR_DIFF(q, base)));
 882         depth++;
 883
 884         q = align_offset(q, base, align);
 885
 886         DBG_RW_IVAL (      "len ", depth, base, io, q, str->len); q += 2;
 887         DBG_RW_PCVAL(True, "addr", depth, base, io, q, str->addr, str->len); q += str->len;
 888
 889         return q;
 890 }
 891
 892 /*******************************************************************
 893 creates an RPC_HDR_BBA structure.
 894 ********************************************************************/
 895 void make_rpc_hdr_bba(RPC_HDR_BBA *bba, uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid)
 896 {
 897         if (bba == NULL) return;
 898
 899         bba->max_tsize = max_tsize; /* maximum transmission fragment size (0x1630) */
 900         bba->max_rsize = max_rsize; /* max receive fragment size (0x1630) */
 901         bba->assoc_gid = assoc_gid; /* associated group id (0x0) */
 902 }
 903
 904 /*******************************************************************
 905 reads or writes an RPC_HDR_BBA structure.
 906 ********************************************************************/
 907 char* smb_io_rpc_hdr_bba(BOOL io, RPC_HDR_BBA *rpc, char *q, char *base, int align, int depth)
 908 {
 909         if (rpc == NULL) return NULL;
 910
 911         DEBUG(5,("%s%04x smb_io_rpc_hdr_bba\n",  tab_depth(depth), PTR_DIFF(q, base)));
 912         depth++;
 913
 914         DBG_RW_SVAL("max_tsize", depth, base, io, q, rpc->max_tsize); q += 2;
 915         DBG_RW_SVAL("max_rsize", depth, base, io, q, rpc->max_rsize); q += 2;
 916         DBG_RW_IVAL("assoc_gid", depth, base, io, q, rpc->assoc_gid); q += 4;
 917
 918         return q;
 919 }
 920
 921 /*******************************************************************
 922 creates an RPC_HDR_RB structure.
 923 ********************************************************************/
 924 void make_rpc_hdr_rb(RPC_HDR_RB *rpc,
 925                                 uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
 926                                 uint32 num_elements, uint16 context_id, uint8 num_syntaxes,
 927                                 RPC_IFACE *abstract, RPC_IFACE *transfer)
 928 {
 929         if (rpc == NULL) return;
 930
 931         make_rpc_hdr_bba(&(rpc->bba), max_tsize, max_rsize, assoc_gid);
 932
 933         rpc->num_elements = num_elements ; /* the number of elements (0x1) */
 934         rpc->context_id   = context_id   ; /* presentation context identifier (0x0) */
 935         rpc->num_syntaxes = num_syntaxes ; /* the number of syntaxes (has always been 1?)(0x1) */
 936
 937         /* num and vers. of interface client is using */
 938         memcpy(&(rpc->abstract), abstract, sizeof(rpc->abstract));
 939
 940         /* num and vers. of interface to use for replies */
 941         memcpy(&(rpc->transfer), transfer, sizeof(rpc->transfer));
 942 }
 943
 944 /*******************************************************************
 945 reads or writes an RPC_HDR_RB structure.
 946 ********************************************************************/
 947 char* smb_io_rpc_hdr_rb(BOOL io, RPC_HDR_RB *rpc, char *q, char *base, int align, int depth)
 948 {
 949         if (rpc == NULL) return NULL;
 950
 951         DEBUG(5,("%s%04x smb_io_rpc_hdr_bba\n", tab_depth(depth), PTR_DIFF(q, base)));
 952         depth++;
 953
 954         q = smb_io_rpc_hdr_bba(io, &(rpc->bba), q, base, align, depth);
 955
 956         DBG_RW_IVAL("num_elements", depth, base, io, q, rpc->num_elements); q += 4;
 957         DBG_RW_IVAL("context_id  ", depth, base, io, q, rpc->context_id  ); q += 4;
 958         DBG_RW_IVAL("num_syntaxes", depth, base, io, q, rpc->num_syntaxes); q += 4;
 959
 960         q = smb_io_rpc_iface(io, &(rpc->abstract), q, base, align, depth);
 961         q = smb_io_rpc_iface(io, &(rpc->transfer), q, base, align, depth);
 962
 963         return q;
 964 }
 965
 966 /*******************************************************************
 967 creates an RPC_RESULTS structure.
 968
 969 lkclXXXX only one reason at the moment!
 970
 971 ********************************************************************/
 972 void make_rpc_results(RPC_RESULTS *res,
 973                                 uint8 num_results, uint16 result, uint16 reason)
 974 {
 975         if (res == NULL) return;
 976
 977         res->num_results = num_results; /* the number of results (0x01) */
 978         res->result      = result     ;  /* result (0x00 = accept) */
 979         res->reason      = reason     ;  /* reason (0x00 = no reason specified) */
 980 }
 981
 982 /*******************************************************************
 983 reads or writes an RPC_RESULTS structure.
 984
 985 lkclXXXX only one reason at the moment!
 986
 987 ********************************************************************/
 988 char* smb_io_rpc_results(BOOL io, RPC_RESULTS *res, char *q, char *base, int align, int depth)
 989 {
 990         if (res == NULL) return NULL;
 991
 992         DEBUG(5,("%s%04x smb_io_rpc_results\n", tab_depth(depth), PTR_DIFF(q, base)));
 993         depth++;
 994
 995         q = align_offset(q, base, align);
 996
 997         DBG_RW_CVAL("num_results", depth, base, io, q, res->num_results); q++;
 998
 999         q = align_offset(q, base, align);
1000
1001         DBG_RW_SVAL("result     ", depth, base, io, q, res->result     ); q += 2;
1002         DBG_RW_SVAL("reason     ", depth, base, io, q, res->reason     ); q += 2;
1003
1004         return q;
1005 }
1006
1007 /*******************************************************************
1008 creates an RPC_HDR_BA structure.
1009
1010 lkclXXXX only one reason at the moment!
1011
1012 ********************************************************************/
1013 void make_rpc_hdr_ba(RPC_HDR_BA *rpc,
1014                                 uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
1015                                 char *pipe_addr,
1016                                 uint8 num_results, uint16 result, uint16 reason,
1017                                 RPC_IFACE *transfer)
1018 {
1019         if (rpc == NULL || transfer == NULL || pipe_addr == NULL) return;
1020
1021         make_rpc_hdr_bba (&(rpc->bba ), max_tsize, max_rsize, assoc_gid);
1022         make_rpc_addr_str(&(rpc->addr), pipe_addr);
1023         make_rpc_results (&(rpc->res ), num_results, result, reason);
1024
1025         /* the transfer syntax from the request */
1026         memcpy(&(rpc->transfer), transfer, sizeof(rpc->transfer));
1027 }
1028
1029 /*******************************************************************
1030 reads or writes an RPC_HDR_BA structure.
1031 ********************************************************************/
1032 char* smb_io_rpc_hdr_ba(BOOL io, RPC_HDR_BA *rpc, char *q, char *base, int align, int depth)
1033 {
1034         if (rpc == NULL) return NULL;
1035
1036         DEBUG(5,("%s%04x smb_io_rpc_hdr_ba\n", tab_depth(depth), PTR_DIFF(q, base)));
1037         depth++;
1038
1039         q = smb_io_rpc_hdr_bba (io, &(rpc->bba)     , q, base, align, depth);
1040         q = smb_io_rpc_addr_str(io, &(rpc->addr)    , q, base, align, depth);
1041         q = smb_io_rpc_results (io, &(rpc->res)     , q, base, align, depth);
1042         q = smb_io_rpc_iface   (io, &(rpc->transfer), q, base, align, depth);
1043
1044         return q;
1045 }
1046
1047 /*******************************************************************
1048 makes an LSA_OBJ_ATTR structure.
1049 ********************************************************************/
1050 void make_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, uint32 sec_qos)
1051 {
1052         if (attr == NULL) return;
1053
1054         DEBUG(5,("make_obj_attr\n"));
1055
1056         attr->len = 0x18; /* length of object attribute block, in bytes */
1057         attr->ptr_root_dir = 0;
1058         attr->ptr_obj_name = 0;
1059         attr->attributes = attributes;
1060         attr->ptr_sec_desc = 0;
1061         attr->sec_qos = sec_qos;
1062 }
1063
1064 /*******************************************************************
1065 reads or writes an LSA_OBJ_ATTR structure.
1066 ********************************************************************/
1067 char* smb_io_obj_attr(BOOL io, LSA_OBJ_ATTR *attr, char *q, char *base, int align, int depth)
1068 {
1069         char *start;
1070
1071         if (attr == NULL) return NULL;
1072
1073         DEBUG(5,("%s%04x smb_io_obj_attr\n",  tab_depth(depth), PTR_DIFF(q, base)));
1074         depth++;
1075
1076         q = align_offset(q, base, align);
1077
1078         start = q;
1079
1080         /* these pointers had _better_ be zero, because we don't know
1081            what they point to!
1082          */
1083         DBG_RW_IVAL("len"         , depth, base, io, q, attr->len         ); q += 4; /* 0x18 - length (in bytes) inc. the length field. */
1084         DBG_RW_IVAL("ptr_root_dir", depth, base, io, q, attr->ptr_root_dir); q += 4; /* 0 - root directory (pointer) */
1085         DBG_RW_IVAL("ptr_obj_name", depth, base, io, q, attr->ptr_obj_name); q += 4; /* 0 - object name (pointer) */
1086         DBG_RW_IVAL("attributes"  , depth, base, io, q, attr->attributes  ); q += 4; /* 0 - attributes (undocumented) */
1087         DBG_RW_IVAL("ptr_sec_desc", depth, base, io, q, attr->ptr_sec_desc); q += 4; /* 0 - security descriptior (pointer) */
1088         DBG_RW_IVAL("sec_qos"     , depth, base, io, q, attr->sec_qos     ); q += 4; /* 0 - security quality of service */
1089
1090         if (attr->len != PTR_DIFF(q, start))
1091         {
1092                 DEBUG(3,("smb_io_obj_attr: length %lx does not match size %lx\n",
1093                          attr->len, PTR_DIFF(q, start)));
1094         }
1095
1096         return q;
1097 }
1098
1099 /*******************************************************************
1100 creates an RPC_HDR_RR structure.
1101 ********************************************************************/
1102 void make_rpc_hdr_rr(RPC_HDR_RR *hdr, enum RPC_PKT_TYPE pkt_type,
1103                                 uint32 call_id, int data_len, uint8 opnum)
1104 {
1105         if (hdr == NULL) return;
1106
1107         /* frag is FIRST_FRAG | LAST_FRAG.  lkclXXXX must define these */
1108         make_rpc_hdr(&(hdr->hdr), pkt_type, 0x03, call_id, data_len);
1109
1110         hdr->alloc_hint   = data_len - 0x18; /* allocation hint */
1111         hdr->context_id   = 0;               /* presentation context identifier */
1112         hdr->cancel_count = 0;               /* cancel count */
1113         hdr->opnum        = opnum;           /* opnum */
1114 }
1115
1116 /*******************************************************************
1117 reads or writes an RPC_HDR_RR structure.
1118 ********************************************************************/
1119 char* smb_io_rpc_hdr_rr(BOOL io, RPC_HDR_RR *rpc, char *q, char *base, int align, int depth)
1120 {
1121         if (rpc == NULL) return NULL;
1122
1123         DEBUG(5,("%s%04x smb_io_rpc_hdr_rr\n",  tab_depth(depth), PTR_DIFF(q, base)));
1124         depth++;
1125
1126         q = smb_io_rpc_hdr(io, &(rpc->hdr), q, base, align, depth);
1127
1128         DBG_RW_IVAL("alloc_hint", depth, base, io, q, rpc->alloc_hint); q += 4;
1129         DBG_RW_CVAL("context_id", depth, base, io, q, rpc->context_id); q++;
1130         DBG_RW_CVAL("cancel_ct ", depth, base, io, q, rpc->cancel_count); q++;
1131         DBG_RW_CVAL("opnum     ", depth, base, io, q, rpc->opnum); q++;
1132
1133         return q;
1134 }
1135 /*******************************************************************
1136 reads or writes an LSA_POL_HND structure.
1137 ********************************************************************/
1138 char* smb_io_pol_hnd(BOOL io, LSA_POL_HND *pol, char *q, char *base, int align, int depth)
1139 {
1140         if (pol == NULL) return NULL;
1141
1142         DEBUG(5,("%s%04x smb_io_pol_hnd\n",  tab_depth(depth), PTR_DIFF(q, base)));
1143         depth++;
1144
1145         q = align_offset(q, base, align);
1146
1147         DBG_RW_PCVAL(False, "data", depth, base, io, q, pol->data, POL_HND_SIZE); q += POL_HND_SIZE;
1148
1149         return q;
1150 }
1151
1152 /*******************************************************************
1153 reads or writes a dom query structure.
1154 ********************************************************************/
1155 char* smb_io_dom_query_3(BOOL io, DOM_QUERY_3 *d_q, char *q, char *base, int align, int depth)
1156 {
1157         return smb_io_dom_query(io, d_q, q, base, align, depth);
1158 }
1159
1160 /*******************************************************************
1161 reads or writes a dom query structure.
1162 ********************************************************************/
1163 char* smb_io_dom_query_5(BOOL io, DOM_QUERY_3 *d_q, char *q, char *base, int align, int depth)
1164 {
1165         return smb_io_dom_query(io, d_q, q, base, align, depth);
1166 }
1167
1168 /*******************************************************************
1169 reads or writes a dom query structure.
1170 ********************************************************************/
1171 char* smb_io_dom_query(BOOL io, DOM_QUERY *d_q, char *q, char *base, int align, int depth)
1172 {
1173         if (d_q == NULL) return NULL;
1174
1175         DEBUG(5,("%s%04x smb_io_dom_query\n",  tab_depth(depth), PTR_DIFF(q, base)));
1176         depth++;
1177
1178         q = align_offset(q, base, align);
1179
1180         DBG_RW_SVAL("uni_dom_max_len", depth, base, io, q, d_q->uni_dom_max_len); q += 2; /* domain name string length * 2 */
1181         DBG_RW_SVAL("uni_dom_str_len", depth, base, io, q, d_q->uni_dom_str_len); q += 2; /* domain name string length * 2 */
1182
1183         DBG_RW_IVAL("buffer_dom_name", depth, base, io, q, d_q->buffer_dom_name); q += 4; /* undocumented domain name string buffer pointer */
1184         DBG_RW_IVAL("buffer_dom_sid ", depth, base, io, q, d_q->buffer_dom_sid ); q += 4; /* undocumented domain SID string buffer pointer */
1185
1186         if (d_q->buffer_dom_name != 0)
1187         {
1188                 q = smb_io_unistr2(io, &(d_q->uni_domain_name), q, base, align, depth); /* domain name (unicode string) */
1189         }
1190         if (d_q->buffer_dom_sid != 0)
1191         {
1192                 q = smb_io_dom_sid(io, &(d_q->dom_sid), q, base, align, depth); /* domain SID */
1193         }
1194
1195         return q;
1196 }
1197
1198 /*******************************************************************
1199 reads or writes a DOM_R_REF structure.
1200 ********************************************************************/
1201 char* smb_io_dom_r_ref(BOOL io, DOM_R_REF *r_r, char *q, char *base, int align, int depth)
1202 {
1203         int i;
1204
1205         DEBUG(5,("%s%04x smb_io_dom_r_ref\n",  tab_depth(depth), PTR_DIFF(q, base)));
1206         depth++;
1207
1208         if (r_r == NULL) return NULL;
1209
1210         q = align_offset(q, base, align);
1211
1212         DBG_RW_IVAL("undoc_buffer   ", depth, base, io, q, r_r->undoc_buffer); q += 4; /* undocumented buffer pointer. */
1213         DBG_RW_IVAL("num_ref_doms_1 ", depth, base, io, q, r_r->num_ref_doms_1); q += 4; /* num referenced domains? */
1214         DBG_RW_IVAL("buffer_dom_name", depth, base, io, q, r_r->buffer_dom_name); q += 4; /* undocumented domain name buffer pointer. */
1215         DBG_RW_IVAL("max_entries    ", depth, base, io, q, r_r->max_entries); q += 4; /* 32 - max number of entries */
1216         DBG_RW_IVAL("num_ref_doms_2 ", depth, base, io, q, r_r->num_ref_doms_2); q += 4; /* 4 - num referenced domains? */
1217
1218         q = smb_io_unihdr2(io, &(r_r->hdr_dom_name), q, base, align, depth); /* domain name unicode string header */
1219
1220         for (i = 0; i < r_r->num_ref_doms_1-1; i++)
1221         {
1222                 q = smb_io_unihdr2(io, &(r_r->hdr_ref_dom[i]), q, base, align, depth);
1223         }
1224
1225         q = smb_io_unistr(io, &(r_r->uni_dom_name), q, base, align, depth); /* domain name unicode string */
1226
1227         for (i = 0; i < r_r->num_ref_doms_2; i++)
1228         {
1229                 q = smb_io_dom_sid(io, &(r_r->ref_dom[i]), q, base, align, depth); /* referenced domain SIDs */
1230         }
1231         return q;
1232 }
1233
1234 /*******************************************************************
1235 reads or writes a DOM_NAME structure.
1236 ********************************************************************/
1237 char* smb_io_dom_name(BOOL io, DOM_NAME *name, char *q, char *base, int align, int depth)
1238 {
1239         if (name == NULL) return NULL;
1240
1241         DEBUG(5,("%s%04x smb_io_dom_name\n",  tab_depth(depth), PTR_DIFF(q, base)));
1242         depth++;
1243
1244         q = align_offset(q, base, align);
1245
1246         DBG_RW_IVAL("uni_str_len", depth, base, io, q, name->uni_str_len); q += 4;
1247
1248         /* don't know if len is specified by uni_str_len member... */
1249         /* assume unicode string is unicode-null-terminated, instead */
1250
1251         q = smb_io_unistr(io, &(name->str), q, base, align, depth);
1252
1253         return q;
1254 }
1255
1256
1257 /*******************************************************************
1258 reads or writes a structure.
1259 ********************************************************************/
1260 char* smb_io_neg_flags(BOOL io, NEG_FLAGS *neg, char *q, char *base, int align, int depth)
1261 {
1262         if (neg == NULL) return NULL;
1263
1264         DEBUG(5,("%s%04x smb_io_neg_flags\n",  tab_depth(depth), PTR_DIFF(q, base)));
1265         depth++;
1266
1267         q = align_offset(q, base, align);
1268
1269         DBG_RW_IVAL("neg_flags", depth, base, io, q, neg->neg_flags); q += 4;
1270
1271         return q;
1272 }
1273
1274
1275 #if 0
1276 /*******************************************************************
1277 reads or writes a structure.
1278 ********************************************************************/
1279  char* smb_io_(BOOL io, *, char *q, char *base, int align, int depth)
1280 {
1281         if (== NULL) return NULL;
1282
1283         q = align_offset(q, base, align);
1284
1285         DBG_RW_IVAL("", depth, base, io, q, ); q += 4;
1286
1287         return q;
1288 }
1289 #endif
1290