int main(int argc, char *argv[])
{
XMLROOT *root = NULL;
XMLNODE *node = NULL;
struct cstring *xml_string=NULL;
CLOG_INFO *log = NULL;
printf("cXML test program\n");
log = clog_open("test.log", clog_getlevel("TRACE"),NULL,0);
root = xml_root_new(log);
if(0==xml_fread(log, root, argv[1])) {
fprintf(stderr, "Something was wrong with the XML File, please check the log!\n");
xml_root_free(log, root);
exit(1);
}
xml_string = xml_node_tostring(log, root->data);
if(NULL!=xml_string) {
fprintf(stderr, "%s\n", xml_string->string);
cstring_free(&xml_string);
}
xml_root_free(log, root);
{ // test xml creation functionality..
XMLNODE* tmpx = NULL;
XMLNODE* tmpy = NULL;
node = xml_node_create(log, NULL, "tickets_container", 17);
xml_node_addattribute(log, node, "bob", "3");
tmpx = xml_node_create(log, node, "ticket", 6);
tmpy = xml_node_create(log, tmpx, "id", 2);
xml_node_adddata(log, tmpy, "3", 1);
xml_string = xml_node_tostring(log, node);
if(0!=xml_string->length) {
fprintf(stderr, "%s\n", xml_string->string);
cstring_free(&xml_string);
}
xml_node_free(log, node);
}
clog_close(log);
return EXIT_SUCCESS;
}
static void
xml_node_dict_set(xml_node_t *parent, const char *name, const char *value)
{
xml_node_t *child;
if (!value || !*value)
return;
child = xml_node_create(parent, name);
xml_node_set_cdata(child, value);
}
static ni_bool_t
__ni_compat_generate_vlan(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_vlan_t *vlan;
xml_node_t *child;
vlan = ni_netdev_get_vlan(compat->dev);
child = xml_node_create(ifnode, "vlan");
xml_node_new_element("device", child, vlan->parent.name);
xml_node_new_element("tag", child, ni_sprint_uint(vlan->tag));
return TRUE;
}
static xml_node_t *
__ni_compat_generate_static_address_list(xml_node_t *ifnode, ni_address_t *addr_list, unsigned int af)
{
ni_address_t *ap;
const char *afname;
xml_node_t *aconf = NULL;
afname = ni_addrfamily_type_to_name(af);
if (!afname) {
ni_error("%s: unknown address family %u", __func__, af);
return NULL;
}
for (ap = addr_list; ap; ap = ap->next) {
xml_node_t *anode;
if (ap->family != af)
continue;
if (aconf == NULL) {
char buffer[64];
snprintf(buffer, sizeof(buffer), "%s:static", afname);
aconf = xml_node_create(ifnode, buffer);
}
anode = xml_node_new("address", aconf);
xml_node_new_element("local", anode, ni_sockaddr_prefix_print(&ap->local_addr, ap->prefixlen));
if (ap->peer_addr.ss_family != AF_UNSPEC)
xml_node_new_element("peer", anode, ni_sockaddr_print(&ap->peer_addr));
if (ap->bcast_addr.ss_family != AF_UNSPEC)
xml_node_new_element("broadcast", anode, ni_sockaddr_print(&ap->bcast_addr));
if (ap->label)
xml_node_new_element("label", anode, ap->label);
}
return aconf;
}
static ni_bool_t
__ni_compat_generate_ifcfg(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
const ni_netdev_t *dev = compat->dev;
xml_node_t *linknode;
if (compat->control) {
const ni_ifworker_control_t *control = compat->control;
xml_node_t *child, *linkdet;
child = xml_node_create(ifnode, "control");
if (control->mode)
xml_node_new_element("mode", child, control->mode);
if (control->boot_stage)
xml_node_new_element("boot-stage", child, control->boot_stage);
if (control->link_timeout || control->link_required) {
linkdet = xml_node_create(child, "link-detection");
if (control->link_timeout)
xml_node_new_element("timeout", linkdet,
ni_sprint_timeout(control->link_timeout));
if (control->link_required)
(void) xml_node_new("require-link", linkdet);
}
}
switch (dev->link.type) {
case NI_IFTYPE_ETHERNET:
__ni_compat_generate_ethernet(ifnode, compat);
break;
case NI_IFTYPE_INFINIBAND:
case NI_IFTYPE_INFINIBAND_CHILD:
__ni_compat_generate_infiniband(ifnode, compat);
break;
case NI_IFTYPE_BOND:
__ni_compat_generate_bonding(ifnode, compat);
break;
case NI_IFTYPE_BRIDGE:
__ni_compat_generate_bridge(ifnode, compat);
break;
case NI_IFTYPE_VLAN:
__ni_compat_generate_vlan(ifnode, compat);
break;
case NI_IFTYPE_WIRELESS:
__ni_compat_generate_wireless(ifnode, compat);
break;
default: ;
}
linknode = xml_node_new("link", ifnode);
if (dev->link.mtu)
xml_node_new_element("mtu", linknode, ni_sprint_uint(dev->link.mtu));
__ni_compat_generate_static_addrconf(ifnode, compat);
__ni_compat_generate_dhcp4_addrconf(ifnode, compat);
__ni_compat_generate_dhcp6_addrconf(ifnode, compat);
return TRUE;
}
static ni_bool_t
__ni_compat_generate_wireless(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_wireless_t *wlan;
ni_wireless_network_t *net;
xml_node_t *wireless, *network, *wep, *wpa_psk, *wpa_eap;
ni_wireless_blob_t *cert;
char *tmp = NULL;
const char *value;
int i, count, key_i;
wlan = ni_netdev_get_wireless(compat->dev);
if (!(wireless = xml_node_create(ifnode, "wireless"))) {
return FALSE;
}
if (ni_string_len(wlan->conf.country) == 2) {
xml_node_new_element("country", wireless, wlan->conf.country);
}
if (wlan->conf.ap_scan <= NI_WIRELESS_AP_SCAN_SUPPLICANT_EXPLICIT_MATCH &&
ni_string_printf(&tmp, "%u", wlan->conf.ap_scan)) {
xml_node_new_element("ap-scan", wireless, tmp);
ni_string_free(&tmp);
}
if (!ni_string_empty(wlan->conf.driver))
xml_node_new_element("wpa-driver", wireless, wlan->conf.driver);
count = wlan->conf.networks.count;
for (i = 0; i < count; i++) {
net = wlan->conf.networks.data[i];
if (!(network = xml_node_new("network", wireless)))
return FALSE;
if (net->essid.len > 0) {
ni_string_set(&tmp, (const char *) net->essid.data, net->essid.len);
xml_node_new_element("essid", network, tmp);
ni_string_free(&tmp);
}
xml_node_new_element("scan-ssid", network, net->scan_ssid?"true":"false");
if (net->priority > 0 &&
ni_string_printf(&tmp, "%u", net->priority)) {
xml_node_new_element("priority", network, tmp);
ni_string_free(&tmp);
}
if ((value = ni_wireless_mode_to_name(net->mode))) {
xml_node_new_element("mode", network, value);
}
if (net->access_point.len > 0) {
xml_node_new_element("access-point", network,
ni_link_address_print(&net->access_point));
}
if (net->channel > 0 &&
ni_string_printf(&tmp, "%u", net->channel)) {
xml_node_new_element("channel", network, tmp);
ni_string_free(&tmp);
}
if (net->fragment_size > 0 &&
ni_string_printf(&tmp, "%u", net->fragment_size)) {
xml_node_new_element("fragment-size", network, tmp);
ni_string_free(&tmp);
}
if ((value = ni_wireless_key_management_to_name(net->keymgmt_proto))) {
xml_node_new_element("key-management", network, value);
}
switch (net->keymgmt_proto) {
case NI_WIRELESS_KEY_MGMT_NONE:
if (!(wep = xml_node_new("wep", network))) {
return FALSE;
}
if ((value = ni_wireless_auth_algo_to_name(net->auth_algo))) {
xml_node_new_element("auth-algo", wep, value);
}
if (net->default_key < NI_WIRELESS_WEP_KEY_COUNT &&
ni_string_printf(&tmp, "%u", net->default_key)) {
xml_node_new_element("default-key", wep, tmp);
ni_string_free(&tmp);
}
for (key_i = 0; key_i < NI_WIRELESS_WEP_KEY_COUNT; key_i++) {
if (!ni_string_empty(net->wep_keys[key_i])) {
/* To be secured */
xml_node_new_element("key", wep, net->wep_keys[key_i]);
}
}
break;
case NI_WIRELESS_KEY_MGMT_PSK:
if (!(wpa_psk = xml_node_new("wpa-psk", network))) {
return FALSE;
}
if (!ni_string_empty(net->wpa_psk.passphrase)) {
/* To be secured */
xml_node_new_element("passphrase", wpa_psk,
net->wpa_psk.passphrase);
}
if ((value = ni_wireless_auth_mode_to_name(net->auth_proto))) {
xml_node_new_element("auth-proto", wpa_psk, value);
}
if ((value = ni_wireless_cipher_to_name(net->pairwise_cipher))) {
xml_node_new_element("pairwise-cipher", wpa_psk, value);
}
if ((value = ni_wireless_cipher_to_name(net->group_cipher))) {
xml_node_new_element("group-cipher", wpa_psk, value);
}
break;
case NI_WIRELESS_KEY_MGMT_EAP:
if (!(wpa_eap = xml_node_new("wpa-eap", network))) {
return FALSE;
}
if ((value = ni_wireless_eap_method_to_name(net->wpa_eap.method))) {
xml_node_new_element("method", wpa_eap, value);
}
if ((value = ni_wireless_auth_mode_to_name(net->auth_proto))) {
xml_node_new_element("auth-proto", wpa_eap, value);
}
if ((value = ni_wireless_cipher_to_name(net->pairwise_cipher))) {
xml_node_new_element("pairwise-cipher", wpa_eap, value);
}
if ((value = ni_wireless_cipher_to_name(net->group_cipher))) {
xml_node_new_element("group-cipher", wpa_eap, value);
}
if (!ni_string_empty(net->wpa_eap.identity)) {
xml_node_new_element("identity", wpa_eap, net->wpa_eap.identity);
}
xml_node_t *phase1 = xml_node_new("phase1", wpa_eap);
if (ni_string_printf(&tmp, "%u", net->wpa_eap.phase1.peapver)) {
xml_node_new_element("peap-version", phase1, tmp);
ni_string_free(&tmp);
}
xml_node_t *phase2 = xml_node_new("phase2", wpa_eap);
if ((value = ni_wireless_eap_method_to_name(net->wpa_eap.phase2.method))) {
xml_node_new_element("method", phase2, value);
}
if (!ni_string_empty(net->wpa_eap.phase2.password)) {
/* To be secured */
xml_node_new_element("password", phase2,
net->wpa_eap.phase2.password);
}
if (!ni_string_empty(net->wpa_eap.anonid)) {
xml_node_new_element("anonid", wpa_eap, net->wpa_eap.anonid);
}
xml_node_t *tls = xml_node_new("tls", wpa_eap);
if ((cert = net->wpa_eap.tls.ca_cert)) {
if (!ni_string_empty(cert->name)) {
xml_node_new_element("ca-cert", tls, cert->name);
/* FIXME/ADDME file data and size exporting */
}
}
if ((cert = net->wpa_eap.tls.client_cert)) {
if (!ni_string_empty(cert->name)) {
xml_node_new_element("client-cert", tls, cert->name);
/* FIXME/ADDME file data and size exporting */
}
}
if ((cert = net->wpa_eap.tls.client_key)) {
if (!ni_string_empty(cert->name)) {
xml_node_new_element("client-key", tls, cert->name);
/* FIXME/ADDME file data and size exporting */
}
}
if (!ni_string_empty(net->wpa_eap.tls.client_key_passwd)) {
xml_node_new_element("client-key-passwd", tls,
net->wpa_eap.tls.client_key_passwd);
/* FIXME/ADDME file data and size exporting */
}
break;
default:
return FALSE;
break;
}
}
return TRUE;
}
static ni_bool_t
__ni_compat_generate_bridge(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_bridge_t *bridge;
xml_node_t *child;
xml_node_t *ports;
unsigned int i;
char *tmp = NULL;
bridge = ni_netdev_get_bridge(compat->dev);
child = xml_node_create(ifnode, "bridge");
xml_node_new_element("stp", child, bridge->stp ? "true" : "false");
if (bridge->priority != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%u", bridge->priority)) {
xml_node_new_element("priority", child, tmp);
ni_string_free(&tmp);
}
if (bridge->forward_delay != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->forward_delay)) {
xml_node_new_element("forward-delay", child, tmp);
ni_string_free(&tmp);
}
if (bridge->ageing_time != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->ageing_time)) {
xml_node_new_element("aging-time", child, tmp);
ni_string_free(&tmp);
}
if (bridge->hello_time != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->hello_time)) {
xml_node_new_element("hello-time", child, tmp);
ni_string_free(&tmp);
}
if (bridge->max_age != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%.2f", bridge->max_age)) {
xml_node_new_element("max-age", child, tmp);
ni_string_free(&tmp);
}
ports = xml_node_new("ports", child);
for (i = 0; i < bridge->ports.count; ++i) {
const ni_bridge_port_t *port = bridge->ports.data[i];
xml_node_t *portnode = xml_node_new("port", ports);
xml_node_new_element("device", portnode, port->ifname);
if (port->priority != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%u", port->priority)) {
xml_node_new_element("priority", portnode, tmp);
ni_string_free(&tmp);
}
if (port->path_cost != NI_BRIDGE_VALUE_NOT_SET &&
ni_string_printf(&tmp, "%u", port->path_cost)) {
xml_node_new_element("path-cost", portnode, tmp);
ni_string_free(&tmp);
}
}
return TRUE;
}
static ni_bool_t
__ni_compat_generate_bonding(xml_node_t *ifnode, const ni_compat_netdev_t *compat)
{
ni_bonding_t *bond;
xml_node_t *child, *slaves, *slave;
unsigned int i;
int verbose = 0; /* do not supress defaults */
bond = ni_netdev_get_bonding(compat->dev);
child = xml_node_create(ifnode, "bond");
xml_node_new_element("mode", child,
ni_bonding_mode_type_to_name(bond->mode));
if (bond->monitoring == NI_BOND_MONITOR_ARP) {
xml_node_t *arpmon;
xml_node_t *targets;
arpmon = xml_node_create(child, "arpmon");
xml_node_new_element("interval", arpmon,
ni_sprint_uint(bond->arpmon.interval));
xml_node_new_element("validate", arpmon,
ni_bonding_arp_validate_type_to_name(bond->arpmon.validate));
targets = xml_node_create(arpmon, "targets");
for (i = 0; i < bond->arpmon.targets.count; ++i) {
xml_node_new_element("ipv4-address", targets,
bond->arpmon.targets.data[i]);
}
} else
if (bond->monitoring == NI_BOND_MONITOR_MII) {
xml_node_t *miimon;
miimon = xml_node_create(child, "miimon");
xml_node_new_element("frequency", miimon,
ni_sprint_uint(bond->miimon.frequency));
if (verbose || bond->miimon.updelay) {
xml_node_new_element("updelay", miimon,
ni_sprint_uint(bond->miimon.updelay));
}
if (verbose || bond->miimon.downdelay) {
xml_node_new_element("downdelay", miimon,
ni_sprint_uint(bond->miimon.downdelay));
}
xml_node_new_element("carrier", miimon,
ni_bonding_mii_carrier_detect_name(bond->miimon.carrier_detect));
}
slaves = xml_node_create(child, "slaves");
for (i = 0; i < bond->slave_names.count; ++i) {
const char *slave_name = bond->slave_names.data[i];
slave = xml_node_new("slave", slaves);
xml_node_new_element("device", slave, slave_name);
switch (bond->mode) {
case NI_BOND_MODE_ACTIVE_BACKUP:
case NI_BOND_MODE_BALANCE_TLB:
case NI_BOND_MODE_BALANCE_ALB:
if (ni_string_eq(bond->primary_slave, slave_name)) {
xml_node_new_element("primary", slave, "true");
}
if (ni_string_eq(bond->active_slave, slave_name)) {
xml_node_new_element("active", slave, "true");
}
default:
break;
}
}
switch (bond->mode) {
case NI_BOND_MODE_802_3AD:
case NI_BOND_MODE_BALANCE_XOR:
if (verbose || bond->xmit_hash_policy) {
xml_node_new_element("xmit-hash-policy", child,
ni_bonding_xmit_hash_policy_to_name(bond->xmit_hash_policy));
}
default:
break;
}
if (bond->mode == NI_BOND_MODE_802_3AD) {
if (verbose || bond->lacp_rate) {
xml_node_new_element("lacp-rate", child,
ni_bonding_lacp_rate_name(bond->lacp_rate));
}
if (verbose || bond->ad_select) {
xml_node_new_element("ad-select", child,
ni_bonding_ad_select_name(bond->ad_select));
}
if (verbose || bond->min_links > 0) {
xml_node_new_element("min-links", child,
ni_sprint_uint(bond->min_links));
}
}
if (bond->mode == NI_BOND_MODE_ACTIVE_BACKUP) {
if (verbose || bond->primary_reselect) {
xml_node_new_element("primary-reselect", child,
ni_bonding_primary_reselect_name(bond->primary_reselect));
}
if (verbose || bond->fail_over_mac) {
xml_node_new_element("fail-over-mac", child,
ni_bonding_fail_over_mac_name(bond->fail_over_mac));
}
if (verbose || bond->num_grat_arp != 1) {
xml_node_new_element("num-grat-arp", child,
ni_sprint_uint(bond->num_grat_arp));
}
if (verbose || bond->num_unsol_na != 1) {
xml_node_new_element("num-unsol-na", child,
ni_sprint_uint(bond->num_unsol_na));
}
}
switch (bond->mode) {
case NI_BOND_MODE_ACTIVE_BACKUP:
case NI_BOND_MODE_BALANCE_RR:
case NI_BOND_MODE_BALANCE_TLB:
case NI_BOND_MODE_BALANCE_ALB:
if (verbose || bond->resend_igmp != 1) {
xml_node_new_element("resend-igmp", child,
ni_sprint_uint(bond->resend_igmp));
}
default:
break;
}
if (verbose || bond->all_slaves_active) {
xml_node_new_element("all-slaves-active", child,
(bond->all_slaves_active ? "true" : "false"));
}
return TRUE;
}
