int
ni_tempstate_mkdir(ni_tempstate_t *ts)
{
if (ts->dirpath == NULL) {
char pathbuf[PATH_MAX];
if (ts->ident != NULL) {
snprintf(pathbuf, sizeof(pathbuf), "%s/%s", ni_config_statedir(), ts->ident);
if (mkdir(pathbuf, 0700) < 0) {
ni_error("unable to create tempstate directory %s: %m", pathbuf);
return -1;
}
} else {
snprintf(pathbuf, sizeof(pathbuf), "%s/tempdirXXXXXX", ni_config_statedir());
if (!mkdtemp(pathbuf)) {
ni_error("unable to create tempstate directory: %m");
return -1;
}
}
ni_string_dup(&ts->dirpath, pathbuf);
}
return 0;
}
static ni_bool_t
ni_iaid_map_set_fallback_file(char **filename)
{
return ni_string_printf(filename, "%s/%s",
ni_config_statedir(),
NI_CONFIG_DEFAULT_IAID_FILE) != NULL;
}
const char *
ni_extension_statedir(const char *ex_name)
{
ni_extension_t *ex = NULL;
ni_config_fslocation_t *fsloc = NULL;
const char *extension_dirname = "extension";
const int mode = 0700;
char pathname[PATH_MAX];
if (!(ni_config_extension_statedir(extension_dirname, mode)))
return NULL;
if (!(ex = ni_config_find_system_updater(ni_global.config, ex_name)))
return NULL;
fsloc = &ex->statedir;
if (fsloc->path == NULL) {
snprintf(pathname, sizeof(pathname), "%s/%s/%s",
ni_config_statedir(), extension_dirname, ex->name);
if (ni_mkdir_maybe(pathname, mode) < 0) {
ni_error("Cannot create extension state directory \"%s\": %m", pathname);
} else {
ni_config_fslocation_init(fsloc, pathname, mode);
}
}
return fsloc->path;
}
static ni_bool_t
ni_config_extension_statedir(const char *extension_dirname, const int mode)
{
static ni_bool_t res = FALSE;
char pathname[PATH_MAX];
if (!res) {
snprintf(pathname, sizeof(pathname), "%s/%s",
ni_config_statedir(), extension_dirname);
if (ni_mkdir_maybe(pathname, mode) < 0) {
ni_error("Cannot create extension state directory \"%s\": %m", pathname);
res = FALSE;
} else {
res = TRUE;
}
}
return res;
}
void
ni_addrconf_lease_file_remove(const char *ifname, int type, int family)
{
__ni_addrconf_lease_file_remove(ni_config_statedir(), ifname, type, family);
__ni_addrconf_lease_file_remove(ni_config_storedir(), ifname, type, family);
}
/*
* Read a lease from a file
*/
ni_addrconf_lease_t *
ni_addrconf_lease_file_read(const char *ifname, int type, int family)
{
ni_addrconf_lease_t *lease = NULL;
xml_node_t *xml = NULL, *lnode;
char *filename = NULL;
FILE *fp;
if (!__ni_addrconf_lease_file_path(&filename,
ni_config_statedir(),
ifname, type, family)) {
ni_error("Unable to construct lease file name: %m");
return NULL;
}
if ((fp = fopen(filename, "re")) == NULL) {
if (errno == ENOENT) {
if (__ni_addrconf_lease_file_path(&filename,
ni_config_storedir(),
ifname, type, family))
fp = fopen(filename, "re");
}
if (fp == NULL) {
if (errno != ENOENT) {
ni_error("Unable to open %s for reading: %m",
filename);
}
ni_string_free(&filename);
return NULL;
}
}
ni_debug_dhcp("Reading lease from %s", filename);
xml = xml_node_scan(fp, filename);
fclose(fp);
if (xml == NULL) {
ni_error("Unable to parse %s", filename);
ni_string_free(&filename);
return NULL;
}
/* find the lease node already here, so we can report it */
if (!ni_string_eq(xml->name, NI_ADDRCONF_LEASE_XML_NODE))
lnode = xml_node_get_child(xml, NI_ADDRCONF_LEASE_XML_NODE);
else
lnode = xml;
if (!lnode) {
ni_error("File '%s' does not contain a valid lease", filename);
ni_string_free(&filename);
xml_node_free(xml);
return NULL;
}
if (ni_addrconf_lease_from_xml(&lease, xml) < 0) {
ni_error("Unable to parse xml lease file '%s'", filename);
ni_string_free(&filename);
xml_node_free(xml);
return NULL;
}
ni_string_free(&filename);
xml_node_free(xml);
return lease;
}
/*
* 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;
}
