bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { //We don't need the callback, as it's an unmanaged resource we should dispose it (could wrap it in a using statement). callback.Dispose(); if (Stream == null) { bytesRead = 0; return(false); } //Data out represents an underlying buffer (typically 32kb in size). var buffer = new byte[dataOut.Length]; bytesRead = Stream.Read(buffer, 0, buffer.Length); //If bytesRead is 0 then no point attempting a write to dataOut if (bytesRead == 0) { return(false); } dataOut.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
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(() => { 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 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); }
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); }
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; }
// 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) { // 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.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; }
// // 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); }
public void TestCallbackDispose(ICallback callback) { var cb = (Callback <CefValue>)callback; id = cb.Id; callback.Dispose(); }
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); }
bool IResourceHandler.Open(IRequest request, out bool handleRequest, ICallback callback) { callback.Dispose(); //Legacy behaviour handleRequest = false; return(false); }
// // 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); }
bool IResourceHandler.Open(IRequest request, out bool handleRequest, ICallback callback) { callback.Dispose(); handleRequest = true; if (dataIn != null) { dataIn.Position = 0; } return(true); }
/// <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); }
bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { callback.Dispose(); try{ int length = (int)dataIn.Length; dataIn.CopyTo(dataOut, length); bytesRead = length; return(true); }catch { // catch IOException, possibly NullReferenceException if dataIn is null bytesRead = 0; 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 bool ProcessRequestAsync(IRequest request, ICallback callback) { var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; if (File.Exists(file)) { Task.Factory.StartNew(() => { using (callback) { try { this.mChromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.OK, Data = "OK." }; byte[] fileBytes = File.ReadAllBytes(file); this.mStream = new MemoryStream(fileBytes); string extension = Path.GetExtension(file); this.mMimeType = MimeMapper.GetMimeType(extension); } catch (Exception exception) { Log.Error(exception); this.mChromelyResponse = 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); }
/// <summary> /// Read response data. If data is available immediately copy to /// dataOut, set bytesRead to the number of bytes copied, and return true. /// To read the data at a later time set bytesRead to 0, return true and call ICallback.Continue() when the /// data is available. To indicate response completion return false. /// </summary> /// <param name="dataOut">Stream to write to</param> /// <param name="bytesRead">Number of bytes copied to the stream</param> /// <param name="callback">The callback used to Continue or Cancel the request (async).</param> /// <returns>If data is available immediately copy to dataOut, set bytesRead to the number of bytes copied, /// and return true.To indicate response completion return false.</returns> /// <remarks>Depending on this size of your response this method may be called multiple times</remarks> public bool ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { callback.Dispose(); if (outputStream == null) { bytesRead = 0; return(false); } outputStream.CopyTo(dataOut); var buffer = new byte[dataOut.Length]; bytesRead = outputStream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { if (!callback.IsDisposed) { callback.Dispose(); } if (_data == null) { bytesRead = 0; return(false); } bytesRead = _data.CopyTo(dataOut, (int)dataOut.Length, 8192); return(bytesRead > 0); }
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; var fileName = uri.Host; //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; //} 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); mimeType = "text/html"; 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 (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 bool ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { callback.Dispose(); if (_response.Body == null) { bytesRead = 0; return(false); } var buffer = new byte[dataOut.Length]; bytesRead = _response.Body.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, bytesRead); return(bytesRead > 0); }
bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { if (!callback.IsDisposed) { callback.Dispose(); } if (_response == null) { bytesRead = 0; return(false); } using (var s = new MemoryStream(_response)) { bytesRead = s.CopyTo(dataOut, (int)dataOut.Length, 8192); return(bytesRead > 0); } }
/// <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) { bool isCustomScheme = UrlSchemeProvider.IsUrlOfRegisteredCustomScheme(request.Url); if (isCustomScheme) { Task.Run(() => { using (callback) { try { this.mChromelyResponse = RequestTaskRunner.Run(request); string jsonData = this.mChromelyResponse.Data.EnsureResponseIsJsonFormat(); var content = Encoding.UTF8.GetBytes(jsonData); this.mStream.Write(content, 0, content.Length); this.mMimeType = "application/json"; } catch (Exception exception) { Log.Error(exception); this.mChromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.BadRequest, Data = "An error occured." }; } finally { callback.Continue(); } } }); return(true); } Log.Error($"Url {request.Url} is not of a registered custom scheme."); callback.Dispose(); return(false); }
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 override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { Uri uri = new Uri(request.Url); string fileName = uri.Authority; if(!uri.AbsolutePath.Equals("/")) { fileName += uri.AbsolutePath; } string requestedFilePath = frontendFolderPath + '/' + fileName; DirectoryInfo filePathDirectoryInfo = new DirectoryInfo(requestedFilePath); bool isAccessToFilePermitted = IsRequestedPathValid(filePathDirectoryInfo, sourceDirectoryInfo); if(filePathDirectoryInfo.Attributes == FileAttributes.Normal) { Logger.LogReport("Yo wtf"); } if (isAccessToFilePermitted && File.Exists(requestedFilePath)) { Task.Run(() => { byte[] bytes = File.ReadAllBytes(requestedFilePath); Stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); MimeType = Cef.GetMimeType(fileExtension); callback.Continue(); return CefReturnValue.Continue; }); return CefReturnValue.ContinueAsync; } StatusCode = (int)HttpStatusCode.NotFound; callback.Dispose(); return CefReturnValue.Cancel; }
bool IResourceHandler.ProcessRequest(IRequest request, ICallback callback) { var uri = new Uri(request.Url); string fullPath = Path.Combine(System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase, uri.Authority + uri.AbsolutePath); if (File.Exists(fullPath)) { stream = new MemoryStream(File.ReadAllBytes(fullPath)); var fileExtension = Path.GetExtension(uri.AbsolutePath); mimeType = ResourceHandler.GetMimeType(fileExtension); callback.Continue(); return(true); } else { HWLogger.DEFAULT.Error("error:can not find filename:" + Path.GetFullPath(fullPath)); callback.Dispose(); return(false); } }
// // Summary: // Read response data. If data is available immediately copy to dataOut, set // bytesRead to the number of bytes copied, and return true. To read the data // at a later time set bytesRead to 0, return true and call ICallback.Continue() // when the data is available. To indicate response completion return false. // // Parameters: // dataOut: // Stream to write to // // bytesRead: // Number of bytes copied to the stream // // callback: // The callback used to Continue or Cancel the request (async). // // Returns: // If data is available immediately copy to dataOut, set bytesRead to the number // of bytes copied, and return true.To indicate response completion return false. // // Remarks: // Depending on this size of your response this method may be called multiple // times public bool ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { //Dispose the callback as it's an unmanaged resource, we don't need it in this case callback.Dispose(); if (stream == null) { bytesRead = 0; return(false); } //Data out represents an underlying buffer (typically 32kb in size). var buffer = new byte[dataOut.Length]; bytesRead = stream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
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 override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; var requestedFilePath = _frontendFolderPath + fileName; if (File.Exists(requestedFilePath)) { byte[] bytes = File.ReadAllBytes(requestedFilePath); Stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); MimeType = Cef.GetMimeType(fileExtension); callback.Continue(); return(CefReturnValue.Continue); } callback.Dispose(); return(CefReturnValue.Cancel); }
// Process request and craft response. public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { var uri = new Uri(request.Url); var fileName = uri.AbsolutePath; var filematch = new Regex("\\.(.{1,5})"); if (!filematch.IsMatch(fileName)) { fileName = "index.html"; } var requestedFilePath = (frontendFolderPath + "\\" + uri.Host + "\\" + fileName).Split('?')[0]; var clearURL = new Regex("index.html(.*)"); requestedFilePath = clearURL.Replace(requestedFilePath, "index.html"); var isAccesToFilePermitted = IsRequestedPathInsideFolder( new DirectoryInfo(requestedFilePath), new DirectoryInfo(frontendFolderPath)); bool fileExists = File.Exists(requestedFilePath); if (isAccesToFilePermitted && fileExists) { byte[] bytes = File.ReadAllBytes(requestedFilePath); Stream = new MemoryStream(bytes); var fileExtension = Path.GetExtension(fileName); MimeType = Cef.GetMimeType(fileExtension); callback.Continue(); return(CefReturnValue.Continue); } callback.Dispose(); return(CefReturnValue.Cancel); }
public bool ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { callback.Dispose(); var buffer = new byte[dataOut.Length]; if (_resourceIsCached) { bytesRead = _fileReadStream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); return(bytesRead > 0); } bytesRead = _httpStream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); _fileWriteStream?.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
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; }
bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { //Dispose the callback as it's an unmanaged resource, we don't need it in this case callback.Dispose(); if(stream == null) { bytesRead = 0; return false; } //Data out represents an underlying buffer (typically 32kb in size). var buffer = new byte[dataOut.Length]; bytesRead = stream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); return bytesRead > 0; }
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(() => { 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; }
// Process request and craft response. public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback) { if (request.Method == "OPTIONS") { // This is the CORS request, and that's good base.StatusCode = 200; if (!string.IsNullOrEmpty(_app.AllowedHosts)) { base.Headers.Add("Access-Control-Allow-Origin", _app.AllowedHosts); } base.Headers.Add("Access-Control-Allow-Methods", "GET,POST,PUT,OPTIONS"); base.Headers.Add("Access-Control-Allow-Headers", "Content-Type, Accept, authorization"); callback.Continue(); return(CefReturnValue.Continue); } var uri = new Uri(request.Url); Console.WriteLine($"-----------------\r\n{request.Url}"); try { // Request for the identity server queries (token/authorize) if (uri.LocalPath == "/authorize") { // validate the client request data var keyValuePairs = uri.Query.Split('&').Select(p => { var pair = p.Split('='); return(new KeyValuePair <string, string>(pair[0], Uri.UnescapeDataString(pair[1]))); }).ToList(); foreach (var item in keyValuePairs) { Console.WriteLine($"Authorize: {item.Key} = {item.Value}"); } string redirectUri = keyValuePairs.FirstOrDefault(k => k.Key == "redirect_uri").Value; string state = keyValuePairs.FirstOrDefault(k => k.Key == "state").Value; string clientId = keyValuePairs.FirstOrDefault(k => k.Key == "client_id").Value; string clientSecret = keyValuePairs.FirstOrDefault(k => k.Key == "client_secret").Value; string requestedScopes = keyValuePairs.FirstOrDefault(k => k.Key == "scope").Value; // TODO: Validate the redirect URL, client ID, secret (and possibly the referrer value) if (clientId != _app.ClientID || clientSecret != _app.ClientSecret) { base.StatusCode = (int)System.Net.HttpStatusCode.BadRequest; // replace this with some Razor content base.Stream = new System.IO.MemoryStream(System.Text.UTF8Encoding.UTF8.GetBytes("<HTML><body>Client ID or Secret bad</body></HTML>")); base.Headers.Add("Cache-Control", "no-store"); base.Headers.Add("Pragma", "no-cache"); base.MimeType = "text/html;charset=UTF-8"; callback.Continue(); return(CefReturnValue.Continue); } if (_app.redirect_uri?.Any() == true && !_app.redirect_uri.Contains(redirectUri)) { base.StatusCode = (int)System.Net.HttpStatusCode.BadRequest; // replace this with some Razor content base.Stream = new System.IO.MemoryStream(System.Text.UTF8Encoding.UTF8.GetBytes("<HTML><body>Bad Redirect URL provided</body></HTML>")); base.Headers.Add("Cache-Control", "no-store"); base.Headers.Add("Pragma", "no-cache"); base.MimeType = "text/html;charset=UTF-8"; callback.Continue(); return(CefReturnValue.Continue); } // Check the scopes _context.Scopes = requestedScopes; // This client (application) is authorized to connect to the system, and we have a logged in user in the system _context.Code = Guid.NewGuid().ToFhirId(); _context.ExpiresAt = DateTimeOffset.Now.AddMinutes(2); // This only lives for a very short time (not that it really matters in process where you can't get in anyway) base.StatusCode = (int)System.Net.HttpStatusCode.Redirect; base.Headers.Remove("Location"); base.Headers.Add("Location", $"{redirectUri}?code={_context.Code}&state={state}"); callback.Continue(); return(CefReturnValue.Continue); } if (uri.LocalPath == "/token") { // validate the token if (request.PostData != null) { var data = request.PostData.Elements.FirstOrDefault(); var body = data.GetBody(); var keyValuePairs = body.Split('&').Select(p => { var pair = p.Split('='); return(new KeyValuePair <string, string>(pair[0], Uri.UnescapeDataString(pair[1]))); }).ToList(); foreach (var item in keyValuePairs) { Console.WriteLine($"Token: {item.Key} = {item.Value}"); } string code = keyValuePairs.FirstOrDefault(k => k.Key == "code").Value; string grant_type = keyValuePairs.FirstOrDefault(k => k.Key == "grant_type").Value; if (code != _context.Code || grant_type != "authorization_code") { base.StatusCode = (int)System.Net.HttpStatusCode.Unauthorized; TokenResponse responseTokenError = new TokenResponse() { error_description = "Invalid Code or unsupported grant_type requested" }; string jsonInvalidCode = JsonConvert.SerializeObject(responseTokenError); Console.WriteLine($"Token: {jsonInvalidCode}"); base.Stream = new System.IO.MemoryStream(System.Text.UTF8Encoding.UTF8.GetBytes(jsonInvalidCode)); base.Headers.Add("Cache-Control", "no-store"); base.Headers.Add("Pragma", "no-cache"); base.MimeType = "application/json;charset=UTF-8"; callback.Continue(); return(CefReturnValue.Continue); } string redirect_uri = keyValuePairs.FirstOrDefault(k => k.Key == "redirect_uri").Value; if (_app.redirect_uri?.Any() == true && !_app.redirect_uri.Contains(redirect_uri)) { base.StatusCode = (int)System.Net.HttpStatusCode.Unauthorized; TokenResponse responseTokenError = new TokenResponse() { error_description = "Invalid redirect_uri provided" }; string jsonInvalidCode = JsonConvert.SerializeObject(responseTokenError); Console.WriteLine($"Token: {jsonInvalidCode}"); base.Stream = new System.IO.MemoryStream(System.Text.UTF8Encoding.UTF8.GetBytes(jsonInvalidCode)); base.Headers.Add("Cache-Control", "no-store"); base.Headers.Add("Pragma", "no-cache"); base.MimeType = "application/json;charset=UTF-8"; callback.Continue(); return(CefReturnValue.Continue); } } // TODO: additional validation // ... // Grab the id_token if it's required string id_token = null; if ((_context.Scopes.Contains("fhirUser") || _context.Scopes.Contains("profile")) && _context.Scopes.Contains("openid") && _getIdToken != null) { // Need to also include the id_token id_token = _getIdToken(_app, _context); } // All has been validated correctly, so we can return the token response _context.ExpiresAt = DateTimeOffset.Now.AddSeconds(3600); _context.Bearer = Guid.NewGuid().ToFhirId(); TokenResponse responseToken = new TokenResponse() { access_token = _context.Bearer, id_token = id_token, token_type = "Bearer", expires_in = 3600, scope = _context.Scopes, }; responseToken.patient = _context.ContextProperties.FirstOrDefault(p => p.Key == "patient").Value; responseToken.encounter = _context.ContextProperties.FirstOrDefault(p => p.Key == "encounter").Value; responseToken.episodeofcare = _context.ContextProperties.FirstOrDefault(p => p.Key == "episodeofcare").Value; responseToken.organization = _context.ContextProperties.FirstOrDefault(p => p.Key == "organization").Value; responseToken.practitioner = _context.ContextProperties.FirstOrDefault(p => p.Key == "practitioner").Value; responseToken.practitionerrole = _context.ContextProperties.FirstOrDefault(p => p.Key == "practitionerrole").Value; responseToken.nash_pub_cert = _context.ContextProperties.FirstOrDefault(p => p.Key == "X-NASH-Public-Cert").Value; base.StatusCode = (int)System.Net.HttpStatusCode.OK; string json = JsonConvert.SerializeObject(responseToken); Console.WriteLine($"Token: {json}"); base.Stream = new System.IO.MemoryStream(System.Text.UTF8Encoding.UTF8.GetBytes(json)); base.Headers.Add("Cache-Control", "no-store"); base.Headers.Add("Pragma", "no-cache"); base.MimeType = "application/json;charset=UTF-8"; callback.Continue(); return(CefReturnValue.Continue); } // This is a regular request // TODO: Process any Auth pages // Otherwise its a big no. callback.Cancel(); return(CefReturnValue.Cancel); } catch (Exception ex) { callback.Dispose(); return(CefReturnValue.Cancel); } }
bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { //We don't need the callback, as it's an unmanaged resource we should dispose it (could wrap it in a using statement). callback.Dispose(); if (Stream == null) { bytesRead = 0; return false; } //Data out represents an underlying buffer (typically 32kb in size). var buffer = new byte[dataOut.Length]; bytesRead = Stream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); return bytesRead > 0; }