3e2048274a91a3ca0b932d8a0170fbba8bb74026
[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 "libnet/libnet.h"
24 #include "libcli/security/security.h"
25 #include "librpc/gen_ndr/ndr_lsa.h"
26 #include "librpc/gen_ndr/ndr_samr.h"
27 #include "librpc/gen_ndr/ndr_srvsvc.h"
28 #include "torture/rpc/torture_rpc.h"
29 #include "torture/libnet/proto.h"
30 #include "param/param.h"
31
32
33 static bool test_connect_service(struct torture_context *tctx,
34                                  struct libnet_context *ctx,
35                                  const struct ndr_interface_table *iface,
36                                  const char *binding_string,
37                                  const char *hostname,
38                                  const enum libnet_RpcConnect_level level,
39                                  bool badcreds, NTSTATUS expected_status)
40 {
41         NTSTATUS status;
42         struct libnet_RpcConnect connect_r;
43         ZERO_STRUCT(connect_r);
44
45         connect_r.level            = level;
46         connect_r.in.binding       = binding_string;
47         connect_r.in.name          = hostname;
48         connect_r.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_r);
58
59         if (!NT_STATUS_EQUAL(status, expected_status)) {
60                 torture_comment(tctx, "Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
61                        "Received: %s\n",
62                        connect_r.in.dcerpc_iface->name, connect_r.in.binding, nt_errstr(expected_status),
63                        nt_errstr(status));
64
65                 return false;
66         }
67
68         torture_comment(tctx, "PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
69                nt_errstr(status));
70
71         if (connect_r.level == LIBNET_RPC_CONNECT_DC_INFO && NT_STATUS_IS_OK(status)) {
72                 torture_comment(tctx, "Domain Controller Info:\n");
73                 torture_comment(tctx, "\tDomain Name:\t %s\n", connect_r.out.domain_name);
74                 torture_comment(tctx, "\tDomain SID:\t %s\n", dom_sid_string(ctx, connect_r.out.domain_sid));
75                 torture_comment(tctx, "\tRealm:\t\t %s\n", connect_r.out.realm);
76                 torture_comment(tctx, "\tGUID:\t\t %s\n", GUID_string(ctx, connect_r.out.guid));
77
78         } else if (!NT_STATUS_IS_OK(status)) {
79                 torture_comment(tctx, "Error string: %s\n", connect_r.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(torture->ev, torture->lp_ctx);
93         ctx->cred = cmdline_credentials;
94
95         torture_comment(torture, "Testing connection to LSA interface\n");
96
97         if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
98                                   hostname, level, false, NT_STATUS_OK)) {
99                 torture_comment(torture, "failed to connect LSA interface\n");
100                 return false;
101         }
102
103         torture_comment(torture, "Testing connection to SAMR interface\n");
104         if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
105                                   hostname, level, false, NT_STATUS_OK)) {
106                 torture_comment(torture, "failed to connect SAMR interface\n");
107                 return false;
108         }
109
110         torture_comment(torture, "Testing connection to SRVSVC interface\n");
111         if (!test_connect_service(torture, ctx, &ndr_table_srvsvc, bindstr,
112                                   hostname, level, false, NT_STATUS_OK)) {
113                 torture_comment(torture, "failed to connect SRVSVC interface\n");
114                 return false;
115         }
116
117         torture_comment(torture, "Testing connection to LSA interface with wrong credentials\n");
118         if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
119                                   hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
120                 torture_comment(torture, "failed to test wrong credentials on LSA interface\n");
121                 return false;
122         }
123
124         torture_comment(torture, "Testing connection to SAMR interface with wrong credentials\n");
125         if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
126                                   hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
127                 torture_comment(torture, "failed to test wrong credentials on SAMR interface\n");
128                 return false;
129         }
130
131         talloc_free(ctx);
132
133         return true;
134 }
135
136
137 bool torture_rpc_connect_srv(struct torture_context *torture)
138 {
139         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_SERVER;
140         NTSTATUS status;
141         struct dcerpc_binding *binding;
142         const char *host;
143
144         status = torture_rpc_binding(torture, &binding);
145         if (!NT_STATUS_IS_OK(status)) {
146                 return false;
147         }
148
149         host = dcerpc_binding_get_string_option(binding, "host");
150
151         return torture_rpc_connect(torture, level, NULL, host);
152 }
153
154
155 bool torture_rpc_connect_pdc(struct torture_context *torture)
156 {
157         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_PDC;
158         NTSTATUS status;
159         struct dcerpc_binding *binding;
160         const char *domain_name;
161
162         status = torture_rpc_binding(torture, &binding);
163         if (!NT_STATUS_IS_OK(status)) {
164                 return false;
165         }
166
167         /* we're accessing domain controller so the domain name should be
168            passed (it's going to be resolved to dc name and address) instead
169            of specific server name. */
170         domain_name = lpcfg_workgroup(torture->lp_ctx);
171         return torture_rpc_connect(torture, level, NULL, domain_name);
172 }
173
174
175 bool torture_rpc_connect_dc(struct torture_context *torture)
176 {
177         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_DC;
178         NTSTATUS status;
179         struct dcerpc_binding *binding;
180         const char *domain_name;
181
182         status = torture_rpc_binding(torture, &binding);
183         if (!NT_STATUS_IS_OK(status)) {
184                 return false;
185         }
186
187         /* we're accessing domain controller so the domain name should be
188            passed (it's going to be resolved to dc name and address) instead
189            of specific server name. */
190         domain_name = lpcfg_workgroup(torture->lp_ctx);
191         return torture_rpc_connect(torture, level, NULL, domain_name);
192 }
193
194
195 bool torture_rpc_connect_dc_info(struct torture_context *torture)
196 {
197         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_DC_INFO;
198         NTSTATUS status;
199         struct dcerpc_binding *binding;
200         const char *domain_name;
201
202         status = torture_rpc_binding(torture, &binding);
203         if (!NT_STATUS_IS_OK(status)) {
204                 return false;
205         }
206
207         /* we're accessing domain controller so the domain name should be
208            passed (it's going to be resolved to dc name and address) instead
209            of specific server name. */
210         domain_name = lpcfg_workgroup(torture->lp_ctx);
211         return torture_rpc_connect(torture, level, NULL, domain_name);
212 }
213
214
215 bool torture_rpc_connect_binding(struct torture_context *torture)
216 {
217         const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_BINDING;
218         NTSTATUS status;
219         struct dcerpc_binding *binding;
220         const char *bindstr;
221
222         status = torture_rpc_binding(torture, &binding);
223         if (!NT_STATUS_IS_OK(status)) {
224                 return false;
225         }
226
227         bindstr = dcerpc_binding_string(torture, binding);
228
229         return torture_rpc_connect(torture, level, bindstr, NULL);
230 }