/*
* Copyright (c) 2005 Christophe Varoqui
* Copyright (c) 2005 Benjamin Marzinski, Redhat
*/
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include <signal.h>
#include "file.h"
#include "debug.h"
#include "uxsock.h"
/*
* significant parts of this file were taken from iscsi-bindings.c of the
* linux-iscsi project.
* Copyright (C) 2002 Cisco Systems, Inc.
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*
* See the file COPYING included with this distribution for more details.
*/
int
ensure_directories_exist(const char *str, mode_t dir_mode)
{
char *pathname;
char *end;
int err;
pathname = strdup(str);
if (!pathname){
condlog(0, "Cannot copy file pathname %s : %s",
str, strerror(errno));
return -1;
}
end = pathname;
/* skip leading slashes */
while (end && *end && (*end == '/'))
end++;
while ((end = strchr(end, '/'))) {
/* if there is another slash, make the dir. */
*end = '\0';
err = mkdir(pathname, dir_mode);
if (err && errno != EEXIST) {
condlog(0, "Cannot make directory [%s] : %s",
pathname, strerror(errno));
free(pathname);
return -1;
}
if (!err)
condlog(3, "Created dir [%s]", pathname);
*end = '/';
end++;
}
free(pathname);
return 0;
}
static void
sigalrm(__attribute__((unused)) int sig)
{
/* do nothing */
}
static int
lock_file(int fd, const char *file_name)
{
struct sigaction act, oldact;
sigset_t set, oldset;
struct flock lock;
int err;
memset(&lock, 0, sizeof(lock));
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
act.sa_handler = sigalrm;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigemptyset(&set);
sigaddset(&set, SIGALRM);
sigaction(SIGALRM, &act, &oldact);
pthread_sigmask(SIG_UNBLOCK, &set, &oldset);
alarm(FILE_TIMEOUT);
err = fcntl(fd, F_SETLKW, &lock);
alarm(0);
if (err) {
if (errno != EINTR)
condlog(0, "Cannot lock %s : %s", file_name,
strerror(errno));
else
condlog(0, "%s is locked. Giving up.", file_name);
}
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigaction(SIGALRM, &oldact, NULL);
return err;
}
int
open_file(const char *file, int *can_write, const char *header)
{
int fd;
struct stat s;
if (ensure_directories_exist(file, 0700))
return -1;
*can_write = 1;
fd = open(file, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
if (fd < 0) {
if (errno == EROFS) {
*can_write = 0;
condlog(3, "Cannot open file [%s] read/write. "
" trying readonly", file);
fd = open(file, O_RDONLY);
if (fd < 0) {
condlog(0, "Cannot open file [%s] "
"readonly : %s", file, strerror(errno));
return -1;
}
}
else {
condlog(0, "Cannot open file [%s] : %s", file,
strerror(errno));
return -1;
}
}
if (*can_write && lock_file(fd, file) < 0)
goto fail;
memset(&s, 0, sizeof(s));
if (fstat(fd, &s) < 0){
condlog(0, "Cannot stat file %s : %s", file, strerror(errno));
goto fail;
}
if (s.st_size == 0) {
if (*can_write == 0)
goto fail;
/* If file is empty, write the header */
int len = strlen(header);
if (write(fd, header, len) != len) {
condlog(0,
"Cannot write header to file %s : %s", file,
strerror(errno));
/* cleanup partially written header */
if (ftruncate(fd, 0))
condlog(0, "Cannot truncate header : %s",
strerror(errno));
goto fail;
}
fsync(fd);
condlog(3, "Initialized new file [%s]", file);
}
return fd;
fail:
close(fd);
return -1;
}