haiku.git

/*
 * Copyright 2005, Haiku Inc. All Rights Reserved.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *	Ficus Kirkpatrick (ficus@ior.com)
 *	Jérôme Duval
 *	Axel Dörfler, axeld@pinc-software.de
 *  Stefano Ceccherini
 */

/* A shell utility for somewhat emulating the Tracker's "Find By Formula"
 * functionality.
 */


#include <Entry.h>
#include <LocaleRoster.h>
#include <Path.h>
#include <Query.h>
#include <String.h>
#include <Volume.h>
#include <VolumeRoster.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "FilteredQuery.h"

extern const char *__progname;
static const char *kProgramName = __progname;

struct folder_params
{
	BPath path;
	bool includeSubFolders;
};


static bool
FilterByFolder(const entry_ref *ref, void *arg)
{
	folder_params* params = static_cast<folder_params*>(arg);
	BPath& wantedPath = params->path;
	bool includeSub = params->includeSubFolders;

	BPath path(ref);
	if (includeSub) {
		if (!strncmp(path.Path(), wantedPath.Path(),
				strlen(wantedPath.Path())))
			return true;
	} else {
		if (path.GetParent(&path) == B_OK &&
			path == wantedPath)
			return true;
	}
	return false;
}


// Option variables.
static bool sAllVolumes = false;		// Query all volumes?
static bool sEscapeMetaChars = true;	// Escape metacharacters?
static bool sFilesOnly = false;			// Show only files?
static bool sLocalizedAppNames = false;	// match localized names
static bool sSubFolders = false;		// Include sub-folders?


void
usage(void)
{
	printf("usage: %s [ -ef ] [ -p <path-to-search> ] [ -s ] [ -a || -v <path-to-volume> ] expression\n"
		"  -e\t\tdon't escape meta-characters\n"
		"  -f\t\tshow only files (ie. no directories or symbolic links)\n"
		"  -l\t\tmatch expression with localized application names\n"
		"  -p <path>\tsearch only in the given path.\n"
		"  -s\t\tinclude subfolders (only meaningful when used with \"-p\")\n"
		"  -a\t\tperform the query on all volumes\n"
		"  -v <file>\tperform the query on just one volume; <file> can be any\n"
		"\t\tfile on that volume. Defaults to the current volume.\n"
		"  Hint: '%s name=foo' will find files named \"foo\"\n",
		kProgramName, kProgramName);
	exit(0);
}


void
perform_query(BVolume &volume, const char *predicate, const char *filterpath)
{
	TFilteredQuery query;
	query.SetVolume(&volume);

	if (sLocalizedAppNames)
		query.SetPredicate("BEOS:APP_SIG=*");
	else
		query.SetPredicate(predicate);

	folder_params options;
	if (filterpath != NULL && filterpath[0] != '\0') {
		options.path = filterpath;
		options.includeSubFolders = sSubFolders;
		query.AddFilter(FilterByFolder, &options);
	}

	status_t status = query.Fetch();
	if (status == B_BAD_VALUE) {
		// the "name=" part may be omitted in our arguments
		BString string = "name=";
		string << predicate;

		query.SetPredicate(string.String());
		status = query.Fetch();
	}
	if (status != B_OK) {
		fprintf(stderr, "%s: bad query expression\n", kProgramName);
		return;
	}

	BEntry entry;
	BPath path;
	while (query.GetNextEntry(&entry) == B_OK) {
		if (sFilesOnly && !entry.IsFile())
			continue;

		if (entry.GetPath(&path) < B_OK) {
			fprintf(stderr, "%s: could not get path for entry\n", kProgramName);
			continue;
		}

		BString string;
		if (sLocalizedAppNames && predicate != NULL) {
			entry_ref ref;

			if (entry.GetRef(&ref) != B_OK || BLocaleRoster::Default()
				->GetLocalizedFileName(string, ref) != B_OK)
				continue;

			if (string.IFindFirst(predicate) < 0)
				continue;
		}

		string = path.Path();
		if (sEscapeMetaChars)
			string.CharacterEscape(" ()?*&\"'[]^\\~|;!<>*$\t", '\\');

		printf("%s\n", string.String());
	}
}


int
main(int argc, char **argv)
{
	// Make sure we have the minimum number of arguments.
	if (argc < 2)
		usage();

	// Which volume do we make the query on?
	// Default to the current volume.
	char volumePath[B_FILE_NAME_LENGTH];
	strcpy(volumePath, ".");

	// We won't filter by dirs unless this gets set by "-p <path>".
	char directoryPath[B_PATH_NAME_LENGTH] = { '\0' };

	// Parse command-line arguments.
	int opt;
	while ((opt = getopt(argc, argv, "efsalv:p:")) != -1) {
		switch(opt) {
			case 'e':
				sEscapeMetaChars = false;
				break;
			case 'f':
				sFilesOnly = true;
				break;
			case 's':
				sSubFolders = true;
				break;
			case 'a':
				sAllVolumes = true;
				break;
			case 'l':
				sLocalizedAppNames = true;
				break;
			case 'v':
				strlcpy(volumePath, optarg, B_FILE_NAME_LENGTH);
				break;
			case 'p':
				strlcpy(directoryPath, optarg, B_PATH_NAME_LENGTH);
				break;

			default:
				usage();
				break;
		}
	}

	BVolume volume;

	if (!sAllVolumes) {
		// Find the volume that the query should be performed on,
		// and set the query to it.
		BEntry entry(volumePath);
		if (entry.InitCheck() != B_OK) {
			fprintf(stderr, "%s: \"%s\" is not a valid file\n", kProgramName, volumePath);
			exit(1);
		}

		status_t status = entry.GetVolume(&volume);
		if (status != B_OK) {
			fprintf(stderr, "%s: could not get volume: %s\n", kProgramName, strerror(status));
			exit(1);
		}

		if (!volume.KnowsQuery())
			fprintf(stderr, "%s: volume containing %s is not query-enabled\n", kProgramName, volumePath);
		else
			perform_query(volume, argv[optind], directoryPath);
	} else {
		// Okay, we want to query all the disks -- so iterate over
		// them, one by one, running the query.
		BVolumeRoster volumeRoster;
		while (volumeRoster.GetNextVolume(&volume) == B_OK) {
			// We don't print errors here -- this will catch /pipe and
			// other filesystems we don't care about.
			if (volume.KnowsQuery())
				perform_query(volume, argv[optind], directoryPath);
		}
	}

	return 0;
}