public static FieldData ConvertParsedField(ParsedField parsedField)
{
bool success = Enum.TryParse(parsedField.type, out ReturnType type);
if (!success)
{
throw new UnexpectedEnumException("Bad return type: " + parsedField.type);
}
EnterValueType enterType = EnterValueType.NONE;
switch (type)
{
case ReturnType.BOOL:
enterType = EnterValueType.BOOL;
break;
case ReturnType.NUMBER:
enterType = EnterValueType.NUMBER;
break;
case ReturnType.TEXT:
enterType = EnterValueType.TEXT;
break;
}
return(new FieldData()
{
text = parsedField.desc,
enterValue = enterType,
returnType = type,
attributes = parsedField.attributes
});
}
public DataLine(ParsedField field, uint tick)
{
No = tick;
_field = field;
string typestring = field.Value.GetType().ToString();
Name = field.Name;
Value = field.Value.ToString();
TrueValue = field.TrueValue;
Type = typestring.Substring(typestring.LastIndexOf(".") + 1);
Comment = field.Comment;
}
/// <summary>
/// If this packet is part of a chain, get only the ParsedData that has changed
/// </summary>
public List <ParsedField> GetDelta()
{
List <ParsedField> delta = new List <ParsedField>(this.ParsedData.ParsedFields);
if (Previous != null)
{
for (int i = 0; i < ParsedData.ParsedFields.Count; i++)
{
if (Previous.ParsedData.ParsedFields.Count == i)
{
break;
}
ParsedField field = this.ParsedData[i];
ParsedField lookup = Previous.ParsedData[i];
if (lookup.Value.Equals(field.Value))
{
delta.Remove(field);
}
}
}
return(delta);
}
/// <summary>
/// This method parses the output of the .p procedure that exports the database info
/// and fills _dataBases
/// It then updates the parser with the new info
/// </summary>
private static void Read(string filePath)
{
if (!File.Exists(filePath))
{
return;
}
_dataBases.Clear();
_sequences.Clear();
var defaultToken = new TokenEos(null, 0, 0, 0, 0);
ParsedDataBase currentDb = null;
ParsedTable currentTable = null;
Utils.ForEachLine(filePath, null, (i, items) => {
var splitted = items.Split('\t');
switch (items[0])
{
case 'H':
// base
//#H|<Dump date ISO 8601>|<Dump time>|<Logical DB name>|<Physical DB name>|<Progress version>
if (splitted.Count() != 6)
{
return;
}
currentDb = new ParsedDataBase(
splitted[3],
splitted[4],
splitted[5],
new List <ParsedTable>());
_dataBases.Add(currentDb);
break;
case 'S':
if (splitted.Count() != 3 || currentDb == null)
{
return;
}
_sequences.Add(new CompletionItem {
DisplayText = splitted[1],
Type = CompletionType.Sequence,
SubString = currentDb.LogicalName
});
break;
case 'T':
// table
//#T|<Table name>|<Table ID>|<Table CRC>|<Dump name>|<Description>
if (splitted.Count() != 6 || currentDb == null)
{
return;
}
currentTable = new ParsedTable(
splitted[1],
defaultToken,
splitted[2],
splitted[3],
splitted[4],
splitted[5],
"", false,
new List <ParsedField>(),
new List <ParsedIndex>(),
new List <ParsedTrigger>()
, "", "");
currentDb.Tables.Add(currentTable);
break;
case 'X':
// trigger
//#X|<Parent table>|<Event>|<Proc name>|<Trigger CRC>
if (splitted.Count() != 5 || currentTable == null)
{
return;
}
currentTable.Triggers.Add(new ParsedTrigger(
splitted[2],
splitted[3]));
break;
case 'I':
// index
//#I|<Parent table>|<Index name>|<Primary? 0/1>|<Unique? 0/1>|<Index CRC>|<Fileds separated with %>
if (splitted.Count() != 7 || currentTable == null)
{
return;
}
var flag = splitted[3].Equals("1") ? ParsedIndexFlag.Primary : ParsedIndexFlag.None;
if (splitted[4].Equals("1"))
{
flag = flag | ParsedIndexFlag.Unique;
}
currentTable.Indexes.Add(new ParsedIndex(
splitted[2],
flag,
splitted[6].Split('%').ToList()));
break;
case 'F':
// field
//#F|<Parent table>|<Field name>|<Type>|<Format>|<Order #>|<Mandatory? 0/1>|<Extent? 0/1>|<Part of index? 0/1>|<Part of PK? 0/1>|<Initial value>|<Desription>
if (splitted.Count() != 12 || currentTable == null)
{
return;
}
var flag2 = splitted[6].Equals("1") ? ParsedFieldFlag.Mandatory : ParsedFieldFlag.None;
if (splitted[7].Equals("1"))
{
flag2 = flag2 | ParsedFieldFlag.Extent;
}
if (splitted[8].Equals("1"))
{
flag2 = flag2 | ParsedFieldFlag.Index;
}
if (splitted[9].Equals("1"))
{
flag2 = flag2 | ParsedFieldFlag.Primary;
}
var curField = new ParsedField(
splitted[2],
splitted[3],
splitted[4],
int.Parse(splitted[5]),
flag2,
splitted[10],
splitted[11],
ParsedAsLike.None);
curField.Type = ParserHandler.ConvertStringToParsedPrimitiveType(curField.TempType, false);
currentTable.Fields.Add(curField);
break;
}
});
}
/// <summary>
/// Matches a new definition
/// </summary>
private void CreateParsedDefine(Token defineToken, bool isDynamic)
{
/*
* all DEFINE and CREATE statement
*/
// info we will extract from the current statement :
string name = "";
ParseFlag flags = isDynamic ? ParseFlag.Dynamic : 0;
ParsedAsLike asLike = ParsedAsLike.None;
ParseDefineType type = ParseDefineType.None;
string tempPrimitiveType = "";
string viewAs = "";
string bufferFor = "";
int extent = 0;
_lastTokenWasSpace = true;
StringBuilder left = new StringBuilder();
// for temp tables:
string likeTable = "";
bool isTempTable = false;
var fields = new List <ParsedField>();
ParsedField currentField = new ParsedField("", "", "", 0, 0, "", "", ParsedAsLike.None);
StringBuilder useIndex = new StringBuilder();
// for tt indexes
var indexList = new List <ParsedIndex>();
string indexName = "";
var indexFields = new List <string>();
ParsedIndexFlag indexFlags = ParsedIndexFlag.None;
var indexSort = "+"; // + for ascending, - for descending
Token token;
int state = 0;
do
{
token = PeekAt(1); // next token
if (token is TokenEos)
{
break;
}
if (token is TokenComment)
{
continue;
}
string lowerToken;
bool matchedLikeTable = false;
switch (state)
{
case 0:
// matching until type of define is found
if (!(token is TokenWord))
{
break;
}
lowerToken = token.Value.ToLower();
switch (lowerToken)
{
case "buffer":
case "browse":
case "stream":
case "button":
case "dataset":
case "frame":
case "query":
case "event":
case "image":
case "menu":
case "rectangle":
case "property":
case "sub-menu":
case "parameter":
if (!Enum.TryParse(lowerToken, true, out type))
{
type = ParseDefineType.None;
}
state++;
break;
case "data-source":
type = ParseDefineType.DataSource;
state++;
break;
case "var":
case "variable":
type = ParseDefineType.Variable;
state++;
break;
case "temp-table":
case "work-table":
case "workfile":
isTempTable = true;
state++;
break;
case "new":
flags |= ParseFlag.New;
break;
case "global":
flags |= ParseFlag.Global;
break;
case "shared":
flags |= ParseFlag.Shared;
break;
case "private":
flags |= ParseFlag.Private;
break;
case "protected":
flags |= ParseFlag.Protected;
break;
case "public":
flags |= ParseFlag.Public;
break;
case "static":
flags |= ParseFlag.Static;
break;
case "abstract":
flags |= ParseFlag.Abstract;
break;
case "override":
flags |= ParseFlag.Override;
break;
case "serializable":
flags |= ParseFlag.Serializable;
break;
case "input":
flags |= ParseFlag.Input;
break;
case "return":
flags |= ParseFlag.Return;
break;
case "output":
flags |= ParseFlag.Output;
break;
case "input-output":
flags |= ParseFlag.InputOutput;
break;
/*default:
* ParseFlag parsedFlag;
* if (Enum.TryParse(lowerToken, true, out parsedFlag))
* flags |= parsedFlag;
* break;*/
}
break;
case 1:
// matching the name
if (!(token is TokenWord))
{
break;
}
name = token.Value;
if (type == ParseDefineType.Variable)
{
state = 10;
}
if (type == ParseDefineType.Buffer)
{
tempPrimitiveType = "buffer";
state = 81;
}
if (type == ParseDefineType.Parameter)
{
lowerToken = token.Value.ToLower();
switch (lowerToken)
{
case "buffer":
tempPrimitiveType = lowerToken;
type = ParseDefineType.Buffer;
flags |= ParseFlag.Parameter;
state = 80;
break;
case "table":
case "table-handle":
case "dataset":
case "dataset-handle":
tempPrimitiveType = lowerToken;
state = 80;
break;
default:
state = 10;
break;
}
}
if (isTempTable)
{
state = 20;
}
if (state != 1)
{
break;
}
state = 99;
break;
case 10:
// define variable : match as or like
if (!(token is TokenWord))
{
break;
}
lowerToken = token.Value.ToLower();
if (lowerToken.Equals("as"))
{
asLike = ParsedAsLike.As;
}
else if (lowerToken.Equals("like"))
{
asLike = ParsedAsLike.Like;
}
if (asLike != ParsedAsLike.None)
{
state = 11;
}
break;
case 11:
// define variable : match a primitive type or a field in db
if (!(token is TokenWord))
{
break;
}
tempPrimitiveType = token.Value;
state = 12;
break;
case 12:
// define variable : match a view-as (or extent)
AddTokenToStringBuilder(left, token);
if (!(token is TokenWord))
{
break;
}
lowerToken = token.Value.ToLower();
if (lowerToken.Equals("view-as"))
{
state = 13;
}
if (lowerToken.Equals("extent"))
{
extent = GetExtentNumber(2);
}
break;
case 13:
// define variable : match a view-as
AddTokenToStringBuilder(left, token);
if (!(token is TokenWord))
{
break;
}
viewAs = token.Value;
state = 99;
break;
case 20:
// define temp-table
if (!(token is TokenWord))
{
break;
}
lowerToken = token.Value.ToLower();
switch (lowerToken)
{
case "field":
// matches FIELD
state = 22;
break;
case "index":
// matches INDEX
state = 25;
break;
case "use-index":
// matches USE-INDEX (after a like/like-sequential, we can have this keyword)
state = 26;
break;
case "help":
// a field has a help text:
state = 27;
break;
case "initial":
// a field has an initial value
state = 29;
break;
case "format":
// a field has a format
state = 30;
break;
case "extent":
// a field is extent:
currentField.Extent = GetExtentNumber(2);
break;
default:
// matches a LIKE table
// ReSharper disable once ConditionIsAlwaysTrueOrFalse, resharper doesn't get this one
if ((lowerToken.Equals("like") || lowerToken.Equals("like-sequential")) && !matchedLikeTable)
{
state = 21;
}
// After a USE-UNDEX and the index name, we can match a AS PRIMARY for the previously defined index
if (lowerToken.Equals("primary") && useIndex.Length > 0)
{
useIndex.Append("!");
}
break;
}
break;
case 21:
// define temp-table : match a LIKE table, get the table name in asLike
// ReSharper disable once RedundantAssignment
matchedLikeTable = true;
if (!(token is TokenWord))
{
break;
}
likeTable = token.Value.ToLower();
state = 20;
break;
case 22:
// define temp-table : matches a FIELD name
if (!(token is TokenWord))
{
break;
}
currentField = new ParsedField(token.Value, "", "", 0, 0, "", "", ParsedAsLike.None);
state = 23;
break;
case 23:
// define temp-table : matches a FIELD AS or LIKE
if (!(token is TokenWord))
{
break;
}
currentField.AsLike = token.Value.EqualsCi("like") ? ParsedAsLike.Like : ParsedAsLike.As;
state = 24;
break;
case 24:
// define temp-table : match a primitive type or a field in db
if (!(token is TokenWord))
{
break;
}
currentField.TempPrimitiveType = token.Value;
// push the field to the fields list
fields.Add(currentField);
state = 20;
break;
case 25:
// define temp-table : match an index name
if (!(token is TokenWord))
{
break;
}
indexName = token.Value;
state = 28;
break;
case 28:
// define temp-table : match the definition of the index
if (!(token is TokenWord))
{
break;
}
lowerToken = token.Value.ToLower();
if (lowerToken.Equals("unique"))
{
indexFlags = indexFlags | ParsedIndexFlag.Unique;
}
else if (lowerToken.Equals("primary"))
{
indexFlags = indexFlags | ParsedIndexFlag.Primary;
}
else if (lowerToken.Equals("word-index"))
{
indexFlags = indexFlags | ParsedIndexFlag.WordIndex;
}
else if (lowerToken.Equals("ascending"))
{
// match a sort order for a field
indexSort = "+";
var lastField = indexFields.LastOrDefault();
if (lastField != null)
{
indexFields.RemoveAt(indexFields.Count - 1);
indexFields.Add(lastField.Replace("-", "+"));
}
}
else if (lowerToken.Equals("descending"))
{
// match a sort order for a field
indexSort = "-";
var lastField = indexFields.LastOrDefault();
if (lastField != null)
{
indexFields.RemoveAt(indexFields.Count - 1);
indexFields.Add(lastField.Replace("+", "-"));
}
}
else if (lowerToken.Equals("index"))
{
// matching a new index
if (!String.IsNullOrEmpty(indexName))
{
indexList.Add(new ParsedIndex(indexName, indexFlags, indexFields.ToList()));
}
indexName = "";
indexFields.Clear();
indexFlags = ParsedIndexFlag.None;
indexSort = "+";
state = 25;
}
else
{
// Otherwise, it's a field name
indexFields.Add(token.Value + indexSort);
}
break;
case 26:
// define temp-table : match a USE-INDEX name
if (!(token is TokenWord))
{
break;
}
useIndex.Append(",");
useIndex.Append(token.Value);
state = 20;
break;
case 27:
// define temp-table : match HELP for a field
if (!(token is TokenString))
{
break;
}
currentField.Description = GetTokenStrippedValue(token);
state = 20;
break;
case 29:
// define temp-table : match INITIAL for a field
if (!(token is TokenWhiteSpace))
{
currentField.InitialValue = GetTokenStrippedValue(token);
state = 20;
}
break;
case 30:
// define temp-table : match FORMAT for a field
if (!(token is TokenWhiteSpace))
{
currentField.Format = GetTokenStrippedValue(token);
state = 20;
}
break;
case 80:
// define parameter : match a temptable, table, dataset or buffer name
if (!(token is TokenWord))
{
break;
}
if (token.Value.ToLower().Equals("for"))
{
break;
}
name = token.Value;
state++;
break;
case 81:
// match the table/dataset name that the buffer or handle is FOR
if (!(token is TokenWord))
{
break;
}
lowerToken = token.Value.ToLower();
if (lowerToken.Equals("for") || lowerToken.Equals("temp-table"))
{
break;
}
bufferFor = lowerToken;
state = 99;
break;
case 99:
// matching the rest of the define
AddTokenToStringBuilder(left, token);
break;
}
} while (MoveNext());
if (state <= 1)
{
return;
}
if (!string.IsNullOrEmpty(indexName))
{
indexList.Add(new ParsedIndex(indexName, indexFlags, indexFields));
}
if (isTempTable)
{
// TEMP-TABLE
var newTable = new ParsedTable(name, defineToken, ParsedTableType.TT, null, null, name, null, likeTable, fields, indexList, new List <ParsedTrigger>(), useIndex.ToString(), false, false)
{
// = end position of the EOS of the statement
EndPosition = token.EndPosition,
Flags = flags
};
AddParsedItem(newTable, defineToken.OwnerNumber);
}
else
{
// other DEFINE
var newDefine = NewParsedDefined(name, flags, defineToken, token, asLike, left.ToString(), type, tempPrimitiveType, viewAs, bufferFor, extent);
AddParsedItem(newDefine, defineToken.OwnerNumber);
// case of a parameters, add it to the current scope (if procedure)
var currentScope = GetCurrentBlock <ParsedScopeBlock>() as ParsedProcedure;
if (type == ParseDefineType.Parameter && currentScope != null)
{
if (currentScope.Parameters == null)
{
currentScope.Parameters = new List <ParsedDefine>();
}
currentScope.Parameters.Add(newDefine);
}
}
}
/// <summary>
/// This method parses the output of the .p procedure that exports the database info
/// and fills _dataBases
/// It then updates the parser with the new info
/// </summary>
private void Read(string filePath)
{
if (!File.Exists(filePath))
{
return;
}
_dataBases.Clear();
_sequences.Clear();
var defaultToken = new TokenEos(null, 0, 0, 0, 0);
ParsedDataBase currentDb = null;
ParsedTable currentTable = null;
Utils.ForEachLine(filePath, null, (i, items) => {
var splitted = items.Split('\t');
switch (items[0])
{
case 'H':
// base
//#H|<Dump date ISO 8601>|<Dump time>|<Logical DB name>|<Physical DB name>|<Progress version>
if (splitted.Length != 6)
{
return;
}
currentDb = new ParsedDataBase(
splitted[3],
splitted[4],
splitted[5],
new List <ParsedTable>(),
null);
_dataBases.Add(currentDb);
break;
case 'S':
if (splitted.Length != 3 || currentDb == null)
{
return;
}
_sequences.Add(new ParsedSequence {
SeqName = splitted[1],
DbName = currentDb.Name
});
break;
case 'T':
// table
//#T|<Table name>|<Table ID>|<Table CRC>|<Dump name>|<Description>|<Hidden? 0/1>|<Frozen? 0/1>|<Table type>
if (splitted.Length != 9 || currentDb == null)
{
return;
}
ParsedTableType tblType;
if (!Enum.TryParse(splitted[8].Trim(), true, out tblType))
{
tblType = ParsedTableType.T;
}
currentTable = new ParsedTable(
splitted[1],
defaultToken,
tblType,
splitted[2],
splitted[3],
splitted[4],
splitted[5],
null,
new List <ParsedField>(),
new List <ParsedIndex>(),
new List <ParsedTrigger>(),
null,
splitted[6].Equals("1"),
splitted[7].Equals("1")
);
currentDb.Tables.Add(currentTable);
break;
case 'X':
// trigger
//#X|<Parent table>|<Event>|<Proc name>|<Trigger CRC>
if (splitted.Length != 5 || currentTable == null)
{
return;
}
currentTable.Triggers.Add(new ParsedTrigger(
splitted[2],
splitted[3]));
break;
case 'I':
// index
//#I|<Parent table>|<Index name>|<Primary? 0/1>|<Unique? 0/1>|<Index CRC>|<Fileds separated with %>
if (splitted.Length != 7 || currentTable == null)
{
return;
}
var flag = splitted[3].Equals("1") ? ParsedIndexFlag.Primary : ParsedIndexFlag.None;
if (splitted[4].Equals("1"))
{
flag = flag | ParsedIndexFlag.Unique;
}
currentTable.Indexes.Add(new ParsedIndex(
splitted[2],
flag,
splitted[6].Split('%').ToList()));
break;
case 'F':
// field
//#F|<Parent table>|<Field name>|<Type>|<Format>|<Order #>|<Mandatory? 0/1>|<Extent? 0/x>|<Part of index? 0/1>|<Part of PK? 0/1>|<Initial value>|<Desription>
if (splitted.Length != 12 || currentTable == null)
{
return;
}
var flags = splitted[6].Equals("1") ? ParseFlag.Mandatory : 0;
if (splitted[8].Equals("1"))
{
flags = flags | ParseFlag.Index;
}
if (splitted[9].Equals("1"))
{
flags = flags | ParseFlag.Primary;
}
var curField = new ParsedField(
splitted[2],
splitted[3],
splitted[4],
int.Parse(splitted[5]),
flags,
splitted[10],
splitted[11],
ParsedAsLike.None);
curField.Extent = int.Parse(splitted[7]);
curField.PrimitiveType = ParserVisitor.ConvertStringToParsedPrimitiveType(curField.TempPrimitiveType);
currentTable.Fields.Add(curField);
break;
}
});
// copy the databases for each aliases
foreach (var aliasCreation in GetAliasesList.Trim().Trim(';').Split(';'))
{
var splitted = aliasCreation.Split(',');
if (splitted.Length == 2)
{
if (!string.IsNullOrWhiteSpace(splitted[0]) && !string.IsNullOrWhiteSpace(splitted[1]))
{
var foundDb = FindDatabaseByName(splitted[1].Trim());
if (foundDb != null)
{
_dataBases.Add(new ParsedDataBase(
splitted[0].Trim(),
foundDb.PhysicalName,
foundDb.ProgressVersion,
foundDb.Tables,
foundDb.Name));
}
}
}
}
// sort all fields by primary then by name
foreach (var dataBase in _dataBases)
{
foreach (var table in dataBase.Tables)
{
table.Fields.Sort((x, y) => {
var compare = y.Flags.HasFlag(ParseFlag.Primary).CompareTo(x.Flags.HasFlag(ParseFlag.Primary));
if (compare != 0)
{
return(compare);
}
return(string.Compare(x.Name, y.Name, StringComparison.CurrentCultureIgnoreCase));
});
}
}
}
public static ParsedDataSet ExtractParsedData(CapturePacket packet, out List <Tuple <string, object> > displayfields, bool extensive)
{
displayfields = new List <Tuple <string, object> >();
if (packet.Packet.PayloadPacket is IPv4Packet)
{
var ipv4 = (IPv4Packet)packet.Packet.PayloadPacket;
if (ipv4.Protocol == PacketDotNet.ProtocolType.Udp)
{
var udp = (UdpPacket)ipv4.PayloadPacket;
// protect against corrupted data with a try read
try
{
var throwaway = udp.DestinationPort + udp.SourcePort + udp.Length + udp.Checksum;
}
catch (Exception e)
{
return(null);
}
if (packet.Protocol == ProtocolType.NTP)
{
var data = NTP.NTPDataSet.Parse(udp.PayloadData);
var refTime = (UInt32)data.ParsedFields.First(f => f.Name == "Ref Timestamp Integer")
.Value;
var refFrac = (UInt32)data.ParsedFields.First(f => f.Name == "Ref Timestamp Fraction")
.Value;
var OrgTime = (UInt32)data.ParsedFields.First(f => f.Name == "Origin Timestamp Integer")
.Value;
var OrgFrac = (UInt32)data.ParsedFields.First(f => f.Name == "Origin Timestamp Fraction")
.Value;
var RecTime = (UInt32)data.ParsedFields.First(f => f.Name == "Receive Timestamp Integer")
.Value;
var RecFrac = (UInt32)data.ParsedFields.First(f => f.Name == "Receive Timestamp Fraction")
.Value;
var transmitTime = (UInt32)data.ParsedFields
.First(f => f.Name == "Transmit Timestamp Integer").Value;
var transmitFrac = (UInt32)data.ParsedFields
.First(f => f.Name == "Transmit Timestamp Fraction").Value;
var list = new List <ParsedField>();
if (refTime != 0)
{
list.Add(
ParsedField.Create("Reference Time", ParseNTPDate(refTime, refFrac).ToString()));
}
if (OrgTime != 0)
{
list.Add(ParsedField.Create("Origin Time", ParseNTPDate(OrgTime, OrgFrac).ToString()));
}
if (RecTime != 0)
{
list.Add(ParsedField.Create("Receive Time", ParseNTPDate(RecTime, RecFrac).ToString()));
}
if (transmitTime != 0)
{
list.Add(ParsedField.Create("Transmit Time",
ParseNTPDate(transmitTime, transmitFrac).ToString()));
}
if (OrgTime != 0 && RecTime != 0)
{
var rec = TimeSpan.FromSeconds(RecTime);
var org = TimeSpan.FromSeconds(OrgTime);
var timeSpan = rec.Subtract(org);
list.Add(ParsedField.Create("Seconds difference", timeSpan.ToString()));
}
foreach (var parsedField in list)
{
data.ParsedFields.Add(parsedField);
displayfields.Add(new Tuple <string, object>(parsedField.Name, parsedField.Value));
}
return(data);
}
else if (packet.Protocol == ProtocolType.IPTWP)
{
return(MainForm.ParseIPTWPData(packet.IPTWPPacket, udp, extensive));
}
}
}
return(null);
}
