/// <summary> /// Retrieves list of Machine objects from SqlCommand, after database query /// number of rows retrieved and returned depends upon the rows field value /// </summary> /// <param name="cmd">The command object to use for query</param> /// <param name="rows">Number of rows to process</param> /// <returns>A list of Machine objects</returns> private MachineList GetList(SqlCommand cmd, long rows) { // Select multiple records SqlDataReader reader; long result = SelectRecords(cmd, out reader); //Machine list MachineList list = new MachineList(); using ( reader ) { // Read rows until end of result or number of rows specified is reached while (reader.Read() && rows-- != 0) { Machine machineObject = new Machine(); FillObject(machineObject, reader); list.Add(machineObject); } // Close the reader in order to receive output parameters // Output parameters are not available until reader is closed. reader.Close(); } return(list); }
IEnumerator LoadLocalJson() { //Debug.Log("111"); WWW www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/CriteriaInfo.json"); yield return(www); Debug.Log(www.text); ListCritera = JsonConvert.DeserializeObject <CriteriaList>(www.text); www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/MachineInfo.json"); yield return(www); Debug.Log(www.text); ListMachine = JsonConvert.DeserializeObject <MachineList>(www.text); www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/SubCriteriaInfo.json"); yield return(www); Debug.Log(www.text); ListSubCriteria = JsonConvert.DeserializeObject <SubCriteriaList>(www.text); www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/AspectInfo.json"); yield return(www); Debug.Log(www.text); ListAspect = JsonConvert.DeserializeObject <AspectList>(www.text); OnInitStatisticsData(); }
static Client() { Machines = new MachineList(); Macros = new List <Macro>(); StartWithWindows = bool.Parse(Defaults.START_WITH_WINDOWS); UserOwnsControlPanel = bool.Parse(Defaults.USER_OWNS_CONTROL_PANEL); KeepControlPanelTopMost = bool.Parse(Defaults.KEEP_CONTROL_PANEL_TOP_MOST); LogTypeMinLevel = (LogType)Enum.Parse(typeof(LogType), Defaults.LOG_TYPE_MIN_LEVEL); CFG_SelectedHostName = Defaults.SELECTED_HOST_NAME; CFG_SelectedConfigurationSection = Defaults.SELECTED_CONFIGURATION_SECTION; CP_SelectedTab = Defaults.SELECTED_TAB; P_SelectedGrouping = Defaults.SELECTED_PROCESS_GROUPING; P_SelectedFilterMachine = Defaults.SELECTED_PROCESS_FILTER_MACHINE; P_SelectedFilterGroup = Defaults.SELECTED_PROCESS_FILTER_GROUP; P_SelectedFilterApplication = Defaults.SELECTED_PROCESS_FILTER_APPLICATION; P_CheckedNodes = new List <Guid>(); P_CollapsedNodes = new Dictionary <ProcessGrouping, List <Guid> >() { { ProcessGrouping.MachineGroupApplication, new List <Guid>() }, { ProcessGrouping.GroupMachineApplication, new List <Guid>() } }; D_SelectedGrouping = Defaults.SELECTED_DISTRIBUTION_GROUPING; D_SelectedFilterSourceMachine = Defaults.SELECTED_DISTRIBUTION_FILTER_SOURCE_MACHINE; D_SelectedFilterGroup = Defaults.SELECTED_DISTRIBUTION_FILTER_GROUP; D_SelectedFilterApplication = Defaults.SELECTED_DISTRIBUTION_FILTER_APPLICATION; D_SelectedFilterDestinationMachine = Defaults.SELECTED_DISTRIBUTION_FILTER_DESTINATION_MACHINE; D_CheckedNodes = new List <Guid>(); D_CollapsedNodes = new Dictionary <DistributionGrouping, List <Guid> >() { { DistributionGrouping.MachineGroupApplicationMachine, new List <Guid>() }, { DistributionGrouping.GroupMachineApplicationMachine, new List <Guid>() } }; M_CheckedNodes = new List <Guid>(); M_CollapsedNodes = new List <Guid>(); }
public void InstantiateMachine(MachineList tm) { this.tmName = tm.mName; this.alph = tm.alph; this.states = tm.states; this.description = tm.description; }
public static IMachine GetMachine(string com) { MachineModel machine = MachineList.Find(item => item.Com == com); if (machine == null) { FileLogger.LogError("根据串口号获取接口失败,找不到该串口" + com + "号对应的接口"); throw new Exception("根据串口号获取接口失败,找不到该串口" + com + "号对应的接口"); } return(machine.Machine); }
public void RemoveMachine(Machine machine) { int index = MachineList.IndexOf(machine); if (index < 0 || machine == null) { return; } RemoveMachine(index); }
/// <summary> /// Constructor. /// </summary> /// <param name="type">Type of field.</param> /// <param name="name">Name user has given the state.</param> /// <param name="bytes">List representing each byte in the state.</param> /// <param name="lib">Library (DLL) containing the helper methods.</param> /// <param name="classname">Class (with namespace) containing the static methods.</param> /// <param name="format">Method to format the field as a string.</param> /// <param name="validate">Method to validate the bytes. Invoked when all bytes match.</param> /// <param name="dt">DateTime method if it's a timestamp.</param> public UserState(MachineList type, string name, List <UserByte> bytes, string lib, string classname, string format, string validate, string dt) { MachineType = type; Name = name; Bytes = bytes; strLibrary = lib; strClass = classname; strMethodFormat = format; strMethodValidate = validate; strMethodDatetime = (type == MachineList.TimeStamp_User) ? dt : null; }
/// <summary> /// Loads the machine list /// </summary> public void Load(bool quietMode = false) { string fileName = SaveName; try { using (Stream stream = new FileStream(fileName, FileMode.OpenOrCreate)) { MachineList.Clear(); MachineList = (ObservableCollection <Machine>)formatter.Deserialize(stream); _hasLoaded = true; RefreshConfigurations(); } } catch (Exception exception) { // don't show the dialog if calling from the instance usage. if (quietMode) { return; } OpenFileDialog openFileDialog = new OpenFileDialog(); openFileDialog.DefaultExt = "dat"; openFileDialog.Filter = "Data Files (.dat)|*.dat|All Files|*"; openFileDialog.Multiselect = false; openFileDialog.Title = "Open machine data file"; bool?accept = openFileDialog.ShowDialog(); if (accept == true) { fileName = openFileDialog.FileName; try { using (Stream stream = new FileStream(fileName, FileMode.OpenOrCreate)) { MachineList.Clear(); MachineList = (ObservableCollection <Machine>)formatter.Deserialize(stream); RefreshConfigurations(); _hasLoaded = true; } } catch (Exception inException) { MessageBox.Show("Unable to load Machine configuration. Error: " + inException.Message, "ERROR", MessageBoxButton.OK); } } } }
public void LoadAllData() { //StartCoroutine(LoadLocalJson()); TextAsset str1 = Resources.Load <TextAsset>("ConfigProfiles/CriteriaInfo"); TextAsset str2 = Resources.Load <TextAsset>("ConfigProfiles/MachineInfo"); TextAsset str3 = Resources.Load <TextAsset>("ConfigProfiles/SubCriteriaInfo"); TextAsset str4 = Resources.Load <TextAsset>("ConfigProfiles/AspectInfo"); ListCritera = JsonConvert.DeserializeObject <CriteriaList>(str1.text); ListMachine = JsonConvert.DeserializeObject <MachineList>(str2.text); ListSubCriteria = JsonConvert.DeserializeObject <SubCriteriaList>(str3.text); ListAspect = JsonConvert.DeserializeObject <AspectList>(str4.text); OnInitStatisticsData(); }
/// <summary> /// Retrieves all Machine objects by PageRequest /// </summary> /// <returns>A list of Machine objects</returns> public MachineList GetPaged(PagedRequest request) { using (SqlCommand cmd = GetSPCommand(GETPAGEDMACHINE)) { AddParameter(cmd, pInt32Out("TotalRows")); AddParameter(cmd, pInt32("PageIndex", request.PageIndex)); AddParameter(cmd, pInt32("RowPerPage", request.RowPerPage)); AddParameter(cmd, pNVarChar("WhereClause", 4000, request.WhereClause)); AddParameter(cmd, pNVarChar("SortColumn", 128, request.SortColumn)); AddParameter(cmd, pNVarChar("SortOrder", 4, request.SortOrder)); MachineList _MachineList = GetList(cmd, ALL_AVAILABLE_RECORDS); request.TotalRows = Convert.ToInt32(GetOutParameter(cmd, "TotalRows")); return(_MachineList); } }
/// <summary> /// Called by the ExtractField() method of Viterbi class, to get a readable format of a Viterbi field /// whose corresponding bytes are passed through input. This metohd is used with user-defined states. /// </summary> /// <param name="machineName">The state's machine name.</param> /// <param name="input">The bytes to ne interpreted.</param> /// <param name="uState">The UserState object, which references the method for interpreting the input.</param> /// <returns>The string representation.</returns> public static string GetUserField(MachineList machineName, byte[] input, UserState uState) { try { if ((machineName == MachineList.PhoneNumber_User) || (machineName == MachineList.Text_User)) { return((string)uState.MethodFormat.Invoke(null, new object[] { input })); } else { // For timestamps get the DateTime and format it, rather than use the user's // format method. This is for consistency. DateTime dt = (DateTime)uState.MethodDatetime.Invoke(null, new object[] { input }); return(dt.ToString()); } } catch { return("???"); } }
public virtual void RefreshWithLoadedConfiguration(Configuration conf, PolicyProvider provider) { IDictionary <Type, AccessControlList[]> newAcls = new IdentityHashMap <Type, AccessControlList []>(); IDictionary <Type, MachineList[]> newMachineLists = new IdentityHashMap <Type, MachineList []>(); string defaultAcl = conf.Get(CommonConfigurationKeys.HadoopSecurityServiceAuthorizationDefaultAcl , AccessControlList.WildcardAclValue); string defaultBlockedAcl = conf.Get(CommonConfigurationKeys.HadoopSecurityServiceAuthorizationDefaultBlockedAcl , string.Empty); string defaultServiceHostsKey = GetHostKey(CommonConfigurationKeys.HadoopSecurityServiceAuthorizationDefaultAcl ); string defaultMachineList = conf.Get(defaultServiceHostsKey, MachineList.WildcardValue ); string defaultBlockedMachineList = conf.Get(defaultServiceHostsKey + Blocked, string.Empty ); // Parse the config file Service[] services = provider.GetServices(); if (services != null) { foreach (Service service in services) { AccessControlList acl = new AccessControlList(conf.Get(service.GetServiceKey(), defaultAcl )); AccessControlList blockedAcl = new AccessControlList(conf.Get(service.GetServiceKey () + Blocked, defaultBlockedAcl)); newAcls[service.GetProtocol()] = new AccessControlList[] { acl, blockedAcl }; string serviceHostsKey = GetHostKey(service.GetServiceKey()); MachineList machineList = new MachineList(conf.Get(serviceHostsKey, defaultMachineList )); MachineList blockedMachineList = new MachineList(conf.Get(serviceHostsKey + Blocked , defaultBlockedMachineList)); newMachineLists[service.GetProtocol()] = new MachineList[] { machineList, blockedMachineList }; } } // Flip to the newly parsed permissions protocolToAcls = newAcls; protocolToMachineLists = newMachineLists; }
/// <exception cref="Org.Apache.Hadoop.Security.Authorize.AuthorizationException"/> public virtual void Authorize(UserGroupInformation user, string remoteAddress) { UserGroupInformation realUser = user.GetRealUser(); if (realUser == null) { return; } AccessControlList acl = proxyUserAcl[configPrefix + realUser.GetShortUserName()]; if (acl == null || !acl.IsUserAllowed(user)) { throw new AuthorizationException("User: "******" is not allowed to impersonate " + user.GetUserName()); } MachineList MachineList = proxyHosts[GetProxySuperuserIpConfKey(realUser.GetShortUserName ())]; if (MachineList == null || !MachineList.Includes(remoteAddress)) { throw new AuthorizationException("Unauthorized connection for super-user: "******" from IP " + remoteAddress); } }
/// <summary> /// Gets the first available machine that produces the passed item. /// </summary> /// <param name="item"></param> /// <returns></returns> public Machine GetAvailableMachine(ProductMasterItem item) { return (MachineList.FirstOrDefault( machine => machine.ConfigurationList.Any(config => config.CanMake(item)))); }
public void GenerateMaps() { //Clear ClientToStoreMap this.ClientToStoreMap.Clear(); this.StoreToDatabaseServiceMap.Clear(); this.StoreToEsbServiceMap.Clear(); this.MachineList.Clear(); //Generate machine to store map if (ClientMachines.Count > 0 && Stores.Count > 0 && ClientStoreMapList.Count > 0) { foreach (var machine in ClientMachines) { if (machine == null) { continue; } ulong machineId = machine.Machine.ClientId; var mapEntry = ClientStoreMapList.Find( x => (x.ClientRegistryId == machineId && x.StoreNumber.Equals(this.StoreNumber))); if (mapEntry == null) { continue; } var pwnSecStore = this.Stores.Find( x => x.StoreSite.StoreNumber.Equals(mapEntry.StoreNumber)); if (pwnSecStore == null) { continue; } //Add client to store map entry ClientToStoreMap.Add(machine, pwnSecStore); MachineList.Add(new StoreMachineVO(machine.Machine.MachineName, machine.Machine.IsAllowed, machine.Machine.IsConnected)); //Create entry for database service and esb service if and only if the store //does not already exist as a key in the list if (StoreToDatabaseServiceMap.ContainsKey(pwnSecStore)) { continue; } var sConfig = pwnSecStore.StoreConfiguration; var sConfigDbServMapList = DatabaseServiceMapList.FindAll(x => x.StoreConfigId == sConfig.Id); if (CollectionUtilities.isNotEmpty(sConfigDbServMapList)) { var dbServList = from dbServ in DatabaseServiceList join dbServMap in sConfigDbServMapList on dbServ.Id equals dbServMap.DatabaseServiceId select dbServ; StoreToDatabaseServiceMap.Add(pwnSecStore, new List <DatabaseServiceVO>(dbServList)); } if (StoreToEsbServiceMap.ContainsKey(pwnSecStore)) { continue; } var sConfigEsbServMapList = ESBServiceMapList.FindAll(x => x.StoreConfigId == sConfig.Id); if (CollectionUtilities.isNotEmpty(sConfigEsbServMapList)) { var esbServList = from esbServ in ESBServiceList join esbServMap in sConfigEsbServMapList on esbServ.Id equals esbServMap.ESBServiceId select esbServ; StoreToEsbServiceMap.Add(pwnSecStore, new List <EsbServiceVO>(esbServList)); } } } //If these three conditions are true, the maps are valid if (CollectionUtilities.isNotEmpty(ClientToStoreMap) && CollectionUtilities.isNotEmpty(StoreToDatabaseServiceMap) && CollectionUtilities.isNotEmpty(StoreToEsbServiceMap) && CollectionUtilities.isNotEmpty(MachineList)) { this.MapsValid = true; } }
/// <summary> /// Parses the response received from the server. /// </summary> /// <param name="responseReader">The binary stream reader that should /// be used to read any response data necessary.</param> protected override void UnpackResponse() { base.UnpackResponse(); MemoryStream responseStream = new MemoryStream(m_responsePayload); BinaryReader responseReader = new BinaryReader(responseStream, Encoding.Unicode); if (responseStream.Length < MinResponseMessageLength) { throw new MessageWrongSizeException("Get Machine Status"); } try { responseReader.BaseStream.Seek(sizeof(int), SeekOrigin.Begin); UInt16 MachineCount = responseReader.ReadUInt16(); MachineList.Clear(); for (ushort x = 0; x < MachineCount; x++) { Machine machine = new Machine(); Staff staff = new Staff(); Operator operatordata = new Operator(); //MachineID machine.MachineID = responseReader.ReadInt32(); //MachineClientID machine.MachineClientID = ReadString(responseReader); //Machine Description machine.MachineDescription = ReadString(responseReader); //Machine LoginDate machine.MachineLoginDate = ReadDateTime(responseReader) ?? DateTime.MinValue; //StaffID staff.Id = responseReader.ReadInt32(); //Staff FirstName staff.FirstName = ReadString(responseReader); //Staff LastName staff.LastName = ReadString(responseReader); //Operator ID operatordata.Id = responseReader.ReadInt32(); //Operator Name operatordata.Name = ReadString(responseReader); machine.staffdata = staff; machine.operatorData = operatordata; MachineList.Add(machine); } } catch (EndOfStreamException e) { throw new MessageWrongSizeException("Get Machine status", e); } catch (Exception e) { throw new ServerException("Get Machine status", e); } finally { if (responseReader != null) { responseReader.Close(); } } }
/// <summary> /// Called by the ExtractField() method of Viterbi class, to get a readable format of a Viterbi field /// whose corresponding bytes are passed through input. This metohd is used with user-defined states. /// </summary> /// <param name="machineName">The state's machine name.</param> /// <param name="input">The bytes to ne interpreted.</param> /// <param name="uState">The UserState object, which references the method for interpreting the input.</param> /// <returns>The string representation.</returns> public static string GetUserField(MachineList machineName, byte[] input, UserState uState) { try { if ((machineName == MachineList.PhoneNumber_User) || (machineName == MachineList.Text_User)) { return (string)uState.MethodFormat.Invoke(null, new object[] { input }); } else { // For timestamps get the DateTime and format it, rather than use the user's // format method. This is for consistency. DateTime dt = (DateTime)uState.MethodDatetime.Invoke(null, new object[] { input }); return dt.ToString(); } } catch { return "???"; } }
public void Unsubscribe() { MessageService.Unsubscribe(this); MachineList.Unsubscribe(); MachineDetails.Unsubscribe(); }
public void Subscribe() { MessageService.Subscribe <MachineListViewModel>(this, OnMessage); MachineList.Subscribe(); MachineDetails.Subscribe(); }
public void Unload() { MachineDetails.CancelEdit(); MachineList.Unload(); }
public async Task LoadAsync(MachineListArgs args) { await MachineList.LoadAsync(args); }
/// <summary> /// Constructor. /// </summary> /// <param name="type">Type of field.</param> /// <param name="name">Name user has given the state.</param> /// <param name="bytes">List representing each byte in the state.</param> /// <param name="lib">Library (DLL) containing the helper methods.</param> /// <param name="classname">Class (with namespace) containing the static methods.</param> /// <param name="format">Method to format the field as a string.</param> /// <param name="validate">Method to validate the bytes. Invoked when all bytes match.</param> /// <param name="dt">DateTime method if it's a timestamp.</param> public UserState(MachineList type, string name, List<UserByte> bytes, string lib, string classname, string format, string validate, string dt) { MachineType = type; Name = name; Bytes = bytes; strLibrary = lib; strClass = classname; strMethodFormat = format; strMethodValidate = validate; strMethodDatetime = (type == MachineList.TimeStamp_User) ? dt : null; }
/// <summary> /// Called by the ExtractField() method of Viterbi class, to get a readable format of a Viterbi field whose corresponding bytes are passed through input. /// </summary> /// <param name="machineName">Name of the parent state machine to which the field belongs to.</param> /// <param name="input">Sequence of bytes corresponding to the field whose readable format is desired.</param> /// <returns>A readable format of the Viterbi field.</returns> public static string GetField(MachineList machineName, byte[] input) { string result; switch (machineName) { case MachineList.Sql_SqliteRecord: result = GetUTFPrintableChars(input); break; case MachineList.Text_SevenBitWithLength: result = GetSevenBitWithLength(input); break; case MachineList.TimeStamp_MotoSms: result = GetMotoSmsTimeStamp(input); break; case MachineList.TimeStamp_Sms: result = GetSmsTimeStamp(input); break; case MachineList.TimeStamp_SmsGsm: result = GetSmsGsmTimeStamp(input); break; case MachineList.CallLogType_Samsung: result = GetSamsungCallLogStatus(input); break; case MachineList.TimeStamp_Samsung: result = GetSamsungTimeStamp(input); break; case MachineList.TimeStamp_Unix: result = GetUnixTimeStamp(input); break; case MachineList.TimeStamp_Epoch1900Tuple: result = GetEpoch1900TimeStamp(input); break; case MachineList.CallLogType_SimpleLE: result = GetSimpleCallLogStatusLE(input); break; case MachineList.CallLogType_Moto: result = GetMotoCallLogStatus(input); break; case MachineList.PhoneNumber_NokiaSevenDigit: case MachineList.PhoneNumber_NokiaEightDigit: case MachineList.PhoneNumber_NokiaTenDigit: case MachineList.PhoneNumber_NokiaElevenDigit: case MachineList.PhoneNumber_NokiaTwelveDigit: result = GetNokiaPhoneString(input); break; case MachineList.PhoneNumber_InternationalFormatSevenDigit: case MachineList.PhoneNumber_InternationalFormatTenDigit: case MachineList.PhoneNumber_InternationalFormatElevenDigit: case MachineList.PhoneNumber_BCDPrepended: result = GetInternationalPhoneString(input); break; case MachineList.PhoneNumber_BCD: result = GetBCDPhoneString(input); break; case MachineList.PhoneNumber_SamsungElevenDigitAscii: case MachineList.PhoneNumber_SamsungTenDigitAscii: case MachineList.PhoneNumber_SamsungSevenDigitAscii: result = GetAsciiPhoneString(input); break; case MachineList.PhoneNumber_MotoSevenUnicode: case MachineList.PhoneNumber_MotoTenUnicode: case MachineList.PhoneNumber_MotoElevenUnicode: result = GetUnicodePhoneString(input); break; case MachineList.PhoneNumber_MotoElevenDigit: case MachineList.PhoneNumber_MotoTenDigit: case MachineList.PhoneNumber_MotoSevenDigit: result = GetMotoPhoneString(input); break; case MachineList.PhoneNumberIndex_Nokia: result = GetStringFromNumber(input); break; case MachineList.Text_AsciiStringWithLength: case MachineList.Text_Unicode: case MachineList.Text_UnicodeEndian: case MachineList.Text_AsciiBigram: case MachineList.Text_AsciiPrintable: case MachineList.Marker_SamsungSms: result = GetTextString(input); break; case MachineList.TimeStamp_Nokia: result = GetNokiaTimeStamp(input, false); break; case MachineList.TimeStamp_NokiaEndian: result = GetNokiaTimeStamp(input, true); break; case MachineList.PhoneNumber_User: case MachineList.TimeStamp_User: case MachineList.Text_User: // Should not get here. result = "???"; break; default: result = "???"; break; } return result; }
/// <summary> /// /// </summary> /// <param name="path"></param> /// <param name="index"></param> /// <returns>The first index after the end of the field</returns> private ViterbiField ExtractField(List <State> path, int index) { int startIndex = index; MachineList machineName = path[index].ParentStateMachine.Name; string fieldHex = "0x"; string fieldAscii = ""; List <byte> fieldBytes = new List <byte>(); while (index < path.Count && machineName == path[index].ParentStateMachine.Name) { fieldBytes.Add(_observations[index]); //If this is an anchor run, no need to print fields if (!_isAnchor) { string observation = Convert.ToString(_observations[index], 16).PadLeft(2, '0'); fieldHex += observation; fieldAscii += (char)_observations[index]; #if PRINT_ALL Console.WriteLine("{0}\t:\t{1}\t{2}", path[index], observation, (char)_observations[index]); #endif } index++; //Allows us to distinguish between adjacent fields of the same type if (path[index - 1].IsSplitState) { break; } } string fieldString; if (!_isAnchor && ((machineName == MachineList.PhoneNumber_User) || (machineName == MachineList.TimeStamp_User) || (machineName == MachineList.TimeStamp_User))) { // If we're printing a user-defined field then we need to use the user-defined // methods. try { UserDefinedState udState = path[index - 1] as UserDefinedState; fieldString = Printer.GetUserField(machineName, fieldBytes.ToArray(), udState.UserStateObj); } catch { fieldString = "???"; } } else { fieldString = _isAnchor ? "" : Printer.GetField(machineName, fieldBytes.ToArray()); } var field = new ViterbiField { OffsetPath = startIndex, OffsetFile = _fileOffset + startIndex, HexString = fieldHex, AsciiString = fieldAscii, FieldString = fieldString, MachineName = machineName, Raw = fieldBytes.ToArray() }; _textList.Add(fieldString); _fieldList.Add(field); #if PRINT_FIELD Console.WriteLine(field); #endif return(field); }
/// <summary> /// Called by the ExtractField() method of Viterbi class, to get a readable format of a Viterbi field whose corresponding bytes are passed through input. /// </summary> /// <param name="machineName">Name of the parent state machine to which the field belongs to.</param> /// <param name="input">Sequence of bytes corresponding to the field whose readable format is desired.</param> /// <returns>A readable format of the Viterbi field.</returns> public static string GetField(MachineList machineName, byte[] input) { string result; switch (machineName) { case MachineList.Sql_SqliteRecord: result = GetUTFPrintableChars(input); break; case MachineList.Text_SevenBitWithLength: result = GetSevenBitWithLength(input); break; case MachineList.TimeStamp_MotoSms: result = GetMotoSmsTimeStamp(input); break; case MachineList.TimeStamp_Sms: result = GetSmsTimeStamp(input); break; case MachineList.TimeStamp_SmsGsm: result = GetSmsGsmTimeStamp(input); break; case MachineList.CallLogType_Samsung: result = GetSamsungCallLogStatus(input); break; case MachineList.TimeStamp_Samsung: result = GetSamsungTimeStamp(input); break; case MachineList.TimeStamp_Unix: result = GetUnixTimeStamp(input); break; case MachineList.TimeStamp_Epoch1900Tuple: result = GetEpoch1900TimeStamp(input); break; case MachineList.CallLogType_SimpleLE: result = GetSimpleCallLogStatusLE(input); break; case MachineList.CallLogType_Moto: result = GetMotoCallLogStatus(input); break; case MachineList.PhoneNumber_NokiaSevenDigit: case MachineList.PhoneNumber_NokiaEightDigit: case MachineList.PhoneNumber_NokiaTenDigit: case MachineList.PhoneNumber_NokiaElevenDigit: case MachineList.PhoneNumber_NokiaTwelveDigit: result = GetNokiaPhoneString(input); break; case MachineList.PhoneNumber_InternationalFormatSevenDigit: case MachineList.PhoneNumber_InternationalFormatTenDigit: case MachineList.PhoneNumber_InternationalFormatElevenDigit: case MachineList.PhoneNumber_BCDPrepended: result = GetInternationalPhoneString(input); break; case MachineList.PhoneNumber_BCD: result = GetBCDPhoneString(input); break; case MachineList.PhoneNumber_SamsungElevenDigitAscii: case MachineList.PhoneNumber_SamsungTenDigitAscii: case MachineList.PhoneNumber_SamsungSevenDigitAscii: result = GetAsciiPhoneString(input); break; case MachineList.PhoneNumber_MotoSevenUnicode: case MachineList.PhoneNumber_MotoTenUnicode: case MachineList.PhoneNumber_MotoElevenUnicode: result = GetUnicodePhoneString(input); break; case MachineList.PhoneNumber_MotoElevenDigit: case MachineList.PhoneNumber_MotoTenDigit: case MachineList.PhoneNumber_MotoSevenDigit: result = GetMotoPhoneString(input); break; case MachineList.PhoneNumberIndex_Nokia: result = GetStringFromNumber(input); break; case MachineList.Text_AsciiStringWithLength: case MachineList.Text_Unicode: case MachineList.Text_UnicodeEndian: case MachineList.Text_AsciiBigram: case MachineList.Text_AsciiPrintable: case MachineList.Marker_SamsungSms: result = GetTextString(input); break; case MachineList.TimeStamp_Nokia: result = GetNokiaTimeStamp(input, false); break; case MachineList.TimeStamp_NokiaEndian: result = GetNokiaTimeStamp(input, true); break; case MachineList.PhoneNumber_User: case MachineList.TimeStamp_User: case MachineList.Text_User: // Should not get here. result = "???"; break; default: result = "???"; break; } return(result); }
/// <summary> /// /// </summary> /// <param name="field"></param> /// <returns>Returns the meta machine. If the machine is not known, then it will return binary</returns> private MetaMachine GetMetaMachine(MachineList field) { bool isPhone = (Convert.ToString(field).StartsWith("PhoneNumber_")); if (isPhone) return MetaMachine.PhoneNumber; bool isTimeStamp = Convert.ToString(field).StartsWith("TimeStamp_"); if (isTimeStamp) return MetaMachine.TimeStamp; bool isText = Convert.ToString(field).StartsWith("Text_"); if (isText) return MetaMachine.Text; bool isSmsPrepend = Convert.ToString(field).StartsWith("Prepend_"); if (isSmsPrepend) return MetaMachine.SmsPrepend; bool isCallLogType = Convert.ToString(field).StartsWith("CallLogType_"); if (isCallLogType) return MetaMachine.CallLogType; bool isCallLogNumberIndex = Convert.ToString(field).StartsWith("PhoneNumberIndex_"); if (isCallLogNumberIndex) return MetaMachine.CallLogNumberIndex; bool isCallLogTypePrepend = Convert.ToString(field).StartsWith("CallLogTypePrepend_"); if (isCallLogTypePrepend) return MetaMachine.CallLogTypePrepend; bool isSamsungSmsMarker = Convert.ToString(field).StartsWith("Marker_SamsungSms"); if (isSamsungSmsMarker) return MetaMachine.MarkerSamsungSms; return MetaMachine.Binary; }
/// <summary> /// /// </summary> /// <param name="field"></param> /// <returns>Returns the meta machine. If the machine is not known, then it will return binary</returns> private MetaMachine GetMetaMachine(MachineList field) { bool isPhone = (Convert.ToString(field).StartsWith("PhoneNumber_")); if (isPhone) { return(MetaMachine.PhoneNumber); } bool isTimeStamp = Convert.ToString(field).StartsWith("TimeStamp_"); if (isTimeStamp) { return(MetaMachine.TimeStamp); } bool isText = Convert.ToString(field).StartsWith("Text_"); if (isText) { return(MetaMachine.Text); } bool isSmsPrepend = Convert.ToString(field).StartsWith("Prepend_"); if (isSmsPrepend) { return(MetaMachine.SmsPrepend); } bool isCallLogType = Convert.ToString(field).StartsWith("CallLogType_"); if (isCallLogType) { return(MetaMachine.CallLogType); } bool isCallLogNumberIndex = Convert.ToString(field).StartsWith("PhoneNumberIndex_"); if (isCallLogNumberIndex) { return(MetaMachine.CallLogNumberIndex); } bool isCallLogTypePrepend = Convert.ToString(field).StartsWith("CallLogTypePrepend_"); if (isCallLogTypePrepend) { return(MetaMachine.CallLogTypePrepend); } bool isSamsungSmsMarker = Convert.ToString(field).StartsWith("Marker_SamsungSms"); if (isSamsungSmsMarker) { return(MetaMachine.MarkerSamsungSms); } return(MetaMachine.Binary); }
public static void PrintMenu() { var machines = new MachineList(); bool menu = true; while (menu) { Console.Clear(); Console.WriteLine("\t=====Welcome to Slynet 1.7====="); Console.WriteLine("\n\tPlease choose your option below."); Console.WriteLine("\t[1]Select Terminator"); Console.WriteLine("\t[2]Set Mission"); Console.WriteLine("\t[3]Quit"); string menuChoice = Console.ReadLine(); switch (menuChoice) { case "1": { Console.Clear(); Console.WriteLine("\tPlease select Terminator"); machines.ListMachine(); Console.WriteLine("\n\tActivate Terminator: "); string select = Console.ReadLine(); if (select == "1") { MachineMenu.Menu(1, machines); } if (select == "2") { MachineMenu.Menu(2, machines); } if (select == "3") { MachineMenu.Menu(3, machines); } if (select == "4") { MachineMenu.Menu(4, machines); } Console.Clear(); break; } case "2": { Console.Clear(); Console.WriteLine("\tPlease select Terminator"); machines.ListMachine(); string select = Console.ReadLine(); if (select == "1") { MachineMenu.Menu(1, machines); } if (select == "2") { MachineMenu.Menu(2, machines); } if (select == "3") { MachineMenu.Menu(3, machines); } if (select == "4") { MachineMenu.Menu(4, machines); } Console.Clear(); break; } case "3": { Console.Clear(); Console.Write("\tDo you want to quit? Y/N: "); string quit = Console.ReadLine(); if (quit == "Y" || quit == "y") { menu = false; } break; } default: Console.WriteLine("\tChoose a number between 1-4"); break; } } }