You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
212 lines
4.9 KiB
212 lines
4.9 KiB
/*
|
|
* gfsec - Secret sharing tools
|
|
* Copyright (C) 2016,2017,2018,2020 Damien Goutte-Gattat
|
|
*
|
|
* 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 3 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include "util.h"
|
|
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include <xmem.h>
|
|
|
|
/**
|
|
* Checks if the specified file exists.
|
|
*
|
|
* @param path The filename to check.
|
|
*
|
|
* @return 0 if the file exists, or -1 (check errno for details).
|
|
*/
|
|
int
|
|
file_exists(const char *path)
|
|
{
|
|
struct stat st;
|
|
|
|
assert(path != NULL);
|
|
|
|
return stat(path, &st);
|
|
}
|
|
|
|
/**
|
|
* Gets the size of the specified file.
|
|
*
|
|
* @param f The file object.
|
|
*
|
|
* @return The file's size, or -1 if an error occured
|
|
* (check errno for details).
|
|
*/
|
|
long
|
|
get_file_size(FILE *f)
|
|
{
|
|
long s;
|
|
|
|
assert(f != NULL);
|
|
|
|
if ( fseek(f, 0, SEEK_END) == -1
|
|
|| (s = ftell(f)) == -1
|
|
|| fseek(f, 0, SEEK_SET) == -1 )
|
|
s = -1;
|
|
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* Reads a file into memory.
|
|
*
|
|
* @param filename The path to the file to read.
|
|
* @param len The address where the file's size will be stored
|
|
* (may be NULL).
|
|
* @param max Do not read the file if its size exceeds this value;
|
|
* if zero, always read the file no matter its size.
|
|
*
|
|
* @return A newly allocated buffer containing the file's data, or
|
|
* NULL if an error occured (check errno for details).
|
|
*/
|
|
unsigned char *
|
|
read_file(const char *filename, size_t *len, size_t max)
|
|
{
|
|
FILE *f;
|
|
unsigned char *blob = NULL;
|
|
|
|
assert(filename != NULL);
|
|
|
|
if ( (f = fopen(filename, "r")) ) {
|
|
long size;
|
|
size_t nread;
|
|
|
|
if ( (size = get_file_size(f)) != -1 ) {
|
|
|
|
if ( max != 0 && (unsigned long) size > max )
|
|
errno = EFBIG;
|
|
else {
|
|
blob = xmalloc(size);
|
|
if ( (nread = fread(blob, 1, size, f)) < (unsigned long) size ) {
|
|
free(blob);
|
|
blob = NULL;
|
|
}
|
|
else if ( len )
|
|
*len = nread;
|
|
}
|
|
}
|
|
|
|
fclose(f);
|
|
}
|
|
|
|
return blob;
|
|
}
|
|
|
|
/**
|
|
* Writes a buffer into a file.
|
|
*
|
|
* @param filename The path to the file to write.
|
|
* @param contents The buffer to write.
|
|
* @param len The size of the \c contents buffer.
|
|
*
|
|
* @return The number of bytes written, or -1 if an error occured
|
|
* (check errno for details).
|
|
*/
|
|
int
|
|
write_file(const char *filename, const unsigned char *contents, size_t len)
|
|
{
|
|
FILE *f;
|
|
int rc = -1;
|
|
|
|
assert(filename != NULL);
|
|
assert(contents != NULL);
|
|
|
|
if ( (f = fopen(filename, "w")) ) {
|
|
rc = fwrite(contents, sizeof(char), len, f) == len ? 0 : -1;
|
|
fclose(f);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Gets the basename part of a path.
|
|
*
|
|
* @param path The path to extract the basename from.
|
|
*
|
|
* @return A newly allocated buffer containing the basename.
|
|
*/
|
|
char *
|
|
get_file_basename(const char *path)
|
|
{
|
|
char *last_slash, *last_dot;
|
|
unsigned n;
|
|
|
|
assert(path != NULL);
|
|
|
|
if ( (last_slash = strrchr(path, '/')) )
|
|
path = last_slash + 1;
|
|
|
|
if ( (last_dot = strrchr(path, '.')) )
|
|
n = last_dot - path;
|
|
else
|
|
n = strlen(path);
|
|
|
|
return xstrndup(path, n);
|
|
}
|
|
|
|
/**
|
|
* Creates a directory and its parents.
|
|
* This function creates the specified directory. Parent directories
|
|
* are created as needed.
|
|
*
|
|
* @param path The pathname of the directory to create.
|
|
* @param mode The permissions of the directory, as in creat(2).
|
|
*
|
|
* @return 0 if the directory was successfully created (or if it
|
|
* already existed), or -1 if an error occured.
|
|
*/
|
|
int
|
|
makedir(const char *path, int mode)
|
|
{
|
|
char *p, q;
|
|
int ret;
|
|
struct stat st_buf;
|
|
|
|
assert(path != NULL);
|
|
|
|
for ( p = (char *)(path + 1), ret = 0; *(p - 1) && ret == 0; p++ ) {
|
|
if ( *p == '/' || *p == '\0' ) {
|
|
q = *p, *p = '\0';
|
|
|
|
if ( stat(path, &st_buf) == -1 ) {
|
|
/* Path does not exist, attempt to create it. */
|
|
ret = mkdir(path, mode);
|
|
}
|
|
else if ( ! S_ISDIR(st_buf.st_mode) ) {
|
|
/* Path exists but is not a directory. */
|
|
errno = ENOTDIR;
|
|
ret = -1;
|
|
}
|
|
|
|
*p = q;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|