void NCDPlaceholderDb_Free (NCDPlaceholderDb *o)
{
for (size_t i = 0; i < o->count; i++) {
BFree(o->arr[i].varnames);
}
BFree(o->arr);
}
int OTPChecker_Init (OTPChecker *mc, int num_otps, int cipher, int num_tables, BThreadWorkDispatcher *twd)
{
ASSERT(num_otps > 0)
ASSERT(BEncryption_cipher_valid(cipher))
ASSERT(num_tables > 0)
// init arguments
mc->num_otps = num_otps;
mc->cipher = cipher;
mc->num_tables = num_tables;
mc->twd = twd;
// set no handlers
mc->handler = NULL;
// set number of entries
if (mc->num_otps > INT_MAX / 2) {
goto fail0;
}
mc->num_entries = 2 * mc->num_otps;
// set no tables used
mc->tables_used = 0;
mc->next_table = 0;
// initialize calculator
if (!OTPCalculator_Init(&mc->calc, mc->num_otps, cipher)) {
goto fail0;
}
// allocate tables
if (!(mc->tables = BAllocArray(mc->num_tables, sizeof(mc->tables[0])))) {
goto fail1;
}
// allocate entries
if (!(mc->entries = BAllocArray2(mc->num_tables, mc->num_entries, sizeof(mc->entries[0])))) {
goto fail2;
}
// initialize tables
for (int i = 0; i < mc->num_tables; i++) {
struct OTPChecker_table *table = &mc->tables[i];
table->entries = mc->entries + (size_t)i * mc->num_entries;
OTPChecker_Table_Empty(mc, table);
}
// have no work
mc->tw_have = 0;
DebugObject_Init(&mc->d_obj);
return 1;
fail2:
BFree(mc->tables);
fail1:
OTPCalculator_Free(&mc->calc);
fail0:
return 0;
}
void SinglePacketBuffer_Free (SinglePacketBuffer *o)
{
DebugObject_Free(&o->d_obj);
// free buffer
BFree(o->buf);
}
void PacketBuffer_Free (PacketBuffer *buf)
{
DebugObject_Free(&buf->d_obj);
// free buffer
BFree(buf->buf_data);
}
void OTPCalculator_Free (OTPCalculator *calc)
{
// free debug object
DebugObject_Free(&calc->d_obj);
// free buffer
BFree(calc->data);
}
static void func_globalfree (struct NCDInterpModuleGroup *group)
{
struct global *g = group->group_state;
ASSERT(LinkedList1_IsEmpty(&g->instances))
// free global state structure
BFree(g);
}
static void replace_func_die (void *vo)
{
struct replace_instance *o = vo;
// free output
BFree((char *)o->output.ptr);
NCDModuleInst_Backend_Dead(o->i);
}
void OTPChecker_Free (OTPChecker *mc)
{
DebugObject_Free(&mc->d_obj);
// free work
if (mc->tw_have) {
BThreadWork_Free(&mc->tw);
}
// free entries
BFree(mc->entries);
// free tables
BFree(mc->tables);
// free calculator
OTPCalculator_Free(&mc->calc);
}
void free_info (struct instance *o)
{
ASSERT(o->have_info)
// free ssid
BFree(o->info_ssid);
// set not have info
o->have_info = 0;
}
static int set_servers (struct global *g)
{
int ret = 0;
// count servers
size_t num_entries = count_entries(g);
// allocate sort array
struct dns_sort_entry *sort_entries = BAllocArray(num_entries, sizeof(sort_entries[0]));
if (!sort_entries) {
goto fail0;
}
// fill sort array
num_entries = 0;
for (LinkedList1Node *n = LinkedList1_GetFirst(&g->instances); n; n = LinkedList1Node_Next(n)) {
struct instance *o = UPPER_OBJECT(n, struct instance, instances_node);
for (LinkedList1Node *en = LinkedList1_GetFirst(&o->entries); en; en = LinkedList1Node_Next(en)) {
struct dns_entry *e = UPPER_OBJECT(en, struct dns_entry, list_node);
sort_entries[num_entries].line = e->line;
sort_entries[num_entries].priority= e->priority;
num_entries++;
}
}
// sort by priority
// use a custom insertion sort instead of qsort() because we want a stable sort
struct dns_sort_entry temp;
BInsertionSort(sort_entries, num_entries, sizeof(sort_entries[0]), dns_sort_comparator, &temp);
ExpString estr;
if (!ExpString_Init(&estr)) {
goto fail1;
}
for (size_t i = 0; i < num_entries; i++) {
if (!ExpString_Append(&estr, sort_entries[i].line)) {
goto fail2;
}
}
// set servers
if (!NCDIfConfig_set_resolv_conf(ExpString_Get(&estr), ExpString_Length(&estr))) {
goto fail2;
}
ret = 1;
fail2:
ExpString_Free(&estr);
fail1:
BFree(sort_entries);
fail0:
return ret;
}
static void func_die (void *vo)
{
struct instance *o = vo;
while (o->num-- > 0) {
BFree(((struct substring *)o->arr.v)[o->num].data);
}
free(o->arr.v);
NCDModuleInst_Backend_Dead(o->i);
}
void recv_handler_done (BSocksClient *o, int data_len)
{
ASSERT(data_len >= 0)
ASSERT(data_len <= o->control.recv_total - o->control.recv_len)
DebugObject_Access(&o->d_obj);
o->control.recv_len += data_len;
if (o->control.recv_len < o->control.recv_total) {
do_receive(o);
return;
}
switch (o->state) {
case STATE_SENT_HELLO: {
BLog(BLOG_DEBUG, "received hello");
struct socks_server_hello imsg;
memcpy(&imsg, o->buffer, sizeof(imsg));
if (ntoh8(imsg.ver) != SOCKS_VERSION) {
BLog(BLOG_NOTICE, "wrong version");
goto fail;
}
size_t auth_index;
for (auth_index = 0; auth_index < o->num_auth_info; auth_index++) {
if (o->auth_info[auth_index].auth_type == ntoh8(imsg.method)) {
break;
}
}
if (auth_index == o->num_auth_info) {
BLog(BLOG_NOTICE, "server didn't accept any authentication method");
goto fail;
}
const struct BSocksClient_auth_info *ai = &o->auth_info[auth_index];
switch (ai->auth_type) {
case SOCKS_METHOD_NO_AUTHENTICATION_REQUIRED: {
BLog(BLOG_DEBUG, "no authentication");
auth_finished(o);
} break;
case SOCKS_METHOD_USERNAME_PASSWORD: {
BLog(BLOG_DEBUG, "password authentication");
if (ai->password.username_len == 0 || ai->password.username_len > 255 ||
ai->password.password_len == 0 || ai->password.password_len > 255
) {
BLog(BLOG_NOTICE, "invalid username/password length");
goto fail;
}
// allocate password packet
bsize_t size = bsize_fromsize(1 + 1 + ai->password.username_len + 1 + ai->password.password_len);
if (!reserve_buffer(o, size)) {
goto fail;
}
// write password packet
char *ptr = o->buffer;
*ptr++ = 1;
*ptr++ = ai->password.username_len;
memcpy(ptr, ai->password.username, ai->password.username_len);
ptr += ai->password.username_len;
*ptr++ = ai->password.password_len;
memcpy(ptr, ai->password.password, ai->password.password_len);
ptr += ai->password.password_len;
// start sending
PacketPassInterface_Sender_Send(o->control.send_if, (uint8_t *)o->buffer, size.value);
// set state
o->state = STATE_SENDING_PASSWORD;
} break;
default: ASSERT(0);
}
} break;
case STATE_SENT_REQUEST: {
BLog(BLOG_DEBUG, "received reply header");
struct socks_reply_header imsg;
memcpy(&imsg, o->buffer, sizeof(imsg));
if (ntoh8(imsg.ver) != SOCKS_VERSION) {
BLog(BLOG_NOTICE, "wrong version");
goto fail;
}
if (ntoh8(imsg.rep) != SOCKS_REP_SUCCEEDED) {
BLog(BLOG_NOTICE, "reply not successful");
goto fail;
}
int addr_len;
switch (ntoh8(imsg.atyp)) {
case SOCKS_ATYP_IPV4:
addr_len = sizeof(struct socks_addr_ipv4);
break;
case SOCKS_ATYP_IPV6:
addr_len = sizeof(struct socks_addr_ipv6);
break;
default:
BLog(BLOG_NOTICE, "reply has unknown address type");
goto fail;
}
// receive the rest of the reply
start_receive(o, (uint8_t *)o->buffer + sizeof(imsg), addr_len);
// set state
o->state = STATE_RECEIVED_REPLY_HEADER;
} break;
case STATE_SENT_PASSWORD: {
BLog(BLOG_DEBUG, "received password reply");
if (o->buffer[0] != 1) {
BLog(BLOG_NOTICE, "password reply has unknown version");
goto fail;
}
if (o->buffer[1] != 0) {
BLog(BLOG_NOTICE, "password reply is negative");
goto fail;
}
auth_finished(o);
} break;
case STATE_RECEIVED_REPLY_HEADER: {
BLog(BLOG_DEBUG, "received reply rest");
// free buffer
BFree(o->buffer);
o->buffer = NULL;
// free control I/O
free_control_io(o);
// init up I/O
init_up_io(o);
// set state
o->state = STATE_UP;
// call handler
o->handler(o->user, BSOCKSCLIENT_EVENT_UP);
return;
} break;
default:
ASSERT(0);
}
return;
fail:
report_error(o, BSOCKSCLIENT_EVENT_ERROR);
}
static void replace_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct replace_instance *o = vo;
o->i = i;
// read arguments
NCDValRef input_arg;
NCDValRef regex_arg;
NCDValRef replace_arg;
if (!NCDVal_ListRead(params->args, 3, &input_arg, ®ex_arg, &replace_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail1;
}
if (!NCDVal_IsString(input_arg) || !NCDVal_IsList(regex_arg) || !NCDVal_IsList(replace_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail1;
}
// check number of regex/replace
if (NCDVal_ListCount(regex_arg) != NCDVal_ListCount(replace_arg)) {
ModuleLog(i, BLOG_ERROR, "number of regex's is not the same as number of replacements");
goto fail1;
}
size_t num_regex = NCDVal_ListCount(regex_arg);
// allocate array for compiled regex's
regex_t *regs = BAllocArray(num_regex, sizeof(regs[0]));
if (!regs) {
ModuleLog(i, BLOG_ERROR, "BAllocArray failed");
goto fail1;
}
size_t num_done_regex = 0;
// compile regex's, check arguments
while (num_done_regex < num_regex) {
NCDValRef regex = NCDVal_ListGet(regex_arg, num_done_regex);
NCDValRef replace = NCDVal_ListGet(replace_arg, num_done_regex);
if (!NCDVal_IsStringNoNulls(regex) || !NCDVal_IsString(replace)) {
ModuleLog(i, BLOG_ERROR, "wrong regex/replace type for pair %zu", num_done_regex);
goto fail2;
}
// null terminate regex
NCDValNullTermString regex_nts;
if (!NCDVal_StringNullTerminate(regex, ®ex_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail2;
}
int res = regcomp(®s[num_done_regex], regex_nts.data, REG_EXTENDED);
NCDValNullTermString_Free(®ex_nts);
if (res != 0) {
ModuleLog(i, BLOG_ERROR, "regcomp failed for pair %zu (error=%d)", num_done_regex, res);
goto fail2;
}
num_done_regex++;
}
// init output string
ExpString out;
if (!ExpString_Init(&out)) {
ModuleLog(i, BLOG_ERROR, "ExpString_Init failed");
goto fail2;
}
// input state
MemRef in = NCDVal_StringMemRef(input_arg);
size_t in_pos = 0;
// process input
while (in_pos < in.len) {
// find first match
int have_match = 0;
size_t match_regex = 0; // to remove warning
regmatch_t match = {0, 0}; // to remove warning
for (size_t j = 0; j < num_regex; j++) {
regmatch_t this_match;
this_match.rm_so = 0;
this_match.rm_eo = in.len - in_pos;
if (regexec(®s[j], in.ptr + in_pos, 1, &this_match, REG_STARTEND) == 0 && (!have_match || this_match.rm_so < match.rm_so)) {
have_match = 1;
match_regex = j;
match = this_match;
}
}
// if no match, append remaining data and finish
if (!have_match) {
if (!ExpString_AppendBinaryMr(&out, MemRef_SubFrom(in, in_pos))) {
ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinaryMr failed");
goto fail3;
}
break;
}
// append data before match
if (!ExpString_AppendBinaryMr(&out, MemRef_Sub(in, in_pos, match.rm_so))) {
ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinaryMr failed");
goto fail3;
}
// append replacement data
NCDValRef replace = NCDVal_ListGet(replace_arg, match_regex);
if (!ExpString_AppendBinaryMr(&out, NCDVal_StringMemRef(replace))) {
ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinaryMr failed");
goto fail3;
}
in_pos += match.rm_eo;
}
// set output
o->output = ExpString_GetMr(&out);
// free compiled regex's
while (num_done_regex-- > 0) {
regfree(®s[num_done_regex]);
}
// free array
BFree(regs);
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail3:
ExpString_Free(&out);
fail2:
while (num_done_regex-- > 0) {
regfree(®s[num_done_regex]);
}
BFree(regs);
fail1:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef delimiter_arg;
NCDValRef input_arg;
NCDValRef limit_arg = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 2, &delimiter_arg, &input_arg) && !NCDVal_ListRead(params->args, 3, &delimiter_arg, &input_arg, &limit_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(delimiter_arg) || !NCDVal_IsString(input_arg) || (!NCDVal_IsInvalid(limit_arg) && !NCDVal_IsString(limit_arg))) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
size_t limit = SIZE_MAX;
if (!NCDVal_IsInvalid(limit_arg)) {
uintmax_t n;
if (!ncd_read_uintmax(limit_arg, &n) || n == 0) {
ModuleLog(i, BLOG_ERROR, "bad limit argument");
goto fail0;
}
n--;
limit = (n <= SIZE_MAX ? n : SIZE_MAX);
}
const char *del_data = NCDVal_StringData(delimiter_arg);
size_t del_len = NCDVal_StringLength(delimiter_arg);
if (del_len == 0) {
ModuleLog(i, BLOG_ERROR, "delimiter must be nonempty");
goto fail0;
}
size_t *table = BAllocArray(del_len, sizeof(table[0]));
if (!table) {
ModuleLog(i, BLOG_ERROR, "ExpArray_init failed");
goto fail0;
}
build_substring_backtrack_table(del_data, del_len, table);
if (!ExpArray_init(&o->arr, sizeof(struct substring), 8)) {
ModuleLog(i, BLOG_ERROR, "ExpArray_init failed");
goto fail1;
}
o->num = 0;
const char *data = NCDVal_StringData(input_arg);
size_t len = NCDVal_StringLength(input_arg);
while (1) {
size_t start;
int is_end = 0;
if (limit == 0 || !find_substring(data, len, del_data, del_len, table, &start)) {
start = len;
is_end = 1;
}
if (!ExpArray_resize(&o->arr, o->num + 1)) {
ModuleLog(i, BLOG_ERROR, "ExpArray_init failed");
goto fail2;
}
struct substring *elem = &((struct substring *)o->arr.v)[o->num];
if (!(elem->data = BAlloc(start))) {
ModuleLog(i, BLOG_ERROR, "BAlloc failed");
goto fail2;
}
memcpy(elem->data, data, start);
elem->len = start;
o->num++;
if (is_end) {
break;
}
data += start + del_len;
len -= start + del_len;
limit--;
}
BFree(table);
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail2:
while (o->num-- > 0) {
BFree(((struct substring *)o->arr.v)[o->num].data);
}
free(o->arr.v);
fail1:
BFree(table);
fail0:
NCDModuleInst_Backend_DeadError(i);
}
void NCDBProcessOpts_Free (NCDBProcessOpts *o)
{
if (o->username) {
BFree(o->username);
}
}
int NCDBProcessOpts_Init2 (NCDBProcessOpts *o, NCDValRef opts_arg, NCDBProcessOpts_func_unknown func_unknown, void *func_unknown_user, NCDModuleInst *i, int blog_channel,
int *out_keep_stdout, int *out_keep_stderr)
{
if (!NCDVal_IsInvalid(opts_arg) && !NCDVal_IsMap(opts_arg)) {
NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "options must be a map");
goto fail0;
}
o->username = NULL;
o->do_setsid = 0;
int keep_stdout = 0;
int keep_stderr = 0;
if (!NCDVal_IsInvalid(opts_arg)) {
for (NCDValMapElem me = NCDVal_MapFirst(opts_arg); !NCDVal_MapElemInvalid(me); me = NCDVal_MapNext(opts_arg, me)) {
NCDValRef key = NCDVal_MapElemKey(opts_arg, me);
NCDValRef val = NCDVal_MapElemVal(opts_arg, me);
if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "keep_stdout")) {
keep_stdout = ncd_read_boolean(val);
}
else if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "keep_stderr")) {
keep_stderr = ncd_read_boolean(val);
}
else if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "do_setsid")) {
o->do_setsid = ncd_read_boolean(val);
}
else if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "username")) {
if (!NCDVal_IsStringNoNulls(val)) {
NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "username must be a string without nulls");
goto fail1;
}
b_cstring cstr = NCDVal_StringCstring(val);
o->username = b_cstring_strdup(cstr, 0, cstr.length);
if (!o->username) {
NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "b_cstring_strdup failed");
goto fail1;
}
}
else {
if (!func_unknown || !func_unknown(func_unknown_user, key, val)) {
NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "unknown option");
goto fail1;
}
}
}
}
o->nfds = 0;
if (keep_stdout) {
o->fds[o->nfds] = 1;
o->fds_map[o->nfds++] = 1;
}
if (keep_stderr) {
o->fds[o->nfds] = 2;
o->fds_map[o->nfds++] = 2;
}
o->fds[o->nfds] = -1;
if (out_keep_stdout) {
*out_keep_stdout = keep_stdout;
}
if (out_keep_stderr) {
*out_keep_stderr = keep_stderr;
}
return 1;
fail1:
if (o->username) {
BFree(o->username);
}
fail0:
return 0;
}
int main ()
{
uint16_t a = 17501;
uint64_t c = 82688926;
uint16_t d1 = 1517;
uint16_t d2 = 1518;
uint8_t e = 72;
const char *f = "hello world";
const char *g = "helo";
// encode message
int len = msg1_SIZEa + msg1_SIZEc + msg1_SIZEd + msg1_SIZEd + msg1_SIZEe + msg1_SIZEf(strlen(f)) + msg1_SIZEg;
uint8_t *msg = (uint8_t *)BAlloc(len);
ASSERT_FORCE(msg)
msg1Writer writer;
msg1Writer_Init(&writer, msg);
msg1Writer_Adda(&writer, a);
msg1Writer_Addc(&writer, c);
msg1Writer_Addd(&writer, d1);
msg1Writer_Addd(&writer, d2);
msg1Writer_Adde(&writer, e);
uint8_t *f_dst = msg1Writer_Addf(&writer, strlen(f));
memcpy(f_dst, f, strlen(f));
uint8_t *g_dst = msg1Writer_Addg(&writer);
memcpy(g_dst, g, strlen(g));
int len2 = msg1Writer_Finish(&writer);
ASSERT_EXECUTE(len2 == len)
// parse message
msg1Parser parser;
ASSERT_EXECUTE(msg1Parser_Init(&parser, msg, len))
// check parse results
uint16_t p_a;
uint64_t p_c;
uint16_t p_d1;
uint16_t p_d2;
uint8_t p_e;
uint8_t *p_f;
int p_f_len;
uint8_t *p_g;
ASSERT_EXECUTE(msg1Parser_Geta(&parser, &p_a))
ASSERT_EXECUTE(msg1Parser_Getc(&parser, &p_c))
ASSERT_EXECUTE(msg1Parser_Getd(&parser, &p_d1))
ASSERT_EXECUTE(msg1Parser_Getd(&parser, &p_d2))
ASSERT_EXECUTE(msg1Parser_Gete(&parser, &p_e))
ASSERT_EXECUTE(msg1Parser_Getf(&parser, &p_f, &p_f_len))
ASSERT_EXECUTE(msg1Parser_Getg(&parser, &p_g))
ASSERT(p_a == a)
ASSERT(p_c == c)
ASSERT(p_d1 == d1)
ASSERT(p_d2 == d2)
ASSERT(p_e == e)
ASSERT(p_f_len == strlen(f) && !memcmp(p_f, f, p_f_len))
ASSERT(!memcmp(p_g, g, strlen(g)))
ASSERT(msg1Parser_GotEverything(&parser))
BFree(msg);
return 0;
}
