*/
#include "includes.h"
+#include "librpc/gen_ndr/ndr_epmapper.h"
+#include "librpc/gen_ndr/ndr_oxidresolver.h"
+#include "auth/auth.h"
+#include "dlinklist.h"
+#include "rpc_server/dcerpc_server.h"
/*
see if two endpoints match
* we try to set it
*/
if (ep->sd == NULL) {
- ep->sd = copy_security_descriptor(dce_ctx, sd);
+ ep->sd = security_descriptor_copy(dce_ctx, sd);
}
/* if now there's no security descriptor given on the endpoint
DATA_BLOB *session_key)
{
/* this took quite a few CPU cycles to find ... */
- session_key->data = discard_const_p(char, "SystemLibraryDTC");
+ session_key->data = discard_const_p(uint8_t, "SystemLibraryDTC");
session_key->length = 16;
return NT_STATUS_OK;
}
return NT_STATUS_OK;
}
+/*
+ handle a bind request
+*/
+static NTSTATUS dcesrv_alter(struct dcesrv_call_state *call)
+{
+ struct dcerpc_packet pkt;
+ struct dcesrv_call_reply *rep;
+ NTSTATUS status;
+ uint32_t result=0, reason=0;
+
+ /* handle any authentication that is being requested */
+ if (!dcesrv_auth_alter(call)) {
+ /* TODO: work out the right reject code */
+ return dcesrv_bind_nak(call, 0);
+ }
+
+ /* setup a alter_ack */
+ dcesrv_init_hdr(&pkt);
+ pkt.auth_length = 0;
+ pkt.call_id = call->pkt.call_id;
+ pkt.ptype = DCERPC_PKT_ALTER_ACK;
+ pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
+ pkt.u.alter_ack.max_xmit_frag = 0x2000;
+ pkt.u.alter_ack.max_recv_frag = 0x2000;
+ pkt.u.alter_ack.assoc_group_id = call->pkt.u.bind.assoc_group_id;
+ pkt.u.alter_ack.secondary_address = NULL;
+ pkt.u.alter_ack.num_results = 1;
+ pkt.u.alter_ack.ctx_list = talloc_p(call, struct dcerpc_ack_ctx);
+ if (!pkt.u.alter_ack.ctx_list) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ pkt.u.alter_ack.ctx_list[0].result = result;
+ pkt.u.alter_ack.ctx_list[0].reason = reason;
+ GUID_from_string(NDR_GUID, &pkt.u.alter_ack.ctx_list[0].syntax.uuid);
+ pkt.u.alter_ack.ctx_list[0].syntax.if_version = NDR_GUID_VERSION;
+ pkt.u.alter_ack.auth_info = data_blob(NULL, 0);
+
+ if (!dcesrv_auth_alter_ack(call, &pkt)) {
+ return dcesrv_bind_nak(call, 0);
+ }
+
+ rep = talloc_p(call, struct dcesrv_call_reply);
+ if (!rep) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ status = dcerpc_push_auth(&rep->data, call, &pkt,
+ call->conn->auth_state.auth_info);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ dcerpc_set_frag_length(&rep->data, rep->data.length);
+
+ DLIST_ADD_END(call->replies, rep, struct dcesrv_call_reply *);
+ DLIST_ADD_END(call->conn->call_list, call, struct dcesrv_call_state *);
+
+ return NT_STATUS_OK;
+}
/*
handle a dcerpc request packet
return NT_STATUS_NO_MEMORY;
}
+ if (call->pkt.pfc_flags & DCERPC_PFC_FLAG_ORPC) {
+ pull->flags |= LIBNDR_FLAG_OBJECT_PRESENT;
+ }
+
r = talloc(call, call->conn->iface->ndr->calls[opnum].struct_size);
if (!r) {
return NT_STATUS_NO_MEMORY;
dce_partial_advance(dce_conn, blob.length);
/* see if this is a continued packet */
- if (!(call->pkt.pfc_flags & DCERPC_PFC_FLAG_FIRST)) {
+ if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
+ !(call->pkt.pfc_flags & DCERPC_PFC_FLAG_FIRST)) {
struct dcesrv_call_state *call2 = call;
uint32_t alloc_size;
/* this may not be the last pdu in the chain - if its isn't then
just put it on the call_list and wait for the rest */
- if (!(call->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST)) {
+ if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
+ !(call->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST)) {
DLIST_ADD_END(dce_conn->call_list, call, struct dcesrv_call_state *);
return NT_STATUS_OK;
}
case DCERPC_PKT_AUTH3:
status = dcesrv_auth3(call);
break;
+ case DCERPC_PKT_ALTER:
+ status = dcesrv_alter(call);
+ break;
case DCERPC_PKT_REQUEST:
status = dcesrv_request(call);
break;
if (rep->data.length == 0) {
/* we're done with this section of the call */
DLIST_REMOVE(call->replies, rep);
+ } else {
+ return STATUS_BUFFER_OVERFLOW;
}
if (call->replies == NULL) {
dcesrv_sock_accept(srv_conn);
}
-static void dcesrv_recv(struct server_connection *srv_conn, time_t t, uint16_t flags)
+static void dcesrv_recv(struct server_connection *srv_conn,
+ struct timeval t, uint16_t flags)
{
dcesrv_sock_recv(srv_conn, t, flags);
}
-static void dcesrv_send(struct server_connection *srv_conn, time_t t, uint16_t flags)
+static void dcesrv_send(struct server_connection *srv_conn,
+ struct timeval t, uint16_t flags)
{
dcesrv_sock_send(srv_conn, t, flags);
}
-static void dcesrv_idle(struct server_connection *srv_conn, time_t t)
-{
- dcesrv_sock_idle(srv_conn, t);
-}
-
static void dcesrv_close(struct server_connection *srv_conn, const char *reason)
{
dcesrv_sock_close(srv_conn, reason);
/* the list of currently registered DCERPC endpoint servers.
*/
-static struct {
+static struct ep_server {
struct dcesrv_endpoint_server *ep_server;
} *ep_servers = NULL;
static int num_ep_servers;
The 'type' is used to specify whether this is for a disk, printer or IPC$ share
*/
-static NTSTATUS dcerpc_register_ep_server(const void *_ep_server)
+NTSTATUS dcerpc_register_ep_server(const void *_ep_server)
{
const struct dcesrv_endpoint_server *ep_server = _ep_server;
return NT_STATUS_OBJECT_NAME_COLLISION;
}
- ep_servers = Realloc(ep_servers, sizeof(ep_servers[0]) * (num_ep_servers+1));
+ ep_servers = realloc_p(ep_servers, struct ep_server, num_ep_servers+1);
if (!ep_servers) {
smb_panic("out of memory in dcerpc_register");
}
return &critical_sizes;
}
-/*
- initialise the DCERPC subsystem
-*/
-BOOL subsystem_dcerpc_init(void)
-{
- NTSTATUS status;
-
- status = register_subsystem("dcerpc", dcerpc_register_ep_server);
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
-
- /* FIXME: Perhaps panic if a basic endpoint server, such as EPMAPPER, fails to initialise? */
- static_init_dcerpc;
-
- DEBUG(3,("DCERPC subsystem version %d initialised\n", DCERPC_MODULE_VERSION));
- return True;
-}
-
static const struct server_service_ops dcesrv_ops = {
.name = "rpc",
.service_init = dcesrv_init,
.accept_connection = dcesrv_accept,
.recv_handler = dcesrv_recv,
.send_handler = dcesrv_send,
- .idle_handler = dcesrv_idle,
+ .idle_handler = NULL,
.close_connection = dcesrv_close,
.service_exit = dcesrv_exit,
};