char *test_simple_matches()
{
m = pattern_match("ZED", strlen("ZED"), "ZED");
mu_assert(m != NULL, "Should match literal identically.");
m = pattern_match("ZED", strlen("ZED"), "Z.D");
mu_assert(m != NULL, "Should match wildcard.");
m = pattern_match("ZED", strlen("ZED"), "FOO");
mu_assert(m == NULL, "Should not match.");
return NULL;
}
char *test_anchors()
{
m = pattern_match("ZED", strlen("ZED"), "ZED$");
mu_assert(m != NULL, "Should match. Anchor at the end.");
m = pattern_match("ZED", strlen("ZED"), "ZE$");
mu_assert(m == NULL, "Should not match. Should have ended at $.'");
m = pattern_match("ZED", strlen("ZED"), "ED");
mu_assert(m == NULL, "Should not match. Implicit anchor at the start of pattern.");
return NULL;
}
char *test_set()
{
m = pattern_match("ZED", strlen("ZED"), "Z[OE]D");
mu_assert(m != NULL, "Should match.");
m = pattern_match("ZED", strlen("ZED"), "Z[^OE]D");
mu_assert(m == NULL, "Should not match.");
m = pattern_match("ZED", strlen("ZED"), "Z[A-Z]D");
mu_assert(m != NULL, "Should match.");
return NULL;
}
char *test_optional()
{
m = pattern_match("ZED", strlen("ZED"), "ZEE?D");
mu_assert(m != NULL, "Should match.");
m = pattern_match("ZEED", strlen("ZEED"), "ZEE?D");
mu_assert(m != NULL, "Should match wildcard.");
m = pattern_match("ZEEED", strlen("ZEEED"), "ZEE?D");
mu_assert(m == NULL, "Should not match.");
return NULL;
}
char *test_balance()
{
// balanced string match, matches the {...} contents
m = pattern_match("/users/{1234}", strlen("/users/{1234}"), "/users/\\b{}");
mu_assert(m != NULL, "Should match balanced chars.");
m = pattern_match("/users/{1234", strlen("/users/{1234}"), "/users/\\b{}");
mu_assert(m == NULL, "Should not match balanced unchars.");
m = pattern_match("/users/1234}", strlen("/users/{1234}"), "/users/\\b{}");
mu_assert(m == NULL, "Should not match balanced unchars.");
return NULL;
}
static bool
pattern_match (const char *pattern, const char *string)
{
const char *p = pattern, *n = string;
char c;
for (; (c = TOLOWER (*p++)) != '\0'; n++)
if (c == '*')
{
for (c = TOLOWER (*p); c == '*'; c = TOLOWER (*++p))
;
for (; *n != '\0'; n++)
if (TOLOWER (*n) == c && pattern_match (p, n))
return true;
#ifdef ASTERISK_EXCLUDES_DOT
else if (*n == '.')
return false;
#endif
return c == '\0';
}
else
{
if (c != TOLOWER (*n))
return false;
}
return *n == '\0';
}
/*
* This does the UNIx style ^xx^yy replace search. Only affects last
* command and display "Modified failed." on a no match.
*/
void history_sub(char *args)
{
char *p;
char buf[MAXSIZ];
char pat[MAXSIZ];
p = strchr(args, '^');
if (!p) {
msg("-- No specified modifier.");
return;
}
*p = '\0';
sprintf(pat, "*%s*", args);
if (!pattern_match(hist_cur->prev->line, pat, pattern)) {
msg("-- Modifier failed.");
return;
} else {
sprintf(buf, "%s%s%s", pattern1, p + 1, pattern2);
msg("%s", buf);
process_key(buf, false);
add_history(buf);
}
}
vector<vector<string>> groupStrings(vector<string>& strings) {
vector<vector<string>> result;
for(int i = 0;i < strings.size();i++)
{
string cur = strings[i];
bool match(false);
for(int j = 0;j < result.size();j++)
{
if(pattern_match(cur, result[j][0]))
{
result[j].push_back(cur);
match = true;
break;
}
}
if(!match)
{
vector<string> pattern;
pattern.push_back(cur);
result.push_back(pattern);
}
}
for(int i = 0;i < result.size();i++)
sort(result[i].begin(), result[i].end());
return result;
}
static int check_exception(struct patterns_data* pdata, const char* message, int pattern_id, enum auth_credentials credentials)
{
sqlite3_stmt *res;
char query[50];
int error = 0;
int exception = 0;
const char *tail;
enum auth_credentials mincred;
enum auth_credentials maxcred;
int n = sprintf(query, "SELECT * FROM pattern_exceptions WHERE pattern_id=%d;", pattern_id);
error = sqlite3_prepare_v2(pdata->db, query, n, &res, &tail);
while (sqlite3_step(res) == SQLITE_ROW)
{
auth_string_to_cred((char*) sqlite3_column_text(res, 3), &mincred);
auth_string_to_cred((char*) sqlite3_column_text(res, 4), &maxcred);
if (maxcred >= credentials && mincred <= credentials && pattern_match(message, (char*) sqlite3_column_text(res, 1)))
{
exception = 1;
}
}
sqlite3_finalize(res);
return exception;
}
int HttpsRetriever::pattern_match (const char *pattern, const char *string)
{
const char *p = pattern, *n = string;
char c;
for (; (c = tolower(*p++)) != '\0'; n++)
if (c == '*')
{
for (c = tolower (*p); c == '*'; c = tolower (*++p))
;
for (; *n != '\0'; n++)
if (tolower (*n) == c && pattern_match (p, n))
return 1;
#ifdef ASTERISK_EXCLUDES_DOT
else if (*n == '.')
return 0;
#endif
return c == '\0';
}
else
{
if (c != tolower (*n))
return 0;
}
return *n == '\0';
}
int main(int argc, char **argv)
{
char line[MAXLINE];
char *pattern;
progn = argv[0];
if(argc!=2) {
usage();
return EXIT_FAILURE;
}
pattern = argv[1];
while(!feof(stdin) && !ferror(stdin)) {
if(!fgets(line,sizeof(line),stdin)) {
break;
}
if(pattern_match(pattern,line)) {
printf("%s",line);
}
}
if(ferror(stdin)) {
perror(progn);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int connection_msg_to_handler(Connection *conn)
{
Handler *handler = Request_get_action(conn->req, handler);
int rc = 0;
int header_len = Request_header_length(conn->req);
// body_len will include \0
int body_len = Request_content_length(conn->req);
check(handler, "JSON request doesn't match any handler: %s",
bdata(Request_path(conn->req)));
if(pattern_match(IOBuf_start(conn->iob), header_len + body_len, bdata(&PING_PATTERN))) {
Register_ping(IOBuf_fd(conn->iob));
} else {
check(body_len >= 0, "Parsing error, body length ended up being: %d", body_len);
bstring payload = Request_to_payload(conn->req, handler->send_ident,
IOBuf_fd(conn->iob), IOBuf_start(conn->iob) + header_len,
body_len - 1); // drop \0 on payloads
rc = Handler_deliver(handler->send_socket, bdata(payload), blength(payload));
bdestroy(payload);
check(rc == 0, "Failed to deliver to handler: %s", bdata(Request_path(conn->req)));
}
// consumes \0 from body_len
IOBuf_read_commit(conn->iob, header_len + body_len);
return REQ_SENT;
error:
return CLOSE;
}
/* la sortie... */
int read_server_for_list (char *ligne, int deb, int max) {
int ret;
char *buf;
if (renvoie_courte_liste==1) {
renvoie_courte_liste=0;
strcpy(ligne,".\r\n");
return 3;
} else if (renvoie_courte_liste==2) {
if (ligne!=tcp_line_read) strcpy(ligne,tcp_line_read);
renvoie_courte_liste=1;
return strlen(tcp_line_read);
}
if (filter_cmd_list[0]=='\0') return read_server(ligne,deb,max);
while (1) {
ret=read_server(ligne,deb,max);
if (ligne[1]=='\r') return ret;
buf=strchr(ligne,' ');
if (buf) *buf='\0';
if (pattern_match(ligne,filter_cmd_list)) {
if (buf) *buf=' ';
return ret;
}
}
}
int
ListCatalogues(const char *pattern, int patlen, int maxnames,
char **catalogues, int *len)
{
int count = 0;
char *catlist = NULL;
int size = 0;
if (maxnames) {
if (pattern_match(pattern, patlen, catalogue_name)) {
size = strlen(catalogue_name);
catlist = (char *) fsalloc(size + 1);
if (!catlist)
goto bail;
*catlist = size;
memmove( &catlist[1], catalogue_name, size);
size++; /* for length */
count++;
}
}
bail:
*len = size;
*catalogues = catlist;
return count;
}
void cfs_normalize(char url[CHIRP_PATH_MAX])
{
char *root = NULL;
char *rest = NULL;
if(strprfx(url, "chirp:")) {
return;
} else if(strprfx(url, "hdfs:")) {
return;
} else if(pattern_match(url, "^confuga://([^?]*)(.*)", &root, &rest) >= 0) {
char absolute[PATH_MAX];
path_absolute(root, absolute, 0);
debug(D_CHIRP, "normalizing url `%s' as `confuga://%s%s'", url, absolute, rest);
snprintf(url, CHIRP_PATH_MAX, "confuga://%s%s", absolute, rest);
} else {
char absolute[PATH_MAX];
if(strprfx(url, "file:") || strprfx(url, "local:"))
path_absolute(strstr(url, ":") + 1, absolute, 0);
else
path_absolute(url, absolute, 0);
debug(D_CHIRP, "normalizing url `%s' as `local://%s'", url, absolute);
strcpy(url, "local://");
strcat(url, absolute);
}
free(root);
free(rest);
}
static int do_ls(int argc, char **argv)
{
u8 buf[256], *cur = buf;
int r, count;
r = sc_list_files(card, buf, sizeof(buf));
if (r < 0) {
check_ret(r, SC_AC_OP_LIST_FILES, "unable to receive file listing", current_file);
return -1;
}
count = r;
printf("FileID\tType Size\n");
while (count >= 2) {
sc_path_t path;
sc_file_t *file = NULL;
char filename[10];
int i = 0;
int matches = 0;
/* construct file name */
sprintf(filename, "%02X%02X", cur[0], cur[1]);
/* compare file name against patterns */
for (i = 0; i < argc; i++) {
if (pattern_match(argv[i], filename)) {
matches = 1;
break;
}
}
/* if any filename pattern were given, filter only matching file names */
if (argc == 0 || matches) {
if (current_path.type != SC_PATH_TYPE_DF_NAME) {
path = current_path;
sc_append_path_id(&path, cur, 2);
} else {
if (sc_path_set(&path, SC_PATH_TYPE_FILE_ID, cur, 2, 0, 0) != SC_SUCCESS) {
printf("unable to set path.\n");
die(1);
}
}
r = sc_select_file(card, &path, &file);
if (r) {
printf(" %02X%02X unable to select file, %s\n", cur[0], cur[1], sc_strerror(r));
} else {
file->id = (cur[0] << 8) | cur[1];
print_file(file);
sc_file_free(file);
}
}
cur += 2;
count -= 2;
select_current_path_or_die();
}
return 0;
}
char *test_frontier()
{
// the frontier pattern, kinda weird, could be useful
// used to find patterns between two other patterns
m = pattern_match("THE (QUICK) brOWN FOx JUMPS",
strlen("THE (QUICK) brOWN FOx JUMPS"), "\\f[\\a]\\u-\\f[\\a]");
mu_assert(m != NULL, "Should match.");
return NULL;
}
static int pattern_match (const TCHAR *str, const TCHAR *pattern)
{
enum State {
Exact, // exact match
Any, // ?
AnyRepeat // *
};
const TCHAR *s = str;
const TCHAR *p = pattern;
const TCHAR *q = 0;
int state = 0;
int match = TRUE;
while (match && *p) {
if (*p == '*') {
state = AnyRepeat;
q = p+1;
} else if (*p == '?') state = Any;
else state = Exact;
if (*s == 0) break;
switch (state) {
case Exact:
match = *s == *p;
s++;
p++;
break;
case Any:
match = TRUE;
s++;
p++;
break;
case AnyRepeat:
match = TRUE;
s++;
if (*s == *q){
// make a recursive call so we don't match on just a single character
if (pattern_match(s,q) == TRUE) {
p++;
}
}
break;
}
}
if (state == AnyRepeat) return (*s == *q);
else if (state == Any) return (*s == *p);
else return match && (*s == *p);
}
boolean pattern_match_simple(const char *pattern, const char *string)
{
PatternSpec *pspec;
boolean ergo;
pspec = pattern_spec_init(pattern);
ergo = pattern_match(pspec, strlen(string), string, NULL);
pattern_spec_free(pspec);
return ergo;
}
bool patternlist_match(char **patlist,const char *str)
/* match string against a list of patterns */
{
if (patlist) {
while (*patlist) {
if (pattern_match(*patlist,str))
return (TRUE);
patlist++;
}
}
return (FALSE);
}
int match_gag(char *pat)
{
Gag *p;
for (p = gag_head; p; p = p->next) {
if (pattern_match(pat, p->name, pattern)) {
return 1;
}
}
return 0;
}
static int fl_match(tn_tuple *fl, struct pattern *pt)
{
int i, j, match = 0;
for (i=0; i < n_tuple_size(fl); i++) {
struct pkgfl_ent *flent = n_tuple_nth(fl, i);
char path[PATH_MAX], *dn;
int n;
dn = flent->dirname;
if (*dn == '/') {
n_assert(*(dn + 1) == '\0');
n = n_snprintf(path, sizeof(path), dn);
} else {
n = n_snprintf(path, sizeof(path), "/%s/", dn);
}
for (j=0; j < flent->items; j++) {
struct flfile *f = flent->files[j];
int nn;
if (S_ISLNK(f->mode)) {
char *name;
name = f->basename + strlen(f->basename) + 1;
if ((match = pattern_match(pt, name, 0)))
goto l_end;
}
nn = n_snprintf(&path[n], sizeof(path) - n, "%s", f->basename);
if ((match = pattern_match(pt, path, n + nn)))
goto l_end;
}
}
l_end:
return match;
}
// static
bool LLMediaEntry::checkUrlAgainstWhitelist(const std::string& url,
const std::vector<std::string> &whitelist)
{
bool passes = true;
// *NOTE: no entries? Don't check
if (whitelist.size() > 0)
{
passes = false;
// Case insensitive: the reason why we toUpper both this and the
// filter
std::string candidate_url = url;
// Use lluri to see if there is a path part in the candidate URL. No path? Assume "/"
LLURI candidate_uri(candidate_url);
std::vector<std::string>::const_iterator iter = whitelist.begin();
std::vector<std::string>::const_iterator end = whitelist.end();
for ( ; iter < end; ++iter )
{
std::string filter = *iter;
LLURI filter_uri(filter);
bool scheme_passes = pattern_match( candidate_uri.scheme(), filter_uri.scheme() );
if (filter_uri.scheme().empty())
{
filter_uri = LLURI(DEFAULT_URL_PREFIX + filter);
}
bool authority_passes = pattern_match( candidate_uri.authority(), filter_uri.authority() );
bool path_passes = pattern_match( candidate_uri.escapedPath(), filter_uri.escapedPath() );
if (scheme_passes && authority_passes && path_passes)
{
passes = true;
break;
}
}
}
return passes;
}
char *test_blocks()
{
// ( and ) are ignored but allowed for routing system later
m = pattern_match("ZED", strlen("ZEED"), "Z(ED)");
mu_assert(m != NULL, "Should match.");
bstring s = bfromcstr("ZED");
bstring p = bfromcstr("Z(ED)");
m = bstring_match(s, p);
mu_assert(m != NULL, "Should match.");
bdestroy(s); bdestroy(p);
return NULL;
}
char *test_escaped()
{
// char classes, which map to C functions:
// \a : isalpha(c)
// \c : iscntrl(c)
// \d : isdigit(c)
// \l : islower(c)
// \p : ispunct(c)
// \s : isspace(c)
// \u : isupper(c)
// \w : isalnum(c)
// \x : isxdigit(c)
// \z : (c == 0) // NUL terminator
m = pattern_match("a \t 9 l . \n U w A \0", 19, "\\a \\c \\d \\l \\p \\s \\u \\w \\x \\z");
mu_assert(m != NULL, "Should match.");
// escaped, non-class characters map to themselves
m = pattern_match("ZED", strlen("ZED"), "Z\\ED");
mu_assert(m != NULL, "Should match.");
// escaped special characters are depowered
m = pattern_match("*Z*E+D.", strlen("*Z*E+D."), "\\*Z\\*E\\+D\\.");
mu_assert(m != NULL, "Should match.");
m = pattern_match("ZED!", strlen("ZED!"), "ZED\\.");
mu_assert(m == NULL, "Should not match.");
return NULL;
}
void database_type::match(std::unordered_set<std::string> & result, const std::string & pattern) const
{
if (pattern == "*") {
for (auto it = values.begin(), end = values.end(); it != end; ++it) {
auto & key = it->first;
result.insert(key);
}
} else {
for (auto it = values.begin(), end = values.end(); it != end; ++it) {
auto & key = it->first;
if (pattern_match(pattern, key)) {
result.insert(key);
}
}
}
}
/*
* Recalls all nodes from recall list matching <args> utilizes the
* pattern_match function.
*/
void recall_match(char *args, int type)
{
Node *p;
for (p = recall_head; p; p = p->next) {
if (type && !p->type) {
continue;
}
if (pattern_match(p->line, args, pattern)) {
msg("%s", p->line);
}
}
msg("-- end of %s", (type ? "convo" : "recall"));
}
int connection_msg_to_handler(Connection *conn)
{
Handler *handler = Request_get_action(conn->req, handler);
int rc = 0;
int header_len = Request_header_length(conn->req);
// body_len will include \0
int body_len = Request_content_length(conn->req);
check(handler, "JSON request doesn't match any handler: %s",
bdata(Request_path(conn->req)));
if(pattern_match(IOBuf_start(conn->iob), header_len + body_len, bdata(&PING_PATTERN))) {
Register_ping(IOBuf_fd(conn->iob));
} else {
check(body_len >= 0, "Parsing error, body length ended up being: %d", body_len);
bstring payload = NULL;
if(handler->protocol == HANDLER_PROTO_TNET) {
payload = Request_to_tnetstring(conn->req, handler->send_ident,
IOBuf_fd(conn->iob), IOBuf_start(conn->iob) + header_len,
body_len - 1); // drop \0 on payloads
} else if(handler->protocol == HANDLER_PROTO_JSON) {
payload = Request_to_payload(conn->req, handler->send_ident,
IOBuf_fd(conn->iob), IOBuf_start(conn->iob) + header_len,
body_len - 1); // drop \0 on payloads
} else {
sentinel("Invalid protocol type: %d", handler->protocol);
}
debug("SENT: %s", bdata(payload));
check(payload != NULL, "Failed to generate payload.");
check(handler->send_socket != NULL, "Handler socket is NULL, tell Zed.");
rc = Handler_deliver(handler->send_socket, bdata(payload), blength(payload));
free(payload);
check(rc == 0, "Failed to deliver to handler: %s", bdata(Request_path(conn->req)));
}
// consumes \0 from body_len
check(IOBuf_read_commit(conn->iob, header_len + body_len) != -1, "Final commit failed.");
return REQ_SENT;
error:
return CLOSE;
}
int main (int arc, char *argv [])
{
char *pattern;
char buffer [BUF_LEN];
char *name;
symbol *anchor = NULL;
char *pattern_array [ARRAY_LEN];
int pattern_len = 0;
if ((arc == HELP_NUM) && (! strcmp (argv [OPTION], "--help")))
{
print_help ();
return (EXIT_SUCCESS);
}
if (arc != CORRECT_ARG_NUM)
{
fprintf (stderr,
"USAGE: wrapgrep <\"search pattern\"> <input file name>\n");
fprintf (stderr,
"HELP: wrapgrep --help\n");
return (EXIT_FAILURE);
}
pattern = argv [PATTERN];
name = argv [FILE_NAME];
copy_string (buffer, pattern, BUF_LEN);
pattern_len = create_pattern_array (pattern_array, ARRAY_LEN, buffer);
anchor = parse_file (name, anchor);
// debugff
// print_pattern_array (pattern_array, pattern_len);
// print_symbol_list (anchor);
// debug
pattern_match (pattern_array, pattern_len, anchor, name);
destroy_pattern_array (pattern_array, pattern_len);
destroy_symbol_list (anchor);
return (EXIT_SUCCESS);
}
/* pattern matching uniquement avec des '*' */
static int pattern_match(char *chaine, char *pat) {
char *p1=chaine,*p2=pat;
while ((*p1!='\0') && (*p2!='\0')) {
if (*p2=='*') {
while (*(++p2)=='*');
if (*p2=='\0') return 1;
while (*p1) {
if (pattern_match(p1,p2)) return 1;
p1++;
}
return 0;
}
if (*p2!=*p1) return 0;
p2++; p1++;
}
return 1;
}
