/* vim: set expandtab ts=4 sw=4: */
/*
* You may redistribute this program and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation,
* either version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "client/AdminClient.h"
#include "benc/serialization/standard/BencMessageReader.h"
#include "benc/serialization/standard/BencMessageWriter.h"
#include "benc/serialization/cloner/Cloner.h"
#include "exception/Except.h"
#include "util/Bits.h"
#include "util/Endian.h"
#include "util/Hex.h"
#include "util/events/Timeout.h"
#include "util/Identity.h"
#include "wire/Message.h"
#include
#include
#include
struct Request;
typedef void (* AdminClient_RespHandler)(struct Request* req);
struct Request
{
struct AdminClient_Result res;
struct AdminClient_Promise* promise;
AdminClient_RespHandler callback;
struct Context* ctx;
struct Allocator* alloc;
/** Need a special allocator for the timeout so it can be axed before the request is complete */
struct Allocator* timeoutAlloc;
struct Timeout* timeout;
Dict* requestMessage;
/** the handle in the ctx->outstandingRequests map */
uint32_t handle;
Identity
};
#define Map_NAME OfRequestByHandle
#define Map_ENABLE_HANDLES
#define Map_VALUE_TYPE struct Request*
#include "util/Map.h"
struct Context
{
struct AdminClient pub;
struct EventBase* eventBase;
struct Iface addrIface;
struct Sockaddr* targetAddr;
struct Log* logger;
String* password;
struct Map_OfRequestByHandle outstandingRequests;
struct Allocator* alloc;
Identity
};
static int calculateAuth(Dict* message,
String* password,
String* cookieStr,
struct Allocator* alloc)
{
// Calculate the hash of the password.
String* hashHex = String_newBinary(NULL, 64, alloc);
uint8_t passAndCookie[64];
uint32_t cookie = (cookieStr != NULL) ? strtoll(cookieStr->bytes, NULL, 10) : 0;
snprintf((char*) passAndCookie, 64, "%s%u", password->bytes, cookie);
uint8_t hash[32];
crypto_hash_sha256(hash, passAndCookie, CString_strlen((char*) passAndCookie));
Hex_encode((uint8_t*)hashHex->bytes, 64, hash, 32);
Dict_putString(message, String_new("hash", alloc), hashHex, alloc);
Dict_putString(message, String_new("cookie", alloc), cookieStr, alloc);
// serialize the message with the password hash
struct Message* msg = Message_new(0, AdminClient_MAX_MESSAGE_SIZE, alloc);
BencMessageWriter_write(message, msg, NULL);
// calculate the hash of the message with the password hash
crypto_hash_sha256(hash, msg->bytes, msg->length);
// swap the hash of the message with the password hash into the location
// where the password hash was.
Hex_encode((uint8_t*)hashHex->bytes, 64, hash, 32);
return 0;
}
static void done(struct Request* req, enum AdminClient_Error err)
{
req->res.err = err;
req->callback(req);
Allocator_free(req->timeoutAlloc);
}
static void timeout(void* vreq)
{
done((struct Request*) vreq, AdminClient_Error_TIMEOUT);
}
static Iface_DEFUN receiveMessage(struct Message* msg, struct Iface* addrIface)
{
struct Context* ctx = Identity_containerOf(addrIface, struct Context, addrIface);
struct Sockaddr_storage source;
Message_pop(msg, &source, ctx->targetAddr->addrLen, NULL);
if (Bits_memcmp(&source, ctx->targetAddr, ctx->targetAddr->addrLen)) {
Log_info(ctx->logger, "Got spurious message from [%s], expecting messages from [%s]",
Sockaddr_print(&source.addr, msg->alloc),
Sockaddr_print(ctx->targetAddr, msg->alloc));
return NULL;
}
// we don't yet know with which message this data belongs,
// the message alloc lives the length of the message reception.
struct Allocator* alloc = Allocator_child(msg->alloc);
int origLen = msg->length;
Dict* d = NULL;
char* err = BencMessageReader_readNoExcept(msg, alloc, &d);
if (err) { return NULL; }
Message_shift(msg, origLen, NULL);
String* txid = Dict_getString(d, String_CONST("txid"));
if (!txid || txid->len != 8) { return NULL; }
// look up the result
uint32_t handle = ~0u;
Hex_decode((uint8_t*)&handle, 4, txid->bytes, 8);
int idx = Map_OfRequestByHandle_indexForHandle(handle, &ctx->outstandingRequests);
if (idx < 0) { return NULL; }
struct Request* req = ctx->outstandingRequests.values[idx];
// now this data will outlive the life of the message.
Allocator_adopt(req->promise->alloc, alloc);
req->res.responseDict = d;
int len =
(msg->length > AdminClient_MAX_MESSAGE_SIZE) ? AdminClient_MAX_MESSAGE_SIZE : msg->length;
Bits_memset(req->res.messageBytes, 0, AdminClient_MAX_MESSAGE_SIZE);
Bits_memcpy(req->res.messageBytes, msg->bytes, len);
done(req, AdminClient_Error_NONE);
return NULL;
}
static int requestOnFree(struct Allocator_OnFreeJob* job)
{
struct Request* req = Identity_check((struct Request*) job->userData);
int idx = Map_OfRequestByHandle_indexForHandle(req->handle, &req->ctx->outstandingRequests);
if (idx > -1) {
Map_OfRequestByHandle_remove(idx, &req->ctx->outstandingRequests);
}
return 0;
}
static struct Request* sendRaw(Dict* messageDict,
struct AdminClient_Promise* promise,
struct Context* ctx,
String* cookie,
AdminClient_RespHandler callback)
{
struct Allocator* reqAlloc = Allocator_child(promise->alloc);
struct Request* req = Allocator_clone(reqAlloc, (&(struct Request) {
.alloc = reqAlloc,
.ctx = ctx,
.promise = promise
}));
Identity_set(req);
int idx = Map_OfRequestByHandle_put(&req, &ctx->outstandingRequests);
req->handle = ctx->outstandingRequests.handles[idx];
String* id = String_newBinary(NULL, 8, req->alloc);
Hex_encode(id->bytes, 8, (int8_t*) &req->handle, 4);
Dict_putString(messageDict, String_CONST("txid"), id, req->alloc);
if (cookie) {
Assert_true(!calculateAuth(messageDict, ctx->password, cookie, req->alloc));
}
struct Allocator* child = Allocator_child(req->alloc);
struct Message* msg = Message_new(0, AdminClient_MAX_MESSAGE_SIZE + 256, child);
BencMessageWriter_write(messageDict, msg, NULL);
req->timeoutAlloc = Allocator_child(req->alloc);
req->timeout = Timeout_setTimeout(timeout,
req,
ctx->pub.millisecondsToWait,
ctx->eventBase,
req->timeoutAlloc);
Allocator_onFree(req->timeoutAlloc, requestOnFree, req);
req->callback = callback;
Message_push(msg, ctx->targetAddr, ctx->targetAddr->addrLen, NULL);
Iface_send(&ctx->addrIface, msg);
Allocator_free(child);
return req;
}
static void requestCallback(struct Request* req)
{
if (req->promise->callback) {
req->promise->callback(req->promise, &req->res);
}
Allocator_free(req->promise->alloc);
}
static void cookieCallback(struct Request* req)
{
if (req->res.err) {
requestCallback(req);
return;
}
String* cookie = Dict_getString(req->res.responseDict, String_CONST("cookie"));
if (!cookie) {
req->res.err = AdminClient_Error_NO_COOKIE;
requestCallback(req);
return;
}
Dict* message = req->requestMessage;
sendRaw(message, req->promise, req->ctx, cookie, requestCallback);
Allocator_free(req->alloc);
}
static struct AdminClient_Promise* doCall(Dict* message,
struct Context* ctx,
struct Allocator* alloc)
{
struct Allocator* promiseAlloc = Allocator_child(alloc);
struct AdminClient_Promise* promise =
Allocator_calloc(promiseAlloc, sizeof(struct AdminClient_Promise), 1);
promise->alloc = promiseAlloc;
Dict gc = Dict_CONST(String_CONST("q"), String_OBJ(String_CONST("cookie")), NULL);
struct Request* req = sendRaw(&gc, promise, ctx, NULL, cookieCallback);
req->requestMessage = Cloner_cloneDict(message, promiseAlloc);
return promise;
}
struct AdminClient_Promise* AdminClient_rpcCall(String* function,
Dict* args,
struct AdminClient* client,
struct Allocator* alloc)
{
struct Context* ctx = Identity_check((struct Context*) client);
Dict a = (args) ? *args : NULL;
Dict message = Dict_CONST(
String_CONST("q"), String_OBJ(String_CONST("auth")), Dict_CONST(
String_CONST("aq"), String_OBJ(function), Dict_CONST(
String_CONST("args"), Dict_OBJ(&a), NULL
)));
return doCall(&message, ctx, alloc);
}
char* AdminClient_errorString(enum AdminClient_Error err)
{
switch (err) {
case AdminClient_Error_NONE:
return "Success";
case AdminClient_Error_OVERLONG_RESPONSE:
return "Overlong resonse message";
case AdminClient_Error_ERROR_READING_FROM_SOCKET:
return "Error reading from socket, check errno.";
case AdminClient_Error_SOCKET_NOT_READY:
return "Socket not ready for reading";
case AdminClient_Error_DESERIALIZATION_FAILED:
return "Failed to deserialize response";
case AdminClient_Error_SERIALIZATION_FAILED:
return "Failed to serialize request";
case AdminClient_Error_TIMEOUT:
return "Timed out waiting for a response";
case AdminClient_Error_NO_COOKIE:
return "Cookie request returned with no cookie";
default:
return "Internal error";
};
}
struct AdminClient* AdminClient_new(struct AddrIface* ai,
struct Sockaddr* connectToAddress,
String* adminPassword,
struct EventBase* eventBase,
struct Log* logger,
struct Allocator* alloc)
{
struct Context* context = Allocator_clone(alloc, (&(struct Context) {
.eventBase = eventBase,
.logger = logger,
.password = adminPassword,
.pub = {
.millisecondsToWait = 5000,
},
.outstandingRequests = {
.allocator = alloc
},
.alloc = alloc
}));
context->addrIface.send = receiveMessage;
Identity_set(context);
context->targetAddr = Sockaddr_clone(connectToAddress, alloc);
if (Sockaddr_getFamily(context->targetAddr) == Sockaddr_AF_INET) {
uint8_t* addrBytes;
int len = Sockaddr_getAddress(context->targetAddr, &addrBytes);
if (Bits_isZero(addrBytes, len)) {
// 127.0.0.1
uint32_t loopback = Endian_hostToBigEndian32(0x7f000001);
Bits_memcpy(addrBytes, &loopback, 4);
}
}
Log_debug(logger, "Connecting to [%s]", Sockaddr_print(context->targetAddr, alloc));
Iface_plumb(&ai->iface, &context->addrIface);
return &context->pub;
}