r4559: prevent the RPC-EPMAPPER test from looping forever against w2k3
[samba.git] / source4 / torture / rpc / epmapper.c
1 /* 
2    Unix SMB/CIFS implementation.
3    test suite for epmapper rpc operations
4
5    Copyright (C) Andrew Tridgell 2003
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 2 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, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23 #include "system/network.h"
24 #include "librpc/gen_ndr/ndr_epmapper.h"
25
26
27 /*
28   display any protocol tower
29  */
30 static void display_tower(TALLOC_CTX *mem_ctx, struct epm_tower *twr)
31 {
32         int i;
33         const char *uuid;
34
35         for (i=0;i<twr->num_floors;i++) {
36                 struct epm_lhs *lhs = &twr->floors[i].lhs;
37                 union epm_rhs *rhs = &twr->floors[i].rhs;
38
39                 switch(lhs->protocol) {
40                 case EPM_PROTOCOL_UUID:
41                         uuid = GUID_string(mem_ctx, &lhs->info.uuid.uuid);
42                         if (strcasecmp(uuid, NDR_GUID) == 0) {
43                                 printf(" NDR");
44                         } else {
45                                 printf(" uuid %s/0x%02x", uuid, lhs->info.uuid.version);
46                         }
47                         break;
48
49                 case EPM_PROTOCOL_NCACN:
50                         printf(" RPC-C");
51                         break;
52
53                 case EPM_PROTOCOL_NCADG:
54                         printf(" RPC");
55                         break;
56
57                 case EPM_PROTOCOL_NCALRPC:
58                         printf(" NCALRPC");
59                         break;
60
61                 case EPM_PROTOCOL_DNET_NSP:
62                         printf(" DNET/NSP");
63                         break;
64
65                 case EPM_PROTOCOL_IP:
66                         printf(" IP:");
67                         {
68                                 struct ipv4_addr in;
69                                 in.addr = htonl(rhs->ip.address);
70                                 printf("%s", sys_inet_ntoa(in));
71                         }
72                         break;
73
74                 case EPM_PROTOCOL_PIPE:
75                         printf(" PIPE:%s", rhs->pipe.path);
76                         break;
77
78                 case EPM_PROTOCOL_SMB:
79                         printf(" SMB:%s", rhs->smb.unc);
80                         break;
81
82                 case EPM_PROTOCOL_UNIX_DS:
83                         printf(" Unix:%s", rhs->unix_ds.path);
84                         break;
85
86                 case EPM_PROTOCOL_NETBIOS:
87                         printf(" NetBIOS:%s", rhs->netbios.name);
88                         break;
89
90                 case EPM_PROTOCOL_NETBEUI:
91                         printf(" NETBeui");
92                         break;
93
94                 case EPM_PROTOCOL_SPX:
95                         printf(" SPX");
96                         break;
97
98                 case EPM_PROTOCOL_NB_IPX:
99                         printf(" NB_IPX");
100                         break;
101
102                 case EPM_PROTOCOL_HTTP:
103                         printf(" HTTP:%d", rhs->http.port);
104                         break;
105
106                 case EPM_PROTOCOL_TCP:
107                         /* what is the difference between this and 0x1f? */
108                         printf(" TCP:%d", rhs->tcp.port);
109                         break;
110
111                 case EPM_PROTOCOL_UDP:
112                         printf(" UDP:%d", rhs->udp.port);
113                         break;
114
115                 default:
116                         printf(" UNK(%02x):", lhs->protocol);
117                         if (rhs->unknown.length == 2) {
118                                 printf("%d", RSVAL(rhs->unknown.data, 0));
119                         }
120                         break;
121                 }
122         }
123         printf("\n");
124 }
125
126
127 static BOOL test_Map(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
128                      struct epm_twr_t *twr)
129 {
130         NTSTATUS status;
131         struct epm_Map r;
132         struct GUID uuid;
133         const char *uuid_str;
134         struct policy_handle handle;
135         int i;
136
137         ZERO_STRUCT(uuid);
138         ZERO_STRUCT(handle);
139
140         r.in.object = &uuid;
141         r.in.map_tower = twr;
142         r.in.entry_handle = &handle;    
143         r.out.entry_handle = &handle;
144         r.in.max_towers = 100;
145
146         uuid_str = GUID_string(mem_ctx, &twr->tower.floors[0].lhs.info.uuid.uuid);
147
148         printf("epm_Map results for '%s':\n", 
149                idl_pipe_name(uuid_str, twr->tower.floors[0].lhs.info.uuid.version));
150
151         twr->tower.floors[2].lhs.protocol = EPM_PROTOCOL_NCACN;
152         twr->tower.floors[2].lhs.info.lhs_data = data_blob(NULL, 0);
153         twr->tower.floors[2].rhs.ncacn.minor_version = 0;
154
155         twr->tower.floors[3].lhs.protocol = EPM_PROTOCOL_TCP;
156         twr->tower.floors[3].lhs.info.lhs_data = data_blob(NULL, 0);
157         twr->tower.floors[3].rhs.tcp.port = 0;
158
159         twr->tower.floors[4].lhs.protocol = EPM_PROTOCOL_IP;
160         twr->tower.floors[4].lhs.info.lhs_data = data_blob(NULL, 0);
161         twr->tower.floors[4].rhs.ip.address = 0;
162
163         status = dcerpc_epm_Map(p, mem_ctx, &r);
164         if (NT_STATUS_IS_OK(status) && r.out.result == 0) {
165                 for (i=0;i<r.out.num_towers;i++) {
166                         if (r.out.towers[i].twr) {
167                                 display_tower(mem_ctx, &r.out.towers[i].twr->tower);
168                         }
169                 }
170         }
171
172         twr->tower.floors[3].lhs.protocol = EPM_PROTOCOL_HTTP;
173         twr->tower.floors[3].lhs.info.lhs_data = data_blob(NULL, 0);
174         twr->tower.floors[3].rhs.http.port = 0;
175
176         status = dcerpc_epm_Map(p, mem_ctx, &r);
177         if (NT_STATUS_IS_OK(status) && r.out.result == 0) {
178                 for (i=0;i<r.out.num_towers;i++) {
179                         if (r.out.towers[i].twr) {
180                                 display_tower(mem_ctx, &r.out.towers[i].twr->tower);
181                         }
182                 }
183         }
184
185         twr->tower.floors[3].lhs.protocol = EPM_PROTOCOL_UDP;
186         twr->tower.floors[3].lhs.info.lhs_data = data_blob(NULL, 0);
187         twr->tower.floors[3].rhs.http.port = 0;
188
189         status = dcerpc_epm_Map(p, mem_ctx, &r);
190         if (NT_STATUS_IS_OK(status) && r.out.result == 0) {
191                 for (i=0;i<r.out.num_towers;i++) {
192                         if (r.out.towers[i].twr) {
193                                 display_tower(mem_ctx, &r.out.towers[i].twr->tower);
194                         }
195                 }
196         }
197
198         twr->tower.floors[3].lhs.protocol = EPM_PROTOCOL_SMB;
199         twr->tower.floors[3].lhs.info.lhs_data = data_blob(NULL, 0);
200         twr->tower.floors[3].rhs.smb.unc = "";
201
202         twr->tower.floors[4].lhs.protocol = EPM_PROTOCOL_NETBIOS;
203         twr->tower.floors[4].lhs.info.lhs_data = data_blob(NULL, 0);
204         twr->tower.floors[4].rhs.netbios.name = "";
205
206         status = dcerpc_epm_Map(p, mem_ctx, &r);
207         if (NT_STATUS_IS_OK(status) && r.out.result == 0) {
208                 for (i=0;i<r.out.num_towers;i++) {
209                         if (r.out.towers[i].twr) {
210                                 display_tower(mem_ctx, &r.out.towers[i].twr->tower);
211                         }
212                 }
213         }
214
215         /* FIXME: Extend to do other protocols as well (ncacn_unix_stream, ncalrpc) */
216         
217         return True;
218 }
219
220 static BOOL test_Lookup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
221 {
222         NTSTATUS status;
223         struct epm_Lookup r;
224         struct GUID uuid;
225         struct rpc_if_id_t iface;
226         struct policy_handle handle;
227
228         ZERO_STRUCT(handle);
229
230         r.in.inquiry_type = 0;
231         r.in.object = &uuid;
232         r.in.interface_id = &iface;
233         r.in.vers_option = 0;
234         r.in.entry_handle = &handle;
235         r.out.entry_handle = &handle;
236         r.in.max_ents = 10;
237
238         do {
239                 int i;
240
241                 ZERO_STRUCT(uuid);
242                 ZERO_STRUCT(iface);
243
244                 status = dcerpc_epm_Lookup(p, mem_ctx, &r);
245                 if (!NT_STATUS_IS_OK(status) || r.out.result != 0) {
246                         break;
247                 }
248
249                 printf("epm_Lookup returned %d events GUID %s\n", 
250                        r.out.num_ents, GUID_string(mem_ctx, &handle.uuid));
251
252                 for (i=0;i<r.out.num_ents;i++) {
253                         printf("\nFound '%s'\n", r.out.entries[i].annotation);
254                         display_tower(mem_ctx, &r.out.entries[i].tower->tower);
255                         if (r.out.entries[i].tower->tower.num_floors == 5) {
256                                 test_Map(p, mem_ctx, r.out.entries[i].tower);
257                         }
258                 }
259         } while (NT_STATUS_IS_OK(status) && 
260                  r.out.result == 0 && 
261                  r.out.num_ents == r.in.max_ents &&
262                  !policy_handle_empty(&handle));
263
264         if (!NT_STATUS_IS_OK(status)) {
265                 printf("Lookup failed - %s\n", nt_errstr(status));
266                 return False;
267         }
268
269
270         return True;
271 }
272
273 static BOOL test_InqObject(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
274 {
275         NTSTATUS status;
276         struct epm_InqObject r;
277
278         r.in.epm_object = talloc_p(mem_ctx, struct GUID);
279         GUID_from_string(DCERPC_EPMAPPER_UUID, r.in.epm_object);
280
281         status = dcerpc_epm_InqObject(p, mem_ctx, &r);
282         if (NT_STATUS_IS_ERR(status)) {
283                 printf("InqObject failed - %s\n", nt_errstr(status));
284                 return False;
285         }
286
287         return True;
288 }
289
290 BOOL torture_rpc_epmapper(void)
291 {
292         NTSTATUS status;
293         struct dcerpc_pipe *p;
294         TALLOC_CTX *mem_ctx;
295         BOOL ret = True;
296
297         mem_ctx = talloc_init("torture_rpc_epmapper");
298
299         status = torture_rpc_connection(&p, 
300                                         DCERPC_EPMAPPER_NAME,
301                                         DCERPC_EPMAPPER_UUID,
302                                         DCERPC_EPMAPPER_VERSION);
303         if (!NT_STATUS_IS_OK(status)) {
304                 return False;
305         }
306
307         if (!test_Lookup(p, mem_ctx)) {
308                 ret = False;
309         }
310
311         if (!test_InqObject(p, mem_ctx)) {
312                 ret = False;
313         }
314
315         talloc_destroy(mem_ctx);
316
317         torture_rpc_close(p);
318
319         return ret;
320 }