public static async Task <IEnumerable <Item> > GetData(int page, int category)
{
string url = string.Format(address, GetCategory(category), page);
var doc = new HtmlDocument();
doc.LoadHtml(await NetworkUtilities.LoadData(url, 65001));
var findclasses = doc.DocumentNode
.Descendants("div")
.Where(d =>
d.Attributes.Contains("class")
&&
d.Attributes["class"].Value.Contains("f_news")
);
List <Item> NList = new List <Item>();
foreach (var element in findclasses)
{
Item item = new Item
{
Title = element.ChildNodes[0].ChildNodes[1].InnerText,
Picture = @"http://faragency.bg/" + element.ChildNodes[0].ChildNodes[0].Attributes["src"].Value,
Date = element.ChildNodes[1].ChildNodes[0].InnerText.Replace(".", "/"),
Description = element.ChildNodes[2].InnerText.Replace("/r/n", ""),
Link = @"http://faragency.bg/" + element.ChildNodes[0].Attributes["href"].Value
};
NList.Add(item);
}
return(NList);
}
private void MainForm_Load(object sender, EventArgs e)
{
if (Sensor1IpAddress.Text != null && NetworkUtilities.ValidateIPAddress(Sensor1IpAddress.Text, true))
{
NetworkUtilities.ParseAddressWithPort(Sensor1IpAddress.Text, out string ip, out int port);
controller.ConnectToSensor1(ip, port, buffersize);
Sensor1ConnectionStatus.BackColor = Color.Gold;
Sensor1ConnectionStatus.Text = "Testing...";
Sensor1IpAddress.Enabled = false;
}
if (Sensor2IpAddress.Text != null && NetworkUtilities.ValidateIPAddress(Sensor2IpAddress.Text, true))
{
NetworkUtilities.ParseAddressWithPort(Sensor2IpAddress.Text, out string ip, out int port);
controller.ConnectToSensor2(ip, port, buffersize);
Sensor2ConnectionStatus.BackColor = Color.Gold;
Sensor2ConnectionStatus.Text = "Testing...";
Sensor2IpAddress.Enabled = false;
}
if (Robot1IpAddress.Text != string.Empty && Robot2IpAddress.Text != string.Empty && RobotServerPort.Text != string.Empty)
{
if (NetworkUtilities.ValidateIPAddress(Robot1IpAddress.Text, false) && NetworkUtilities.ValidateIPAddress(Robot2IpAddress.Text, false))
{
int port = Convert.ToInt32(RobotServerPort.Text);
controller.Robot1IpAddress = Robot1IpAddress.Text;
controller.Robot2IpAddress = Robot2IpAddress.Text;
controller.StartRobotServer(port, buffersize);
RobotConnectionSave.BackColor = Color.OliveDrab;
RobotConnectionSave.ForeColor = Color.White;
RobotConnectionSave.Text = "Server Started";
RobotConnectionSave.Enabled = false;
}
}
}
public override Result DecodeRequest()
{
var decodeRequest = base.DecodeRequest();
if (decodeRequest.Failure)
{
return(decodeRequest);
}
var nextReadIndex = 1;
var localIpLen = BitConverter.ToInt32(RequestBytes, nextReadIndex);
nextReadIndex += Constants.SizeOfInt32InBytes;
var localIp = Encoding.UTF8.GetString(RequestBytes, nextReadIndex, localIpLen);
nextReadIndex += localIpLen + Constants.SizeOfInt32InBytes;
PortNumber = BitConverter.ToInt32(RequestBytes, nextReadIndex);
nextReadIndex += Constants.SizeOfInt32InBytes + Constants.SizeOfInt32InBytes;
var platformBytes = BitConverter.ToInt32(RequestBytes, nextReadIndex).ToString();
Platform = (ServerPlatform)Enum.Parse(typeof(ServerPlatform), platformBytes);
nextReadIndex += Constants.SizeOfInt32InBytes;
var publicIpLen = BitConverter.ToInt32(RequestBytes, nextReadIndex);
nextReadIndex += Constants.SizeOfInt32InBytes;
var publicIp = Encoding.UTF8.GetString(RequestBytes, nextReadIndex, publicIpLen);
nextReadIndex += publicIpLen;
var transferFolderPathLen = BitConverter.ToInt32(RequestBytes, nextReadIndex);
nextReadIndex += Constants.SizeOfInt32InBytes;
TransferFolderPath = Encoding.UTF8.GetString(RequestBytes, nextReadIndex, transferFolderPathLen);
LocalIpAddress = IPAddress.None;
PublicIpAddress = IPAddress.None;
var parseLocalIp = NetworkUtilities.ParseSingleIPv4Address(localIp);
if (parseLocalIp.Success)
{
LocalIpAddress = parseLocalIp.Value;
}
var parsePublicIp = NetworkUtilities.ParseSingleIPv4Address(publicIp);
if (parsePublicIp.Success)
{
PublicIpAddress = parsePublicIp.Value;
}
return(Result.Ok());
}
public async Task <bool> CheckUdpHolePunchingAvailable()
{
if (!_remoteConnectionInformation.UdpConnectionInformation.IsHolePunchingPossible)
{
return(false);
}
return(await Task.Run(() =>
{
var ipAddress = NetworkUtilities.GetLanIp();
using (var socket = new Socket(SocketType.Dgram, ProtocolType.Udp))
{
socket.Bind(new IPEndPoint(ipAddress, 3478));
IPEndPoint ipEndPoint;
if (SessionTraversalUtilitiesForNAT.IsHolePunchingPossible(socket, out ipEndPoint))
{
return true;
}
socket.Close();
}
return false;
}));
}
private void btnScan_Click_1(object sender, EventArgs e)
{
if (_hostScanner.IsScanning)
{
_hostScanner.Cancel();
ChangeScanState(ScanState.Cancel);
}
else
{
List <IpV4Address> range;
if (rbtnCustomRange.Checked)
{
try
{
range = NetworkUtilities.GetIpRange(tbIpRange.Text);
}
catch (FormatException)
{
MessageBox.Show("IP range string is invalid.", "Scan Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
else
{
range = _networkInfo.SubnetRange;
}
ChangeScanState(ScanState.Scan);
_hostScanner.Scan(range);
}
}
/// <summary>
/// Generar y/o utilizar un certificado generado automaticamente
/// </summary>
public static void AutoGenerateCertificate()
{
IPAddress main = NetworkUtilities.GetMainLocalIPAddress();
Debug.WriteLine("SSLAutogen", "Revisando certificado SSL para dirección IP principal: " + main.ToString(), VerbosityLevel.Info);
CheckAutoGenerateCertificate(main);
}
public void TransmitIP()
{
// Send local IPAddress for device to communicate back.
byte[] bytes = EncodeUtilities.EncodeData("IPADDRESS", NetworkUtilities.LocalIPAddress(), out string currentMessage);
this.udpSender.QueueUpData(bytes);
//bool success = connect.udpSender.flagSuccess;
}
internal static void Check()
{
if (PlayerPrefs.GetInt("QModManager_EnableUpdateCheck", 1) == 0)
{
Logger.Info("Update check disabled");
return;
}
if (!NetworkUtilities.CheckConnection())
{
Logger.Warn("Cannot check for updates, internet disabled");
return;
}
ServicePointManager.ServerCertificateValidationCallback = NetworkUtilities.CustomSCVC;
using (WebClient client = new WebClient())
{
client.DownloadStringCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Error("There was an error retrieving the latest version from GitHub!");
Logger.Exception(e.Error);
return;
}
Parse(e.Result);
};
Logger.Debug("Getting the latest version...");
client.DownloadStringAsync(new Uri(VersionURL));
}
}
public void RunBeforeEveryTest()
{
_utility = new NetworkUtilities();
_testConnectionServer = new TcpConnectionServer(_utility.GetLocalIPAddress(), 8080);
_testScheduler = new CommandScheduler();
_testServer = new EditorConnectionServer(_testConnectionServer, _testScheduler, 15000);
}
/// <summary>
/// Calculate the route for a set of coordinates
/// </summary>
public static OSMResponse CalculateRoute(String osrmAddress, IEnumerable <Coordinate> coords)
{
// Get initial response
var response = NetworkUtilities.JsonRequest <OSMResponse>(
new Uri(osrmAddress + MakeRouteAction(coords)));
// process response
// here i used a linq expression instead of foreach loop
// this part is dependent on System.Linq namespace!
response.Route_Instructions = (
from objs in response.Raw_Route select new OSMInstruction(objs)).ToArray();
var alt_instructions = new List <AlternativeInstructions>();
foreach (var instSet in response.Raw_Alternatives)
{
var i = new OSMInstruction[instSet.Length];
for (int j = 0; j < instSet.Length; j++)
{
i[j] = new OSMInstruction(instSet[j]);
}
var alt = new AlternativeInstructions();
alt.Instructions = i;
alt_instructions.Add(alt);
}
response.Alternative_Instructions = alt_instructions.ToArray();
// another linq shorthand
response.Via_Points = (from raw_coord in response.Raw_Via
select
new Coordinate(Convert.ToDouble(raw_coord[0]), Convert.ToDouble(raw_coord[1]))).ToArray();
return(response);
}
public static async Task <IEnumerable <object> > GetData()
{
var doc = new HtmlDocument();
doc.LoadHtml(await NetworkUtilities.LoadData(url, 65001));
var panes = doc.DocumentNode
.Descendants("table")
.First(x => x.Attributes.Contains("class") && x.Attributes["class"].Value.Contains("blog"))
.Descendants("div")
.Where(x => x.Attributes.Contains("class") && x.Attributes["class"].Value.Contains("contentpaneopen"));
var data = panes.Select(pane =>
{
var heading = pane.ChildNodes.First(child =>
child.Attributes.Contains("class") &&
child.Attributes["class"].Value.Contains("contentheading"));
var content = pane.ChildNodes.First(child =>
child.Attributes.Contains("class") &&
child.Attributes["class"].Value.Contains("article-content"));
return(new
{
Title = TextUtilities.ExtractText(heading),
Content = TextUtilities.ExtractText(content)
});
});
return(data);
}
public void StartGame()
{
//first player
StartGameMessage startGameMessage = new StartGameMessage()
{
playerData = NetworkUtilities.GetNetPlayerData(players[0]),
opponentData = NetworkUtilities.GetNetPlayerData(players[1])
};
SendNetMessage(ref m_Driver, players[0].m_connenction, startGameMessage);
//second player
startGameMessage = new StartGameMessage()
{
playerData = NetworkUtilities.GetNetPlayerData(players[1]),
opponentData = NetworkUtilities.GetNetPlayerData(players[0])
};
SendNetMessage(ref m_Driver, players[1].m_connenction, startGameMessage);
currentPlayer = players.IndexOf(players.Find(x => x.guid == 0));
gameStarted = true;
}
private static IEnumerable <byte> Build(SystemWrapper.IO.IFileInfoWrap file)
{
var sha = new SHA256Managed();
var createDate = Encoding.ASCII.GetBytes(file.CreationTime.ToString(CultureInfo.InvariantCulture));
var createDateChecksum = sha.ComputeHash(createDate);
var modifyDate = Encoding.ASCII.GetBytes(file.LastWriteTime.ToString(CultureInfo.InvariantCulture));
var modifyDateChecksum = sha.ComputeHash(modifyDate);
var fileName = Encoding.ASCII.GetBytes(file.Name);
var fileNameChecksum = sha.ComputeHash(fileName);
// TODO: Verifiy if including file data (expensive operation) is necessary
byte[] fileChecksum;
using (var fileStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var bufferedStream = new BufferedStream(fileStream.StreamInstance, 64 * 1000))
{
fileChecksum = sha.ComputeHash(bufferedStream);
}
}
var networkId = Encoding.ASCII.GetBytes(NetworkUtilities.GetNetworkId());
var networkIdChecksum = sha.ComputeHash(networkId);
var checksumSum = createDateChecksum.Concat(modifyDateChecksum).Concat(fileNameChecksum).Concat(fileChecksum).Concat(networkIdChecksum);
var checksum = sha.ComputeHash(checksumSum.ToArray());
return(checksum);
}
private void Robot2IpAddress_TextChanged(object sender, EventArgs e)
{
if (NetworkUtilities.ValidateIPAddress(Robot2IpAddress.Text, false))
{
controller.Robot1IpAddress = Robot2IpAddress.Text;
}
}
private static void OpenClientEvent(object sender, EventArgs e)
{
var ip = NetworkUtilities.GetIPv4Address();
var httpPort = HttpServer.GlobalPort;
Process.Start($"http://{ip}:{httpPort}");
}
public void LoadNetZone(RuntimeZone _localZone, NetZone _netZone, PlayerData _ownerPlayer)
{
//remove any illegal cards
for (int i = 0; i < _localZone.cards.Count; i++)
{
RuntimeCard _card = _localZone.cards[i];
if (Array.Exists(_netZone.cards, x => x.unique_cardId == _card.guid) == false)
{
//remove the card
StartCoroutine(GameScene.Active.ShowPlayerMessage("Developer Warning:: The Server Reverted A Move"));
_localZone.RemoveCard(_card.guid);
}
}
//add any new cards
for (int i = 0; i < _netZone.cards.Length; i++)
{
NetCard _card = _netZone.cards[i];
RuntimeCard _localCard = _localZone.cards.Find(x => x.guid == _card.unique_cardId);
if (_localCard == null)
{
//add the card
_localZone.AddCard(NetworkUtilities.GetRuntimeCard(_card, _ownerPlayer));
}
}
}
public void RunBeforeEveryTest()
{
var networkUtilities = new NetworkUtilities();
_localIpAddress = networkUtilities.GetLocalIPAddress();
_server = new TcpConnectionServer(_localIpAddress, 15845);
}
public static bool CidrIpHasChanged(AppState state)
{
var getCidrIp = NetworkUtilities.GetCidrIp();
if (getCidrIp.Failure)
{
return(false);
}
var newCidrIp = getCidrIp.Value;
var cidrIpMatch = state.Settings.LocalNetworkCidrIp == newCidrIp;
if (cidrIpMatch)
{
return(false);
}
var prompt =
"The current value for CIDR IP is " +
$"{state.Settings.LocalNetworkCidrIp}, however it appears " +
$"that {newCidrIp} is the correct value for the current LAN, " +
"would you like to use this value?";
var updateCidrIp = PromptUserYesOrNo(state, prompt);
if (!updateCidrIp)
{
return(false);
}
state.Settings.LocalNetworkCidrIp = newCidrIp;
return(true);
}
public void VerifyIpAddressIsInCidrRange()
{
var cidrRange1 = "192.168.2.0/24";
var cidrRange2 = "10.2.0.0/8";
var ip1 = "192.168.2.2";
var ip2 = "192.169.2.2";
var ip3 = "192.168.3.2";
var ip4 = "10.168.2.2";
var ip5 = "10.2.0.2";
var ip6 = "1.1.1.1";
var ip7 = "71.94.90.29";
var checkIp1InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip1, cidrRange1);
var checkIp2InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip2, cidrRange1);
var checkIp3InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip3, cidrRange1);
var checkIp4InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip4, cidrRange1);
var checkIp5InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip5, cidrRange1);
var checkIp6InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip6, cidrRange1);
var checkIp7InCidrRange1 = NetworkUtilities.IpAddressIsInRange(ip7, cidrRange1);
var checkIp1InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip1, cidrRange2);
var checkIp2InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip2, cidrRange2);
var checkIp3InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip3, cidrRange2);
var checkIp4InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip4, cidrRange2);
var checkIp5InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip5, cidrRange2);
var checkIp6InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip6, cidrRange2);
var checkIp7InCidrRange2 = NetworkUtilities.IpAddressIsInRange(ip7, cidrRange2);
Assert.IsTrue(checkIp1InCidrRange1.Success);
Assert.IsTrue(checkIp1InCidrRange1.Value);
Assert.IsTrue(checkIp2InCidrRange1.Success);
Assert.IsFalse(checkIp2InCidrRange1.Value);
Assert.IsTrue(checkIp3InCidrRange1.Success);
Assert.IsFalse(checkIp3InCidrRange1.Value);
Assert.IsTrue(checkIp4InCidrRange1.Success);
Assert.IsFalse(checkIp4InCidrRange1.Value);
Assert.IsTrue(checkIp5InCidrRange1.Success);
Assert.IsFalse(checkIp5InCidrRange1.Value);
Assert.IsTrue(checkIp6InCidrRange1.Success);
Assert.IsFalse(checkIp6InCidrRange1.Value);
Assert.IsTrue(checkIp7InCidrRange1.Success);
Assert.IsFalse(checkIp7InCidrRange1.Value);
Assert.IsTrue(checkIp1InCidrRange2.Success);
Assert.IsFalse(checkIp1InCidrRange2.Value);
Assert.IsTrue(checkIp2InCidrRange2.Success);
Assert.IsFalse(checkIp2InCidrRange2.Value);
Assert.IsTrue(checkIp3InCidrRange2.Success);
Assert.IsFalse(checkIp3InCidrRange2.Value);
Assert.IsTrue(checkIp4InCidrRange2.Success);
Assert.IsTrue(checkIp4InCidrRange2.Value);
Assert.IsTrue(checkIp5InCidrRange2.Success);
Assert.IsTrue(checkIp5InCidrRange2.Value);
Assert.IsTrue(checkIp6InCidrRange2.Success);
Assert.IsFalse(checkIp6InCidrRange2.Value);
Assert.IsTrue(checkIp7InCidrRange2.Success);
Assert.IsFalse(checkIp7InCidrRange2.Value);
}
public void ConnectHost(string username, JeffistanceMessageProcessor messageProcessor)
{
username = string.IsNullOrWhiteSpace(username) ? DEFAULT_HOST_NAME : username;
Host.Name = username;
Host.Connect(NetworkUtilities.GetLocalIPAddress(), Connection.PORT_NO);
Host.AttachMessageHandler(new MessageHandler(messageProcessor, Host.Connection));
Host.GreetServer();
}
public static Result <bool> IsInRange(this IPAddress ip, string cidrIp)
{
var checkRangeResult = NetworkUtilities.IpAddressIsInRange(ip, cidrIp);
return(checkRangeResult.Success
? Result.Ok(checkRangeResult.Value)
: Result.Fail <bool>(checkRangeResult.Error));
}
public void Start()
{
Core.Instance.Log.Info("Starting EnhancedRestoreChunkConnInfoService");
Core.Instance.MCChannel.Received
.Where(message => message.MessageType == Messages.MessageType.ConnInfo)
.Cast <ConnInfoMessage>().Where(message => NetworkUtilities.GetLocalIPAddresses().Contains(message.PassiveIP))
.Subscribe(this);
}
public void RunBeforeEveryTest()
{
var networkUtilities = new NetworkUtilities();
_localIpAddress = networkUtilities.GetLocalIPAddress();
_server = new TcpConnectionServer(_localIpAddress, 15845);
_testClient = Substitute.For <IConnectionClient>();
}
public void GetAvailableTcpPortTest()
{
int Port = NetworkUtilities.GetAvailableTcpPort();
var Listener = new TcpListener(IPAddress.Parse("127.0.0.1"), Port);
Listener.Start();
Listener.Stop();
}
/// <summary>
/// Confirm the IP address retrieved isn't the
/// loopback address.
/// </summary>
public void GetIpAddressTest()
{
const string localhost = "127.0.0.1";
string ip;
Assert.AreNotEqual(localhost, ip = NetworkUtilities.GetIPv4Address());
DebugUtilities.Log(TAG + ip);
}
/* Private methods */
/// <summary>
/// Private constructor that prevents initialisation
/// of an instance of UCServer by using the default
/// constructor.
/// </summary>
private UCServer(int port, int maxConn)
{
serverSocket = NetworkUtilities.InitSocketServer(
NetworkUtilities.GetIPv4Address(),
port);
clients = new Socket[maxConn];
}
private void Sensor2ConnectionStatus_Click(object sender, EventArgs e)
{
NetworkUtilities.ParseAddressWithPort(Sensor2IpAddress.Text, out string ip, out int port);
controller.ConnectToSensor2(ip, port, buffersize);
Sensor2ConnectionStatus.BackColor = Color.Gold;
Sensor2ConnectionStatus.Text = "Testing...";
Sensor2IpAddress.Enabled = false;
}
private void InvalidCommand(Socket socket, string cmd)
{
DebugUtilities.Log(
msg: UCCommand.InvalidCmd + " {" + cmd + "}",
type: LogType.Error
);
NetworkUtilities.Send(socket, UCCommand.InvalidCmd);
}
public void RunBeforeEveryTest()
{
var networkUtilities = new NetworkUtilities();
_localIpAddress = networkUtilities.GetLocalIPAddress();
_testPort = 15987;
_testListener = new TcpConnectionServer(_localIpAddress, _testPort);
_testListener.StartServer();
}
private void SpoofLoop(CancellationToken token)
{
var sourcePhysicalAddress = _networkInfo.Interface.GetNetworkInterface().GetPhysicalAddress();
while (!token.IsCancellationRequested)
{
List <Host> hosts;
lock (_spoofedHostsLock)
hosts = new List <Host>(_spoofedHosts);
foreach (var host in hosts)
{
var gatewayPacket = PacketBuilder.Build(
DateTime.Now,
new EthernetLayer()
{
EtherType = EthernetType.None,
Source = NetworkUtilities.PhysicalAddressToMacAddress(sourcePhysicalAddress),
Destination = _networkInfo.GatewayMac,
},
new ArpLayer()
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Reply,
SenderProtocolAddress = host.IpAddress.ToBytes(),
SenderHardwareAddress = sourcePhysicalAddress.GetAddressBytes().AsReadOnly(),
TargetProtocolAddress = _networkInfo.GatewayIp.ToBytes(),
TargetHardwareAddress = _networkInfo.GatewayMac.ToBytes(),
}
);
var targetPacket = PacketBuilder.Build(
DateTime.Now,
new EthernetLayer()
{
EtherType = EthernetType.None,
Source = NetworkUtilities.PhysicalAddressToMacAddress(sourcePhysicalAddress),
Destination = host.MacAddress,
},
new ArpLayer()
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Reply,
SenderProtocolAddress = _networkInfo.GatewayIp.ToBytes(),
SenderHardwareAddress = sourcePhysicalAddress.GetAddressBytes().AsReadOnly(),
TargetProtocolAddress = host.IpAddress.ToBytes(),
TargetHardwareAddress = host.MacAddress.ToBytes(),
}
);
_networkInfo.Communicator.SendPacket(gatewayPacket);
_networkInfo.Communicator.SendPacket(targetPacket);
}
Thread.Sleep(Config.SpoofSendInterval);
}
}
