mirror of
https://github.com/ibm-s390-linux/s390-tools.git
synced 2026-08-05 02:14:52 +00:00
a97a8f1cba
By default, files opened via fopen are block-buffered. As a result, I/O errors that occur during file write operations via util_file_write_* are silently ignored because fputs() only buffers data while actual I/O occurs during the flush operation that is part of the final fclose() library call. Fix this by indicating errors that occur during fclose() via the util_file_write_* function return code. Reviewed-by: Jan Höppner <hoeppner@linux.ibm.com> Signed-off-by: Peter Oberparleiter <oberpar@linux.ibm.com> Signed-off-by: Steffen Eiden <seiden@linux.ibm.com>
672 lines
15 KiB
C
672 lines
15 KiB
C
/*
|
|
* util - Utility function library
|
|
*
|
|
* Read and write files
|
|
*
|
|
* Copyright IBM Corp. 2016, 2017
|
|
*
|
|
* s390-tools is free software; you can redistribute it and/or modify
|
|
* it under the terms of the MIT license. See LICENSE for details.
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <linux/limits.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include "lib/util_base.h"
|
|
#include "lib/util_exit_code.h"
|
|
#include "lib/util_file.h"
|
|
#include "lib/util_libc.h"
|
|
#include "lib/util_panic.h"
|
|
#include "lib/util_prg.h"
|
|
|
|
#define READ_CHUNK_SIZE 4096
|
|
|
|
extern const char *toolname;
|
|
|
|
/*
|
|
* Read the first line of a file into given buffer
|
|
*/
|
|
static int file_gets(char *str, size_t size, const char *path)
|
|
{
|
|
char *p, *end;
|
|
FILE *fp;
|
|
int rc;
|
|
|
|
/* In case of error we always return empty string */
|
|
str[0] = 0;
|
|
/* Read the string */
|
|
fp = fopen(path, "r");
|
|
if (!fp)
|
|
return -1;
|
|
p = fgets(str, size, fp);
|
|
if (p) {
|
|
/* Check for end of line */
|
|
end = memchr(str, '\n', size);
|
|
if (end)
|
|
*end = 0;
|
|
else
|
|
str[size - 1] = 0;
|
|
}
|
|
if (strlen(str) == 0) {
|
|
rc = -1;
|
|
goto out_fclose;
|
|
}
|
|
rc = 0;
|
|
out_fclose:
|
|
fclose(fp);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Read the first line of a file
|
|
*
|
|
* If read is successful 'str' contains first line of a file without the
|
|
* trailing newline. If read fails, an empty string is returned for 'str'
|
|
* The resulting string will always be null-terminated.
|
|
*
|
|
* @param[out] str Result buffer
|
|
* @param[in] size Size of the result buffer
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 File was read
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_line(char *const str, size_t size, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX];
|
|
va_list ap;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
return file_gets(str, size, path);
|
|
}
|
|
|
|
/*
|
|
* Write string to a file
|
|
*/
|
|
static int file_puts(const char *str, const char *path)
|
|
{
|
|
FILE *fp;
|
|
int rc;
|
|
|
|
/* write the string */
|
|
fp = fopen(path, "w");
|
|
if (!fp)
|
|
return -1;
|
|
if (fputs(str, fp) == EOF) {
|
|
rc = -1;
|
|
goto out_fclose;
|
|
}
|
|
rc = 0;
|
|
out_fclose:
|
|
if (fclose(fp))
|
|
return -1;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Write string to a file without the terminating null byte
|
|
*
|
|
* @param[in] str Content is to be written
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Write was successful
|
|
* @retval -1 Error while writing file
|
|
*/
|
|
int util_file_write_s(const char *str, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX];
|
|
va_list ap;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
return file_puts(str, path);
|
|
}
|
|
|
|
/**
|
|
* Write signed long value to a file according to given base
|
|
*
|
|
* @param[in] val Value is to be written
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Write was successful
|
|
* @retval -1 Error while writing file
|
|
*/
|
|
int util_file_write_l(long val, int base, const char *fmt, ...)
|
|
{
|
|
char *str, path[PATH_MAX];
|
|
va_list ap;
|
|
int rc;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
switch (base) {
|
|
case 8:
|
|
util_asprintf(&str, "%lo", val);
|
|
break;
|
|
case 10:
|
|
util_asprintf(&str, "%ld", val);
|
|
break;
|
|
case 16:
|
|
util_asprintf(&str, "%lx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
rc = file_puts(str, path);
|
|
free(str);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Write signed long long value to a file according to given base
|
|
*
|
|
* @param[in] val Value is to be written
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Write was successful
|
|
* @retval -1 Error while writing file
|
|
*/
|
|
int util_file_write_ll(long long val, int base, const char *fmt, ...)
|
|
{
|
|
char *str, path[PATH_MAX];
|
|
va_list ap;
|
|
int rc;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
switch (base) {
|
|
case 8:
|
|
util_asprintf(&str, "%llo", val);
|
|
break;
|
|
case 10:
|
|
util_asprintf(&str, "%lld", val);
|
|
break;
|
|
case 16:
|
|
util_asprintf(&str, "%llx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
rc = file_puts(str, path);
|
|
free(str);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Write unsigned long value to a file according to given base
|
|
*
|
|
* @param[in] val Value is to be written
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Write was successful
|
|
* @retval -1 Error while writing file
|
|
*/
|
|
int util_file_write_ul(unsigned long val, int base, const char *fmt, ...)
|
|
{
|
|
char *str, path[PATH_MAX];
|
|
va_list ap;
|
|
int rc;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
switch (base) {
|
|
case 8:
|
|
util_asprintf(&str, "%lo", val);
|
|
break;
|
|
case 10:
|
|
util_asprintf(&str, "%lu", val);
|
|
break;
|
|
case 16:
|
|
util_asprintf(&str, "%lx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
rc = file_puts(str, path);
|
|
free(str);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Write unsigned long long value to a file according to given base
|
|
*
|
|
* @param[in] val Value is to be written
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Write was successful
|
|
* @retval -1 Error while writing file
|
|
*/
|
|
int util_file_write_ull(unsigned long long val, int base, const char *fmt, ...)
|
|
{
|
|
char *str, path[PATH_MAX];
|
|
va_list ap;
|
|
int rc;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
switch (base) {
|
|
case 8:
|
|
util_asprintf(&str, "%llo", val);
|
|
break;
|
|
case 10:
|
|
util_asprintf(&str, "%llu", val);
|
|
break;
|
|
case 16:
|
|
util_asprintf(&str, "%llx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
rc = file_puts(str, path);
|
|
free(str);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it to signed int according to given base
|
|
*
|
|
* @param[out] val Buffer for value
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Integer has been read correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_i(int *val, int base, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX], buf[512];
|
|
va_list ap;
|
|
int count;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
switch (base) {
|
|
case 8:
|
|
count = sscanf(buf, "%o", val);
|
|
break;
|
|
case 10:
|
|
count = sscanf(buf, "%d", val);
|
|
break;
|
|
case 16:
|
|
count = sscanf(buf, "%x", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
return (count == 1) ? 0 : -1;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it to signed long according to given base
|
|
*
|
|
* @param[out] val Buffer for value
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Long integer has been read correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_l(long *val, int base, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX], buf[512];
|
|
va_list ap;
|
|
int count;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
switch (base) {
|
|
case 8:
|
|
count = sscanf(buf, "%lo", val);
|
|
break;
|
|
case 10:
|
|
count = sscanf(buf, "%ld", val);
|
|
break;
|
|
case 16:
|
|
count = sscanf(buf, "%lx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
return (count == 1) ? 0 : -1;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it to signed long long according to given base
|
|
*
|
|
* @param[out] val Buffer for value
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Long integer has been read correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_ll(long long *val, int base, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX], buf[512];
|
|
va_list ap;
|
|
int count;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
switch (base) {
|
|
case 8:
|
|
count = sscanf(buf, "%llo", val);
|
|
break;
|
|
case 10:
|
|
count = sscanf(buf, "%lld", val);
|
|
break;
|
|
case 16:
|
|
count = sscanf(buf, "%llx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
return (count == 1) ? 0 : -1;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it to unsigned int according to given base
|
|
*
|
|
* @param[out] val Buffer for value
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Integer has been read correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_ui(unsigned int *val, int base, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX], buf[512];
|
|
va_list ap;
|
|
int count;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
switch (base) {
|
|
case 8:
|
|
count = sscanf(buf, "%o", val);
|
|
break;
|
|
case 10:
|
|
count = sscanf(buf, "%u", val);
|
|
break;
|
|
case 16:
|
|
count = sscanf(buf, "%x", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
return (count == 1) ? 0 : -1;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it to unsigned long according to given base
|
|
*
|
|
* @param[out] val Buffer for value
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Long integer has been read correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_ul(unsigned long *val, int base, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX], buf[512];
|
|
va_list ap;
|
|
int count;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
switch (base) {
|
|
case 8:
|
|
count = sscanf(buf, "%lo", val);
|
|
break;
|
|
case 10:
|
|
count = sscanf(buf, "%lu", val);
|
|
break;
|
|
case 16:
|
|
count = sscanf(buf, "%lx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
return (count == 1) ? 0 : -1;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it to unsigned long long according to given base
|
|
*
|
|
* @param[out] val Buffer for value
|
|
* @param[in] base Base for conversion, either 8, 10, or 16
|
|
* @param[in] fmt Format string for generation of the path name
|
|
* @param[in] ... Parameters for format string
|
|
*
|
|
* @retval 0 Long integer has been read correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
int util_file_read_ull(unsigned long long *val, int base, const char *fmt, ...)
|
|
{
|
|
char path[PATH_MAX], buf[512];
|
|
va_list ap;
|
|
int count;
|
|
|
|
/* Construct the file name */
|
|
UTIL_VSPRINTF(path, fmt, ap);
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
switch (base) {
|
|
case 8:
|
|
count = sscanf(buf, "%llo", val);
|
|
break;
|
|
case 10:
|
|
count = sscanf(buf, "%llu", val);
|
|
break;
|
|
case 16:
|
|
count = sscanf(buf, "%llx", val);
|
|
break;
|
|
default:
|
|
util_panic("Invalid base: %d\n", base);
|
|
}
|
|
return (count == 1) ? 0 : -1;
|
|
}
|
|
|
|
/**
|
|
* Read a file and convert it according to format string
|
|
*
|
|
* @param[in] path File name to read
|
|
* @param[in] fmt Format string for parsing the content
|
|
* @param[out] ... Parameters for format string
|
|
*
|
|
* @retval != -1 Number of values parsed correctly
|
|
* @retval -1 Error while reading file
|
|
*/
|
|
|
|
int util_file_read_va(const char *path, const char *fmt, ...)
|
|
{
|
|
char buf[512];
|
|
va_list ap;
|
|
int ret;
|
|
|
|
if (file_gets(buf, sizeof(buf), path))
|
|
return -1;
|
|
|
|
va_start(ap, fmt);
|
|
ret = vsscanf(buf, fmt, ap);
|
|
va_end(ap);
|
|
if (ret == EOF)
|
|
return -1;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Print an error message indicating an out-of-memory situation and exit.
|
|
*/
|
|
static void oom(void)
|
|
{
|
|
fprintf(stderr, "Out of memory\n");
|
|
|
|
/* We can't rely on our clean-up routines to work reliably during an
|
|
* OOM situation, so just exit here.
|
|
*/
|
|
exit(UTIL_EXIT_OUT_OF_MEMORY);
|
|
}
|
|
|
|
/**
|
|
* Read all data from @fd and return address of resulting buffer in
|
|
* @buffer_ptr. If @size_ptr is non-zero, use it to store the size of the
|
|
* resulting buffer. Return %UTIL_EXIT_OK on success.
|
|
*
|
|
* @param[in] fd File descriptor to read data from
|
|
* @param[in, out] buffer_ptr Buffer to read data into
|
|
* @param[in, out] size_ptr Buffer to save size of data read into buffer_ptr
|
|
*
|
|
* @retval 0 read was successful
|
|
* @retval UTIL_EXIT_RUNTIME_ERROR error while reading file
|
|
*/
|
|
util_exit_code_t util_file_read_fd_buf(FILE *fd, void **buffer_ptr,
|
|
size_t *size_ptr)
|
|
{
|
|
char *buffer = NULL;
|
|
size_t done = 0;
|
|
|
|
while (!feof(fd)) {
|
|
buffer = realloc(buffer, done + READ_CHUNK_SIZE);
|
|
if (!buffer)
|
|
oom();
|
|
done += fread(&buffer[done], 1, READ_CHUNK_SIZE, fd);
|
|
if (ferror(fd)) {
|
|
free(buffer);
|
|
return UTIL_EXIT_RUNTIME_ERROR;
|
|
}
|
|
}
|
|
|
|
buffer = realloc(buffer, done);
|
|
if (!buffer && done > 0)
|
|
oom();
|
|
|
|
*buffer_ptr = buffer;
|
|
if (size_ptr)
|
|
*size_ptr = done;
|
|
|
|
return UTIL_EXIT_OK;
|
|
}
|
|
|
|
/**
|
|
* Read text from @fd and return resulting NULL-terminated text buffer.
|
|
* If @chomp is non-zero, remove trailing newline character. Return %NULL
|
|
* on error or when unprintable characters are read.
|
|
*
|
|
* @param[in] fd File descriptor to read data from
|
|
* @param[in] chomp Flag to indicate trailing newlines should be removed
|
|
*
|
|
* @retval NULL Error reading from fd
|
|
* @retval != 0 Data read successfully, buffer returned
|
|
*/
|
|
char *util_file_read_fd(FILE *fd, int chomp)
|
|
{
|
|
char *buffer;
|
|
size_t done, i;
|
|
|
|
if (util_file_read_fd_buf(fd, (void **) &buffer, &done))
|
|
return NULL;
|
|
|
|
/* Check if this is a text file at all (required to filter out
|
|
* binary sysfs attributes).
|
|
*/
|
|
for (i = 0; i < done; i++) {
|
|
if (!isgraph(buffer[i]) && !isspace(buffer[i])) {
|
|
free(buffer);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* Remove trailing new-line character if requested. */
|
|
if (chomp && done > 0 && buffer[done - 1] == '\n')
|
|
done--;
|
|
|
|
/* NULL-terminate. */
|
|
buffer = realloc(buffer, done + 1);
|
|
if (!buffer)
|
|
oom();
|
|
buffer[done] = 0;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* Read file as text and return NULL-terminated contents. Remove trailing
|
|
* newline if CHOMP is specified.
|
|
*
|
|
* @param[in] path Path to the file that will be read from
|
|
* @param[in] chomp Flag to indicate trailing newlines should be removed
|
|
*
|
|
* @retval NULL Error reading from file
|
|
* @retval != 0 File read successfully, contents returned in buffer
|
|
*/
|
|
char *util_file_read_text_file(const char *path, int chomp)
|
|
{
|
|
char *buffer = NULL;
|
|
FILE *fd;
|
|
|
|
fd = fopen(path, "r");
|
|
if (!fd)
|
|
goto out;
|
|
|
|
buffer = util_file_read_fd(fd, chomp);
|
|
fclose(fd);
|
|
|
|
out:
|
|
if (!buffer) {
|
|
fprintf(stderr, "Could not read file %s: %s\n", path,
|
|
strerror(errno));
|
|
}
|
|
|
|
return buffer;
|
|
}
|