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