mirror of
http://thekelleys.org.uk/git/dnsmasq.git
synced 2026-10-19 11:19:34 +00:00
Simon Kelley
65adc53130
only created after dnsmasq has changed permissions and userid. This means that the permissions used when creating the watches are the same as used for accessing watched files, which makes more sense and avoids odd and confusing error conditions.
388 lines
9.8 KiB
C
388 lines
9.8 KiB
C
/* dnsmasq is Copyright (c) 2000-2025 Simon Kelley
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 dated June, 1991, or
|
|
(at your option) version 3 dated 29 June, 2007.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "dnsmasq.h"
|
|
#ifdef HAVE_INOTIFY
|
|
|
|
#include <sys/inotify.h>
|
|
#include <sys/param.h> /* For MAXSYMLINKS */
|
|
|
|
/* the strategy is to set an inotify on the directories containing
|
|
resolv files, for any files in the directory which are close-write
|
|
or moved into the directory.
|
|
|
|
When either of those happen, we look to see if the file involved
|
|
is actually a resolv-file, and if so, call poll-resolv with
|
|
the "force" argument, to ensure it's read.
|
|
|
|
This adds one new error condition: the directories containing
|
|
all specified resolv-files must exist at start-up, even if the actual
|
|
files don't.
|
|
*/
|
|
|
|
static char *inotify_buffer;
|
|
#define INOTIFY_SZ (sizeof(struct inotify_event) + NAME_MAX + 1)
|
|
|
|
/* If path is a symbolic link, return the path it
|
|
points to, made absolute if relative.
|
|
If path doesn't exist or is not a symlink, return NULL.
|
|
Return value is malloc'ed */
|
|
static char *my_readlink(int errfd, char *path)
|
|
{
|
|
ssize_t rc, size = 64;
|
|
char *buf;
|
|
|
|
while (1)
|
|
{
|
|
buf = safe_malloc(size);
|
|
rc = readlink(path, buf, (size_t)size);
|
|
|
|
if (rc == -1)
|
|
{
|
|
/* Not link or doesn't exist. */
|
|
if (errno == EINVAL || errno == ENOENT)
|
|
{
|
|
free(buf);
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
send_event(errfd, EVENT_LINK_ERR, errno, path);
|
|
_exit(0);
|
|
}
|
|
}
|
|
else if (rc < size-1)
|
|
{
|
|
char *d;
|
|
|
|
buf[rc] = 0;
|
|
if (buf[0] != '/' && ((d = strrchr(path, '/'))))
|
|
{
|
|
/* Add path to relative link */
|
|
char *new_buf = safe_malloc((d - path) + strlen(buf) + 2);
|
|
*(d+1) = 0;
|
|
strcpy(new_buf, path);
|
|
strcat(new_buf, buf);
|
|
free(buf);
|
|
buf = new_buf;
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/* Buffer too small, increase and retry */
|
|
size += 64;
|
|
free(buf);
|
|
}
|
|
}
|
|
|
|
void inotify_dnsmasq_init(int errfd)
|
|
{
|
|
struct resolvc *res;
|
|
inotify_buffer = safe_malloc(INOTIFY_SZ);
|
|
daemon->inotifyfd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
|
|
|
|
if (daemon->inotifyfd == -1)
|
|
{
|
|
send_event(errfd, EVENT_INOTFY_ERR, errno, NULL);
|
|
_exit(0);
|
|
}
|
|
|
|
if (daemon->port == 0 || option_bool(OPT_NO_RESOLV))
|
|
return;
|
|
|
|
for (res = daemon->resolv_files; res; res = res->next)
|
|
{
|
|
char *d, *new_path, *path = safe_malloc(strlen(res->name) + 1);
|
|
int links = MAXSYMLINKS;
|
|
|
|
strcpy(path, res->name);
|
|
|
|
/* Follow symlinks until we reach a non-symlink, or a non-existent file. */
|
|
while ((new_path = my_readlink(errfd, path)))
|
|
{
|
|
if (links-- == 0)
|
|
{
|
|
send_event(errfd, EVENT_TMSL_ERR, 0, res->name);
|
|
_exit(0);
|
|
}
|
|
free(path);
|
|
path = new_path;
|
|
}
|
|
|
|
res->wd = -1;
|
|
|
|
if ((d = strrchr(path, '/')))
|
|
{
|
|
*d = 0; /* make path just directory */
|
|
res->wd = inotify_add_watch(daemon->inotifyfd, path, IN_CLOSE_WRITE | IN_MOVED_TO);
|
|
|
|
res->file = d+1; /* pointer to filename */
|
|
*d = '/';
|
|
|
|
if (res->wd == -1 && errno == ENOENT)
|
|
{
|
|
send_event(errfd, EVENT_RESOLV_ERR, 0, res->name);
|
|
_exit(0);
|
|
}
|
|
}
|
|
|
|
if (res->wd == -1)
|
|
{
|
|
send_event(errfd, EVENT_IFILE_ERR, errno, res->name);
|
|
_exit(0);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static struct hostsfile *dyndir_addhosts(struct dyndir *dd, char *file)
|
|
{
|
|
/* Check if this file is already known in dd->files */
|
|
struct hostsfile *ah;
|
|
size_t dirlen = strlen(dd->dname);
|
|
|
|
/* ah->fname always starts with the string in dd->dname */
|
|
for (ah = dd->files; ah; ah = ah->next)
|
|
if (ah->fname[dirlen] == '/' &&
|
|
strcmp(&ah->fname[dirlen+1], file) == 0)
|
|
return ah;
|
|
|
|
/* Not known, create new hostsfile record for this dyndir */
|
|
if ((ah = whine_malloc(sizeof(struct hostsfile))))
|
|
{
|
|
char *path;
|
|
|
|
if (!(path = whine_malloc(dirlen + strlen(file) + 2)))
|
|
{
|
|
free(ah);
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(path, dd->dname);
|
|
strcat(path, "/");
|
|
strcat(path, file);
|
|
|
|
/* Add this file to the tip of the linked list */
|
|
ah->next = dd->files;
|
|
dd->files = ah;
|
|
|
|
/* Copy flags, set index and the full file path */
|
|
ah->flags = dd->flags;
|
|
ah->index = daemon->host_index++;
|
|
ah->fname = path;
|
|
}
|
|
|
|
return ah;
|
|
}
|
|
|
|
|
|
/* initialisation for dynamic-dir. Set inotify watch for each directory, and read pre-existing files */
|
|
void set_dynamic_inotify(int flag, int total_size, struct crec **rhash, int revhashsz)
|
|
{
|
|
struct dyndir *dd;
|
|
|
|
for (dd = daemon->dynamic_dirs; dd; dd = dd->next)
|
|
{
|
|
DIR *dir_stream = NULL;
|
|
struct dirent *ent;
|
|
struct stat buf;
|
|
|
|
if (!(dd->flags & flag))
|
|
continue;
|
|
|
|
if (stat(dd->dname, &buf) == -1)
|
|
{
|
|
my_syslog(LOG_ERR, _("bad dynamic directory %s: %s"),
|
|
dd->dname, strerror(errno));
|
|
continue;
|
|
}
|
|
|
|
if (!(S_ISDIR(buf.st_mode)))
|
|
{
|
|
my_syslog(LOG_ERR, _("bad dynamic directory %s: %s"),
|
|
dd->dname, _("not a directory"));
|
|
continue;
|
|
}
|
|
|
|
if (!(dd->flags & AH_WD_DONE))
|
|
{
|
|
dd->wd = inotify_add_watch(daemon->inotifyfd, dd->dname, IN_CLOSE_WRITE | IN_MOVED_TO | IN_DELETE);
|
|
dd->flags |= AH_WD_DONE;
|
|
}
|
|
|
|
/* Read contents of dir _after_ calling add_watch, in the hope of avoiding
|
|
a race which misses files being added as we start */
|
|
if (dd->wd == -1 || !(dir_stream = opendir(dd->dname)))
|
|
{
|
|
my_syslog(LOG_ERR, _("failed to create inotify for %s: %s"),
|
|
dd->dname, strerror(errno));
|
|
continue;
|
|
}
|
|
|
|
while ((ent = readdir(dir_stream)))
|
|
{
|
|
size_t lenfile = strlen(ent->d_name);
|
|
|
|
/* ignore emacs backups and dotfiles */
|
|
if (lenfile == 0 ||
|
|
ent->d_name[lenfile - 1] == '~' ||
|
|
(ent->d_name[0] == '#' && ent->d_name[lenfile - 1] == '#') ||
|
|
ent->d_name[0] == '.')
|
|
continue;
|
|
|
|
if (dd->flags & AH_HOSTS)
|
|
{
|
|
struct hostsfile *ah;
|
|
|
|
/* ignore non-regular files */
|
|
if ((ah = dyndir_addhosts(dd, ent->d_name)) &&
|
|
stat(ah->fname, &buf) != -1 && S_ISREG(buf.st_mode))
|
|
total_size = read_hostsfile(ah->fname, ah->index, total_size, rhash, revhashsz);
|
|
}
|
|
#ifdef HAVE_DHCP
|
|
else if (dd->flags & (AH_DHCP_HST | AH_DHCP_OPT))
|
|
{
|
|
char *path;
|
|
|
|
if ((path = whine_malloc(strlen(dd->dname) + lenfile + 2)))
|
|
{
|
|
strcpy(path, dd->dname);
|
|
strcat(path, "/");
|
|
strcat(path, ent->d_name);
|
|
|
|
/* ignore non-regular files */
|
|
if (stat(path, &buf) != -1 && S_ISREG(buf.st_mode))
|
|
option_read_dynfile(path, dd->flags);
|
|
|
|
free(path);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
closedir(dir_stream);
|
|
}
|
|
}
|
|
|
|
int inotify_check(time_t now)
|
|
{
|
|
int hit = 0;
|
|
struct dyndir *dd;
|
|
|
|
(void)now;
|
|
|
|
while (1)
|
|
{
|
|
int rc;
|
|
char *p;
|
|
struct resolvc *res;
|
|
struct inotify_event *in;
|
|
|
|
while ((rc = read(daemon->inotifyfd, inotify_buffer, INOTIFY_SZ)) == -1 && errno == EINTR);
|
|
|
|
if (rc <= 0)
|
|
break;
|
|
|
|
for (p = inotify_buffer; rc - (p - inotify_buffer) >= (int)sizeof(struct inotify_event); p += sizeof(struct inotify_event) + in->len)
|
|
{
|
|
size_t namelen;
|
|
|
|
in = (struct inotify_event*)p;
|
|
|
|
/* ignore emacs backups and dotfiles */
|
|
if (in->len == 0 || (namelen = strlen(in->name)) == 0 ||
|
|
in->name[namelen - 1] == '~' ||
|
|
(in->name[0] == '#' && in->name[namelen - 1] == '#') ||
|
|
in->name[0] == '.')
|
|
continue;
|
|
|
|
for (res = daemon->resolv_files; res; res = res->next)
|
|
if (res->wd == in->wd && strcmp(res->file, in->name) == 0)
|
|
hit = 1;
|
|
|
|
for (dd = daemon->dynamic_dirs; dd; dd = dd->next)
|
|
if (dd->wd == in->wd)
|
|
{
|
|
if (dd->flags & AH_HOSTS)
|
|
{
|
|
struct hostsfile *ah;
|
|
if ((ah = dyndir_addhosts(dd, in->name)))
|
|
{
|
|
const unsigned int removed = cache_remove_uid(ah->index);
|
|
|
|
/* Is this is a deletion event? */
|
|
if (in->mask & IN_DELETE)
|
|
my_syslog(LOG_INFO, _("inotify: %s removed"), ah->fname);
|
|
else
|
|
my_syslog(LOG_INFO, _("inotify: %s new or modified"), ah->fname);
|
|
|
|
if (removed > 0)
|
|
my_syslog(LOG_INFO, _("inotify: flushed %u names read from %s"), removed, ah->fname);
|
|
|
|
/* (Re-)load hostsfile only if this event isn't triggered by deletion */
|
|
if (!(in->mask & IN_DELETE))
|
|
read_hostsfile(ah->fname, ah->index, 0, NULL, 0);
|
|
#ifdef HAVE_DHCP
|
|
if (daemon->dhcp || daemon->doing_dhcp6)
|
|
{
|
|
/* Propagate the consequences of loading a new dhcp-host */
|
|
dhcp_update_configs(daemon->dhcp_conf);
|
|
lease_update_from_configs();
|
|
lease_update_file(now);
|
|
lease_update_dns(1);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
#ifdef HAVE_DHCP
|
|
else if (!(in->mask & IN_DELETE))
|
|
{
|
|
char *path;
|
|
|
|
if ((path = whine_malloc(strlen(dd->dname) + in->len + 2)))
|
|
{
|
|
strcpy(path, dd->dname);
|
|
strcat(path, "/");
|
|
strcat(path, in->name);
|
|
|
|
my_syslog(LOG_INFO, _("inotify: %s new or modified"), path);
|
|
|
|
if ((dd->flags & AH_DHCP_HST) && option_read_dynfile(path, AH_DHCP_HST))
|
|
{
|
|
/* Propagate the consequences of loading a new dhcp-host */
|
|
dhcp_update_configs(daemon->dhcp_conf);
|
|
lease_update_from_configs();
|
|
lease_update_file(now);
|
|
lease_update_dns(1);
|
|
}
|
|
|
|
if (dd->flags & AH_DHCP_OPT)
|
|
option_read_dynfile(path, AH_DHCP_OPT);
|
|
|
|
free(path);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return hit;
|
|
}
|
|
|
|
#endif /* INOTIFY */
|