[thirdparty/xfsprogs-dev.git] / db / fprint.c

/*
 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * 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.
 *
 * This program is distributed in the hope that it would 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 the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "libxfs.h"
#include <ctype.h>
#include <time.h>
#include "type.h"
#include "faddr.h"
#include "fprint.h"
#include "field.h"
#include "inode.h"
#include "btblock.h"
#include "bit.h"
#include "print.h"
#include "output.h"
#include "sig.h"
#include "malloc.h"
#include "io.h"

int
fp_charns(
	void	*obj,
	int	bit,
	int	count,
	char	*fmtstr,
	int	size,
	int	arg,
	int	base,
	int	array)
{
	int	i;
	char	*p;

	ASSERT(bitoffs(bit) == 0);
	ASSERT(size == bitsz(char));
	dbprintf("\"");
	for (i = 0, p = (char *)obj + byteize(bit);
	     i < count && !seenint();
	     i++, p++) {
		if (*p == '\\' || *p == '\'' || *p == '"' || *p == '\?')
			dbprintf("\\%c", *p);
		else if (isgraph((int)*p) || *p == ' ')
			dbprintf("%c", *p);
		else if (*p == '\a' || *p == '\b' || *p == '\f' || *p == '\n' ||
			 *p == '\r' || *p == '\t' || *p == '\v')
			dbprintf("\\%c", *p + ('a' - '\a'));
		else
			dbprintf("\\%03o", *p & 0xff);
	}
	dbprintf("\"");
	return 1;
}

int
fp_num(
	void		*obj,
	int		bit,
	int		count,
	char		*fmtstr,
	int		size,
	int		arg,
	int		base,
	int		array)
{
	int		bitpos;
	int		i;
	int		isnull;
	__int64_t	val;

	for (i = 0, bitpos = bit;
	     i < count && !seenint();
	     i++, bitpos += size) {
		val = getbitval(obj, bitpos, size,
			(arg & FTARG_SIGNED) ? BVSIGNED : BVUNSIGNED);
		if ((arg & FTARG_SKIPZERO) && val == 0)
			continue;
		isnull = (arg & FTARG_SIGNED) || size == 64 ?
			val == -1LL : val == ((1LL << size) - 1LL);
		if ((arg & FTARG_SKIPNULL) && isnull)
			continue;
		if (array && count > 1)
			dbprintf("%d:", i + base);
		if ((arg & FTARG_DONULL) && isnull)
			dbprintf(_("null"));
		else if (size > 32)
			dbprintf(fmtstr, val);
		else
			dbprintf(fmtstr, (__int32_t)val);
		if (i < count - 1)
			dbprintf(" ");
	}
	return 1;
}

/*ARGSUSED*/
int
fp_sarray(
	void	*obj,
	int	bit,
	int	count,
	char	*fmtstr,
	int	size,
	int	arg,
	int	base,
	int	array)
{
	print_sarray(obj, bit, count, size, base, array,
		(const field_t *)fmtstr, (arg & FTARG_SKIPNMS) != 0);
	return 1;
}

/*ARGSUSED*/
int
fp_time(
	void	*obj,
	int	bit,
	int	count,
	char	*fmtstr,
	int	size,
	int	arg,
	int	base,
	int	array)
{
	int	bitpos;
	char	*c;
	int	i;
	time_t  t;

	ASSERT(bitoffs(bit) == 0);
	for (i = 0, bitpos = bit;
	     i < count && !seenint();
	     i++, bitpos += size) {
		if (array)
			dbprintf("%d:", i + base);
		t=(time_t)getbitval((char *)obj + byteize(bitpos), 0, sizeof(int32_t)*8, 0);
		c = ctime(&t);
		dbprintf("%24.24s", c);
		if (i < count - 1)
			dbprintf(" ");
	}
	return 1;
}

/*ARGSUSED*/
int
fp_uuid(
	void	*obj,
	int	bit,
	int	count,
	char	*fmtstr,
	int	size,
	int	arg,
	int	base,
	int	array)
{
	char	bp[40];	/* UUID string is 36 chars + trailing '\0' */
	int	i;
	uuid_t	*p;

	ASSERT(bitoffs(bit) == 0);
	for (p = (uuid_t *)((char *)obj + byteize(bit)), i = 0;
	     i < count && !seenint();
	     i++, p++) {
		if (array)
			dbprintf("%d:", i + base);
		platform_uuid_unparse(p, bp);
		dbprintf("%s", bp);
		if (i < count - 1)
			dbprintf(" ");
	}
	return 1;
}

/*
 * CRC is correct is the current buffer it is being pulled out
 * of is not marked with a EFSCORRUPTED error.
 */
int
fp_crc(
	void	*obj,
	int	bit,
	int	count,
	char	*fmtstr,
	int	size,
	int	arg,
	int	base,
	int	array)
{
	int		bitpos;
	int		i;
	__int64_t	val;
	char		*ok;

	switch (iocur_crc_valid()) {
	case -1:
		ok = "unchecked";
		break;
	case 0:
		ok = "bad";
		break;
	case 1:
		ok = "correct";
		break;
	default:
		ok = "unknown state";
		break;
	}

	for (i = 0, bitpos = bit;
	     i < count && !seenint();
	     i++, bitpos += size) {
		if (array)
			dbprintf("%d:", i + base);
		val = getbitval(obj, bitpos, size, BVUNSIGNED);
		if (size > 32)
			dbprintf(fmtstr, val, ok);
		else
			dbprintf(fmtstr, (__int32_t)val, ok);
		if (i < count - 1)
			dbprintf(" ");
	}
	return 1;
}
Commit	Line	Data
2bd0ea18	1	/*
da23017d NS	2	* Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
da23017d NS	3	* All Rights Reserved.
dfc130f3	4	*
da23017d NS	5	* This program is free software; you can redistribute it and/or
da23017d NS	6	* modify it under the terms of the GNU General Public License as
2bd0ea18	7	* published by the Free Software Foundation.
dfc130f3	8	*
da23017d NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
dfc130f3	13	*
da23017d NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2bd0ea18 NS	17	*/
2bd0ea18 NS	18
6b803e5a	19	#include "libxfs.h"
2bd0ea18 NS	20	#include <ctype.h>
	21	#include <time.h>
	22	#include "type.h"
	23	#include "faddr.h"
	24	#include "fprint.h"
	25	#include "field.h"
	26	#include "inode.h"
49b31417	27	#include "btblock.h"
2bd0ea18 NS	28	#include "bit.h"
	29	#include "print.h"
	30	#include "output.h"
	31	#include "sig.h"
	32	#include "malloc.h"
0522f1cc	33	#include "io.h"
2bd0ea18 NS	34
	35	int
	36	fp_charns(
	37	void *obj,
	38	int bit,
	39	int count,
	40	char *fmtstr,
	41	int size,
	42	int arg,
	43	int base,
	44	int array)
	45	{
	46	int i;
	47	char *p;
	48
	49	ASSERT(bitoffs(bit) == 0);
	50	ASSERT(size == bitsz(char));
	51	dbprintf("\"");
	52	for (i = 0, p = (char *)obj + byteize(bit);
	53	i < count && !seenint();
	54	i++, p++) {
	55	if (p == '\\' \|\| p == '\'' \|\| p == '"' \|\| p == '\?')
	56	dbprintf("\\%c", *p);
93d9f139	57	else if (isgraph((int)p) \|\| p == ' ')
2bd0ea18 NS	58	dbprintf("%c", *p);
	59	else if (p == '\a' \|\| p == '\b' \|\| p == '\f' \|\| p == '\n' \|\|
	60	p == '\r' \|\| p == '\t' \|\| *p == '\v')
	61	dbprintf("\\%c", *p + ('a' - '\a'));
	62	else
	63	dbprintf("\\%03o", *p & 0xff);
	64	}
	65	dbprintf("\"");
	66	return 1;
	67	}
	68
	69	int
	70	fp_num(
	71	void *obj,
	72	int bit,
	73	int count,
	74	char *fmtstr,
	75	int size,
	76	int arg,
	77	int base,
	78	int array)
	79	{
	80	int bitpos;
	81	int i;
	82	int isnull;
	83	__int64_t val;
	84
	85	for (i = 0, bitpos = bit;
	86	i < count && !seenint();
	87	i++, bitpos += size) {
	88	val = getbitval(obj, bitpos, size,
	89	(arg & FTARG_SIGNED) ? BVSIGNED : BVUNSIGNED);
	90	if ((arg & FTARG_SKIPZERO) && val == 0)
	91	continue;
	92	isnull = (arg & FTARG_SIGNED) \|\| size == 64 ?
	93	val == -1LL : val == ((1LL << size) - 1LL);
	94	if ((arg & FTARG_SKIPNULL) && isnull)
	95	continue;
0ebbf1d5	96	if (array && count > 1)
2bd0ea18 NS	97	dbprintf("%d:", i + base);
2bd0ea18 NS	98	if ((arg & FTARG_DONULL) && isnull)
9ee7055c	99	dbprintf(_("null"));
2bd0ea18 NS	100	else if (size > 32)
	101	dbprintf(fmtstr, val);
	102	else
	103	dbprintf(fmtstr, (__int32_t)val);
	104	if (i < count - 1)
	105	dbprintf(" ");
	106	}
	107	return 1;
	108	}
	109
	110	/ARGSUSED/
	111	int
	112	fp_sarray(
	113	void *obj,
	114	int bit,
	115	int count,
	116	char *fmtstr,
	117	int size,
	118	int arg,
	119	int base,
	120	int array)
	121	{
	122	print_sarray(obj, bit, count, size, base, array,
	123	(const field_t *)fmtstr, (arg & FTARG_SKIPNMS) != 0);
	124	return 1;
	125	}
	126
	127	/ARGSUSED/
	128	int
	129	fp_time(
	130	void *obj,
	131	int bit,
	132	int count,
	133	char *fmtstr,
	134	int size,
	135	int arg,
	136	int base,
	137	int array)
	138	{
	139	int bitpos;
	140	char *c;
	141	int i;
dfc130f3	142	time_t t;
2bd0ea18 NS	143
	144	ASSERT(bitoffs(bit) == 0);
	145	for (i = 0, bitpos = bit;
	146	i < count && !seenint();
	147	i++, bitpos += size) {
	148	if (array)
	149	dbprintf("%d:", i + base);
dfc130f3	150	t=(time_t)getbitval((char )obj + byteize(bitpos), 0, sizeof(int32_t)8, 0);
2bd0ea18 NS	151	c = ctime(&t);
	152	dbprintf("%24.24s", c);
	153	if (i < count - 1)
	154	dbprintf(" ");
	155	}
	156	return 1;
	157	}
	158
	159	/ARGSUSED/
	160	int
	161	fp_uuid(
	162	void *obj,
	163	int bit,
	164	int count,
	165	char *fmtstr,
	166	int size,
	167	int arg,
	168	int base,
	169	int array)
	170	{
	171	char bp[40]; /* UUID string is 36 chars + trailing '\0' */
	172	int i;
	173	uuid_t *p;
	174
	175	ASSERT(bitoffs(bit) == 0);
	176	for (p = (uuid_t )((char )obj + byteize(bit)), i = 0;
	177	i < count && !seenint();
	178	i++, p++) {
	179	if (array)
	180	dbprintf("%d:", i + base);
4d32d744	181	platform_uuid_unparse(p, bp);
2bd0ea18 NS	182	dbprintf("%s", bp);
	183	if (i < count - 1)
	184	dbprintf(" ");
	185	}
	186	return 1;
	187	}
0522f1cc DC	188
	189	/*
	190	* CRC is correct is the current buffer it is being pulled out
	191	* of is not marked with a EFSCORRUPTED error.
	192	*/
	193	int
	194	fp_crc(
	195	void *obj,
	196	int bit,
	197	int count,
	198	char *fmtstr,
	199	int size,
	200	int arg,
	201	int base,
	202	int array)
	203	{
	204	int bitpos;
	205	int i;
	206	__int64_t val;
	207	char *ok;
	208
b511ff41 DC	209	switch (iocur_crc_valid()) {
	210	case -1:
	211	ok = "unchecked";
	212	break;
	213	case 0:
	214	ok = "bad";
	215	break;
	216	case 1:
	217	ok = "correct";
	218	break;
	219	default:
	220	ok = "unknown state";
	221	break;
	222	}
0522f1cc DC	223
	224	for (i = 0, bitpos = bit;
	225	i < count && !seenint();
	226	i++, bitpos += size) {
	227	if (array)
	228	dbprintf("%d:", i + base);
	229	val = getbitval(obj, bitpos, size, BVUNSIGNED);
	230	if (size > 32)
	231	dbprintf(fmtstr, val, ok);
	232	else
	233	dbprintf(fmtstr, (__int32_t)val, ok);
	234	if (i < count - 1)
	235	dbprintf(" ");
	236	}
	237	return 1;
	238	}