996432181ae3899e6956d70e6aaede4e33b0feed
[samba.git] / source4 / lib / dcom / common / main.c
1 /*
2    Unix SMB/CIFS implementation.
3    Main DCOM functionality
4    Copyright (C) 2004 Jelmer Vernooij <jelmer@samba.org>
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22 #include "dlinklist.h"
23 #include "librpc/gen_ndr/ndr_epmapper.h"
24 #include "librpc/gen_ndr/ndr_remact.h"
25 #include "librpc/gen_ndr/ndr_oxidresolver.h"
26 #include "librpc/gen_ndr/ndr_dcom.h"
27
28 #define DCOM_NEGOTIATED_PROTOCOLS { EPM_PROTOCOL_TCP, EPM_PROTOCOL_SMB, EPM_PROTOCOL_NCALRPC }
29
30 static NTSTATUS dcerpc_binding_from_STRINGBINDING(TALLOC_CTX *mem_ctx, struct dcerpc_binding *b, struct STRINGBINDING *bd)
31 {
32         char *host, *endpoint;
33
34         ZERO_STRUCTP(b);
35         
36         b->transport = dcerpc_transport_by_endpoint_protocol(bd->wTowerId);
37
38         if (b->transport == -1) {
39                 DEBUG(1, ("Can't find transport match endpoint protocol %d\n", bd->wTowerId));
40                 return NT_STATUS_NOT_SUPPORTED;
41         }
42
43         host = talloc_strdup(mem_ctx, bd->NetworkAddr);
44         endpoint = strchr(host, '[');
45
46         if (endpoint) {
47                 *endpoint = '\0';
48                 endpoint++;
49
50                 endpoint[strlen(endpoint)-1] = '\0';
51         }
52
53         b->host = host;
54         b->endpoint = endpoint;
55
56         return NT_STATUS_OK;
57 }
58
59 static NTSTATUS dcom_connect_host(struct dcom_context *ctx, struct dcerpc_pipe **p, const char *server)
60 {
61         struct dcerpc_binding bd;
62         enum dcerpc_transport_t available_transports[] = { NCACN_IP_TCP, NCACN_NP };
63         int i;
64         NTSTATUS status;
65         TALLOC_CTX *mem_ctx = talloc_init("dcom_connect");
66
67         /* Allow server name to contain a binding string */
68         if (NT_STATUS_IS_OK(dcerpc_parse_binding(mem_ctx, server, &bd))) {
69                 status = dcerpc_pipe_connect_b(p, &bd, 
70                                         DCERPC_IREMOTEACTIVATION_UUID, 
71                                         DCERPC_IREMOTEACTIVATION_VERSION, 
72                                         ctx->domain, ctx->user, ctx->password);
73
74                 talloc_destroy(mem_ctx);
75                 return status;
76         }
77         talloc_destroy(mem_ctx);
78
79         ZERO_STRUCT(bd);
80         bd.host = server;
81         
82         if (server == NULL) { 
83                 bd.transport = NCALRPC; 
84                 return dcerpc_pipe_connect_b(p, &bd, 
85                                         DCERPC_IREMOTEACTIVATION_UUID, 
86                                         DCERPC_IREMOTEACTIVATION_VERSION, 
87                                         ctx->domain, ctx->user, ctx->password);
88         }
89
90         for (i = 0; i < ARRAY_SIZE(available_transports); i++)
91         {
92                 bd.transport = available_transports[i];
93                 
94                 status = dcerpc_pipe_connect_b(p, &bd, 
95                                                 DCERPC_IREMOTEACTIVATION_UUID, 
96                                                 DCERPC_IREMOTEACTIVATION_VERSION, 
97                                                 ctx->domain, ctx->user, ctx->password);
98
99                 if (NT_STATUS_IS_OK(status)) {
100                         return status;
101                 }
102         }
103         
104         return status;
105 }
106
107 WERROR dcom_init(struct dcom_context **ctx, const char *domain, const char *user, const char *pass)
108 {
109         *ctx = talloc_p(NULL, struct dcom_context);
110         (*ctx)->oxids = NULL;
111         (*ctx)->domain = talloc_strdup(*ctx, domain);
112         (*ctx)->user = talloc_strdup(*ctx, user);
113         (*ctx)->password = talloc_strdup(*ctx, pass);
114         
115         return WERR_OK;
116 }
117
118 WERROR dcom_ping(struct dcom_context *ctx)
119 {
120         /* FIXME: If OID's waiting in queue, do a ComplexPing call */
121         /* FIXME: otherwise, do a SimplePing call */
122         return WERR_OK;
123 }
124
125 WERROR dcom_create_object(struct dcom_context *ctx, struct GUID *clsid, const char *server, int num_ifaces, struct GUID *iid, struct dcom_interface **ip, WERROR *results)
126 {
127         struct dcom_oxid_mapping *m;
128         struct RemoteActivation r;
129         int i;
130         struct dcerpc_pipe *p;
131         NTSTATUS status;
132         uint16 protseq[] = DCOM_NEGOTIATED_PROTOCOLS;
133
134         status = dcom_connect_host(ctx, &p, server);
135         if (NT_STATUS_IS_ERR(status)) {
136                 DEBUG(1, ("Unable to connect to %s - %s\n", server, nt_errstr(status)));
137                 return ntstatus_to_werror(status);
138         }
139
140         ZERO_STRUCT(r.in);
141         r.in.this.version.MajorVersion = COM_MAJOR_VERSION;
142         r.in.this.version.MinorVersion = COM_MINOR_VERSION;
143         uuid_generate_random(&r.in.this.cid);
144         r.in.Clsid = *clsid;
145         r.in.ClientImpLevel = RPC_C_IMP_LEVEL_IDENTIFY;
146         r.in.num_protseqs = ARRAY_SIZE(protseq);
147         r.in.protseq = protseq;
148         r.in.Interfaces = num_ifaces;
149         r.in.pIIDs = iid;
150         r.out.ifaces = talloc_array_p(ctx, struct pMInterfacePointer, num_ifaces);
151         m = talloc_zero_p(ctx, struct dcom_oxid_mapping);
152         r.out.pdsaOxidBindings = &m->bindings;
153         
154         status = dcerpc_RemoteActivation(p, ctx, &r);
155         if(NT_STATUS_IS_ERR(status)) {
156                 DEBUG(1, ("Error while running RemoteActivation %s\n", nt_errstr(status)));
157                 return ntstatus_to_werror(status);
158         }
159
160         if(!W_ERROR_IS_OK(r.out.result)) {
161                 return r.out.result; 
162         }
163         
164         if(!W_ERROR_IS_OK(r.out.hr)) { 
165                 return r.out.hr; 
166         }
167
168         *ip = talloc_array_p(ctx, struct dcom_interface, num_ifaces);
169         for (i = 0; i < num_ifaces; i++) {
170                 results[i] = r.out.results[i];
171                 (*ip)[i].private_references = 1;
172                 (*ip)[i].objref = &r.out.ifaces[i].p->obj;
173                 (*ip)[i].pipe = NULL;
174                 (*ip)[i].ctx = ctx;
175         }
176
177         /* Add the OXID data for the returned oxid */
178         m->oxid = r.out.pOxid;
179         m->bindings = *r.out.pdsaOxidBindings;
180         DLIST_ADD(ctx->oxids, m);
181         
182         return WERR_OK;
183 }
184
185 WERROR dcom_get_class_object(struct dcom_context *ctx, struct GUID *clsid, const char *server, struct GUID *iid, struct dcom_interface *ip)
186 {
187         struct dcom_oxid_mapping *m;
188         struct RemoteActivation r;
189         struct dcerpc_pipe *p;
190         NTSTATUS status;
191         struct pMInterfacePointer pm;
192         uint16 protseq[] = DCOM_NEGOTIATED_PROTOCOLS;
193
194         status = dcom_connect_host(ctx, &p, server);
195         if (NT_STATUS_IS_ERR(status)) {
196                 DEBUG(1, ("Unable to connect to %s - %s\n", server, nt_errstr(status)));
197                 return ntstatus_to_werror(status);
198         }
199
200         ZERO_STRUCT(r.in);
201         r.in.this.version.MajorVersion = COM_MAJOR_VERSION;
202         r.in.this.version.MinorVersion = COM_MINOR_VERSION;
203         uuid_generate_random(&r.in.this.cid);
204         r.in.Clsid = *clsid;
205         r.in.ClientImpLevel = RPC_C_IMP_LEVEL_IDENTIFY;
206         r.in.num_protseqs = ARRAY_SIZE(protseq);
207         r.in.protseq = protseq;
208         r.in.Interfaces = 1;
209         r.in.pIIDs = iid;
210         r.in.Mode = MODE_GET_CLASS_OBJECT;
211         r.out.ifaces = &pm;
212         m = talloc_zero_p(ctx, struct dcom_oxid_mapping);
213         r.out.pdsaOxidBindings = &m->bindings;
214
215         status = dcerpc_RemoteActivation(p, ctx, &r);
216         if(NT_STATUS_IS_ERR(status)) {
217                 DEBUG(1, ("Error while running RemoteActivation - %s\n", nt_errstr(status)));
218                 return ntstatus_to_werror(status);
219         }
220
221         if(!W_ERROR_IS_OK(r.out.result)) { return r.out.result; }
222         if(!W_ERROR_IS_OK(r.out.hr)) { return r.out.hr; }
223         if(!W_ERROR_IS_OK(r.out.results[0])) { return r.out.results[0]; }
224         
225         /* Set up the interface data */
226         ip->private_references = 1;
227         ip->pipe = NULL;
228         ip->objref = &pm.p->obj;
229         ip->ctx = ctx;
230         
231         /* Add the OXID data for the returned oxid */
232         m->oxid = r.out.pOxid;
233         m->bindings = *r.out.pdsaOxidBindings;
234         DLIST_ADD(ctx->oxids, m);
235
236         return WERR_OK;
237 }
238
239 static struct dcom_oxid_mapping *oxid_mapping_by_oxid (struct dcom_context *ctx, HYPER_T oxid)
240 {
241         struct dcom_oxid_mapping *m;
242         
243         for (m = ctx->oxids;m;m = m->next) {
244                 if (m->oxid     == oxid) {
245                         return m;
246                 }
247         }
248
249         return NULL;
250 }
251
252 NTSTATUS dcom_get_pipe (struct dcom_interface *iface, struct dcerpc_pipe **p)
253 {
254         struct dcom_oxid_mapping *m;
255         struct dcerpc_binding binding;
256         struct GUID iid;
257         HYPER_T oxid;
258         NTSTATUS status;
259         int i;
260
261         *p = NULL;
262         
263         SMB_ASSERT(iface->objref->signature == OBJREF_SIGNATURE);
264
265         if (iface->objref->flags & OBJREF_HANDLER) {
266                 DEBUG(0, ("dcom_get_pipe: OBJREF_HANDLER not supported!\n"));
267                 return NT_STATUS_NOT_SUPPORTED;
268         }
269
270         if (iface->objref->flags & OBJREF_CUSTOM) {
271                 DEBUG(0, ("dcom_get_pipe: OBJREF_CUSTOM not supported!\n"));
272                 return NT_STATUS_NOT_SUPPORTED;
273         }
274
275         oxid = iface->objref->u_objref.u_standard.std.oxid;
276         iid = iface->objref->iid;
277
278         m = oxid_mapping_by_oxid(iface->ctx, oxid);
279
280         /* Add OXID mapping if none present yet */
281         if (!m) {
282                 struct dcerpc_pipe *po;
283                 struct ResolveOxid r;
284                 uint16 protseq[] = DCOM_NEGOTIATED_PROTOCOLS;
285
286                 DEBUG(3, ("No binding data present yet, resolving OXID %llu\n", oxid));
287
288                 m = talloc_zero_p(iface->ctx, struct dcom_oxid_mapping);
289                 m->oxid = oxid; 
290
291                 i = 0;
292                 do {
293                         status = dcerpc_binding_from_STRINGBINDING(iface->ctx, &binding, iface->objref->u_objref.u_standard.saResAddr.stringbindings[i]);
294
295                         if (NT_STATUS_IS_OK(status)) {
296                                 binding.flags = iface->ctx->dcerpc_flags;
297                                 status = dcerpc_pipe_connect_b(&po, &binding, DCERPC_IOXIDRESOLVER_UUID, DCERPC_IOXIDRESOLVER_VERSION, iface->ctx->domain, iface->ctx->user, iface->ctx->password);
298                         } else {
299                                 DEBUG(1, ("Error parsing string binding - %s", nt_errstr(status)));
300                         }
301
302                         i++;
303                 } while (!NT_STATUS_IS_OK(status) && iface->objref->u_objref.u_standard.saResAddr.stringbindings[i]);
304
305                 if (NT_STATUS_IS_ERR(status)) {
306                         DEBUG(1, ("Error while connecting to OXID Resolver : %s\n", nt_errstr(status)));
307                         return status;
308                 }
309
310                 r.in.pOxid = oxid;
311                 r.in.cRequestedProtseqs = ARRAY_SIZE(protseq);
312                 r.in.arRequestedProtseqs = protseq;
313                 r.out.ppdsaOxidBindings = &m->bindings;
314
315                 status = dcerpc_ResolveOxid(po, iface->ctx, &r);
316                 if (NT_STATUS_IS_ERR(status)) {
317                         DEBUG(1, ("Error while resolving OXID: %s\n", nt_errstr(status)));
318                         return status;
319                 }
320
321                 dcerpc_pipe_close(po);
322
323                 DLIST_ADD(iface->ctx->oxids, m);
324         }
325
326         if (m->pipe) {
327                 if (!uuid_equal(&m->pipe->syntax.uuid, &iid)) {
328                         m->pipe->syntax.uuid = iid;
329                         status = dcerpc_alter(m->pipe, iface->ctx);
330                         if (NT_STATUS_IS_ERR(status)) {
331                                 return status;
332                         }
333                 }
334                 *p = m->pipe;
335                 return NT_STATUS_OK;
336         }
337
338         i = 0;
339         do {
340                 status = dcerpc_binding_from_STRINGBINDING(iface->ctx, &binding, m->bindings.stringbindings[i]);
341                 if (NT_STATUS_IS_ERR(status)) {
342                         DEBUG(1, ("Error parsing string binding"));
343                 } else {
344                         binding.flags = iface->ctx->dcerpc_flags;
345                         status = dcerpc_pipe_connect_b(&m->pipe, &binding, GUID_string(iface->ctx, &iid) , 0.0, iface->ctx->domain, iface->ctx->user, iface->ctx->password);
346                 }
347
348                 i++;
349         } while (NT_STATUS_IS_ERR(status) && m->bindings.stringbindings[i]);
350
351         if (NT_STATUS_IS_ERR(status)) {
352                 DEBUG(0, ("Unable to connect to remote host - %s\n", nt_errstr(status)));
353                 return status;
354         }
355
356         DEBUG(2, ("Successfully connected to OXID %llx\n", oxid));
357         
358         *p = m->pipe;
359         return NT_STATUS_OK;
360 }