bool pattern_match(const char *pat,const char *str)
{
char c;
char *pat1,*pat2;
LONG len;
bool rc = FALSE;
/* convert Unix to AmigaDos pattern */
pat2 = pat1 = alloc(2*strlen(pat)+1);
while (c = *pat++) {
if (c == '*') {
*pat2++ = '#';
*pat2++ = '?';
}
else
*pat2++ = c;
}
*pat2 = '\0';
/* tokenize pattern and match it against str */
len = 2*strlen(pat1)+3;
pat2 = alloc(len);
if (ParsePattern((STRPTR)pat1,(STRPTR)pat2,len) >= 0) {
if (MatchPattern((STRPTR)pat2,(STRPTR)str))
rc = TRUE;
}
else
ierror("pattern_match(): ParsePattern() failed for \"%s\"",pat);
free(pat2);
free(pat1);
return (rc);
}
PatternFormatter::PatternFormatter(const std::string& format):
_localTime(false),
_localTimeOffset(Timestamp::resolution()*(Timezone::utcOffset() + Timezone::dst())),
_pattern(format)
{
ParsePattern();
}
PatternFormatter::PatternFormatter(const std::string& format):
_localTime(false),
_localTimeOffset(0),
_pattern(format)
{
ParsePattern();
}
void CBatchTextDlg::OnBnStartClicked()
{
if (m_VarTbl.empty())
{
return;
}
//处理文件内容模式
CString str;
m_ctrlPattern.GetWindowText(str);
CStringW strContent(str);
m_ContPat.clear();
ParsePattern(strContent, m_ContPat);
//处理文件名模式
m_ctrlFileName.GetWindowText(str);
CStringW strFileName(str);
m_FilePat.clear();
ParsePattern(strFileName, m_FilePat);
//处理目标文件夹
CString strFolder;
m_ctrlFolder.GetWindowText(strFolder);
if (FALSE == PathFileExists(strFolder))
{
CreateDirectory(strFolder, NULL);
}
if (strFolder[strFolder.GetLength() - 1] != _T('\\'))
{
strFolder.AppendChar(_T('\\'));
}
if (m_FilePat.size() == 1)
{
CString strPathName = strFolder + m_FilePat.front();
DeleteFile(strPathName);
}
//开始生成
for (STRTABLE::iterator i = m_VarTbl.begin();
i != m_VarTbl.end(); ++i)
{
GenTextFromPat(m_ContPat, *i, strContent);
GenTextFromPat(m_FilePat, *i, strFileName);
CString strPathName = strFolder + CString(strFileName);
SaveTextFile(strPathName, strContent);
}
}
/// Constructor that takes a pattern.
CharSet::CharSet(const char* pattern)
{
memset(bitset, 0, sizeof(bitset));
memset(bittab, 0, sizeof(bittab));
matchAll = false;
ParsePattern(pattern);
}
void ParsePatterns(const Indices& pats, Builder& builder) const
{
Dbg("Patterns: %1% to parse", pats.Count());
for (Indices::Iterator it = pats.Items(); it; ++it)
{
const uint_t patIndex = *it;
Dbg("Parse pattern %1%", patIndex);
ParsePattern(patIndex, builder);
}
}
uint_t ADVBPatterns::ParsePatterns(ADataList& patternlist, const AString& patterns, AString& errors, const AString& sep, const AString& user)
{
uint_t i, n = patterns.CountLines(sep);
for (i = 0; i < n; i++) {
ParsePattern(patternlist, patterns.Line(i, sep), errors, user);
}
return patternlist.Count();
}
void PatternFormatter::setProperty(const std::string& name, const std::string& value)
{
if (name == PROP_PATTERN)
{
_pattern = value;
ParsePattern();
}
else if (name == PROP_TIMES)
{
_localTime = (value == "local");
_localTimeOffset = Timestamp::resolution()*( Timezone::utcOffset() + Timezone::dst() );
}
else
Formatter::setProperty(name, value);
}
void PatternFormatter::setProperty(const std::string& name, const std::string& value)
{
if (name == PROP_PATTERN)
{
_pattern = value;
ParsePattern();
}
else if (name == PROP_TIMES)
{
_localTime = (value == "local");
}
else
{
Formatter::setProperty(name, value);
}
}
bool ADVBPatterns::ParsePattern(ADataList& patternlist, const AString& line, AString& errors, const AString& user)
{
//const ADVBConfig& config = ADVBConfig::Get();
PATTERN *pattern;
bool success = false;
patternlist.SetDestructor(&__DeletePattern);
if ((pattern = new PATTERN) != NULL) {
AString errs = ParsePattern(line, *pattern, user);
if (errs.Valid()) {
//config.printf("Error parsing '%s': %s", line.str(), errs.str());
errors += errs + "\n";
}
if ((pattern->list.Count() > 0) || pattern->errors.Valid()) {
patternlist.Add((uptr_t)pattern);
success = true;
}
}
return success;
}
static int ConvertContentOption(Rule *rule, int index, OptTreeNode *otn)
{
ContentInfo *content = rule->options[index]->option_u.content;
PatternMatchData *pmd = NULL;
OptFpList *fpl;
char *pattern;
unsigned int pattern_size, i;
/* ParsePattern expects quotations marks around the pattern. */
if (content->pattern[0] != '"')
{
pattern_size = strlen((const char*)content->pattern) + 3;
pattern = SnortAlloc(sizeof(char) * pattern_size);
pattern[0] = '"';
memcpy(pattern+1, content->pattern, pattern_size-3);
pattern[pattern_size-2] = '"';
}
else
{
pattern = (char*)content->pattern;
}
/* Allocate a new node, based on the type of content option. */
if ( content->flags & URI_CONTENT_BUFS )
{
pmd = NewNode(otn, PLUGIN_PATTERN_MATCH_URI);
ParsePattern(pattern, otn, PLUGIN_PATTERN_MATCH_URI);
fpl = AddOptFuncToList(CheckUriPatternMatch, otn);
fpl->type = RULE_OPTION_TYPE_CONTENT_URI;
pmd->buffer_func = CHECK_URI_PATTERN_MATCH;
}
else
{
pmd = NewNode(otn, PLUGIN_PATTERN_MATCH);
ParsePattern(pattern, otn, PLUGIN_PATTERN_MATCH);
fpl = AddOptFuncToList(CheckANDPatternMatch, otn);
fpl->type = RULE_OPTION_TYPE_CONTENT;
pmd->buffer_func = CHECK_AND_PATTERN_MATCH;
}
/* Initialize var numbers */
if (content->flags & CONTENT_RELATIVE)
{
pmd->distance_var = GetVarByName(content->offset_refId);
pmd->within_var = GetVarByName(content->depth_refId);
pmd->offset_var = -1;
pmd->depth_var = -1;
}
else
{
pmd->offset_var = GetVarByName(content->offset_refId);
pmd->depth_var = GetVarByName(content->depth_refId);
pmd->distance_var = -1;
pmd->within_var = -1;
}
/* Set URI buffer flags */
if (content->flags & CONTENT_BUF_URI)
pmd->uri_buffer |= HTTP_SEARCH_URI;
if (content->flags & CONTENT_BUF_HEADER)
pmd->uri_buffer |= HTTP_SEARCH_HEADER;
if (content->flags & CONTENT_BUF_POST)
pmd->uri_buffer |= HTTP_SEARCH_CLIENT_BODY;
if (content->flags & CONTENT_BUF_METHOD)
pmd->uri_buffer |= HTTP_SEARCH_METHOD;
if (content->flags & CONTENT_BUF_COOKIE)
pmd->uri_buffer |= HTTP_SEARCH_COOKIE;
if (content->flags & CONTENT_BUF_RAW_URI)
pmd->uri_buffer |= HTTP_SEARCH_RAW_URI;
if (content->flags & CONTENT_BUF_RAW_HEADER)
pmd->uri_buffer |= HTTP_SEARCH_RAW_HEADER;
if (content->flags & CONTENT_BUF_RAW_COOKIE)
pmd->uri_buffer |= HTTP_SEARCH_RAW_COOKIE;
if (content->flags & CONTENT_BUF_STAT_CODE)
pmd->uri_buffer |= HTTP_SEARCH_STAT_CODE;
if (content->flags & CONTENT_BUF_STAT_MSG)
pmd->uri_buffer |= HTTP_SEARCH_STAT_MSG;
if (content->flags & CONTENT_BUF_RAW)
{
pmd->rawbytes = 1;
}
/* Handle options */
if (content->flags & CONTENT_NOCASE)
{
pmd->nocase = 1;
for (i = 0; i < pmd->pattern_size; i++)
{
pmd->pattern_buf[i] = toupper(pmd->pattern_buf[i]);
}
make_precomp(pmd);
pmd->search = uniSearchCI;
}
if (content->flags & CONTENT_RELATIVE)
{
pmd->distance = content->offset;
pmd->within = content->depth;
pmd->use_doe = 1;
fpl->isRelative = 1;
}
else
{
pmd->offset = content->offset;
pmd->depth = content->depth;
}
if (content->flags & CONTENT_FAST_PATTERN)
pmd->fp = 1;
/* Fast pattern only and specifying an offset and length are
* technically mutually exclusive - see
* detection-plugins/sp_pattern_match.c */
if (content->flags & CONTENT_FAST_PATTERN_ONLY)
{
pmd->fp_only = 1;
}
else
{
pmd->fp_offset = content->fp_offset;
pmd->fp_length = content->fp_length;
}
if (content->flags & NOT_FLAG)
pmd->exception_flag = 1;
fpl->context = pmd;
pmd->fpl = fpl;
if (pattern != (char *)content->pattern)
free(pattern);
return 1;
}
