r25026: Move param/param.h out of includes.h
[gd/samba-autobuild/.git] / source4 / rpc_server / remote / dcesrv_remote.c
1 /* 
2    Unix SMB/CIFS implementation.
3    remote dcerpc operations
4
5    Copyright (C) Stefan (metze) Metzmacher 2004
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "rpc_server/dcerpc_server.h"
23 #include "auth/auth.h"
24 #include "auth/credentials/credentials.h"
25 #include "librpc/ndr/ndr_table.h"
26 #include "param/param.h"
27
28
29 struct dcesrv_remote_private {
30         struct dcerpc_pipe *c_pipe;
31 };
32
33 static NTSTATUS remote_op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
34 {
35         return NT_STATUS_OK;
36 }
37
38 static NTSTATUS remote_op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
39 {
40         NTSTATUS status;
41         const struct ndr_interface_table *table;
42         struct dcesrv_remote_private *private;
43         const char *binding = lp_parm_string(-1, "dcerpc_remote", "binding");
44         const char *user, *pass, *domain;
45         struct cli_credentials *credentials;
46         BOOL machine_account;
47
48         machine_account = lp_parm_bool(-1, "dcerpc_remote", "use_machine_account", False);
49
50         private = talloc(dce_call->conn, struct dcesrv_remote_private);
51         if (!private) {
52                 return NT_STATUS_NO_MEMORY;     
53         }
54         
55         private->c_pipe = NULL;
56         dce_call->context->private = private;
57
58         if (!binding) {
59                 DEBUG(0,("You must specify a DCE/RPC binding string\n"));
60                 return NT_STATUS_INVALID_PARAMETER;
61         }
62
63         user = lp_parm_string(-1, "dcerpc_remote", "user");
64         pass = lp_parm_string(-1, "dcerpc_remote", "password");
65         domain = lp_parm_string(-1, "dceprc_remote", "domain");
66
67         table = ndr_table_by_uuid(&iface->syntax_id.uuid); /* FIXME: What about if_version ? */
68         if (!table) {
69                 dce_call->fault_code = DCERPC_FAULT_UNK_IF;
70                 return NT_STATUS_NET_WRITE_FAULT;
71         }
72
73         if (user && pass) {
74                 DEBUG(5, ("dcerpc_remote: RPC Proxy: Using specified account\n"));
75                 credentials = cli_credentials_init(private);
76                 if (!credentials) {
77                         return NT_STATUS_NO_MEMORY;
78                 }
79                 cli_credentials_set_conf(credentials);
80                 cli_credentials_set_username(credentials, user, CRED_SPECIFIED);
81                 if (domain) {
82                         cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
83                 }
84                 cli_credentials_set_password(credentials, pass, CRED_SPECIFIED);
85         } else if (machine_account) {
86                 DEBUG(5, ("dcerpc_remote: RPC Proxy: Using machine account\n"));
87                 credentials = cli_credentials_init(private);
88                 cli_credentials_set_conf(credentials);
89                 if (domain) {
90                         cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
91                 }
92                 status = cli_credentials_set_machine_account(credentials);
93                 if (!NT_STATUS_IS_OK(status)) {
94                         return status;
95                 }
96         } else if (dce_call->conn->auth_state.session_info->credentials) {
97                 DEBUG(5, ("dcerpc_remote: RPC Proxy: Using delegated credentials\n"));
98                 credentials = dce_call->conn->auth_state.session_info->credentials;
99         } else {
100                 DEBUG(1,("dcerpc_remote: RPC Proxy: You must supply binding, user and password or have delegated credentials\n"));
101                 return NT_STATUS_INVALID_PARAMETER;
102         }
103
104         status = dcerpc_pipe_connect(private, 
105                                      &(private->c_pipe), binding, table,
106                                      credentials, dce_call->event_ctx);
107
108         talloc_free(credentials);
109         if (!NT_STATUS_IS_OK(status)) {
110                 return status;
111         }
112
113         return NT_STATUS_OK;    
114 }
115
116 static void remote_op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
117 {
118         struct dcesrv_remote_private *private = (struct dcesrv_remote_private *)context->private;
119
120         talloc_free(private->c_pipe);
121
122         return; 
123 }
124
125 static NTSTATUS remote_op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
126 {
127         NTSTATUS status;
128         const struct ndr_interface_table *table = (const struct ndr_interface_table *)dce_call->context->iface->private;
129         uint16_t opnum = dce_call->pkt.u.request.opnum;
130
131         dce_call->fault_code = 0;
132
133         if (opnum >= table->num_calls) {
134                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
135                 return NT_STATUS_NET_WRITE_FAULT;
136         }
137
138         *r = talloc_size(mem_ctx, table->calls[opnum].struct_size);
139         if (!*r) {
140                 return NT_STATUS_NO_MEMORY;
141         }
142
143         /* unravel the NDR for the packet */
144         status = table->calls[opnum].ndr_pull(pull, NDR_IN, *r);
145         if (!NT_STATUS_IS_OK(status)) {
146                 dcerpc_log_packet(table, opnum, NDR_IN,
147                                   &dce_call->pkt.u.request.stub_and_verifier);
148                 dce_call->fault_code = DCERPC_FAULT_NDR;
149                 return NT_STATUS_NET_WRITE_FAULT;
150         }
151
152         return NT_STATUS_OK;
153 }
154
155 static NTSTATUS remote_op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
156 {
157         struct dcesrv_remote_private *private = dce_call->context->private;
158         uint16_t opnum = dce_call->pkt.u.request.opnum;
159         const struct ndr_interface_table *table = dce_call->context->iface->private;
160         const struct ndr_interface_call *call;
161         const char *name;
162
163         name = table->calls[opnum].name;
164         call = &table->calls[opnum];
165
166         if (private->c_pipe->conn->flags & DCERPC_DEBUG_PRINT_IN) {
167                 ndr_print_function_debug(call->ndr_print, name, NDR_IN | NDR_SET_VALUES, r);            
168         }
169
170         private->c_pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;
171
172         /* we didn't use the return code of this function as we only check the last_fault_code */
173         dcerpc_ndr_request(private->c_pipe, NULL, table, opnum, mem_ctx,r);
174
175         dce_call->fault_code = private->c_pipe->last_fault_code;
176         if (dce_call->fault_code != 0) {
177                 DEBUG(0,("dcesrv_remote: call[%s] failed with: %s!\n",name, dcerpc_errstr(mem_ctx, dce_call->fault_code)));
178                 return NT_STATUS_NET_WRITE_FAULT;
179         }
180
181         if ((dce_call->fault_code == 0) && 
182             (private->c_pipe->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
183                 ndr_print_function_debug(call->ndr_print, name, NDR_OUT, r);            
184         }
185
186         return NT_STATUS_OK;
187 }
188
189 static NTSTATUS remote_op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
190 {
191         NTSTATUS status;
192         const struct ndr_interface_table *table = dce_call->context->iface->private;
193         uint16_t opnum = dce_call->pkt.u.request.opnum;
194
195         /* unravel the NDR for the packet */
196         status = table->calls[opnum].ndr_push(push, NDR_OUT, r);
197         if (!NT_STATUS_IS_OK(status)) {
198                 dce_call->fault_code = DCERPC_FAULT_NDR;
199                 return NT_STATUS_NET_WRITE_FAULT;
200         }
201
202         return NT_STATUS_OK;
203 }
204
205 static NTSTATUS remote_register_one_iface(struct dcesrv_context *dce_ctx, const struct dcesrv_interface *iface)
206 {
207         int i;
208         const struct ndr_interface_table *table = iface->private;
209
210         for (i=0;i<table->endpoints->count;i++) {
211                 NTSTATUS ret;
212                 const char *name = table->endpoints->names[i];
213
214                 ret = dcesrv_interface_register(dce_ctx, name, iface, NULL);
215                 if (!NT_STATUS_IS_OK(ret)) {
216                         DEBUG(1,("remote_op_init_server: failed to register endpoint '%s'\n",name));
217                         return ret;
218                 }
219         }
220
221         return NT_STATUS_OK;
222 }
223
224 static NTSTATUS remote_op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
225 {
226         int i;
227         const char **ifaces = str_list_make(dce_ctx, lp_parm_string(-1,"dcerpc_remote","interfaces"),NULL);
228
229         if (!ifaces) {
230                 DEBUG(3,("remote_op_init_server: no interfaces configured\n"));
231                 return NT_STATUS_OK;
232         }
233
234         for (i=0;ifaces[i];i++) {
235                 NTSTATUS ret;
236                 struct dcesrv_interface iface;
237                 
238                 if (!ep_server->interface_by_name(&iface, ifaces[i])) {
239                         DEBUG(0,("remote_op_init_server: failed to find interface = '%s'\n", ifaces[i]));
240                         talloc_free(ifaces);
241                         return NT_STATUS_UNSUCCESSFUL;
242                 }
243
244                 ret = remote_register_one_iface(dce_ctx, &iface);
245                 if (!NT_STATUS_IS_OK(ret)) {
246                         DEBUG(0,("remote_op_init_server: failed to register interface = '%s'\n", ifaces[i]));
247                         talloc_free(ifaces);
248                         return ret;
249                 }
250         }
251
252         talloc_free(ifaces);
253         return NT_STATUS_OK;
254 }
255
256 static BOOL remote_fill_interface(struct dcesrv_interface *iface, const struct ndr_interface_table *if_tabl)
257 {
258         iface->name = if_tabl->name;
259         iface->syntax_id = if_tabl->syntax_id;
260         
261         iface->bind = remote_op_bind;
262         iface->unbind = remote_op_unbind;
263
264         iface->ndr_pull = remote_op_ndr_pull;
265         iface->dispatch = remote_op_dispatch;
266         iface->reply = remote_op_reply;
267         iface->ndr_push = remote_op_ndr_push;
268
269         iface->private = if_tabl;
270
271         return True;
272 }
273
274 static BOOL remote_op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
275 {
276         const struct ndr_interface_list *l;
277
278         for (l=ndr_table_list();l;l=l->next) {
279                 if (l->table->syntax_id.if_version == if_version &&
280                         GUID_equal(&l->table->syntax_id.uuid, uuid)==0) {
281                         return remote_fill_interface(iface, l->table);
282                 }
283         }
284
285         return False;   
286 }
287
288 static BOOL remote_op_interface_by_name(struct dcesrv_interface *iface, const char *name)
289 {
290         const struct ndr_interface_table *tbl = ndr_table_by_name(name);
291
292         if (tbl)
293                 return remote_fill_interface(iface, tbl);
294
295         return False;   
296 }
297
298 NTSTATUS dcerpc_server_remote_init(void)
299 {
300         NTSTATUS ret;
301         struct dcesrv_endpoint_server ep_server;
302
303         ZERO_STRUCT(ep_server);
304
305         /* fill in our name */
306         ep_server.name = "remote";
307
308         /* fill in all the operations */
309         ep_server.init_server = remote_op_init_server;
310
311         ep_server.interface_by_uuid = remote_op_interface_by_uuid;
312         ep_server.interface_by_name = remote_op_interface_by_name;
313
314         /* register ourselves with the DCERPC subsystem. */
315         ret = dcerpc_register_ep_server(&ep_server);
316         if (!NT_STATUS_IS_OK(ret)) {
317                 DEBUG(0,("Failed to register 'remote' endpoint server!\n"));
318                 return ret;
319         }
320
321         /* We need the full DCE/RPC interface table */
322         ndr_table_init();
323
324         return ret;
325 }