// e1 ; e2
inline bool do_Loop() {
if (!allocate(true)) return false;
CuMetaFirst left;
CuMetaFirst right;
if (!meta_StartFirstSets(input, node->arg.pair->left, &left)) {
CU_DEBUG(1, "meta_StartFirstSets checking left failed\n");
return false;
}
if (!meta_StartFirstSets(input, node->arg.pair->right, &right)) {
CU_DEBUG(1, "meta_StartFirstSets checking right failed\n");
return false;
}
result->type = inSequence(left->type, right->type);
merge(left);
if (pft_transparent == left->type) {
merge(right);
}
if (pft_event == left->type) {
merge(right);
}
return true;
}
static int _get_capabilities(const char *xml, struct capabilities *caps)
{
int len;
int ret = 0;
xmlDoc *xmldoc = NULL;
xmlXPathContext *xpathctx = NULL;
xmlXPathObject *xpathobj = NULL;
const xmlChar *xpathhoststr = (xmlChar *)"//capabilities//host";
const xmlChar *xpathgueststr = (xmlChar *)"//capabilities//guest";
xmlNodeSet *nsv;
len = strlen(xml) + 1;
if ((xmldoc = xmlParseMemory(xml, len)) == NULL)
goto err;
if ((xpathctx = xmlXPathNewContext(xmldoc)) == NULL)
goto err;
/* host node */
if ((xpathobj = xmlXPathEvalExpression(xpathhoststr, xpathctx)) == NULL)
goto err;
if (xmlXPathNodeSetIsEmpty(xpathobj->nodesetval)) {
CU_DEBUG("No capabilities host node found!");
goto err;
}
nsv = xpathobj->nodesetval;
if (!parse_cap_host(nsv, &caps->host))
goto err;
xmlXPathFreeObject(xpathobj);
/* all guest nodes */
if ((xpathobj = xmlXPathEvalExpression(xpathgueststr, xpathctx)) == NULL)
goto err;
if (xmlXPathNodeSetIsEmpty(xpathobj->nodesetval)) {
CU_DEBUG("No capabilities guest nodes found!");
goto err;
}
nsv = xpathobj->nodesetval;
caps->guests = calloc(nsv->nodeNr, sizeof(struct cap_guest));
if (caps->guests == NULL)
goto err;
caps->num_guests = nsv->nodeNr;
parse_cap_guests(nsv, caps->guests);
extend_defaults_cap_guests(caps);
ret = 1;
err:
xmlXPathFreeObject(xpathobj);
xmlXPathFreeContext(xpathctx);
xmlFreeDoc(xmldoc);
return ret;
}
int append_filter_rule(struct acl_filter *filter, struct acl_rule *rule)
{
struct acl_rule **old_rules = NULL;
if ((filter == NULL) || (rule == NULL))
return 0;
rule->name = make_rule_id(filter->name, filter->rule_ct);
if (rule->name == NULL)
return 0;
old_rules = filter->rules;
filter->rules =
malloc((filter->rule_ct + 1) * sizeof(struct acl_rule *));
if (filter->rules == NULL) {
CU_DEBUG("Failed to allocate memory for new rule");
filter->rules = old_rules;
return 0;
}
memcpy(filter->rules,
old_rules,
filter->rule_ct * sizeof(struct acl_rule *));
filter->rules[filter->rule_ct] = rule;
filter->rule_ct++;
free(old_rules);
return 1;
}
static void parse_cap_arch(struct cap_arch *cg_archinfo,
xmlNode *arch)
{
CU_DEBUG("Capabilities arch node: %s", arch->name);
xmlNode *child;
cg_archinfo->name = get_attr_value(arch, "name");
for (child = arch->children; child != NULL; child = child->next) {
if (XSTREQ(child->name, "wordsize")) {
char *wordsize_str;
unsigned int wordsize;
wordsize_str = get_node_content(child);
/* Default to 0 wordsize if garbage */
if (wordsize_str == NULL ||
sscanf(wordsize_str, "%i", &wordsize) != 1)
wordsize = 0;
free(wordsize_str);
cg_archinfo->wordsize = wordsize;
} else if (XSTREQ(child->name, "domain")) {
struct cap_domain *tmp_list = NULL;
tmp_list = realloc(cg_archinfo->domains,
(cg_archinfo->num_domains + 1) *
sizeof(struct cap_domain));
if (tmp_list == NULL) {
/* Nothing you can do. Just go on. */
CU_DEBUG("Could not alloc space for "
"guest domain");
continue;
}
memset(&tmp_list[cg_archinfo->num_domains],
0, sizeof(struct cap_domain));
cg_archinfo->domains = tmp_list;
parse_cap_domain(&cg_archinfo->
domains[cg_archinfo->num_domains],
child);
cg_archinfo->num_domains++;
} else {
/* Check for the default domain child nodes */
parse_cap_domain_info(&cg_archinfo->default_domain_info,
child);
}
}
}
static void parse_cap_domain(struct cap_domain *cg_domain,
xmlNode *guest_dom)
{
CU_DEBUG("Capabilities guest domain node: %s", guest_dom->name);
xmlNode *child;
cg_domain->typestr = get_attr_value(guest_dom, "type");
for (child = guest_dom->children; child != NULL; child = child->next)
parse_cap_domain_info(&cg_domain->guest_domain_info, child);
}
// e1 e2 /
inline bool do_Choice() {
if (!allocate(true)) return false;
CuMetaFirst left;
CuMetaFirst right;
if (!meta_StartFirstSets(input, node->arg.pair->left, &left)) {
CU_DEBUG(1, "meta_StartFirstSets checking left failed\n");
return false;
}
if (!meta_StartFirstSets(input, node->arg.pair->right, &right)) {
CU_DEBUG(1, "meta_StartFirstSets checking right failed\n");
return false;
}
result->type = inChoice(left->type, right->type);
merge(left);
merge(right);
return true;
}
static int parse_acl_mac_rule(xmlNode *rnode, struct acl_rule *rule)
{
CU_DEBUG("ACL mac rule %s", rnode->name);
rule->type = MAC_RULE;
rule->var.mac.protocol_id = get_attr_value(rnode, "protocolid");
rule->var.mac.srcmacaddr = get_attr_value(rnode, "srcmacaddr");
rule->var.mac.srcmacmask = get_attr_value(rnode, "srcmacmask");
rule->var.mac.dstmacaddr = get_attr_value(rnode, "dstmacaddr");
rule->var.mac.dstmacmask = get_attr_value(rnode, "dstmacmask");
rule->var.mac.comment = get_attr_value(rnode, "comment");
return 1;
}
int get_capabilities(virConnectPtr conn, struct capabilities **caps)
{
char *caps_xml = NULL;
int ret = 0;
if (conn == NULL) {
CU_DEBUG("Unable to connect to libvirt.");
return 0;
}
caps_xml = virConnectGetCapabilities(conn);
if (caps_xml == NULL) {
CU_DEBUG("Unable to get capabilities xml.");
return 0;
}
ret = get_caps_from_xml(caps_xml, caps);
free(caps_xml);
return ret;
}
static int parse_cap_host_cpu(struct cap_host *cap_host, xmlNode *cpu)
{
xmlNode *child;
for (child = cpu->children; child != NULL; child = child->next) {
if (XSTREQ(child->name, "arch")) {
cap_host->cpu_arch = get_node_content(child);
if (cap_host->cpu_arch != NULL)
return 1; /* success - host arch node found */
else {
CU_DEBUG("Host architecture is not defined");
break;
}
}
}
return 0; /* error - no arch node or empty arch node */
}
// e &
// e +
inline bool do_AssertChild() {
if (!allocate(true)) return false;
CuMetaFirst child;
if (!meta_StartFirstSets(input, node->arg.node, &child)) {
CU_DEBUG(1, "meta_StartFirstSets checking child failed\n");
return false;
}
// T(f&) = f, T(o&) = o, T(t&) = t, T(e&) = e
// T(f+) = f, T(o+) = o, T(t+) = t, T(e+) = ERROR
result->type = inRequired(child->type);
merge(child);
return true;
}
// e ?
// e *
inline bool do_TestChild() {
if (!allocate(true)) return false;
CuMetaFirst child;
if (!meta_StartFirstSets(input, node->arg.node, &child)) {
CU_DEBUG(1, "meta_StartFirstSets checking child failed\n");
return false;
}
// T(f?) = t, T(o?) = o, T(t?) = t, T(e?) = e
// T(f*) = t, T(o*) = o, T(t*) = t, T(e+) = ERROR
result->type = inOptional(child->type);
merge(child);
return true;
}
static void parse_cap_domain_info(struct cap_domain_info *cg_domaininfo,
xmlNode *domain_child_node)
{
CU_DEBUG("Capabilities guest domain info element node: %s",
domain_child_node->name);
if (XSTREQ(domain_child_node->name, "emulator")) {
cg_domaininfo->emulator =
get_node_content(domain_child_node);
} else if (XSTREQ(domain_child_node->name, "loader")) {
cg_domaininfo->loader =
get_node_content(domain_child_node);
} else if (XSTREQ(domain_child_node->name, "machine")) {
extend_cap_machines(cg_domaininfo,
get_node_content(domain_child_node),
get_attr_value(domain_child_node,
"canonical"));
}
}
int get_caps_from_xml(const char *xml, struct capabilities **caps)
{
CU_DEBUG("In get_caps_from_xml");
free(*caps);
*caps = calloc(1, sizeof(struct capabilities));
if (*caps == NULL)
goto err;
if (_get_capabilities(xml, *caps) == 0)
goto err;
return 1;
err:
free(*caps);
*caps = NULL;
return 0;
}
static int parse_acl_arp_rule(xmlNode *rnode, struct acl_rule *rule)
{
CU_DEBUG("ACL arp rule %s", rnode->name);
rule->type = ARP_RULE;
rule->var.arp.srcmacaddr = get_attr_value(rnode, "srcmacaddr");
rule->var.arp.srcmacmask = get_attr_value(rnode, "srcmacmask");
rule->var.arp.dstmacaddr = get_attr_value(rnode, "dstmacaddr");
rule->var.arp.dstmacmask = get_attr_value(rnode, "dstmacmask");
rule->var.arp.hw_type = get_attr_value(rnode, "hwtype");
rule->var.arp.protocol_type = get_attr_value(rnode, "protocoltype");
rule->var.arp.opcode = get_attr_value(rnode, "opcode");
rule->var.arp.arpsrcmacaddr = get_attr_value(rnode, "arpsrcmacaddr");
rule->var.arp.arpdstmacaddr = get_attr_value(rnode, "arpdstmacaddr");
rule->var.arp.arpsrcipaddr = get_attr_value(rnode, "arpsrcipaddr");
rule->var.arp.arpdstipaddr = get_attr_value(rnode, "arpdstipaddr");
rule->var.arp.comment = get_attr_value(rnode, "comment");
return 1;
}
static void extend_cap_machines(struct cap_domain_info *cg_domaininfo,
char *name, char *canonical_name)
{
struct cap_machine *tmp_list = NULL;
tmp_list = realloc(cg_domaininfo->machines,
(cg_domaininfo->num_machines + 1) *
sizeof(struct cap_machine));
if (tmp_list == NULL) {
/* Nothing you can do. Just go on. */
CU_DEBUG("Could not alloc space for "
"guest domain info list");
return;
}
cg_domaininfo->machines = tmp_list;
struct cap_machine *cap_gm =
&cg_domaininfo->machines[cg_domaininfo->num_machines];
cap_gm->name = name;
cap_gm->canonical_name = canonical_name;
cg_domaininfo->num_machines++;
}
static int parse_acl_ip_rule(xmlNode *rnode, struct acl_rule *rule)
{
CU_DEBUG("ACP ip rule %s", rnode->name);
rule->type = IP_RULE;
rule->var.ip.srcmacaddr = get_attr_value(rnode, "srcmacaddr");
rule->var.ip.srcmacmask = get_attr_value(rnode, "srcmacmask");
rule->var.ip.dstmacaddr = get_attr_value(rnode, "dstmacaddr");
rule->var.ip.dstmacmask = get_attr_value(rnode, "dstmacmaks");
rule->var.ip.srcipaddr = get_attr_value(rnode, "srcipaddr");
rule->var.ip.srcipmask = get_attr_value(rnode, "srcipmask");
rule->var.ip.dstipaddr = get_attr_value(rnode, "dstipaddr");
rule->var.ip.dstipmask = get_attr_value(rnode, "dstipmask");
rule->var.ip.protocol = get_attr_value(rnode, "protocol");
rule->var.ip.srcportstart = get_attr_value(rnode, "srcportstart");
rule->var.ip.srcportend = get_attr_value(rnode, "srcportend");
rule->var.ip.dstportstart = get_attr_value(rnode, "dstportstart");
rule->var.ip.dstportend = get_attr_value(rnode, "dstportend");
rule->var.ip.comment = get_attr_value(rnode, "comment");
return 1;
}
static int parse_acl_icmp_igmp_rule(xmlNode *rnode, struct acl_rule *rule)
{
CU_DEBUG("ACL %s rule %s", rule->protocol_id, rnode->name);
rule->type = ICMP_IGMP_RULE;
rule->var.icmp_igmp.srcmacaddr = get_attr_value(rnode, "srcmacaddr");
rule->var.icmp_igmp.srcmacmask = get_attr_value(rnode, "srcmacmask");
rule->var.icmp_igmp.dstmacaddr = get_attr_value(rnode, "dstmacaddr");
rule->var.icmp_igmp.dstmacmask = get_attr_value(rnode, "dstmacmask");
rule->var.icmp_igmp.srcipaddr = get_attr_value(rnode, "srcipaddr");
rule->var.icmp_igmp.srcipmask = get_attr_value(rnode, "srcipmask");
rule->var.icmp_igmp.dstipaddr = get_attr_value(rnode, "dstipaddr");
rule->var.icmp_igmp.dstipmask = get_attr_value(rnode, "dstipmask");
rule->var.icmp_igmp.srcipfrom = get_attr_value(rnode, "srcipfrom");
rule->var.icmp_igmp.srcipto = get_attr_value(rnode, "srcipto");
rule->var.icmp_igmp.dstipfrom = get_attr_value(rnode, "dstipfrom");
rule->var.icmp_igmp.dstipto = get_attr_value(rnode, "dstipto");
rule->var.icmp_igmp.comment = get_attr_value(rnode, "comment");
rule->var.icmp_igmp.state = get_attr_value(rnode, "state");
return 1;
}
static int parse_acl_tcp_rule(xmlNode *rnode, struct acl_rule *rule)
{
CU_DEBUG("ACL tcp rule %s", rnode->name);
rule->type = TCP_RULE;
rule->var.tcp.srcmacaddr = get_attr_value(rnode, "srcmacaddr");
rule->var.tcp.srcipaddr = get_attr_value(rnode, "srcipaddr");
rule->var.tcp.srcipmask = get_attr_value(rnode, "srcipmask");
rule->var.tcp.dstipaddr = get_attr_value(rnode, "dstipaddr");
rule->var.tcp.dstipmask = get_attr_value(rnode, "dstipmask");
rule->var.tcp.srcipfrom = get_attr_value(rnode, "srcipfrom");
rule->var.tcp.srcipto = get_attr_value(rnode, "srcipto");
rule->var.tcp.dstipfrom = get_attr_value(rnode, "dstipfrom");
rule->var.tcp.dstipto = get_attr_value(rnode, "dstipto");
rule->var.tcp.srcportstart = get_attr_value(rnode, "srcportstart");
rule->var.tcp.srcportend = get_attr_value(rnode, "srcportend");
rule->var.tcp.dstportstart = get_attr_value(rnode, "dstportstart");
rule->var.tcp.dstportend = get_attr_value(rnode, "dstportend");
rule->var.tcp.comment = get_attr_value(rnode, "comment");
rule->var.tcp.state = get_attr_value(rnode, "state");
return 1;
}
static CMPIStatus raise_indication(const CMPIBroker *broker,
const CMPIContext *ctx,
const CMPIObjectPath *ref,
const CMPIInstance *ind)
{
struct std_indication_ctx *_ctx = NULL;
CMPIStatus s = {CMPI_RC_OK, NULL};
struct ind_args *args = NULL;
CMPIObjectPath *_ref = NULL;
_ctx = malloc(sizeof(struct std_indication_ctx));
if (_ctx == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Unable to allocate indication context");
goto out;
}
_ctx->brkr = broker;
_ctx->handler = NULL;
_ctx->filters = filters;
_ctx->enabled = 1;
args = malloc(sizeof(struct ind_args));
if (args == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Unable to allocate ind_args");
goto out;
}
_ref = CMGetObjectPath(ind, &s);
if (_ref == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Got a null object path");
goto out;
}
/* FIXME: This is a Pegasus work around. Pegsus loses the namespace
when an ObjectPath is pulled from an instance */
CMSetNameSpace(_ref, "root/virt");
args->ns = strdup(NAMESPACE(_ref));
args->classname = strdup(CLASSNAME(_ref));
args->_ctx = _ctx;
/* This is a workaround for Pegasus, it loses its objectpath by
CMGetObjectPath. So set it back. */
ind->ft->setObjectPath((CMPIInstance *)ind, _ref);
s = stdi_deliver(broker, ctx, args, (CMPIInstance *)ind);
if (s.rc == CMPI_RC_OK) {
CU_DEBUG("Indication delivered");
} else {
if (s.msg == NULL) {
CU_DEBUG("Not delivered: msg is NULL.");
} else {
CU_DEBUG("Not delivered: %s", CMGetCharPtr(s.msg));
}
}
out:
if (args != NULL)
stdi_free_ind_args(&args);
if (_ctx != NULL)
free(_ctx);
return s;
}
