static void sendFirstMessageToCore(void* vcontext)
{
struct NodeContext* ctx = Identity_check((struct NodeContext*) vcontext);
struct Allocator* alloc = Allocator_child(ctx->alloc);
struct Message* msg = Message_new(0, 512, alloc);
Dict* d = Dict_new(alloc);
Dict_putString(d, String_CONST("privateKey"), String_new(ctx->privateKeyHex, alloc), alloc);
Dict* logging = Dict_new(alloc);
{
Dict_putString(logging, String_CONST("logTo"), String_CONST("stdout"), alloc);
}
Dict_putDict(d, String_CONST("logging"), logging, alloc);
Dict* admin = Dict_new(alloc);
{
Dict_putString(admin, String_CONST("bind"), ctx->bind, alloc);
Dict_putString(admin, String_CONST("pass"), ctx->pass, alloc);
}
Dict_putDict(d, String_CONST("admin"), admin, alloc);
BencMessageWriter_write(d, msg, NULL);
Iface_send(&ctx->angelIface, msg);
Allocator_free(alloc);
}
static String* getExpectedResponse(struct Sockaddr* sa4, int prefix4, int alloc4,
struct Sockaddr* sa6, int prefix6, int alloc6,
struct Allocator* allocator)
{
Assert_true(alloc6 >= prefix6);
Assert_true(alloc4 >= prefix4);
struct Allocator* alloc = Allocator_child(allocator);
Dict* addresses = Dict_new(alloc);
if (sa4) {
uint8_t* addr = NULL;
Assert_true(Sockaddr_getAddress(sa4, &addr) == 4);
String* addrStr = String_newBinary(addr, 4, alloc);
Dict_putString(addresses, String_new("ip4", alloc), addrStr, alloc);
Dict_putInt(addresses, String_new("ip4Prefix", alloc), prefix4, alloc);
Dict_putInt(addresses, String_new("ip4Alloc", alloc), alloc4, alloc);
}
if (sa6) {
uint8_t* addr = NULL;
Assert_true(Sockaddr_getAddress(sa6, &addr) == 16);
String* addrStr = String_newBinary(addr, 16, alloc);
Dict_putString(addresses, String_new("ip6", alloc), addrStr, alloc);
Dict_putInt(addresses, String_new("ip6Prefix", alloc), prefix6, alloc);
Dict_putInt(addresses, String_new("ip6Alloc", alloc), alloc6, alloc);
}
Dict* output = Dict_new(alloc);
Dict_putDict(output, String_new("addresses", alloc), addresses, alloc);
Dict_putString(output, String_new("txid", alloc), String_new("abcd", alloc), alloc);
struct Message* msg = Message_new(0, 512, alloc);
BencMessageWriter_write(output, msg, NULL);
String* outStr = String_newBinary(msg->bytes, msg->length, allocator);
Allocator_free(alloc);
return outStr;
}
void Admin_registerFunctionWithArgCount(char* name,
Admin_FUNCTION(callback),
void* callbackContext,
bool needsAuth,
struct Admin_FunctionArg* arguments,
int argCount,
struct Admin* admin)
{
if (!admin) {
return;
}
String* str = String_new(name, admin->allocator);
if (!admin->functionCount) {
admin->functions = admin->allocator->malloc(sizeof(struct Function), admin->allocator);
} else {
admin->functions =
admin->allocator->realloc(admin->functions,
sizeof(struct Function) * (admin->functionCount + 1),
admin->allocator);
}
struct Function* fu = &admin->functions[admin->functionCount];
admin->functionCount++;
fu->name = str;
fu->call = callback;
fu->context = callbackContext;
fu->needsAuth = needsAuth;
fu->args = Dict_new(admin->allocator);
for (int i = 0; arguments && i < argCount; i++) {
// "type" must be one of: [ "String", "Int", "Dict", "List" ]
String* type = NULL;
if (!strcmp(arguments[i].type, STRING->bytes)) {
type = STRING;
} else if (!strcmp(arguments[i].type, INT->bytes)) {
type = INT;
} else if (!strcmp(arguments[i].type, DICT->bytes)) {
type = DICT;
} else if (!strcmp(arguments[i].type, LIST->bytes)) {
type = LIST;
} else {
abort();
}
Dict* arg = Dict_new(admin->allocator);
Dict_putString(arg, TYPE, type, admin->allocator);
Dict_putInt(arg, REQUIRED, arguments[i].required, admin->allocator);
String* name = String_new(arguments[i].name, admin->allocator);
Dict_putDict(fu->args, name, arg, admin->allocator);
}
}
int main(int argc, char** argv)
{
#ifdef Log_KEYS
fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n");
#endif
Assert_true(argc > 0);
struct Except* eh = NULL;
// Allow it to allocate 4MB
struct Allocator* allocator = MallocAllocator_new(1<<22);
struct Random* rand = Random_new(allocator, NULL, eh);
struct EventBase* eventBase = EventBase_new(allocator);
if (argc == 2) {
// one argument
if (strcmp(argv[1], "--help") == 0) {
return usage(argv[0]);
} else if (strcmp(argv[1], "--genconf") == 0) {
return genconf(rand);
} else if (strcmp(argv[1], "--pidfile") == 0) {
// Performed after reading the configuration
} else if (strcmp(argv[1], "--reconf") == 0) {
// Performed after reading the configuration
} else if (strcmp(argv[1], "--bench") == 0) {
return benchmark();
} else if (strcmp(argv[1], "--version") == 0) {
//printf("Version ID: %s\n", RouterModule_gitVersion());
return 0;
} else {
fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]);
fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
return -1;
}
} else if (argc > 2) {
// more than one argument?
fprintf(stderr, "%s: too many arguments\n", argv[0]);
fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
return -1;
}
if (isatty(STDIN_FILENO)) {
// We were started from a terminal
// The chances an user wants to type in a configuration
// bij hand are pretty slim so we show him the usage
return usage(argv[0]);
} else {
// We assume stdin is a configuration file and that we should
// start routing
}
struct Reader* stdinReader = FileReader_new(stdin, allocator);
Dict config;
if (JsonBencSerializer_get()->parseDictionary(stdinReader, allocator, &config)) {
fprintf(stderr, "Failed to parse configuration.\n");
return -1;
}
struct Writer* logWriter = FileWriter_new(stdout, allocator);
struct Log* logger = WriterLog_new(logWriter, allocator);
// --------------------- Setup Pipes to Angel --------------------- //
int pipeToAngel[2];
int pipeFromAngel[2];
if (Pipe_createUniPipe(pipeToAngel) || Pipe_createUniPipe(pipeFromAngel)) {
Except_raise(eh, -1, "Failed to create pipes to angel [%s]", Errno_getString());
}
char pipeToAngelStr[8];
snprintf(pipeToAngelStr, 8, "%d", pipeToAngel[0]);
char pipeFromAngelStr[8];
snprintf(pipeFromAngelStr, 8, "%d", pipeFromAngel[1]);
char* args[] = { "angel", pipeToAngelStr, pipeFromAngelStr, NULL };
// --------------------- Spawn Angel --------------------- //
String* privateKey = Dict_getString(&config, String_CONST("privateKey"));
String* corePath = getCorePath(allocator);
if (!corePath) {
Except_raise(eh, -1, "Can't find a usable cjdns core executable, "
"make sure it is in the same directory as cjdroute");
}
if (!privateKey) {
Except_raise(eh, -1, "Need to specify privateKey.");
}
Log_info(logger, "Forking angel to background.");
Process_spawn(corePath->bytes, args);
// --------------------- Get Admin --------------------- //
Dict* configAdmin = Dict_getDict(&config, String_CONST("admin"));
String* adminPass = Dict_getString(configAdmin, String_CONST("password"));
String* adminBind = Dict_getString(configAdmin, String_CONST("bind"));
if (!adminPass) {
adminPass = String_newBinary(NULL, 32, allocator);
Random_base32(rand, (uint8_t*) adminPass->bytes, 32);
adminPass->len = strlen(adminPass->bytes);
}
if (!adminBind) {
adminBind = String_new("127.0.0.1:0", allocator);
}
// --------------------- Get user for angel to setuid() ---------------------- //
String* securityUser = NULL;
List* securityConf = Dict_getList(&config, String_CONST("security"));
for (int i = 0; i < List_size(securityConf); i++) {
securityUser = Dict_getString(List_getDict(securityConf, i), String_CONST("setuser"));
if (securityUser) {
int64_t* ea = Dict_getInt(List_getDict(securityConf, i), String_CONST("exemptAngel"));
if (ea && *ea) {
securityUser = NULL;
}
break;
}
}
// --------------------- Pre-Configure Angel ------------------------- //
Dict* preConf = Dict_new(allocator);
Dict* adminPreConf = Dict_new(allocator);
Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator);
Dict_putString(adminPreConf, String_CONST("core"), corePath, allocator);
Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator);
Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator);
Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator);
if (securityUser) {
Dict_putString(adminPreConf, String_CONST("user"), securityUser, allocator);
}
#define CONFIG_BUFF_SIZE 1024
uint8_t buff[CONFIG_BUFF_SIZE] = {0};
struct Writer* toAngelWriter = ArrayWriter_new(buff, CONFIG_BUFF_SIZE - 1, allocator);
if (StandardBencSerializer_get()->serializeDictionary(toAngelWriter, preConf)) {
Except_raise(eh, -1, "Failed to serialize pre-configuration");
}
write(pipeToAngel[1], buff, toAngelWriter->bytesWritten(toAngelWriter));
Log_keys(logger, "Sent [%s] to angel process.", buff);
// --------------------- Get Response from Angel --------------------- //
uint32_t amount = Waiter_getData(buff, CONFIG_BUFF_SIZE, pipeFromAngel[0], eventBase, eh);
Dict responseFromAngel;
struct Reader* responseFromAngelReader = ArrayReader_new(buff, amount, allocator);
if (StandardBencSerializer_get()->parseDictionary(responseFromAngelReader,
allocator,
&responseFromAngel))
{
Except_raise(eh, -1, "Failed to parse pre-configuration response [%s]", buff);
}
// --------------------- Get Admin Addr/Port/Passwd --------------------- //
Dict* responseFromAngelAdmin = Dict_getDict(&responseFromAngel, String_CONST("admin"));
adminBind = Dict_getString(responseFromAngelAdmin, String_CONST("bind"));
if (!adminBind) {
Except_raise(eh, -1, "didn't get address and port back from angel");
}
struct Sockaddr_storage adminAddr;
if (Sockaddr_parse(adminBind->bytes, &adminAddr)) {
Except_raise(eh, -1, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234",
adminBind->bytes);
}
// sanity check
Assert_true(EventBase_eventCount(eventBase) == 0);
// --------------------- Configuration ------------------------- //
Configurator_config(&config,
&adminAddr.addr,
adminPass,
eventBase,
logger,
allocator);
return 0;
}
int main(int argc, char** argv)
{
#ifdef Log_KEYS
fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n");
#endif
if (argc < 2) {
// Fall through.
} else if (!CString_strcmp("angel", argv[1])) {
return AngelInit_main(argc, argv);
} else if (!CString_strcmp("core", argv[1])) {
return Core_main(argc, argv);
}
Assert_ifParanoid(argc > 0);
struct Except* eh = NULL;
// Allow it to allocate 8MB
struct Allocator* allocator = MallocAllocator_new(1<<23);
struct Random* rand = Random_new(allocator, NULL, eh);
struct EventBase* eventBase = EventBase_new(allocator);
if (argc == 2) {
// one argument
if ((CString_strcmp(argv[1], "--help") == 0) || (CString_strcmp(argv[1], "-h") == 0)) {
return usage(allocator, argv[0]);
} else if (CString_strcmp(argv[1], "--genconf") == 0) {
return genconf(rand);
} else if (CString_strcmp(argv[1], "--pidfile") == 0) {
// deprecated
fprintf(stderr, "'--pidfile' option is deprecated.\n");
return 0;
} else if (CString_strcmp(argv[1], "--reconf") == 0) {
// Performed after reading the configuration
} else if (CString_strcmp(argv[1], "--bench") == 0) {
return benchmark();
} else if ((CString_strcmp(argv[1], "--version") == 0)
|| (CString_strcmp(argv[1], "-v") == 0))
{
printf("Cjdns protocol version: %d\n", Version_CURRENT_PROTOCOL);
return 0;
} else if (CString_strcmp(argv[1], "--cleanconf") == 0) {
// Performed after reading configuration
} else if (CString_strcmp(argv[1], "--nobg") == 0) {
// Performed while reading configuration
} else {
fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]);
fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
return -1;
}
} else if (argc > 2) {
// more than one argument?
fprintf(stderr, "%s: too many arguments [%s]\n", argv[0], argv[1]);
fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]);
// because of '--pidfile $filename'?
if (CString_strcmp(argv[1], "--pidfile") == 0)
{
fprintf(stderr, "\n'--pidfile' option is deprecated.\n");
}
return -1;
}
if (isatty(STDIN_FILENO)) {
// We were started from a terminal
// The chances an user wants to type in a configuration
// bij hand are pretty slim so we show him the usage
return usage(allocator, argv[0]);
} else {
// We assume stdin is a configuration file and that we should
// start routing
}
struct Reader* stdinReader = FileReader_new(stdin, allocator);
Dict config;
if (JsonBencSerializer_get()->parseDictionary(stdinReader, allocator, &config)) {
fprintf(stderr, "Failed to parse configuration.\n");
return -1;
}
if (argc == 2 && CString_strcmp(argv[1], "--cleanconf") == 0) {
struct Writer* stdoutWriter = FileWriter_new(stdout, allocator);
JsonBencSerializer_get()->serializeDictionary(stdoutWriter, &config);
printf("\n");
return 0;
}
int forceNoBackground = 0;
if (argc == 2 && CString_strcmp(argv[1], "--nobg") == 0) {
forceNoBackground = 1;
}
struct Writer* logWriter = FileWriter_new(stdout, allocator);
struct Log* logger = WriterLog_new(logWriter, allocator);
// --------------------- Get Admin --------------------- //
Dict* configAdmin = Dict_getDict(&config, String_CONST("admin"));
String* adminPass = Dict_getString(configAdmin, String_CONST("password"));
String* adminBind = Dict_getString(configAdmin, String_CONST("bind"));
if (!adminPass) {
adminPass = String_newBinary(NULL, 32, allocator);
Random_base32(rand, (uint8_t*) adminPass->bytes, 32);
adminPass->len = CString_strlen(adminPass->bytes);
}
if (!adminBind) {
Except_throw(eh, "You must specify admin.bind in the cjdroute.conf file.");
}
// --------------------- Welcome to cjdns ---------------------- //
char* archInfo = ArchInfo_describe(ArchInfo_detect(), allocator);
char* sysInfo = SysInfo_describe(SysInfo_detect(), allocator);
Log_info(logger, "Cjdns %s %s", archInfo, sysInfo);
// --------------------- Check for running instance --------------------- //
Log_info(logger, "Checking for running instance...");
checkRunningInstance(allocator, eventBase, adminBind, adminPass, logger, eh);
// --------------------- Setup Pipes to Angel --------------------- //
char angelPipeName[64] = "client-angel-";
Random_base32(rand, (uint8_t*)angelPipeName+13, 31);
Assert_ifParanoid(EventBase_eventCount(eventBase) == 0);
struct Pipe* angelPipe = Pipe_named(angelPipeName, eventBase, eh, allocator);
Assert_ifParanoid(EventBase_eventCount(eventBase) == 2);
angelPipe->logger = logger;
char* args[] = { "angel", angelPipeName, NULL };
// --------------------- Spawn Angel --------------------- //
String* privateKey = Dict_getString(&config, String_CONST("privateKey"));
char* corePath = Process_getPath(allocator);
if (!corePath) {
Except_throw(eh, "Can't find a usable cjdns core executable, "
"make sure it is in the same directory as cjdroute");
}
if (!privateKey) {
Except_throw(eh, "Need to specify privateKey.");
}
Log_info(logger, "Forking angel to background.");
Process_spawn(corePath, args, eventBase, allocator);
// --------------------- Get user for angel to setuid() ---------------------- //
String* securityUser = NULL;
List* securityConf = Dict_getList(&config, String_CONST("security"));
for (int i = 0; securityConf && i < List_size(securityConf); i++) {
securityUser = Dict_getString(List_getDict(securityConf, i), String_CONST("setuser"));
if (securityUser) {
int64_t* ea = Dict_getInt(List_getDict(securityConf, i), String_CONST("exemptAngel"));
if (ea && *ea) {
securityUser = NULL;
}
break;
}
}
// --------------------- Pre-Configure Angel ------------------------- //
Dict* preConf = Dict_new(allocator);
Dict* adminPreConf = Dict_new(allocator);
Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator);
Dict_putString(adminPreConf, String_CONST("core"), String_new(corePath, allocator), allocator);
Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator);
Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator);
Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator);
if (securityUser) {
Dict_putString(adminPreConf, String_CONST("user"), securityUser, allocator);
}
Dict* logging = Dict_getDict(&config, String_CONST("logging"));
if (logging) {
Dict_putDict(preConf, String_CONST("logging"), logging, allocator);
}
struct Message* toAngelMsg = Message_new(0, 1024, allocator);
BencMessageWriter_write(preConf, toAngelMsg, eh);
Interface_sendMessage(&angelPipe->iface, toAngelMsg);
Log_debug(logger, "Sent [%d] bytes to angel process", toAngelMsg->length);
// --------------------- Get Response from Angel --------------------- //
struct Message* fromAngelMsg =
InterfaceWaiter_waitForData(&angelPipe->iface, eventBase, allocator, eh);
Dict* responseFromAngel = BencMessageReader_read(fromAngelMsg, allocator, eh);
// --------------------- Get Admin Addr/Port/Passwd --------------------- //
Dict* responseFromAngelAdmin = Dict_getDict(responseFromAngel, String_CONST("admin"));
adminBind = Dict_getString(responseFromAngelAdmin, String_CONST("bind"));
if (!adminBind) {
Except_throw(eh, "didn't get address and port back from angel");
}
struct Sockaddr_storage adminAddr;
if (Sockaddr_parse(adminBind->bytes, &adminAddr)) {
Except_throw(eh, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234",
adminBind->bytes);
}
// sanity check, Pipe_named() creates 2 events, see above.
Assert_ifParanoid(EventBase_eventCount(eventBase) == 2);
// --------------------- Configuration ------------------------- //
Configurator_config(&config,
&adminAddr.addr,
adminPass,
eventBase,
logger,
allocator);
// --------------------- noBackground ------------------------ //
int64_t* noBackground = Dict_getInt(&config, String_CONST("noBackground"));
if (forceNoBackground || (noBackground && *noBackground)) {
EventBase_beginLoop(eventBase);
}
//Allocator_free(allocator);
return 0;
}
static void handleRequestFromChild(struct Admin* admin,
union Admin_TxidPrefix* txid_prefix,
Dict* message,
uint8_t* buffer,
size_t amount,
struct Allocator* allocator)
{
String* query = Dict_getString(message, CJDHTConstants_QUERY);
if (!query) {
Log_info(admin->logger,
"Got a non-query from admin interface on channel [%u].",
admin->messageHeader.channelNum);
adminChannelClose(admin, admin->messageHeader.channelNum);
return;
}
// txid becomes the user supplied txid combined with the inter-process txid.
String* userTxid = Dict_getString(message, TXID);
uint32_t txidlen = ((userTxid) ? userTxid->len : 0) + Admin_TxidPrefix_SIZE;
String* txid = String_newBinary(NULL, txidlen, allocator);
Bits_memcpyConst(txid->bytes, txid_prefix->raw, Admin_TxidPrefix_SIZE);
if (userTxid) {
Bits_memcpy(txid->bytes + Admin_TxidPrefix_SIZE, userTxid->bytes, userTxid->len);
}
// If they're asking for a cookie then lets give them one.
String* cookie = String_CONST("cookie");
if (String_equals(query, cookie)) {
Dict* d = Dict_new(allocator);
char bytes[32];
snprintf(bytes, 32, "%u", (uint32_t) Time_currentTimeSeconds(admin->eventBase));
String* theCookie = &(String) { .len = strlen(bytes), .bytes = bytes };
Dict_putString(d, cookie, theCookie, allocator);
Admin_sendMessage(d, txid, admin);
return;
}
// If this is a permitted query, make sure the cookie is right.
String* auth = String_CONST("auth");
bool authed = false;
if (String_equals(query, auth)) {
if (!authValid(message, buffer, amount, admin)) {
Dict* d = Dict_new(allocator);
Dict_putString(d, String_CONST("error"), String_CONST("Auth failed."), allocator);
Admin_sendMessage(d, txid, admin);
return;
}
query = Dict_getString(message, String_CONST("aq"));
authed = true;
}
Dict* args = Dict_getDict(message, String_CONST("args"));
bool noFunctionsCalled = true;
for (int i = 0; i < admin->functionCount; i++) {
if (String_equals(query, admin->functions[i].name)
&& (authed || !admin->functions[i].needsAuth))
{
if (checkArgs(args, &admin->functions[i], txid, admin)) {
admin->functions[i].call(args, admin->functions[i].context, txid);
}
noFunctionsCalled = false;
}
}
if (noFunctionsCalled) {
Dict* d = Dict_new(allocator);
Dict_putString(d,
String_CONST("error"),
String_CONST("No functions matched your request."),
allocator);
Dict* functions = Dict_new(allocator);
for (int i = 0; i < admin->functionCount; i++) {
Dict_putDict(functions, admin->functions[i].name, admin->functions[i].args, allocator);
}
if (functions) {
Dict_putDict(d, String_CONST("availableFunctions"), functions, allocator);
}
Admin_sendMessage(d, txid, admin);
return;
}
return;
}
static void handleRequestFromChild(struct Admin* admin,
uint8_t buffer[MAX_API_REQUEST_SIZE],
size_t amount,
struct Allocator* allocator)
{
struct Reader* reader = ArrayReader_new(buffer + TXID_LEN, amount - TXID_LEN, allocator);
Dict message;
if (StandardBencSerializer_get()->parseDictionary(reader, allocator, &message)) {
Log_info(admin->logger, "Got unparsable data from admin interface.");
return;
}
String* query = Dict_getString(&message, CJDHTConstants_QUERY);
if (!query) {
Log_info(admin->logger, "Got a non-query from admin interface.");
return;
}
// txid becomes the user supplied txid combined with the inter-process txid.
String* userTxid = Dict_getString(&message, TXID);
String* txid =
String_newBinary((char*)buffer, ((userTxid) ? userTxid->len : 0) + TXID_LEN, allocator);
if (userTxid) {
Bits_memcpy(txid->bytes + TXID_LEN, userTxid->bytes, userTxid->len);
}
// If they're asking for a cookie then lets give them one.
String* cookie = String_CONST("cookie");
if (String_equals(query, cookie)) {
Dict* d = Dict_new(allocator);
char bytes[32];
snprintf(bytes, 32, "%u", (uint32_t) Time_currentTimeSeconds(admin->eventBase));
String* theCookie = &(String) { .len = strlen(bytes), .bytes = bytes };
Dict_putString(d, cookie, theCookie, allocator);
Admin_sendMessage(d, txid, admin);
return;
}
// If this is a permitted query, make sure the cookie is right.
String* auth = String_CONST("auth");
bool authed = false;
if (String_equals(query, auth)) {
if (!authValid(&message, buffer + TXID_LEN, reader->bytesRead(reader), admin)) {
Dict* d = Dict_new(allocator);
Dict_putString(d, String_CONST("error"), String_CONST("Auth failed."), allocator);
Admin_sendMessage(d, txid, admin);
return;
}
query = Dict_getString(&message, String_CONST("aq"));
authed = true;
}
Dict* args = Dict_getDict(&message, String_CONST("args"));
bool noFunctionsCalled = true;
for (int i = 0; i < admin->functionCount; i++) {
if (String_equals(query, admin->functions[i].name)
&& (authed || !admin->functions[i].needsAuth))
{
if (checkArgs(args, &admin->functions[i], txid, admin)) {
admin->functions[i].call(args, admin->functions[i].context, txid);
}
noFunctionsCalled = false;
}
}
if (noFunctionsCalled) {
Dict* d = Dict_new(allocator);
Dict_putString(d,
String_CONST("error"),
String_CONST("No functions matched your request."),
allocator);
Dict* functions = Dict_new(allocator);
for (int i = 0; i < admin->functionCount; i++) {
Dict_putDict(functions, admin->functions[i].name, admin->functions[i].args, allocator);
}
if (functions) {
Dict_putDict(d, String_CONST("availableFunctions"), functions, allocator);
}
Admin_sendMessage(d, txid, admin);
return;
}
return;
}
static void dumpTable_addEntries(struct Context* ctx,
int i,
int j,
struct List_Item* last,
String* txid)
{
uint8_t path[20];
uint8_t ip[40];
String* pathStr = &(String) { .len = 19, .bytes = (char*)path };
String* ipStr = &(String) { .len = 39, .bytes = (char*)ip };
Object* link = Int_OBJ(0xFFFFFFFF);
Object* version = Int_OBJ(Version_DEFAULT_ASSUMPTION);
Dict entry = Dict_CONST(
String_CONST("ip"), String_OBJ(ipStr), Dict_CONST(
String_CONST("link"), link, Dict_CONST(
String_CONST("path"), String_OBJ(pathStr), Dict_CONST(
String_CONST("version"), version, NULL
))));
struct List_Item next = { .next = last, .elem = Dict_OBJ(&entry) };
if (i >= ctx->store->size || j >= ENTRIES_PER_PAGE) {
if (i > j) {
dumpTable_send(ctx, last, (j >= ENTRIES_PER_PAGE), txid);
return;
}
Address_printIp(ip, ctx->store->selfAddress);
strcpy((char*)path, "0000.0000.0000.0001");
version->as.number = Version_CURRENT_PROTOCOL;
dumpTable_send(ctx, &next, (j >= ENTRIES_PER_PAGE), txid);
return;
}
struct Node* n = NodeStore_dumpTable(ctx->store, i);
link->as.number = n->reach;
version->as.number = n->version;
Address_printIp(ip, &n->address);
AddrTools_printPath(path, n->address.path);
dumpTable_addEntries(ctx, i + 1, j + 1, &next, txid);
}
static void dumpTable(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
int64_t* page = Dict_getInt(args, String_CONST("page"));
int i = (page) ? *page * ENTRIES_PER_PAGE : 0;
dumpTable_addEntries(ctx, i, 0, NULL, txid);
}
static bool isOneHop(struct Node_Link* link)
{
struct EncodingScheme* ps = link->parent->encodingScheme;
int num = EncodingScheme_getFormNum(ps, link->cannonicalLabel);
Assert_always(num > -1 && num < ps->count);
return EncodingScheme_formSize(&ps->forms[num]) == Bits_log2x64(link->cannonicalLabel);
}
static void getLink(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
Dict* ret = Dict_new(alloc);
Dict* result = Dict_new(alloc);
Dict_putDict(ret, String_new("result", alloc), result, alloc);
Dict_putString(ret, String_new("error", alloc), String_new("none", alloc), alloc);
struct Node_Link* link;
String* ipStr = Dict_getString(args, String_new("parent", alloc));
int64_t* linkNum = Dict_getInt(args, String_new("linkNum", alloc));
uint8_t ip[16];
if (ipStr->len != 39 || AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("Could not parse ip", alloc),
alloc);
} else if ((link = NodeStore_getLink(ctx->store, ip, *linkNum))) {
Dict_putInt(result,
String_new("inverseLinkEncodingFormNumber", alloc),
link->inverseLinkEncodingFormNumber,
alloc);
Dict_putInt(result, String_new("linkState", alloc), link->linkState, alloc);
Dict_putInt(result, String_new("isOneHop", alloc), isOneHop(link), alloc);
String* cannonicalLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(cannonicalLabel->bytes, link->cannonicalLabel);
Dict_putString(result, String_new("cannonicalLabel", alloc), cannonicalLabel, alloc);
String* parent = String_newBinary(NULL, 39, alloc);
AddrTools_printIp(parent->bytes, link->parent->address.ip6.bytes);
Dict_putString(result, String_new("parent", alloc), parent, alloc);
String* child = String_newBinary(NULL, 39, alloc);
AddrTools_printIp(child->bytes, link->child->address.ip6.bytes);
Dict_putString(result, String_new("child", alloc), child, alloc);
}
Admin_sendMessage(ret, txid, ctx->admin);
}
static void getNode(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
Dict* ret = Dict_new(alloc);
Dict* result = Dict_new(alloc);
Dict_putDict(ret, String_new("result", alloc), result, alloc);
Dict_putString(ret, String_new("error", alloc), String_new("none", alloc), alloc);
// no ipStr specified --> return self-node
struct Node_Two* node = ctx->store->selfNode;
String* ipStr = Dict_getString(args, String_new("ip", alloc));
uint8_t ip[16];
while (ipStr) {
if (ipStr->len != 39 || AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("Could not parse ip", alloc),
alloc);
} else if (!(node = NodeStore_getNode2(ctx->store, ip))) {
// not found
} else {
break;
}
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
Dict_putInt(result, String_new("protocolVersion", alloc), node->version, alloc);
String* key = Key_stringify(node->address.key, alloc);
Dict_putString(result, String_new("key", alloc), key, alloc);
uint32_t linkCount = NodeStore_linkCount(node);
Dict_putInt(result, String_new("linkCount", alloc), linkCount, alloc);
List* encScheme = EncodingScheme_asList(node->encodingScheme, alloc);
Dict_putList(result, String_new("encodingScheme", alloc), encScheme, alloc);
Admin_sendMessage(ret, txid, ctx->admin);
}
static void getRouteLabel(Dict* args, void* vcontext, String* txid, struct Allocator* requestAlloc)
{
struct Context* ctx = Identity_cast((struct Context*) vcontext);
char* err = NULL;
String* pathToParentS = Dict_getString(args, String_CONST("pathToParent"));
uint64_t pathToParent;
if (pathToParentS->len != 19) {
err = "pathToParent incorrect length";
} else if (AddrTools_parsePath(&pathToParent, pathToParentS->bytes)) {
err = "Failed to parse pathToParent";
}
String* childAddressS = Dict_getString(args, String_CONST("childAddress"));
uint8_t childAddress[16];
if (childAddressS->len != 39) {
err = "childAddress of incorrect length, must be a 39 character full ipv6 address";
} else if (AddrTools_parseIp(childAddress, childAddressS->bytes)) {
err = "Failed to parse childAddress";
}
uint64_t label = UINT64_MAX;
if (!err) {
label = NodeStore_getRouteLabel(ctx->store, pathToParent, childAddress);
err = NodeStore_getRouteLabel_strerror(label);
}
Dict* response = Dict_new(requestAlloc);
if (!err) {
String* printedPath = String_newBinary(NULL, 19, requestAlloc);
AddrTools_printPath(printedPath->bytes, label);
Dict_putString(response, String_new("result", requestAlloc), printedPath, requestAlloc);
Dict_putString(response,
String_new("error", requestAlloc),
String_new("none", requestAlloc),
requestAlloc);
Admin_sendMessage(response, txid, ctx->admin);
} else {
Dict_putString(response,
String_new("error", requestAlloc),
String_new(err, requestAlloc),
requestAlloc);
Admin_sendMessage(response, txid, ctx->admin);
}
}
void NodeStore_admin_register(struct NodeStore* nodeStore,
struct Admin* admin,
struct Allocator* alloc)
{
struct Context* ctx = Allocator_clone(alloc, (&(struct Context) {
.admin = admin,
.alloc = alloc,
.store = nodeStore
}));
Identity_set(ctx);
Admin_registerFunction("NodeStore_dumpTable", dumpTable, ctx, false,
((struct Admin_FunctionArg[]) {
{ .name = "page", .required = 1, .type = "Int" },
}), admin);
Admin_registerFunction("NodeStore_getLink", getLink, ctx, true,
((struct Admin_FunctionArg[]) {
{ .name = "parent", .required = 1, .type = "String" },
{ .name = "linkNum", .required = 1, .type = "Int" },
}), admin);
int main(int argc, char** argv)
{
Assert_ifParanoid(argc > 0);
struct Allocator* allocator = MallocAllocator_new(1<<23);
if (argc != 6 || (argc == 2 &&
(!(CString_strcmp(argv[1], "--help") == 0) || (CString_strcmp(argv[1], "-h") == 0)))) {
return usage(allocator, argv[0]);
}
struct Except* eh = NULL;
struct EventBase* eventBase = EventBase_new(allocator);
struct Log* logger = FileWriterLog_new(stdout, allocator);
String* privateKey = String_new(argv[3], allocator);
String* adminBind = String_new(argv[4], allocator);
String* adminPass = String_new(argv[5], allocator);
String* logTo = String_new("stdout", allocator);
// --------------------- Welcome to cjdns ---------------------- //
char* sysInfo = SysInfo_describe(SysInfo_detect(), allocator);
Log_info(logger, "Cjdns %s %s", ArchInfo_getArchStr(), sysInfo);
// --------------------- Setup Pipes to Angel --------------------- //
struct Allocator* corePipeAlloc = Allocator_child(allocator);
String* corePipeDir = String_new(argv[1], allocator);
String* corePipeName = String_new(argv[2], allocator);
if (!Defined(win32) && access(corePipeDir->bytes, W_OK)) {
Except_throw(eh, "Don't have write permission to [%s].", corePipeDir->bytes);
}
Assert_ifParanoid(EventBase_eventCount(eventBase) == 0);
struct Pipe* corePipe = Pipe_named(corePipeDir->bytes, corePipeName->bytes,
eventBase, eh, corePipeAlloc);
Assert_ifParanoid(EventBase_eventCount(eventBase) == 2);
corePipe->logger = logger;
// --------------------- Pre-Configure Core ------------------------- //
Dict* preConf = Dict_new(allocator);
Dict* adminPreConf = Dict_new(allocator);
Dict* logPreConf = Dict_new(allocator);
Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator);
Dict_putDict(preConf, String_CONST("logging"), logPreConf, allocator);
Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator);
Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator);
Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator);
Dict_putString(logPreConf, String_CONST("logTo"), logTo, allocator);
struct Message* toCoreMsg = Message_new(0, 1024, allocator);
BencMessageWriter_write(preConf, toCoreMsg, eh);
Iface_CALL(corePipe->iface.send, toCoreMsg, &corePipe->iface);
Log_debug(logger, "Sent [%d] bytes to core.", toCoreMsg->length);
// --------------------- Get Response from Core --------------------- //
struct Message* fromCoreMsg =
InterfaceWaiter_waitForData(&corePipe->iface, eventBase, allocator, eh);
Dict* responseFromCore = BencMessageReader_read(fromCoreMsg, allocator, eh);
// --------------------- Close the Core Pipe --------------------- //
Allocator_free(corePipeAlloc);
corePipe = NULL;
// --------------------- Get Admin Addr/Port/Passwd --------------------- //
Dict* responseFromCoreAdmin = Dict_getDict(responseFromCore, String_CONST("admin"));
adminBind = Dict_getString(responseFromCoreAdmin, String_CONST("bind"));
if (!adminBind) {
Except_throw(eh, "Didn't get ADMIN_BIND back from cjdroute.");
}
struct Sockaddr_storage adminAddr;
if (Sockaddr_parse(adminBind->bytes, &adminAddr)) {
Except_throw(eh, "Unable to parse [%s] as an IP address:port.",
adminBind->bytes);
}
Assert_ifParanoid(EventBase_eventCount(eventBase) == 0);
Log_info(logger, "Admin API ready at [%s].", adminBind->bytes);
return 0;
}
static void nodeForAddr(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_check((struct Context*) vcontext);
Dict* ret = Dict_new(alloc);
Dict* result = Dict_new(alloc);
Dict_putDict(ret, String_new("result", alloc), result, alloc);
Dict_putString(ret, String_new("error", alloc), String_new("none", alloc), alloc);
// no ipStr specified --> return self-node
struct Node_Two* node = ctx->store->selfNode;
String* ipStr = Dict_getString(args, String_new("ip", alloc));
uint8_t ip[16];
while (ipStr) {
if (AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("parse_ip", alloc),
alloc);
} else if (!(node = NodeStore_nodeForAddr(ctx->store, ip))) {
// not found
} else {
break;
}
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
Dict_putInt(result, String_new("protocolVersion", alloc), node->address.protocolVersion, alloc);
String* key = Key_stringify(node->address.key, alloc);
Dict_putString(result, String_new("key", alloc), key, alloc);
uint32_t count = linkCount(node);
Dict_putInt(result, String_new("linkCount", alloc), count, alloc);
Dict_putInt(result, String_new("cost", alloc), Node_getCost(node), alloc);
List* encScheme = EncodingScheme_asList(node->encodingScheme, alloc);
Dict_putList(result, String_new("encodingScheme", alloc), encScheme, alloc);
Dict* bestParent = Dict_new(alloc);
String* parentIp = String_newBinary(NULL, 39, alloc);
AddrTools_printIp(parentIp->bytes, Node_getBestParent(node)->parent->address.ip6.bytes);
Dict_putString(bestParent, String_CONST("ip"), parentIp, alloc);
String* parentChildLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(parentChildLabel->bytes, Node_getBestParent(node)->cannonicalLabel);
Dict_putString(bestParent, String_CONST("parentChildLabel"), parentChildLabel, alloc);
int isOneHop = Node_isOneHopLink(Node_getBestParent(node));
Dict_putInt(bestParent, String_CONST("isOneHop"), isOneHop, alloc);
Dict_putDict(result, String_CONST("bestParent"), bestParent, alloc);
String* bestLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(bestLabel->bytes, node->address.path);
Dict_putString(result, String_CONST("routeLabel"), bestLabel, alloc);
Admin_sendMessage(ret, txid, ctx->admin);
}
static void getLink(Dict* args, void* vcontext, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_check((struct Context*) vcontext);
Dict* ret = Dict_new(alloc);
Dict* result = Dict_new(alloc);
Dict_putDict(ret, String_new("result", alloc), result, alloc);
Dict_putString(ret, String_new("error", alloc), String_new("none", alloc), alloc);
struct Node_Link* link = NULL;
struct Node_Two* node = NULL;
String* ipStr = Dict_getString(args, String_new("parent", alloc));
int64_t* linkNum = Dict_getInt(args, String_new("linkNum", alloc));
if (ipStr && ipStr->len) {
uint8_t ip[16];
if (AddrTools_parseIp(ip, ipStr->bytes)) {
Dict_remove(ret, String_CONST("result"));
Dict_putString(ret,
String_new("error", alloc),
String_new("parse_parent", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
} else if (!(node = NodeStore_nodeForAddr(ctx->store, ip))) {
Dict_putString(ret,
String_new("error", alloc),
String_new("not_found", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
} else if (!(link = getLinkByNum(node, *linkNum))) {
Dict_putString(ret,
String_new("error", alloc),
String_new("unknown", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
} else {
for (int i = 0; i <= *linkNum; i++) {
link = NodeStore_getNextLink(ctx->store, link);
if (!link) { break; }
}
if (!link) {
Dict_putString(ret,
String_new("error", alloc),
String_new("not_found", alloc),
alloc);
Admin_sendMessage(ret, txid, ctx->admin);
return;
}
}
Dict_putInt(result,
String_new("inverseLinkEncodingFormNumber", alloc),
link->inverseLinkEncodingFormNumber,
alloc);
Dict_putInt(result, String_new("linkCost", alloc), link->linkCost, alloc);
Dict_putInt(result, String_new("isOneHop", alloc), Node_isOneHopLink(link), alloc);
int bestParent = (Node_getBestParent(link->child) == link);
Dict_putInt(result, String_new("bestParent", alloc), bestParent, alloc);
String* cannonicalLabel = String_newBinary(NULL, 19, alloc);
AddrTools_printPath(cannonicalLabel->bytes, link->cannonicalLabel);
Dict_putString(result, String_new("cannonicalLabel", alloc), cannonicalLabel, alloc);
String* parent = Address_toString(&link->parent->address, alloc);
Dict_putString(result, String_new("parent", alloc), parent, alloc);
String* child = Address_toString(&link->child->address, alloc);
Dict_putString(result, String_new("child", alloc), child, alloc);
Admin_sendMessage(ret, txid, ctx->admin);
}
