| … | … | @@ -0,0 +1 @@ |
| 1 | node_modules/ |
| … | … | @@ -0,0 +1,34 @@ |
| 1 | # swarmd | |
| 2 | ||
| 3 | **A C/C++ program.** Not a Node program, and not a Node program with C in it. | |
| 4 | ||
| 5 | That distinction is easy to lose because there is a `package.json` here, so: | |
| 6 | ||
| 7 | schema/build.js a Node script, run by hand when the wire changes | |
| 8 | schema/*.c, *.h the C it emits — COMMITTED | |
| 9 | src/ the daemon, C++ | |
| 10 | package.json devDependencies for the generators. Build-time only. | |
| 11 | ||
| 12 | `npm install` and `npm run build:schema` are needed **only to regenerate**, i.e. | |
| 13 | only when `schema/build.js` changes. A fresh checkout builds the daemon from the | |
| 14 | committed C with no npm, no Node, and no JavaScript at runtime. | |
| 15 | ||
| 16 | This is holepunch's own convention: `libhc` is a C library that generates its | |
| 17 | encodings the same way, with `schema/build.js` and the resulting | |
| 18 | `schema/hc_schema.{c,h}` checked into the repo. | |
| 19 | ||
| 20 | ## Generated from | |
| 21 | ||
| 22 | - **hyperschema-c** — structs + `preencode/encode/decode/destroy(compact_state_t*)` | |
| 23 | - **hrpc-c** — typed sans-io RPC over the bare-rpc wire (unary + event handlers) | |
| 24 | ||
| 25 | ## Links against | |
| 26 | ||
| 27 | - **libcompact** — compact-encoding in C, ABI-identical to the JS codec | |
| 28 | - **libutf** — string views (pulled in by libcompact) | |
| 29 | - **librpc** — the C RPC codec | |
| 30 | ||
| 31 | ## Status | |
| 32 | ||
| 33 | Wire generated and compiling. **No daemon yet** — see `../docs/SWARMD-DESIGN.md`, | |
| 34 | §9 for the order and §8 for the gates. |
| … | … | @@ -0,0 +1,280 @@ |
| 1 | { | |
| 2 | "name": "swarmd-codegen", | |
| 3 | "lockfileVersion": 3, | |
| 4 | "requires": true, | |
| 5 | "packages": { | |
| 6 | "": { | |
| 7 | "name": "swarmd-codegen", | |
| 8 | "devDependencies": { | |
| 9 | "hrpc-c": "*", | |
| 10 | "hyperschema-c": "*" | |
| 11 | } | |
| 12 | }, | |
| 13 | "node_modules/b4a": { | |
| 14 | "version": "1.8.1", | |
| 15 | "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.1.tgz", | |
| 16 | "integrity": "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==", | |
| 17 | "dev": true, | |
| 18 | "license": "Apache-2.0", | |
| 19 | "peerDependencies": { | |
| 20 | "react-native-b4a": "*" | |
| 21 | }, | |
| 22 | "peerDependenciesMeta": { | |
| 23 | "react-native-b4a": { | |
| 24 | "optional": true | |
| 25 | } | |
| 26 | } | |
| 27 | }, | |
| 28 | "node_modules/bare-events": { | |
| 29 | "version": "2.9.2", | |
| 30 | "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.9.2.tgz", | |
| 31 | "integrity": "sha512-AIPKioV7/Y/8KfZ3AAhjPJxLLbY49S64Ym5DakZlUg75qQiTgUq9hEJoEwa4eUezPUlXRy/i5NpsKvo9jgKmoA==", | |
| 32 | "dev": true, | |
| 33 | "license": "Apache-2.0", | |
| 34 | "peer": true, | |
| 35 | "peerDependencies": { | |
| 36 | "bare-abort-controller": "*" | |
| 37 | }, | |
| 38 | "peerDependenciesMeta": { | |
| 39 | "bare-abort-controller": { | |
| 40 | "optional": true | |
| 41 | } | |
| 42 | } | |
| 43 | }, | |
| 44 | "node_modules/bare-fs": { | |
| 45 | "version": "4.8.1", | |
| 46 | "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.8.1.tgz", | |
| 47 | "integrity": "sha512-N1nnXdHZAOSstz0XiHikGS4HGMH4CnSwhqWdGQQMqqdvp4Jybm9sE3R1WVnpWVd4SFkc8ryPDBLViNLwiEqECg==", | |
| 48 | "dev": true, | |
| 49 | "license": "Apache-2.0", | |
| 50 | "dependencies": { | |
| 51 | "bare-events": "^2.5.4", | |
| 52 | "bare-path": "^3.0.0", | |
| 53 | "bare-stream": "^2.6.4", | |
| 54 | "bare-url": "^2.2.2", | |
| 55 | "fast-fifo": "^1.3.2" | |
| 56 | }, | |
| 57 | "engines": { | |
| 58 | "bare": ">=1.28.0" | |
| 59 | }, | |
| 60 | "peerDependencies": { | |
| 61 | "bare-buffer": "*" | |
| 62 | }, | |
| 63 | "peerDependenciesMeta": { | |
| 64 | "bare-buffer": { | |
| 65 | "optional": true | |
| 66 | } | |
| 67 | } | |
| 68 | }, | |
| 69 | "node_modules/bare-path": { | |
| 70 | "version": "3.1.2", | |
| 71 | "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.1.2.tgz", | |
| 72 | "integrity": "sha512-ZyKbsuuqK6Ag0K8pX6V5Txq6XeJRvY+wXucnFGRjiyVYP9YWDpIQugk/b+enRYrEYBJaqLzghRQpXPMR7341Nw==", | |
| 73 | "dev": true, | |
| 74 | "license": "Apache-2.0" | |
| 75 | }, | |
| 76 | "node_modules/bare-rpc": { | |
| 77 | "version": "1.3.8", | |
| 78 | "resolved": "https://registry.npmjs.org/bare-rpc/-/bare-rpc-1.3.8.tgz", | |
| 79 | "integrity": "sha512-6fnkIHK+mecUjriOmzaXCYPpJm9JZxKHb5q4I1eTclHN5H+M7keYS68YjEhpVomnF14ArZYTWfRHJPZibTEMWA==", | |
| 80 | "dev": true, | |
| 81 | "license": "Apache-2.0", | |
| 82 | "dependencies": { | |
| 83 | "b4a": "^1.6.6", | |
| 84 | "bare-stream": "^2.1.3", | |
| 85 | "compact-encoding": "^3.0.0", | |
| 86 | "safety-catch": "^1.0.2" | |
| 87 | }, | |
| 88 | "peerDependencies": { | |
| 89 | "bare-buffer": "*" | |
| 90 | }, | |
| 91 | "peerDependenciesMeta": { | |
| 92 | "bare-buffer": { | |
| 93 | "optional": true | |
| 94 | } | |
| 95 | } | |
| 96 | }, | |
| 97 | "node_modules/bare-stream": { | |
| 98 | "version": "2.13.4", | |
| 99 | "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.13.4.tgz", | |
| 100 | "integrity": "sha512-PcrQ8lVLbiJscNm1Kez+Yp4Gy4AHGcN1lzwjvf5NybWen7VvEgUfyfnXYJ2zNqWnzOfCb1Abq6lH8ti0syQszA==", | |
| 101 | "dev": true, | |
| 102 | "license": "Apache-2.0", | |
| 103 | "dependencies": { | |
| 104 | "b4a": "^1.8.1", | |
| 105 | "streamx": "^2.25.0", | |
| 106 | "teex": "^1.0.1" | |
| 107 | }, | |
| 108 | "peerDependencies": { | |
| 109 | "bare-abort-controller": "*", | |
| 110 | "bare-buffer": "*", | |
| 111 | "bare-events": "*" | |
| 112 | }, | |
| 113 | "peerDependenciesMeta": { | |
| 114 | "bare-abort-controller": { | |
| 115 | "optional": true | |
| 116 | }, | |
| 117 | "bare-buffer": { | |
| 118 | "optional": true | |
| 119 | }, | |
| 120 | "bare-events": { | |
| 121 | "optional": true | |
| 122 | } | |
| 123 | } | |
| 124 | }, | |
| 125 | "node_modules/bare-url": { | |
| 126 | "version": "2.5.4", | |
| 127 | "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.5.4.tgz", | |
| 128 | "integrity": "sha512-Gxa7UVWBr0/edU1b+TJhn/AZvMQUj9OGspvYsaTYQrAbZA4BOTZGL3LiZxvD+CeMlDH4juwD84+eTAp/bLYW5g==", | |
| 129 | "dev": true, | |
| 130 | "license": "Apache-2.0", | |
| 131 | "dependencies": { | |
| 132 | "bare-path": "^3.0.0" | |
| 133 | } | |
| 134 | }, | |
| 135 | "node_modules/compact-encoding": { | |
| 136 | "version": "3.5.0", | |
| 137 | "resolved": "https://registry.npmjs.org/compact-encoding/-/compact-encoding-3.5.0.tgz", | |
| 138 | "integrity": "sha512-X7yaWh0NNMVB2YXAWSTWjYU3WXvDTniKxbtQlisbXOVutIE6awd+zCQdNqScTjIXv9m9orqdlri+oaWWsKqTuA==", | |
| 139 | "dev": true, | |
| 140 | "license": "Apache-2.0", | |
| 141 | "dependencies": { | |
| 142 | "b4a": "^1.3.0" | |
| 143 | } | |
| 144 | }, | |
| 145 | "node_modules/events-universal": { | |
| 146 | "version": "1.0.1", | |
| 147 | "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz", | |
| 148 | "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==", | |
| 149 | "dev": true, | |
| 150 | "license": "Apache-2.0", | |
| 151 | "dependencies": { | |
| 152 | "bare-events": "^2.7.0" | |
| 153 | } | |
| 154 | }, | |
| 155 | "node_modules/fast-fifo": { | |
| 156 | "version": "1.3.2", | |
| 157 | "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz", | |
| 158 | "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==", | |
| 159 | "dev": true, | |
| 160 | "license": "MIT" | |
| 161 | }, | |
| 162 | "node_modules/generate-object-property": { | |
| 163 | "version": "2.0.0", | |
| 164 | "resolved": "https://registry.npmjs.org/generate-object-property/-/generate-object-property-2.0.0.tgz", | |
| 165 | "integrity": "sha512-KwuURPyqn2Mz8DdV29pJwQu0Y7tcsbkULr82eeOcY/ZllFK6I9Wm8dsRByIu7CKWlFi9BdW1b3mcXMp/kQBQsw==", | |
| 166 | "dev": true, | |
| 167 | "license": "MIT", | |
| 168 | "dependencies": { | |
| 169 | "is-property": "^1.0.0" | |
| 170 | } | |
| 171 | }, | |
| 172 | "node_modules/generate-string": { | |
| 173 | "version": "1.0.1", | |
| 174 | "resolved": "https://registry.npmjs.org/generate-string/-/generate-string-1.0.1.tgz", | |
| 175 | "integrity": "sha512-IfTY0dKZM43ACyGvXkbG7De7WY7MxTS5VO6Juhe8oJKpCmrYYXoqp/cJMskkpi0k9H8wuXq0H+eI898/BCqvXg==", | |
| 176 | "dev": true, | |
| 177 | "license": "MIT" | |
| 178 | }, | |
| 179 | "node_modules/hrpc": { | |
| 180 | "version": "4.3.1", | |
| 181 | "resolved": "https://registry.npmjs.org/hrpc/-/hrpc-4.3.1.tgz", | |
| 182 | "integrity": "sha512-eSdDrds+BOvrwSCnBuaTaGCB2Gn8pl6PkaDNHqr+FdoNFOlSsQpiundQcYqUA++OaP0j7m0CGxpDkPqQ+yJvKQ==", | |
| 183 | "dev": true, | |
| 184 | "license": "Apache-2.0", | |
| 185 | "dependencies": { | |
| 186 | "b4a": "^1.6.7", | |
| 187 | "bare-rpc": "^1.1.0", | |
| 188 | "hyperschema": "^1.10.4", | |
| 189 | "streamx": "^2.22.0" | |
| 190 | } | |
| 191 | }, | |
| 192 | "node_modules/hrpc-c": { | |
| 193 | "version": "0.1.0", | |
| 194 | "resolved": "https://registry.npmjs.org/hrpc-c/-/hrpc-c-0.1.0.tgz", | |
| 195 | "integrity": "sha512-aYanvErNKO5/cEO5GaLOocLmntFNcP81TzxVI3z2Xvqm5N6BBZ35v0f+WQFxVOq/NYQ6SHUVqpsvxWUuulSjPA==", | |
| 196 | "dev": true, | |
| 197 | "license": "Apache-2.0", | |
| 198 | "workspaces": [ | |
| 199 | "test/c-workspace" | |
| 200 | ], | |
| 201 | "dependencies": { | |
| 202 | "bare-fs": "^4.7.1", | |
| 203 | "hrpc": "^4.3.0" | |
| 204 | } | |
| 205 | }, | |
| 206 | "node_modules/hyperschema": { | |
| 207 | "version": "1.24.0", | |
| 208 | "resolved": "https://registry.npmjs.org/hyperschema/-/hyperschema-1.24.0.tgz", | |
| 209 | "integrity": "sha512-kbeeIAA0GmdW+Lhem1x9aawtXsJUGXXGEYk5yBupYyPxsym4ndAyqY7gLr64KyPvMvNO220jgoqgow+5OnX1jg==", | |
| 210 | "dev": true, | |
| 211 | "license": "Apache-2.0", | |
| 212 | "dependencies": { | |
| 213 | "bare-fs": "^4.0.1", | |
| 214 | "compact-encoding": "^3.5.0", | |
| 215 | "generate-object-property": "^2.0.0", | |
| 216 | "generate-string": "^1.0.1" | |
| 217 | } | |
| 218 | }, | |
| 219 | "node_modules/hyperschema-c": { | |
| 220 | "version": "0.4.0", | |
| 221 | "resolved": "https://registry.npmjs.org/hyperschema-c/-/hyperschema-c-0.4.0.tgz", | |
| 222 | "integrity": "sha512-dmC+8X66TgDgzFgdtLUBTFvCwucVwsUw7AuEToFvBiY6kWKeyZHA4yRSu2Kldzmf8TmdOurXe/SkjGmQiS63Lw==", | |
| 223 | "dev": true, | |
| 224 | "license": "Apache-2.0", | |
| 225 | "workspaces": [ | |
| 226 | "test/c-workspace" | |
| 227 | ], | |
| 228 | "dependencies": { | |
| 229 | "bare-fs": "^4.7.1", | |
| 230 | "hyperschema": "^1.20.1" | |
| 231 | } | |
| 232 | }, | |
| 233 | "node_modules/is-property": { | |
| 234 | "version": "1.0.2", | |
| 235 | "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz", | |
| 236 | "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==", | |
| 237 | "dev": true, | |
| 238 | "license": "MIT" | |
| 239 | }, | |
| 240 | "node_modules/safety-catch": { | |
| 241 | "version": "1.0.3", | |
| 242 | "resolved": "https://registry.npmjs.org/safety-catch/-/safety-catch-1.0.3.tgz", | |
| 243 | "integrity": "sha512-Zq+J1TefpoEq/HTUabo0YXX5MNvttjWYODGohgPBO2jfko8Wqx3JYMgE823szDFVamdH5PlpByvfiWScTdSYDA==", | |
| 244 | "dev": true, | |
| 245 | "license": "MIT" | |
| 246 | }, | |
| 247 | "node_modules/streamx": { | |
| 248 | "version": "2.28.1", | |
| 249 | "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.28.1.tgz", | |
| 250 | "integrity": "sha512-zEzXb0s5Cds7tqMH6rhZ05lcJydCWiQPEwiNngVqzsxCc962vLY4Uw+mW7od8kDH258k2Uz/JrOkdIAAhSh9VA==", | |
| 251 | "dev": true, | |
| 252 | "license": "MIT", | |
| 253 | "dependencies": { | |
| 254 | "events-universal": "^1.0.0", | |
| 255 | "fast-fifo": "^1.3.2", | |
| 256 | "text-decoder": "^1.1.0" | |
| 257 | } | |
| 258 | }, | |
| 259 | "node_modules/teex": { | |
| 260 | "version": "1.0.1", | |
| 261 | "resolved": "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz", | |
| 262 | "integrity": "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==", | |
| 263 | "dev": true, | |
| 264 | "license": "MIT", | |
| 265 | "dependencies": { | |
| 266 | "streamx": "^2.12.5" | |
| 267 | } | |
| 268 | }, | |
| 269 | "node_modules/text-decoder": { | |
| 270 | "version": "1.2.7", | |
| 271 | "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.7.tgz", | |
| 272 | "integrity": "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==", | |
| 273 | "dev": true, | |
| 274 | "license": "Apache-2.0", | |
| 275 | "dependencies": { | |
| 276 | "b4a": "^1.6.4" | |
| 277 | } | |
| 278 | } | |
| 279 | } | |
| 280 | } |
| … | … | @@ -0,0 +1,12 @@ |
| 1 | { | |
| 2 | "private": true, | |
| 3 | "name": "swarmd", | |
| 4 | "description": "Build-time codegen ONLY. swarmd is a C/C++ program: the generated C in schema/ is committed, and the daemon links libcompact + librpc with no JavaScript at runtime. Node is needed only to REGENERATE, i.e. when schema/build.js changes.", | |
| 5 | "scripts": { | |
| 6 | "build:schema": "node schema/build.js" | |
| 7 | }, | |
| 8 | "devDependencies": { | |
| 9 | "hyperschema-c": "^0.4.0", | |
| 10 | "hrpc-c": "^0.1.0" | |
| 11 | } | |
| 12 | } |
| … | … | @@ -0,0 +1,20 @@ |
| 1 | # This file is autogenerated by hrpc-c | |
| 2 | # !!DO NOT EDIT!! | |
| 3 | # | |
| 4 | # Expects: `compact`, `rpc`, and `swarmd_schema` CMake targets provided by the consumer. | |
| 5 | ||
| 6 | cmake_minimum_required(VERSION 4.0) | |
| 7 | ||
| 8 | project(swarmd_hrpc C) | |
| 9 | ||
| 10 | add_library(swarmd_hrpc OBJECT swarmd_hrpc.c) | |
| 11 | ||
| 12 | set_target_properties( | |
| 13 | swarmd_hrpc | |
| 14 | PROPERTIES | |
| 15 | C_STANDARD 99 | |
| 16 | ) | |
| 17 | ||
| 18 | target_include_directories(swarmd_hrpc PUBLIC .) | |
| 19 | ||
| 20 | target_link_libraries(swarmd_hrpc PUBLIC compact rpc swarmd_schema) |
| … | … | @@ -0,0 +1,241 @@ |
| 1 | // Generates swarmd's wire in C. BUILD TIME ONLY. | |
| 2 | // | |
| 3 | // Run `npm run build:schema` after editing this file; the emitted .c/.h are | |
| 4 | // COMMITTED beside it and the daemon builds from them with no npm and no Node. | |
| 5 | // This mirrors libhc, which does exactly the same thing with the same tools | |
| 6 | // (libhc/schema/build.js -> schema/hc_schema.{c,h}, both checked in). | |
| 7 | // | |
| 8 | // ⛔ These generators are for protocols WE define. They cannot generate | |
| 9 | // dht_messages.h: hyperdht has no spec/, no hyperschema dependency, and | |
| 10 | // lib/messages.js opens `const c = require('compact-encoding')` — it hand-writes | |
| 11 | // its wire exactly as we do. See docs/SWARMD-DESIGN.md §3. | |
| 12 | ||
| 13 | const CHyperschema = require('hyperschema-c') | |
| 14 | const CHRPC = require('hrpc-c') | |
| 15 | ||
| 16 | const schema = CHyperschema.from(__dirname) | |
| 17 | const s = schema.namespace('swarmd') | |
| 18 | ||
| 19 | // ---- session ---- | |
| 20 | ||
| 21 | s.register({ | |
| 22 | name: 'hello-request', | |
| 23 | fields: [ | |
| 24 | { name: 'name', type: 'string', required: true }, | |
| 25 | // The APPLICATION identity, durable and supplied by the client. Distinct | |
| 26 | // from the daemon's transport keypair: transport identity is not | |
| 27 | // application identity (see memory identity-vs-writer-keypair). | |
| 28 | { name: 'app-identity', type: 'fixed32', required: true }, | |
| 29 | { name: 'version', type: 'uint', required: true } | |
| 30 | ] | |
| 31 | }) | |
| 32 | ||
| 33 | s.register({ | |
| 34 | name: 'hello-response', | |
| 35 | fields: [ | |
| 36 | { name: 'client-id', type: 'uint', required: true }, | |
| 37 | { name: 'daemon-pubkey', type: 'fixed32', required: true } | |
| 38 | ] | |
| 39 | }) | |
| 40 | ||
| 41 | // ⛔ AN UNOBSERVABLE DAEMON IS HOW A DEAD DHT LOOKED HEALTHY. Two peers sat on | |
| 42 | // one topic for ten minutes both reporting "joined" while neither had ever | |
| 43 | // bootstrapped (hyper-games #68). "joined" is a LOCAL fact; these are the ones | |
| 44 | // that mean reachable. | |
| 45 | s.register({ | |
| 46 | name: 'status', | |
| 47 | fields: [ | |
| 48 | { name: 'dht-state', type: 'uint', required: true }, // 0 starting 1 connecting 2 up | |
| 49 | { name: 'bootstrapped', type: 'bool', required: true }, | |
| 50 | { name: 'peers-known', type: 'uint', required: true }, | |
| 51 | { name: 'peers-connected', type: 'uint', required: true }, | |
| 52 | { name: 'connecting', type: 'uint', required: true }, | |
| 53 | { name: 'queued', type: 'uint', required: true }, | |
| 54 | { name: 'local-clients', type: 'uint', required: true } | |
| 55 | ] | |
| 56 | }) | |
| 57 | ||
| 58 | s.register({ name: 'ok', fields: [{ name: 'ok', type: 'bool', required: true }] }) | |
| 59 | s.register({ name: 'none', fields: [{ name: 'reserved', type: 'uint', required: true }] }) | |
| 60 | ||
| 61 | // ---- swarm ---- | |
| 62 | ||
| 63 | s.register({ | |
| 64 | name: 'swarm-join', | |
| 65 | fields: [ | |
| 66 | { name: 'topic', type: 'fixed32', required: true }, | |
| 67 | { name: 'server', type: 'bool', required: true }, | |
| 68 | { name: 'client', type: 'bool', required: true } | |
| 69 | ] | |
| 70 | }) | |
| 71 | ||
| 72 | s.register({ name: 'topic-ref', fields: [{ name: 'topic', type: 'fixed32', required: true }] }) | |
| 73 | s.register({ name: 'peer-key', fields: [{ name: 'pubkey', type: 'fixed32', required: true }] }) | |
| 74 | ||
| 75 | // ---- channels ---- | |
| 76 | ||
| 77 | s.register({ | |
| 78 | name: 'channel-open', | |
| 79 | fields: [ | |
| 80 | { name: 'protocol', type: 'string', required: true }, | |
| 81 | { name: 'id', type: 'buffer', required: true }, | |
| 82 | { name: 'slots', type: 'uint', required: true } | |
| 83 | ] | |
| 84 | }) | |
| 85 | ||
| 86 | s.register({ name: 'channel-ref', fields: [{ name: 'channel', type: 'uint', required: true }] }) | |
| 87 | ||
| 88 | s.register({ | |
| 89 | name: 'send-request', | |
| 90 | fields: [ | |
| 91 | { name: 'channel', type: 'uint', required: true }, | |
| 92 | { name: 'slot', type: 'uint', required: true }, | |
| 93 | { name: 'target', type: 'uint', required: true }, // 0 = broadcast | |
| 94 | { name: 'bytes', type: 'buffer', required: true } | |
| 95 | ] | |
| 96 | }) | |
| 97 | ||
| 98 | // ⛔ WRITABILITY MUST REACH THE CLIENT. Protomux returns it and its own header | |
| 99 | // says discarding that answer "left every protocol above with no way to avoid | |
| 100 | // burying the connection". | |
| 101 | s.register({ | |
| 102 | name: 'send-result', | |
| 103 | fields: [ | |
| 104 | { name: 'accepted', type: 'bool', required: true }, | |
| 105 | { name: 'writable', type: 'bool', required: true } | |
| 106 | ] | |
| 107 | }) | |
| 108 | ||
| 109 | // ---- content (hyper-overlay) ---- | |
| 110 | // | |
| 111 | // ⛔ BULK BYTES NEVER CROSS THE SOCKET. A .res is 108 MB. The overlay writes to | |
| 112 | // a path and the client opens the path; only a 32-byte hash travels here. | |
| 113 | ||
| 114 | s.register({ name: 'path', fields: [{ name: 'path', type: 'string', required: true }] }) | |
| 115 | s.register({ name: 'hash', fields: [{ name: 'hash', type: 'fixed32', required: true }] }) | |
| 116 | ||
| 117 | s.register({ | |
| 118 | name: 'content-serve', | |
| 119 | fields: [ | |
| 120 | { name: 'hash', type: 'fixed32', required: true }, | |
| 121 | { name: 'path', type: 'string', required: true } | |
| 122 | ] | |
| 123 | }) | |
| 124 | ||
| 125 | s.register({ | |
| 126 | name: 'content-fetch', | |
| 127 | fields: [ | |
| 128 | { name: 'hash', type: 'fixed32', required: true }, | |
| 129 | { name: 'dest-path', type: 'string', required: true } | |
| 130 | ] | |
| 131 | }) | |
| 132 | ||
| 133 | s.register({ | |
| 134 | name: 'content-cancel', | |
| 135 | fields: [ | |
| 136 | { name: 'hash', type: 'fixed32', required: true }, | |
| 137 | { name: 'discard', type: 'bool', required: true } | |
| 138 | ] | |
| 139 | }) | |
| 140 | ||
| 141 | s.register({ | |
| 142 | name: 'content-progress', | |
| 143 | fields: [ | |
| 144 | { name: 'hash', type: 'fixed32', required: true }, | |
| 145 | { name: 'received', type: 'uint', required: true }, | |
| 146 | { name: 'total', type: 'uint', required: true } | |
| 147 | ] | |
| 148 | }) | |
| 149 | ||
| 150 | s.register({ | |
| 151 | name: 'content-done', | |
| 152 | fields: [ | |
| 153 | { name: 'hash', type: 'fixed32', required: true }, | |
| 154 | { name: 'path', type: 'string', required: true } | |
| 155 | ] | |
| 156 | }) | |
| 157 | ||
| 158 | s.register({ | |
| 159 | name: 'content-failed', | |
| 160 | fields: [ | |
| 161 | { name: 'hash', type: 'fixed32', required: true }, | |
| 162 | { name: 'reason', type: 'string', required: true } | |
| 163 | ] | |
| 164 | }) | |
| 165 | ||
| 166 | // ---- events ---- | |
| 167 | ||
| 168 | s.register({ | |
| 169 | name: 'peer-up', | |
| 170 | fields: [ | |
| 171 | { name: 'peer', type: 'uint', required: true }, | |
| 172 | { name: 'pubkey', type: 'fixed32', required: true } | |
| 173 | ] | |
| 174 | }) | |
| 175 | ||
| 176 | s.register({ name: 'peer-down', fields: [{ name: 'peer', type: 'uint', required: true }] }) | |
| 177 | ||
| 178 | // origin-kind separates a REMOTE peer from ANOTHER LOCAL CLIENT. That is what | |
| 179 | // lets a client suppress its own echo, which session-daemon cannot do. | |
| 180 | s.register({ | |
| 181 | name: 'message', | |
| 182 | fields: [ | |
| 183 | { name: 'channel', type: 'uint', required: true }, | |
| 184 | { name: 'slot', type: 'uint', required: true }, | |
| 185 | { name: 'origin-kind', type: 'uint', required: true }, // 0 peer, 1 local client | |
| 186 | { name: 'origin-id', type: 'uint', required: true }, | |
| 187 | { name: 'bytes', type: 'buffer', required: true } | |
| 188 | ] | |
| 189 | }) | |
| 190 | ||
| 191 | // ---- RPC ---- | |
| 192 | ||
| 193 | // ⛔ NOT `new CHRPC(schema, __dirname)`, which is what hrpc-c's README shows. | |
| 194 | // HRPC's constructor is (schema, hrpcJson, { hrpcDir, schemaDir }) — the second | |
| 195 | // argument is a PARSED JSON OBJECT, not a directory. Passing a path there makes | |
| 196 | // `hrpcJson.schema` undefined and the constructor dies on `.length`. The static | |
| 197 | // HRPC.from(schemaDir, hrpcDir) does take paths, but it re-reads schema.json | |
| 198 | // from disk, which does not exist until toDisk has run. Passing the in-memory | |
| 199 | // schema with explicit dirs avoids the round-trip entirely. | |
| 200 | const hrpc = new CHRPC(schema, null, { hrpcDir: __dirname, schemaDir: __dirname }) | |
| 201 | const r = hrpc.namespace('swarmd') | |
| 202 | ||
| 203 | const unary = (name, req, res) => r.register({ | |
| 204 | name, | |
| 205 | request: { name: `@swarmd/${req}`, stream: false }, | |
| 206 | response: { name: `@swarmd/${res}`, stream: false } | |
| 207 | }) | |
| 208 | const event = (name, req) => r.register({ | |
| 209 | name, | |
| 210 | request: { name: `@swarmd/${req}`, send: true } | |
| 211 | }) | |
| 212 | ||
| 213 | unary('hello', 'hello-request', 'hello-response') | |
| 214 | unary('status-get', 'none', 'status') | |
| 215 | ||
| 216 | unary('swarm-join', 'swarm-join', 'ok') | |
| 217 | unary('swarm-leave', 'topic-ref', 'ok') | |
| 218 | unary('peer-add', 'peer-key', 'ok') | |
| 219 | unary('peer-remove', 'peer-key', 'ok') | |
| 220 | ||
| 221 | unary('channel-open', 'channel-open', 'channel-ref') | |
| 222 | unary('channel-close', 'channel-ref', 'ok') | |
| 223 | unary('send', 'send-request', 'send-result') | |
| 224 | ||
| 225 | unary('content-hash', 'path', 'hash') | |
| 226 | unary('content-serve', 'content-serve', 'ok') | |
| 227 | unary('content-fetch', 'content-fetch', 'ok') | |
| 228 | unary('content-cancel', 'content-cancel', 'ok') | |
| 229 | ||
| 230 | // Daemon -> client. Fire-and-forget: nobody replies to a peer arriving. | |
| 231 | event('on-peer-up', 'peer-up') | |
| 232 | event('on-peer-down', 'peer-down') | |
| 233 | event('on-message', 'message') | |
| 234 | event('on-drain', 'channel-ref') | |
| 235 | event('on-status', 'status') | |
| 236 | event('on-content-progress', 'content-progress') | |
| 237 | event('on-content-done', 'content-done') | |
| 238 | event('on-content-failed', 'content-failed') | |
| 239 | ||
| 240 | CHyperschema.toDisk(schema) | |
| 241 | CHRPC.toDisk(hrpc) |
| … | … | @@ -0,0 +1,40 @@ |
| 1 | // This file is autogenerated by hrpc-c | |
| 2 | // !!DO NOT EDIT!! | |
| 3 | #ifndef HRPC_H | |
| 4 | #define HRPC_H | |
| 5 | ||
| 6 | #include <stddef.h> | |
| 7 | #include <stdint.h> | |
| 8 | #include <utf.h> | |
| 9 | ||
| 10 | #include "utf/string.h" | |
| 11 | ||
| 12 | // Error reply / error stream-frame payload. On decode the views point | |
| 13 | // into the inbound frame; copy out anything kept past the read loop. | |
| 14 | typedef struct { | |
| 15 | utf8_string_view_t message; | |
| 16 | utf8_string_view_t code; | |
| 17 | int64_t status; | |
| 18 | } hrpc_error_t; | |
| 19 | ||
| 20 | // <command>_decode_<name>_response result | |
| 21 | enum { | |
| 22 | hrpc_ok = 0, | |
| 23 | hrpc_error_response = 1, | |
| 24 | }; | |
| 25 | ||
| 26 | // <target>_dispatch result (>= 0) | |
| 27 | enum { | |
| 28 | hrpc_dispatch_reply = 0, | |
| 29 | hrpc_dispatch_no_reply = 1, | |
| 30 | hrpc_dispatch_stream = 2, | |
| 31 | }; | |
| 32 | ||
| 33 | // error codes (< 0), distinct from librpc rpc_error / rpc_partial | |
| 34 | enum { | |
| 35 | hrpc_err_alloc = -1, | |
| 36 | hrpc_err_decode = -2, | |
| 37 | hrpc_err_unknown = -3, | |
| 38 | }; | |
| 39 | ||
| 40 | #endif // HRPC_H |
| … | … | @@ -0,0 +1,246 @@ |
| 1 | { | |
| 2 | "version": 1, | |
| 3 | "schema": [ | |
| 4 | { | |
| 5 | "id": 0, | |
| 6 | "name": "@swarmd/hello", | |
| 7 | "request": { | |
| 8 | "name": "@swarmd/hello-request", | |
| 9 | "stream": false | |
| 10 | }, | |
| 11 | "response": { | |
| 12 | "name": "@swarmd/hello-response", | |
| 13 | "stream": false | |
| 14 | }, | |
| 15 | "version": 1 | |
| 16 | }, | |
| 17 | { | |
| 18 | "id": 1, | |
| 19 | "name": "@swarmd/status-get", | |
| 20 | "request": { | |
| 21 | "name": "@swarmd/none", | |
| 22 | "stream": false | |
| 23 | }, | |
| 24 | "response": { | |
| 25 | "name": "@swarmd/status", | |
| 26 | "stream": false | |
| 27 | }, | |
| 28 | "version": 1 | |
| 29 | }, | |
| 30 | { | |
| 31 | "id": 2, | |
| 32 | "name": "@swarmd/swarm-join", | |
| 33 | "request": { | |
| 34 | "name": "@swarmd/swarm-join", | |
| 35 | "stream": false | |
| 36 | }, | |
| 37 | "response": { | |
| 38 | "name": "@swarmd/ok", | |
| 39 | "stream": false | |
| 40 | }, | |
| 41 | "version": 1 | |
| 42 | }, | |
| 43 | { | |
| 44 | "id": 3, | |
| 45 | "name": "@swarmd/swarm-leave", | |
| 46 | "request": { | |
| 47 | "name": "@swarmd/topic-ref", | |
| 48 | "stream": false | |
| 49 | }, | |
| 50 | "response": { | |
| 51 | "name": "@swarmd/ok", | |
| 52 | "stream": false | |
| 53 | }, | |
| 54 | "version": 1 | |
| 55 | }, | |
| 56 | { | |
| 57 | "id": 4, | |
| 58 | "name": "@swarmd/peer-add", | |
| 59 | "request": { | |
| 60 | "name": "@swarmd/peer-key", | |
| 61 | "stream": false | |
| 62 | }, | |
| 63 | "response": { | |
| 64 | "name": "@swarmd/ok", | |
| 65 | "stream": false | |
| 66 | }, | |
| 67 | "version": 1 | |
| 68 | }, | |
| 69 | { | |
| 70 | "id": 5, | |
| 71 | "name": "@swarmd/peer-remove", | |
| 72 | "request": { | |
| 73 | "name": "@swarmd/peer-key", | |
| 74 | "stream": false | |
| 75 | }, | |
| 76 | "response": { | |
| 77 | "name": "@swarmd/ok", | |
| 78 | "stream": false | |
| 79 | }, | |
| 80 | "version": 1 | |
| 81 | }, | |
| 82 | { | |
| 83 | "id": 6, | |
| 84 | "name": "@swarmd/channel-open", | |
| 85 | "request": { | |
| 86 | "name": "@swarmd/channel-open", | |
| 87 | "stream": false | |
| 88 | }, | |
| 89 | "response": { | |
| 90 | "name": "@swarmd/channel-ref", | |
| 91 | "stream": false | |
| 92 | }, | |
| 93 | "version": 1 | |
| 94 | }, | |
| 95 | { | |
| 96 | "id": 7, | |
| 97 | "name": "@swarmd/channel-close", | |
| 98 | "request": { | |
| 99 | "name": "@swarmd/channel-ref", | |
| 100 | "stream": false | |
| 101 | }, | |
| 102 | "response": { | |
| 103 | "name": "@swarmd/ok", | |
| 104 | "stream": false | |
| 105 | }, | |
| 106 | "version": 1 | |
| 107 | }, | |
| 108 | { | |
| 109 | "id": 8, | |
| 110 | "name": "@swarmd/send", | |
| 111 | "request": { | |
| 112 | "name": "@swarmd/send-request", | |
| 113 | "stream": false | |
| 114 | }, | |
| 115 | "response": { | |
| 116 | "name": "@swarmd/send-result", | |
| 117 | "stream": false | |
| 118 | }, | |
| 119 | "version": 1 | |
| 120 | }, | |
| 121 | { | |
| 122 | "id": 9, | |
| 123 | "name": "@swarmd/content-hash", | |
| 124 | "request": { | |
| 125 | "name": "@swarmd/path", | |
| 126 | "stream": false | |
| 127 | }, | |
| 128 | "response": { | |
| 129 | "name": "@swarmd/hash", | |
| 130 | "stream": false | |
| 131 | }, | |
| 132 | "version": 1 | |
| 133 | }, | |
| 134 | { | |
| 135 | "id": 10, | |
| 136 | "name": "@swarmd/content-serve", | |
| 137 | "request": { | |
| 138 | "name": "@swarmd/content-serve", | |
| 139 | "stream": false | |
| 140 | }, | |
| 141 | "response": { | |
| 142 | "name": "@swarmd/ok", | |
| 143 | "stream": false | |
| 144 | }, | |
| 145 | "version": 1 | |
| 146 | }, | |
| 147 | { | |
| 148 | "id": 11, | |
| 149 | "name": "@swarmd/content-fetch", | |
| 150 | "request": { | |
| 151 | "name": "@swarmd/content-fetch", | |
| 152 | "stream": false | |
| 153 | }, | |
| 154 | "response": { | |
| 155 | "name": "@swarmd/ok", | |
| 156 | "stream": false | |
| 157 | }, | |
| 158 | "version": 1 | |
| 159 | }, | |
| 160 | { | |
| 161 | "id": 12, | |
| 162 | "name": "@swarmd/content-cancel", | |
| 163 | "request": { | |
| 164 | "name": "@swarmd/content-cancel", | |
| 165 | "stream": false | |
| 166 | }, | |
| 167 | "response": { | |
| 168 | "name": "@swarmd/ok", | |
| 169 | "stream": false | |
| 170 | }, | |
| 171 | "version": 1 | |
| 172 | }, | |
| 173 | { | |
| 174 | "id": 13, | |
| 175 | "name": "@swarmd/on-peer-up", | |
| 176 | "request": { | |
| 177 | "name": "@swarmd/peer-up", | |
| 178 | "send": true | |
| 179 | }, | |
| 180 | "version": 1 | |
| 181 | }, | |
| 182 | { | |
| 183 | "id": 14, | |
| 184 | "name": "@swarmd/on-peer-down", | |
| 185 | "request": { | |
| 186 | "name": "@swarmd/peer-down", | |
| 187 | "send": true | |
| 188 | }, | |
| 189 | "version": 1 | |
| 190 | }, | |
| 191 | { | |
| 192 | "id": 15, | |
| 193 | "name": "@swarmd/on-message", | |
| 194 | "request": { | |
| 195 | "name": "@swarmd/message", | |
| 196 | "send": true | |
| 197 | }, | |
| 198 | "version": 1 | |
| 199 | }, | |
| 200 | { | |
| 201 | "id": 16, | |
| 202 | "name": "@swarmd/on-drain", | |
| 203 | "request": { | |
| 204 | "name": "@swarmd/channel-ref", | |
| 205 | "send": true | |
| 206 | }, | |
| 207 | "version": 1 | |
| 208 | }, | |
| 209 | { | |
| 210 | "id": 17, | |
| 211 | "name": "@swarmd/on-status", | |
| 212 | "request": { | |
| 213 | "name": "@swarmd/status", | |
| 214 | "send": true | |
| 215 | }, | |
| 216 | "version": 1 | |
| 217 | }, | |
| 218 | { | |
| 219 | "id": 18, | |
| 220 | "name": "@swarmd/on-content-progress", | |
| 221 | "request": { | |
| 222 | "name": "@swarmd/content-progress", | |
| 223 | "send": true | |
| 224 | }, | |
| 225 | "version": 1 | |
| 226 | }, | |
| 227 | { | |
| 228 | "id": 19, | |
| 229 | "name": "@swarmd/on-content-done", | |
| 230 | "request": { | |
| 231 | "name": "@swarmd/content-done", | |
| 232 | "send": true | |
| 233 | }, | |
| 234 | "version": 1 | |
| 235 | }, | |
| 236 | { | |
| 237 | "id": 20, | |
| 238 | "name": "@swarmd/on-content-failed", | |
| 239 | "request": { | |
| 240 | "name": "@swarmd/content-failed", | |
| 241 | "send": true | |
| 242 | }, | |
| 243 | "version": 1 | |
| 244 | } | |
| 245 | ] | |
| 246 | } |
| … | … | @@ -0,0 +1,501 @@ |
| 1 | { | |
| 2 | "version": 1, | |
| 3 | "schema": [ | |
| 4 | { | |
| 5 | "name": "hello-request", | |
| 6 | "namespace": "swarmd", | |
| 7 | "compact": false, | |
| 8 | "flagsPosition": -1, | |
| 9 | "fields": [ | |
| 10 | { | |
| 11 | "name": "name", | |
| 12 | "required": true, | |
| 13 | "type": "string", | |
| 14 | "version": 1 | |
| 15 | }, | |
| 16 | { | |
| 17 | "name": "app-identity", | |
| 18 | "required": true, | |
| 19 | "type": "fixed32", | |
| 20 | "version": 1 | |
| 21 | }, | |
| 22 | { | |
| 23 | "name": "version", | |
| 24 | "required": true, | |
| 25 | "type": "uint", | |
| 26 | "version": 1 | |
| 27 | } | |
| 28 | ] | |
| 29 | }, | |
| 30 | { | |
| 31 | "name": "hello-response", | |
| 32 | "namespace": "swarmd", | |
| 33 | "compact": false, | |
| 34 | "flagsPosition": -1, | |
| 35 | "fields": [ | |
| 36 | { | |
| 37 | "name": "client-id", | |
| 38 | "required": true, | |
| 39 | "type": "uint", | |
| 40 | "version": 1 | |
| 41 | }, | |
| 42 | { | |
| 43 | "name": "daemon-pubkey", | |
| 44 | "required": true, | |
| 45 | "type": "fixed32", | |
| 46 | "version": 1 | |
| 47 | } | |
| 48 | ] | |
| 49 | }, | |
| 50 | { | |
| 51 | "name": "status", | |
| 52 | "namespace": "swarmd", | |
| 53 | "compact": false, | |
| 54 | "flagsPosition": 1, | |
| 55 | "fields": [ | |
| 56 | { | |
| 57 | "name": "dht-state", | |
| 58 | "required": true, | |
| 59 | "type": "uint", | |
| 60 | "version": 1 | |
| 61 | }, | |
| 62 | { | |
| 63 | "name": "bootstrapped", | |
| 64 | "required": false, | |
| 65 | "type": "bool", | |
| 66 | "version": 1 | |
| 67 | }, | |
| 68 | { | |
| 69 | "name": "peers-known", | |
| 70 | "required": true, | |
| 71 | "type": "uint", | |
| 72 | "version": 1 | |
| 73 | }, | |
| 74 | { | |
| 75 | "name": "peers-connected", | |
| 76 | "required": true, | |
| 77 | "type": "uint", | |
| 78 | "version": 1 | |
| 79 | }, | |
| 80 | { | |
| 81 | "name": "connecting", | |
| 82 | "required": true, | |
| 83 | "type": "uint", | |
| 84 | "version": 1 | |
| 85 | }, | |
| 86 | { | |
| 87 | "name": "queued", | |
| 88 | "required": true, | |
| 89 | "type": "uint", | |
| 90 | "version": 1 | |
| 91 | }, | |
| 92 | { | |
| 93 | "name": "local-clients", | |
| 94 | "required": true, | |
| 95 | "type": "uint", | |
| 96 | "version": 1 | |
| 97 | } | |
| 98 | ] | |
| 99 | }, | |
| 100 | { | |
| 101 | "name": "ok", | |
| 102 | "namespace": "swarmd", | |
| 103 | "compact": false, | |
| 104 | "flagsPosition": 0, | |
| 105 | "fields": [ | |
| 106 | { | |
| 107 | "name": "ok", | |
| 108 | "required": false, | |
| 109 | "type": "bool", | |
| 110 | "version": 1 | |
| 111 | } | |
| 112 | ] | |
| 113 | }, | |
| 114 | { | |
| 115 | "name": "none", | |
| 116 | "namespace": "swarmd", | |
| 117 | "compact": false, | |
| 118 | "flagsPosition": -1, | |
| 119 | "fields": [ | |
| 120 | { | |
| 121 | "name": "reserved", | |
| 122 | "required": true, | |
| 123 | "type": "uint", | |
| 124 | "version": 1 | |
| 125 | } | |
| 126 | ] | |
| 127 | }, | |
| 128 | { | |
| 129 | "name": "swarm-join", | |
| 130 | "namespace": "swarmd", | |
| 131 | "compact": false, | |
| 132 | "flagsPosition": 1, | |
| 133 | "fields": [ | |
| 134 | { | |
| 135 | "name": "topic", | |
| 136 | "required": true, | |
| 137 | "type": "fixed32", | |
| 138 | "version": 1 | |
| 139 | }, | |
| 140 | { | |
| 141 | "name": "server", | |
| 142 | "required": false, | |
| 143 | "type": "bool", | |
| 144 | "version": 1 | |
| 145 | }, | |
| 146 | { | |
| 147 | "name": "client", | |
| 148 | "required": false, | |
| 149 | "type": "bool", | |
| 150 | "version": 1 | |
| 151 | } | |
| 152 | ] | |
| 153 | }, | |
| 154 | { | |
| 155 | "name": "topic-ref", | |
| 156 | "namespace": "swarmd", | |
| 157 | "compact": false, | |
| 158 | "flagsPosition": -1, | |
| 159 | "fields": [ | |
| 160 | { | |
| 161 | "name": "topic", | |
| 162 | "required": true, | |
| 163 | "type": "fixed32", | |
| 164 | "version": 1 | |
| 165 | } | |
| 166 | ] | |
| 167 | }, | |
| 168 | { | |
| 169 | "name": "peer-key", | |
| 170 | "namespace": "swarmd", | |
| 171 | "compact": false, | |
| 172 | "flagsPosition": -1, | |
| 173 | "fields": [ | |
| 174 | { | |
| 175 | "name": "pubkey", | |
| 176 | "required": true, | |
| 177 | "type": "fixed32", | |
| 178 | "version": 1 | |
| 179 | } | |
| 180 | ] | |
| 181 | }, | |
| 182 | { | |
| 183 | "name": "channel-open", | |
| 184 | "namespace": "swarmd", | |
| 185 | "compact": false, | |
| 186 | "flagsPosition": -1, | |
| 187 | "fields": [ | |
| 188 | { | |
| 189 | "name": "protocol", | |
| 190 | "required": true, | |
| 191 | "type": "string", | |
| 192 | "version": 1 | |
| 193 | }, | |
| 194 | { | |
| 195 | "name": "id", | |
| 196 | "required": true, | |
| 197 | "type": "buffer", | |
| 198 | "version": 1 | |
| 199 | }, | |
| 200 | { | |
| 201 | "name": "slots", | |
| 202 | "required": true, | |
| 203 | "type": "uint", | |
| 204 | "version": 1 | |
| 205 | } | |
| 206 | ] | |
| 207 | }, | |
| 208 | { | |
| 209 | "name": "channel-ref", | |
| 210 | "namespace": "swarmd", | |
| 211 | "compact": false, | |
| 212 | "flagsPosition": -1, | |
| 213 | "fields": [ | |
| 214 | { | |
| 215 | "name": "channel", | |
| 216 | "required": true, | |
| 217 | "type": "uint", | |
| 218 | "version": 1 | |
| 219 | } | |
| 220 | ] | |
| 221 | }, | |
| 222 | { | |
| 223 | "name": "send-request", | |
| 224 | "namespace": "swarmd", | |
| 225 | "compact": false, | |
| 226 | "flagsPosition": -1, | |
| 227 | "fields": [ | |
| 228 | { | |
| 229 | "name": "channel", | |
| 230 | "required": true, | |
| 231 | "type": "uint", | |
| 232 | "version": 1 | |
| 233 | }, | |
| 234 | { | |
| 235 | "name": "slot", | |
| 236 | "required": true, | |
| 237 | "type": "uint", | |
| 238 | "version": 1 | |
| 239 | }, | |
| 240 | { | |
| 241 | "name": "target", | |
| 242 | "required": true, | |
| 243 | "type": "uint", | |
| 244 | "version": 1 | |
| 245 | }, | |
| 246 | { | |
| 247 | "name": "bytes", | |
| 248 | "required": true, | |
| 249 | "type": "buffer", | |
| 250 | "version": 1 | |
| 251 | } | |
| 252 | ] | |
| 253 | }, | |
| 254 | { | |
| 255 | "name": "send-result", | |
| 256 | "namespace": "swarmd", | |
| 257 | "compact": false, | |
| 258 | "flagsPosition": 0, | |
| 259 | "fields": [ | |
| 260 | { | |
| 261 | "name": "accepted", | |
| 262 | "required": false, | |
| 263 | "type": "bool", | |
| 264 | "version": 1 | |
| 265 | }, | |
| 266 | { | |
| 267 | "name": "writable", | |
| 268 | "required": false, | |
| 269 | "type": "bool", | |
| 270 | "version": 1 | |
| 271 | } | |
| 272 | ] | |
| 273 | }, | |
| 274 | { | |
| 275 | "name": "path", | |
| 276 | "namespace": "swarmd", | |
| 277 | "compact": false, | |
| 278 | "flagsPosition": -1, | |
| 279 | "fields": [ | |
| 280 | { | |
| 281 | "name": "path", | |
| 282 | "required": true, | |
| 283 | "type": "string", | |
| 284 | "version": 1 | |
| 285 | } | |
| 286 | ] | |
| 287 | }, | |
| 288 | { | |
| 289 | "name": "hash", | |
| 290 | "namespace": "swarmd", | |
| 291 | "compact": false, | |
| 292 | "flagsPosition": -1, | |
| 293 | "fields": [ | |
| 294 | { | |
| 295 | "name": "hash", | |
| 296 | "required": true, | |
| 297 | "type": "fixed32", | |
| 298 | "version": 1 | |
| 299 | } | |
| 300 | ] | |
| 301 | }, | |
| 302 | { | |
| 303 | "name": "content-serve", | |
| 304 | "namespace": "swarmd", | |
| 305 | "compact": false, | |
| 306 | "flagsPosition": -1, | |
| 307 | "fields": [ | |
| 308 | { | |
| 309 | "name": "hash", | |
| 310 | "required": true, | |
| 311 | "type": "fixed32", | |
| 312 | "version": 1 | |
| 313 | }, | |
| 314 | { | |
| 315 | "name": "path", | |
| 316 | "required": true, | |
| 317 | "type": "string", | |
| 318 | "version": 1 | |
| 319 | } | |
| 320 | ] | |
| 321 | }, | |
| 322 | { | |
| 323 | "name": "content-fetch", | |
| 324 | "namespace": "swarmd", | |
| 325 | "compact": false, | |
| 326 | "flagsPosition": -1, | |
| 327 | "fields": [ | |
| 328 | { | |
| 329 | "name": "hash", | |
| 330 | "required": true, | |
| 331 | "type": "fixed32", | |
| 332 | "version": 1 | |
| 333 | }, | |
| 334 | { | |
| 335 | "name": "dest-path", | |
| 336 | "required": true, | |
| 337 | "type": "string", | |
| 338 | "version": 1 | |
| 339 | } | |
| 340 | ] | |
| 341 | }, | |
| 342 | { | |
| 343 | "name": "content-cancel", | |
| 344 | "namespace": "swarmd", | |
| 345 | "compact": false, | |
| 346 | "flagsPosition": 1, | |
| 347 | "fields": [ | |
| 348 | { | |
| 349 | "name": "hash", | |
| 350 | "required": true, | |
| 351 | "type": "fixed32", | |
| 352 | "version": 1 | |
| 353 | }, | |
| 354 | { | |
| 355 | "name": "discard", | |
| 356 | "required": false, | |
| 357 | "type": "bool", | |
| 358 | "version": 1 | |
| 359 | } | |
| 360 | ] | |
| 361 | }, | |
| 362 | { | |
| 363 | "name": "content-progress", | |
| 364 | "namespace": "swarmd", | |
| 365 | "compact": false, | |
| 366 | "flagsPosition": -1, | |
| 367 | "fields": [ | |
| 368 | { | |
| 369 | "name": "hash", | |
| 370 | "required": true, | |
| 371 | "type": "fixed32", | |
| 372 | "version": 1 | |
| 373 | }, | |
| 374 | { | |
| 375 | "name": "received", | |
| 376 | "required": true, | |
| 377 | "type": "uint", | |
| 378 | "version": 1 | |
| 379 | }, | |
| 380 | { | |
| 381 | "name": "total", | |
| 382 | "required": true, | |
| 383 | "type": "uint", | |
| 384 | "version": 1 | |
| 385 | } | |
| 386 | ] | |
| 387 | }, | |
| 388 | { | |
| 389 | "name": "content-done", | |
| 390 | "namespace": "swarmd", | |
| 391 | "compact": false, | |
| 392 | "flagsPosition": -1, | |
| 393 | "fields": [ | |
| 394 | { | |
| 395 | "name": "hash", | |
| 396 | "required": true, | |
| 397 | "type": "fixed32", | |
| 398 | "version": 1 | |
| 399 | }, | |
| 400 | { | |
| 401 | "name": "path", | |
| 402 | "required": true, | |
| 403 | "type": "string", | |
| 404 | "version": 1 | |
| 405 | } | |
| 406 | ] | |
| 407 | }, | |
| 408 | { | |
| 409 | "name": "content-failed", | |
| 410 | "namespace": "swarmd", | |
| 411 | "compact": false, | |
| 412 | "flagsPosition": -1, | |
| 413 | "fields": [ | |
| 414 | { | |
| 415 | "name": "hash", | |
| 416 | "required": true, | |
| 417 | "type": "fixed32", | |
| 418 | "version": 1 | |
| 419 | }, | |
| 420 | { | |
| 421 | "name": "reason", | |
| 422 | "required": true, | |
| 423 | "type": "string", | |
| 424 | "version": 1 | |
| 425 | } | |
| 426 | ] | |
| 427 | }, | |
| 428 | { | |
| 429 | "name": "peer-up", | |
| 430 | "namespace": "swarmd", | |
| 431 | "compact": false, | |
| 432 | "flagsPosition": -1, | |
| 433 | "fields": [ | |
| 434 | { | |
| 435 | "name": "peer", | |
| 436 | "required": true, | |
| 437 | "type": "uint", | |
| 438 | "version": 1 | |
| 439 | }, | |
| 440 | { | |
| 441 | "name": "pubkey", | |
| 442 | "required": true, | |
| 443 | "type": "fixed32", | |
| 444 | "version": 1 | |
| 445 | } | |
| 446 | ] | |
| 447 | }, | |
| 448 | { | |
| 449 | "name": "peer-down", | |
| 450 | "namespace": "swarmd", | |
| 451 | "compact": false, | |
| 452 | "flagsPosition": -1, | |
| 453 | "fields": [ | |
| 454 | { | |
| 455 | "name": "peer", | |
| 456 | "required": true, | |
| 457 | "type": "uint", | |
| 458 | "version": 1 | |
| 459 | } | |
| 460 | ] | |
| 461 | }, | |
| 462 | { | |
| 463 | "name": "message", | |
| 464 | "namespace": "swarmd", | |
| 465 | "compact": false, | |
| 466 | "flagsPosition": -1, | |
| 467 | "fields": [ | |
| 468 | { | |
| 469 | "name": "channel", | |
| 470 | "required": true, | |
| 471 | "type": "uint", | |
| 472 | "version": 1 | |
| 473 | }, | |
| 474 | { | |
| 475 | "name": "slot", | |
| 476 | "required": true, | |
| 477 | "type": "uint", | |
| 478 | "version": 1 | |
| 479 | }, | |
| 480 | { | |
| 481 | "name": "origin-kind", | |
| 482 | "required": true, | |
| 483 | "type": "uint", | |
| 484 | "version": 1 | |
| 485 | }, | |
| 486 | { | |
| 487 | "name": "origin-id", | |
| 488 | "required": true, | |
| 489 | "type": "uint", | |
| 490 | "version": 1 | |
| 491 | }, | |
| 492 | { | |
| 493 | "name": "bytes", | |
| 494 | "required": true, | |
| 495 | "type": "buffer", | |
| 496 | "version": 1 | |
| 497 | } | |
| 498 | ] | |
| 499 | } | |
| 500 | ] | |
| 501 | } |
| … | … | @@ -0,0 +1,1757 @@ |
| 1 | // This file is autogenerated by hrpc-c | |
| 2 | // !!DO NOT EDIT!! | |
| 3 | #include "swarmd_hrpc.h" | |
| 4 | ||
| 5 | #include <compact.h> | |
| 6 | #include <stdlib.h> | |
| 7 | ||
| 8 | static int | |
| 9 | swarmd_hrpc__frame (const rpc_message_t *msg, uint8_t **out, size_t *out_len) { | |
| 10 | compact_state_t state = {0, 0, NULL}; | |
| 11 | int err = rpc_preencode_message(&state, msg); | |
| 12 | if (err < 0) return hrpc_err_decode; | |
| 13 | state.buffer = malloc(state.end); | |
| 14 | if (state.buffer == NULL) return hrpc_err_alloc; | |
| 15 | err = rpc_encode_message(&state, msg); | |
| 16 | if (err < 0) { | |
| 17 | free(state.buffer); | |
| 18 | return hrpc_err_decode; | |
| 19 | } | |
| 20 | *out = state.buffer; | |
| 21 | *out_len = state.end; | |
| 22 | return 0; | |
| 23 | } | |
| 24 | ||
| 25 | int | |
| 26 | swarmd_encode_hello (uint64_t id, const swarmd_hello_request_t *args, uint8_t **out, size_t *out_len) { | |
| 27 | compact_state_t payload = {0, 0, NULL}; | |
| 28 | int err = swarmd_hello_request_preencode(&payload, args); | |
| 29 | if (err < 0) return hrpc_err_decode; | |
| 30 | if (payload.end > 0) { | |
| 31 | payload.buffer = malloc(payload.end); | |
| 32 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 33 | err = swarmd_hello_request_encode(&payload, args); | |
| 34 | if (err < 0) { | |
| 35 | free(payload.buffer); | |
| 36 | return hrpc_err_decode; | |
| 37 | } | |
| 38 | } | |
| 39 | ||
| 40 | rpc_message_t msg = {0}; | |
| 41 | msg.type = rpc_request; | |
| 42 | msg.id = id; | |
| 43 | msg.command = swarmd_command_hello; | |
| 44 | msg.stream = 0; | |
| 45 | msg.data = payload.buffer; | |
| 46 | msg.len = payload.end; | |
| 47 | ||
| 48 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 49 | free(payload.buffer); | |
| 50 | return err; | |
| 51 | } | |
| 52 | ||
| 53 | int | |
| 54 | swarmd_encode_hello_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 55 | rpc_message_t msg = {0}; | |
| 56 | msg.type = rpc_response; | |
| 57 | msg.id = id; | |
| 58 | msg.error = true; | |
| 59 | msg.stream = 0; | |
| 60 | msg.message = error.message; | |
| 61 | msg.code = error.code; | |
| 62 | msg.status = error.status; | |
| 63 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 64 | } | |
| 65 | ||
| 66 | int | |
| 67 | swarmd_decode_hello_response (const rpc_message_t *msg, swarmd_hello_response_t *result, hrpc_error_t *error) { | |
| 68 | if (msg->error) { | |
| 69 | error->message = msg->message; | |
| 70 | error->code = msg->code; | |
| 71 | error->status = msg->status; | |
| 72 | return hrpc_error_response; | |
| 73 | } | |
| 74 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 75 | int err = swarmd_hello_response_decode(&payload, result); | |
| 76 | if (err < 0) return hrpc_err_decode; | |
| 77 | return hrpc_ok; | |
| 78 | } | |
| 79 | ||
| 80 | int | |
| 81 | swarmd_encode_status_get (uint64_t id, const swarmd_none_t *args, uint8_t **out, size_t *out_len) { | |
| 82 | compact_state_t payload = {0, 0, NULL}; | |
| 83 | int err = swarmd_none_preencode(&payload, args); | |
| 84 | if (err < 0) return hrpc_err_decode; | |
| 85 | if (payload.end > 0) { | |
| 86 | payload.buffer = malloc(payload.end); | |
| 87 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 88 | err = swarmd_none_encode(&payload, args); | |
| 89 | if (err < 0) { | |
| 90 | free(payload.buffer); | |
| 91 | return hrpc_err_decode; | |
| 92 | } | |
| 93 | } | |
| 94 | ||
| 95 | rpc_message_t msg = {0}; | |
| 96 | msg.type = rpc_request; | |
| 97 | msg.id = id; | |
| 98 | msg.command = swarmd_command_status_get; | |
| 99 | msg.stream = 0; | |
| 100 | msg.data = payload.buffer; | |
| 101 | msg.len = payload.end; | |
| 102 | ||
| 103 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 104 | free(payload.buffer); | |
| 105 | return err; | |
| 106 | } | |
| 107 | ||
| 108 | int | |
| 109 | swarmd_encode_status_get_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 110 | rpc_message_t msg = {0}; | |
| 111 | msg.type = rpc_response; | |
| 112 | msg.id = id; | |
| 113 | msg.error = true; | |
| 114 | msg.stream = 0; | |
| 115 | msg.message = error.message; | |
| 116 | msg.code = error.code; | |
| 117 | msg.status = error.status; | |
| 118 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 119 | } | |
| 120 | ||
| 121 | int | |
| 122 | swarmd_decode_status_get_response (const rpc_message_t *msg, swarmd_status_t *result, hrpc_error_t *error) { | |
| 123 | if (msg->error) { | |
| 124 | error->message = msg->message; | |
| 125 | error->code = msg->code; | |
| 126 | error->status = msg->status; | |
| 127 | return hrpc_error_response; | |
| 128 | } | |
| 129 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 130 | int err = swarmd_status_decode(&payload, result); | |
| 131 | if (err < 0) return hrpc_err_decode; | |
| 132 | return hrpc_ok; | |
| 133 | } | |
| 134 | ||
| 135 | int | |
| 136 | swarmd_encode_swarm_join (uint64_t id, const swarmd_swarm_join_t *args, uint8_t **out, size_t *out_len) { | |
| 137 | compact_state_t payload = {0, 0, NULL}; | |
| 138 | int err = swarmd_swarm_join_preencode(&payload, args); | |
| 139 | if (err < 0) return hrpc_err_decode; | |
| 140 | if (payload.end > 0) { | |
| 141 | payload.buffer = malloc(payload.end); | |
| 142 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 143 | err = swarmd_swarm_join_encode(&payload, args); | |
| 144 | if (err < 0) { | |
| 145 | free(payload.buffer); | |
| 146 | return hrpc_err_decode; | |
| 147 | } | |
| 148 | } | |
| 149 | ||
| 150 | rpc_message_t msg = {0}; | |
| 151 | msg.type = rpc_request; | |
| 152 | msg.id = id; | |
| 153 | msg.command = swarmd_command_swarm_join; | |
| 154 | msg.stream = 0; | |
| 155 | msg.data = payload.buffer; | |
| 156 | msg.len = payload.end; | |
| 157 | ||
| 158 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 159 | free(payload.buffer); | |
| 160 | return err; | |
| 161 | } | |
| 162 | ||
| 163 | int | |
| 164 | swarmd_encode_swarm_join_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 165 | rpc_message_t msg = {0}; | |
| 166 | msg.type = rpc_response; | |
| 167 | msg.id = id; | |
| 168 | msg.error = true; | |
| 169 | msg.stream = 0; | |
| 170 | msg.message = error.message; | |
| 171 | msg.code = error.code; | |
| 172 | msg.status = error.status; | |
| 173 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 174 | } | |
| 175 | ||
| 176 | int | |
| 177 | swarmd_decode_swarm_join_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 178 | if (msg->error) { | |
| 179 | error->message = msg->message; | |
| 180 | error->code = msg->code; | |
| 181 | error->status = msg->status; | |
| 182 | return hrpc_error_response; | |
| 183 | } | |
| 184 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 185 | int err = swarmd_ok_decode(&payload, result); | |
| 186 | if (err < 0) return hrpc_err_decode; | |
| 187 | return hrpc_ok; | |
| 188 | } | |
| 189 | ||
| 190 | int | |
| 191 | swarmd_encode_swarm_leave (uint64_t id, const swarmd_topic_ref_t *args, uint8_t **out, size_t *out_len) { | |
| 192 | compact_state_t payload = {0, 0, NULL}; | |
| 193 | int err = swarmd_topic_ref_preencode(&payload, args); | |
| 194 | if (err < 0) return hrpc_err_decode; | |
| 195 | if (payload.end > 0) { | |
| 196 | payload.buffer = malloc(payload.end); | |
| 197 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 198 | err = swarmd_topic_ref_encode(&payload, args); | |
| 199 | if (err < 0) { | |
| 200 | free(payload.buffer); | |
| 201 | return hrpc_err_decode; | |
| 202 | } | |
| 203 | } | |
| 204 | ||
| 205 | rpc_message_t msg = {0}; | |
| 206 | msg.type = rpc_request; | |
| 207 | msg.id = id; | |
| 208 | msg.command = swarmd_command_swarm_leave; | |
| 209 | msg.stream = 0; | |
| 210 | msg.data = payload.buffer; | |
| 211 | msg.len = payload.end; | |
| 212 | ||
| 213 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 214 | free(payload.buffer); | |
| 215 | return err; | |
| 216 | } | |
| 217 | ||
| 218 | int | |
| 219 | swarmd_encode_swarm_leave_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 220 | rpc_message_t msg = {0}; | |
| 221 | msg.type = rpc_response; | |
| 222 | msg.id = id; | |
| 223 | msg.error = true; | |
| 224 | msg.stream = 0; | |
| 225 | msg.message = error.message; | |
| 226 | msg.code = error.code; | |
| 227 | msg.status = error.status; | |
| 228 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 229 | } | |
| 230 | ||
| 231 | int | |
| 232 | swarmd_decode_swarm_leave_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 233 | if (msg->error) { | |
| 234 | error->message = msg->message; | |
| 235 | error->code = msg->code; | |
| 236 | error->status = msg->status; | |
| 237 | return hrpc_error_response; | |
| 238 | } | |
| 239 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 240 | int err = swarmd_ok_decode(&payload, result); | |
| 241 | if (err < 0) return hrpc_err_decode; | |
| 242 | return hrpc_ok; | |
| 243 | } | |
| 244 | ||
| 245 | int | |
| 246 | swarmd_encode_peer_add (uint64_t id, const swarmd_peer_key_t *args, uint8_t **out, size_t *out_len) { | |
| 247 | compact_state_t payload = {0, 0, NULL}; | |
| 248 | int err = swarmd_peer_key_preencode(&payload, args); | |
| 249 | if (err < 0) return hrpc_err_decode; | |
| 250 | if (payload.end > 0) { | |
| 251 | payload.buffer = malloc(payload.end); | |
| 252 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 253 | err = swarmd_peer_key_encode(&payload, args); | |
| 254 | if (err < 0) { | |
| 255 | free(payload.buffer); | |
| 256 | return hrpc_err_decode; | |
| 257 | } | |
| 258 | } | |
| 259 | ||
| 260 | rpc_message_t msg = {0}; | |
| 261 | msg.type = rpc_request; | |
| 262 | msg.id = id; | |
| 263 | msg.command = swarmd_command_peer_add; | |
| 264 | msg.stream = 0; | |
| 265 | msg.data = payload.buffer; | |
| 266 | msg.len = payload.end; | |
| 267 | ||
| 268 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 269 | free(payload.buffer); | |
| 270 | return err; | |
| 271 | } | |
| 272 | ||
| 273 | int | |
| 274 | swarmd_encode_peer_add_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 275 | rpc_message_t msg = {0}; | |
| 276 | msg.type = rpc_response; | |
| 277 | msg.id = id; | |
| 278 | msg.error = true; | |
| 279 | msg.stream = 0; | |
| 280 | msg.message = error.message; | |
| 281 | msg.code = error.code; | |
| 282 | msg.status = error.status; | |
| 283 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 284 | } | |
| 285 | ||
| 286 | int | |
| 287 | swarmd_decode_peer_add_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 288 | if (msg->error) { | |
| 289 | error->message = msg->message; | |
| 290 | error->code = msg->code; | |
| 291 | error->status = msg->status; | |
| 292 | return hrpc_error_response; | |
| 293 | } | |
| 294 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 295 | int err = swarmd_ok_decode(&payload, result); | |
| 296 | if (err < 0) return hrpc_err_decode; | |
| 297 | return hrpc_ok; | |
| 298 | } | |
| 299 | ||
| 300 | int | |
| 301 | swarmd_encode_peer_remove (uint64_t id, const swarmd_peer_key_t *args, uint8_t **out, size_t *out_len) { | |
| 302 | compact_state_t payload = {0, 0, NULL}; | |
| 303 | int err = swarmd_peer_key_preencode(&payload, args); | |
| 304 | if (err < 0) return hrpc_err_decode; | |
| 305 | if (payload.end > 0) { | |
| 306 | payload.buffer = malloc(payload.end); | |
| 307 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 308 | err = swarmd_peer_key_encode(&payload, args); | |
| 309 | if (err < 0) { | |
| 310 | free(payload.buffer); | |
| 311 | return hrpc_err_decode; | |
| 312 | } | |
| 313 | } | |
| 314 | ||
| 315 | rpc_message_t msg = {0}; | |
| 316 | msg.type = rpc_request; | |
| 317 | msg.id = id; | |
| 318 | msg.command = swarmd_command_peer_remove; | |
| 319 | msg.stream = 0; | |
| 320 | msg.data = payload.buffer; | |
| 321 | msg.len = payload.end; | |
| 322 | ||
| 323 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 324 | free(payload.buffer); | |
| 325 | return err; | |
| 326 | } | |
| 327 | ||
| 328 | int | |
| 329 | swarmd_encode_peer_remove_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 330 | rpc_message_t msg = {0}; | |
| 331 | msg.type = rpc_response; | |
| 332 | msg.id = id; | |
| 333 | msg.error = true; | |
| 334 | msg.stream = 0; | |
| 335 | msg.message = error.message; | |
| 336 | msg.code = error.code; | |
| 337 | msg.status = error.status; | |
| 338 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 339 | } | |
| 340 | ||
| 341 | int | |
| 342 | swarmd_decode_peer_remove_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 343 | if (msg->error) { | |
| 344 | error->message = msg->message; | |
| 345 | error->code = msg->code; | |
| 346 | error->status = msg->status; | |
| 347 | return hrpc_error_response; | |
| 348 | } | |
| 349 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 350 | int err = swarmd_ok_decode(&payload, result); | |
| 351 | if (err < 0) return hrpc_err_decode; | |
| 352 | return hrpc_ok; | |
| 353 | } | |
| 354 | ||
| 355 | int | |
| 356 | swarmd_encode_channel_open (uint64_t id, const swarmd_channel_open_t *args, uint8_t **out, size_t *out_len) { | |
| 357 | compact_state_t payload = {0, 0, NULL}; | |
| 358 | int err = swarmd_channel_open_preencode(&payload, args); | |
| 359 | if (err < 0) return hrpc_err_decode; | |
| 360 | if (payload.end > 0) { | |
| 361 | payload.buffer = malloc(payload.end); | |
| 362 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 363 | err = swarmd_channel_open_encode(&payload, args); | |
| 364 | if (err < 0) { | |
| 365 | free(payload.buffer); | |
| 366 | return hrpc_err_decode; | |
| 367 | } | |
| 368 | } | |
| 369 | ||
| 370 | rpc_message_t msg = {0}; | |
| 371 | msg.type = rpc_request; | |
| 372 | msg.id = id; | |
| 373 | msg.command = swarmd_command_channel_open; | |
| 374 | msg.stream = 0; | |
| 375 | msg.data = payload.buffer; | |
| 376 | msg.len = payload.end; | |
| 377 | ||
| 378 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 379 | free(payload.buffer); | |
| 380 | return err; | |
| 381 | } | |
| 382 | ||
| 383 | int | |
| 384 | swarmd_encode_channel_open_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 385 | rpc_message_t msg = {0}; | |
| 386 | msg.type = rpc_response; | |
| 387 | msg.id = id; | |
| 388 | msg.error = true; | |
| 389 | msg.stream = 0; | |
| 390 | msg.message = error.message; | |
| 391 | msg.code = error.code; | |
| 392 | msg.status = error.status; | |
| 393 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 394 | } | |
| 395 | ||
| 396 | int | |
| 397 | swarmd_decode_channel_open_response (const rpc_message_t *msg, swarmd_channel_ref_t *result, hrpc_error_t *error) { | |
| 398 | if (msg->error) { | |
| 399 | error->message = msg->message; | |
| 400 | error->code = msg->code; | |
| 401 | error->status = msg->status; | |
| 402 | return hrpc_error_response; | |
| 403 | } | |
| 404 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 405 | int err = swarmd_channel_ref_decode(&payload, result); | |
| 406 | if (err < 0) return hrpc_err_decode; | |
| 407 | return hrpc_ok; | |
| 408 | } | |
| 409 | ||
| 410 | int | |
| 411 | swarmd_encode_channel_close (uint64_t id, const swarmd_channel_ref_t *args, uint8_t **out, size_t *out_len) { | |
| 412 | compact_state_t payload = {0, 0, NULL}; | |
| 413 | int err = swarmd_channel_ref_preencode(&payload, args); | |
| 414 | if (err < 0) return hrpc_err_decode; | |
| 415 | if (payload.end > 0) { | |
| 416 | payload.buffer = malloc(payload.end); | |
| 417 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 418 | err = swarmd_channel_ref_encode(&payload, args); | |
| 419 | if (err < 0) { | |
| 420 | free(payload.buffer); | |
| 421 | return hrpc_err_decode; | |
| 422 | } | |
| 423 | } | |
| 424 | ||
| 425 | rpc_message_t msg = {0}; | |
| 426 | msg.type = rpc_request; | |
| 427 | msg.id = id; | |
| 428 | msg.command = swarmd_command_channel_close; | |
| 429 | msg.stream = 0; | |
| 430 | msg.data = payload.buffer; | |
| 431 | msg.len = payload.end; | |
| 432 | ||
| 433 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 434 | free(payload.buffer); | |
| 435 | return err; | |
| 436 | } | |
| 437 | ||
| 438 | int | |
| 439 | swarmd_encode_channel_close_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 440 | rpc_message_t msg = {0}; | |
| 441 | msg.type = rpc_response; | |
| 442 | msg.id = id; | |
| 443 | msg.error = true; | |
| 444 | msg.stream = 0; | |
| 445 | msg.message = error.message; | |
| 446 | msg.code = error.code; | |
| 447 | msg.status = error.status; | |
| 448 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 449 | } | |
| 450 | ||
| 451 | int | |
| 452 | swarmd_decode_channel_close_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 453 | if (msg->error) { | |
| 454 | error->message = msg->message; | |
| 455 | error->code = msg->code; | |
| 456 | error->status = msg->status; | |
| 457 | return hrpc_error_response; | |
| 458 | } | |
| 459 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 460 | int err = swarmd_ok_decode(&payload, result); | |
| 461 | if (err < 0) return hrpc_err_decode; | |
| 462 | return hrpc_ok; | |
| 463 | } | |
| 464 | ||
| 465 | int | |
| 466 | swarmd_encode_send (uint64_t id, const swarmd_send_request_t *args, uint8_t **out, size_t *out_len) { | |
| 467 | compact_state_t payload = {0, 0, NULL}; | |
| 468 | int err = swarmd_send_request_preencode(&payload, args); | |
| 469 | if (err < 0) return hrpc_err_decode; | |
| 470 | if (payload.end > 0) { | |
| 471 | payload.buffer = malloc(payload.end); | |
| 472 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 473 | err = swarmd_send_request_encode(&payload, args); | |
| 474 | if (err < 0) { | |
| 475 | free(payload.buffer); | |
| 476 | return hrpc_err_decode; | |
| 477 | } | |
| 478 | } | |
| 479 | ||
| 480 | rpc_message_t msg = {0}; | |
| 481 | msg.type = rpc_request; | |
| 482 | msg.id = id; | |
| 483 | msg.command = swarmd_command_send; | |
| 484 | msg.stream = 0; | |
| 485 | msg.data = payload.buffer; | |
| 486 | msg.len = payload.end; | |
| 487 | ||
| 488 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 489 | free(payload.buffer); | |
| 490 | return err; | |
| 491 | } | |
| 492 | ||
| 493 | int | |
| 494 | swarmd_encode_send_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 495 | rpc_message_t msg = {0}; | |
| 496 | msg.type = rpc_response; | |
| 497 | msg.id = id; | |
| 498 | msg.error = true; | |
| 499 | msg.stream = 0; | |
| 500 | msg.message = error.message; | |
| 501 | msg.code = error.code; | |
| 502 | msg.status = error.status; | |
| 503 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 504 | } | |
| 505 | ||
| 506 | int | |
| 507 | swarmd_decode_send_response (const rpc_message_t *msg, swarmd_send_result_t *result, hrpc_error_t *error) { | |
| 508 | if (msg->error) { | |
| 509 | error->message = msg->message; | |
| 510 | error->code = msg->code; | |
| 511 | error->status = msg->status; | |
| 512 | return hrpc_error_response; | |
| 513 | } | |
| 514 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 515 | int err = swarmd_send_result_decode(&payload, result); | |
| 516 | if (err < 0) return hrpc_err_decode; | |
| 517 | return hrpc_ok; | |
| 518 | } | |
| 519 | ||
| 520 | int | |
| 521 | swarmd_encode_content_hash (uint64_t id, const swarmd_path_t *args, uint8_t **out, size_t *out_len) { | |
| 522 | compact_state_t payload = {0, 0, NULL}; | |
| 523 | int err = swarmd_path_preencode(&payload, args); | |
| 524 | if (err < 0) return hrpc_err_decode; | |
| 525 | if (payload.end > 0) { | |
| 526 | payload.buffer = malloc(payload.end); | |
| 527 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 528 | err = swarmd_path_encode(&payload, args); | |
| 529 | if (err < 0) { | |
| 530 | free(payload.buffer); | |
| 531 | return hrpc_err_decode; | |
| 532 | } | |
| 533 | } | |
| 534 | ||
| 535 | rpc_message_t msg = {0}; | |
| 536 | msg.type = rpc_request; | |
| 537 | msg.id = id; | |
| 538 | msg.command = swarmd_command_content_hash; | |
| 539 | msg.stream = 0; | |
| 540 | msg.data = payload.buffer; | |
| 541 | msg.len = payload.end; | |
| 542 | ||
| 543 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 544 | free(payload.buffer); | |
| 545 | return err; | |
| 546 | } | |
| 547 | ||
| 548 | int | |
| 549 | swarmd_encode_content_hash_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 550 | rpc_message_t msg = {0}; | |
| 551 | msg.type = rpc_response; | |
| 552 | msg.id = id; | |
| 553 | msg.error = true; | |
| 554 | msg.stream = 0; | |
| 555 | msg.message = error.message; | |
| 556 | msg.code = error.code; | |
| 557 | msg.status = error.status; | |
| 558 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 559 | } | |
| 560 | ||
| 561 | int | |
| 562 | swarmd_decode_content_hash_response (const rpc_message_t *msg, swarmd_hash_t *result, hrpc_error_t *error) { | |
| 563 | if (msg->error) { | |
| 564 | error->message = msg->message; | |
| 565 | error->code = msg->code; | |
| 566 | error->status = msg->status; | |
| 567 | return hrpc_error_response; | |
| 568 | } | |
| 569 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 570 | int err = swarmd_hash_decode(&payload, result); | |
| 571 | if (err < 0) return hrpc_err_decode; | |
| 572 | return hrpc_ok; | |
| 573 | } | |
| 574 | ||
| 575 | int | |
| 576 | swarmd_encode_content_serve (uint64_t id, const swarmd_content_serve_t *args, uint8_t **out, size_t *out_len) { | |
| 577 | compact_state_t payload = {0, 0, NULL}; | |
| 578 | int err = swarmd_content_serve_preencode(&payload, args); | |
| 579 | if (err < 0) return hrpc_err_decode; | |
| 580 | if (payload.end > 0) { | |
| 581 | payload.buffer = malloc(payload.end); | |
| 582 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 583 | err = swarmd_content_serve_encode(&payload, args); | |
| 584 | if (err < 0) { | |
| 585 | free(payload.buffer); | |
| 586 | return hrpc_err_decode; | |
| 587 | } | |
| 588 | } | |
| 589 | ||
| 590 | rpc_message_t msg = {0}; | |
| 591 | msg.type = rpc_request; | |
| 592 | msg.id = id; | |
| 593 | msg.command = swarmd_command_content_serve; | |
| 594 | msg.stream = 0; | |
| 595 | msg.data = payload.buffer; | |
| 596 | msg.len = payload.end; | |
| 597 | ||
| 598 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 599 | free(payload.buffer); | |
| 600 | return err; | |
| 601 | } | |
| 602 | ||
| 603 | int | |
| 604 | swarmd_encode_content_serve_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 605 | rpc_message_t msg = {0}; | |
| 606 | msg.type = rpc_response; | |
| 607 | msg.id = id; | |
| 608 | msg.error = true; | |
| 609 | msg.stream = 0; | |
| 610 | msg.message = error.message; | |
| 611 | msg.code = error.code; | |
| 612 | msg.status = error.status; | |
| 613 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 614 | } | |
| 615 | ||
| 616 | int | |
| 617 | swarmd_decode_content_serve_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 618 | if (msg->error) { | |
| 619 | error->message = msg->message; | |
| 620 | error->code = msg->code; | |
| 621 | error->status = msg->status; | |
| 622 | return hrpc_error_response; | |
| 623 | } | |
| 624 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 625 | int err = swarmd_ok_decode(&payload, result); | |
| 626 | if (err < 0) return hrpc_err_decode; | |
| 627 | return hrpc_ok; | |
| 628 | } | |
| 629 | ||
| 630 | int | |
| 631 | swarmd_encode_content_fetch (uint64_t id, const swarmd_content_fetch_t *args, uint8_t **out, size_t *out_len) { | |
| 632 | compact_state_t payload = {0, 0, NULL}; | |
| 633 | int err = swarmd_content_fetch_preencode(&payload, args); | |
| 634 | if (err < 0) return hrpc_err_decode; | |
| 635 | if (payload.end > 0) { | |
| 636 | payload.buffer = malloc(payload.end); | |
| 637 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 638 | err = swarmd_content_fetch_encode(&payload, args); | |
| 639 | if (err < 0) { | |
| 640 | free(payload.buffer); | |
| 641 | return hrpc_err_decode; | |
| 642 | } | |
| 643 | } | |
| 644 | ||
| 645 | rpc_message_t msg = {0}; | |
| 646 | msg.type = rpc_request; | |
| 647 | msg.id = id; | |
| 648 | msg.command = swarmd_command_content_fetch; | |
| 649 | msg.stream = 0; | |
| 650 | msg.data = payload.buffer; | |
| 651 | msg.len = payload.end; | |
| 652 | ||
| 653 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 654 | free(payload.buffer); | |
| 655 | return err; | |
| 656 | } | |
| 657 | ||
| 658 | int | |
| 659 | swarmd_encode_content_fetch_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 660 | rpc_message_t msg = {0}; | |
| 661 | msg.type = rpc_response; | |
| 662 | msg.id = id; | |
| 663 | msg.error = true; | |
| 664 | msg.stream = 0; | |
| 665 | msg.message = error.message; | |
| 666 | msg.code = error.code; | |
| 667 | msg.status = error.status; | |
| 668 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 669 | } | |
| 670 | ||
| 671 | int | |
| 672 | swarmd_decode_content_fetch_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 673 | if (msg->error) { | |
| 674 | error->message = msg->message; | |
| 675 | error->code = msg->code; | |
| 676 | error->status = msg->status; | |
| 677 | return hrpc_error_response; | |
| 678 | } | |
| 679 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 680 | int err = swarmd_ok_decode(&payload, result); | |
| 681 | if (err < 0) return hrpc_err_decode; | |
| 682 | return hrpc_ok; | |
| 683 | } | |
| 684 | ||
| 685 | int | |
| 686 | swarmd_encode_content_cancel (uint64_t id, const swarmd_content_cancel_t *args, uint8_t **out, size_t *out_len) { | |
| 687 | compact_state_t payload = {0, 0, NULL}; | |
| 688 | int err = swarmd_content_cancel_preencode(&payload, args); | |
| 689 | if (err < 0) return hrpc_err_decode; | |
| 690 | if (payload.end > 0) { | |
| 691 | payload.buffer = malloc(payload.end); | |
| 692 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 693 | err = swarmd_content_cancel_encode(&payload, args); | |
| 694 | if (err < 0) { | |
| 695 | free(payload.buffer); | |
| 696 | return hrpc_err_decode; | |
| 697 | } | |
| 698 | } | |
| 699 | ||
| 700 | rpc_message_t msg = {0}; | |
| 701 | msg.type = rpc_request; | |
| 702 | msg.id = id; | |
| 703 | msg.command = swarmd_command_content_cancel; | |
| 704 | msg.stream = 0; | |
| 705 | msg.data = payload.buffer; | |
| 706 | msg.len = payload.end; | |
| 707 | ||
| 708 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 709 | free(payload.buffer); | |
| 710 | return err; | |
| 711 | } | |
| 712 | ||
| 713 | int | |
| 714 | swarmd_encode_content_cancel_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len) { | |
| 715 | rpc_message_t msg = {0}; | |
| 716 | msg.type = rpc_response; | |
| 717 | msg.id = id; | |
| 718 | msg.error = true; | |
| 719 | msg.stream = 0; | |
| 720 | msg.message = error.message; | |
| 721 | msg.code = error.code; | |
| 722 | msg.status = error.status; | |
| 723 | return swarmd_hrpc__frame(&msg, out, out_len); | |
| 724 | } | |
| 725 | ||
| 726 | int | |
| 727 | swarmd_decode_content_cancel_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error) { | |
| 728 | if (msg->error) { | |
| 729 | error->message = msg->message; | |
| 730 | error->code = msg->code; | |
| 731 | error->status = msg->status; | |
| 732 | return hrpc_error_response; | |
| 733 | } | |
| 734 | compact_state_t payload = {0, msg->len, msg->data}; | |
| 735 | int err = swarmd_ok_decode(&payload, result); | |
| 736 | if (err < 0) return hrpc_err_decode; | |
| 737 | return hrpc_ok; | |
| 738 | } | |
| 739 | ||
| 740 | int | |
| 741 | swarmd_encode_on_peer_up (const swarmd_peer_up_t *args, uint8_t **out, size_t *out_len) { | |
| 742 | compact_state_t payload = {0, 0, NULL}; | |
| 743 | int err = swarmd_peer_up_preencode(&payload, args); | |
| 744 | if (err < 0) return hrpc_err_decode; | |
| 745 | if (payload.end > 0) { | |
| 746 | payload.buffer = malloc(payload.end); | |
| 747 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 748 | err = swarmd_peer_up_encode(&payload, args); | |
| 749 | if (err < 0) { | |
| 750 | free(payload.buffer); | |
| 751 | return hrpc_err_decode; | |
| 752 | } | |
| 753 | } | |
| 754 | ||
| 755 | rpc_message_t msg = {0}; | |
| 756 | msg.type = rpc_request; | |
| 757 | msg.id = 0; | |
| 758 | msg.command = swarmd_command_on_peer_up; | |
| 759 | msg.stream = 0; | |
| 760 | msg.data = payload.buffer; | |
| 761 | msg.len = payload.end; | |
| 762 | ||
| 763 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 764 | free(payload.buffer); | |
| 765 | return err; | |
| 766 | } | |
| 767 | ||
| 768 | int | |
| 769 | swarmd_encode_on_peer_down (const swarmd_peer_down_t *args, uint8_t **out, size_t *out_len) { | |
| 770 | compact_state_t payload = {0, 0, NULL}; | |
| 771 | int err = swarmd_peer_down_preencode(&payload, args); | |
| 772 | if (err < 0) return hrpc_err_decode; | |
| 773 | if (payload.end > 0) { | |
| 774 | payload.buffer = malloc(payload.end); | |
| 775 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 776 | err = swarmd_peer_down_encode(&payload, args); | |
| 777 | if (err < 0) { | |
| 778 | free(payload.buffer); | |
| 779 | return hrpc_err_decode; | |
| 780 | } | |
| 781 | } | |
| 782 | ||
| 783 | rpc_message_t msg = {0}; | |
| 784 | msg.type = rpc_request; | |
| 785 | msg.id = 0; | |
| 786 | msg.command = swarmd_command_on_peer_down; | |
| 787 | msg.stream = 0; | |
| 788 | msg.data = payload.buffer; | |
| 789 | msg.len = payload.end; | |
| 790 | ||
| 791 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 792 | free(payload.buffer); | |
| 793 | return err; | |
| 794 | } | |
| 795 | ||
| 796 | int | |
| 797 | swarmd_encode_on_message (const swarmd_message_t *args, uint8_t **out, size_t *out_len) { | |
| 798 | compact_state_t payload = {0, 0, NULL}; | |
| 799 | int err = swarmd_message_preencode(&payload, args); | |
| 800 | if (err < 0) return hrpc_err_decode; | |
| 801 | if (payload.end > 0) { | |
| 802 | payload.buffer = malloc(payload.end); | |
| 803 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 804 | err = swarmd_message_encode(&payload, args); | |
| 805 | if (err < 0) { | |
| 806 | free(payload.buffer); | |
| 807 | return hrpc_err_decode; | |
| 808 | } | |
| 809 | } | |
| 810 | ||
| 811 | rpc_message_t msg = {0}; | |
| 812 | msg.type = rpc_request; | |
| 813 | msg.id = 0; | |
| 814 | msg.command = swarmd_command_on_message; | |
| 815 | msg.stream = 0; | |
| 816 | msg.data = payload.buffer; | |
| 817 | msg.len = payload.end; | |
| 818 | ||
| 819 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 820 | free(payload.buffer); | |
| 821 | return err; | |
| 822 | } | |
| 823 | ||
| 824 | int | |
| 825 | swarmd_encode_on_drain (const swarmd_channel_ref_t *args, uint8_t **out, size_t *out_len) { | |
| 826 | compact_state_t payload = {0, 0, NULL}; | |
| 827 | int err = swarmd_channel_ref_preencode(&payload, args); | |
| 828 | if (err < 0) return hrpc_err_decode; | |
| 829 | if (payload.end > 0) { | |
| 830 | payload.buffer = malloc(payload.end); | |
| 831 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 832 | err = swarmd_channel_ref_encode(&payload, args); | |
| 833 | if (err < 0) { | |
| 834 | free(payload.buffer); | |
| 835 | return hrpc_err_decode; | |
| 836 | } | |
| 837 | } | |
| 838 | ||
| 839 | rpc_message_t msg = {0}; | |
| 840 | msg.type = rpc_request; | |
| 841 | msg.id = 0; | |
| 842 | msg.command = swarmd_command_on_drain; | |
| 843 | msg.stream = 0; | |
| 844 | msg.data = payload.buffer; | |
| 845 | msg.len = payload.end; | |
| 846 | ||
| 847 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 848 | free(payload.buffer); | |
| 849 | return err; | |
| 850 | } | |
| 851 | ||
| 852 | int | |
| 853 | swarmd_encode_on_status (const swarmd_status_t *args, uint8_t **out, size_t *out_len) { | |
| 854 | compact_state_t payload = {0, 0, NULL}; | |
| 855 | int err = swarmd_status_preencode(&payload, args); | |
| 856 | if (err < 0) return hrpc_err_decode; | |
| 857 | if (payload.end > 0) { | |
| 858 | payload.buffer = malloc(payload.end); | |
| 859 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 860 | err = swarmd_status_encode(&payload, args); | |
| 861 | if (err < 0) { | |
| 862 | free(payload.buffer); | |
| 863 | return hrpc_err_decode; | |
| 864 | } | |
| 865 | } | |
| 866 | ||
| 867 | rpc_message_t msg = {0}; | |
| 868 | msg.type = rpc_request; | |
| 869 | msg.id = 0; | |
| 870 | msg.command = swarmd_command_on_status; | |
| 871 | msg.stream = 0; | |
| 872 | msg.data = payload.buffer; | |
| 873 | msg.len = payload.end; | |
| 874 | ||
| 875 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 876 | free(payload.buffer); | |
| 877 | return err; | |
| 878 | } | |
| 879 | ||
| 880 | int | |
| 881 | swarmd_encode_on_content_progress (const swarmd_content_progress_t *args, uint8_t **out, size_t *out_len) { | |
| 882 | compact_state_t payload = {0, 0, NULL}; | |
| 883 | int err = swarmd_content_progress_preencode(&payload, args); | |
| 884 | if (err < 0) return hrpc_err_decode; | |
| 885 | if (payload.end > 0) { | |
| 886 | payload.buffer = malloc(payload.end); | |
| 887 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 888 | err = swarmd_content_progress_encode(&payload, args); | |
| 889 | if (err < 0) { | |
| 890 | free(payload.buffer); | |
| 891 | return hrpc_err_decode; | |
| 892 | } | |
| 893 | } | |
| 894 | ||
| 895 | rpc_message_t msg = {0}; | |
| 896 | msg.type = rpc_request; | |
| 897 | msg.id = 0; | |
| 898 | msg.command = swarmd_command_on_content_progress; | |
| 899 | msg.stream = 0; | |
| 900 | msg.data = payload.buffer; | |
| 901 | msg.len = payload.end; | |
| 902 | ||
| 903 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 904 | free(payload.buffer); | |
| 905 | return err; | |
| 906 | } | |
| 907 | ||
| 908 | int | |
| 909 | swarmd_encode_on_content_done (const swarmd_content_done_t *args, uint8_t **out, size_t *out_len) { | |
| 910 | compact_state_t payload = {0, 0, NULL}; | |
| 911 | int err = swarmd_content_done_preencode(&payload, args); | |
| 912 | if (err < 0) return hrpc_err_decode; | |
| 913 | if (payload.end > 0) { | |
| 914 | payload.buffer = malloc(payload.end); | |
| 915 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 916 | err = swarmd_content_done_encode(&payload, args); | |
| 917 | if (err < 0) { | |
| 918 | free(payload.buffer); | |
| 919 | return hrpc_err_decode; | |
| 920 | } | |
| 921 | } | |
| 922 | ||
| 923 | rpc_message_t msg = {0}; | |
| 924 | msg.type = rpc_request; | |
| 925 | msg.id = 0; | |
| 926 | msg.command = swarmd_command_on_content_done; | |
| 927 | msg.stream = 0; | |
| 928 | msg.data = payload.buffer; | |
| 929 | msg.len = payload.end; | |
| 930 | ||
| 931 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 932 | free(payload.buffer); | |
| 933 | return err; | |
| 934 | } | |
| 935 | ||
| 936 | int | |
| 937 | swarmd_encode_on_content_failed (const swarmd_content_failed_t *args, uint8_t **out, size_t *out_len) { | |
| 938 | compact_state_t payload = {0, 0, NULL}; | |
| 939 | int err = swarmd_content_failed_preencode(&payload, args); | |
| 940 | if (err < 0) return hrpc_err_decode; | |
| 941 | if (payload.end > 0) { | |
| 942 | payload.buffer = malloc(payload.end); | |
| 943 | if (payload.buffer == NULL) return hrpc_err_alloc; | |
| 944 | err = swarmd_content_failed_encode(&payload, args); | |
| 945 | if (err < 0) { | |
| 946 | free(payload.buffer); | |
| 947 | return hrpc_err_decode; | |
| 948 | } | |
| 949 | } | |
| 950 | ||
| 951 | rpc_message_t msg = {0}; | |
| 952 | msg.type = rpc_request; | |
| 953 | msg.id = 0; | |
| 954 | msg.command = swarmd_command_on_content_failed; | |
| 955 | msg.stream = 0; | |
| 956 | msg.data = payload.buffer; | |
| 957 | msg.len = payload.end; | |
| 958 | ||
| 959 | err = swarmd_hrpc__frame(&msg, out, out_len); | |
| 960 | free(payload.buffer); | |
| 961 | return err; | |
| 962 | } | |
| 963 | ||
| 964 | int | |
| 965 | swarmd_hrpc_dispatch (const swarmd_hrpc_handlers_t *handlers, const rpc_message_t *msg, uint8_t **reply_out, size_t *reply_len) { | |
| 966 | switch (msg->command) { | |
| 967 | case swarmd_command_hello: { | |
| 968 | if (handlers->on_hello == NULL) return hrpc_err_unknown; | |
| 969 | swarmd_hello_request_t req = {0}; | |
| 970 | compact_state_t in = {0, msg->len, msg->data}; | |
| 971 | if (swarmd_hello_request_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 972 | swarmd_hello_response_t res = {0}; | |
| 973 | hrpc_error_t error = {0}; | |
| 974 | int r = handlers->on_hello(handlers->ctx, &req, &res, &error); | |
| 975 | swarmd_hello_request_destroy(&req); | |
| 976 | if (r < 0) { | |
| 977 | swarmd_hello_response_destroy(&res); | |
| 978 | return r; | |
| 979 | } | |
| 980 | if (r == hrpc_error_response) { | |
| 981 | swarmd_hello_response_destroy(&res); | |
| 982 | rpc_message_t reply = {0}; | |
| 983 | reply.type = rpc_response; | |
| 984 | reply.id = msg->id; | |
| 985 | reply.error = true; | |
| 986 | reply.stream = 0; | |
| 987 | reply.message = error.message; | |
| 988 | reply.code = error.code; | |
| 989 | reply.status = error.status; | |
| 990 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 991 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 992 | } | |
| 993 | compact_state_t payload = {0, 0, NULL}; | |
| 994 | if (swarmd_hello_response_preencode(&payload, &res) < 0) { | |
| 995 | swarmd_hello_response_destroy(&res); | |
| 996 | return hrpc_err_decode; | |
| 997 | } | |
| 998 | if (payload.end > 0) { | |
| 999 | payload.buffer = malloc(payload.end); | |
| 1000 | if (payload.buffer == NULL) { | |
| 1001 | swarmd_hello_response_destroy(&res); | |
| 1002 | return hrpc_err_alloc; | |
| 1003 | } | |
| 1004 | if (swarmd_hello_response_encode(&payload, &res) < 0) { | |
| 1005 | free(payload.buffer); | |
| 1006 | swarmd_hello_response_destroy(&res); | |
| 1007 | return hrpc_err_decode; | |
| 1008 | } | |
| 1009 | } | |
| 1010 | swarmd_hello_response_destroy(&res); | |
| 1011 | rpc_message_t reply = {0}; | |
| 1012 | reply.type = rpc_response; | |
| 1013 | reply.id = msg->id; | |
| 1014 | reply.error = false; | |
| 1015 | reply.stream = 0; | |
| 1016 | reply.data = payload.buffer; | |
| 1017 | reply.len = payload.end; | |
| 1018 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1019 | free(payload.buffer); | |
| 1020 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1021 | } | |
| 1022 | case swarmd_command_status_get: { | |
| 1023 | if (handlers->on_status_get == NULL) return hrpc_err_unknown; | |
| 1024 | swarmd_none_t req = {0}; | |
| 1025 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1026 | if (swarmd_none_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1027 | swarmd_status_t res = {0}; | |
| 1028 | hrpc_error_t error = {0}; | |
| 1029 | int r = handlers->on_status_get(handlers->ctx, &req, &res, &error); | |
| 1030 | swarmd_none_destroy(&req); | |
| 1031 | if (r < 0) { | |
| 1032 | swarmd_status_destroy(&res); | |
| 1033 | return r; | |
| 1034 | } | |
| 1035 | if (r == hrpc_error_response) { | |
| 1036 | swarmd_status_destroy(&res); | |
| 1037 | rpc_message_t reply = {0}; | |
| 1038 | reply.type = rpc_response; | |
| 1039 | reply.id = msg->id; | |
| 1040 | reply.error = true; | |
| 1041 | reply.stream = 0; | |
| 1042 | reply.message = error.message; | |
| 1043 | reply.code = error.code; | |
| 1044 | reply.status = error.status; | |
| 1045 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1046 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1047 | } | |
| 1048 | compact_state_t payload = {0, 0, NULL}; | |
| 1049 | if (swarmd_status_preencode(&payload, &res) < 0) { | |
| 1050 | swarmd_status_destroy(&res); | |
| 1051 | return hrpc_err_decode; | |
| 1052 | } | |
| 1053 | if (payload.end > 0) { | |
| 1054 | payload.buffer = malloc(payload.end); | |
| 1055 | if (payload.buffer == NULL) { | |
| 1056 | swarmd_status_destroy(&res); | |
| 1057 | return hrpc_err_alloc; | |
| 1058 | } | |
| 1059 | if (swarmd_status_encode(&payload, &res) < 0) { | |
| 1060 | free(payload.buffer); | |
| 1061 | swarmd_status_destroy(&res); | |
| 1062 | return hrpc_err_decode; | |
| 1063 | } | |
| 1064 | } | |
| 1065 | swarmd_status_destroy(&res); | |
| 1066 | rpc_message_t reply = {0}; | |
| 1067 | reply.type = rpc_response; | |
| 1068 | reply.id = msg->id; | |
| 1069 | reply.error = false; | |
| 1070 | reply.stream = 0; | |
| 1071 | reply.data = payload.buffer; | |
| 1072 | reply.len = payload.end; | |
| 1073 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1074 | free(payload.buffer); | |
| 1075 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1076 | } | |
| 1077 | case swarmd_command_swarm_join: { | |
| 1078 | if (handlers->on_swarm_join == NULL) return hrpc_err_unknown; | |
| 1079 | swarmd_swarm_join_t req = {0}; | |
| 1080 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1081 | if (swarmd_swarm_join_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1082 | swarmd_ok_t res = {0}; | |
| 1083 | hrpc_error_t error = {0}; | |
| 1084 | int r = handlers->on_swarm_join(handlers->ctx, &req, &res, &error); | |
| 1085 | swarmd_swarm_join_destroy(&req); | |
| 1086 | if (r < 0) { | |
| 1087 | swarmd_ok_destroy(&res); | |
| 1088 | return r; | |
| 1089 | } | |
| 1090 | if (r == hrpc_error_response) { | |
| 1091 | swarmd_ok_destroy(&res); | |
| 1092 | rpc_message_t reply = {0}; | |
| 1093 | reply.type = rpc_response; | |
| 1094 | reply.id = msg->id; | |
| 1095 | reply.error = true; | |
| 1096 | reply.stream = 0; | |
| 1097 | reply.message = error.message; | |
| 1098 | reply.code = error.code; | |
| 1099 | reply.status = error.status; | |
| 1100 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1101 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1102 | } | |
| 1103 | compact_state_t payload = {0, 0, NULL}; | |
| 1104 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1105 | swarmd_ok_destroy(&res); | |
| 1106 | return hrpc_err_decode; | |
| 1107 | } | |
| 1108 | if (payload.end > 0) { | |
| 1109 | payload.buffer = malloc(payload.end); | |
| 1110 | if (payload.buffer == NULL) { | |
| 1111 | swarmd_ok_destroy(&res); | |
| 1112 | return hrpc_err_alloc; | |
| 1113 | } | |
| 1114 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1115 | free(payload.buffer); | |
| 1116 | swarmd_ok_destroy(&res); | |
| 1117 | return hrpc_err_decode; | |
| 1118 | } | |
| 1119 | } | |
| 1120 | swarmd_ok_destroy(&res); | |
| 1121 | rpc_message_t reply = {0}; | |
| 1122 | reply.type = rpc_response; | |
| 1123 | reply.id = msg->id; | |
| 1124 | reply.error = false; | |
| 1125 | reply.stream = 0; | |
| 1126 | reply.data = payload.buffer; | |
| 1127 | reply.len = payload.end; | |
| 1128 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1129 | free(payload.buffer); | |
| 1130 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1131 | } | |
| 1132 | case swarmd_command_swarm_leave: { | |
| 1133 | if (handlers->on_swarm_leave == NULL) return hrpc_err_unknown; | |
| 1134 | swarmd_topic_ref_t req = {0}; | |
| 1135 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1136 | if (swarmd_topic_ref_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1137 | swarmd_ok_t res = {0}; | |
| 1138 | hrpc_error_t error = {0}; | |
| 1139 | int r = handlers->on_swarm_leave(handlers->ctx, &req, &res, &error); | |
| 1140 | swarmd_topic_ref_destroy(&req); | |
| 1141 | if (r < 0) { | |
| 1142 | swarmd_ok_destroy(&res); | |
| 1143 | return r; | |
| 1144 | } | |
| 1145 | if (r == hrpc_error_response) { | |
| 1146 | swarmd_ok_destroy(&res); | |
| 1147 | rpc_message_t reply = {0}; | |
| 1148 | reply.type = rpc_response; | |
| 1149 | reply.id = msg->id; | |
| 1150 | reply.error = true; | |
| 1151 | reply.stream = 0; | |
| 1152 | reply.message = error.message; | |
| 1153 | reply.code = error.code; | |
| 1154 | reply.status = error.status; | |
| 1155 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1156 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1157 | } | |
| 1158 | compact_state_t payload = {0, 0, NULL}; | |
| 1159 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1160 | swarmd_ok_destroy(&res); | |
| 1161 | return hrpc_err_decode; | |
| 1162 | } | |
| 1163 | if (payload.end > 0) { | |
| 1164 | payload.buffer = malloc(payload.end); | |
| 1165 | if (payload.buffer == NULL) { | |
| 1166 | swarmd_ok_destroy(&res); | |
| 1167 | return hrpc_err_alloc; | |
| 1168 | } | |
| 1169 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1170 | free(payload.buffer); | |
| 1171 | swarmd_ok_destroy(&res); | |
| 1172 | return hrpc_err_decode; | |
| 1173 | } | |
| 1174 | } | |
| 1175 | swarmd_ok_destroy(&res); | |
| 1176 | rpc_message_t reply = {0}; | |
| 1177 | reply.type = rpc_response; | |
| 1178 | reply.id = msg->id; | |
| 1179 | reply.error = false; | |
| 1180 | reply.stream = 0; | |
| 1181 | reply.data = payload.buffer; | |
| 1182 | reply.len = payload.end; | |
| 1183 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1184 | free(payload.buffer); | |
| 1185 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1186 | } | |
| 1187 | case swarmd_command_peer_add: { | |
| 1188 | if (handlers->on_peer_add == NULL) return hrpc_err_unknown; | |
| 1189 | swarmd_peer_key_t req = {0}; | |
| 1190 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1191 | if (swarmd_peer_key_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1192 | swarmd_ok_t res = {0}; | |
| 1193 | hrpc_error_t error = {0}; | |
| 1194 | int r = handlers->on_peer_add(handlers->ctx, &req, &res, &error); | |
| 1195 | swarmd_peer_key_destroy(&req); | |
| 1196 | if (r < 0) { | |
| 1197 | swarmd_ok_destroy(&res); | |
| 1198 | return r; | |
| 1199 | } | |
| 1200 | if (r == hrpc_error_response) { | |
| 1201 | swarmd_ok_destroy(&res); | |
| 1202 | rpc_message_t reply = {0}; | |
| 1203 | reply.type = rpc_response; | |
| 1204 | reply.id = msg->id; | |
| 1205 | reply.error = true; | |
| 1206 | reply.stream = 0; | |
| 1207 | reply.message = error.message; | |
| 1208 | reply.code = error.code; | |
| 1209 | reply.status = error.status; | |
| 1210 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1211 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1212 | } | |
| 1213 | compact_state_t payload = {0, 0, NULL}; | |
| 1214 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1215 | swarmd_ok_destroy(&res); | |
| 1216 | return hrpc_err_decode; | |
| 1217 | } | |
| 1218 | if (payload.end > 0) { | |
| 1219 | payload.buffer = malloc(payload.end); | |
| 1220 | if (payload.buffer == NULL) { | |
| 1221 | swarmd_ok_destroy(&res); | |
| 1222 | return hrpc_err_alloc; | |
| 1223 | } | |
| 1224 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1225 | free(payload.buffer); | |
| 1226 | swarmd_ok_destroy(&res); | |
| 1227 | return hrpc_err_decode; | |
| 1228 | } | |
| 1229 | } | |
| 1230 | swarmd_ok_destroy(&res); | |
| 1231 | rpc_message_t reply = {0}; | |
| 1232 | reply.type = rpc_response; | |
| 1233 | reply.id = msg->id; | |
| 1234 | reply.error = false; | |
| 1235 | reply.stream = 0; | |
| 1236 | reply.data = payload.buffer; | |
| 1237 | reply.len = payload.end; | |
| 1238 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1239 | free(payload.buffer); | |
| 1240 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1241 | } | |
| 1242 | case swarmd_command_peer_remove: { | |
| 1243 | if (handlers->on_peer_remove == NULL) return hrpc_err_unknown; | |
| 1244 | swarmd_peer_key_t req = {0}; | |
| 1245 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1246 | if (swarmd_peer_key_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1247 | swarmd_ok_t res = {0}; | |
| 1248 | hrpc_error_t error = {0}; | |
| 1249 | int r = handlers->on_peer_remove(handlers->ctx, &req, &res, &error); | |
| 1250 | swarmd_peer_key_destroy(&req); | |
| 1251 | if (r < 0) { | |
| 1252 | swarmd_ok_destroy(&res); | |
| 1253 | return r; | |
| 1254 | } | |
| 1255 | if (r == hrpc_error_response) { | |
| 1256 | swarmd_ok_destroy(&res); | |
| 1257 | rpc_message_t reply = {0}; | |
| 1258 | reply.type = rpc_response; | |
| 1259 | reply.id = msg->id; | |
| 1260 | reply.error = true; | |
| 1261 | reply.stream = 0; | |
| 1262 | reply.message = error.message; | |
| 1263 | reply.code = error.code; | |
| 1264 | reply.status = error.status; | |
| 1265 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1266 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1267 | } | |
| 1268 | compact_state_t payload = {0, 0, NULL}; | |
| 1269 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1270 | swarmd_ok_destroy(&res); | |
| 1271 | return hrpc_err_decode; | |
| 1272 | } | |
| 1273 | if (payload.end > 0) { | |
| 1274 | payload.buffer = malloc(payload.end); | |
| 1275 | if (payload.buffer == NULL) { | |
| 1276 | swarmd_ok_destroy(&res); | |
| 1277 | return hrpc_err_alloc; | |
| 1278 | } | |
| 1279 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1280 | free(payload.buffer); | |
| 1281 | swarmd_ok_destroy(&res); | |
| 1282 | return hrpc_err_decode; | |
| 1283 | } | |
| 1284 | } | |
| 1285 | swarmd_ok_destroy(&res); | |
| 1286 | rpc_message_t reply = {0}; | |
| 1287 | reply.type = rpc_response; | |
| 1288 | reply.id = msg->id; | |
| 1289 | reply.error = false; | |
| 1290 | reply.stream = 0; | |
| 1291 | reply.data = payload.buffer; | |
| 1292 | reply.len = payload.end; | |
| 1293 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1294 | free(payload.buffer); | |
| 1295 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1296 | } | |
| 1297 | case swarmd_command_channel_open: { | |
| 1298 | if (handlers->on_channel_open == NULL) return hrpc_err_unknown; | |
| 1299 | swarmd_channel_open_t req = {0}; | |
| 1300 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1301 | if (swarmd_channel_open_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1302 | swarmd_channel_ref_t res = {0}; | |
| 1303 | hrpc_error_t error = {0}; | |
| 1304 | int r = handlers->on_channel_open(handlers->ctx, &req, &res, &error); | |
| 1305 | swarmd_channel_open_destroy(&req); | |
| 1306 | if (r < 0) { | |
| 1307 | swarmd_channel_ref_destroy(&res); | |
| 1308 | return r; | |
| 1309 | } | |
| 1310 | if (r == hrpc_error_response) { | |
| 1311 | swarmd_channel_ref_destroy(&res); | |
| 1312 | rpc_message_t reply = {0}; | |
| 1313 | reply.type = rpc_response; | |
| 1314 | reply.id = msg->id; | |
| 1315 | reply.error = true; | |
| 1316 | reply.stream = 0; | |
| 1317 | reply.message = error.message; | |
| 1318 | reply.code = error.code; | |
| 1319 | reply.status = error.status; | |
| 1320 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1321 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1322 | } | |
| 1323 | compact_state_t payload = {0, 0, NULL}; | |
| 1324 | if (swarmd_channel_ref_preencode(&payload, &res) < 0) { | |
| 1325 | swarmd_channel_ref_destroy(&res); | |
| 1326 | return hrpc_err_decode; | |
| 1327 | } | |
| 1328 | if (payload.end > 0) { | |
| 1329 | payload.buffer = malloc(payload.end); | |
| 1330 | if (payload.buffer == NULL) { | |
| 1331 | swarmd_channel_ref_destroy(&res); | |
| 1332 | return hrpc_err_alloc; | |
| 1333 | } | |
| 1334 | if (swarmd_channel_ref_encode(&payload, &res) < 0) { | |
| 1335 | free(payload.buffer); | |
| 1336 | swarmd_channel_ref_destroy(&res); | |
| 1337 | return hrpc_err_decode; | |
| 1338 | } | |
| 1339 | } | |
| 1340 | swarmd_channel_ref_destroy(&res); | |
| 1341 | rpc_message_t reply = {0}; | |
| 1342 | reply.type = rpc_response; | |
| 1343 | reply.id = msg->id; | |
| 1344 | reply.error = false; | |
| 1345 | reply.stream = 0; | |
| 1346 | reply.data = payload.buffer; | |
| 1347 | reply.len = payload.end; | |
| 1348 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1349 | free(payload.buffer); | |
| 1350 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1351 | } | |
| 1352 | case swarmd_command_channel_close: { | |
| 1353 | if (handlers->on_channel_close == NULL) return hrpc_err_unknown; | |
| 1354 | swarmd_channel_ref_t req = {0}; | |
| 1355 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1356 | if (swarmd_channel_ref_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1357 | swarmd_ok_t res = {0}; | |
| 1358 | hrpc_error_t error = {0}; | |
| 1359 | int r = handlers->on_channel_close(handlers->ctx, &req, &res, &error); | |
| 1360 | swarmd_channel_ref_destroy(&req); | |
| 1361 | if (r < 0) { | |
| 1362 | swarmd_ok_destroy(&res); | |
| 1363 | return r; | |
| 1364 | } | |
| 1365 | if (r == hrpc_error_response) { | |
| 1366 | swarmd_ok_destroy(&res); | |
| 1367 | rpc_message_t reply = {0}; | |
| 1368 | reply.type = rpc_response; | |
| 1369 | reply.id = msg->id; | |
| 1370 | reply.error = true; | |
| 1371 | reply.stream = 0; | |
| 1372 | reply.message = error.message; | |
| 1373 | reply.code = error.code; | |
| 1374 | reply.status = error.status; | |
| 1375 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1376 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1377 | } | |
| 1378 | compact_state_t payload = {0, 0, NULL}; | |
| 1379 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1380 | swarmd_ok_destroy(&res); | |
| 1381 | return hrpc_err_decode; | |
| 1382 | } | |
| 1383 | if (payload.end > 0) { | |
| 1384 | payload.buffer = malloc(payload.end); | |
| 1385 | if (payload.buffer == NULL) { | |
| 1386 | swarmd_ok_destroy(&res); | |
| 1387 | return hrpc_err_alloc; | |
| 1388 | } | |
| 1389 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1390 | free(payload.buffer); | |
| 1391 | swarmd_ok_destroy(&res); | |
| 1392 | return hrpc_err_decode; | |
| 1393 | } | |
| 1394 | } | |
| 1395 | swarmd_ok_destroy(&res); | |
| 1396 | rpc_message_t reply = {0}; | |
| 1397 | reply.type = rpc_response; | |
| 1398 | reply.id = msg->id; | |
| 1399 | reply.error = false; | |
| 1400 | reply.stream = 0; | |
| 1401 | reply.data = payload.buffer; | |
| 1402 | reply.len = payload.end; | |
| 1403 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1404 | free(payload.buffer); | |
| 1405 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1406 | } | |
| 1407 | case swarmd_command_send: { | |
| 1408 | if (handlers->on_send == NULL) return hrpc_err_unknown; | |
| 1409 | swarmd_send_request_t req = {0}; | |
| 1410 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1411 | if (swarmd_send_request_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1412 | swarmd_send_result_t res = {0}; | |
| 1413 | hrpc_error_t error = {0}; | |
| 1414 | int r = handlers->on_send(handlers->ctx, &req, &res, &error); | |
| 1415 | swarmd_send_request_destroy(&req); | |
| 1416 | if (r < 0) { | |
| 1417 | swarmd_send_result_destroy(&res); | |
| 1418 | return r; | |
| 1419 | } | |
| 1420 | if (r == hrpc_error_response) { | |
| 1421 | swarmd_send_result_destroy(&res); | |
| 1422 | rpc_message_t reply = {0}; | |
| 1423 | reply.type = rpc_response; | |
| 1424 | reply.id = msg->id; | |
| 1425 | reply.error = true; | |
| 1426 | reply.stream = 0; | |
| 1427 | reply.message = error.message; | |
| 1428 | reply.code = error.code; | |
| 1429 | reply.status = error.status; | |
| 1430 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1431 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1432 | } | |
| 1433 | compact_state_t payload = {0, 0, NULL}; | |
| 1434 | if (swarmd_send_result_preencode(&payload, &res) < 0) { | |
| 1435 | swarmd_send_result_destroy(&res); | |
| 1436 | return hrpc_err_decode; | |
| 1437 | } | |
| 1438 | if (payload.end > 0) { | |
| 1439 | payload.buffer = malloc(payload.end); | |
| 1440 | if (payload.buffer == NULL) { | |
| 1441 | swarmd_send_result_destroy(&res); | |
| 1442 | return hrpc_err_alloc; | |
| 1443 | } | |
| 1444 | if (swarmd_send_result_encode(&payload, &res) < 0) { | |
| 1445 | free(payload.buffer); | |
| 1446 | swarmd_send_result_destroy(&res); | |
| 1447 | return hrpc_err_decode; | |
| 1448 | } | |
| 1449 | } | |
| 1450 | swarmd_send_result_destroy(&res); | |
| 1451 | rpc_message_t reply = {0}; | |
| 1452 | reply.type = rpc_response; | |
| 1453 | reply.id = msg->id; | |
| 1454 | reply.error = false; | |
| 1455 | reply.stream = 0; | |
| 1456 | reply.data = payload.buffer; | |
| 1457 | reply.len = payload.end; | |
| 1458 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1459 | free(payload.buffer); | |
| 1460 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1461 | } | |
| 1462 | case swarmd_command_content_hash: { | |
| 1463 | if (handlers->on_content_hash == NULL) return hrpc_err_unknown; | |
| 1464 | swarmd_path_t req = {0}; | |
| 1465 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1466 | if (swarmd_path_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1467 | swarmd_hash_t res = {0}; | |
| 1468 | hrpc_error_t error = {0}; | |
| 1469 | int r = handlers->on_content_hash(handlers->ctx, &req, &res, &error); | |
| 1470 | swarmd_path_destroy(&req); | |
| 1471 | if (r < 0) { | |
| 1472 | swarmd_hash_destroy(&res); | |
| 1473 | return r; | |
| 1474 | } | |
| 1475 | if (r == hrpc_error_response) { | |
| 1476 | swarmd_hash_destroy(&res); | |
| 1477 | rpc_message_t reply = {0}; | |
| 1478 | reply.type = rpc_response; | |
| 1479 | reply.id = msg->id; | |
| 1480 | reply.error = true; | |
| 1481 | reply.stream = 0; | |
| 1482 | reply.message = error.message; | |
| 1483 | reply.code = error.code; | |
| 1484 | reply.status = error.status; | |
| 1485 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1486 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1487 | } | |
| 1488 | compact_state_t payload = {0, 0, NULL}; | |
| 1489 | if (swarmd_hash_preencode(&payload, &res) < 0) { | |
| 1490 | swarmd_hash_destroy(&res); | |
| 1491 | return hrpc_err_decode; | |
| 1492 | } | |
| 1493 | if (payload.end > 0) { | |
| 1494 | payload.buffer = malloc(payload.end); | |
| 1495 | if (payload.buffer == NULL) { | |
| 1496 | swarmd_hash_destroy(&res); | |
| 1497 | return hrpc_err_alloc; | |
| 1498 | } | |
| 1499 | if (swarmd_hash_encode(&payload, &res) < 0) { | |
| 1500 | free(payload.buffer); | |
| 1501 | swarmd_hash_destroy(&res); | |
| 1502 | return hrpc_err_decode; | |
| 1503 | } | |
| 1504 | } | |
| 1505 | swarmd_hash_destroy(&res); | |
| 1506 | rpc_message_t reply = {0}; | |
| 1507 | reply.type = rpc_response; | |
| 1508 | reply.id = msg->id; | |
| 1509 | reply.error = false; | |
| 1510 | reply.stream = 0; | |
| 1511 | reply.data = payload.buffer; | |
| 1512 | reply.len = payload.end; | |
| 1513 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1514 | free(payload.buffer); | |
| 1515 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1516 | } | |
| 1517 | case swarmd_command_content_serve: { | |
| 1518 | if (handlers->on_content_serve == NULL) return hrpc_err_unknown; | |
| 1519 | swarmd_content_serve_t req = {0}; | |
| 1520 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1521 | if (swarmd_content_serve_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1522 | swarmd_ok_t res = {0}; | |
| 1523 | hrpc_error_t error = {0}; | |
| 1524 | int r = handlers->on_content_serve(handlers->ctx, &req, &res, &error); | |
| 1525 | swarmd_content_serve_destroy(&req); | |
| 1526 | if (r < 0) { | |
| 1527 | swarmd_ok_destroy(&res); | |
| 1528 | return r; | |
| 1529 | } | |
| 1530 | if (r == hrpc_error_response) { | |
| 1531 | swarmd_ok_destroy(&res); | |
| 1532 | rpc_message_t reply = {0}; | |
| 1533 | reply.type = rpc_response; | |
| 1534 | reply.id = msg->id; | |
| 1535 | reply.error = true; | |
| 1536 | reply.stream = 0; | |
| 1537 | reply.message = error.message; | |
| 1538 | reply.code = error.code; | |
| 1539 | reply.status = error.status; | |
| 1540 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1541 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1542 | } | |
| 1543 | compact_state_t payload = {0, 0, NULL}; | |
| 1544 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1545 | swarmd_ok_destroy(&res); | |
| 1546 | return hrpc_err_decode; | |
| 1547 | } | |
| 1548 | if (payload.end > 0) { | |
| 1549 | payload.buffer = malloc(payload.end); | |
| 1550 | if (payload.buffer == NULL) { | |
| 1551 | swarmd_ok_destroy(&res); | |
| 1552 | return hrpc_err_alloc; | |
| 1553 | } | |
| 1554 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1555 | free(payload.buffer); | |
| 1556 | swarmd_ok_destroy(&res); | |
| 1557 | return hrpc_err_decode; | |
| 1558 | } | |
| 1559 | } | |
| 1560 | swarmd_ok_destroy(&res); | |
| 1561 | rpc_message_t reply = {0}; | |
| 1562 | reply.type = rpc_response; | |
| 1563 | reply.id = msg->id; | |
| 1564 | reply.error = false; | |
| 1565 | reply.stream = 0; | |
| 1566 | reply.data = payload.buffer; | |
| 1567 | reply.len = payload.end; | |
| 1568 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1569 | free(payload.buffer); | |
| 1570 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1571 | } | |
| 1572 | case swarmd_command_content_fetch: { | |
| 1573 | if (handlers->on_content_fetch == NULL) return hrpc_err_unknown; | |
| 1574 | swarmd_content_fetch_t req = {0}; | |
| 1575 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1576 | if (swarmd_content_fetch_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1577 | swarmd_ok_t res = {0}; | |
| 1578 | hrpc_error_t error = {0}; | |
| 1579 | int r = handlers->on_content_fetch(handlers->ctx, &req, &res, &error); | |
| 1580 | swarmd_content_fetch_destroy(&req); | |
| 1581 | if (r < 0) { | |
| 1582 | swarmd_ok_destroy(&res); | |
| 1583 | return r; | |
| 1584 | } | |
| 1585 | if (r == hrpc_error_response) { | |
| 1586 | swarmd_ok_destroy(&res); | |
| 1587 | rpc_message_t reply = {0}; | |
| 1588 | reply.type = rpc_response; | |
| 1589 | reply.id = msg->id; | |
| 1590 | reply.error = true; | |
| 1591 | reply.stream = 0; | |
| 1592 | reply.message = error.message; | |
| 1593 | reply.code = error.code; | |
| 1594 | reply.status = error.status; | |
| 1595 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1596 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1597 | } | |
| 1598 | compact_state_t payload = {0, 0, NULL}; | |
| 1599 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1600 | swarmd_ok_destroy(&res); | |
| 1601 | return hrpc_err_decode; | |
| 1602 | } | |
| 1603 | if (payload.end > 0) { | |
| 1604 | payload.buffer = malloc(payload.end); | |
| 1605 | if (payload.buffer == NULL) { | |
| 1606 | swarmd_ok_destroy(&res); | |
| 1607 | return hrpc_err_alloc; | |
| 1608 | } | |
| 1609 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1610 | free(payload.buffer); | |
| 1611 | swarmd_ok_destroy(&res); | |
| 1612 | return hrpc_err_decode; | |
| 1613 | } | |
| 1614 | } | |
| 1615 | swarmd_ok_destroy(&res); | |
| 1616 | rpc_message_t reply = {0}; | |
| 1617 | reply.type = rpc_response; | |
| 1618 | reply.id = msg->id; | |
| 1619 | reply.error = false; | |
| 1620 | reply.stream = 0; | |
| 1621 | reply.data = payload.buffer; | |
| 1622 | reply.len = payload.end; | |
| 1623 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1624 | free(payload.buffer); | |
| 1625 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1626 | } | |
| 1627 | case swarmd_command_content_cancel: { | |
| 1628 | if (handlers->on_content_cancel == NULL) return hrpc_err_unknown; | |
| 1629 | swarmd_content_cancel_t req = {0}; | |
| 1630 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1631 | if (swarmd_content_cancel_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1632 | swarmd_ok_t res = {0}; | |
| 1633 | hrpc_error_t error = {0}; | |
| 1634 | int r = handlers->on_content_cancel(handlers->ctx, &req, &res, &error); | |
| 1635 | swarmd_content_cancel_destroy(&req); | |
| 1636 | if (r < 0) { | |
| 1637 | swarmd_ok_destroy(&res); | |
| 1638 | return r; | |
| 1639 | } | |
| 1640 | if (r == hrpc_error_response) { | |
| 1641 | swarmd_ok_destroy(&res); | |
| 1642 | rpc_message_t reply = {0}; | |
| 1643 | reply.type = rpc_response; | |
| 1644 | reply.id = msg->id; | |
| 1645 | reply.error = true; | |
| 1646 | reply.stream = 0; | |
| 1647 | reply.message = error.message; | |
| 1648 | reply.code = error.code; | |
| 1649 | reply.status = error.status; | |
| 1650 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1651 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1652 | } | |
| 1653 | compact_state_t payload = {0, 0, NULL}; | |
| 1654 | if (swarmd_ok_preencode(&payload, &res) < 0) { | |
| 1655 | swarmd_ok_destroy(&res); | |
| 1656 | return hrpc_err_decode; | |
| 1657 | } | |
| 1658 | if (payload.end > 0) { | |
| 1659 | payload.buffer = malloc(payload.end); | |
| 1660 | if (payload.buffer == NULL) { | |
| 1661 | swarmd_ok_destroy(&res); | |
| 1662 | return hrpc_err_alloc; | |
| 1663 | } | |
| 1664 | if (swarmd_ok_encode(&payload, &res) < 0) { | |
| 1665 | free(payload.buffer); | |
| 1666 | swarmd_ok_destroy(&res); | |
| 1667 | return hrpc_err_decode; | |
| 1668 | } | |
| 1669 | } | |
| 1670 | swarmd_ok_destroy(&res); | |
| 1671 | rpc_message_t reply = {0}; | |
| 1672 | reply.type = rpc_response; | |
| 1673 | reply.id = msg->id; | |
| 1674 | reply.error = false; | |
| 1675 | reply.stream = 0; | |
| 1676 | reply.data = payload.buffer; | |
| 1677 | reply.len = payload.end; | |
| 1678 | r = swarmd_hrpc__frame(&reply, reply_out, reply_len); | |
| 1679 | free(payload.buffer); | |
| 1680 | return r < 0 ? r : hrpc_dispatch_reply; | |
| 1681 | } | |
| 1682 | case swarmd_command_on_peer_up: { | |
| 1683 | if (handlers->on_on_peer_up == NULL) return hrpc_err_unknown; | |
| 1684 | swarmd_peer_up_t req = {0}; | |
| 1685 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1686 | if (swarmd_peer_up_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1687 | handlers->on_on_peer_up(handlers->ctx, &req); | |
| 1688 | swarmd_peer_up_destroy(&req); | |
| 1689 | return hrpc_dispatch_no_reply; | |
| 1690 | } | |
| 1691 | case swarmd_command_on_peer_down: { | |
| 1692 | if (handlers->on_on_peer_down == NULL) return hrpc_err_unknown; | |
| 1693 | swarmd_peer_down_t req = {0}; | |
| 1694 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1695 | if (swarmd_peer_down_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1696 | handlers->on_on_peer_down(handlers->ctx, &req); | |
| 1697 | swarmd_peer_down_destroy(&req); | |
| 1698 | return hrpc_dispatch_no_reply; | |
| 1699 | } | |
| 1700 | case swarmd_command_on_message: { | |
| 1701 | if (handlers->on_on_message == NULL) return hrpc_err_unknown; | |
| 1702 | swarmd_message_t req = {0}; | |
| 1703 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1704 | if (swarmd_message_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1705 | handlers->on_on_message(handlers->ctx, &req); | |
| 1706 | swarmd_message_destroy(&req); | |
| 1707 | return hrpc_dispatch_no_reply; | |
| 1708 | } | |
| 1709 | case swarmd_command_on_drain: { | |
| 1710 | if (handlers->on_on_drain == NULL) return hrpc_err_unknown; | |
| 1711 | swarmd_channel_ref_t req = {0}; | |
| 1712 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1713 | if (swarmd_channel_ref_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1714 | handlers->on_on_drain(handlers->ctx, &req); | |
| 1715 | swarmd_channel_ref_destroy(&req); | |
| 1716 | return hrpc_dispatch_no_reply; | |
| 1717 | } | |
| 1718 | case swarmd_command_on_status: { | |
| 1719 | if (handlers->on_on_status == NULL) return hrpc_err_unknown; | |
| 1720 | swarmd_status_t req = {0}; | |
| 1721 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1722 | if (swarmd_status_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1723 | handlers->on_on_status(handlers->ctx, &req); | |
| 1724 | swarmd_status_destroy(&req); | |
| 1725 | return hrpc_dispatch_no_reply; | |
| 1726 | } | |
| 1727 | case swarmd_command_on_content_progress: { | |
| 1728 | if (handlers->on_on_content_progress == NULL) return hrpc_err_unknown; | |
| 1729 | swarmd_content_progress_t req = {0}; | |
| 1730 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1731 | if (swarmd_content_progress_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1732 | handlers->on_on_content_progress(handlers->ctx, &req); | |
| 1733 | swarmd_content_progress_destroy(&req); | |
| 1734 | return hrpc_dispatch_no_reply; | |
| 1735 | } | |
| 1736 | case swarmd_command_on_content_done: { | |
| 1737 | if (handlers->on_on_content_done == NULL) return hrpc_err_unknown; | |
| 1738 | swarmd_content_done_t req = {0}; | |
| 1739 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1740 | if (swarmd_content_done_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1741 | handlers->on_on_content_done(handlers->ctx, &req); | |
| 1742 | swarmd_content_done_destroy(&req); | |
| 1743 | return hrpc_dispatch_no_reply; | |
| 1744 | } | |
| 1745 | case swarmd_command_on_content_failed: { | |
| 1746 | if (handlers->on_on_content_failed == NULL) return hrpc_err_unknown; | |
| 1747 | swarmd_content_failed_t req = {0}; | |
| 1748 | compact_state_t in = {0, msg->len, msg->data}; | |
| 1749 | if (swarmd_content_failed_decode(&in, &req) < 0) return hrpc_err_decode; | |
| 1750 | handlers->on_on_content_failed(handlers->ctx, &req); | |
| 1751 | swarmd_content_failed_destroy(&req); | |
| 1752 | return hrpc_dispatch_no_reply; | |
| 1753 | } | |
| 1754 | default: | |
| 1755 | return hrpc_err_unknown; | |
| 1756 | } | |
| 1757 | } |
| … | … | @@ -0,0 +1,297 @@ |
| 1 | // This file is autogenerated by hrpc-c | |
| 2 | // !!DO NOT EDIT!! | |
| 3 | #ifndef SWARMD_HRPC_H | |
| 4 | #define SWARMD_HRPC_H | |
| 5 | ||
| 6 | #include "swarmd_schema.h" | |
| 7 | #include "hrpc.h" | |
| 8 | #include <rpc.h> | |
| 9 | #include <stddef.h> | |
| 10 | #include <stdint.h> | |
| 11 | ||
| 12 | enum { | |
| 13 | swarmd_command_hello = 0, | |
| 14 | swarmd_command_status_get = 1, | |
| 15 | swarmd_command_swarm_join = 2, | |
| 16 | swarmd_command_swarm_leave = 3, | |
| 17 | swarmd_command_peer_add = 4, | |
| 18 | swarmd_command_peer_remove = 5, | |
| 19 | swarmd_command_channel_open = 6, | |
| 20 | swarmd_command_channel_close = 7, | |
| 21 | swarmd_command_send = 8, | |
| 22 | swarmd_command_content_hash = 9, | |
| 23 | swarmd_command_content_serve = 10, | |
| 24 | swarmd_command_content_fetch = 11, | |
| 25 | swarmd_command_content_cancel = 12, | |
| 26 | swarmd_command_on_peer_up = 13, | |
| 27 | swarmd_command_on_peer_down = 14, | |
| 28 | swarmd_command_on_message = 15, | |
| 29 | swarmd_command_on_drain = 16, | |
| 30 | swarmd_command_on_status = 17, | |
| 31 | swarmd_command_on_content_progress = 18, | |
| 32 | swarmd_command_on_content_done = 19, | |
| 33 | swarmd_command_on_content_failed = 20, | |
| 34 | }; | |
| 35 | ||
| 36 | // @swarmd/hello (unary) | |
| 37 | int | |
| 38 | swarmd_encode_hello (uint64_t id, const swarmd_hello_request_t *args, uint8_t **out, size_t *out_len); | |
| 39 | ||
| 40 | int | |
| 41 | swarmd_encode_hello_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 42 | ||
| 43 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 44 | int | |
| 45 | swarmd_decode_hello_response (const rpc_message_t *msg, swarmd_hello_response_t *result, hrpc_error_t *error); | |
| 46 | ||
| 47 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 48 | typedef int (*swarmd_on_hello) (void *ctx, const swarmd_hello_request_t *req, swarmd_hello_response_t *res, hrpc_error_t *error); | |
| 49 | ||
| 50 | // @swarmd/status-get (unary) | |
| 51 | int | |
| 52 | swarmd_encode_status_get (uint64_t id, const swarmd_none_t *args, uint8_t **out, size_t *out_len); | |
| 53 | ||
| 54 | int | |
| 55 | swarmd_encode_status_get_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 56 | ||
| 57 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 58 | int | |
| 59 | swarmd_decode_status_get_response (const rpc_message_t *msg, swarmd_status_t *result, hrpc_error_t *error); | |
| 60 | ||
| 61 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 62 | typedef int (*swarmd_on_status_get) (void *ctx, const swarmd_none_t *req, swarmd_status_t *res, hrpc_error_t *error); | |
| 63 | ||
| 64 | // @swarmd/swarm-join (unary) | |
| 65 | int | |
| 66 | swarmd_encode_swarm_join (uint64_t id, const swarmd_swarm_join_t *args, uint8_t **out, size_t *out_len); | |
| 67 | ||
| 68 | int | |
| 69 | swarmd_encode_swarm_join_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 70 | ||
| 71 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 72 | int | |
| 73 | swarmd_decode_swarm_join_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 74 | ||
| 75 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 76 | typedef int (*swarmd_on_swarm_join) (void *ctx, const swarmd_swarm_join_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 77 | ||
| 78 | // @swarmd/swarm-leave (unary) | |
| 79 | int | |
| 80 | swarmd_encode_swarm_leave (uint64_t id, const swarmd_topic_ref_t *args, uint8_t **out, size_t *out_len); | |
| 81 | ||
| 82 | int | |
| 83 | swarmd_encode_swarm_leave_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 84 | ||
| 85 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 86 | int | |
| 87 | swarmd_decode_swarm_leave_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 88 | ||
| 89 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 90 | typedef int (*swarmd_on_swarm_leave) (void *ctx, const swarmd_topic_ref_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 91 | ||
| 92 | // @swarmd/peer-add (unary) | |
| 93 | int | |
| 94 | swarmd_encode_peer_add (uint64_t id, const swarmd_peer_key_t *args, uint8_t **out, size_t *out_len); | |
| 95 | ||
| 96 | int | |
| 97 | swarmd_encode_peer_add_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 98 | ||
| 99 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 100 | int | |
| 101 | swarmd_decode_peer_add_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 102 | ||
| 103 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 104 | typedef int (*swarmd_on_peer_add) (void *ctx, const swarmd_peer_key_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 105 | ||
| 106 | // @swarmd/peer-remove (unary) | |
| 107 | int | |
| 108 | swarmd_encode_peer_remove (uint64_t id, const swarmd_peer_key_t *args, uint8_t **out, size_t *out_len); | |
| 109 | ||
| 110 | int | |
| 111 | swarmd_encode_peer_remove_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 112 | ||
| 113 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 114 | int | |
| 115 | swarmd_decode_peer_remove_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 116 | ||
| 117 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 118 | typedef int (*swarmd_on_peer_remove) (void *ctx, const swarmd_peer_key_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 119 | ||
| 120 | // @swarmd/channel-open (unary) | |
| 121 | int | |
| 122 | swarmd_encode_channel_open (uint64_t id, const swarmd_channel_open_t *args, uint8_t **out, size_t *out_len); | |
| 123 | ||
| 124 | int | |
| 125 | swarmd_encode_channel_open_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 126 | ||
| 127 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 128 | int | |
| 129 | swarmd_decode_channel_open_response (const rpc_message_t *msg, swarmd_channel_ref_t *result, hrpc_error_t *error); | |
| 130 | ||
| 131 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 132 | typedef int (*swarmd_on_channel_open) (void *ctx, const swarmd_channel_open_t *req, swarmd_channel_ref_t *res, hrpc_error_t *error); | |
| 133 | ||
| 134 | // @swarmd/channel-close (unary) | |
| 135 | int | |
| 136 | swarmd_encode_channel_close (uint64_t id, const swarmd_channel_ref_t *args, uint8_t **out, size_t *out_len); | |
| 137 | ||
| 138 | int | |
| 139 | swarmd_encode_channel_close_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 140 | ||
| 141 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 142 | int | |
| 143 | swarmd_decode_channel_close_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 144 | ||
| 145 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 146 | typedef int (*swarmd_on_channel_close) (void *ctx, const swarmd_channel_ref_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 147 | ||
| 148 | // @swarmd/send (unary) | |
| 149 | int | |
| 150 | swarmd_encode_send (uint64_t id, const swarmd_send_request_t *args, uint8_t **out, size_t *out_len); | |
| 151 | ||
| 152 | int | |
| 153 | swarmd_encode_send_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 154 | ||
| 155 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 156 | int | |
| 157 | swarmd_decode_send_response (const rpc_message_t *msg, swarmd_send_result_t *result, hrpc_error_t *error); | |
| 158 | ||
| 159 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 160 | typedef int (*swarmd_on_send) (void *ctx, const swarmd_send_request_t *req, swarmd_send_result_t *res, hrpc_error_t *error); | |
| 161 | ||
| 162 | // @swarmd/content-hash (unary) | |
| 163 | int | |
| 164 | swarmd_encode_content_hash (uint64_t id, const swarmd_path_t *args, uint8_t **out, size_t *out_len); | |
| 165 | ||
| 166 | int | |
| 167 | swarmd_encode_content_hash_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 168 | ||
| 169 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 170 | int | |
| 171 | swarmd_decode_content_hash_response (const rpc_message_t *msg, swarmd_hash_t *result, hrpc_error_t *error); | |
| 172 | ||
| 173 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 174 | typedef int (*swarmd_on_content_hash) (void *ctx, const swarmd_path_t *req, swarmd_hash_t *res, hrpc_error_t *error); | |
| 175 | ||
| 176 | // @swarmd/content-serve (unary) | |
| 177 | int | |
| 178 | swarmd_encode_content_serve (uint64_t id, const swarmd_content_serve_t *args, uint8_t **out, size_t *out_len); | |
| 179 | ||
| 180 | int | |
| 181 | swarmd_encode_content_serve_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 182 | ||
| 183 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 184 | int | |
| 185 | swarmd_decode_content_serve_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 186 | ||
| 187 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 188 | typedef int (*swarmd_on_content_serve) (void *ctx, const swarmd_content_serve_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 189 | ||
| 190 | // @swarmd/content-fetch (unary) | |
| 191 | int | |
| 192 | swarmd_encode_content_fetch (uint64_t id, const swarmd_content_fetch_t *args, uint8_t **out, size_t *out_len); | |
| 193 | ||
| 194 | int | |
| 195 | swarmd_encode_content_fetch_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 196 | ||
| 197 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 198 | int | |
| 199 | swarmd_decode_content_fetch_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 200 | ||
| 201 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 202 | typedef int (*swarmd_on_content_fetch) (void *ctx, const swarmd_content_fetch_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 203 | ||
| 204 | // @swarmd/content-cancel (unary) | |
| 205 | int | |
| 206 | swarmd_encode_content_cancel (uint64_t id, const swarmd_content_cancel_t *args, uint8_t **out, size_t *out_len); | |
| 207 | ||
| 208 | int | |
| 209 | swarmd_encode_content_cancel_error (uint64_t id, hrpc_error_t error, uint8_t **out, size_t *out_len); | |
| 210 | ||
| 211 | // Returns hrpc_ok (fills *result), hrpc_error_response (fills *error), or < 0. | |
| 212 | int | |
| 213 | swarmd_decode_content_cancel_response (const rpc_message_t *msg, swarmd_ok_t *result, hrpc_error_t *error); | |
| 214 | ||
| 215 | // Return hrpc_ok after filling *res, or hrpc_error_response after filling *error. | |
| 216 | typedef int (*swarmd_on_content_cancel) (void *ctx, const swarmd_content_cancel_t *req, swarmd_ok_t *res, hrpc_error_t *error); | |
| 217 | ||
| 218 | // @swarmd/on-peer-up (event) | |
| 219 | int | |
| 220 | swarmd_encode_on_peer_up (const swarmd_peer_up_t *args, uint8_t **out, size_t *out_len); | |
| 221 | ||
| 222 | typedef void (*swarmd_on_on_peer_up) (void *ctx, const swarmd_peer_up_t *req); | |
| 223 | ||
| 224 | // @swarmd/on-peer-down (event) | |
| 225 | int | |
| 226 | swarmd_encode_on_peer_down (const swarmd_peer_down_t *args, uint8_t **out, size_t *out_len); | |
| 227 | ||
| 228 | typedef void (*swarmd_on_on_peer_down) (void *ctx, const swarmd_peer_down_t *req); | |
| 229 | ||
| 230 | // @swarmd/on-message (event) | |
| 231 | int | |
| 232 | swarmd_encode_on_message (const swarmd_message_t *args, uint8_t **out, size_t *out_len); | |
| 233 | ||
| 234 | typedef void (*swarmd_on_on_message) (void *ctx, const swarmd_message_t *req); | |
| 235 | ||
| 236 | // @swarmd/on-drain (event) | |
| 237 | int | |
| 238 | swarmd_encode_on_drain (const swarmd_channel_ref_t *args, uint8_t **out, size_t *out_len); | |
| 239 | ||
| 240 | typedef void (*swarmd_on_on_drain) (void *ctx, const swarmd_channel_ref_t *req); | |
| 241 | ||
| 242 | // @swarmd/on-status (event) | |
| 243 | int | |
| 244 | swarmd_encode_on_status (const swarmd_status_t *args, uint8_t **out, size_t *out_len); | |
| 245 | ||
| 246 | typedef void (*swarmd_on_on_status) (void *ctx, const swarmd_status_t *req); | |
| 247 | ||
| 248 | // @swarmd/on-content-progress (event) | |
| 249 | int | |
| 250 | swarmd_encode_on_content_progress (const swarmd_content_progress_t *args, uint8_t **out, size_t *out_len); | |
| 251 | ||
| 252 | typedef void (*swarmd_on_on_content_progress) (void *ctx, const swarmd_content_progress_t *req); | |
| 253 | ||
| 254 | // @swarmd/on-content-done (event) | |
| 255 | int | |
| 256 | swarmd_encode_on_content_done (const swarmd_content_done_t *args, uint8_t **out, size_t *out_len); | |
| 257 | ||
| 258 | typedef void (*swarmd_on_on_content_done) (void *ctx, const swarmd_content_done_t *req); | |
| 259 | ||
| 260 | // @swarmd/on-content-failed (event) | |
| 261 | int | |
| 262 | swarmd_encode_on_content_failed (const swarmd_content_failed_t *args, uint8_t **out, size_t *out_len); | |
| 263 | ||
| 264 | typedef void (*swarmd_on_on_content_failed) (void *ctx, const swarmd_content_failed_t *req); | |
| 265 | ||
| 266 | typedef struct { | |
| 267 | void *ctx; | |
| 268 | swarmd_on_hello on_hello; | |
| 269 | swarmd_on_status_get on_status_get; | |
| 270 | swarmd_on_swarm_join on_swarm_join; | |
| 271 | swarmd_on_swarm_leave on_swarm_leave; | |
| 272 | swarmd_on_peer_add on_peer_add; | |
| 273 | swarmd_on_peer_remove on_peer_remove; | |
| 274 | swarmd_on_channel_open on_channel_open; | |
| 275 | swarmd_on_channel_close on_channel_close; | |
| 276 | swarmd_on_send on_send; | |
| 277 | swarmd_on_content_hash on_content_hash; | |
| 278 | swarmd_on_content_serve on_content_serve; | |
| 279 | swarmd_on_content_fetch on_content_fetch; | |
| 280 | swarmd_on_content_cancel on_content_cancel; | |
| 281 | swarmd_on_on_peer_up on_on_peer_up; | |
| 282 | swarmd_on_on_peer_down on_on_peer_down; | |
| 283 | swarmd_on_on_message on_on_message; | |
| 284 | swarmd_on_on_drain on_on_drain; | |
| 285 | swarmd_on_on_status on_on_status; | |
| 286 | swarmd_on_on_content_progress on_on_content_progress; | |
| 287 | swarmd_on_on_content_done on_on_content_done; | |
| 288 | swarmd_on_on_content_failed on_on_content_failed; | |
| 289 | } swarmd_hrpc_handlers_t; | |
| 290 | ||
| 291 | // Dispatch one decoded request. Returns hrpc_dispatch_reply (sets | |
| 292 | // *reply_out / *reply_len, caller sends then frees), hrpc_dispatch_no_reply, | |
| 293 | // hrpc_dispatch_stream, or < 0 (no reply written). | |
| 294 | int | |
| 295 | swarmd_hrpc_dispatch (const swarmd_hrpc_handlers_t *handlers, const rpc_message_t *msg, uint8_t **reply_out, size_t *reply_len); | |
| 296 | ||
| 297 | #endif // SWARMD_HRPC_H |
| … | … | @@ -0,0 +1,788 @@ |
| 1 | // This file is autogenerated by hyperschema-c | |
| 2 | // !!DO NOT EDIT!! | |
| 3 | ||
| 4 | #include "swarmd_schema.h" | |
| 5 | ||
| 6 | int | |
| 7 | swarmd_hello_request_preencode (compact_state_t *state, const swarmd_hello_request_t *value) | |
| 8 | { | |
| 9 | int err; | |
| 10 | if ((err = compact_preencode_utf8(state, value->name)) < 0) return err; | |
| 11 | if ((err = compact_preencode_fixed32(state, value->app_identity)) < 0) return err; | |
| 12 | if ((err = compact_preencode_uint(state, value->version)) < 0) return err; | |
| 13 | return 0; | |
| 14 | } | |
| 15 | ||
| 16 | int | |
| 17 | swarmd_hello_request_encode (compact_state_t *state, const swarmd_hello_request_t *value) | |
| 18 | { | |
| 19 | int err; | |
| 20 | if ((err = compact_encode_utf8(state, value->name)) < 0) return err; | |
| 21 | if ((err = compact_encode_fixed32(state, value->app_identity)) < 0) return err; | |
| 22 | if ((err = compact_encode_uint(state, value->version)) < 0) return err; | |
| 23 | return 0; | |
| 24 | } | |
| 25 | ||
| 26 | int | |
| 27 | swarmd_hello_request_decode (compact_state_t *state, swarmd_hello_request_t *result) | |
| 28 | { | |
| 29 | int err; | |
| 30 | if ((err = compact_decode_utf8(state, &result->name)) < 0) return err; | |
| 31 | if ((err = compact_decode_fixed32(state, result->app_identity)) < 0) return err; | |
| 32 | if ((err = compact_decode_uint(state, &result->version)) < 0) return err; | |
| 33 | return 0; | |
| 34 | } | |
| 35 | ||
| 36 | void | |
| 37 | swarmd_hello_request_destroy (swarmd_hello_request_t *result) | |
| 38 | { | |
| 39 | } | |
| 40 | ||
| 41 | int | |
| 42 | swarmd_hello_response_preencode (compact_state_t *state, const swarmd_hello_response_t *value) | |
| 43 | { | |
| 44 | int err; | |
| 45 | if ((err = compact_preencode_uint(state, value->client_id)) < 0) return err; | |
| 46 | if ((err = compact_preencode_fixed32(state, value->daemon_pubkey)) < 0) return err; | |
| 47 | return 0; | |
| 48 | } | |
| 49 | ||
| 50 | int | |
| 51 | swarmd_hello_response_encode (compact_state_t *state, const swarmd_hello_response_t *value) | |
| 52 | { | |
| 53 | int err; | |
| 54 | if ((err = compact_encode_uint(state, value->client_id)) < 0) return err; | |
| 55 | if ((err = compact_encode_fixed32(state, value->daemon_pubkey)) < 0) return err; | |
| 56 | return 0; | |
| 57 | } | |
| 58 | ||
| 59 | int | |
| 60 | swarmd_hello_response_decode (compact_state_t *state, swarmd_hello_response_t *result) | |
| 61 | { | |
| 62 | int err; | |
| 63 | if ((err = compact_decode_uint(state, &result->client_id)) < 0) return err; | |
| 64 | if ((err = compact_decode_fixed32(state, result->daemon_pubkey)) < 0) return err; | |
| 65 | return 0; | |
| 66 | } | |
| 67 | ||
| 68 | void | |
| 69 | swarmd_hello_response_destroy (swarmd_hello_response_t *result) | |
| 70 | { | |
| 71 | } | |
| 72 | ||
| 73 | int | |
| 74 | swarmd_status_preencode (compact_state_t *state, const swarmd_status_t *value) | |
| 75 | { | |
| 76 | int err; | |
| 77 | if ((err = compact_preencode_uint(state, value->dht_state)) < 0) return err; | |
| 78 | uint64_t flags = 0; | |
| 79 | if (value->bootstrapped) flags |= ((uint64_t)1 << 0); | |
| 80 | if ((err = compact_preencode_uint(state, flags)) < 0) return err; | |
| 81 | if ((err = compact_preencode_uint(state, value->peers_known)) < 0) return err; | |
| 82 | if ((err = compact_preencode_uint(state, value->peers_connected)) < 0) return err; | |
| 83 | if ((err = compact_preencode_uint(state, value->connecting)) < 0) return err; | |
| 84 | if ((err = compact_preencode_uint(state, value->queued)) < 0) return err; | |
| 85 | if ((err = compact_preencode_uint(state, value->local_clients)) < 0) return err; | |
| 86 | return 0; | |
| 87 | } | |
| 88 | ||
| 89 | int | |
| 90 | swarmd_status_encode (compact_state_t *state, const swarmd_status_t *value) | |
| 91 | { | |
| 92 | int err; | |
| 93 | if ((err = compact_encode_uint(state, value->dht_state)) < 0) return err; | |
| 94 | uint64_t flags = 0; | |
| 95 | if (value->bootstrapped) flags |= ((uint64_t)1 << 0); | |
| 96 | if ((err = compact_encode_uint(state, flags)) < 0) return err; | |
| 97 | if ((err = compact_encode_uint(state, value->peers_known)) < 0) return err; | |
| 98 | if ((err = compact_encode_uint(state, value->peers_connected)) < 0) return err; | |
| 99 | if ((err = compact_encode_uint(state, value->connecting)) < 0) return err; | |
| 100 | if ((err = compact_encode_uint(state, value->queued)) < 0) return err; | |
| 101 | if ((err = compact_encode_uint(state, value->local_clients)) < 0) return err; | |
| 102 | return 0; | |
| 103 | } | |
| 104 | ||
| 105 | int | |
| 106 | swarmd_status_decode (compact_state_t *state, swarmd_status_t *result) | |
| 107 | { | |
| 108 | int err; | |
| 109 | if ((err = compact_decode_uint(state, &result->dht_state)) < 0) return err; | |
| 110 | uint64_t flags = 0; | |
| 111 | if ((err = compact_decode_uint(state, &flags)) < 0) return err; | |
| 112 | result->bootstrapped = (flags & ((uint64_t)1 << 0)) != 0; | |
| 113 | if ((err = compact_decode_uint(state, &result->peers_known)) < 0) return err; | |
| 114 | if ((err = compact_decode_uint(state, &result->peers_connected)) < 0) return err; | |
| 115 | if ((err = compact_decode_uint(state, &result->connecting)) < 0) return err; | |
| 116 | if ((err = compact_decode_uint(state, &result->queued)) < 0) return err; | |
| 117 | if ((err = compact_decode_uint(state, &result->local_clients)) < 0) return err; | |
| 118 | return 0; | |
| 119 | } | |
| 120 | ||
| 121 | void | |
| 122 | swarmd_status_destroy (swarmd_status_t *result) | |
| 123 | { | |
| 124 | } | |
| 125 | ||
| 126 | int | |
| 127 | swarmd_ok_preencode (compact_state_t *state, const swarmd_ok_t *value) | |
| 128 | { | |
| 129 | int err; | |
| 130 | uint64_t flags = 0; | |
| 131 | if (value->ok) flags |= ((uint64_t)1 << 0); | |
| 132 | if ((err = compact_preencode_uint(state, flags)) < 0) return err; | |
| 133 | return 0; | |
| 134 | } | |
| 135 | ||
| 136 | int | |
| 137 | swarmd_ok_encode (compact_state_t *state, const swarmd_ok_t *value) | |
| 138 | { | |
| 139 | int err; | |
| 140 | uint64_t flags = 0; | |
| 141 | if (value->ok) flags |= ((uint64_t)1 << 0); | |
| 142 | if ((err = compact_encode_uint(state, flags)) < 0) return err; | |
| 143 | return 0; | |
| 144 | } | |
| 145 | ||
| 146 | int | |
| 147 | swarmd_ok_decode (compact_state_t *state, swarmd_ok_t *result) | |
| 148 | { | |
| 149 | int err; | |
| 150 | uint64_t flags = 0; | |
| 151 | if ((err = compact_decode_uint(state, &flags)) < 0) return err; | |
| 152 | result->ok = (flags & ((uint64_t)1 << 0)) != 0; | |
| 153 | return 0; | |
| 154 | } | |
| 155 | ||
| 156 | void | |
| 157 | swarmd_ok_destroy (swarmd_ok_t *result) | |
| 158 | { | |
| 159 | } | |
| 160 | ||
| 161 | int | |
| 162 | swarmd_none_preencode (compact_state_t *state, const swarmd_none_t *value) | |
| 163 | { | |
| 164 | int err; | |
| 165 | if ((err = compact_preencode_uint(state, value->reserved)) < 0) return err; | |
| 166 | return 0; | |
| 167 | } | |
| 168 | ||
| 169 | int | |
| 170 | swarmd_none_encode (compact_state_t *state, const swarmd_none_t *value) | |
| 171 | { | |
| 172 | int err; | |
| 173 | if ((err = compact_encode_uint(state, value->reserved)) < 0) return err; | |
| 174 | return 0; | |
| 175 | } | |
| 176 | ||
| 177 | int | |
| 178 | swarmd_none_decode (compact_state_t *state, swarmd_none_t *result) | |
| 179 | { | |
| 180 | int err; | |
| 181 | if ((err = compact_decode_uint(state, &result->reserved)) < 0) return err; | |
| 182 | return 0; | |
| 183 | } | |
| 184 | ||
| 185 | void | |
| 186 | swarmd_none_destroy (swarmd_none_t *result) | |
| 187 | { | |
| 188 | } | |
| 189 | ||
| 190 | int | |
| 191 | swarmd_swarm_join_preencode (compact_state_t *state, const swarmd_swarm_join_t *value) | |
| 192 | { | |
| 193 | int err; | |
| 194 | if ((err = compact_preencode_fixed32(state, value->topic)) < 0) return err; | |
| 195 | uint64_t flags = 0; | |
| 196 | if (value->server) flags |= ((uint64_t)1 << 0); | |
| 197 | if (value->client) flags |= ((uint64_t)1 << 1); | |
| 198 | if ((err = compact_preencode_uint(state, flags)) < 0) return err; | |
| 199 | return 0; | |
| 200 | } | |
| 201 | ||
| 202 | int | |
| 203 | swarmd_swarm_join_encode (compact_state_t *state, const swarmd_swarm_join_t *value) | |
| 204 | { | |
| 205 | int err; | |
| 206 | if ((err = compact_encode_fixed32(state, value->topic)) < 0) return err; | |
| 207 | uint64_t flags = 0; | |
| 208 | if (value->server) flags |= ((uint64_t)1 << 0); | |
| 209 | if (value->client) flags |= ((uint64_t)1 << 1); | |
| 210 | if ((err = compact_encode_uint(state, flags)) < 0) return err; | |
| 211 | return 0; | |
| 212 | } | |
| 213 | ||
| 214 | int | |
| 215 | swarmd_swarm_join_decode (compact_state_t *state, swarmd_swarm_join_t *result) | |
| 216 | { | |
| 217 | int err; | |
| 218 | if ((err = compact_decode_fixed32(state, result->topic)) < 0) return err; | |
| 219 | uint64_t flags = 0; | |
| 220 | if ((err = compact_decode_uint(state, &flags)) < 0) return err; | |
| 221 | result->server = (flags & ((uint64_t)1 << 0)) != 0; | |
| 222 | result->client = (flags & ((uint64_t)1 << 1)) != 0; | |
| 223 | return 0; | |
| 224 | } | |
| 225 | ||
| 226 | void | |
| 227 | swarmd_swarm_join_destroy (swarmd_swarm_join_t *result) | |
| 228 | { | |
| 229 | } | |
| 230 | ||
| 231 | int | |
| 232 | swarmd_topic_ref_preencode (compact_state_t *state, const swarmd_topic_ref_t *value) | |
| 233 | { | |
| 234 | int err; | |
| 235 | if ((err = compact_preencode_fixed32(state, value->topic)) < 0) return err; | |
| 236 | return 0; | |
| 237 | } | |
| 238 | ||
| 239 | int | |
| 240 | swarmd_topic_ref_encode (compact_state_t *state, const swarmd_topic_ref_t *value) | |
| 241 | { | |
| 242 | int err; | |
| 243 | if ((err = compact_encode_fixed32(state, value->topic)) < 0) return err; | |
| 244 | return 0; | |
| 245 | } | |
| 246 | ||
| 247 | int | |
| 248 | swarmd_topic_ref_decode (compact_state_t *state, swarmd_topic_ref_t *result) | |
| 249 | { | |
| 250 | int err; | |
| 251 | if ((err = compact_decode_fixed32(state, result->topic)) < 0) return err; | |
| 252 | return 0; | |
| 253 | } | |
| 254 | ||
| 255 | void | |
| 256 | swarmd_topic_ref_destroy (swarmd_topic_ref_t *result) | |
| 257 | { | |
| 258 | } | |
| 259 | ||
| 260 | int | |
| 261 | swarmd_peer_key_preencode (compact_state_t *state, const swarmd_peer_key_t *value) | |
| 262 | { | |
| 263 | int err; | |
| 264 | if ((err = compact_preencode_fixed32(state, value->pubkey)) < 0) return err; | |
| 265 | return 0; | |
| 266 | } | |
| 267 | ||
| 268 | int | |
| 269 | swarmd_peer_key_encode (compact_state_t *state, const swarmd_peer_key_t *value) | |
| 270 | { | |
| 271 | int err; | |
| 272 | if ((err = compact_encode_fixed32(state, value->pubkey)) < 0) return err; | |
| 273 | return 0; | |
| 274 | } | |
| 275 | ||
| 276 | int | |
| 277 | swarmd_peer_key_decode (compact_state_t *state, swarmd_peer_key_t *result) | |
| 278 | { | |
| 279 | int err; | |
| 280 | if ((err = compact_decode_fixed32(state, result->pubkey)) < 0) return err; | |
| 281 | return 0; | |
| 282 | } | |
| 283 | ||
| 284 | void | |
| 285 | swarmd_peer_key_destroy (swarmd_peer_key_t *result) | |
| 286 | { | |
| 287 | } | |
| 288 | ||
| 289 | int | |
| 290 | swarmd_channel_open_preencode (compact_state_t *state, const swarmd_channel_open_t *value) | |
| 291 | { | |
| 292 | int err; | |
| 293 | if ((err = compact_preencode_utf8(state, value->protocol)) < 0) return err; | |
| 294 | if ((err = compact_preencode_uint8array(state, value->id, value->id_len)) < 0) return err; | |
| 295 | if ((err = compact_preencode_uint(state, value->slots)) < 0) return err; | |
| 296 | return 0; | |
| 297 | } | |
| 298 | ||
| 299 | int | |
| 300 | swarmd_channel_open_encode (compact_state_t *state, const swarmd_channel_open_t *value) | |
| 301 | { | |
| 302 | int err; | |
| 303 | if ((err = compact_encode_utf8(state, value->protocol)) < 0) return err; | |
| 304 | if ((err = compact_encode_uint8array(state, value->id, value->id_len)) < 0) return err; | |
| 305 | if ((err = compact_encode_uint(state, value->slots)) < 0) return err; | |
| 306 | return 0; | |
| 307 | } | |
| 308 | ||
| 309 | int | |
| 310 | swarmd_channel_open_decode (compact_state_t *state, swarmd_channel_open_t *result) | |
| 311 | { | |
| 312 | int err; | |
| 313 | if ((err = compact_decode_utf8(state, &result->protocol)) < 0) return err; | |
| 314 | if ((err = compact_decode_uint8array(state, &result->id, &result->id_len)) < 0) return err; | |
| 315 | if ((err = compact_decode_uint(state, &result->slots)) < 0) return err; | |
| 316 | return 0; | |
| 317 | } | |
| 318 | ||
| 319 | void | |
| 320 | swarmd_channel_open_destroy (swarmd_channel_open_t *result) | |
| 321 | { | |
| 322 | } | |
| 323 | ||
| 324 | int | |
| 325 | swarmd_channel_ref_preencode (compact_state_t *state, const swarmd_channel_ref_t *value) | |
| 326 | { | |
| 327 | int err; | |
| 328 | if ((err = compact_preencode_uint(state, value->channel)) < 0) return err; | |
| 329 | return 0; | |
| 330 | } | |
| 331 | ||
| 332 | int | |
| 333 | swarmd_channel_ref_encode (compact_state_t *state, const swarmd_channel_ref_t *value) | |
| 334 | { | |
| 335 | int err; | |
| 336 | if ((err = compact_encode_uint(state, value->channel)) < 0) return err; | |
| 337 | return 0; | |
| 338 | } | |
| 339 | ||
| 340 | int | |
| 341 | swarmd_channel_ref_decode (compact_state_t *state, swarmd_channel_ref_t *result) | |
| 342 | { | |
| 343 | int err; | |
| 344 | if ((err = compact_decode_uint(state, &result->channel)) < 0) return err; | |
| 345 | return 0; | |
| 346 | } | |
| 347 | ||
| 348 | void | |
| 349 | swarmd_channel_ref_destroy (swarmd_channel_ref_t *result) | |
| 350 | { | |
| 351 | } | |
| 352 | ||
| 353 | int | |
| 354 | swarmd_send_request_preencode (compact_state_t *state, const swarmd_send_request_t *value) | |
| 355 | { | |
| 356 | int err; | |
| 357 | if ((err = compact_preencode_uint(state, value->channel)) < 0) return err; | |
| 358 | if ((err = compact_preencode_uint(state, value->slot)) < 0) return err; | |
| 359 | if ((err = compact_preencode_uint(state, value->target)) < 0) return err; | |
| 360 | if ((err = compact_preencode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err; | |
| 361 | return 0; | |
| 362 | } | |
| 363 | ||
| 364 | int | |
| 365 | swarmd_send_request_encode (compact_state_t *state, const swarmd_send_request_t *value) | |
| 366 | { | |
| 367 | int err; | |
| 368 | if ((err = compact_encode_uint(state, value->channel)) < 0) return err; | |
| 369 | if ((err = compact_encode_uint(state, value->slot)) < 0) return err; | |
| 370 | if ((err = compact_encode_uint(state, value->target)) < 0) return err; | |
| 371 | if ((err = compact_encode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err; | |
| 372 | return 0; | |
| 373 | } | |
| 374 | ||
| 375 | int | |
| 376 | swarmd_send_request_decode (compact_state_t *state, swarmd_send_request_t *result) | |
| 377 | { | |
| 378 | int err; | |
| 379 | if ((err = compact_decode_uint(state, &result->channel)) < 0) return err; | |
| 380 | if ((err = compact_decode_uint(state, &result->slot)) < 0) return err; | |
| 381 | if ((err = compact_decode_uint(state, &result->target)) < 0) return err; | |
| 382 | if ((err = compact_decode_uint8array(state, &result->bytes, &result->bytes_len)) < 0) return err; | |
| 383 | return 0; | |
| 384 | } | |
| 385 | ||
| 386 | void | |
| 387 | swarmd_send_request_destroy (swarmd_send_request_t *result) | |
| 388 | { | |
| 389 | } | |
| 390 | ||
| 391 | int | |
| 392 | swarmd_send_result_preencode (compact_state_t *state, const swarmd_send_result_t *value) | |
| 393 | { | |
| 394 | int err; | |
| 395 | uint64_t flags = 0; | |
| 396 | if (value->accepted) flags |= ((uint64_t)1 << 0); | |
| 397 | if (value->writable) flags |= ((uint64_t)1 << 1); | |
| 398 | if ((err = compact_preencode_uint(state, flags)) < 0) return err; | |
| 399 | return 0; | |
| 400 | } | |
| 401 | ||
| 402 | int | |
| 403 | swarmd_send_result_encode (compact_state_t *state, const swarmd_send_result_t *value) | |
| 404 | { | |
| 405 | int err; | |
| 406 | uint64_t flags = 0; | |
| 407 | if (value->accepted) flags |= ((uint64_t)1 << 0); | |
| 408 | if (value->writable) flags |= ((uint64_t)1 << 1); | |
| 409 | if ((err = compact_encode_uint(state, flags)) < 0) return err; | |
| 410 | return 0; | |
| 411 | } | |
| 412 | ||
| 413 | int | |
| 414 | swarmd_send_result_decode (compact_state_t *state, swarmd_send_result_t *result) | |
| 415 | { | |
| 416 | int err; | |
| 417 | uint64_t flags = 0; | |
| 418 | if ((err = compact_decode_uint(state, &flags)) < 0) return err; | |
| 419 | result->accepted = (flags & ((uint64_t)1 << 0)) != 0; | |
| 420 | result->writable = (flags & ((uint64_t)1 << 1)) != 0; | |
| 421 | return 0; | |
| 422 | } | |
| 423 | ||
| 424 | void | |
| 425 | swarmd_send_result_destroy (swarmd_send_result_t *result) | |
| 426 | { | |
| 427 | } | |
| 428 | ||
| 429 | int | |
| 430 | swarmd_path_preencode (compact_state_t *state, const swarmd_path_t *value) | |
| 431 | { | |
| 432 | int err; | |
| 433 | if ((err = compact_preencode_utf8(state, value->path)) < 0) return err; | |
| 434 | return 0; | |
| 435 | } | |
| 436 | ||
| 437 | int | |
| 438 | swarmd_path_encode (compact_state_t *state, const swarmd_path_t *value) | |
| 439 | { | |
| 440 | int err; | |
| 441 | if ((err = compact_encode_utf8(state, value->path)) < 0) return err; | |
| 442 | return 0; | |
| 443 | } | |
| 444 | ||
| 445 | int | |
| 446 | swarmd_path_decode (compact_state_t *state, swarmd_path_t *result) | |
| 447 | { | |
| 448 | int err; | |
| 449 | if ((err = compact_decode_utf8(state, &result->path)) < 0) return err; | |
| 450 | return 0; | |
| 451 | } | |
| 452 | ||
| 453 | void | |
| 454 | swarmd_path_destroy (swarmd_path_t *result) | |
| 455 | { | |
| 456 | } | |
| 457 | ||
| 458 | int | |
| 459 | swarmd_hash_preencode (compact_state_t *state, const swarmd_hash_t *value) | |
| 460 | { | |
| 461 | int err; | |
| 462 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 463 | return 0; | |
| 464 | } | |
| 465 | ||
| 466 | int | |
| 467 | swarmd_hash_encode (compact_state_t *state, const swarmd_hash_t *value) | |
| 468 | { | |
| 469 | int err; | |
| 470 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 471 | return 0; | |
| 472 | } | |
| 473 | ||
| 474 | int | |
| 475 | swarmd_hash_decode (compact_state_t *state, swarmd_hash_t *result) | |
| 476 | { | |
| 477 | int err; | |
| 478 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 479 | return 0; | |
| 480 | } | |
| 481 | ||
| 482 | void | |
| 483 | swarmd_hash_destroy (swarmd_hash_t *result) | |
| 484 | { | |
| 485 | } | |
| 486 | ||
| 487 | int | |
| 488 | swarmd_content_serve_preencode (compact_state_t *state, const swarmd_content_serve_t *value) | |
| 489 | { | |
| 490 | int err; | |
| 491 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 492 | if ((err = compact_preencode_utf8(state, value->path)) < 0) return err; | |
| 493 | return 0; | |
| 494 | } | |
| 495 | ||
| 496 | int | |
| 497 | swarmd_content_serve_encode (compact_state_t *state, const swarmd_content_serve_t *value) | |
| 498 | { | |
| 499 | int err; | |
| 500 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 501 | if ((err = compact_encode_utf8(state, value->path)) < 0) return err; | |
| 502 | return 0; | |
| 503 | } | |
| 504 | ||
| 505 | int | |
| 506 | swarmd_content_serve_decode (compact_state_t *state, swarmd_content_serve_t *result) | |
| 507 | { | |
| 508 | int err; | |
| 509 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 510 | if ((err = compact_decode_utf8(state, &result->path)) < 0) return err; | |
| 511 | return 0; | |
| 512 | } | |
| 513 | ||
| 514 | void | |
| 515 | swarmd_content_serve_destroy (swarmd_content_serve_t *result) | |
| 516 | { | |
| 517 | } | |
| 518 | ||
| 519 | int | |
| 520 | swarmd_content_fetch_preencode (compact_state_t *state, const swarmd_content_fetch_t *value) | |
| 521 | { | |
| 522 | int err; | |
| 523 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 524 | if ((err = compact_preencode_utf8(state, value->dest_path)) < 0) return err; | |
| 525 | return 0; | |
| 526 | } | |
| 527 | ||
| 528 | int | |
| 529 | swarmd_content_fetch_encode (compact_state_t *state, const swarmd_content_fetch_t *value) | |
| 530 | { | |
| 531 | int err; | |
| 532 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 533 | if ((err = compact_encode_utf8(state, value->dest_path)) < 0) return err; | |
| 534 | return 0; | |
| 535 | } | |
| 536 | ||
| 537 | int | |
| 538 | swarmd_content_fetch_decode (compact_state_t *state, swarmd_content_fetch_t *result) | |
| 539 | { | |
| 540 | int err; | |
| 541 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 542 | if ((err = compact_decode_utf8(state, &result->dest_path)) < 0) return err; | |
| 543 | return 0; | |
| 544 | } | |
| 545 | ||
| 546 | void | |
| 547 | swarmd_content_fetch_destroy (swarmd_content_fetch_t *result) | |
| 548 | { | |
| 549 | } | |
| 550 | ||
| 551 | int | |
| 552 | swarmd_content_cancel_preencode (compact_state_t *state, const swarmd_content_cancel_t *value) | |
| 553 | { | |
| 554 | int err; | |
| 555 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 556 | uint64_t flags = 0; | |
| 557 | if (value->discard) flags |= ((uint64_t)1 << 0); | |
| 558 | if ((err = compact_preencode_uint(state, flags)) < 0) return err; | |
| 559 | return 0; | |
| 560 | } | |
| 561 | ||
| 562 | int | |
| 563 | swarmd_content_cancel_encode (compact_state_t *state, const swarmd_content_cancel_t *value) | |
| 564 | { | |
| 565 | int err; | |
| 566 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 567 | uint64_t flags = 0; | |
| 568 | if (value->discard) flags |= ((uint64_t)1 << 0); | |
| 569 | if ((err = compact_encode_uint(state, flags)) < 0) return err; | |
| 570 | return 0; | |
| 571 | } | |
| 572 | ||
| 573 | int | |
| 574 | swarmd_content_cancel_decode (compact_state_t *state, swarmd_content_cancel_t *result) | |
| 575 | { | |
| 576 | int err; | |
| 577 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 578 | uint64_t flags = 0; | |
| 579 | if ((err = compact_decode_uint(state, &flags)) < 0) return err; | |
| 580 | result->discard = (flags & ((uint64_t)1 << 0)) != 0; | |
| 581 | return 0; | |
| 582 | } | |
| 583 | ||
| 584 | void | |
| 585 | swarmd_content_cancel_destroy (swarmd_content_cancel_t *result) | |
| 586 | { | |
| 587 | } | |
| 588 | ||
| 589 | int | |
| 590 | swarmd_content_progress_preencode (compact_state_t *state, const swarmd_content_progress_t *value) | |
| 591 | { | |
| 592 | int err; | |
| 593 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 594 | if ((err = compact_preencode_uint(state, value->received)) < 0) return err; | |
| 595 | if ((err = compact_preencode_uint(state, value->total)) < 0) return err; | |
| 596 | return 0; | |
| 597 | } | |
| 598 | ||
| 599 | int | |
| 600 | swarmd_content_progress_encode (compact_state_t *state, const swarmd_content_progress_t *value) | |
| 601 | { | |
| 602 | int err; | |
| 603 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 604 | if ((err = compact_encode_uint(state, value->received)) < 0) return err; | |
| 605 | if ((err = compact_encode_uint(state, value->total)) < 0) return err; | |
| 606 | return 0; | |
| 607 | } | |
| 608 | ||
| 609 | int | |
| 610 | swarmd_content_progress_decode (compact_state_t *state, swarmd_content_progress_t *result) | |
| 611 | { | |
| 612 | int err; | |
| 613 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 614 | if ((err = compact_decode_uint(state, &result->received)) < 0) return err; | |
| 615 | if ((err = compact_decode_uint(state, &result->total)) < 0) return err; | |
| 616 | return 0; | |
| 617 | } | |
| 618 | ||
| 619 | void | |
| 620 | swarmd_content_progress_destroy (swarmd_content_progress_t *result) | |
| 621 | { | |
| 622 | } | |
| 623 | ||
| 624 | int | |
| 625 | swarmd_content_done_preencode (compact_state_t *state, const swarmd_content_done_t *value) | |
| 626 | { | |
| 627 | int err; | |
| 628 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 629 | if ((err = compact_preencode_utf8(state, value->path)) < 0) return err; | |
| 630 | return 0; | |
| 631 | } | |
| 632 | ||
| 633 | int | |
| 634 | swarmd_content_done_encode (compact_state_t *state, const swarmd_content_done_t *value) | |
| 635 | { | |
| 636 | int err; | |
| 637 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 638 | if ((err = compact_encode_utf8(state, value->path)) < 0) return err; | |
| 639 | return 0; | |
| 640 | } | |
| 641 | ||
| 642 | int | |
| 643 | swarmd_content_done_decode (compact_state_t *state, swarmd_content_done_t *result) | |
| 644 | { | |
| 645 | int err; | |
| 646 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 647 | if ((err = compact_decode_utf8(state, &result->path)) < 0) return err; | |
| 648 | return 0; | |
| 649 | } | |
| 650 | ||
| 651 | void | |
| 652 | swarmd_content_done_destroy (swarmd_content_done_t *result) | |
| 653 | { | |
| 654 | } | |
| 655 | ||
| 656 | int | |
| 657 | swarmd_content_failed_preencode (compact_state_t *state, const swarmd_content_failed_t *value) | |
| 658 | { | |
| 659 | int err; | |
| 660 | if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err; | |
| 661 | if ((err = compact_preencode_utf8(state, value->reason)) < 0) return err; | |
| 662 | return 0; | |
| 663 | } | |
| 664 | ||
| 665 | int | |
| 666 | swarmd_content_failed_encode (compact_state_t *state, const swarmd_content_failed_t *value) | |
| 667 | { | |
| 668 | int err; | |
| 669 | if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err; | |
| 670 | if ((err = compact_encode_utf8(state, value->reason)) < 0) return err; | |
| 671 | return 0; | |
| 672 | } | |
| 673 | ||
| 674 | int | |
| 675 | swarmd_content_failed_decode (compact_state_t *state, swarmd_content_failed_t *result) | |
| 676 | { | |
| 677 | int err; | |
| 678 | if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err; | |
| 679 | if ((err = compact_decode_utf8(state, &result->reason)) < 0) return err; | |
| 680 | return 0; | |
| 681 | } | |
| 682 | ||
| 683 | void | |
| 684 | swarmd_content_failed_destroy (swarmd_content_failed_t *result) | |
| 685 | { | |
| 686 | } | |
| 687 | ||
| 688 | int | |
| 689 | swarmd_peer_up_preencode (compact_state_t *state, const swarmd_peer_up_t *value) | |
| 690 | { | |
| 691 | int err; | |
| 692 | if ((err = compact_preencode_uint(state, value->peer)) < 0) return err; | |
| 693 | if ((err = compact_preencode_fixed32(state, value->pubkey)) < 0) return err; | |
| 694 | return 0; | |
| 695 | } | |
| 696 | ||
| 697 | int | |
| 698 | swarmd_peer_up_encode (compact_state_t *state, const swarmd_peer_up_t *value) | |
| 699 | { | |
| 700 | int err; | |
| 701 | if ((err = compact_encode_uint(state, value->peer)) < 0) return err; | |
| 702 | if ((err = compact_encode_fixed32(state, value->pubkey)) < 0) return err; | |
| 703 | return 0; | |
| 704 | } | |
| 705 | ||
| 706 | int | |
| 707 | swarmd_peer_up_decode (compact_state_t *state, swarmd_peer_up_t *result) | |
| 708 | { | |
| 709 | int err; | |
| 710 | if ((err = compact_decode_uint(state, &result->peer)) < 0) return err; | |
| 711 | if ((err = compact_decode_fixed32(state, result->pubkey)) < 0) return err; | |
| 712 | return 0; | |
| 713 | } | |
| 714 | ||
| 715 | void | |
| 716 | swarmd_peer_up_destroy (swarmd_peer_up_t *result) | |
| 717 | { | |
| 718 | } | |
| 719 | ||
| 720 | int | |
| 721 | swarmd_peer_down_preencode (compact_state_t *state, const swarmd_peer_down_t *value) | |
| 722 | { | |
| 723 | int err; | |
| 724 | if ((err = compact_preencode_uint(state, value->peer)) < 0) return err; | |
| 725 | return 0; | |
| 726 | } | |
| 727 | ||
| 728 | int | |
| 729 | swarmd_peer_down_encode (compact_state_t *state, const swarmd_peer_down_t *value) | |
| 730 | { | |
| 731 | int err; | |
| 732 | if ((err = compact_encode_uint(state, value->peer)) < 0) return err; | |
| 733 | return 0; | |
| 734 | } | |
| 735 | ||
| 736 | int | |
| 737 | swarmd_peer_down_decode (compact_state_t *state, swarmd_peer_down_t *result) | |
| 738 | { | |
| 739 | int err; | |
| 740 | if ((err = compact_decode_uint(state, &result->peer)) < 0) return err; | |
| 741 | return 0; | |
| 742 | } | |
| 743 | ||
| 744 | void | |
| 745 | swarmd_peer_down_destroy (swarmd_peer_down_t *result) | |
| 746 | { | |
| 747 | } | |
| 748 | ||
| 749 | int | |
| 750 | swarmd_message_preencode (compact_state_t *state, const swarmd_message_t *value) | |
| 751 | { | |
| 752 | int err; | |
| 753 | if ((err = compact_preencode_uint(state, value->channel)) < 0) return err; | |
| 754 | if ((err = compact_preencode_uint(state, value->slot)) < 0) return err; | |
| 755 | if ((err = compact_preencode_uint(state, value->origin_kind)) < 0) return err; | |
| 756 | if ((err = compact_preencode_uint(state, value->origin_id)) < 0) return err; | |
| 757 | if ((err = compact_preencode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err; | |
| 758 | return 0; | |
| 759 | } | |
| 760 | ||
| 761 | int | |
| 762 | swarmd_message_encode (compact_state_t *state, const swarmd_message_t *value) | |
| 763 | { | |
| 764 | int err; | |
| 765 | if ((err = compact_encode_uint(state, value->channel)) < 0) return err; | |
| 766 | if ((err = compact_encode_uint(state, value->slot)) < 0) return err; | |
| 767 | if ((err = compact_encode_uint(state, value->origin_kind)) < 0) return err; | |
| 768 | if ((err = compact_encode_uint(state, value->origin_id)) < 0) return err; | |
| 769 | if ((err = compact_encode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err; | |
| 770 | return 0; | |
| 771 | } | |
| 772 | ||
| 773 | int | |
| 774 | swarmd_message_decode (compact_state_t *state, swarmd_message_t *result) | |
| 775 | { | |
| 776 | int err; | |
| 777 | if ((err = compact_decode_uint(state, &result->channel)) < 0) return err; | |
| 778 | if ((err = compact_decode_uint(state, &result->slot)) < 0) return err; | |
| 779 | if ((err = compact_decode_uint(state, &result->origin_kind)) < 0) return err; | |
| 780 | if ((err = compact_decode_uint(state, &result->origin_id)) < 0) return err; | |
| 781 | if ((err = compact_decode_uint8array(state, &result->bytes, &result->bytes_len)) < 0) return err; | |
| 782 | return 0; | |
| 783 | } | |
| 784 | ||
| 785 | void | |
| 786 | swarmd_message_destroy (swarmd_message_t *result) | |
| 787 | { | |
| 788 | } |
| … | … | @@ -0,0 +1,434 @@ |
| 1 | // This file is autogenerated by hyperschema-c | |
| 2 | // !!DO NOT EDIT!! | |
| 3 | // Schema Version: 1 | |
| 4 | ||
| 5 | #ifndef SWARMD_SCHEMA_H | |
| 6 | #define SWARMD_SCHEMA_H | |
| 7 | ||
| 8 | #include <compact.h> | |
| 9 | #include <stdbool.h> | |
| 10 | ||
| 11 | // @swarmd/hello-request | |
| 12 | typedef struct swarmd_hello_request_s { | |
| 13 | utf8_string_view_t name; /* borrows from decode buffer */ | |
| 14 | uint8_t app_identity[32]; | |
| 15 | uint64_t version; | |
| 16 | } swarmd_hello_request_t; | |
| 17 | ||
| 18 | int | |
| 19 | swarmd_hello_request_preencode (compact_state_t *state, const swarmd_hello_request_t *value); | |
| 20 | ||
| 21 | int | |
| 22 | swarmd_hello_request_encode (compact_state_t *state, const swarmd_hello_request_t *value); | |
| 23 | ||
| 24 | int | |
| 25 | swarmd_hello_request_decode (compact_state_t *state, swarmd_hello_request_t *result); | |
| 26 | ||
| 27 | void | |
| 28 | swarmd_hello_request_destroy (swarmd_hello_request_t *result); | |
| 29 | ||
| 30 | // @swarmd/hello-response | |
| 31 | typedef struct swarmd_hello_response_s { | |
| 32 | uint64_t client_id; | |
| 33 | uint8_t daemon_pubkey[32]; | |
| 34 | } swarmd_hello_response_t; | |
| 35 | ||
| 36 | int | |
| 37 | swarmd_hello_response_preencode (compact_state_t *state, const swarmd_hello_response_t *value); | |
| 38 | ||
| 39 | int | |
| 40 | swarmd_hello_response_encode (compact_state_t *state, const swarmd_hello_response_t *value); | |
| 41 | ||
| 42 | int | |
| 43 | swarmd_hello_response_decode (compact_state_t *state, swarmd_hello_response_t *result); | |
| 44 | ||
| 45 | void | |
| 46 | swarmd_hello_response_destroy (swarmd_hello_response_t *result); | |
| 47 | ||
| 48 | // @swarmd/status | |
| 49 | typedef struct swarmd_status_s { | |
| 50 | uint64_t dht_state; | |
| 51 | bool bootstrapped; | |
| 52 | uint64_t peers_known; | |
| 53 | uint64_t peers_connected; | |
| 54 | uint64_t connecting; | |
| 55 | uint64_t queued; | |
| 56 | uint64_t local_clients; | |
| 57 | } swarmd_status_t; | |
| 58 | ||
| 59 | int | |
| 60 | swarmd_status_preencode (compact_state_t *state, const swarmd_status_t *value); | |
| 61 | ||
| 62 | int | |
| 63 | swarmd_status_encode (compact_state_t *state, const swarmd_status_t *value); | |
| 64 | ||
| 65 | int | |
| 66 | swarmd_status_decode (compact_state_t *state, swarmd_status_t *result); | |
| 67 | ||
| 68 | void | |
| 69 | swarmd_status_destroy (swarmd_status_t *result); | |
| 70 | ||
| 71 | // @swarmd/ok | |
| 72 | typedef struct swarmd_ok_s { | |
| 73 | bool ok; | |
| 74 | } swarmd_ok_t; | |
| 75 | ||
| 76 | int | |
| 77 | swarmd_ok_preencode (compact_state_t *state, const swarmd_ok_t *value); | |
| 78 | ||
| 79 | int | |
| 80 | swarmd_ok_encode (compact_state_t *state, const swarmd_ok_t *value); | |
| 81 | ||
| 82 | int | |
| 83 | swarmd_ok_decode (compact_state_t *state, swarmd_ok_t *result); | |
| 84 | ||
| 85 | void | |
| 86 | swarmd_ok_destroy (swarmd_ok_t *result); | |
| 87 | ||
| 88 | // @swarmd/none | |
| 89 | typedef struct swarmd_none_s { | |
| 90 | uint64_t reserved; | |
| 91 | } swarmd_none_t; | |
| 92 | ||
| 93 | int | |
| 94 | swarmd_none_preencode (compact_state_t *state, const swarmd_none_t *value); | |
| 95 | ||
| 96 | int | |
| 97 | swarmd_none_encode (compact_state_t *state, const swarmd_none_t *value); | |
| 98 | ||
| 99 | int | |
| 100 | swarmd_none_decode (compact_state_t *state, swarmd_none_t *result); | |
| 101 | ||
| 102 | void | |
| 103 | swarmd_none_destroy (swarmd_none_t *result); | |
| 104 | ||
| 105 | // @swarmd/swarm-join | |
| 106 | typedef struct swarmd_swarm_join_s { | |
| 107 | uint8_t topic[32]; | |
| 108 | bool server; | |
| 109 | bool client; | |
| 110 | } swarmd_swarm_join_t; | |
| 111 | ||
| 112 | int | |
| 113 | swarmd_swarm_join_preencode (compact_state_t *state, const swarmd_swarm_join_t *value); | |
| 114 | ||
| 115 | int | |
| 116 | swarmd_swarm_join_encode (compact_state_t *state, const swarmd_swarm_join_t *value); | |
| 117 | ||
| 118 | int | |
| 119 | swarmd_swarm_join_decode (compact_state_t *state, swarmd_swarm_join_t *result); | |
| 120 | ||
| 121 | void | |
| 122 | swarmd_swarm_join_destroy (swarmd_swarm_join_t *result); | |
| 123 | ||
| 124 | // @swarmd/topic-ref | |
| 125 | typedef struct swarmd_topic_ref_s { | |
| 126 | uint8_t topic[32]; | |
| 127 | } swarmd_topic_ref_t; | |
| 128 | ||
| 129 | int | |
| 130 | swarmd_topic_ref_preencode (compact_state_t *state, const swarmd_topic_ref_t *value); | |
| 131 | ||
| 132 | int | |
| 133 | swarmd_topic_ref_encode (compact_state_t *state, const swarmd_topic_ref_t *value); | |
| 134 | ||
| 135 | int | |
| 136 | swarmd_topic_ref_decode (compact_state_t *state, swarmd_topic_ref_t *result); | |
| 137 | ||
| 138 | void | |
| 139 | swarmd_topic_ref_destroy (swarmd_topic_ref_t *result); | |
| 140 | ||
| 141 | // @swarmd/peer-key | |
| 142 | typedef struct swarmd_peer_key_s { | |
| 143 | uint8_t pubkey[32]; | |
| 144 | } swarmd_peer_key_t; | |
| 145 | ||
| 146 | int | |
| 147 | swarmd_peer_key_preencode (compact_state_t *state, const swarmd_peer_key_t *value); | |
| 148 | ||
| 149 | int | |
| 150 | swarmd_peer_key_encode (compact_state_t *state, const swarmd_peer_key_t *value); | |
| 151 | ||
| 152 | int | |
| 153 | swarmd_peer_key_decode (compact_state_t *state, swarmd_peer_key_t *result); | |
| 154 | ||
| 155 | void | |
| 156 | swarmd_peer_key_destroy (swarmd_peer_key_t *result); | |
| 157 | ||
| 158 | // @swarmd/channel-open | |
| 159 | typedef struct swarmd_channel_open_s { | |
| 160 | utf8_string_view_t protocol; /* borrows from decode buffer */ | |
| 161 | uint8_t *id; /* borrows from decode buffer */ | |
| 162 | size_t id_len; | |
| 163 | uint64_t slots; | |
| 164 | } swarmd_channel_open_t; | |
| 165 | ||
| 166 | int | |
| 167 | swarmd_channel_open_preencode (compact_state_t *state, const swarmd_channel_open_t *value); | |
| 168 | ||
| 169 | int | |
| 170 | swarmd_channel_open_encode (compact_state_t *state, const swarmd_channel_open_t *value); | |
| 171 | ||
| 172 | int | |
| 173 | swarmd_channel_open_decode (compact_state_t *state, swarmd_channel_open_t *result); | |
| 174 | ||
| 175 | void | |
| 176 | swarmd_channel_open_destroy (swarmd_channel_open_t *result); | |
| 177 | ||
| 178 | // @swarmd/channel-ref | |
| 179 | typedef struct swarmd_channel_ref_s { | |
| 180 | uint64_t channel; | |
| 181 | } swarmd_channel_ref_t; | |
| 182 | ||
| 183 | int | |
| 184 | swarmd_channel_ref_preencode (compact_state_t *state, const swarmd_channel_ref_t *value); | |
| 185 | ||
| 186 | int | |
| 187 | swarmd_channel_ref_encode (compact_state_t *state, const swarmd_channel_ref_t *value); | |
| 188 | ||
| 189 | int | |
| 190 | swarmd_channel_ref_decode (compact_state_t *state, swarmd_channel_ref_t *result); | |
| 191 | ||
| 192 | void | |
| 193 | swarmd_channel_ref_destroy (swarmd_channel_ref_t *result); | |
| 194 | ||
| 195 | // @swarmd/send-request | |
| 196 | typedef struct swarmd_send_request_s { | |
| 197 | uint64_t channel; | |
| 198 | uint64_t slot; | |
| 199 | uint64_t target; | |
| 200 | uint8_t *bytes; /* borrows from decode buffer */ | |
| 201 | size_t bytes_len; | |
| 202 | } swarmd_send_request_t; | |
| 203 | ||
| 204 | int | |
| 205 | swarmd_send_request_preencode (compact_state_t *state, const swarmd_send_request_t *value); | |
| 206 | ||
| 207 | int | |
| 208 | swarmd_send_request_encode (compact_state_t *state, const swarmd_send_request_t *value); | |
| 209 | ||
| 210 | int | |
| 211 | swarmd_send_request_decode (compact_state_t *state, swarmd_send_request_t *result); | |
| 212 | ||
| 213 | void | |
| 214 | swarmd_send_request_destroy (swarmd_send_request_t *result); | |
| 215 | ||
| 216 | // @swarmd/send-result | |
| 217 | typedef struct swarmd_send_result_s { | |
| 218 | bool accepted; | |
| 219 | bool writable; | |
| 220 | } swarmd_send_result_t; | |
| 221 | ||
| 222 | int | |
| 223 | swarmd_send_result_preencode (compact_state_t *state, const swarmd_send_result_t *value); | |
| 224 | ||
| 225 | int | |
| 226 | swarmd_send_result_encode (compact_state_t *state, const swarmd_send_result_t *value); | |
| 227 | ||
| 228 | int | |
| 229 | swarmd_send_result_decode (compact_state_t *state, swarmd_send_result_t *result); | |
| 230 | ||
| 231 | void | |
| 232 | swarmd_send_result_destroy (swarmd_send_result_t *result); | |
| 233 | ||
| 234 | // @swarmd/path | |
| 235 | typedef struct swarmd_path_s { | |
| 236 | utf8_string_view_t path; /* borrows from decode buffer */ | |
| 237 | } swarmd_path_t; | |
| 238 | ||
| 239 | int | |
| 240 | swarmd_path_preencode (compact_state_t *state, const swarmd_path_t *value); | |
| 241 | ||
| 242 | int | |
| 243 | swarmd_path_encode (compact_state_t *state, const swarmd_path_t *value); | |
| 244 | ||
| 245 | int | |
| 246 | swarmd_path_decode (compact_state_t *state, swarmd_path_t *result); | |
| 247 | ||
| 248 | void | |
| 249 | swarmd_path_destroy (swarmd_path_t *result); | |
| 250 | ||
| 251 | // @swarmd/hash | |
| 252 | typedef struct swarmd_hash_s { | |
| 253 | uint8_t hash[32]; | |
| 254 | } swarmd_hash_t; | |
| 255 | ||
| 256 | int | |
| 257 | swarmd_hash_preencode (compact_state_t *state, const swarmd_hash_t *value); | |
| 258 | ||
| 259 | int | |
| 260 | swarmd_hash_encode (compact_state_t *state, const swarmd_hash_t *value); | |
| 261 | ||
| 262 | int | |
| 263 | swarmd_hash_decode (compact_state_t *state, swarmd_hash_t *result); | |
| 264 | ||
| 265 | void | |
| 266 | swarmd_hash_destroy (swarmd_hash_t *result); | |
| 267 | ||
| 268 | // @swarmd/content-serve | |
| 269 | typedef struct swarmd_content_serve_s { | |
| 270 | uint8_t hash[32]; | |
| 271 | utf8_string_view_t path; /* borrows from decode buffer */ | |
| 272 | } swarmd_content_serve_t; | |
| 273 | ||
| 274 | int | |
| 275 | swarmd_content_serve_preencode (compact_state_t *state, const swarmd_content_serve_t *value); | |
| 276 | ||
| 277 | int | |
| 278 | swarmd_content_serve_encode (compact_state_t *state, const swarmd_content_serve_t *value); | |
| 279 | ||
| 280 | int | |
| 281 | swarmd_content_serve_decode (compact_state_t *state, swarmd_content_serve_t *result); | |
| 282 | ||
| 283 | void | |
| 284 | swarmd_content_serve_destroy (swarmd_content_serve_t *result); | |
| 285 | ||
| 286 | // @swarmd/content-fetch | |
| 287 | typedef struct swarmd_content_fetch_s { | |
| 288 | uint8_t hash[32]; | |
| 289 | utf8_string_view_t dest_path; /* borrows from decode buffer */ | |
| 290 | } swarmd_content_fetch_t; | |
| 291 | ||
| 292 | int | |
| 293 | swarmd_content_fetch_preencode (compact_state_t *state, const swarmd_content_fetch_t *value); | |
| 294 | ||
| 295 | int | |
| 296 | swarmd_content_fetch_encode (compact_state_t *state, const swarmd_content_fetch_t *value); | |
| 297 | ||
| 298 | int | |
| 299 | swarmd_content_fetch_decode (compact_state_t *state, swarmd_content_fetch_t *result); | |
| 300 | ||
| 301 | void | |
| 302 | swarmd_content_fetch_destroy (swarmd_content_fetch_t *result); | |
| 303 | ||
| 304 | // @swarmd/content-cancel | |
| 305 | typedef struct swarmd_content_cancel_s { | |
| 306 | uint8_t hash[32]; | |
| 307 | bool discard; | |
| 308 | } swarmd_content_cancel_t; | |
| 309 | ||
| 310 | int | |
| 311 | swarmd_content_cancel_preencode (compact_state_t *state, const swarmd_content_cancel_t *value); | |
| 312 | ||
| 313 | int | |
| 314 | swarmd_content_cancel_encode (compact_state_t *state, const swarmd_content_cancel_t *value); | |
| 315 | ||
| 316 | int | |
| 317 | swarmd_content_cancel_decode (compact_state_t *state, swarmd_content_cancel_t *result); | |
| 318 | ||
| 319 | void | |
| 320 | swarmd_content_cancel_destroy (swarmd_content_cancel_t *result); | |
| 321 | ||
| 322 | // @swarmd/content-progress | |
| 323 | typedef struct swarmd_content_progress_s { | |
| 324 | uint8_t hash[32]; | |
| 325 | uint64_t received; | |
| 326 | uint64_t total; | |
| 327 | } swarmd_content_progress_t; | |
| 328 | ||
| 329 | int | |
| 330 | swarmd_content_progress_preencode (compact_state_t *state, const swarmd_content_progress_t *value); | |
| 331 | ||
| 332 | int | |
| 333 | swarmd_content_progress_encode (compact_state_t *state, const swarmd_content_progress_t *value); | |
| 334 | ||
| 335 | int | |
| 336 | swarmd_content_progress_decode (compact_state_t *state, swarmd_content_progress_t *result); | |
| 337 | ||
| 338 | void | |
| 339 | swarmd_content_progress_destroy (swarmd_content_progress_t *result); | |
| 340 | ||
| 341 | // @swarmd/content-done | |
| 342 | typedef struct swarmd_content_done_s { | |
| 343 | uint8_t hash[32]; | |
| 344 | utf8_string_view_t path; /* borrows from decode buffer */ | |
| 345 | } swarmd_content_done_t; | |
| 346 | ||
| 347 | int | |
| 348 | swarmd_content_done_preencode (compact_state_t *state, const swarmd_content_done_t *value); | |
| 349 | ||
| 350 | int | |
| 351 | swarmd_content_done_encode (compact_state_t *state, const swarmd_content_done_t *value); | |
| 352 | ||
| 353 | int | |
| 354 | swarmd_content_done_decode (compact_state_t *state, swarmd_content_done_t *result); | |
| 355 | ||
| 356 | void | |
| 357 | swarmd_content_done_destroy (swarmd_content_done_t *result); | |
| 358 | ||
| 359 | // @swarmd/content-failed | |
| 360 | typedef struct swarmd_content_failed_s { | |
| 361 | uint8_t hash[32]; | |
| 362 | utf8_string_view_t reason; /* borrows from decode buffer */ | |
| 363 | } swarmd_content_failed_t; | |
| 364 | ||
| 365 | int | |
| 366 | swarmd_content_failed_preencode (compact_state_t *state, const swarmd_content_failed_t *value); | |
| 367 | ||
| 368 | int | |
| 369 | swarmd_content_failed_encode (compact_state_t *state, const swarmd_content_failed_t *value); | |
| 370 | ||
| 371 | int | |
| 372 | swarmd_content_failed_decode (compact_state_t *state, swarmd_content_failed_t *result); | |
| 373 | ||
| 374 | void | |
| 375 | swarmd_content_failed_destroy (swarmd_content_failed_t *result); | |
| 376 | ||
| 377 | // @swarmd/peer-up | |
| 378 | typedef struct swarmd_peer_up_s { | |
| 379 | uint64_t peer; | |
| 380 | uint8_t pubkey[32]; | |
| 381 | } swarmd_peer_up_t; | |
| 382 | ||
| 383 | int | |
| 384 | swarmd_peer_up_preencode (compact_state_t *state, const swarmd_peer_up_t *value); | |
| 385 | ||
| 386 | int | |
| 387 | swarmd_peer_up_encode (compact_state_t *state, const swarmd_peer_up_t *value); | |
| 388 | ||
| 389 | int | |
| 390 | swarmd_peer_up_decode (compact_state_t *state, swarmd_peer_up_t *result); | |
| 391 | ||
| 392 | void | |
| 393 | swarmd_peer_up_destroy (swarmd_peer_up_t *result); | |
| 394 | ||
| 395 | // @swarmd/peer-down | |
| 396 | typedef struct swarmd_peer_down_s { | |
| 397 | uint64_t peer; | |
| 398 | } swarmd_peer_down_t; | |
| 399 | ||
| 400 | int | |
| 401 | swarmd_peer_down_preencode (compact_state_t *state, const swarmd_peer_down_t *value); | |
| 402 | ||
| 403 | int | |
| 404 | swarmd_peer_down_encode (compact_state_t *state, const swarmd_peer_down_t *value); | |
| 405 | ||
| 406 | int | |
| 407 | swarmd_peer_down_decode (compact_state_t *state, swarmd_peer_down_t *result); | |
| 408 | ||
| 409 | void | |
| 410 | swarmd_peer_down_destroy (swarmd_peer_down_t *result); | |
| 411 | ||
| 412 | // @swarmd/message | |
| 413 | typedef struct swarmd_message_s { | |
| 414 | uint64_t channel; | |
| 415 | uint64_t slot; | |
| 416 | uint64_t origin_kind; | |
| 417 | uint64_t origin_id; | |
| 418 | uint8_t *bytes; /* borrows from decode buffer */ | |
| 419 | size_t bytes_len; | |
| 420 | } swarmd_message_t; | |
| 421 | ||
| 422 | int | |
| 423 | swarmd_message_preencode (compact_state_t *state, const swarmd_message_t *value); | |
| 424 | ||
| 425 | int | |
| 426 | swarmd_message_encode (compact_state_t *state, const swarmd_message_t *value); | |
| 427 | ||
| 428 | int | |
| 429 | swarmd_message_decode (compact_state_t *state, swarmd_message_t *result); | |
| 430 | ||
| 431 | void | |
| 432 | swarmd_message_destroy (swarmd_message_t *result); | |
| 433 | ||
| 434 | #endif // SWARMD_SCHEMA_H |