public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, string zoneName, uint appRecordTtl, string appRecordData, bool isRecursionAllowed, IDnsServer dnsServer)
{
switch (request.Question[0].Type)
{
case DnsResourceRecordType.A:
case DnsResourceRecordType.AAAA:
dynamic jsonAppRecordData = JsonConvert.DeserializeObject(appRecordData);
dynamic jsonAddresses;
if (NetUtilities.IsPrivateIP(remoteEP.Address))
{
jsonAddresses = jsonAppRecordData.@private;
}
else
{
jsonAddresses = jsonAppRecordData.@public;
}
if (jsonAddresses == null)
{
return(Task.FromResult <DnsDatagram>(null));
}
List <DnsResourceRecord> answers = new List <DnsResourceRecord>();
foreach (dynamic jsonAddress in jsonAddresses)
{
IPAddress address = IPAddress.Parse(jsonAddress.Value);
switch (request.Question[0].Type)
{
case DnsResourceRecordType.A:
if (address.AddressFamily == AddressFamily.InterNetwork)
{
answers.Add(new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.A, DnsClass.IN, appRecordTtl, new DnsARecord(address)));
}
break;
case DnsResourceRecordType.AAAA:
if (address.AddressFamily == AddressFamily.InterNetworkV6)
{
answers.Add(new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.AAAA, DnsClass.IN, appRecordTtl, new DnsAAAARecord(address)));
}
break;
}
}
if (answers.Count == 0)
{
return(Task.FromResult <DnsDatagram>(null));
}
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, answers)));
default:
return(Task.FromResult <DnsDatagram>(null));
}
}
private void RelayConnectionKeepAliveTimerCallback(object state)
{
try
{
bool lessRelayNodesAvailable;
//send noop to all connections to keep them alive
lock (_tcpRelayConnections)
{
foreach (Connection relayConnection in _tcpRelayConnections.Values)
{
ThreadPool.QueueUserWorkItem(SendNOOPAsync, relayConnection);
}
lessRelayNodesAvailable = (_tcpRelayConnections.Count < TCP_RELAY_MAX_CONNECTIONS);
}
//if less number of relay node connections available, try to find new relay nodes
if (lessRelayNodesAvailable)
{
IPEndPoint[] nodeEPs = _connectionManager.IPv4DhtNode.GetKClosestRandomNodeEPs();
foreach (IPEndPoint relayNodeEP in nodeEPs)
{
lock (_tcpRelayConnections)
{
if (_tcpRelayConnections.Count >= TCP_RELAY_MAX_CONNECTIONS)
{
return;
}
if (_tcpRelayConnections.ContainsKey(relayNodeEP))
{
continue;
}
}
if (NetUtilities.IsPrivateIP(relayNodeEP.Address))
{
continue;
}
ThreadPool.QueueUserWorkItem(ConnectTcpRelayNodeAsync, relayNodeEP);
}
}
}
catch
{ }
finally
{
if (_tcpRelayConnectionKeepAliveTimer != null)
{
_tcpRelayConnectionKeepAliveTimer.Change(TCP_RELAY_KEEP_ALIVE_INTERVAL, Timeout.Infinite);
}
}
}
public void AddNode(IPEndPoint nodeEP)
{
if (!NetUtilities.IsPrivateIP(nodeEP.Address))
{
if (!_routingTable.ContactExists(nodeEP))
{
ThreadPool.QueueUserWorkItem(AddNodeAfterPingAsync, nodeEP);
}
}
}
public void AddNode(NodeContact contact)
{
if (!NetUtilities.IsPrivateIP(contact.NodeEP.Address) && (contact.NodeEP.AddressFamily == _currentNode.NodeEP.AddressFamily))
{
if (_routingTable.AddContact(contact))
{
ThreadPool.QueueUserWorkItem(delegate(object state)
{
Query(DhtRpcPacket.CreatePingPacket(_currentNode), contact);
});
}
}
}
public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, string zoneName, uint appRecordTtl, string appRecordData, bool isRecursionAllowed, IDnsServer dnsServer)
{
dynamic jsonAppRecordData = JsonConvert.DeserializeObject(appRecordData);
dynamic jsonCname;
if (NetUtilities.IsPrivateIP(remoteEP.Address))
{
jsonCname = jsonAppRecordData.@private;
}
else
{
jsonCname = jsonAppRecordData.@public;
}
if (jsonCname == null)
{
return(Task.FromResult <DnsDatagram>(null));
}
string cname = jsonCname.Value;
if (string.IsNullOrEmpty(cname))
{
return(Task.FromResult <DnsDatagram>(null));
}
IReadOnlyList <DnsResourceRecord> answers;
if (request.Question[0].Name.Equals(zoneName, StringComparison.OrdinalIgnoreCase)) //check for zone apex
{
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.ANAME, DnsClass.IN, appRecordTtl, new DnsANAMERecord(cname)) }
}
; //use ANAME
else
{
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.CNAME, DnsClass.IN, appRecordTtl, new DnsCNAMERecord(cname)) }
};
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, answers)));
}
private bool IsRecursionAllowed(EndPoint remoteEP)
{
if (!_allowRecursion)
{
return(false);
}
if (_allowRecursionOnlyForPrivateNetworks)
{
switch (remoteEP.AddressFamily)
{
case AddressFamily.InterNetwork:
case AddressFamily.InterNetworkV6:
return(NetUtilities.IsPrivateIP((remoteEP as IPEndPoint).Address));
default:
return(false);
}
}
return(true);
}
private IPAddress GetRequestRemoteAddress(HttpContext context)
{
try
{
if (NetUtilities.IsPrivateIP(context.Connection.RemoteIpAddress))
{
//reverse proxy X-Real-IP header supported only when remote IP address is private
string xRealIp = context.Request.Headers["X-Real-IP"];
if (!string.IsNullOrEmpty(xRealIp))
{
//get the real IP address of the requesting client from X-Real-IP header set in nginx proxy_pass block
return(IPAddress.Parse(xRealIp));
}
}
return(context.Connection.RemoteIpAddress);
}
catch
{
return(IPAddress.Any);
}
}
private IPEndPoint GetRequestRemoteEndPoint(HttpListenerRequest request)
{
//this is due to mono NullReferenceException issue
try
{
if (NetUtilities.IsPrivateIP(request.RemoteEndPoint.Address))
{
//reverse proxy X-Real-IP header supported only when remote IP address is private
string xRealIp = request.Headers["X-Real-IP"];
if (!string.IsNullOrEmpty(xRealIp))
{
//get the real IP address of the requesting client from X-Real-IP header set in nginx proxy_pass block
return(new IPEndPoint(IPAddress.Parse(xRealIp), 0));
}
}
return(request.RemoteEndPoint);
}
catch
{
return(new IPEndPoint(IPAddress.Any, 0));
}
}
public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, DnsTransportProtocol protocol, bool isRecursionAllowed, string zoneName, uint appRecordTtl, string appRecordData)
{
dynamic jsonAppRecordData = JsonConvert.DeserializeObject(appRecordData);
dynamic jsonCname = null;
foreach (dynamic jsonProperty in jsonAppRecordData)
{
string name = jsonProperty.Name;
if ((name == "public") || (name == "private"))
{
continue;
}
NetworkAddress networkAddress = NetworkAddress.Parse(name);
if (networkAddress.Contains(remoteEP.Address))
{
jsonCname = jsonProperty.Value;
break;
}
}
if (jsonCname is null)
{
if (NetUtilities.IsPrivateIP(remoteEP.Address))
{
jsonCname = jsonAppRecordData.@private;
}
else
{
jsonCname = jsonAppRecordData.@public;
}
if (jsonCname is null)
{
return(Task.FromResult <DnsDatagram>(null));
}
}
string cname = jsonCname.Value;
if (string.IsNullOrEmpty(cname))
{
return(Task.FromResult <DnsDatagram>(null));
}
DnsQuestionRecord question = request.Question[0];
IReadOnlyList <DnsResourceRecord> answers;
if (question.Name.Equals(zoneName, StringComparison.OrdinalIgnoreCase)) //check for zone apex
{
answers = new DnsResourceRecord[] { new DnsResourceRecord(question.Name, DnsResourceRecordType.ANAME, DnsClass.IN, appRecordTtl, new DnsANAMERecordData(cname)) }
}
; //use ANAME
else
{
answers = new DnsResourceRecord[] { new DnsResourceRecord(question.Name, DnsResourceRecordType.CNAME, DnsClass.IN, appRecordTtl, new DnsCNAMERecordData(cname)) }
};
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, answers)));
}
internal void MeshNetworkRequest(Connection connection, BinaryNumber networkId, Stream channel)
{
MeshNetwork network = null;
lock (_networks)
{
if (_networks.ContainsKey(networkId))
{
network = _networks[networkId];
}
}
if (network == null)
{
if (!networkId.Equals(_maskedUserId))
{
//no network found
channel.Dispose();
return;
}
//private network connection invitation attempt
if (!_allowInboundInvitations || (_allowOnlyLocalInboundInvitations && ((connection.RemotePeerEP.AddressFamily == AddressFamily.Unspecified) || !NetUtilities.IsPrivateIP((connection.RemotePeerEP as IPEndPoint).Address))))
{
//not allowed
channel.Dispose();
return;
}
//accept invitation
network = MeshNetwork.AcceptPrivateNetworkInvitation(_connectionManager, connection, channel);
//add network
lock (_networks)
{
_networks.Add(network.NetworkId, network);
}
//notify UI
RaiseEventInvitationReceived(network);
}
else
{
network.AcceptConnectionAndJoinNetwork(connection, channel);
}
}
private void NetworkWatcherAsync(object state)
{
try
{
bool networkChanged = false;
List <NetworkInfo> newNetworks = new List <NetworkInfo>();
{
List <NetworkInfo> currentNetworks = NetUtilities.GetNetworkInfo();
networkChanged = (currentNetworks.Count != _networks.Count);
foreach (NetworkInfo currentNetwork in currentNetworks)
{
if (!_networks.Contains(currentNetwork))
{
networkChanged = true;
newNetworks.Add(currentNetwork);
}
}
_networks.Clear();
_networks.AddRange(currentNetworks);
}
if (networkChanged)
{
lock (_localNetworkDhtManagers)
{
//remove local network dht manager with offline networks
{
List <LocalNetworkDhtManager> localNetworkDhtManagersToRemove = new List <LocalNetworkDhtManager>();
foreach (LocalNetworkDhtManager localNetworkDhtManager in _localNetworkDhtManagers)
{
if (!_networks.Contains(localNetworkDhtManager.Network))
{
localNetworkDhtManagersToRemove.Add(localNetworkDhtManager);
}
}
foreach (LocalNetworkDhtManager localNetworkDhtManager in localNetworkDhtManagersToRemove)
{
localNetworkDhtManager.Dispose();
_localNetworkDhtManagers.Remove(localNetworkDhtManager);
}
}
//add local network dht managers for new online networks
if (newNetworks.Count > 0)
{
foreach (NetworkInfo network in newNetworks)
{
if (IPAddress.IsLoopback(network.LocalIP))
{
continue; //skip loopback networks
}
if (network.LocalIP.AddressFamily == AddressFamily.InterNetworkV6)
{
continue; //skip ipv6 private networks for saving resources
}
if (!NetUtilities.IsPrivateIP(network.LocalIP))
{
continue; //skip public networks
}
_localNetworkDhtManagers.Add(new LocalNetworkDhtManager(network));
Debug.Write(this.GetType().Name, "local network dht manager created: " + network.LocalIP.ToString());
}
}
}
}
}
catch (Exception ex)
{
Debug.Write(this.GetType().Name, ex);
}
}
public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, DnsTransportProtocol protocol, bool isRecursionAllowed, string zoneName, uint appRecordTtl, string appRecordData)
{
DnsQuestionRecord question = request.Question[0];
switch (question.Type)
{
case DnsResourceRecordType.A:
case DnsResourceRecordType.AAAA:
dynamic jsonAppRecordData = JsonConvert.DeserializeObject(appRecordData);
dynamic jsonAddresses = null;
foreach (dynamic jsonProperty in jsonAppRecordData)
{
string name = jsonProperty.Name;
if ((name == "public") || (name == "private"))
{
continue;
}
NetworkAddress networkAddress = NetworkAddress.Parse(name);
if (networkAddress.Contains(remoteEP.Address))
{
jsonAddresses = jsonProperty.Value;
break;
}
}
if (jsonAddresses is null)
{
if (NetUtilities.IsPrivateIP(remoteEP.Address))
{
jsonAddresses = jsonAppRecordData.@private;
}
else
{
jsonAddresses = jsonAppRecordData.@public;
}
if (jsonAddresses is null)
{
return(Task.FromResult <DnsDatagram>(null));
}
}
List <DnsResourceRecord> answers = new List <DnsResourceRecord>();
switch (question.Type)
{
case DnsResourceRecordType.A:
foreach (dynamic jsonAddress in jsonAddresses)
{
IPAddress address = IPAddress.Parse(jsonAddress.Value);
if (address.AddressFamily == AddressFamily.InterNetwork)
{
answers.Add(new DnsResourceRecord(question.Name, DnsResourceRecordType.A, DnsClass.IN, appRecordTtl, new DnsARecordData(address)));
}
}
break;
case DnsResourceRecordType.AAAA:
foreach (dynamic jsonAddress in jsonAddresses)
{
IPAddress address = IPAddress.Parse(jsonAddress.Value);
if (address.AddressFamily == AddressFamily.InterNetworkV6)
{
answers.Add(new DnsResourceRecord(question.Name, DnsResourceRecordType.AAAA, DnsClass.IN, appRecordTtl, new DnsAAAARecordData(address)));
}
}
break;
}
if (answers.Count == 0)
{
return(Task.FromResult <DnsDatagram>(null));
}
if (answers.Count > 1)
{
answers.Shuffle();
}
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, answers)));
default:
return(Task.FromResult <DnsDatagram>(null));
}
}
