sbase/rm.c

/* See LICENSE file for copyright and license details. */
#include "fs.h"
#include "util.h"

static void
usage(void)
{
	eprintf("usage: %s [-f] [-Rr] file ...\n", argv0);
}

int
main(int argc, char *argv[])
{
	struct recursor r = { .fn = rm, .hist = NULL, .depth = 0, .maxdepth = 1,
	                      .follow = 'P', .flags = 0 };

	ARGBEGIN {
	case 'f':
		r.flags |= SILENT;
		break;
	case 'R':
	case 'r':
		r.maxdepth = 0;
		break;
	default:
		usage();
	} ARGEND

	if (!argc) {
		if (!(r.flags & SILENT))
			usage();
		else
			return 0;
	}

	for (; *argv; argc--, argv++)
		recurse(*argv, NULL, &r);

	return rm_status || recurse_status;
}
add rm, thanks rob 2011-05-23 20:52:28 -04:00			`/* See LICENSE file for copyright and license details. */`
implement cp and mv and improve rm 2012-01-30 17:41:33 -05:00			`#include "fs.h"`
add rm, thanks rob 2011-05-23 20:52:28 -04:00			`#include "util.h"`

Eliminating the getopt disgrace. 2013-06-14 14:20:47 -04:00			`static void`
			`usage(void)`
			`{`
rm: Remove -i from usage and manpage We do not support it so do not lie to the user. 2015-02-19 09:54:12 -05:00			`eprintf("usage: %s [-f] [-Rr] file ...\n", argv0);`
Eliminating the getopt disgrace. 2013-06-14 14:20:47 -04:00			`}`

add rm, thanks rob 2011-05-23 20:52:28 -04:00			`int`
			`main(int argc, char *argv[])`
			`{`
Add maxdepth to recurse() This also makes more sense. 2015-04-18 16:04:49 -04:00			`struct recursor r = { .fn = rm, .hist = NULL, .depth = 0, .maxdepth = 1,`
			`.follow = 'P', .flags = 0 };`
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before. 2015-03-12 19:25:32 -04:00
Eliminating the getopt disgrace. 2013-06-14 14:20:47 -04:00			`ARGBEGIN {`
			`case 'f':`
Add SILENT flag to recurse() recurse() is getting smarter every day. I expect it to pass the Turing test in a few months. Along the way, it was reported that "rm -f" on nonexistant files reports their missing as an internal recurse()-error. So recurse() knows when to shut up, I added the SILENT flag to fix all these things. 2015-04-19 08:00:47 -04:00			`r.flags \|= SILENT;`
Eliminating the getopt disgrace. 2013-06-14 14:20:47 -04:00			`break;`
Add -R as a synonym to -r for rm(1) Some scripts require this. 2013-12-12 08:15:07 -05:00			`case 'R':`
Eliminating the getopt disgrace. 2013-06-14 14:20:47 -04:00			`case 'r':`
Add maxdepth to recurse() This also makes more sense. 2015-04-18 16:04:49 -04:00			`r.maxdepth = 0;`
Eliminating the getopt disgrace. 2013-06-14 14:20:47 -04:00			`break;`
			`default:`
			`usage();`
No need for semicolon after ARGEND This is also the style used in Plan 9. 2015-11-01 05:16:49 -05:00			`} ARGEND`
None of these work without the proper # of arguments so print usage 2013-08-31 18:04:49 -04:00
Audit rm(1) 1) One small argc-style-matter 2) manpage cleanup 3) NOTE: The utility-functions will be evaluated separately. 2015-02-28 15:30:20 -05:00			`if (!argc) {`
Add SILENT flag to recurse() recurse() is getting smarter every day. I expect it to pass the Turing test in a few months. Along the way, it was reported that "rm -f" on nonexistant files reports their missing as an internal recurse()-error. So recurse() knows when to shut up, I added the SILENT flag to fix all these things. 2015-04-19 08:00:47 -04:00			`if (!(r.flags & SILENT))`
A plain rm -f is valid and should not be considered an error 2014-07-04 09:50:20 -04:00			`usage();`
			`else`
Stop using EXIT_{SUCCESS,FAILURE} 2014-10-02 18:46:04 -04:00			`return 0;`
A plain rm -f is valid and should not be considered an error 2014-07-04 09:50:20 -04:00			`}`
None of these work without the proper # of arguments so print usage 2013-08-31 18:04:49 -04:00
Make already audited tools argv-centric instead of argc-centric This has already been suggested by Evan Gates <evan.gates@gmail.com> and he's totally right about it. So, what's the problem? I wrote a testing program asshole.c with int main(void) { execl("/path/to/sbase/echo", "echo", "test"); return 0; } and checked the results with glibc and musl. Note that the sentinel NULL is missing from the end of the argument list. glibc calculates an argc of 5, musl 4 (instead of 2) and thus mess up things anyway. The powerful arg.h also focuses on argv instead of argc as well, but ignoring argc completely is also the wrong way to go. Instead, a more idiomatic approach is to check *argv only and decrement argc on the go. While at it, I rewrote yes(1) in an argv-centric way as well. All audited tools have been "fixed" and each following audited tool will receive the same treatment. 2015-03-02 08:19:26 -05:00			`for (; *argv; argc--, argv++)`
Refactor recurse() again Okay, why yet another recurse()-refactor? The last one added the recursor-struct, which simplified things on the user-end, but there was still one thing that bugged me a lot: Previously, all fn()'s were forced to (l)stat the paths themselves. This does not work well when you try to keep up with H-, L- and P- flags at the same time, as each utility-function would have to set the right function-pointer for (l)stat every single time. This is not desirable. Furthermore, recurse should be easy to use and not involve trouble finding the right (l)stat-function to do it right. So, what we needed was a stat-argument for each fn(), so it is directly accessible. This was impossible to do though when the fn()'s are still directly called by the programs to "start" the recurse. Thus, the fundamental change is to make recurse() the function to go, while designing the fn()'s in a way they can "live" with st being NULL (we don't want a null-pointer-deref). What you can see in this commit is the result of this work. Why all this trouble instead of using nftw? The special thing about recurse() is that you tell the function when to recurse() in your fn(). You don't need special flags to tell nftw() to skip the subtree, just to give an example. The only single downside to this is that now, you are not allowed to unconditionally call recurse() from your fn(). It has to be a directory. However, that is a cost I think is easily weighed up by the advantages. Another thing is the history: I added a procedure at the end of the outmost recurse to free the history. This way we don't leak memory. A simple optimization on the side: - if (h->dev == st.st_dev && h->ino == st.st_ino) + if (h->ino == st.st_ino && h->dev == st.st_dev) First compare the likely difference in inode-numbers instead of checking the unlikely condition that the device-numbers are different. 2015-03-18 19:53:42 -04:00			`recurse(*argv, NULL, &r);`
add rm, thanks rob 2011-05-23 20:52:28 -04:00
Add history and config-struct to recurse For loop detection, a history is mandatory. In the process of also adding a flexible struct to recurse, the recurse-definition was moved to fs.h. The motivation behind the struct is to allow easy extensions to the recurse-function without having to change the prototypes of all functions in the process. Adding flags is really simple as well now. Using the recursor-struct, it's also easier to see which defaults apply to a program (for instance, which type of follow, ...). Another change was to add proper stat-lstat-usage in recurse. It was wrong before. 2015-03-12 19:25:32 -04:00			`return rm_status \|\| recurse_status;`
add rm, thanks rob 2011-05-23 20:52:28 -04:00			`}`