|
/**
|
|
* Copyright © 2019, Oracle and/or its affiliates. All rights reserved.
|
|
*
|
|
* Licensed under the Universal Permissive License v 1.0 as shown at
|
|
* http://oss.oracle.com/licenses/upl
|
|
*
|
|
*/
|
|
#define _GNU_SOURCE
|
|
#include "putils.h"
|
|
#include "malloc.h"
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <ftw.h>
|
|
#include "common/spew.h"
|
|
|
|
FILE* do_creat(const char *fullname) {
|
|
int fd = open(fullname, O_CREAT | O_WRONLY | O_TRUNC, S_IWUSR);
|
|
if (fd == -1) {
|
|
if (errno == EEXIST || errno == EISDIR) {
|
|
return NULL;
|
|
}
|
|
fprintf(stderr, "Trying to open %s:\n", fullname);
|
|
perror("open");
|
|
spew(SPEW_ERROR, "Create of %s failed errno=%d (%s)",
|
|
fullname, errno, strerror(errno));
|
|
abort();
|
|
}
|
|
assert(fd >= 0);
|
|
FILE *f = fdopen(fd, "w");
|
|
if (!f) {
|
|
perror("fdopen");
|
|
spew(SPEW_ERROR, "fdopen of %s for write failed errno=%d (%s)",
|
|
fullname, errno, strerror(errno));
|
|
}
|
|
assert(f);
|
|
return f;
|
|
}
|
|
|
|
FILE* do_open_for_read(const char *fullname) {
|
|
int fd = open(fullname, O_RDONLY);
|
|
if (fd == -1) {
|
|
fprintf(stderr, "Trying to open %s:\n", fullname);
|
|
perror("open");
|
|
spew(SPEW_ERROR, "Open of %s failed errno=%d (%s)",
|
|
fullname, errno, strerror(errno));
|
|
abort();
|
|
}
|
|
assert(fd >= 0);
|
|
FILE *f = fdopen(fd, "r");
|
|
if (!f) {
|
|
perror("fdopen");
|
|
spew(SPEW_ERROR, "fdopen of %s for read failed errno=%d (%s)",
|
|
fullname, errno, strerror(errno));
|
|
}
|
|
assert(f);
|
|
return f;
|
|
}
|
|
|
|
|
|
void do_fclose(FILE *f) {
|
|
int r = fclose(f);
|
|
if (r != 0) {
|
|
perror("fclose");
|
|
spew(SPEW_ERROR, "fclose %p failed errno=%d (%s)",
|
|
f, errno, strerror(errno));
|
|
}
|
|
assert(r == 0);
|
|
}
|
|
|
|
void do_write(FILE *f, const char *bytes, size_t size) {
|
|
size_t r = fwrite(bytes, 1, size, f);
|
|
if (r != size) {
|
|
perror("fwrite");
|
|
spew(SPEW_ERROR, "fwrite failed errno=%d (%s)",
|
|
errno, strerror(errno));
|
|
}
|
|
assert(r == size);
|
|
}
|
|
|
|
size_t do_read(FILE *f, char *bytes, size_t size) {
|
|
// We might be reading from a socket or a pipe, so keep reading till we get all the bytes.
|
|
size_t r = fread(bytes, 1, size, f);
|
|
if (r == 0) {
|
|
if (feof(f)) {
|
|
return 0;
|
|
}
|
|
assert(ferror(f));
|
|
fprintf(stderr, "do_read got error %d\n", ferror(f));
|
|
spew(SPEW_ERROR, "fread failed errno=%d (%s)",
|
|
errno, strerror(errno));
|
|
assert(0);
|
|
}
|
|
if (r < size) {
|
|
return r + do_read(f, bytes+r, size-r);
|
|
} else {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
int do_mkdir(const char *fullname) {
|
|
if (0) fprintf(stderr, "mkdir(\"%s\");\n", fullname);
|
|
int r = mkdir(fullname, S_IRUSR|S_IWUSR|S_IXUSR);
|
|
if (r != 0) {
|
|
if (errno == EEXIST) {
|
|
return r;
|
|
}
|
|
// We ensure that the parent exists before we call do_mkdir,
|
|
// so ENOENT is a real error.
|
|
fprintf(stderr, "Trying to mkdir %s\n", fullname);
|
|
perror("mkdir");
|
|
spew(SPEW_ERROR, "mkdir %s failed errno=%d (%s)",
|
|
fullname, errno, strerror(errno));
|
|
abort();
|
|
}
|
|
assert(r == 0);
|
|
return 0; //returns Success
|
|
}
|
|
|
|
int do_mkfifo(const char *fullname, mode_t mode) {
|
|
int r = mkfifo(fullname, mode);
|
|
if (r) {
|
|
if (errno == EEXIST) {
|
|
return r;
|
|
}
|
|
fprintf(stderr, "Trying to mkfifo(%s, %d)\n", fullname, mode);
|
|
perror("mkfifo");
|
|
spew(SPEW_ERROR, "mkfifo %s failed errno=%d (%s)",
|
|
fullname, errno, strerror(errno));
|
|
abort();
|
|
}
|
|
return 0; //returns Success
|
|
}
|
|
|
|
int do_link(const char *linkto, const char *fullname)
|
|
// Effect create a hardlink. If the file already exists delete it and then
|
|
// link.
|
|
{
|
|
int r = link(linkto, fullname);
|
|
if (r && errno == EEXIST) {
|
|
return r;
|
|
}
|
|
if (r) {
|
|
fprintf(stderr, "Trying to link \"%s\" --> \"%s\"\nerrno=%d\n", fullname, linkto, errno);
|
|
perror("link");
|
|
spew(SPEW_ERROR, "linking \"%s\" --> \"%s\" failed errno=%d (%s)",
|
|
fullname, linkto, errno, strerror(errno));
|
|
abort();
|
|
}
|
|
return 0; //returns Success
|
|
}
|
|
|
|
|
|
int do_symlink(const char *contents, const char *fullname) {
|
|
int r = symlink(contents, fullname);
|
|
return r;
|
|
}
|
|
|
|
void do_unlink(const char *fullname) {
|
|
int r = unlink(fullname);
|
|
assert(r == 0);
|
|
}
|
|
void do_rmdir(const char *fullname) {
|
|
int r = rmdir(fullname);
|
|
assert(r == 0);
|
|
}
|
|
|
|
/*
|
|
* This function is callback for nftw call that is made
|
|
* with the intention of deleting conflicts. The function
|
|
* deletes file or directory provided in the argument 'path'
|
|
*/
|
|
int delete_subtree(const char *path, const struct stat *st, int typeflag, struct FTW *d_ftw) {
|
|
int ret = 1;
|
|
if (typeflag == 4 || d_ftw == NULL) {
|
|
return ret;
|
|
}
|
|
if (S_ISDIR(st->st_mode)) {
|
|
ret = rmdir(path);
|
|
} else {
|
|
ret = unlink(path);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* Recursively deletes files/directories in directory path passed */
|
|
void delete_dir_recursively(const char *path) {
|
|
int ret = nftw(path, delete_subtree, 10, FTW_DEPTH);
|
|
if (ret != 0) {
|
|
spew(SPEW_ERROR, "Unable to delete subtree for %s. Aborting\n", path);
|
|
abort();
|
|
}
|
|
}
|
|
|
|
|
|
char *pathcat(const char *a, const char *b) {
|
|
char *result = NULL;
|
|
int r = asprintf(&result, "%s/%s", a, b);
|
|
assert(r > 0);
|
|
return result;
|
|
}
|
|
|
|
size_t parse_number_or_help(const char *numstring) {
|
|
errno = 0;
|
|
char *end;
|
|
size_t result = strtoul(numstring, &end, 0);
|
|
if (0
|
|
|| errno != 0
|
|
|| *end != 0)
|
|
{
|
|
fprintf(stderr, "Trying to parse %s as a number\n", numstring);
|
|
spew(SPEW_DEBUG, "Trying to parse %s as a number", numstring);
|
|
help(1);
|
|
return 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void
|
|
maybe_error(int r, const char *fun, const char *fname, const char *srcfile, int line) {
|
|
if (r != 0) {
|
|
fprintf(stderr, "%s:%d Could not %s(\"%s\"). errno=%d (%s)\n",
|
|
srcfile, line, fun, fname, errno, strerror(errno));
|
|
spew(SPEW_ERROR, "Could not %s(\"%s\"). errno=%d (%s)",
|
|
fun, fname, errno, strerror(errno));
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
void
|
|
maybe_error2(int r, const char *fun, const char *fname, const char *fname2, const char *srcfile, int line) {
|
|
if (r != 0) {
|
|
fprintf(stderr, "%s:%d Could not %s(\"%s\", \"%s\"). errno=%d (%s)\n",
|
|
srcfile, line,
|
|
fun, fname, fname2, errno, strerror(errno));
|
|
spew(SPEW_ERROR, "Could not %s(\"%s\", \"%s\"). errno=%d (%s)",
|
|
fun, fname, fname2, errno, strerror(errno));
|
|
exit(1);
|
|
}
|
|
}
|