lib/tdb_wrap: use tdb directly, not tdb_compat.
[kai/samba.git] / source4 / ntvfs / posix / posix_eadb.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - xattr support using a tdb
5
6    Copyright (C) Andrew Tridgell 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 #include "includes.h"
23 #include "lib/tdb_wrap/tdb_wrap.h"
24 #include "vfs_posix.h"
25 #include "posix_eadb.h"
26
27 #define XATTR_LIST_ATTR ".xattr_list"
28
29 /*
30   we need to maintain a list of attributes on each file, so that unlink
31   can automatically clean them up
32 */
33 static NTSTATUS posix_eadb_add_list(struct tdb_wrap *ea_tdb, TALLOC_CTX *ctx, const char *attr_name,
34                                    const char *fname, int fd)
35 {
36         DATA_BLOB blob;
37         TALLOC_CTX *mem_ctx;
38         const char *s;
39         NTSTATUS status;
40         size_t len;
41
42         if (strcmp(attr_name, XATTR_LIST_ATTR) == 0) {
43                 return NT_STATUS_OK;
44         }
45
46         mem_ctx = talloc_new(ctx);
47
48         status = pull_xattr_blob_tdb_raw(ea_tdb, mem_ctx, XATTR_LIST_ATTR,
49                                      fname, fd, 100, &blob);
50         if (!NT_STATUS_IS_OK(status)) {
51                 blob = data_blob(NULL, 0);
52         }
53
54         for (s=(const char *)blob.data; s < (const char *)(blob.data+blob.length); s += strlen(s) + 1) {
55                 if (strcmp(attr_name, s) == 0) {
56                         talloc_free(mem_ctx);
57                         return NT_STATUS_OK;
58                 }
59         }
60
61         len = strlen(attr_name) + 1;
62
63         blob.data = talloc_realloc(mem_ctx, blob.data, uint8_t, blob.length + len);
64         if (blob.data == NULL) {
65                 talloc_free(mem_ctx);
66                 return NT_STATUS_NO_MEMORY;
67         }
68         memcpy(blob.data + blob.length, attr_name, len);
69         blob.length += len;
70
71         status = push_xattr_blob_tdb_raw(ea_tdb, XATTR_LIST_ATTR, fname, fd, &blob);
72         talloc_free(mem_ctx);
73
74         return status;
75 }
76
77 /*
78   form a key for using in the ea_tdb
79 */
80 static NTSTATUS get_ea_tdb_key(TALLOC_CTX *mem_ctx,
81                               const char *attr_name,
82                               const char *fname, int fd,
83                               TDB_DATA *key)
84 {
85         struct stat st;
86         size_t len = strlen(attr_name);
87
88         if (fd == -1) {
89                 if (stat(fname, &st) == -1) {
90                         return NT_STATUS_NOT_FOUND;
91                 }
92         } else {
93                 if (fstat(fd, &st) == -1) {
94                         return NT_STATUS_NOT_FOUND;
95                 }
96         }
97
98         key->dptr = talloc_array(mem_ctx, uint8_t, 16 + len);
99         if (key->dptr == NULL) {
100                 return NT_STATUS_NO_MEMORY;
101         }
102         key->dsize = 16 + len;
103
104         SBVAL(key->dptr, 0, st.st_dev);
105         SBVAL(key->dptr, 8, st.st_ino);
106         memcpy(key->dptr+16, attr_name, len);
107
108         return NT_STATUS_OK;
109 }
110
111
112
113 /*
114   pull a xattr as a blob, using the ea_tdb_context tdb
115 */
116 NTSTATUS pull_xattr_blob_tdb_raw(struct tdb_wrap *ea_tdb,
117                              TALLOC_CTX *mem_ctx,
118                              const char *attr_name,
119                              const char *fname,
120                              int fd,
121                              size_t estimated_size,
122                              DATA_BLOB *blob)
123 {
124         TDB_DATA tkey, tdata;
125         NTSTATUS status;
126
127         status = get_ea_tdb_key(mem_ctx, attr_name, fname, fd, &tkey);
128         if (!NT_STATUS_IS_OK(status)) {
129                 return status;
130         }
131
132         tdata = tdb_fetch(ea_tdb->tdb, tkey);
133         if (tdata.dptr == NULL) {
134                 return NT_STATUS_NOT_FOUND;
135         }
136
137         *blob = data_blob_talloc(mem_ctx, tdata.dptr, tdata.dsize);
138         free(tdata.dptr);
139         if (blob->data == NULL) {
140                 return NT_STATUS_NO_MEMORY;
141         }
142
143         return NT_STATUS_OK;
144 }
145
146 NTSTATUS pull_xattr_blob_tdb(struct pvfs_state *pvfs_state,
147                              TALLOC_CTX *mem_ctx,
148                              const char *attr_name,
149                              const char *fname,
150                              int fd,
151                              size_t estimated_size,
152                              DATA_BLOB *blob)
153 {
154         return pull_xattr_blob_tdb_raw(pvfs_state->ea_db,mem_ctx,attr_name,fname,fd,estimated_size,blob);
155 }
156
157 /*
158   push a xattr as a blob, using ea_tdb
159 */
160 NTSTATUS push_xattr_blob_tdb_raw(struct tdb_wrap *ea_tdb,
161                              const char *attr_name,
162                              const char *fname,
163                              int fd,
164                              const DATA_BLOB *blob)
165 {
166         TDB_DATA tkey, tdata;
167         NTSTATUS status;
168         TALLOC_CTX *mem_ctx = talloc_new(ea_tdb);
169         if (!mem_ctx) {
170                 return NT_STATUS_NO_MEMORY;
171         }
172
173         status = get_ea_tdb_key(mem_ctx, attr_name, fname, fd, &tkey);
174         if (!NT_STATUS_IS_OK(status)) {
175                 talloc_free(mem_ctx);
176                 return status;
177         }
178
179         tdata.dptr = blob->data;
180         tdata.dsize = blob->length;
181
182         if (tdb_chainlock(ea_tdb->tdb, tkey) != 0) {
183                 talloc_free(mem_ctx);
184                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
185         }
186
187         status = posix_eadb_add_list(ea_tdb,mem_ctx, attr_name, fname, fd);
188         if (!NT_STATUS_IS_OK(status)) {
189                 talloc_free(mem_ctx);
190                 goto done;
191         }
192
193         if (tdb_store(ea_tdb->tdb, tkey, tdata, TDB_REPLACE) != 0) {
194                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
195         }
196
197 done:
198         tdb_chainunlock(ea_tdb->tdb, tkey);
199         talloc_free(mem_ctx);
200         return status;
201 }
202 NTSTATUS push_xattr_blob_tdb(struct pvfs_state *pvfs_state,
203                              const char *attr_name,
204                              const char *fname,
205                              int fd,
206                              const DATA_BLOB *blob)
207 {
208         return push_xattr_blob_tdb_raw(pvfs_state->ea_db, attr_name, fname, fd, blob);
209 }
210
211
212 /*
213   delete a xattr
214 */
215 NTSTATUS delete_posix_eadb_raw(struct tdb_wrap *ea_tdb, const char *attr_name,
216                           const char *fname, int fd)
217 {
218         TDB_DATA tkey;
219         NTSTATUS status;
220
221         status = get_ea_tdb_key(NULL, attr_name, fname, fd, &tkey);
222         if (!NT_STATUS_IS_OK(status)) {
223                 return status;
224         }
225
226         if (tdb_delete(ea_tdb->tdb, tkey) != 0) {
227                 talloc_free(tkey.dptr);
228                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
229         }
230
231         talloc_free(tkey.dptr);
232         return NT_STATUS_OK;
233 }
234
235
236 /*
237   delete a xattr
238 */
239 NTSTATUS delete_posix_eadb(struct pvfs_state *pvfs_state, const char *attr_name,
240                           const char *fname, int fd)
241 {
242         return delete_posix_eadb_raw(pvfs_state->ea_db,
243                                     attr_name, fname, fd);
244 }
245
246
247 /*
248   delete all xattrs for a file
249 */
250 NTSTATUS unlink_posix_eadb_raw(struct tdb_wrap *ea_tdb, const char *fname, int fd)
251 {
252         TALLOC_CTX *mem_ctx = talloc_new(ea_tdb);
253         DATA_BLOB blob;
254         const char *s;
255         NTSTATUS status;
256
257         status = pull_xattr_blob_tdb_raw(ea_tdb, mem_ctx, XATTR_LIST_ATTR,
258                                      fname, fd, 100, &blob);
259         if (!NT_STATUS_IS_OK(status)) {
260                 talloc_free(mem_ctx);
261                 return NT_STATUS_OK;
262         }
263
264         for (s=(const char *)blob.data; s < (const char *)(blob.data+blob.length); s += strlen(s) + 1) {
265                 delete_posix_eadb_raw(ea_tdb, s, fname, -1);
266         }
267
268         status = delete_posix_eadb_raw(ea_tdb, XATTR_LIST_ATTR, fname, fd);
269         talloc_free(mem_ctx);
270         return status;
271 }
272
273 /*
274   delete all xattrs for a file
275 */
276 NTSTATUS unlink_posix_eadb(struct pvfs_state *pvfs_state, const char *fname)
277 {
278         return unlink_posix_eadb_raw(pvfs_state->ea_db, fname, -1);
279 }
280
281 /*
282   list all xattrs for a file
283 */
284 NTSTATUS list_posix_eadb_raw(struct tdb_wrap *ea_tdb, TALLOC_CTX *mem_ctx,
285                             const char *fname, int fd,
286                             DATA_BLOB *list)
287 {
288         return pull_xattr_blob_tdb_raw(ea_tdb, mem_ctx, XATTR_LIST_ATTR,
289                                      fname, fd, 100, list);
290 }