public static void BuildResource()
    {
        AssetDatabase.Refresh();

        //执行依赖性打包

        //资源最大等级
        int maxLevel = allLevelAssets.Count;

        if (maxLevel == 0)
        {
            return;
        }

        //从最低等级开始打包
        for (int level = 1; level <= maxLevel; level++)
        {
            BuildPipeline.PushAssetDependencies();

            //获取不同等级的aaset
            Dictionary <string, AssetUnit> levelAssets = allLevelAssets[level];

            //遍历该等级的所有asset打包
            foreach (KeyValuePair <string, AssetUnit> pair in levelAssets)
            {
                //根据路径获取asset资源
                Object asset = AssetDatabase.LoadMainAssetAtPath(pair.Value.mPath);
                if (null == asset)
                {
                    DebugEx.LogError("load " + pair.Value.mPath + " failed!!!", "BuildResource", true);
                }

                //生成打包保存路径
                string savePath = pair.Value.mPath.Insert(6, assetFilePath) + ResourceCommon.assetbundleFileSuffix;
                BuildCommon.CheckFolder(BuildCommon.getPath(savePath));

                //打包名称去Asset



                //普通资源
                if (pair.Value.mSuffix != "unity")//普通资源
                {
                    string assetName = pair.Value.mPath.Replace("Assets/", "");

                    //资源打包
                    if (!BuildPipeline.BuildAssetBundleExplicitAssetNames(
                            new Object[] { asset }, new string[] { assetName }, savePath, options, buildPlatform))
                    {
                        DebugEx.LogError("build assetbundle " + savePath + " failed!!!", "BuildResource", true);
                    }
                }
                //场景资源,没有依赖场景的
                else
                {
                    AssetDatabase.Refresh();
                    BuildPipeline.PushAssetDependencies();
                    string error = BuildPipeline.BuildStreamedSceneAssetBundle(new string[] { pair.Value.mPath }, savePath, buildPlatform);
                    if (error != "")
                    {
                        DebugEx.LogError(error, "BuildResource", true);
                    }
                    BuildPipeline.PopAssetDependencies();

                    Debug.Log("scene path" + pair.Value.mPath);
                    //pair.Value.mPath
                }
            }
        }

        //popdepency依赖
        for (int level = 1; level <= maxLevel; level++)
        {
            BuildPipeline.PopAssetDependencies();
        }
    }
Ejemplo n.º 2
0
 //------------------------------------------------------------------------------------------------------------------------
 public override void OnTransportConnected(string msg)
 {
     base.OnTransportConnected(msg);
     SendQueue.Continue();
     DebugEx.TraceLog("Transport connected");
 }
Ejemplo n.º 3
0
        //------------------------------------------------------------------------------------------------------------------------
        #endregion

        #region Functions
        //------------------------------------------------------------------------------------------------------------------------
        public override bool Initialize(mNodeConfig mNodeConfig, string PluginConfig, string UserConfig)
        {
            //init base
            if (base.Initialize(mNodeConfig, PluginConfig, UserConfig) == false)
            {
                return(false);
            }

            //set queue handler
            SendQueue.SetHandler(s =>
            {
                if (SendToCloudPort != null)
                {
                    SetPortState(SendToCloudPort.PortKey, s);
                }
            });

            //init
            try
            {
                var ports = SerialPort.GetPortNames();
                DebugEx.TraceLog("Serial Ports found: " + string.Join(",", ports));

                var port = ports?.Where(p => p.Contains("USB")).FirstOrDefault();
                if (port != null && !port.IsNullOrEmpty())
                {
                    DebugEx.TraceLog("Selected Port: " + port);

                    //replace this with entry from conf
                    mySerial = new SerialPort(port, 9600);
                    if (mySerial.IsOpen)
                    {
                        try
                        {
                            mySerial.Close();
                            mySerial.Dispose();
                        }
                        catch { }
                    }
                    mySerial.DataReceived  += MySerial_DataReceived;
                    mySerial.ErrorReceived += MySerial_ErrorReceived;
                    mySerial.ReadTimeout    = 2000;
                    mySerial.NewLine        = "\r\n";
                    mySerial.Open();

                    _IsRunning = true;
                    StartSerialPortReadThread();

                    SendQueue.Start();
                    SendQueue.Pause();
                }
                else
                {
                    DebugEx.Assert("The USB port does not exist");
                }
            }
            catch (Exception ex) { DebugEx.Assert(ex, "Could not init"); }

            //setup
            SetupSerialPortThings();

            //done
            return(true);
        }
Ejemplo n.º 4
0
 private void OnTransportConnectedCb(NodeLibrary.Transport Transport, string msg)
 {
     DebugEx.TraceLog("OnConnected transport=" + Transport.ToString() + " msg=" + msg);
 }
Ejemplo n.º 5
0
 public override void StartLoad()
 {
     DebugEx.Info("Loading KIS global settings...");
     ConfigAccessor.ReadFieldsInType(typeof(KISAddonConfig), instance: null);
     ConfigAccessor.ReadFieldsInType(typeof(ModuleKISInventory), instance: null);
 }
Ejemplo n.º 6
0
 private void OnTransportErrorCb(NodeLibrary.Transport Transport, TransportErrors Error, string msg)
 {
     DebugEx.TraceLog("OnTransportError transport=" + Transport.ToString() + " msg=" + msg);
 }
Ejemplo n.º 7
0
 private void OnUnexpectedMessageCb(object message)
 {
     DebugEx.TraceLog("Unexpected message received.");
 }
Ejemplo n.º 8
0
        public override SegmentMap LoadImageBytes(IPlatform platform, byte[] rawImage, Address addrPreferred)
        {
            var segMap = AllocateMemoryAreas(
                Segments
                .Where(p => IsLoadable(p.p_pmemsz, p.p_type))
                .Select(p => Tuple.Create(
                            Address.Ptr32((uint)p.p_vaddr),
                            (uint)p.p_pmemsz)));

            foreach (var ph in Segments)
            {
                DebugEx.Inform(ElfImageLoader.trace, "ph: addr {0:X8} filesize {0:X8} memsize {0:X8}", ph.p_vaddr, ph.p_filesz, ph.p_pmemsz);
                if (!IsLoadable(ph.p_pmemsz, ph.p_type))
                {
                    continue;
                }
                var vaddr = Address.Ptr32((uint)ph.p_vaddr);
                segMap.TryGetLowerBound(vaddr, out var mem);
                if (ph.p_filesz > 0)
                {
                    Array.Copy(
                        rawImage,
                        (long)ph.p_offset, mem.Bytes,
                        vaddr - mem.BaseAddress, (long)ph.p_filesz);
                }
            }
            var segmentMap = new SegmentMap(addrPreferred);

            if (Sections.Count > 0)
            {
                foreach (var section in Sections)
                {
                    if (string.IsNullOrEmpty(section.Name) || section.Address == null)
                    {
                        continue;
                    }

                    if (segMap.TryGetLowerBound(section.Address, out var mem) &&
                        section.Address < mem.EndAddress)
                    {
                        AccessMode mode = AccessModeOf(section.Flags);
                        var        seg  = segmentMap.AddSegment(new ImageSegment(
                                                                    section.Name,
                                                                    section.Address,
                                                                    mem, mode)
                        {
                            Size = (uint)section.Size
                        });
                        seg.Designer = CreateRenderer(section, machine);
                    }
                    else
                    {
                        //$TODO: warn
                    }
                }
            }
            else
            {
                // There are stripped ELF binaries with 0 sections. If we have one
                // create a pseudo-section from the segMap.
                foreach (var segment in segMap)
                {
                    var imgSegment = new ImageSegment(
                        segment.Value.BaseAddress.GenerateName("seg", ""),
                        segment.Value,
                        AccessMode.ReadExecute)        //$TODO: writeable segments.
                    {
                        Size = (uint)segment.Value.Length,
                    };
                    segmentMap.AddSegment(imgSegment);
                }
            }
            segmentMap.DumpSections();
            return(segmentMap);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Executes the change operations annotated into this instance against the underlying
        /// database as a single logical operation that either succeeds or fails as a whole.
        /// <para>Once this method is executed all the submitted operations are disposed
        /// automatically.</para>
        /// </summary>
        public void ExecuteChanges()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(this.ToString());
            }
            lock (MasterLock)
            {
                ChangeEntries = new List <ChangeEntry>();
                try
                {
                    DebugEx.IndentWriteLine("\n--- Executing changes for '{0}'...".FormatWith(this));

                    Link.Transaction.Start();
                    foreach (var op in UberOperations)
                    {
                        op.OnExecute();
                    }
                    Link.Transaction.Commit();

                    DebugEx.Unindent();
                    DebugEx.IndentWriteLine("\n--- Refreshing changes for '{0}'...".FormatWith(this));

                    ChangeEntries.Reverse();
                    foreach (var entry in ChangeEntries)
                    {
                        entry.MetaEntity.Completed = false;
                    }
                    foreach (var entry in ChangeEntries)
                    {
                        if (entry.MetaEntity.Completed)
                        {
                            continue;
                        }
                        if (entry.ChangeType == ChangeType.Delete)
                        {
                            continue;
                        }

                        if (entry.MetaEntity.UberMap == null)
                        {
                            entry.UberMap.RefreshNow(entry.Entity);
                        }
                        else
                        {
                            entry.UberMap.CompleteMembers(entry.MetaEntity);
                        }
                    }
                }
                catch (Exception e)
                {
                    DebugEx.Unindent();
                    DebugEx.IndentWriteLine("\n--- Reverting changes for '{0}' because '{1}'...", this, e.ToDisplayString());

                    Link.Transaction.Abort();
                    Link.Dispose();

                    ChangeEntries.Reverse();
                    foreach (var entry in ChangeEntries)
                    {
                        switch (entry.ChangeType)
                        {
                        case ChangeType.Delete: entry.UberMap.Attach(entry.Entity); break;

                        case ChangeType.Insert: entry.UberMap.Detach(entry.Entity); break;
                        }
                    }
                    foreach (var entry in ChangeEntries)
                    {
                        entry.MetaEntity.Completed = false;
                    }
                    foreach (var entry in ChangeEntries)
                    {
                        if (entry.MetaEntity.Completed)
                        {
                            continue;
                        }
                        if (entry.ChangeType == ChangeType.Delete)
                        {
                            continue;
                        }
                        entry.UberMap.RefreshNow(entry.Entity);
                    }

                    throw;
                }
                finally
                {
                    ClearChangeEntries(setToNull: true);
                    DiscardChanges();
                    DebugEx.Unindent();
                }
            }
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Determines whether menu is visible.
        /// </summary>
        /// <returns><c>true</c> if menu is visible; otherwise, <c>false</c>.</returns>
        private bool IsMenuVisible()
        {
            DebugEx.Verbose("MainWindowScript.IsMenuVisible()");

            return(Global.mainMenuScript.gameObject.activeSelf);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Loads dock widgets layout.
        /// </summary>
        private void LoadDockWidgets()
        {
            DebugEx.Verbose("MainWindowScript.LoadDockWidgets()");

            ServersDockWidgetScript.Create().InsertToDockingArea(Global.dockingAreaScript);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Creates the content.
        /// </summary>
        /// <param name="contentTransform">Content transform.</param>
        /// <param name="width">Width of content.</param>
        /// <param name="height">Height of content.</param>
        protected override void CreateContent(Transform contentTransform, out float width, out float height)
        {
            DebugEx.VerboseFormat("MainWindowScript.CreateContent(contentTransform = {0})", contentTransform);

            width  = 0f;
            height = 0f;

            //***************************************************************************
            // MainMenu GameObject
            //***************************************************************************
            #region MainMenu GameObject
            GameObject mainMenu = new GameObject("MainMenu");
            Utils.InitUIObject(mainMenu, contentTransform);

#if MENU_BUTTON_TO_SHOW_MENU
            mainMenu.SetActive(false);
#endif

            //===========================================================================
            // RectTransform Component
            //===========================================================================
            #region RectTransform Component
            RectTransform mainMenuTransform = mainMenu.AddComponent <RectTransform>();
            Utils.AlignRectTransformTopStretch(mainMenuTransform, MAIN_MENU_HEIGHT);
            #endregion

            //===========================================================================
            // MainMenuScript Component
            //===========================================================================
            #region MainMenuScript Component
            Global.mainMenuScript = mainMenu.AddComponent <MainMenuScript>();
            #endregion
            #endregion



            //***************************************************************************
            // Toolbar GameObject
            //***************************************************************************
            #region Toolbar GameObject
            GameObject toolbar = new GameObject("Toolbar");
            Utils.InitUIObject(toolbar, contentTransform);

#if MENU_BUTTON_TO_SHOW_MENU
            toolbar.SetActive(false);
#endif

            //===========================================================================
            // RectTransform Component
            //===========================================================================
            #region RectTransform Component
            RectTransform toolbarTransform = toolbar.AddComponent <RectTransform>();
            Utils.AlignRectTransformTopStretch(toolbarTransform, TOOLBAR_HEIGHT, MAIN_MENU_HEIGHT);
            #endregion

            //===========================================================================
            // ToolbarScript Component
            //===========================================================================
            #region ToolbarScript Component
            Global.toolbarScript = toolbar.AddComponent <ToolbarScript>();
            #endregion
            #endregion



            //***************************************************************************
            // DockingArea GameObject
            //***************************************************************************
            #region DockingArea GameObject
            GameObject dockingArea = new GameObject("DockingArea");
            Utils.InitUIObject(dockingArea, contentTransform);

            //===========================================================================
            // RectTransform Component
            //===========================================================================
            #region RectTransform Component
            RectTransform dockingAreaTransform = dockingArea.AddComponent <RectTransform>();

#if MENU_BUTTON_TO_SHOW_MENU
            Utils.AlignRectTransformStretchStretch(dockingAreaTransform);
#else
            Utils.AlignRectTransformStretchStretch(dockingAreaTransform, 0f, MAIN_MENU_HEIGHT + TOOLBAR_HEIGHT, 0f, 0f);
#endif
            #endregion

            //===========================================================================
            // DockingAreaScript Component
            //===========================================================================
            #region DockingAreaScript Component
            Global.dockingAreaScript = dockingArea.AddComponent <DockingAreaScript>();
            #endregion
            #endregion

#if HANDLE_ESCAPE_BUTTON
            EscapeButtonListenerScript.PushHandlerToTop(this);
#endif

            // TODO: [Major] It looks bad on start up on Android
            LoadDockWidgets();
        }
Ejemplo n.º 13
0
 //-------------------------------------------------------------------------------------------------------------------------
 private void YPChannel_OnOpenEvent(YPChannel.Channel Channel)
 {
     DebugEx.TraceLog($"RemoteNode : Openned channel with node. (ip:{IPAddress} port:{RemotePort} nodekey:{RemoteNodeKey})");
     //raise events
     OnChannelOpen?.Invoke(this);
 }
Ejemplo n.º 14
0
        public void ReadConfig(string xmlFilePath)
        {
            ResourceUnit xmlFileUnit = ResourceManager.Instance.LoadImmediate(xmlFilePath, EResourceType.ASSET);
            TextAsset    xmlFile     = xmlFileUnit.Asset as TextAsset;

            if (!xmlFile)
            {
                DebugEx.LogError("unable to load " + xmlFilePath);
            }

            mXmlDoc = new XmlDocument();
            mXmlDoc.LoadXml(xmlFile.text);

            XmlNodeList infoNodeList = mXmlDoc.SelectSingleNode("MapLoadCfg").ChildNodes;

            for (int i = 0; i < infoNodeList.Count; i++)
            {
                var node = (infoNodeList[i] as XmlElement).GetAttributeNode("MapID");
                if (node == null)
                {
                    continue;
                }
                string  mapId   = node.InnerText;
                MapInfo mapInfo = new MapInfo();
                mapInfo.Id = Convert.ToUInt32(mapId);
                foreach (XmlElement element in infoNodeList[i].ChildNodes)
                {
                    switch (element.Name)
                    {
                    case "LoadScene":
                        mapInfo.Scene = Convert.ToString(element.InnerText);
                        break;

                    case "MiniMap":
                        mapInfo.MiniMap = Convert.ToString(element.InnerText);
                        break;

                    case "NameCn":
                        mapInfo.Name = Convert.ToString(element.InnerText);
                        break;

                    case "ACameraPos":
                        mapInfo.ACameraPos = Convert.ToString(element.InnerText);
                        break;

                    case "BCameraPos":
                        mapInfo.BCameraPos = Convert.ToString(element.InnerText);
                        break;

                    case "ShowPic":
                        mapInfo.ShowPic = Convert.ToString(element.InnerText);
                        break;

                    case "PlayerNum":
                        mapInfo.PlayerNum = Convert.ToInt32(element.InnerText);
                        break;

                    case "PlayerMode":
                        mapInfo.PlayerMode = Convert.ToString(element.InnerText);
                        break;

                    case "CameraType":
                        mapInfo.CameraType = Convert.ToInt32(element.InnerText);
                        break;

                    case "IsAI":
                        mapInfo.IsAI = Convert.ToBoolean(Convert.ToInt32(element.InnerText));
                        break;

                    case "IsNormal":
                        mapInfo.IsNormal = Convert.ToBoolean(Convert.ToInt32(element.InnerText));
                        break;

                    case "IsRank":
                        mapInfo.IsRank = Convert.ToBoolean(Convert.ToInt32(element.InnerText));
                        break;

                    case "IsTrain":
                        mapInfo.IsTrain = Convert.ToBoolean(Convert.ToInt32(element.InnerText));
                        break;

                    case "IsDungeon":
                        mapInfo.IsDungeon = Convert.ToBoolean(Convert.ToInt32(element.InnerText));
                        break;

                    case "ShopID":
                        mapInfo.ShopId = Convert.ToInt32(element.InnerText);
                        break;
                    }
                }
                mMapDic.Add(mapInfo.Id, mapInfo);
            }
        }
Ejemplo n.º 15
0
        /// <summary>Localizes the <see cref="PartModule"/> items.</summary>
        /// <remarks>
        /// <para>
        /// The localizable items must be declared as non-static public members. The following items are
        /// supported:
        /// <list type="bullet">
        /// <item>
        /// <see cref="KSPField"/>. This type may have multiple localization items: for <c>guiName</c>
        /// (spec=<c>null</c>) and for <c>guiUnits</c> (spec=<see cref="KspFieldUnitsSpec"/>).
        /// </item>
        /// <item><see cref="KSPEvent"/>.</item>
        /// <item><see cref="KSPAction"/>.</item>
        /// </list>
        /// </para>
        /// <para>
        /// The original KSP attributes don't need to specify <c>guiName</c> field since it will be
        /// overwritten anyways. However, it's a good idea to give a default value just in case.
        /// </para>
        /// <para>
        /// This method can be called at any time during the module's life. However, the
        /// <see cref="IsLocalizableModule.LocalizeModule"/> method looks the most appropriate.
        /// </para>
        /// </remarks>
        /// <param name="module">The module instance to localize.</param>
        /// <example><code source="Examples/GUIUtils/LocalizationLoader-Examples.cs" region="LocalizationLoaderDemo1"/></example>
        /// <example><code source="Examples/GUIUtils/LocalizationLoader-Examples.cs" region="LocalizationLoaderDemo2"/></example>
        /// <seealso cref="LocalizableItemAttribute"/>
        /// <seealso cref="IsLocalizableModule"/>
        /// <include file="KSPAPI_HelpIndex.xml" path="//item[@name='T:KSPField']"/>
        /// <include file="KSPAPI_HelpIndex.xml" path="//item[@name='T:KSPEvent']"/>
        /// <include file="KSPAPI_HelpIndex.xml" path="//item[@name='T:KSPAction']"/>
        public static void LoadItemsInModule(PartModule module)
        {
            // This method may look ugly and over complicated, but it's because if it's performance
            // optimized. On a vessel with 100 parts this method can be called 1000 times. So every
            // millisecond matters.

            // Go thru all the KSP fields that may have the localizable content.
            foreach (var field in module.Fields)
            {
                var locItems = (LocalizableItemAttribute[])field.FieldInfo.GetCustomAttributes(
                    typeof(LocalizableItemAttribute), false);
                foreach (var locItem in locItems)
                {
                    if (string.IsNullOrEmpty(locItem.tag))
                    {
                        continue; // Localization is disabled for the item.
                    }
                    if (string.IsNullOrEmpty(locItem.spec))
                    {
                        field.guiName = locItem.GetLocalizedString();
                    }
                    else if (locItem.spec == KspFieldUnitsSpec)
                    {
                        field.guiUnits = locItem.GetLocalizedString();
                    }
                    else
                    {
                        DebugEx.Warning("Bad specialization tag for field {0}.{1}: {2}",
                                        field.FieldInfo.FieldType.FullName,
                                        field.FieldInfo.Name,
                                        locItem.spec);
                    }
                }
            }

            // Go thru all the KSP events that may have the localizable content.
            foreach (var @event in module.Events)
            {
                var info = module.GetType().GetMethod(@event.name);
                if (info != null)
                {
                    var locItems = (LocalizableItemAttribute[])info.GetCustomAttributes(
                        typeof(LocalizableItemAttribute), false);
                    if (locItems.Length > 0 && !string.IsNullOrEmpty(locItems[0].tag))
                    {
                        @event.guiName = locItems[0].GetLocalizedString();
                    }
                }
            }

            // Go thru all the KSP actions that may have the localizable content.
            foreach (var action in module.Actions)
            {
                var info = module.GetType().GetMethod(action.name);
                if (info != null)
                {
                    var locItems = (LocalizableItemAttribute[])info.GetCustomAttributes(
                        typeof(LocalizableItemAttribute), false);
                    if (locItems.Length > 0 && !string.IsNullOrEmpty(locItems[0].tag))
                    {
                        action.guiName = locItems[0].GetLocalizedString();
                    }
                }
            }
        }
Ejemplo n.º 16
0
        public static string FindLocalIpAddress()
        {
#if NETFX
            try
            {
                //check connection
                if (!System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
                {
                    return(null);
                }

                //find ethernet
                foreach (var iface in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces())
                {
                    if (iface.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Up)
                    {
                        if (iface.NetworkInterfaceType == System.Net.NetworkInformation.NetworkInterfaceType.Ethernet)
                        {
                            if (iface.GetIPProperties().GatewayAddresses.Count > 0)
                            {
                                var addrs = iface.GetIPProperties().UnicastAddresses;
                                if (addrs != null)
                                {
                                    foreach (var ip in addrs)
                                    {
                                        if (ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                                        {
                                            return(ip.Address.ToStringInvariant());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                //find wifi
                foreach (var iface in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces())
                {
                    if (iface.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Up)
                    {
                        if (iface.NetworkInterfaceType == System.Net.NetworkInformation.NetworkInterfaceType.Wireless80211)
                        {
                            if (iface.GetIPProperties().GatewayAddresses.Count > 0)
                            {
                                var addrs = iface.GetIPProperties().UnicastAddresses;
                                if (addrs != null)
                                {
                                    foreach (var ip in addrs)
                                    {
                                        if (ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                                        {
                                            return(ip.Address.ToStringInvariant());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                //get a valid address
                var host = Dns.GetHostEntry(Dns.GetHostName());
                foreach (var ip in host.AddressList)
                {
                    if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                    {
                        return(ip.ToString());
                    }
                }
            }
            catch (Exception ex) { DebugEx.TraceWarning("Could not find internal ip (" + ex.Message + ")"); }
#endif
            //not found
            return("127.0.0.1");
        }
Ejemplo n.º 17
0
            /// <summary>
            /// Attempt to fuse together the definitions of all the identifiers in <paramref name="sids"/>.
            /// </summary>
            /// <param name="sids"></param>
            /// <returns>A new expression if the fusion succeeded, otherwise null.</returns>
            private Expression FuseIdentifiers(params SsaIdentifier[] sids)
            {
                // Are all the definitions of the ids in the same basic block? If they're
                // not, we give up.

                if (!AllSame(sids, (a, b) =>
                             a.DefStatement.Block == b.DefStatement.Block &&
                             a.Identifier.Storage.GetType() == b.Identifier.Storage.GetType()))
                {
                    return(null);
                }

                var        dtWide = PrimitiveType.CreateWord(sids.Sum(s => s.Identifier.DataType.BitSize));
                Identifier idWide = GenerateWideIdentifier(dtWide, sids);

                var ass = sids.Select(s => s.DefStatement.Instruction as Assignment).ToArray();

                if (ass.All(a => a != null))
                {
                    // All assignments. Are they all slices?
                    var slices = ass.Select(AsSlice).ToArray();
                    if (slices.All(s => s != null))
                    {
                        if (AllSame(slices, (a, b) => cmp.Equals(a.Expression, b.Expression)) &&
                            AllAdjacent(slices))
                        {
                            trace.Verbose("Prpr: Fusing slices in {0}", ssa.Procedure.Name);
                            trace.Verbose("{0}", string.Join(Environment.NewLine, ass.Select(a => $"    {a}")));
                            return(RewriteSeqOfSlices(dtWide, sids, slices));
                        }
                    }
                    trace.Warn("Prpr: Couldn't fuse assignments in {0}", ssa.Procedure.Name);
                    trace.Warn("{0}", string.Join(Environment.NewLine, ass.Select(a => $"    {a}")));
                    return(null);
                }

                if (idWide != null)
                {
                    if (sids.All(s => s.DefStatement.Instruction is DefInstruction))
                    {
                        // All the identifiers are generated by def statements.
                        return(RewriteSeqOfDefs(sids, idWide));
                    }

                    var phis = sids.Select(s => s.DefStatement.Instruction as PhiAssignment).ToArray();
                    if (phis.All(a => a != null))
                    {
                        // We have a sequence of phi functions
                        return(RewriteSeqOfPhi(sids, phis, idWide));
                    }
                    if (sids[0].DefStatement.Instruction is CallInstruction call &&
                        sids.All(s => s.DefStatement == sids[0].DefStatement))
                    {
                        // All of the identifiers in the sequence were defined by the same call.
                        return(RewriteSeqDefinedByCall(sids, call, idWide));
                    }
                }
                DebugEx.Warn(trace, "Prpr: Couldn't fuse statements in {0}", ssa.Procedure.Name);
                DebugEx.Warn(trace, "{0}", string.Join(Environment.NewLine, sids.Select(s => $"    {s.DefStatement}")));
                return(null);
            }
Ejemplo n.º 18
0
        //private ToolbarScript mScript;



        /// <summary>
        /// Initializes a new instance of the <see cref="UI.Windows.MainWindow.Toolbar.ToolbarUI"/> class.
        /// </summary>
        /// <param name="script">Toolbar script.</param>
        public ToolbarUI(ToolbarScript script)
        {
            DebugEx.VerboseFormat("Created ToolbarUI(script = {0}) object", script);

            //mScript = script;
        }
Ejemplo n.º 19
0
 private PlegmaApiMsg OnUnexpectedRequestCb(object request)
 {
     DebugEx.TraceLog("Unexpected request received.");
     return(null);
 }
Ejemplo n.º 20
0
        /// <summary>
        /// Setup user interface.
        /// </summary>
        public void SetupUI()
        {
            DebugEx.Verbose("ToolbarUI.SetupUI()");

            CreateUI();
        }
Ejemplo n.º 21
0
        public void Start()
        {
            YConfig   = Config.Init();
            ActiveCfg = YConfig.GetActiveConf();

            NodeConfig conf = new NodeConfig()
            {
                uuid = ActiveCfg.Uuid,
                Name = "SkyWriter Node",
                MqttBrokerHostname = ActiveCfg.MqttBrokerHostname,
                MqttUseSsl         = ActiveCfg.MqttUseSsl,
                YpServer           = ActiveCfg.ApiServer,
                YpchannelPort      = ActiveCfg.YpchannelPort,
                SecureYpc          = ActiveCfg.YpchannelSecure,
                FrontendServer     = ActiveCfg.FrontendServer,
                CanSolveGraphs     = false,// deactivate for GrovePi
            };

            //prepare pairing module
            var pairmodule = new Yodiwo.NodeLibrary.Pairing.NancyPairing.NancyPairing();

            //create node
            node = new Yodiwo.NodeLibrary.Node(conf,
                                               pairmodule,
                                               null, null,
                                               NodeGraphManager: null
                                               );
            Helper.node = node;
            //set TransPort
            node.Transport = transport;

            //register callbacks for grovepi node
            node.OnChangedState          += OnChangedStateCb;
            node.OnNodePaired            += OnPaired;
            node.OnTransportConnected    += OnTransportConnectedCb;
            node.OnTransportDisconnected += OnTransportDisconnectedCb;
            node.OnTransportError        += OnTransportErrorCb;
            node.OnUnexpectedMessage     += OnUnexpectedMessageCb;
            node.OnThingActivated        += OnThingActivatedCb;
            node.OnThingDeactivated      += OnThingDeactivatedCb;

            //register port event handlers

            //start Pairing
            if (String.IsNullOrWhiteSpace(ActiveCfg.NodeKey))
            {
                DebugEx.TraceLog("Starting pairing procedure.");
                var pair = node.StartPairing(ActiveCfg.FrontendServer, null, ActiveCfg.LocalWebServer).GetResults();
            }
            else
            {
                node.SetupNodeKeys(ActiveCfg.NodeKey, ActiveCfg.NodeSecret.ToSecureString());
                DebugEx.TraceLog("Node already paired: NodeKey = "
                                 + ActiveCfg.NodeKey + ", NodeSecret = ", ActiveCfg.NodeSecret);
            }

            //add things
            Helper.CreateThings(this.pysharp, node);

            //connect
            node.Connect();
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Creates user interface.
        /// </summary>
        private void CreateUI()
        {
            DebugEx.Verbose("ToolbarUI.CreateUI()");

            // TODO: [Minor] Implement Create UI
        }
Ejemplo n.º 23
0
        /// <summary>
        /// Refuels kerbal's EVA pack up to the maximum, and decreases canister reserve.
        /// </summary>
        /// <param name="item">Item to get fuel from.</param>
        void RefillEvaPack(KIS_Item item)
        {
            var p = item.inventory.part;

            if (!p.isVesselEVA)
            {
                HostedDebugLog.Error(this, "Cannot refill non-EVA kerbal");
                return;
            }
            var stockInventory = p.FindModuleImplementing <ModuleInventoryPart>();

            if (stockInventory == null)
            {
                HostedDebugLog.Error(this, "Cannot find stock inventory module");
                return;
            }
            var evaModule = p.FindModuleImplementing <KerbalEVA>();
            var propellantResourceField = evaModule.GetType()
                                          .GetField("propellantResource", BindingFlags.Instance | BindingFlags.NonPublic);

            if (propellantResourceField == null)
            {
                HostedDebugLog.Error(this, "Cannot access internal KerbalEVA logic: propellant field");
                return;
            }
            var propellantResource = propellantResourceField.GetValue(evaModule) as PartResource;

            if (propellantResource == null)
            {
                HostedDebugLog.Error(this, "Cannot access internal KerbalEVA logic: propellant field value");
                return;
            }

            var needAmount = propellantResource.maxAmount - propellantResource.amount;

            if (needAmount <= double.Epsilon)
            {
                ScreenMessaging.ShowPriorityScreenMessage(NoNeedToRefillJetpackMsg);
                return;
            }
            var canisterFuelResource = GetCanisterFuelResource(item);

            if (canisterFuelResource.amount < double.Epsilon)
            {
                ScreenMessaging.ShowPriorityScreenMessage(CanisterIsEmptyMsg);
                UISounds.PlayBipWrong();
                return;
            }
            var canProvide = Math.Min(needAmount, canisterFuelResource.amount);

            var storedResources = stockInventory.storedParts.Values.SelectMany(x => x.snapshot.resources)
                                  .Where(x => x.resourceName == StockResourceNames.EvaPropellant)
                                  .ToArray();

            if (storedResources.Length == 0)
            {
                UISounds.PlayBipWrong();
                DebugEx.Error("Unexpectedly no EVA resource parts found in: {0}", evaModule);
                return;
            }
            item.UpdateResource(_mainResourceName, -canProvide, isAmountRelative: true);
            p.TransferResource(propellantResource, canProvide, p);
            var distributeAmount = canProvide;

            for (var i = 0; i < storedResources.Length && canProvide > double.Epsilon; i++)
            {
                var resource  = storedResources[i];
                var canAccept = resource.maxAmount - resource.amount;
                if (canAccept <= double.Epsilon)
                {
                    continue;
                }
                var refillAmount = Math.Min(canAccept, distributeAmount);
                resource.amount += refillAmount;
                resource.UpdateConfigNodeAmounts();
                distributeAmount -= refillAmount;
            }
            if (canProvide < needAmount)
            {
                ScreenMessaging.ShowPriorityScreenMessage(JetpackPartiallyRefueledMsg.Format(canProvide));
            }
            else
            {
                ScreenMessaging.ShowPriorityScreenMessage(JetpackFullyRefueledMsg);
            }
            UISoundPlayer.instance.Play(refuelSndPath);
        }
Ejemplo n.º 24
0
        public List <ImageSymbol> LoadEntryPoints(
            uint offEntryTable,
            NeSegment [] segments,
            Dictionary <int, string> names,
            IProcessorArchitecture arch)
        {
            DebugEx.Inform(trace, "== Loading entry points from offset {0:X}", offEntryTable);
            var rdr = new LeImageReader(RawImage, offEntryTable);

            var entries           = new List <ImageSymbol>();
            int bundleOrdinal     = 1;
            int nextbundleOrdinal = 1;

            for (; ;)
            {
                var cBundleEntries = rdr.ReadByte();
                if (cBundleEntries == 0)
                {
                    break;
                }
                nextbundleOrdinal = bundleOrdinal + cBundleEntries;
                var segNum = rdr.ReadByte();
                if (segNum != 0)
                {
                    // If segNum had been 0, it would have
                    // meant that all we want to do is allocate
                    // (skip) some ordinal numbers. Since it wasn't 0,
                    // we proceed to generate entry points.
                    for (int i = 0; i < cBundleEntries; ++i)
                    {
                        byte flags = rdr.ReadByte();
                        (byte iSeg, ushort offset)entry;
                        if (segNum == 0xFF)
                        {
                            entry = ReadMovableSegmentEntry(rdr);
                        }
                        else
                        {
                            entry = ReadFixedSegmentEntry(rdr, segNum);
                        }
                        var seg  = segments[entry.iSeg - 1];
                        var addr = seg.Address + entry.offset;
                        var ep   = ImageSymbol.Procedure(arch, addr);
                        ep.Ordinal = bundleOrdinal + i;
                        if (names.TryGetValue(bundleOrdinal + i, out string name))
                        {
                            ep.Name = name;
                        }
                        ep.Type                  = SymbolType.Procedure;
                        ep.ProcessorState        = arch.CreateProcessorState();
                        imageSymbols[ep.Address] = ep;
                        entries.Add(ep);
                        DebugEx.Verbose(trace, "   {0:X2} {1} {2} - {3}", segNum, ep.Address, ep.Name, ep.Ordinal);
                    }
                }
                else
                {
                    // We have unused entries, they have to occupy a space in the resulting entries table.
                    entries.AddRange(Enumerable.Range(0, cBundleEntries).Select(x => (ImageSymbol)null));
                }
                bundleOrdinal = nextbundleOrdinal;
            }
            return(entries);
        }
Ejemplo n.º 25
0
        //------------------------------------------------------------------------------------------------------------------------

        private void MySerial_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            DebugEx.TraceLog($"{sender} sent {e.EventType}");
        }
 public BfxParentOrderTransaction(BfTradingMarket market, BfParentOrderRequest request)
 {
     DebugEx.EnterMethod();
     _market = market;
     State   = new BfxParentOrderTransactionState(_market, request);
 }
Ejemplo n.º 27
0
 //------------------------------------------------------------------------------------------------------------------------
 public override void OnTransportDisconnected(string msg)
 {
     base.OnTransportDisconnected(msg);
     SendQueue.Pause();
     DebugEx.TraceLog("Transport disconnected");
 }
Ejemplo n.º 28
0
        public SlicerResult VisitBinaryExpression(BinaryExpression binExp, BackwardSlicerContext ctx)
        {
            if (binExp.Operator == Operator.Eq || binExp.Operator == Operator.Ne)
            {
                // Equality comparisons cannot contribute to determining the size
                // of the jump table; stop processing this instruction.
                return(null);
            }

            if ((binExp.Operator == Operator.Xor || binExp.Operator == Operator.ISub) &&
                this.slicer.AreEqual(binExp.Left, binExp.Right))
            {
                // XOR r,r (or SUB r,r) clears a register. Is it part of a live register?
                var regDst = this.assignLhs as Identifier;
                var regHi  = binExp.Left as Identifier;
                if (regHi != null && regDst != null &&
                    DomainOf(regDst) == regHi.Storage.Domain &&
                    regDst.Storage.OffsetOf(regHi.Storage) == 8)
                {
                    // The 8086 didn't have a MOVZX instruction, so clearing the high byte of a
                    // register BX was done by issuing XOR BH,BH
                    var seXor = new SlicerResult
                    {
                        SrcExpr   = new Cast(regDst.DataType, new Cast(PrimitiveType.Byte, this.assignLhs)),
                        LiveExprs = new Dictionary <Expression, BackwardSlicerContext>
                        {
                            {
                                this.assignLhs,
                                BackwardSlicerContext.Jump(new BitRange(0, 8))
                            }
                        }
                    };
                    return(seXor);
                }
            }

            var seLeft  = binExp.Left.Accept(this, ctx);
            var seRight = binExp.Right.Accept(this, ctx);

            if (seLeft == null && seRight == null)
            {
                return(null);
            }
            if (binExp.Operator == Operator.ISub && this.Live != null && (ctx.Type & ContextType.Condition) != 0)
            {
                var domLeft = DomainOf(seLeft.SrcExpr);

                if (Live.Count > 0)
                {
                    foreach (var live in Live)
                    {
                        if (live.Value.Type != ContextType.Jumptable)
                        {
                            continue;
                        }
                        if ((domLeft != StorageDomain.Memory && DomainOf(live.Key) == domLeft)
                            ||
                            (this.slicer.AreEqual(live.Key, binExp.Left)))
                        {
                            //$TODO: if jmptableindex and jmptableindextouse not same, inject a statement.
                            this.JumpTableIndex         = live.Key;
                            this.JumpTableIndexToUse    = binExp.Left;
                            this.JumpTableIndexInterval = MakeInterval_ISub(live.Key, binExp.Right as Constant);
                            DebugEx.Verbose(BackwardSlicer.trace, "  Found range of {0}: {1}", live, JumpTableIndexInterval);
                            return(new SlicerResult
                            {
                                SrcExpr = binExp,
                                Stop = true
                            });
                        }
                    }
                }
                else
                {
                    // We have no live variables, which means this subtraction instruction
                    // is both computing the jumptable index and also performing the
                    // comparison.
                    this.JumpTableIndex         = assignLhs;
                    this.JumpTableIndexToUse    = assignLhs;
                    this.JumpTableIndexInterval = MakeInterval_ISub(assignLhs, binExp.Right as Constant);
                    DebugEx.Verbose(BackwardSlicer.trace, "  Found range of {0}: {1}", assignLhs, JumpTableIndexInterval);
                    return(new SlicerResult
                    {
                        SrcExpr = null,     // the jump table expression already has the correct shape.
                        Stop = true
                    });
                }
            }
            else if (binExp.Operator == Operator.And)
            {
                this.JumpTableIndex         = binExp.Left;
                this.JumpTableIndexToUse    = binExp.Left;
                this.JumpTableIndexInterval = MakeInterval_And(binExp.Left, binExp.Right as Constant);
                return(new SlicerResult
                {
                    SrcExpr = binExp,
                    Stop = true,
                });
            }
            IEnumerable <KeyValuePair <Expression, BackwardSlicerContext> > liveExpr = seLeft.LiveExprs;

            if (seRight != null)
            {
                liveExpr = liveExpr.Concat(seRight.LiveExprs);
            }
            var se = new SlicerResult
            {
                LiveExprs = liveExpr
                            .GroupBy(e => e.Key)
                            .ToDictionary(k => k.Key, v => v.Max(vv => vv.Value)),
                SrcExpr = binExp,
            };

            return(se);
        }
Ejemplo n.º 29
0
        public virtual void ProcessCDPResult(string command_result, CDPDataSet.DevicesRow parent_device, CDPDataSet ds)
        {
            if (command_result.IndexOf("CDP is not enabled") >= 0)
            {
                parent_device.CDP_status = false;
            }
            else
            {
                string[] cdp_lines = command_result.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                CDPDataSet.DevicesRow current_device = null; // As going through the CDP output lines, this is the actual neighbor
                string currentDeviceName             = "";
                string currentDeviceIP = "";
                CDPDataSet.NeighboursRow    new_neigbor    = null; // This is the neighbor created for current_device as a neighbor of parent_device
                PGTDataSet.ScriptSettingRow ScriptSettings = SettingsManager.GetCurrentScriptSettings();
                // As the ip address must be unique for each device, adding a device with ip address of nocdpip constant would fail for the second time
                // To overcome this issue, we do indexing for devices with no ip address (such as VMware ESX hosts)
                int nocdpip_index = 0;
                foreach (string line in cdp_lines)
                {
                    DebugEx.WriteLine(String.Format("CDP2VISIO : parsing cdp neighbor row [ {0} ]", line), DebugLevel.Full);
                    try
                    {
                        bool isVMWareESX = false;

                        #region Check for DeviceID line and set currentDeviceName accordingly
                        if (line.IndexOf(DeviceID()) >= 0)
                        {
                            try
                            {
                                if (new_neigbor != null)
                                {
                                    ds.Neighbours.AddNeighboursRow(new_neigbor);
                                }
                            }
                            catch (Exception Ex)
                            {
                                // Depending on discovery list, under special circumstances it can happen that we try to add a new neighbor row
                                // with the same connection parameters (same parent, neighbor and interfaces) that will violate unique key constraint
                                DebugEx.WriteLine(String.Format("CDP2VISIO : Error storing neighbor row : {0}", Ex.InnerExceptionsMessage()), DebugLevel.Warning);
                            }
                            new_neigbor = null;
                            string[] words = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                            currentDeviceName = words[2].Trim();;
                            currentDeviceIP   = "";
                            DebugEx.WriteLine(String.Format("CDP2VISIO : CDPParser found a new neighbor : {0}", currentDeviceName), DebugLevel.Informational);
                        }
                        #endregion

                        if (currentDeviceName == "")
                        {
                            continue;
                        }

                        #region Check for IPAddress line and set currentDeviceIP accordingly
                        if (line.IndexOf(IPAddress()) >= 0)
                        {
                            string[] words_in_line = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                            currentDeviceIP = words_in_line[2].Trim();
                            if (currentDeviceIP == "")
                            {
                                DebugEx.WriteLine(String.Format("CDP2VISIO : cdp is not reporting ip address for neighbor {0}", currentDeviceName), DebugLevel.Debug);
                                currentDeviceIP = string.Format("{0}_{1}", nocdpip, nocdpip_index);
                                nocdpip_index++;
                            }
                        }
                        #endregion

                        #region Check whether the Platform is VMware ESX
                        if (line.Trim().StartsWith("Platform:"))
                        {
                            string[] words = line.SplitByComma();
                            // words[0] should be PlatForm, words[1] is Capabilities
                            isVMWareESX = words[0].ToLowerInvariant().IndexOf("vmware esx") >= 0;
                            if (isVMWareESX)
                            {
                                DebugEx.WriteLine(String.Format("CDP2VISIO : neighbor {0} is an ESX host", currentDeviceName), DebugLevel.Debug);
                                currentDeviceIP = string.Format("{0}_{1}", nocdpip, nocdpip_index);
                                nocdpip_index++;
                            }
                        }
                        #endregion

                        if (currentDeviceIP == "")
                        {
                            continue;
                        }

                        #region Add current device as new device or select existing device from Devices table
                        // At this point we can identify the current device(cdp neighbor) by name and ip. This is also a new neighbor
                        // Two devices considered identical if :
                        // - have the same hostname, or
                        // - have the same IPAddress
                        string currentDeviceHostName = DottedNameSpace.TLD(currentDeviceName);
                        current_device = ds.Devices.FirstOrDefault(d =>
                                                                   currentDeviceIP != nocdpip && d.IP_Address.SplitBySemicolon().Any(thisIP => thisIP == currentDeviceIP) ||
                                                                   d.Name.SplitBySemicolon().Any(thisName => DottedNameSpace.CompateTLD(thisName, currentDeviceHostName))
                                                                   );
                        if (current_device == null)
                        {
                            DebugEx.WriteLine(String.Format("CDP2VISIO : neighbor {0} is a new device, adding to devices data table", currentDeviceName), DebugLevel.Informational);
                            // This device is not yet known. Add to device list and also to list of devices in script
                            current_device = ds.Devices.NewDevicesRow();
                            //if (current_device.Name != currentDeviceName) current_device.Name += ";" + currentDeviceName;
                            //else
                            current_device.Name = currentDeviceName;
                            if (current_device.IsIP_AddressNull() || current_device.IP_Address == "")
                            {
                                current_device.IP_Address = currentDeviceIP;
                            }
                            else if (current_device.IP_Address != currentDeviceIP)
                            {
                                current_device.IP_Address += ";" + currentDeviceIP;
                            }
                            ds.Devices.AddDevicesRow(current_device);
                            // Add a new entry for discovered device if has a valid neighbor ip, Recursion is allowed
                            // and this ip is not defined as discovery boundary
                            if (_AllowRecursion && !currentDeviceIP.StartsWith(nocdpip))
                            {
                                var includedAddresses = (from addressdefinition in ds.DomainBoundary where addressdefinition.Action == BoundaryAddressAction.Include.ToString() select addressdefinition.IP_Address)?.ToList();
                                var excludedAddresses = (from addressdefinition in ds.DomainBoundary where addressdefinition.Action == BoundaryAddressAction.Exclude.ToString() select addressdefinition.IP_Address)?.ToList();
                                if (IPOperations.IsIPAddressInNetworks(currentDeviceIP, includedAddresses, true) && !IPOperations.IsIPAddressInNetworks(currentDeviceIP, excludedAddresses, false))
                                {
                                    string[] newScriptLine = _ConnectionInfo.ScriptLine.Split(ScriptSettings.CSVSeparator.ToCharArray());
                                    newScriptLine[2] = currentDeviceIP;
                                    newScriptLine[3] = currentDeviceName;
                                    _Executor.AddScriptEntry(string.Join(ScriptSettings.CSVSeparator, newScriptLine));
                                    string msg = string.Format("Added device <{0}> to discovery list.", currentDeviceIP);
                                    DebugEx.WriteLine(msg, DebugLevel.Informational);
                                    _Executor.ShowActivity(msg);
                                }
                                else
                                {
                                    string msg = string.Format("Not adding device <{0}> to discovery list because it is either explicitly excluded or not included in discovery domain", currentDeviceIP);
                                    DebugEx.WriteLine(msg, DebugLevel.Full);
                                    _Executor.ShowActivity(msg);
                                }
                            }
                            else
                            {
                                string msg = "Not adding device a new neighbor to discovery list because Active Discovery is not allowed or the neighbor does not have a valid ip address detected.";
                                DebugEx.WriteLine(msg, DebugLevel.Full);
                            }
                        }
                        else
                        {
                            DebugEx.WriteLine(String.Format("CDP2VISIO : neighbor {0} is already a known device", currentDeviceName), DebugLevel.Full);
                        }
                        #endregion

                        if (current_device == null)
                        {
                            continue;
                        }

                        #region Create Neighbor for parent_device <-> current_device
                        if (new_neigbor == null)
                        {
                            new_neigbor             = ds.Neighbours.NewNeighboursRow();
                            new_neigbor.Neighbor_ID = current_device.ID;
                            new_neigbor.Parent_ID   = parent_device.ID;
                            new_neigbor.Name        = current_device.Name;
                            DebugEx.WriteLine(String.Format("CDP2VISIO : new neighbor {0} added for device {1}", currentDeviceName, parent_device.Name), DebugLevel.Full);
                        }
                        #endregion

                        #region  Get Platform/Interfaces info and update the neighbor

                        if (line.Trim().StartsWith("Platform") && new_neigbor != null)
                        {
                            string[] words = line.SplitByComma();
                            // words[0] should be PlatForm, words[1] is Capabilities
                            string[] platformWords = words[0].SplitBySpace();
                            string[] capabilities  = words[1].SplitBySpace();
                            current_device.Platform = string.Join(" ", platformWords.SkipWhile((string l, int i) => i < 1));
                            if (current_device.Type != "VSS" && current_device.Type != "ASA" && !current_device.Type.StartsWith("Stack"))
                            {
                                current_device.Type = string.Join(";", capabilities.SkipWhile((s, i) => i < 1));
                            }
                            DebugEx.WriteLine(String.Format("CDP2VISIO : Platform of neighbor {0} identified as {1}. Device type was set to {2}", currentDeviceName, current_device.Platform, current_device.Type), DebugLevel.Full);
                        }

                        if (line.IndexOf("Interface") >= 0 && new_neigbor != null)
                        {
                            string[] words_in_line        = line.SplitBySpace();
                            int      words_length         = words_in_line.Length;
                            string   neighbour_interfaces = words_in_line[words_length - 1];
                            neighbour_interfaces = Common.ConvInt(neighbour_interfaces);

                            string local_interfaces = words_in_line[1].Replace(",", "");
                            local_interfaces = Common.ConvInt(local_interfaces);

                            new_neigbor.Neighbour_Interface = neighbour_interfaces;
                            new_neigbor.Local_Interface     = local_interfaces;
                            DebugEx.WriteLine(String.Format("CDP2VISIO : connected interface added {0}::{1} connects to  {2}::{3}", currentDeviceName, local_interfaces, parent_device.Name, neighbour_interfaces), DebugLevel.Full);
                        }
                        #endregion
                    }
                    catch (Exception Ex)
                    {
                        DebugEx.WriteLine(String.Format("CDP2VISIO : Error while parsing cdp output line [{0}]. Error is : {1}", line, Ex.InnerExceptionsMessage()));
                    }
                }
                if (new_neigbor != null)
                {
                    ds.Neighbours.AddNeighboursRow(new_neigbor);
                }
            }
        }
Ejemplo n.º 30
0
        /// <summary>
        /// Relocates all relocations found in the DT_DYNAMIC segment.
        /// </summary>
        /// <param name="program"></param>
        /// <returns></returns>
        public List <ElfSymbol> RelocateDynamicSymbols(Program program)
        {
            var symbols = new List <ElfSymbol>();

            foreach (var dynSeg in EnumerateDynamicSegments())
            {
                DumpDynamicSegment(dynSeg);

                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_STRTAB, out var strtab);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_SYMTAB, out var symtab);

                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_RELA, out var rela);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_RELASZ, out var relasz);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_RELAENT, out var relaent);

                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_REL, out var rel);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_RELSZ, out var relsz);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_RELENT, out var relent);

                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_SYMENT, out var syment);
                if (symtab == null || (rela == null && rel == null))
                {
                    continue;
                }
                if (strtab == null)
                {
                    throw new BadImageFormatException("ELF dynamic segment lacks a string table.");
                }
                if (syment == null)
                {
                    throw new BadImageFormatException("ELF dynamic segment lacks the size of symbol table entries.");
                }
                RelocationTable relTable;
                if (rela != null)
                {
                    if (relasz == null)
                    {
                        throw new BadImageFormatException("ELF dynamic segment lacks the size of the relocation table.");
                    }
                    if (relaent == null)
                    {
                        throw new BadImageFormatException("ELF dynamic segment lacks the size of relocation table entries.");
                    }
                    relTable = new RelaTable(this, rela.UValue, relasz.UValue);
                }
                else
                {
                    Debug.Assert(rel != null);
                    if (relsz == null)
                    {
                        throw new BadImageFormatException("ELF dynamic segment lacks the size of the relocation table.");
                    }
                    if (relent == null)
                    {
                        throw new BadImageFormatException("ELF dynamic segment lacks the size of relocation table entries.");
                    }
                    relTable = new RelTable(this, rel.UValue, relsz.UValue);
                }

                var offStrtab = Loader.AddressToFileOffset(strtab.UValue);
                var offSymtab = Loader.AddressToFileOffset(symtab.UValue);

                LoadSymbolsFromDynamicSegment(dynSeg, symtab, syment, offStrtab, offSymtab);

                // Generate a symbol for each relocation.
                Debug.Print("Relocating entries in .dynamic:");
                foreach (var elfSym in relTable.RelocateEntries(program, offStrtab, offSymtab, syment.UValue))
                {
                    symbols.Add(elfSym);
                    var imgSym = Loader.CreateImageSymbol(elfSym, true);
                    if (imgSym == null || imgSym.Address.ToLinear() == 0)
                    {
                        continue;
                    }
                    imageSymbols[imgSym.Address] = imgSym;
                }

                // Relocate the DT_JMPREL table.
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_JMPREL, out var jmprel);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_PLTRELSZ, out var pltrelsz);
                Loader.DynamicEntries.TryGetValue(ElfDynamicEntry.DT_PLTREL, out var pltrel);
                if (jmprel != null && pltrelsz != null && pltrel != null)
                {
                    if (pltrel.SValue == 7) // entries are in RELA format.
                    {
                        relTable = new RelaTable(this, jmprel.UValue, pltrelsz.UValue);
                    }
                    else if (pltrel.SValue == 0x11) // entries are in REL format
                    {
                        relTable = new RelTable(this, jmprel.UValue, pltrelsz.UValue);
                    }
                    else
                    {
                        //$REVIEW: bad elf format!
                        continue;
                    }

                    DebugEx.Inform(ElfImageLoader.trace, "Relocating entries in DT_JMPREL:");
                    foreach (var elfSym in relTable.RelocateEntries(program, offStrtab, offSymtab, syment.UValue))
                    {
                        symbols.Add(elfSym);
                        var imgSym = Loader.CreateImageSymbol(elfSym, true);
                        if (imgSym == null || imgSym.Address.ToLinear() == 0)
                        {
                            continue;
                        }
                        imageSymbols[imgSym.Address]             = imgSym;
                        program.ImportReferences[imgSym.Address] =
                            new NamedImportReference(
                                imgSym.Address,
                                null,   // ELF imports don't specify which modile to take the import from
                                imgSym.Name,
                                imgSym.Type);
                    }
                }
            }
            return(symbols);
        }