76d412a7cd81d3b6d721243dcc902384acbda77f
[gd/samba-autobuild/.git] / source4 / torture / ldap / basic.c
1 /* 
2    Unix SMB/CIFS mplementation.
3    LDAP protocol helper functions for SAMBA
4    
5    Copyright (C) Stefan Metzmacher 2004
6    Copyright (C) Simo Sorce 2004
7     
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20    
21 */
22
23 #include "includes.h"
24 #include "libcli/ldap/ldap_client.h"
25 #include "lib/cmdline/popt_common.h"
26
27 #include "torture/torture.h"
28 #include "torture/ldap/proto.h"
29
30 #include "param/param.h"
31
32 static bool test_bind_simple(struct ldap_connection *conn, const char *userdn, const char *password)
33 {
34         NTSTATUS status;
35         bool ret = true;
36
37         status = torture_ldap_bind(conn, userdn, password);
38         if (!NT_STATUS_IS_OK(status)) {
39                 ret = false;
40         }
41
42         return ret;
43 }
44
45 static bool test_bind_sasl(struct ldap_connection *conn, struct cli_credentials *creds)
46 {
47         NTSTATUS status;
48         bool ret = true;
49
50         printf("Testing sasl bind as user\n");
51
52         status = torture_ldap_bind_sasl(conn, creds, global_loadparm);
53         if (!NT_STATUS_IS_OK(status)) {
54                 ret = false;
55         }
56
57         return ret;
58 }
59
60 static bool test_multibind(struct ldap_connection *conn, const char *userdn, const char *password)
61 {
62         bool ret = true;
63
64         printf("Testing multiple binds on a single connnection as anonymous and user\n");
65
66         ret = test_bind_simple(conn, NULL, NULL);
67         if (!ret) {
68                 printf("1st bind as anonymous failed\n");
69                 return ret;
70         }
71
72         ret = test_bind_simple(conn, userdn, password);
73         if (!ret) {
74                 printf("2nd bind as authenticated user failed\n");
75         }
76
77         return ret;
78 }
79
80 static bool test_search_rootDSE(struct ldap_connection *conn, char **basedn)
81 {
82         bool ret = true;
83         struct ldap_message *msg, *result;
84         struct ldap_request *req;
85         int i;
86         struct ldap_SearchResEntry *r;
87         NTSTATUS status;
88
89         printf("Testing RootDSE Search\n");
90
91         *basedn = NULL;
92
93         msg = new_ldap_message(conn);
94         if (!msg) {
95                 return false;
96         }
97
98         msg->type = LDAP_TAG_SearchRequest;
99         msg->r.SearchRequest.basedn = "";
100         msg->r.SearchRequest.scope = LDAP_SEARCH_SCOPE_BASE;
101         msg->r.SearchRequest.deref = LDAP_DEREFERENCE_NEVER;
102         msg->r.SearchRequest.timelimit = 0;
103         msg->r.SearchRequest.sizelimit = 0;
104         msg->r.SearchRequest.attributesonly = false;
105         msg->r.SearchRequest.tree = ldb_parse_tree(msg, "(objectclass=*)");
106         msg->r.SearchRequest.num_attributes = 0;
107         msg->r.SearchRequest.attributes = NULL;
108
109         req = ldap_request_send(conn, msg);
110         if (req == NULL) {
111                 printf("Could not setup ldap search\n");
112                 return false;
113         }
114
115         status = ldap_result_one(req, &result, LDAP_TAG_SearchResultEntry);
116         if (!NT_STATUS_IS_OK(status)) {
117                 printf("search failed - %s\n", nt_errstr(status));
118                 return false;
119         }
120
121         printf("received %d replies\n", req->num_replies);
122
123         r = &result->r.SearchResultEntry;
124                 
125         DEBUG(1,("\tdn: %s\n", r->dn));
126         for (i=0; i<r->num_attributes; i++) {
127                 int j;
128                 for (j=0; j<r->attributes[i].num_values; j++) {
129                         DEBUG(1,("\t%s: %d %.*s\n", r->attributes[i].name,
130                                  (int)r->attributes[i].values[j].length,
131                                  (int)r->attributes[i].values[j].length,
132                                  (char *)r->attributes[i].values[j].data));
133                         if (!(*basedn) && 
134                             strcasecmp("defaultNamingContext",r->attributes[i].name)==0) {
135                                 *basedn = talloc_asprintf(conn, "%.*s",
136                                                           (int)r->attributes[i].values[j].length,
137                                                           (char *)r->attributes[i].values[j].data);
138                         }
139                 }
140         }
141
142         talloc_free(req);
143
144         return ret;
145 }
146
147 static bool test_compare_sasl(struct ldap_connection *conn, const char *basedn)
148 {
149         struct ldap_message *msg, *rep;
150         struct ldap_request *req;
151         const char *val;
152         NTSTATUS status;
153
154         printf("Testing SASL Compare: %s\n", basedn);
155
156         if (!basedn) {
157                 return false;
158         }
159
160         msg = new_ldap_message(conn);
161         if (!msg) {
162                 return false;
163         }
164
165         msg->type = LDAP_TAG_CompareRequest;
166         msg->r.CompareRequest.dn = basedn;
167         msg->r.CompareRequest.attribute = talloc_strdup(msg, "objectClass");
168         val = "domain";
169         msg->r.CompareRequest.value = data_blob_talloc(msg, val, strlen(val));
170
171         req = ldap_request_send(conn, msg);
172         if (!req) {
173                 return false;
174         }
175
176         status = ldap_result_one(req, &rep, LDAP_TAG_CompareResponse);
177         if (!NT_STATUS_IS_OK(status)) {
178                 printf("error in ldap compare request - %s\n", nt_errstr(status));
179                 return false;
180         }
181
182         DEBUG(5,("Code: %d DN: [%s] ERROR:[%s] REFERRAL:[%s]\n",
183                 rep->r.CompareResponse.resultcode,
184                 rep->r.CompareResponse.dn,
185                 rep->r.CompareResponse.errormessage,
186                 rep->r.CompareResponse.referral));
187
188         return true;
189 }
190
191
192 bool torture_ldap_basic(struct torture_context *torture)
193 {
194         NTSTATUS status;
195         struct ldap_connection *conn;
196         TALLOC_CTX *mem_ctx;
197         bool ret = true;
198         const char *host = torture_setting_string(torture, "host", NULL);
199         const char *userdn = torture_setting_string(torture, "ldap_userdn", NULL);
200         const char *secret = torture_setting_string(torture, "ldap_secret", NULL);
201         char *url;
202         char *basedn;
203
204         mem_ctx = talloc_init("torture_ldap_basic");
205
206         url = talloc_asprintf(mem_ctx, "ldap://%s/", host);
207
208         status = torture_ldap_connection(mem_ctx, &conn, url);
209         if (!NT_STATUS_IS_OK(status)) {
210                 return false;
211         }
212
213         if (!test_search_rootDSE(conn, &basedn)) {
214                 ret = false;
215         }
216
217         /* other basic tests here */
218
219         if (!test_multibind(conn, userdn, secret)) {
220                 ret = false;
221         }
222
223         if (!test_bind_sasl(conn, cmdline_credentials)) {
224                 ret = false;
225         }
226
227         if (!test_compare_sasl(conn, basedn)) {
228                 ret = false;
229         }
230
231         /* no more test we are closing */
232         torture_ldap_close(conn);
233         talloc_free(mem_ctx);
234
235
236         return ret;
237 }
238