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