static av_cold int init(AVFilterContext *ctx) { StreamSelectContext *s = ctx->priv; int ret, nb_outputs = 0; char *map = s->map_str; if (!strcmp(ctx->filter->name, "astreamselect")) s->is_audio = 1; for (; map;) { char *p; strtol(map, &p, 0); if (map == p) break; nb_outputs++; map = p; } s->last_pts = av_calloc(s->nb_inputs, sizeof(*s->last_pts)); if (!s->last_pts) return AVERROR(ENOMEM); if ((ret = parse_definition(ctx, s->nb_inputs, filter_frame, s->is_audio)) < 0 || (ret = parse_definition(ctx, nb_outputs, NULL, s->is_audio)) < 0) return ret; av_log(ctx, AV_LOG_DEBUG, "Configured with %d inpad and %d outpad\n", ctx->nb_inputs, ctx->nb_outputs); return parse_mapping(ctx, s->map_str); }
int parse_database_mapping(cfg_t *cfg, lisp_xtr_t *xtr, shash_t *lcaf_ht) { int n,i; mapping_t *mapping; map_local_entry_t *map_loc_e; void *fwd_map_inf; n = cfg_size(cfg, "database-mapping"); for (i = 0; i < n; i++) { mapping = parse_mapping(cfg_getnsec(cfg, "database-mapping", i),&(xtr->super),lcaf_ht,TRUE); if (mapping == NULL){ continue; } map_loc_e = map_local_entry_new_init(mapping); if (map_loc_e == NULL){ mapping_del(mapping); continue; } fwd_map_inf = xtr->fwd_policy->new_map_loc_policy_inf(xtr->fwd_policy_dev_parm,mapping,NULL); if (fwd_map_inf == NULL){ OOR_LOG(LERR, "Couldn't create forward information for mapping with EID: %s. Discarding it...", lisp_addr_to_char(mapping_eid(mapping))); map_local_entry_del(map_loc_e); continue; } map_local_entry_set_fwd_info(map_loc_e, fwd_map_inf, xtr->fwd_policy->del_map_loc_policy_inf); if (add_local_db_map_local_entry(map_loc_e,xtr) != GOOD){ map_local_entry_del(map_loc_e); continue; } } return (GOOD); }
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags) { if (!strcmp(cmd, "map")) { int ret = parse_mapping(ctx, args); if (ret < 0) return ret; return avfilter_config_links(ctx); } return AVERROR(ENOSYS); }
static int parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int attr) { yaml_node_item_t *item; yaml_node_t *val; item = node->data.sequence.items.start; while (item < node->data.sequence.items.top) { val = yaml_document_get_node(doc, *item); switch (attr) { case PKG_CONFLICTS: if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) pkg_emit_error("Skipping malformed conflict"); else pkg_addconflict(pkg, val->data.scalar.value); break; case PKG_CATEGORIES: if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) pkg_emit_error("Skipping malformed category"); else pkg_addcategory(pkg, val->data.scalar.value); break; case PKG_LICENSES: if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) pkg_emit_error("Skipping malformed license"); else pkg_addlicense(pkg, val->data.scalar.value); break; case PKG_USERS: if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) pkg_emit_error("Skipping malformed license"); else pkg_adduser(pkg, val->data.scalar.value); break; case PKG_GROUPS: if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) pkg_emit_error("Skipping malformed license"); else pkg_addgroup(pkg, val->data.scalar.value); break; case PKG_DIRS: if (val->type == YAML_SCALAR_NODE && val->data.scalar.length > 0) pkg_adddir(pkg, val->data.scalar.value, 1); else if (val->type == YAML_MAPPING_NODE) parse_mapping(pkg, val, doc, attr); else pkg_emit_error("Skipping malformed dirs"); } ++item; } return (EPKG_OK); }
static VALUE parse_node(rb_yaml_parser_t *parser) { VALUE node; NEXT_EVENT(); switch (parser->event.type) { case YAML_DOCUMENT_END_EVENT: case YAML_MAPPING_END_EVENT: case YAML_SEQUENCE_END_EVENT: case YAML_STREAM_END_EVENT: return Qundef; case YAML_MAPPING_START_EVENT: node = parse_mapping(parser); break; case YAML_SEQUENCE_START_EVENT: node = parse_sequence(parser); break; case YAML_SCALAR_EVENT: node = parse_scalar(parser); break; case YAML_ALIAS_EVENT: // ignoring alias node = Qundef; break; default: rb_raise(rb_eArgError, "Invalid event %d at top level", (int)parser->event.type); } return node; }
int configure_ms(cfg_t *cfg) { char *iface_name; iface_t *iface; lisp_site_prefix_t *site; shash_t *lcaf_ht; int i; lisp_ms_t *ms; mapping_t *mapping; /* create and configure xtr */ if (ctrl_dev_create(MS_MODE, &ctrl_dev) != GOOD) { OOR_LOG(LCRIT, "Failed to create MS. Aborting!"); exit_cleanup(); } ms = CONTAINER_OF(ctrl_dev, lisp_ms_t, super); /* create lcaf hash table */ lcaf_ht = parse_lcafs(cfg); /* CONTROL INTERFACE */ /* TODO: should work with all interfaces in the future */ iface_name = cfg_getstr(cfg, "control-iface"); if (iface_name) { iface = add_interface(iface_name); if (iface == NULL) { return(BAD); } } if (iface_address(iface, AF_INET) == NULL){ iface_setup_addr(iface, AF_INET); data_plane->datap_add_iface_addr(iface,AF_INET); lctrl->control_data_plane->control_dp_add_iface_addr(lctrl,iface,AF_INET); } if (iface_address(iface, AF_INET6) == NULL){ iface_setup_addr(iface, AF_INET6); data_plane->datap_add_iface_addr(iface,AF_INET6); lctrl->control_data_plane->control_dp_add_iface_addr(lctrl,iface,AF_INET6); } /* LISP-SITE CONFIG */ for (i = 0; i < cfg_size(cfg, "lisp-site"); i++) { cfg_t *ls = cfg_getnsec(cfg, "lisp-site", i); site = build_lisp_site_prefix(ms, cfg_getstr(ls, "eid-prefix"), cfg_getint(ls, "iid"), cfg_getint(ls, "key-type"), cfg_getstr(ls, "key"), cfg_getbool(ls, "accept-more-specifics") ? 1:0, cfg_getbool(ls, "proxy-reply") ? 1:0, cfg_getbool(ls, "merge") ? 1 : 0, lcaf_ht); if (site != NULL) { if (mdb_lookup_entry(ms->lisp_sites_db, site->eid_prefix) != NULL){ OOR_LOG(LDBG_1, "Configuration file: Duplicated lisp-site: %s . Discarding...", lisp_addr_to_char(site->eid_prefix)); lisp_site_prefix_del(site); continue; } OOR_LOG(LDBG_1, "Adding lisp site prefix %s to the lisp-sites " "database", lisp_addr_to_char(site->eid_prefix)); ms_add_lisp_site_prefix(ms, site); }else{ OOR_LOG(LERR, "Can't add lisp-site prefix %s. Discarded ...", cfg_getstr(ls, "eid-prefix")); } } /* LISP REGISTERED SITES CONFIG */ for (i = 0; i< cfg_size(cfg, "ms-static-registered-site"); i++ ) { cfg_t *mss = cfg_getnsec(cfg, "ms-static-registered-site", i); mapping = parse_mapping(mss,&(ms->super),lcaf_ht,FALSE); if (mapping == NULL){ OOR_LOG(LERR, "Can't create static register site for %s", cfg_getstr(mss, "eid-prefix")); continue; } /* If the mapping doesn't exist, add it the the database */ if (mdb_lookup_entry_exact(ms->reg_sites_db, mapping_eid(mapping)) == NULL){ if (ms_add_registered_site_prefix(ms, mapping) == GOOD){ OOR_LOG(LDBG_1, "Added static registered site for %s to the registered sites list!", lisp_addr_to_char(mapping_eid(mapping))); }else{ OOR_LOG(LERR, "Failed to add static registered site for %s to the registered sites list!", lisp_addr_to_char(mapping_eid(mapping))); mapping_del(mapping); } }else{ OOR_LOG(LERR, "Configuration file: Duplicated static registered site for %s. Discarded ...", cfg_getstr(mss, "eid-prefix")); mapping_del(mapping); continue; } } /* destroy the hash table */ shash_destroy(lcaf_ht); return(GOOD); }
int configure_rtr(cfg_t *cfg) { lisp_xtr_t *xtr; shash_t *lcaf_ht; mapping_t *mapping; map_local_entry_t *map_loc_e; void *fwd_map_inf; int n,i; /* CREATE AND CONFIGURE RTR (xTR in fact) */ if (ctrl_dev_create(RTR_MODE, &ctrl_dev) != GOOD) { OOR_LOG(LCRIT, "Failed to create RTR. Aborting!"); return (BAD); } lcaf_ht = parse_lcafs(cfg); xtr = CONTAINER_OF(ctrl_dev, lisp_xtr_t, super); if (configure_tunnel_router(cfg, xtr, lcaf_ht)!=GOOD){ return (BAD); } /* INTERFACES CONFIG */ n = cfg_size(cfg, "rtr-ifaces"); if (n) { cfg_t *rifs = cfg_getsec(cfg, "rtr-ifaces"); int nr = cfg_size(rifs, "rtr-iface"); for(i = 0; i < nr; i++) { cfg_t *ri = cfg_getnsec(rifs, "rtr-iface", i); if (add_rtr_iface(xtr, cfg_getstr(ri, "iface"), cfg_getint(ri, "ip_version"), cfg_getint(ri, "priority"), cfg_getint(ri, "weight")) == GOOD) { OOR_LOG(LDBG_1, "Configured interface %s for RTR", cfg_getstr(ri, "iface")); } else{ OOR_LOG(LERR, "Can't configure iface %s for RTR", cfg_getstr(ri, "iface")); } } } /* RTR DATABASE MAPPINGS (like for instance replication lists) */ n = cfg_size(cfg, "rtr-database-mapping"); for (i = 0; i < n; i++) { mapping = parse_mapping(cfg_getnsec(cfg, "rtr-database-mapping",i),&(xtr->super),lcaf_ht,TRUE); if (mapping == NULL){ continue; } map_loc_e = map_local_entry_new_init(mapping); if (map_loc_e == NULL){ mapping_del(mapping); continue; } fwd_map_inf = xtr->fwd_policy->new_map_loc_policy_inf(xtr->fwd_policy_dev_parm,mapping,NULL); if (fwd_map_inf == NULL){ OOR_LOG(LERR, "Couldn't create forward information for rtr database mapping with EID: %s. Discarding it...", lisp_addr_to_char(mapping_eid(mapping))); map_local_entry_del(map_loc_e); continue; } map_local_entry_set_fwd_info(map_loc_e, fwd_map_inf, xtr->fwd_policy->del_map_loc_policy_inf); if (add_local_db_map_local_entry(map_loc_e,xtr) != GOOD){ map_local_entry_del(map_loc_e); continue; } if (add_local_db_map_local_entry(map_loc_e,xtr) != GOOD){ map_local_entry_del(map_loc_e); } } /* Deallocate PiTRs and PeTRs elements */ glist_destroy(xtr->pitrs); xtr->pitrs = NULL; shash_destroy(lcaf_ht); return(GOOD); }
int configure_tunnel_router(cfg_t *cfg, lisp_xtr_t *xtr, shash_t *lcaf_ht) { int i,n,ret; char *map_resolver; char *encap; mapping_t *mapping; /* FWD POLICY STRUCTURES */ xtr->fwd_policy = fwd_policy_class_find("flow_balancing"); xtr->fwd_policy_dev_parm = xtr->fwd_policy->new_dev_policy_inf(ctrl_dev,NULL); if ((encap = cfg_getstr(cfg, "encapsulation")) != NULL) { if (strcmp(encap, "LISP") == 0) { xtr->encap_type = ENCP_LISP; }else if (strcmp(encap, "VXLAN-GPE") == 0){ xtr->encap_type = ENCP_VXLAN_GPE; }else{ OOR_LOG(LERR, "Unknown encapsulation type: %s",encap); return (BAD); } } /* RETRIES */ ret = cfg_getint(cfg, "map-request-retries"); xtr->map_request_retries = (ret != 0) ? ret : DEFAULT_MAP_REQUEST_RETRIES; /* RLOC PROBING CONFIG */ cfg_t *dm = cfg_getnsec(cfg, "rloc-probing", 0); if (dm != NULL) { xtr->probe_interval = cfg_getint(dm, "rloc-probe-interval"); xtr->probe_retries = cfg_getint(dm, "rloc-probe-retries"); xtr->probe_retries_interval = cfg_getint(dm, "rloc-probe-retries-interval"); validate_rloc_probing_parameters(&xtr->probe_interval, &xtr->probe_retries, &xtr->probe_retries_interval); } else { OOR_LOG(LDBG_1, "Configuration file: RLOC probing not defined. " "Setting default values: RLOC Probing Interval: %d sec.", RLOC_PROBING_INTERVAL); xtr->probe_interval = RLOC_PROBING_INTERVAL; xtr->probe_retries = DEFAULT_RLOC_PROBING_RETRIES; xtr->probe_retries_interval = DEFAULT_RLOC_PROBING_RETRIES_INTERVAL; } /* MAP-RESOLVER CONFIG */ n = cfg_size(cfg, "map-resolver"); for(i = 0; i < n; i++) { if ((map_resolver = cfg_getnstr(cfg, "map-resolver", i)) != NULL) { if (add_server(map_resolver, xtr->map_resolvers) == GOOD){ OOR_LOG(LDBG_1, "Added %s to map-resolver list", map_resolver); }else{ OOR_LOG(LCRIT,"Can't add %s Map Resolver.",map_resolver); } } } /* STATIC MAP-CACHE CONFIG */ n = cfg_size(cfg, "static-map-cache"); for (i = 0; i < n; i++) { cfg_t *smc = cfg_getnsec(cfg, "static-map-cache", i); mapping = parse_mapping(smc,&(xtr->super),lcaf_ht,FALSE); if (mapping == NULL){ OOR_LOG(LERR, "Can't add static Map Cache entry with EID prefix %s. Discarded ...", cfg_getstr(smc, "eid-prefix")); continue; } if (mcache_lookup_exact(xtr->map_cache, mapping_eid(mapping)) == NULL){ if (tr_mcache_add_static_mapping(xtr, mapping) == GOOD){ OOR_LOG(LDBG_1, "Added static Map Cache entry with EID prefix %s in the database.", lisp_addr_to_char(mapping_eid(mapping))); }else{ OOR_LOG(LERR, "Can't add static Map Cache entry with EID prefix %s. Discarded ...", mapping_eid(mapping)); mapping_del(mapping); } }else{ OOR_LOG(LERR, "Configuration file: Duplicated static Map Cache entry with EID prefix %s." "Discarded ...",cfg_getstr(smc, "eid-prefix")); mapping_del(mapping); continue; } continue; } return (GOOD); }
static int parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int attr) { yaml_node_item_t *item; yaml_node_t *val; item = node->data.sequence.items.start; while (item < node->data.sequence.items.top) { val = yaml_document_get_node(doc, *item); switch (attr) { case PKG_CATEGORIES: if (!is_valid_yaml_scalar(val)) pkg_emit_error("Skipping malformed category"); else pkg_addcategory(pkg, val->data.scalar.value); break; case PKG_LICENSES: if (!is_valid_yaml_scalar(val)) pkg_emit_error("Skipping malformed license"); else pkg_addlicense(pkg, val->data.scalar.value); break; case PKG_USERS: if (is_valid_yaml_scalar(val)) pkg_adduser(pkg, val->data.scalar.value); else if (val->type == YAML_MAPPING_NODE) parse_mapping(pkg, val, doc, attr); else pkg_emit_error("Skipping malformed license"); break; case PKG_GROUPS: if (is_valid_yaml_scalar(val)) pkg_addgroup(pkg, val->data.scalar.value); else if (val->type == YAML_MAPPING_NODE) parse_mapping(pkg, val, doc, attr); else pkg_emit_error("Skipping malformed license"); break; case PKG_DIRS: if (is_valid_yaml_scalar(val)) pkg_adddir(pkg, val->data.scalar.value, 1, false); else if (val->type == YAML_MAPPING_NODE) parse_mapping(pkg, val, doc, attr); else pkg_emit_error("Skipping malformed dirs"); break; case PKG_SHLIBS_REQUIRED: if (!is_valid_yaml_scalar(val)) pkg_emit_error("Skipping malformed required shared library"); else pkg_addshlib_required(pkg, val->data.scalar.value); break; case PKG_SHLIBS_PROVIDED: if (!is_valid_yaml_scalar(val)) pkg_emit_error("Skipping malformed provided shared library"); else pkg_addshlib_provided(pkg, val->data.scalar.value); break; } ++item; } return (EPKG_OK); }
/************************************************************************ * Main function ***********************************************************************/ int main(int argc, char **argv) { XCape_t *self = malloc(sizeof(XCape_t)); int dummy, ch; static char default_mapping[] = "Num_Lock;Caps_Lock"; char *mapping = default_mapping; self->debug = False; while ((ch = getopt(argc, argv, "d")) != -1) { switch (ch) { case 'd': self->debug = True; break; default: fprintf(stdout, "Usage: %s [-d]\n", argv[0]); fprintf(stdout, "Runs as a daemon unless -d flag is set\n"); return EXIT_SUCCESS; } } self->data_conn = XOpenDisplay(NULL); self->ctrl_conn = XOpenDisplay(NULL); if (!self->data_conn || !self->ctrl_conn) { fprintf(stderr, "Unable to connect to X11 display. Is $DISPLAY set?\n"); exit(EXIT_FAILURE); } if (!XQueryExtension(self->ctrl_conn, "XTEST", &dummy, &dummy, &dummy)) { fprintf(stderr, "Xtst extension missing\n"); exit(EXIT_FAILURE); } if (!XRecordQueryVersion(self->ctrl_conn, &dummy, &dummy)) { fprintf(stderr, "Failed to obtain xrecord version\n"); exit(EXIT_FAILURE); } if (!XkbQueryExtension(self->ctrl_conn, &dummy, &dummy, &dummy, &dummy, &dummy)) { fprintf(stderr, "Failed to obtain xkb version\n"); exit(EXIT_FAILURE); } self->map = parse_mapping(self->ctrl_conn, mapping); if (self->map == NULL) exit(EXIT_FAILURE); if (self->debug != True) daemon(0, 0); sigemptyset(&self->sigset); sigaddset(&self->sigset, SIGINT); sigaddset(&self->sigset, SIGTERM); pthread_sigmask(SIG_BLOCK, &self->sigset, NULL); pthread_create(&self->sigwait_thread, NULL, sig_handler, self); XRecordRange *rec_range = XRecordAllocRange(); rec_range->device_events.first = KeyPress; rec_range->device_events.last = ButtonRelease; XRecordClientSpec client_spec = XRecordAllClients; self->record_ctx = XRecordCreateContext(self->ctrl_conn, 0, &client_spec, 1, &rec_range, 1); if (self->record_ctx == 0) { fprintf(stderr, "Failed to create xrecord context\n"); exit(EXIT_FAILURE); } XSync(self->ctrl_conn, False); if (!XRecordEnableContext(self->data_conn, self->record_ctx, intercept, (XPointer) self)) { fprintf(stderr, "Failed to enable xrecord context\n"); exit(EXIT_FAILURE); } if (!XRecordFreeContext(self->ctrl_conn, self->record_ctx)) { fprintf(stderr, "Failed to free xrecord context\n"); } XCloseDisplay(self->ctrl_conn); XCloseDisplay(self->data_conn); if (self->debug) fprintf(stdout, "main exiting\n"); return EXIT_SUCCESS; }