int OTPCalculator_Init (OTPCalculator *calc, int num_otps, int cipher)
{
ASSERT(num_otps >= 0)
ASSERT(BEncryption_cipher_valid(cipher))
// init arguments
calc->num_otps = num_otps;
calc->cipher = cipher;
// remember block size
calc->block_size = BEncryption_cipher_block_size(calc->cipher);
// calculate number of blocks
if (calc->num_otps > SIZE_MAX / sizeof(otp_t)) {
goto fail0;
}
calc->num_blocks = bdivide_up(calc->num_otps * sizeof(otp_t), calc->block_size);
// allocate buffer
if (!(calc->data = (otp_t *)BAllocArray(calc->num_blocks, calc->block_size))) {
goto fail0;
}
// init debug object
DebugObject_Init(&calc->d_obj);
return 1;
fail0:
return 0;
}
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;
}
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;
}
int NCDPlaceholderDb_Init (NCDPlaceholderDb *o, NCDStringIndex *string_index)
{
ASSERT(string_index)
o->count = 0;
o->capacity = 1;
o->string_index = string_index;
if (!(o->arr = BAllocArray(o->capacity, sizeof(o->arr[0])))) {
BLog(BLOG_ERROR, "NCDPlaceholderDb_Init failed");
return 0;
}
return 1;
}
int PacketBuffer_Init (PacketBuffer *buf, PacketRecvInterface *input, PacketPassInterface *output, int num_packets, BPendingGroup *pg)
{
ASSERT(PacketPassInterface_GetMTU(output) >= PacketRecvInterface_GetMTU(input))
ASSERT(num_packets > 0)
// init arguments
buf->input = input;
buf->output = output;
// init input
PacketRecvInterface_Receiver_Init(buf->input, (PacketRecvInterface_handler_done)input_handler_done, buf);
// set input MTU
buf->input_mtu = PacketRecvInterface_GetMTU(buf->input);
// init output
PacketPassInterface_Sender_Init(buf->output, (PacketPassInterface_handler_done)output_handler_done, buf);
// allocate buffer
int num_blocks = ChunkBuffer2_calc_blocks(buf->input_mtu, num_packets);
if (num_blocks < 0) {
goto fail0;
}
if (!(buf->buf_data = BAllocArray(num_blocks, sizeof(buf->buf_data[0])))) {
goto fail0;
}
// init buffer
ChunkBuffer2_Init(&buf->buf, buf->buf_data, num_blocks, buf->input_mtu);
// schedule receive
PacketRecvInterface_Receiver_Recv(buf->input, buf->buf.input_dest);
DebugObject_Init(&buf->d_obj);
return 1;
fail0:
return 0;
}
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);
}