move InMessage, OutMessage, TransportLayer, and TransportLayerJavaNet to net package

1 files changed, 127 insertions, 0 deletions

diff --git a/src/main/kotlin/net/OutMessage.kt b/src/main/kotlin/net/OutMessage.kt
new file mode 100644
index 0000000..c9ae879
--- /dev/null
+++ b/src/main/kotlin/net/OutMessage.kt
@@ -0,0 +1,127 @@
+package net
+
+import NinePMessageType
+import java.math.BigInteger
+import kotlin.math.pow
+
+/**
+ * An outgoing 9P message with the given type, tag, and fields. The message size is calculated automatically.
+ *
+ * Important note: the field names in [fieldValuesInt], [fieldValuesStr], and [fieldValuesRaw] (i.e. the keys of their
+ * maps) must be mutually exclusive and the union of these two maps' keys must result in a subset of (or a set equal to)
+ * [fieldNames]. Calling [write] when these conditions are not met throws an exception.
+ *
+ * @param type The 9P message type.
+ * @param tag The tag given to the message.
+ * @param fieldNames The names of the message fields, in the same order they are expected to be sent.
+ * @param fieldValuesInt A map of each integer field's name into its value and size in bytes.
+ * @param fieldValuesStr A map of each string field's name into its value.
+ * @param fieldValuesRaw A map of each raw field's name into its value.
+ * @param maxSize The maximum message size.
+ */
+class OutMessage(val type: NinePMessageType, val tag: UShort, val fieldNames: List<String>, val fieldValuesInt: Map<String, Pair<BigInteger, UInt>>, val fieldValuesStr: Map<String, String>, val fieldValuesRaw: Map<String, List<UByte>>, val maxSize: UInt) {
+    /**
+     * Intersection between [fieldNames] and [fieldValuesInt]. In other words: the integer fields that are going to be
+     * used when writing the message.
+     */
+    private val insecInts = fieldNames.intersect(fieldValuesInt.keys)
+
+    /**
+     * Intersection between [fieldNames] and [fieldValuesStr]. In other words: the string fields that are going to be
+     * used when writing the message.
+     */
+    private val insecStrs = fieldNames.intersect(fieldValuesStr.keys)
+
+    /**
+     * Intersection between [fieldNames] and [fieldValuesRaw]. In other words: the raw fields that are going to be used
+     * when writing the message.
+     */
+    private val insecRaws = fieldNames.intersect(fieldValuesRaw.keys)
+
+    /**
+     * Send the message using the given networking API.
+     *
+     * @param tl The networking API.
+     * @throws IllegalArgumentException if [fieldNames], [fieldValuesInt], and [fieldValuesStr] are incoherent or the
+     *         final size of the message exceeds the negotiated value.
+     */
+    fun write(tl: TransportLayer) {
+        // check that names in fieldNames exist as keys in either fieldValuesInt or fieldValuesStr but not both
+        require(fieldNames.size == insecInts.size + insecStrs.size + insecRaws.size)
+
+        val totalSize = size()
+        if (totalSize > this.maxSize) {
+            throw IllegalArgumentException("Message size exceeded.")
+        }
+        writeMessageSizeTypeTag(tl, totalSize, type, tag)
+        for (field in fieldNames) {
+            tl.transmit(
+                if (field in insecInts) {
+                    val valsize = fieldValuesInt[field]!!
+                    convIntegerToBytes(valsize.first, valsize.second)
+                } else if (field in insecStrs) {
+                    convStringToBytes(fieldValuesStr[field]!!)
+                } else {
+                    fieldValuesRaw[field]!!.toList()
+                }
+            )
+        }
+    }
+
+    /**
+     * Write the message size and type.
+     *
+     * @param tl The networking API.
+     * @param size The total message size, including the 4 bytes of this parameter and the type's byte.
+     * @param type The 9P message type as a [NinePMessageType] constant.
+     * @param tag The 9P message tag.
+     */
+    private fun writeMessageSizeTypeTag(tl: TransportLayer, size: UInt, type: NinePMessageType, tag: UShort) {
+        var bytes: List<UByte> = emptyList()
+        bytes += convIntegerToBytes(BigInteger(size.toString()), 4u)
+        bytes += convIntegerToBytes(BigInteger(type.value.toString()), 1u)
+        bytes += convIntegerToBytes(BigInteger(tag.toString()), 2u)
+        tl.transmit(bytes)
+    }
+
+    /**
+     * Calculate the expected size of the message.
+     */
+    fun size(): UInt {
+        return 4u + 1u + 2u + this.insecInts.sumOf { this.fieldValuesInt[it]!!.second } + this.insecStrs.sumOf { 2u + this.fieldValuesStr[it]!!.length.toUInt() } + this.insecRaws.sumOf { this.fieldValuesRaw[it]!!.size.toUInt() }
+    }
+
+    companion object {
+        // TODO: Add size that the value is required to fit in
+
+        /**
+         * Convert an integer number to its byte representation.
+         *
+         * In 9P, binary numbers (non-textual) are specified in little-endian order (least significant byte first).
+         *
+         * @param value The number's value.
+         * @param size The number's size in bytes.
+         */
+        fun convIntegerToBytes(value: BigInteger, size: UInt): List<UByte> {
+            var bytes: List<UByte> = value.toByteArray().toList().map { x -> x.toUByte() }
+            bytes += List(size.toInt() - bytes.size, {0u}) // add padding for missing bytes
+            return bytes
+        }
+
+        /**
+         * Write a string to the connection.
+         *
+         * In 9P, strings are represented as a 2-byte integer (the string's size) followed by the actual UTF-8 string. The
+         * null terminator is forbidden in 9P messages.
+         *
+         * @param value The string.
+         * @throws IllegalArgumentException if the value of the string's size does not fit into 2 bytes.
+         */
+        fun convStringToBytes(value: String): List<UByte> {
+            require(value.length <= 2.0.pow(16.0) - 1)
+            var bytes = convIntegerToBytes(value.length.toBigInteger(), 2u)
+            bytes += value.toByteArray().toList().map { x -> x.toUByte() }
+            return bytes
+        }
+    }
+}
\ No newline at end of file