summaryrefslogtreecommitdiff
path: root/9p
diff options
context:
space:
mode:
Diffstat (limited to '9p')
-rw-r--r--9p/9P2000.u.txt2
-rw-r--r--9p/defs.h9
-rw-r--r--9p/internal.h47
-rw-r--r--9p/srv.c205
-rw-r--r--9p/srv.h25
5 files changed, 223 insertions, 65 deletions
diff --git a/9p/9P2000.u.txt b/9p/9P2000.u.txt
index 20aea48..60d2b11 100644
--- a/9p/9P2000.u.txt
+++ b/9p/9P2000.u.txt
@@ -15,6 +15,6 @@ stat += "file_extension[s]"
"file_owner_n_gid[4]"
"file_last_modified_n_uid[4]"
-Tauth += "nxs_uname[4]"
+Tauth += "n_uname[4]"
Rerror += "errno[4]"
diff --git a/9p/defs.h b/9p/defs.h
index 20a6411..907cdde 100644
--- a/9p/defs.h
+++ b/9p/defs.h
@@ -13,6 +13,7 @@
#define P9_NOFID ((uint32_t)~0U)
enum p9_version {
+ P9_VER_UNINITIALIZED,
/* P9_VER_9P1, */
P9_VER_9P2000,
/*P9_VER_9P2000_u,*/
@@ -21,13 +22,9 @@ enum p9_version {
_P9_VER_CNT,
};
-struct p9_ctx {
- enum p9_version version;
- uint32_t max_msg_size;
+struct p9_ctx;
- uint32_t err_num;
- char err_msg[256]; /* I chose 256 arbitrarily. */
-};
+enum p9_version p9_ctx_version(p9_ctx *);
/** Write an static error into ctx, return -1. */
int p9_error(struct p9_ctx *ctx, uint32_t linux_errno, char const *msg);
diff --git a/9p/internal.h b/9p/internal.h
index 1bc0e92..61977d4 100644
--- a/9p/internal.h
+++ b/9p/internal.h
@@ -7,15 +7,36 @@
#ifndef _9P_INTERNAL_H_
#define _9P_INTERNAL_H_
+#include <assert.h>
#include <stdint.h>
#include <stdbool.h>
#include "9p/defs.h"
+#define USE_CONFIG_9P
+#include "config.h"
+static_assert(CONFIG_9P_MAX_ERR_SIZE <= UINT16_MAX);
+
/* C language *****************************************************************/
#define UNUSED(name) /* name __attribute__ ((unused)) */
+/* types **********************************************************************/
+
+struct p9_ctx {
+ enum p9_version version;
+ uint32_t max_msg_size;
+ uint32_t Rerror_overhead;
+
+ uint32_t err_num;
+ char err_msg[CONFIG_9P_MAX_ERR_SIZE];
+};
+
+static inline enum p9_version p9_ctx_version(p9_ctx *ctx) {
+ assert(ctx);
+ return ctx->version;
+}
+
/* vtables ********************************************************************/
typedef bool (*_checksize_fn_t)(uint32_t net_len, uint8_t *net_bytes, uint32_t *mut_net_offset, size_t *mut_host_extra);
@@ -65,26 +86,30 @@ static inline uint64_t decode_u64le(uint8_t *in) {
;
}
-static inline bool is_valid_utf8_without_nul(uint8_t *str, size_t len) {
- uint8_t mask;
+static inline bool _is_valid_utf8(uint8_t *str, size_t len, bool forbid_nul) {
+ uint32_t ch;
uint8_t chlen;
+ assert(str);
for (size_t pos = 0; pos < len;) {
- if ((str[pos] & 0b10000000) == 0b00000000) { mask = 0b01111111; chlen = 1; }
- else if ((str[pos] & 0b11100000) == 0b11000000) { mask = 0b00011111; chlen = 2; }
- else if ((str[pos] & 0b11110000) == 0b11100000) { mask = 0b00001111; chlen = 3; }
- else if ((str[pos] & 0b11111000) == 0b11110000) { mask = 0b00000111; chlen = 4; }
+ if ((str[pos] & 0b10000000) == 0b00000000) { ch = str[pos] & 0b01111111; chlen = 1; }
+ else if ((str[pos] & 0b11100000) == 0b11000000) { ch = str[pos] & 0b00011111; chlen = 2; }
+ else if ((str[pos] & 0b11110000) == 0b11100000) { ch = str[pos] & 0b00001111; chlen = 3; }
+ else if ((str[pos] & 0b11111000) == 0b11110000) { ch = str[pos] & 0b00000111; chlen = 4; }
else return false;
- if (pos + chlen > len || (str[pos] & mask) == 0) return false;
- switch (chlen) {
- case 4: if ((str[pos+3] & 0b11000000) != 0b10000000) return false; /* fallthrough */
- case 3: if ((str[pos+2] & 0b11000000) != 0b10000000) return false; /* fallthrough */
- case 2: if ((str[pos+1] & 0b11000000) != 0b10000000) return false; /* fallthrough */
+ if ((ch == 0 && (chlen != 1 || forbid_nul)) || pos + chlen > len) return false;
+ for (uint8_t i = 1; i < chlen; i++) {
+ if ((str[pos+i] & 0b11000000) != 0b10000000) return false;
+ ch = (ch << 6) | (str[pos+i] & 0b00111111);
}
+ if (ch > 0x10FFFF) return false;
pos += chlen;
}
return true;
}
+#define is_valid_utf8(str, len) _is_valid_utf8(str, len, false)
+#define is_valid_utf8_without_nul(str, len) _is_valid_utf8(str, len, true)
+
/* marshal utilities **********************************************************/
static inline void encode_u8le(uint8_t in, uint8_t *out) {
diff --git a/9p/srv.c b/9p/srv.c
index f7c8195..652a76b 100644
--- a/9p/srv.c
+++ b/9p/srv.c
@@ -1,44 +1,191 @@
-#include "net9p.h"
-#include "net9p_defs.h"
+#include <assert.h>
+
+#include "coroutine.h"
#include "netio.h"
+#include "9p/9p.h"
-#define MAX_MSG_SIZE 1024
+#include "9p/internal.h"
-int read_msg(int conn, uint16_t *out_tag, void **out_body) {
- uint8_t buf[MAX_MSG_SIZE];
- size_t todo = 7, done = 0;
+struct p9_srvconn {
+ /* immutable */
+ p9_srv *srv;
+ cid_t reader;
+ int fd;
+ /* mutable */
+ uint32_t max_msg_size;
+ enum p9_version version;
+ unsigned int refcount;
+};
- while (done < todo) {
- ssize_t r = netio_read(conn, buf, 7);
- if (r < 0)
- return r;
- done += r;
- }
- todo = docode_u32le(buf);
- if (todo < 7)
- return -EINVAL;
- while (done < todo) {
- ssize_t r = netio_read(conn, buf, 7);
- if (r < 0)
- return r;
- done += r;
- }
- return v9fs_unmarshal_msg(buf, out_tag, out_body);
-}
+struct p9_srvreq {
+ p9_srvconn *conn;
+ uint8_t *msg;
+};
+
+COROUTINE p9_srv_read_cr(void *_srv) {
+ uint8_t buf[CONFIG_9P_MAX_MSG_SIZE];
-void net9p_cr(void *_arg) {
- int sock = *((int *)_arg);
+ p9_srv *srv = _srv;
+ assert(srv);
cr_begin();
for (;;) {
- int conn = netio_accept(sock);
- if (conn < 0) {
- error(0, -conn, "netio_accept");
+ struct p9_srvconn conn = {
+ .srv = srv,
+ .reader = cr_getcid();
+
+ .max_msg_size = CONFIG_9P_MAX_MSG_SIZE;
+ .version = P9_VER_UNINITIALIZED;
+ .refcount = 1,
+ };
+ conn.fd = netio_accept(srv->sockfd);
+ if (conn.fd < 0) {
+ fprintf(stderr, "error: accept: %m", -conn.fd);
continue;
}
-
+ for (;;) {
+ /* Read the message size. */
+ size_t goal = 4, done = 0;
+ while (done < goal) {
+ ssize_t r = netio_read(conn.fd, &buf[done], sizeof(buf)-done);
+ if (r < 0) {
+ fprintf(stderr, "error: read: %m", -r);
+ goto close;
+ } else if (r == 0) {
+ if (done != 0)
+ fprintf(stderr, "error: read: unexpected EOF");
+ goto close;
+ }
+ done += r;
+ }
+ goal = decode_u32le(buf);
+ if (goal < 7) {
+ /* We can't respond with an Rerror becuase we wouldn't know what tag to use! */
+ fprintf(stderr, "error: T-message is impossibly small");
+ goto close;
+ }
+ if (goal > conn.max_msg_size) {
+ struct p9_ctx ctx = {
+ .version = conn.version,
+ .max_msg_size = conn.max_msg_size,
+ };
+ if (initialized)
+ p9_errorf(&ctx, LINUX_EMSGSIZE, "T-message larger than negotiated limit (%zu > %zu)", goal, conn.max_msg_size);
+ else
+ p9_errorf(&ctx, LINUX_EMSGSIZE, "T-message larger than server limit (%zu > %zu)", goal, conn.max_msg_size);
+ marshal_error(&ctx, buf);
+ netio_write(conn.fd, buf, decode_u32le(buf));
+ continue;
+ }
+ /* Read the rest of the message. */
+ while (done < goal) {
+ ssize_t r = netio_read(conn.fd, &buf[done], sizeof(buf)-done);
+ if (r < 0) {
+ fprintf(stderr, "error: read: %m", -r);
+ goto close;
+ } else if (r == 0) {
+ fprintf(stderr, "error: read: unexpected EOF");
+ goto close;
+ }
+ done += r;
+ }
+
+ /* Handle the message... */
+ if (conn.version == P9_VER_UNINITIALIZED) {
+ /* ...synchronously if we haven't negotiated the protocol yet, ... */
+ handle_message(&conn, buf);
+ } else {
+ /* ...asynchronously if we have. */
+ cr_chan_send(&srv->reqch, buf);
+ cr_pause_and_yield();
+ }
+ }
+ close:
+ netio_close(conn.fd, true, (--conn.refcount) == 0);
+ if (conn.refcount) {
+ cr_pause_and_yield();
+ assert(conn.refcount == 0);
+ netio_close(conn.fd, false, true);
+ }
}
cr_end();
}
+
+COROUTINE p9_srv_write_cr(void *_srv) {
+ uint8_t net[CONFIG_9P_MAX_MSG_SIZE];
+
+ p9_srv *srv = _srv;
+ assert(srv);
+ cr_begin();
+
+ for (;;) {
+ struct p9_srvreq req;
+ cr_chan_recv(&srv->reqch, &req);
+ memcpy(net, req.msg, decode_u32le(req.msg));
+ req.conn->refcount++;
+ cr_unpause(req.conn->reader);
+
+ handle_message(&req.conn, net);
+
+ if ((--req.conn->refcount) == 0)
+ cr_unpause(req.conn->reader);
+ }
+
+ cr_end();
+}
+
+void handle_message(p9_srvconn *conn, uint8_t *net) {
+ uint8_t host[CONFIG_9P_MAX_MSG_SIZE];
+
+ struct p9_ctx ctx = {
+ .version = req.conn->version,
+ .max_msg_size = req.conn->max_msg_size,
+ };
+
+ size_t host_size = p9_unmarshal_size(&ctx, net);
+ if (host_size == (size_t)-1)
+ goto write;
+ if (host_size > sizeof(host)) {
+ p9_errorf(&ctx, LINUX_EMSGSIZE, "unmarshalled payload larger than server limit (%zu > %zu)", host_size, sizeof(host));
+ goto write;
+ }
+
+ uint16_t tag;
+ uint8_t typ = p9_unmarshal(&ctx, net, &tag, host);
+ if (typ == (uint8_t)-1)
+ goto write;
+ if (typ % 2 != 0) {
+ p9_errorf(&ctx, LINUX_EOPNOTSUPP, "expected a T-message but got an R-message");
+ goto write;
+ }
+
+ TODO;
+
+ write:
+ if (ctx.err_num || ctx.err_msg[0])
+ marshal_error(&ctx, net);
+ else
+ TODO;
+ netio_write(req.conn->fd, net, decode_u32le(net));
+}
+
+static inline uint16_t min_u16(uint16_t a, b) {
+ return (a < b) ? a : b;
+}
+
+/* We have special code for marshaling Rerror because we don't ever
+ * want to produce an error because the err_msg is too long for the
+ * `ctx->max_msg_size`! */
+void marshal_error(struct p9_ctx *ctx, uint16_t tag, uint8_t *net) {
+ struct p9_msg_Rerror host = {
+ .ename = {
+ .len = strnlen(ctx->err_msg, CONFIG_9P_MAX_ERR_SIZE),
+ .utf8 = ctx->err_msg,
+ },
+ };
+ if (host.ename.len + ctx->Rerror_overhead > ctx->max_msg_size)
+ host.ename.len = ctx->max_msg_size - overhead;
+ p9_marshal(ctx, tag, host, net);
+}
diff --git a/9p/srv.h b/9p/srv.h
index 32a2e30..e3623ed 100644
--- a/9p/srv.h
+++ b/9p/srv.h
@@ -3,25 +3,14 @@
#include "coroutine.h"
-#define 9P_DEFAULT_PORT 564
+struct p9_srvreq;
-/**
- * The default here is the same as in Plan 9 4e's lib9p. It's sized
- * so that a Twrite message can return 8KiB of data; it uses the
- * default (1024*8)+24 with the comment that "24" is "ample room for
- * Twrite/Rread header (iounit)". In fact, the Twrite header is only
- * 23 bytes ("size[4] Twrite[1] tag[2] fid[4] offset[8] count[4]") and
- * the Rread header is even shorter at 11 bytes ("size[4] Rread[1]
- * tag[2] count[4]"), so "24" appears to be the size of the Twrite
- * header rounded up to a nice round number.
- *
- * In older versions of 9P ("9P1"), the max message size was defined
- * as part of the protocol specification rather than negotiated. In
- * Plan 9 1e it was (1024*8)+128, and was bumped to (1024*8)+160 in 2e
- * and 3e.
- */
-#define 9P_DEFAULT_MAX_MSG_SIZE ((1024*8)+24)
+struct p9_srv {
+ int sockfd;
+ cr_chan_t(p9_srvreq *) reqch;
+};
-COROUTINE net9p_cr(void *);
+COROUTINE p9_srv_read_cr(void *_srv);
+COROUTINE p9_srv_write_cr(void *_srv);
#endif /* _NET9P_H_ */
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2025-04-06 04:51:25 +0000