r3689: Large number of COM updates:
[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         (*ctx)->dcerpc_flags = 0;
115         
116         return WERR_OK;
117 }
118
119 static struct dcom_object_exporter *oxid_mapping_by_oxid (struct dcom_context *ctx, HYPER_T oxid)
120 {
121         struct dcom_object_exporter *m;
122         
123         for (m = ctx->oxids;m;m = m->next) {
124                 if (m->oxid     == oxid) {
125                         break;
126                 }
127         }
128
129         /* Add oxid mapping if we couldn't find one */
130         if (!m) {
131                 m = talloc_zero_p(ctx, struct dcom_object_exporter);
132                 m->oxid = oxid;
133                 DLIST_ADD(ctx->oxids, m);
134         }
135
136         return m;
137 }
138
139 WERROR dcom_ping(struct dcom_context *ctx)
140 {
141         /* FIXME: If OID's waiting in queue, do a ComplexPing call */
142         /* FIXME: otherwise, do a SimplePing call */
143         return WERR_OK;
144 }
145
146 WERROR dcom_create_object(struct dcom_context *ctx, struct GUID *clsid, const char *server, int num_ifaces, struct GUID *iid, struct dcom_interface_p ***ip, WERROR *results)
147 {
148         struct RemoteActivation r;
149         struct DUALSTRINGARRAY dualstring;
150         int i;
151         struct dcom_object_exporter *m;
152         struct dcerpc_pipe *p;
153         NTSTATUS status;
154         uint16 protseq[] = DCOM_NEGOTIATED_PROTOCOLS;
155
156         status = dcom_connect_host(ctx, &p, server);
157         if (NT_STATUS_IS_ERR(status)) {
158                 DEBUG(1, ("Unable to connect to %s - %s\n", server, nt_errstr(status)));
159                 return ntstatus_to_werror(status);
160         }
161
162         ZERO_STRUCT(r.in);
163         r.in.this.version.MajorVersion = COM_MAJOR_VERSION;
164         r.in.this.version.MinorVersion = COM_MINOR_VERSION;
165         uuid_generate_random(&r.in.this.cid);
166         r.in.Clsid = *clsid;
167         r.in.ClientImpLevel = RPC_C_IMP_LEVEL_IDENTIFY;
168         r.in.num_protseqs = ARRAY_SIZE(protseq);
169         r.in.protseq = protseq;
170         r.in.Interfaces = num_ifaces;
171         r.in.pIIDs = iid;
172         r.out.ifaces = talloc_array_p(ctx, struct pMInterfacePointer, num_ifaces);
173         r.out.pdsaOxidBindings = &dualstring;
174         
175         status = dcerpc_RemoteActivation(p, ctx, &r);
176         if(NT_STATUS_IS_ERR(status)) {
177                 DEBUG(1, ("Error while running RemoteActivation %s\n", nt_errstr(status)));
178                 return ntstatus_to_werror(status);
179         }
180
181         if(!W_ERROR_IS_OK(r.out.result)) {
182                 return r.out.result; 
183         }
184         
185         if(!W_ERROR_IS_OK(r.out.hr)) { 
186                 return r.out.hr; 
187         }
188
189         *ip = talloc_array_p(ctx, struct dcom_interface_p *, num_ifaces);
190         for (i = 0; i < num_ifaces; i++) {
191                 results[i] = r.out.results[i];
192                 (*ip)[i] = NULL;
193                 if (W_ERROR_IS_OK(results[i])) {
194                         status = dcom_ifacep_from_OBJREF(ctx, &(*ip)[i], &r.out.ifaces[i].p->obj);
195                         if (NT_STATUS_IS_OK(status)) {
196                                 (*ip)[i]->private_references = 1;
197                         } else {
198                                 results[i] = ntstatus_to_werror(status);
199                         }
200                 }
201         }
202
203         /* Add the OXID data for the returned oxid */
204         m = oxid_mapping_by_oxid(ctx, r.out.pOxid);
205         m->bindings = *r.out.pdsaOxidBindings;
206         
207         return WERR_OK;
208 }
209
210 WERROR dcom_get_class_object(struct dcom_context *ctx, struct GUID *clsid, const char *server, struct GUID *iid, struct dcom_interface_p **ip)
211 {
212         struct dcom_object_exporter *m;
213         struct RemoteActivation r;
214         struct dcerpc_pipe *p;
215         struct DUALSTRINGARRAY dualstring;
216         NTSTATUS status;
217         struct pMInterfacePointer pm;
218         uint16 protseq[] = DCOM_NEGOTIATED_PROTOCOLS;
219
220         status = dcom_connect_host(ctx, &p, server);
221         if (NT_STATUS_IS_ERR(status)) {
222                 DEBUG(1, ("Unable to connect to %s - %s\n", server, nt_errstr(status)));
223                 return ntstatus_to_werror(status);
224         }
225
226         ZERO_STRUCT(r.in);
227         r.in.this.version.MajorVersion = COM_MAJOR_VERSION;
228         r.in.this.version.MinorVersion = COM_MINOR_VERSION;
229         uuid_generate_random(&r.in.this.cid);
230         r.in.Clsid = *clsid;
231         r.in.ClientImpLevel = RPC_C_IMP_LEVEL_IDENTIFY;
232         r.in.num_protseqs = ARRAY_SIZE(protseq);
233         r.in.protseq = protseq;
234         r.in.Interfaces = 1;
235         r.in.pIIDs = iid;
236         r.in.Mode = MODE_GET_CLASS_OBJECT;
237         r.out.ifaces = &pm;
238         r.out.pdsaOxidBindings = &dualstring;
239
240         status = dcerpc_RemoteActivation(p, ctx, &r);
241         if(NT_STATUS_IS_ERR(status)) {
242                 DEBUG(1, ("Error while running RemoteActivation - %s\n", nt_errstr(status)));
243                 return ntstatus_to_werror(status);
244         }
245
246         if(!W_ERROR_IS_OK(r.out.result)) { return r.out.result; }
247         if(!W_ERROR_IS_OK(r.out.hr)) { return r.out.hr; }
248         if(!W_ERROR_IS_OK(r.out.results[0])) { return r.out.results[0]; }
249         
250         /* Set up the interface data */
251         dcom_ifacep_from_OBJREF(ctx, ip, &pm.p->obj);
252         (*ip)->private_references = 1;
253         
254         /* Add the OXID data for the returned oxid */
255         m = oxid_mapping_by_oxid(ctx, r.out.pOxid);
256         m->bindings = *r.out.pdsaOxidBindings;
257
258         return WERR_OK;
259 }
260
261 NTSTATUS dcom_get_pipe (struct dcom_interface_p *iface, struct dcerpc_pipe **p)
262 {
263         struct dcerpc_binding binding;
264         struct GUID iid;
265         HYPER_T oxid;
266         NTSTATUS status;
267         int i;
268
269         *p = NULL;
270         
271         oxid = iface->ox->oxid;
272         iid = iface->interface->iid;
273
274         if (iface->ox->pipe) {
275                 if (!uuid_equal(&iface->ox->pipe->syntax.uuid, &iid)) {
276                         iface->ox->pipe->syntax.uuid = iid;
277                         status = dcerpc_alter(iface->ox->pipe, iface->ctx);
278                         if (NT_STATUS_IS_ERR(status)) {
279                                 return status;
280                         }
281                 }
282                 *p = iface->ox->pipe;
283                 return NT_STATUS_OK;
284         }
285
286         i = 0;
287         do {
288                 status = dcerpc_binding_from_STRINGBINDING(iface->ctx, &binding, iface->ox->bindings.stringbindings[i]);
289                 if (NT_STATUS_IS_ERR(status)) {
290                         DEBUG(1, ("Error parsing string binding"));
291                 } else {
292                         binding.flags = iface->ctx->dcerpc_flags;
293                         status = dcerpc_pipe_connect_b(&iface->ox->pipe, &binding, GUID_string(iface->ctx, &iid) , 0.0, iface->ctx->domain, iface->ctx->user, iface->ctx->password);
294                 }
295
296                 i++;
297         } while (NT_STATUS_IS_ERR(status) && iface->ox->bindings.stringbindings[i]);
298
299         if (NT_STATUS_IS_ERR(status)) {
300                 DEBUG(0, ("Unable to connect to remote host - %s\n", nt_errstr(status)));
301                 return status;
302         }
303
304         DEBUG(2, ("Successfully connected to OXID %llx\n", oxid));
305         
306         *p = iface->ox->pipe;
307         return NT_STATUS_OK;
308 }
309
310 struct dcom_object *dcom_object_by_oid(struct dcom_object_exporter *ox, HYPER_T oid)
311 {
312         struct dcom_object *o;
313
314         for (o = ox->objects; o; o = o->next) {
315                 if (o->oid == oid) {
316                         break;
317                 }
318         }
319
320         if (o == NULL) {
321                 o = talloc_zero_p(ox, struct dcom_object);
322                 o->oid = oid;
323                 DLIST_ADD(ox->objects, o);
324         }
325         
326         return o;
327 }
328
329 NTSTATUS dcom_ifacep_from_OBJREF(struct dcom_context *ctx, struct dcom_interface_p **_p, struct OBJREF *o)
330 {
331         struct dcom_interface_p *p = talloc_p(ctx, struct dcom_interface_p);
332
333         p->ctx = ctx;   
334         p->interface = dcom_interface_by_iid(&o->iid);
335         if (!p->interface) {
336                 DEBUG(0, ("Unable to find interface with IID %s\n", GUID_string(ctx, &o->iid)));
337                 return NT_STATUS_NOT_SUPPORTED;
338         }
339
340         p->private_references = 0;
341         p->objref_flags = o->flags;
342         
343         switch(p->objref_flags) {
344         case OBJREF_NULL: 
345                 p->object = NULL; 
346                 p->ox = NULL;
347                 p->vtable = dcom_proxy_vtable_by_iid(&p->interface->iid);
348                 ZERO_STRUCT(p->ipid);
349                 *_p = p;
350                 return NT_STATUS_OK;
351                 
352         case OBJREF_STANDARD:
353                 p->ox = oxid_mapping_by_oxid(ctx, o->u_objref.u_standard.std.oxid);
354                 p->ipid = o->u_objref.u_standard.std.ipid;
355                 p->object = dcom_object_by_oid(p->ox, o->u_objref.u_standard.std.oid);
356                 p->ox->resolver_address = o->u_objref.u_standard.saResAddr;
357                 p->vtable = dcom_proxy_vtable_by_iid(&p->interface->iid);
358                 *_p = p;
359                 return NT_STATUS_OK;
360                 
361         case OBJREF_HANDLER:
362                 p->ox = oxid_mapping_by_oxid(ctx, o->u_objref.u_handler.std.oxid );
363                 p->ipid = o->u_objref.u_handler.std.ipid;
364                 p->object = dcom_object_by_oid(p->ox, o->u_objref.u_standard.std.oid);
365                 p->ox->resolver_address = o->u_objref.u_handler.saResAddr;
366                 p->vtable = dcom_vtable_by_clsid(&o->u_objref.u_handler.clsid);
367                 /* FIXME: Do the custom unmarshaling call */
368         
369                 *_p = p;
370                 return NT_STATUS_OK;
371                 
372         case OBJREF_CUSTOM:
373                 {
374                         const struct dcom_interface *imarshal = dcom_vtable_by_clsid(&o->u_objref.u_custom.clsid);
375                         p->vtable = NULL;
376                 
377                 /* FIXME: Do the actual custom unmarshaling call */
378                 p->ox = NULL;
379                 p->object = NULL;
380                 ZERO_STRUCT(p->ipid);
381                 *_p = p;
382                 return NT_STATUS_NOT_SUPPORTED;
383                 }
384         }
385
386         return NT_STATUS_NOT_SUPPORTED;
387
388         
389 #if 0
390         struct dcom_oxid_mapping *m;
391         /* Add OXID mapping if none present yet */
392         if (!m) {
393                 struct dcerpc_pipe *po;
394                 struct ResolveOxid r;
395                 uint16 protseq[] = DCOM_NEGOTIATED_PROTOCOLS;
396
397                 DEBUG(3, ("No binding data present yet, resolving OXID %llu\n", p->ox->oxid));
398
399                 m = talloc_zero_p(p->ctx, struct dcom_oxid_mapping);
400                 m->oxid = oxid; 
401
402                 i = 0;
403                 do {
404                         status = dcerpc_binding_from_STRINGBINDING(p->ctx, &binding, p->client.objref->u_objref.u_standard.saResAddr.stringbindings[i]);
405
406                         if (NT_STATUS_IS_OK(status)) {
407                                 binding.flags = iface->ctx->dcerpc_flags;
408                                 status = dcerpc_pipe_connect_b(&po, &binding, DCERPC_IOXIDRESOLVER_UUID, DCERPC_IOXIDRESOLVER_VERSION, iface->ctx->domain, iface->ctx->user, iface->ctx->password);
409                         } else {
410                                 DEBUG(1, ("Error parsing string binding - %s", nt_errstr(status)));
411                         }
412
413                         i++;
414                 } while (!NT_STATUS_IS_OK(status) && iface->client.objref->u_objref.u_standard.saResAddr.stringbindings[i]);
415
416                 if (NT_STATUS_IS_ERR(status)) {
417                         DEBUG(1, ("Error while connecting to OXID Resolver : %s\n", nt_errstr(status)));
418                         return status;
419                 }
420
421                 r.in.pOxid = oxid;
422                 r.in.cRequestedProtseqs = ARRAY_SIZE(protseq);
423                 r.in.arRequestedProtseqs = protseq;
424                 r.out.ppdsaOxidBindings = &m->bindings;
425
426                 status = dcerpc_ResolveOxid(po, iface->ctx, &r);
427                 if (NT_STATUS_IS_ERR(status)) {
428                         DEBUG(1, ("Error while resolving OXID: %s\n", nt_errstr(status)));
429                         return status;
430                 }
431
432                 dcerpc_pipe_close(po);
433
434                 DLIST_ADD(iface->ctx->oxids, m);
435         }
436 #endif
437
438         return NT_STATUS_NOT_SUPPORTED; 
439 }