bool IsTimeoutException(SocketException e)
{
#if CF
return (e.NativeErrorCode == 10060);
#else
return (e.SocketErrorCode == SocketError.TimedOut);
#endif
}
bool IsWouldBlockException(SocketException e)
{
#if CF
return (e.NativeErrorCode == 10035);
#else
return (e.SocketErrorCode == SocketError.WouldBlock);
#endif
}
/// <summary>
/// Handles the command input from the client. This
/// message returns when the client issues the quit command.
/// </summary>
private void ProcessCommands(SmtpContext context)
{
bool isRunning = true;
string inputLine;
// Loop until the client quits.
while (isRunning)
{
try
{
inputLine = context.ReadLine();
if (inputLine == null)
{
isRunning = false;
context.WriteLine(MESSAGE_GOODBYE);
context.Close();
continue;
}
string[] inputs = inputLine.Split(" ".ToCharArray());
switch (inputs[0].ToLower())
{
case "helo":
this.Helo(context, inputs);
break;
case "rset":
this.Rset(context);
break;
case "noop":
context.WriteLine(MESSAGE_OK);
break;
case "quit":
isRunning = false;
context.WriteLine(MESSAGE_GOODBYE);
context.Close();
break;
case "mail":
if (inputs[1].ToLower().StartsWith("from"))
{
this.Mail(context, inputLine.Substring(inputLine.IndexOf(" ")));
break;
}
context.WriteLine(MESSAGE_UNKNOWN_COMMAND);
break;
case "rcpt":
if (inputs[1].ToLower().StartsWith("to"))
{
this.Rcpt(context, inputLine.Substring(inputLine.IndexOf(" ")));
break;
}
context.WriteLine(MESSAGE_UNKNOWN_COMMAND);
break;
case "data":
this.Data(context);
break;
default:
context.WriteLine(MESSAGE_UNKNOWN_COMMAND);
break;
}
}
catch (Exception ex)
{
SocketException sx = ex as SocketException;
if (sx != null && sx.ErrorCode == 10060)
{
context.WriteLine(MESSAGE_GOODBYE);
}
// else
// context.WriteLine(MESSAGE_SYSTEM_ERROR);
isRunning = false;
context.Socket.Dispose();
}
}
}
public static bool IsSocketExceptionRetryable(SocketException socketException)
{
ArgCheck.NotNull(nameof(socketException), socketException);
switch (socketException.SocketErrorCode)
{
case SocketError.AccessDenied:
case SocketError.ConnectionAborted:
case SocketError.ConnectionRefused:
case SocketError.ConnectionReset:
case SocketError.Disconnecting:
case SocketError.Fault:
case SocketError.HostDown:
case SocketError.HostNotFound:
case SocketError.HostUnreachable:
case SocketError.InProgress:
case SocketError.Interrupted:
case SocketError.IOPending:
case SocketError.IsConnected:
case SocketError.MessageSize:
case SocketError.NetworkDown:
case SocketError.NetworkReset:
case SocketError.NetworkUnreachable:
case SocketError.NoBufferSpaceAvailable:
case SocketError.NoData:
case SocketError.NoRecovery:
case SocketError.NotConnected:
case SocketError.NotInitialized:
case SocketError.NotSocket:
case SocketError.OperationAborted:
case SocketError.ProcessLimit:
case SocketError.ProtocolOption:
case SocketError.Shutdown:
case SocketError.SocketError:
case SocketError.SystemNotReady:
case SocketError.TimedOut:
case SocketError.TooManyOpenSockets:
case SocketError.TryAgain:
case SocketError.TypeNotFound:
case SocketError.WouldBlock:
return(true);
case SocketError.AddressAlreadyInUse:
case SocketError.AddressFamilyNotSupported:
case SocketError.AddressNotAvailable:
case SocketError.AlreadyInProgress:
case SocketError.DestinationAddressRequired:
case SocketError.InvalidArgument:
case SocketError.OperationNotSupported:
case SocketError.ProtocolFamilyNotSupported:
case SocketError.ProtocolNotSupported:
case SocketError.ProtocolType:
case SocketError.SocketNotSupported:
case SocketError.Success:
case SocketError.VersionNotSupported:
default:
break;
}
return(false);
}
protected override AsyncCompletionResult BeginWriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout,
Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
bool abortWrite = true;
try
{
lock (ThisLock)
{
Contract.Assert(!_asyncWritePending, "Called BeginWrite twice.");
this.ThrowIfClosed();
SetWriteTimeout(timeout, false);
_asyncWritePending = true;
_asyncWriteCallback = callback;
_asyncWriteState = state;
}
Task writeTask = _outputStream.WriteAsync(buffer, offset, size, _sendCts.Token);
if (immediate)
{
writeTask = writeTask.ContinueWith(s_flushWriteImmedaite, this, CancellationToken.None);
}
if (!writeTask.IsCompleted)
{
writeTask.ContinueWith(s_onSendAsyncCompleted, this, CancellationToken.None);
abortWrite = false;
return(AsyncCompletionResult.Queued);
}
writeTask.GetAwaiter().GetResult();
abortWrite = false;
return(AsyncCompletionResult.Completed);
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write);
if (object.ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
catch (Exception exception)
{
if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown)
{
SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, TimeSpan.MaxValue));
}
throw;
}
finally
{
if (abortWrite)
{
this.AbortWrite();
}
}
}
protected void Reload()
{
Encryption.RNG.Reload();
// some logic in configuration updated the config when saving, we need to read it again
_config = Configuration.Load();
StatisticsConfiguration = StatisticsStrategyConfiguration.Load();
if (privoxyRunner == null)
{
privoxyRunner = new PrivoxyRunner();
}
if (_pacServer == null)
{
_pacServer = new PACServer();
_pacServer.PACFileChanged += pacServer_PACFileChanged;
_pacServer.UserRuleFileChanged += pacServer_UserRuleFileChanged;
}
_pacServer.UpdateConfiguration(_config);
if (gfwListUpdater == null)
{
gfwListUpdater = new GFWListUpdater();
gfwListUpdater.UpdateCompleted += pacServer_PACUpdateCompleted;
gfwListUpdater.Error += pacServer_PACUpdateError;
}
availabilityStatistics.UpdateConfiguration(this);
if (_listener != null)
{
_listener.Stop();
}
// don't put PrivoxyRunner.Start() before pacServer.Stop()
// or bind will fail when switching bind address from 0.0.0.0 to 127.0.0.1
// though UseShellExecute is set to true now
// http://stackoverflow.com/questions/10235093/socket-doesnt-close-after-application-exits-if-a-launched-process-is-open
privoxyRunner.Stop();
try
{
var strategy = GetCurrentStrategy();
if (strategy != null)
{
strategy.ReloadServers();
}
privoxyRunner.Start(_config);
TCPRelay tcpRelay = new TCPRelay(this, _config);
UDPRelay udpRelay = new UDPRelay(this);
List <Listener.IService> services = new List <Listener.IService>();
services.Add(tcpRelay);
services.Add(udpRelay);
services.Add(_pacServer);
services.Add(new PortForwarder(privoxyRunner.RunningPort));
_listener = new Listener(services);
_listener.Start(_config);
}
catch (Exception e)
{
// translate Microsoft language into human language
// i.e. An attempt was made to access a socket in a way forbidden by its access permissions => Port already in use
if (e is SocketException)
{
SocketException se = (SocketException)e;
if (se.SocketErrorCode == SocketError.AccessDenied)
{
e = new Exception(I18N.GetString("Port already in use"), e);
}
}
Logging.LogUsefulException(e);
ReportError(e);
}
if (ConfigChanged != null)
{
ConfigChanged(this, new EventArgs());
}
UpdateSystemProxy();
Utils.ReleaseMemory(true);
}
public void Ctor_Raw_NotSupported_ExpectedError(AddressFamily addressFamily, ProtocolType protocolType)
{
SocketException e = Assert.Throws <SocketException>(() => new Socket(addressFamily, SocketType.Raw, protocolType));
Assert.Contains(e.SocketErrorCode, new[] { SocketError.AccessDenied, SocketError.ProtocolNotSupported });
}
private bool IsWouldBlockException(SocketException e)
{
return (e.SocketErrorCode == SocketError.WouldBlock);
}
protected override bool InnerStart()
{
try
{
serverSocket = new Socket(config.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
// serverSocket.SetSocketOption(SocketOptionLevel.IP, (SocketOptionName)27, 0);
serverSocket.Bind(EndPoint);
serverSocket.Listen(config.Backlog);
serverSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
serverSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
Logger.Info("监听已启动：{0}", EndPoint.ToString());
}
catch (Exception e)
{
Logger.Error("启动监听时发生异常：{0}", e.ToString());
return(false);
}
maxConntectedSemaphore = new Semaphore(config.MaxConnectionNumber, config.MaxConnectionNumber);
Status = Dynamic.Net.Base.NetServerStatus.Started;
StartupCompleted();
IsRunning = true;
while (Status == Dynamic.Net.Base.NetServerStatus.Started)
{
try
{
maxConntectedSemaphore.WaitOne();
if (Status != Dynamic.Net.Base.NetServerStatus.Started)
{
maxConntectedSemaphore.Release();
break;
}
SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
acceptEventArg.Completed += new EventHandler <SocketAsyncEventArgs>(acceptEventArg_Completed);
if (!serverSocket.AcceptAsync(acceptEventArg))
{
aceptClient(acceptEventArg);
}
}
catch (ObjectDisposedException)
{
break;
}
catch (NullReferenceException)
{
break;
}
catch (Exception e)
{
SocketException se = e as SocketException;
Logger.Error("客户端连接异常：{0}", e.ToString());
maxConntectedSemaphore.Release();
break;
}
}
IsRunning = false;
return(true);
}
public Server(List <IPEndPoint> endpoints, ServerSettings settings, ModData modData, ServerType type)
{
Log.AddChannel("server", "server.log", true);
SocketException lastException = null;
var checkReadServer = new List <Socket>();
foreach (var endpoint in endpoints)
{
var listener = new TcpListener(endpoint);
try
{
try
{
listener.Server.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 1);
}
catch (Exception ex)
{
if (ex is SocketException || ex is ArgumentException)
{
Log.Write("server", "Failed to set socket option on {0}: {1}", endpoint.ToString(), ex.Message);
}
else
{
throw;
}
}
listener.Start();
listeners.Add(listener);
checkReadServer.Add(listener.Server);
}
catch (SocketException ex)
{
lastException = ex;
Log.Write("server", "Failed to listen on {0}: {1}", endpoint.ToString(), ex.Message);
}
}
if (listeners.Count == 0)
{
throw lastException;
}
Type = type;
Settings = settings;
Settings.Name = OpenRA.Settings.SanitizedServerName(Settings.Name);
ModData = modData;
playerDatabase = modData.Manifest.Get <PlayerDatabase>();
randomSeed = (int)DateTime.Now.ToBinary();
if (type != ServerType.Local && settings.EnableGeoIP)
{
GeoIP.Initialize();
}
if (UPnP.Status == UPnPStatus.Enabled)
{
UPnP.ForwardPort(Settings.ListenPort, Settings.ListenPort).Wait();
}
foreach (var trait in modData.Manifest.ServerTraits)
{
serverTraits.Add(modData.ObjectCreator.CreateObject <ServerTrait>(trait));
}
serverTraits.TrimExcess();
LobbyInfo = new Session
{
GlobalSettings =
{
RandomSeed = randomSeed,
Map = settings.Map,
ServerName = settings.Name,
EnableSingleplayer = settings.EnableSingleplayer || Type != ServerType.Dedicated,
EnableSyncReports = settings.EnableSyncReports,
GameUid = Guid.NewGuid().ToString(),
Dedicated = Type == ServerType.Dedicated
}
};
new Thread(_ =>
{
foreach (var t in serverTraits.WithInterface <INotifyServerStart>())
{
t.ServerStarted(this);
}
Log.Write("server", "Initial mod: {0}", ModData.Manifest.Id);
Log.Write("server", "Initial map: {0}", LobbyInfo.GlobalSettings.Map);
while (true)
{
var checkRead = new List <Socket>();
if (State == ServerState.WaitingPlayers)
{
checkRead.AddRange(checkReadServer);
}
checkRead.AddRange(Conns.Select(c => c.Socket));
checkRead.AddRange(PreConns.Select(c => c.Socket));
// Block for at most 1 second in order to guarantee a minimum tick rate for ServerTraits
// Decrease this to 100ms to improve responsiveness if we are waiting for an authentication query
var localTimeout = waitingForAuthenticationCallback > 0 ? 100000 : 1000000;
if (checkRead.Count > 0)
{
Socket.Select(checkRead, null, null, localTimeout);
}
if (State == ServerState.ShuttingDown)
{
EndGame();
break;
}
foreach (var s in checkRead)
{
var serverIndex = checkReadServer.IndexOf(s);
if (serverIndex >= 0)
{
AcceptConnection(listeners[serverIndex]);
continue;
}
var preConn = PreConns.SingleOrDefault(c => c.Socket == s);
if (preConn != null)
{
preConn.ReadData(this);
continue;
}
var conn = Conns.SingleOrDefault(c => c.Socket == s);
conn?.ReadData(this);
}
delayedActions.PerformActions(0);
// PERF: Dedicated servers need to drain the action queue to remove references blocking the GC from cleaning up disposed objects.
if (Type == ServerType.Dedicated)
{
Game.PerformDelayedActions();
}
foreach (var t in serverTraits.WithInterface <ITick>())
{
t.Tick(this);
}
if (State == ServerState.ShuttingDown)
{
EndGame();
if (UPnP.Status == UPnPStatus.Enabled)
{
UPnP.RemovePortForward().Wait();
}
break;
}
}
foreach (var t in serverTraits.WithInterface <INotifyServerShutdown>())
{
t.ServerShutdown(this);
}
PreConns.Clear();
Conns.Clear();
foreach (var listener in listeners)
{
try { listener.Stop(); }
catch { }
}
})
{
IsBackground = true
}.Start();
}
public static bool wouldBlock(SocketException ex)
{
return(socketErrorCode(ex) == SocketError.WouldBlock);
}
public static bool interrupted(SocketException ex)
{
return(socketErrorCode(ex) == SocketError.Interrupted);
}
void HandleSocketException(SocketException exn)
{
error = exn.ErrorCode + ": " + exn.SocketErrorCode.ToString();
}
public DSCClientErrorEventArgs(SocketException e)
{
this.exception = e;
}
public static bool RecvTruncated(SocketException ex) => SocketErrorCode(ex) == SocketError.MessageSize;
public static SocketError SocketErrorCode(SocketException ex) => ex.SocketErrorCode;
/// <summary>
/// Listen for messages from the websocket. Once they are received they are parsed and the WebSocketMessageReceived event is raised.
/// </summary>
/// <returns>The task of listening for messages from the websocket.</returns>
private async Task ListenForMessagesInternalAsync()
{
this.receivingMessagesTask = Task.Run(async() =>
{
try
{
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[MaxChunkSizeInBytes]);
// Once close message is sent do not try to get any more messages as WDP will abort the web socket connection.
while (this.websocket.State == WebSocketState.Open)
{
// Receive single message in chunks.
using (var ms = new MemoryStream())
{
WebSocketReceiveResult result;
do
{
result = await this.websocket.ReceiveAsync(buffer, CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
await this.websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
return;
}
if (result.Count > MaxChunkSizeInBytes)
{
throw new InvalidOperationException("Buffer not large enough");
}
ms.Write(buffer.Array, buffer.Offset, result.Count);
}while (!result.EndOfMessage);
ms.Seek(0, SeekOrigin.Begin);
if (result.MessageType == WebSocketMessageType.Text)
{
Stream stream = new MemoryStream();
await ms.CopyToAsync(stream);
// Ensure we return with the stream pointed at the origin.
stream.Position = 0;
this.ConvertStreamToMessage(stream);
}
}
}
}
catch (WebSocketException e)
{
// If WDP aborted the web socket connection ignore the exception.
SocketException socketException = e.InnerException?.InnerException as SocketException;
if (socketException != null)
{
if (socketException.NativeErrorCode == WSAECONNRESET)
{
return;
}
}
throw;
}
finally
{
this.IsListeningForMessages = false;
}
});
await this.receivingMessagesTask;
}
private unsafe static IPAddress InternalParse(string ipString, bool tryParse)
{
if (ipString == null)
{
if (tryParse)
{
return null;
}
throw new ArgumentNullException("ipString");
}
else
{
if (ipString.IndexOf(':') != -1)
{
SocketException innerException;
if (Socket.OSSupportsIPv6)
{
byte[] array = new byte[16];
SocketAddress socketAddress = new SocketAddress(AddressFamily.InterNetworkV6, 28);
if (OSSOCK.WSAStringToAddress(ipString, AddressFamily.InterNetworkV6, IntPtr.Zero, socketAddress.m_Buffer, ref socketAddress.m_Size) == SocketError.Success)
{
for (int i = 0; i < 16; i++)
{
array[i] = socketAddress[i + 8];
}
long scopeid = (long)(((int)socketAddress[27] << 24) + ((int)socketAddress[26] << 16) + ((int)socketAddress[25] << 8) + (int)socketAddress[24]);
return new IPAddress(array, scopeid);
}
if (tryParse)
{
return null;
}
innerException = new SocketException();
}
else
{
int start = 0;
if (ipString[0] != '[')
{
ipString += ']';
}
else
{
start = 1;
}
int length = ipString.Length;
fixed (char* name = ipString)
{
if (IPv6AddressHelper.IsValidStrict(name, start, ref length) || length != ipString.Length)
{
ushort[] array2 = new ushort[8];
string text = null;
fixed (ushort* ptr = array2)
{
IPv6AddressHelper.Parse(ipString, ptr, 0, ref text);
}
IPAddress result;
if (text == null || text.Length == 0)
{
result = new IPAddress(array2, 0u);
}
else
{
text = text.Substring(1);
uint scopeid2;
if (!uint.TryParse(text, NumberStyles.None, null, out scopeid2))
{
goto IL_193;
}
result = new IPAddress(array2, scopeid2);
}
return result;
}
IL_193: ;
}
if (tryParse)
{
return null;
}
innerException = new SocketException(SocketError.InvalidArgument);
}
throw new FormatException("dns_bad_ip_address" + innerException);
}
Socket.InitializeSockets();
int length2 = ipString.Length;
long num;
fixed (char* name2 = ipString)
{
num = IPv4AddressHelper.ParseNonCanonical(name2, 0, ref length2, true);
}
if (num != -1L && length2 == ipString.Length)
{
num = ((num & 255L) << 24 | ((num & 65280L) << 8 | ((num & 16711680L) >> 8 | (num & 1095216660480) >> 24)));
return new IPAddress(num);
}
if (tryParse)
{
return null;
}
throw new FormatException("dns_bad_ip_address");
}
}
private void ProcessCommands(SmtpContext context)
{
bool isRunning = true;
String inputLine;
while (isRunning)
{
try
{
inputLine = context.ReadLine();
// TODO: remove this if gmail google is running
if (inputLine == null)
{
isRunning = false;
context.WriteLine(MESSAGE_GOODBYE);
context.Close();
break;
}
String[] inputs = inputLine.Split(' ');
switch (inputs[0].ToLower())
{
case "helo":
Helo(context, inputs);
break;
case "ehlo":
Ehlo(context, inputs);
break;
case "rset":
Rset(context);
break;
case "noop":
context.WriteLine(MESSAGE_OK);
break;
case "vrfy":
Vrfy(context, inputLine.Substring(5));
break;
case "quit":
isRunning = false;
context.WriteLine(MESSAGE_GOODBYE);
context.Close();
break;
case "mail":
// TODO: move the input line to Mail(...)
if (inputs[1].ToLower().StartsWith("from"))
{
Mail(context, inputLine.Substring(inputLine.IndexOf(":")));
break;
}
context.WriteLine(MESSAGE_UNKNOWN_COMMAND);
break;
case "rcpt":
if (inputs[1].ToLower().StartsWith("to"))
{
Rcpt(context, inputLine.Substring(inputLine.IndexOf(":")));
break;
}
context.WriteLine(MESSAGE_UNKNOWN_COMMAND);
break;
case "data":
Data(context);
break;
default:
context.WriteLine(MESSAGE_UNKNOWN_COMMAND);
break;
}
}
catch (Exception ex)
{
SocketException sx = ex as SocketException;
if (sx != null && sx.ErrorCode == 10060)
{
context.WriteLine(MESSAGE_GOODBYE);
}
else
{
context.WriteLine(MESSAGE_SYSTEM_ERROR);
}
isRunning = false;
context.Close();
}
}
}
private void _OnError(SocketException ex)
{
if (OnError != null) {
this.OnError(this, new DSCClientErrorEventArgs(ex));
}
}
public static NetMQException Create([NotNull] SocketException innerException)
{
return(Create(innerException.SocketErrorCode, innerException));
}
static internal bool ConnectToEndPoint(int port, string address, out Socket socket, out SocketException exception)
{
socket = null;
exception = null;
short _numberOfTries = 1;
bool _isConnected = false;
SocketException _exception = null;
while (_numberOfTries <= 3)
{
Socket _peerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
System.Threading.Thread thread = new System.Threading.Thread(() => ConnectToParticularEndpoint(ref _isConnected, ref _exception, ref _peerSocket, address, port));
thread.Name = "Attempt connection to " + address;
thread.IsBackground = true;
thread.Start();
thread.Join(1000);
//connected
if (_isConnected)
{
socket = _peerSocket;
return(true);
}
//Some other exception occurs
if (_exception != null && _exception.ErrorCode != 10061 && _exception.ErrorCode != 10065 && _exception.ErrorCode != 10060 && _exception.ErrorCode != 10064)
{
exception = _exception;
return(false);
}
}
return(false);
}
public void Socket_CreateUnixDomainSocket_Throws_OnWindows()
{
SocketException e = Assert.Throws <SocketException>(() => new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified));
Assert.Equal(SocketError.AddressFamilyNotSupported, e.SocketErrorCode);
}
protected void Reload()
{
if (_port_map_listener != null)
{
foreach (Listener l in _port_map_listener)
{
l.Stop();
}
_port_map_listener = null;
}
// some logic in configuration updated the config when saving, we need to read it again
_config = MergeGetConfiguration(_config);
_config.FlushPortMapCache();
ReloadIPRange();
#if !_CONSOLE
if (polipoRunner == null)
{
polipoRunner = new HttpProxyRunner();
}
#endif
if (_pacServer == null)
{
_pacServer = new PACServer();
_pacServer.PACFileChanged += pacServer_PACFileChanged;
}
_pacServer.UpdateConfiguration(_config);
if (gfwListUpdater == null)
{
gfwListUpdater = new GFWListUpdater();
gfwListUpdater.UpdateCompleted += pacServer_PACUpdateCompleted;
gfwListUpdater.Error += pacServer_PACUpdateError;
}
// don't put polipoRunner.Start() before pacServer.Stop()
// or bind will fail when switching bind address from 0.0.0.0 to 127.0.0.1
// though UseShellExecute is set to true now
// http://stackoverflow.com/questions/10235093/socket-doesnt-close-after-application-exits-if-a-launched-process-is-open
bool _firstRun = firstRun;
for (int i = 1; i <= 5; ++i)
{
_firstRun = false;
try
{
if (_listener != null && !_listener.isConfigChange(_config))
{
Local local = new Local(_config, _transfer, _rangeSet);
_listener.GetServices()[0] = local;
#if !_CONSOLE
if (polipoRunner.HasExited())
{
polipoRunner.Stop();
polipoRunner.Start(_config);
_listener.GetServices()[3] = new HttpPortForwarder(polipoRunner.RunningPort, _config);
}
#endif
}
else
{
if (_listener != null)
{
_listener.Stop();
_listener = null;
}
#if !_CONSOLE
polipoRunner.Stop();
polipoRunner.Start(_config);
#endif
Local local = new Local(_config, _transfer, _rangeSet);
List <Listener.Service> services = new List <Listener.Service>();
services.Add(local);
services.Add(_pacServer);
services.Add(new APIServer(this, _config));
#if !_CONSOLE
services.Add(new HttpPortForwarder(polipoRunner.RunningPort, _config));
#endif
_listener = new Listener(services);
_listener.Start(_config, 0);
}
break;
}
catch (Exception e)
{
// translate Microsoft language into human language
// i.e. An attempt was made to access a socket in a way forbidden by its access permissions => Port already in use
if (e is SocketException)
{
SocketException se = (SocketException)e;
if (se.SocketErrorCode == SocketError.AccessDenied)
{
e = new Exception(I18N.GetString("Port already in use") + string.Format(" {0}", _config.localPort), e);
}
}
Logging.LogUsefulException(e);
if (!_firstRun)
{
ReportError(e);
break;
}
else
{
Thread.Sleep(1000 * i * i);
}
if (_listener != null)
{
_listener.Stop();
_listener = null;
}
}
}
_port_map_listener = new List <Listener>();
foreach (KeyValuePair <int, PortMapConfigCache> pair in _config.GetPortMapCache())
{
try
{
Local local = new Local(_config, _transfer, _rangeSet);
List <Listener.Service> services = new List <Listener.Service>();
services.Add(local);
Listener listener = new Listener(services);
listener.Start(_config, pair.Key);
_port_map_listener.Add(listener);
}
catch (Exception e)
{
// translate Microsoft language into human language
// i.e. An attempt was made to access a socket in a way forbidden by its access permissions => Port already in use
if (e is SocketException)
{
SocketException se = (SocketException)e;
if (se.SocketErrorCode == SocketError.AccessDenied)
{
e = new Exception(I18N.GetString("Port already in use") + string.Format(" {0}", pair.Key), e);
}
}
Logging.LogUsefulException(e);
ReportError(e);
}
}
ConfigChanged?.Invoke(this, new EventArgs());
UpdateSystemProxy();
Util.Utils.ReleaseMemory();
}
public string Call()
{
String message = "";
String errorMessage = "";
var handler = new HttpClientHandler();
handler.AllowAutoRedirect = false;
String hostName = url;
try
{
Uri uri = new Uri(url);
hostName = uri.Host;
HttpClient client = new HttpClient(handler);
client.BaseAddress = uri;
HttpResponseMessage response = client.GetAsync(uri.AbsolutePath).Result; // Blocking call!
this.response = response.Content.ReadAsStringAsync().Result;
if (response.IsSuccessStatusCode)
{
message = String.Format("Success: {0} bytes (HTTP {1})", response.Content.ReadAsStringAsync().Result.Length, response.StatusCode);
}
else
{
errorMessage = String.Format("HTTP Response: {0} ({1})", response.StatusCode, (int)response.StatusCode);
}
}
catch (AggregateException ae)
{
ae.Handle((ex) =>
{
do
{
if (ex is WebException)
{
WebException wex = ex as WebException;
switch (wex.Status)
{
// The SSL/TLS connection could not be established.
case WebExceptionStatus.SecureChannelFailure:
List <string> protocols = new List <string>();
if ((ServicePointManager.SecurityProtocol & SecurityProtocolType.Ssl3) != 0)
{
protocols.Add("SSL 3");
}
if ((ServicePointManager.SecurityProtocol & SecurityProtocolType.Tls) != 0)
{
protocols.Add("TLS 1.0");
}
if ((ServicePointManager.SecurityProtocol & SecurityProtocolType.Tls11) != 0)
{
protocols.Add("TLS 1.1");
}
if ((ServicePointManager.SecurityProtocol & SecurityProtocolType.Tls12) != 0)
{
protocols.Add("TLS 1.2");
}
errorMessage = String.Format("Could not establish SSL/TLS connection (supported protocols: {0})", String.Join(", ", protocols));
break;
case WebExceptionStatus.TrustFailure:
errorMessage = String.Format("SSL Certificate for '{0}' invalid", hostName);
break;
case WebExceptionStatus.NameResolutionFailure:
errorMessage = String.Format("Invalid domain name '{0}'", hostName);
break;
default:
errorMessage = wex.Status.ToString();
break;
}
}
else if (ex is SocketException)
{
SocketException sex = ex as SocketException;
errorMessage = sex.Message;
}
else if (ex is IOException)
{
IOException ioex = ex as IOException;
errorMessage = ioex.Message;
}
ex = ex.InnerException;
} while (ex != null);
return(true);
});
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
if (errorMessage != "")
{
throw new Exception(errorMessage);
}
return(message);
}
internal override void HandleConnectionForciblyClosed(NetConnection connection, SocketException sex)
{
if (m_serverConnection == null)
{
return;
}
if (m_serverConnection.Status == NetConnectionStatus.Connecting)
{
// failed to connect; server is not listening
m_serverConnection.Disconnect("Failed to connect; server is not listening", 0, false, true);
return;
}
m_connectRequested = false;
m_serverConnection.Disconnect("Connection forcibly closed by server", 0, false, true);
return;
}
private void ConnectImpl(string host, int port, int timeout, Action <NetHandler, Exception> callback)
{
if (!running)
{
throw new ObjectDisposedException(ToString());
}
Stopwatch clock = new Stopwatch();
clock.Start();
Dns.BeginGetHostAddresses(host, delegate(IAsyncResult ar)
{
clock.Stop();
timeout -= (int)clock.ElapsedMilliseconds;
try
{
IPAddress[] iplist = Dns.EndGetHostAddresses(ar);
if (timeout > 0)
{
AddressFamily family = AddressFamily.InterNetwork;
for (int i = 0; i < iplist.Length; ++i)
{
if (iplist[i].AddressFamily == AddressFamily.InterNetworkV6)
{
family = AddressFamily.InterNetworkV6;
break;
}
}
NetHandlerImpl socket = new NetHandlerImpl(family, this);
Timer timer = new Timer(delegate(object state)
{
socket.Socket.Close();
}, null, Timeout.Infinite, Timeout.Infinite);
socket.Socket.BeginConnect(iplist, port, delegate(IAsyncResult result)
{
try
{
timer.Dispose();
}
catch
{
}
Exception exception = null;
try
{
socket.Socket.EndConnect(result);
socket.Socket.Blocking = false;
socket.OnConnected();
}
catch (ObjectDisposedException)
{
exception = new SocketException((int)SocketError.TimedOut);
}
catch (Exception e)
{
exception = e;
socket.Socket.Close();
}
callback(exception == null ? socket : null, exception);
}, null);
timer.Change(timeout, Timeout.Infinite);
}
else
{
callback(null, new SocketException((int)SocketError.TimedOut));
}
}
catch (Exception e)
{
callback(null, e);
}
}, null);
}
public static bool LogSocketException(string remarks, string server, Exception e)
{
UpdateLogFile();
// just log useful exceptions, not all of them
if (e is ObfsException)
{
ObfsException oe = (ObfsException)e;
Error("Proxy server [" + remarks + "(" + server + ")] "
+ oe.Message);
return(true);
}
else if (e is NullReferenceException)
{
return(true);
}
else if (e is ObjectDisposedException)
{
// ignore
return(true);
}
else if (e is SocketException)
{
SocketException se = (SocketException)e;
if ((uint)se.SocketErrorCode == 0x80004005)
{
// already closed
return(true);
}
else if (se.ErrorCode == 11004)
{
Logging.Log(LogLevel.Warn, "Proxy server [" + remarks + "(" + server + ")] "
+ "DNS lookup failed");
return(true);
}
else if (se.SocketErrorCode == SocketError.HostNotFound)
{
Logging.Log(LogLevel.Warn, "Proxy server [" + remarks + "(" + server + ")] "
+ "Host not found");
return(true);
}
else if (se.SocketErrorCode == SocketError.ConnectionRefused)
{
Logging.Log(LogLevel.Warn, "Proxy server [" + remarks + "(" + server + ")] "
+ "connection refused");
return(true);
}
else if (se.SocketErrorCode == SocketError.NetworkUnreachable)
{
Logging.Log(LogLevel.Warn, "Proxy server [" + remarks + "(" + server + ")] "
+ "network unreachable");
return(true);
}
else if (se.SocketErrorCode == SocketError.TimedOut)
{
//Logging.Log(LogLevel.Warn, "Proxy server [" + remarks + "(" + server + ")] "
// + "connection timeout");
return(true);
}
else if (se.SocketErrorCode == SocketError.Shutdown)
{
return(true);
}
else
{
Logging.Log(LogLevel.Info, "Proxy server [" + remarks + "(" + server + ")] "
+ Convert.ToString(se.SocketErrorCode) + ":" + se.Message);
Debug(ToString(new StackTrace().GetFrames()));
return(true);
}
}
return(false);
}
/// <summary>
/// Internal for re-use by CommandAvailabilityPublisher
/// </summary>
internal static void ReportSocketExceptionAndExit(SocketException exception, WebSocketServer server)
{
ErrorReport.NotifyUserOfProblem(exception, SocketExceptionMsg, Environment.NewLine, server.Port);
Application.Exit();
}
public static bool ConnectionRefused(SocketException ex) => SocketErrorCode(ex) == SocketError.ConnectionRefused;
/// <summary>
/// Event triggered if a network error occurs while communicating with
/// the LoginServer.
/// </summary>
/// <param name="Exception"></param>
private void m_LoginClient_OnNetworkError(SocketException Exc)
{
MessageBox.Show(Exc.ToString());
Application.Exit();
}
public static bool OperationAborted(SocketException ex) => SocketErrorCode(ex) == SocketError.OperationAborted;
internal ServerInfoEventArgs(ServerEndPoint serverEndPoint, SocketException error)
: base(serverEndPoint)
{
SocketError = error.SocketErrorCode;
Exception = error;
}
private bool IsTimeoutException(SocketException e)
{
return (e.SocketErrorCode == SocketError.TimedOut);
}
private void HandleSocketException(SocketException e)
{
Logger.WriteLine("Socket Exception: {0}, Disconnecting", TraceEventType.Error, e);
this.HandleDisconnect();
//this.OnUnknownError(new ErrorEventArgs(e));
}
public static void Connect()
{
//Starts the C# server to send string data to
Process.Start("Server");
//Find own local IP address
IPHostEntry host;
string localIP = "";
host = Dns.GetHostEntry(Dns.GetHostName());
foreach (IPAddress ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
localIP = ip.ToString();
break;
}
}
byte[] data = new byte[1024];
string input, stringData;
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 137);
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
server.Connect(ipep);
}
catch (SocketException e)
{
UnityEngine.Debug.Log("Unable to connect to the server.");
UnityEngine.Debug.Log(e.ToString());
return;
}
int recv = server.Receive(data);
stringData = Encoding.ASCII.GetString(data, 0, recv);
UnityEngine.Debug.Log(stringData);
int i = 0;
while (true)
{
i = i + 1;
input = "Client Side: " + i;
server.Send(Encoding.ASCII.GetBytes(input));
data = new byte[1024];
try
{
recv = server.Receive(data);
stringData = Encoding.ASCII.GetString(data, 0, recv);
UnityEngine.Debug.Log(ipep.Address + ": " + stringData);
if (i == 5)
{
string msg = "Closing connection";
server.Send(Encoding.ASCII.GetBytes(msg));
break;
}
}
catch
{
UnityEngine.Debug.Log("Server disconnected.");
break;
}
}
SocketException ee = new SocketException();
try
{
server.Shutdown(SocketShutdown.Both);
UnityEngine.Debug.Log (ee);
UnityEngine.Debug.Log ("Server.close() worked??");
}
catch{
UnityEngine.Debug.Log("Disconnecting from server");
}
finally{
server.Close();
}
}
public SocketClosedByAccidentEventArgs(SocketException ex)
{
Exception = ex;
}
private void exception(Ice.Current current)
{
if(current.operation.Equals("ice_ids"))
{
throw new Test.TestIntfUserException();
}
else if(current.operation.Equals("requestFailedException"))
{
throw new ObjectNotExistException();
}
else if(current.operation.Equals("unknownUserException"))
{
UnknownUserException ex = new UnknownUserException();
ex.unknown = "reason";
throw ex;
}
else if(current.operation.Equals("unknownLocalException"))
{
UnknownLocalException ex = new UnknownLocalException();
ex.unknown = "reason";
throw ex;
}
else if(current.operation.Equals("unknownException"))
{
UnknownException ex = new UnknownException();
ex.unknown = "reason";
throw ex;
}
else if(current.operation.Equals("userException"))
{
throw new TestIntfUserException();
}
else if(current.operation.Equals("localException"))
{
SocketException ex = new SocketException();
ex.error = 0;
throw ex;
}
else if(current.operation.Equals("csException"))
{
throw new System.Exception("message");
}
else if(current.operation.Equals("unknownExceptionWithServantException"))
{
throw new UnknownException("reason");
}
else if(current.operation.Equals("impossibleException"))
{
throw new Test.TestIntfUserException(); // Yes, it really is meant to be TestIntfException.
}
else if(current.operation.Equals("intfUserException"))
{
throw new Test.TestImpossibleException(); // Yes, it really is meant to be TestImpossibleException.
}
else if(current.operation.Equals("asyncResponse"))
{
throw new Test.TestImpossibleException();
}
else if(current.operation.Equals("asyncException"))
{
throw new Test.TestImpossibleException();
}
}
public void Exception_HostNotFound_Success()
{
var ex = new SocketException((int)SocketError.HostNotFound);
Assert.Equal(-1, ex.Message.IndexOf("Device"));
}
public SocketOperationResult(SocketException exception)
{
SocketError = exception;
BytesTransferred = 0;
}
/// <summary>
/// Gets if the specified exception can safely be ignored.
/// </summary>
private static bool _CanIgnore(SocketException Exception)
{
return Exception.SocketErrorCode == SocketError.ConnectionReset;
}
