/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
Console.WriteLine("FileServer: Started");
var transport = new Transport(BUFSIZE, APP);
var fileByte = new byte[BUFSIZE];
transport.Receive(ref fileByte);
var filePath = Encoding.Default.GetString(fileByte);
filePath = filePath.TrimEnd('\0');
var fileName = LIB.extractFileName(filePath);
var fileSize = LIB.check_File_Exists(filePath);
if (fileSize <= 0)
{
Console.WriteLine("File not found. Closing connection");
}
else
{
Console.WriteLine("Found file named: {0} \n File Size: {1}", fileName, fileSize);
sendFile(filePath, fileSize, transport);
}
Console.WriteLine("File transfer done. Closing connection");
}
public ActionResult Index()
{
//user = userDA.selectUserPassword("CJ");
// product = productDA.selectProductCategory();
//product = productDA.selectALLCategory();
//List<int> ID = new List<int>();
//List<string> Type = new List<string>();
//List<string> Description = new List<string>();
//List<bool> Deleted = new List<bool>();
//ID.Add(8);
//Type.Add("Alibab3");
//Description.Add("");
//Deleted.Add(true);
//product.ID = ID;
//product.Type = Type;
//product.Description = Description;
//product.Deleted = Deleted;
//int result = productDA.updateProductCategory(product);
user.LoginID = "Testing123";
user.LoginPassword = "******";
if (LIB.insertFunction(user, "[User]") > 0)
{
ViewBag.Message = "Successful Insert";
}
return(View());
}
/// <summary>
/// Receives the file.
/// </summary>
/// <param name='fileName'>
/// File name.
/// </param>
/// <param name='transport'>
/// Transportlaget
/// </param>
private void ReceiveFile(string path, long fileSize, Transport transport)
{
byte[] fileBuffer = new byte[BUFSIZE];
string fileName = LIB.extractFileName(path);
var readSize = 0;
var read = 0;
Console.WriteLine("Receiving file..");
FileStream newFile = new FileStream(fileName, FileMode.Create, FileAccess.Write);
while (read < fileSize && (readSize = transport.Receive(ref fileBuffer)) > 0)
{
newFile.Write(fileBuffer, 0, readSize);
read += readSize;
}
if (read == fileSize)
{
Console.WriteLine("The requested file was received");
}
else
{
Console.WriteLine("An error occured while downloading file..");
}
newFile.Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
Transport transport = new Transport(BUFSIZE, APP);
try
{
Console.WriteLine("Server ready - Awaiting Client");
string fileToSend = transport.readText();
Console.WriteLine("Client connected, want to pick up: " + fileToSend);
long fileSize = LIB.check_File_Exists(fileToSend);
if (fileSize != 0)
{
transport.sendText("FileFound");
Console.WriteLine($"File {LIB.extractFileName(fileToSend)} exists. Transmitting... ");
sendFile(fileToSend, fileSize, transport);
}
else
{
transport.sendText("NoFileFound");
Console.WriteLine($"File {LIB.extractFileName(fileToSend)} do NOT exists. Aborting Transmission... ");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
//finally
//{
// Console.WriteLine("Exits");
//}
}
public void receiveFile()
{
NetworkStream serverStream = _clientSocket.GetStream();
serverStream.ReadTimeout = 10;
LIB.writeTextTCP(serverStream, _fileOnServer);
byte[] buffer = new byte[1000];
FileStream fileWriter = new FileStream(_fileDestination, FileMode.Create);
int expectedNumOfBytes;
int.TryParse(LIB.readTextTCP(serverStream), out expectedNumOfBytes);
Console.WriteLine("ExpectedNumOfBytes :: {0}", expectedNumOfBytes);
int totalBytesRead = 0;
int thisTransferBytesRead = 0;
if (expectedNumOfBytes > 0)
{
do
{
thisTransferBytesRead = serverStream.Read(buffer, 0, buffer.Length);
if (thisTransferBytesRead == 0)
{
break;
}
fileWriter.Write(buffer, 0, thisTransferBytesRead);
totalBytesRead += thisTransferBytesRead;
} while(serverStream.DataAvailable || expectedNumOfBytes != totalBytesRead);
}
Console.WriteLine("ClientProgram :: Done reading {0} KB from Network Stream", totalBytesRead / 1000);
serverStream.Close();
_clientSocket.Close();
}
private file_server()
{
while (true)
{
try
{
ITransport trans = new Transport(BUFSIZE, APP);
byte[] buffer = new byte[BUFSIZE];
int fileLength = 0;
fileLength = trans.Receive(ref buffer);
string fileName = Encoding.Default.GetString(buffer, 0, fileLength);
//check_File_Exists returns filesize
long fileSize = LIB.check_File_Exists(fileName);
Console.WriteLine($"Received request for: {fileName}");
//Convert filesize to byte array
buffer = BitConverter.GetBytes(fileSize);
trans.Send(buffer, buffer.Length);
if (fileSize == 0)
{
throw new FileNotFoundException();
}
sendFile(fileName, fileSize, trans);
}
catch (FileNotFoundException e)
{
Console.WriteLine("File not found...");
throw e;
}
}
}
/// <summary>
/// Sends the file.
/// </summary>
/// <param name='fileName'>
/// File name.
/// </param>
/// <param name='fileSize'>
/// File size.
/// </param>
/// <param name='tl'>
/// Tl.
/// </param>
private void sendFile(string filePath, Transport transport)
{
var fileSize = (int)LIB.check_File_Exists(@filePath);
var lengthToSend = Encoding.UTF8.GetBytes(fileSize.ToString());
transport.Send(lengthToSend, lengthToSend.Length);
if (fileSize != 0)
{
Console.WriteLine("Sending file: " + filePath + " to client");
var fileBuf = new byte[BUFSIZE];
var bytesRead = 0;
using (var fileStream = File.Open(@filePath, FileMode.Open)) {
while ((bytesRead = ReadChunk(fileStream, ref fileBuf)) != 0)
{
transport.Send(fileBuf, bytesRead);
}
}
Console.WriteLine("The requested file was sent");
}
else
{
Console.WriteLine("The requested file was not found on the server!");
}
}
private void ReceiveFile(String fileName, ITransport transport)
{
byte[] fileNameBuffer = Encoding.ASCII.GetBytes(fileName);
transport.Send(fileNameBuffer, fileNameBuffer.Length);
string newFileName = LIB.extractFileName(fileName);
FileStream fs = File.Create(newFileName);
byte[] buffer = new Byte[BUFSIZE];
transport.Receive(ref buffer);
long fileSize = BitConverter.ToInt64(buffer, 0);
if (fileSize == 0)
{
throw new FileNotFoundException();
}
byte[] chunks = new byte[BUFSIZE];
while (fileSize > 0)
{
int m = transport.Receive(ref chunks);
fs.Write(chunks, 0, m);
Console.WriteLine("Chunk contains: {0} bytes", m);
fileSize -= m;
Console.WriteLine("Filecontent remaning: {0} bytes", fileSize);
}
Console.WriteLine("File named {0} was created succesfully...", fileName);
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
transport = new Transport(BUFSIZE, APP);
String dataDir = "/root/ServerData/";
var receivedData = new byte[BUFSIZE];
Console.WriteLine("Server started");
String fileName;
long fileSize;
int receivedSize;
do
{
Console.WriteLine("Reading filename");
receivedSize = transport.receive(ref receivedData);
Console.WriteLine("ReceivedSize: " + receivedSize);
fileName = Encoding.ASCII.GetString(receivedData, 0, receivedSize);
Console.WriteLine("Filename: " + fileName);
fileSize = LIB.check_File_Exists(dataDir + fileName);
Console.WriteLine("Filepath: " + dataDir + fileName);
Console.WriteLine("Filesize: " + fileSize);
transport.send(Encoding.ASCII.GetBytes(fileSize.ToString()), fileSize.ToString().Length);
} while (fileSize == 0);
sendFile(dataDir + fileName, fileSize, transport);
//Cleaning
Console.WriteLine("Exit");
}
/// <summary>
/// Receives the file.
/// </summary>
/// <param name='fileName'>
/// File name.
/// </param>
/// <param name='transport'>
/// Transportlaget
/// </param>
private void receiveFile(String filePath, Transport transport)
{
try {
var fileToReceive = Encoding.ASCII.GetBytes(filePath);
transport.Send(fileToReceive, fileToReceive.Length);
var bytesToReceive = new byte[BUFSIZE];
transport.Receive(ref bytesToReceive);
var fileName = LIB.extractFileName(filePath);
var file = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write);
var fileSize = BitConverter.ToInt32(bytesToReceive, 0);
var receivedData = new byte[BUFSIZE];
while (fileSize > 0)
{
var receivedBytes = transport.Receive(ref receivedData);
file.Write(receivedData, 0, receivedBytes);
fileSize -= receivedBytes;
}
file.Close();
}
catch (System.TimeoutException e) {
Console.WriteLine("System has timed out");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
///
/// file_client metoden opretter en peer-to-peer forbindelse
/// Sender en forspørgsel for en bestemt fil om denne findes på serveren
/// Modtager filen hvis denne findes eller en besked om at den ikke findes (jvf. protokol beskrivelse)
/// Lukker alle streams og den modtagede fil
/// Udskriver en fejl-meddelelse hvis ikke antal argumenter er rigtige
/// </summary>
/// <param name='args'>
/// Filnavn med evtuelle sti.
/// </param>
private file_client(string[] args)
{
int bytelength;
buffer = new byte[BUFSIZE];
Console.WriteLine("Client started");
Transport clientSocket = new Transport(BUFSIZE);
clientSocket.send(Encoding.ASCII.GetBytes(args [0]), Encoding.ASCII.GetBytes(args [0]).Length);
Console.WriteLine(Encoding.ASCII.GetBytes(args [0]).Length.ToString());
//Filename
bytelength = clientSocket.receive(ref buffer);
var filename = Encoding.ASCII.GetString(buffer).Substring(0, bytelength);
Console.WriteLine(filename);
//Filesize
bytelength = clientSocket.receive(ref buffer);
Console.WriteLine(Encoding.ASCII.GetString(buffer).Substring(0, bytelength));
var filesize = Int64.Parse(Encoding.ASCII.GetString(buffer).Substring(0, bytelength));
if (filesize > 0)
{
var extractedFilename = LIB.extractFileName(filename);
receiveFile("/root/Desktop/" + extractedFilename, clientSocket, filesize);
}
}
//const int PORT = 9000;
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
Console.WriteLine("Starting server...");
Transport t = new Transport(BUFSIZE, APP);
while (true)
{
Console.WriteLine("Waiting for filename...");
byte[] clientFileBuffer = new byte[BUFSIZE];
t.receive(ref clientFileBuffer);
string clientFile = Encoding.ASCII.GetString(clientFileBuffer);
clientFile = clientFile.Replace("\0", string.Empty);
// Nedestående linje var udkommenteret i TCP koden
//clientFile = LIB.extractFileName(clientFile);
Console.WriteLine("File requested: " + clientFile);
if (LIB.check_File_Exists(clientFile) != 0)
{
Console.WriteLine("Sending filesize to client...");
string fileSize = LIB.check_File_Exists(clientFile).ToString();
byte[] fileSizeBytes = Encoding.ASCII.GetBytes(fileSize);
t.send(fileSizeBytes, fileSizeBytes.Length);
Console.WriteLine("Sending file to client...");
sendFile(clientFile, long.Parse(fileSize), t);
}
else
{
Console.WriteLine("File does not exist!");
string error = "Error: File does not exist on server.";
byte[] errorBytes = Encoding.ASCII.GetBytes(error);
t.send(errorBytes, errorBytes.Length);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
int bytelength;
byte[] buf = new byte[BUFSIZE];
Transport = new Transport(BUFSIZE);
while (true)
{
bytelength = Transport.receive(ref buf);
Console.WriteLine(bytelength.ToString());
string filename = System.Text.Encoding.Default.GetString(buf).Substring(0, bytelength);
long size = (LIB.check_File_Exists(filename));
Transport.send(Encoding.ASCII.GetBytes(filename), Encoding.ASCII.GetBytes(filename).Length);
var sizeinbytes = Encoding.ASCII.GetBytes(size.ToString());
var sizeinbyteslength = sizeinbytes.Length;
Transport.send(sizeinbytes, sizeinbyteslength);
if (size > 0)
{
sendFile(filename, size, Transport);
}
else
{
Console.WriteLine("File does not exist");
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
Transport transport = new Transport(BUFSIZE);
Console.WriteLine("Receiving filename");
byte[] receivedFilename = new byte[1000];
int buffSize = transport.receive(ref receivedFilename);
String filename = Encoding.ASCII.GetString(receivedFilename, 0, buffSize);
Console.WriteLine("Received filename: " + filename);
long filesize = LIB.check_File_Exists(filename);
byte[] bytefilesize = Encoding.ASCII.GetBytes(filesize.ToString());
Console.WriteLine("Sending filesize");
transport.send(bytefilesize, bytefilesize.Length);
Console.WriteLine("Filesize sent: " + filesize);
if (filesize > 0)
{
sendFile(filename, filesize, transport);
}
}
public int DeleteCopy(LIB.CopyDTO copy, SqlTransaction trans)
{
bool isInScopeCreated = false;
int rs;
if (trans == null)
{
isInScopeCreated = true;
trans = ConnectionManager.Con.BeginTransaction("CAT_CRE_TRANSACT");
}
CopyDAO dao = new CopyDAO();
rs = dao.DeleteCopy(copy, trans);
if (isInScopeCreated)
{
if (rs == 0)
trans.Rollback();
else
trans.Commit();
}
return rs;
}
public IActionResult capmatudong()
{
string Matudong = LIB.GET_MATUDONG("Đơn đặt hàng web", "dathangweb", "dathangweb", _manage.Madonvi, false, "WE");
return(new JsonResult(new
{
Magiaodichpk = Matudong
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
///
/// file_client metoden opretter en peer-to-peer forbindelse
/// Sender en forspørgsel for en bestemt fil om denne findes på serveren
/// Modtager filen hvis denne findes eller en besked om at den ikke findes (jvf. protokol beskrivelse)
/// Lukker alle streams og den modtagede fil
/// Udskriver en fejl-meddelelse hvis ikke antal argumenter er rigtige
/// </summary>
/// <param name='args'>
/// Filnavn med evtuelle sti.
/// </param>
private file_client(String[] args)
{
byte[] buff = new byte[BUFSIZE];
string patchfil = args[0], fileName = LIB.extractFileName(patchfil);
Transport tran = new Transport(BUFSIZE, APP); // oprettes transport objekt
buff = Encoding.ASCII.GetBytes(patchfil);
tran.send(buff, buff.Length);
receiveFile(fileName, tran);
}
public void WaitForRequest_SendFile()
{
NetworkStream networkStream = _clientSocket.GetStream();
string filename = LIB.readTextTCP(networkStream);
if (!File.Exists(filename))
{
}
FileStream fileToSend = File.OpenRead(filename);
LIB.writeTextTCP(networkStream, fileToSend.Length.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
var transport = new Transport(BUFSIZE, APP);
var receiveBuffer = new byte[BUFSIZE];
var receivedData = new byte[] { };
while (true)
{
try
{
var receiveSize = 0;
int index = 0;
Console.WriteLine("Awaiting new file request");
do
{
receiveSize = transport.receive(ref receiveBuffer);
Array.Resize(ref receivedData, receiveSize);
Array.Copy(receiveBuffer, 0, receivedData, index, receiveSize);
index += receiveSize;
} while (receiveSize == BUFSIZE);
string receivedFilePath = Encoding.UTF8.GetString(receivedData);
var requestedFile = LIB.extractFileName(Encoding.UTF8.GetString(receivedData));
Console.WriteLine("Extracted " + requestedFile + "from client.");
//til filer på vilkårlige placeringer
var fileLength = LIB.check_File_Exists(receivedFilePath);
if (fileLength > 0) //tjekker om filen findes på den givne sti
{
Console.WriteLine($"Fuld sti:{receivedFilePath}" +
$"\nstørrelse:{fileLength}");
sendFile(receivedFilePath, fileLength, transport);
}
else
{
Console.WriteLine($"Fuld sti:{receivedFilePath}" +
$"\nFil ikke fundet.");
byte[] sizeArray = Encoding.UTF8.GetBytes(fileLength.ToString());
transport.send(sizeArray, sizeArray.Length);
}
}
catch (Exception e)
{
Debug.WriteLine(e);
throw;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
///
/// </summary>
/// <param name='args'>
/// Filnavn med evtuelle sti.
/// </param>
private file_client(String[] args)
{
Transport transport = new Transport(BUFSIZE, APP);
try
{
Console.WriteLine("Recipient file");
string fileToReceive = (args.Length > 0) ? args[0] : "/test/test.txt";
Console.WriteLine($"Requesting file: {fileToReceive}");
var Filename = LIB.extractFileName(fileToReceive);
Console.WriteLine($"File name: {Filename}");
transport.sendText(fileToReceive);
var isFileFound = transport.readText();
switch (isFileFound)
{
case "FileFound":
Console.WriteLine($"File \"{Filename}\" exists. Commencing Transfer...");
receiveFile(Filename, transport);
break;
case "NoFileFound":
Console.WriteLine($"File \"{Filename}\" does NOT exist on specified path. Aborting Transfer");
break;
default:
Console.WriteLine("unknown error");
break;
}
//if (transport.readText() == "FileFound")
//{
// Console.WriteLine($"File \"{Filename}\" exists. Commencing Transfer...");
// receiveFile(Filename, transport);
//}
//else if (transport.readText() == "NoFileFound")
//{
// Console.WriteLine($"File \"{Filename}\" does NOT exist on specified path. Aborting Transfer");
//}
//else
//{
// Console.WriteLine("unknown error");
//}
}
catch (Exception ex)
{
Console.WriteLine("Exception :(");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
Transport transport = new Transport(BUFSIZE, APP);
byte[] buffer = new byte[BUFSIZE];
Console.WriteLine("Server ready");
Console.WriteLine();
while (true)
{
Console.WriteLine("Waiting for file request");
int receivedBytes = transport.receive(ref buffer);
string filename = LIB.extractFileName(Encoding.ASCII.GetString(buffer, 0, receivedBytes));
Console.WriteLine("Received: \"{0}\"", filename);
if (File.Exists(filename) == false)
{
Console.WriteLine("File did not exist");
Console.WriteLine();
string nul = "0";
transport.send(Encoding.ASCII.GetBytes(nul), nul.Length);
}
else
{
Console.WriteLine("Found file");
var file = File.OpenRead(LIB.extractFileName(filename));
byte[] fileSize = Encoding.ASCII.GetBytes(file.Length.ToString());
Console.WriteLine("File \"{0}\" exists with size {1}, now sending file length to client", LIB.extractFileName(filename), Encoding.ASCII.GetString(fileSize));
//Send file size
transport.send(fileSize, fileSize.Length);
int remainingBytes = file.Read(buffer, 0, BUFSIZE);
int remaining = int.Parse(file.Length.ToString());
while (remainingBytes > 0)
{
transport.send(buffer, remainingBytes);
remainingBytes = file.Read(buffer, 0, BUFSIZE);
remaining = remaining - remainingBytes;
Console.WriteLine("Need to write {0} of {1} bytes", remaining, file.Length.ToString());
}
file.Close();
Console.WriteLine("File \"{0}\" sent", LIB.extractFileName(filename));
}
}
}
/// <summary>
/// Receives the file.
/// </summary>
/// <param name='fileName'>
/// File name.
/// </param>
/// <param name='transport'>
/// Transportlaget
/// </param>
private void receiveFile(String fileName, Transport transport)
{
long readBytes = 0;
Byte[] readbuffer = new byte[BUFSIZE];
// Extract filename and send to server
Console.WriteLine("Sending filename to server");
String extractedFileName = LIB.extractFileName(fileName);
byte[] filenameToSend = Encoding.ASCII.GetBytes(extractedFileName);
transport.send(filenameToSend, filenameToSend.Length);
Console.WriteLine("Filename sent to server: " + extractedFileName);
Console.WriteLine();
byte[] fileSizeBuf = new byte[BUFSIZE];
int receivedByteCount = transport.receive(ref fileSizeBuf);
int filesize = Int32.Parse(Encoding.ASCII.GetString(fileSizeBuf, 0, receivedByteCount));
Console.WriteLine("Received file size: " + filesize);
Console.WriteLine();
Console.WriteLine("Receiving file");
if (filesize != 0)
{
// Receive file
FileStream downloadedfile = File.Create(extractedFileName);
while (filesize > 0)
{
readBytes = transport.receive(ref readbuffer);
filesize -= (int)readBytes;
downloadedfile.Write(readbuffer, 0, (int)readBytes);
}
Console.WriteLine("Download complete...");
}
else
{
Console.WriteLine("Filename: " + extractedFileName + " does not exist");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
/*
* // TO DO Your own code
* string args = "hest";
* Transport t = new Transport(args.Length);
* byte[] file = new byte[args.Length*sizeof(char)];
* System.Buffer.BlockCopy (args.ToCharArray (), 0, file,0, file.Length);
* //for (int i = 0; i > args.Length; i++) {
* // file [i] = Convert.ToByte(args [i]);
* //}
*
* t.send (file, file.Length);
*/
Console.WriteLine("Server started!");
byte[] buffer = new byte[BUFSIZE];
Transport transport = new Transport(BUFSIZE);
while (true)
{
var size = transport.receive(ref buffer);
if (size != 0)
{
//fjern null efter filnavn
var fileNamePath = System.Text.Encoding.Default.GetString(buffer);
var fileName = LIB.extractFileName(fileNamePath);
fileName = fileName.Replace("\0", string.Empty);
var fileSize = LIB.check_File_Exists(fileName);
var mySize = fileSize.ToString();
byte[] sendfileSize = new byte[mySize.Length];
sendfileSize = Encoding.ASCII.GetBytes(mySize);
transport.send(sendfileSize, sendfileSize.Length);
if (fileSize != 0)
{
sendFile(fileName, fileSize, transport);
}
else
{
Console.WriteLine("File does not exist.");
}
}
}
}
/// <summary>
/// Receives the file.
/// </summary>
/// <param name='fileName'>
/// File name.
/// </param>
/// <param name='transport'>
/// Transportlaget
/// </param>
private void receiveFile(String fileName, Transport transport)
{
var fileNameArray = Encoding.UTF8.GetBytes(fileName);
Console.WriteLine($"Sender anmodning om fil på:" +
$"\n{fileName}");
transport.send(fileNameArray, fileNameArray.Length);
var filePath = AppDomain.CurrentDomain.BaseDirectory + "/" + LIB.extractFileName(fileName);
var existCheck = new byte[BUFSIZE];
transport.receive(ref existCheck);
var fileSize = long.Parse(Encoding.UTF8.GetString(existCheck));
if (fileSize > 0)
{
Console.WriteLine($"Fil eksisterer på serveren." +
$"\nStart receiving file of size: {fileSize} bytes");
var receiveBuffer = new byte[BUFSIZE];
var receivedData = new byte[] { };
var receiveSize = 0;
int index = 0;
do
{
receiveSize = transport.receive(ref receiveBuffer);
Array.Resize(ref receivedData, index + receiveSize);
Array.Copy(receiveBuffer, 0, receivedData, index, receiveSize);
index += receiveSize;
} while (receivedData.Length != fileSize); //Keeps looping until the desired filesize is reached
Console.WriteLine($"File received");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
File.WriteAllBytes(filePath, receivedData);
Console.WriteLine($"File created");
}
else
{
Console.WriteLine($"Fil ikke fundet på server");
}
}
public int UpdateAuthor(LIB.AuthorDTO author)
{
int rs = 0;
using (SqlTransaction trans = ConnectionManager.Con.BeginTransaction())
{
AuthorDAO dao = new AuthorDAO();
rs = dao.UpdateAuthor(author);
if (rs == 1)
{
trans.Commit();
}
else
{
trans.Rollback();
}
}
return rs;
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
Console.WriteLine("Waiting for client to supply filename \n");
var filename = new byte[BUFSIZE];
// Get filename with size of byte
int size = _transport.Receive(ref filename);
Console.WriteLine($"\nFilename {LIB.ToString(filename)}");
// Check file exist
long fileSize = LIB.check_File_Exists(LIB.ToString(filename).Substring(0, size));
Console.WriteLine(LIB.ToString(filename).Substring(0, size));
// If it does not exist, ask for another filename
while (fileSize == 0)
{
string errorMsg = "File '" + LIB.ToString(filename) + "' not found \n";
Console.WriteLine(errorMsg);
// Send filesize back
_transport.Send(LIB.ToBytes(fileSize.ToString()), LIB.ToBytes(fileSize.ToString()).Length);
size = _transport.Receive(ref filename);
Console.WriteLine(LIB.ToString(filename));
// Check if file exist - must do with substring to get exact path
fileSize = LIB.check_File_Exists(LIB.ToString(filename).Substring(0, size));
}
Console.WriteLine("File is found with size " + fileSize);
_transport.Send(LIB.ToBytes(fileSize.ToString()), LIB.ToBytes(fileSize.ToString()).Length);
sendFile(LIB.ToString(filename).Substring(0, size), fileSize, _transport);
// TO DO Your own code
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
byte[] buf = new byte[BUFSIZE];
int sizeofbuf;
string pathfill;
long lenghtfill;
Transport trp = new Transport(BUFSIZE, APP); //oprettes transport objekt.
sizeofbuf = trp.receive(ref buf);
Console.WriteLine(Encoding.ASCII.GetString(buf) + ", File of size: " + sizeofbuf);
pathfill = Encoding.ASCII.GetString(buf, 0, sizeofbuf);
Console.WriteLine(pathfill);
lenghtfill = LIB.check_File_Exists(pathfill);
if (lenghtfill == 0) // hvis vaerdien er 0, så vil den udskrive fejl
{
Console.WriteLine("FAILED!!!");
return;
}
buf = BitConverter.GetBytes(lenghtfill);
sendFile(pathfill, lenghtfill, trp);
}
/// <summary>
/// Initializes a new instance of the <see cref="file_client"/> class.
///
/// file_client metoden opretter en peer-to-peer forbindelse
/// Sender en forspørgsel for en bestemt fil om denne findes på serveren
/// Modtager filen hvis denne findes eller en besked om at den ikke findes (jvf. protokol beskrivelse)
/// Lukker alle streams og den modtagede fil
/// Udskriver en fejl-meddelelse hvis ikke antal argumenter er rigtige
/// </summary>
/// <param name='args'>
/// Filnavn med evtuelle sti.
/// </param>
private file_client(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Please supply a filename");
Environment.Exit(0);
}
// Get filename
string filename = args[0];
Console.WriteLine("Requesting filename " + args [0] + "\n");
// Send file name
_transport.Send(LIB.ToBytes(filename), LIB.ToBytes(filename).Length);
// Filesize in bytes
byte[] fileSize = new byte[BUFSIZE];
// Receive file size
int size = _transport.Receive(ref fileSize);
// If the file size is equal to 0, resend a new file name
while ((LIB.ToString(fileSize).Substring(0, size) == "0"))
{
Console.WriteLine($"File {filename} not found. Input a valid file");
filename = Console.ReadLine();
Console.WriteLine($"Requesting filename '{filename}'");
_transport.Send(LIB.ToBytes(filename), LIB.ToBytes(filename).Length);
_transport.Receive(ref fileSize);
}
Console.WriteLine("File size: " + LIB.ToString(fileSize));
// Receive the file with the file size
receiveFile(filename, long.Parse(LIB.ToString(fileSize)), _transport);
}
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
t1 = new Transport(BUFSIZE, APP);
var filePath = "";
long fileSize = 0;
var srvBuffer = new byte[BUFSIZE];
var bufferSize = 0;
while (true)
{
bufferSize = t1.receive(ref srvBuffer); // wait for client input
var filename = ((new UTF8Encoding()).GetString(srvBuffer)).Substring(0, bufferSize);
filename = filename.Replace("\0", string.Empty);
Console.WriteLine($"Server looking for file {filename}");
fileSize = LIB.check_File_Exists(filename);
sendFile(filename, fileSize, t1);
}
}
public void SendFile()
{
using (NetworkStream networkStream = _clientSocket.GetStream())
{
string filename = LIB.readTextTCP(networkStream);
if (File.Exists(filename))
{
try
{
FileStream fileReader = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BufferedStream bufferStream = new BufferedStream(fileReader, _bufferSize);
LIB.writeTextTCP(networkStream, fileReader.Length.ToString());
do
{
bufferStream.CopyTo(networkStream);
} while (fileReader.Position != fileReader.Length);
}
catch (System.IO.IOException e)
{
Console.WriteLine(e.Message);
CloseConnection();
return;
}
}
else
{
try
{
LIB.writeTextTCP(networkStream, "0");
}
catch (System.IO.IOException e)
{
Console.WriteLine(e.Message);
}
}
}
CloseConnection();
}
/*
* IPAddress localAddr = IPAddress.Parse("10.0.0.1");
* byte[] buff = new byte[BUFSIZE];
*/
/// <summary>
/// Initializes a new instance of the <see cref="file_server"/> class.
/// </summary>
private file_server()
{
//Link link = new Link(BUFSIZE,APP);
Transport transport = new Transport(BUFSIZE, APP);
Console.WriteLine("Server started");
int size = 0;
while (true)
{
byte[] responsebuff = new byte[BUFSIZE];
byte[] buffer = new byte[BUFSIZE];
//receive
while ((size = transport.receive(ref buffer)) == 0)
{
//Console.Write("\rwaiting for name");
}
Console.WriteLine("received a name");
//Console.WriteLine (buffer.Length+System.Text.Encoding.ASCII.GetString(buffer));
//check what we got here
string received = Encoding.UTF8.GetString(buffer, 0, size - 4);
//this must be a filename!
//Console.WriteLine($"After link layer server got filename: {received}");
//find the file
long filesize = LIB.check_File_Exists(received);
//send størrelse:
if (filesize != 0)
{
Console.WriteLine("found the file");
//Console.WriteLine ("\n Sender: " + "\n Størrelse: " + filesize);
string filename = LIB.extractFileName(received);
Console.WriteLine("filename is " + filename);
//Console.WriteLine ("sender om lidt..");
//Thread.Sleep (1000);
Console.WriteLine("sender navn " + filename);
string requestName = filename;
responsebuff = Encoding.ASCII.GetBytes(requestName);
transport.send(responsebuff, responsebuff.Length);
Console.WriteLine("navn sendt afsted");
string requestSize = filesize.ToString();
responsebuff = Encoding.ASCII.GetBytes(requestSize);
Console.WriteLine("sender størrelse " + filesize);
transport.send(responsebuff, responsebuff.Length);
Console.WriteLine("størrelse sendt afsted");
sendFile(received, filesize, transport);
//send data
/*
* Console.WriteLine ("Sending file: " + received + " to client");
*
* var fileBuf = new byte[BUFSIZE];
* var bytesRead = 0;
*
* using (var fileStream = File.Open (received, FileMode.Open)) {
*
* while ((bytesRead = ReadChunk (fileStream, ref fileBuf)) != 0) {
* transport.send (fileBuf, bytesRead);
* }
*
* }
* Console.WriteLine ("The requested file was sent");
*
*/
}
else
{
Console.WriteLine("file not found");
}
//done reset transport
transport = new Transport(BUFSIZE, APP);
}
}
private void receiveFile(String fileName, long size)
{
// Commence download
Console.WriteLine("Downloading...");
byte[] inStream = new byte[BUFSIZE];
long totalReceived = 0;
// Setup FileStream which writes to desktop
string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "/" + LIB.extractFileName(fileName);
FileStream fs = new FileStream(path, FileMode.Create);
// Download file chunk by chunk and write it to FileStream path
do
{
int count = trans.receive(ref inStream);
fs.Write(inStream, 0, count);
totalReceived += count;
string diff = totalReceived + "/" + size;
Console.Write("\r{0}% " + diff + " bytes", String.Format("{0:0}", 100 * totalReceived / size));
}while (totalReceived != size);
Console.WriteLine("\nDownload complete");
}
public int InsertCopy(LIB.CopyDTO copy)
{
CopyDAO dao = new CopyDAO();
return dao.InsertCopy(copy);
}
public int UpdateCopy(LIB.CopyDTO copy)
{
CopyDAO dao = new CopyDAO();
return dao.UpdateCopy(copy);
}
