dba0549b4445e15c8e0f2a37cf97cc2ca4e7cb18
[samba.git] / source4 / lib / ldb / tools / ldbsearch.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Tridgell  2004
5
6      ** NOTE! The following LGPL license applies to the ldb
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9    
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 3 of the License, or (at your option) any later version.
14
15    This library is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 /*
25  *  Name: ldb
26  *
27  *  Component: ldbsearch
28  *
29  *  Description: utility for ldb search - modelled on ldapsearch
30  *
31  *  Author: Andrew Tridgell
32  */
33
34 #include "ldb_includes.h"
35 #include "tools/cmdline.h"
36
37 static void usage(void)
38 {
39         printf("Usage: ldbsearch <options> <expression> <attrs...>\n");
40         printf("Options:\n");
41         printf("  -H ldb_url       choose the database (or $LDB_URL)\n");
42         printf("  -s base|sub|one  choose search scope\n");
43         printf("  -b basedn        choose baseDN\n");
44         printf("  -i               read search expressions from stdin\n");
45         printf("  -S               sort returned attributes\n");
46         printf("  -o options       pass options like modules to activate\n");
47         printf("              e.g: -o modules:timestamps\n");
48         exit(1);
49 }
50
51 static int do_compare_msg(struct ldb_message **el1,
52                           struct ldb_message **el2,
53                           void *opaque)
54 {
55         return ldb_dn_compare((*el1)->dn, (*el2)->dn);
56 }
57
58 struct search_context {
59         struct ldb_control **req_ctrls;
60
61         int sort;
62         int num_stored;
63         struct ldb_message **store;
64         char **refs_store;
65
66         int entries;
67         int refs;
68
69         int pending;
70         int status;
71 };
72
73 static int store_message(struct ldb_message *msg, struct search_context *sctx) {
74
75         sctx->store = talloc_realloc(sctx, sctx->store, struct ldb_message *, sctx->num_stored + 2);
76         if (!sctx->store) {
77                 fprintf(stderr, "talloc_realloc failed while storing messages\n");
78                 return -1;
79         }
80
81         sctx->store[sctx->num_stored] = talloc_move(sctx->store, &msg);
82         sctx->num_stored++;
83         sctx->store[sctx->num_stored] = NULL;
84
85         return 0;
86 }
87
88 static int store_referral(char *referral, struct search_context *sctx) {
89
90         sctx->refs_store = talloc_realloc(sctx, sctx->refs_store, char *, sctx->refs + 2);
91         if (!sctx->refs_store) {
92                 fprintf(stderr, "talloc_realloc failed while storing referrals\n");
93                 return -1;
94         }
95
96         sctx->refs_store[sctx->refs] = talloc_move(sctx->refs_store, &referral);
97         sctx->refs++;
98         sctx->refs_store[sctx->refs] = NULL;
99
100         return 0;
101 }
102
103 static int display_message(struct ldb_context *ldb, struct ldb_message *msg, struct search_context *sctx) {
104         struct ldb_ldif ldif;
105
106         sctx->entries++;
107         printf("# record %d\n", sctx->entries);
108
109         ldif.changetype = LDB_CHANGETYPE_NONE;
110         ldif.msg = msg;
111
112         if (sctx->sort) {
113         /*
114          * Ensure attributes are always returned in the same
115          * order.  For testing, this makes comparison of old
116          * vs. new much easier.
117          */
118                 ldb_msg_sort_elements(ldif.msg);
119         }
120
121         ldb_ldif_write_file(ldb, stdout, &ldif);
122
123         return 0;
124 }
125
126 static int display_referral(char *referral, struct search_context *sctx)
127 {
128
129         sctx->refs++;
130         printf("# Referral\nref: %s\n\n", referral);
131
132         return 0;
133 }
134
135 static int search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
136 {
137         struct search_context *sctx = talloc_get_type(context, struct search_context);
138         int ret;
139         
140         switch (ares->type) {
141
142         case LDB_REPLY_ENTRY:
143                 if (sctx->sort) {
144                         ret = store_message(ares->message, sctx);
145                 } else {
146                         ret = display_message(ldb, ares->message, sctx);
147                 }
148                 break;
149
150         case LDB_REPLY_REFERRAL:
151                 if (sctx->sort) {
152                         ret = store_referral(ares->referral, sctx);
153                 } else {
154                         ret = display_referral(ares->referral, sctx);
155                 }
156                 break;
157
158         case LDB_REPLY_DONE:
159                 if (ares->controls) {
160                         if (handle_controls_reply(ares->controls, sctx->req_ctrls) == 1)
161                                 sctx->pending = 1;
162                 }
163                 ret = 0;
164                 break;
165                 
166         default:
167                 fprintf(stderr, "unknown Reply Type\n");
168                 return LDB_ERR_OTHER;
169         }
170
171         if (talloc_free(ares) == -1) {
172                 fprintf(stderr, "talloc_free failed\n");
173                 sctx->pending = 0;
174                 return LDB_ERR_OPERATIONS_ERROR;
175         }
176
177         if (ret) {
178                 return LDB_ERR_OPERATIONS_ERROR;
179         }
180
181         return LDB_SUCCESS;
182 }
183
184 static int do_search(struct ldb_context *ldb,
185                      struct ldb_dn *basedn,
186                      struct ldb_cmdline *options,
187                      const char *expression,
188                      const char * const *attrs)
189 {
190         struct ldb_request *req;
191         struct search_context *sctx;
192         int ret;
193
194         req = talloc(ldb, struct ldb_request);
195         if (!req) return -1;
196         
197         sctx = talloc(req, struct search_context);
198         if (!sctx) return -1;
199
200         sctx->sort = options->sorted;
201         sctx->num_stored = 0;
202         sctx->store = NULL;
203         sctx->req_ctrls = ldb_parse_control_strings(ldb, sctx, (const char **)options->controls);
204         if (options->controls != NULL &&  sctx->req_ctrls== NULL) {
205                 printf("parsing controls failed: %s\n", ldb_errstring(ldb));
206                 return -1;
207         }
208         sctx->entries = 0;
209         sctx->refs = 0;
210
211         if (basedn == NULL) {
212                 basedn = ldb_get_default_basedn(ldb);
213         }
214
215         req->operation = LDB_SEARCH;
216         req->op.search.base = basedn;
217         req->op.search.scope = options->scope;
218         req->op.search.tree = ldb_parse_tree(req, expression);
219         if (req->op.search.tree == NULL) return -1;
220         req->op.search.attrs = attrs;
221         req->controls = sctx->req_ctrls;
222         req->context = sctx;
223         req->callback = &search_callback;
224         ldb_set_timeout(ldb, req, 0); /* TODO: make this settable by command line */
225
226 again:
227         sctx->pending = 0;
228
229         ret = ldb_request(ldb, req);
230         if (ret != LDB_SUCCESS) {
231                 printf("search failed - %s\n", ldb_errstring(ldb));
232                 return -1;
233         }
234
235         ret = ldb_wait(req->handle, LDB_WAIT_ALL);
236         if (ret != LDB_SUCCESS) {
237                 printf("search error - %s\n", ldb_errstring(ldb));
238                 return -1;
239         }
240
241         if (sctx->pending)
242                 goto again;
243
244         if (sctx->sort && (sctx->num_stored != 0 || sctx->refs != 0)) {
245                 int i;
246
247                 ldb_qsort(sctx->store, sctx->num_stored, sizeof(struct ldb_message *),
248                           ldb, (ldb_qsort_cmp_fn_t)do_compare_msg);
249
250                 if (ret != 0) {
251                         fprintf(stderr, "An error occurred while sorting messages\n");
252                         exit(1);
253                 }
254
255                 for (i = 0; i < sctx->num_stored; i++) {
256                         display_message(ldb, sctx->store[i], sctx);
257                 }
258
259                 for (i = 0; i < sctx->refs; i++) {
260                         display_referral(sctx->refs_store[i], sctx);
261                 }
262         }
263
264         printf("# returned %d records\n# %d entries\n# %d referrals\n",
265                 sctx->entries + sctx->refs, sctx->entries, sctx->refs);
266
267         talloc_free(req);
268
269         return 0;
270 }
271
272 int main(int argc, const char **argv)
273 {
274         struct ldb_context *ldb;
275         struct ldb_dn *basedn = NULL;
276         const char * const * attrs = NULL;
277         struct ldb_cmdline *options;
278         int ret = -1;
279         const char *expression = "(|(objectClass=*)(distinguishedName=*))";
280
281         ldb_global_init();
282
283         ldb = ldb_init(NULL);
284
285         options = ldb_cmdline_process(ldb, argc, argv, usage);
286
287         /* the check for '=' is for compatibility with ldapsearch */
288         if (!options->interactive &&
289             options->argc > 0 && 
290             strchr(options->argv[0], '=')) {
291                 expression = options->argv[0];
292                 options->argv++;
293                 options->argc--;
294         }
295
296         if (options->argc > 0) {
297                 attrs = (const char * const *)(options->argv);
298         }
299
300         if (options->basedn != NULL) {
301                 basedn = ldb_dn_new(ldb, ldb, options->basedn);
302                 if ( ! ldb_dn_validate(basedn)) {
303                         fprintf(stderr, "Invalid Base DN format\n");
304                         exit(1);
305                 }
306         }
307
308         if (options->interactive) {
309                 char line[1024];
310                 while (fgets(line, sizeof(line), stdin)) {
311                         if (do_search(ldb, basedn, options, line, attrs) == -1) {
312                                 ret = -1;
313                         }
314                 }
315         } else {
316                 ret = do_search(ldb, basedn, options, expression, attrs);
317         }
318
319         talloc_free(ldb);
320         return ret;
321 }