6b934d7d1b42e5ed01fff3e39874629ca951a5e0
[samba.git] / source4 / rpc_server / epmapper / rpc_epmapper.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    endpoint server for the epmapper pipe
5
6    Copyright (C) Andrew Tridgell 2003
7    Copyright (C) Jelmer Vernooij 2004
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "librpc/gen_ndr/ndr_epmapper.h"
25 #include "rpc_server/dcerpc_server.h"
26
27 #define DCESRV_INTERFACE_EPMAPPER_BIND(call, iface) \
28        dcesrv_interface_epmapper_bind(call, iface)
29 static NTSTATUS dcesrv_interface_epmapper_bind(struct dcesrv_call_state *dce_call,
30                                              const struct dcesrv_interface *iface)
31 {
32         return dcesrv_interface_bind_allow_connect(dce_call, iface);
33 }
34
35 typedef uint32_t error_status_t;
36
37 /* handle types for this module */
38 enum handle_types {HTYPE_LOOKUP};
39
40 /* a endpoint combined with an interface description */
41 struct dcesrv_ep_iface {
42         const char *name;
43         struct epm_tower ep;
44 };
45
46 /*
47   build a list of all interfaces handled by all endpoint servers
48 */
49 static uint32_t build_ep_list(TALLOC_CTX *mem_ctx,
50                               struct dcesrv_endpoint *endpoint_list,
51                               struct dcesrv_ep_iface **eps)
52 {
53         struct dcesrv_endpoint *d;
54         uint32_t total = 0;
55         NTSTATUS status;
56
57         *eps = NULL;
58
59         for (d=endpoint_list; d; d=d->next) {
60                 struct dcesrv_if_list *iface;
61
62                 for (iface=d->interface_list;iface;iface=iface->next) {
63                         struct dcerpc_binding *description;
64
65                         (*eps) = talloc_realloc(mem_ctx, 
66                                                   *eps, 
67                                                   struct dcesrv_ep_iface,
68                                                   total + 1);
69                         if (!*eps) {
70                                 return 0;
71                         }
72                         (*eps)[total].name = iface->iface.name;
73
74                         description = dcerpc_binding_dup(*eps, d->ep_description);
75                         if (description == NULL) {
76                                 return 0;
77                         }
78
79                         status = dcerpc_binding_set_abstract_syntax(description,
80                                                         &iface->iface.syntax_id);
81                         if (!NT_STATUS_IS_OK(status)) {
82                                 return 0;
83                         }
84
85                         status = dcerpc_binding_build_tower(*eps, description, &(*eps)[total].ep);
86                         TALLOC_FREE(description);
87                         if (!NT_STATUS_IS_OK(status)) {
88                                 DEBUG(1, ("Unable to build tower for %s - %s\n",
89                                           iface->iface.name, nt_errstr(status)));
90                                 continue;
91                         }
92                         total++;
93                 }
94         }
95
96         return total;
97 }
98
99
100 static error_status_t dcesrv_epm_Insert(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct epm_Insert *r)
101 {
102         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
103 }
104
105 static error_status_t dcesrv_epm_Delete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, 
106                                  struct epm_Delete *r)
107 {
108         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
109 }
110
111
112 /*
113   implement epm_Lookup. This call is used to enumerate the interfaces
114   available on a rpc server
115 */
116 static error_status_t dcesrv_epm_Lookup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, 
117                                  struct epm_Lookup *r)
118 {
119         struct dcesrv_handle *h;
120         struct rpc_eps {
121                 uint32_t count;
122                 struct dcesrv_ep_iface *e;
123         } *eps;
124         uint32_t num_ents;
125         unsigned int i;
126
127         DCESRV_PULL_HANDLE_FAULT(h, r->in.entry_handle, HTYPE_LOOKUP);
128
129         eps = h->data;
130
131         if (!eps) {
132                 /* this is the first call - fill the list. Subsequent calls 
133                    will feed from this list, stored in the handle */
134                 eps = talloc(h, struct rpc_eps);
135                 if (!eps) {
136                         return EPMAPPER_STATUS_NO_MEMORY;
137                 }
138                 h->data = eps;
139
140                 eps->count = build_ep_list(h, dce_call->conn->dce_ctx->endpoint_list, &eps->e);
141         }
142
143         /* return the next N elements */
144         num_ents = r->in.max_ents;
145         if (num_ents > eps->count) {
146                 num_ents = eps->count;
147         }
148
149         *r->out.entry_handle = h->wire_handle;
150         r->out.num_ents = talloc(mem_ctx, uint32_t);
151         *r->out.num_ents = num_ents;
152
153         if (num_ents == 0) {
154                 r->out.entries = NULL;
155                 ZERO_STRUCTP(r->out.entry_handle);
156                 talloc_free(h);
157                 return EPMAPPER_STATUS_NO_MORE_ENTRIES;
158         }
159
160         r->out.entries = talloc_array(mem_ctx, struct epm_entry_t, num_ents);
161         if (!r->out.entries) {
162                 return EPMAPPER_STATUS_NO_MEMORY;
163         }
164
165         for (i=0;i<num_ents;i++) {
166                 ZERO_STRUCT(r->out.entries[i].object);
167                 r->out.entries[i].annotation = eps->e[i].name;
168                 r->out.entries[i].tower = talloc(mem_ctx, struct epm_twr_t);
169                 if (!r->out.entries[i].tower) {
170                         return EPMAPPER_STATUS_NO_MEMORY;
171                 }
172                 r->out.entries[i].tower->tower = eps->e[i].ep;
173         }
174
175         eps->count -= num_ents;
176         eps->e += num_ents;
177
178         return EPMAPPER_STATUS_OK;
179 }
180
181
182 /*
183   implement epm_Map. This is used to find the specific endpoint to talk to given
184   a generic protocol tower
185 */
186 static error_status_t dcesrv_epm_Map(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, 
187                               struct epm_Map *r)
188 {
189         uint32_t count;
190         unsigned int i;
191         struct dcesrv_ep_iface *eps;
192         struct epm_floor *floors;
193         enum dcerpc_transport_t transport;
194         struct ndr_syntax_id ndr_syntax;
195
196         count = build_ep_list(mem_ctx, dce_call->conn->dce_ctx->endpoint_list, &eps);
197
198         ZERO_STRUCT(*r->out.entry_handle);
199         r->out.num_towers = talloc(mem_ctx, uint32_t);
200         if (!r->out.num_towers) {
201                 return EPMAPPER_STATUS_NO_MEMORY;
202         }
203         *r->out.num_towers = 1;
204         r->out.towers = talloc(mem_ctx, struct epm_twr_p_t);
205         if (!r->out.towers) {
206                 return EPMAPPER_STATUS_NO_MEMORY;
207         }
208         r->out.towers->twr = talloc(mem_ctx, struct epm_twr_t);
209         if (!r->out.towers->twr) {
210                 return EPMAPPER_STATUS_NO_MEMORY;
211         }
212         
213         if (!r->in.map_tower || r->in.max_towers == 0 || 
214             r->in.map_tower->tower.num_floors < 3) {
215                 goto failed;
216         }
217
218         floors = r->in.map_tower->tower.floors;
219
220         dcerpc_floor_get_lhs_data(&r->in.map_tower->tower.floors[1], &ndr_syntax);
221
222         if (floors[1].lhs.protocol != EPM_PROTOCOL_UUID ||
223                 !GUID_equal(&ndr_syntax.uuid, &ndr_transfer_syntax_ndr.uuid) ||
224             ndr_syntax.if_version != ndr_transfer_syntax_ndr.if_version) {
225                 goto failed;
226         }
227
228         transport = dcerpc_transport_by_tower(&r->in.map_tower->tower);
229
230         if (transport == -1) {
231                 DEBUG(2, ("Client requested unknown transport with levels: "));
232                 for (i = 2; i < r->in.map_tower->tower.num_floors; i++) {
233                         DEBUG(2, ("%d, ", r->in.map_tower->tower.floors[i].lhs.protocol));
234                 }
235                 DEBUG(2, ("\n"));
236                 goto failed;
237         }
238
239         for (i=0;i<count;i++) {
240                 if (
241                         data_blob_cmp(&r->in.map_tower->tower.floors[0].lhs.lhs_data, 
242                         &eps[i].ep.floors[0].lhs.lhs_data) != 0 
243                         || transport != dcerpc_transport_by_tower(&eps[i].ep)) {
244                         continue;
245                 }
246                 
247                 r->out.towers->twr->tower = eps[i].ep;
248                 r->out.towers->twr->tower_length = 0;
249                 return EPMAPPER_STATUS_OK;
250         }
251
252
253 failed:
254         *r->out.num_towers = 0;
255         r->out.towers->twr = NULL;
256
257         return EPMAPPER_STATUS_NO_MORE_ENTRIES;
258 }
259
260 static error_status_t dcesrv_epm_LookupHandleFree(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, 
261                                            struct epm_LookupHandleFree *r)
262 {
263         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
264 }
265
266 static error_status_t dcesrv_epm_InqObject(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, 
267                                     struct epm_InqObject *r)
268 {
269         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
270 }
271
272 static error_status_t dcesrv_epm_MgmtDelete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, 
273                                struct epm_MgmtDelete *r)
274 {
275         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
276 }
277
278 static error_status_t dcesrv_epm_MapAuth(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
279                             struct epm_MapAuth *r)
280 {
281         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
282 }
283
284 /* include the generated boilerplate */
285 #include "librpc/gen_ndr/ndr_epmapper_s.c"