/// <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); }