/*
* Free the configuration. Called only when the server is exiting.
*/
int free_mainconfig(void)
{
cached_config_t *cc, *next;
virtual_servers_free(0);
/*
* Clean up the configuration data
* structures.
*/
clients_free(NULL);
realms_free();
listen_free(&mainconfig.listen);
/*
* Free all of the cached configurations.
*/
for (cc = cs_cache; cc != NULL; cc = next) {
next = cc->next;
cf_file_free(cc->cs);
free(cc);
}
dict_free();
return 0;
}
void main_config_hup(void)
{
cached_config_t *cc;
CONF_SECTION *cs;
char buffer[1024];
INFO("HUP - Re-reading configuration files");
/* Read the configuration file */
snprintf(buffer, sizeof(buffer), "%.200s/%.50s.conf",
radius_dir, main_config.name);
if ((cs = cf_file_read(buffer)) == NULL) {
ERROR("Failed to re-read or parse %s", buffer);
return;
}
cc = talloc_zero(cs_cache, cached_config_t);
if (!cc) {
ERROR("Out of memory");
return;
}
/*
* Save the current configuration. Note that we do NOT
* free older ones. We should probably do so at some
* point. Doing so will require us to mark which modules
* are still in use, and which aren't. Modules that
* can't be HUPed always use the original configuration.
* Modules that can be HUPed use one of the newer
* configurations.
*/
cc->created = time(NULL);
cc->cs = talloc_steal(cc, cs);
cc->next = cs_cache;
cs_cache = cc;
/*
* Re-open the log file. If we can't, then keep logging
* to the old log file.
*
* The "open log file" code is here rather than in log.c,
* because it makes that function MUCH simpler.
*/
hup_logfile();
INFO("HUP - loading modules");
/*
* Prefer the new module configuration.
*/
modules_hup(cf_section_sub_find(cs, "modules"));
/*
* Load new servers BEFORE freeing old ones.
*/
virtual_servers_load(cs);
virtual_servers_free(cc->created - main_config.max_request_time * 4);
}
void hup_mainconfig(void)
{
cached_config_t *cc;
CONF_SECTION *cs;
char buffer[1024];
/* Read the configuration file */
snprintf(buffer, sizeof(buffer), "%.200s/%.50s.conf",
radius_dir, mainconfig.name);
if ((cs = cf_file_read(buffer)) == NULL) {
radlog(L_ERR, "Failed to re-read %s", buffer);
return;
}
cc = rad_malloc(sizeof(*cc));
memset(cc, 0, sizeof(*cc));
/*
* Save the current configuration. Note that we do NOT
* free older ones. We should probably do so at some
* point. Doing so will require us to mark which modules
* are still in use, and which aren't. Modules that
* can't be HUPed always use the original configuration.
* Modules that can be HUPed use one of the newer
* configurations.
*/
cc->created = time(NULL);
cc->cs = cs;
cc->next = cs_cache;
cs_cache = cc;
/*
* Prefer the new module configuration.
*/
module_hup(cf_section_sub_find(cs, "modules"));
/*
* Load new servers BEFORE freeing old ones.
*/
virtual_servers_load(cs);
virtual_servers_free(cc->created - mainconfig.max_request_time * 4);
}
/*
* Free the configuration. Called only when the server is exiting.
*/
int main_config_free(void)
{
virtual_servers_free(0);
/*
* Clean up the configuration data
* structures.
*/
clients_free(NULL);
realms_free();
listen_free(&main_config.listen);
/*
* Frees current config and any previous configs.
*/
TALLOC_FREE(cs_cache);
dict_free();
return 0;
}
void hup_mainconfig(void)
{
cached_config_t *cc;
CONF_SECTION *cs;
char buffer[1024];
radlog(L_INFO, "HUP - Re-reading configuration files");
/* Read the configuration file */
snprintf(buffer, sizeof(buffer), "%.200s/%.50s.conf",
radius_dir, mainconfig.name);
if ((cs = cf_file_read(buffer)) == NULL) {
radlog(L_ERR, "Failed to re-read or parse %s", buffer);
return;
}
cc = rad_malloc(sizeof(*cc));
memset(cc, 0, sizeof(*cc));
/*
* Save the current configuration. Note that we do NOT
* free older ones. We should probably do so at some
* point. Doing so will require us to mark which modules
* are still in use, and which aren't. Modules that
* can't be HUPed always use the original configuration.
* Modules that can be HUPed use one of the newer
* configurations.
*/
cc->created = time(NULL);
cc->cs = cs;
cc->next = cs_cache;
cs_cache = cc;
/*
* Re-open the log file. If we can't, then keep logging
* to the old log file.
*
* The "open log file" code is here rather than in log.c,
* because it makes that function MUCH simpler.
*/
if (mainconfig.radlog_dest == RADLOG_FILES) {
int fd, old_fd;
fd = open(mainconfig.log_file,
O_WRONLY | O_APPEND | O_CREAT, 0640);
if (fd >= 0) {
/*
* Atomic swap. We'd like to keep the old
* FD around so that callers don't
* suddenly find the FD closed, and the
* writes go nowhere. But that's hard to
* do. So... we have the case where a
* log message *might* be lost on HUP.
*/
old_fd = mainconfig.radlog_fd;
mainconfig.radlog_fd = fd;
close(old_fd);
}
}
radlog(L_INFO, "HUP - loading modules");
/*
* Prefer the new module configuration.
*/
module_hup(cf_section_sub_find(cs, "modules"));
/*
* Load new servers BEFORE freeing old ones.
*/
virtual_servers_load(cs);
virtual_servers_free(cc->created - mainconfig.max_request_time * 4);
}
