summaryrefslogtreecommitdiff
path: root/lib9p/srv.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib9p/srv.c')
-rw-r--r--lib9p/srv.c438
1 files changed, 253 insertions, 185 deletions
diff --git a/lib9p/srv.c b/lib9p/srv.c
index 478a642..077db83 100644
--- a/lib9p/srv.c
+++ b/lib9p/srv.c
@@ -21,7 +21,7 @@
#define NAME reqmap
#define KEY_T uint32_t
-#define VAL_T struct lib9p_srv_reqctx
+#define VAL_T struct _lib9p_srv_req *
#define CAP CONFIG_9P_MAX_REQS
#include "map.h"
@@ -31,9 +31,9 @@
*
*/
-/* struct lib9p_srv {} is defined in <lib9p/srv.h> */
+/* struct _srv_srv {} is defined in <lib9p/srv.h> */
-struct lib9p_conn {
+struct _srv_conn {
/* immutable */
struct lib9p_srv *parent_srv;
int fd;
@@ -42,9 +42,9 @@ struct lib9p_conn {
cr_mutex_t writelock;
};
-struct lib9p_sess {
+struct _srv_sess {
/* immutable */
- struct lib9p_conn *parent_conn;
+ struct _srv_conn *parent_conn;
enum lib9p_version version;
uint32_t max_msg_size;
uint32_t rerror_overhead;
@@ -55,56 +55,78 @@ struct lib9p_sess {
struct fidmap fids;
};
-struct lib9p_req {
+struct _lib9p_srv_req {
/* immutable */
- struct lib9p_sess *parent_sess;
+ struct _srv_sess *parent_sess;
uint16_t tag;
/* mutable */
uint8_t *net_bytes; /* CONFIG_9P_MAX_MSG_SIZE-sized */
- struct lib9p_ctx ctx;
+ struct lib9p_srv_ctx ctx;
};
/* base utilities *************************************************************/
-#define nonrespond_errorf(fmt, ...) fprintf(stderr, "error: " fmt "\n" __VA_OPT__(,) __VA_ARGS__)
+#define nonrespond_errorf(fmt, ...) \
+ fprintf(stderr, "error: " fmt "\n" __VA_OPT__(,) __VA_ARGS__)
-static uint32_t rerror_overhead_for_version(enum lib9p_version version, uint8_t *scratch) {
+static uint32_t rerror_overhead_for_version(enum lib9p_version version,
+ uint8_t *scratch) {
struct lib9p_ctx empty_ctx = {
.version = version,
.max_msg_size = CONFIG_9P_MAX_MSG_SIZE,
};
struct lib9p_msg_Rerror empty_error = { 0 };
+ bool e;
+
+ e = lib9p_marshal(&empty_ctx, LIB9P_TYP_Rerror,
+ 0, /* tag */
+ &empty_error, /* host_body */
+ scratch); /* net_bytes */
+ assert(!e);
- assert(!lib9p_marshal(&empty_ctx, LIB9P_TYP_Rerror, 0, &empty_error, scratch));
uint32_t min_msg_size = decode_u32le(scratch);
+
+ /* Assert that min_msg_size + biggest_possible_MAX_ERR_SIZE
+ * won't overflow uint32... because using
+ * __builtin_add_overflow in respond_error() would be a bit
+ * much. */
assert(min_msg_size < (UINT32_MAX - UINT16_MAX));
+ /* Assert that min_msg_size doesn't overflow MAX_MSG_SIZE. */
assert(CONFIG_9P_MAX_MSG_SIZE >= min_msg_size);
return min_msg_size;
}
-static void respond_error(struct lib9p_req *req) {
- assert(req->ctx.err_num);
- assert(req->ctx.err_msg[0]);
+static void respond_error(struct _lib9p_srv_req *req) {
+ assert(req->ctx.basectx.err_num);
+ assert(req->ctx.basectx.err_msg[0]);
ssize_t r;
struct lib9p_msg_Rerror host = {
.ename = {
- .len = strnlen(req->ctx.err_msg, CONFIG_9P_MAX_ERR_SIZE),
- .utf8 = req->ctx.err_msg,
+ .len = strnlen(req->ctx.basectx.err_msg,
+ CONFIG_9P_MAX_ERR_SIZE),
+ .utf8 = req->ctx.basectx.err_msg,
},
- .errno = req->ctx.err_num,
+ .errno = req->ctx.basectx.err_num,
};
- /* Truncate the error-string if necessary to avoid needing to return ERANGE. */
- if (((uint32_t)host.ename.len) + req->parent_sess->rerror_overhead > req->parent_sess->max_msg_size)
- host.ename.len = req->parent_sess->max_msg_size - req->parent_sess->rerror_overhead;
+ struct _srv_sess *sess = req->parent_sess;
- lib9p_marshal(&req->ctx, LIB9P_TYP_Rerror, req->tag, &host, req->net_bytes);
+ /* Truncate the error-string if necessary to avoid needing to
+ * return ERANGE. The assert() in
+ * rerror_overhead_for_version() has checked that this
+ * addition doesn't overflow. */
+ if (((uint32_t)host.ename.len) + sess->rerror_overhead > sess->max_msg_size)
+ host.ename.len = sess->max_msg_size - sess->rerror_overhead;
- cr_mutex_lock(&req->parent_sess->parent_conn->writelock);
- r = netio_write(req->parent_sess->parent_conn->fd, req->net_bytes, decode_u32le(req->net_bytes));
- cr_mutex_unlock(&req->parent_sess->parent_conn->writelock);
+ lib9p_marshal(&req->ctx.basectx, LIB9P_TYP_Rerror,
+ req->tag, &host, req->net_bytes);
+
+ cr_mutex_lock(&sess->parent_conn->writelock);
+ r = netio_write(sess->parent_conn->fd,
+ req->net_bytes, decode_u32le(req->net_bytes));
+ cr_mutex_unlock(&sess->parent_conn->writelock);
if (r < 0)
nonrespond_errorf("write: %s", strerror(-r));
}
@@ -130,7 +152,7 @@ static bool read_at_least(int fd, uint8_t *buf, size_t goal, size_t *done) {
return false;
}
-static bool handle_Tmessage(struct lib9p_req *);
+static bool handle_Tmessage(struct _lib9p_srv_req *ctx);
COROUTINE lib9p_srv_read_cr(void *_srv) {
uint8_t buf[CONFIG_9P_MAX_MSG_SIZE];
@@ -142,7 +164,7 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
uint32_t initial_rerror_overhead = rerror_overhead_for_version(0, buf);
for (;;) {
- struct lib9p_conn conn = {
+ struct _srv_conn conn = {
.parent_srv = srv,
.fd = netio_accept(srv->sockfd),
.reader = cr_getcid(),
@@ -152,9 +174,9 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
continue;
}
- struct lib9p_sess sess = {
+ struct _srv_sess sess = {
.parent_conn = &conn,
- .version = 0,
+ .version = LIB9P_VER_unknown,
.max_msg_size = CONFIG_9P_MAX_MSG_SIZE,
.rerror_overhead = initial_rerror_overhead,
.initialized = false,
@@ -171,18 +193,23 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
}
if (read_at_least(conn.fd, buf, 7, &done))
goto close;
- struct lib9p_req req = {
+ struct _lib9p_srv_req req = {
.parent_sess = &sess,
.tag = decode_u16le(&buf[5]),
.net_bytes = buf,
.ctx = {
- .version = sess.version,
- .max_msg_size = sess.max_msg_size,
+ .basectx = {
+ .version = sess.version,
+ .max_msg_size = sess.max_msg_size,
+ },
},
};
if (goal > sess.max_msg_size) {
- lib9p_errorf(&req.ctx, LINUX_EMSGSIZE, "T-message larger than %s limit (%zu > %"PRIu32")",
- sess.initialized ? "negotiated" : "server", goal, sess.max_msg_size);
+ lib9p_errorf(&req.ctx.basectx,
+ LINUX_EMSGSIZE, "T-message larger than %s limit (%zu > %"PRIu32")",
+ sess.initialized ? "negotiated" : "server",
+ goal,
+ sess.max_msg_size);
respond_error(&req);
continue;
}
@@ -207,42 +234,33 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
/* write coroutine ************************************************************/
-static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *req, struct lib9p_msg_Rversion *resp);
-static void handle_Tauth(struct lib9p_req *ctx, struct lib9p_msg_Tauth *req, struct lib9p_msg_Rauth *resp);
-static void handle_Tattach(struct lib9p_req *ctx, struct lib9p_msg_Tattach *req, struct lib9p_msg_Rattach *resp);
-static void handle_Tflush(struct lib9p_req *ctx, struct lib9p_msg_Tflush *req, struct lib9p_msg_Rflush *resp);
-static void handle_Twalk(struct lib9p_req *ctx, struct lib9p_msg_Twalk *req, struct lib9p_msg_Rwalk *resp);
-static void handle_Topen(struct lib9p_req *ctx, struct lib9p_msg_Topen *req, struct lib9p_msg_Ropen *resp);
-static void handle_Tcreate(struct lib9p_req *ctx, struct lib9p_msg_Tcreate *req, struct lib9p_msg_Rcreate *resp);
-static void handle_Tread(struct lib9p_req *ctx, struct lib9p_msg_Tread *req, struct lib9p_msg_Rread *resp);
-static void handle_Twrite(struct lib9p_req *ctx, struct lib9p_msg_Twrite *req, struct lib9p_msg_Rwrite *resp);
-static void handle_Tclunk(struct lib9p_req *ctx, struct lib9p_msg_Tclunk *req, struct lib9p_msg_Rclunk *resp);
-static void handle_Tremove(struct lib9p_req *ctx, struct lib9p_msg_Tremove *req, struct lib9p_msg_Rremove *resp);
-static void handle_Tstat(struct lib9p_req *ctx, struct lib9p_msg_Tstat *req, struct lib9p_msg_Rstat *resp);
-static void handle_Twstat(struct lib9p_req *ctx, struct lib9p_msg_Twstat *req, struct lib9p_msg_Rwstat *resp);
-static void handle_Tsession(struct lib9p_req *ctx, struct lib9p_msg_Tsession *req, struct lib9p_msg_Rsession *resp);
-static void handle_Tsread(struct lib9p_req *ctx, struct lib9p_msg_Tsread *req, struct lib9p_msg_Rsread *resp);
-static void handle_Tswrite(struct lib9p_req *ctx, struct lib9p_msg_Tswrite *req, struct lib9p_msg_Rswrite *resp);
-
COROUTINE lib9p_srv_write_cr(void *_srv) {
- uint8_t net[CONFIG_9P_MAX_MSG_SIZE];
+ uint8_t net[CONFIG_9P_MAX_MSG_SIZE];
+ struct _lib9p_srv_req req;
+ _lib9p_srv_reqch_req_t rpc_handle;
struct lib9p_srv *srv = _srv;
assert(srv);
cr_begin();
for (;;) {
- /* Receive the request from the reader coroutine. */
- struct lib9p_req req;
- _lib9p_srv_reqch_req_t req_handle;
- req_handle = _lib9p_srv_reqch_recv_req(&srv->_reqch);
- req = *req_handle.req;
+ /* Receive the request from the reader coroutine. ************/
+ rpc_handle = _lib9p_srv_reqch_recv_req(&srv->_reqch);
+ /* Deep-copy the request from the reader coroutine's
+ * stack to our stack. */
+ req = *rpc_handle.req;
memcpy(net, req.net_bytes, decode_u32le(req.net_bytes));
req.net_bytes = net;
- _lib9p_srv_reqch_send_resp(req_handle, 0); /* notify that we've copied req */
+ /* Record that we have it. */
+ reqmap_store(&req.parent_sess->reqs, req.tag, &req);
+ /* Notify the reader coroutine that we're done with
+ * its data. */
+ _lib9p_srv_reqch_send_resp(rpc_handle, 0);
+ /* Process the request. **************************************/
handle_Tmessage(&req);
+ /* Release resources. ****************************************/
reqmap_del(&req.parent_sess->reqs, req.tag);
if (req.parent_sess->closing && !req.parent_sess->reqs.len)
cr_unpause(req.parent_sess->parent_conn->reader);
@@ -251,96 +269,95 @@ COROUTINE lib9p_srv_write_cr(void *_srv) {
cr_end();
}
-static bool handle_Tmessage(struct lib9p_req *req) {
+#define _HANDLER_PROTO(typ) \
+ static void handle_T##typ(struct _lib9p_srv_req *, \
+ struct lib9p_msg_T##typ *, \
+ struct lib9p_msg_R##typ *)
+_HANDLER_PROTO(version);
+_HANDLER_PROTO(auth);
+_HANDLER_PROTO(attach);
+_HANDLER_PROTO(flush);
+_HANDLER_PROTO(walk);
+_HANDLER_PROTO(open);
+_HANDLER_PROTO(create);
+_HANDLER_PROTO(read);
+_HANDLER_PROTO(write);
+_HANDLER_PROTO(clunk);
+_HANDLER_PROTO(remove);
+_HANDLER_PROTO(stat);
+_HANDLER_PROTO(wstat);
+_HANDLER_PROTO(session); /* 9P2000.e */
+_HANDLER_PROTO(sread); /* 9P2000.e */
+_HANDLER_PROTO(swrite); /* 9P2000.e */
+
+typedef void (*tmessage_handler)(struct _lib9p_srv_req *, void *, void *);
+
+static tmessage_handler tmessage_handlers[0x100] = {
+ [LIB9P_TYP_Tversion] = (tmessage_handler)handle_Tversion,
+ [LIB9P_TYP_Tauth] = (tmessage_handler)handle_Tauth,
+ [LIB9P_TYP_Tattach] = (tmessage_handler)handle_Tattach,
+ [LIB9P_TYP_Tflush] = (tmessage_handler)handle_Tflush,
+ [LIB9P_TYP_Twalk] = (tmessage_handler)handle_Twalk,
+ [LIB9P_TYP_Topen] = (tmessage_handler)handle_Topen,
+ [LIB9P_TYP_Tcreate] = (tmessage_handler)handle_Tcreate,
+ [LIB9P_TYP_Tread] = (tmessage_handler)handle_Tread,
+ [LIB9P_TYP_Twrite] = (tmessage_handler)handle_Twrite,
+ [LIB9P_TYP_Tclunk] = (tmessage_handler)handle_Tclunk,
+ [LIB9P_TYP_Tremove] = (tmessage_handler)handle_Tremove,
+ [LIB9P_TYP_Tstat] = (tmessage_handler)handle_Tstat,
+ [LIB9P_TYP_Twstat] = (tmessage_handler)handle_Twstat,
+ [LIB9P_TYP_Tsession] = (tmessage_handler)handle_Tsession, /* 9P2000.e */
+ [LIB9P_TYP_Tsread] = (tmessage_handler)handle_Tsread, /* 9P2000.e */
+ [LIB9P_TYP_Tswrite] = (tmessage_handler)handle_Tswrite, /* 9P2000.e */
+};
+
+static bool handle_Tmessage(struct _lib9p_srv_req *ctx) {
uint8_t host_req[CONFIG_9P_MAX_HOSTMSG_SIZE];
uint8_t host_resp[CONFIG_9P_MAX_HOSTMSG_SIZE];
/* Unmarshal it. */
- enum lib9p_msg_type typ = req->net_bytes[4];
+ enum lib9p_msg_type typ = ctx->net_bytes[4];
if (typ % 2 != 0) {
- lib9p_errorf(&req->ctx, LINUX_EOPNOTSUPP, "expected a T-message but got an R-message: message_type=%s",
+ lib9p_errorf(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "expected a T-message but got an R-message: message_type=%s",
lib9p_msg_type_str(typ));
goto write;
}
- ssize_t host_size = lib9p_validate(&req->ctx, req->net_bytes);
+ ssize_t host_size = lib9p_validate(&ctx->ctx.basectx, ctx->net_bytes);
if (host_size < 0)
goto write;
if ((size_t)host_size > sizeof(host_req)) {
- lib9p_errorf(&req->ctx, LINUX_EMSGSIZE, "unmarshalled payload larger than server limit (%zu > %zu)",
+ lib9p_errorf(&ctx->ctx.basectx,
+ LINUX_EMSGSIZE, "unmarshalled payload larger than server limit (%zu > %zu)",
host_size, sizeof(host_req));
goto write;
}
- lib9p_unmarshal(&req->ctx, req->net_bytes, &typ, &req->tag, host_req);
+ lib9p_unmarshal(&ctx->ctx.basectx, ctx->net_bytes,
+ &typ, &ctx->tag, host_req);
/* Handle it. */
- switch (typ) {
- case LIB9P_TYP_Tversion:
- handle_Tversion(req, (struct lib9p_msg_Tversion *)host_req, (struct lib9p_msg_Rversion *)host_resp);
- break;
- case LIB9P_TYP_Tauth:
- handle_Tauth(req, (struct lib9p_msg_Tauth *)host_req, (struct lib9p_msg_Rauth *)host_resp);
- break;
- case LIB9P_TYP_Tattach:
- handle_Tattach(req, (struct lib9p_msg_Tattach *)host_req, (struct lib9p_msg_Rattach *)host_resp);
- break;
- case LIB9P_TYP_Tflush:
- handle_Tflush(req, (struct lib9p_msg_Tflush *)host_req, (struct lib9p_msg_Rflush *)host_resp);
- break;
- case LIB9P_TYP_Twalk:
- handle_Twalk(req, (struct lib9p_msg_Twalk *)host_req, (struct lib9p_msg_Rwalk *)host_resp);
- break;
- case LIB9P_TYP_Topen:
- handle_Topen(req, (struct lib9p_msg_Topen *)host_req, (struct lib9p_msg_Ropen *)host_resp);
- break;
- case LIB9P_TYP_Tcreate:
- handle_Tcreate(req, (struct lib9p_msg_Tcreate *)host_req, (struct lib9p_msg_Rcreate *)host_resp);
- break;
- case LIB9P_TYP_Tread:
- handle_Tread(req, (struct lib9p_msg_Tread *)host_req, (struct lib9p_msg_Rread *)host_resp);
- break;
- case LIB9P_TYP_Twrite:
- handle_Twrite(req, (struct lib9p_msg_Twrite *)host_req, (struct lib9p_msg_Rwrite *)host_resp);
- break;
- case LIB9P_TYP_Tclunk:
- handle_Tclunk(req, (struct lib9p_msg_Tclunk *)host_req, (struct lib9p_msg_Rclunk *)host_resp);
- break;
- case LIB9P_TYP_Tremove:
- handle_Tremove(req, (struct lib9p_msg_Tremove *)host_req, (struct lib9p_msg_Rremove *)host_resp);
- break;
- case LIB9P_TYP_Tstat:
- handle_Tstat(req, (struct lib9p_msg_Tstat *)host_req, (struct lib9p_msg_Rstat *)host_resp);
- break;
- case LIB9P_TYP_Twstat:
- handle_Twstat(req, (struct lib9p_msg_Twstat *)host_req, (struct lib9p_msg_Rwstat *)host_resp);
- break;
- case LIB9P_TYP_Tsession: /* 9P2000.e */
- handle_Tsession(req, (struct lib9p_msg_Tsession *)host_req, (struct lib9p_msg_Rsession *)host_resp);
- break;
- case LIB9P_TYP_Tsread: /* 9P2000.e */
- handle_Tsread(req, (struct lib9p_msg_Tsread *)host_req, (struct lib9p_msg_Rsread *)host_resp);
- break;
- case LIB9P_TYP_Tswrite: /* 9P2000.e */
- handle_Tswrite(req, (struct lib9p_msg_Tswrite *)host_req, (struct lib9p_msg_Rswrite *)host_resp);
- break;
- default:
- assert(false);
- }
+ tmessage_handlers[typ](ctx, (void *)host_req, (void *)host_resp);
write:
- if (lib9p_ctx_has_error(&req->ctx)) {
- respond_error(req);
+ if (lib9p_ctx_has_error(&ctx->ctx.basectx)) {
+ respond_error(ctx);
return true;
} else {
- if (lib9p_marshal(&req->ctx, typ+1, req->tag, host_resp, req->net_bytes))
+ if (lib9p_marshal(&ctx->ctx.basectx, typ+1, ctx->tag, host_resp,
+ ctx->net_bytes))
goto write;
- cr_mutex_lock(&req->parent_sess->parent_conn->writelock);
- netio_write(req->parent_sess->parent_conn->fd, req->net_bytes, decode_u32le(req->net_bytes));
- cr_mutex_unlock(&req->parent_sess->parent_conn->writelock);
+
+ cr_mutex_lock(&ctx->parent_sess->parent_conn->writelock);
+ netio_write(ctx->parent_sess->parent_conn->fd,
+ ctx->net_bytes, decode_u32le(ctx->net_bytes));
+ cr_mutex_unlock(&ctx->parent_sess->parent_conn->writelock);
return false;
}
}
-static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *req, struct lib9p_msg_Rversion *resp) {
+static void handle_Tversion(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tversion *req,
+ struct lib9p_msg_Rversion *resp) {
enum lib9p_version version = LIB9P_VER_unknown;
if (req->version.len >= 6 &&
@@ -361,14 +378,12 @@ static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *re
uint32_t min_msg_size = rerror_overhead_for_version(version, ctx->net_bytes);
if (req->max_msg_size < min_msg_size) {
- lib9p_errorf(&ctx->ctx, LINUX_EDOM, "requested max_msg_size is less than minimum for %s (%"PRIu32" < %"PRIu32")",
+ lib9p_errorf(&ctx->ctx.basectx,
+ LINUX_EDOM, "requested max_msg_size is less than minimum for %s (%"PRIu32" < %"PRIu32")",
version, req->max_msg_size, min_msg_size);
return;
}
- struct lib9p_srv_reqctx subctx = {
- .base = &ctx->ctx,
- };
if (ctx->parent_sess->reqs.len) {
ctx->parent_sess->closing = true;
// TODO: send flush events
@@ -379,7 +394,7 @@ static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *re
uint32_t fid;
struct lib9p_srv_file *fptr;
MAP_FOREACH(&ctx->parent_sess->fids, fid, fptr) {
- fptr->vtable.free(&subctx, fptr->impldata);
+ fptr->vtable.free(&ctx->ctx, fptr->impldata);
fidmap_del(&ctx->parent_sess->fids, fid);
}
}
@@ -395,75 +410,89 @@ static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *re
: req->max_msg_size;
}
-static void handle_Tauth(struct lib9p_req *ctx, struct lib9p_msg_Tauth *req, struct lib9p_msg_Rauth *UNUSED(resp)) {
- if (!ctx->parent_sess->parent_conn->parent_srv->auth) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "authentication not required");
+static void handle_Tauth(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tauth *req,
+ struct lib9p_msg_Rauth *UNUSED(resp)) {
+ ctx->ctx.uid = req->n_uname;
+ ctx->ctx.uname = req->uname.utf8;
+ struct lib9p_srv *srv = ctx->parent_sess->parent_conn->parent_srv;
+
+ if (!srv->auth) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "authentication not required");
return;
}
- struct lib9p_srv_reqctx subctx = {
- .base = &ctx->ctx,
- .uid = req->n_uname,
- .uname = req->uname.utf8,
- };
- ctx->parent_sess->parent_conn->parent_srv->auth(&subctx, req->aname.utf8);
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "TODO: auth not implemented");
+
+ srv->auth(&ctx->ctx, req->aname.utf8);
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "TODO: auth not implemented");
}
-static void handle_Tattach(struct lib9p_req *ctx, struct lib9p_msg_Tattach *req, struct lib9p_msg_Rattach *resp) {
- struct lib9p_srv_reqctx subctx = {
- .base = &ctx->ctx,
- .uid = req->n_uname,
- .uname = req->uname.utf8,
- };
- if (ctx->parent_sess->parent_conn->parent_srv->auth) {
+static void handle_Tattach(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tattach *req,
+ struct lib9p_msg_Rattach *resp) {
+ ctx->ctx.uid = req->n_uname;
+ ctx->ctx.uname = req->uname.utf8;
+ struct lib9p_srv *srv = ctx->parent_sess->parent_conn->parent_srv;
+
+ if (srv->auth) {
/*
struct lib9p_srv_filehandle *fh = fidmap_get(req->afid);
if (!fh)
- lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is not a valid FID");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EACCES, "FID provided as auth-file is not a valid FID");
else if (fh->type != FH_AUTH)
- lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is not an auth-file");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EACCES, "FID provided as auth-file is not an auth-file");
else if (strcmp(fh->data.auth.uname, req->uname.utf8) != 0)
- lib9p_errorf(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is for user=\"%s\" and cannot be used for user=\"%s\"",
+ lib9p_errorf(&ctx->ctx.basectx,
+ LINUX_EACCES, "FID provided as auth-file is for user=\"%s\" and cannot be used for user=\"%s\"",
fh->data.auth.uname, req->uname.utf8);
else if (strcmp(fh->data.auth.aname, req->aname.utf8) != 0)
- lib9p_errorf(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is for tree=\"%s\" and cannot be used for tree=\"%s\"",
+ lib9p_errorf(&ctx->ctx.basectx,
+ LINUX_EACCES, "FID provided as auth-file is for tree=\"%s\" and cannot be used for tree=\"%s\"",
fh->data.auth.aname, req->aname.utf8);
else if (!fh->data.auth.authenticated)
- lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file has not completed authentication");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EACCES, "FID provided as auth-file has not completed authentication");
fh->refcount--;
if (lib9p_ctx_has_error(&ctx->ctx))
return;
*/
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "TODO: auth not implemented");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "TODO: auth not implemented");
return;
} else {
if (req->afid != LIB9P_NOFID) {
- lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file, but no auth-file is required");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EACCES, "FID provided as auth-file, but no auth-file is required");
return;
}
}
if (fidmap_load(&ctx->parent_sess->fids, req->fid)) {
- lib9p_error(&ctx->ctx, LINUX_EBADF, "FID already in use");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EBADF, "FID already in use");
return;
}
- struct lib9p_srv_file rootdir = ctx->parent_sess->parent_conn->parent_srv->rootdir(&subctx, req->aname.utf8);
- if (lib9p_ctx_has_error(&ctx->ctx))
+ struct lib9p_srv_file rootdir = srv->rootdir(&ctx->ctx, req->aname.utf8);
+ if (lib9p_ctx_has_error(&ctx->ctx.basectx))
return;
- struct lib9p_stat stat = rootdir.vtable.stat(&subctx, rootdir.impldata);
- if (lib9p_ctx_has_error(&ctx->ctx)) {
+ struct lib9p_stat stat = rootdir.vtable.stat(&ctx->ctx, rootdir.impldata);
+ if (lib9p_ctx_has_error(&ctx->ctx.basectx)) {
if (rootdir.vtable.free)
- rootdir.vtable.free(&subctx, rootdir.impldata);
+ rootdir.vtable.free(&ctx->ctx, rootdir.impldata);
return;
}
struct lib9p_srv_file *rootdir_ptr = fidmap_store(&ctx->parent_sess->fids, req->fid, rootdir);
if (!rootdir_ptr) {
- lib9p_error(&ctx->ctx, LINUX_EMFILE, "too many open files");
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EMFILE, "too many open files");
if (rootdir.vtable.free)
- rootdir.vtable.free(&subctx, rootdir.impldata);
+ rootdir.vtable.free(&ctx->ctx, rootdir.impldata);
return;
}
@@ -471,54 +500,93 @@ static void handle_Tattach(struct lib9p_req *ctx, struct lib9p_msg_Tattach *req,
return;
}
-static void handle_Tflush(struct lib9p_req *ctx, struct lib9p_msg_Tflush *UNUSED(req), struct lib9p_msg_Rflush *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "flush not yet implemented");
+static void handle_Tflush(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tflush *UNUSED(req),
+ struct lib9p_msg_Rflush *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "flush not yet implemented");
}
-static void handle_Twalk(struct lib9p_req *ctx, struct lib9p_msg_Twalk *UNUSED(req), struct lib9p_msg_Rwalk *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "walk not yet implemented");
+static void handle_Twalk(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Twalk *UNUSED(req),
+ struct lib9p_msg_Rwalk *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "walk not yet implemented");
}
-static void handle_Topen(struct lib9p_req *ctx, struct lib9p_msg_Topen *UNUSED(req), struct lib9p_msg_Ropen *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "open not yet implemented");
+static void handle_Topen(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Topen *UNUSED(req),
+ struct lib9p_msg_Ropen *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "open not yet implemented");
}
-static void handle_Tcreate(struct lib9p_req *ctx, struct lib9p_msg_Tcreate *UNUSED(req), struct lib9p_msg_Rcreate *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "create not yet implemented");
+static void handle_Tcreate(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tcreate *UNUSED(req),
+ struct lib9p_msg_Rcreate *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "create not yet implemented");
}
-static void handle_Tread(struct lib9p_req *ctx, struct lib9p_msg_Tread *UNUSED(req), struct lib9p_msg_Rread *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "read not yet implemented");
+static void handle_Tread(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tread *UNUSED(req),
+ struct lib9p_msg_Rread *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "read not yet implemented");
}
-static void handle_Twrite(struct lib9p_req *ctx, struct lib9p_msg_Twrite *UNUSED(req), struct lib9p_msg_Rwrite *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "write not yet implemented");
+static void handle_Twrite(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Twrite *UNUSED(req),
+ struct lib9p_msg_Rwrite *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "write not yet implemented");
}
-static void handle_Tclunk(struct lib9p_req *ctx, struct lib9p_msg_Tclunk *UNUSED(req), struct lib9p_msg_Rclunk *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "clunk not yet implemented");
+static void handle_Tclunk(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tclunk *UNUSED(req),
+ struct lib9p_msg_Rclunk *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "clunk not yet implemented");
}
-static void handle_Tremove(struct lib9p_req *ctx, struct lib9p_msg_Tremove *UNUSED(req), struct lib9p_msg_Rremove *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "remove not yet implemented");
+static void handle_Tremove(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tremove *UNUSED(req),
+ struct lib9p_msg_Rremove *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "remove not yet implemented");
}
-static void handle_Tstat(struct lib9p_req *ctx, struct lib9p_msg_Tstat *UNUSED(req), struct lib9p_msg_Rstat *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "stat not yet implemented");
+static void handle_Tstat(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tstat *UNUSED(req),
+ struct lib9p_msg_Rstat *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "stat not yet implemented");
}
-static void handle_Twstat(struct lib9p_req *ctx, struct lib9p_msg_Twstat *UNUSED(req), struct lib9p_msg_Rwstat *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "wstat not yet implemented");
+static void handle_Twstat(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Twstat *UNUSED(req),
+ struct lib9p_msg_Rwstat *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "wstat not yet implemented");
}
-static void handle_Tsession(struct lib9p_req *ctx, struct lib9p_msg_Tsession *UNUSED(req), struct lib9p_msg_Rsession *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "session not yet implemented");
+static void handle_Tsession(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tsession *UNUSED(req),
+ struct lib9p_msg_Rsession *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "session not yet implemented");
}
-static void handle_Tsread(struct lib9p_req *ctx, struct lib9p_msg_Tsread *UNUSED(req), struct lib9p_msg_Rsread *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "sread not yet implemented");
+static void handle_Tsread(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tsread *UNUSED(req),
+ struct lib9p_msg_Rsread *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "sread not yet implemented");
}
-static void handle_Tswrite(struct lib9p_req *ctx, struct lib9p_msg_Tswrite *UNUSED(req), struct lib9p_msg_Rswrite *UNUSED(resp)) {
- lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "swrite not yet implemented");
+static void handle_Tswrite(struct _lib9p_srv_req *ctx,
+ struct lib9p_msg_Tswrite *UNUSED(req),
+ struct lib9p_msg_Rswrite *UNUSED(resp)) {
+ lib9p_error(&ctx->ctx.basectx,
+ LINUX_EOPNOTSUPP, "swrite not yet implemented");
}
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2024-11-22 00:10:28 +0000