Fix bug #6195 - Migrating from 3.0.x to 3.3.x can fail to update passdb.tdb correctly...
[ira/wip.git] / source3 / lib / dbwrap.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Database interface wrapper
4    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
5
6    Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
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 #include "includes.h"
23 #ifdef CLUSTER_SUPPORT
24 #include "ctdb_private.h"
25 #endif
26 /*
27  * Fall back using fetch_locked if no genuine fetch operation is provided
28  */
29
30 static int dbwrap_fallback_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
31                                  TDB_DATA key, TDB_DATA *data)
32 {
33         struct db_record *rec;
34
35         if (!(rec = db->fetch_locked(db, mem_ctx, key))) {
36                 return -1;
37         }
38
39         data->dsize = rec->value.dsize;
40         data->dptr = talloc_move(mem_ctx, &rec->value.dptr);
41         TALLOC_FREE(rec);
42         return 0;
43 }
44
45 /*
46  * Fall back using fetch if no genuine parse operation is provided
47  */
48
49 static int dbwrap_fallback_parse_record(struct db_context *db, TDB_DATA key,
50                                         int (*parser)(TDB_DATA key,
51                                                       TDB_DATA data,
52                                                       void *private_data),
53                                         void *private_data)
54 {
55         TDB_DATA data;
56         int res;
57
58         res = db->fetch(db, talloc_tos(), key, &data);
59         if (res != 0) {
60                 return res;
61         }
62
63         res = parser(key, data, private_data);
64         TALLOC_FREE(data.dptr);
65         return res;
66 }
67
68 bool db_is_local(const char *name)
69 {
70 #ifdef CLUSTER_SUPPORT
71         const char *sockname = lp_ctdbd_socket();
72
73         if(!sockname || !*sockname) {
74                 sockname = CTDB_PATH;
75         }
76
77         if (lp_clustering() && socket_exist(sockname)) {
78                 const char *partname;
79                 /* ctdb only wants the file part of the name */
80                 partname = strrchr(name, '/');
81                 if (partname) {
82                         partname++;
83                 } else {
84                         partname = name;
85                 }
86                 /* allow ctdb for individual databases to be disabled */
87                 if (lp_parm_bool(-1, "ctdb", partname, True)) {
88                         return false;
89                 }
90         }
91 #endif
92         return true;
93 }
94
95 /**
96  * open a database
97  */
98 struct db_context *db_open(TALLOC_CTX *mem_ctx,
99                            const char *name,
100                            int hash_size, int tdb_flags,
101                            int open_flags, mode_t mode)
102 {
103         struct db_context *result = NULL;
104 #ifdef CLUSTER_SUPPORT
105         const char *sockname = lp_ctdbd_socket();
106 #endif
107
108 #ifdef CLUSTER_SUPPORT
109         if(!sockname || !*sockname) {
110                 sockname = CTDB_PATH;
111         }
112
113         if (lp_clustering()) {
114                 const char *partname;
115
116                 if (!socket_exist(sockname)) {
117                         DEBUG(1, ("ctdb socket does not exist - is ctdb not "
118                                   "running?\n"));
119                         return NULL;
120                 }
121
122                 /* ctdb only wants the file part of the name */
123                 partname = strrchr(name, '/');
124                 if (partname) {
125                         partname++;
126                 } else {
127                         partname = name;
128                 }
129                 /* allow ctdb for individual databases to be disabled */
130                 if (lp_parm_bool(-1, "ctdb", partname, True)) {
131                         result = db_open_ctdb(mem_ctx, partname, hash_size,
132                                               tdb_flags, open_flags, mode);
133                         if (result == NULL) {
134                                 DEBUG(0,("failed to attach to ctdb %s\n",
135                                          partname));
136                                 if (errno == 0) {
137                                         errno = EIO;
138                                 }
139                                 return NULL;
140                         }
141                 }
142         }
143
144 #endif
145
146         if (result == NULL) {
147                 result = db_open_tdb(mem_ctx, name, hash_size,
148                                      tdb_flags, open_flags, mode);
149         }
150
151         if ((result != NULL) && (result->fetch == NULL)) {
152                 result->fetch = dbwrap_fallback_fetch;
153         }
154         if ((result != NULL) && (result->parse_record == NULL)) {
155                 result->parse_record = dbwrap_fallback_parse_record;
156         }
157
158         return result;
159 }
160
161 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
162 {
163         struct db_record *rec;
164         NTSTATUS status;
165
166         rec = db->fetch_locked(db, talloc_tos(), key);
167         if (rec == NULL) {
168                 return NT_STATUS_NO_MEMORY;
169         }
170         status = rec->delete_rec(rec);
171         TALLOC_FREE(rec);
172         return status;
173 }
174
175 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
176                       TDB_DATA data, int flags)
177 {
178         struct db_record *rec;
179         NTSTATUS status;
180
181         rec = db->fetch_locked(db, talloc_tos(), key);
182         if (rec == NULL) {
183                 return NT_STATUS_NO_MEMORY;
184         }
185
186         status = rec->store(rec, data, flags);
187         TALLOC_FREE(rec);
188         return status;
189 }
190
191 TDB_DATA dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
192                       TDB_DATA key)
193 {
194         TDB_DATA result;
195
196         if (db->fetch(db, mem_ctx, key, &result) == -1) {
197                 return make_tdb_data(NULL, 0);
198         }
199
200         return result;
201 }
202
203 NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
204 {
205         return dbwrap_delete(db, string_term_tdb_data(key));
206 }
207
208 NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
209                                TDB_DATA data, int flags)
210 {
211         return dbwrap_store(db, string_term_tdb_data(key), data, flags);
212 }
213
214 TDB_DATA dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx,
215                                const char *key)
216 {
217         return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key));
218 }
219