0x30EB2530FC4525C12Fa0A09f1edf4f861356F276

PZY3C

0x4a2F07EeD9F5727359c310cE099ca48179B8446B

fee refund

Ignore

Ignore

fee refund

fee refund

0x82857BFB831201443790404dBa3f691644F13eC6

tcf

cs

0x1F51020A6d3b6575F920C5606976D60b5F1627D7

0x4DE84985D5b4365d057C6Bc64361F092494D00B0

fee refund

tcf

fee refund

0xA0344e1020Ebe2D567D15357343474F401224382

fee refund

fee refund

fee refund

fee refund

0xD7D84c077A10f2A6Ab534C235405F62F702192cf

#include <stdio.h>
#include <string.h>
#include <time.h>

#define STORAGE_FILE "data.bin"
#define STORAGE_DIR "/var/lib/resilience"

char storage_path[1024];

/*
* FIPS 180-2 SHA-224/256/384/512 implementation
* Last update: 02/02/2007
* Issue date: 04/30/2005
*
* Copyright (C) 2013, Con Kolivas <[email protected]>
* Copyright (C) 2005, 2007 Olivier Gay <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <stdint.h>

#define SHA256_DIGEST_SIZE ( 256 / 8)
#define SHA256_BLOCK_SIZE ( 512 / 8)

#define SHFR(x, n) (x >> n)
#define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
#define CH(x, y, z) ((x & y) ^ (~x & z))
#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))

#define SHA256_F1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define SHA256_F2(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define SHA256_F3(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHFR(x, 3))
#define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))

typedef struct {
unsigned int tot_len;
unsigned int len;
unsigned char block[2 * SHA256_BLOCK_SIZE];
uint32_t h[8];
} sha256_ctx;

#define UNPACK32(x, str) \
{ \
*((str) + 3) = (uint8_t) ((x) ); \
*((str) + 2) = (uint8_t) ((x) >> 8); \
*((str) + 1) = (uint8_t) ((x) >> 16); \
*((str) + 0) = (uint8_t) ((x) >> 24); \
}

#define PACK32(str, x) \
{ \
*(x) = ((uint32_t) *((str) + 3) ) \
| ((uint32_t) *((str) + 2) << 8) \
| ((uint32_t) *((str) + 1) << 16) \
| ((uint32_t) *((str) + 0) << 24); \
}

#define SHA256_SCR(i) \
{ \
w[i] = SHA256_F4(w[i - 2]) + w[i - 7] \
+ SHA256_F3(w[i - 15]) + w[i - 16]; \
}

uint32_t sha256_h0[8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};

uint32_t sha256_k[64] =
{0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};

/* SHA-256 functions */

void sha256_transf(sha256_ctx *ctx, const unsigned char *message,
unsigned int block_nb)
{
uint32_t w[64];
uint32_t wv[8];
uint32_t t1, t2;
const unsigned char *sub_block;
int i;

int j;

for (i = 0; i < (int) block_nb; i++) {
sub_block = message + (i << 6);

for (j = 0; j < 16; j++) {
PACK32(&sub_block[j << 2], &w[j]);
}

for (j = 16; j < 64; j++) {
SHA256_SCR(j);
}

for (j = 0; j < 8; j++) {
wv[j] = ctx->h[j];
}

for (j = 0; j < 64; j++) {
t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6])
+ sha256_k[j] + w[j];
t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
wv[7] = wv[6];
wv[6] = wv[5];
wv[5] = wv[4];
wv[4] = wv[3] + t1;
wv[3] = wv[2];
wv[2] = wv[1];
wv[1] = wv[0];
wv[0] = t1 + t2;
}

for (j = 0; j < 8; j++) {
ctx->h[j] += wv[j];
}
}
}

void sha256_init(sha256_ctx *ctx)
{
int i;
for (i = 0; i < 8; i++) {
ctx->h[i] = sha256_h0[i];
}

ctx->len = 0;
ctx->tot_len = 0;
}

void sha256_update(sha256_ctx *ctx, const unsigned char *message,
unsigned int len)
{
unsigned int block_nb;
unsigned int new_len, rem_len, tmp_len;
const unsigned char *shifted_message;

tmp_len = SHA256_BLOCK_SIZE - ctx->len;
rem_len = len < tmp_len ? len : tmp_len;

memcpy(&ctx->block[ctx->len], message, rem_len);

if (ctx->len + len < SHA256_BLOCK_SIZE) {
ctx->len += len;
return;
}

new_len = len - rem_len;
block_nb = new_len / SHA256_BLOCK_SIZE;

shifted_message = message + rem_len;

sha256_transf(ctx, ctx->block, 1);
sha256_transf(ctx, shifted_message, block_nb);

rem_len = new_len % SHA256_BLOCK_SIZE;

memcpy(ctx->block, &shifted_message[block_nb << 6],
rem_len);

ctx->len = rem_len;
ctx->tot_len += (block_nb + 1) << 6;
}

void sha256_final(sha256_ctx *ctx, unsigned char *digest)
{
unsigned int block_nb;
unsigned int pm_len;
unsigned int len_b;

int i;

block_nb = (1 + ((SHA256_BLOCK_SIZE - 9)
< (ctx->len % SHA256_BLOCK_SIZE)));

len_b = (ctx->tot_len + ctx->len) << 3;
pm_len = block_nb << 6;

memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
ctx->block[ctx->len] = 0x80;
UNPACK32(len_b, ctx->block + pm_len - 4);

sha256_transf(ctx, ctx->block, block_nb);

for (i = 0 ; i < 8; i++) {
UNPACK32(ctx->h[i], &digest[i << 2]);
}
}

void sha256(const unsigned char *message, unsigned int len, unsigned char *digest)
{
sha256_ctx ctx;

sha256_init(&ctx);
sha256_update(&ctx, message, len);
sha256_final(&ctx, digest);
}

unsigned char one_time_key_buf[SHA256_DIGEST_SIZE];

#define MAX_DG 508

unsigned char send_buf[MAX_DG];

unsigned char secret_block[32+4];

void compute_one_time_key() {
memcpy(secret_block + 32, send_buf + 1, 4);
sha256(secret_block, 36, one_time_key_buf);
}

#define SCHEDULER_PERIOD 60

#define BUFFER_SIZE 16

#define TIMEOUT 300
#define MAX_DEPTH 7
#define PENALTY_RATE_SEC 300
#define FEE_RATE 0.02

#define COMMIT 0
#define SEAL 1
#define FINALIZE 2
#define CANCEL 3
#define CLEANUP 4
#define SYNCING_MASK 0x06

struct account {
unsigned char username[32];
unsigned char server_address[32];
unsigned short port;
unsigned char secret_key[32];
unsigned int counter_in;
unsigned int counter_out;
long long balance;
unsigned long long creditlimit;
unsigned long long creditlimit_in;
unsigned char ack_pending : 1;
float width;
unsigned long long tax_syncing;
unsigned long long sync_in;
unsigned long long sync_out;
};

struct base_path {
unsigned char identifier[32];
unsigned long long amount;
unsigned long long tax;
signed char incoming;
signed char outgoing;
signed char counterpart;
unsigned int penalty_rate;
unsigned long long fee;
unsigned char hops;
long long time_value;
};

struct payment {
struct base_path base;
unsigned long long commit_penalty;
unsigned long long finalize_out;
unsigned char preimage[32];
union {
struct {
unsigned char status : 3;
unsigned char commit_out : 1;
unsigned char ack_preimage: 1;
unsigned char ack_sync : 1;
unsigned char synced : 1;
};
unsigned char bits;
};
};

struct receipt {
unsigned char type;
unsigned char identifier[32];
unsigned char username[32];
unsigned char server_address[32];
long long amount;
long long timestamp;
unsigned char status;
};

struct storage {
unsigned char username[32];
unsigned char server_address[32];
unsigned short port;
unsigned char secret_key[32];
unsigned int counter;
float trust_index;
struct account accounts[BUFFER_SIZE];
unsigned short acc_bitmap;
struct payment payments[BUFFER_SIZE];
unsigned char num_payments;
struct receipt receipts[BUFFER_SIZE];
unsigned char receipts_head;
};

struct storage storage;

void save_storage(void) {
FILE *fp = fopen(storage_path, "wb");
if (!fp) return;
fwrite(&storage, sizeof(struct storage), 1, fp);
fclose(fp);
}

void load_storage() {
FILE *fp = fopen(storage_path, "rb");
if (!fp) return;
fread(&storage, sizeof(struct storage), 1, fp);
fclose(fp);
}

signed char lookup_account_idx(unsigned char *identifier) {
unsigned short temp_bitmap = storage.acc_bitmap;
signed char i = 0;
while (temp_bitmap) {
struct account *a = &storage.accounts[i];
if ((temp_bitmap & 1) && strncmp(a->username, identifier, 32) == 0 &&
strncmp(a->server_address, identifier + 32, 32) == 0) {
return i;
}
i++;
temp_bitmap >>= 1;
};
return -1;
}

struct counterpart {
unsigned char username[32];
unsigned char server_address[32];
unsigned short port;
unsigned char secret_key[32];
unsigned int counter_in;
unsigned int counter_out;
};

struct counterpart counterparts[BUFFER_SIZE];
unsigned short cpt_bitmap;

struct pathfinding {
struct base_path base;
unsigned char depth;
unsigned char in_or_out : 1;
unsigned char commit : 1;
};

struct pathfinding paths[BUFFER_SIZE];
unsigned char num_paths;
unsigned long long tax_buffer[BUFFER_SIZE];

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>

#define HEADER_SIZE 5
#define MAX_RETRIES 8
#define BASE_DELAY 1
#define MAX_DELAY 16

#define ACCOUNT_SESSION 0
#define USER_SESSION 2
#define COUNTERPART_SESSION 4

#define USER_SENDER BUFFER_SIZE
#define CPT_SENDER_BASE (BUFFER_SIZE+1)

#define TX_ENVELOPE (1+32+64+4+32)
#define REQ_ENVELOPE (1+4+32)

short endianess;

int sockfd;

time_t next_timer;

struct datagram {
unsigned char payload[MAX_DG];
unsigned short len;
struct sockaddr_in addr;
};

struct send_rtx {
signed char sender_idx;
struct datagram send_queue[BUFFER_SIZE];
unsigned char head;
unsigned char tail;
unsigned char size;
time_t deadline;
unsigned char retries;
};

struct send_rtx send_tasks[BUFFER_SIZE*2+1];
unsigned char num_active_sends = 0;

void remove_send_task(unsigned char idx) {
struct send_rtx* t = &send_tasks[idx];
t->head = (t->head + 1) % BUFFER_SIZE;
t->size--;
if (t->size == 0) {
send_tasks[idx] = send_tasks[num_active_sends - 1];
num_active_sends--;
return;
}
struct datagram *dg = &t->send_queue[t->head];
sendto(sockfd, dg->payload, dg->len, 0, (struct sockaddr *)&dg->addr, sizeof(struct sockaddr_in));
t->retries = 0;
time_t deadline = time(NULL) + BASE_DELAY;
t->deadline = deadline;
if (deadline < next_timer) {
next_timer = deadline;
}
}

void retransmit(time_t current_time) {
for (unsigned char i = 0; i < num_active_sends; i++) {
struct send_rtx *t = &send_tasks[i];
if (t->deadline <= current_time) {
struct datagram *dg = &t->send_queue[t->head];
sendto(sockfd, dg->payload, dg->len, 0, (struct sockaddr *)&dg->addr, sizeof(struct sockaddr_in));
t->retries++;
if (t->retries >= MAX_RETRIES) {
remove_send_task(i);
i--;
continue;
}
unsigned char delay = BASE_DELAY << t->retries;
if (delay > MAX_DELAY) delay = MAX_DELAY;
t->deadline = current_time + delay;
}
if (t->deadline < next_timer) {
next_timer = t->deadline;
}
}
}

void enqueue_send(signed char sender_idx, unsigned short len, struct sockaddr_in *addr) {
unsigned char idx = 0;
while (idx < num_active_sends) {
if (send_tasks[idx].sender_idx == sender_idx) {
break;
}
idx++;
}
struct send_rtx* t = &send_tasks[idx];
if (idx == num_active_sends) {
memset(&t->head, 0, sizeof(struct send_rtx) - ((char*)&t->head-(char*)t));
t->sender_idx = sender_idx;
num_active_sends++;
} else if (t->size >= BUFFER_SIZE) {
return;
}

struct datagram *slot = &t->send_queue[t->tail];
memcpy(slot->payload, send_buf, len);
slot->len = len;
slot->addr = *addr;
t->tail = (t->tail + 1) % BUFFER_SIZE;
t->size++;
if (t->size == 1) {
time_t deadline = time(NULL) + BASE_DELAY;
t->deadline = deadline;
if (deadline < next_timer) {
next_timer = deadline;
}
sendto(sockfd, slot->payload, slot->len, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));
}
}

#include <netdb.h>

int create_sockaddr_in(const char *addr_str, unsigned short port, struct sockaddr_in *addr) {
memset(addr, 0, sizeof(struct sockaddr_in));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
if (inet_pton(AF_INET, addr_str, &addr->sin_addr) == 1) {
return 0;
} else {
struct hostent *host = gethostbyname(addr_str);
if (host == NULL) {
return -1;
}
memcpy(&addr->sin_addr, host->h_addr, host->h_length);
return 0;
}
}

void remove_sender(signed char sender_idx) {
for (unsigned char i = 0; i < num_active_sends; ++i) {
if (send_tasks[i].sender_idx == sender_idx) {
send_tasks[i] = send_tasks[--num_active_sends];
return;
}
}
}

signed char lookup_cpt_idx_by_id(unsigned char *u, unsigned char *s) {
unsigned short temp = cpt_bitmap;
signed char i = 0;
while (temp) {
if ((temp & 1) &&
strncmp(counterparts[i].username, u, 32) == 0 &&
strncmp(counterparts[i].server_address, s, 32) == 0) {
return i;
}
i++;
temp >>= 1;
}
return -1;
}

signed char get_counterpart(struct base_path *base) {
signed char idx = base->counterpart;
unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(counterparts[idx].secret_key, 32, pay_id_buf);
if (memcmp(base->identifier, pay_id_buf, 32) == 0) {
return idx;
}
return -1;
}

void remove_counterpart_by_idx(signed char idx) {
remove_sender((signed char)(BUFFER_SIZE + 1 + idx));
cpt_bitmap &= ~(1 << idx);
}

void remove_counterpart(struct base_path *base) {
signed char idx = get_counterpart(base);
if (idx != -1) {
remove_counterpart_by_idx(idx);
}
}

void write_receipt(struct base_path *base, unsigned char status) {
struct receipt *r = &storage.receipts[storage.receipts_head];
storage.receipts_head = (storage.receipts_head + 1) % BUFFER_SIZE;

unsigned char in_or_out = base->outgoing == -1;
if (in_or_out) {
r->amount = (long long)base->amount;
} else {
r->amount = -(long long)base->amount;
}
r->timestamp = time(NULL);
r->status = status;

memcpy(r->identifier, base->identifier, 32);
signed char cpt_idx = get_counterpart(base);
if (cpt_idx != -1) {
memcpy(r->username, counterparts[cpt_idx].username, 32);
memcpy(r->server_address, counterparts[cpt_idx].server_address, 32);
} else {
memset(r->username, 0, 64);
}
save_storage();
}

unsigned char is_counterpart(const struct base_path *b) {
return b->counterpart != -1;
}

static void remove_path_at(unsigned char idx, unsigned char receipt) {
struct pathfinding *pf = &paths[idx];
if (is_counterpart(&pf->base)) {
if (receipt) {
write_receipt(&pf->base, 1);
}
remove_counterpart(&pf->base);
}
paths[idx] = paths[--num_paths];
}

static void remove_payment_at(unsigned char pay_idx) {
if (is_counterpart(&storage.payments[pay_idx].base)) {
remove_counterpart(&storage.payments[pay_idx].base);
}
storage.payments[pay_idx] = storage.payments[--storage.num_payments];
}

struct pathfinding *get_pathfinding_by_idx(unsigned char idx) {
struct pathfinding *pf = &paths[idx];
if (pf->base.time_value < time(NULL)) {
remove_path_at(idx, 1);
return NULL;
}
return pf;
}

signed char get_pathfinding(unsigned char *payment_id) {
signed char idx = 0;
while (idx < num_paths) {
struct pathfinding *pf = get_pathfinding_by_idx(idx);
if (!pf) {
continue;
}
if (memcmp(pf->base.identifier, payment_id, 32) == 0) {
break;
}
idx++;
}
if (idx == num_paths) {
return -1;
}
return idx;
}

void set_commit(struct pathfinding *pf) {
pf->base.time_value = time(NULL) + TIMEOUT;
pf->commit = 1;
}

unsigned long long fee_in(struct base_path *base) {
return ((unsigned long long)base->hops + 1) * base->fee;
}

unsigned long long fee_out(struct base_path *base) {
return (unsigned long long)base->hops * base->fee;
}

unsigned long long tax_in(struct base_path *base) {
return ((unsigned long long)base->hops + 1) * base->tax;
}

unsigned long long tax_out(struct base_path *base) {
return (unsigned long long)base->hops * base->tax;
}

unsigned long long preview_bandwidth_in(signed char account_idx) {
struct account *acc = &storage.accounts[account_idx];
long long bandwidth = (long long)acc->creditlimit - acc->balance;
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->base.incoming == account_idx) {
bandwidth -= (long long)(p->base.amount + fee_in(&p->base) + tax_in(&p->base));
}
}
for (unsigned char i = 0; i < num_paths; i++) {
struct pathfinding *pf = get_pathfinding_by_idx(i);
if (!pf) {
i--;
continue;
}

if (pf->base.incoming == account_idx && pf->commit) {
bandwidth -= (long long)(pf->base.amount + fee_in(&pf->base) + tax_in(&pf->base));
}
}
return (unsigned long long)(bandwidth > 0 ? bandwidth : 0);
}

unsigned long long preview_bandwidth_out(signed char account_idx) {
struct account *acc = &storage.accounts[account_idx];
long long bandwidth = (long long)acc->creditlimit_in + acc->balance;
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->base.outgoing == account_idx) {
bandwidth -= (long long)(p->base.amount + fee_out(&p->base) + tax_out(&p->base));
}
}
for (unsigned char i = 0; i < num_paths; i++) {
struct pathfinding *pf = get_pathfinding_by_idx(i);
if (!pf) {
i--;
continue;
}

if (pf->base.outgoing == account_idx && pf->commit) {
bandwidth -= (long long)(pf->base.amount + fee_out(&pf->base) + tax_out(&pf->base));
}
}
return (unsigned long long)(bandwidth > 0 ? bandwidth : 0);
}

int verify_signature(unsigned char *data, unsigned short len, unsigned char *secret_key) {
unsigned char hash[SHA256_DIGEST_SIZE];
unsigned char signature[32];
memcpy(signature, data + len - 32, 32);
memcpy(data + len - 32, secret_key, 32);
sha256(data, len, hash);
return memcmp(hash, signature, 32) == 0;
}

void sign_data(unsigned short len, unsigned char *secret_key) {
unsigned char signature[SHA256_DIGEST_SIZE];
memcpy(send_buf + len, secret_key, 32);
sha256(send_buf, len+32, signature);
memcpy(send_buf + len, signature, 32);
}

void bswapn(unsigned char* dst, unsigned char* src, unsigned char n) {
unsigned char fwd = 0;
unsigned char rev = n - 1;
unsigned char half = n/2;
while (fwd < half) {
dst[fwd] = src[rev];
dst[rev] = src[fwd];
fwd++;
rev--;
}
}
void ntohn(void* dst, unsigned char* src, unsigned char n, unsigned char size) {
unsigned char *dst_c = (unsigned char*)dst;
unsigned char padding = size-n;
if (endianess) {
bswapn(dst_c, src, n);
dst_c = dst_c+n;
} else {
memcpy(dst_c+padding, src, n);
}
if (padding) {
memset(dst_c, 0, padding);
}
}

void htonn(void* src, unsigned char* dst, unsigned char n, unsigned char size) {
unsigned char *src_c = (unsigned char*)src;
if (endianess) {
bswapn(dst, src_c, n);
} else {
memcpy(dst, src_c+size-n, n);
}
}

unsigned short error_message(unsigned char *msg, unsigned short len) {
send_buf[5] = 1;
memcpy(send_buf + 6, msg, len);
return len + 1;
}

unsigned short success_message(unsigned char *msg, unsigned short len) {
send_buf[5] = 0;
memcpy(send_buf + 6, msg, len);
return len + 1;
}

unsigned short set_trust_index(unsigned char *data) {
uint32_t bits;
ntohn(&bits, data, 4, sizeof(uint32_t));
float val = *((float*)&bits);
storage.trust_index = val;
save_storage();
return success_message("Set trust index", 15);
}

unsigned short add_account(unsigned char *data) {
unsigned char *id = data;
unsigned char *portBytes = data+64;
unsigned char *acc_secret_key = data + 66;

if (lookup_account_idx(id) != -1) {
return error_message("Peer already exists", 20);
}
signed char account_idx = 0;

unsigned short temp_bitmap = storage.acc_bitmap;
while (temp_bitmap) {
if ((temp_bitmap & 1) == 0) {
break;
}
account_idx++;
temp_bitmap >>= 1;
}

if (account_idx == BUFFER_SIZE) {
return error_message("Peer slots full", 16);
}

compute_one_time_key();

for (unsigned char i = 0; i < 32; i++) {
acc_secret_key[i] ^= one_time_key_buf[i];
}

struct account *acc = &storage.accounts[account_idx];

strncpy(acc->username, id, 32);
strncpy(acc->server_address, id + 32, 31);
acc->server_address[31] = '\0';

ntohn(&acc->port, portBytes, 2, sizeof(short));
memcpy(acc->secret_key, acc_secret_key, 32);

memset(&acc->counter_in, 0, sizeof(struct account) - ((char*)&acc->counter_in - (char*)acc));
storage.acc_bitmap |= (1 << account_idx);
save_storage();

return success_message("Add account", 12);
}

unsigned short remove_account(unsigned char *data) {
unsigned char *id = data;
signed char account_idx = lookup_account_idx(id);
if (account_idx == -1) {
return error_message("Peer does not exist", 20);
}
for (unsigned char i = 0; i < num_paths; ) {
struct pathfinding *pf = &paths[i];
if (pf->base.incoming == account_idx || pf->base.outgoing == account_idx) {
remove_path_at(i, 0);
} else {
i++;
}
}
for (unsigned char i = 0; i < storage.num_payments; ) {
struct payment *p = &storage.payments[i];
if (p->base.incoming == account_idx) {
p->base.incoming = -1;
}
if (p->base.outgoing == account_idx) {
p->base.outgoing = -1;
}
if (p->base.incoming == -1 && p->base.outgoing == -1) {
remove_payment_at(i);
} else {
i++;
}
}
remove_sender(account_idx);
storage.acc_bitmap &= ~(1 << account_idx);
save_storage();
return success_message("Remove account", 15);
}

void tx_header(unsigned char session_type, unsigned char * username) {
send_buf[0] = session_type;
strncpy(send_buf+1, username, 32);
strcpy(send_buf+33, storage.username);
strcpy(send_buf+65, storage.server_address);
}

void account_sign_and_send(signed char account_idx, unsigned short len) {
struct account *acc = &storage.accounts[account_idx];
tx_header(ACCOUNT_SESSION, acc->username);
acc->counter_out++;
save_storage();
htonn(&acc->counter_out, send_buf+97, 4, sizeof(int));
sign_data(TX_ENVELOPE + len - 32, acc->secret_key);
struct sockaddr_in addr;
create_sockaddr_in(acc->server_address, acc->port, &addr);
enqueue_send(account_idx, TX_ENVELOPE + len, &addr);
}

static void cpt_sign_and_send_idx(signed char cpt_idx, unsigned char cmd) {
struct counterpart *cpt = &counterparts[cpt_idx];
tx_header(COUNTERPART_SESSION, cpt->username);
cpt->counter_out++;
htonn(&cpt->counter_out, send_buf + 97, 4, sizeof(int));
send_buf[101] = cmd;
sign_data(TX_ENVELOPE + 1 - 32, cpt->secret_key);
struct sockaddr_in addr;
create_sockaddr_in(cpt->server_address, cpt->port, &addr);
enqueue_send((signed char)(CPT_SENDER_BASE + cpt_idx), TX_ENVELOPE + 1, &addr);
}

void account_send_32_bytes(signed char account_idx, unsigned char cmd, unsigned char* bytes) {
send_buf[101] = cmd;
memcpy(send_buf + 102, bytes, 32);
account_sign_and_send(account_idx, 1 + 32);
}

void account_send_32_1(signed char account_idx, unsigned char cmd, unsigned char* bytes, unsigned char byte) {
send_buf[101] = cmd;
memcpy(send_buf + 102, bytes, 32);
send_buf[134] = byte;
account_sign_and_send(account_idx, 1 + 32 + 1);
}

void account_send_sync_payment(signed char account_idx, unsigned char* bytes, unsigned long long amount) {
send_buf[101] = 10;
memcpy(send_buf + 102, bytes, 32);
htonn(&amount, send_buf + 134, 8, sizeof(long long));
account_sign_and_send(account_idx, 1 + 40);
}

void account_send_8(signed char account_idx, unsigned char cmd, unsigned long long val) {
send_buf[101] = cmd;
htonn(&val, send_buf + 102, 8, sizeof(long long));
account_sign_and_send(account_idx, 1 + 8);
}

void account_send_16(signed char account_idx, unsigned char cmd, unsigned long long val1, unsigned long long val2) {
send_buf[101] = cmd;
htonn(&val1, send_buf + 102, 8, sizeof(long long));
htonn(&val2, send_buf + 110, 8, sizeof(long long));
account_sign_and_send(account_idx, 1 + 16);
}

unsigned short set_trustline(unsigned char *data) {
unsigned char *id = data;
unsigned long long value;
ntohn(&value, data + 64, 8, sizeof(long long));
signed char account_idx = lookup_account_idx(id);
if (account_idx == -1) {
return error_message("Peer does not exist", 20);
}
struct account *acc = &storage.accounts[account_idx];
acc->creditlimit = value;
acc->ack_pending = 1;
save_storage();
account_send_8(account_idx, 15, value);
return success_message("Set trustline", 14);
}

unsigned char validate_payment_overflow(unsigned long long amount, unsigned long long fee, unsigned long long tax) {
unsigned long long max_value = 0-1;
if (amount > max_value >> 1 || (fee | tax) > max_value >> 10) {
return 0;
}
return 1;
}

signed char set_counterpart(unsigned char *id, unsigned short port, unsigned char *cpt_secret_key) {
signed char cpt_idx = lookup_cpt_idx_by_id(id, id + 32);
if (cpt_idx != -1) {
unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(counterparts[cpt_idx].secret_key, 32, pay_id_buf);
signed int pf_idx = get_pathfinding(pay_id_buf);
if (pf_idx != -1) {
struct pathfinding *pf = &paths[pf_idx];
if (is_counterpart(&pf->base)) {
write_receipt(&pf->base, 1);
}
paths[pf_idx] = paths[--num_paths];
}
remove_counterpart_by_idx(cpt_idx);
} else {
cpt_idx = 0;
unsigned short temp = cpt_bitmap;
while (temp) {
if ((temp & 1) == 0) break;
cpt_idx++;
temp >>= 1;
}
if (cpt_idx == BUFFER_SIZE) return -1;
}

cpt_bitmap |= (1 << cpt_idx);
struct counterpart *cpt = &counterparts[cpt_idx];

strncpy(cpt->username, id, 32);
strncpy(cpt->server_address, id + 32, 31);
cpt->server_address[31] = '\0';
cpt->port = port;
memcpy(cpt->secret_key, cpt_secret_key, 32);
cpt->counter_in = 0;
cpt->counter_out = 0;
return cpt_idx;
}

void cpt_send_new_payment(signed char cpt_idx, unsigned char pf_idx) {
struct pathfinding *pf = &paths[pf_idx];
struct counterpart *cpt = &counterparts[cpt_idx];

tx_header(COUNTERPART_SESSION, cpt->username);
cpt->counter_out++;
htonn(&cpt->counter_out, send_buf + 97, 4, sizeof(int));

send_buf[101] = 0;

unsigned char *p = send_buf + 102;
htonn(&pf->base.amount, p, 8, sizeof(long long)); p += 8;
htonn(&pf->base.penalty_rate, p, 4, sizeof(int)); p += 4;
htonn(&pf->base.fee, p, 8, sizeof(long long)); p += 8;
htonn(&pf->base.tax, p, 8, sizeof(long long));

sign_data(TX_ENVELOPE + 1 + 28 - 32, cpt->secret_key);

struct sockaddr_in addr;
create_sockaddr_in(cpt->server_address, cpt->port, &addr);
enqueue_send((signed char)(CPT_SENDER_BASE + cpt_idx), TX_ENVELOPE + 1 + 28, &addr);
}

signed char get_payment_idx(unsigned char *payment_id) {
for (signed char i = 0; i < storage.num_payments; i++) {
if (memcmp(storage.payments[i].base.identifier, payment_id, 32) == 0) {
return i;
}
}
return -1;
}

void add_pathfinding(unsigned char *payment_id, signed char cpt_idx, unsigned long long amount, unsigned long long tax, unsigned long long fee, unsigned int penalty_rate, unsigned char in_or_out) {
struct pathfinding *pf = &paths[num_paths++];
memcpy(pf->base.identifier, payment_id, 32);
pf->base.amount = amount;
pf->base.tax = tax;
pf->base.incoming = -1;
pf->base.outgoing = -1;
pf->base.counterpart = cpt_idx;
pf->base.penalty_rate = penalty_rate;
pf->base.fee = fee;
pf->base.hops = 0;
pf->base.time_value = time(NULL) + TIMEOUT;
pf->depth = 0;
pf->in_or_out = in_or_out;
pf->commit = 0;
}

signed short create_new_payment(unsigned char *id, unsigned short port, unsigned char *cpt_secret_key, unsigned long long amount, unsigned short *out_len) {
unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(cpt_secret_key, 32, pay_id_buf);

if (get_pathfinding(pay_id_buf) != -1 || get_payment_idx(pay_id_buf) != -1) {
*out_len = error_message("Payment already pending", 23);
return -1;
}

signed char cpt_idx = set_counterpart(id, port, cpt_secret_key);
if (cpt_idx < 0 || num_paths >= BUFFER_SIZE - storage.num_payments) {
*out_len = error_message("Payment slots full", 19);
return -1;
}

unsigned long long fee = (unsigned long long)((float)amount * FEE_RATE);
unsigned long long tax = (unsigned long long)((float)amount * storage.trust_index);

if (!validate_payment_overflow(amount, fee, tax) || amount == 0) {
*out_len = error_message("Payment overflow", 17);
return -1;
}
add_pathfinding(pay_id_buf, cpt_idx, amount, tax, fee, PENALTY_RATE_SEC, 0);

return cpt_idx;
}

unsigned short new_payment(unsigned char *data) {
unsigned char *id = data;
unsigned short port;
ntohn(&port, data + 64, 2, sizeof(short));
unsigned char *cpt_secret_key = data + 66;
unsigned long long amount;
ntohn(&amount, data + 98, 8, sizeof(long long));

compute_one_time_key();
for (unsigned char i = 0; i < 32; i++) {
cpt_secret_key[i] ^= one_time_key_buf[i];
}

unsigned short err_len;
signed char cpt_idx = create_new_payment(id, port, cpt_secret_key, amount, &err_len);
if (cpt_idx == -1) {
return err_len;
}
cpt_send_new_payment(cpt_idx, num_paths-1);

return success_message("New payment", 12);
}

unsigned short receive_payment(unsigned char *data) {
unsigned char *id = data;
unsigned short port;
ntohn(&port, data + 64, 2, sizeof(short));
unsigned char *cpt_secret_key = data + 66;

compute_one_time_key();
for (unsigned char i = 0; i < 32; i++) {
cpt_secret_key[i] ^= one_time_key_buf[i];
}

signed char idx = set_counterpart(id, port, cpt_secret_key);
if (idx < 0) return error_message("Payment slots full", 19);

cpt_sign_and_send_idx(idx, 1);

return success_message("Receive payment", 15);
}

unsigned short local_payment(unsigned char *data) {
unsigned char *id = data;
unsigned long long amount;
ntohn(&amount, data + 64, 8, sizeof(long long));
unsigned char *nonce = data + 72;

signed char account_idx = lookup_account_idx(id);
if (account_idx == -1) {
return error_message("Peer does not exist", 20);
}
struct account *acc = &storage.accounts[account_idx];

unsigned char cpt_secret_key[32];
unsigned char hash_buf[40];
memcpy(hash_buf, acc->secret_key, 32);
memcpy(hash_buf + 32, nonce, 8);
sha256(hash_buf, 40, cpt_secret_key);

unsigned short err_len;
if (create_new_payment(id, acc->port, cpt_secret_key, amount, &err_len) == -1) {
return err_len;
}

send_buf[101] = 14;
memcpy(send_buf + 102, nonce, 8);
account_sign_and_send(account_idx, 1 + 8);

return success_message("Local payment", 14);
}

unsigned short get_trust_index(unsigned char *data){
send_buf[5] = 0;
unsigned char *resp = send_buf + 6;
htonn(&storage.trust_index, resp, 4, sizeof(float));
return 5;
}

unsigned short get_num_accounts(unsigned char *data) {
unsigned short temp_bitmap = storage.acc_bitmap;
unsigned char count = 0;
while (temp_bitmap) {
if (temp_bitmap & 1) {
count++;
}
temp_bitmap >>= 1;
};
send_buf[5] = 0;
send_buf[6] = count;
return 2;
}

unsigned short get_account(unsigned char *data) {
unsigned char idx = data[0];
unsigned short temp_bitmap = storage.acc_bitmap;
unsigned char count = 0;
unsigned char account_idx = 0;
while (temp_bitmap) {
if (temp_bitmap & 1) {
if (count == idx) break;
count++;
}
temp_bitmap >>= 1;
account_idx++;
}
if (!temp_bitmap) {
return error_message("Account not found", 18);
}
struct account *a = &storage.accounts[account_idx];

send_buf[5] = 0;
unsigned char *resp_data = send_buf+6;
memcpy(resp_data, a->username, 32);
memcpy(resp_data+32, a->server_address, 32);
htonn(&a->balance, resp_data+64, 8, sizeof(long long));
htonn(&a->creditlimit, resp_data+72, 8, sizeof(long long));
htonn(&a->creditlimit_in, resp_data+80, 8, sizeof(long long));
return 89;
}

unsigned short get_receipt(unsigned char *data) {
unsigned char idx = data[0];
if (idx >= BUFFER_SIZE) {
return error_message("Invalid index", 14);
}
struct receipt *r = &storage.receipts[idx];

send_buf[5] = 0;
unsigned char *resp = send_buf + 6;
memcpy(resp, r->identifier, 32);
memcpy(resp + 32, r->username, 32);
memcpy(resp + 64, r->server_address, 32);
htonn(&r->amount, resp + 96, 8, sizeof(long long));
htonn(&r->timestamp, resp + 104, 8, sizeof(long long));
resp[112] = r->status;
return 114;
}

unsigned char num_counterparts() {
unsigned char count = 0;
unsigned short temp = cpt_bitmap;
while (temp) {
if (temp & 1) {
count++;
}
temp >>= 1;
}
return count;
}

unsigned short get_num_counterparts(unsigned char *data) {
send_buf[5] = 0;
send_buf[6] = num_counterparts();
return 2;
}

void forward_find_path(unsigned char path_idx) {
struct pathfinding *path = &paths[path_idx];

if (path->depth >= MAX_DEPTH) {
return;
}

signed char from;

unsigned long long (*bandwidth_fn)(signed char);

if (path->in_or_out) {
bandwidth_fn = preview_bandwidth_in;
from = path->base.outgoing;
} else {
bandwidth_fn = preview_bandwidth_out;
from = path->base.incoming;
}

unsigned short temp_bitmap = storage.acc_bitmap;
signed char i = 0;
while (temp_bitmap) {
if (temp_bitmap & 1 && i != from && bandwidth_fn(i) >= path->base.amount) {
send_buf[101] = 0;
unsigned char *data = send_buf+102;
memcpy(data, path->base.identifier, 32);
htonn(&path->base.amount, data+32, 8, sizeof(long long));
data[40] = path->in_or_out;
htonn(&path->base.penalty_rate, data+41, 4, sizeof(int));
htonn(&path->base.fee, data+45, 8, sizeof(long long));
data[53] = path->base.hops;
htonn(&path->base.tax, data+54, 8, sizeof(long long));
account_sign_and_send(i, 1 + 62);
}
i++;
temp_bitmap >>= 1;
};
path->depth++;
}

unsigned char is_path_found(struct pathfinding *pf) {
return pf->base.incoming != -1 && (pf->base.outgoing != -1 || is_counterpart(&pf->base));
}

unsigned char buyer_can_prepare(struct pathfinding *pf) {
return preview_bandwidth_out(pf->base.outgoing) >= pf->base.amount + fee_out(&pf->base) + tax_out(&pf->base) && pf->base.hops <= pf->depth * 2 + 1;
}

void find_path(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned long long amount;
ntohn(&amount, args + 32, 8, sizeof(long long));
unsigned char in_or_out = args[40];
unsigned int penalty_rate;
ntohn(&penalty_rate, args + 41, 4, sizeof(int));
unsigned long long fee;
ntohn(&fee, args + 45, 8, sizeof(long long));
unsigned char hops = args[53];
unsigned long long tax;
ntohn(&tax, args + 54, 8, sizeof(long long));

if (!in_or_out && preview_bandwidth_in(account_idx) < amount) {
return;
}

signed char pf_idx = get_pathfinding(payment_id);

if (pf_idx == -1) {
if (amount == 0 || penalty_rate < PENALTY_RATE_SEC / 2 || (float)fee / (float)amount < FEE_RATE / 2) {
return;
}

float tax_rate = (float)tax / (float)amount;
if(tax_rate < storage.trust_index / 2) {
return;
}
if (!validate_payment_overflow(amount, fee, tax)) {
return;
}
if (num_paths >= (BUFFER_SIZE - storage.num_payments) / 2) {
return;
}
pf_idx = num_paths++;
struct pathfinding *pf = &paths[pf_idx];
memcpy(pf->base.identifier, payment_id, 32);
pf->base.amount = amount;
pf->base.counterpart = -1;
pf->in_or_out = in_or_out;
pf->base.penalty_rate = penalty_rate;
pf->base.fee = fee;
pf->base.tax = tax;
pf->base.time_value = time(NULL) + TIMEOUT;
pf->depth = 0;
pf->commit = 0;
if (!in_or_out) {
pf->base.incoming = account_idx;
pf->base.outgoing = -1;
pf->base.hops = 0;
} else {
pf->base.incoming = -1;
pf->base.outgoing = account_idx;
pf->base.hops = hops+1;
}
account_send_32_1(account_idx, 1, payment_id, 0);
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (pf->commit || is_path_found(pf)) {
return;
}

if (in_or_out != pf->in_or_out) {

if (amount != pf->base.amount ||
penalty_rate != pf->base.penalty_rate ||
fee != pf->base.fee ||
tax != pf->base.tax) {
return;
}

if (!in_or_out) {
pf->base.incoming = account_idx;
} else {
pf->base.outgoing = account_idx;
pf->base.hops = hops + 1;
}
if (is_counterpart(&pf->base)) {
if (!pf->in_or_out) {
if (buyer_can_prepare(pf)) {
set_commit(pf);
account_send_32_bytes(account_idx, 3, payment_id);
}
return;
}
}
account_send_32_1(pf->base.incoming, 2, payment_id, pf->base.hops);
return;
}
if (!in_or_out && pf->base.incoming == account_idx || in_or_out && pf->base.outgoing == account_idx) {
forward_find_path(pf_idx);
}
}

void path_recurse(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned char depth = args[32];

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (pf->commit || is_path_found(pf) || depth + 1 != pf->depth) {
return;
}

if (is_counterpart(&pf->base)) {
signed char cpt_idx = get_counterpart(&pf->base);
if (cpt_idx >= 0) cpt_sign_and_send_idx(cpt_idx, 1);
return;
}

signed char prev_idx;
if (!pf->in_or_out) {
prev_idx = pf->base.incoming;
} else {
prev_idx = pf->base.outgoing;
}

account_send_32_1(prev_idx, 1, payment_id, pf->depth);
}

void path_found(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned char hops = args[32];

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (is_path_found(pf) || pf->commit || pf->in_or_out) {
return;
}

pf->base.outgoing = account_idx;
pf->base.hops = hops + 1;

if (is_counterpart(&pf->base)) {
if (buyer_can_prepare(pf)) {
set_commit(pf);
account_send_32_bytes(account_idx, 3, payment_id);
}
return;
}

account_send_32_1(pf->base.incoming, 2, payment_id, pf->base.hops);
}

void prepare_path(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (pf->commit || preview_bandwidth_in(account_idx) < pf->base.amount + fee_in(&pf->base) + tax_in(&pf->base)) {
return;
}

if (is_counterpart(&pf->base)) {
if (!pf->in_or_out) {
return;
}
pf->base.incoming = account_idx;
set_commit(pf);
signed char cpt_idx = get_counterpart(&pf->base);
if (cpt_idx >= 0) cpt_sign_and_send_idx(cpt_idx, 2);
return;
}

if (pf->base.outgoing == -1 || preview_bandwidth_out(pf->base.outgoing) < pf->base.amount + fee_out(&pf->base) + tax_out(&pf->base)) {
return;
}

pf->base.incoming = account_idx;
set_commit(pf);

account_send_32_bytes(pf->base.outgoing, 3, payment_id);
}

void commit_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (!pf->commit || account_idx != pf->base.incoming) {
return;
}

struct payment *payment = &storage.payments[storage.num_payments];
storage.num_payments++;

memcpy(&payment->base, &pf->base, (char*)&pf->base.time_value - (char*)&pf->base);
payment->base.time_value = time(NULL);

payment->bits = 0;

if (is_counterpart(&pf->base)) {
signed char cpt_idx = get_counterpart(&pf->base);
if (cpt_idx < 0) { paths[pf_idx] = paths[--num_paths]; return; }
memcpy(payment->preimage, counterparts[cpt_idx].secret_key, 32);
save_storage();
paths[pf_idx] = paths[--num_paths];
cpt_sign_and_send_idx(cpt_idx, 3);
return;
}
paths[pf_idx] = paths[--num_paths];
save_storage();

account_send_32_bytes(pf->base.outgoing, 4, payment_id);
}

unsigned long long penalty_ticker(struct payment *payment) {
long long now = time(NULL);
if (now > payment->base.time_value && payment->base.penalty_rate > 0) {
unsigned long long ticker = (unsigned long long)(now - payment->base.time_value) / (unsigned long long)payment->base.penalty_rate;
return ticker > payment->base.amount ? payment->base.amount : ticker;
}
return 0;
}

void seal_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}
struct payment *payment = &storage.payments[pay_idx];

if (payment->status != COMMIT || payment->base.incoming != account_idx) {
return;
}

unsigned long long ticker = penalty_ticker(payment);
payment->commit_penalty = ticker;

if (ticker >= payment->base.amount) {
payment->status = CLEANUP;
save_storage();
account_send_32_bytes(account_idx, 8, payment_id);

if (payment->base.outgoing != -1) {
payment->finalize_out = payment->base.amount + fee_out(&payment->base) + tax_out(&payment->base);
save_storage();
account_send_32_bytes(payment->base.outgoing, 8, payment_id);
}
return;
}

if (is_counterpart(&payment->base)) {
payment->status = FINALIZE;
save_storage();
account_send_32_bytes(account_idx, 6, payment->preimage);
return;
}
payment->status = SEAL;
save_storage();
if (payment->base.outgoing != -1) {
account_send_32_bytes(payment->base.outgoing, 5, payment_id);
}
}

unsigned long long seal_penalty(struct payment *payment, unsigned long long ticker) {
return ticker > payment->commit_penalty ? ticker - payment->commit_penalty : 0;
}

unsigned long long finalize_out(struct payment *payment) {
unsigned long long ticker = penalty_ticker(payment);
unsigned long long amount = payment->base.amount - seal_penalty(payment, ticker);
unsigned long long tax = tax_out(&payment->base) * amount / payment->base.amount;
unsigned long long fee = fee_out(&payment->base) * ticker / payment->base.amount;
return amount + tax + fee;
}

static void send_ack_preimage(signed char sender_idx, unsigned char *payment_id) {
account_send_32_bytes(sender_idx, 9, payment_id);
}

void finalize_payment(signed char account_idx, unsigned char *args) {
unsigned char *preimage_arg = args;
unsigned char payment_id[32];
sha256(preimage_arg, 32, payment_id);

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
send_ack_preimage(account_idx, payment_id);
return;
}
struct payment *payment = &storage.payments[pay_idx];

if (payment->status == FINALIZE || payment->status == CLEANUP) {
send_ack_preimage(account_idx, payment_id);
return;
}

if (payment->status != SEAL || payment->base.outgoing != account_idx) {
return;
}

payment->finalize_out = finalize_out(payment);
payment->status = FINALIZE;
memcpy(payment->preimage, preimage_arg, 32);
save_storage();

account_send_sync_payment(account_idx, payment_id, payment->finalize_out);
send_ack_preimage(account_idx, payment_id);

if (payment->base.incoming != -1) {
account_send_32_bytes(payment->base.incoming, 6, preimage_arg);
}
}

unsigned long long cancel_out(struct payment *payment) {
unsigned long long ticker = penalty_ticker(payment);
unsigned long long total = payment->base.amount + fee_out(&payment->base) + tax_out(&payment->base);
if (ticker >= payment->base.amount) {
return total;
} else {
return total * ticker / payment->base.amount;
}
}

void cancel_payment(signed char account_idx, unsigned char *args) {
unsigned char *preimage_arg = args;

unsigned char payment_id[32];
sha256(preimage_arg, 32, payment_id);

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
send_ack_preimage(account_idx, payment_id);
return;
}
struct payment *payment = &storage.payments[pay_idx];

unsigned char status = payment->status;
if (status == CANCEL || status == CLEANUP) {
send_ack_preimage(account_idx, payment_id);
return;
}

if (status != COMMIT || payment->base.incoming != account_idx) {
return;
}

memcpy(payment->preimage, preimage_arg, 32);
payment->status = CANCEL;

if (payment->base.outgoing != -1) {
payment->finalize_out = cancel_out(payment);
}

save_storage();

if (payment->base.outgoing != -1) {
account_send_32_bytes(payment->base.outgoing, 7, payment->preimage);
}
send_ack_preimage(account_idx, payment_id);
}

unsigned long long cleanup_out(struct payment *payment) {
return payment->base.amount - seal_penalty(payment, payment->base.amount) + fee_out(&payment->base) + tax_out(&payment->base);
}

unsigned char counterpart_in(struct base_path *base) {
return is_counterpart(base) && base->incoming == -1;
}

void cleanup_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}
struct payment *payment = &storage.payments[pay_idx];

if ((payment->status & SYNCING_MASK) || penalty_ticker(payment) < payment->base.amount) {
return;
}

if (payment->status == COMMIT) {
if (counterpart_in(&payment->base)) return;
payment->commit_penalty = payment->base.amount;
}

payment->status = CLEANUP;

if (payment->base.outgoing != -1) {
payment->finalize_out = cleanup_out(payment);
save_storage();
if (payment->base.outgoing != account_idx) {
account_send_32_bytes(payment->base.outgoing, 8, payment_id);
}
}

save_storage();

if (payment->base.incoming != -1 && payment->base.incoming != account_idx) {
account_send_32_bytes(payment->base.incoming, 8, payment_id);
}
}

unsigned char synchronized_in(struct payment *payment) {
unsigned char ack_preimage = payment->status != FINALIZE || payment->ack_preimage;
return payment->synced && ack_preimage || counterpart_in(&payment->base);
}

unsigned char synchronized_out(struct payment *payment) {
unsigned char ack_preimage = payment->status != CANCEL || payment->ack_preimage;
unsigned char commit_out = payment->status == FINALIZE || payment->commit_out;
return payment->ack_sync && ack_preimage && commit_out || is_counterpart(&payment->base) && payment->base.outgoing == -1;
}

void ack_preimage(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}
struct payment *payment = &storage.payments[pay_idx];

unsigned char status = payment->status;
if (payment->ack_preimage ||
!((status == FINALIZE && payment->base.incoming == account_idx) ||
(status == CANCEL && payment->base.outgoing == account_idx))) {
return;
}

payment->ack_preimage = 1;

if (synchronized_in(payment)) {
payment->base.incoming = -1;
}
if (synchronized_out(payment)) {
payment->base.outgoing = -1;
}

if (payment->base.incoming == -1 && payment->base.outgoing == -1) {
remove_payment_at(pay_idx);
}
save_storage();
}

long long preview_balance(signed char account_idx) {
struct account *acc = &storage.accounts[account_idx];
long long bal = acc->balance;
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->base.incoming == account_idx) {
bal -= (long long)(p->base.amount + fee_in(&p->base) + tax_in(&p->base));
}
}
for (unsigned char i = 0; i < num_paths; i++) {
struct pathfinding *pf = get_pathfinding_by_idx(i);
if (!pf) {
i--;
continue;
}
if (pf->base.incoming == account_idx && pf->commit) {
bal -= (long long)(pf->base.amount + fee_in(&pf->base) + tax_in(&pf->base));
}
}
return bal;
}

unsigned long long calculate_tax(struct payment *payment) {
return payment->base.tax * (payment->base.amount - seal_penalty(payment, penalty_ticker(payment)))/payment->base.amount;
}

void redistribute(signed char from_idx, unsigned long long tax, float tax_rate) {
if (tax == 0) return;
struct { signed char idx; unsigned long long val; } positive_balances[BUFFER_SIZE];
unsigned char num_positive = 0;
float total_width = 0.0;
unsigned short temp_bitmap = storage.acc_bitmap;
signed char i = 0;
while (temp_bitmap) {
if (temp_bitmap & 1 && i != from_idx) {
long long preview = preview_balance(i);
if (preview > 0) {
positive_balances[num_positive].idx = i;
positive_balances[num_positive].val = (unsigned long long)preview;
total_width += storage.accounts[i].width;
num_positive++;
}
}
i++;
temp_bitmap >>= 1;
}
if (total_width == 0.0) return;
if (total_width < tax_rate) {
tax = (unsigned long long)((float)tax * (total_width / tax_rate));
}
for (unsigned char j = 0; j < num_positive; j++) {
signed char idx = positive_balances[j].idx;
struct account *acc = &storage.accounts[idx];
float proportion = acc->width / total_width;
unsigned long long dist = (unsigned long long)((float)tax * proportion);
if (dist == 0) continue;
if (dist > positive_balances[j].val) dist = positive_balances[j].val;
tax_buffer[idx] += dist;
if (acc->tax_syncing == 0) {
acc->sync_out++;
acc->tax_syncing = tax_buffer[idx];
save_storage();
account_send_16(idx, 17, acc->tax_syncing, acc->sync_out);
tax_buffer[idx] = 0;
}
}
}

float get_tax_rate(struct payment *p) {
if (p->base.tax == 0) {
return 0;
}
return (float)p->base.tax / (float)(p->base.amount + p->base.tax);
}

void increase_balance(signed char account_idx, unsigned long long amount, float tax_rate) {
struct account *acc = &storage.accounts[account_idx];
long long old_balance = acc->balance;
acc->balance += (long long)amount;
long long new_balance = acc->balance;
if (new_balance > 0) {
float weight;
if (old_balance > 0) {
weight = (float)old_balance / (float)new_balance;
acc->width = weight * acc->width + (1 - weight) * tax_rate;
} else {
acc->width = tax_rate;
tax_buffer[account_idx] = 0;
}
}
}

void decrease_balance(signed char account_idx, unsigned long long amount, float tax_rate) {
struct account *acc = &storage.accounts[account_idx];
long long old_balance = acc->balance;
acc->balance -= (long long)amount;
long long new_balance = acc->balance;
if (new_balance < 0) {
float weight;
if (old_balance < 0) {
weight = (float)(-old_balance) / (float)(-new_balance);
acc->width = weight * acc->width + (1 - weight) * tax_rate;
} else {
acc->width = tax_rate;
}
}
}

void sync_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

unsigned long long amount;
ntohn(&amount, args + 32, 8, sizeof(long long));

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
account_send_32_bytes(account_idx, 11, payment_id);
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (!(payment->status & SYNCING_MASK) || (payment->base.incoming != -1 && payment->base.incoming != account_idx) || amount > payment->base.amount + fee_in(&payment->base) + tax_in(&payment->base)) {
return;
}

if (payment->base.incoming == account_idx && !payment->synced) {
float tax_rate = get_tax_rate(payment);
increase_balance(payment->base.incoming, amount, tax_rate);

payment->synced = 1;

if (is_counterpart(&payment->base)) {
write_receipt(&payment->base, payment->status == CANCEL);
}
if (synchronized_in(payment)) {
payment->base.incoming = -1;
}
save_storage();
redistribute(account_idx, calculate_tax(payment), tax_rate);
}

if (payment->base.incoming == -1 && payment->base.outgoing == -1) {
remove_payment_at(pay_idx);
save_storage();
}

account_send_32_bytes(account_idx, 11, payment_id);
}

void ack_sync(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (!(payment->status & SYNCING_MASK) || payment->ack_sync || payment->base.outgoing != account_idx) {
return;
}
payment->ack_sync = 1;

decrease_balance(payment->base.outgoing, payment->finalize_out, get_tax_rate(payment));

if (is_counterpart(&payment->base)) {
write_receipt(&payment->base, payment->status == CANCEL);
}
if (synchronized_out(payment)) {
payment->base.outgoing = -1;
}
if (payment->base.incoming == -1 && payment->base.outgoing == -1) {
remove_payment_at(pay_idx);
}
save_storage();
}

void verify_commit(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
account_send_32_1(account_idx, 13, payment_id, 1);
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (payment->base.incoming != account_idx) {
account_send_32_1(account_idx, 13, payment_id, 1);
return;
}
account_send_32_1(account_idx, 13, payment_id, 0);
}

void ack_commit(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned char status = args[32];

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (payment->commit_out || payment->base.outgoing != account_idx) {
return;
}

if (status == 0) {
payment->commit_out = 1;
save_storage();
if (payment->status & SYNCING_MASK) {
account_send_sync_payment(payment->base.outgoing, payment->base.identifier, payment->finalize_out);
}
} else {
payment->base.outgoing = -1;
if (payment->base.incoming == -1) {
if (is_counterpart(&payment->base)) {
write_receipt(&payment->base, 1);
}
remove_payment_at(pay_idx);
save_storage();
}
}
}

void receive_local(signed char account_idx, unsigned char *args) {
unsigned char *nonce = args;

if (num_counterparts()>3*BUFFER_SIZE/4) {
return;
}

struct account *acc = &storage.accounts[account_idx];

unsigned char cpt_secret_key[32];
unsigned char hash_buf[40];
memcpy(hash_buf, acc->secret_key, 32);
memcpy(hash_buf + 32, nonce, 8);
sha256(hash_buf, 40, cpt_secret_key);

signed char idx = set_counterpart(acc->username, acc->port, cpt_secret_key);
cpt_sign_and_send_idx(idx, 1);
}

void sync_trustline(signed char account_idx, unsigned char *args) {
unsigned long long limit;
ntohn(&limit, args, 8, sizeof(long long));
struct account *acc = &storage.accounts[account_idx];
acc->creditlimit_in = limit;
save_storage();
account_send_8(account_idx, 16, limit);
}

void ack_trustline(signed char account_idx, unsigned char *args) {
unsigned long long limit;
ntohn(&limit, args, 8, sizeof(long long));

struct account *acc = &storage.accounts[account_idx];

if (!acc->ack_pending || acc->creditlimit != limit) {
return;
}

acc->ack_pending = 0;
save_storage();
}

void swarm_redistribution(signed char account_idx, unsigned char *args) {
unsigned long long amount;
ntohn(&amount, args, 8, sizeof(long long));
unsigned long long counter;
ntohn(&counter, args + 8, 8, sizeof(long long));
struct account *acc = &storage.accounts[account_idx];
if (counter > acc->sync_in) {
if (acc->balance + (long long)amount > 0) return;
acc->balance += (long long)amount;
acc->sync_in = counter;
save_storage();
redistribute(account_idx, amount, acc->width);
}
account_send_8(account_idx, 18, counter);
}

void redistribution_ack(signed char account_idx, unsigned char *args) {
unsigned long long counter;
ntohn(&counter, args, 8, sizeof(long long));
struct account *acc = &storage.accounts[account_idx];
if (acc->tax_syncing > 0 && counter == acc->sync_out) {
acc->balance -= (long long)acc->tax_syncing;
acc->tax_syncing = 0;
save_storage();
}
}

void cpt_new_payment(signed char cpt_idx, unsigned char *args) {
unsigned long long amount;
unsigned long long fee;
unsigned long long tax;
unsigned int penalty_rate;
ntohn(&amount, args, 8, sizeof(long long));
ntohn(&penalty_rate, args + 8, 4, sizeof(int));
ntohn(&fee, args + 12, 8, sizeof(long long));
ntohn(&tax, args + 20, 8, sizeof(long long));

if (num_paths >= BUFFER_SIZE - storage.num_payments || !validate_payment_overflow(amount, fee, tax) || amount == 0) {
return;
}

unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(counterparts[cpt_idx].secret_key, 32, pay_id_buf);

if (get_pathfinding(pay_id_buf) != -1 || get_payment_idx(pay_id_buf) != -1) {
return;
}

add_pathfinding(pay_id_buf, cpt_idx, amount, tax, fee, penalty_rate, 1);

forward_find_path((unsigned char)num_paths-1);
}

void cpt_find_path(signed char cpt_idx, unsigned char *args) {
(void)args;
unsigned char payment_id[32];
sha256(counterparts[cpt_idx].secret_key, 32, payment_id);
signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) return;
forward_find_path((unsigned char)pf_idx);
}

void cpt_commit_payment(signed char cpt_idx, unsigned char *args) {
(void)args;
unsigned char payment_id[32];
sha256(counterparts[cpt_idx].secret_key, 32, payment_id);

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) return;

struct pathfinding *pf = &paths[pf_idx];

if (!is_counterpart(&pf->base) || pf->in_or_out || !pf->commit) return;

struct payment *payment = &storage.payments[storage.num_payments];
storage.num_payments++;

memcpy(&payment->base, &pf->base, (char*)&pf->base.time_value - (char*)&pf->base);
payment->base.time_value = time(NULL);
memcpy(payment->preimage, counterparts[cpt_idx].secret_key, 32);

payment->bits = 0;

save_storage();

paths[pf_idx] = paths[--num_paths];

account_send_32_bytes(pf->base.outgoing, 4, payment_id);
}

void cpt_seal_payment(signed char cpt_idx, unsigned char *args) {
(void)args;
unsigned char payment_id[32];
sha256(counterparts[cpt_idx].secret_key, 32, payment_id);

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) return;

struct payment *payment = &storage.payments[pay_idx];

if (payment->status != COMMIT || payment->base.incoming != -1) return;

unsigned long long ticker = penalty_ticker(payment);
payment->commit_penalty = ticker;

if (ticker >= payment->base.amount) {
payment->status = CLEANUP;
save_storage();
account_send_32_bytes(payment->base.outgoing, 8, payment_id);
return;
}

payment->status = SEAL;
save_storage();
account_send_32_bytes(payment->base.outgoing, 5, payment_id);
}

void cpt_start_payment(signed char cpt_idx, unsigned char *args) {
unsigned char pay_id_buf[32];
sha256(counterparts[cpt_idx].secret_key, 32, pay_id_buf);
signed char pf_idx = get_pathfinding(pay_id_buf);
if (pf_idx == -1) return;
cpt_send_new_payment(cpt_idx, pf_idx);
}

unsigned short (*user_handlers[])(unsigned char*) = {
set_trust_index, add_account, remove_account, set_trustline, new_payment,
receive_payment, local_payment, get_trust_index, get_num_accounts,
get_account, get_receipt, get_num_counterparts
};
void (*acc_handlers[])(signed char, unsigned char*) = {
find_path, path_recurse, path_found, prepare_path, commit_payment, seal_payment,
finalize_payment, cancel_payment, cleanup_payment, ack_preimage, sync_payment,
ack_sync, verify_commit, ack_commit, receive_local, sync_trustline, ack_trustline,
swarm_redistribution, redistribution_ack
};
void (*cpt_handlers[])(signed char, unsigned char*) = {
cpt_new_payment, cpt_start_payment, cpt_find_path, cpt_commit_payment, cpt_seal_payment
};

unsigned short acc_args_len[] = {62, 33, 33, 32, 32, 32, 32, 32, 32, 32, 40, 32, 32, 33, 8, 8, 8, 16, 8};
unsigned short user_args_len[] = {4, 98, 64, 72, 106, 98, 80, 0, 0, 1, 1, 0};
unsigned short cpt_args_len[] = {28, 0, 0, 0, 0};

void push_payment_instructions(void) {
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (!p->ack_preimage) {
if (p->status == FINALIZE && p->base.incoming != -1) {
account_send_32_bytes(p->base.incoming, 6, p->preimage);
} else if (p->status == CANCEL && p->base.outgoing != -1) {
account_send_32_bytes(p->base.outgoing, 7, p->preimage);
}
}

if ((p->status & SYNCING_MASK) && p->base.outgoing != -1 && !p->ack_sync) {
if ((p->status == CANCEL || p->status == CLEANUP) && !p->commit_out) {
account_send_32_bytes(p->base.outgoing, 12, p->base.identifier);
} else {
account_send_sync_payment(p->base.outgoing, p->base.identifier, p->finalize_out);
}
}
}
}

void push_sync_account(void) {
unsigned short temp_bitmap = storage.acc_bitmap;
signed char idx = 0;

while (temp_bitmap) {
if (temp_bitmap & 1) {
struct account *acc = &storage.accounts[idx];
if (acc->ack_pending) {
account_send_8(idx, 15, acc->creditlimit);
}
if (acc->tax_syncing > 0) {
account_send_16(idx, 17, acc->tax_syncing, acc->sync_out);
}
}
idx++;
temp_bitmap >>= 1;
}
}

void auto_cancel_routine(void) {
long long now = time(NULL);
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->status != COMMIT || !counterpart_in(&p->base) || now - p->base.time_value <= TIMEOUT) continue;
p->status = CANCEL;
save_storage();
account_send_32_bytes(p->base.outgoing, 7, p->preimage);
}
}

void cleanup_payment_routine(void) {
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if ((p->status & SYNCING_MASK) || penalty_ticker(p) < p->base.amount) continue;
if (p->status == COMMIT) {
if (counterpart_in(&p->base)) continue;
p->commit_penalty = p->base.amount;
}
if (p->base.incoming != -1) {
account_send_32_bytes(p->base.incoming, 8, p->base.identifier);
}
if (p->base.outgoing != -1) {
p->finalize_out = cleanup_out(p);
account_send_32_bytes(p->base.outgoing, 8, p->base.identifier);
}
p->status = CLEANUP;
save_storage();
}
}

void ack_received(signed char sender_idx, unsigned char *data, unsigned char offset) {
for (unsigned char i = 0; i < num_active_sends; i++) {
struct send_rtx *t = &send_tasks[i];
if (t->sender_idx == sender_idx) {
if (memcmp(t->send_queue[t->head].payload + offset, data+offset, 4) == 0) {
remove_send_task(i);
}
break;
}
}
}

unsigned int receive_tx(unsigned char session_type, signed char sender_idx, struct sockaddr_in *addr, unsigned char *username, unsigned char *server_address, unsigned char *secret_key, unsigned int counter_in, unsigned char *data, unsigned short len) {
if (!verify_signature(data, len, secret_key)) {
return 0;
}
if (data[0]&1) {
ack_received(sender_idx, data, 97);
return 0;
}
unsigned int counter;
ntohn(&counter, data+97, 4, sizeof(int));
if (counter < counter_in) {
return 0;
}
tx_header(session_type | 1, username);
memcpy(send_buf+97, data+97, 4);
sign_data(TX_ENVELOPE-32, secret_key);
sendto(sockfd, send_buf, TX_ENVELOPE, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));

if (counter == counter_in) {
return 0;
}
return counter;
}

#if 1
#define DEBUG_PRINT_MESSAGE(addr, type, cmd) print_message(addr, type, cmd)
static const char* command_names[] = {
"ACCOUNT_FIND_PATH", "ACCOUNT_PATH_RECURSE", "ACCOUNT_PATH_FOUND", "ACCOUNT_PREPARE_PATH",
"ACCOUNT_COMMIT_PAYMENT", "ACCOUNT_SEAL_PAYMENT", "ACCOUNT_FINALIZE_PAYMENT", "ACCOUNT_CANCEL_PAYMENT",
"ACCOUNT_CLEANUP_PAYMENT", "ACCOUNT_ACK_PREIMAGE", "ACCOUNT_SYNC_PAYMENT", "ACCOUNT_ACK_SYNC",
"ACCOUNT_VERIFY_COMMIT", "ACCOUNT_ACK_COMMIT", "ACCOUNT_RECEIVE_LOCAL", "ACCOUNT_SYNC_TRUSTLINE",
"ACCOUNT_ACK_TRUSTLINE", "ACCOUNT_SWARM_REDISTRIBUTION", "ACCOUNT_REDISTRIBUTION_ACK", "USER_SET_TRUST_INDEX",
"USER_ADD_ACCOUNT", "USER_REMOVE_ACCOUNT", "USER_SET_TRUSTLINE", "USER_NEW_PAYMENT", "USER_RECEIVE_PAYMENT",
"USER_LOCAL_PAYMENT", "USER_GET_TRUST_INDEX", "USER_GET_NUM_ACCOUNTS", "USER_GET_ACCOUNT", "USER_GET_RECEIPT",
"USER_GET_NUM_COUNTERPARTS", "COUNTERPART_NEW_PAYMENT", "COUNTERPART_START_PAYMENT", "COUNTERPART_FIND_PATH",
"COUNTERPART_COMMIT_PAYMENT", "COUNTERPART_SEAL_PAYMENT"

};
void print_message(struct sockaddr_in *addr, unsigned char type, unsigned char cmd) {
printf("%s:%d: %s (0x%02X)\n", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port), command_names[cmd + ((type&2)>>1)*19 + (type>>2)*31], cmd);
}
#else
#define DEBUG_PRINT_MESSAGE(addr, type, cmd) ((void)0)
#endif

void transport_datagram(unsigned char *data, unsigned short len, struct sockaddr_in *addr) {
if (len<1) return;
unsigned char session_type = data[0]&6;
if (session_type%4==0) {
if (len < TX_ENVELOPE) {
return;
}
if (session_type==ACCOUNT_SESSION) {
signed char account_idx = lookup_account_idx(data+33);
if (account_idx == -1) {
return;
}
struct account *acc = &storage.accounts[account_idx];
unsigned int counter = receive_tx(ACCOUNT_SESSION, account_idx, addr, acc->username, acc->server_address, acc->secret_key, acc->counter_in, data, len);
if (!counter) {
return;
}
acc->counter_in = counter;
save_storage();
unsigned char cmd = data[101];
if (cmd <= 18 && len-TX_ENVELOPE >= 1 + acc_args_len[cmd]) {
DEBUG_PRINT_MESSAGE(addr, session_type, cmd);
acc_handlers[cmd](account_idx, data+102);
}
} else {
signed char cpt_idx = lookup_cpt_idx_by_id(data+33, data+65);
if (cpt_idx == -1) {
return;
}
struct counterpart *cpt = &counterparts[cpt_idx];
unsigned int counter = receive_tx(COUNTERPART_SESSION, (signed char)(CPT_SENDER_BASE + cpt_idx), addr, cpt->username, cpt->server_address, cpt->secret_key, cpt->counter_in, data, len);
if (!counter) {
return;
}
cpt->counter_in = counter;
unsigned char cmd = data[101];
if (cmd <= 4 && len - TX_ENVELOPE >= 1 + cpt_args_len[cmd]) {
DEBUG_PRINT_MESSAGE(addr, session_type, cmd);
cpt_handlers[cmd](cpt_idx, data+102);
}
}
} else if ((len >= REQ_ENVELOPE) && (verify_signature(data, len, secret_block))) {
if (data[0]&1) {
ack_received(USER_SENDER, data, 1);
return;
}
unsigned int counter;
ntohn(&counter, data+1, 4, sizeof(int));
if (counter < storage.counter) {
return;
}

send_buf[0] = 1;
memcpy(send_buf+1, data+1, 4);
sign_data(REQ_ENVELOPE-32, secret_block);
sendto(sockfd, send_buf, REQ_ENVELOPE, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));
if (counter == storage.counter) {
return;
}
storage.counter = counter;
save_storage();

unsigned short out_len;
unsigned char cmd = data[5];
if (cmd <= 11 && len-REQ_ENVELOPE >= 1 + user_args_len[cmd]) {
DEBUG_PRINT_MESSAGE(addr, session_type, cmd);
out_len = user_handlers[cmd](data+6);
} else {
out_len = error_message("Invalid instruction", 20);
}
send_buf[0] = 0;
memcpy(send_buf+1, data+1, 4);
sign_data(5+out_len, secret_block);
enqueue_send(USER_SENDER, REQ_ENVELOPE+out_len, addr);
}
}

#include <signal.h>

static volatile sig_atomic_t running = 1;

static void on_shutdown_signal(int sig) { running = 0; }

void run_loop() {
unsigned int period = 0;
struct timeval tv;
tv.tv_usec = 0;
unsigned char buf[MAX_DG];
struct sockaddr_in src_addr;
socklen_t addrlen;

while (running) {
time_t now = time(NULL);
unsigned int current_period = (unsigned int)now / SCHEDULER_PERIOD;

if (current_period > period) {
period = current_period;
int tz = __builtin_ctzl(current_period);
push_payment_instructions();
push_sync_account();
if (tz >= 1) auto_cancel_routine();
if (tz >= 2) cleanup_payment_routine();
}
next_timer = (current_period + 1) * SCHEDULER_PERIOD;

retransmit(now);
tv.tv_sec = next_timer - now;

setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
addrlen = sizeof(struct sockaddr_in);
ssize_t n = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&src_addr, &addrlen);

if (n >= REQ_ENVELOPE) {
transport_datagram(buf, (unsigned short)n, &src_addr);
}
}
}

#include <sys/stat.h>

unsigned char nibble_to_byte(char c) {
return (c >= '0' && c <= '9') ? c - '0' : c - 'a' + 10;
}

int main(int argc, char *argv[]) {
if ((unsigned char)~0 != 0xFF) return 1;
endianess = 0x0001;
endianess = (*(char*)&endianess);

if (argc == 2 || argc == 6) {
snprintf(storage_path, sizeof(storage_path), "%s/%s", STORAGE_DIR, argv[argc-1]);
} else {
strcpy(storage_path, STORAGE_DIR "/" STORAGE_FILE);
}

if (argc >= 5) {
struct stat sb;
if (stat(STORAGE_DIR, &sb) != 0) {
if (mkdir(STORAGE_DIR, 0755) != 0) {
return 1;
}
}
strcpy(storage.username, argv[1]);
strcpy(storage.server_address, argv[2]);
char *port_str = argv[3];
unsigned short value = 0;
while (*port_str >= '0' && *port_str <= '9') {
value = value * 10 + (*port_str++ - '0');
if (value > 65535) {
value = 65535;
break;
}
}
storage.port = value;
char *key_str = argv[4];
for (size_t i = 0; i < 64; i += 2) {
storage.secret_key[i / 2] = (nibble_to_byte(key_str[i]) << 4) | nibble_to_byte(key_str[i + 1]);
}
save_storage();
} else {
load_storage();
}
memcpy(secret_block, storage.secret_key, 32);

struct sockaddr_in server_addr;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
return 1;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(storage.port);
server_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
return 1;
}

struct sigaction sa;
sa.sa_handler = on_shutdown_signal;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);

run_loop();

return 0;
}

0x82857BFB831201443790404dBa3f691644F13eC6

0x2842DEfd9f1eCEb7E92501DC70994d8fEd15E33C