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