findstr.c

/* Synchronet find string routines */

/****************************************************************************
 * @format.tab-size 4		(Plain Text/Source Code File Header)			*
 * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
 *																			*
 * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
 *																			*
 * 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.					*
 * See the GNU General Public License for more details: gpl.txt or			*
 * http://www.fsf.org/copyleft/gpl.html										*
 *																			*
 * For Synchronet coding style and modification guidelines, see				*
 * http://www.synchro.net/source.html										*
 *																			*
 * Note: If this box doesn't appear square, then you need to fix your tabs.	*
 ****************************************************************************/

#include "genwrap.h"
#include "findstr.h"
#include "nopen.h"

/****************************************************************************/
/* Pattern matching string search of 'search' in 'pattern'.					*/
/* pattern matching is case-insensitive										*/
/* patterns beginning with ';' are comments (never match)					*/
/* patterns beginning with '!' are reverse-matched (returns false if match)	*/
/* patterns ending in '~' will match string anywhere (sub-string search)	*/
/* patterns ending in '^' will match left string fragment only				*/
/* patterns including '*' must match both left and right string fragments	*/
/* all other patterns are exact-match checking								*/
/****************************************************************************/
bool findstr_in_string(const char* search, const char* pattern)
{
	char	buf[FINDSTR_MAX_LINE_LEN + 1];
	char*	p = (char*)pattern;
	char*	last;
	const char*	splat;
	size_t	len;
	bool	found = false;

	if(pattern == NULL)
		return false;

	if(*p == ';')		/* comment */
		return false;

	if(*p == '!')	{	/* reverse-match */
		found = true;
		p++;
	}

	if(search == NULL)
		return found;

	SAFECOPY(buf, p);
	p = buf;

	truncsp(p);
	len = strlen(p);
	if(len > 0) {
		last = p + len - 1;
		if(*last == '~') {
			*last = '\0';
			if(strcasestr(search, p) != NULL)
				found = !found; 
		}

		else if(*last == '^') {
			if(strnicmp(p, search, len - 1) == 0)
				found = !found; 
		}

		else if((splat = strchr(p, '*')) != NULL) {
			int left = splat - p;
			int right = len - (left + 1);
			int slen = strlen(search);
			if(slen < left + right)
				return found;
			if(strnicmp(search, p, left) == 0
				&& strnicmp(p + left + 1, search + (slen - right), right) == 0)
				found = !found;
		}

		else if(stricmp(p, search) == 0)
			found = !found; 
	} 
	return found;
}

static uint32_t encode_ipv4_address(unsigned int byte[])
{
	if(byte[0] > 0xff || byte[1] > 0xff || byte[2] > 0xff || byte[3] > 0xff)
		return 0;
	return (byte[0]<<24) | (byte[1]<<16) | (byte[2]<<8) | byte[3];
}

static uint32_t parse_ipv4_address(const char* str)
{
	unsigned int byte[4];

	if(str == NULL)
		return 0;
	if(sscanf(str, "%u.%u.%u.%u", &byte[0], &byte[1], &byte[2], &byte[3]) != 4)
		return 0;
	return encode_ipv4_address(byte);
}

static uint32_t parse_cidr(const char* p, unsigned* subnet)
{
	unsigned int byte[4];

	if(*p == '!')
		p++;

	*subnet = 0;
	if(sscanf(p, "%u.%u.%u.%u/%u", &byte[0], &byte[1], &byte[2], &byte[3], subnet) != 5 || *subnet > 32)
		return 0;
	return encode_ipv4_address(byte);
}

static bool is_cidr_match(const char *p, uint32_t ip_addr, uint32_t cidr, unsigned subnet)
{
	bool	match = false;

	if(*p == '!')
		match = true;

	if(((ip_addr ^ cidr) >> (32-subnet)) == 0)
		match = !match;

	return match;
}

static bool findstr_compare(const char* str, uint32_t ip_addr, const char* pattern, char* metadata)
{
	uint32_t cidr;
	unsigned subnet;
	char buf[FINDSTR_MAX_LINE_LEN + 1];
	char* p;

	SAFECOPY(buf, pattern);
	if((p = strchr(buf, '\t')) != NULL) {
		*p = '\0';
		p++;
		if(metadata != NULL)
			snprintf(metadata, FINDSTR_MAX_LINE_LEN, "%s", p);
	} else {
		if(metadata != NULL)
			*metadata = '\0';
	}
	if(ip_addr != 0 && (cidr = parse_cidr(pattern, &subnet)) != 0)
		return is_cidr_match(pattern, ip_addr, cidr, subnet);
	return findstr_in_string(str, buf);
}

/****************************************************************************/
/* Pattern matching string search of 'insearchof' in 'list'.				*/
/****************************************************************************/
bool findstr_in_list(const char* insearchof, str_list_t list, char* metadata)
{
	return find2strs_in_list(insearchof, NULL, list, metadata);
}

/****************************************************************************/
/* Pattern matching string search of 'str1' or 'str2' in 'list'.			*/
/****************************************************************************/
bool find2strs_in_list(const char* str1, const char* str2, str_list_t list, char* metadata)
{
	size_t	index;
	bool	found=false;
	char*	p;
	uint32_t ip_addr1, ip_addr2;

	if(list == NULL)
		return false;
	ip_addr1 = parse_ipv4_address(str1);
	ip_addr2 = parse_ipv4_address(str2);
	for(index=0; list[index]!=NULL; index++) {
		p=list[index];
		if(*p == '\0')
			continue;
		found = findstr_compare(str1, ip_addr1, p, metadata);
		if(!found && str2 != NULL)
			found = findstr_compare(str2, ip_addr2, p, metadata);
		if(found != (*p=='!'))
			break;
	}
	return found;
}

/****************************************************************************/
/* Pattern matching string search of 'insearchof' in 'fname'.				*/
/****************************************************************************/
bool findstr(const char* insearchof, const char* fname)
{
	return find2strs(insearchof, NULL, fname, NULL);
}

/****************************************************************************/
/* Pattern matching string search of 'str1' or 'str2' in 'fname'.			*/
/****************************************************************************/
bool find2strs(const char* str1, const char* str2, const char* fname, char* metadata)
{
	char		str[FINDSTR_MAX_LINE_LEN + 1];
	bool		found=false;
	FILE*		fp;
	uint32_t	ip_addr1, ip_addr2;

	if(fname == NULL || *fname == '\0')
		return false;

	if ((fp = fnopen(NULL, fname, O_RDONLY)) == NULL)
		return false; 

	ip_addr1 = parse_ipv4_address(str1);
	ip_addr2 = parse_ipv4_address(str2);
	while(!feof(fp) && !ferror(fp)) {
		if(!fgets(str,sizeof(str),fp))
			break;
		char* p = str;
		SKIP_WHITESPACE(p);
		if(*p == '\0')
			continue;
		c_unescape_str(p);
		found = findstr_compare(str1, ip_addr1, p, metadata);
		if(!found && str2 != NULL)
			found = findstr_compare(str2, ip_addr2, p, metadata);
		if(found != (*p=='!'))
			break;
	}

	fclose(fp);
	return found;
}

static char* process_findstr_item(size_t index, char *str, void* cbdata)
{
	SKIP_WHITESPACE(str);
	return c_unescape_str(str);
}

/****************************************************************************/
str_list_t findstr_list(const char* fname)
{
	FILE*	fp;
	str_list_t	list;

	if ((fp = fnopen(NULL, fname, O_RDONLY)) == NULL)
		return NULL;

	list=strListReadFile(fp, NULL, FINDSTR_MAX_LINE_LEN);
	strListModifyEach(list, process_findstr_item, /* cbdata: */NULL);

	fclose(fp);

	return list;
}