public bool ProcessRequest(IRequest request, ICallback callback) { if (!string.Equals(request.Method, "get", StringComparison.CurrentCultureIgnoreCase)) { callback.Continue(); return(true); } _cachedResource = new CachedResource(GetCachedResourcePath(request.Url)); _resourceIsCached = _cachedResource.Exists; if (_resourceIsCached) { _fileReadStream = _cachedResource.ContentReadStream; } else { _httpClient = new HttpClient(); _httpReponse = _httpClient.GetAsync(request.Url).Result; _httpStream = _httpReponse.Content.ReadAsStreamAsync().Result; if (_httpReponse.IsSuccessStatusCode) { _fileWriteStream = _cachedResource.ContentWriteStream; } } callback.Continue(); return(true); }
// // Summary: // Open the response stream. - To handle the request immediately set handleRequest // to true and return true. - To decide at a later time set handleRequest to false, // return true, and execute callback to continue or cancel the request. - To cancel // the request immediately set handleRequest to true and return false. This method // will be called in sequence but not from a dedicated thread. For backwards compatibility // set handleRequest to false and return false and the CefSharp.IResourceHandler.ProcessRequest(CefSharp.IRequest,CefSharp.ICallback) // method will be called. // // Parameters: // request: // request // // handleRequest: // see main summary // // callback: // callback // // Returns: // see main summary public bool Open(IRequest request, out bool handleRequest, ICallback callback) { uri = new Uri(request.Url); fileName = uri.AbsolutePath; // if url is blocked /*if (...request.Url....) { * * // cancel the request - set handleRequest to true and return false * handleRequest = true; * return false; * }*/ // if url is browser file if (uri.Host == "storage") { fileName = appPath + uri.Host + fileName; if (File.Exists(fileName)) { Task.Factory.StartNew(() => { using (callback) { FileStream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read); mimeType = ResourceHandler.GetMimeType(Path.GetExtension(fileName)); stream = fStream; callback.Continue(); } }); // handle the request at a later time handleRequest = false; return(true); } } // if url is request for icon of another file if (uri.Host == "fileicon") { Task.Factory.StartNew(() => { using (callback) { stream = FileIconUtils.GetFileIcon(fileName, FileIconSize.Large); mimeType = ResourceHandler.GetMimeType(".png"); callback.Continue(); } }); // handle the request at a later time handleRequest = false; return(true); } // by default reject callback.Dispose(); // cancel the request - set handleRequest to true and return false handleRequest = true; return(false); }
/// <summary> /// The process request async. /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; _fileInfo = new FileInfo(file); // Check if file exists if (!_fileInfo.Exists) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo); callback.Continue(); } // Check if file exists but empty else if (_fileInfo.Length == 0) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo); callback.Continue(); } else { Task.Run(() => { using (callback) { _chromelyResource.Content = null; _chromelyResource.MimeType = "text/html"; try { byte[] fileBytes = File.ReadAllBytes(file); _chromelyResource.Content = new MemoryStream(fileBytes); string extension = Path.GetExtension(file); _chromelyResource.MimeType = MimeMapper.GetMimeType(extension); } catch (Exception exception) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception); } if (_chromelyResource.Content == null) { callback.Cancel(); } else { SetResponseInfoOnSuccess(); callback.Continue(); } } }); } return(CefReturnValue.ContinueAsync); }
bool IResourceHandler.ProcessRequest(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; string resource; var fileExtension = Path.GetExtension(fileName); if (ResourceDictionary.TryGetValue(fileName, out resource) && !string.IsNullOrEmpty(resource)) { Task.Run(() => { using (callback) { var bytes = Encoding.UTF8.GetBytes(resource); stream = new MemoryStream(bytes); //var fileExtension = Path.GetExtension(fileName); mimeType = CefSharp.ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } }); return(true); } if (fileExtension == ".jpg") { Task.Run(() => { using (callback) { var path = AppDomain.CurrentDomain.BaseDirectory + string.Format(@"Resource\{0}", fileName);//The path for the home page of the module FileStream fs = File.OpenRead(path); int filelength = 0; filelength = (int)fs.Length; Byte[] bytes = new Byte[filelength]; fs.Read(bytes, 0, filelength); stream = new MemoryStream(bytes); mimeType = CefSharp.ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } }); return(true); } else { callback.Dispose(); } return(false); }
/// <summary> /// The process request async. /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var u = new Uri(request.Url); var fileAbsolutePath = u.AbsolutePath; var file = u.Authority + fileAbsolutePath; _fileInfo = new FileInfo(file); // Check if file exists if (!_fileInfo.Exists) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo); callback.Continue(); } // Check if file exists but empty else if (_fileInfo.Length == 0) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo); callback.Continue(); } else { Task.Run(() => { using (callback) { _chromelyResource.Content = null; _chromelyResource.MimeType = "text/html"; try { if (!ProcessAssmblyEmbeddedFile(request.Url, file, fileAbsolutePath)) { ProcessLocalFile(file); } } catch (Exception exception) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception); } if (_chromelyResource.Content == null) { callback.Cancel(); } else { SetResponseInfoOnSuccess(); callback.Continue(); } } }); } return(CefReturnValue.ContinueAsync); }
// // Summary: // Begin processing the request. // // Parameters: // request: // The request object. // // callback: // The callback used to Continue or Cancel the request (async). // // Returns: // To handle the request return true and call CefSharp.ICallback.Continue() // once the response header information is available CefSharp.ICallback.Continue() // can also be called from inside this method if header information is available // immediately). To cancel the request return false. public bool ProcessRequest(IRequest request, ICallback callback) { uri = new Uri(request.Url); fileName = uri.AbsolutePath; // if url is blocked /*if (!myForm.IsURLOk(request.Url)) { * // return true so it does not open up * return true; * }*/ // if url is browser file if (uri.Host == "storage") { fileName = appPath + uri.Host + fileName; if (File.Exists(fileName)) { Task.Factory.StartNew(() => { using (callback) { //var bytes = Encoding.UTF8.GetBytes(resource); //stream = new MemoryStream(bytes); FileStream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read); mimeType = ResourceHandler.GetMimeType(Path.GetExtension(fileName)); stream = fStream; callback.Continue(); } }); return(true); } } // if url is request for icon of another file if (uri.Host == "fileicon") { Task.Factory.StartNew(() => { using (callback) { stream = FileIconUtils.GetFileIcon(fileName, FileIconSize.Large); mimeType = ResourceHandler.GetMimeType(".png"); callback.Continue(); } }); return(true); } // by default reject callback.Dispose(); return(false); }
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { using (callback) { var url = request.Url; var image_path = url.Replace(@"/", "").Replace(@"resource:", ""); MimeType = ResourceHandler.GetMimeType(System.IO.Path.GetExtension(image_path)); var asm_name = Assembly.GetExecutingAssembly().GetName().Name; var bitmap = new BitmapImage(new Uri( $"pack://application:,,,/{asm_name};component/Images/{image_path}", UriKind.Absolute)); //make image a little bigger (just for purposes of visibility) var scale = new ScaleTransform() { ScaleX = 2, ScaleY = 2 }; var transformBmp = new TransformedBitmap(bitmap, scale); var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(transformBmp)); MemoryStream mem_stream = new MemoryStream(); encoder.Save(mem_stream); mem_stream.Position = 0; Stream = mem_stream; StatusCode = (int)HttpStatusCode.OK; callback.Continue(); } return(CefReturnValue.Continue); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://samples.mplayerhq.hu/SWF/zeldaADPCM5bit.swf"); var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse(); // Get the stream associated with the response. var receiveStream = httpWebResponse.GetResponseStream(); var mime = httpWebResponse.ContentType; var stream = new MemoryStream(); receiveStream.CopyTo(stream); httpWebResponse.Close(); //Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer stream.Position = 0; //Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect) ResponseLength = stream.Length; MimeType = mime; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } }); return(true); }
bool IResourceHandler.ProcessRequest(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; Assembly ass = Assembly.GetExecutingAssembly(); string resourcePath = ass.GetName().Name + "." + fileName.Replace("/", "."); if (!string.IsNullOrEmpty(request.Url)) { Task.Run(() => { using (callback) { var bytes = Encoding.UTF8.GetBytes(request.GetCharSet()); stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } }); return(true); } else { callback.Dispose(); } return(false); }
//New: //To upgrade: store the response stream in a class field, then call callback.Continue() instead of the old `requestCompletedCallback`. //See here for example of new usage: https://github.com/cefsharp/CefSharp/blob/cefsharp/43/CefSharp.Example/CefSharpSchemeHandler.cs public bool ProcessRequestAsync(IRequest request, ICallback callback) { try { Task.Run(delegate { // Base to dispose of callback as it wraps a managed resource using (callback) { var u = new Uri(request.Url); var filepath = u.Authority + u.AbsolutePath; FileInfo = new FileInfo(filepath); // When processing complete call continue callback.Continue(); } }); return true; } catch { return false; } }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { string value = "<SceneList><Scene name=\"Scene1\"/><Scene name=\"Scene2\"/></SceneList>"; Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(value ?? "")); if (stream == null) { callback.Cancel(); } //Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer stream.Position = 0; //Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect) ResponseLength = stream.Length; MimeType = "text/plain"; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } }); return(true); }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath.Substring(1); // remove starting slash var resourceName = "CefSharpSample.EmbeddedResources." + fileName; if (AvailableFiles.Contains(resourceName)) { Task.Run(() => { using (callback) { stream = ResourceAssembly.GetManifestResourceStream(resourceName); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } }); return true; } else { callback.Dispose(); } return false; }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { var url = request.Url; Task.Run(() => { using (callback) { var raw = Download(url); if (raw.Length >= 3 && "CWS" == Encoding.ASCII.GetString(raw.Take(3).ToArray())) { var policyPort = 843; var infoPort = Rand.om(49152, 65535); var info = ProductConfiguration.InfoWebSocketUrl; var compileSwf = DefacingAbc.EditHost(raw, infoPort); var cws = Converter.ToCws(compileSwf); PolicyServer.Start(policyPort); PiggInfoProxy.Start(info, infoPort); var stream = new MemoryStream(cws); ResponseLength = stream.Length; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } } }); return(true); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://samples.mplayerhq.hu/SWF/zeldaADPCM5bit.swf"); var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse(); // Get the stream associated with the response. var receiveStream = httpWebResponse.GetResponseStream(); var mime = httpWebResponse.ContentType; var stream = new MemoryStream(); receiveStream.CopyTo(stream); httpWebResponse.Close(); //Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer stream.Position = 0; //Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect) ResponseLength = stream.Length; MimeType = mime; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } }); return true; }
/// <summary> /// Begin processing the request. /// </summary> /// <param name="request">The request object.</param> /// <param name="callback">The callback used to Continue or Cancel the request (async).</param> /// <returns>To handle the request return true and call /// <see cref="ICallback.Continue"/> once the response header information is available /// <see cref="ICallback.Continue"/> can also be called from inside this method if /// header information is available immediately). /// To cancel the request return false.</returns> public bool ProcessRequest(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { var httpWebRequest = (HttpWebRequest)WebRequest.Create(request.Url); var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse(); // Get the stream associated with the response. var receiveStream = httpWebResponse.GetResponseStream(); var mime = httpWebResponse.ContentType; var stream = new MemoryStream(); receiveStream.CopyTo(stream); httpWebResponse.Close(); stream.Position = 0; //FFmpeg = _converter.ConvertLiveMedia(stream, Format.mp4, outputStream, Format.webm, new ConvertSettings() { VideoCodec = "libvpx", AudioCodec = "libvorbis", CustomInputArgs = "-preset ultrafast" }); //FFmpeg.Start(); //FFmpeg.Wait(); callback.Continue(); } }); return(true); }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; string resource; if (ResourceDictionary.TryGetValue(fileName, out resource) && !string.IsNullOrEmpty(resource)) { Task.Run(() => { var bytes = Encoding.UTF8.GetBytes(resource); stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); }); return(true); } return(false); }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; var localFilePath = "./LocalFiles" + fileName; if (File.Exists(localFilePath)) { Task.Run(() => { using (callback) { stream = File.OpenRead(localFilePath); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } }); return true; } else { callback.Dispose(); } return false; }
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var names = typeof(SkinView3D.Class).Assembly.GetManifestResourceNames(); Uri u = new Uri(request.Url); string resourceName = string.Format("{0}{1}", u.Authority, u.AbsolutePath).ToLower(); string resourcePath = @"/SkinView3D;component/" + resourceName; var assembly = typeof(SkinView3D.Class).Assembly; var rm = new ResourceManager(assembly.GetName().Name + ".g", assembly); var resources = rm.GetResourceSet(CultureInfo.CurrentCulture, true, true); var resourceDictionary = resources.Cast <DictionaryEntry>().ToDictionary(r => r.Key.ToString(), r => r.Value.ToString()); bool validResource = resourceDictionary.ContainsKey(resourceName); if (validResource) { Task.Run(() => { using (callback) { try { StreamResourceInfo sri = Application.GetResourceStream(new Uri(resourcePath, UriKind.Relative)); if (sri != null) { Stream stream = sri.Stream; string mimeType = sri.ContentType; // Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer stream.Position = 0; // Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect) ResponseLength = stream.Length; MimeType = mimeType; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } else { callback.Cancel(); } } catch (Exception ex) { callback.Cancel(); Program.LogConsoleLine(ex); } } }); } else { callback.Cancel(); } rm.ReleaseAllResources(); return(CefReturnValue.ContinueAsync); }
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var file = $"{uri.Host}:{uri.LocalPath}"; Task.Run(() => { using (callback) { if (!File.Exists(file)) { callback.Cancel(); return; } byte[] bytes = File.ReadAllBytes(file); var stream = new MemoryStream(bytes) { Position = 0 }; ResponseLength = stream.Length; var fileExtension = Path.GetExtension(file); MimeType = GetMimeType(fileExtension); StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } }); return(CefReturnValue.ContinueAsync); }
// Process request and craft response. public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; var requestedFilePath = frontendFolderPath + fileName; var isAccesToFilePermitted = IsRequestedPathInsideFolder( new DirectoryInfo(requestedFilePath), new DirectoryInfo(frontendFolderPath)); if (isAccesToFilePermitted && File.Exists(requestedFilePath)) { byte[] bytes = File.ReadAllBytes(requestedFilePath); Stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); MimeType = GetMimeType(fileExtension); callback.Continue(); return(CefReturnValue.Continue); } callback.Dispose(); return(CefReturnValue.Cancel); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; var localFilePath = "./_Local/" + fileName; if (File.Exists(localFilePath)) { stream = File.OpenRead(localFilePath); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); return(true); } callback.Dispose(); return(false); } }); return(true); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath.Substring(1); // remove starting slash var resourceName = "DemoWpfApp._Embedded." + fileName; if (AvailableFiles.Contains(resourceName)) { Task.Run(() => { using (callback) { stream = ResourceAssembly.GetManifestResourceStream(resourceName); var fileExtension = Path.GetExtension(fileName); mimeType = GetMimeType(fileExtension); callback.Continue(); } }); return(true); } callback.Dispose(); return(false); }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; string resource; if (ResourceDictionary.TryGetValue(fileName, out resource) && !string.IsNullOrEmpty(resource)) { Task.Run(() => { var bytes = Encoding.UTF8.GetBytes(resource); stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); }); return true; } return false; }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; if (uri.Host == "storage") { fileName = appPath + uri.Host + fileName; if (File.Exists(fileName)) { Task.Factory.StartNew(() => { using (callback) { //var bytes = Encoding.UTF8.GetBytes(resource); //stream = new MemoryStream(bytes); FileStream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read); mimeType = ResourceHandler.GetMimeType(Path.GetExtension(fileName)); stream = fStream; callback.Continue(); } }); return(true); } } if (uri.Host == "fileicon") { Task.Factory.StartNew(() => { using (callback) { stream = GetFileIcon(fileName, IconReader.IconSize.Large); mimeType = ResourceHandler.GetMimeType(".png"); callback.Continue(); } }); return(true); } callback.Dispose(); return(false); }
public void Continue() { if (responseCallback != null) { using (responseCallback) { responseCallback.Continue(); } } }
bool IResourceHandler.ProcessRequest(IRequest request, ICallback callback) { var processRequest = ProcessRequestAsync(request, callback); if (processRequest == CefReturnValue.Continue) { callback.Continue(); } return(processRequest != CefReturnValue.Cancel); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Uri u = new Uri(request.Url); String file = u.Authority + u.AbsolutePath; Assembly ass = Assembly.GetExecutingAssembly(); String resourcePath = ass.GetName().Name + "." + file.Replace("/", "."); Task.Run(() => { using (callback) { if (ass.GetManifestResourceInfo(resourcePath) != null) { Stream stream = ass.GetManifestResourceStream(resourcePath); string mimeType = "application/octet-stream"; switch (Path.GetExtension(file)) { case ".html": mimeType = "text/html"; break; case ".js": mimeType = "text/javascript"; break; case ".png": mimeType = "image/png"; break; case ".appcache": case ".manifest": mimeType = "text/cache-manifest"; break; } // Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer stream.Position = 0; // Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect) ResponseLength = stream.Length; MimeType = mimeType; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } else { callback.Cancel(); } } }); return(true); }
public async void FindServers(ICallback callback) { // Get the timeout value from the query string var result = await new ServerLocator(_logger).FindServers(1000).ConfigureAwait(false); var json = _json.SerializeToString(result); _stream = new MemoryStream(Encoding.UTF8.GetBytes(json)); callback.Continue(); }
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { MimeType = _response.Content.Headers.ContentType.MediaType; Stream = GenerateStreamFromString(_content); StatusCode = (int)_response.StatusCode; foreach (var header in _response.Headers) { Headers[header.Key] = string.Join(", ", header.Value); } callback.Continue(); return(CefReturnValue.Continue); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; Task.Run(() => { using (callback) { Stream stream = null; if (string.Equals(fileName, "/PostDataTest.html", StringComparison.OrdinalIgnoreCase)) { var postDataElement = request.PostData.Elements.FirstOrDefault(); stream = ResourceHandler.GetMemoryStream("Post Data: " + (postDataElement == null ? "null" : postDataElement.GetBody()), Encoding.UTF8); } if (string.Equals(fileName, "/PostDataAjaxTest.html", StringComparison.OrdinalIgnoreCase)) { var postData = request.PostData; if (postData == null) { stream = ResourceHandler.GetMemoryStream("Post Data: null", Encoding.UTF8); } else { var postDataElement = postData.Elements.FirstOrDefault(); stream = ResourceHandler.GetMemoryStream("Post Data: " + (postDataElement == null ? "null" : postDataElement.GetBody()), Encoding.UTF8); } } if (stream == null) { callback.Cancel(); } else { //Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer stream.Position = 0; //Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect) ResponseLength = stream.Length; MimeType = "text/html"; StatusCode = (int)HttpStatusCode.OK; Stream = stream; callback.Continue(); } } }); return(true); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { string requestUrl = request.Url; Task.Run(() => { using ( callback ) { try { var httpWebRequest = (HttpWebRequest)WebRequest.Create(requestUrl); var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse(); // Get the stream associated with the response. var receiveStream = httpWebResponse.GetResponseStream(); var mime = httpWebResponse.ContentType; var stream = new MemoryStream(); receiveStream.CopyTo(stream); httpWebResponse.Close(); stream.Position = 0; Bitmap bitmap = new Bitmap(stream); List <Rectangle> rectangleList = new List <Rectangle>(); rectangleList = FaceDetection.DetectAllFromBitmap(bitmap); foreach (Rectangle rectangle in rectangleList) { bitmap = ImageProcessor.Blur(bitmap, rectangle); } if (rectangleList.Count > 0) { stream.Position = 0; bitmap.Save(stream, ImageFormat.Jpeg); } stream.Position = 0; ResponseLength = stream.Length; MimeType = mime; StatusCode = (int)HttpStatusCode.OK; Stream = stream; } catch { } callback.Continue(); } }); return(true); }
/// <summary> /// Process request and craft response. /// </summary> /// <param name="request">the request object from CefSharp</param> /// <param name="callback">the object we call when we are done with processing</param> /// <returns></returns> public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { Handler.OnProcessRequest(this, request); callback.Continue(); } }); return(CefReturnValue.ContinueAsync); }
/// <summary> /// The process request async. /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override bool ProcessRequestAsync(IRequest request, ICallback callback) { var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; // Check if file exists and not empty var fileInfo = new FileInfo(file); if ((fileInfo.Exists) && fileInfo.Length > 0) { Task.Run(() => { using (callback) { try { _chromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.OK, Data = "OK." }; byte[] fileBytes = File.ReadAllBytes(file); _stream = new MemoryStream(fileBytes); string extension = Path.GetExtension(file); _mimeType = MimeMapper.GetMimeType(extension); } catch (Exception exception) { Log.Error(exception); _chromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.BadRequest, Data = "An error occured." }; } finally { callback.Continue(); } } }); return(true); } Log.Error($"File {request.Url} is not valid."); callback.Dispose(); return(false); }
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Configuring_servers_for_Ogg_media public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { var extension = Path.GetExtension(request.Url).TrimStart('.').ToLower(); var filePath = Resources.GetFilePath(extension); var stream = File.OpenRead(filePath); var len = stream.Length; var startI = 0L; Headers.Add("accept-ranges", "bytes"); Headers.Add("connection", "keep-alive"); var range = (request.Headers.Get("Range")); if (range != null) { var start = range.Split('=')[1]; var m = Regex.Match(start, @"(\d+)-(\d+)?"); start = m.Groups[1].Value; var end = len - 1; if (m.Groups[2] != null && !string.IsNullOrWhiteSpace(m.Groups[2].Value)) { end = Convert.ToInt64(m.Groups[2].Value); } startI = Convert.ToInt64(start); var length = len - startI; Headers.Add("content-range", "bytes " + start + "-" + end + "/" + len); Headers.Add("content-length", length.ToString(System.Globalization.CultureInfo.InvariantCulture)); stream.Seek(startI, SeekOrigin.Begin); len = length; } StatusCode = (int)HttpStatusCode.PartialContent; StatusText = "Partial Content"; MimeType = "video/" + extension; ResponseLength = len; callback.Continue(); } }); return(true); }
public override bool ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { Uri u = new Uri(request.Url); String file = u.Authority + u.AbsolutePath; Assembly ass = Assembly.GetExecutingAssembly(); String resourcePath = ass.GetName().Name + "." + file.Replace("/", ".").Replace("-", "_"); if (ass.GetManifestResourceInfo(resourcePath) != null) { Stream = ass.GetManifestResourceStream(resourcePath); switch (System.IO.Path.GetExtension(file)) { case ".html": MimeType = "text/html"; break; case ".js": MimeType = "text/javascript"; break; case ".png": MimeType = "image/png"; break; case ".appcache": case ".manifest": MimeType = "text/cache-manifest"; break; default: MimeType = "application/octet-stream"; break; } ResponseLength = Stream.Length; StatusCode = (int)HttpStatusCode.OK; callback.Continue(); } } }); return(true); }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.ToString().Substring(6); Uri u = ResourceHelper.GetResourceUri(fileName); if (u != null) { Task.Run(() => { using (callback) { try { StreamResourceInfo info = Application.GetResourceStream(u); byte[] buffer = new byte[info.Stream.Length]; info.Stream.Read(buffer, 0, buffer.Length); stream = new MemoryStream(buffer); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } catch { //todo: unknown image } } }); return true; } else { callback.Dispose(); } return false; }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var file = uri.Authority + uri.AbsolutePath; if (!File.Exists(file)) return false; var bytes = File.ReadAllBytes(file); stream = new MemoryStream(bytes); switch (Path.GetExtension(file)) { case ".html": mimeType = "text/html"; break; case ".js": mimeType = "text/javascript"; break; case ".png": mimeType = "image/png"; break; case ".appcache": case ".manifest": mimeType = "text/cache-manifest"; break; case ".css": mimeType = "text/css"; break; default: mimeType = "application/octet-stream"; break; } callback.Continue(); return true; }
bool IResourceHandler.ProcessRequestAsync(IRequest request, ICallback callback) { Task.Run(() => { using (callback) { var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://samples.mplayerhq.hu/SWF/zeldaADPCM5bit.swf"); var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse(); // Get the stream associated with the response. var receiveStream = httpWebResponse.GetResponseStream(); mime = httpWebResponse.ContentType; stream = new MemoryStream(); receiveStream.CopyTo(stream); httpWebResponse.Close(); callback.Continue(); } }); return true; }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { // The 'host' portion is entirely ignored by this scheme handler. var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; if(string.Equals(fileName, "/PostDataTest.html", StringComparison.OrdinalIgnoreCase)) { var postDataElement = request.PostData.Elements.FirstOrDefault(); var resourceHandler = ResourceHandler.FromString("Post Data: " + (postDataElement == null ? "null" : postDataElement.GetBody())); stream = (MemoryStream)resourceHandler.Stream; mimeType = "text/html"; callback.Continue(); return true; } if (string.Equals(fileName, "/PostDataAjaxTest.html", StringComparison.OrdinalIgnoreCase)) { var postData = request.PostData; if(postData == null) { var resourceHandler = ResourceHandler.FromString("Post Data: null"); stream = (MemoryStream)resourceHandler.Stream; mimeType = "text/html"; callback.Continue(); } else { var postDataElement = postData.Elements.FirstOrDefault(); var resourceHandler = ResourceHandler.FromString("Post Data: " + (postDataElement == null ? "null" : postDataElement.GetBody())); stream = (MemoryStream)resourceHandler.Stream; mimeType = "text/html"; callback.Continue(); } return true; } string resource; if (ResourceDictionary.TryGetValue(fileName, out resource) && !string.IsNullOrEmpty(resource)) { Task.Run(() => { using (callback) { var bytes = Encoding.UTF8.GetBytes(resource); stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); } }); return true; } else { callback.Dispose(); } return false; }
public bool ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; if (fileName == "/pure-min.css") { var content = File.ReadAllText(@".\static\pure-min.css"); stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); mimeType = "text/css"; statusText = "OK"; statusCode = (int)HttpStatusCode.OK; callback.Continue(); return true; } if (fileName == "/editor.html") { var content = File.ReadAllText(@".\static\editor.html"); stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); mimeType = "text/html"; statusText = "OK"; statusCode = (int)HttpStatusCode.OK; callback.Continue(); return true; } if (fileName == "/file") { if (request.Method == "GET") { var param = HttpUtility.ParseQueryString(uri.Query); var path = param["path"]; if (File.Exists(path)) { var content = File.ReadAllText(path); stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); mimeType = "text/plain"; statusText = "OK"; statusCode = (int)HttpStatusCode.OK; callback.Continue(); return true; } } else if (request.Method == "POST") { var elems = request.PostData.Elements; if (elems != null && elems.Count > 0) { var data = elems[0].GetBody("utf8"); MessageBox.Show(data); // @todo } } } stream = new MemoryStream(); statusText = "404 error"; statusCode = (int)HttpStatusCode.NotFound; callback.Continue(); return true; }
bool IResourceHandler.ProcessRequestAsync(IRequest request, ICallback callback) { callback.Continue(); return true; }
/// <summary> /// Read the request, then process it through the OWEN pipeline /// then populate the response properties. /// </summary> /// <param name="request">request</param> /// <param name="callback">callback</param> /// <returns>always returns true as we'll handle all requests this handler is registered for.</returns> public override bool ProcessRequestAsync(IRequest request, ICallback callback) { // PART 1 - Read the request - here we read the request and create a dictionary // that follows the OWEN standard var responseStream = new MemoryStream(); var requestBody = Stream.Null; if (request.Method == "POST") { using (var postData = request.PostData) { if (postData != null) { var postDataElements = postData.Elements; var firstPostDataElement = postDataElements.First(); var bytes = firstPostDataElement.Bytes; requestBody = new MemoryStream(bytes, 0, bytes.Length); //TODO: Investigate how to process multi part POST data //var charSet = request.GetCharSet(); //foreach (var element in elements) //{ // if (element.Type == PostDataElementType.Bytes) // { // var body = element.GetBody(charSet); // } //} } } } //TODO: Implement cancellation token //var cancellationTokenSource = new CancellationTokenSource(); //var cancellationToken = cancellationTokenSource.Token; var uri = new Uri(request.Url); var requestHeaders = request.Headers.ToDictionary(); //Add Host header as per http://owin.org/html/owin.html#5-2-hostname requestHeaders.Add("Host", new[] { uri.Host + (uri.Port > 0 ? (":" + uri.Port) : "") }); //http://owin.org/html/owin.html#3-2-environment //The Environment dictionary stores information about the request, //the response, and any relevant server state. //The server is responsible for providing body streams and header collections for both the request and response in the initial call. //The application then populates the appropriate fields with response data, writes the response body, and returns when done. //Keys MUST be compared using StringComparer.Ordinal. var owinEnvironment = new Dictionary<string, object>(StringComparer.Ordinal) { //Request http://owin.org/html/owin.html#3-2-1-request-data {"owin.RequestBody", requestBody}, {"owin.RequestHeaders", requestHeaders}, {"owin.RequestMethod", request.Method}, {"owin.RequestPath", uri.AbsolutePath}, {"owin.RequestPathBase", "/"}, {"owin.RequestProtocol", "HTTP/1.1"}, {"owin.RequestQueryString", uri.Query}, {"owin.RequestScheme", uri.Scheme}, //Response http://owin.org/html/owin.html#3-2-2-response-data {"owin.ResponseHeaders", new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)}, {"owin.ResponseBody", responseStream}, //Other Data {"owin.Version", "1.0.0"}, //{"owin.CallCancelled", cancellationToken} }; //PART 2 - Spawn a new task to execute the OWIN pipeline //We execute this in an async fashion and return true so other processing //can occur Task.Run(async () => { //Call into the OWEN pipeline await _appFunc(owinEnvironment); //Response has been populated - reset the position to 0 so it can be read responseStream.Position = 0; int statusCode; if (owinEnvironment.ContainsKey("owin.ResponseStatusCode")) { statusCode = Convert.ToInt32(owinEnvironment["owin.ResponseStatusCode"]); //TODO: Improve status code mapping - see if CEF has a helper function that can be exposed //StatusText = StatusCodeToStatusTextMapping[response.StatusCode]; } else { statusCode = (int)HttpStatusCode.OK; //StatusText = "OK"; } //Grab a reference to the ResponseHeaders var responseHeaders = (Dictionary<string, string[]>)owinEnvironment["owin.ResponseHeaders"]; //Populate the response properties Stream = responseStream; ResponseLength = responseStream.Length; StatusCode = statusCode; MimeType = responseHeaders.ContainsKey("Content-Type") ? responseHeaders["Content-Type"].First() : "text/plain"; //Add the response headers from OWEN to the Headers NameValueCollection foreach (var responseHeader in responseHeaders) { //It's possible for headers to have multiple values Headers.Add(responseHeader.Key, string.Join(";", responseHeader.Value)); } //Once we've finished populating the properties we execute the callback //Callback wraps an unmanaged resource, so let's explicitly Dispose when we're done using (callback) { callback.Continue(); } }); return true; }
/// <summary> /// Begin processing the request. If you have the data in memory you can execute the callback /// immediately and return true. For Async processing you would typically spawn a Task to perform processing, /// then return true. When the processing is complete execute callback.Continue(); In your processing Task, simply set /// the StatusCode, StatusText, MimeType, ResponseLength and Stream /// </summary> /// <param name="request">The request object.</param> /// <param name="callback">The callback used to Continue or Cancel the request (async).</param> /// <returns>To handle the request return true and call /// <see cref="ICallback.Continue"/> once the response header information is available /// <see cref="ICallback.Continue"/> can also be called from inside this method if /// header information is available immediately). /// To cancel the request return false.</returns> public virtual bool ProcessRequestAsync(IRequest request, ICallback callback) { callback.Continue(); return true; }