public override void Handler(WebRequest req) { if (!req.URI.StartsWith(this.ServiceURI)) { throw new InvalidOperationException(); } // Percent-decode our filename string percenDecoded = Uri.UnescapeDataString(req.URI); //If we want the root folder if (percenDecoded == ServiceURI) { RespondWithList(r_sys.GetRoot(), req); return; } // The pluse one is the '/' after the '/files' so we remove '/files/' string[] peices = percenDecoded.Substring(ServiceURI.Length + 1).Split('/'); Dir422 dir = r_sys.GetRoot(); for (int i = 0; i < peices.Length - 1; i++) { dir = dir.GetDir(peices[i]); if (dir == null) { //This wants a response? req.WriteNotFoundResponse(string.Empty); return; } } string lastPeice = peices [peices.Length - 1]; File422 file = dir.GetFile(lastPeice); if (file != null) { //Send back the file to them. RespondWithFile(file, req); } else { //Send the dir contents (if it is a dir to send back) dir = dir.GetDir(lastPeice); if (dir != null) { //Respond with the list of files and dirs RespondWithList(dir, req); } else { req.WriteNotFoundResponse(string.Empty); } } }
public override void Handler(WebRequest req) { if (!req.requestTarget.StartsWith("/files")) { throw new Exception(); } if (req.requestTarget == "/files" || req.requestTarget == "files" || req.requestTarget == "/files/") { RespondWithList(_fs.GetRoot(), req); return; } var dir = _fs.GetRoot(); string newRequestTarget = System.Uri.UnescapeDataString(req.requestTarget.Substring(ServiceURI.Length)); string[] uriPieces = newRequestTarget.Split(new char[1] { '/' }, StringSplitOptions.RemoveEmptyEntries); if (null == uriPieces || uriPieces.Length == 0) { req.WriteNotFoundResponse("NOT FOUND"); return; } for (int i = 0; i < uriPieces.Length - 1; i++) { string uriPiece = uriPieces[i]; dir = dir.GetDir(uriPiece); if (null == dir) { req.WriteNotFoundResponse("NOT FOUND"); return; } } var file = dir.GetFile(uriPieces[uriPieces.Length - 1]); if (null != file) { RespondWithFile(file, req); return; } dir = dir.GetDir(uriPieces[uriPieces.Length - 1]); if (dir == null) { req.WriteNotFoundResponse("NOT FOUND"); return; } RespondWithList(dir, req); }
public override void Handler(WebRequest req) { if (!req.RequestURI.StartsWith(ServiceURI, StringComparison.CurrentCulture)) { throw new InvalidOperationException(); } if (req.RequestURI == "/files" || req.RequestURI == "/files/") { RespondWithList(m_fs.GetRoot(), req); return; } string[] pieces = req.RequestURI.Substring(ServiceURI.Length).Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); if (pieces == null || pieces.Length == 0) { req.WriteNotFoundResponse("404: Path error."); return; } Dir422 dir = m_fs.GetRoot(); for (int i = 0; i < pieces.Length - 1; i++) { string piece = pieces[i]; dir = dir.GetDir(piece); if (dir == null) { req.WriteNotFoundResponse("404: Path error."); return; } } string name = PercentDecoding(pieces[pieces.Length - 1]); File422 file = dir.GetFile(name); if (file != null) { RespondWithFile(file, req); return; } dir = dir.GetDir(name); if (dir == null) { req.WriteNotFoundResponse("404: Path error."); return; } RespondWithList(dir, req); }
public static bool Start(int port, int number_threads) { // Create thread to listen for incoming clients new Thread(() => { // Init and start server TcpListener listener = new TcpListener(IPAddress.Any, port); listener.Start(); threadPool.Start((ushort)number_threads); while (true) { TcpClient client = listener.AcceptTcpClient(); // Make thread task function and add it to the ThreadPool threadPool.AddTask(() => { WebRequest req = BuildRequest(client); // Invalid request object, close connection. if (null != req) { // Handle that request // Find services that will handle the request URI int longestPrefix = 0; WebService serviceToUse = null; foreach (var service in services) { if (req.URI.StartsWith(service.ServiceURI)) { // We'll select the service that has a longer prefix of the request URI and use it if (service.ServiceURI.Length > longestPrefix) { longestPrefix = service.ServiceURI.Length; serviceToUse = service; } } } if (null == serviceToUse) { // send 404 reponse req.WriteNotFoundResponse(""); } else { // "Handle" request serviceToUse.Handler(req); } } client.Close(); }); } }).Start(); return(true); }
public void ThreadWork() { WebRequest request = BuildRequest(_client); if (request == null) { _client.GetStream().Dispose(); _client.Close(); } else { // we have a valid http request // Try to find a valid service foreach (var service in services) { if (validate.URI.StartsWith(service.ServiceURI)) { service.Handler(request); break; } else { // No handler exists. request.WriteNotFoundResponse("Unable to find an appropriate handler"); } } //Thread.Sleep (5000); _client.GetStream().Dispose(); _client.Close(); } }
private static void ThreadWork() { while (true) { TcpClient client = _collection.Take(); if (client == null) { return; } WebRequest request = BuildRequest(client); if (request == null) { client.Close(); continue; } foreach (var service in _services) { if (request.URI.StartsWith(service.ServiceURI)) { service.Handler(request); return; } } // No valid handler request.WriteNotFoundResponse(request.URI); } }
// Methods public override void Handler(WebRequest request) { Console.WriteLine("Service Handler: OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"); _request = request; // Parse the URI and determine which of the 3 is the case: string[] parsedURI = request.URI.Split('/'); List <string> dirNames = new List <string>(); int count = 0; foreach (string s in parsedURI) { if (count > 1)// so we only have traversable dirnames { Console.WriteLine("adding: " + parsedURI[count]); dirNames.Add(parsedURI[count]); } Console.WriteLine("s: " + s); Console.WriteLine("c: " + count); count++; } Console.WriteLine("dirNames.Count: " + dirNames.Count); Dir422 currentDir = _fs.GetRoot(); Dir422 lastDir; File422 file = null; foreach (string s in dirNames) { if (!String.IsNullOrEmpty(s)) { Console.WriteLine("locating: " + s); lastDir = currentDir; currentDir = currentDir.GetDir(s); if (null == currentDir) // check to see if a file { Console.WriteLine("Null Dir"); file = lastDir.GetFile(s); if (null == file) { Console.WriteLine("Null File"); //requested Resource does not exist // so 404 write to network and return request.WriteNotFoundResponse("Could not find file: " + s + "."); return; } // otherwise write file contents as html WriteFileContents(file); return; } } } // If this point is reached then we should have a dir and // we must write its file listing to the network WriteDirListing(currentDir); // Provide support for partial content responses // (i.e. support the Range header) }
//have this write back to the request public override void Handler(WebRequest req) { if (!req.Headers.ContainsKey("Content-Length")) { int length = 0; if (req.Body != null) { length = (int)req.Body.Length; } req.Headers.Add("Content-Length", length.ToString()); } //call the service on the request if (req.URI.StartsWith(ServiceURI, StringComparison.Ordinal)) { req.WriteHtmlResponse(string.Format(c_template, req.Method, req.URI, req.Headers["Content-Length"], "11382134")); } else { req.WriteNotFoundResponse(string.Format(c_template, req.Method, req.URI, req.Headers["Content-Length"], "11382134")); } }
static void ThreadWork(object clientObj) { TcpClient client = clientObj as TcpClient; WebRequest request = BuildRequest(client); processCount++; Console.WriteLine("process: {0}", processCount); Console.WriteLine("Request built"); if (request == null) { client.Close(); Console.WriteLine("Closing connection"); return; } var handlerService = fetchHandler(request); if (handlerService == null) { Console.WriteLine("Handler not found, writing not found response"); request.WriteNotFoundResponse("NoasdasdasdasdtFound"); client.GetStream().Dispose(); client.Close(); } else { Console.WriteLine("Handler found, delegating response"); handlerService.Handler(request); client.GetStream().Dispose(); client.Close(); } client.Close(); }
private void GetHandler(WebRequest req) { //NOTE use Uri.UnescapeDataString to convert the escaped string //to it's unescaped representation. //i.e if we get http://localhost:4220/%20test/ //would become http://localhost:4220/ test/ string[] names = Uri.UnescapeDataString(req.RequestTarget).Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); //first name is files. string currString = ""; Dir422 currNode = _fs.GetRoot(); //root is what we chose, the client knows it as "files". Dir422 nextNode = null; File422 file = null; int uriCase = 1; for (int i = 1; i < names.Length; i++) { currString = names[i]; if ((nextNode = currNode.GetDir(currString)) != null) { //go to next dir to repeat iteration. currNode = nextNode; } else if ((file = currNode.GetFile(currString)) != null) { uriCase = 2; break; } else { uriCase = 3; break; } } switch (uriCase) { //URI maps to an existing directory in the file system. case 1: string htmlString = BuildDirHTML(currNode); req.WriteHTMLResponse(htmlString); break; //The URI maps to an existing file in the file system case 2: SendFileContent(file, req); break; //The URI maps to something that doesn’t exist in the file system case 3: req.WriteNotFoundResponse(errorHtml); break; } }
//Accept TCP client and Call BulildRequest static void ThreadWork(Object clnt) { TcpClient client = clnt as TcpClient; WebRequest req = BuildRequest(client); WebService handler = null;; bool processRequest; if (req == null) { //close client connection client.GetStream().Close(); client.Close(); } else { //if the request-target/URI starts with the string specified by the WebService object’s //ServiceURI parameter, then it can process that request. processRequest = false; foreach (var x in servicesList) { if (req.URI.StartsWith(x.Key)) { processRequest = true; handler = x.Value; } } if (processRequest) { //find appropriate handler in the list of //handlers/services that the webserver stores //WebService handler; //servicesList.TryGetValue (req.URI, out handler); //call the handle handler.Handler(req); } //write a 404 – Not Found response else { string pageHTML = "<html> ERROR! </html>"; req.WriteNotFoundResponse(pageHTML); } //client. client.GetStream().Close(); client.Close(); } }
public override void Handler(WebRequest req) { if (!req.URI.StartsWith(ServiceURI, StringComparison.Ordinal)) { throw new InvalidOperationException(); } //split the path string[] places = req.URI.Substring(ServiceURI.Length).Split('/'); Dir422 dir = r_sys.GetRoot(); for (int i = 0; i < places.Length - 1; i++) { dir = dir.GetDir(places[i]); if (dir == null) { req.WriteNotFoundResponse(""); return; } } File422 file = dir.GetFile(places[places.Length - 1]); if (file != null) { RespondWithFile(file, req); } else { dir = dir.GetDir(places[places.Length - 1]); if (dir != null) { RespondWithList(dir, req); } else { req.WriteNotFoundResponse(""); } } }
public override void Handler(WebRequest req) { // TODO maybe change this var url = req.RequestTarget.Substring("/files/".Length); if (url.Length == 0) { Console.WriteLine("Root requested"); req.WriteHTMLResponse(BuildDirHTML(fileSystem.GetRoot())); return; } if (url.EndsWith("/")) { url = url.Remove(url.Length - 1, 1); } var dir = getParentDir(url); Console.WriteLine(url); var tokens = url.Split('/'); var fileOrFolderName = tokens [tokens.Length - 1]; if (dir == null) { Console.WriteLine("Not found null"); return; } else if (dir.ContainsFile(fileOrFolderName, false)) { Console.WriteLine("file"); SendFile(dir.GetFile(fileOrFolderName), req); } else if (dir.ContainsDir(fileOrFolderName, false)) { Console.WriteLine("folder: {0}, parent: {1}", fileOrFolderName, dir.GetDir(fileOrFolderName).Name); req.Headers = new System.Collections.Concurrent.ConcurrentDictionary <string, string> (); req.WriteHTMLResponse(BuildDirHTML(dir.GetDir(fileOrFolderName))); } else { req.WriteNotFoundResponse(@"<h1>File not found</h1>"); } Console.WriteLine("done"); }
public override void Handler(WebRequest req) { switch (req.Method.ToUpper()) { case "GET": handleGET(req); break; case "PUT": handlePUT(req); break; default: req.WriteNotFoundResponse("<h1>404</h1><br/><h2><strong>Not Found</strong></h2>"); break; } }
/* * Don’t allow overwriting existing files * Allow all (non-existing-file-overwriting) uploads provided the file name doesn’t contain reserve characters (/ and \) * Files can be uploaded to any directory that the service shares * Files must be uploaded into the current directory that the user is seeing the listing for within the browser * There is no limit on file sizes or content * You only need to support uploading 1 file at a time (1 per page refresh, as described below) * You do NOT need to support cross-origin requests or the OPTIONS method, which will have been discussed in class * */ void handlePUT(WebRequest req) { string[] path = req.URI.Split('/'); // The file already exists if (fileSystem.GetRoot().ContainsFile(path[path.Length - 1], true)) { req.WriteNotFoundResponse("File exists"); } // Make file else { Dir422 currentDir = fileSystem.GetRoot(); // Don't include last element because thats the file name for (int i = 2; i < path.Length - 1; i++) { // Fix '/' at end of URI if (path[i] != "") { currentDir = currentDir.GetDir(path[i]); } } File422 file = currentDir.CreateFile(path[path.Length - 1]); using (Stream stream = file.OpenReadWrite()) { byte[] buffer = new byte[1024 * 8]; int bytesRead = 0, size = int.Parse(req.Headers["content-length"]), totalRead = 0; while (totalRead < size) { bytesRead = req.Body.Read(buffer, 0, (size - totalRead > buffer.Length) ? buffer.Length : size - totalRead); totalRead += bytesRead; Console.WriteLine(totalRead < size); stream.Write(buffer, 0, (bytesRead < size) ? bytesRead : size); } } Console.WriteLine("File uploaded"); req.WriteHTMLResponse("file uploaded!"); } }
private void GETHandler(WebRequest req, string name, Dir422 dir) { File422 file = dir.GetFile(name); if (file != null) { RespondWithFile(file, req); return; } dir = dir.GetDir(name); if (dir == null) { req.WriteNotFoundResponse("404: Path error."); return; } RespondWithList(dir, req); }
/* * ThreadWork function to serve as the request-handling function for a thread from the thread pool */ private static void ThreadWork() { while (true) { TcpClient client = _collection.Take(); if (client == null) { break; } /* * Processing a client involves calling the BuildRequest function first. * Should the return value be null, the client connection is closed immediately * and the thread goes back into a waiting/sleeping state. * Should it be non-null, * then an appropriate handler is found in the list of handlers/services that the web * server stores, and the request is sent to that handler by calling its “Handle” function */ WebRequest request = BuildRequest(client); if (request == null) { client.Close(); } else { WebService handler = Handler(request); if (handler != null) { handler.Handler(request); client.GetStream().Dispose(); client.Close(); } else { request.WriteNotFoundResponse(request.RequestURI); client.GetStream().Dispose(); client.Close(); } } } }
static void ThreadWork(object clientObj) { TcpClient client = clientObj as TcpClient; while (client.Connected) { //Console.WriteLine ("about to build request"); WebRequest request = BuildRequest(client); processCount++; //Console.WriteLine ("process: {0}", processCount); //Console.WriteLine ("Request built"); if (request == null) { //Console.WriteLine ("Closing connection"); client.Close(); } else { var handlerService = fetchHandler(request); if (handlerService == null) { //Console.WriteLine ("Handler not found, writing not found response"); request.WriteNotFoundResponse("not found"); } else { //Console.WriteLine ("Handler found, delegating response"); handlerService.Handler(request); } } //Console.WriteLine ("Loopoing"); } client.Close(); //Console.WriteLine ("Exiting"); }
void handleGET(WebRequest req) { try { string[] path = req.URI.Split('/'); // To handle '/files' request if (path.Length == 2) { req.WriteHTMLResponse(BuildDirHTML(fileSystem.GetRoot())); return; } // This handles '/files/**' // The URI maps to an existing directory in the file system if (fileSystem.GetRoot().ContainsDir(path[path.Length - 1], true)) { // Imidiately set the content-type to html since we are returning html code req.Headers["content-type"] = "text/html"; Dir422 currentDir = fileSystem.GetRoot(); for (int i = 2; i < path.Length; i++) { // Fix '/' at end of URI if (path[i] != "") { currentDir = currentDir.GetDir(path[i]); } } req.WriteHTMLResponse(BuildDirHTML(currentDir)); } // The URI maps to an existing file in the file system else if (fileSystem.GetRoot().ContainsFile(path[path.Length - 1], true)) { // Get the file type and set the content-type to the file type string filename = path[path.Length - 1]; int dot = filename.LastIndexOf('.'); string type = (dot >= 0) ? filename.Substring(dot).ToLower() : ""; switch (type) { case ".txt": req.Headers["content-type"] = "text/plain"; break; case ".xml": req.Headers["content-type"] = "text/xml"; break; case ".jpg": req.Headers["content-type"] = "image/jpg"; break; case ".jpeg": req.Headers["content-type"] = "image/jpeg"; break; case ".png": req.Headers["content-type"] = "image/png"; break; case ".mp4": req.Headers["content-type"] = "video/mp4"; break; case ".pdf": req.Headers["content-type"] = "application/pdf"; break; default: req.Headers["content-type"] = "text/html"; break; } Dir422 currentDir = fileSystem.GetRoot(); // Don't include last element because thats the file name for (int i = 2; i < path.Length - 1; i++) { // Fix '/' at end of URI if (path[i] != "") { currentDir = currentDir.GetDir(path[i]); } } File422 file = currentDir.GetFile(path[path.Length - 1]); // Get the file stuff int bytesRead; // Did the client send us a range header string rangeValue; if (req.Headers.TryGetValue("range", out rangeValue)) { byte[] buffer; // Send the chunk they want. Only works for bytes=%d-%d rangeValue = rangeValue.Replace(" ", ""); rangeValue = rangeValue.Remove(0, "bytes=".Length); string[] bytes = rangeValue.Split('-'); int start = int.Parse(bytes[0]), end = int.Parse(bytes[1]), totalRead = 0; buffer = new byte[end - start]; using (BufferedStream reader = new BufferedStream(file.OpenReadOnly())) { // Add header = content-range: bytes %d-%d/%d req.Headers["content-range"] = "bytes " + rangeValue + "/" + reader.Length; req.WritePreBody(206, buffer.Length); while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0) { req.WriteFile(buffer, totalRead, bytesRead); totalRead += bytesRead; } } } else { // Send the entire thing BufferedStream reader = new BufferedStream(file.OpenReadOnly()); byte[] buffer = new byte[8 * 1024]; req.WritePreBody(200, reader.Length); while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0) { req.WriteFile(buffer, 0, bytesRead); } reader.Close(); } } else { // The URI maps to something that doesn’t exist in the file system req.WriteNotFoundResponse("<h1>404</h1><br><b>Content not found</b>"); } } catch (Exception) { return; } }
public override void Handler(WebRequest req) { //Every request should start with /files/ if (!req.URI.StartsWith(this.ServiceURI)) { throw new InvalidOperationException(); } //percent-decode URI string uri = req.URI; string[] pieces = req.URI.Substring(ServiceURI.Length).Split('/', '\\'); Dir422 dir = _fs.GetRoot(); //Grabs all the parts but the last part, which could be a file or a dir string piece = ""; for (int i = 1; i < pieces.Length - 1; i++) { piece = pieces[i]; //if (piece.Contains("%20")) piece = piece.Replace("%20", " "); dir = dir.GetDir(piece); //Check if directory exists if (dir == null) { req.WriteNotFoundResponse(); return; } } //Check if the last part is a file or a directory piece = pieces[pieces.Length - 1]; //if (piece.Contains("%20")) piece = piece.Replace("%20", " "); File422 file = dir.GetFile(piece); //TODO: This is returning Null and is not supposed to. if (file == null && req.Method == "PUT") { HandlePut(req, dir); return; } if (file != null) { //If it's a file, then return the file. Console.WriteLine("It's a file!"); RespondWithFile(file, req); } else { piece = pieces[pieces.Length - 1]; //if (piece.Contains("%20")) piece = piece.Replace("%20", " "); if (piece != "") { dir = dir.GetDir(piece); } if (dir != null) { //If it's a dir, return the dir RespondWithList(dir, req); } else { //Else return that nothing was found. req.WriteNotFoundResponse(); } } }
private void UploadFile(WebRequest req) { string[] pieces = req.URI.Substring(ServiceURI.Length).Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); if (pieces == null || pieces.Length == 0) { req.WriteNotFoundResponse("404: Path error."); return; } Dir422 dir = r_fs.GetRoot(); for (int i = 0; i < pieces.Length - 1; i++) { string piece = pieces[i]; dir = dir.GetDir(piece); if (dir == null) { req.WriteNotFoundResponse("404: Path error."); return; } } File422 file = dir.GetFile(PercentDecoding(pieces[pieces.Length - 1])); if (file != null) { req.WriteHTMLResponse("<html> File Already Exists! </html>"); return; } File422 newFile = dir.CreateFile(PercentDecoding(pieces[pieces.Length - 1])); FileStream str = (newFile.OpenReadWrite() as FileStream); Stream reqStr = req.Body; byte[] buf = new byte[4096]; long len = req.Len; if (len < 4096) { reqStr.Read(buf, 0, (int)len); str.Write(buf, 0, (int)len); str.Close(); return; } int count = reqStr.Read(buf, 0, 4096); int totalRead = count; while (count != 0 && totalRead < len) { str.Write(buf, 0, count); buf = new byte[4096]; count = reqStr.Read(buf, 0, 4096); totalRead += count; } // If bytes were read last time, trim zeroes and write last bit if (count != 0) { str.Write(buf, 0, count); } str.Close(); req.WriteHTMLResponse("<html> Upload Successful! </html>"); return; }
public override void Handler(WebRequest Req) { Dir422 Root = m_FS.GetRoot(); //Remove Last / here!!!! if (Req.URI.LastIndexOf('/') == Req.URI.Length - 1) { Req.URI = Req.URI.Substring(0, Req.URI.Length - 1); } //int x = 0; //1. Percent-decode URI. // THIS NOT GOOD ENOUGH!!! Req.URI = Utility.PercentDecode(Req.URI); //string test = Req.URI.Replace ("%20", " ");; // Set name of requested file||dir. string uriName = Utility.NameFromPath(Req.URI); //2. If it refers to file somewhere in the shared folder. if (Root.ContainsFile(uriName, true)) { string path = Req.URI.Substring(0, Req.URI.LastIndexOf("/")); Dir422 Dir = Utility.TraverseToDir(Root, path); StdFSFile File = (StdFSFile)Dir.GetFile(uriName); FileStream MyFileStream = (FileStream)File.OpenReadOnly(); if (Req.headers.ContainsKey("Range")) { // process partial response here Console.WriteLine("Process Partial Request"); int x = 0; } else { string contentType = Utility.ContentType(uriName); string response = Utility.BuildFileResponseString( MyFileStream.Length.ToString(), contentType); //if (contentType != "video/mp4") //{ byte[] sendResponseString = Encoding.ASCII.GetBytes(response); Req.bodyRequest.Write(sendResponseString, 0, sendResponseString.Length); //} //byte[] sendResponseString = Encoding.ASCII.GetBytes(response); int read = 0; byte[] send = new byte[7500]; while (read < MyFileStream.Length) { read = read + MyFileStream.Read(send, 0, send.Length); Req.bodyRequest.Write(send, 0, send.Length); } } } //3. Else if it refers to a folder somewhere in the shared folder. // Or is the shared directory else if (Root.ContainsDir(uriName, true) || Req.URI == ServiceURI || uriName == "") { if (Req.URI == ServiceURI || uriName == "") { string dirHTMLListing = BuildDirHTML(Root); byte[] sendResponseString = Encoding.ASCII.GetBytes(dirHTMLListing); Req.bodyRequest.Write(sendResponseString, 0, sendResponseString.Length); //Req.WriteHTMLResponse (dirHTMLListing); } else { Dir422 Dir = Utility.TraverseToDir(Root, Req.URI); string dirHTMLListing = BuildDirHTML(Dir); byte[] sendResponseString = Encoding.ASCII.GetBytes(dirHTMLListing); Req.bodyRequest.Write(sendResponseString, 0, sendResponseString.Length); //Req.WriteHTMLResponse (dirHTMLListing); } } //4.Else it’s a bad URI. else { Req.WriteNotFoundResponse("File or directory not found"); } }
private void DoUpload(WebRequest req, string percenDecoded) { string fileName = ""; Dir422 currentDir = null; if (percenDecoded == ServiceURI) { currentDir = r_sys.GetRoot(); } else { // The pluse one is the '/' after the '/files' so we remove '/files/' string[] pathPeices = percenDecoded.Substring(ServiceURI.Length + 1).Split('/'); currentDir = r_sys.GetRoot(); for (int i = 0; i < pathPeices.Length - 1; i++) { currentDir = currentDir.GetDir(pathPeices[i]); if (currentDir == null) { req.WriteNotFoundResponse(string.Empty); return; } } fileName = pathPeices [pathPeices.Length - 1]; } File422 newFile = currentDir.CreateFile(fileName); if (newFile == null) { // We could not create a new file return; } Stream s = newFile.OpenReadWrite(); if (s == null) { return; } byte[] bodyBytes = new byte[1024]; long bytesRead = 0; //Read all that we can. while (bytesRead < req.BodyLength) { // We need to read chuncks at a time since read wants an int // as the count, and we may loose data if we cast a long to an int. int read = req.Body.Read(bodyBytes, 0, 1024); bytesRead += read; if (read == 0) { break; } s.Write(bodyBytes, 0, read); Array.Clear(bodyBytes, 0, bodyBytes.Length); } s.Close(); req.WriteHTMLResponse(""); return; }
public static bool Start(int port, int threadCount) { //enable to true for testing with console outputs. bool test = false; //you need at least one to listen and additional for TCP sockets. threadCount = (threadCount <= 0) ? threadCount = 64 : threadCount; Initialize(threadCount); int threadCounter = 0; while (threadCounter < threadCount) { Thread t = new Thread( new ThreadStart(() => { ThreadWork(coll); }) ); threads.Add(t); //start the ThreadWorkerMethod from this thread t.Start(); threadCounter++; } //create listen thread Thread listenerThread = new Thread( new ThreadStart(() => { tcpListener = new TcpListener(IPAddress.Any, port); tcpListener.Start(); // start listening while (true) { try { TcpClient client = tcpListener.AcceptTcpClient(); //******NOTE: must dispose yourself. //create a thread to deal with new TCP socket. coll.Add(() => { WebRequest request = BuildRequest(client); if (request != null) { if (test) { Console.WriteLine(); Console.WriteLine("METHOD = {0}", request.Method); Console.WriteLine("REQUEST-TARGET = {0}", request.RequestTarget); Console.WriteLine("HTTP-VERSION = {0}", request.HTTPVersion); foreach (Tuple <string, string> t in request.Headers.Values) { Console.WriteLine("{0}: {1}", t.Item1, t.Item2); } Console.WriteLine(); byte[] buffer = new byte[1024]; int bytesRead = 0; string dataRead = ""; while ((bytesRead = request.Body.Read(buffer, 0, buffer.Length)) > 0) { dataRead += System.Text.Encoding.ASCII.GetString(buffer, 0, bytesRead); } Console.WriteLine("dataRead.Length = {0}", dataRead.Length); Console.WriteLine("dataRead = {0}", dataRead); } //should it be non-null then an appropriate handler is found in the list //of handlers/services that the web stores bool flag = false; for (int i = 0; i < services.Count; i++) { string SURI = services[i].ServiceURI; //if serviceURI is a prefix of request-target if (SURI == request.RequestTarget.Substring(0, SURI.Length)) { services[i].Handler(request); flag = true; break; } } if (!flag) { request.WriteNotFoundResponse(errorHtml); } } //else if request was null, then invalid request from client. //thread will go back to idle if it is null //close client before we leave. client.Close(); }); } catch (SocketException) { /*if (e.SocketErrorCode == SocketError.Interrupted){ * break; * } */ break; } } }) ); listenerThread.Start(); return(true); }
public override void Handler(WebRequest req) { if (req.URI.Length < this.ServiceURI.Length) { req.URI = this.ServiceURI; } if (!req.URI.StartsWith(this.ServiceURI)) { throw new InvalidOperationException(); } uriPath = req.URI; string[] pieces = req.URI.Substring(ServiceURI.Length).Split('/'); //split up the path by '/' tokens if (pieces.Length == 1 && pieces[0] == "") //we passed in only the root { RespondWithList(r_sys.GetRoot(), req); } for (int x = 0; x < pieces.Length; x++) { pieces[x] = decode(pieces[x]); } Dir422 dir = r_sys.GetRoot(); //grab the root of the filesystem if (req.httpMethod == "PUT") //if the method is put. { foreach (Tuple <string, string> header in req.headers) { if (header.Item1 == "Content-Length") { if (Convert.ToInt64(header.Item2) <= 0) { req.WriteInvalidUpload("400"); return; } } } for (int i = 0; i < pieces.Length - 1; i++) //go through the parts of the path { dir = dir.getDir(pieces[i]); if (dir == null) //if you encounter a directory that doesn't exist, tell the user that the target they requested is not found and return { req.WriteNotFoundResponse("File not found.\n"); return; } } File422 fileToCreate = dir.GetFile(pieces[pieces.Length - 1]); //grab the last file of the path if (fileToCreate == null) { string pathName = StandardFileSystem.rootPath; for (int i = 0; i < pieces.Length; i++) { pathName += "/"; pathName += pieces[i]; } FileStream fs = new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite); int x = 0; byte[] bodyBytes = new byte[4096]; string bodyContent = ""; x = req.bodyStream.Read(bodyBytes, 0, 4096); fs.Write(bodyBytes, 0, 4096); while (x > 0) { bodyContent += Encoding.ASCII.GetString(bodyBytes); x = req.bodyStream.Read(bodyBytes, 0, 4096); fs.Write(bodyBytes, 0, 4096); } fs.Close(); req.WriteHTMLResponse("200 OK"); } else { req.WriteInvalidUpload("File already exists"); } return; } for (int i = 0; i < pieces.Length - 1; i++) //go through the parts of the path { dir = dir.getDir(pieces[i]); if (dir == null) //if you encounter a directory that doesn't exist, tell the user that the target they requested is not found and return { req.WriteNotFoundResponse("File not found.\n"); return; } } //we now have the directory of one above the file / directory //one piece to process left //check if dir is in the last piece we have File422 file = dir.GetFile(pieces[pieces.Length - 1]); //grab the last file of the path if (file != null) { RespondWithFile(file, req); } else { dir = dir.getDir(pieces[pieces.Length - 1]); //if it wasn't a file, grab it as a dir if (dir != null) { RespondWithList(dir, req); } else //if it's null, tell the user it was not found { req.WriteNotFoundResponse("Not found\n"); } } }
public static bool Start(int port, int threadCount) { //you need at least one to listen and additional for TCP sockets. threadCount = (threadCount <= 0) ? threadCount = 64 : threadCount; Initialize(threadCount); int threadCounter = 0; while (threadCounter < threadCount) { Thread t = new Thread( new ThreadStart(() => { ThreadWork(coll); }) ); threads.Add(t); //start the ThreadWorkerMethod from this thread t.Start(); threadCounter++; } //create listen thread Thread listenerThread = new Thread( new ThreadStart(() => { tcpListener = new TcpListener(IPAddress.Any, port); tcpListener.Start(); // start listening while (true) { try { TcpClient client = tcpListener.AcceptTcpClient(); //******NOTE: must dispose yourself. //create a thread to deal with new TCP socket. coll.Add(() => { WebRequest request = BuildRequest(client); if (request != null) { //should it be non-null then an appropriate handler is found in the list //of handlers/services that the web stores bool flag = false; for (int i = 0; i < services.Count; i++) { string SURI = services[i].ServiceURI; //if serviceURI is a prefix of request-target if (request.RequestTarget.Length >= SURI.Length && SURI == request.RequestTarget.Substring(0, SURI.Length)) { services[i].Handler(request); flag = true; break; } } if (!flag) { request.WriteNotFoundResponse(errorHtml); } } //else if request was null, then invalid request from client. //thread will go back to idle if it is null //close client before we leave. client.Close(); }); } catch (SocketException) { /*if (e.SocketErrorCode == SocketError.Interrupted){ * break; * } */ break; } } } )); listenerThread.Start(); return(true); }
void SendFileRange(File422 file, long start, long end, long chunkSize, WebRequest req) { if (end < start) { throw new ArgumentException("Invalid start and end range"); } var fileStream = file.OpenReadOnly(); long fileSize = fileStream.Length; if (start > end) { req.WriteNotFoundResponse("Invalid Range Header Specified"); } if (end == 0) { end = fileSize; } req.Headers = new System.Collections.Concurrent.ConcurrentDictionary <string, string> (); if (end - start + 1 < chunkSize) { // only need to send 1 response string contentType = GetContentType(file.Name); if (contentType != null) { req.Headers ["Content-Type"] = contentType; } else { req.Headers ["Content-Type"] = "text/plain"; } var fileContents = GetFileRange(fileStream, start, end); req.WriteResponse("206 Partial Content", fileContents); } else { // need to send multiple responses string boundary = "5187ab27335732"; string contentType = GetContentType(file.Name); if (contentType != null) { req.Headers ["Content-Type"] = contentType; } long offset = start; long sent = 0; req.Headers ["Accept-Ranges"] = "bytes"; long sizeToSend = end - start + 1; while (sent <= sizeToSend) { long currentSize = (sizeToSend - sent) < chunkSize ? sizeToSend - sent: chunkSize; if (offset + currentSize > fileSize) { currentSize = fileSize - offset + 1; } if (currentSize <= 0) { break; } //Console.WriteLine ("Getting file range [{0}, {1}]", offset, offset + currentSize); var fileContents = GetFileRange(fileStream, offset, offset + currentSize); req.Headers ["Content-Range"] = String.Format("bytes {0}-{1}/{2}", offset, currentSize + offset, sizeToSend); req.WriteResponse("206 PartialContent", fileContents); offset += currentSize + 1; sent += currentSize; } } }