/* 
   Unix SMB/CIFS implementation.
   filename matching routine
   Copyright (C) Andrew Tridgell 1992-2004

   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 3 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will 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, see <http://www.gnu.org/licenses/>.  
*/

/*
   This module was originally based on fnmatch.c copyright by the Free
   Software Foundation. It bears little (if any) resemblence to that
   code now
*/  

/**
 * @file
 * @brief MS-style Filename matching
 */

#include "includes.h"
#include "libcli/smb/smb_constants.h"

static int null_match(const char *p)
{
	for (;*p;p++) {
		if (*p != '*' &&
		    *p != '<' &&
		    *p != '"' &&
		    *p != '>') return -1;
	}
	return 0;
}

/*
  the max_n structure is purely for efficiency, it doesn't contribute
  to the matching algorithm except by ensuring that the algorithm does
  not grow exponentially
*/
struct max_n {
	const char *predot;
	const char *postdot;
};


/*
  p and n are the pattern and string being matched. The max_n array is
  an optimisation only. The ldot pointer is NULL if the string does
  not contain a '.', otherwise it points at the last dot in 'n'.
*/
static int ms_fnmatch_core(const char *p, const char *n, 
			   struct max_n *max_n, const char *ldot,
			   bool is_case_sensitive)
{
	codepoint_t c, c2;
	int i;
	size_t size, size_n;

	while ((c = next_codepoint(p, &size))) {
		p += size;

		switch (c) {
		case '*':
			/* a '*' matches zero or more characters of any type */
			if (max_n != NULL && max_n->predot &&
			    max_n->predot <= n) {
				return null_match(p);
			}
			for (i=0; n[i]; i += size_n) {
				next_codepoint(n+i, &size_n);
				if (ms_fnmatch_core(p, n+i, max_n+1, ldot, is_case_sensitive) == 0) {
					return 0;
				}
			}
			if (max_n != NULL && (!max_n->predot ||
			    max_n->predot > n)) {
				max_n->predot = n;
			}
			return null_match(p);

		case '<':
			/* a '<' matches zero or more characters of
			   any type, but stops matching at the last
			   '.' in the string. */
			if (max_n != NULL && max_n->predot &&
			    max_n->predot <= n) {
				return null_match(p);
			}
			if (max_n != NULL && max_n->postdot &&
			    max_n->postdot <= n && n <= ldot) {
				return -1;
			}
			for (i=0; n[i]; i += size_n) {
				next_codepoint(n+i, &size_n);
				if (ms_fnmatch_core(p, n+i, max_n+1, ldot, is_case_sensitive) == 0) return 0;
				if (n+i == ldot) {
					if (ms_fnmatch_core(p, n+i+size_n, max_n+1, ldot, is_case_sensitive) == 0) return 0;
					if (max_n != NULL) {
						if (!max_n->postdot ||
						    max_n->postdot > n) {
							max_n->postdot = n;
						}
					}
					return -1;
				}
			}
			if (max_n != NULL && (!max_n->predot ||
			    max_n->predot > n)) {
				max_n->predot = n;
			}
			return null_match(p);

		case '?':
			/* a '?' matches any single character */
			if (! *n) {
				return -1;
			}
			next_codepoint(n, &size_n);
			n += size_n;
			break;

		case '>':
			/* a '?' matches any single character, but
			   treats '.' specially */
			if (n[0] == '.') {
				if (! n[1] && null_match(p) == 0) {
					return 0;
				}
				break;
			}
			if (! *n) return null_match(p);
			next_codepoint(n, &size_n);
			n += size_n;
			break;

		case '"':
			/* a bit like a soft '.' */
			if (*n == 0 && null_match(p) == 0) {
				return 0;
			}
			if (*n != '.') return -1;
			next_codepoint(n, &size_n);
			n += size_n;
			break;

		default:
			c2 = next_codepoint(n, &size_n);
			if (c != c2) {
				if (is_case_sensitive) {
					return -1;
				}
				if (codepoint_cmpi(c, c2) != 0) {
					return -1;
				}
			}
			n += size_n;
			break;
		}
	}
	
	if (! *n) {
		return 0;
	}
	
	return -1;
}

int ms_fnmatch_protocol(const char *pattern, const char *string, int protocol,
			bool is_case_sensitive)
{
	int ret = -1;
	size_t count, i;

	if (strcmp(string, "..") == 0) {
		string = ".";
	}

	if (strpbrk(pattern, "<>*?\"") == NULL) {
		/* this is not just an optimisation - it is essential
		   for LANMAN1 correctness */
		return strcasecmp_m(pattern, string);
	}

	if (protocol <= PROTOCOL_LANMAN2) {
		char *p = talloc_strdup(NULL, pattern);
		if (p == NULL) {
			return -1;
		}
		/*
		  for older negotiated protocols it is possible to
		  translate the pattern to produce a "new style"
		  pattern that exactly matches w2k behaviour
		*/
		for (i=0;p[i];i++) {
			if (p[i] == '?') {
				p[i] = '>';
			} else if (p[i] == '.' && 
				   (p[i+1] == '?' || 
				    p[i+1] == '*' ||
				    p[i+1] == 0)) {
				p[i] = '"';
			} else if (p[i] == '*' && 
				   p[i+1] == '.') {
				p[i] = '<';
			}
		}
		ret = ms_fnmatch_protocol(p, string, PROTOCOL_NT1,
					  is_case_sensitive);
		talloc_free(p);
		return ret;
	}

	for (count=i=0;pattern[i];i++) {
		if (pattern[i] == '*' || pattern[i] == '<') count++;
	}

	/* If the pattern includes '*' or '<' */
	if (count >= 1) {
		struct max_n max_n[count];

		memset(max_n, 0, sizeof(struct max_n) * count);

		ret = ms_fnmatch_core(pattern, string, max_n, strrchr(string, '.'),
				      is_case_sensitive);
	} else {
		ret = ms_fnmatch_core(pattern, string, NULL, strrchr(string, '.'),
				      is_case_sensitive);
	}

	return ret;
}


/** a generic fnmatch function - uses for non-CIFS pattern matching */
int gen_fnmatch(const char *pattern, const char *string)
{
	return ms_fnmatch_protocol(pattern, string, PROTOCOL_NT1, false);
}
