/// <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)
{
int fileSize = (int)LIB.getFileSizeTCP(io);
//File.WriteAllText(fileName,LIB.readTextTCP(io);
if (fileSize > 0)
{
Byte[] receivingBuffer = new byte[BUFSIZE];
Console.WriteLine(fileSize);
FileStream DataWeWant = new FileStream(fileName, FileMode.Create, FileAccess.Write);
int totalNumberOfReceivedBytes = 0;
// læs mens der stadig er ting tilbage
while (totalNumberOfReceivedBytes < fileSize)
{
int bytesRead = io.Read(receivingBuffer, 0, receivingBuffer.Length);
DataWeWant.Write(receivingBuffer, 0, bytesRead);
totalNumberOfReceivedBytes += bytesRead;
Array.Clear(receivingBuffer, 0, BUFSIZE);
}
DataWeWant.Close();
io.Close();
Console.WriteLine("File Received: {0} Bytes", fileSize);
}
else
{
Console.WriteLine("No file found");
}
}
/// <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, long fileSize)
{
fileName = LIB.extractFileName(fileName);
string dataDir = "/root/Desktop/ExFiles/";
Directory.CreateDirectory(dataDir);
FileStream file = new FileStream(dataDir + fileName, FileMode.Create, FileAccess.Write);
byte[] data = new byte[BUFSIZE]; //Vi modtager kun 1k bytes af gangen
int totalBytes = 0;
int bytesRead;
Console.WriteLine("Reading file " + fileName + " ... ");
//while ((bytesRead = io.Read(data, 0, data.Length)) > 0) //Nu bliver den ved indtil længden af det den modtager er 0
while (fileSize > totalBytes)
{
bytesRead = io.Read(data, 0, data.Length);
file.Write(data, 0, bytesRead);
totalBytes += bytesRead;
Console.WriteLine("Read bytes: " + bytesRead.ToString() + "\t Total bytes read:" + totalBytes);
}
Console.WriteLine("File received");
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
/// </summary>
/// <param name='args'>
/// The command-line arguments. First ip-adress of the server. Second the filename
/// </param>
private file_client(string[] args)
{
try
{
TcpClient client = new TcpClient(args[0], PORT);
NetworkStream stream = client.GetStream();
Console.WriteLine("Client stream connected");
LIB.writeTextTCP(stream, args[1]);
Console.WriteLine("Write " + args[1] + " to server");
long fileSize = LIB.getFileSizeTCP(stream);
Console.WriteLine("Get filesize: " + fileSize);
string fileName = LIB.extractFileName(args[1]); //Hvis en sti indtastes findes filnavnet fra denne.
if (fileSize > 0) //Check if file exists on server, and recieve.
{
receiveFile(AppDomain.CurrentDomain.BaseDirectory + "/" + fileName, stream);
}
else
{
Console.WriteLine("File does not exist on server");
}
client.GetStream().Close();
Console.WriteLine("Close stream");
client.Close();
Console.WriteLine("Close client");
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine($"Fejl: Kunne ikke oprette forbindelse til {args[0]}, indtast en valid IP adresse.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
/// </summary>
/// <param name='args'>
/// The command-line arguments. First ip-adress of the server. Second the filename
/// </param>
private file_client(string[] args)
{
TcpClient client = new TcpClient();
//Sikrer connection til det angivne Port
client.Connect(args[0], PORT);
Console.WriteLine($"'{args[0]}' Has been connected <---");
//Requester client streamet
NetworkStream server = client.GetStream();
Console.WriteLine($"'{args[1]}'Filename requested <---");
string File_Name = args[1];
LIB.writeTextTCP(server, File_Name);
long File_Size = LIB.getFileSizeTCP(server);
//Sædvanlige check om filen eksistere eller ej
while (File_Size == 0)
{
Console.WriteLine("File not found!");
File_Name = Console.ReadLine();
Console.WriteLine($"Requesting this file ---> '{File_Name}'");
LIB.writeTextTCP(server, File_Name);
File_Size = LIB.getFileSizeTCP(server);
}
Console.WriteLine("Size of file ---> " + File_Size);
receiveFile(File_Name, server, File_Size);
}
private void sendFile(String filePath, long fileSize, NetworkStream io)
{
LIB.writeTextTCP(io, fileSize.ToString());
long length = new System.IO.FileInfo(filePath).Length;
FileStream fs = new FileStream(filePath, FileMode.Open);
byte[] fileBuf = new byte[1000];
int offset = 0;
int size = 1000;
while (offset < length)
{
fs.Read(fileBuf, 0, size);
io.Write(fileBuf, 0, size);
offset += 1000;
if ((offset < length) && (offset + 1000 > length))
{
size = (int)length - offset;
}
}
fs.Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
IPAddress IP = IPAddress.Parse("10.0.0.1");
var Socket = new TcpListener(IP, PORT);
TcpClient ClientSocket = default(TcpClient);
Socket.Start();
Console.WriteLine("SERVER STARTED");
while (true)
{
Console.WriteLine("Waiting for Client");
ClientSocket = Socket.AcceptTcpClient();
Console.WriteLine("Client accepted");
NetworkStream networkStream = ClientSocket.GetStream();
string filepath = LIB.readTextTCP(networkStream); // modtager fil-sti
long filesize = LIB.check_File_Exists(filepath); // checker fil
if (filesize != 0)
{
Console.WriteLine("Sending file");
LIB.writeTextTCP(networkStream, filesize.ToString()); // sender filesize
sendFile(filepath, filesize, networkStream); // sender fil
Console.WriteLine("File sent!");
}
else
{
LIB.writeTextTCP(networkStream, "Kan ikke finde fil");
}
ClientSocket.Close();
}
}
/// <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)
{
// Adding null terminator to fileName
LIB.writeTextTCP(io, fileName + "\0");
long fileSize = LIB.getFileSizeTCP(io);
// If getting filesize fails, return
if (fileSize == -1)
{
Console.WriteLine("File not found!");
return;
}
byte[] file = new byte[fileSize];
int received = 0;
// Loop till all files received
while (received < fileSize)
{
if (fileSize - received < BUFSIZE)
{
int lastRead = io.Read(file, received, (int)fileSize - received);
received = received + lastRead;
}
else
{
int read = io.Read(file, received, BUFSIZE);
received = received + read;
}
}
File.WriteAllBytes(LIB.extractFileName(fileName), file);
Console.WriteLine(LIB.extractFileName(fileName) + " received!");
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
/// </summary>
/// <param name='args'>
/// The command-line arguments. First ip-adress of the server. Second the filename
/// </param>
private file_client(string[] args)
{
Console.WriteLine("trying to connect...");
//etabler tcp forbindelsen
TcpClient NyTcpSocket = new TcpClient();
NyTcpSocket.Connect(args [0], PORT);
//sæt streameren til at snakke på den nu åbne tcp connection
NetworkStream fileStream = NyTcpSocket.GetStream();
//Skriv til server at vi ønsker den og den fil.
LIB.writeTextTCP(fileStream, args [1]);
//string ModtagetStatus = LIB.readTextTCP (fileStream);
receiveFile(args [1], fileStream);
//reager på det der kommer tilbage, hvis det ikke er null.
// luk forbindelsen.
fileStream.Close();
NyTcpSocket.Close();
// TO DO Your own code
}
/// <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 filePath, NetworkStream io)
{
string fileName = string.Empty;
string fileDirectory = string.Empty;
long fileSize = 0;
int bytesRead = 0;
byte[] buffer = new byte[BUFSIZE];
//Create directory for file
fileDirectory = "/root/Desktop/ServerFiles/";
Directory.CreateDirectory(fileDirectory);
fileName = LIB.extractFileName(filePath);
FileStream Fs = new FileStream(fileDirectory + fileName, FileMode.OpenOrCreate, FileAccess.Write);
Console.WriteLine("Reading file " + fileName + "...");
//Writes into file as long as it receives bytes, bytesRead>0
do
{
bytesRead = io.Read(buffer, 0, BUFSIZE);
Fs.Write(buffer, 0, bytesRead);
Console.WriteLine("Read bytes: " + bytesRead.ToString());
}while (bytesRead > 0);
//Lukker fil
Fs.Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
/// </summary>
/// <param name='args'>
/// The command-line arguments. First ip-adress of the server. Second the filename
/// </param>
private file_client(string[] args)
{
// TO DO Your own code
TcpClient clientSocket = new TcpClient();
Console.WriteLine(" >> Client connecting");
clientSocket.Connect(args[0], PORT);
NetworkStream serverStream = clientSocket.GetStream();
LIB.writeTextTCP(serverStream, args[1]);
long size = LIB.getFileSizeTCP(serverStream);
if (size != 0)
{
string fileName = LIB.extractFileName(args[1]);
receiveFile(fileName, serverStream, size);
}
else
{
Console.WriteLine(LIB.readTextTCP(serverStream));
}
serverStream.Flush();
clientSocket.Close();
}
/// <param name='fname'>
/// File name.
/// </param>
/// <param name='output'>
/// Network stream for reading from the server
/// </param>
private void receiveFile(String fname, NetworkStream output, long file_size)
{
fname = LIB.extractFileName(fname);
//Opretter mappe og putter ind til denne directory
string data_directory = "/root/Desktop/TilTorben/";
Directory.CreateDirectory(data_directory);
FileStream file = new FileStream(data_directory + fname, FileMode.Create, FileAccess.Write);
byte[] data = new byte[BUFSIZE];
int bytes_total = 0;
int bytes_read;
Console.WriteLine("Reading file! " + fname);
//Løkke - der tjekker størrelsen af filen og skriver til bytes read - som læses fra i cw
while (file_size > bytes_total)
{
bytes_read = output.Read(data, 0, data.Length);
file.Write(data, 0, bytes_read);
bytes_total += bytes_read;
Console.WriteLine("Reading bytes = " + bytes_read.ToString() + "\t Total bytes read = " + bytes_total);
}
Console.WriteLine("File received");
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
/// </summary>
/// <param name='args'>
/// The command-line arguments. First ip-adress of the server. Second the filename
/// </param>
private file_client(string[] args)
{
// TO DO Your own code
TcpClient clientSocket = new TcpClient();
clientSocket.Connect(args[0], PORT);
Console.WriteLine("Client connected...");
NetworkStream network = clientSocket.GetStream();
LIB.writeTextTCP(network, args[1]);
fileSize = LIB.getFileSizeTCP(network);
Console.WriteLine("File size from server: {0}", fileSize, " bytes");
if (fileSize == 0)
{
throw new Exception("File not found..!");
}
else
{
receiveFile(args[1], network);
Console.WriteLine("Received file(s)...");
}
}
private void ReceiveFile(string fileName, NetworkStream io)
{
var fileSize = (int)LIB.getFileSizeTCP(io);
if (fileSize != 0)
{
var totalAmountReceived = 0;
var bytes = new byte[BUFSIZE];
var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
while (totalAmountReceived < fileSize)
{
// Kunne man ikke også bare have brugt BUFSIZE her?
var bytesRead = io.Read(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytesRead);
totalAmountReceived += bytesRead;
Array.Clear(bytes, 0, BUFSIZE);
}
fs.Close();
//io.Close(); // Det behøver man vel ikke?
}
else
{
Console.WriteLine("No file found!");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
TcpListener serverSocket = null;
TcpClient clientSocket = null;
try{
//SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
//TcpListener serverSocket = new TcpListener(PORT);
serverSocket = new TcpListener(IPAddress.Any, PORT);
clientSocket = default(TcpClient);
serverSocket.Start();
while (true)
{
Console.WriteLine(" >> Server Started listening for request");
clientSocket = serverSocket.AcceptTcpClient();
Console.WriteLine($" Forbindelse til {clientSocket.ToString()}");
NetworkStream networkStream = clientSocket.GetStream();
//byte[] bytesFrom = new byte[1000];
Console.WriteLine((int)clientSocket.ReceiveBufferSize);
string dataFromClient = LIB.readTextTCP(networkStream);
dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
long length = LIB.check_File_Exists(dataFromClient);
Console.WriteLine(" >> Data from client - " + dataFromClient);
string serverResponse = length.ToString();
if (length < 1)
{
serverResponse = "Filen kunne ikke lokaliseres";
}
LIB.writeTextTCP(networkStream, serverResponse);
Console.WriteLine(" >> " + serverResponse);
if (length > 0)
{
sendFile(dataFromClient, length, networkStream);
}
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
clientSocket.Close();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
String clientData = null;
IPAddress localAddress = IPAddress.Any;
TcpListener serverSocket = new TcpListener(localAddress, PORT);
serverSocket.Start();
while (true)
{
try
{
Console.WriteLine("Waiting for connection...");
TcpClient client = serverSocket.AcceptTcpClient();
Console.WriteLine("Client connected!");
NetworkStream stream = client.GetStream();
Console.WriteLine("Stream created.");
clientData = LIB.readTextTCP(stream);
Console.WriteLine("Read data from client.");
String requestedFile = LIB.extractFileName(clientData);
Console.WriteLine("Extracted " + requestedFile + "from client.");
//til filer på vilkårlige placeringer
long FileLength = LIB.check_File_Exists(clientData);
if (FileLength > 0) //tjekker om filen findes på den givne sti
{
Console.WriteLine($"Fuld sti:{clientData}" +
$"\nstørrelse:{FileLength}");
LIB.writeTextTCP(stream, FileLength.ToString()); //sender størrelsen på filen til client
SendFile(clientData, stream);
Console.WriteLine("File sent.");
}
else
{
LIB.writeTextTCP(stream, 0.ToString()); //hvis filen ikke findes skrives der blot 0 til clienten
}
client.GetStream().Close();
Console.WriteLine("Close stream");
client.Close();
Console.WriteLine("Close client");
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
private file_server()
{
TcpListener server = null;
try
{
server = new TcpListener(PORT);
server.Start();
TcpClient client = null;
byte[] from = new byte[BUFSIZE];
string fileReq = null;
while (true)
{
Console.WriteLine("Waiting for connection");
client = server.AcceptTcpClient();
Console.WriteLine("Someone connected");
//resetting string for new request.
fileReq = null;
NetworkStream nStream = client.GetStream();
//File request from client
fileReq = LIB.readTextTCP(nStream);
Console.WriteLine("got: {0}", fileReq);
/*Getting filename and then
* Checking if file exist on system, els returns 0.*/
string file = LIB.extractFileName(fileReq);
long file_len = LIB.check_File_Exists(file);
sendLength(file_len, nStream);
if (file_len > 0)
{
//Delay to ensure nStream is ready.
System.Threading.Thread.Sleep(10);
sendFile(file, file_len, nStream);
}
client.Close();
}
}
catch (Exception e)
{
Console.WriteLine("Socket expection: {0}", e);
}
finally
{
server.Stop();
}
}
/// <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)
{
LIB.writeTextTCP(io, fileName + "$");
string lenghtString = LIB.readTextTCP(io);
long fileSize;
try
{
fileSize = long.Parse(lenghtString);
}
catch (System.FormatException)
{
Console.WriteLine(lenghtString);
return;
}
if (fileSize < 1)
{
Console.WriteLine("Vi er stødt på en fejl. længden er rapporteret som 0 :(");
return;
}
Console.WriteLine("length= " + lenghtString);
if (File.Exists(fileName))
{
File.Delete(fileName);
}
//https://stackoverflow.com/a/2398471
using (var fileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.None))
using (var bw = new BinaryWriter(fileStream))
{
int i;
for (i = 0; i < fileSize - 1000; i += 1000)
{
byte[] bytearray = new byte[1000];
io.Read(bytearray, 0, 1000);
Console.WriteLine(i.ToString());
bw.Write(bytearray);
Console.WriteLine($"Wrote: {bytearray[900]}\n");
}
byte[] lastChunk = new byte[1000];
io.Read(lastChunk, 0, 1000);
Console.WriteLine(i.ToString());
bw.Write(lastChunk, 0, (int)fileSize % 1000);
Console.WriteLine($"Wrote: {lastChunk[900]}\n");
}
}
/// <summary>
/// The entry point of the program, where the program control starts and ends.
/// </summary>
/// <param name='args'>
/// The command-line arguments.
/// </param>
public static void Main(string[] args)
{
Console.WriteLine("Server starts...");
new file_server();
TcpListener serverSocket = new TcpListener(PORT);
serverSocket.Start();
Console.WriteLine("Server socket started");
while (true)
{
try
{
TcpClient clientSocket = serverSocket.AcceptTcpClient();
Console.WriteLine("Client acceped");
NetworkStream networkStream = clientSocket.GetStream();
Console.WriteLine("Got stream");
string path = LIB.readTextTCP(networkStream);
Console.WriteLine("Path received:" + path);
string fileName = LIB.extractFileName(path);
long fileLength = LIB.check_File_Exists(fileName);
Console.WriteLine(fileName);
if (fileLength == 0) //File not found
{
Console.WriteLine("File length: " + fileLength.ToString());
LIB.writeTextTCP(networkStream, fileLength.ToString());
clientSocket.Close();
}
else // File found
{
Console.WriteLine("File length sent: " + fileLength.ToString());
LIB.writeTextTCP(networkStream, fileLength.ToString());
Thread.Sleep(1);
sendFile(path, fileLength, networkStream);
clientSocket.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{
}
}
serverSocket.Stop();
Console.WriteLine(" >> exit");
Console.ReadLine();
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
/// </summary>
/// <param name='args'>
/// The command-line arguments. First ip-adress of the server. Second the filename
/// </param>
private file_client(string[] args)
{
try
{
string ipa = args [0];
IPAddress ipAddress = IPAddress.Parse(ipa);
TcpClient clientSocket = new TcpClient();
clientSocket.Connect(ipAddress, PORT);
NetworkStream serverStream = clientSocket.GetStream();
// Send filename to server
string filename = args [1];
LIB.writeTextTCP(serverStream, filename);
// Extract filename
string extractedFilename = LIB.extractFileName(filename);
// Recieve notice if filename exists
long currentfilesize = LIB.getFileSizeTCP(serverStream);
//Console.WriteLine (currentfilesize);
// If filename exists recieve file
if (currentfilesize != 0)
{
receiveFile(extractedFilename, serverStream, currentfilesize);
}
else
{
Console.WriteLine("Filename: " + extractedFilename + " does not exist");
}
}
catch (ArgumentException e)
{
Console.WriteLine("ArgumentException: " + e.Message);
}
catch (SocketException se)
{
Console.WriteLine("SocketException: " + se.Message);
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
}
private long sendFileSize(Transport trans, string fileName)
{
//checks if file exist
long size = LIB.check_File_Exists(fileName);
//Send size to client
Console.WriteLine("\nSending size:");
var sizeInBytes = System.Text.Encoding.UTF8.GetBytes(size.ToString());
trans.send(sizeInBytes, sizeInBytes.Length);
return(size);
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
// Create the local endpoint for the socket and the TCP/IP socket
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, PORT);
Socket server = new Socket(SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local endpoint
try
{
server.Bind(endPoint);
// Listen for connections
server.Listen(10);
while (true)
{
Console.WriteLine("Listening...");
Socket handler = server.Accept();
// Create networkstream and connect it to socket
NetworkStream networkStream = new NetworkStream(handler);
string fileNameAndPath = LIB.readTextTCP(networkStream);
Console.WriteLine("Requested file: " + fileNameAndPath);
long fileSize = LIB.check_File_Exists(fileNameAndPath);
// If file doesnt exist, close the networkstream, shutdown the socket and close it
if (fileSize < 1)
{
Console.WriteLine("File not found!");
LIB.writeTextTCP(networkStream, "-1");
networkStream.Close();
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
else
{
sendFile(fileNameAndPath, fileSize, networkStream);
networkStream.Close();
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
private file_client(string[] args)
{
// Setting Path and IP
SetPathAndIP(args);
try
{
TcpClient client = new TcpClient(ServerIP, PORT);
// Get a client stream for reading and writing.
// Stream stream = client.GetStream();
NetworkStream stream = client.GetStream();
Console.WriteLine($"Requesting server for file: {FileFromServer}");
LIB.writeTextTCP(stream, FilePathServer);
fileSize = LIB.getFileSizeTCP(stream);
if (fileSize > 0)
{
Console.WriteLine($"File exists and has size {fileSize}");
Console.WriteLine("Saving file...");
receiveFile(FileSavePath, stream);
}
else
{
Console.WriteLine("File does not exist.");
}
client.Close();
}
catch (ArgumentNullException e)
{
Console.WriteLine("ArgumentNullException: {0}", e);
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
// TO DO Your own code
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
TcpListener serverSocket = new TcpListener(new IPAddress(ipAddress), PORT);
try
{
serverSocket.Start();
while (true)
{
TcpClient newClient = serverSocket.AcceptTcpClient();
Console.WriteLine("Client Accepted...");
// Recieve filename from client
NetworkStream networkStream = newClient.GetStream();
String filename = LIB.readTextTCP(networkStream);
// Check to see if filename exists and notify client
long filesize = LIB.check_File_Exists(filename);
//Console.WriteLine (filesize);
string filesizeascii = filesize.ToString();
LIB.writeTextTCP(networkStream, filesizeascii);
if (filesize != 0)
{
sendFile(filename, filesize, networkStream);
}
newClient.Close();
}
}
catch (ArgumentException e)
{
Console.WriteLine("ArgumentException: " + e.Message);
}
catch (SocketException se)
{
Console.WriteLine("SocketException: " + se.Message);
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
finally {
serverSocket.Stop();
}
}
private long sendFileSize(Transport trans, string fileName)
{
//checks if file exist
long size = LIB.check_File_Exists(fileName);
//Send size to client
Console.WriteLine(" >> Size of file: " + size + " long");
var sizeInBytes = BitConverter.GetBytes(size); // System.Text.Encoding.UTF8.GetBytes(size.ToString());
Console.WriteLine("SIZE OF ARRAY " + sizeInBytes.Length);
trans.send(sizeInBytes, sizeInBytes.Length);
return(size);
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
// TO DO Your own code
TcpListener serverSocket = new TcpListener(localAddr, PORT);
serverSocket.Start();
while (true)
{
try
{
Console.WriteLine("Waiting for a connection...");
// Accept requests
TcpClient client = serverSocket.AcceptTcpClient();
Console.WriteLine("Connected to client!");
NetworkStream stream = client.GetStream();
string fileName = LIB.readTextTCP(stream);
Console.WriteLine($"Client asks for file: {fileName}");
Console.WriteLine("Cheking if file exists...");
long fileSize = LIB.check_File_Exists(fileName);
if (fileSize > 0)
{
Console.WriteLine($"File exists an has size: {fileSize}");
LIB.writeTextTCP(stream, fileSize.ToString());
sendFile(fileName, fileSize, stream);
}
else
{
Console.WriteLine("File does not exist");
LIB.writeTextTCP(stream, fileSize.ToString());
}
client.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
// Starts server and accepts a client
Console.WriteLine("Starting server - waiting for client --->");
//Opretter en socket
TcpListener Server_Socket = new TcpListener(IPAddress.Any, PORT);
TcpClient Client_Socket = default(TcpClient);
//Starter serveren og connectecter til client vha Accept funktionen
Server_Socket.Start();
Client_Socket = Server_Socket.AcceptTcpClient();
Console.WriteLine("Connected to client!");
// getter client stream
NetworkStream client = Client_Socket.GetStream();
//Istantiering af filename til at læse og checke om file size eksistere
string File_Name = LIB.readTextTCP(client);
long File_Size = LIB.check_File_Exists(File_Name);
// loop - der tjekker om filen er fundet.
while (File_Size == 0)
{
string msg = "File '" + File_Name + "' not found";
Console.WriteLine(msg);
LIB.writeTextTCP(client, File_Size.ToString());
File_Name = LIB.readTextTCP(client);
File_Size = LIB.check_File_Exists(File_Name);
}
//Udskriver filnavn og størrelsen som er initialiseret
Console.WriteLine("Filename: " + File_Name);
Console.WriteLine("Size: " + File_Size);
//Skriver texten til client stream
LIB.writeTextTCP(client, File_Size.ToString());
sendFile(File_Name, client);
//Lukker programmet
Client_Socket.Close();
Server_Socket.Stop();
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
//opret socket
TcpListener serverSocket = new TcpListener(localAddr, PORT);
TcpClient clientSocket = default(TcpClient);
serverSocket.Start();
Console.WriteLine("Server started");
while (true)
{
//wait for client
clientSocket = serverSocket.AcceptTcpClient();
Console.WriteLine("client connected");
//opretter en stream fra client
NetworkStream serverStreamIO = clientSocket.GetStream();
Console.WriteLine(" >> Accepted connection from client");
//modtager filnavn
string fileDir; //= @"/root/Desktop/IKNServerClientTCP/Exercise_6_server/file_server/bin/Debug/files/";
string userfile = tcp.LIB.readTextTCP(serverStreamIO);
fileDir = userfile;
//check for exsitens af fil
long lengthOfFile = tcp.LIB.check_File_Exists(fileDir);
if (lengthOfFile != 0) //filen findes
{
Console.WriteLine("filen findes " + fileDir);
//find størrelsen på filen
//long filesize = new System.IO.FileInfo (fileDir).Length;
long filesize = LIB.check_File_Exists(fileDir);
//send the file
sendFile(fileDir, filesize, serverStreamIO);
}
else //filen exsitere ikke
{
Console.WriteLine("Filen findes ikke " + fileDir);
tcp.LIB.writeTextTCP(serverStreamIO, "filen findes ikke");
}
//clientSocket.Close ();
}
serverSocket.Stop();
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// Opretter en socket.
/// Venter på en connect fra en klient.
/// Modtager filnavn
/// Finder filstørrelsen
/// Kalder metoden sendFile
/// Lukker socketen og programmet
/// </summary>
private file_server()
{
TcpListener serverSocket = new TcpListener(IPAddress.Any, PORT);
TcpClient clientSocket = default(TcpClient);
serverSocket.Start();
byte[] bytes = new byte[BUFSIZE];
string data;
while (true)
{
clientSocket = serverSocket.AcceptTcpClient();
Console.WriteLine("Accept conn from client");
NetworkStream network = clientSocket.GetStream();
try
{
data = LIB.readTextTCP(network);
Console.WriteLine("{0}", data);
long fileLength = LIB.check_File_Exists(data);
string fileName = LIB.extractFileName(data);
Console.WriteLine("File name: {0}", fileName);
Console.WriteLine("File length: {0}", fileLength);
LIB.writeTextTCP(network, fileLength.ToString());
sendFile(data, fileLength, network);
Console.WriteLine("Closing connection to client...");
Console.WriteLine("Returning to idle.");
clientSocket.GetStream().Close();
clientSocket.Close();
}
catch (FileNotFoundException ex)
{
Console.WriteLine("File not found..!");
throw ex;
}
}
}
private file_client(string[] args)
{
Console.WriteLine("Trying to connect...");
// Opretter forbindelse til Client:
var client = new TcpClient();
client.Connect(args[0], PORT);
// Aktivere stream på den åbne forbindelsen:
var stream = client.GetStream();
// Kontakter serveren og angiver hvilken fil:
LIB.writeTextTCP(stream, args[1]);
ReceiveFile(args[1], stream);
stream.Close();
client.Close();
}
/// <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)
{
var fs = new FileStream($"/root/Client/{fileName}", FileMode.OpenOrCreate);
byte[] inStream = new byte[BUFSIZE];
int size = int.Parse(filesize);
int ReceivedData = 0;
int DataLeft = size;
while (ReceivedData < size)
{
int readBytes = io.Read(inStream, 0, BUFSIZE);
fs.Write(inStream, 0, readBytes);
ReceivedData += readBytes;
DataLeft -= readBytes;
}
LIB.extractFileName(fileName);
}
