include/smb_share_modes.h

ソースコードを見る。

データ構造
struct	smb_share_mode_entry
関数
smbdb_ctx *	smb_share_mode_db_open (const char *db_path)
int	smb_share_mode_db_close (struct smbdb_ctx *db_ctx)
int	smb_lock_share_mode_entry (struct smbdb_ctx *db_ctx, uint64_t dev, uint64_t ino)
int	smb_unlock_share_mode_entry (struct smbdb_ctx *db_ctx, uint64_t dev, uint64_t ino)
int	smb_get_share_mode_entries (struct smbdb_ctx *db_ctx, uint64_t dev, uint64_t ino, struct smb_share_mode_entry **pp_list, unsigned char *p_delete_on_close)
int	smb_create_share_mode_entry (struct smbdb_ctx *db_ctx, uint64_t dev, uint64_t ino, const struct smb_share_mode_entry *set_entry, const char *path)
int	smb_delete_share_mode_entry (struct smbdb_ctx *db_ctx, uint64_t dev, uint64_t ino, const struct smb_share_mode_entry *set_entry)
int	smb_change_share_mode_entry (struct smbdb_ctx *db_ctx, uint64_t dev, uint64_t ino, const struct smb_share_mode_entry *set_entry, const struct smb_share_mode_entry *new_entry)

---

関数

struct smbdb_ctx* smb_share_mode_db_open

(

const char *

db_path

)

smb_share_modes.c の 59 行で定義されています。

参照先 smbdb_ctx::smb_tdb・tdb_open().

{
        struct smbdb_ctx *smb_db = (struct smbdb_ctx *)malloc(sizeof(struct smbdb_ctx));

        if (!smb_db) {
                return NULL;
        }

        memset(smb_db, '\0', sizeof(struct smbdb_ctx));

        smb_db->smb_tdb = tdb_open(db_path,
                                0, TDB_DEFAULT|TDB_CLEAR_IF_FIRST,
                                O_RDWR|O_CREAT,
                                0644);

        if (!smb_db->smb_tdb) {
                free(smb_db);
                return NULL;
        }

        /* Should check that this is the correct version.... */
        return smb_db;
}

int smb_share_mode_db_close

(

struct smbdb_ctx *

db_ctx

)

smb_share_modes.c の 89 行で定義されています。

参照先 smbdb_ctx::smb_tdb・tdb_close().

{
        int ret = tdb_close(db_ctx->smb_tdb);
        free(db_ctx);
        return ret;
}

int smb_lock_share_mode_entry	(	struct smbdb_ctx *	db_ctx,
		uint64_t	dev,
		uint64_t	ino
	)

smb_share_modes.c の 113 行で定義されています。

参照先 get_locking_key()・smbdb_ctx::smb_tdb・tdb_chainlock().

{
        return tdb_chainlock(db_ctx->smb_tdb, get_locking_key(dev, ino));
}

int smb_unlock_share_mode_entry	(	struct smbdb_ctx *	db_ctx,
		uint64_t	dev,
		uint64_t	ino
	)

smb_share_modes.c の 120 行で定義されています。

参照先 get_locking_key()・smbdb_ctx::smb_tdb・tdb_chainunlock().

{
        return tdb_chainunlock(db_ctx->smb_tdb, get_locking_key(dev, ino));
}

int smb_get_share_mode_entries	(	struct smbdb_ctx *	db_ctx,
		uint64_t	dev,
		uint64_t	ino,
		struct smb_share_mode_entry **	pp_list,
		unsigned char *	p_delete_on_close
	)

smb_share_modes.c の 170 行で定義されています。

参照先 TDB_DATA::dptr・errno・get_locking_key()・list()・process_id::pid・locking_data::s・share・sharemodes_procid_to_pid()・shares・smbdb_ctx::smb_tdb・tdb_fetch()・locking_data::u.

{
        TDB_DATA db_data;
        struct smb_share_mode_entry *list = NULL;
        int num_share_modes = 0;
        struct locking_data *ld = NULL; /* internal samba db state. */
        struct share_mode_entry *shares = NULL;
        size_t i;
        int list_num;

        *pp_list = NULL;
        *p_delete_on_close = 0;

        db_data = tdb_fetch(db_ctx->smb_tdb, get_locking_key(dev, ino));
        if (!db_data.dptr) {
                return 0;
        }

        ld = (struct locking_data *)db_data.dptr;
        num_share_modes = ld->u.s.num_share_mode_entries;

        if (!num_share_modes) {
                free(db_data.dptr);
                return 0;
        }

        list = (struct smb_share_mode_entry *)malloc(sizeof(struct smb_share_mode_entry)*num_share_modes);
        if (!list) {
                free(db_data.dptr);
                return -1;
        }

        memset(list, '\0', num_share_modes * sizeof(struct smb_share_mode_entry));

        shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));

        list_num = 0;
        for (i = 0; i < num_share_modes; i++) {
                struct share_mode_entry *share = &shares[i];
                struct smb_share_mode_entry *sme = &list[list_num];
                struct process_id pid = share->pid;

                /* Check this process really exists. */
                if (kill(sharemodes_procid_to_pid(&pid), 0) == -1 && (errno == ESRCH)) {
                        continue; /* No longer exists. */
                }

                /* Ignore deferred open entries. */
                if (share->op_type == DEFERRED_OPEN_ENTRY) {
                        continue;
                }

                /* Copy into the external list. */
                sme->dev = (uint64_t)share->dev;
                sme->ino = (uint64_t)share->inode;
                sme->share_access = (uint32_t)share->share_access;
                sme->access_mask = (uint32_t)share->access_mask;
                sme->open_time.tv_sec = share->time.tv_sec;
                sme->open_time.tv_usec = share->time.tv_usec;
                sme->file_id = (uint32_t)share->share_file_id;
                sme->pid = share->pid;
                list_num++;
        }

        if (list_num == 0) {
                free(db_data.dptr);
                free(list);
                return 0;
        }

        *p_delete_on_close = ld->u.s.delete_on_close;
        *pp_list = list;
        free(db_data.dptr);
        return list_num;
}

int smb_create_share_mode_entry	(	struct smbdb_ctx *	db_ctx,
		uint64_t	dev,
		uint64_t	ino,
		const struct smb_share_mode_entry *	set_entry,
		const char *	path
	)

smb_share_modes.c の 356 行で定義されています。

参照先 smb_create_share_mode_entry_ex().

{
        if (*filename != '/') {
                abort();
        }
        return smb_create_share_mode_entry_ex(db_ctx, dev, ino, new_entry,
                                                "/", &filename[1]);
}

int smb_delete_share_mode_entry	(	struct smbdb_ctx *	db_ctx,
		uint64_t	dev,
		uint64_t	ino,
		const struct smb_share_mode_entry *	set_entry
	)

smb_share_modes.c の 369 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・errno・get_locking_key()・locking_key()・process_id::pid・locking_data::s・share・share_mode_entry_equal()・sharemodes_procid_to_pid()・shares・smbdb_ctx::smb_tdb・tdb_delete()・tdb_fetch()・tdb_store()・locking_data::u.

{
        TDB_DATA db_data;
        TDB_DATA locking_key =  get_locking_key(dev, ino);
        int orig_num_share_modes = 0;
        struct locking_data *ld = NULL; /* internal samba db state. */
        struct share_mode_entry *shares = NULL;
        char *new_data_p = NULL;
        size_t remaining_size = 0;
        size_t i, num_share_modes;
        const char *remaining_ptr = NULL;

        db_data = tdb_fetch(db_ctx->smb_tdb, locking_key);
        if (!db_data.dptr) {
                return -1; /* Error - missing entry ! */
        }

        ld = (struct locking_data *)db_data.dptr;
        orig_num_share_modes = ld->u.s.num_share_mode_entries;
        shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));

        if (orig_num_share_modes == 1) {
                /* Only one entry - better be ours... */
                if (!share_mode_entry_equal(del_entry, shares)) {
                        /* Error ! We can't delete someone else's entry ! */
                        free(db_data.dptr);
                        return -1;
                }
                /* It's ours - just remove the entire record. */
                free(db_data.dptr);
                return tdb_delete(db_ctx->smb_tdb, locking_key);
        }

        /* More than one - allocate a new record minus the one we'll delete. */
        new_data_p = (char *)malloc(
                db_data.dsize - sizeof(struct share_mode_entry));
        if (!new_data_p) {
                free(db_data.dptr);
                return -1;
        }

        /* Copy the header. */
        memcpy(new_data_p, db_data.dptr, sizeof(struct locking_data));

        num_share_modes = 0;
        for (i = 0; i < orig_num_share_modes; i++) {
                struct share_mode_entry *share = &shares[i];
                struct process_id pid = share->pid;

                /* Check this process really exists. */
                if (kill(sharemodes_procid_to_pid(&pid), 0) == -1 && (errno == ESRCH)) {
                        continue; /* No longer exists. */
                }

                if (share_mode_entry_equal(del_entry, share)) {
                        continue; /* This is our delete taget. */
                }

                memcpy(new_data_p + sizeof(struct locking_data) +
                                (num_share_modes * sizeof(struct share_mode_entry)),
                        share, sizeof(struct share_mode_entry) );

                num_share_modes++;
        }

        if (num_share_modes == 0) {
                /* None left after pruning. Delete record. */
                free(db_data.dptr);
                free(new_data_p);
                return tdb_delete(db_ctx->smb_tdb, locking_key);
        }

        /* Copy any delete token plus the terminating filenames. */
        remaining_ptr = db_data.dptr + sizeof(struct locking_data) + (orig_num_share_modes * sizeof(struct share_mode_entry));
        remaining_size = db_data.dsize - (remaining_ptr - db_data.dptr);

        memcpy(new_data_p + sizeof(struct locking_data) + (num_share_modes * sizeof(struct share_mode_entry)),
                remaining_ptr,
                remaining_size);

        free(db_data.dptr);

        db_data.dptr = new_data_p;

        /* Re-save smaller record. */
        ld = (struct locking_data *)db_data.dptr;
        ld->u.s.num_share_mode_entries = num_share_modes;

        db_data.dsize = sizeof(struct locking_data) + (num_share_modes * sizeof(struct share_mode_entry)) + remaining_size;

        if (tdb_store(db_ctx->smb_tdb, locking_key, db_data, TDB_REPLACE) == -1) {
                free(db_data.dptr);
                return -1;
        }
        free(db_data.dptr);
        return 0;
}

int smb_change_share_mode_entry	(	struct smbdb_ctx *	db_ctx,
		uint64_t	dev,
		uint64_t	ino,
		const struct smb_share_mode_entry *	set_entry,
		const struct smb_share_mode_entry *	new_entry
	)

smb_share_modes.c の 470 行で定義されています。

参照先 create_share_mode_entry()・TDB_DATA::dptr・errno・get_locking_key()・locking_key()・process_id::pid・locking_data::s・share・share_mode_entry_equal()・sharemodes_procid_to_pid()・shares・smbdb_ctx::smb_tdb・tdb_fetch()・tdb_store()・locking_data::u.

{
        TDB_DATA db_data;
        TDB_DATA locking_key =  get_locking_key(dev, ino);
        int num_share_modes = 0;
        struct locking_data *ld = NULL; /* internal samba db state. */
        struct share_mode_entry *shares = NULL;
        size_t i;
        int found_entry = 0;

        db_data = tdb_fetch(db_ctx->smb_tdb, locking_key);
        if (!db_data.dptr) {
                return -1; /* Error - missing entry ! */
        }

        ld = (struct locking_data *)db_data.dptr;
        num_share_modes = ld->u.s.num_share_mode_entries;
        shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));

        for (i = 0; i < num_share_modes; i++) {
                struct share_mode_entry *share = &shares[i];
                struct process_id pid = share->pid;

                /* Check this process really exists. */
                if (kill(sharemodes_procid_to_pid(&pid), 0) == -1 && (errno == ESRCH)) {
                        continue; /* No longer exists. */
                }

                if (share_mode_entry_equal(set_entry, share)) {
                        create_share_mode_entry(share, new_entry);
                        found_entry = 1;
                        break;
                }
        }

        if (!found_entry) {
                free(db_data.dptr);
                return -1;
        }

        /* Save modified data. */
        if (tdb_store(db_ctx->smb_tdb, locking_key, db_data, TDB_REPLACE) == -1) {
                free(db_data.dptr);
                return -1;
        }
        free(db_data.dptr);
        return 0;
}

---