This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
+ version 3 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* Author: Andrew Tridgell
*/
-#include "includes.h"
-#include "ldb/include/includes.h"
-#include "ldb/tools/cmdline.h"
+#include "ldb_includes.h"
+#include "tools/cmdline.h"
static void usage(void)
{
struct ldb_message **el2,
void *opaque)
{
- struct ldb_context *ldb = talloc_get_type(opaque, struct ldb_context);
- return ldb_dn_compare(ldb, (*el1)->dn, (*el2)->dn);
+ return ldb_dn_compare((*el1)->dn, (*el2)->dn);
}
-static struct ldb_control **parse_controls(void *mem_ctx, char **control_strings)
-{
- int i;
- struct ldb_control **ctrl;
-
- if (control_strings == NULL || control_strings[0] == NULL)
- return NULL;
-
- for (i = 0; control_strings[i]; i++);
-
- ctrl = talloc_array(mem_ctx, struct ldb_control *, i + 1);
+struct search_context {
+ struct ldb_control **req_ctrls;
- for (i = 0; control_strings[i]; i++) {
- if (strncmp(control_strings[i], "extended_dn:", 12) == 0) {
- struct ldb_extended_dn_control *control;
- const char *p;
- int crit, type, ret;
+ int sort;
+ int num_stored;
+ struct ldb_message **store;
+ char **refs_store;
- p = &(control_strings[i][12]);
- ret = sscanf(p, "%d:%d", &crit, &type);
- if ((ret != 2) || (crit < 0) || (crit > 1) || (type < 0) || (type > 1)) {
- fprintf(stderr, "invalid extended_dn control syntax\n");
- return NULL;
- }
+ int entries;
+ int refs;
- ctrl[i] = talloc(ctrl, struct ldb_control);
- ctrl[i]->oid = LDB_CONTROL_EXTENDED_DN_OID;
- ctrl[i]->critical = crit;
- control = talloc(ctrl[i], struct ldb_extended_dn_control);
- control->type = type;
- ctrl[i]->data = control;
+ int pending;
+ int status;
+};
- continue;
- }
+static int store_message(struct ldb_message *msg, struct search_context *sctx) {
- if (strncmp(control_strings[i], "paged_results:", 14) == 0) {
- struct ldb_paged_control *control;
- const char *p;
- int crit, size, ret;
-
- p = &(control_strings[i][14]);
- ret = sscanf(p, "%d:%d", &crit, &size);
-
- if ((ret != 2) || (crit < 0) || (crit > 1) || (size < 0)) {
- fprintf(stderr, "invalid paged_results control syntax\n");
- return NULL;
- }
+ sctx->store = talloc_realloc(sctx, sctx->store, struct ldb_message *, sctx->num_stored + 2);
+ if (!sctx->store) {
+ fprintf(stderr, "talloc_realloc failed while storing messages\n");
+ return -1;
+ }
- ctrl[i] = talloc(ctrl, struct ldb_control);
- ctrl[i]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
- ctrl[i]->critical = crit;
- control = talloc(ctrl[i], struct ldb_paged_control);
- control->size = size;
- control->cookie = NULL;
- control->cookie_len = 0;
- ctrl[i]->data = control;
+ sctx->store[sctx->num_stored] = talloc_move(sctx->store, &msg);
+ sctx->num_stored++;
+ sctx->store[sctx->num_stored] = NULL;
- continue;
- }
+ return 0;
+}
- if (strncmp(control_strings[i], "server_sort:", 12) == 0) {
- struct ldb_server_sort_control **control;
- const char *p;
- char attr[256];
- char rule[128];
- int crit, rev, ret;
-
- attr[0] = '\0';
- rule[0] = '\0';
- p = &(control_strings[i][12]);
- ret = sscanf(p, "%d:%d:%255[^:]:%127[^:]", &crit, &rev, attr, rule);
- if ((ret < 3) || (crit < 0) || (crit > 1) || (rev < 0 ) || (rev > 1) ||attr[0] == '\0') {
- fprintf(stderr, "invalid server_sort control syntax\n");
- return NULL;
- }
- ctrl[i] = talloc(ctrl, struct ldb_control);
- ctrl[i]->oid = LDB_CONTROL_SERVER_SORT_OID;
- ctrl[i]->critical = crit;
- control = talloc_array(ctrl[i], struct ldb_server_sort_control *, 2);
- control[0] = talloc(control, struct ldb_server_sort_control);
- control[0]->attributeName = talloc_strdup(control, attr);
- if (rule[0])
- control[0]->orderingRule = talloc_strdup(control, rule);
- else
- control[0]->orderingRule = NULL;
- control[0]->reverse = rev;
- control[1] = NULL;
- ctrl[i]->data = control;
-
- continue;
- }
+static int store_referral(char *referral, struct search_context *sctx) {
- /* no controls matched, throw an error */
- fprintf(stderr, "Invalid control name\n");
- return NULL;
+ sctx->refs_store = talloc_realloc(sctx, sctx->refs_store, char *, sctx->refs + 2);
+ if (!sctx->refs_store) {
+ fprintf(stderr, "talloc_realloc failed while storing referrals\n");
+ return -1;
}
- ctrl[i] = NULL;
+ sctx->refs_store[sctx->refs] = talloc_move(sctx->refs_store, &referral);
+ sctx->refs++;
+ sctx->refs_store[sctx->refs] = NULL;
- return ctrl;
+ return 0;
}
-/* this function check controls reply and determines if more
- * processing is needed setting up the request controls correctly
- *
- * returns:
- * -1 error
- * 0 all ok
- * 1 all ok, more processing required
- */
-static int handle_controls_reply(struct ldb_control **reply, struct ldb_control **request)
-{
- int i, j;
- int ret = 0;
+static int display_message(struct ldb_context *ldb, struct ldb_message *msg, struct search_context *sctx) {
+ struct ldb_ldif ldif;
- if (reply == NULL || request == NULL) return -1;
-
- for (i = 0; reply[i]; i++) {
- if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, reply[i]->oid) == 0) {
- struct ldb_paged_control *rep_control, *req_control;
+ sctx->entries++;
+ printf("# record %d\n", sctx->entries);
- rep_control = talloc_get_type(reply[i]->data, struct ldb_paged_control);
- if (rep_control->cookie_len == 0) /* we are done */
- break;
+ ldif.changetype = LDB_CHANGETYPE_NONE;
+ ldif.msg = msg;
- /* more processing required */
- /* let's fill in the request control with the new cookie */
+ if (sctx->sort) {
+ /*
+ * Ensure attributes are always returned in the same
+ * order. For testing, this makes comparison of old
+ * vs. new much easier.
+ */
+ ldb_msg_sort_elements(ldif.msg);
+ }
- for (j = 0; request[j]; j++) {
- if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, request[j]->oid) == 0)
- break;
- }
- /* if there's a reply control we must find a request
- * control matching it */
- if (! request[j]) return -1;
+ ldb_ldif_write_file(ldb, stdout, &ldif);
- req_control = talloc_get_type(request[j]->data, struct ldb_paged_control);
-
- if (req_control->cookie)
- talloc_free(req_control->cookie);
- req_control->cookie = talloc_memdup(req_control,
- rep_control->cookie,
- rep_control->cookie_len);
- req_control->cookie_len = rep_control->cookie_len;
+ return 0;
+}
- ret = 1;
+static int display_referral(char *referral, struct search_context *sctx)
+{
- continue;
- }
+ sctx->refs++;
+ printf("# Referral\nref: %s\n\n", referral);
- if (strcmp(LDB_CONTROL_SORT_RESP_OID, reply[i]->oid) == 0) {
- struct ldb_sort_resp_control *rep_control;
+ return 0;
+}
- rep_control = talloc_get_type(reply[i]->data, struct ldb_sort_resp_control);
+static int search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+{
+ struct search_context *sctx = talloc_get_type(context, struct search_context);
+ int ret;
+
+ switch (ares->type) {
- /* check we have a matching control in the request */
- for (j = 0; request[j]; j++) {
- if (strcmp(LDB_CONTROL_SERVER_SORT_OID, request[j]->oid) == 0)
- break;
- }
- if (! request[j]) {
- fprintf(stderr, "Warning Server Sort reply received but no request found\n");
- continue;
- }
+ case LDB_REPLY_ENTRY:
+ if (sctx->sort) {
+ ret = store_message(ares->message, sctx);
+ } else {
+ ret = display_message(ldb, ares->message, sctx);
+ }
+ break;
- /* check the result */
- if (rep_control->result != 0) {
- fprintf(stderr, "Warning: Sorting not performed with error: %d\n", rep_control->result);
- }
+ case LDB_REPLY_REFERRAL:
+ if (sctx->sort) {
+ ret = store_referral(ares->referral, sctx);
+ } else {
+ ret = display_referral(ares->referral, sctx);
+ }
+ break;
- continue;
+ case LDB_REPLY_DONE:
+ if (ares->controls) {
+ if (handle_controls_reply(ares->controls, sctx->req_ctrls) == 1)
+ sctx->pending = 1;
}
+ ret = 0;
+ break;
+
+ default:
+ fprintf(stderr, "unknown Reply Type\n");
+ return LDB_ERR_OTHER;
+ }
- /* no controls matched, throw a warning */
- fprintf(stderr, "Unknown reply control oid: %s\n", reply[i]->oid);
+ if (talloc_free(ares) == -1) {
+ fprintf(stderr, "talloc_free failed\n");
+ sctx->pending = 0;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
-}
+ if (ret) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ return LDB_SUCCESS;
+}
static int do_search(struct ldb_context *ldb,
- const struct ldb_dn *basedn,
+ struct ldb_dn *basedn,
struct ldb_cmdline *options,
const char *expression,
const char * const *attrs)
{
- int ret, i;
- int loop = 0;
- int total = 0;
- struct ldb_request req;
- struct ldb_result *result = NULL;
-
- req.operation = LDB_REQ_SEARCH;
- req.op.search.base = basedn;
- req.op.search.scope = options->scope;
- req.op.search.tree = ldb_parse_tree(ldb, expression);
- req.op.search.attrs = attrs;
- req.op.search.res = NULL;
- req.controls = parse_controls(ldb, options->controls);
- if (options->controls != NULL && req.controls == NULL) return -1;
- req.creds = NULL;
-
- do {
- loop = 0;
-
- ret = ldb_request(ldb, &req);
- if (ret != LDB_SUCCESS) {
- printf("search failed - %s\n", ldb_errstring(ldb));
- return -1;
- }
+ struct ldb_request *req;
+ struct search_context *sctx;
+ int ret;
- result = req.op.search.res;
- printf("# returned %d records\n", result->count);
+ req = talloc(ldb, struct ldb_request);
+ if (!req) return -1;
+
+ sctx = talloc(req, struct search_context);
+ if (!sctx) return -1;
+
+ sctx->sort = options->sorted;
+ sctx->num_stored = 0;
+ sctx->store = NULL;
+ sctx->req_ctrls = ldb_parse_control_strings(ldb, sctx, (const char **)options->controls);
+ if (options->controls != NULL && sctx->req_ctrls== NULL) {
+ printf("parsing controls failed: %s\n", ldb_errstring(ldb));
+ return -1;
+ }
+ sctx->entries = 0;
+ sctx->refs = 0;
- if (options->sorted) {
- ldb_qsort(result->msgs, ret, sizeof(struct ldb_message *),
- ldb, (ldb_qsort_cmp_fn_t)do_compare_msg);
- }
+ if (basedn == NULL) {
+ basedn = ldb_get_default_basedn(ldb);
+ }
- for (i = 0; i < result->count; i++, total++) {
- struct ldb_ldif ldif;
- printf("# record %d\n", total + 1);
-
- ldif.changetype = LDB_CHANGETYPE_NONE;
- ldif.msg = result->msgs[i];
-
- if (options->sorted) {
- /*
- * Ensure attributes are always returned in the same
- * order. For testing, this makes comparison of old
- * vs. new much easier.
- */
- ldb_msg_sort_elements(ldif.msg);
- }
-
- ldb_ldif_write_file(ldb, stdout, &ldif);
+ req->operation = LDB_SEARCH;
+ req->op.search.base = basedn;
+ req->op.search.scope = options->scope;
+ req->op.search.tree = ldb_parse_tree(req, expression);
+ if (req->op.search.tree == NULL) return -1;
+ req->op.search.attrs = attrs;
+ req->controls = sctx->req_ctrls;
+ req->context = sctx;
+ req->callback = &search_callback;
+ ldb_set_timeout(ldb, req, 0); /* TODO: make this settable by command line */
+
+again:
+ sctx->pending = 0;
+
+ ret = ldb_request(ldb, req);
+ if (ret != LDB_SUCCESS) {
+ printf("search failed - %s\n", ldb_errstring(ldb));
+ return -1;
+ }
+
+ ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+ if (ret != LDB_SUCCESS) {
+ printf("search error - %s\n", ldb_errstring(ldb));
+ return -1;
+ }
+
+ if (sctx->pending)
+ goto again;
+
+ if (sctx->sort && (sctx->num_stored != 0 || sctx->refs != 0)) {
+ int i;
+
+ ldb_qsort(sctx->store, sctx->num_stored, sizeof(struct ldb_message *),
+ ldb, (ldb_qsort_cmp_fn_t)do_compare_msg);
+
+ if (ret != 0) {
+ fprintf(stderr, "An error occurred while sorting messages\n");
+ exit(1);
}
- if (result->controls) {
- if (handle_controls_reply(result->controls, req.controls) == 1)
- loop = 1;
+ for (i = 0; i < sctx->num_stored; i++) {
+ display_message(ldb, sctx->store[i], sctx);
}
- if (result) {
- ret = talloc_free(result);
- if (ret == -1) {
- fprintf(stderr, "talloc_free failed\n");
- exit(1);
- }
+ for (i = 0; i < sctx->refs; i++) {
+ display_referral(sctx->refs_store[i], sctx);
}
+ }
- req.op.search.res = NULL;
-
- } while(loop);
+ printf("# returned %d records\n# %d entries\n# %d referrals\n",
+ sctx->entries + sctx->refs, sctx->entries, sctx->refs);
+
+ talloc_free(req);
return 0;
}
- int main(int argc, const char **argv)
+int main(int argc, const char **argv)
{
struct ldb_context *ldb;
struct ldb_dn *basedn = NULL;
int ret = -1;
const char *expression = "(|(objectClass=*)(distinguishedName=*))";
+ ldb_global_init();
+
ldb = ldb_init(NULL);
options = ldb_cmdline_process(ldb, argc, argv, usage);
}
if (options->basedn != NULL) {
- basedn = ldb_dn_explode(ldb, options->basedn);
- if (basedn == NULL) {
+ basedn = ldb_dn_new(ldb, ldb, options->basedn);
+ if ( ! ldb_dn_validate(basedn)) {
fprintf(stderr, "Invalid Base DN format\n");
exit(1);
}