On advice from Jelmer and Andrew, move the blksize_t and blkcnt_t tests into librepla...
[kai/samba.git] / lib / ldb / tools / ldbutil.c
1 /*
2    ldb database library utility
3
4    Copyright (C) Matthieu Patou 2009
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  *  Description: Common function used by ldb_add/ldb_modify/ldb_delete
28  *
29  *  Author: Matthieu Patou
30  */
31
32 #include "ldb.h"
33 #include "ldb_module.h"
34 #include "ldbutil.h"
35
36
37 /* autostarts a transacion if none active */
38 static int ldb_do_autotransaction(struct ldb_context *ldb,
39                                        struct ldb_request *req)
40 {
41         int ret;
42
43         ret = ldb_transaction_start(ldb);
44         if (ret != LDB_SUCCESS) {
45                 return ret;
46         }
47
48         ret = ldb_request(ldb, req);
49         if (ret == LDB_SUCCESS) {
50                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
51         }
52
53         if (ret == LDB_SUCCESS) {
54                 return ldb_transaction_commit(ldb);
55         }
56         ldb_transaction_cancel(ldb);
57
58         if (ldb_errstring(ldb) == NULL) {
59                 /* no error string was setup by the backend */
60                 ldb_asprintf_errstring(ldb, "%s (%d)", ldb_strerror(ret), ret);
61         }
62
63         return ret;
64 }
65 /*
66   Same as ldb_add but accept control
67 */
68 int ldb_add_ctrl(struct ldb_context *ldb,
69                 const struct ldb_message *message,
70                 struct ldb_control **controls, bool do_transaction)
71 {
72         struct ldb_request *req;
73         int ret;
74
75         ret = ldb_msg_sanity_check(ldb, message);
76         if (ret != LDB_SUCCESS) {
77                 return ret;
78         }
79
80         ret = ldb_build_add_req(&req, ldb, ldb,
81                                         message,
82                                         controls,
83                                         NULL,
84                                         ldb_op_default_callback,
85                                         NULL);
86
87         if (ret != LDB_SUCCESS) return ret;
88
89         /* do request and autostart a transaction */
90         if (do_transaction)
91                 ret = ldb_do_autotransaction(ldb, req);
92
93         talloc_free(req);
94         return ret;
95 }
96
97 /*
98   same as ldb_delete but accept control
99 */
100 int ldb_delete_ctrl(struct ldb_context *ldb, struct ldb_dn *dn,
101                 struct ldb_control **controls, bool do_transaction)
102 {
103         struct ldb_request *req;
104         int ret;
105
106         ret = ldb_build_del_req(&req, ldb, ldb,
107                                         dn,
108                                         controls,
109                                         NULL,
110                                         ldb_op_default_callback,
111                                         NULL);
112
113         if (ret != LDB_SUCCESS) return ret;
114
115         /* do request and autostart a transaction */
116         if (do_transaction)
117                 ret = ldb_do_autotransaction(ldb, req);
118
119         talloc_free(req);
120         return ret;
121 }
122
123
124 /*
125   same as ldb_modify, but accepts controls
126 */
127 int ldb_modify_ctrl(struct ldb_context *ldb,
128                     const struct ldb_message *message,
129                     struct ldb_control **controls, bool do_transaction)
130 {
131         struct ldb_request *req;
132         int ret;
133
134         ret = ldb_msg_sanity_check(ldb, message);
135         if (ret != LDB_SUCCESS) {
136                 return ret;
137         }
138
139         ret = ldb_build_mod_req(&req, ldb, ldb,
140                                         message,
141                                         controls,
142                                         NULL,
143                                         ldb_op_default_callback,
144                                         NULL);
145
146         if (ret != LDB_SUCCESS) return ret;
147
148         /* do request and autostart a transaction */
149         if (do_transaction)
150                 ret = ldb_do_autotransaction(ldb, req);
151
152         talloc_free(req);
153         return ret;
154 }
155
156
157 /*
158   ldb_search with controls
159 */
160 int ldb_search_ctrl(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
161                     struct ldb_result **result, struct ldb_dn *base,
162                     enum ldb_scope scope, const char * const *attrs,
163                     struct ldb_control **controls,
164                     const char *exp_fmt, ...)
165 {
166         struct ldb_request *req;
167         struct ldb_result *res;
168         char *expression;
169         va_list ap;
170         int ret;
171
172         expression = NULL;
173         *result = NULL;
174         req = NULL;
175
176         res = talloc_zero(mem_ctx, struct ldb_result);
177         if (!res) {
178                 return LDB_ERR_OPERATIONS_ERROR;
179         }
180
181         if (exp_fmt) {
182                 va_start(ap, exp_fmt);
183                 expression = talloc_vasprintf(mem_ctx, exp_fmt, ap);
184                 va_end(ap);
185
186                 if (!expression) {
187                         talloc_free(res);
188                         return LDB_ERR_OPERATIONS_ERROR;
189                 }
190         }
191
192         ret = ldb_build_search_req(&req, ldb, mem_ctx,
193                                    base?base:ldb_get_default_basedn(ldb),
194                                    scope,
195                                    expression,
196                                    attrs,
197                                    controls,
198                                    res,
199                                    ldb_search_default_callback,
200                                    NULL);
201         ldb_req_set_location(req, "ldb_search_ctrl");
202
203         if (ret != LDB_SUCCESS) goto done;
204
205         ret = ldb_request(ldb, req);
206
207         if (ret == LDB_SUCCESS) {
208                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
209         }
210
211 done:
212         if (ret != LDB_SUCCESS) {
213                 talloc_free(res);
214                 res = NULL;
215         }
216
217         talloc_free(expression);
218         talloc_free(req);
219
220         *result = res;
221         return ret;
222 }