2 Samba share mode database library external interface library.
3 Used by non-Samba products needing access to the Samba share mode db.
5 Copyright (C) Jeremy Allison 2005 - 2006
7 sharemodes_procid functions (C) Copyright (C) Volker Lendecke 2005
9 ** NOTE! The following LGPL license applies to this module only.
10 ** This does NOT imply that all of Samba is released
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 2 of the License, or (at your option) any later version.
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include "smb_share_modes.h"
31 /* Remove the paranoid malloc checker. */
36 static BOOL
sharemodes_procid_equal(const struct process_id
*p1
, const struct process_id
*p2
)
38 return (p1
->pid
== p2
->pid
);
41 static pid_t
sharemodes_procid_to_pid(const struct process_id
*proc
)
47 * open/close sharemode database.
50 struct smbdb_ctx
*smb_share_mode_db_open(const char *db_path
)
52 struct smbdb_ctx
*smb_db
= (struct smbdb_ctx
*)malloc(sizeof(struct smbdb_ctx
));
58 memset(smb_db
, '\0', sizeof(struct smbdb_ctx
));
60 smb_db
->smb_tdb
= tdb_open(db_path
,
61 0, TDB_DEFAULT
|TDB_CLEAR_IF_FIRST
,
65 if (!smb_db
->smb_tdb
) {
70 /* Should check that this is the correct version.... */
74 /* key and data records in the tdb locking database */
80 int smb_share_mode_db_close(struct smbdb_ctx
*db_ctx
)
82 int ret
= tdb_close(db_ctx
->smb_tdb
);
87 static TDB_DATA
get_locking_key(uint64_t dev
, uint64_t ino
)
89 static struct locking_key lk
;
92 memset(&lk
, '\0', sizeof(struct locking_key
));
93 lk
.dev
= (SMB_DEV_T
)dev
;
94 lk
.inode
= (SMB_INO_T
)ino
;
95 ld
.dptr
= (char *)&lk
;
96 ld
.dsize
= sizeof(lk
);
101 * lock/unlock entry in sharemode database.
104 int smb_lock_share_mode_entry(struct smbdb_ctx
*db_ctx
,
108 return tdb_chainlock(db_ctx
->smb_tdb
, get_locking_key(dev
, ino
));
111 int smb_unlock_share_mode_entry(struct smbdb_ctx
*db_ctx
,
115 return tdb_chainunlock(db_ctx
->smb_tdb
, get_locking_key(dev
, ino
));
119 * Check if an external smb_share_mode_entry and an internal share_mode entry match.
122 static int share_mode_entry_equal(const struct smb_share_mode_entry
*e_entry
,
123 const struct share_mode_entry
*entry
)
125 return (sharemodes_procid_equal(&e_entry
->pid
, &entry
->pid
) &&
126 e_entry
->file_id
== (uint32_t)entry
->share_file_id
&&
127 e_entry
->open_time
.tv_sec
== entry
->time
.tv_sec
&&
128 e_entry
->open_time
.tv_usec
== entry
->time
.tv_usec
&&
129 e_entry
->share_access
== (uint32_t)entry
->share_access
&&
130 e_entry
->access_mask
== (uint32_t)entry
->access_mask
&&
131 e_entry
->dev
== (uint64_t)entry
->dev
&&
132 e_entry
->ino
== (uint64_t)entry
->inode
);
136 * Create an internal Samba share_mode entry from an external smb_share_mode_entry.
139 static void create_share_mode_entry(struct share_mode_entry
*out
,
140 const struct smb_share_mode_entry
*in
)
142 memset(out
, '\0', sizeof(struct share_mode_entry
));
145 out
->share_file_id
= (unsigned long)in
->file_id
;
146 out
->time
.tv_sec
= in
->open_time
.tv_sec
;
147 out
->time
.tv_usec
= in
->open_time
.tv_usec
;
148 out
->share_access
= in
->share_access
;
149 out
->access_mask
= in
->access_mask
;
150 out
->dev
= (SMB_DEV_T
)in
->dev
;
151 out
->inode
= (SMB_INO_T
)in
->ino
;
152 out
->uid
= (uint32
)geteuid();
156 * Return the current share mode list for an open file.
157 * This uses similar (but simplified) logic to locking/locking.c
160 int smb_get_share_mode_entries(struct smbdb_ctx
*db_ctx
,
163 struct smb_share_mode_entry
**pp_list
,
164 unsigned char *p_delete_on_close
)
167 struct smb_share_mode_entry
*list
= NULL
;
168 int num_share_modes
= 0;
169 struct locking_data
*ld
= NULL
; /* internal samba db state. */
170 struct share_mode_entry
*shares
= NULL
;
175 *p_delete_on_close
= 0;
177 db_data
= tdb_fetch(db_ctx
->smb_tdb
, get_locking_key(dev
, ino
));
182 ld
= (struct locking_data
*)db_data
.dptr
;
183 num_share_modes
= ld
->u
.s
.num_share_mode_entries
;
185 if (!num_share_modes
) {
190 list
= (struct smb_share_mode_entry
*)malloc(sizeof(struct smb_share_mode_entry
)*num_share_modes
);
196 memset(list
, '\0', num_share_modes
* sizeof(struct smb_share_mode_entry
));
198 shares
= (struct share_mode_entry
*)(db_data
.dptr
+ sizeof(struct share_mode_entry
));
201 for (i
= 0; i
< num_share_modes
; i
++) {
202 struct share_mode_entry
*share
= &shares
[i
];
203 struct smb_share_mode_entry
*sme
= &list
[list_num
];
204 struct process_id pid
= share
->pid
;
206 /* Check this process really exists. */
207 if (kill(sharemodes_procid_to_pid(&pid
), 0) == -1 && (errno
== ESRCH
)) {
208 continue; /* No longer exists. */
211 /* Ignore deferred open entries. */
212 if (share
->op_type
== DEFERRED_OPEN_ENTRY
) {
216 /* Copy into the external list. */
217 sme
->dev
= (uint64_t)share
->dev
;
218 sme
->ino
= (uint64_t)share
->inode
;
219 sme
->share_access
= (uint32_t)share
->share_access
;
220 sme
->access_mask
= (uint32_t)share
->access_mask
;
221 sme
->open_time
.tv_sec
= share
->time
.tv_sec
;
222 sme
->open_time
.tv_usec
= share
->time
.tv_usec
;
223 sme
->file_id
= (uint32_t)share
->share_file_id
;
224 sme
->pid
= share
->pid
;
234 *p_delete_on_close
= ld
->u
.s
.delete_on_close
;
241 * Create an entry in the Samba share mode db.
244 int smb_create_share_mode_entry_ex(struct smbdb_ctx
*db_ctx
,
247 const struct smb_share_mode_entry
*new_entry
,
248 const char *sharepath
, /* Must be absolute utf8 path. */
249 const char *filename
) /* Must be relative utf8 path. */
252 TDB_DATA locking_key
= get_locking_key(dev
, ino
);
253 int orig_num_share_modes
= 0;
254 struct locking_data
*ld
= NULL
; /* internal samba db state. */
255 struct share_mode_entry
*shares
= NULL
;
256 char *new_data_p
= NULL
;
257 size_t new_data_size
= 0;
259 db_data
= tdb_fetch(db_ctx
->smb_tdb
, locking_key
);
261 /* We must create the entry. */
262 db_data
.dptr
= (char *)malloc(
263 (2*sizeof(struct share_mode_entry
)) +
264 strlen(sharepath
) + 1 +
265 strlen(filename
) + 1);
269 ld
= (struct locking_data
*)db_data
.dptr
;
270 memset(ld
, '\0', sizeof(struct locking_data
));
271 ld
->u
.s
.num_share_mode_entries
= 1;
272 ld
->u
.s
.delete_on_close
= 0;
273 ld
->u
.s
.initial_delete_on_close
= 0;
274 ld
->u
.s
.delete_token_size
= 0;
275 shares
= (struct share_mode_entry
*)(db_data
.dptr
+ sizeof(struct share_mode_entry
));
276 create_share_mode_entry(shares
, new_entry
);
278 memcpy(db_data
.dptr
+ 2*sizeof(struct share_mode_entry
),
280 strlen(sharepath
) + 1);
281 memcpy(db_data
.dptr
+ 2*sizeof(struct share_mode_entry
) +
282 strlen(sharepath
) + 1,
284 strlen(filename
) + 1);
286 db_data
.dsize
= 2*sizeof(struct share_mode_entry
) +
287 strlen(sharepath
) + 1 +
288 strlen(filename
) + 1;
289 if (tdb_store(db_ctx
->smb_tdb
, locking_key
, db_data
, TDB_INSERT
) == -1) {
297 /* Entry exists, we must add a new entry. */
298 new_data_p
= (char *)malloc(
299 db_data
.dsize
+ sizeof(struct share_mode_entry
));
305 ld
= (struct locking_data
*)db_data
.dptr
;
306 orig_num_share_modes
= ld
->u
.s
.num_share_mode_entries
;
308 /* Copy the original data. */
309 memcpy(new_data_p
, db_data
.dptr
, (orig_num_share_modes
+1)*sizeof(struct share_mode_entry
));
311 /* Add in the new share mode */
312 shares
= (struct share_mode_entry
*)(new_data_p
+
313 ((orig_num_share_modes
+1)*sizeof(struct share_mode_entry
)));
315 create_share_mode_entry(shares
, new_entry
);
317 ld
= (struct locking_data
*)new_data_p
;
318 ld
->u
.s
.num_share_mode_entries
++;
320 /* Append the original delete_token and filenames. */
321 memcpy(new_data_p
+ ((ld
->u
.s
.num_share_mode_entries
+1)*sizeof(struct share_mode_entry
)),
322 db_data
.dptr
+ ((orig_num_share_modes
+1)*sizeof(struct share_mode_entry
)),
323 db_data
.dsize
- ((orig_num_share_modes
+1) * sizeof(struct share_mode_entry
)));
325 new_data_size
= db_data
.dsize
+ sizeof(struct share_mode_entry
);
329 db_data
.dptr
= new_data_p
;
330 db_data
.dsize
= new_data_size
;
332 if (tdb_store(db_ctx
->smb_tdb
, locking_key
, db_data
, TDB_REPLACE
) == -1) {
341 * Create an entry in the Samba share mode db. Original interface - doesn't
342 * Distinguish between share path and filename. Fudge this by using a
343 * sharepath of / and a relative filename of (filename+1).
346 int smb_create_share_mode_entry(struct smbdb_ctx
*db_ctx
,
349 const struct smb_share_mode_entry
*new_entry
,
350 const char *filename
) /* Must be absolute utf8 path. */
352 if (*filename
!= '/') {
355 return smb_create_share_mode_entry_ex(db_ctx
, dev
, ino
, new_entry
,
359 int smb_delete_share_mode_entry(struct smbdb_ctx
*db_ctx
,
362 const struct smb_share_mode_entry
*del_entry
)
365 TDB_DATA locking_key
= get_locking_key(dev
, ino
);
366 int orig_num_share_modes
= 0;
367 struct locking_data
*ld
= NULL
; /* internal samba db state. */
368 struct share_mode_entry
*shares
= NULL
;
369 char *new_data_p
= NULL
;
370 size_t remaining_size
= 0;
371 size_t i
, num_share_modes
;
372 const char *remaining_ptr
= NULL
;
374 db_data
= tdb_fetch(db_ctx
->smb_tdb
, locking_key
);
376 return -1; /* Error - missing entry ! */
379 ld
= (struct locking_data
*)db_data
.dptr
;
380 orig_num_share_modes
= ld
->u
.s
.num_share_mode_entries
;
381 shares
= (struct share_mode_entry
*)(db_data
.dptr
+ sizeof(struct share_mode_entry
));
383 if (orig_num_share_modes
== 1) {
384 /* Only one entry - better be ours... */
385 if (!share_mode_entry_equal(del_entry
, shares
)) {
386 /* Error ! We can't delete someone else's entry ! */
390 /* It's ours - just remove the entire record. */
392 return tdb_delete(db_ctx
->smb_tdb
, locking_key
);
395 /* More than one - allocate a new record minus the one we'll delete. */
396 new_data_p
= (char *)malloc(
397 db_data
.dsize
- sizeof(struct share_mode_entry
));
403 /* Copy the header. */
404 memcpy(new_data_p
, db_data
.dptr
, sizeof(struct share_mode_entry
));
407 for (i
= 0; i
< orig_num_share_modes
; i
++) {
408 struct share_mode_entry
*share
= &shares
[i
];
409 struct process_id pid
= share
->pid
;
411 /* Check this process really exists. */
412 if (kill(sharemodes_procid_to_pid(&pid
), 0) == -1 && (errno
== ESRCH
)) {
413 continue; /* No longer exists. */
416 if (share_mode_entry_equal(del_entry
, share
)) {
417 continue; /* This is our delete taget. */
420 memcpy(new_data_p
+ ((num_share_modes
+1)*sizeof(struct share_mode_entry
)),
421 share
, sizeof(struct share_mode_entry
) );
426 if (num_share_modes
== 0) {
427 /* None left after pruning. Delete record. */
430 return tdb_delete(db_ctx
->smb_tdb
, locking_key
);
433 /* Copy any delete token plus the terminating filenames. */
434 remaining_ptr
= db_data
.dptr
+ ((orig_num_share_modes
+1) * sizeof(struct share_mode_entry
));
435 remaining_size
= db_data
.dsize
- (remaining_ptr
- db_data
.dptr
);
437 memcpy(new_data_p
+ ((num_share_modes
+1)*sizeof(struct share_mode_entry
)),
443 db_data
.dptr
= new_data_p
;
445 /* Re-save smaller record. */
446 ld
= (struct locking_data
*)db_data
.dptr
;
447 ld
->u
.s
.num_share_mode_entries
= num_share_modes
;
449 db_data
.dsize
= ((num_share_modes
+1)*sizeof(struct share_mode_entry
)) + remaining_size
;
451 if (tdb_store(db_ctx
->smb_tdb
, locking_key
, db_data
, TDB_REPLACE
) == -1) {
459 int smb_change_share_mode_entry(struct smbdb_ctx
*db_ctx
,
462 const struct smb_share_mode_entry
*set_entry
,
463 const struct smb_share_mode_entry
*new_entry
)
466 TDB_DATA locking_key
= get_locking_key(dev
, ino
);
467 int num_share_modes
= 0;
468 struct locking_data
*ld
= NULL
; /* internal samba db state. */
469 struct share_mode_entry
*shares
= NULL
;
473 db_data
= tdb_fetch(db_ctx
->smb_tdb
, locking_key
);
475 return -1; /* Error - missing entry ! */
478 ld
= (struct locking_data
*)db_data
.dptr
;
479 num_share_modes
= ld
->u
.s
.num_share_mode_entries
;
480 shares
= (struct share_mode_entry
*)(db_data
.dptr
+ sizeof(struct share_mode_entry
));
482 for (i
= 0; i
< num_share_modes
; i
++) {
483 struct share_mode_entry
*share
= &shares
[i
];
484 struct process_id pid
= share
->pid
;
486 /* Check this process really exists. */
487 if (kill(sharemodes_procid_to_pid(&pid
), 0) == -1 && (errno
== ESRCH
)) {
488 continue; /* No longer exists. */
491 if (share_mode_entry_equal(set_entry
, share
)) {
492 create_share_mode_entry(share
, new_entry
);
503 /* Save modified data. */
504 if (tdb_store(db_ctx
->smb_tdb
, locking_key
, db_data
, TDB_REPLACE
) == -1) {