void
view_setup(FileView *view)
{
view->list_rows = 0;
view->dir_entry = NULL;
assert_success(filter_init(&view->local_filter.filter, 1));
assert_success(filter_init(&view->manual_filter, 1));
assert_success(filter_init(&view->auto_filter, 1));
view->sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(view, view->sort);
}
static void
init_view(FileView *view)
{
filter_init(&view->local_filter.filter, 1);
filter_init(&view->manual_filter, 1);
filter_init(&view->auto_filter, 1);
view->dir_entry = NULL;
view->list_rows = 0;
view->window_rows = 1;
view->sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(view, view->sort);
}
void
view_setup(view_t *view)
{
char *error;
view->list_rows = 0;
view->dir_entry = NULL;
assert_success(filter_init(&view->local_filter.filter, 1));
assert_non_null(view->manual_filter = matcher_alloc("", 0, 0, "", &error));
assert_success(filter_init(&view->auto_filter, 1));
view->sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(view, view->sort);
}
/**
* Homes the filterwheel.
*
* @param standalone, 0 or 1, indicates if this function is called on its own
* @return Zero on success, non-zero on failure.
*/
int filter_home(int standalone) {
long status;
int err;
if (standalone) {
err = filter_init();
if (err) return err;
}
/* Home the filter by setting the position to -1 */
CALLFLIAPI(FLISetFilterPos(fli->active_filter, -1), "FLISetFilterPos(-1)");
/* check if it has really arrived at home */
CALLFLIAPI(FLIGetDeviceStatus(fli->active_filter, &status), "FLIGetDeviceStatus");
/* the 0x80 status means that it's at home */
if (status == 0x80) {
fli->current_filter = 1;
} else {
fprintf(stderr, "filter has failed to home\n");
return -1;
}
if (standalone) {
err = filter_fini();
if (err) return err;
}
return (0);
}
gboolean filter_close_comms_port (void)
{
/* Close the requested filter wheel type */
if (!fw.Open) /* return if already closed */
return TRUE;
switch (fw.device) {
case INTERNAL:
break;
#ifdef HAVE_SX_FILTERWHEEL
case SX: /* Assume direct USB connection */
if (!sxf_connect (FALSE, NULL))
return show_error (__func__, "Unable to close filter wheel!");
fw.Open = FALSE;
break;
#endif
case OTHER: /* INDI etc */
break;
default:
break;
}
filter_init ();
L_print ("{b}****---->>>> Filter wheel closed\n");
return TRUE;
}
/**
* Prints information about the filterwheel.
*
* @return Zero on success, non-zero on failure.
*/
int filter_info() {
long fwrev, hwrev, filter_count;
char * serial;
char * model;
char * lib_version;
int err;
err = filter_init();
if (err) return err;
lib_version = (char*) malloc((128) * sizeof (char));
model = (char*) malloc((128) * sizeof (char));
serial = (char*) malloc((128) * sizeof (char));
CALLFLIAPI(FLIGetFWRevision(fli->active_filter, &fwrev), "FLIGetFWRevision");
CALLFLIAPI(FLIGetHWRevision(fli->active_filter, &hwrev), "FLIGetHWRevision");
CALLFLIAPI(FLIGetSerialString(fli->active_filter, serial, 128), "FLIGetSerialString");
CALLFLIAPI(FLIGetModel(fli->active_filter, model, 128), "FLIGetModel");
CALLFLIAPI(FLIGetLibVersion(lib_version, 128), "FLIGetLibVersion");
CALLFLIAPI(FLIGetFilterCount(fli->active_filter, &filter_count), "FLIGetFilterCount");
fprintf(stdout, "filterwheel FW revision: 0x%04lx\n", fwrev);
fprintf(stdout, "filterwheel HW revision: 0x%04lx\n", hwrev);
fprintf(stdout, "filterwheel serial number: %s\n", serial);
fprintf(stdout, "filterwheel model: %s\n", model);
fprintf(stdout, "FLI lib version: %s\n", lib_version);
fprintf(stdout, "filterwheel, number of filters: %ld\n", filter_count);
err = filter_fini();
if (err) return err;
return (0);
}
void do_passthrough(void)
{
timer_stop();
free_all_filters();
free_all_buf();
filters_count = 2;
filters_buf[0] = 0;
filters_buf[1] = 0;
filters_buf[2] = 1;
filters_buf[3] = 0;
filters_buf[4] = 0;
filters_buf[5] = 0;
filters_buf[6] = 0;
filters_buf[7] = 0;
filters_buf[8+0] = 1;
filters_buf[8+1] = 1;
filters_buf[8+2] = 0;
filters_buf[8+3] = 0;
filters_buf[8+4] = 0;
filters_buf[8+5] = 0;
filters_buf[8+6] = 0;
filters_buf[8+7] = 0;
filter_init(filters_buf, filters_count);
timer_start();
}
enum sec_status
nsec3_prove_nxornodata(struct module_env* env, struct val_env* ve,
struct ub_packed_rrset_key** list, size_t num,
struct query_info* qinfo, struct key_entry_key* kkey, int* nodata)
{
enum sec_status sec, secnx;
rbtree_t ct;
struct nsec3_filter flt;
*nodata = 0;
if(!list || num == 0 || !kkey || !key_entry_isgood(kkey))
return sec_status_bogus; /* no valid NSEC3s, bogus */
rbtree_init(&ct, &nsec3_hash_cmp); /* init names-to-hash cache */
filter_init(&flt, list, num, qinfo); /* init RR iterator */
if(!flt.zone)
return sec_status_bogus; /* no RRs */
if(nsec3_iteration_count_high(ve, &flt, kkey))
return sec_status_insecure; /* iteration count too high */
/* try nxdomain and nodata after another, while keeping the
* hash cache intact */
secnx = nsec3_do_prove_nameerror(env, &flt, &ct, qinfo);
if(secnx==sec_status_secure)
return sec_status_secure;
sec = nsec3_do_prove_nodata(env, &flt, &ct, qinfo);
if(sec==sec_status_secure) {
*nodata = 1;
} else if(sec == sec_status_insecure) {
*nodata = 1;
} else if(secnx == sec_status_insecure) {
sec = sec_status_insecure;
}
return sec;
}
void
view_setup(FileView *view)
{
view->list_rows = 0;
view->filtered = 0;
view->list_pos = 0;
view->dir_entry = NULL;
assert_success(filter_init(&view->local_filter.filter, 1));
assert_success(filter_init(&view->manual_filter, 1));
assert_success(filter_init(&view->auto_filter, 1));
strcpy(view->curr_dir, "/path");
update_string(&view->custom.orig_dir, NULL);
view->sort[0] = SK_BY_NAME;
memset(&view->sort[1], SK_NONE, sizeof(view->sort) - 1);
}
static struct filter *
normalize_filter_init(G_GNUC_UNUSED const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
struct normalize_filter *filter = g_new(struct normalize_filter, 1);
filter_init(&filter->filter, &normalize_filter_plugin);
return &filter->filter;
}
static struct filter *
volume_filter_init(G_GNUC_UNUSED const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
struct volume_filter *filter = g_new(struct volume_filter, 1);
filter_init(&filter->filter, &volume_filter_plugin);
filter->volume = PCM_VOLUME_1;
return &filter->filter;
}
static void list_filter_init(list_t *list)
{
/* Init filter lists */
list->fl_periph.filter = filter_init();
list->fl_tag.filter = filter_init();
list->fl_case.filter = filter_init();
/* Connect filtering event handlers */
filter_connect_select(list->fl_periph.filter, (filter_event_t *) event_periph_select, list);
filter_connect_unselect(list->fl_periph.filter, (filter_event_t *) event_periph_unselect, list);
filter_connect_destroyed(list->fl_periph.filter, event_destroyed, &(list->fl_periph));
filter_connect_select(list->fl_tag.filter, (filter_event_t *) event_tag_select, list);
filter_connect_unselect(list->fl_tag.filter, (filter_event_t *) event_tag_unselect, list);
filter_connect_destroyed(list->fl_tag.filter, event_destroyed, &(list->fl_tag));
filter_connect_select(list->fl_case.filter, (filter_event_t *) event_case_select, list);
filter_connect_unselect(list->fl_case.filter, (filter_event_t *) event_case_unselect, list);
filter_connect_destroyed(list->fl_case.filter, event_destroyed, &(list->fl_case));
}
struct filter *
autoconvert_filter_new(struct filter *_filter)
{
struct autoconvert_filter *filter =
g_new(struct autoconvert_filter, 1);
filter_init(&filter->base, &autoconvert_filter_plugin);
filter->filter = _filter;
return &filter->base;
}
static void
test_append_escapes(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_append(&filter, "ef|gh"));
assert_true(filter_matches(&filter, "ef|gh"));
filter_dispose(&filter);
}
static struct filter *
chain_filter_init(G_GNUC_UNUSED const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
struct filter_chain *chain = g_new(struct filter_chain, 1);
filter_init(&chain->base, &chain_filter_plugin);
chain->children = NULL;
return &chain->base;
}
static void
test_set_to_empty_is_like_clear(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, ""));
assert_true(filter_is_empty(&filter));
filter_dispose(&filter);
}
static void
decoder_init (decoder * tta, long nch, long byte_size)
{
long shift = flt_set[byte_size - 1];
long i;
for (i = 0; i < nch; i++) {
filter_init (&tta[i].fst, shift);
rice_init (&tta[i].rice, 10, 10);
tta[i].last = 0;
}
}
/* Resets filter to empty state (either initializes or clears it). */
static void
reset_filter(filter_t *filter)
{
if(filter->raw == NULL)
{
(void)filter_init(filter, FILTER_DEF_CASE_SENSITIVITY);
}
else
{
filter_clear(filter);
}
}
static struct filter *
route_filter_init(const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
struct route_filter *filter = g_new(struct route_filter, 1);
filter_init(&filter->base, &route_filter_plugin);
// Allocate and set the filter->sources[] array
route_filter_parse(param, filter, error_r);
return &filter->base;
}
/*
* NAME: filter->new()
* DESCRIPTION: allocate a new filter object and chain it to another
*/
struct filter *filter_new(filter_func_t *func, void *data,
struct filter *chain)
{
struct filter *filter;
filter = malloc(sizeof(*filter));
if (filter) {
filter_init(filter, func, data, chain);
filter->flags |= FILTER_FLAG_DMEM;
}
return filter;
}
int frame_command_init(shell_t *shell, frame_display_t *display)
{
/* Init frame filters */
filter_init();
/* Setup frame commands */
shell_set_cmd(shell, frame_command_set);
shell_std_set_help(frame_command_help);
/* Set display pointer */
frame_command_display = display;
return 0;
}
static struct filter *
replay_gain_filter_init(G_GNUC_UNUSED const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
struct replay_gain_filter *filter = g_new(struct replay_gain_filter, 1);
filter_init(&filter->filter, &replay_gain_filter_plugin);
filter->mixer = NULL;
filter->mode = replay_gain_mode;
replay_gain_info_init(&filter->info);
filter->volume = PCM_VOLUME_1;
return &filter->filter;
}
SETUP()
{
char cwd[PATH_MAX];
assert_success(chdir(SANDBOX_PATH));
assert_true(get_cwd(cwd, sizeof(cwd)) == cwd);
copy_str(view->curr_dir, sizeof(view->curr_dir), cwd);
assert_success(os_mkdir("0", 0000));
assert_success(os_mkdir("1", 0000));
assert_success(os_mkdir("2", 0000));
assert_success(os_mkdir("3", 0000));
filter_init(&view->local_filter.filter, 1);
filter_init(&view->manual_filter, 1);
filter_init(&view->auto_filter, 1);
view->sort[0] = SK_BY_NAME;
memset(&view->sort[1], SK_NONE, sizeof(view->sort) - 1);
view->dir_entry = NULL;
view->list_rows = 0;
populate_dir_list(view, 0);
}
/**
* @brief create a thread for temperature measurement
* @param None
* @retval The thread ID for temperature
*/
osThreadId temperature_Thread_Create(void)
{
//initialize ADC
temperature_Init();
pwm_alarm_init();
//create semaphore
tempeature_semaphore = osSemaphoreCreate(osSemaphore(tempeature_semaphore), 1);
//initialize filter
filter_init(&temperature_filter_struct, 20);
temperature_filter_struct.mutexId = osMutexCreate(osMutex (temperatureFilterMutex));
//create temperature thread
tempeature_thread_id = osThreadCreate(osThread(temperature_Thread), NULL);
return tempeature_thread_id;
}
static void
test_regexp_is_changed(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_int_equal(0, filter_change(&filter, "a123", 0));
assert_false(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "a123"));
filter_dispose(&filter);
}
static void
test_filter_matches_differently_after_set(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_int_equal(0, filter_set(&filter, "a123"));
assert_false(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "a123"));
filter_dispose(&filter);
}
static void
test_append_produces_desired_effect(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_false(filter_matches(&filter, "efgh"));
assert_int_equal(0, filter_append(&filter, "efgh"));
assert_true(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "efgh"));
filter_dispose(&filter);
}
static void
test_case_sensitivity_is_changed(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_false(filter_matches(&filter, "aBCd"));
assert_int_equal(0, filter_change(&filter, "abcd", 0));
assert_true(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "aBCd"));
filter_dispose(&filter);
}
static void
test_empty_value_not_appended(void)
{
char *initial_value;
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
initial_value = strdup(filter.raw);
assert_int_equal(1, filter_append(&filter, ""));
assert_string_equal(initial_value, filter.raw);
free(initial_value);
filter_dispose(&filter);
}
enum sec_status
nsec3_prove_wildcard(struct module_env* env, struct val_env* ve,
struct ub_packed_rrset_key** list, size_t num,
struct query_info* qinfo, struct key_entry_key* kkey, uint8_t* wc)
{
rbtree_t ct;
struct nsec3_filter flt;
struct ce_response ce;
uint8_t* nc;
size_t nc_len;
size_t wclen;
(void)dname_count_size_labels(wc, &wclen);
if(!list || num == 0 || !kkey || !key_entry_isgood(kkey))
return sec_status_bogus; /* no valid NSEC3s, bogus */
rbtree_init(&ct, &nsec3_hash_cmp); /* init names-to-hash cache */
filter_init(&flt, list, num, qinfo); /* init RR iterator */
if(!flt.zone)
return sec_status_bogus; /* no RRs */
if(nsec3_iteration_count_high(ve, &flt, kkey))
return sec_status_insecure; /* iteration count too high */
/* We know what the (purported) closest encloser is by just
* looking at the supposed generating wildcard.
* The *. has already been removed from the wc name.
*/
memset(&ce, 0, sizeof(ce));
ce.ce = wc;
ce.ce_len = wclen;
/* Now we still need to prove that the original data did not exist.
* Otherwise, we need to show that the next closer name is covered. */
next_closer(qinfo->qname, qinfo->qname_len, ce.ce, &nc, &nc_len);
if(!find_covering_nsec3(env, &flt, &ct, nc, nc_len,
&ce.nc_rrset, &ce.nc_rr)) {
verbose(VERB_ALGO, "proveWildcard: did not find a covering "
"NSEC3 that covered the next closer name.");
return sec_status_bogus;
}
if(ce.nc_rrset && nsec3_has_optout(ce.nc_rrset, ce.nc_rr)) {
verbose(VERB_ALGO, "proveWildcard: NSEC3 optout");
return sec_status_insecure;
}
return sec_status_secure;
}
