2 Unix SMB/CIFS implementation.
4 dcerpc utility functions
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Jelmer Vernooij 2004
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "system/network.h"
26 #include "librpc/gen_ndr/ndr_epmapper.h"
29 find the pipe name for a local IDL interface
31 const char *idl_pipe_name(const char *uuid
, uint32_t if_version
)
33 const struct dcerpc_interface_list
*l
;
34 for (l
=librpc_dcerpc_pipes();l
;l
=l
->next
) {
35 if (strcasecmp(l
->table
->uuid
, uuid
) == 0 &&
36 l
->table
->if_version
== if_version
) {
37 return l
->table
->name
;
44 find the number of calls defined by local IDL
46 int idl_num_calls(const char *uuid
, uint32_t if_version
)
48 const struct dcerpc_interface_list
*l
;
49 for (l
=librpc_dcerpc_pipes();l
;l
=l
->next
){
50 if (strcasecmp(l
->table
->uuid
, uuid
) == 0 &&
51 l
->table
->if_version
== if_version
) {
52 return l
->table
->num_calls
;
60 find a dcerpc interface by name
62 const struct dcerpc_interface_table
*idl_iface_by_name(const char *name
)
64 const struct dcerpc_interface_list
*l
;
65 for (l
=librpc_dcerpc_pipes();l
;l
=l
->next
) {
66 if (strcasecmp(l
->table
->name
, name
) == 0) {
74 find a dcerpc interface by uuid
76 const struct dcerpc_interface_table
*idl_iface_by_uuid(const char *uuid
)
78 const struct dcerpc_interface_list
*l
;
79 for (l
=librpc_dcerpc_pipes();l
;l
=l
->next
) {
80 if (strcasecmp(l
->table
->uuid
, uuid
) == 0) {
89 push a dcerpc_packet into a blob, potentially with auth info
91 NTSTATUS
dcerpc_push_auth(DATA_BLOB
*blob
, TALLOC_CTX
*mem_ctx
,
92 struct dcerpc_packet
*pkt
,
93 struct dcerpc_auth
*auth_info
)
98 ndr
= ndr_push_init_ctx(mem_ctx
);
100 return NT_STATUS_NO_MEMORY
;
103 if (!(pkt
->drep
[0] & DCERPC_DREP_LE
)) {
104 ndr
->flags
|= LIBNDR_FLAG_BIGENDIAN
;
107 if (pkt
->pfc_flags
& DCERPC_PFC_FLAG_ORPC
) {
108 ndr
->flags
|= LIBNDR_FLAG_OBJECT_PRESENT
;
112 pkt
->auth_length
= auth_info
->credentials
.length
;
114 pkt
->auth_length
= 0;
117 status
= ndr_push_dcerpc_packet(ndr
, NDR_SCALARS
|NDR_BUFFERS
, pkt
);
118 if (!NT_STATUS_IS_OK(status
)) {
123 status
= ndr_push_dcerpc_auth(ndr
, NDR_SCALARS
|NDR_BUFFERS
, auth_info
);
126 *blob
= ndr_push_blob(ndr
);
128 /* fill in the frag length */
129 dcerpc_set_frag_length(blob
, blob
->length
);
134 #define MAX_PROTSEQ 10
136 static const struct {
138 enum dcerpc_transport_t transport
;
140 enum epm_protocol protseq
[MAX_PROTSEQ
];
142 { "ncacn_np", NCACN_NP
, 3,
143 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_SMB
, EPM_PROTOCOL_NETBIOS
}},
144 { "ncacn_ip_tcp", NCACN_IP_TCP
, 3,
145 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_TCP
, EPM_PROTOCOL_IP
} },
146 { "ncacn_http", NCACN_HTTP
, 3,
147 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_HTTP
, EPM_PROTOCOL_IP
} },
148 { "ncadg_ip_udp", NCACN_IP_UDP
, 3,
149 { EPM_PROTOCOL_NCADG
, EPM_PROTOCOL_UDP
, EPM_PROTOCOL_IP
} },
150 { "ncalrpc", NCALRPC
, 2,
151 { EPM_PROTOCOL_NCALRPC
, EPM_PROTOCOL_PIPE
} },
152 { "ncacn_unix_stream", NCACN_UNIX_STREAM
, 2,
153 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_UNIX_DS
} },
154 { "ncadg_unix_dgram", NCADG_UNIX_DGRAM
, 2,
155 { EPM_PROTOCOL_NCADG
, EPM_PROTOCOL_UNIX_DS
} },
156 { "ncacn_at_dsp", NCACN_AT_DSP
, 3,
157 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_APPLETALK
, EPM_PROTOCOL_DSP
} },
158 { "ncadg_at_ddp", NCADG_AT_DDP
, 3,
159 { EPM_PROTOCOL_NCADG
, EPM_PROTOCOL_APPLETALK
, EPM_PROTOCOL_DDP
} },
160 { "ncacn_vns_ssp", NCACN_VNS_SPP
, 3,
161 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_STREETTALK
, EPM_PROTOCOL_VINES_SPP
} },
162 { "ncacn_vns_ipc", NCACN_VNS_IPC
, 3,
163 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_STREETTALK
, EPM_PROTOCOL_VINES_IPC
}, },
164 { "ncadg_ipx", NCADG_IPX
, 2,
165 { EPM_PROTOCOL_NCADG
, EPM_PROTOCOL_IPX
},
167 { "ncacn_spx", NCACN_SPX
, 2,
168 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_SPX
},
172 static const struct {
175 } ncacn_options
[] = {
176 {"sign", DCERPC_SIGN
},
177 {"seal", DCERPC_SEAL
},
178 {"connect", DCERPC_CONNECT
},
179 {"spnego", DCERPC_AUTH_SPNEGO
},
180 {"krb5", DCERPC_AUTH_KRB5
},
181 {"validate", DCERPC_DEBUG_VALIDATE_BOTH
},
182 {"print", DCERPC_DEBUG_PRINT_BOTH
},
183 {"padcheck", DCERPC_DEBUG_PAD_CHECK
},
184 {"bigendian", DCERPC_PUSH_BIGENDIAN
}
187 const char *epm_floor_string(TALLOC_CTX
*mem_ctx
, struct epm_floor
*fl
)
193 switch(fl
->lhs
.protocol
) {
194 case EPM_PROTOCOL_UUID
:
195 status
= dcerpc_floor_get_lhs_data(fl
, &uuid
, &if_version
);
196 if (NT_STATUS_IS_OK(status
)) {
197 /* lhs is used: UUID */
200 uuidstr
= GUID_string(mem_ctx
, &uuid
);
202 if (strcasecmp(uuidstr
, NDR_GUID
) == 0) {
206 return talloc_asprintf(mem_ctx
, " uuid %s/0x%02x", uuidstr
, if_version
);
208 return talloc_asprintf(mem_ctx
, "IPX:%s",
209 data_blob_hex_string(mem_ctx
, &fl
->rhs
.uuid
.unknown
));
212 case EPM_PROTOCOL_NCACN
:
215 case EPM_PROTOCOL_NCADG
:
218 case EPM_PROTOCOL_NCALRPC
:
221 case EPM_PROTOCOL_DNET_NSP
:
224 case EPM_PROTOCOL_IP
:
225 return talloc_asprintf(mem_ctx
, "IP:%s", fl
->rhs
.ip
.ipaddr
);
227 case EPM_PROTOCOL_PIPE
:
228 return talloc_asprintf(mem_ctx
, "PIPE:%s", fl
->rhs
.pipe
.path
);
230 case EPM_PROTOCOL_SMB
:
231 return talloc_asprintf(mem_ctx
, "SMB:%s", fl
->rhs
.smb
.unc
);
233 case EPM_PROTOCOL_UNIX_DS
:
234 return talloc_asprintf(mem_ctx
, "Unix:%s", fl
->rhs
.unix_ds
.path
);
236 case EPM_PROTOCOL_NETBIOS
:
237 return talloc_asprintf(mem_ctx
, "NetBIOS:%s", fl
->rhs
.netbios
.name
);
239 case EPM_PROTOCOL_NETBEUI
:
242 case EPM_PROTOCOL_SPX
:
245 case EPM_PROTOCOL_NB_IPX
:
248 case EPM_PROTOCOL_HTTP
:
249 return talloc_asprintf(mem_ctx
, "HTTP:%d", fl
->rhs
.http
.port
);
251 case EPM_PROTOCOL_TCP
:
252 return talloc_asprintf(mem_ctx
, "TCP:%d", fl
->rhs
.tcp
.port
);
254 case EPM_PROTOCOL_UDP
:
255 return talloc_asprintf(mem_ctx
, "UDP:%d", fl
->rhs
.udp
.port
);
258 return talloc_asprintf(mem_ctx
, "UNK(%02x):", fl
->lhs
.protocol
);
264 form a binding string from a binding structure
266 const char *dcerpc_binding_string(TALLOC_CTX
*mem_ctx
, const struct dcerpc_binding
*b
)
268 char *s
= talloc_strdup(mem_ctx
, "");
270 const char *t_name
=NULL
;
272 for (i
=0;i
<ARRAY_SIZE(transports
);i
++) {
273 if (transports
[i
].transport
== b
->transport
) {
274 t_name
= transports
[i
].name
;
281 if (!GUID_all_zero(&b
->object
)) {
282 s
= talloc_asprintf(s
, "%s@",
283 GUID_string(mem_ctx
, &b
->object
));
286 s
= talloc_asprintf_append(s
, "%s:", t_name
);
290 s
= talloc_asprintf_append(s
, "%s", b
->host
);
293 if (!b
->endpoint
&& !b
->options
&& !b
->flags
) {
297 s
= talloc_asprintf_append(s
, "[");
300 s
= talloc_asprintf_append(s
, "%s", b
->endpoint
);
303 /* this is a *really* inefficent way of dealing with strings,
304 but this is rarely called and the strings are always short,
306 for (i
=0;b
->options
&& b
->options
[i
];i
++) {
307 s
= talloc_asprintf_append(s
, ",%s", b
->options
[i
]);
311 for (i
=0;i
<ARRAY_SIZE(ncacn_options
);i
++) {
312 if (b
->flags
& ncacn_options
[i
].flag
) {
313 s
= talloc_asprintf_append(s
, ",%s", ncacn_options
[i
].name
);
318 s
= talloc_asprintf_append(s
, "]");
324 parse a binding string into a dcerpc_binding structure
326 NTSTATUS
dcerpc_parse_binding(TALLOC_CTX
*mem_ctx
, const char *s
, struct dcerpc_binding
*b
)
328 char *options
, *type
;
330 int i
, j
, comma_count
;
334 if (p
&& PTR_DIFF(p
, s
) == 36) { /* 36 is the length of a UUID */
337 status
= GUID_from_string(s
, &b
->object
);
339 if (NT_STATUS_IS_ERR(status
)) {
340 DEBUG(0, ("Failed parsing UUID\n"));
346 ZERO_STRUCT(b
->object
);
349 b
->object_version
= 0;
353 return NT_STATUS_INVALID_PARAMETER
;
356 type
= talloc_strndup(mem_ctx
, s
, PTR_DIFF(p
, s
));
358 return NT_STATUS_NO_MEMORY
;
361 for (i
=0;i
<ARRAY_SIZE(transports
);i
++) {
362 if (strcasecmp(type
, transports
[i
].name
) == 0) {
363 b
->transport
= transports
[i
].transport
;
367 if (i
==ARRAY_SIZE(transports
)) {
368 DEBUG(0,("Unknown dcerpc transport '%s'\n", type
));
369 return NT_STATUS_INVALID_PARAMETER
;
376 b
->host
= talloc_strndup(mem_ctx
, s
, PTR_DIFF(p
, s
));
377 options
= talloc_strdup(mem_ctx
, p
+1);
378 if (options
[strlen(options
)-1] != ']') {
379 return NT_STATUS_INVALID_PARAMETER
;
381 options
[strlen(options
)-1] = 0;
383 b
->host
= talloc_strdup(mem_ctx
, s
);
388 return NT_STATUS_NO_MEMORY
;
399 comma_count
= count_chars(options
, ',');
401 b
->options
= talloc_array(mem_ctx
, const char *, comma_count
+2);
403 return NT_STATUS_NO_MEMORY
;
406 for (i
=0; (p
= strchr(options
, ',')); i
++) {
407 b
->options
[i
] = talloc_strndup(mem_ctx
, options
, PTR_DIFF(p
, options
));
408 if (!b
->options
[i
]) {
409 return NT_STATUS_NO_MEMORY
;
413 b
->options
[i
] = options
;
414 b
->options
[i
+1] = NULL
;
416 /* some options are pre-parsed for convenience */
417 for (i
=0;b
->options
[i
];i
++) {
418 for (j
=0;j
<ARRAY_SIZE(ncacn_options
);j
++) {
419 if (strcasecmp(ncacn_options
[j
].name
, b
->options
[i
]) == 0) {
421 b
->flags
|= ncacn_options
[j
].flag
;
422 for (k
=i
;b
->options
[k
];k
++) {
423 b
->options
[k
] = b
->options
[k
+1];
432 /* Endpoint is first option */
433 b
->endpoint
= b
->options
[0];
434 if (strlen(b
->endpoint
) == 0) b
->endpoint
= NULL
;
436 for (i
=0;b
->options
[i
];i
++) {
437 b
->options
[i
] = b
->options
[i
+1];
441 if (b
->options
[0] == NULL
)
447 NTSTATUS
dcerpc_floor_get_lhs_data(struct epm_floor
*floor
, struct GUID
*uuid
, uint16_t *if_version
)
449 TALLOC_CTX
*mem_ctx
= talloc_init("floor_get_lhs_data");
450 struct ndr_pull
*ndr
= ndr_pull_init_blob(&floor
->lhs
.lhs_data
, mem_ctx
);
453 ndr
->flags
|= LIBNDR_FLAG_NOALIGN
;
455 status
= ndr_pull_GUID(ndr
, NDR_SCALARS
| NDR_BUFFERS
, uuid
);
456 if (NT_STATUS_IS_ERR(status
)) {
457 talloc_free(mem_ctx
);
461 status
= ndr_pull_uint16(ndr
, NDR_SCALARS
, if_version
);
463 talloc_free(mem_ctx
);
468 DATA_BLOB
dcerpc_floor_pack_lhs_data(TALLOC_CTX
*mem_ctx
, struct GUID
*uuid
, uint32_t if_version
)
470 struct ndr_push
*ndr
= ndr_push_init_ctx(mem_ctx
);
472 ndr
->flags
|= LIBNDR_FLAG_NOALIGN
;
474 ndr_push_GUID(ndr
, NDR_SCALARS
| NDR_BUFFERS
, uuid
);
475 ndr_push_uint16(ndr
, NDR_SCALARS
, if_version
);
477 return ndr_push_blob(ndr
);
480 const char *dcerpc_floor_get_rhs_data(TALLOC_CTX
*mem_ctx
, struct epm_floor
*floor
)
482 switch (floor
->lhs
.protocol
) {
483 case EPM_PROTOCOL_TCP
:
484 if (floor
->rhs
.tcp
.port
== 0) return NULL
;
485 return talloc_asprintf(mem_ctx
, "%d", floor
->rhs
.tcp
.port
);
487 case EPM_PROTOCOL_UDP
:
488 if (floor
->rhs
.udp
.port
== 0) return NULL
;
489 return talloc_asprintf(mem_ctx
, "%d", floor
->rhs
.udp
.port
);
491 case EPM_PROTOCOL_HTTP
:
492 if (floor
->rhs
.http
.port
== 0) return NULL
;
493 return talloc_asprintf(mem_ctx
, "%d", floor
->rhs
.http
.port
);
495 case EPM_PROTOCOL_IP
:
496 return talloc_strdup(mem_ctx
, floor
->rhs
.ip
.ipaddr
);
498 case EPM_PROTOCOL_NCACN
:
501 case EPM_PROTOCOL_NCADG
:
504 case EPM_PROTOCOL_SMB
:
505 if (strlen(floor
->rhs
.smb
.unc
) == 0) return NULL
;
506 return talloc_strdup(mem_ctx
, floor
->rhs
.smb
.unc
);
508 case EPM_PROTOCOL_PIPE
:
509 if (strlen(floor
->rhs
.pipe
.path
) == 0) return NULL
;
510 return talloc_strdup(mem_ctx
, floor
->rhs
.pipe
.path
);
512 case EPM_PROTOCOL_NETBIOS
:
513 if (strlen(floor
->rhs
.netbios
.name
) == 0) return NULL
;
514 return talloc_strdup(mem_ctx
, floor
->rhs
.netbios
.name
);
516 case EPM_PROTOCOL_NCALRPC
:
519 case EPM_PROTOCOL_VINES_SPP
:
520 return talloc_asprintf(mem_ctx
, "%d", floor
->rhs
.vines_spp
.port
);
522 case EPM_PROTOCOL_VINES_IPC
:
523 return talloc_asprintf(mem_ctx
, "%d", floor
->rhs
.vines_ipc
.port
);
525 case EPM_PROTOCOL_STREETTALK
:
526 return talloc_strdup(mem_ctx
, floor
->rhs
.streettalk
.streettalk
);
528 case EPM_PROTOCOL_UNIX_DS
:
529 if (strlen(floor
->rhs
.unix_ds
.path
) == 0) return NULL
;
530 return talloc_strdup(mem_ctx
, floor
->rhs
.unix_ds
.path
);
532 case EPM_PROTOCOL_NULL
:
536 DEBUG(0,("Unsupported lhs protocol %d\n", floor
->lhs
.protocol
));
543 static NTSTATUS
dcerpc_floor_set_rhs_data(TALLOC_CTX
*mem_ctx
, struct epm_floor
*floor
, const char *data
)
545 switch (floor
->lhs
.protocol
) {
546 case EPM_PROTOCOL_TCP
:
547 floor
->rhs
.tcp
.port
= atoi(data
);
550 case EPM_PROTOCOL_UDP
:
551 floor
->rhs
.udp
.port
= atoi(data
);
554 case EPM_PROTOCOL_HTTP
:
555 floor
->rhs
.http
.port
= atoi(data
);
558 case EPM_PROTOCOL_IP
:
559 floor
->rhs
.ip
.ipaddr
= talloc_strdup(mem_ctx
, data
);
560 NT_STATUS_HAVE_NO_MEMORY(floor
->rhs
.ip
.ipaddr
);
563 case EPM_PROTOCOL_NCACN
:
564 floor
->rhs
.ncacn
.minor_version
= 0;
567 case EPM_PROTOCOL_NCADG
:
568 floor
->rhs
.ncadg
.minor_version
= 0;
571 case EPM_PROTOCOL_SMB
:
572 floor
->rhs
.smb
.unc
= talloc_strdup(mem_ctx
, data
);
573 NT_STATUS_HAVE_NO_MEMORY(floor
->rhs
.smb
.unc
);
576 case EPM_PROTOCOL_PIPE
:
577 floor
->rhs
.pipe
.path
= talloc_strdup(mem_ctx
, data
);
578 NT_STATUS_HAVE_NO_MEMORY(floor
->rhs
.pipe
.path
);
581 case EPM_PROTOCOL_NETBIOS
:
582 floor
->rhs
.netbios
.name
= talloc_strdup(mem_ctx
, data
);
583 NT_STATUS_HAVE_NO_MEMORY(floor
->rhs
.netbios
.name
);
586 case EPM_PROTOCOL_NCALRPC
:
589 case EPM_PROTOCOL_VINES_SPP
:
590 floor
->rhs
.vines_spp
.port
= atoi(data
);
593 case EPM_PROTOCOL_VINES_IPC
:
594 floor
->rhs
.vines_ipc
.port
= atoi(data
);
597 case EPM_PROTOCOL_STREETTALK
:
598 floor
->rhs
.streettalk
.streettalk
= talloc_strdup(mem_ctx
, data
);
599 NT_STATUS_HAVE_NO_MEMORY(floor
->rhs
.streettalk
.streettalk
);
602 case EPM_PROTOCOL_UNIX_DS
:
603 floor
->rhs
.unix_ds
.path
= talloc_strdup(mem_ctx
, data
);
604 NT_STATUS_HAVE_NO_MEMORY(floor
->rhs
.unix_ds
.path
);
607 case EPM_PROTOCOL_NULL
:
611 DEBUG(0,("Unsupported lhs protocol %d\n", floor
->lhs
.protocol
));
615 return NT_STATUS_NOT_SUPPORTED
;
618 enum dcerpc_transport_t
dcerpc_transport_by_endpoint_protocol(int prot
)
622 /* Find a transport that has 'prot' as 4th protocol */
623 for (i
=0;i
<ARRAY_SIZE(transports
);i
++) {
624 if (transports
[i
].num_protocols
>= 2 &&
625 transports
[i
].protseq
[1] == prot
) {
626 return transports
[i
].transport
;
630 /* Unknown transport */
634 enum dcerpc_transport_t
dcerpc_transport_by_tower(struct epm_tower
*tower
)
638 /* Find a transport that matches this tower */
639 for (i
=0;i
<ARRAY_SIZE(transports
);i
++) {
641 if (transports
[i
].num_protocols
!= tower
->num_floors
- 2) {
645 for (j
= 0; j
< transports
[i
].num_protocols
; j
++) {
646 if (transports
[i
].protseq
[j
] != tower
->floors
[j
+2].lhs
.protocol
) {
651 if (j
== transports
[i
].num_protocols
) {
652 return transports
[i
].transport
;
656 /* Unknown transport */
660 NTSTATUS
dcerpc_binding_from_tower(TALLOC_CTX
*mem_ctx
, struct epm_tower
*tower
, struct dcerpc_binding
*binding
)
664 ZERO_STRUCT(binding
->object
);
665 binding
->options
= NULL
;
666 binding
->host
= NULL
;
669 binding
->transport
= dcerpc_transport_by_tower(tower
);
671 if (binding
->transport
== -1) {
672 return NT_STATUS_NOT_SUPPORTED
;
675 if (tower
->num_floors
< 1) {
679 /* Set object uuid */
680 status
= dcerpc_floor_get_lhs_data(&tower
->floors
[0], &binding
->object
, &binding
->object_version
);
682 if (!NT_STATUS_IS_OK(status
)) {
683 DEBUG(1, ("Error pulling object uuid and version: %s", nt_errstr(status
)));
687 /* Ignore floor 1, it contains the NDR version info */
689 binding
->options
= NULL
;
692 if (tower
->num_floors
>= 4) {
693 binding
->endpoint
= dcerpc_floor_get_rhs_data(mem_ctx
, &tower
->floors
[3]);
695 binding
->endpoint
= NULL
;
698 /* Set network address */
699 if (tower
->num_floors
>= 5) {
700 binding
->host
= dcerpc_floor_get_rhs_data(mem_ctx
, &tower
->floors
[4]);
705 NTSTATUS
dcerpc_binding_build_tower(TALLOC_CTX
*mem_ctx
, struct dcerpc_binding
*binding
, struct epm_tower
*tower
)
707 const enum epm_protocol
*protseq
= NULL
;
708 int num_protocols
= -1, i
;
709 struct GUID ndr_guid
;
713 for (i
=0;i
<ARRAY_SIZE(transports
);i
++) {
714 if (transports
[i
].transport
== binding
->transport
) {
715 protseq
= transports
[i
].protseq
;
716 num_protocols
= transports
[i
].num_protocols
;
721 if (num_protocols
== -1) {
722 DEBUG(0, ("Unable to find transport with id '%d'\n", binding
->transport
));
723 return NT_STATUS_UNSUCCESSFUL
;
726 tower
->num_floors
= 2 + num_protocols
;
727 tower
->floors
= talloc_array(mem_ctx
, struct epm_floor
, tower
->num_floors
);
730 tower
->floors
[0].lhs
.protocol
= EPM_PROTOCOL_UUID
;
732 tower
->floors
[0].lhs
.lhs_data
= dcerpc_floor_pack_lhs_data(mem_ctx
, &binding
->object
, binding
->object_version
);
734 tower
->floors
[0].rhs
.uuid
.unknown
= data_blob_talloc_zero(mem_ctx
, 2);
737 tower
->floors
[1].lhs
.protocol
= EPM_PROTOCOL_UUID
;
739 status
= GUID_from_string(NDR_GUID
, &ndr_guid
);
740 if (NT_STATUS_IS_ERR(status
)) {
744 tower
->floors
[1].lhs
.lhs_data
= dcerpc_floor_pack_lhs_data(mem_ctx
, &ndr_guid
, NDR_GUID_VERSION
);
746 tower
->floors
[1].rhs
.uuid
.unknown
= data_blob_talloc_zero(mem_ctx
, 2);
748 /* Floor 2 to num_protocols */
749 for (i
= 0; i
< num_protocols
; i
++) {
750 tower
->floors
[2 + i
].lhs
.protocol
= protseq
[i
];
751 tower
->floors
[2 + i
].lhs
.lhs_data
= data_blob_talloc(mem_ctx
, NULL
, 0);
752 ZERO_STRUCT(tower
->floors
[2 + i
].rhs
);
753 dcerpc_floor_set_rhs_data(mem_ctx
, &tower
->floors
[2 + i
], "");
756 /* The 4th floor contains the endpoint */
757 if (num_protocols
>= 2 && binding
->endpoint
) {
758 status
= dcerpc_floor_set_rhs_data(mem_ctx
, &tower
->floors
[3], binding
->endpoint
);
759 if (NT_STATUS_IS_ERR(status
)) {
764 /* The 5th contains the network address */
765 if (num_protocols
>= 3 && binding
->host
) {
766 status
= dcerpc_floor_set_rhs_data(mem_ctx
, &tower
->floors
[4], binding
->host
);
767 if (NT_STATUS_IS_ERR(status
)) {
775 NTSTATUS
dcerpc_epm_map_binding(TALLOC_CTX
*mem_ctx
, struct dcerpc_binding
*binding
,
776 const char *uuid
, uint_t version
)
778 struct dcerpc_pipe
*p
;
781 struct policy_handle handle
;
783 struct epm_twr_t twr
, *twr_r
;
784 struct dcerpc_binding epmapper_binding
;
785 const struct dcerpc_interface_table
*table
= idl_iface_by_uuid(uuid
);
788 /* First, check if there is a default endpoint specified in the IDL */
791 struct dcerpc_binding default_binding
;
793 binding
->authservice
= talloc_strdup(mem_ctx
, table
->authservices
->names
[0]);
795 /* Find one of the default pipes for this interface */
796 for (i
= 0; i
< table
->endpoints
->count
; i
++) {
797 status
= dcerpc_parse_binding(mem_ctx
, table
->endpoints
->names
[i
], &default_binding
);
799 if (NT_STATUS_IS_OK(status
) && default_binding
.transport
== binding
->transport
&& default_binding
.endpoint
) {
800 binding
->endpoint
= talloc_strdup(mem_ctx
, default_binding
.endpoint
);
807 ZERO_STRUCT(epmapper_binding
);
808 epmapper_binding
.transport
= binding
->transport
;
809 epmapper_binding
.host
= binding
->host
;
810 epmapper_binding
.options
= NULL
;
811 epmapper_binding
.flags
= 0;
812 epmapper_binding
.endpoint
= NULL
;
813 epmapper_binding
.authservice
= NULL
;
815 status
= dcerpc_pipe_connect_b(&p
,
817 DCERPC_EPMAPPER_UUID
,
818 DCERPC_EPMAPPER_VERSION
,
821 if (!NT_STATUS_IS_OK(status
)) {
828 status
= GUID_from_string(uuid
, &binding
->object
);
829 if (NT_STATUS_IS_ERR(status
)) {
833 binding
->object_version
= version
;
835 status
= dcerpc_binding_build_tower(p
, binding
, &twr
.tower
);
836 if (NT_STATUS_IS_ERR(status
)) {
840 /* with some nice pretty paper around it of course */
842 r
.in
.map_tower
= &twr
;
843 r
.in
.entry_handle
= &handle
;
845 r
.out
.entry_handle
= &handle
;
847 status
= dcerpc_epm_Map(p
, p
, &r
);
848 if (!NT_STATUS_IS_OK(status
)) {
849 dcerpc_pipe_close(p
);
852 if (r
.out
.result
!= 0 || r
.out
.num_towers
!= 1) {
853 dcerpc_pipe_close(p
);
854 return NT_STATUS_PORT_UNREACHABLE
;
857 twr_r
= r
.out
.towers
[0].twr
;
859 dcerpc_pipe_close(p
);
860 return NT_STATUS_PORT_UNREACHABLE
;
863 if (twr_r
->tower
.num_floors
!= twr
.tower
.num_floors
||
864 twr_r
->tower
.floors
[3].lhs
.protocol
!= twr
.tower
.floors
[3].lhs
.protocol
) {
865 dcerpc_pipe_close(p
);
866 return NT_STATUS_PORT_UNREACHABLE
;
869 binding
->endpoint
= dcerpc_floor_get_rhs_data(mem_ctx
, &twr_r
->tower
.floors
[3]);
871 dcerpc_pipe_close(p
);
878 perform an authenticated bind if needed
880 static NTSTATUS
dcerpc_pipe_auth(struct dcerpc_pipe
*p
,
881 struct dcerpc_binding
*binding
,
882 const char *pipe_uuid
,
883 uint32_t pipe_version
,
885 const char *username
,
886 const char *password
)
889 p
->conn
->flags
= binding
->flags
;
891 /* remember the binding string for possible secondary connections */
892 p
->conn
->binding_string
= dcerpc_binding_string(p
, binding
);
894 if (username
&& username
[0] && (binding
->flags
& DCERPC_SCHANNEL_ANY
)) {
895 status
= dcerpc_bind_auth_schannel(p
, pipe_uuid
, pipe_version
,
896 domain
, username
, password
);
897 } else if (username
&& username
[0]) {
899 if (binding
->flags
& DCERPC_AUTH_SPNEGO
) {
900 auth_type
= DCERPC_AUTH_TYPE_SPNEGO
;
901 } else if (binding
->flags
& DCERPC_AUTH_KRB5
) {
902 auth_type
= DCERPC_AUTH_TYPE_KRB5
;
904 auth_type
= DCERPC_AUTH_TYPE_NTLMSSP
;
907 status
= dcerpc_bind_auth_password(p
, pipe_uuid
, pipe_version
,
908 domain
, username
, password
,
910 binding
->authservice
);
912 status
= dcerpc_bind_auth_none(p
, pipe_uuid
, pipe_version
);
915 if (!NT_STATUS_IS_OK(status
)) {
916 DEBUG(0,("Failed to bind to uuid %s - %s\n", pipe_uuid
, nt_errstr(status
)));
922 /* open a rpc connection to a rpc pipe on SMB using the binding
923 structure to determine the endpoint and options */
924 static NTSTATUS
dcerpc_pipe_connect_ncacn_np(struct dcerpc_pipe
**pp
,
925 struct dcerpc_binding
*binding
,
926 const char *pipe_uuid
,
927 uint32_t pipe_version
,
929 const char *username
,
930 const char *password
)
932 struct dcerpc_pipe
*p
;
934 struct smbcli_state
*cli
;
935 const char *pipe_name
= NULL
;
940 p
= dcerpc_pipe_init(NULL
);
942 return NT_STATUS_NO_MEMORY
;
944 tmp_ctx
= talloc_new(p
);
946 /* Look up identifier using the epmapper */
947 if (!binding
->endpoint
) {
948 status
= dcerpc_epm_map_binding(tmp_ctx
, binding
, pipe_uuid
, pipe_version
);
949 if (!NT_STATUS_IS_OK(status
)) {
950 DEBUG(0,("Failed to map DCERPC/TCP NCACN_NP pipe for '%s' - %s\n",
951 pipe_uuid
, nt_errstr(status
)));
955 DEBUG(1,("Mapped to DCERPC/NP pipe %s\n", binding
->endpoint
));
958 pipe_name
= binding
->endpoint
;
960 if (!strncasecmp(pipe_name
, "/pipe/", 6) ||
961 !strncasecmp(pipe_name
, "\\pipe\\", 6)) {
965 if (pipe_name
[0] != '\\') {
966 pipe_name
= talloc_asprintf(tmp_ctx
, "\\%s", pipe_name
);
969 if (!username
|| !username
[0] ||
970 (binding
->flags
& DCERPC_SCHANNEL_ANY
)) {
971 status
= smbcli_full_connection(p
->conn
, &cli
, lp_netbios_name(),
976 status
= smbcli_full_connection(p
->conn
, &cli
, lp_netbios_name(),
982 if (!NT_STATUS_IS_OK(status
)) {
983 DEBUG(0,("Failed to connect to %s - %s\n", binding
->host
, nt_errstr(status
)));
988 status
= dcerpc_pipe_open_smb(p
->conn
, cli
->tree
, pipe_name
);
989 if (!NT_STATUS_IS_OK(status
)) {
990 DEBUG(0,("Failed to open pipe %s - %s\n", pipe_name
, nt_errstr(status
)));
995 if (!(binding
->flags
& DCERPC_AUTH_OPTIONS
)) {
999 status
= dcerpc_pipe_auth(p
, binding
, pipe_uuid
, pipe_version
, domain
, username
, password
);
1000 if (!NT_STATUS_IS_OK(status
)) {
1006 talloc_free(tmp_ctx
);
1008 return NT_STATUS_OK
;
1011 /* open a rpc connection to a rpc pipe on SMP using the binding
1012 structure to determine the endpoint and options */
1013 static NTSTATUS
dcerpc_pipe_connect_ncalrpc(struct dcerpc_pipe
**pp
,
1014 struct dcerpc_binding
*binding
,
1015 const char *pipe_uuid
,
1016 uint32_t pipe_version
,
1018 const char *username
,
1019 const char *password
)
1022 struct dcerpc_pipe
*p
;
1023 TALLOC_CTX
*tmp_ctx
;
1027 p
= dcerpc_pipe_init(NULL
);
1029 return NT_STATUS_NO_MEMORY
;
1031 tmp_ctx
= talloc_new(p
);
1033 /* Look up identifier using the epmapper */
1034 if (!binding
->endpoint
) {
1035 status
= dcerpc_epm_map_binding(tmp_ctx
, binding
, pipe_uuid
, pipe_version
);
1036 if (!NT_STATUS_IS_OK(status
)) {
1037 DEBUG(0,("Failed to map DCERPC/TCP NCALRPC identifier for '%s' - %s\n",
1038 pipe_uuid
, nt_errstr(status
)));
1042 DEBUG(1,("Mapped to DCERPC/LRPC identifier %s\n", binding
->endpoint
));
1045 status
= dcerpc_pipe_open_pipe(p
->conn
, binding
->endpoint
);
1046 if (!NT_STATUS_IS_OK(status
)) {
1047 DEBUG(0,("Failed to open ncalrpc pipe '%s' - %s\n",
1048 binding
->endpoint
, nt_errstr(status
)));
1053 status
= dcerpc_pipe_auth(p
, binding
, pipe_uuid
, pipe_version
, domain
, username
, password
);
1054 if (!NT_STATUS_IS_OK(status
)) {
1060 talloc_free(tmp_ctx
);
1067 /* open a rpc connection to a rpc pipe on SMP using the binding
1068 structure to determine the endpoint and options */
1069 static NTSTATUS
dcerpc_pipe_connect_ncacn_unix_stream(struct dcerpc_pipe
**pp
,
1070 struct dcerpc_binding
*binding
,
1071 const char *pipe_uuid
,
1072 uint32_t pipe_version
,
1074 const char *username
,
1075 const char *password
)
1078 struct dcerpc_pipe
*p
;
1082 if (!binding
->endpoint
) {
1083 DEBUG(0, ("Path to unix socket not specified\n"));
1084 return NT_STATUS_INVALID_PARAMETER
;
1087 p
= dcerpc_pipe_init(NULL
);
1089 return NT_STATUS_NO_MEMORY
;
1092 status
= dcerpc_pipe_open_unix_stream(p
->conn
, binding
->endpoint
);
1093 if (!NT_STATUS_IS_OK(status
)) {
1094 DEBUG(0,("Failed to open unix socket %s - %s\n",
1095 binding
->endpoint
, nt_errstr(status
)));
1100 status
= dcerpc_pipe_auth(p
, binding
, pipe_uuid
, pipe_version
, domain
, username
, password
);
1101 if (!NT_STATUS_IS_OK(status
)) {
1111 /* open a rpc connection to a rpc pipe on SMP using the binding
1112 structure to determine the endpoint and options */
1113 static NTSTATUS
dcerpc_pipe_connect_ncacn_ip_tcp(struct dcerpc_pipe
**pp
,
1114 struct dcerpc_binding
*binding
,
1115 const char *pipe_uuid
,
1116 uint32_t pipe_version
,
1118 const char *username
,
1119 const char *password
)
1123 struct dcerpc_pipe
*p
;
1124 TALLOC_CTX
*tmp_ctx
;
1128 p
= dcerpc_pipe_init(NULL
);
1130 return NT_STATUS_NO_MEMORY
;
1132 tmp_ctx
= talloc_new(p
);
1134 if (!binding
->endpoint
) {
1135 status
= dcerpc_epm_map_binding(tmp_ctx
, binding
,
1136 pipe_uuid
, pipe_version
);
1137 if (!NT_STATUS_IS_OK(status
)) {
1138 DEBUG(0,("Failed to map DCERPC/TCP port for '%s' - %s\n",
1139 pipe_uuid
, nt_errstr(status
)));
1143 DEBUG(1,("Mapped to DCERPC/TCP port %s\n", binding
->endpoint
));
1146 port
= atoi(binding
->endpoint
);
1148 status
= dcerpc_pipe_open_tcp(p
->conn
, binding
->host
, port
);
1149 if (!NT_STATUS_IS_OK(status
)) {
1150 DEBUG(0,("Failed to connect to %s:%d - %s\n",
1151 binding
->host
, port
, nt_errstr(status
)));
1156 status
= dcerpc_pipe_auth(p
, binding
, pipe_uuid
, pipe_version
, domain
, username
, password
);
1157 if (!NT_STATUS_IS_OK(status
)) {
1163 talloc_free(tmp_ctx
);
1169 /* open a rpc connection to a rpc pipe, using the specified
1170 binding structure to determine the endpoint and options */
1171 NTSTATUS
dcerpc_pipe_connect_b(struct dcerpc_pipe
**pp
,
1172 struct dcerpc_binding
*binding
,
1173 const char *pipe_uuid
,
1174 uint32_t pipe_version
,
1176 const char *username
,
1177 const char *password
)
1179 NTSTATUS status
= NT_STATUS_INVALID_PARAMETER
;
1181 switch (binding
->transport
) {
1183 status
= dcerpc_pipe_connect_ncacn_np(pp
, binding
, pipe_uuid
, pipe_version
,
1184 domain
, username
, password
);
1187 status
= dcerpc_pipe_connect_ncacn_ip_tcp(pp
, binding
, pipe_uuid
, pipe_version
,
1188 domain
, username
, password
);
1190 case NCACN_UNIX_STREAM
:
1191 status
= dcerpc_pipe_connect_ncacn_unix_stream(pp
, binding
, pipe_uuid
, pipe_version
,
1192 domain
, username
, password
);
1195 status
= dcerpc_pipe_connect_ncalrpc(pp
, binding
, pipe_uuid
, pipe_version
,
1196 domain
, username
, password
);
1199 return NT_STATUS_NOT_SUPPORTED
;
1206 /* open a rpc connection to a rpc pipe, using the specified string
1207 binding to determine the endpoint and options */
1208 NTSTATUS
dcerpc_pipe_connect(struct dcerpc_pipe
**pp
,
1209 const char *binding
,
1210 const char *pipe_uuid
,
1211 uint32_t pipe_version
,
1213 const char *username
,
1214 const char *password
)
1216 struct dcerpc_binding b
;
1218 TALLOC_CTX
*tmp_ctx
;
1220 tmp_ctx
= talloc_new(NULL
);
1222 status
= dcerpc_parse_binding(tmp_ctx
, binding
, &b
);
1223 if (!NT_STATUS_IS_OK(status
)) {
1224 DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding
));
1225 talloc_free(tmp_ctx
);
1229 DEBUG(3,("Using binding %s\n", dcerpc_binding_string(tmp_ctx
, &b
)));
1231 status
= dcerpc_pipe_connect_b(pp
, &b
, pipe_uuid
, pipe_version
, domain
, username
, password
);
1233 talloc_free(tmp_ctx
);
1240 create a secondary dcerpc connection from a primary connection
1242 if the primary is a SMB connection then the secondary connection
1243 will be on the same SMB connection, but use a new fnum
1245 NTSTATUS
dcerpc_secondary_connection(struct dcerpc_pipe
*p
, struct dcerpc_pipe
**p2
,
1246 const char *pipe_name
,
1247 const char *pipe_uuid
,
1248 uint32_t pipe_version
)
1250 struct smbcli_tree
*tree
;
1251 NTSTATUS status
= NT_STATUS_INVALID_PARAMETER
;
1252 struct dcerpc_binding b
;
1254 (*p2
) = dcerpc_pipe_init(p
);
1256 return NT_STATUS_NO_MEMORY
;
1259 switch (p
->conn
->transport
.transport
) {
1261 tree
= dcerpc_smb_tree(p
->conn
);
1263 return NT_STATUS_INVALID_PARAMETER
;
1265 status
= dcerpc_pipe_open_smb((*p2
)->conn
, tree
, pipe_name
);
1269 status
= dcerpc_parse_binding(p
, p
->conn
->binding_string
, &b
);
1270 if (!NT_STATUS_IS_OK(status
)) {
1273 status
= dcerpc_pipe_open_tcp((*p2
)->conn
, b
.host
, atoi(b
.endpoint
));
1277 status
= dcerpc_parse_binding(p
, p
->conn
->binding_string
, &b
);
1278 if (!NT_STATUS_IS_OK(status
)) {
1281 status
= dcerpc_pipe_open_pipe((*p2
)->conn
, b
.endpoint
);
1285 return NT_STATUS_NOT_SUPPORTED
;
1288 if (!NT_STATUS_IS_OK(status
)) {
1293 (*p2
)->conn
->flags
= p
->conn
->flags
;
1295 status
= dcerpc_bind_auth_none(*p2
, pipe_uuid
, pipe_version
);
1296 if (!NT_STATUS_IS_OK(status
)) {
1301 return NT_STATUS_OK
;
1304 NTSTATUS
dcerpc_generic_session_key(struct dcerpc_connection
*c
,
1305 DATA_BLOB
*session_key
)
1307 /* this took quite a few CPU cycles to find ... */
1308 session_key
->data
= discard_const_p(unsigned char, "SystemLibraryDTC");
1309 session_key
->length
= 16;
1310 return NT_STATUS_OK
;
1314 fetch the user session key - may be default (above) or the SMB session key
1316 NTSTATUS
dcerpc_fetch_session_key(struct dcerpc_pipe
*p
,
1317 DATA_BLOB
*session_key
)
1319 return p
->conn
->security_state
.session_key(p
->conn
, session_key
);
1324 log a rpc packet in a format suitable for ndrdump. This is especially useful
1325 for sealed packets, where ethereal cannot easily see the contents
1327 this triggers on a debug level of >= 10
1329 void dcerpc_log_packet(const struct dcerpc_interface_table
*ndr
,
1330 uint32_t opnum
, uint32_t flags
, DATA_BLOB
*pkt
)
1332 const int num_examples
= 20;
1335 if (DEBUGLEVEL
< 10) return;
1337 for (i
=0;i
<num_examples
;i
++) {
1339 asprintf(&name
, "%s/rpclog/%s-%u.%d.%s",
1340 lp_lockdir(), ndr
->name
, opnum
, i
,
1341 (flags
&NDR_IN
)?"in":"out");
1345 if (!file_exist(name
)) {
1346 if (file_save(name
, pkt
->data
, pkt
->length
)) {
1347 DEBUG(10,("Logged rpc packet to %s\n", name
));
1359 create a secondary context from a primary connection
1361 this uses dcerpc_alter_context() to create a new dcerpc context_id
1363 NTSTATUS
dcerpc_secondary_context(struct dcerpc_pipe
*p
,
1364 struct dcerpc_pipe
**pp2
,
1365 const char *pipe_uuid
,
1366 uint32_t pipe_version
)
1369 struct dcerpc_pipe
*p2
;
1371 p2
= talloc_zero(p
, struct dcerpc_pipe
);
1373 return NT_STATUS_NO_MEMORY
;
1375 p2
->conn
= talloc_reference(p2
, p
->conn
);
1377 p2
->context_id
= ++p
->conn
->next_context_id
;
1379 status
= GUID_from_string(pipe_uuid
, &p2
->syntax
.uuid
);
1380 if (!NT_STATUS_IS_OK(status
)) {
1384 p2
->syntax
.if_version
= pipe_version
;
1386 status
= GUID_from_string(NDR_GUID
, &p2
->transfer_syntax
.uuid
);
1387 if (!NT_STATUS_IS_OK(status
)) {
1391 p2
->transfer_syntax
.if_version
= NDR_GUID_VERSION
;
1393 status
= dcerpc_alter_context(p2
, p2
, &p2
->syntax
, &p2
->transfer_syntax
);
1394 if (!NT_STATUS_IS_OK(status
)) {