path: root/src/vty/utils.c

/*! \file utils.c
 * Utility routines for printing common objects in the Osmocom world. */
/*
 * (C) 2009-2010 by Harald Welte <laforge@gnumonks.org>
 * (C) 2013,2015 by sysmocom - s.f.m.c. GmbH
 *
 * All Rights Reserved
 *
 * SPDX-License-Identifier: GPL-2.0+
 *
 * 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 2 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, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>

#include <osmocom/core/linuxlist.h>
#include <osmocom/core/talloc.h>
#include <osmocom/core/timer.h>
#include <osmocom/core/rate_ctr.h>
#include <osmocom/core/stat_item.h>
#include <osmocom/core/utils.h>
#include <osmocom/core/counter.h>

#include <osmocom/vty/vty.h>

/*! \addtogroup rate_ctr
 *  @{
 */

struct vty_out_context {
	struct vty *vty;
	const char *prefix;
	int max_level;
};

static int rate_ctr_handler(
	struct rate_ctr_group *ctrg, struct rate_ctr *ctr,
	const struct rate_ctr_desc *desc, void *vctx_)
{
	struct vty_out_context *vctx = vctx_;
	struct vty *vty = vctx->vty;

	vty_out(vty, " %s%s: %8" PRIu64 " "
		"(%" PRIu64 "/s %" PRIu64 "/m %" PRIu64 "/h %" PRIu64 "/d)%s",
		vctx->prefix, desc->description, ctr->current,
		ctr->intv[RATE_CTR_INTV_SEC].rate,
		ctr->intv[RATE_CTR_INTV_MIN].rate,
		ctr->intv[RATE_CTR_INTV_HOUR].rate,
		ctr->intv[RATE_CTR_INTV_DAY].rate,
		VTY_NEWLINE);

	return 0;
}

/*! print a rate counter group to given VTY
 *  \param[in] vty The VTY to which it should be printed
 *  \param[in] prefix Any additional log prefix ahead of each line
 *  \param[in] ctrg Rate counter group to be printed
 */
void vty_out_rate_ctr_group(struct vty *vty, const char *prefix,
			    struct rate_ctr_group *ctrg)
{
	struct vty_out_context vctx = {vty, prefix};

	vty_out(vty, "%s%s:%s", prefix, ctrg->desc->group_description, VTY_NEWLINE);

	rate_ctr_for_each_counter(ctrg, rate_ctr_handler, &vctx);
}

static char *
pad_append_str(char *s, const char *a, int minwidth)
{
	s = talloc_asprintf_append(s, "%*s", minwidth, a);
	OSMO_ASSERT(s);
	return s;
}

static char *
pad_append_ctr(char *s, uint64_t ctr, int minwidth)
{
	s = talloc_asprintf_append(s, "%*" PRIu64, minwidth, ctr);
	OSMO_ASSERT(s);
	return s;
}

static int rate_ctr_handler_fmt(
	struct rate_ctr_group *ctrg, struct rate_ctr *ctr,
	const struct rate_ctr_desc *desc, void *vctx_)
{
	struct vty_out_context *vctx = vctx_;
	struct vty *vty = vctx->vty;
	const char *fmt = vctx->prefix;
	char *s = talloc_strdup(vty, "");
	OSMO_ASSERT(s);

	while (*fmt) {
		int ch, minwidth = 0, sign = 1;
		char *p = strchr(fmt, '%');

		if (p == NULL) {
			/* No further % directives in format string. Copy rest verbatim and exit. */
			s = talloc_strdup_append_buffer(s, fmt);
			OSMO_ASSERT(s);
			break;
		} else {
			ptrdiff_t len;

			OSMO_ASSERT(p >= fmt);
			len = p - fmt;
			if (len) {
				/* Copy bytes verbatim until next '%' byte. */
				s = talloc_strndup_append_buffer(s, fmt, len);
				OSMO_ASSERT(s);
			}
			fmt = (const char *)(p + 1); /* skip past '%' */
			if (*fmt == '\0')
				break;
		}

		ch = *fmt++;
		if (ch == '-' && isdigit(*fmt)) {
			sign = -1;
			ch = *fmt++;
		}
		while (isdigit(ch) && *fmt != '\0') {
			minwidth *= 10;
			minwidth += (ch - '0');
			ch = *fmt++;
		}
		minwidth *= sign;

		switch (ch) {
		case '%':
			s = talloc_asprintf_append(s, "%c", ch);
			OSMO_ASSERT(s);
			break;
		case 'd':
			s = pad_append_str(s, desc->description, minwidth);
			break;
		case 'n':
			s = pad_append_str(s, desc->name, minwidth);
			break;
		case 'c':
			s = pad_append_ctr(s, ctr->current, minwidth);
			break;
		case 'p':
			s = pad_append_ctr(s, ctr->previous, minwidth);
			break;
		case 'S':
			s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_SEC].rate, minwidth);
			break;
		case 'M':
			s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_MIN].rate, minwidth);
			break;
		case 'H':
			s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_HOUR].rate, minwidth);
			break;
		case 'D':
			s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_DAY].rate, minwidth);
			break;
		default:
			break;
		}
	}

	vty_out(vty, "%s%s", s, VTY_NEWLINE);
	talloc_free(s);

	return 0;
}

/*! print a rate counter group to given VTY, formatting the line for each counter according to a format string.
 *
 * The following format string directives are supported:
 * - %d: The description of the counter
 * - %n: The name of the counter
 * - %c: The current value of the counter
 * - %p: The previous value of the counter
 * - %S: The interval of the counter in seconds
 * - %M: The interval of the counter in minutes
 * - %H: The interval of the counter in hours
 * - %D: The interval of the counter in days
 * - %%: Print a literal %.
 *
 * An optional number between % and the letter in a format directive may be used to set a minimum field width.
 * If the expanded format directive is smaller than this width (according to strlen()) the string will be
 * left-padded (if the number is positive) or right-padded (if the number is negative) with spaces.
 * For example, "%25n" prints the counter name left-padded up to a minimum width of 25 columns.
 *
 * VTY_NEWLINE will be appended to the format string when it is printed.
 *
 *  \param[in] vty The VTY to which it should be printed
 *  \param[in] ctrg Rate counter group to be printed
 *  \param[in] fmt A format which may contain the above directives.
 */
void vty_out_rate_ctr_group_fmt(struct vty *vty, const char *fmt,
				struct rate_ctr_group *ctrg)
{
	struct vty_out_context vctx = {vty, fmt};

	vty_out(vty, "%s:%s", ctrg->desc->group_description, VTY_NEWLINE);

	rate_ctr_for_each_counter(ctrg, rate_ctr_handler_fmt, &vctx);
}

static int rate_ctr_group_handler(struct rate_ctr_group *ctrg, void *vctx_)
{
	struct vty_out_context *vctx = vctx_;
	struct vty *vty = vctx->vty;

	if (ctrg->desc->class_id > vctx->max_level)
		return 0;

	if (ctrg->idx)
		vty_out(vty, "%s%s (%d):%s", vctx->prefix,
			ctrg->desc->group_description, ctrg->idx, VTY_NEWLINE);
	else
		vty_out(vty, "%s%s:%s", vctx->prefix,
			ctrg->desc->group_description, VTY_NEWLINE);

	rate_ctr_for_each_counter(ctrg, rate_ctr_handler, vctx);

	return 0;
}

/*! @} */


/*! \addtogroup stats
 *  @{
 */

static int osmo_stat_item_handler(
	struct osmo_stat_item_group *statg, struct osmo_stat_item *item, void *vctx_)
{
	struct vty_out_context *vctx = vctx_;
	struct vty *vty = vctx->vty;
	const char *unit =
		item->desc->unit != OSMO_STAT_ITEM_NO_UNIT ?
		item->desc->unit : "";

	vty_out(vty, " %s%s: %8" PRIi32 " %s%s",
		vctx->prefix, item->desc->description,
		osmo_stat_item_get_last(item),
		unit, VTY_NEWLINE);

	return 0;
}

/*! print a stat item group to given VTY
 *  \param[in] vty The VTY to which it should be printed
 *  \param[in] prefix Any additional log prefix ahead of each line
 *  \param[in] statg Stat item group to be printed
 */
void vty_out_stat_item_group(struct vty *vty, const char *prefix,
			     struct osmo_stat_item_group *statg)
{
	struct vty_out_context vctx = {vty, prefix};

	vty_out(vty, "%s%s:%s", prefix, statg->desc->group_description,
		VTY_NEWLINE);
	osmo_stat_item_for_each_item(statg, osmo_stat_item_handler, &vctx);
}

static int osmo_stat_item_group_handler(struct osmo_stat_item_group *statg, void *vctx_)
{
	struct vty_out_context *vctx = vctx_;
	struct vty *vty = vctx->vty;

	if (statg->desc->class_id > vctx->max_level)
		return 0;

	if (statg->idx)
		vty_out(vty, "%s%s (%d):%s", vctx->prefix,
			statg->desc->group_description, statg->idx,
			VTY_NEWLINE);
	else
		vty_out(vty, "%s%s:%s", vctx->prefix,
			statg->desc->group_description, VTY_NEWLINE);

	osmo_stat_item_for_each_item(statg, osmo_stat_item_handler, vctx);

	return 0;
}

/*! @} */

/*! \addtogroup vty
 *  @{
 */

static int handle_counter(struct osmo_counter *counter, void *vctx_)
{
	struct vty_out_context *vctx = vctx_;
	struct vty *vty = vctx->vty;
	const char *description = counter->description;

	if (!counter->description)
		description = counter->name;

	vty_out(vty, " %s%s: %8lu%s",
		vctx->prefix, description,
		osmo_counter_get(counter), VTY_NEWLINE);

	return 0;
}

void vty_out_statistics_partial(struct vty *vty, const char *prefix,
	int max_level)
{
	struct vty_out_context vctx = {vty, prefix, max_level};

	vty_out(vty, "%sUngrouped counters:%s", prefix, VTY_NEWLINE);
	osmo_counters_for_each(handle_counter, &vctx);
	rate_ctr_for_each_group(rate_ctr_group_handler, &vctx);
	osmo_stat_item_for_each_group(osmo_stat_item_group_handler, &vctx);
}

void vty_out_statistics_full(struct vty *vty, const char *prefix)
{
	vty_out_statistics_partial(vty, prefix, INT_MAX);
}

/*! Generate a VTY command string from value_string */
char *vty_cmd_string_from_valstr(void *ctx, const struct value_string *vals,
				 const char *prefix, const char *sep,
				 const char *end, int do_lower)
{
	int len = 0, offset = 0, ret, rem;
	int size = strlen(prefix) + strlen(end);
	int sep_len = strlen(sep);
	const struct value_string *vs;
	char *str;

	for (vs = vals; vs->value || vs->str; vs++)
		size += strlen(vs->str) + sep_len;

	rem = size;
	str = talloc_zero_size(ctx, size);
	if (!str)
		return NULL;

	ret = snprintf(str + offset, rem, "%s", prefix);
	if (ret < 0)
		goto err;
	OSMO_SNPRINTF_RET(ret, rem, offset, len);

	for (vs = vals; vs->value || vs->str; vs++) {
		if (vs->str) {
			int j, name_len = strlen(vs->str)+1;
			char name[name_len];

			for (j = 0; j < name_len; j++)
				name[j] = do_lower ?
					tolower(vs->str[j]) : vs->str[j];

			name[name_len-1] = '\0';
			ret = snprintf(str + offset, rem, "%s%s", name, sep);
			if (ret < 0)
				goto err;
			OSMO_SNPRINTF_RET(ret, rem, offset, len);
		}
	}
	offset -= sep_len;	/* to remove the trailing sep */
	rem += sep_len;

	ret = snprintf(str + offset, rem, "%s", end);
	if (ret < 0)
		goto err;
	OSMO_SNPRINTF_RET(ret, rem, offset, len);
err:
	str[size-1] = '\0';
	return str;
}

/*! @} */