Program.cs - master - dalek/IP-Address-Lister

Program.cs
378 строк11 KB
dalek
update: Program.cs
04 май 2026, 12:49
04 май 2026, 12:498d1426e
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using System.Xml.Linq;

namespace IpAddressLister
{
	class Program
	{
		// Сравнивает символы по байтам
		private const StringComparison ordinalIgnoreCase = StringComparison.OrdinalIgnoreCase;

		// Словарь допустимых параметров и их возможных вариантов (опечаток)
		private static readonly Dictionary<string, string[]> ParameterAliases = new()
		{
			["-help"] = ["-h", "-hlp", "/?", "/h"],
			["-text"] = ["-t", "-txt", "-tex"],
			["-json"] = ["-j", "-jsn"],
			["-xml"] = ["-x", "-xl"],
			["-ipall"] = ["-all", "-iall", "-ial"],
			["-ipv4"] = ["-ip4", "-i4", "-ivp4", "-ip"],
			["-ipv6"] = ["-ip6", "-i6", "-ivp6"],
			["-ipvirtual"] = ["-ipvirt", "-ipv", "-virtual"],
			["-iplb"] = ["-ilb", "-lb"]
		};

		static int Main(string[] args)
		{
			// Нормализуем параметры перед обработкой
			string[] normalizedArgs = NormalizeArguments(args);

			// Если нет параметров или запрошена справка
			if (normalizedArgs.Length == 0 ||
				normalizedArgs.Contains("-help") ||
				normalizedArgs.Contains("-h") ||
				normalizedArgs.Contains("/?") ||
				normalizedArgs.Contains("/h"))
			{
				ShowHelp();

				return 0;
			}

			// Парсим параметры
			Parameters parameters = ParseArguments(normalizedArgs);

			try
			{
				List<string> ipList = GetIpAddresses(parameters);

				switch (parameters.Format)
				{
					case "-text":
						OutputAsText(ipList);
						break;
					case "-json":
						OutputAsJson(ipList);
						break;
					case "-xml":
						OutputAsXml(ipList);
						break;
					default:
						Console.Error.WriteLine($"Ошибка: Неизвестный параметр");
						Console.Error.WriteLine("Используйте -help, -h для получения справки");
						return 1;
				}

				return 0;
			}
			catch (Exception ex)
			{
				Console.Error.WriteLine($"Ошибка: {ex.Message}");

				return 1;
			}
		}

		class Parameters
		{
			public string Format { get; set; } = "-text";
			public bool IncludeIPall { get; set; } = false;
			public bool IncludeIPv4 { get; set; } = true;
			public bool IncludeIPv6 { get; set; } = false;
			public bool IncludeIPvirtual { get; set; } = false;
			public bool IncludeLoopback { get; set; } = false;
		}

		static Parameters ParseArguments(string[] args)
		{
			Parameters parameters = new();

			foreach (string arg in args)
			{
				string lowerArg = arg.ToLower();

				switch (lowerArg)
				{
					case "-text":
						break;
					case "-json":
						parameters.Format = "-json";
						break;
					case "-xml":
						parameters.Format = "-xml";
						break;
					case "-ipall":
						parameters.IncludeIPall = true;
						parameters.IncludeIPv4 = true;
						parameters.IncludeIPv6 = true;
						parameters.IncludeIPvirtual = true;
						parameters.IncludeLoopback = true;
						break;
					case "-ipv4":
						parameters.IncludeIPv4 = true;
						break;
					case "-ipv6":
						parameters.IncludeIPv6 = true;
						break;
					case "-ipvirtual":
						parameters.IncludeIPvirtual = true;
						break;
					case "-iplb":
						parameters.IncludeLoopback = true;
						break;
				}
			}

			// Настройки вывода
			if (parameters.IncludeIPall)
			{
				if (args.Any(a => a.Equals("-ipv4", ordinalIgnoreCase)))
				{
					parameters.IncludeIPv6 = false;
					parameters.IncludeIPvirtual = true;
					parameters.IncludeLoopback = false;
				}
				if (args.Any(a => a.Equals("-ipv6", ordinalIgnoreCase)))
				{
					parameters.IncludeIPv4 = false;
					parameters.IncludeIPvirtual = true;
					parameters.IncludeLoopback = false;
				}
				if (args.Any(a => a.Equals("-ipvirtual", ordinalIgnoreCase)))
				{
					parameters.IncludeIPvirtual = false;
					parameters.IncludeLoopback = false;
				}
				if (args.Any(a => a.Equals("-iplb", ordinalIgnoreCase)))
				{
					parameters.IncludeLoopback = true;
				}
			}
			else
			{
				// Если указан -ipv6, но не указан -ipv4, то исключаем IPv4
				if (parameters.IncludeIPv6 && !args.Any(a => a.Equals("-ipv4", ordinalIgnoreCase)))
				{
					parameters.IncludeIPv4 = true;
				}
			}

			return parameters;
		}

		static void ShowHelp()
		{
			Console.WriteLine(@"
----------------------------------------------------------------
--- IP Address Lister ------------------------------------------
----------------------------------------------------------------

Консольное приложение для получения списка IP-адресов устройства

ИСПОЛЬЗОВАНИЕ:
  # Windows
    ./IpAddressLister.exe <ФОРМАТ> [ОПЦИИ]
  # Linux/macOS
    ./IpAddressLister <ФОРМАТ> [ОПЦИИ]

ПАРАМЕТРЫ ФОРМАТА (обязательный, первый параметр):
  -text | Возвращает IP-адреса в виде текстовой строки, разделенной ';' (по умолчанию)
  -json | Возвращает IP-адреса в формате JSON (массив строк)
  -xml  | Возвращает IP-адреса в формате XML

ПАРАМЕТРЫ ОПЦИЙ:
  -ipall     | Включать все IP адреса
  -ipv4      | Включать IPv4 адреса (по умолчанию)
  -ipv6      | Включать IPv6 адреса
  -ipvirtual | Включать виртуальные IP адреса
  -iplb      | Включать loopback адреса 127.0.0.1 и ::1

ПРИМЕЧАНИЯ:
  - Выводятся только IP адреса активных сетевых интерфейсов
  - По умолчанию выводятся только IPv4 адреса
  - Виртуальные IP адреса исключаются, если не указан параметр -ipvirtual
  - Loopback IP адреса (127.0.0.1, ::1) исключаются, если не указан параметр -iplb
  - Для вывода всех IP адресов используйте параметр -ipall
  - Если указан флаг -ipv6 без -ipv4, IPv4 адреса исключаются
  - Приложение возвращает только список IP-адресов

ПРИМЕРЫ ИСПОЛЬЗОВАНИЯ:
  # Все IP адреса:
    ./IpAddressLister -text -ipall
  # Только IPv4 адреса (по умолчанию):
    ./IpAddressLister -text
    ./IpAddressLister -text -ipv4
  # Только IPv6 адреса:
    ./IpAddressLister -text -ipv6
  # Все IP адреса (IPv4 + IPv6), исключая Loopback:
    ./IpAddressLister -text -ipv4 -ipv6
  # Включая Loopback IP адреса:
    ./IpAddressLister -text -iplb

  # Формат вывода IP адресов
  # TEXT формат:
    ./IpAddressLister -text
  # JSON формат:
    ./IpAddressLister -json
  # XML формат:
    ./IpAddressLister -xml

ИСПОЛЬЗОВАНИЕ В СКРИПТАХ:
  # Bash:
    IPS=$(./IpAddressLister -text)
    IFS=';' read -ra IP_ARRAY <<< ""$IPS""
    for ip in ""${IP_ARRAY[@]}""; do
       echo ""IP: $ip""
    done
  # PowerShell (Linux):
    $ips = & ""./IpAddressLister"" -text
    $ips -split ';'

ВОЗВРАЩАЕМЫЕ КОДЫ:
  0 - Успешное выполнение
  1 - Ошибка выполнения
");
		}

		static List<string> GetIpAddresses(Parameters parameters)
		{
			List<string> ipList = [];

			foreach (NetworkInterface networkInterface in NetworkInterface.GetAllNetworkInterfaces())
			{
				// Фильтрация неактивные интерфейсы
				if (networkInterface.OperationalStatus != OperationalStatus.Up)
				{
					continue;
				}

				// Фильтрация виртуальных интерфейсов
				if (!parameters.IncludeIPvirtual)
				{
					string name = networkInterface.Name.ToLower();

					if (name.StartsWith("veth") ||
						name.StartsWith("docker") ||
						name.StartsWith("br-") ||
						name.StartsWith("virbr"))
					{
						continue;
					}
				}

				// Фильтрация виртуальных интерфейсов для Linux
				//if (Environment.OSVersion.Platform == PlatformID.Unix)
				//{
				//}

				foreach (UnicastIPAddressInformation ip in networkInterface.GetIPProperties().UnicastAddresses)
				{
					bool isIPv4 = ip.Address.AddressFamily == AddressFamily.InterNetwork;
					bool isIPv6 = ip.Address.AddressFamily == AddressFamily.InterNetworkV6;
					bool isLoopback = IPAddress.IsLoopback(ip.Address);

					// Фильтрация loopback, если не разрешено
					if (isLoopback && !parameters.IncludeLoopback)
					{
						continue;
					}

					// Добавляем адрес в зависимости от параметров
					if ((isIPv4 && parameters.IncludeIPv4) ||
						(isIPv6 && parameters.IncludeIPv6))
					{
						ipList.Add(ip.Address.ToString());
					}
				}
			}

			return [.. ipList.Distinct().OrderBy(ip => ip)];
		}

		static void OutputAsText(List<string> ipList)
		{
			Console.Write(string.Join(";", ipList));
		}

		static void OutputAsJson(List<string> ipList)
		{
			StringBuilder stringBuilder = new();

			stringBuilder.Append('[');

			for (int i = 0; i < ipList.Count; i++)
			{
				stringBuilder.Append($"\"{ipList[i]}\"");

				if (i < ipList.Count - 1)
				{
					stringBuilder.Append(',');
				}
			}

			stringBuilder.Append(']');

			Console.Write(stringBuilder.ToString());
		}

		static void OutputAsXml(List<string> ipList)
		{
			XDocument xml = new(
				new XDeclaration("1.0", "utf-8", null),
				new XElement("ipaddresses", ipList.Select(ip => new XElement("ip", ip)))
			);

			Console.Write(xml.ToString());
		}

		static string[] NormalizeArguments(string[] args)
		{
			string[] normalized = new string[args.Length];

			for (int i = 0; i < args.Length; i++)
			{
				string arg = args[i].ToLowerInvariant();

				// Проверяем, является ли параметр одним из допустимых
				if (ParameterAliases.Keys.Any(k => k.Equals(arg, ordinalIgnoreCase)))
				{
					// Параметр правильный, оставляем как есть в нижнем регистре
					normalized[i] = arg;

					continue;
				}

				// Ищем совпадение среди алиасов вариантов (опечаток)
				string matchedParam = "";

				foreach (var kvp in ParameterAliases)
				{
					if (kvp.Value.Any(alias => alias.Equals(arg, ordinalIgnoreCase)))
					{
						// Возвращаем правильный вариант
						matchedParam = kvp.Key;

						//Console.WriteLine($"Исправлено: '{args[i]}' → '{matchedParam}'");

						break;
					}
				}

				if (matchedParam != null)
				{
					normalized[i] = matchedParam;
				}
				else
				{
					// Оставляем как есть (не параметр, значение или неизвестный параметр)
					normalized[i] = args[i];
				}
			}

			return normalized;
		}
	}
}