public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(config)
.UseIISIntegration()
.UseStartup <Startup>()
.Build();
var location = config.GetSection("server.urls").Value;
if (location != null)
{
myWebsocket = location.Replace("http", "ws") + "/ws";
}
myAddress = config.GetSection("myAddress").Value;
if (myAddress == null)
{
Console.WriteLine("Please specify address for TCP");
Environment.Exit(-1);
}
var initTCP = new TCPHandler();
initTCP.Init(myWebsocket, myAddress);
initTCP.StartCom();
host.Run();
}
private void VerifyHanderSendVersionPacketAndContinueByHandshakeSendCallback(TCPHandler sut)
{
var expectedSendBack = TCPHandler.Socks5HandshakeResponseHead;
_socketMock.Verify(_ => _.BeginSend(expectedSendBack, 0, expectedSendBack.Length, SocketFlags.None,
new AsyncCallback(sut.HandshakeSendCallback), null));
}
public static TCPHandler getInstance()
{
if(instance == null){
instance = new TCPHandler();
}
return instance;
}
private void VerifySendBackEstablishedResponse(TCPHandler sut)
{
var expectedResponse = new byte[] { TCPHandler.Socks5Version, TCPHandler.SuccessREP, TCPHandler.Reserve, TCPHandler.IpV4, 0, 0, 0, 0, 0, 0 };
_socketMock.Verify(_ => _.BeginSend(expectedResponse, 0, expectedResponse.Length, SocketFlags.None,
new AsyncCallback(sut.ResponseConnectCallback), null));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseDefaultFiles();
app.UseStaticFiles();
app.Map("/ws", WebSocketHandler.Map);
var initTCP = new TCPHandler();
initTCP.StartComServer();
}
private static void AssertResourcesProperlyCleaned(TCPHandler sut, TCPRelay relay, Mock <SocketProxy> socketMock, Mock <IProxy> remoteMock,
Mock <IEncryptor> encryptorMock)
{
Assert.True(sut.Closed);
AssertRelayRemoveHandler(relay, sut);
VerifySocketDisposed(socketMock);
VerifyRemoteDisposed(remoteMock);
VerifyEncryptorDisposed(encryptorMock);
}
public void StartTCPHandler(IPAddress remoteIP)
{
if (tcpHandler == null || tcpHandler.IsInvalid)
{
tcpHandler = new TCPHandler(this);
}
tcpHandler.BeginHandle(new IPEndPoint(remoteIP, TCP_PORT));
TCPConnecting?.Invoke(this, new EventArgs());
}
public TCPHandlerTest()
{
_asyncSession = new TCPHandler.AsyncSession(_remoteMock.Object);
_sut = new TCPHandler(null, _configuration, _tcpRelay, _socketMock.Object)
{
CurrentRemoteSession = _asyncSession
};
_sut.ConnetionRecvBuffer[4] = ExpectedDomainLength;
_sut.Encryptor = _encryptorMock.Object;
_tcpRelay.Handlers.Add(_sut);
}
public void RemoveClient(WebSocketHandler socket)
{
Console.WriteLine("Removing client");
var updateTCP = new TCPHandler();
updateTCP.UserLeft();
lock (clientLock)
{
clients.Remove(socket);
}
}
public void close_should_ignore_closed_handler()
{
var socketMock = new Mock <SocketProxy>(MockBehavior.Loose, (Socket)null);
var config = CreateMockConfiguration();
var relay = new TCPRelay(null, null);
var sut = new TCPHandler(null, config, relay, socketMock.Object);
sut.Closed = true;
sut.Close();
VerifyHandlerDoNotCloseSocket(socketMock);
}
private async Task ServerReceive()
{
var buffer = new byte[BufferSize];
var seg = new ArraySegment <byte>(buffer);
while (true)
{
if (socket.State != WebSocketState.Open)
{
break;
}
try
{
var result = await socket.ReceiveAsync(seg, CancellationToken.None);
if ((DateTime.Now - recent_message).Ticks <= span_limit)
{
RelayModel.Instance.RemoveClient(this);
break;
}
else
{
recent_message = DateTime.Now;
}
if (result.MessageType == WebSocketMessageType.Close)
{
RelayModel.Instance.RemoveClient(this);
break;
}
var raw = System.Text.Encoding.ASCII.GetString(seg.Array.Take(result.Count).ToArray());
var data = JsonConvert.DeserializeObject <DataObject>(raw);
var relayTCP = new TCPHandler();
relayTCP.Relay(raw);
await RelayModel.Instance.PropogateMessage(raw);
}
catch
{
System.Console.WriteLine("Error");
}
}
}
//this function is called when the service begins.
protected override void OnStart(string[] args)
{
eventLog1.WriteEntry("In OnStart");
//creating logging service to send messages to the log
this.ils = new LoggingService();
//every time the logger receives a message MessageRecieved is invoked and onmsg function in this class is called
this.ils.MessageRecieved += this.OnMsg;
string outputDir = ReadAppConfig.ReadSetting("OutPutDir");
int thumbnailSize = ReadAppConfig.ReadThumbnailSize("ThumbnailSize");
if (thumbnailSize == -1) //in case of failed conversion to an int
{
thumbnailSize = 120;
eventLog1.WriteEntry("warning: parsing failed, sets thumbnailsize to 120");
}
else
{
eventLog1.WriteEntry("Thumbnail size has been read successfuly");
}
//creating image model (thumbail size should be taken from app.config file)
this.modal = new ImageServiceModal(outputDir, thumbnailSize);
eventLog1.WriteEntry("output dir is: " + outputDir);
//creating the controller and the server.
this.controller = new ImageController(modal, ils);
this.server = new ImageServer(this.controller, this.ils);
this.server.Close += OnServerClose;
this.controller.addServer(this.server);
this.cServer = new ComunicationServer(8000, this.controller);
this.ils.MessageRecieved += delegate(object sender, MessageRecievedEventArgs e)
{
string[] logArgs = { e.Status.ToString(), e.Message };
this.cServer.SendCommandToAllClients((int)CommandsEnum.LogCommand, logArgs);
};
this.cServer.Start();
ITCPHandler tcpClientHandler = new TCPHandler(controller, ils);
ITCPServer tcpServer = new TCPServer(8001, ils, tcpClientHandler);
tcpServer.Start();
this.imageServer = new TCPServer(8001, ils, new TCPHandler(this.controller, ils));
this.imageServer.Start();
}
private static void AssertRelayRemoveHandler(TCPRelay relay, TCPHandler sut)
{
Assert.False(relay.Handlers.Contains(sut));
}
private static void VerifyHandlerClosed(TCPHandler sut, Mock <SocketProxy> socketMock)
{
Assert.True(sut.Closed);
VerifySocketDisposed(socketMock);
}
private void VerifyHandlerProperlyBeginReceiveCommand(IAsyncResult asyncResult, TCPHandler sut)
{
_socketMock.Verify(_ => _.EndSend(asyncResult));
_socketMock.Verify(_ => _.BeginReceive(It.IsAny <byte[]>(), 0, 3 + EncryptorBase.ADDR_ATYP_LEN + 1, SocketFlags.None,
new AsyncCallback(sut.HandshakeReceive2Callback), null));
}
public ConfigHubTests()
{
var h = new TCPHandler("127.0.0.1", 9060);
b.AddHandler(h);
}
