1/*
2 * test_icount.c
3 *
4 * Copyright (C) 1997 Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Public
8 * License.
9 * %End-Header%
10 */
11
12#include "config.h"
13#include <stdio.h>
14#include <stdlib.h>
15#include <string.h>
16#include <unistd.h>
17#ifdef HAVE_GETOPT_H
18#include <getopt.h>
19#endif
20#include <fcntl.h>
21
22#include <ext2fs/ext2_fs.h>
23
24#include <et/com_err.h>
25#include <ss/ss.h>
26#include <ext2fs/ext2fs.h>
27#include <ext2fs/irel.h>
28#include <ext2fs/brel.h>
29
30extern ss_request_table test_cmds;
31
32#include "test_icount.h"
33
34ext2_filsys test_fs;
35ext2_icount_t test_icount;
36
37/*
38 * Helper function which assures that the icount structure is valid
39 */
40static int check_icount(char *request)
41{
42	if (test_icount)
43		return 0;
44	com_err(request, 0, "The icount structure must be allocated.");
45	return 1;
46}
47
48/*
49 * Helper function which parses an inode number.
50 */
51static int parse_inode(const char *request, const char *desc,
52		       const char *str, ext2_ino_t *ino)
53{
54	char *tmp;
55
56	*ino = strtoul(str, &tmp, 0);
57	if (*tmp) {
58		com_err(request, 0, "Bad %s - %s", desc, str);
59		return 1;
60	}
61	return 0;
62}
63
64void do_create_icount(int argc, char **argv)
65{
66	errcode_t	retval;
67	char		*progname;
68	int		flags = 0;
69	ext2_ino_t	size = 5;
70
71	progname = *argv;
72	argv++; argc --;
73
74	if (argc && !strcmp("-i", *argv)) {
75		flags |= EXT2_ICOUNT_OPT_INCREMENT;
76		argv++; argc--;
77	}
78	if (argc) {
79		if (parse_inode(progname, "icount size", argv[0], &size))
80			return;
81		argv++; argc--;
82	}
83#if 0
84	printf("Creating icount... flags=%d, size=%d\n", flags, (int) size);
85#endif
86	retval = ext2fs_create_icount(test_fs, flags, (int) size,
87				      &test_icount);
88	if (retval) {
89		com_err(progname, retval, "while creating icount");
90		return;
91	}
92}
93
94void do_free_icount(int argc, char **argv)
95{
96	if (check_icount(argv[0]))
97		return;
98
99	ext2fs_free_icount(test_icount);
100	test_icount = 0;
101}
102
103void do_fetch(int argc, char **argv)
104{
105	const char	*usage = "usage: %s inode\n";
106	errcode_t	retval;
107	ext2_ino_t	ino;
108	__u16		count;
109
110	if (argc < 2) {
111		printf(usage, argv[0]);
112		return;
113	}
114	if (check_icount(argv[0]))
115		return;
116	if (parse_inode(argv[0], "inode", argv[1], &ino))
117		return;
118	retval = ext2fs_icount_fetch(test_icount, ino, &count);
119	if (retval) {
120		com_err(argv[0], retval, "while calling ext2fs_icount_fetch");
121		return;
122	}
123	printf("Count is %u\n", count);
124}
125
126void do_increment(int argc, char **argv)
127{
128	const char	*usage = "usage: %s inode\n";
129	errcode_t	retval;
130	ext2_ino_t	ino;
131	__u16		count;
132
133	if (argc < 2) {
134		printf(usage, argv[0]);
135		return;
136	}
137	if (check_icount(argv[0]))
138		return;
139	if (parse_inode(argv[0], "inode", argv[1], &ino))
140		return;
141	retval = ext2fs_icount_increment(test_icount, ino, &count);
142	if (retval) {
143		com_err(argv[0], retval,
144			"while calling ext2fs_icount_increment");
145		return;
146	}
147	printf("Count is now %u\n", count);
148}
149
150void do_decrement(int argc, char **argv)
151{
152	const char	*usage = "usage: %s inode\n";
153	errcode_t	retval;
154	ext2_ino_t	ino;
155	__u16		count;
156
157	if (argc < 2) {
158		printf(usage, argv[0]);
159		return;
160	}
161	if (check_icount(argv[0]))
162		return;
163	if (parse_inode(argv[0], "inode", argv[1], &ino))
164		return;
165	retval = ext2fs_icount_decrement(test_icount, ino, &count);
166	if (retval) {
167		com_err(argv[0], retval,
168			"while calling ext2fs_icount_decrement");
169		return;
170	}
171	printf("Count is now %u\n", count);
172}
173
174void do_store(int argc, char **argv)
175{
176	const char	*usage = "usage: %s inode count\n";
177	errcode_t	retval;
178	ext2_ino_t	ino;
179	ext2_ino_t	count;
180
181	if (argc < 3) {
182		printf(usage, argv[0]);
183		return;
184	}
185	if (check_icount(argv[0]))
186		return;
187	if (parse_inode(argv[0], "inode", argv[1], &ino))
188		return;
189	if (parse_inode(argv[0], "count", argv[2], &count))
190		return;
191	if (count > 65535) {
192		printf("Count too large.\n");
193		return;
194	}
195	retval = ext2fs_icount_store(test_icount, ino, (__u16) count);
196	if (retval) {
197		com_err(argv[0], retval,
198			"while calling ext2fs_icount_store");
199		return;
200	}
201}
202
203void do_dump(int argc, char **argv)
204{
205	errcode_t	retval;
206	ext2_ino_t	i;
207	__u16		count;
208
209	if (check_icount(argv[0]))
210		return;
211	for (i=1; i <= test_fs->super->s_inodes_count; i++) {
212		retval = ext2fs_icount_fetch(test_icount, i, &count);
213		if (retval) {
214			com_err(argv[0], retval,
215				"while fetching icount for %lu", (unsigned long)i);
216			return;
217		}
218		if (count)
219			printf("%lu: %u\n", (unsigned long)i, count);
220	}
221}
222
223void do_validate(int argc, char **argv)
224{
225	errcode_t	retval;
226
227	if (check_icount(argv[0]))
228		return;
229	retval = ext2fs_icount_validate(test_icount, stdout);
230	if (retval) {
231		com_err(argv[0], retval, "while validating icount structure");
232		return;
233	}
234	printf("Icount structure successfully validated\n");
235}
236
237void do_get_size(int argc, char **argv)
238{
239	ext2_ino_t	size;
240
241	if (check_icount(argv[0]))
242		return;
243	size = ext2fs_get_icount_size(test_icount);
244	printf("Size of icount is: %lu\n", (unsigned long)size);
245}
246
247static int source_file(const char *cmd_file, int sci_idx)
248{
249	FILE		*f;
250	char		buf[256];
251	char		*cp;
252	int		exit_status = 0;
253	int		retval;
254	int 		noecho;
255
256	if (strcmp(cmd_file, "-") == 0)
257		f = stdin;
258	else {
259		f = fopen(cmd_file, "r");
260		if (!f) {
261			perror(cmd_file);
262			exit(1);
263		}
264	}
265	fflush(stdout);
266	fflush(stderr);
267	setbuf(stdout, NULL);
268	setbuf(stderr, NULL);
269	while (!feof(f)) {
270		if (fgets(buf, sizeof(buf), f) == NULL)
271			break;
272		if (buf[0] == '#')
273			continue;
274		noecho = 0;
275		if (buf[0] == '-') {
276			noecho = 1;
277			buf[0] = ' ';
278		}
279		cp = strchr(buf, '\n');
280		if (cp)
281			*cp = 0;
282		cp = strchr(buf, '\r');
283		if (cp)
284			*cp = 0;
285		if (!noecho)
286			printf("test_icount: %s\n", buf);
287		retval = ss_execute_line(sci_idx, buf);
288		if (retval) {
289			ss_perror(sci_idx, retval, buf);
290			exit_status++;
291		}
292	}
293	if (f != stdin)
294		fclose(f);
295	return exit_status;
296}
297
298int main(int argc, char **argv)
299{
300	int		retval;
301	int		sci_idx;
302	int		c;
303	char		*request = 0;
304	int		exit_status = 0;
305	char		*cmd_file = 0;
306	struct ext2_super_block param;
307
308	initialize_ext2_error_table();
309
310	/*
311	 * Create a sample filesystem structure
312	 */
313	memset(&param, 0, sizeof(struct ext2_super_block));
314	ext2fs_blocks_count_set(&param, 80000);
315	param.s_inodes_count = 20000;
316	retval = ext2fs_initialize("/dev/null", 0, &param,
317				   unix_io_manager, &test_fs);
318	if (retval) {
319		com_err("/dev/null", retval, "while setting up test fs");
320		exit(1);
321	}
322
323	while ((c = getopt (argc, argv, "wR:f:")) != EOF) {
324		switch (c) {
325		case 'R':
326			request = optarg;
327			break;
328		case 'f':
329			cmd_file = optarg;
330			break;
331		default:
332			com_err(argv[0], 0, "Usage: test_icount "
333				"[-R request] [-f cmd_file]");
334			exit(1);
335		}
336	}
337	sci_idx = ss_create_invocation("test_icount", "0.0", (char *) NULL,
338				       &test_cmds, &retval);
339	if (retval) {
340		ss_perror(sci_idx, retval, "creating invocation");
341		exit(1);
342	}
343
344	(void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &retval);
345	if (retval) {
346		ss_perror(sci_idx, retval, "adding standard requests");
347		exit (1);
348	}
349	if (request) {
350		retval = 0;
351		retval = ss_execute_line(sci_idx, request);
352		if (retval) {
353			ss_perror(sci_idx, retval, request);
354			exit_status++;
355		}
356	} else if (cmd_file) {
357		exit_status = source_file(cmd_file, sci_idx);
358	} else {
359		ss_listen(sci_idx);
360	}
361
362	return(exit_status);
363}
364