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, 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
uint8_t buffer[AdminClient_MAX_MESSAGE_SIZE];
struct Writer* writer = ArrayWriter_new(buffer, AdminClient_MAX_MESSAGE_SIZE, alloc);
if (StandardBencSerializer_get()->serializeDictionary(writer, message)) {
return -1;
}
int length = writer->bytesWritten;
// calculate the hash of the message with the password hash
crypto_hash_sha256(hash, buffer, 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;
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
gc_begin_func();
STRING(s1);
STRING(s2);
STRING(t);
bool s1t;
bool s2t;
s1 = String_new("hellp");
s2 = String_new("aello");
t = String_new("hello");
s1t = str_gt(s1,t);
if (s1t) {
gt_msg(s1,t);
}
else {
le_msg(s1,t);
}
s2t = str_gt(s2,t);
if (s2t) {
gt_msg(s2,t);
}
else {
le_msg(s2,t);
}
gc_end_func();
gc();
Heap_Info info = get_heap_info();
if ( info.live!=0 ) fprintf(stderr, "%d objects remain after collection\n", info.live);
gc_shutdown();
return 0;
}
void f() {
// var x = "cat" + "dog"
String *tmp1;
String *tmp2;
String *x = String_add(tmp1=String_new("cat"), tmp2=String_new("dog"));
// print(x)
print_string(x);
// print(x[1]+x[3])
String *tmp3;
String *tmp4;
String *tmp5;
print_string(
tmp5=String_add(
tmp3=String_from_char(x->str[(1)-1]),
tmp4=String_from_char(x->str[(3)-1])
)
);
// end of scope code; drop ref count by 1 for all [], string vars
DEREF(x);
DEREF(tmp1);
DEREF(tmp2);
DEREF(tmp3);
DEREF(tmp4);
DEREF(tmp5);
}
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 getSomething(Dict* args,
struct RouteGen_admin_Ctx* ctx,
String* txid,
struct Allocator* requestAlloc,
Dict* genRoutes)
{
int page = getIntVal(args, String_CONST("page"));
List* routes;
if (getIntVal(args, String_CONST("ip6"))) {
routes = Dict_getList(genRoutes, String_CONST("ipv6"));
} else {
routes = Dict_getList(genRoutes, String_CONST("ipv4"));
}
Assert_true(routes);
List* outList = List_new(requestAlloc);
bool more = false;
for (int i = page * ROUTES_PER_PAGE, j = 0; i < List_size(routes) && j < ROUTES_PER_PAGE; j++) {
String* route = List_getString(routes, i);
Assert_true(route);
List_addString(outList, route, requestAlloc);
if (++i >= List_size(routes)) {
more = false;
break;
}
more = true;
}
Dict* out = Dict_new(requestAlloc);
if (more) {
Dict_putInt(out, String_new("more", requestAlloc), 1, requestAlloc);
}
Dict_putList(out, String_new("routes", requestAlloc), outList, requestAlloc);
Admin_sendMessage(out, txid, ctx->admin);
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
print_string(becomeSuper(String_new("man")));
print_string(becomeSuper(String_new("duper")));
return 0;
}
Dict* Security_getUser(char* userName, struct Allocator* retAlloc)
{
Dict* ret = Dict_new(retAlloc);
Dict_putString(ret, String_new("error", retAlloc),
String_new("Not supported on windows", retAlloc),
retAlloc);
return ret;
}
static int set_device(Instance *pi, const char *value)
{
ALSAio_private *priv = (ALSAio_private *)pi;
int rc = 0;
int i;
String_free(&priv->c.device);
priv->c.device = String_new(value);
if (priv->c.handle) {
snd_pcm_close(priv->c.handle);
}
/* Try matching by description first... */
Range available_alsa_devices = {};
get_device_range(pi, &available_alsa_devices);
for (i=0; i < available_alsa_devices.descriptions.count; i++) {
if (strstr(available_alsa_devices.descriptions.items[i]->bytes, value)) {
puts("found it!");
priv->c.device = String_new(available_alsa_devices.strings.items[i]->bytes);
break;
}
}
Range_clear(&available_alsa_devices);
if (String_is_none(priv->c.device)) {
/* Not found, try value as supplied. */
priv->c.device = String_new(value);
}
rc = snd_pcm_open(&priv->c.handle, s(priv->c.device), priv->c.mode, 0);
if (rc < 0) {
fprintf(stderr, "*** snd_pcm_open %s: %s\n", s(priv->c.device), snd_strerror(rc));
goto out;
}
fprintf(stderr, "ALSA device %s opened, handle=%p\n", s(priv->c.device), priv->c.handle);
/* Allocate hardware parameter structure, and call "any", and use
the resulting hwparams in subsequent calls. I had tried calling
_any() in each get/set function, but recording failed, so it
seems ALSA doesn't work that way. */
snd_pcm_hw_params_malloc(&priv->c.hwparams);
rc = snd_pcm_hw_params_any(priv->c.handle, priv->c.hwparams);
/* Might as well set interleaved here, too. */
rc = snd_pcm_hw_params_set_access(priv->c.handle, priv->c.hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (rc != 0) {
fprintf(stderr, "*** snd_pcm_hw_params_set_access %s: %s\n", s(priv->c.device), snd_strerror(rc));
}
out:
return rc;
}
static Dict* makeLogMessage(struct Subscription* subscription,
struct AdminLog* logger,
enum Log_Level logLevel,
const char* fullFilePath,
uint32_t line,
const char* format,
va_list vaArgs,
struct Allocator* alloc)
{
time_t now;
time(&now);
Dict* out = Dict_new(alloc);
char* buff = Allocator_malloc(alloc, 20);
Hex_encode((uint8_t*)buff, 20, subscription->streamId, 8);
Dict_putString(out, String_new("streamId", alloc), String_new(buff, alloc), alloc);
Dict_putInt(out, String_new("time", alloc), now, alloc);
Dict_putString(out,
String_new("level", alloc),
String_new(Log_nameForLevel(logLevel), alloc),
alloc);
const char* shortName = getShortName(fullFilePath);
Dict_putString(out, String_new("file", alloc), String_new((char*)shortName, alloc), alloc);
Dict_putInt(out, String_new("line", alloc), line, alloc);
String* message = String_vprintf(alloc, format, vaArgs);
// Strip all of the annoying \n marks in the log entries.
if (message->len > 0 && message->bytes[message->len - 1] == '\n') {
message->len--;
}
Dict_putString(out, String_new("message", alloc), message, alloc);
return out;
}
static void adminPeerStats(Dict* args, void* vcontext, String* txid)
{
struct Context* context = vcontext;
struct Allocator* alloc = Allocator_child(context->alloc);
struct InterfaceController_peerStats* stats = NULL;
int64_t* page = Dict_getInt(args, String_CONST("page"));
int i = (page) ? *page * ENTRIES_PER_PAGE : 0;
int count = context->ic->getPeerStats(context->ic, alloc, &stats);
String* bytesIn = String_CONST("bytesIn");
String* bytesOut = String_CONST("bytesOut");
String* pubKey = String_CONST("publicKey");
String* state = String_CONST("state");
String* last = String_CONST("last");
String* switchLabel = String_CONST("switchLabel");
String* isIncoming = String_CONST("isIncoming");
List* list = NULL;
for (int counter=0; i < count && counter++ < ENTRIES_PER_PAGE; i++) {
Dict* d = Dict_new(alloc);
Dict_putInt(d, bytesIn, stats[i].bytesIn, alloc);
Dict_putInt(d, bytesOut, stats[i].bytesOut, alloc);
Dict_putString(d, pubKey, Key_stringify(stats[i].pubKey, alloc), alloc);
String* stateString = String_new(InterfaceController_stateString(stats[i].state), alloc);
Dict_putString(d, state, stateString, alloc);
Dict_putInt(d, last, stats[i].timeOfLastMessage, alloc);
uint8_t labelStack[20];
AddrTools_printPath(labelStack, stats[i].switchLabel);
Dict_putString(d, switchLabel, String_new((char*)labelStack, alloc), alloc);
Dict_putInt(d, isIncoming, stats[i].isIncomingConnection, alloc);
list = List_addDict(list, d, alloc);
}
Dict response = Dict_CONST(
String_CONST("peers"), List_OBJ(list), Dict_CONST(
String_CONST("total"), Int_OBJ(count), NULL
));
if (i < count) {
response = Dict_CONST(
String_CONST("more"), Int_OBJ(1), response
);
}
Admin_sendMessage(&response, txid, context->admin);
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 f()
{
ENTER();
STRING(x);
x = String_add(String_new("cat"),String_new("dog"));
REF((void *)x);
print_string(x);
print_string(String_add(String_from_char(x->str[(1)-1]),String_from_char(x->str[(3)-1])));
EXIT();
}
static void addRemoveSomething(Dict* args,
void* vcontext,
String* txid,
struct Allocator* requestAlloc,
enum addRemoveSomething_What what)
{
struct RouteGen_admin_Ctx* ctx = Identity_check((struct RouteGen_admin_Ctx*) vcontext);
String* route = Dict_getString(args, String_CONST("route"));
char* error = NULL;
struct Sockaddr_storage ss;
if (route->len > 63) {
error = "parse_failed";
}
if (!error) {
if (Sockaddr_parse(route->bytes, &ss)) {
error = "parse_failed";
} else {
int family = Sockaddr_getFamily(&ss.addr);
if (family != Sockaddr_AF_INET && family != Sockaddr_AF_INET6) {
error = "unexpected_af";
}
}
}
int retVal = -1;
Dict* out = Dict_new(requestAlloc);
if (!error) {
switch (what) {
case addRemoveSomething_What_ADD_EXCEPTION:
RouteGen_addException(ctx->rg, &ss.addr); break;
case addRemoveSomething_What_ADD_PREFIX:
RouteGen_addPrefix(ctx->rg, &ss.addr); break;
case addRemoveSomething_What_ADD_LOCALPREFIX:
RouteGen_addLocalPrefix(ctx->rg, &ss.addr); break;
case addRemoveSomething_What_RM_EXCEPTION:
retVal = RouteGen_removeException(ctx->rg, &ss.addr); break;
case addRemoveSomething_What_RM_PREFIX:
retVal = RouteGen_removePrefix(ctx->rg, &ss.addr); break;
case addRemoveSomething_What_RM_LOCALPREFIX:
retVal = RouteGen_removeLocalPrefix(ctx->rg, &ss.addr); break;
default: Assert_failure("invalid op");
}
if (!retVal) {
error = "no_such_route";
} else {
error = "none";
}
}
Dict_putString(out,
String_new("error", requestAlloc),
String_new(error, requestAlloc),
requestAlloc);
Admin_sendMessage(out, txid, ctx->admin);
}
static void sessionStats(Dict* args,
void* vcontext,
String* txid,
struct Allocator* alloc)
{
struct Context* context = Identity_check((struct Context*) vcontext);
int64_t* handleP = Dict_getInt(args, String_CONST("handle"));
uint32_t handle = *handleP;
struct SessionManager_Session* session = SessionManager_sessionForHandle(handle, context->sm);
Dict* r = Dict_new(alloc);
if (!session) {
Dict_putString(r, String_CONST("error"), String_CONST("no such session"), alloc);
Admin_sendMessage(r, txid, context->admin);
return;
}
uint8_t printedAddr[40];
AddrTools_printIp(printedAddr, session->caSession->herIp6);
Dict_putString(r, String_CONST("ip6"), String_new(printedAddr, alloc), alloc);
String* state =
String_new(CryptoAuth_stateString(CryptoAuth_getState(session->caSession)), alloc);
Dict_putString(r, String_CONST("state"), state, alloc);
struct ReplayProtector* rp = &session->caSession->replayProtector;
Dict_putInt(r, String_CONST("duplicates"), rp->duplicates, alloc);
Dict_putInt(r, String_CONST("lostPackets"), rp->lostPackets, alloc);
Dict_putInt(r, String_CONST("receivedOutOfRange"), rp->receivedOutOfRange, alloc);
struct Address addr;
Bits_memcpyConst(addr.key, session->caSession->herPublicKey, 32);
addr.path = session->sendSwitchLabel;
addr.protocolVersion = session->version;
Dict_putString(r, String_CONST("addr"), Address_toString(&addr, alloc), alloc);
Dict_putString(r, String_CONST("publicKey"),
Key_stringify(session->caSession->herPublicKey, alloc), alloc);
Dict_putInt(r, String_CONST("version"), session->version, alloc);
Dict_putInt(r, String_CONST("handle"), session->receiveHandle, alloc);
Dict_putInt(r, String_CONST("sendHandle"), session->sendHandle, alloc);
Dict_putInt(r, String_CONST("timeOfLastIn"), session->timeOfLastIn, alloc);
Dict_putInt(r, String_CONST("timeOfLastOut"), session->timeOfLastOut, alloc);
Dict_putString(r, String_CONST("deprecation"),
String_CONST("publicKey,version will soon be removed"), alloc);
Admin_sendMessage(r, txid, context->admin);
return;
}
static void showActiveSearch(Dict* args, void* vctx, String* txid, struct Allocator* alloc)
{
struct Context* ctx = Identity_check((struct Context*) vctx);
int number = *(Dict_getIntC(args, "number"));
struct SearchRunner_SearchData* search =
SearchRunner_showActiveSearch(ctx->runner, number, alloc);
Dict* dict = Dict_new(alloc);
// Nothing is an error
Dict_putString(dict, String_new("error", alloc), String_new("none", alloc), alloc);
if (number < search->activeSearches) {
uint8_t target[40];
AddrTools_printIp(target, search->target);
Dict_putString(dict, String_new("target", alloc), String_new((char*)target, alloc), alloc);
uint8_t lastNodeAsked[60];
Address_print(lastNodeAsked, &search->lastNodeAsked);
Dict_putString(dict,
String_new("lastNodeAsked", alloc),
String_new((char*)lastNodeAsked, alloc),
alloc);
Dict_putInt(dict, String_new("totalRequests", alloc), search->totalRequests, alloc);
}
Dict_putInt(dict, String_new("activeSearches", alloc), search->activeSearches, alloc);
Admin_sendMessage(dict, txid, ctx->admin);
}
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);
}
}
static void sessionStats(Dict* args,
void* vcontext,
String* txid,
struct Allocator* alloc)
{
struct Context* context = vcontext;
int64_t* handleP = Dict_getInt(args, String_CONST("handle"));
uint32_t handle = *handleP;
struct SessionManager_Session* session = SessionManager_sessionForHandle(handle, context->sm);
uint8_t* ip6 = SessionManager_getIp6(handle, context->sm);
Dict* r = Dict_new(alloc);
if (!session) {
Dict_putString(r, String_CONST("error"), String_CONST("no such session"), alloc);
Admin_sendMessage(r, txid, context->admin);
return;
}
// both or neither
Assert_true(ip6);
uint8_t printedAddr[40];
AddrTools_printIp(printedAddr, ip6);
Dict_putString(r, String_CONST("ip6"), String_new(printedAddr, alloc), alloc);
Dict_putString(r,
String_CONST("state"),
String_new(CryptoAuth_stateString(session->cryptoAuthState), alloc),
alloc);
struct ReplayProtector* rp = CryptoAuth_getReplayProtector(session->internal);
Dict_putInt(r, String_CONST("duplicates"), rp->duplicates, alloc);
Dict_putInt(r, String_CONST("lostPackets"), rp->lostPackets, alloc);
Dict_putInt(r, String_CONST("receivedOutOfRange"), rp->receivedOutOfRange, alloc);
uint8_t* key = CryptoAuth_getHerPublicKey(session->internal);
Dict_putString(r, String_CONST("publicKey"), Key_stringify(key, alloc), alloc);
Dict_putInt(r, String_CONST("version"), session->version, alloc);
Dict_putInt(r, String_CONST("handle"),
Endian_bigEndianToHost32(session->receiveHandle_be), alloc);
Dict_putInt(r, String_CONST("sendHandle"),
Endian_bigEndianToHost32(session->sendHandle_be), alloc);
Dict_putInt(r, String_CONST("timeOfLastIn"), session->timeOfLastIn, alloc);
Dict_putInt(r, String_CONST("timeOfLastOut"), session->timeOfLastOut, alloc);
Admin_sendMessage(r, txid, context->admin);
return;
}
int main(int ____c, char *____v[])
{
setup_error_handlers();
int x;
bool y;
x = 5;
y = foo(x);
if (y) {
print_string(String_new("happy"));
}
else {
print_string(String_new("sad"));
}
return 0;
}
static void adminPingOnResponse(struct SwitchPinger_Response* resp, void* vping)
{
struct Allocator* pingAlloc = resp->ping->pingAlloc;
struct Ping* ping = vping;
Dict* rd = Dict_new(pingAlloc);
if (resp->res == SwitchPinger_Result_LABEL_MISMATCH) {
uint8_t path[20] = {0};
AddrTools_printPath(path, resp->label);
String* pathStr = String_new(path, pingAlloc);
Dict_putString(rd, String_CONST("rpath"), pathStr, pingAlloc);
}
Dict_putInt(rd, String_CONST("version"), resp->version, pingAlloc);
Dict_putInt(rd, String_CONST("ms"), resp->milliseconds, pingAlloc);
Dict_putString(rd, String_CONST("result"), SwitchPinger_resultString(resp->res), pingAlloc);
Dict_putString(rd, String_CONST("path"), ping->path, pingAlloc);
if (resp->data) {
Dict_putString(rd, String_CONST("data"), resp->data, pingAlloc);
}
if (!Bits_isZero(resp->key, 32)) {
Dict_putString(rd, String_CONST("key"), Key_stringify(resp->key, pingAlloc), pingAlloc);
}
Admin_sendMessage(rd, ping->txid, ping->context->admin);
}
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 void tunInterface(Dict* ifaceConf, struct Allocator* tempAlloc, struct Context* ctx)
{
String* ifaceType = Dict_getString(ifaceConf, String_CONST("type"));
if (!String_equals(ifaceType, String_CONST("TUNInterface"))) {
return;
}
// Setup the interface.
String* tunfd = Dict_getString(ifaceConf, String_CONST("tunfd"));
String* device = Dict_getString(ifaceConf, String_CONST("tunDevice"));
Dict* args = Dict_new(tempAlloc);
if (tunfd && device) {
Dict_putString(args, String_CONST("path"), device, tempAlloc);
Dict_putString(args, String_CONST("type"),
String_new(tunfd->bytes, tempAlloc), tempAlloc);
Dict* res = NULL;
rpcCall0(String_CONST("FileNo_import"), args, ctx, tempAlloc, &res, false);
if (res) {
Dict* args = Dict_new(tempAlloc);
int64_t* tunfd = Dict_getInt(res, String_CONST("tunfd"));
int64_t* type = Dict_getInt(res, String_CONST("type"));
Dict_putInt(args, String_CONST("tunfd"), *tunfd, tempAlloc);
Dict_putInt(args, String_CONST("type"), *type, tempAlloc);
rpcCall0(String_CONST("Core_initTunfd"), args, ctx, tempAlloc, NULL, false);
}
} else {
if (device) {
Dict_putString(args, String_CONST("desiredTunName"), device, tempAlloc);
}
rpcCall0(String_CONST("Core_initTunnel"), args, ctx, tempAlloc, NULL, false);
}
}
void le_msg(String * s,String * t)
{
gc_begin_func();
print_string(String_add(String_add(s,String_new(" is less than or equal to ")),t));
gc_end_func();
}
void gt_msg(String * s,String * t)
{
gc_begin_func();
print_string(String_add(String_add(s,String_new(" is greater than ")),t));
gc_end_func();
}
String *String_from_float(double value) {
char *s = calloc(20, sizeof(char));
char buf[50];
sprintf(buf,"%1.2f",value);
strcat(s, buf);
return String_new(s);
}
struct CryptoAuth_Session* CryptoAuth_newSession(struct CryptoAuth* ca,
struct Allocator* alloc,
const uint8_t herPublicKey[32],
const uint8_t herIp6[16],
const bool requireAuth,
char* displayName)
{
struct CryptoAuth_pvt* context = Identity_check((struct CryptoAuth_pvt*) ca);
struct CryptoAuth_Session_pvt* session =
Allocator_calloc(alloc, sizeof(struct CryptoAuth_Session_pvt), 1);
Identity_set(session);
session->context = context;
session->requireAuth = requireAuth;
session->pub.displayName = String_new(displayName, alloc);
session->timeOfLastPacket = Time_currentTimeSeconds(context->eventBase);
session->alloc = alloc;
if (herPublicKey != NULL) {
Bits_memcpyConst(session->pub.herPublicKey, herPublicKey, 32);
uint8_t calculatedIp6[16];
AddressCalc_addressForPublicKey(calculatedIp6, herPublicKey);
Bits_memcpyConst(session->pub.herIp6, calculatedIp6, 16);
if (herIp6 != NULL) {
Assert_true(!Bits_memcmp(calculatedIp6, herIp6, 16));
}
} else if (herIp6) {
Bits_memcpyConst(session->pub.herIp6, herIp6, 16);
}
return &session->pub;
}
static void checkRunningInstance(struct Allocator* allocator,
struct EventBase* base,
String* addr,
String* password,
struct Log* logger,
struct Except* eh)
{
struct Allocator* alloc = Allocator_child(allocator);
struct Sockaddr_storage pingAddrStorage;
if (Sockaddr_parse(addr->bytes, &pingAddrStorage)) {
Except_raise(eh, -1, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234",
addr->bytes);
}
struct AdminClient* adminClient =
AdminClient_new(&pingAddrStorage.addr, password, base, logger, alloc);
// 100 milliseconds is plenty to wait for a process to respond on the same machine.
adminClient->millisecondsToWait = 100;
Dict* pingArgs = Dict_new(alloc);
struct AdminClient_Result* pingResult =
AdminClient_rpcCall(String_new("ping", alloc), pingArgs, adminClient, alloc);
if (pingResult->err == AdminClient_Error_NONE) {
Except_raise(eh, -1, "Startup failed: cjdroute is already running.");
}
Allocator_free(alloc);
}
int32_t CryptoAuth_addUser(String* password,
uint8_t authType,
String* user,
struct CryptoAuth* ca)
{
struct CryptoAuth_pvt* context = Identity_check((struct CryptoAuth_pvt*) ca);
if (authType != 1) {
return CryptoAuth_addUser_INVALID_AUTHTYPE;
}
if (context->passwordCount == context->passwordCapacity) {
// TODO(cjd): realloc password space and increase buffer.
return CryptoAuth_addUser_OUT_OF_SPACE;
}
struct CryptoAuth_Auth a;
hashPassword_sha256(&a, password);
for (uint32_t i = 0; i < context->passwordCount; i++) {
if (!Bits_memcmp(a.secret, context->passwords[i].secret, 32) ||
String_equals(user, context->passwords[i].user)) {
return CryptoAuth_addUser_DUPLICATE;
}
}
a.user = String_new(user->bytes, context->allocator);
Bits_memcpyConst(&context->passwords[context->passwordCount],
&a,
sizeof(struct CryptoAuth_Auth));
context->passwordCount++;
return 0;
}
char *test_print()
{
object = Object_new();
Object_print(object);
Object_destroy(object);
object = True_new();
Object_print(object);
Object_destroy_immortal(object);
object = False_new();
Object_print(object);
Object_destroy_immortal(object);
object = Nil_new();
Object_print(object);
Object_destroy_immortal(object);
object = Integer_new(123);
Object_print(object);
Object_destroy(object);
bstring hello = bfromcstr("hello");
object = String_new(hello);
Object_print(object);
Object_destroy(object);
return NULL;
}
void
State_bootstrap(STATE)
{
DArray *filenames = kernel_files(state);
int count = DArray_count(filenames);
// Expose toplevel constants
expose_VM(state, state->lobby);
int reenable_debugger = 0;
// Disable debugger while loading kernel files
if(Debug) {
reenable_debugger = 1;
Debug = 0;
}
// Load all files.
for(int i=0; i < count; i++) {
bstring filename = (bstring)DArray_at(filenames, i);
bstring path = bfromcstr("kernel/");
bconcat(path, filename);
Primitive_require(state, String_new(state, bdata(path)), NULL, NULL);
bdestroy(path);
bdestroy(filename);
}
DArray_destroy(filenames);
// Reenable debugger if needed
if(reenable_debugger) Debug = 1;
}
MenuEntry* MenuEntry_new(String* text, WindowMouseclickHandler click_action) {
MenuEntry* menu_entry;
if(!(menu_entry = (MenuEntry*)malloc(sizeof(MenuEntry))))
return menu_entry;
if(!(Window_init((Window*)menu_entry, 0, 0, 100, 14, WIN_NORAISE | WIN_NODECORATION, (Context*)0))) {
Object_delete((Object*)menu_entry);
return (MenuEntry*)0;
}
Object_init((Object*)menu_entry, MenuEntry_delete_function);
if(!(menu_entry->text = String_new(text->buf))) {
Object_delete((Object*)menu_entry);
return (MenuEntry*)0;
}
menu_entry->mouse_over = 0;
menu_entry->window.paint_function = MenuEntry_paint_handler;
menu_entry->window.mouseclick_function = click_action;
menu_entry->window.mouseover_function = MenuEntry_mouseover_handler;
menu_entry->window.mouseout_function = MenuEntry_mouseout_handler;
return menu_entry;
}
