sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-30 06:50:24 +03:00
Code

lib/util: Move unix_wild_match() from source3/lib/util to lib/util/

Browse Source 
Use top-level functions instead of source3 specific ones.

BUG: https://bugzilla.samba.org/show_bug.cgi?id=12419

Signed-off-by: Jeremy Allison <jra@samba.org>
Reviewed-by: Andreas Schneider <asn@samba.org>
This commit is contained in:
Jeremy Allison 2016-11-11 10:35:01 -08:00 committed by Andreas Schneider
parent caadd8afe6
commit 828b60f30d
5 changed files with 210 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
lib/util/unix_match.c Normal file
View File

@ -0,0 +1,183 @@
/*
Unix SMB/CIFS implementation.
Samba utility functions
Copyright (C) Jeremy Allison 2001
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/>.
*/
#include "replace.h"
#include <talloc.h>
#include "lib/util/talloc_stack.h"
#include "lib/util/charset/charset.h"
#include "lib/util/unix_match.h"
/*********************************************************
Recursive routine that is called by unix_wild_match.
*********************************************************/
static bool unix_do_match(const char *regexp, const char *str)
{
const char *p;
for( p = regexp; *p && *str; ) {
switch(*p) {
case '?':
str++;
p++;
break;
case '*':
/*
* Look for a character matching
* the one after the '*'.
*/
p++;
if(!*p) {
return true; /* Automatic match */
}
while(*str) {
while(*str && (*p != *str)) {
str++;
}
/*
* Patch from weidel@multichart.de.
* In the case of the regexp
* '*XX*' we want to ensure there are
* at least 2 'X' characters in the
* string after the '*' for a match to
* be made.
*/
{
int matchcount=0;
/*
* Eat all the characters that
* match, but count how many
* there were.
*/
while(*str && (*p == *str)) {
str++;
matchcount++;
}
/*
* Now check that if the regexp
* had n identical characters
* that matchcount had at least
* that many matches.
*/
while (*(p+1) && (*(p+1)==*p)) {
p++;
matchcount--;
}
if ( matchcount <= 0 ) {
return false;
}
}
/*
* We've eaten the match char
* after the '*'
*/
str--;
if(unix_do_match(p, str)) {
return true;
}
if(!*str) {
return false;
} else {
str++;
}
}
return false;
default:
if(*str != *p) {
return false;
}
str++;
p++;
break;
}
}
if(!*p && !*str) {
return true;
}
if (!*p && str[0] == '.' && str[1] == 0) {
return true;
}
if (!*str && *p == '?') {
while (*p == '?') {
p++;
}
return(!*p);
}
if(!*str && (*p == '*' && p[1] == '\0')) {
return true;
}
return false;
}
/*******************************************************************
Simple case insensitive interface to a UNIX wildcard matcher.
Returns True if match, False if not.
*******************************************************************/
bool unix_wild_match(const char *pattern, const char *string)
{
TALLOC_CTX *ctx = talloc_stackframe();
char *p2;
char *s2;
char *p;
bool ret = false;
p2 = strlower_talloc(ctx, pattern);
s2 = strlower_talloc(ctx, string);
if (!p2 || !s2) {
TALLOC_FREE(ctx);
return false;
}
/* Remove any *? and ** from the pattern as they are meaningless */
for(p = p2; *p; p++) {
while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
memmove(&p[1], &p[2], strlen(&p[2])+1);
}
}
if (p2[0] == '*' && p2[1] == '\0') {
TALLOC_FREE(ctx);
return true;
}
ret = unix_do_match(p2, s2);
TALLOC_FREE(ctx);
return ret;
}

25
lib/util/unix_match.h Normal file
View File

@ -0,0 +1,25 @@
/*
Unix SMB/CIFS implementation.
Utility functions for Samba
Copyright (C) Jeremy Allison 2001
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/>.
*/
#ifndef _UNIX_MASK_H_
#define _UNIX_MASK_H_
bool unix_wild_match(const char *pattern, const char *string);
#endif

2
lib/util/wscript_build
View File

@ -120,7 +120,7 @@ else:
idtree_random.c base64.c
util_str.c util_str_common.c ms_fnmatch.c
server_id.c dprintf.c bitmap.c pidfile.c
tevent_debug.c memcache.c''',
tevent_debug.c memcache.c unix_match.c''',
deps='samba-util-core DYNCONFIG close-low-fd tini tiniparser genrand',
public_deps='talloc tevent execinfo pthread LIBCRYPTO charset util_setid systemd systemd-daemon',
public_headers='debug.h attr.h byteorder.h data_blob.h memory.h safe_string.h time.h talloc_stack.h xfile.h string_wrappers.h idtree.h idtree_random.h blocking.h signal.h substitute.h fault.h genrand.h',

2
source3/include/proto.h
View File

@ -411,7 +411,7 @@ bool ms_has_wild_w(const smb_ucs2_t *s);
bool mask_match(const char *string, const char *pattern, bool is_case_sensitive);
bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive);
bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive);
bool unix_wild_match(const char *pattern, const char *string);
#include "lib/util/unix_match.h"
bool name_to_fqdn(fstring fqdn, const char *name);
uint32_t map_share_mode_to_deny_mode(uint32_t share_access, uint32_t private_options);

159
source3/lib/util.c
View File

@ -1785,165 +1785,6 @@ bool mask_match_list(const char *string, char **list, int listLen, bool is_case_
return False;
}
/*********************************************************
Recursive routine that is called by unix_wild_match.
*********************************************************/
static bool unix_do_match(const char *regexp, const char *str)
{
const char *p;
for( p = regexp; *p && *str; ) {
switch(*p) {
case '?':
str++;
p++;
break;
case '*':
/*
* Look for a character matching
* the one after the '*'.
*/
p++;
if(!*p) {
return true; /* Automatic match */
}
while(*str) {
while(*str && (*p != *str)) {
str++;
}
/*
* Patch from weidel@multichart.de.
* In the case of the regexp
* '*XX*' we want to ensure there are
* at least 2 'X' characters in the
* string after the '*' for a match to
* be made.
*/
{
int matchcount=0;
/*
* Eat all the characters that
* match, but count how many
* there were.
*/
while(*str && (*p == *str)) {
str++;
matchcount++;
}
/*
* Now check that if the regexp
* had n identical characters
* that matchcount had at least
* that many matches.
*/
while (*(p+1) && (*(p+1)==*p)) {
p++;
matchcount--;
}
if ( matchcount <= 0 ) {
return false;
}
}
/*
* We've eaten the match char
* after the '*'
*/
str--;
if(unix_do_match(p, str)) {
return true;
}
if(!*str) {
return false;
} else {
str++;
}
}
return false;
default:
if(*str != *p) {
return false;
}
str++;
p++;
break;
}
}
if(!*p && !*str) {
return true;
}
if (!*p && str[0] == '.' && str[1] == 0) {
return true;
}
if (!*str && *p == '?') {
while (*p == '?') {
p++;
}
return(!*p);
}
if(!*str && (*p == '*' && p[1] == '\0')) {
return true;
}
return false;
}
/*******************************************************************
Simple case insensitive interface to a UNIX wildcard matcher.
Returns True if match, False if not.
*******************************************************************/
bool unix_wild_match(const char *pattern, const char *string)
{
TALLOC_CTX *ctx = talloc_stackframe();
char *p2;
char *s2;
char *p;
bool ret = false;
p2 = strlower_talloc(ctx, pattern);
s2 = strlower_talloc(ctx, string);
if (!p2 || !s2) {
TALLOC_FREE(ctx);
return false;
}
/* Remove any *? and ** from the pattern as they are meaningless */
for(p = p2; *p; p++) {
while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
memmove(&p[1], &p[2], strlen(&p[2])+1);
}
}
if (p2[0] == '*' && p2[1] == '\0') {
TALLOC_FREE(ctx);
return true;
}
ret = unix_do_match(p2, s2);
TALLOC_FREE(ctx);
return ret;
}
/**********************************************************************
Converts a name to a fully qualified domain name.
Returns true if lookup succeeded, false if not (then fqdn is set to name)