btrfs-progs/common/format-output.c
Adam Borowski 1e6246eaec btrfs-progs: fix a printf format string fatal warning
At least in Debian, default build flags include -Werror=format-security,
for good reasons in most cases.  Here, the string comes from strftime --
and though I don't suspect any locale would be crazy enough to have %X
include a '%' char, the compiler has no way to know that.

Signed-off-by: Adam Borowski <kilobyte@angband.pl>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-07-26 17:46:41 +02:00

315 lines
7.4 KiB
C

/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License v2 as published by the Free Software Foundation.
*
* 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, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 021110-1307, USA.
*/
#include "kerncompat.h"
#include <stdio.h>
#include <uuid/uuid.h>
#include "common-defs.h"
#include "common/format-output.h"
#include "common/utils.h"
#include "cmds/commands.h"
static void print_uuid(const u8 *uuid)
{
char uuidparse[BTRFS_UUID_UNPARSED_SIZE];
if (uuid_is_null(uuid)) {
putchar('-');
} else {
uuid_unparse(uuid, uuidparse);
printf("%s", uuidparse);
}
}
static void fmt_indent1(int indent)
{
while (indent--)
putchar(' ');
}
static void fmt_indent2(int indent)
{
while (indent--) {
putchar(' ');
putchar(' ');
}
}
static void fmt_error(struct format_ctx *fctx)
{
printf("INTERNAL ERROR: formatting json: depth=%d\n", fctx->depth);
exit(1);
}
static void fmt_inc_depth(struct format_ctx *fctx)
{
if (fctx->depth >= JSON_NESTING_LIMIT - 1) {
printf("INTERNAL ERROR: nesting too deep, limit %d\n",
JSON_NESTING_LIMIT);
exit(1);
}
fctx->depth++;
}
static void fmt_dec_depth(struct format_ctx *fctx)
{
if (fctx->depth < 1) {
printf("INTERNAL ERROR: nesting below first level\n");
exit(1);
}
fctx->depth--;
}
static void fmt_separator(struct format_ctx *fctx)
{
if (bconf.output_format == CMD_FORMAT_JSON) {
/* Check current depth */
if (fctx->memb[fctx->depth] == 0) {
/* First member, only indent */
putchar('\n');
fmt_indent2(fctx->depth);
fctx->memb[fctx->depth] = 1;
} else if (fctx->memb[fctx->depth] == 1) {
/* Something has been printed already */
printf(",\n");
fmt_indent2(fctx->depth);
fctx->memb[fctx->depth] = 2;
} else {
/* N-th member */
printf(",\n");
fmt_indent2(fctx->depth);
}
}
}
void fmt_start(struct format_ctx *fctx, const struct rowspec *spec, int width,
int indent)
{
fctx->width = width;
fctx->indent = indent;
fctx->rowspec = spec;
fctx->depth = 1;
if (bconf.output_format & CMD_FORMAT_JSON) {
putchar('{');
/* The top level is a map and is the first one */
fctx->jtype[fctx->depth] = JSON_TYPE_MAP;
fctx->memb[fctx->depth] = 0;
fmt_print_start_group(fctx, "__header", JSON_TYPE_MAP);
fmt_separator(fctx);
printf("\"version\": \"1\"");
fctx->memb[fctx->depth] = 1;
fmt_print_end_group(fctx, "__header");
}
}
void fmt_end(struct format_ctx *fctx)
{
if (fctx->depth != 1)
fprintf(stderr, "WARNING: wrong nesting\n");
/* Close, no continuation to print */
if (bconf.output_format & CMD_FORMAT_TEXT)
putchar('\n');
else if (bconf.output_format & CMD_FORMAT_JSON) {
fmt_dec_depth(fctx);
fmt_separator(fctx);
printf("}\n");
}
}
void fmt_start_list_value(struct format_ctx *fctx)
{
if (bconf.output_format == CMD_FORMAT_TEXT) {
fmt_indent1(fctx->indent);
} else if (bconf.output_format == CMD_FORMAT_JSON) {
fmt_separator(fctx);
fmt_indent2(fctx->depth);
putchar('"');
}
}
void fmt_end_list_value(struct format_ctx *fctx)
{
if (bconf.output_format == CMD_FORMAT_TEXT)
putchar('\n');
else if (bconf.output_format == CMD_FORMAT_JSON)
putchar('"');
}
void fmt_start_value(struct format_ctx *fctx, const struct rowspec *row)
{
if (bconf.output_format == CMD_FORMAT_TEXT) {
if (strcmp(row->fmt, "list") == 0)
putchar('\n');
else if (strcmp(row->fmt, "map") == 0)
putchar('\n');
} else if (bconf.output_format == CMD_FORMAT_JSON) {
if (strcmp(row->fmt, "list") == 0) {
} else if (strcmp(row->fmt, "map") == 0) {
} else {
putchar('"');
}
}
}
void fmt_end_value(struct format_ctx *fctx, const struct rowspec *row)
{
if (bconf.output_format == CMD_FORMAT_JSON) {
if (strcmp(row->fmt, "list") == 0) {
} else if (strcmp(row->fmt, "map") == 0) {
} else {
putchar('"');
}
}
}
void fmt_print_start_group(struct format_ctx *fctx, const char *name,
enum json_type jtype)
{
if (bconf.output_format == CMD_FORMAT_JSON) {
fmt_separator(fctx);
fmt_inc_depth(fctx);
fctx->jtype[fctx->depth] = jtype;
fctx->memb[fctx->depth] = 0;
if (jtype == JSON_TYPE_MAP)
printf("\"%s\": {", name);
else if (jtype == JSON_TYPE_ARRAY)
printf("\"%s\": [", name);
else
fmt_error(fctx);
}
}
void fmt_print_end_group(struct format_ctx *fctx, const char *name)
{
if (bconf.output_format == CMD_FORMAT_JSON) {
/* Whatever was on previous line won't continue with "," */
const enum json_type jtype = fctx->jtype[fctx->depth];
fmt_dec_depth(fctx);
putchar('\n');
fmt_indent2(fctx->depth);
if (jtype == JSON_TYPE_MAP)
putchar('}');
else if (jtype == JSON_TYPE_ARRAY)
putchar(']');
else
fmt_error(fctx);
}
}
/* Use rowspec to print according to currently set output format */
void fmt_print(struct format_ctx *fctx, const char* key, ...)
{
va_list args;
const struct rowspec *row;
bool found = false;
va_start(args, key);
row = &fctx->rowspec[0];
while (row->key) {
if (strcmp(key, row->key) == 0) {
found = true;
break;
}
row++;
}
if (!found) {
printf("INTERNAL ERROR: unknown key: %s\n", key);
exit(1);
}
if (bconf.output_format == CMD_FORMAT_TEXT) {
const bool print_colon = row->out_text[0];
int len;
putchar('\n');
fmt_indent1(fctx->indent);
len = strlen(row->out_text);
printf("%s", row->out_text);
if (print_colon) {
putchar(':');
len++;
}
fmt_indent1(fctx->width - len);
} else if (bconf.output_format == CMD_FORMAT_JSON) {
if (strcmp(row->fmt, "list") == 0) {
fmt_print_start_group(fctx, row->out_json,
JSON_TYPE_ARRAY);
} else if (strcmp(row->fmt, "map") == 0) {
fmt_print_start_group(fctx, row->out_json,
JSON_TYPE_MAP);
} else {
/* Simple key/values */
fmt_separator(fctx);
printf("\"%s\": ", row->out_json);
}
}
fmt_start_value(fctx, row);
if (row->fmt[0] == '%') {
vprintf(row->fmt, args);
} else if (strcmp(row->fmt, "uuid") == 0) {
const u8 *uuid = va_arg(args, const u8*);
print_uuid(uuid);
} else if (strcmp(row->fmt, "time-long") == 0) {
const time_t ts = va_arg(args, time_t);
if (ts) {
char tstr[256];
struct tm tm;
localtime_r(&ts, &tm);
strftime(tstr, 256, "%Y-%m-%d %X %z", &tm);
printf("%s", tstr);
} else {
putchar('-');
}
} else if (strcmp(row->fmt, "list") == 0) {
} else if (strcmp(row->fmt, "map") == 0) {
} else if (strcmp(row->fmt, "qgroupid") == 0) {
const u64 level = va_arg(args, u64);
const u64 id = va_arg(args, u64);
printf("%llu/%llu", level, id);
} else if (strcmp(row->fmt, "size-or-none") == 0) {
const u64 size = va_arg(args, u64);
const unsigned int unit_mode = va_arg(args, unsigned int);
if (size)
printf("%s", pretty_size_mode(size, unit_mode));
else
putchar('-');
} else if (strcmp(row->fmt, "size") == 0) {
const u64 size = va_arg(args, u64);
const unsigned int unit_mode = va_arg(args, unsigned int);
printf("%s", pretty_size_mode(size, unit_mode));
} else {
printf("INTERNAL ERROR: unknown format %s\n", row->fmt);
}
fmt_end_value(fctx, row);
/* No newline here, the line is closed by next value or group end */
va_end(args);
}