/*
* read_file_line - read a line from a file
*
* Used to compose a filename from a printf format and to read a line from this
* file. All leading and trailing whitespaces (including line endings) are
* removed. The returned buffer must be freed with free(). This function is
* supposed for reading variable like content into a buffer, so files > 1024
* bytes are ignored.
*/
char *read_file_line(const char *fmt, ...)
{
va_list args;
char *filename;
char *buf, *line = NULL;
size_t size;
int ret;
struct stat s;
va_start(args, fmt);
filename = bvasprintf(fmt, args);
va_end(args);
ret = stat(filename, &s);
if (ret)
goto out;
if (s.st_size > 1024)
goto out;
buf = read_file(filename, &size);
if (!buf)
goto out;
line = strim(buf);
line = xstrdup(line);
free(buf);
out:
free(filename);
return line;
}
/*
* sprintf into a newly allocated string, reporting a fatal error with bail on
* failure.
*/
void
basprintf(char **strp, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
bvasprintf(strp, fmt, args);
va_end(args);
}
message_log_buffer(int len UNUSED, const char *fmt, va_list args,
int error UNUSED)
{
char *message;
bvasprintf(&message, fmt, args);
if (errors == NULL)
basprintf(&errors, "%s\n", message);
else {
char *new_errors;
basprintf(&new_errors, "%s%s\n", errors, message);
free(errors);
errors = new_errors;
}
free(message);
}
/*
* Report a Kerberos error and bail out.
*/
void
bail_krb5(krb5_context ctx, krb5_error_code code, const char *format, ...)
{
const char *k5_msg = NULL;
char *message;
va_list args;
if (ctx != NULL)
k5_msg = krb5_get_error_message(ctx, code);
va_start(args, format);
bvasprintf(&message, format, args);
va_end(args);
if (k5_msg == NULL)
bail("%s", message);
else
bail("%s: %s", message, k5_msg);
}
/*
* Given a function, data to pass to that function, an expected exit status,
* and expected output, runs that function in a subprocess, capturing stdout
* and stderr via a pipe, and compare the combination of stdout and stderr
* with the expected output and the exit status with the expected status.
* Expects the function to always exit (not die from a signal).
*/
void
is_function_output(test_function_type function, void *data, int status,
const char *output, const char *format, ...)
{
char *buf, *msg;
int rval;
va_list args;
run_child_function(function, data, &rval, &buf);
/* Now, check the results against what we expected. */
va_start(args, format);
bvasprintf(&msg, format, args);
va_end(args);
ok(WIFEXITED(rval), "%s (exited)", msg);
is_int(status, WEXITSTATUS(rval), "%s (status)", msg);
is_string(output, buf, "%s (output)", msg);
free(buf);
free(msg);
}
