int dbfs_aopen(struct mangoo_store *storep, const char *locator, struct mangoo_handle **mhpp)
{
int error;
struct dbfs_handle *dh;
struct dbfs_store *dsp = (struct dbfs_store *)storep;
printf("dbfs_aopen:1\n");
if (!(dh = dbfs_createhandle(locator, dsp->dbp))) {
error = ENOMEM;
goto errout;
}
printf("dbfs_aopen:2\n");
dh->mh.mh_interface = mangoo_attr_interface;
dh->mh.mh_fvector = (void *)&dbfs_attr_ops;
if ((error = dbfs_read_attr(dsp->dbp, dh->attr_ddk, dbfs_ddk_size(locator),
&dh->attr_ddd))) {
goto errout;
}
printf("dbfs_aopen:3\n");
*mhpp = (struct mangoo_handle *)dh;
return 0;
errout:
return error;
}
int dbfs_write_attr(DB *dbp, struct dbfs_dentry_key *attr_ddk, struct dbfs_dentry_data *attr_ddd)
{
int error;
DBT key, data;
attr_ddk->ddk_dk.dk_type = kt_dentry;
memset(&key, 0, sizeof(DBT));
key.data = attr_ddk;
key.size = dbfs_ddk_size(attr_ddk->ddk_path);
memset(&data, 0, sizeof(DBT));
data.data = attr_ddd;
data.size = sizeof(*attr_ddd);
if ((error = dbp->put(dbp, NULL, &key, &data, 0))) {
dbp->err(dbp, error, "Can't update attribute record for %s\n", attr_ddk->ddk_path);
error = EINVAL;
goto errout;
}
return 0;
errout:
return error;
}
int dbfs_stat(DB *dbp, const char *locator, struct stat *stbuf)
{
struct dbfs_dentry_key *ddk;
struct dbfs_dentry_data ddd;
int ddk_size;
uint32_t ddd_type;
uint64_t ino;
int type;
int error;
printf("dbfs_stat:1 %s\n", locator);
ddk_size = dbfs_ddk_size(locator);
if (!(ddk = malloc(ddk_size))) {
error = ENOMEM;
goto errout;
}
ddk->ddk_dk.dk_type = kt_dentry;
strcpy(ddk->ddk_path, locator);
if ((error = dbfs_read_attr(dbp, ddk, ddk_size, &ddd))) {
goto errout;
}
ino = ddd.ddd_ino;
memset(stbuf, 0, sizeof(*stbuf));
stbuf->st_ino = ino;
/* Hardcoded for now */
stbuf->st_uid = geteuid();
stbuf->st_gid = getegid();
stbuf->st_ctime = time(NULL);
stbuf->st_mtime = time(NULL);
stbuf->st_atime = time(NULL);
stbuf->st_size = ddd.ddd_size;
ddd_type = ddd.ddd_type;
if (ddd_type == S_IFREG) {
stbuf->st_mode = S_IFREG | 0444;
stbuf->st_nlink = 1;
} else if (ddd_type == S_IFDIR) {
stbuf->st_mode = S_IFDIR | 0755;
stbuf->st_nlink = 2;
} else {
error = EINVAL;
goto errout;
}
printf("dbfs_stat:10\n");
return 0;
errout:
return error;
}
int main(int argc, const char *argv[])
{
DB *dbp;
int error;
const char *progname = argv[0];
const char *dbname = argv[1];
int retval = 0;
struct dbfs_fsinfo_data dfd;
struct dbfs_dentry_key *ddk;
struct dbfs_dentry_data ddd;
size_t ddk_size;
if (argc != 2) {
fprintf(stderr, "Format: %s file name\n", progname);
goto out1;
}
if ((error = db_create(&dbp, NULL, 0))) {
fprintf(stderr, "%s: db_create failed", progname);
goto out1;
}
dbp->set_errfile(dbp, stderr);
dbp->set_errpfx(dbp, progname);
if ((error = dbp->set_bt_compare(dbp, dbfs_bt_compare))) {
dbp->err(dbp, error, "%s: open failed", dbname);
goto out1;
}
/* Create database */
if ((error = dbp->open(dbp,
NULL, dbname, NULL, DB_BTREE, DB_CREATE | DB_EXCL | DB_THREAD, 0664))) {
dbp->err(dbp, error, "open: %s", dbname);
goto out1;
}
ddk_size = dbfs_ddk_size("/");
if (!(ddk = malloc(ddk_size))) {
goto out2;
}
dbfs_init_dentry_key("/", ddk);
if ((error = dbfs_create_attr(dbp, ddk, ddk_size, &ddd, mangoo_container,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, DBFS_ROOT_INO))) {
goto out2;
}
dfd.dfd_lastino = DBFS_ROOT_INO;
if ((error = dbfs_create_fsinfo(dbp, &dfd)))
goto out2;
printf("dbfs created successfully.\n");
out2:
if ((dbp->close(dbp, 0))) {
fprintf(stderr, "%s: close failed", progname);
}
out1:
return retval;
}
