7341bc4b76afe64c66b7b12587b1579e4aafbe50
[samba.git] / source3 / librpc / rpc / dcerpc_ep.c
1 /*
2  *  Endpoint Mapper Functions
3  *  DCERPC local endpoint mapper client routines
4  *  Copyright (c) 2010      Andreas Schneider.
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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include "includes.h"
21 #include "librpc/rpc/dcerpc.h"
22 #include "librpc/rpc/dcerpc_ep.h"
23 #include "../librpc/gen_ndr/ndr_epmapper_c.h"
24 #include "rpc_client/cli_pipe.h"
25 #include "auth.h"
26 #include "rpc_server/rpc_ncacn_np.h"
27 #include "../lib/tsocket/tsocket.h"
28
29 #define EPM_MAX_ANNOTATION_SIZE 64
30
31 NTSTATUS dcerpc_binding_vector_create(TALLOC_CTX *mem_ctx,
32                                       const struct ndr_interface_table *iface,
33                                       uint16_t port,
34                                       const char *ncalrpc,
35                                       struct dcerpc_binding_vector **pbvec)
36 {
37         struct dcerpc_binding_vector *bvec;
38         uint32_t ep_count;
39         uint32_t count = 0;
40         uint32_t i;
41         NTSTATUS status;
42         TALLOC_CTX *tmp_ctx;
43
44         tmp_ctx = talloc_stackframe();
45         if (tmp_ctx == NULL) {
46                 return NT_STATUS_NO_MEMORY;
47         }
48
49         ep_count = iface->endpoints->count;
50
51         bvec = talloc_zero(tmp_ctx, struct dcerpc_binding_vector);
52         if (bvec == NULL) {
53                 status = NT_STATUS_NO_MEMORY;
54                 goto done;
55         }
56
57         bvec->bindings = talloc_zero_array(bvec, struct dcerpc_binding, ep_count);
58         if (bvec->bindings == NULL) {
59                 status = NT_STATUS_NO_MEMORY;
60                 goto done;
61         }
62
63         for (i = 0; i < ep_count; i++) {
64                 struct dcerpc_binding *b;
65
66                 b = talloc_zero(bvec->bindings, struct dcerpc_binding);
67                 if (b == NULL) {
68                         status = NT_STATUS_NO_MEMORY;
69                         goto done;
70                 }
71
72                 status = dcerpc_parse_binding(b, iface->endpoints->names[i], &b);
73                 if (!NT_STATUS_IS_OK(status)) {
74                         status = NT_STATUS_UNSUCCESSFUL;
75                         goto done;
76                 }
77
78                 b->object = iface->syntax_id;
79
80                 switch (b->transport) {
81                         case NCACN_NP:
82                                 b->host = talloc_asprintf(b, "\\\\%s", lp_netbios_name());
83                                 if (b->host == NULL) {
84                                         status = NT_STATUS_NO_MEMORY;
85                                         goto done;
86                                 }
87                                 break;
88                         case NCACN_IP_TCP:
89                                 if (port == 0) {
90                                         talloc_free(b);
91                                         continue;
92                                 }
93
94                                 b->endpoint = talloc_asprintf(b, "%u", port);
95                                 if (b->endpoint == NULL) {
96                                         status = NT_STATUS_NO_MEMORY;
97                                         goto done;
98                                 }
99
100                                 break;
101                         case NCALRPC:
102                                 if (ncalrpc == NULL) {
103                                         talloc_free(b);
104                                         continue;
105                                 }
106
107                                 b->endpoint = talloc_asprintf(b,
108                                                               "%s/%s",
109                                                               lp_ncalrpc_dir(),
110                                                               ncalrpc);
111                                 if (b->endpoint == NULL) {
112                                         status = NT_STATUS_NO_MEMORY;
113                                         goto done;
114                                 }
115                                 break;
116                         default:
117                                 talloc_free(b);
118                                 continue;
119                 }
120
121                 bvec->bindings[count] = *b;
122                 count++;
123         }
124
125         bvec->count = count;
126
127         *pbvec = talloc_move(mem_ctx, &bvec);
128
129         status = NT_STATUS_OK;
130 done:
131         talloc_free(tmp_ctx);
132
133         return status;
134 }
135
136 static NTSTATUS ep_register(TALLOC_CTX *mem_ctx,
137                             const struct ndr_interface_table *iface,
138                             const struct dcerpc_binding_vector *bind_vec,
139                             const struct GUID *object_guid,
140                             const char *annotation,
141                             uint32_t replace,
142                             uint32_t unregister,
143                             struct dcerpc_binding_handle **pbh)
144 {
145         struct rpc_pipe_client *cli = NULL;
146         struct dcerpc_binding_handle *h;
147         struct pipe_auth_data *auth;
148         const char *ncalrpc_sock;
149         const char *rpcsrv_type;
150         struct epm_entry_t *entries;
151         uint32_t num_ents, i;
152         TALLOC_CTX *tmp_ctx;
153         uint32_t result = EPMAPPER_STATUS_OK;
154         NTSTATUS status;
155
156         if (iface == NULL) {
157                 return NT_STATUS_INVALID_PARAMETER;
158         }
159
160         if (bind_vec == NULL || bind_vec->count == 0) {
161                 return NT_STATUS_INVALID_PARAMETER;
162         }
163
164         tmp_ctx = talloc_stackframe();
165         if (tmp_ctx == NULL) {
166                 return NT_STATUS_NO_MEMORY;
167         }
168
169         rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
170                                            "rpc_server", "epmapper",
171                                            "none");
172
173         if (strcasecmp_m(rpcsrv_type, "embedded") == 0) {
174                 struct tsocket_address *local;
175                 int rc;
176
177                 rc = tsocket_address_inet_from_strings(tmp_ctx,
178                                                        "ip",
179                                                        "127.0.0.1",
180                                                        0,
181                                                        &local);
182                 if (rc < 0) {
183                         return NT_STATUS_NO_MEMORY;
184                 }
185
186                 status = rpcint_binding_handle(tmp_ctx,
187                                                &ndr_table_epmapper,
188                                                local,
189                                                get_session_info_system(),
190                                                server_messaging_context(),
191                                                &h);
192                 if (!NT_STATUS_IS_OK(status)) {
193                         DEBUG(1, ("dcerpc_ep_register: Could not connect to "
194                                   "epmapper (%s)", nt_errstr(status)));
195                         goto done;
196                 }
197         } else if (strcasecmp_m(rpcsrv_type, "daemon") == 0) {
198                 /* Connect to the endpoint mapper locally */
199                 ncalrpc_sock = talloc_asprintf(tmp_ctx,
200                                               "%s/%s",
201                                               lp_ncalrpc_dir(),
202                                               "EPMAPPER");
203                 if (ncalrpc_sock == NULL) {
204                         status = NT_STATUS_NO_MEMORY;
205                         goto done;
206                 }
207
208                 status = rpc_pipe_open_ncalrpc(tmp_ctx,
209                                                ncalrpc_sock,
210                                                &ndr_table_epmapper.syntax_id,
211                                                &cli);
212                 if (!NT_STATUS_IS_OK(status)) {
213                         goto done;
214                 }
215
216                 status = rpccli_ncalrpc_bind_data(cli, &auth);
217                 if (!NT_STATUS_IS_OK(status)) {
218                         DEBUG(0, ("Failed to initialize anonymous bind.\n"));
219                         goto done;
220                 }
221
222                 status = rpc_pipe_bind(cli, auth);
223                 if (!NT_STATUS_IS_OK(status)) {
224                         DEBUG(2, ("Failed to bind ncalrpc socket.\n"));
225                         goto done;
226                 }
227
228                 h = cli->binding_handle;
229         } else {
230                 status = NT_STATUS_INVALID_PARAMETER;
231                 goto done;
232         }
233
234         num_ents = bind_vec->count;
235         entries = talloc_array(tmp_ctx, struct epm_entry_t, num_ents);
236
237         for (i = 0; i < num_ents; i++) {
238                 struct dcerpc_binding *map_binding = &bind_vec->bindings[i];
239                 struct epm_twr_t *map_tower;
240
241                 map_tower = talloc_zero(entries, struct epm_twr_t);
242                 if (map_tower == NULL) {
243                         status = NT_STATUS_NO_MEMORY;
244                         goto done;
245                 }
246
247                 status = dcerpc_binding_build_tower(entries,
248                                                     map_binding,
249                                                     &map_tower->tower);
250                 if (!NT_STATUS_IS_OK(status)) {
251                         goto done;
252                 }
253
254                 entries[i].tower = map_tower;
255                 if (annotation == NULL) {
256                         entries[i].annotation = talloc_strdup(entries, "");
257                 } else {
258                         entries[i].annotation = talloc_strndup(entries,
259                                                                annotation,
260                                                                EPM_MAX_ANNOTATION_SIZE);
261                 }
262                 if (entries[i].annotation == NULL) {
263                         status = NT_STATUS_NO_MEMORY;
264                         goto done;
265                 }
266
267                 if (object_guid != NULL) {
268                         entries[i].object = *object_guid;
269                 } else {
270                         entries[i].object = map_binding->object.uuid;
271                 }
272         }
273
274         if (unregister) {
275                 status = dcerpc_epm_Delete(h,
276                                            tmp_ctx,
277                                            num_ents,
278                                            entries,
279                                            &result);
280         } else {
281                 status = dcerpc_epm_Insert(h,
282                                            tmp_ctx,
283                                            num_ents,
284                                            entries,
285                                            replace,
286                                            &result);
287         }
288         if (!NT_STATUS_IS_OK(status)) {
289                 DEBUG(0, ("dcerpc_ep_register: Could not insert tower (%s)\n",
290                           nt_errstr(status)));
291                 goto done;
292         }
293         if (result != EPMAPPER_STATUS_OK) {
294                 DEBUG(0, ("dcerpc_ep_register: Could not insert tower (0x%.8x)\n",
295                           result));
296                 status = NT_STATUS_UNSUCCESSFUL;
297                 goto done;
298         }
299
300         if (pbh != NULL) {
301                 *pbh = talloc_move(mem_ctx, &h);
302                 talloc_steal(*pbh, cli);
303         }
304
305 done:
306         talloc_free(tmp_ctx);
307
308         return status;
309 }
310
311 NTSTATUS dcerpc_ep_register(TALLOC_CTX *mem_ctx,
312                             const struct ndr_interface_table *iface,
313                             const struct dcerpc_binding_vector *bind_vec,
314                             const struct GUID *object_guid,
315                             const char *annotation,
316                             struct dcerpc_binding_handle **ph)
317 {
318         return ep_register(mem_ctx,
319                            iface,
320                            bind_vec,
321                            object_guid,
322                            annotation,
323                            1,
324                            0,
325                            ph);
326 }
327
328 NTSTATUS dcerpc_ep_register_noreplace(TALLOC_CTX *mem_ctx,
329                                       const struct ndr_interface_table *iface,
330                                       const struct dcerpc_binding_vector *bind_vec,
331                                       const struct GUID *object_guid,
332                                       const char *annotation,
333                                       struct dcerpc_binding_handle **ph)
334 {
335         return ep_register(mem_ctx,
336                            iface,
337                            bind_vec,
338                            object_guid,
339                            annotation,
340                            0,
341                            0,
342                            ph);
343 }
344
345 NTSTATUS dcerpc_ep_unregister(const struct ndr_interface_table *iface,
346                               const struct dcerpc_binding_vector *bind_vec,
347                               const struct GUID *object_guid)
348 {
349         return ep_register(NULL,
350                            iface,
351                            bind_vec,
352                            object_guid,
353                            NULL,
354                            0,
355                            1,
356                            NULL);
357 }
358
359 /* vim: set ts=8 sw=8 noet cindent syntax=c.doxygen: */