/*******************************************************************
reads or writes a UTIME type.
********************************************************************/
-void smb_io_utime(char *desc, UTIME *t, prs_struct *ps, int depth)
+static void smb_io_utime(char *desc, UTIME *t, prs_struct *ps, int depth)
{
if (t == NULL) return;
********************************************************************/
void make_dom_sid2(DOM_SID2 *sid2, DOM_SID *sid)
{
- sid2->sid = *sid;
+ sid_copy(&sid2->sid, sid);
sid2->num_auths = sid2->sid.num_auths;
}
********************************************************************/
void make_uni_hdr(UNIHDR *hdr, int max_len, int len, uint32 buffer)
{
- hdr->uni_max_len = 2 * max_len;
hdr->uni_str_len = 2 * len;
+ hdr->uni_max_len = 2 * max_len;
hdr->buffer = buffer;
}
if (hdr->uni_str_len > MAX_UNISTRLEN) hdr->uni_str_len = MAX_UNISTRLEN;
}
+/*******************************************************************
+creates a BUFHDR structure.
+********************************************************************/
+void make_buf_hdr(BUFHDR *hdr, int max_len, int len)
+{
+ hdr->buf_max_len = max_len;
+ hdr->buf_len = len;
+}
+
+/*******************************************************************
+ prs_uint16 wrapper. call this and it sets up a pointer to where the
+ uint16 should be stored, or gets the size if reading
+ ********************************************************************/
+void smb_io_hdrbuf_pre(char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
+{
+ (*offset) = ps->offset;
+ if (ps->io)
+ {
+ /* reading. */
+ smb_io_hdrbuf(desc, hdr, ps, depth);
+ }
+ else
+ {
+ ps->offset += sizeof(uint32) * 2;
+ }
+}
+
+/*******************************************************************
+ smb_io_hdrbuf wrapper. call this and it retrospectively stores the size.
+ does nothing on reading, as that is already handled by ...._pre()
+ ********************************************************************/
+void smb_io_hdrbuf_post(char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
+ uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
+{
+ if (!ps->io)
+ {
+ /* storing: go back and do a retrospective job. i hate this */
+ uint32 old_offset = ps->offset;
+
+ make_buf_hdr(hdr, max_len, len);
+ ps->offset = ptr_hdrbuf;
+ smb_io_hdrbuf(desc, hdr, ps, depth);
+ ps->offset = old_offset;
+ }
+}
+/*******************************************************************
+reads or writes a BUFHDR structure.
+********************************************************************/
+void smb_io_hdrbuf(char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
+{
+ if (hdr == NULL) return;
+
+ prs_debug(ps, depth, desc, "smb_io_hdrbuf");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("buf_max_len", ps, depth, &(hdr->buf_max_len));
+ prs_uint32("buf_len ", ps, depth, &(hdr->buf_len ));
+
+ /* oops! XXXX maybe issue a warning that this is happening... */
+ if (hdr->buf_max_len > MAX_BUFFERLEN) hdr->buf_max_len = MAX_BUFFERLEN;
+ if (hdr->buf_len > MAX_BUFFERLEN) hdr->buf_len = MAX_BUFFERLEN;
+}
+
/*******************************************************************
creates a UNIHDR2 structure.
********************************************************************/
}
/*******************************************************************
-creates a UNINOTSTR2 structure.
+creates a BUFFER3 structure from a uint32
********************************************************************/
-void make_uninotstr2(UNINOTSTR2 *str, char *buf, int len)
+void make_buffer3_uint32(BUFFER3 *str, uint32 val)
{
- /* set up string lengths. add one if string is not null-terminated */
- str->uni_max_len = (len+1)*2;
+ ZERO_STRUCTP(str);
+
+ /* set up string lengths. */
+ str->buf_max_len = sizeof(uint32);
+ str->buf_len = sizeof(uint32);
+
+ SIVAL(str->buffer, 0, val);
+}
+
+/*******************************************************************
+creates a BUFFER3 structure.
+********************************************************************/
+void make_buffer3_str(BUFFER3 *str, char *buf, int len)
+{
+ ZERO_STRUCTP(str);
+
+ /* set up string lengths. */
+ str->buf_max_len = len * 2;
+ str->buf_len = len * 2;
+
+ /* store the string (null-terminated 8 bit chars into 16 bit chars) */
+ struni2((uint16*)str->buffer, buf);
+}
+
+/*******************************************************************
+creates a BUFFER3 structure from a hex string.
+********************************************************************/
+void make_buffer3_hex(BUFFER3 *str, char *buf)
+{
+ ZERO_STRUCTP(str);
+ str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
+}
+
+/*******************************************************************
+creates a BUFFER3 structure.
+********************************************************************/
+void make_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
+{
+ ZERO_STRUCTP(str);
+
+ /* max buffer size (allocated size) */
+ str->buf_max_len = len;
+ if (buf != NULL)
+ {
+ memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
+ }
+ str->buf_len = buf != NULL ? len : 0;
+}
+
+/*******************************************************************
+reads or writes a BUFFER3 structure.
+ the uni_max_len member tells you how large the buffer is.
+ the uni_str_len member tells you how much of the buffer is really used.
+********************************************************************/
+void smb_io_buffer3(char *desc, BUFFER3 *buf3, prs_struct *ps, int depth)
+{
+ if (buf3 == NULL) return;
+
+ prs_debug(ps, depth, desc, "smb_io_buffer3");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("uni_max_len", ps, depth, &(buf3->buf_max_len));
+ if (buf3->buf_max_len > MAX_UNISTRLEN) buf3->buf_max_len = MAX_UNISTRLEN;
+
+ prs_uint8s(True, "buffer ", ps, depth, buf3->buffer, buf3->buf_max_len);
+
+ prs_uint32("buf_len ", ps, depth, &(buf3->buf_len));
+ if (buf3->buf_len > MAX_UNISTRLEN) buf3->buf_len = MAX_UNISTRLEN;
+}
+
+/*******************************************************************
+creates a BUFFER2 structure.
+********************************************************************/
+void make_buffer2(BUFFER2 *str, uint8 *buf, int len)
+{
+ ZERO_STRUCTP(str);
+
+ /* max buffer size (allocated size) */
+ str->buf_max_len = len;
str->undoc = 0;
- str->uni_buf_len = (len+1)*2;
+ str->buf_len = buf != NULL ? len : 0;
- /* store the string (null-terminated copy) */
- struni2(str->buffer, buf);
+ if (buf != NULL)
+ {
+ memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
+ }
}
/*******************************************************************
-reads or writes a UNINOTSTR2 structure.
-XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
- the uni_str_len member tells you how long the string is;
+reads or writes a BUFFER2 structure.
the uni_max_len member tells you how large the buffer is.
+ the uni_str_len member tells you how much of the buffer is really used.
********************************************************************/
-void smb_io_uninotstr2(char *desc, UNINOTSTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
+void smb_io_buffer2(char *desc, BUFFER2 *buf2, uint32 buffer, prs_struct *ps, int depth)
{
- if (uni2 == NULL) return;
+ if (buf2 == NULL) return;
if (buffer)
{
- prs_debug(ps, depth, desc, "smb_io_uninotstr2");
+ prs_debug(ps, depth, desc, "smb_io_buffer2");
depth++;
prs_align(ps);
- prs_uint32("uni_max_len", ps, depth, &(uni2->uni_max_len));
- prs_uint32("undoc ", ps, depth, &(uni2->undoc ));
- prs_uint32("uni_buf_len", ps, depth, &(uni2->uni_buf_len));
+ prs_uint32("buf_max_len", ps, depth, &(buf2->buf_max_len));
+ prs_uint32("undoc ", ps, depth, &(buf2->undoc ));
+ prs_uint32("buf_len ", ps, depth, &(buf2->buf_len));
/* oops! XXXX maybe issue a warning that this is happening... */
- if (uni2->uni_max_len > MAX_UNISTRLEN) uni2->uni_max_len = MAX_UNISTRLEN;
- if (uni2->uni_buf_len > MAX_UNISTRLEN) uni2->uni_buf_len = MAX_UNISTRLEN;
+ if (buf2->buf_max_len > MAX_UNISTRLEN) buf2->buf_max_len = MAX_UNISTRLEN;
+ if (buf2->buf_len > MAX_UNISTRLEN) buf2->buf_len = MAX_UNISTRLEN;
/* buffer advanced by indicated length of string
NOT by searching for null-termination */
- prs_uninotstr2(True, "buffer ", ps, depth, uni2);
+ prs_buffer2(True, "buffer ", ps, depth, buf2);
}
else
{
- prs_debug(ps, depth, desc, "smb_io_uninotstr2 - NULL");
+ prs_debug(ps, depth, desc, "smb_io_buffer2 - NULL");
depth++;
- bzero(uni2, sizeof(*uni2));
+ bzero(buf2, sizeof(*buf2));
}
}
if (buf != NULL)
{
*ptr = 1;
- make_unistr2(str, buf, strlen(buf));
+ make_unistr2(str, buf, strlen(buf)+1);
}
else
{
********************************************************************/
void make_unistr2(UNISTR2 *str, char *buf, int len)
{
- /* set up string lengths. add one if string is not null-terminated */
- str->uni_max_len = len+1;
+ ZERO_STRUCTP(str);
+
+ /* set up string lengths. */
+ str->uni_max_len = len;
str->undoc = 0;
- str->uni_str_len = len+1;
+ str->uni_str_len = len;
/* store the string (null-terminated 8 bit chars into 16 bit chars) */
struni2(str->buffer, buf);
/*******************************************************************
creates a DOM_RID2 structure.
********************************************************************/
-void make_dom_rid2(DOM_RID2 *rid2, uint32 rid)
+void make_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type)
{
- rid2->type = 0x5;
- rid2->undoc = 0x5;
+ rid2->type = type;
rid2->rid = rid;
rid2->rid_idx = 0;
}
prs_align(ps);
- /* should be value 5, so enforce it */
- rid2->type = 5;
-
- /* should be value 5, so enforce it */
- rid2->undoc = 5;
-
- prs_uint32("type ", ps, depth, &(rid2->type));
- prs_uint32("undoc ", ps, depth, &(rid2->undoc ));
+ prs_uint8("type ", ps, depth, &(rid2->type));
+ prs_align(ps);
prs_uint32("rid ", ps, depth, &(rid2->rid ));
prs_uint32("rid_idx", ps, depth, &(rid2->rid_idx ));
}
/*******************************************************************
creates a DOM_RID3 structure.
********************************************************************/
-void make_dom_rid3(DOM_RID3 *rid3, uint32 rid)
+void make_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
{
rid3->rid = rid;
- rid3->type1 = 0x1;
+ rid3->type1 = type;
rid3->ptr_type = 0x1; /* non-zero, basically. */
rid3->type2 = 0x1;
+ rid3->unk = type;
}
/*******************************************************************
prs_uint32("type1 ", ps, depth, &(rid3->type1 ));
prs_uint32("ptr_type", ps, depth, &(rid3->ptr_type));
prs_uint32("type2 ", ps, depth, &(rid3->type2 ));
+ prs_uint32("unk ", ps, depth, &(rid3->unk ));
}
/*******************************************************************
rid4->rid = rid;
}
-/*******************************************************************
-reads or writes a DOM_RID4 structure.
-********************************************************************/
-void smb_io_dom_rid4(char *desc, DOM_RID4 *rid4, prs_struct *ps, int depth)
-{
- if (rid4 == NULL) return;
-
- prs_debug(ps, depth, desc, "smb_io_dom_rid4. XXXX !check size of unknown! XXXX");
- depth++;
-
- prs_align(ps);
-
- prs_uint32("unknown", ps, depth, &(rid4->unknown));
- prs_uint16("attr ", ps, depth, &(rid4->attr ));
- prs_uint32("rid ", ps, depth, &(rid4->rid ));
-}
-
/*******************************************************************
makes a DOM_CLNT_SRV structure.
********************************************************************/
-void make_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
+static void make_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
{
if (log == NULL) return;
if (logon_srv != NULL)
{
log->undoc_buffer = 1;
- make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv));
+ make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
}
else
{
if (comp_name != NULL)
{
log->undoc_buffer2 = 1;
- make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name));
+ make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
}
else
{
/*******************************************************************
reads or writes a DOM_CLNT_SRV structure.
********************************************************************/
-void smb_io_clnt_srv(char *desc, DOM_CLNT_SRV *log, prs_struct *ps, int depth)
+static void smb_io_clnt_srv(char *desc, DOM_CLNT_SRV *log, prs_struct *ps, int depth)
{
if (log == NULL) return;
log->undoc_buffer = 1;
- make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv));
- make_unistr2(&(log->uni_acct_name), acct_name, strlen(acct_name));
+ make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
+ make_unistr2(&(log->uni_acct_name), acct_name, strlen(acct_name)+1);
log->sec_chan = sec_chan;
- make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name));
+ make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
}
/*******************************************************************
/*******************************************************************
reads or writes a dom query structure.
********************************************************************/
-void smb_io_dom_query_3(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
-{
- smb_io_dom_query("", d_q, ps, depth);
-}
-
-/*******************************************************************
-reads or writes a dom query structure.
-********************************************************************/
-void smb_io_dom_query_5(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
-{
- smb_io_dom_query("", d_q, ps, depth);
-}
-
-/*******************************************************************
-reads or writes a dom query structure.
-********************************************************************/
-void smb_io_dom_query(char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
+static void smb_io_dom_query(char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
{
if (d_q == NULL) return;
}
/*******************************************************************
-reads or writes a DOM_NAME structure.
+reads or writes a dom query structure.
+********************************************************************/
+void smb_io_dom_query_3(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
+{
+ smb_io_dom_query("", d_q, ps, depth);
+}
+
+/*******************************************************************
+reads or writes a dom query structure.
+********************************************************************/
+void smb_io_dom_query_5(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
+{
+ smb_io_dom_query("", d_q, ps, depth);
+}
+
+
+/*******************************************************************
+reads or writes a UNISTR3 structure.
********************************************************************/
-void smb_io_dom_name(char *desc, DOM_NAME *name, prs_struct *ps, int depth)
+void smb_io_unistr3(char *desc, UNISTR3 *name, prs_struct *ps, int depth)
{
if (name == NULL) return;
- prs_debug(ps, depth, desc, "smb_io_dom_name");
+ prs_debug(ps, depth, desc, "smb_io_unistr3");
depth++;
prs_align(ps);
/* don't know if len is specified by uni_str_len member... */
/* assume unicode string is unicode-null-terminated, instead */
- smb_io_unistr("", &(name->str), ps, depth);
+ prs_unistr3(True, "unistr", name, ps, depth);
}
git.samba.org / samba.git / blobdiff