summaryrefslogtreecommitdiff
path: root/9p
diff options
context:
space:
mode:
Diffstat (limited to '9p')
-rw-r--r--9p/.editorconfig3
-rw-r--r--9p/.gitignore5
-rw-r--r--9p/9P2000.L.txt56
-rw-r--r--9p/9P2000.e.txt11
-rw-r--r--9p/9P2000.txt82
-rw-r--r--9p/9P2000.u.txt20
-rwxr-xr-x9p/generate541
-rwxr-xr-x9p/linux-errno.h.gen33
-rw-r--r--9p/misc.txt24
-rw-r--r--9p/srv.c44
-rw-r--r--9p/srv.h8
11 files changed, 827 insertions, 0 deletions
diff --git a/9p/.editorconfig b/9p/.editorconfig
new file mode 100644
index 0000000..3de59d7
--- /dev/null
+++ b/9p/.editorconfig
@@ -0,0 +1,3 @@
+[{generate,linux-errno.h.gen}]
+indent_style = space
+indent_size = 4
diff --git a/9p/.gitignore b/9p/.gitignore
new file mode 100644
index 0000000..c8e8c58
--- /dev/null
+++ b/9p/.gitignore
@@ -0,0 +1,5 @@
+/9P2000.c
+/9P2000.h
+/9P2000.*.c
+/9P2000.*.h
+/linux-errno.h
diff --git a/9p/9P2000.L.txt b/9p/9P2000.L.txt
new file mode 100644
index 0000000..71ab171
--- /dev/null
+++ b/9p/9P2000.L.txt
@@ -0,0 +1,56 @@
+# 9P2000.L.txt - Definitions of 9P2000.L messages
+#
+# Copyright (C) 2024 Luke T. Shumaker <lukeshu@lukeshu.com>
+# SPDX-Licence-Identifier: AGPL-3.0-or-later
+
+# "9P2000.L" Linux extension
+# https://github.com/chaos/diod/blob/master/protocol.md
+version "9P2000.L"
+
+from 9P2000.txt import *
+from 9P2000.u.txt import Tauth, Tattach
+
+#6/Tlerror = "illegal" # analogous to 106/Terror
+7/Rlerror = "ecode[4]" # analogous to 107/Rerror
+8/Tstatfs = "TODO"
+9/Rstatfs = "TODO"
+12/Tlopen = "TODO" # analogous to 112/Topen
+13/Rlopen = "TODO" # analogous to 113/Ropen
+14/Tlcreate = "TODO" # analogous to 114/Tcreate
+15/Rlcreate = "TODO" # analogous to 115/Rcreate
+16/Tsymlink = "TODO"
+17/Rsymlink = "TODO"
+18/Tmknod = "TODO"
+19/Rmknod = "TODO"
+20/Trename = "TODO"
+21/Rrename = "TODO"
+22/Treadlink = "TODO"
+23/Rreadlink = "TODO"
+24/Tgetattr = "TODO"
+25/Rgetattr = "TODO"
+26/Tsetattr = "TODO"
+27/Rsetattr = "TODO"
+#...
+30/Txattrwalk = "TODO"
+31/Rxattrwalk = "TODO"
+32/Txattrcreate = "TODO"
+33/Rxattrcreate = "TODO"
+#...
+40/Treaddir = "TODO"
+41/Rreaddir = "TODO"
+#...
+50/Tfsync = "TODO"
+51/Rfsync = "TODO"
+52/Tlock = "TODO"
+53/Rlock = "TODO"
+54/Tgetlock = "TODO"
+55/Rgetlock = "TODO"
+# ...
+70/Tlink = "TODO"
+71/Rlink = "TODO"
+72/Tmkdir = "TODO"
+73/Tmkdir = "TODO"
+74/Trenameat = "TODO"
+75/Rrenameat = "TODO"
+76/Tunlinkat = "TODO"
+77/Runlinkat = "TODO"
diff --git a/9p/9P2000.e.txt b/9p/9P2000.e.txt
new file mode 100644
index 0000000..f926dc0
--- /dev/null
+++ b/9p/9P2000.e.txt
@@ -0,0 +1,11 @@
+# 9P2000e.e.txt - Definitions of 9P2000.e messages
+#
+# Copyright (C) 2024 Luke T. Shumaker <lukeshu@lukeshu.com>
+# SPDX-Licence-Identifier: AGPL-3.0-or-later
+
+# "9P2000.e" Erlang extension
+# https://erlangonxen.org/more/9p2000e
+# https://github.com/cloudozer/ling/blob/master/doc/9p2000e.md
+version "9P2000.e"
+
+# TODO
diff --git a/9p/9P2000.txt b/9p/9P2000.txt
new file mode 100644
index 0000000..778673f
--- /dev/null
+++ b/9p/9P2000.txt
@@ -0,0 +1,82 @@
+# 9P2000.txt - Definitions of 9P2000 messages
+#
+# Copyright (C) 2024 Luke T. Shumaker <lukeshu@lukeshu.com>
+# SPDX-Licence-Identifier: AGPL-3.0-or-later
+
+# The format of each message (excluding the "size[4] msg_type[1]
+# tag[2]" header) is written here as a sequence of
+# "member_name[member_type]" struct members.
+#
+# The primitive member types types are the following single-character
+# mnemonics:
+#
+# - 1 = u8
+# - 2 = u16le
+# - 4 = u32le
+# - 8 = u16le
+
+# "9P2000" base protocol
+# https://ericvh.github.io/9p-rfc/rfc9p2000.html
+# https://github.com/ericvh/9p-rfc/blob/master/9p2000.xml
+#
+# But due to incompleteness of the draft RFC, the Plan 9 manual
+# section-5 and the Plan 9 headers (particularly fcall.h) are a better
+# references.
+version "9P2000"
+
+# data (u32le `n`, then `n` bytes of data)
+d = "len[8] len*(dat[1])"
+
+# string (u16le `n`, then `n` bytes of UTF-8)
+s = "len[2] len*(utf8[1])"
+
+# qid (TODO)
+qid = "type[1] vers[4] path[8]"
+
+# stat (TODO)
+stat = "stat_size[2]"
+ "kern_type[2]"
+ "kern_dev[4]"
+ "file_qid[qid]"
+ "file_mode[4]"
+ "file_atime[4]"
+ "file_mtime[4]"
+ "file_size[8]"
+ "file_name[s]"
+ "file_owner_uid[s]"
+ "file_owner_gid[s]"
+ "file_last_modified_uid[s]"
+
+# In the 9P protocol, each message has a type, and message types come
+# in pairs (except "Rerror"); "T" and "R"; "T" messages are
+# client->server requests, and "R" messages are server->client
+# responses (I do not know what the Plan 9 designers intended "T" and
+# "R" to stand for). The type of a message is represented by a u8 ID.
+100/Tversion = "max_msg_size[4] version[s]"
+101/Rversion = "max_msg_size[4] version[s]"
+102/Tauth = "afid[4] uname[s] aname[s]"
+103/Rauth = "aqid[qid]"
+104/Tattach = "fid[4] afid[4] uname[s] aname[s]"
+105/Rattach = "qid[qid]"
+#106/Terror = "illegal"
+107/Rerror = "ename[s]"
+108/Tflush = "oldtag[2]"
+109/Rflush = ""
+110/Twalk = "fid[4] newfid[4] nwname[2] nwname*(wname[s])"
+111/Rwalk = "nwqid[2] nwqid*(wqid[qid])"
+112/Topen = "fid[4] mode[1]"
+113/Ropen = "qid[qid] iounit[4]"
+114/Tcreate = "fid[4] name[s] perm[4] mode[1]"
+115/Rcreate = "qid[qid] iounit[4]"
+116/Tread = "fid[4] offset[8] count[4]"
+117/Rread = "data[d]" # for directories data is the sequence "cnt*(entries[stat])"
+118/Twrite = "fid[4] offset[8] data[d]"
+119/Rwrite = "count[4]"
+120/Tclunk = "fid[4]"
+121/Rclunk = ""
+122/Tremove = "fid[4]"
+123/Rremove = ""
+124/Tstat = "fid[4]"
+125/Rstat = "stat[stat]"
+126/Twstat = "fid[4] stat[stat]"
+127/Rwstat = ""
diff --git a/9p/9P2000.u.txt b/9p/9P2000.u.txt
new file mode 100644
index 0000000..20aea48
--- /dev/null
+++ b/9p/9P2000.u.txt
@@ -0,0 +1,20 @@
+# 9P2000.u.txt - Definitions of 9P2000.u messages
+#
+# Copyright (C) 2024 Luke T. Shumaker <lukeshu@lukeshu.com>
+# SPDX-Licence-Identifier: AGPL-3.0-or-later
+
+# "9P2000.u" Unix extension
+# https://ericvh.github.io/9p-rfc/rfc9p2000.u.html
+# https://github.com/ericvh/9p-rfc/blob/master/9p2000.u.xml
+version "9P2000.u"
+
+from 9P2000.txt import *
+
+stat += "file_extension[s]"
+ "file_owner_n_uid[4]"
+ "file_owner_n_gid[4]"
+ "file_last_modified_n_uid[4]"
+
+Tauth += "nxs_uname[4]"
+
+Rerror += "errno[4]"
diff --git a/9p/generate b/9p/generate
new file mode 100755
index 0000000..6456609
--- /dev/null
+++ b/9p/generate
@@ -0,0 +1,541 @@
+#!/usr/bin/env python
+# 9p/generate - Generate C marshalers/unmarshalers for a .txt file
+# defining a 9P protocol variant.
+#
+# Copyright (C) 2024 Luke T. Shumaker <lukeshu@lukeshu.com>
+# SPDX-Licence-Identifier: AGPL-3.0-or-later
+
+import enum
+import re
+
+PROGRAM = "./9p/generate"
+
+# Parse the *.txt ##############################################################
+
+
+class Atom(enum.Enum):
+ u8 = 1
+ u16 = 2
+ u32 = 4
+ u64 = 8
+
+ @property
+ def name(self) -> str:
+ return str(self.value)
+
+ @property
+ def static_size(self) -> int:
+ return self.value
+
+
+# `msgid/structname = "member1 member2..."`
+# `structname = "member1 member2..."`
+# `structname += "member1 member2..."`
+class Struct:
+ msgid: int | None = None
+ name: str
+ members: list["Member"]
+
+ @property
+ def static_size(self) -> int | None:
+ size = 0
+ for member in self.members:
+ msize = member.static_size
+ if msize is None:
+ return None
+ size += msize
+ return size
+
+
+# `cnt*(name[typ])`
+# the `cnt*(...)` wrapper is optional
+class Member:
+ cnt: str | None = None
+ name: str
+ typ: Atom | Struct
+
+ @property
+ def static_size(self) -> int | None:
+ if self.cnt:
+ return None
+ return self.typ.static_size
+
+
+re_membername = "(?:[a-zA-Z_][a-zA-Z_0-9]*)"
+re_memberspec = (
+ f"(?:(?P<cnt>{re_membername})\\*\\()?(?P<name>{re_membername})\\[(?P<typ>.*)\\]\\)?"
+)
+
+
+def parse_members(
+ env: dict[str, Atom | Struct], existing: list[Member], specs: str
+) -> list[Member]:
+ ret = existing
+ for spec in specs.split():
+ m = re.fullmatch(re_memberspec, spec)
+ if not m:
+ raise SyntaxError(f"invalid member spec {repr(spec)}")
+
+ member = Member()
+
+ member.name = m.group("name")
+ if any(x.name == member.name for x in ret):
+ raise ValueError(f"duplicate member name {repr(member.name)}")
+
+ if m.group("typ") not in env:
+ raise NameError(f"Unknown type {repr(m.group(2))}")
+ member.typ = env[m.group("typ")]
+
+ if cnt := m.group("cnt"):
+ if len(ret) == 0 or ret[-1].name != cnt:
+ raise ValueError(f"list count must be previous item: {repr(cnt)}")
+ if not isinstance(ret[-1].typ, Atom):
+ raise ValueError(f"list count must be an integer type: {repr(cnt)}")
+ member.cnt = cnt
+
+ ret += [member]
+ return ret
+
+
+re_version = r'version\s+"(?P<version>[^"]+)"'
+re_structspec = (
+ r'(?:(?P<msgid>[0-9]+)/)?(?P<name>\S+)\s*(?P<op>\+?=)\s*"(?P<members>[^"]*)"'
+)
+re_structspec_cont = r'"(?P<members>[^"]*)"'
+
+
+def parse_file(filename: str) -> tuple[str, list[Struct]]:
+ version: str | None = None
+ env: dict[str, Atom | Struct] = {
+ "1": Atom.u8,
+ "2": Atom.u16,
+ "4": Atom.u32,
+ "8": Atom.u64,
+ }
+ with open(filename, "r") as fh:
+ prev: Struct | None = None
+ for line in fh:
+ line = line.split("#", 1)[0].strip()
+ if not line:
+ continue
+ if m := re.fullmatch(re_version, line):
+ if version:
+ raise SyntaxError("must have exactly 1 version line")
+ version = m.group("version")
+ elif m := re.fullmatch(re_structspec, line):
+ if m.group("op") == "+=" and m.group("msgid"):
+ raise SyntaxError("cannot += to a message that is not yet defined")
+ match m.group("op"):
+ case "=":
+ struct = Struct()
+ if m.group("msgid"):
+ struct.msgid = int(m.group("msgid"))
+ struct.name = m.group("name")
+ struct.members = parse_members(env, [], m.group("members"))
+ env[struct.name] = struct
+ prev = struct
+ case "+=":
+ if m.group("name") not in env:
+ raise NameError(f"Unknown type {repr(m.group('name'))}")
+ _struct = env[m.group("name")]
+ if not isinstance(_struct, Struct):
+ raise NameError(
+ f"Type {repr(m.group('name'))} is not a struct"
+ )
+ struct = _struct
+ struct.members = parse_members(
+ env, struct.members, m.group("members")
+ )
+ prev = struct
+ elif m := re.fullmatch(re_structspec_cont, line):
+ if not prev:
+ raise SyntaxError("continuation line must come after a struct line")
+ prev.members = parse_members(env, prev.members, m.group("members"))
+ else:
+ raise SyntaxError(f"invalid line {repr(line)}")
+ if not version:
+ raise SyntaxError("must have exactly 1 version line")
+ structs = [x for x in env.values() if isinstance(x, Struct)]
+ return version, structs
+
+
+# Generate C ###################################################################
+
+
+def c_typename(idprefix: str, typ: Atom | Struct) -> str:
+ match typ:
+ case Atom():
+ return f"uint{typ.value*8}_t"
+ case Struct():
+ if typ.msgid is not None:
+ return f"struct {idprefix}msg_{typ.name}"
+ return f"struct {idprefix}{typ.name}"
+ case _:
+ raise ValueError(f"not a type: {typ.__class__.__name__}")
+
+
+def gen_h(txtname: str, idprefix: str, structs: list[Struct]) -> str:
+ guard = (
+ "_"
+ + txtname.replace(".txt", ".h").upper().replace("/", "_").replace(".", "_")
+ + "_"
+ )
+ ret = f"""/* Generated by `{PROGRAM} {txtname}`. DO NOT EDIT! */
+
+#ifndef {guard}
+#define {guard}
+
+#define {idprefix.upper()}MIN_MSGLEN 7
+"""
+ ret += """
+/* non-message structs ********************************************************/
+
+"""
+ for struct in structs:
+ if struct.msgid is not None:
+ continue
+ ret += c_typename(idprefix, struct) + " {\n"
+ typewidth = max(
+ len(c_typename(idprefix, member.typ)) for member in struct.members
+ )
+ for member in struct.members:
+ ret += f"\t{c_typename(idprefix, member.typ).ljust(typewidth)} {'*' if member.cnt else ' '}{member.name};\n"
+ ret += "};\n"
+
+ ret += """
+/* message types **************************************************************/
+
+"""
+ ret += f"enum {idprefix}msg_type {{ /* uint8_t */\n"
+ namewidth = max(len(msg.name) for msg in structs if msg.msgid is not None)
+ for msg in structs:
+ if msg.msgid is None:
+ continue
+ ret += f"\t{idprefix.upper()}TYP_{msg.name.ljust(namewidth)} = {msg.msgid},\n"
+ ret += "};\n"
+
+ ret += """
+/* message structs ************************************************************/
+
+"""
+ for msg in structs:
+ if msg.msgid is None:
+ continue
+ if not msg.members:
+ ret += c_typename(idprefix, msg) + " {};\n"
+ continue
+ ret += c_typename(idprefix, msg) + " {\n"
+ typewidth = max(len(c_typename(idprefix, member.typ)) for member in msg.members)
+ for member in msg.members:
+ ret += f"\t{c_typename(idprefix, member.typ).ljust(typewidth)} {'*' if member.cnt else ' '}{member.name};\n"
+ ret += "};\n"
+
+ ret += f"""
+/* functions ******************************************************************/
+
+/**
+ * @param net_bytes : the complete request, starting with the "size[4]"
+ * @param out_tag : the message-ID tag
+ * @param out_body : a pointer that get set to the parsed body, whose
+ * type is known by the return value, will need to
+ * be free()d
+ * @return -{idprefix.upper()}E{{error}} on error, {idprefix.upper()}TYP_{{type}} on success
+ */
+int {idprefix}unmarshal_msg(uint8_t *net_bytes, uint16_t *out_tag, void **out_body);
+
+/**
+ * @param uint16_t in_msgid : the message-ID tag
+ * @param struct {idprefix}msg_{{type}} in_msg : the message to encode
+ * @param uint8_t *out_buf : the buffer to encode to
+ * @return uint32_t : the encoded length
+ */
+#define {idprefix}marshal_msg(in_msgid, in_msg, out_buf) _Generic((in_msg)"""
+ for msg in structs:
+ if msg.msgid is None:
+ continue
+ ret += f", \\\n\t\t{c_typename(idprefix, msg)}: _{idprefix}marshal_{msg.name}(in_msgid, in_msg, out_buf)"
+ ret += "\\\n\t)(in_msg)\n"
+ for msg in structs:
+ if msg.msgid is None:
+ continue
+ ret += f"uint32_t _{idprefix}marshal_{msg.name}(uint16_t in_msgid, {c_typename(idprefix, msg)} in_msg, uint8_t *out_buf);\n"
+
+ ret += "\n"
+ ret += f"#endif /* {guard} */\n"
+ return ret
+
+
+def gen_c(txtname: str, idprefix: str, structs: list[Struct]) -> str:
+ ret = f"""/* Generated by `{PROGRAM} {txtname}`. DO NOT EDIT! */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h> /* for malloc() */
+
+#include "{txtname.replace('.txt', '.h')}"
+"""
+
+ # basic utilities ##########################################################
+ ret += """
+/* basic utilities ************************************************************/
+
+#define UNUSED(name) /* name __attribute__ ((unused)) */
+
+static inline uint8_t decode_u8le(uint8_t *in) {
+ return in[0];
+}
+static inline uint16_t decode_u16le(uint8_t *in) {
+ return (((uint16_t)(in[0])) << 0)
+ | (((uint16_t)(in[1])) << 8)
+ ;
+}
+static inline uint32_t decode_u32le(uint8_t *in) {
+ return (((uint32_t)(in[0])) << 0)
+ | (((uint32_t)(in[1])) << 8)
+ | (((uint32_t)(in[2])) << 16)
+ | (((uint32_t)(in[3])) << 24)
+ ;
+}
+static inline uint64_t decode_u64le(uint8_t *in) {
+ return (((uint64_t)(in[0])) << 0)
+ | (((uint64_t)(in[1])) << 8)
+ | (((uint64_t)(in[2])) << 16)
+ | (((uint64_t)(in[3])) << 24)
+ | (((uint64_t)(in[4])) << 32)
+ | (((uint64_t)(in[5])) << 40)
+ | (((uint64_t)(in[6])) << 48)
+ | (((uint64_t)(in[7])) << 56)
+ ;
+}
+
+static inline void encode_u8le(uint8_t in, uint8_t *out) {
+ out[0] = in;
+}
+static inline void encode_u16le(uint16_t in, uint8_t *out) {
+ out[0] = (uint8_t)((in >> 0) & 0xFF);
+ out[1] = (uint8_t)((in >> 8) & 0xFF);
+}
+static inline void encode_u32le(uint32_t in, uint8_t *out) {
+ out[0] = (uint8_t)((in >> 0) & 0xFF);
+ out[1] = (uint8_t)((in >> 8) & 0xFF);
+ out[2] = (uint8_t)((in >> 16) & 0xFF);
+ out[3] = (uint8_t)((in >> 24) & 0xFF);
+}
+static inline void encode_u64le(uint64_t in, uint8_t *out) {
+ out[0] = (uint8_t)((in >> 0) & 0xFF);
+ out[1] = (uint8_t)((in >> 8) & 0xFF);
+ out[2] = (uint8_t)((in >> 16) & 0xFF);
+ out[3] = (uint8_t)((in >> 24) & 0xFF);
+ out[4] = (uint8_t)((in >> 32) & 0xFF);
+ out[5] = (uint8_t)((in >> 40) & 0xFF);
+ out[6] = (uint8_t)((in >> 48) & 0xFF);
+ out[7] = (uint8_t)((in >> 56) & 0xFF);
+}
+"""
+
+ def used(arg: str) -> str:
+ return arg
+
+ def unused(arg: str) -> str:
+ return f"UNUSED({arg})"
+
+ # checksize_* ##############################################################
+ ret += """
+/* checksize_* ****************************************************************/
+
+typedef bool (*_checksize_fn_t)(uint32_t net_len, uint8_t *net_bytes, uint32_t *mut_net_offset, size_t *mut_host_extra);
+static inline bool _checksize_list(size_t cnt, _checksize_fn_t fn, size_t host_size,
+ uint32_t net_len, uint8_t *net_bytes, uint32_t *mut_net_offset, size_t *mut_host_extra) {
+ for (size_t i = 0; i < cnt; i++)
+ if (__builtin_add_overflow(*mut_host_extra, host_size, mut_host_extra)
+ || fn(net_len, net_bytes, mut_net_offset, mut_host_extra))
+ return true;
+ return false;
+}
+static inline bool checksize_1(uint32_t net_len, uint8_t *UNUSED(net_bytes), uint32_t *mut_net_offset, size_t *UNUSED(mut_host_extra)) {
+ return __builtin_add_overflow(*mut_net_offset, 1, mut_net_offset) || net_len < *mut_net_offset;
+}
+static inline bool checksize_2(uint32_t net_len, uint8_t *UNUSED(net_bytes), uint32_t *mut_net_offset, size_t *UNUSED(mut_host_extra)) {
+ return __builtin_add_overflow(*mut_net_offset, 2, mut_net_offset) || net_len < *mut_net_offset;
+}
+static inline bool checksize_4(uint32_t net_len, uint8_t *UNUSED(net_bytes), uint32_t *mut_net_offset, size_t *UNUSED(mut_host_extra)) {
+ return __builtin_add_overflow(*mut_net_offset, 4, mut_net_offset) || net_len < *mut_net_offset;
+}
+static inline bool checksize_8(uint32_t net_len, uint8_t *UNUSED(net_bytes), uint32_t *mut_net_offset, size_t *UNUSED(mut_host_extra)) {
+ return __builtin_add_overflow(*mut_net_offset, 8, mut_net_offset) || net_len < *mut_net_offset;
+}
+"""
+ for struct in structs:
+ argfn = used if struct.members else unused
+ ret += f"static inline bool checksize_{struct.name}(uint32_t {argfn('net_len')}, uint8_t *{argfn('net_bytes')}, uint32_t *{argfn('mut_net_offset')}, size_t *{argfn('mut_host_extra')}) {{\n"
+ if len(struct.members) == 0:
+ ret += "\treturn false;\n"
+ ret += "}\n"
+ continue
+ prefix0 = "\treturn "
+ prefix1 = "\t || "
+ prefix2 = "\t "
+ prefix = prefix0
+ prev_size: int | None = None
+ for member in struct.members:
+ if member.cnt is not None:
+ assert prev_size
+ ret += f"\n{prefix }_checksize_list(decode_u{prev_size*8}le(&net_bytes[(*mut_net_offset)-{prev_size}]), checksize_{member.typ.name}, sizeof({c_typename(idprefix, member.typ)}),"
+ ret += f"\n{prefix2} net_len, net_bytes, mut_net_offset, mut_host_extra)"
+ else:
+ ret += f"\n{prefix}checksize_{member.typ.name}(net_len, net_bytes, mut_net_offset, mut_host_extra)"
+ prefix = prefix1
+ prev_size = member.static_size
+ if struct.name == "s":
+ ret += (
+ f"\n{prefix}__builtin_add_overflow(*mut_host_extra, 1, mut_host_extra)"
+ )
+ ret += ";\n}\n"
+
+ # unmarshal_* ##############################################################
+ ret += """
+/* unmarshal_* ****************************************************************/
+/* checksize_XXX() should be called before unmarshal_XXX(). */
+
+static inline void unmarshal_1(uint8_t *net_bytes, uint32_t *mut_net_offset, void **UNUSED(mut_host_extra), uint8_t *out) {
+ *out = decode_u8le(&net_bytes[*mut_net_offset]);
+ *mut_net_offset += 1;
+}
+static inline void unmarshal_2(uint8_t *net_bytes, uint32_t *mut_net_offset, void **UNUSED(mut_host_extra), uint16_t *out) {
+ *out = decode_u16le(&net_bytes[*mut_net_offset]);
+ *mut_net_offset += 2;
+}
+static inline void unmarshal_4(uint8_t *net_bytes, uint32_t *mut_net_offset, void **UNUSED(mut_host_extra), uint32_t *out) {
+ *out = decode_u32le(&net_bytes[*mut_net_offset]);
+ *mut_net_offset += 4;
+}
+static inline void unmarshal_8(uint8_t *net_bytes, uint32_t *mut_net_offset, void **UNUSED(mut_host_extra), uint64_t *out) {
+ *out = decode_u64le(&net_bytes[*mut_net_offset]);
+ *mut_net_offset += 8;
+}
+"""
+ for struct in structs:
+ argfn = used if struct.members else unused
+ ret += f"static inline void unmarshal_{struct.name}(uint8_t *{argfn('net_bytes')}, uint32_t *{argfn('mut_net_offset')}, void **{argfn('mut_host_extra')}, {c_typename(idprefix, struct)} *{argfn('out')}) {{"
+ if len(struct.members) == 0:
+ ret += "}\n"
+ continue
+ ret += "\n"
+ for member in struct.members:
+ if member.cnt:
+ ret += f"\tout->{member.name} = *mut_host_extra;\n"
+ ret += f"\t*mut_host_extra += sizeof(*out->{member.name}) * out->{member.cnt};\n"
+ ret += f"\tfor (typeof(out->{member.cnt}) i = 0; i < out->{member.cnt}; i++)\n"
+ ret += f"\t\tunmarshal_{member.typ.name}(net_bytes, mut_net_offset, mut_host_extra, &(out->{member.name}[i]));\n"
+ else:
+ ret += f"\tunmarshal_{member.typ.name}(net_bytes, mut_net_offset, mut_host_extra, &(out->{member.name}));\n"
+ ret += "}\n"
+
+ # unmarshal_msg ############################################################
+ ret += f"""
+/* unmarshal_msg **************************************************************/
+
+int {idprefix}unmarshal_msg(uint8_t *net_bytes, uint16_t *out_tag, void **out_body) {{
+ uint32_t net_len = decode_u32le(net_bytes);
+ if (net_len < 7)
+ return -LINUX_EWRONGSIZE;
+ uint8_t typ = net_bytes[4];
+ *out_tag = decode_u16le(&net_bytes[5]);
+
+ uint32_t net_offset = 7;
+ size_t host_size;
+ void *host_extra;
+ switch (typ) {{
+"""
+ for msg in structs:
+ if msg.msgid is None:
+ continue
+ ret += f"\tcase {idprefix.upper()}TYP_{msg.name}:\n"
+ ret += f"\t\thost_size = sizeof({c_typename(idprefix, msg)});\n"
+ ret += f"\t\tif (checksize_{msg.name}(net_len, net_bytes, &net_offset, &host_size))\n"
+ ret += "\t\t\treturn -LINUX_EWRONGSIZE;\n"
+ ret += "\n"
+ ret += "\t\t*out_body = malloc(host_size);"
+ ret += "\n"
+ ret += "\t\tnet_offset = 7;\n"
+ ret += f"\t\thost_extra = *out_body + sizeof({c_typename(idprefix, msg)});\n"
+ ret += f"\t\tunmarshal_{msg.name}(net_bytes, &net_offset, &host_extra, *out_body);\n"
+ ret += "\n"
+ ret += "\t\tbreak;\n"
+ ret += """
+ default:
+ return -LINUX_EOPNOTSUPP;
+ }
+ return typ;
+}
+"""
+
+ # marshal_* ################################################################
+ ret += """
+/* marshal_* ******************************************************************/
+
+static inline void marshal_1(uint8_t val, uint8_t *out_net_bytes, uint32_t *mut_net_offset) {
+ out_net_bytes[*mut_net_offset] = val;
+ *mut_net_offset += 1;
+}
+static inline void marshal_2(uint16_t val, uint8_t *out_net_bytes, uint32_t *mut_net_offset) {
+ encode_u16le(val, &out_net_bytes[*mut_net_offset]);
+ *mut_net_offset += 2;
+}
+static inline void marshal_4(uint32_t val, uint8_t *out_net_bytes, uint32_t *mut_net_offset) {
+ encode_u32le(val, &out_net_bytes[*mut_net_offset]);
+ *mut_net_offset += 4;
+}
+static inline void marshal_8(uint64_t val, uint8_t *out_net_bytes, uint32_t *mut_net_offset) {
+ encode_u64le(val, &out_net_bytes[*mut_net_offset]);
+ *mut_net_offset += 8;
+}
+"""
+ for struct in structs:
+ argfn = used if struct.members else unused
+ ret += f"static inline void marshal_{struct.name}({c_typename(idprefix, struct)} {argfn('val')}, uint8_t *{argfn('out_net_bytes')}, uint32_t *{argfn('mut_net_offset')}) {{"
+ if len(struct.members) == 0:
+ ret += "}\n"
+ continue
+ ret += "\n"
+ for member in struct.members:
+ if member.cnt:
+ ret += f"\tfor (typeof(val.{member.cnt}) i = 0; i < val.{member.cnt}; i++)\n"
+ ret += f"\t\tmarshal_{member.typ.name}(val.{member.name}[i], out_net_bytes, mut_net_offset);\n"
+ else:
+ ret += f"\tmarshal_{member.typ.name}(val.{member.name}, out_net_bytes, mut_net_offset);\n"
+ ret += "}\n"
+
+ # _marshal_msg_* ###########################################################
+ ret += """
+/* _marshal_msg_* *************************************************************/
+
+"""
+ for msg in structs:
+ if msg.msgid is None:
+ continue
+ ret += f"uint32_t _{idprefix}marshal_{msg.name}(uint16_t in_msgid, {c_typename(idprefix, msg)} in_msg, uint8_t *out_buf) {{\n"
+ ret += "\tuint32_t offset = 4;\n"
+ ret += f"\tmarshal_1({idprefix.upper()}TYP_{msg.name}, out_buf, &offset);\n"
+ ret += "\tmarshal_2(in_msgid, out_buf, &offset);\n"
+ ret += f"\tmarshal_{msg.name}(in_msg, out_buf, &offset);\n"
+ ret += "\tencode_u32le(offset, out_buf);\n"
+ ret += "\treturn offset;\n"
+ ret += "}\n"
+ ret += "\n"
+
+ ############################################################################
+ return ret
+
+
+################################################################################
+
+if __name__ == "__main__":
+ import sys
+
+ for txtname in sys.argv[1:]:
+ version, structs = parse_file(txtname)
+ with open(txtname.replace(".txt", ".h"), "w") as fh:
+ fh.write(gen_h(txtname, "p9_", structs))
+ with open(txtname.replace(".txt", ".c"), "w") as fh:
+ fh.write(gen_c(txtname, "p9_", structs))
diff --git a/9p/linux-errno.h.gen b/9p/linux-errno.h.gen
new file mode 100755
index 0000000..749cd8e
--- /dev/null
+++ b/9p/linux-errno.h.gen
@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+
+
+def print_errnos(txtlists: list[str]) -> None:
+ print(
+ f"/* Generated by `./9p/linux-errno.h.gen {' '.join(txtlists)}`. DO NOT EDIT! */"
+ )
+ errnos: dict[str, int] = {}
+ for txtlist in sys.argv[1:]:
+ with open(txtlist, "r") as fh:
+ for line in fh:
+ if line.startswith("#"):
+ print(f"/* {line[1:].strip()} */")
+ continue
+ _num, name = line.split(maxsplit=1)
+ num = int(_num)
+ name = name.strip()
+ errnos[name] = int(num)
+ namelen = max(len(name) for name in errnos.keys())
+ print()
+ print("#ifndef _9P_LINUX_ERRNO_H_")
+ print("#define _9P_LINUX_ERRNO_H_")
+ print()
+ for name in errnos:
+ print(f"#define LINUX_{name.ljust(namelen)} {errnos[name]}")
+ print()
+ print("#endif /* _9P_LINUX_ERRNO_H_ */")
+
+
+if __name__ == "__main__":
+ import sys
+
+ print_errnos(sys.argv[1:])
diff --git a/9p/misc.txt b/9p/misc.txt
new file mode 100644
index 0000000..93aa304
--- /dev/null
+++ b/9p/misc.txt
@@ -0,0 +1,24 @@
+# qid.types
+QTDIR = 1<<7
+QTAPPEND = 1<<6
+QTEXCL = 1<<5
+QTMOUNT = 1<<4 # been around forever, but undocumented?
+QTAUTH = 1<<3
+QTTMP = 1<<2 # added to Plan 9 2003-12
+QTSYMLINK = 1<<1 # .u
+QTFILE = 1<<0
+
+DMDIR = 1<<31
+DMAPPEND = 1<<30
+DMEXCL = 1<<29
+DMMOUNT = 1<<28
+DMAUTH = 1<<27
+DMTMP = 1<<26
+# = 1<<25
+# = 1<<24
+DMDEVICE = 1<<23 # .u
+# = 1<<22
+DMNAMEDPIPE = 1<<21 # .u
+DMSOCKET = 1<<20 # .u
+DMSETUID = 1<<19 # .u
+DMSETGID = 1<<18 # .u
diff --git a/9p/srv.c b/9p/srv.c
new file mode 100644
index 0000000..f7c8195
--- /dev/null
+++ b/9p/srv.c
@@ -0,0 +1,44 @@
+#include "net9p.h"
+#include "net9p_defs.h"
+#include "netio.h"
+
+#define MAX_MSG_SIZE 1024
+
+int read_msg(int conn, uint16_t *out_tag, void **out_body) {
+ uint8_t buf[MAX_MSG_SIZE];
+ size_t todo = 7, done = 0;
+
+ 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);
+}
+
+void net9p_cr(void *_arg) {
+ int sock = *((int *)_arg);
+ cr_begin();
+
+ for (;;) {
+ int conn = netio_accept(sock);
+ if (conn < 0) {
+ error(0, -conn, "netio_accept");
+ continue;
+ }
+
+
+ }
+
+ cr_end();
+}
diff --git a/9p/srv.h b/9p/srv.h
new file mode 100644
index 0000000..f28a525
--- /dev/null
+++ b/9p/srv.h
@@ -0,0 +1,8 @@
+#ifndef _NET9P_H_
+#define _NET9P_H_
+
+#include "coroutine.h"
+
+COROUTINE net9p_cr(void *);
+
+#endif /* _NET9P_H_ */
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2025-04-05 07:14:44 +0000