1

#include <string.h>

     2

#include <errno.h>

     3

#include <stdlib.h>

     4

     5

#include <event2/event.h>

     6

#include <fuse/fuse_opt.h>

     7

     8

#include "lib/log.h"

     9

#include "lib/math.h"

    10

#include "lib/signals.h"

    11

#include "evfuse.h"

    12

#include "dirbuf.h"

    13

    14

const char *file_name = "hello";

    15

const char *file_data = "Hello World\n";

    16

    17

static struct hello {

    18

    struct event_base *ev_base;

    19

    20

    struct signals *signals;

    21

    22

    struct evfuse *ev_fuse;

    23

    24

} ctx;

    25

    26

void hello_init (void *userdata, struct fuse_conn_info *conn) {

    27

    INFO("[hello.init] userdata=%p, conn=%p", userdata, conn);

    28

}

    29

    30

void hello_destroy (void *userdata) {

    31

    INFO("[hello.destroy] userdata=%p", userdata);

    32

}

    33

    34

void hello_lookup (fuse_req_t req, fuse_ino_t parent, const char *name) {

    35

    struct fuse_entry_param e;

    36

    37

    INFO("[hello.lookup] (uid=%d, pid=%d) parent=%lu name=%s", fuse_req_ctx(req)->uid, fuse_req_ctx(req)->pid, parent, name);

    38

    39

    // the world is flat

    40

    if (parent != 1 || strcmp(name, file_name)) {

    41

        fuse_reply_err(req, ENOENT);

    42

    43

        return;

    44

    }

    45

    46

    // set up the entry

    47

    memset(&e, 0, sizeof(e));

    48

    e.ino = 2;

    49

    e.attr_timeout = 1.0;

    50

    e.entry_timeout = 1.0;

    51

    e.attr.st_mode = S_IFREG | 0444;

    52

    e.attr.st_nlink = 1;

    53

    e.attr.st_size = strlen(file_data);

    54

    55

    // reply

    56

    fuse_reply_entry(req, &e);

    57

}

    58

    59

void hello_getattr (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {

    60

    struct stat stbuf;

    61

    62

    INFO("[hello.getattr] (uid=%d, pid=%d) ino=%lu, fi=%p", fuse_req_ctx(req)->uid, fuse_req_ctx(req)->pid, ino, fi);

    63

    64

    memset(&stbuf, 0, sizeof(stbuf));

    65

    66

    // the root dir, or the file?

    67

    if (ino == 1) {

    68

        stbuf.st_mode = S_IFDIR | 0555;

    69

        stbuf.st_nlink = 2;

    70

    71

    } else if (ino == 2) {

    72

        stbuf.st_mode = S_IFREG | 0444;

    73

        stbuf.st_nlink = 1;

    74

        stbuf.st_size = strlen(file_data);

    75

    76

    } else {

    77

        fuse_reply_err(req, ENOENT);

    78

        return;

    79

    }

    80

    81

    // reply

    82

    fuse_reply_attr(req, &stbuf, 1.0);

    83

}

    84

    85

    86

void hello_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {

    87

    int err = 0;

    88

    struct dirbuf buf;

    89

    90

    INFO("[hello.readdir] ino=%lu, size=%zu, off=%zu, fi=%p", ino, size, off, fi);

    91

    92

    // there exists only one dir

    93

    if (ino != 1) {

    94

        fuse_reply_err(req, ENOTDIR);

    95

        return;

    96

    }

    97

    98

    // fill in the dirbuf

    99

    if (dirbuf_init(&buf, size, off))

   100

        ERROR("failed to init dirbuf");

   101

   102

    err =   dirbuf_add(req, &buf, 0, 1,  ".",        1,    S_IFDIR )

   103

        ||  dirbuf_add(req, &buf, 1, 2,  "..",       1,    S_IFDIR )

   104

        ||  dirbuf_add(req, &buf, 2, 3,  file_name,  2,    S_IFREG );

   105

   106

    if (err < 0)

   107

        ERROR("failed to add dirents to buf");

   108

   109

    // send it

   110

    if ((err = -dirbuf_done(req, &buf)))

   111

        EERROR(-err, "failed to send buf");

   112

   113

    // success

   114

    return;

   115

   116

error:

   117

    if ((err = fuse_reply_err(req, err ? err : EIO)))

   118

        EWARNING(err, "failed to send error reply");

   119

}

   120

   121

void hello_open (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi) {

   122

    int err = 0;

   123

   124

    INFO("[hello.open] ino=%lu, fi=%p, fi->flags=%08X", ino, fi, fi->flags);

   125

   126

    if (ino != 2) {

   127

        // must open our only file, not the dir

   128

        fuse_reply_err(req, ino == 1 ? EISDIR : ENOENT);

   129

        return;

   130

   131

    } else if ((fi->flags & 0x03) != O_RDONLY) {

   132

        // "permission denied"

   133

        fuse_reply_err(req, EACCES);

   134

        return;

   135

    }

   136

   137

    // XXX: update fi stuff?

   138

   139

    // open it!

   140

    if ((err = fuse_reply_open(req, fi)))

   141

        EERROR(err, "fuse_reply_open");

   142

   143

    // success

   144

    return;

   145

   146

error:

   147

    if ((err = fuse_reply_err(req, err ? err : EIO)))

   148

        EWARNING(err, "failed to send error reply");

   149

}

   150

   151

void hello_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {

   152

    int err = 0;

   153

   154

    // fi is unused

   155

    (void) fi;

   156

   157

    INFO("[hello.read] ino=%lu, size=%zu, off=%zu, fi=%p", ino, size, off, fi);

   158

   159

    if (ino != 2) {

   160

        // EEK!

   161

        FATAL("wrong inode");

   162

    }

   163

   164

    if (off >= strlen(file_data)) {

   165

        // offset is out-of-file, so return EOF

   166

        err = fuse_reply_buf(req, NULL, 0);

   167

   168

    } else {

   169

        // reply with the requested file data

   170

        err = fuse_reply_buf(req, file_data + off, MIN(strlen(file_data) - off, size));

   171

    }

   172

   173

    // reply

   174

    if (err)

   175

        PERROR("fuse_reply_buf");

   176

   177

    // success

   178

    return;

   179

   180

error:

   181

    if ((err = fuse_reply_err(req, err ? err : EIO)))

   182

        EWARNING(err, "failed to send error reply");

   183

}

   184

   185

void hello_getxattr (fuse_req_t req, fuse_ino_t ino, const char *name, size_t size) {

   186

    INFO("[hello.getxattr] ino=%lu, name=`%s', size=%zu", ino, name, size);

   187

   188

    fuse_reply_err(req, ENOSYS);

   189

}

   190

   191

struct fuse_lowlevel_ops hello_llops = {

   192

    .init = &hello_init,

   193

    .destroy = &hello_destroy,

   194

   195

    .lookup = &hello_lookup,

   196

    .getattr = &hello_getattr,

   197

   198

    .open = &hello_open,

   199

   200

    .read = &hello_read,

   201

   202

    .readdir = &hello_readdir,

   203

   204

    .getxattr = hello_getxattr,

   205

};

   206

   207

   208

int main (int argc, char **argv) {

   209

    struct fuse_args fuse_args = FUSE_ARGS_INIT(argc, argv);

   210

   211

    // zero

   212

    memset(&ctx, 0, sizeof(ctx));

   213

   214

    // init libevent

   215

    if ((ctx.ev_base = event_base_new()) == NULL)

   216

        ERROR("event_base_new");

   217

   218

    // setup signals

   219

    if ((ctx.signals = signals_default(ctx.ev_base)) == NULL)

   220

        ERROR("signals_default");

   221

   222

    // open fuse

   223

    if ((ctx.ev_fuse = evfuse_new(ctx.ev_base, &fuse_args, &hello_llops, &ctx)) == NULL)

   224

        ERROR("evfuse_new");

   225

   226

    // run libevent

   227

    INFO("running libevent loop");

   228

   229

    if (event_base_dispatch(ctx.ev_base))

   230

        PERROR("event_base_dispatch");

   231

   232

    // clean shutdown

   233

   234

error :

   235

    // cleanup

   236

    if (ctx.ev_fuse)

   237

        evfuse_free(ctx.ev_fuse);

   238

   239

    if (ctx.signals)

   240

        signals_free(ctx.signals);

   241

   242

    if (ctx.ev_base)

   243

        event_base_free(ctx.ev_base);

   244

   245

    fuse_opt_free_args(&fuse_args);

   246

}

   247