1 #include <stdlib.h>

     2 #include <assert.h>

     3 #include <string.h>

     4 

     5 #include "trans.h"

     6 #include "../lib/log.h"

     7 

     8 struct dbfs_mk_ctx {

     9     struct dbfs_trans base;

    10 

    11     const char *type, *data_expr;

    12     char *link, *name;

    13     uint16_t mode;

    14     uint32_t ino, parent;

    15 };

    16 

    17 // default mode for symlinks

    18 #define DBFS_SYMLINK_MODE 0777

    19 

    20 // max. size for an dbfs_mk INSERT query

    21 #define DBFS_MK_SQL_MAX 512

    22 

    23 void dbfs_mk_free (struct dbfs_trans *ctx_base) {

    24     struct dbfs_mk_ctx *ctx = (struct dbfs_mk_ctx *) ctx_base;

    25     

    26     free(ctx->link);

    27     free(ctx->name);

    28 }

    29 

    30 void dbfs_mk_commit (struct dbfs_trans *ctx_base) {

    31     struct dbfs_mk_ctx *ctx = (struct dbfs_mk_ctx *) ctx_base;

    32     struct fuse_entry_param e;

    33     int err;

    34     

    35     // build entry

    36     e.ino = e.attr.st_ino = ctx->ino;

    37     e.attr.st_mode = _dbfs_mode(ctx->type) | ctx->mode;

    38     e.attr.st_size = ctx->link ? strlen(ctx->link) : 0;

    39     e.attr.st_nlink = 1;

    40     e.attr_timeout = e.entry_timeout = CACHE_TIMEOUT;

    41 

    42     // reply

    43     if ((err = fuse_reply_entry(ctx_base->req, &e)))

    44         goto error;

    45 

    46     // req good

    47     ctx_base->req = NULL;

    48     

    49     // free

    50     dbfs_trans_free(ctx_base);

    51 

    52     // return

    53     return;

    54 

    55 error:

    56     dbfs_trans_fail(ctx_base, err);

    57 }

    58 

    59 void dbfs_mk_filetree (const struct evsql_result_info *res, void *arg) {

    60     struct dbfs_mk_ctx *ctx = arg;

    61     int err = EIO;

    62     

    63     // check results

    64     if (_dbfs_check_res(res, 0, 0) < 0)

    65         goto error;

    66     

    67     // commit

    68     dbfs_trans_commit(&ctx->base);

    69 

    70     // fallthrough for result_free

    71     err = 0;

    72 

    73 error:

    74     if (err)

    75         dbfs_trans_fail(&ctx->base, err);

    76 

    77     evsql_result_free(res);

    78 }

    79 

    80 void dbfs_mk_inode (const struct evsql_result_info *res, void *arg) {

    81     struct dbfs_mk_ctx *ctx = arg;

    82     struct dbfs *dbfs_ctx = fuse_req_userdata(ctx->base.req);

    83     int err = EIO;

    84     

    85     // check result

    86     if ((err = _dbfs_check_res(res, 1, 1)))

    87         SERROR(err = err > 0 ? ENOENT : EIO);

    88     

    89     // get ino

    90     if (evsql_result_uint32(res, 0, 0, &ctx->ino, 0))

    91         goto error;

    92 

    93     // insert file_tree entry

    94     const char *sql = 

    95         "INSERT"

    96         " INTO file_tree (name, parent, ino)"

    97         " VALUES ($1::varchar, $2::int4, $3::int4)";

    98     

    99     static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   100         EVSQL_PARAM ( STRING ),

   101         EVSQL_PARAM ( UINT32 ),

   102         EVSQL_PARAM ( UINT32 ),

   103 

   104         EVSQL_PARAMS_END

   105     };

   106 

   107     if (0

   108         ||  evsql_param_string(&params, 0, ctx->name)

   109         ||  evsql_param_uint32(&params, 1, ctx->parent)

   110         ||  evsql_param_uint32(&params, 2, ctx->ino)

   111     )

   112         goto error;

   113     

   114     // query

   115     if (evsql_query_params(dbfs_ctx->db, ctx->base.trans, sql, &params, dbfs_mk_filetree, ctx))

   116         goto error;

   117     

   118     // fallthrough for result_free

   119     err = 0;

   120 

   121 error:

   122     if (err)

   123         dbfs_trans_fail(&ctx->base, err);

   124 

   125     evsql_result_free(res);

   126 }

   127 

   128 void dbfs_mk_begin (struct dbfs_trans *ctx_base) {

   129     struct dbfs_mk_ctx *ctx = (struct dbfs_mk_ctx *) ctx_base;

   130     struct dbfs *dbfs_ctx = fuse_req_userdata(ctx_base->req);

   131     int ret;

   132 

   133     // insert inode

   134     char sql_buf[DBFS_MK_SQL_MAX];

   135     

   136     if ((ret = snprintf(sql_buf, DBFS_MK_SQL_MAX, 

   137         "INSERT"

   138         " INTO inodes (type, mode, data, link_path)"

   139         " VALUES ($1::char(3), $2::int2, %s, $3::varchar)"

   140         " RETURNING inodes.ino", ctx->data_expr ? ctx->data_expr : "NULL"

   141     )) >= DBFS_MK_SQL_MAX)

   142         ERROR("sql_buf is too small: %d", ret);

   143 

   144     static struct evsql_query_params params = EVSQL_PARAMS(EVSQL_FMT_BINARY) {

   145         EVSQL_PARAM ( STRING ),

   146         EVSQL_PARAM ( UINT16 ),

   147         EVSQL_PARAM ( STRING ),

   148 

   149         EVSQL_PARAMS_END

   150     };

   151 

   152     if (0

   153         || evsql_param_string(&params, 0, ctx->type)

   154         || evsql_param_uint16(&params, 1, ctx->mode)

   155         || evsql_param_string(&params, 2, ctx->link)

   156     )

   157         goto error;

   158     

   159     if (evsql_query_params(dbfs_ctx->db, ctx_base->trans, sql_buf, &params, dbfs_mk_inode, ctx) == NULL)

   160         goto error;

   161     

   162     return;

   163 

   164 error:

   165     dbfs_trans_fail(ctx_base, EIO);

   166 }

   167 

   168 /*

   169  * It is assumed that name and link_path must be copied, but type remains useable

   170  */ 

   171 void dbfs_mk (struct fuse_req *req, fuse_ino_t parent, const char *name, const char *type, uint16_t mode, const char *data_expr, const char *link) {

   172     struct dbfs_mk_ctx *ctx = NULL;

   173 

   174     // alloc

   175     if ((ctx = calloc(1, sizeof(*ctx))) == NULL)

   176         ERROR("calloc");

   177 

   178     // start trans

   179     if (dbfs_trans_init(&ctx->base, req))

   180         goto error;

   181  

   182     // callbacks

   183     ctx->base.free_fn = dbfs_mk_free;

   184     ctx->base.begin_fn = dbfs_mk_begin;

   185     ctx->base.commit_fn = dbfs_mk_commit;

   186    

   187     // state

   188     ctx->ino = 0;

   189     ctx->parent = parent;

   190     ctx->type = type;

   191     ctx->data_expr = data_expr;

   192     ctx->mode = mode;

   193 

   194     // copy volatile strings

   195     if (

   196             (link && (ctx->link = strdup(link)) == NULL)

   197         ||  (name && (ctx->name = strdup(name)) == NULL)

   198     )

   199         ERROR("strdup");

   200     

   201     // log

   202     INFO("[dbfs.mk %p:%p] parent=%lu, name=%s, type=%s, mode=%#04o data_expr=%s link=%s", ctx, req, parent, name, type, mode, data_expr, link);

   203 

   204     // wait

   205     return;

   206 

   207 error:

   208     if (ctx)

   209         dbfs_trans_fail(&ctx->base, EIO);

   210 }

   211 

   212 /*

   213  * These are all just aliases to dbfs_mk

   214  */ 

   215 void dbfs_mknod (struct fuse_req *req, fuse_ino_t parent, const char *name, mode_t mode, dev_t rdev) {

   216     int err;

   217 

   218     if ((mode & S_IFMT) != S_IFREG)

   219         EERROR(err = EINVAL, "mode is not REG: %#08o", mode);

   220 

   221     dbfs_mk(req, parent, name, "REG", mode & 07777, "lo_create(0)", NULL);

   222 

   223     return;

   224 

   225 error:

   226     if ((err = fuse_reply_err(req, err)))

   227         EWARNING(err, "fuse_reply_error");

   228 }

   229 

   230 void dbfs_mkdir (struct fuse_req *req, fuse_ino_t parent, const char *name, mode_t mode) {

   231     dbfs_mk(req, parent, name, "DIR", mode, NULL, NULL);

   232 }

   233 

   234 

   235 void dbfs_symlink (struct fuse_req *req, const char *link, fuse_ino_t parent, const char *name) {

   236     dbfs_mk(req, parent, name, "LNK", DBFS_SYMLINK_MODE, NULL, link);

   237 }

   238