/// <summary>
/// 将两个<see cref="Socket"/> 进行数据交换。
/// </summary>
/// <param name="server"></param>
/// <param name="client"></param>
public static void ExchangeData(this Socket server, Socket client)
{
var clientStream = new NetworkStream(client, true);
var serverStream = new NetworkStream(server, true);
#if NET40
Task.WaitAll(Task.Factory.StartNew(() =>
{
try
{
clientStream.CopyTo(serverStream);
}
catch
{
client?.Close();
server?.Close();
}
}), Task.Factory.StartNew(() =>
{
try
{
serverStream.CopyTo(clientStream);
}
catch
{
client?.Close();
server?.Close();
}
}));
#else
Task.WaitAll(Task.Run(() =>
{
try
{
clientStream.CopyTo(serverStream);
}
catch
{
client?.Close();
server?.Close();
}
}), Task.Run(() =>
{
try
{
serverStream.CopyTo(clientStream);
}
catch
{
client?.Close();
server?.Close();
}
}));
#endif
client?.Close();
server?.Close();
}
public static Stream CopyFromClient(TcpClient client)
{
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
/*byte[] buffer = new byte[512];
* int i;
* while ((i = stream.Read(buffer, 0, 512)) != 0)
* {
* foreach (byte b in buffer)
* Console.Write(b);
* Console.WriteLine();
* }*/
MemoryStream localStream = new MemoryStream();
stream.CopyTo(localStream);
localStream.Seek(0, SeekOrigin.Begin);
// Send back a response.
byte[] msg = System.Text.Encoding.ASCII.GetBytes("Finished.");
stream.Write(msg, 0, msg.Length);
// Close down connection.
client.Close();
return(localStream);
}
private byte[] receiveImage(IPAddress ip)
{
TcpClient client = new TcpClient();
client.Connect(ip, 12000);
NetworkStream ns = client.GetStream();
byte[] data;
try
{
using (var stream = ns)
{
MemoryStream ms = new MemoryStream();
ns.CopyTo(ms);
data = ms.ToArray();
return(data);
}
}
catch (Exception) {
Console.Write("eccezione immagine");
}
return(null);
}
/// <summary>
/// 将两个<see cref="Socket"/> 进行数据交换。
/// </summary>
/// <param name="server"></param>
/// <param name="client"></param>
public static void ExchangeData(this Socket server, Socket client)
{
var clientStream = new NetworkStream(client, true);
var serverStream = new NetworkStream(server, true);
Task.WaitAll(Task.Factory.StartNew(() =>
{
try
{
clientStream.CopyTo(serverStream);
}
catch
{
client?.Close();
server?.Close();
}
}, TaskCreationOptions.LongRunning), Task.Factory.StartNew(() =>
{
try
{
serverStream.CopyTo(clientStream);
}
catch
{
client?.Close();
server?.Close();
}
}, TaskCreationOptions.LongRunning));
client?.Close();
server?.Close();
}
private void DoListen(TcpClient client)
{
NetworkStream stream = client.GetStream();
using (MemoryStream memStream = new MemoryStream())
{
stream.CopyTo(memStream);
StreamReader sr = new StreamReader(memStream);
while (!sr.EndOfStream)
{
var req = sr.ReadLine();
Debug.Print("receive " + req);
}
memStream.Seek(0, SeekOrigin.Begin);
NetDataContractSerializer dcs = new NetDataContractSerializer();
dcs.SurrogateSelector = new ActorSurrogatorSelector();
dcs.Binder = new ActorBinder();
Object obj = dcs.ReadObject(memStream);
SerialObject so = (SerialObject)obj;
// no answer expected
client.Close();
// find hosted actor directory
// forward msg to hostedactordirectory
Become(new Behavior <SerialObject>(t => { return(true); }, DoProcessMessage));
SendMessage(so);
}
}
/// <summary>
/// Reads all contents of NetworkStream
/// </summary>
/// <param name="str">Stream to read from</param>
/// <returns>Byte array of stream contents</returns>
public static byte[] ReadContents(NetworkStream str)
{
using (var memoryStream = new MemoryStream())
{
str.CopyTo(memoryStream);
return(memoryStream.ToArray());
}
}
public static void ForwardRequest(NetworkStream browserStream, TcpClient client, string request)
{
try
{
string[] temp = request.Trim().Split(new char[] { '\r', '\n' });
string hostLine = temp.FirstOrDefault(x => x.Contains("Host"));
hostLine = hostLine.Substring(hostLine.IndexOf(":") + 2);
string[] endPoint = hostLine.Trim().Split(new char[] { ':' }); //доменное имя + порт
string[] requestLine = temp[0].Trim().Split(' ');
string newRequestLine = requestLine[1];
if (requestLine[1].Contains(endPoint[0]))
{
newRequestLine = requestLine[1].Remove(0, requestLine[1].IndexOf(endPoint[0]));
newRequestLine = newRequestLine.Remove(0, newRequestLine.IndexOf('/'));
//Console.WriteLine(newRequestLine);
}
request = request.Substring(0, request.IndexOf(requestLine[1])) + newRequestLine + " " + request.Substring(request.IndexOf("HTTP/1.1"));
//Console.WriteLine(request);
TcpClient forwardingClient;
if (endPoint.Length == 2)
{
forwardingClient = new TcpClient(endPoint[0], int.Parse(endPoint[1]));
}
else
{
forwardingClient = new TcpClient(endPoint[0], 80);
}
NetworkStream servStream = forwardingClient.GetStream();
byte[] data = Encoding.ASCII.GetBytes(request); //пересылка пакета с использованием относительного пути
servStream.Write(data, 0, data.Length);
byte[] respBuf = new byte[256]; //forwardingClient.ReceiveBufferSize];
servStream.Read(respBuf, 0, 256); // forwardingClient.ReceiveBufferSize);
browserStream.Write(respBuf, 0, respBuf.Length);
string[] head = Encoding.ASCII.GetString(respBuf).Split(new char[] { '\r', '\n' });
string ResponseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
Console.WriteLine($"Request to {hostLine}\nResponse:\n");
Console.WriteLine($"{hostLine} {ResponseCode}\n");
servStream.CopyTo(browserStream);
}
catch
{
return;
}
finally
{
client.Dispose();
}
}
byte[] ReceiveResponse(NetworkStream stream)
{
using (var memory = new MemoryStream())
{
stream.CopyTo(memory);
memory.Position = 0;
return(memory.ToArray());
}
}
internal async void Start(string[] args)
{
Connect();
var inputTask = Console.OpenStandardInput().CopyToAsync(engineStream);
engineStream.CopyTo(Console.OpenStandardOutput());
await inputTask;
}
/// <summary>
/// \brief Start streaming from one stream to another.
///
/// This is repeated as long as both clients are connected.
/// When the connection on one of the clients is closed, the CloseConnection() method is called.
/// </summary>
/// <param name="inStream">The input stream to get data from.</param>
/// <param name="outStream">The output stream to pass data to.</param>
private void StreamTo(NetworkStream inStream, NetworkStream outStream)
{
while (client1.IsConnected() && client2.IsConnected())
{
while (inStream.DataAvailable)
{
inStream.CopyTo(outStream);
}
}
CloseConnection();
}
public void HttpResponser(byte[] buffer, NetworkStream browser)
{
TcpClient server;
string responseRecord;
string responseCode;
try
{
buffer = CutGet(buffer);
string[] temp = Encoding.ASCII.GetString(buffer).Trim().Split(new char[] { '\r', '\n' });
string request = temp.FirstOrDefault(x => x.Contains("Host"));
request = request.Substring(request.IndexOf(":") + 2);
string[] hostAndPort = request.Trim().Split(new char[] { ':' }); // Получаем имя домена и по возможности номер порта
if (hostAndPort.Length == 2) // Соединяемся с сервером по имени хоста и по порту
{ // (или стандартному 80, или указанному)
server = new TcpClient(hostAndPort[0], int.Parse(hostAndPort[1]));
}
else
{
server = new TcpClient(hostAndPort[0], 80);
}
NetworkStream serverStream = server.GetStream(); // Поток с сервером
if (blackList != null && Array.IndexOf(blackList, request.ToLower()) != -1)
{
byte[] blackResponse = Encoding.ASCII.GetBytes("HTTP/1.1 403 Forbidden\r\nContent-Type: text/html\r\nContent-Length: 19\r\n\r\nYou shall not pass!");
browser.Write(blackResponse, 0, blackResponse.Length);
responseCode = "403";
responseRecord = request + " " + responseCode;
Console.WriteLine(responseRecord);
return;
}
serverStream.Write(buffer, 0, buffer.Length); // Отправляем данные на сервер, которые получили от браузера
var bufResponse = new byte[32]; // Для заголовка
serverStream.Read(bufResponse, 0, bufResponse.Length); // Ответ от сервера
browser.Write(bufResponse, 0, bufResponse.Length); // Отправляем этот ответ браузеру
string[] head = Encoding.UTF8.GetString(bufResponse).Split(new char[] { '\r', '\n' }); // Получаем код ответа
responseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
responseRecord = request + " " + responseCode;
Console.WriteLine(responseRecord);
serverStream.CopyTo(browser); // Перенаправляем остальные данные от сервера к браузеру
}
catch { return; }
}
public byte[] ReceiveBytes(ref Socket clientSocket)
{
using (NetworkStream ns = new NetworkStream(clientSocket))
{
using (MemoryStream ms = new MemoryStream())
{
ns.CopyTo(ms);
return(ms.ToArray());
}
}
}
public void SaveFile(string path)
{
fileWriteStream = true;
stream = client.GetStream();
using (FileStream fileStream = new FileStream(path, FileMode.Create))
{
do
{
stream.CopyTo(fileStream);
}while (fileWriteStream && stream.DataAvailable);
}
client.Close();
}
private void ClientRequestProcessing(Socket client)
{
try
{
NetworkStream clientStream = new NetworkStream(client);
byte[] clientRequest;
int clientRequestLength;
(clientRequest, clientRequestLength) = ReadStream(clientStream);
// Get Host name, ip
Http httpClientRequest = new Http(Encoding.UTF8.GetString(clientRequest));
if (httpClientRequest.host != null && IsBlackList(httpClientRequest.host.HostName))
{
ProcessBlackListRequest(clientStream, httpClientRequest.host.HostName);
throw new Exception();
}
// Create server variable
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint serverHost = new IPEndPoint(httpClientRequest.ip, httpClientRequest.port);
server.Connect(serverHost);
NetworkStream serverStream = new NetworkStream(server);
clientRequest = Encoding.UTF8.GetBytes(httpClientRequest.modifiedRequest);
// Send Modified Request to Server
serverStream.Write(clientRequest, 0, clientRequest.Length);
byte[] serverResponse;
int serverResponseLength;
// Get data from reply
(serverResponse, serverResponseLength) = ReadStream(serverStream);
clientStream.Write(serverResponse, 0, serverResponseLength);
Console.WriteLine(GetResponse(Encoding.UTF8.GetString(serverResponse), httpClientRequest.host.HostName));
serverStream.CopyTo(clientStream);
}
catch (Exception e)
{
//Console.WriteLine(e.Message);
}
finally
{
client.Close();
}
}
//thread Loop
private void ProccessClient(object cl)
{
TcpClient client = (TcpClient)cl;
if (authorizeClient(client))
{
try
{
StreamReader reader = new StreamReader(client.GetStream());
//Recevoir d'id d'image et id du projet
String projectId = reader.ReadLine();
String imageId = reader.ReadLine();
Console.WriteLine(imageId);
NetworkStream netStream = client.GetStream();
MemoryStream ms = new MemoryStream();
netStream.CopyTo(ms);
Image receivedImg = Image.FromStream(ms);
//Enregistrer l'image
saveImage(receivedImg, imageId, projectId);
client.Close();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
if (client != null)
{
client.Close();
}
}
}
else
{
return;
}
}
public static void ProcessRequest(byte[] buf, int bufLength, NetworkStream browserStream)
{
try
{
char[] splitCharsArray = new char[] { '\r', '\n' };
string[] buffer = Encoding.UTF8.GetString(buf).Trim().Split(splitCharsArray);
string host = buffer.FirstOrDefault(x => x.Contains("Host"));
host = host.Substring(host.IndexOf(":") + 2);
string[] port = host.Trim().Split(new char[] { ':' });
TcpClient sender;
string hostname = port[0];
// Если в массиве есть имя хоста и порт подключения.
if (port.Length == 2)
{
sender = new TcpClient(hostname, int.Parse(port[1]));
}
else
{
sender = new TcpClient(hostname, 80);
}
NetworkStream serverStream = sender.GetStream();
// Отправка запроса серверу.
serverStream.Write(CutPath(buf), 0, bufLength);
byte[] answer = new byte[65536];
// Получение ответа от сервера.
int length = serverStream.Read(answer, 0, answer.Length);
string[] head = Encoding.UTF8.GetString(answer).Split(splitCharsArray);
// Выборка кода ответа.
string ResponseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
Console.WriteLine(host + " " + ResponseCode);
browserStream.Write(answer, 0, length);
serverStream.CopyTo(browserStream);
serverStream.Close();
}
catch
{
return;
}
finally
{
browserStream.Close();
}
}
public void GetResponse(NetworkStream browser, byte[] buffer)
{
TcpClient server;
string responseInfo;
string responseCode;
try
{
buffer = AbsoluteToRelative(buffer);
string[] tempArr = Encoding.ASCII.GetString(buffer).Trim().Split(new char[] { '\r', '\n' });
string request = tempArr.FirstOrDefault(x => x.Contains("Host"));
request = request.Substring(request.IndexOf(":") + 2);
//Get name and port (if possible)
string[] hostAndPort = request.Trim().Split(new char[] { ':' });
//If we have port - coonect with this port, if no - 80
if (hostAndPort.Length == 2)
{
server = new TcpClient(hostAndPort[0], int.Parse(hostAndPort[1]));
}
else
{
server = new TcpClient(hostAndPort[0], 80);
}
NetworkStream serverStream = server.GetStream();
//Send data from browser to server
serverStream.Write(buffer, 0, buffer.Length);
//Response from server
var bufResponse = new byte[32];
serverStream.Read(bufResponse, 0, bufResponse.Length);
//Send this response to browser
browser.Write(bufResponse, 0, bufResponse.Length);
//Get the response code
string[] partsOfResponse = Encoding.UTF8.GetString(bufResponse).Split(new char[] { '\r', '\n' });
responseCode = partsOfResponse[0].Substring(partsOfResponse[0].IndexOf(" ") + 1);
responseInfo = request + " " + responseCode;
Console.WriteLine(responseInfo);
serverStream.CopyTo(browser);
}
catch { return; }
}
public void CopyTo()
{
try
{
clientStream.CopyTo(upstream);
}
catch (ObjectDisposedException)
{
Log.Information("the reader has closed");
}
catch (IOException)
{
Log.Information("the reader has closed");
}
}
public void Download(String filename, FileEndPoint ep, String outFileName)
{
TcpClient client = new TcpClient(ep.IpAddress, ep.Port);
StreamWriter sw = new StreamWriter(client.GetStream());
sw.WriteLine("GET " + filename);
sw.Flush();
NetworkStream fromStream = client.GetStream();
FileStream toStream = File.Create(Configurations.FileClientPath + outFileName);
fromStream.CopyTo(toStream);
toStream?.Close();
client?.Close();
}
public void ConnectAndReceive()
{
try
{
string path = @"C:\Users\Dawid\Desktop\Studia\ProjektServerKlient\Receive\Profile.png";
if (File.Exists(path))
{
File.Delete(path);
}
//TcpClient zgodnie z tym co podano w konsoli
Console.WriteLine("Próba połączenia z {0}:{1}", server, port);
TcpClient client = new TcpClient(this.server, this.port);
NetworkStream stream = client.GetStream();
if (stream != null)
{
using (FileStream fs = File.Create(path))
{
Console.WriteLine("Zapis pliku:{0}", path);
stream.CopyTo(fs);
}
}
Console.WriteLine("Zakończono zapis");
// Close everything.
stream.Close();
client.Close();
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
TryAgain();
}
catch (FileNotFoundException e)
{
Console.WriteLine("FileNotFoundException: {0}", e);
TryAgain();
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e);
TryAgain();
}
Console.Read();
}
public static void ProcessMessage(byte[] buf, int bytesRead, NetworkStream browserStream)
{
try
{
string[] buffer = Encoding.UTF8.GetString(buf).Trim().Split(new char[] { '\r', '\n' });
// if (buffer.Length > 1)
{
string host = buffer.FirstOrDefault(x => x.Contains("Host"));
host = host.Substring(host.IndexOf(":") + 2);
string[] port = host.Trim().Split(new char[] { ':' });
TcpClient sender;
if (port.Length == 2)
{
sender = new TcpClient(port[0], int.Parse(port[1]));
}
else
{
sender = new TcpClient(port[0], 80);
}
NetworkStream serverStream = sender.GetStream();
serverStream.Write(CutPath(buf), 0, bytesRead);
byte[] answer = new byte[65536];
int length = serverStream.Read(answer, 0, answer.Length);
string[] head = Encoding.UTF8.GetString(answer).Split(new char[] { '\r', '\n' });
string ResponseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
Console.WriteLine(host + " " + ResponseCode);
browserStream.Write(answer, 0, length);
serverStream.CopyTo(browserStream);
serverStream.Close();
}
}
catch
{
return;
}
finally
{
browserStream.Close();
}
}
/// <summary>
/// A method for receiving a sent file from a another socket
/// </summary>
/// <param name="Sender">The socket who sent a file</param>
/// <param name="Filepath">The name of file currently being sent</param>
public static void ReceiveFile(this Socket Sender, string Filepath)
{
using (var SenderStream = new NetworkStream(Sender))
{
try
{
using (var fileStream = File.Open(Filepath, FileMode.Create))
{
SenderStream.CopyTo(fileStream);
}
}
catch (SocketException)
{
Logger.LogMessage("An error receiving a file has occured");
throw;
}
}
}
private static string GetMessageFromNetworkStream(NetworkStream stream)
{
string rtn = "";
int total_len = 0;
MemoryStream memoryStream = new MemoryStream();
while (total_len < BUFFER_LEN)
{
stream.CopyTo(memoryStream);
byte[] curBytes = new byte[BUFFER_LEN];
total_len += (int)memoryStream.Length;
rtn += System.Text.Encoding.ASCII.GetString(curBytes);
memoryStream.Read(curBytes, 0, (int)memoryStream.Length);
}
return(rtn);
}
/// <summary>
/// Receives the file.
/// </summary>
/// <param name='fileName'>
/// File name.
/// </param>
/// <param name='io'>
/// Network stream for reading from the server
/// </param>
private void receiveFile(String fileName, NetworkStream io)
{
FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
Console.WriteLine("Filestream created.");
try
{
io.CopyTo(fs, BUFSIZE);
Console.WriteLine("Copy to filestream.");
}
catch (Exception e)
{
Debug.WriteLine(e);
throw;
}
fs.Close();
Console.WriteLine("Filestream closed.");
}
public static void HTTPserv(byte[] buf, TcpClient client)
{
try
{
NetworkStream stream = client.GetStream();
string[] temp = Encoding.ASCII.GetString(buf).Trim().Split(new char[] { '\r', '\n' });
string req = temp.FirstOrDefault(x => x.Contains("Host"));
req = req.Substring(req.IndexOf(" ") + 1);
var blacklist = ConfigurationManager.AppSettings;
foreach (var key in blacklist.AllKeys)
{
if (parser(req).Equals(key))
{
string htmlBody = "<html><body><h1>Error</h1></body></html>";
byte[] errorBodyBytes = Encoding.ASCII.GetBytes(htmlBody);
stream.Write(errorBodyBytes, 0, errorBodyBytes.Length);
return;
}
}
var server = new TcpClient(req, 80);
NetworkStream servStream = server.GetStream();
servStream.Write(buf, 0, buf.Length);
var respBuf = new byte[32];
servStream.Read(respBuf, 0, respBuf.Length);
stream.Write(respBuf, 0, respBuf.Length);
var head = Encoding.UTF8.GetString(respBuf).Split(new char[] { '\r', '\n' });
string ResponseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
Console.WriteLine($"\n{req} {ResponseCode}");
servStream.CopyTo(stream);
}
catch
{
return;
}
finally
{
client.Dispose();
}
}
public static void HTTPserv(byte[] buf, NetworkStream browser, TcpClient client)
{
try
{
string[] temp = Encoding.ASCII.GetString(buf).Trim().Split(new char[] { '\r', '\n' });
string req = temp.FirstOrDefault(x => x.Contains("Host"));
req = req.Substring(req.IndexOf(":") + 2);
string[] port = req.Trim().Split(new char[] { ':' });
TcpClient server;
if (port.Length == 2)
{
server = new TcpClient(port[0], int.Parse(port[1]));
}
else
{
server = new TcpClient(port[0], 80);
}
NetworkStream servStream = server.GetStream();
servStream.Write(buf, 0, buf.Length);
var respBuf = new byte[32];
servStream.Read(respBuf, 0, respBuf.Length);
browser.Write(respBuf, 0, respBuf.Length);
string[] head = Encoding.UTF8.GetString(respBuf).Split(new char[] { '\r', '\n' });
string ResponseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
Console.WriteLine($"\n{req} {ResponseCode}");
servStream.CopyTo(browser);
}
catch
{
return;
}
finally
{
client.Dispose();
}
}
public static void HTTPserv(byte[] buf, NetworkStream browser, TcpClient client)
{
try
{
string[] temp = Encoding.ASCII.GetString(buf).Trim().Split(new char[] { '\r', '\n' });
string req = temp.FirstOrDefault(x => x.Contains("Host"));
req = req.Substring(req.IndexOf(":") + 2);
string[] port = req.Trim().Split(new char[] { ':' }); // получаем хост, имя домена и номер порта (если есть)
TcpClient server;
if (port.Length == 2) // тут мы соединяемся с сервером по имени хоста и если есть порт в запросе то по порту, а если нет то по стандартному 80
{
server = new TcpClient(port[0], int.Parse(port[1]));
}
else
{
server = new TcpClient(port[0], 80);
}
NetworkStream servStream = server.GetStream(); // поток с сервером
servStream.Write(buf, 0, buf.Length); // отправляем данные на сервер, которые получили от браузера
var respBuf = new byte[32]; // для заголовка
servStream.Read(respBuf, 0, respBuf.Length); // ответ от сервера
browser.Write(respBuf, 0, respBuf.Length); // отправляем этот ответ браузеру
string[] head = Encoding.UTF8.GetString(respBuf).Split(new char[] { '\r', '\n' }); // получаем код ответа
string ResponseCode = head[0].Substring(head[0].IndexOf(" ") + 1);
Console.WriteLine($"\n{req} {ResponseCode}");
servStream.CopyTo(browser); // перенаправляем остальные данные от сервера к браузеру
}
catch
{
return;
}
finally
{
client.Dispose();
}
}
protected void handleRemoteCommand(NetworkStream stream, QueuedCommand serverCommand)
{
var emc = encryptMessage(serverCommand);
emc.WriteToStream(stream);
string response;
using (MemoryStream ms = new MemoryStream())
{
stream.CopyTo(ms);
ms.Position = 0;
var emr = EncryptedMessage.FromStream(ms);
response = decryptMessage(emr);
}
serverCommand.ResultSource.SetResult(response);
stream.Close();
}
/// <summary>
/// Get Tcp stream
/// </summary>
/// <returns></returns>
public byte[] GetStream()
{
TcpClient tcp = new TcpClient();
tcp.Connect(EndPoint);
NetworkStream ret = tcp.GetStream();
if (Request != null)
{
ret.Write(Request, 0, Request.Length);
}
using (MemoryStream ms = new MemoryStream())
{
ret.CopyTo(ms);
return(ms.ToArray());
}
}
private bool ReceiveFile(string fileName, string extWithDot, TcpClient localClient)
{
string filepath = serverroot + "/Temp/" + fileName + extWithDot;
int offset = 0;
NetworkStream ns = localClient.GetStream();
int timeout = 100;
while (!ns.DataAvailable && timeout > 0)
{
Thread.Sleep(100);
timeout--;
}
ns.ReadTimeout = 2000;
using (FileStream fs = new FileStream(filepath, FileMode.OpenOrCreate))
{
try
{
ns.CopyTo(fs);
}
catch
{
}
//byte[] buffer = new byte[65536];
//while (ns.DataAvailable)
//{
// int readBytes = ns.Read(buffer, offset, 65535);
// fs.Write(buffer, offset, readBytes);
// offset += readBytes;
//}
}
//ns.Close();
FileInfo fileinfo = new FileInfo(filepath);
if (fileinfo.Length > 0)
{
return(true);
}
else
{
return(false);
}
}
private void ForwardPort(NetworkStream sourceStream, NetworkStream targetStream, PortForwardingOptionEnum portForwardingOption)
{
switch (portForwardingOption)
{
case PortForwardingOptionEnum.Compress:
this.Compress(sourceStream, targetStream);
break;
case PortForwardingOptionEnum.Decompress:
this.Decompress(sourceStream, targetStream);
break;
case PortForwardingOptionEnum.None:
default:
sourceStream.CopyTo(targetStream, this._bufferSize);
break;
}
}
private int AcceptaFisier(string locatieSalvare, string deLa)
{
//TcpListener server = null;
Socket server = null;
int portPrimire;
for (portPrimire = 4000; portPrimire < 65535; portPrimire++)
{
try
{
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(new IPEndPoint(IPAddress.Any, portPrimire));
server.Listen(10);
break;
}
catch (Exception e) { }
}
if (server == null)
return -1;
Thread fir = new Thread(() =>
{
Socket client = server.Accept();
Stream stream = File.Open(locatieSalvare, FileMode.Create);
NetworkStream streamClient = new NetworkStream(client, true);
streamClient.CopyTo(stream);
client.Close();
stream.Close();
fPrincipala.FereastraPentru(deLa).AdaugaTextAutomat("S-a terminat descărcarea fișierului în „"
+ new FileInfo(locatieSalvare).FullName + "”.");
});
fir.IsBackground = true;
fir.Start();
return portPrimire;
}
