1
0

IpTunnel_admin.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238
  1. /* vim: set expandtab ts=4 sw=4: */
  2. /*
  3. * You may redistribute this program and/or modify it under the terms of
  4. * the GNU General Public License as published by the Free Software Foundation,
  5. * either version 3 of the License, or (at your option) any later version.
  6. *
  7. * This program is distributed in the hope that it will be useful,
  8. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. * GNU General Public License for more details.
  11. *
  12. * You should have received a copy of the GNU General Public License
  13. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  14. */
  15. #include "admin/Admin.h"
  16. #include "benc/String.h"
  17. #include "benc/Int.h"
  18. #include "benc/Dict.h"
  19. #include "benc/List.h"
  20. #include "crypto/Key.h"
  21. #include "memory/Allocator.h"
  22. #include "tunnel/IpTunnel.h"
  23. #include "tunnel/IpTunnel_admin.h"
  24. #include "util/platform/Sockaddr.h"
  25. #include <stddef.h>
  26. struct Context
  27. {
  28. struct IpTunnel* ipTun;
  29. struct Admin* admin;
  30. };
  31. static void sendResponse(int conn, String* txid, struct Admin* admin)
  32. {
  33. Dict resp = Dict_CONST(
  34. String_CONST("connection"), Int_OBJ(conn), Dict_CONST(
  35. String_CONST("error"), String_OBJ(String_CONST("none")), NULL
  36. ));
  37. Admin_sendMessage(&resp, txid, admin);
  38. }
  39. static void sendError(char* error, String* txid, struct Admin* admin)
  40. {
  41. Dict resp = Dict_CONST(
  42. String_CONST("error"), String_OBJ(String_CONST(error)), NULL
  43. );
  44. Admin_sendMessage(&resp, txid, admin);
  45. }
  46. static void allowConnection(Dict* args,
  47. void* vcontext,
  48. String* txid,
  49. struct Allocator* requestAlloc)
  50. {
  51. struct Context* context = (struct Context*) vcontext;
  52. String* publicKeyOfAuthorizedNode =
  53. Dict_getString(args, String_CONST("publicKeyOfAuthorizedNode"));
  54. String* ip6Address = Dict_getString(args, String_CONST("ip6Address"));
  55. int64_t* ip6Prefix = Dict_getInt(args, String_CONST("ip6Prefix"));
  56. String* ip4Address = Dict_getString(args, String_CONST("ip4Address"));
  57. int64_t* ip4Prefix = Dict_getInt(args, String_CONST("ip4Prefix"));
  58. uint8_t pubKey[32];
  59. uint8_t ip6Addr[16];
  60. struct Sockaddr_storage ip6ToGive;
  61. struct Sockaddr_storage ip4ToGive;
  62. char* error;
  63. int ret;
  64. if (!ip6Address && !ip4Address) {
  65. error = "Must specify ip6Address or ip4Address";
  66. } else if ((ret = Key_parse(publicKeyOfAuthorizedNode, pubKey, ip6Addr)) != 0) {
  67. error = Key_parse_strerror(ret);
  68. } else if (ip6Prefix && !ip6Address) {
  69. error = "Must specify ip6Address with ip6Prefix";
  70. } else if (ip6Prefix && (*ip6Prefix > 128 || *ip6Prefix < 0)) {
  71. error = "ip6Prefix out of range: must be 0 to 128";
  72. } else if (ip4Prefix && (*ip4Prefix > 32 || *ip4Prefix < 0)) {
  73. error = "ip4Prefix out of range: must be 0 to 32";
  74. } else if (ip4Prefix && !ip4Address) {
  75. error = "Must specify ip4Address with ip4Prefix";
  76. } else if (ip6Address
  77. && (Sockaddr_parse(ip6Address->bytes, &ip6ToGive)
  78. || Sockaddr_getFamily(&ip6ToGive.addr) != Sockaddr_AF_INET6))
  79. {
  80. error = "malformed ip6Address";
  81. } else if (ip4Address
  82. && (Sockaddr_parse(ip4Address->bytes, &ip4ToGive)
  83. || Sockaddr_getFamily(&ip4ToGive.addr) != Sockaddr_AF_INET))
  84. {
  85. error = "malformed ip4Address";
  86. } else {
  87. int conn = IpTunnel_allowConnection(pubKey,
  88. (ip6Address) ? &ip6ToGive.addr : NULL,
  89. (ip6Prefix) ? (uint8_t) (*ip6Prefix) : 0,
  90. (ip4Address) ? &ip4ToGive.addr : NULL,
  91. (ip4Prefix) ? (uint8_t) (*ip4Prefix) : 0,
  92. context->ipTun);
  93. sendResponse(conn, txid, context->admin);
  94. return;
  95. }
  96. sendError(error, txid, context->admin);
  97. }
  98. static void connectTo(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
  99. {
  100. struct Context* context = vcontext;
  101. String* publicKeyOfNodeToConnectTo =
  102. Dict_getString(args, String_CONST("publicKeyOfNodeToConnectTo"));
  103. uint8_t pubKey[32];
  104. uint8_t ip6[16];
  105. int ret;
  106. if ((ret = Key_parse(publicKeyOfNodeToConnectTo, pubKey, ip6)) != 0) {
  107. sendError(Key_parse_strerror(ret), txid, context->admin);
  108. return;
  109. }
  110. int conn = IpTunnel_connectTo(pubKey, context->ipTun);
  111. sendResponse(conn, txid, context->admin);
  112. }
  113. static void removeConnection(Dict* args,
  114. void* vcontext,
  115. String* txid,
  116. struct Allocator* requestAlloc)
  117. {
  118. struct Context* context = vcontext;
  119. /*
  120. int conn = (int) *(Dict_getInt(args, String_CONST("connection")));
  121. char* error = "none";
  122. if (IpTunnel_removeConnection_NOT_FOUND == IpTunnel_removeConnection(conn, context->ipTun)) {
  123. error = "not found";
  124. }
  125. */
  126. sendError("not implemented", txid, context->admin);
  127. }
  128. static void listConnections(Dict* args,
  129. void* vcontext,
  130. String* txid,
  131. struct Allocator* alloc)
  132. {
  133. struct Context* context = vcontext;
  134. List* l = List_new(alloc);
  135. for (int i = 0; i < (int)context->ipTun->connectionList.count; i++) {
  136. List_addInt(l, context->ipTun->connectionList.connections[i].number, alloc);
  137. }
  138. Dict* resp = Dict_new(alloc);
  139. Dict_putList(resp, String_CONST("connections"), l, alloc);
  140. Dict_putString(resp, String_CONST("error"), String_CONST("none"), alloc);
  141. Admin_sendMessage(resp, txid, context->admin);
  142. }
  143. static void showConn(struct IpTunnel_Connection* conn,
  144. String* txid,
  145. struct Admin* admin,
  146. struct Allocator* alloc)
  147. {
  148. Dict* d = Dict_new(alloc);
  149. if (!Bits_isZero(conn->connectionIp6, 16)) {
  150. struct Sockaddr* addr = Sockaddr_clone(Sockaddr_LOOPBACK6, alloc);
  151. uint8_t* address;
  152. Assert_true(16 == Sockaddr_getAddress(addr, &address));
  153. Bits_memcpyConst(address, conn->connectionIp6, 16);
  154. char* printedAddr = Sockaddr_print(addr, alloc);
  155. Dict_putString(d, String_CONST("ip6Address"), String_CONST(printedAddr), alloc);
  156. Dict_putInt(d, String_CONST("ip6Prefix"), conn->connectionIp6Prefix, alloc);
  157. }
  158. if (!Bits_isZero(conn->connectionIp4, 4)) {
  159. struct Sockaddr* addr = Sockaddr_clone(Sockaddr_LOOPBACK, alloc);
  160. uint8_t* address;
  161. Assert_true(4 == Sockaddr_getAddress(addr, &address));
  162. Bits_memcpyConst(address, conn->connectionIp4, 4);
  163. char* printedAddr = Sockaddr_print(addr, alloc);
  164. Dict_putString(d, String_CONST("ip4Address"), String_CONST(printedAddr), alloc);
  165. Dict_putInt(d, String_CONST("ip4Prefix"), conn->connectionIp4Prefix, alloc);
  166. }
  167. Dict_putString(d, String_CONST("key"),
  168. Key_stringify(conn->routeHeader.publicKey, alloc), alloc);
  169. Dict_putInt(d, String_CONST("outgoing"), (conn->isOutgoing) ? 1 : 0, alloc);
  170. Dict_putString(d, String_CONST("error"), String_CONST("none"), alloc);
  171. Admin_sendMessage(d, txid, admin);
  172. }
  173. static void showConnection(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
  174. {
  175. struct Context* context = vcontext;
  176. int connNum = (int) *(Dict_getInt(args, String_CONST("connection")));
  177. for (int i = 0; i < (int)context->ipTun->connectionList.count; i++) {
  178. if (connNum == context->ipTun->connectionList.connections[i].number) {
  179. showConn(&context->ipTun->connectionList.connections[i], txid, context->admin, alloc);
  180. return;
  181. }
  182. }
  183. sendError("connection not found", txid, context->admin);
  184. }
  185. void IpTunnel_admin_register(struct IpTunnel* ipTun, struct Admin* admin, struct Allocator* alloc)
  186. {
  187. struct Context* context = Allocator_clone(alloc, (&(struct Context) {
  188. .admin = admin,
  189. .ipTun = ipTun
  190. }));
  191. Admin_registerFunction("IpTunnel_allowConnection", allowConnection, context, true,
  192. ((struct Admin_FunctionArg[]) {
  193. { .name = "publicKeyOfAuthorizedNode", .required = 1, .type = "String" },
  194. { .name = "ip6Address", .required = 0, .type = "String" },
  195. { .name = "ip6Prefix", .required = 0, .type = "Int" },
  196. { .name = "ip4Address", .required = 0, .type = "String" },
  197. { .name = "ip4Prefix", .required = 0, .type = "Int" },
  198. }), admin);
  199. Admin_registerFunction("IpTunnel_connectTo", connectTo, context, true,
  200. ((struct Admin_FunctionArg[]) {
  201. { .name = "publicKeyOfNodeToConnectTo", .required = 1, .type = "String" }
  202. }), admin);
  203. Admin_registerFunction("IpTunnel_removeConnection", removeConnection, context, true,
  204. ((struct Admin_FunctionArg[]) {
  205. { .name = "connection", .required = 1, .type = "Int" }
  206. }), admin);
  207. Admin_registerFunction("IpTunnel_showConnection", showConnection, context, true,
  208. ((struct Admin_FunctionArg[]) {
  209. { .name = "connection", .required = 1, .type = "Int" }
  210. }), admin);
  211. Admin_registerFunction("IpTunnel_listConnections", listConnections, context, true, NULL, admin);
  212. }