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;
}
