2 Unix SMB/CIFS implementation.
3 simple kerberos5/SPNEGO routines
4 Copyright (C) Andrew Tridgell 2001
5 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002
6 Copyright (C) Andrew Bartlett 2002-2003
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
26 this is a tiny msrpc packet generator. I am only using this to
27 avoid tying this code to a particular varient of our rpc code. This
28 generator is not general enough for all our rpc needs, its just
29 enough for the spnego/ntlmssp code
31 format specifiers are:
33 U = unicode string (input is unix string)
34 a = address (input is char *unix_string)
35 (1 byte type, 1 byte length, unicode/ASCII string, all inline)
36 A = ASCII string (input is unix string)
37 B = data blob (pointer + length)
38 b = data blob in header (pointer + length)
41 C = constant ascii string
43 bool msrpc_gen(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
44 const char *format, ...)
51 int head_size=0, data_size=0;
52 int head_ofs, data_ofs;
57 pointers = talloc_array(mem_ctx, DATA_BLOB, strlen(format));
58 intargs = talloc_array(pointers, int, strlen(format));
60 /* first scan the format to work out the header and body size */
62 for (i=0; format[i]; i++) {
65 s = va_arg(ap, char *);
67 n = push_ucs2_talloc(pointers, global_smb_iconv_convenience, (void **)&pointers[i].data, s);
71 pointers[i].length = n;
72 pointers[i].length -= 2;
73 data_size += pointers[i].length;
76 s = va_arg(ap, char *);
78 n = push_ascii_talloc(pointers, global_smb_iconv_convenience, (char **)&pointers[i].data, s);
82 pointers[i].length = n;
83 pointers[i].length -= 1;
84 data_size += pointers[i].length;
89 s = va_arg(ap, char *);
90 n = push_ucs2_talloc(pointers, global_smb_iconv_convenience, (void **)&pointers[i].data, s);
94 pointers[i].length = n;
95 pointers[i].length -= 2;
96 data_size += pointers[i].length + 4;
99 b = va_arg(ap, uint8_t *);
101 pointers[i].data = b;
102 pointers[i].length = va_arg(ap, int);
103 data_size += pointers[i].length;
106 b = va_arg(ap, uint8_t *);
107 pointers[i].data = b;
108 pointers[i].length = va_arg(ap, int);
109 head_size += pointers[i].length;
117 s = va_arg(ap, char *);
118 pointers[i].data = (uint8_t *)s;
119 pointers[i].length = strlen(s)+1;
120 head_size += pointers[i].length;
126 /* allocate the space, then scan the format again to fill in the values */
127 *blob = data_blob_talloc(mem_ctx, NULL, head_size + data_size);
130 data_ofs = head_size;
132 va_start(ap, format);
133 for (i=0; format[i]; i++) {
138 n = pointers[i].length;
139 SSVAL(blob->data, head_ofs, n); head_ofs += 2;
140 SSVAL(blob->data, head_ofs, n); head_ofs += 2;
141 SIVAL(blob->data, head_ofs, data_ofs); head_ofs += 4;
142 if (pointers[i].data && n) /* don't follow null pointers... */
143 memcpy(blob->data+data_ofs, pointers[i].data, n);
148 SSVAL(blob->data, data_ofs, n); data_ofs += 2;
150 n = pointers[i].length;
151 SSVAL(blob->data, data_ofs, n); data_ofs += 2;
153 memcpy(blob->data+data_ofs, pointers[i].data, n);
159 SIVAL(blob->data, head_ofs, n);
163 n = pointers[i].length;
164 memcpy(blob->data + head_ofs, pointers[i].data, n);
168 n = pointers[i].length;
169 memcpy(blob->data + head_ofs, pointers[i].data, n);
176 talloc_free(pointers);
182 /* a helpful macro to avoid running over the end of our blob */
183 #define NEED_DATA(amount) \
184 if ((head_ofs + amount) > blob->length) { \
189 this is a tiny msrpc packet parser. This the the partner of msrpc_gen
191 format specifiers are:
193 U = unicode string (output is unix string)
196 b = data blob in header
198 C = constant ascii string
201 bool msrpc_parse(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob,
202 const char *format, ...)
213 char *p = talloc_array(mem_ctx, char, p_len);
216 va_start(ap, format);
217 for (i=0; format[i]; i++) {
221 len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
222 len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
223 ptr = IVAL(blob->data, head_ofs); head_ofs += 4;
225 ps = (const char **)va_arg(ap, char **);
226 if (len1 == 0 && len2 == 0) {
229 /* make sure its in the right format - be strict */
230 if ((len1 != len2) || (ptr + len1 < ptr) || (ptr + len1 < len1) || (ptr + len1 > blob->length)) {
235 /* if odd length and unicode */
239 if (blob->data + ptr < (uint8_t *)ptr ||
240 blob->data + ptr < blob->data) {
246 pull_string(global_smb_iconv_convenience, p, blob->data + ptr, p_len,
247 len1, STR_UNICODE|STR_NOALIGN);
248 (*ps) = talloc_strdup(mem_ctx, p);
260 len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
261 len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
262 ptr = IVAL(blob->data, head_ofs); head_ofs += 4;
264 ps = (const char **)va_arg(ap, char **);
265 /* make sure its in the right format - be strict */
266 if (len1 == 0 && len2 == 0) {
269 if ((len1 != len2) || (ptr + len1 < ptr) || (ptr + len1 < len1) || (ptr + len1 > blob->length)) {
274 if (blob->data + ptr < (uint8_t *)ptr ||
275 blob->data + ptr < blob->data) {
281 pull_string(global_smb_iconv_convenience, p, blob->data + ptr, p_len,
282 len1, STR_ASCII|STR_NOALIGN);
283 (*ps) = talloc_strdup(mem_ctx, p);
295 len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
296 len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
297 ptr = IVAL(blob->data, head_ofs); head_ofs += 4;
299 b = (DATA_BLOB *)va_arg(ap, void *);
300 if (len1 == 0 && len2 == 0) {
301 *b = data_blob_talloc(mem_ctx, NULL, 0);
303 /* make sure its in the right format - be strict */
304 if ((len1 != len2) || (ptr + len1 < ptr) || (ptr + len1 < len1) || (ptr + len1 > blob->length)) {
309 if (blob->data + ptr < (uint8_t *)ptr ||
310 blob->data + ptr < blob->data) {
315 *b = data_blob_talloc(mem_ctx, blob->data + ptr, len1);
319 b = (DATA_BLOB *)va_arg(ap, void *);
320 len1 = va_arg(ap, uint_t);
321 /* make sure its in the right format - be strict */
323 if (blob->data + head_ofs < (uint8_t *)head_ofs ||
324 blob->data + head_ofs < blob->data) {
329 *b = data_blob_talloc(mem_ctx, blob->data + head_ofs, len1);
333 v = va_arg(ap, uint32_t *);
335 *v = IVAL(blob->data, head_ofs); head_ofs += 4;
338 s = va_arg(ap, char *);
340 if (blob->data + head_ofs < (uint8_t *)head_ofs ||
341 blob->data + head_ofs < blob->data) {
346 head_ofs += pull_string(global_smb_iconv_convenience, p,
347 blob->data+head_ofs, p_len,
348 blob->length - head_ofs,
349 STR_ASCII|STR_TERMINATE);
350 if (strcmp(s, p) != 0) {