Example #1
0
        void GetSubnet(ObjectNetwork objectNetwork, string line)
        {
            string lineParsed = line.Replace(ObjectNetwork.SubnetTag, null).Trim();

            string[] ips     = lineParsed.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
            bool     foundIp = false;

            foreach (var stringIp in ips)
            {
                IPAddress subnetIp = null;

                if (IPAddress.TryParse(stringIp, out subnetIp))
                {
                    if (!foundIp)
                    {
                        objectNetwork.IPGroup.IP = subnetIp;
                        foundIp = true;
                    }
                    else
                    {
                        objectNetwork.IPGroup.Subnet = subnetIp;
                    }
                }
                else
                {
                    objectNetwork.IPGroup.IPAlias = lineParsed;
                    break;
                }
            }
        }
Example #2
0
        void CollectObjectNetworkChecklist(ParserArgs args)
        {
            var objectNetworkReferences = args.Lines.Where(x => x.Contains(ObjectNetwork.ObjectNetworkTag));

            //Collecting all the starting points for the object networks
            foreach (var header in objectNetworkReferences.Distinct())
            {
                var objectNetwork = new ObjectNetwork()
                {
                    Name         = header.Replace(ObjectNetwork.ObjectNetworkTag, null).Trim(),
                    OriginalName = header
                };

                bool firstRound = true;
                int  lastIndex  = 0;

                while (true)
                {
                    lastIndex = args.Lines.ToList().IndexOf(objectNetwork.OriginalName, firstRound ? 0 : lastIndex + 1);

                    if (lastIndex == -1)
                    {
                        break;
                    }

                    objectNetwork.Indices.Add(lastIndex);
                    firstRound = false;
                }

                args.Results.ObjectNetworkResults.Add(objectNetwork);
            }
        }
Example #3
0
        void GetOthers(ObjectNetwork objectNetwork, string line)
        {
            var firstSpace = line.IndexOf(" ", 0);

            if (firstSpace <= 0)
            {
                return;
            }

            var pair = new KeyValuePair <string, string>(line.Substring(0, firstSpace),
                                                         line.Substring(firstSpace < 0 ? 0 : firstSpace));

            objectNetwork.AdditionalColumnValues.Add(pair);
        }
Example #4
0
        void GetHost(ObjectNetwork objectNetwork, string line)
        {
            string    lineParsed = line.Replace(ObjectNetwork.HostTag, null).Trim();
            IPAddress hostIp     = null;

            if (IPAddress.TryParse(lineParsed, out hostIp))
            {
                objectNetwork.IPGroup.IP = hostIp;
            }
            else
            {
                objectNetwork.IPGroup.IPAlias = lineParsed;
            }
        }
Example #5
0
        void ParseLinesForObjectNetworkConfigurations(ObjectNetwork focusedObjectNetwork, ParserArgs args)
        {
            //First pass in collecting all configurations for a specific object network.
            foreach (var index in focusedObjectNetwork.Indices)
            {
                var skippedGroup = args.Lines.Skip(index);

                foreach (var line in skippedGroup)
                {
                    bool groupComplete = AddConfiguration(focusedObjectNetwork, line);

                    if (groupComplete)
                    {
                        break;
                    }
                }
            }
        }
Example #6
0
        bool AddConfiguration(ObjectNetwork objectNetwork, string line)
        {
            bool groupComplete = false;

            switch (FindTagType(line))
            {
            case ObjectNetworkTagOption.ObjectNetwork:
                if (line == objectNetwork.OriginalName)
                {
                    groupComplete = false;
                }
                else     //Found the end of the configuration
                {
                    groupComplete = true;
                }
                break;

            case ObjectNetworkTagOption.Host:
                GetHost(objectNetwork, line);
                break;

            case ObjectNetworkTagOption.Subnet:
                GetSubnet(objectNetwork, line);
                break;

            case ObjectNetworkTagOption.Nat:
                GetNat(objectNetwork, line);
                break;

            case ObjectNetworkTagOption.Description:
                objectNetwork.Description = line.Replace(ObjectNetwork.DescriptionTag, null).Trim();
                break;

            case ObjectNetworkTagOption.None:
                GetOthers(objectNetwork, line);
                break;

            default:
                break;
            }

            return(groupComplete);
        }
Example #7
0
        void AddNetworkDetailFromAliases(ObjectNetwork focusedObjectNetwork, ParserArgs args)
        {
            string        aliasErrorMessage = "";
            ObjectNetwork aliasNetwork      = null;
            var           objectNetworks    = args.Results.ObjectNetworkResults;

            if (!string.IsNullOrEmpty(focusedObjectNetwork.IPGroup.IPAlias))
            {
                aliasNetwork = GetObjectNetworkFromAliases(focusedObjectNetwork.IPGroup.IPAlias, objectNetworks.ToList());

                if (aliasNetwork != null)
                {
                    focusedObjectNetwork.IPGroup.IP     = aliasNetwork.IPGroup.IP;
                    focusedObjectNetwork.IPGroup.Subnet = aliasNetwork.IPGroup.Subnet;
                }
                else
                {
                    aliasErrorMessage = string.Format("Unable to find alias '{0}' for {1} '{2}'. This name was an alias provided for the host or subnet ip.", focusedObjectNetwork.IPGroup.IPAlias,
                                                      ObjectNetwork.ObjectGroupTag,
                                                      focusedObjectNetwork.Name);
                }
            }
            if (!string.IsNullOrEmpty(focusedObjectNetwork.NatIPAlias))
            {
                aliasNetwork = GetObjectNetworkFromAliases(focusedObjectNetwork.NatIPAlias, objectNetworks.ToList());

                if (aliasNetwork != null)
                {
                    focusedObjectNetwork.NatIP = aliasNetwork.IPGroup.IP != null ? aliasNetwork.IPGroup.IP : aliasNetwork.NatIP;
                }
                else
                {
                    aliasErrorMessage = string.Format("Unable to find alias '{0}' for {1} '{2}'. This name was an alias provided for the NatIP.", focusedObjectNetwork.NatIPAlias,
                                                      ObjectNetwork.ObjectGroupTag,
                                                      focusedObjectNetwork.Name);
                }
            }

            if (!string.IsNullOrEmpty(aliasErrorMessage))
            {
                focusedObjectNetwork.Comments.AppendLine(aliasErrorMessage);
            }
        }
Example #8
0
        void GetNat(ObjectNetwork objectNetwork, string line)
        {
            //nat (inside,outside) static Someone2
            //nat (inside,outside) static 208.97.227.215
            //nat (inside,outside) dynamic HPS_Global_DataCenter

            var       values = line.Replace(ObjectNetwork.NatTag, null).Trim().Split(' ');
            IPAddress natIP  = null;

            foreach (var value in values)
            {
                if (string.IsNullOrEmpty(objectNetwork.NatStatement))
                {
                    objectNetwork.NatStatement = string.Format("\"{0}\"", value);
                }
                else if (string.IsNullOrEmpty(objectNetwork.NatType))
                {
                    objectNetwork.NatType = value;
                }
                else if (objectNetwork.NatIP == null && string.IsNullOrEmpty(objectNetwork.NatIPAlias))
                {
                    if (!IPAddress.TryParse(value, out natIP))
                    {
                        objectNetwork.NatIPAlias = value;
                    }
                    else
                    {
                        objectNetwork.NatIP = natIP;
                    }
                }
                else
                {
                    objectNetwork.NatPorts.Add(value); //TODO: Figure out how we want to display this information...
                }
            }
        }