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