protected override DataObject EvaluateBinary(DataObject ob1, DataObject ob2, IEvaluateContext context)
{
if (ob1.IsNull)
{
return(ob1);
}
if (ob2.IsNull)
{
return(ob2);
}
char cEscape = '\\';
if (Escape is ConstantExpression)
{
// TODO: some more checks...
var escapeValue = ((ConstantExpression)Escape).Value;
cEscape = escapeValue.ToString()[0];
}
string val = ob1.CastTo(PrimitiveTypes.String()).ToStringValue();
string pattern = ob2.CastTo(PrimitiveTypes.String()).ToStringValue();
return(DataObject.Boolean(PatternSearch.FullPatternMatch(pattern, val, cEscape)));
}
public bool Matches(ISqlString source, string pattern, char escapeChar)
{
if (!(source is SqlString))
{
throw new ArgumentException("This implementation of the string search does not support long strings");
}
var s = ((SqlString)source).Value;
return(PatternSearch.PatternMatch(pattern, s, escapeChar));
}
public IHttpActionResult Search([FromBody] PatternSearch search)
{
IHttpActionResult result;
if (db.patterns.Count() > 0)
{
result = Ok(db.patterns.Where(x => x.free == true && x.name.Contains(search.PatternName)));
}
else
{
result = NotFound();
}
return(result);
}
public long SearchForBytePattern(byte[] pattern, bool wildcard = false)
{
MEMORY_BASIC_INFORMATION mem_info = new MEMORY_BASIC_INFORMATION();
long min_address = 0;
long max_address = 0x7FFFFFFF;
byte[] buffer = new byte[81920];
PatternSearch patternSearch = new PatternSearch(buffer, pattern, wildcard);
//scan process memory regions
while (min_address < max_address &&
VirtualQueryEx(processHandle, (IntPtr)min_address, out mem_info, (uint)Marshal.SizeOf(typeof(MEMORY_BASIC_INFORMATION))) > 0)
{
//check if memory region is accessible
//skip regions smaller than 16M (default DOSBOX memory size)
if (mem_info.Protect == PAGE_READWRITE && mem_info.State == MEM_COMMIT && (mem_info.Type & MEM_PRIVATE) == MEM_PRIVATE &&
(int)mem_info.RegionSize >= 1024 * 1024 * 16)
{
long readPosition = (long)mem_info.BaseAddress;
int bytesToRead = Math.Min((int)mem_info.RegionSize, 1024 * 640); //scan first 640K only
long bytesRead;
while (bytesToRead > 0 && (bytesRead = Read(buffer, readPosition, Math.Min(buffer.Length, bytesToRead))) > 0)
{
//search bytes pattern
int index = patternSearch.IndexOf((int)bytesRead);
if (index != -1)
{
return(readPosition + index);
}
readPosition += bytesRead;
bytesToRead -= (int)bytesRead;
}
}
// move to next memory region
min_address = (long)mem_info.BaseAddress + (long)mem_info.RegionSize;
}
return(-1);
}
public SqlBoolean IsLike(ISqlString value, ISqlString pattern)
{
if (value == null && IsNull)
{
return(true);
}
if (!IsNull && value == null)
{
return(false);
}
if (value == null)
{
return(false);
}
var s1 = value.ToString();
var s2 = pattern.ToString();
return(PatternSearch.FullPatternMatch(s1, s2, '\\'));
}
public static PatternSelect AddPattern(this PatternSelect subject, string name, string pattern, Func <PatternContext, PatternResult, PatternResult>?transform = null)
{
subject.VerifyNotNull(nameof(subject));
name.VerifyNotEmpty(nameof(name));
pattern.VerifyNotEmpty(nameof(pattern));
subject.Add(name, context =>
{
var search = new PatternSearch
{
Name = name,
Pattern = pattern
};
if (new PatternTransform().TryMatch(search, context.Source, out PatternResult? pathPatternResult) == false)
{
return(null);
}
return(transform?.Invoke(context, pathPatternResult) ?? pathPatternResult);
});
return(subject);
}
public void SetUp()
{
patternProcessor = new PatternProcessor();
queryValidator = new InputValidator();
patternSearch = new PatternSearch(patternProcessor, queryValidator);
}
public bool TryMatch(PatternSearch pathPatternSearch, string source, [NotNullWhen(true)] out PatternResult?pathPatternResult)
{
pathPatternSearch
.VerifyNotNull(nameof(pathPatternSearch))
.Pattern.VerifyNotEmpty(nameof(pathPatternSearch.Pattern));
pathPatternResult = null;
if (source.IsEmpty())
{
return(false);
}
// Tokenized
IReadOnlyList <IToken> patternTokens = new StringTokenizer()
.Add("{", "}")
.Parse(pathPatternSearch.Pattern);
var matches = new List <string>();
var names = new List <string>();
var nameValues = new List <string>();
var cursor = new Cursor <IToken>(patternTokens);
while (cursor.TryNextValue(out IToken? item))
{
if (item.Value == "{")
{
if (!cursor.TryNextValue(out IToken? propertyName))
{
return(false);
}
names.Add(propertyName.Value);
if (!cursor.TryNextValue(out propertyName))
{
return(false);
}
if (propertyName.Value != "}")
{
return(false);
}
continue;
}
matches.Add(item.Value);
}
int start = 0;
var matchCursor = new Cursor <string>(matches);
while (matchCursor.TryNextValue(out string?matchItem))
{
int indexOf = source.IndexOf(matchItem, start);
if (indexOf < 0)
{
return(false);
}
if (indexOf > start)
{
nameValues.Add(source.Substring(start, indexOf - start));
}
start = indexOf + matchItem.Length;
}
if (start < source.Length)
{
nameValues.Add(source.Substring(start));
}
if (names.Count != nameValues.Count)
{
return(false);
}
pathPatternResult = new PatternResult
{
Name = pathPatternSearch.Name,
Pattern = pathPatternSearch.Pattern,
Source = source,
Values = new ConcurrentDictionary <string, string>(names.Zip(nameValues, (o, i) => new KeyValuePair <string, string>(o, i)), StringComparer.OrdinalIgnoreCase),
};
return(true);
}
