r26238: Add a loadparm context parameter to torture_context, remove more uses of...
[gd/samba-autobuild/.git] / source4 / torture / libnet / libnet_rpc.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Test suite for libnet calls.
4
5    Copyright (C) Rafal Szczesniak 2005
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 3 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, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "lib/cmdline/popt_common.h"
23 #include "auth/credentials/credentials.h"
24 #include "libnet/libnet.h"
25 #include "libcli/security/security.h"
26 #include "librpc/ndr/libndr.h"
27 #include "librpc/gen_ndr/ndr_lsa.h"
28 #include "librpc/gen_ndr/ndr_samr.h"
29 #include "librpc/gen_ndr/ndr_srvsvc.h"
30 #include "librpc/rpc/dcerpc.h"
31 #include "torture/rpc/rpc.h"
32 #include "torture/torture.h"
33 #include "param/param.h"
34
35
36 static bool test_connect_service(struct libnet_context *ctx,
37                                  const struct ndr_interface_table *iface,
38                                  const char *binding_string,
39                                  const char *hostname,
40                                  const enum libnet_RpcConnect_level level,
41                                  bool badcreds, NTSTATUS expected_status)
42 {
43         NTSTATUS status;
44         struct libnet_RpcConnect connect;
45         connect.level            = level;
46         connect.in.binding       = binding_string;
47         connect.in.name          = hostname;
48         connect.in.dcerpc_iface  = iface;
49
50         /* if bad credentials are needed, set baduser%badpassword instead
51            of default commandline-passed credentials */
52         if (badcreds) {
53                 cli_credentials_set_username(ctx->cred, "baduser", CRED_SPECIFIED);
54                 cli_credentials_set_password(ctx->cred, "badpassword", CRED_SPECIFIED);
55         }
56
57         status = libnet_RpcConnect(ctx, ctx, &connect);
58
59         if (!NT_STATUS_EQUAL(status, expected_status)) {
60                 d_printf("Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
61                        "Received: %s\n",
62                        connect.in.dcerpc_iface->name, connect.in.binding, nt_errstr(expected_status),
63                        nt_errstr(status));
64
65                 return false;
66         }
67
68         d_printf("PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
69                nt_errstr(status));
70
71         if (connect.level == LIBNET_RPC_CONNECT_DC_INFO && NT_STATUS_IS_OK(status)) {
72                 d_printf("Domain Controller Info:\n");
73                 d_printf("\tDomain Name:\t %s\n", connect.out.domain_name);
74                 d_printf("\tDomain SID:\t %s\n", dom_sid_string(ctx, connect.out.domain_sid));
75                 d_printf("\tRealm:\t\t %s\n", connect.out.realm);
76                 d_printf("\tGUID:\t\t %s\n", GUID_string(ctx, connect.out.guid));
77
78         } else if (!NT_STATUS_IS_OK(status)) {
79                 d_printf("Error string: %s\n", connect.out.error_string);
80         }
81
82         return true;
83 }
84
85
86 static bool torture_rpc_connect(struct torture_context *torture,
87                                 const enum libnet_RpcConnect_level level,
88                                 const char *bindstr, const char *hostname)
89 {
90         struct libnet_context *ctx;
91
92         ctx = libnet_context_init(NULL);
93         ctx->cred = cmdline_credentials;
94         
95         d_printf("Testing connection to LSA interface\n");
96         if (!test_connect_service(ctx, &ndr_table_lsarpc, bindstr,
97                                   hostname, level, false, NT_STATUS_OK)) {
98                 d_printf("failed to connect LSA interface\n");
99                 return false;
100         }
101
102         d_printf("Testing connection to SAMR interface\n");
103         if (!test_connect_service(ctx, &ndr_table_samr, bindstr,
104                                   hostname, level, false, NT_STATUS_OK)) {
105                 d_printf("failed to connect SAMR interface\n");
106                 return false;
107         }
108
109         d_printf("Testing connection to SRVSVC interface\n");
110         if (!test_connect_service(ctx, &ndr_table_srvsvc, bindstr,
111                                   hostname, level, false, NT_STATUS_OK)) {
112                 d_printf("failed to connect SRVSVC interface\n");
113                 return false;
114         }
115
116         d_printf("Testing connection to LSA interface with wrong credentials\n");
117         if (!test_connect_service(ctx, &ndr_table_lsarpc, bindstr,
118                                   hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
119                 d_printf("failed to test wrong credentials on LSA interface\n");
120                 return false;
121         }
122
123         d_printf("Testing connection to SAMR interface with wrong credentials\n");
124         if (!test_connect_service(ctx, &ndr_table_samr, bindstr,
125                                   hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
126                 d_printf("failed to test wrong credentials on SAMR interface\n");
127                 return false;
128         }
129
130         talloc_free(ctx);
131
132         return true;
133 }
134
135
136 bool torture_rpc_connect_srv(struct torture_context *torture)
137 {
138         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_SERVER;
139         NTSTATUS status;
140         struct dcerpc_binding *binding;
141
142         status = torture_rpc_binding(torture, &binding);
143         if (!NT_STATUS_IS_OK(status)) {
144                 return false;
145         }
146
147         return torture_rpc_connect(torture, level, NULL, binding->host);
148 }
149
150
151 bool torture_rpc_connect_pdc(struct torture_context *torture)
152 {
153         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_PDC;
154         NTSTATUS status;
155         struct dcerpc_binding *binding;
156         const char *domain_name;
157         
158         status = torture_rpc_binding(torture, &binding);
159         if (!NT_STATUS_IS_OK(status)) {
160                 return false;
161         }
162
163         /* we're accessing domain controller so the domain name should be
164            passed (it's going to be resolved to dc name and address) instead
165            of specific server name. */
166         domain_name = lp_workgroup(torture->lp_ctx);
167         return torture_rpc_connect(torture, level, NULL, domain_name);
168 }
169
170
171 bool torture_rpc_connect_dc(struct torture_context *torture)
172 {
173         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_DC;
174         NTSTATUS status;
175         struct dcerpc_binding *binding;
176         const char *domain_name;
177         
178         status = torture_rpc_binding(torture, &binding);
179         if (!NT_STATUS_IS_OK(status)) {
180                 return false;
181         }
182
183         /* we're accessing domain controller so the domain name should be
184            passed (it's going to be resolved to dc name and address) instead
185            of specific server name. */
186         domain_name = lp_workgroup(torture->lp_ctx);
187         return torture_rpc_connect(torture, level, NULL, domain_name);
188 }
189
190
191 bool torture_rpc_connect_dc_info(struct torture_context *torture)
192 {
193         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_DC_INFO;
194         NTSTATUS status;
195         struct dcerpc_binding *binding;
196         const char *domain_name;
197         
198         status = torture_rpc_binding(torture, &binding);
199         if (!NT_STATUS_IS_OK(status)) {
200                 return false;
201         }
202
203         /* we're accessing domain controller so the domain name should be
204            passed (it's going to be resolved to dc name and address) instead
205            of specific server name. */
206         domain_name = lp_workgroup(torture->lp_ctx);
207         return torture_rpc_connect(torture, level, NULL, domain_name);
208 }
209
210
211 bool torture_rpc_connect_binding(struct torture_context *torture)
212 {
213         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_BINDING;
214         NTSTATUS status;
215         struct dcerpc_binding *binding;
216         const char *bindstr;
217         
218         status = torture_rpc_binding(torture, &binding);
219         if (!NT_STATUS_IS_OK(status)) {
220                 return false;
221         }
222
223         bindstr = dcerpc_binding_string(torture, binding);
224
225         return torture_rpc_connect(torture, level, bindstr, NULL);
226 }