int
xml_node_print_fn(const xml_node_t *node, void (*writefn)(const char *, void *), void *user_data)
{
char *membuf = NULL;
size_t memsz = 0;
FILE *memf;
int rv;
memf = open_memstream(&membuf, &memsz);
rv = xml_node_print(node, memf);
fclose(memf);
if (rv >= 0) {
char *s, *t;
for (s = membuf; s; s = t) {
if ((t = strchr(s, '\n')) != NULL)
*t++ = '\0';
writefn(s, user_data);
}
}
free(membuf);
return rv;
}
static void xml_node_walk(acl::xml_node& node, int depth)
{
acl::xml_node* child = node.first_child();
while (child)
{
xml_node_print(*child, depth);
xml_node_walk(*child, depth + 1);
child = node.next_child();
}
}
int
ni_dhcp6_save_duid(const ni_opaque_t *duid, const char *filename)
{
char path[PATH_MAX];
const char *name = CONFIG_DHCP6_DUID_NODE;
ni_opaque_t temp = NI_OPAQUE_INIT;
xml_node_t *node;
FILE *fp;
int rv = -1;
if (!duid || !duid->len) {
ni_error("BUG: Refusing to save empty duid");
return -1;
}
if(ni_dhcp6_load_duid(&temp, filename) == 0)
return 1;
if (!filename) {
snprintf(path, sizeof(path), "%s/%s",
ni_config_storedir(),
CONFIG_DHCP6_DUID_FILE);
filename = path;
} else {
name = "duid";
}
if ((node = xml_node_new(name, NULL)) == NULL) {
ni_error("Unable to create %s xml node: %m", name);
return -1;
}
ni_duid_format_hex(&node->cdata, duid);
if ((fp = fopen(filename, "w")) == NULL) {
ni_error("%s: unable to open file for writing: %m", filename);
}
else if ((rv = xml_node_print(node, fp)) < 0) {
ni_error("%s: unable to write %s xml representation",
filename, name);
}
xml_node_free(node);
fclose(fp);
if(rv < 0)
unlink(filename);
return rv;
}
static void
ni_dhcp4_tester_protocol_event(enum ni_dhcp4_event ev, const ni_dhcp4_device_t *dev,
ni_addrconf_lease_t *lease)
{
ni_debug_dhcp("%s(ev=%u, dev=%s[%u], config-uuid=%s)", __func__, ev,
dev->ifname, dev->link.ifindex,
dev->config ? ni_uuid_print(&dev->config->uuid) : "<none>");
switch (ev) {
case NI_DHCP4_EVENT_ACQUIRED:
if (lease && lease->state == NI_ADDRCONF_STATE_GRANTED) {
FILE *fp = stdout;
if (dhcp4_tester_opts.output != NULL) {
fp = fopen(dhcp4_tester_opts.output, "w");
if (!fp) {
ni_error("Cannot open %s for output",
dhcp4_tester_opts.output);
dhcp4_tester_status = NI_WICKED_RC_ERROR;
return;
}
}
if (dhcp4_tester_opts.outfmt == NI_DHCP4_TESTER_OUT_LEASE_XML) {
xml_node_t *xml = NULL;
if (ni_addrconf_lease_to_xml(lease, &xml, dev->ifname) != 0) {
if (dhcp4_tester_opts.output)
fclose(fp);
dhcp4_tester_status = NI_WICKED_RC_ERROR;
return;
}
xml_node_print(xml, fp);
xml_node_free(xml);
} else {
ni_leaseinfo_dump(fp, lease, dev->ifname, NULL);
}
fflush(fp);
if (dhcp4_tester_opts.output)
fclose(fp);
dhcp4_tester_status = NI_WICKED_RC_SUCCESS;
}
break;
default:
break;
}
}
char *
xml_node_sprint(const xml_node_t *node)
{
char *string = NULL;
size_t size = 0;
FILE *fp;
int rv;
if ((fp = open_memstream(&string, &size)) == NULL) {
ni_error("%s: unable to open memstream", __func__);
return NULL;
}
rv = xml_node_print(node, fp);
fclose(fp);
if (rv < 0) {
free(string);
return NULL;
}
return string;
}
/*
* Write a lease to a file
*/
int
ni_addrconf_lease_file_write(const char *ifname, ni_addrconf_lease_t *lease)
{
char tempname[PATH_MAX] = {'\0'};
ni_bool_t fallback = FALSE;
char *filename = NULL;
xml_node_t *xml = NULL;
FILE *fp = NULL;
int ret = -1;
int fd;
if (lease->state == NI_ADDRCONF_STATE_RELEASED) {
ni_addrconf_lease_file_remove(ifname, lease->type, lease->family);
return 0;
}
if (!__ni_addrconf_lease_file_path(&filename, ni_config_storedir(),
ifname, lease->type, lease->family)) {
ni_error("Cannot construct lease file name: %m");
return -1;
}
ni_debug_dhcp("Preparing xml lease data for '%s'", filename);
if ((ret = ni_addrconf_lease_to_xml(lease, &xml)) != 0) {
if (ret > 0) {
ni_debug_dhcp("Skipped, %s:%s leases are disabled",
ni_addrfamily_type_to_name(lease->family),
ni_addrconf_type_to_name(lease->type));
} else {
ni_error("Unable to represent %s:%s lease as XML",
ni_addrfamily_type_to_name(lease->family),
ni_addrconf_type_to_name(lease->type));
}
goto failed;
}
snprintf(tempname, sizeof(tempname), "%s.XXXXXX", filename);
if ((fd = mkstemp(tempname)) < 0) {
if (errno == EROFS && __ni_addrconf_lease_file_path(&filename,
ni_config_statedir(), ifname,
lease->type, lease->family)) {
ni_debug_dhcp("Read-only filesystem, try fallback to %s",
filename);
snprintf(tempname, sizeof(tempname), "%s.XXXXXX", filename);
fd = mkstemp(tempname);
fallback = TRUE;
}
if (fd < 0) {
ni_error("Cannot create temporary lease file '%s': %m",
tempname);
tempname[0] = '\0';
ret = -1;
goto failed;
}
}
if ((fp = fdopen(fd, "we")) == NULL) {
ret = -1;
close(fd);
ni_error("Cannot reopen temporary lease file '%s': %m", tempname);
goto failed;
}
ni_debug_dhcp("Writing lease to temporary file for '%s'", filename);
xml_node_print(xml, fp);
fclose(fp);
xml_node_free(xml);
if ((ret = rename(tempname, filename)) != 0) {
ni_error("Unable to rename temporary lease file '%s' to '%s': %m",
tempname, filename);
goto failed;
} else if (!fallback) {
__ni_addrconf_lease_file_remove(ni_config_statedir(),
ifname, lease->type, lease->family);
}
ni_debug_dhcp("Lease written to file '%s'", filename);
ni_string_free(&filename);
return 0;
failed:
if (fp)
fclose(fp);
if (xml)
xml_node_free(xml);
if (tempname[0])
unlink(tempname);
ni_string_free(&filename);
return -1;
}
