/// <summary>
/// Copies the item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="store">The store.</param>
/// <param name="source">The source.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavForbiddenException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavPreconditionFailedException"></exception>
private static void CopyItem(IWebDavContext context, IWebDavStore store, IWebDavStoreItem source)
{
Uri destinationUri = GetDestinationHeader(context.Request);
IWebDavStoreCollection destinationParentCollection = GetParentCollection(store, context, destinationUri);
bool copyContent = (GetDepthHeader(context.Request) != 0);
bool isNew = true;
string destinationName = Uri.UnescapeDataString(destinationUri.Segments.Last().TrimEnd('/', '\\'));
IWebDavStoreItem destination = destinationParentCollection.GetItemByName(destinationName);
if (destination != null)
{
if (source.ItemPath == destination.ItemPath)
{
throw new WebDavForbiddenException();
}
if (!GetOverwriteHeader(context.Request))
{
throw new WebDavPreconditionFailedException();
}
if (destination is IWebDavStoreCollection)
{
destinationParentCollection.Delete(destination);
}
isNew = false;
}
destinationParentCollection.CopyItemHere(source, destinationName, copyContent);
var statusCode = isNew ? HttpStatusCode.Created : HttpStatusCode.NoContent;
context.SetStatusCode(statusCode);
}
/// <summary>
/// Moves the
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <param name="sourceWebDavStoreItem">The <see cref="IWebDavStoreItem" /> that will be moved</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavForbiddenException">If the source path is the same as the destination path</exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavPreconditionFailedException">If one of the preconditions failed</exception>
private void MoveItem(IWebDavContext context, IWebDavStore store, IWebDavStoreItem sourceWebDavStoreItem)
{
Uri destinationUri = GetDestinationHeader(context.Request);
IWebDavStoreCollection destinationParentCollection = GetParentCollection(store, context, destinationUri);
bool isNew = true;
string destinationName = Uri.UnescapeDataString(destinationUri.Segments.Last().TrimEnd('/', '\\'));
IWebDavStoreItem destination = destinationParentCollection.GetItemByName(destinationName);
if (destination != null)
{
if (sourceWebDavStoreItem.ItemPath == destination.ItemPath)
{
throw new WebDavForbiddenException();
}
// if the overwrite header is F, statuscode = precondition failed
if (!GetOverwriteHeader(context.Request))
{
throw new WebDavPreconditionFailedException();
}
// else delete destination and set isNew to false
destinationParentCollection.Delete(destination);
isNew = false;
}
destinationParentCollection.MoveItemHere(sourceWebDavStoreItem, destinationName);
// send correct response
context.SetStatusCode(isNew ? HttpStatusCode.Created : HttpStatusCode.NoContent);
}
/// <summary>
/// Initializes a new instance of the <see cref="TextFilePropertyStoreFactory"/> class.
/// </summary>
/// <param name="options">The options for the text file property store</param>
/// <param name="deadPropertyFactory">The factory for the dead properties</param>
/// <param name="webDavContext">The WebDAV request context</param>
/// <param name="logger">The logger for the property store factory</param>
public TextFilePropertyStoreFactory(IOptions <TextFilePropertyStoreOptions> options, IDeadPropertyFactory deadPropertyFactory, IWebDavContext webDavContext, ILogger <TextFilePropertyStore> logger)
{
_options = options?.Value ?? new TextFilePropertyStoreOptions();
_logger = logger;
_deadPropertyFactory = deadPropertyFactory;
_webDavContext = webDavContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="SQLitePropertyStoreFactory"/> class.
/// </summary>
/// <param name="webDavContext">The WebDAV request context</param>
/// <param name="logger">The logger for the property store factory</param>
/// <param name="deadPropertyFactory">The factory for dead properties</param>
/// <param name="options">The options for this property store</param>
public SQLitePropertyStoreFactory(IWebDavContext webDavContext, ILogger <SQLitePropertyStore> logger, IDeadPropertyFactory deadPropertyFactory, IOptions <SQLitePropertyStoreOptions> options = null)
{
_webDavContext = webDavContext;
_logger = logger;
_deadPropertyFactory = deadPropertyFactory;
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="PutHandler"/> class.
/// </summary>
/// <param name="fileSystem">The root file system</param>
/// <param name="context">The WebDAV request context</param>
/// <param name="entryPropertyInitializer">The property initializer</param>
/// <param name="logger">The logger</param>
public PutHandler(IFileSystem fileSystem, IWebDavContext context, IEntryPropertyInitializer entryPropertyInitializer, ILogger <PutHandler> logger)
{
_fileSystem = fileSystem;
_context = context;
_entryPropertyInitializer = entryPropertyInitializer;
_logger = logger;
}
/// <summary>
/// Copies the item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="store">The store.</param>
/// <param name="source">The source.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavForbiddenException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavPreconditionFailedException"></exception>
private static void CopyItem(IWebDavContext context, IWebDavStore store, IWebDavStoreItem source)
{
Uri destinationUri = GetDestinationHeader(context.Request);
IWebDavStoreCollection destinationParentCollection = GetParentCollection(store, context, destinationUri);
bool copyContent = (GetDepthHeader(context.Request) != 0);
bool isNew = true;
string destinationName = Uri.UnescapeDataString(destinationUri.Segments.Last().TrimEnd('/', '\\'));
IWebDavStoreItem destination = destinationParentCollection.GetItemByName(destinationName);
if (destination != null)
{
if (source.ItemPath == destination.ItemPath)
throw new WebDavForbiddenException();
if (!GetOverwriteHeader(context.Request))
throw new WebDavPreconditionFailedException();
if (destination is IWebDavStoreCollection)
destinationParentCollection.Delete(destination);
isNew = false;
}
destinationParentCollection.CopyItemHere(source, destinationName, copyContent);
var statusCode = isNew ? HttpStatusCode.Created : HttpStatusCode.NoContent;
context.SetStatusCode(statusCode);
}
/// <summary>
/// Initializes a new instance of the <see cref="SQLitePropertyStoreFactory"/> class.
/// </summary>
/// <param name="webDavContext">The WebDAV request context</param>
/// <param name="logger">The logger for the property store factory</param>
/// <param name="deadPropertyFactory">The factory for dead properties</param>
/// <param name="options">The options for this property store</param>
public SQLitePropertyStoreFactory([NotNull] IWebDavContext webDavContext, [NotNull] ILogger <SQLitePropertyStore> logger, [NotNull] IDeadPropertyFactory deadPropertyFactory, [CanBeNull] IOptions <SQLitePropertyStoreOptions> options = null)
{
_webDavContext = webDavContext;
_logger = logger;
_deadPropertyFactory = deadPropertyFactory;
_options = options;
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IHttpListenerContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavMethodNotAllowedException"></exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
IWebDavStoreItem source = context.Request.Url.GetItem(store, context);
if (source is IWebDavStoreDocument || source is IWebDavStoreCollection)
CopyItem(context, store, source);
else
throw new WebDavMethodNotAllowedException();
}
/// <summary>
/// Create generic property
/// </summary>
/// <param name="entry">The entry to create the properties for</param>
/// <param name="propertyStore">The property store</param>
/// <param name="context">The PUT/MKCOL request context</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The task</returns>
protected virtual Task CreateGenericPropertiesAsync(
IEntry entry,
IPropertyStore propertyStore,
IWebDavContext context,
CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
/// <summary>
/// Initializes a new instance of the <see cref="LockHandler"/> class.
/// </summary>
/// <param name="context">The WebDAV request context</param>
/// <param name="rootFileSystem">The root file system</param>
/// <param name="lockManager">The lock manager</param>
/// <param name="timeoutPolicy">The timeout policy for the selection of the <see cref="TimeoutHeader"/> value</param>
public LockHandler(IWebDavContext context, IFileSystem rootFileSystem, ILockManager lockManager = null, ITimeoutPolicy timeoutPolicy = null)
{
_context = context;
_rootFileSystem = rootFileSystem;
_lockManager = lockManager;
_timeoutPolicy = timeoutPolicy;
HttpMethods = _lockManager == null ? new string[0] : new[] { "LOCK" };
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
/***************************************************************************************************
* Send the response
***************************************************************************************************/
WindowsIdentity Identity = (WindowsIdentity)Thread.GetData(Thread.GetNamedDataSlot(Constants.HttpUser));
var statusCode = WebDavStoreItemLock.UnLock(context.Request.Url, GetLockTokenHeader(context.Request), Identity.Name);
context.SetStatusCode(statusCode);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
/***************************************************************************************************
* Send the response
***************************************************************************************************/
WindowsIdentity Identity = (WindowsIdentity)Thread.GetData(Thread.GetNamedDataSlot(Constants.HttpUser));
var statusCode = WebDavStoreItemLock.UnLock(context.Request.Url, GetLockTokenHeader(context.Request), Identity.Name);
context.SetStatusCode(statusCode);
}
/// <summary>
/// Sets status code and description.
/// </summary>
/// <param name="context">The <see cref="IHttpListenerContext" /> to send the response through.</param>
/// <param name="statusCode">The HTTP status code for the response.</param>
/// <exception cref="System.ArgumentNullException">context</exception>
/// <exception cref="ArgumentNullException"><paramref name="context" /> is <c>null</c>.</exception>
public static void SetStatusCode(this IWebDavContext context, int statusCode)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
context.Response.StatusCode = statusCode;
context.Response.StatusDescription = HttpWorkerRequest.GetStatusDescription(statusCode);
}
///// <summary>
///// Gets the prefix <see cref="Uri" /> that matches the specified <see cref="Uri" />.
///// </summary>
///// <param name="uri">The <see cref="Uri" /> to find the most specific prefix <see cref="Uri" /> for.</param>
///// <param name="context">Context</param>
///// <returns>
///// The most specific <see cref="Uri" /> for the given <paramref name="uri" />.
///// </returns>
///// <exception cref="WebDAVSharp.Server.Exceptions.WebDavInternalServerException">Unable to find correct server root</exception>
///// <exception cref="WebDavInternalServerException"><paramref name="uri" /> specifies a <see cref="Uri" /> that is not known to the <paramref name="server" />.</exception>
//public static Uri GetPrefixUri(this Uri uri, IWebDavContext context)
//{
// string.Format("{0}://{1}", context.Request.Url.Scheme, context.Request.Url.Authority);
// string url = uri.ToString();
// foreach (
// string prefix in
// server.Listener.Prefixes.Where(
// prefix => url.StartsWith(uri.ToString(), StringComparison.OrdinalIgnoreCase)))
// return new Uri(prefix);
// throw new WebDavInternalServerException("Unable to find correct server root");
//}
/// <summary>
/// Retrieves a store item through the specified
/// <see cref="Uri" /> from the
/// specified
/// <see cref="WebDavServer" /> and
/// <see cref="IWebDavStore" />.
/// </summary>
/// <param name="uri">The <see cref="Uri" /> to retrieve the store item for.</param>
/// <param name="store">The <see cref="IWebDavStore" /> from which to retrieve the store item.</param>
/// <param name="context">Context</param>
/// <returns>
/// The retrieved store item.
/// </returns>
/// <exception cref="System.ArgumentNullException"><para>
/// <paramref name="uri" /> is <c>null</c>.</para>
/// <para>
/// <paramref name="context" /> is <c>null</c>.</para>
/// <para>
/// <paramref name="store" /> is <c>null</c>.</para></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavNotFoundException">If the item was not found.</exception>
/// <exception cref="WebDavConflictException"><paramref name="uri" /> refers to a document in a collection, where the collection does not exist.</exception>
/// <exception cref="WebDavNotFoundException"><paramref name="uri" /> refers to a document that does not exist.</exception>
public static IWebDavStoreItem GetItem(this Uri uri, IWebDavStore store, IWebDavContext context)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (store == null)
{
throw new ArgumentNullException("store");
}
IWebDavStoreCollection collection = store.Root;
IWebDavStoreItem item = null;
if (context.Request.Url.Segments.Length - 1 == uri.Segments.Length)
{
return(collection);
}
//todo пути с глубиной больше рута глючат. надо дописать логику далее.
for (int index = uri.Segments.Length; index < context.Request.Url.Segments.Length; index++)
{
string segmentName = Uri.UnescapeDataString(context.Request.Url.Segments[index]);
IWebDavStoreItem nextItem = collection.GetItemByName(segmentName.TrimEnd('/', '\\'));
if (nextItem == null)
{
throw new WebDavNotFoundException(); //throw new WebDavConflictException();
}
if (index == context.Request.Url.Segments.Length - 1)
{
item = nextItem;
}
else
{
collection = nextItem as IWebDavStoreCollection;
if (collection == null)
{
throw new WebDavNotFoundException();
}
}
}
if (item == null)
{
throw new WebDavNotFoundException();
}
return(item);
}
/// <summary>
/// Parses the text into a <see cref="IfHeader"/>
/// </summary>
/// <param name="s">The text to parse</param>
/// <param name="etagComparer">The comparer to use for entity tag comparison</param>
/// <param name="context">The WebDAV request context</param>
/// <returns>The new <see cref="IfHeader"/></returns>
public static IfHeader Parse(string s, EntityTagComparer etagComparer, IWebDavContext context)
{
var source = new StringSource(s);
var lists = IfHeaderList.Parse(source, etagComparer, context).ToList();
if (!source.Empty)
{
throw new ArgumentException("Not an accepted list of conditions", nameof(s));
}
return(new IfHeader(lists));
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
// Get the parent collection of the item
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
// Get the item from the collection
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
// Deletes the item
collection.Delete(item);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
// Get the parent collection of the item
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
// Get the item from the collection
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
// Deletes the item
collection.Delete(item);
}
/// <summary>
/// Sends the response
/// </summary>
/// <param name="context">The <see cref="IWebDavContext" /> containing the response</param>
/// <param name="responseDocument">The <see cref="XmlDocument" /> containing the response body</param>
private static void MakeResponse(IWebDavContext context, XmlDocument responseDocument)
{
// convert the XmlDocument
byte[] responseBytes = Encoding.UTF8.GetBytes(responseDocument.InnerXml);
// HttpStatusCode doesn't contain WebDav status codes, but HttpWorkerRequest can handle these WebDav status codes
context.SetStatusCode((int)WebDavStatusCode.MultiStatus);
context.Response.ContentLength64 = responseBytes.Length;
context.Response.AppendHeader("Content-Type", "text/xml");
context.Response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
foreach (string verb in verbsAllowed)
context.Response.AppendHeader("Allow", verb);
foreach (string verb in verbsPublic)
context.Response.AppendHeader("Public", verb);
// Sends 200 OK
context.SetStatusCode();
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IHttpListenerContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavMethodNotAllowedException"></exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
IWebDavStoreItem source = context.Request.Url.GetItem(store, context);
if (source is IWebDavStoreDocument || source is IWebDavStoreCollection)
{
CopyItem(context, store, source);
}
else
{
throw new WebDavMethodNotAllowedException();
}
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
foreach (string verb in verbsAllowed)
{
context.Response.AppendHeader("Allow", verb);
}
foreach (string verb in verbsPublic)
{
context.Response.AppendHeader("Public", verb);
}
// Sends 200 OK
context.SetStatusCode();
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavNotFoundException"></exception>
/// <exception cref="WebDavNotFoundException"><para>
/// <paramref name="context" /> specifies a request for a store item that does not exist.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="context" /> specifies a request for a store item that is not a document.</para></exception>
/// <exception cref="WebDavConflictException"><paramref name="context" /> specifies a request for a store item using a collection path that does not exist.</exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
IWebDavStoreDocument doc = item as IWebDavStoreDocument;
if (doc == null)
{
throw new WebDavNotFoundException();
}
long docSize = doc.Size;
if (docSize == 0)
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.ContentLength64 = 0;
}
using (Stream stream = doc.OpenReadStream())
{
if (stream == null)
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.ContentLength64 = 0;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
//todo Это статика. Надо определять MIME тип по расширению
context.Response.AppendHeader("Content-type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
if (docSize > 0)
{
context.Response.ContentLength64 = docSize;
}
byte[] buffer = new byte[4096];
int inBuffer;
while ((inBuffer = stream.Read(buffer, 0, buffer.Length)) > 0)
{
context.Response.OutputStream.Write(buffer, 0, inBuffer);
}
context.Response.OutputStream.Flush();
}
}
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavUnsupportedMediaTypeException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavMethodNotAllowedException"></exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
if (context.Request.ContentLength64 > 0)
throw new WebDavUnsupportedMediaTypeException();
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
string collectionName = Uri.UnescapeDataString(
context.Request.Url.Segments.Last().TrimEnd('/', '\\')
);
if (collection.GetItemByName(collectionName) != null)
throw new WebDavMethodNotAllowedException();
collection.CreateCollection(collectionName);
context.SetStatusCode(HttpStatusCode.Created);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavMethodNotAllowedException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavLengthRequiredException">If the ContentLength header was not found</exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
// Get the parent collection
IWebDavStoreCollection parentCollection = GetParentCollection(store, context, context.Request.Url);
// Gets the item name from the url
string itemName = Uri.UnescapeDataString(context.Request.Url.Segments.Last().TrimEnd('/', '\\'));
IWebDavStoreItem item = parentCollection.GetItemByName(itemName);
IWebDavStoreDocument doc;
if (item != null)
{
doc = item as IWebDavStoreDocument;
if (doc == null)
{
throw new WebDavMethodNotAllowedException();
}
}
else
{
doc = parentCollection.CreateDocument(itemName);
}
if (context.Request.ContentLength64 < 0)
{
throw new WebDavLengthRequiredException();
}
using (Stream stream = doc.OpenWriteStream(false))
{
long left = context.Request.ContentLength64;
byte[] buffer = new byte[4096];
while (left > 0)
{
int toRead = Convert.ToInt32(Math.Min(left, buffer.Length));
int inBuffer = context.Request.InputStream.Read(buffer, 0, toRead);
stream.Write(buffer, 0, inBuffer);
left -= inBuffer;
}
}
context.SetStatusCode(HttpStatusCode.Created);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebDavDispatcherClass2"/> class.
/// </summary>
/// <param name="handlers">The WebDAV class 2 handlers</param>
/// <param name="context">The WebDAV context</param>
public WebDavDispatcherClass2([NotNull][ItemNotNull] IEnumerable <IClass2Handler> handlers, [NotNull] IWebDavContext context)
{
var httpMethods = new HashSet <string>();
foreach (var handler in handlers)
{
var handlerFound = false;
if (handler is ILockHandler lockHandler)
{
_lockHandler = lockHandler;
handlerFound = true;
}
if (handler is IUnlockHandler unlockHandler)
{
_unlockHandler = unlockHandler;
handlerFound = true;
}
if (!handlerFound)
{
throw new NotSupportedException();
}
foreach (var httpMethod in handler.HttpMethods)
{
httpMethods.Add(httpMethod);
}
}
HttpMethods = httpMethods.ToList();
WebDavContext = context;
OptionsResponseHeaders = new Dictionary <string, IEnumerable <string> >()
{
["Allow"] = HttpMethods,
};
DefaultResponseHeaders = new Dictionary <string, IEnumerable <string> >()
{
["DAV"] = new[] { "2" },
};
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDavNotFoundException"><para>
/// <paramref name="context" /> specifies a request for a store item that does not exist.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="context" /> specifies a request for a store item that is not a document.</para></exception>
/// <exception cref="WebDavConflictException"><paramref name="context" /> specifies a request for a store item using a collection path that does not exist.</exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
// Get the parent collection of the item
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
// Get the item from the collection
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
/***************************************************************************************************
* Send the response
***************************************************************************************************/
// HttpStatusCode doesn't contain WebDav status codes, but HttpWorkerRequest can handle these WebDav status codes
context.SetStatusCode();
// set the headers of the response
context.Response.ContentLength64 = 0;
context.Response.AppendHeader("Content-Type", "text/html");
context.Response.AppendHeader("Last-Modified", item.ModificationDate.ToUniversalTime().ToString("R"));
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDavNotFoundException"><para>
/// <paramref name="context" /> specifies a request for a store item that does not exist.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="context" /> specifies a request for a store item that is not a document.</para></exception>
/// <exception cref="WebDavConflictException"><paramref name="context" /> specifies a request for a store item using a collection path that does not exist.</exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
// Get the parent collection of the item
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
// Get the item from the collection
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
/***************************************************************************************************
* Send the response
***************************************************************************************************/
// HttpStatusCode doesn't contain WebDav status codes, but HttpWorkerRequest can handle these WebDav status codes
context.SetStatusCode();
// set the headers of the response
context.Response.ContentLength64 = 0;
context.Response.AppendHeader("Content-Type", "text/html");
context.Response.AppendHeader("Last-Modified", item.ModificationDate.ToUniversalTime().ToString("R"));
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavNotFoundException"></exception>
/// <exception cref="WebDavNotFoundException"><para>
/// <paramref name="context" /> specifies a request for a store item that does not exist.</para>
/// <para>- or -</para>
/// <para>
/// <paramref name="context" /> specifies a request for a store item that is not a document.</para></exception>
/// <exception cref="WebDavConflictException"><paramref name="context" /> specifies a request for a store item using a collection path that does not exist.</exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
IWebDavStoreDocument doc = item as IWebDavStoreDocument;
if (doc == null)
throw new WebDavNotFoundException();
long docSize = doc.Size;
if (docSize == 0)
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.ContentLength64 = 0;
}
using (Stream stream = doc.OpenReadStream())
{
if (stream == null)
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.ContentLength64 = 0;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
//todo Это статика. Надо определять MIME тип по расширению
context.Response.AppendHeader("Content-type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
if (docSize > 0)
context.Response.ContentLength64 = docSize;
byte[] buffer = new byte[4096];
int inBuffer;
while ((inBuffer = stream.Read(buffer, 0, buffer.Length)) > 0)
context.Response.OutputStream.Write(buffer, 0, inBuffer);
context.Response.OutputStream.Flush();
}
}
}
/// <summary>
/// Get the parent collection from the requested
/// <see cref="Uri" />.
/// <see cref="WebDavException" /> 409 Conflict possible.
/// </summary>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <param name="context">Context</param>
/// <param name="childUri">The <see cref="Uri" /> object containing the specific location of the child</param>
/// <returns>
/// The parrent collection as an <see cref="IWebDavStoreCollection" />
/// </returns>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavUnauthorizedException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavConflictException">
/// </exception>
/// <exception cref="WebDavUnauthorizedException">When the user is unauthorized and doesn't have access</exception>
/// <exception cref="WebDavConflictException">When the parent collection doesn't exist</exception>
public static IWebDavStoreCollection GetParentCollection(IWebDavStore store, IWebDavContext context, Uri childUri)
{
Uri parentCollectionUri = childUri.GetParentUri();
IWebDavStoreCollection collection;
try
{
collection = parentCollectionUri.GetItem(store, context) as IWebDavStoreCollection;
}
catch (UnauthorizedAccessException)
{
throw new WebDavUnauthorizedException();
}
catch (WebDavNotFoundException)
{
throw new WebDavConflictException();
}
if (collection == null)
throw new WebDavConflictException();
return collection;
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavMethodNotAllowedException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavLengthRequiredException">If the ContentLength header was not found</exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
// Get the parent collection
IWebDavStoreCollection parentCollection = GetParentCollection(store, context, context.Request.Url);
// Gets the item name from the url
string itemName = Uri.UnescapeDataString(context.Request.Url.Segments.Last().TrimEnd('/', '\\'));
IWebDavStoreItem item = parentCollection.GetItemByName(itemName);
IWebDavStoreDocument doc;
if (item != null)
{
doc = item as IWebDavStoreDocument;
if (doc == null)
throw new WebDavMethodNotAllowedException();
}
else
{
doc = parentCollection.CreateDocument(itemName);
}
if (context.Request.ContentLength64 < 0)
throw new WebDavLengthRequiredException();
using (Stream stream = doc.OpenWriteStream(false))
{
long left = context.Request.ContentLength64;
byte[] buffer = new byte[4096];
while (left > 0)
{
int toRead = Convert.ToInt32(Math.Min(left, buffer.Length));
int inBuffer = context.Request.InputStream.Read(buffer, 0, toRead);
stream.Write(buffer, 0, inBuffer);
left -= inBuffer;
}
}
context.SetStatusCode(HttpStatusCode.Created);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavUnsupportedMediaTypeException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavMethodNotAllowedException"></exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
if (context.Request.ContentLength64 > 0)
{
throw new WebDavUnsupportedMediaTypeException();
}
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
string collectionName = Uri.UnescapeDataString(
context.Request.Url.Segments.Last().TrimEnd('/', '\\')
);
if (collection.GetItemByName(collectionName) != null)
{
throw new WebDavMethodNotAllowedException();
}
collection.CreateCollection(collectionName);
context.SetStatusCode(HttpStatusCode.Created);
}
/// <summary>
/// Get the parent collection from the requested
/// <see cref="Uri" />.
/// <see cref="WebDavException" /> 409 Conflict possible.
/// </summary>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <param name="context">Context</param>
/// <param name="childUri">The <see cref="Uri" /> object containing the specific location of the child</param>
/// <returns>
/// The parrent collection as an <see cref="IWebDavStoreCollection" />
/// </returns>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavUnauthorizedException"></exception>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavConflictException">
/// </exception>
/// <exception cref="WebDavUnauthorizedException">When the user is unauthorized and doesn't have access</exception>
/// <exception cref="WebDavConflictException">When the parent collection doesn't exist</exception>
public static IWebDavStoreCollection GetParentCollection(IWebDavStore store, IWebDavContext context, Uri childUri)
{
Uri parentCollectionUri = childUri.GetParentUri();
IWebDavStoreCollection collection;
try
{
collection = parentCollectionUri.GetItem(store, context) as IWebDavStoreCollection;
}
catch (UnauthorizedAccessException)
{
throw new WebDavUnauthorizedException();
}
catch (WebDavNotFoundException)
{
throw new WebDavConflictException();
}
if (collection == null)
{
throw new WebDavConflictException();
}
return(collection);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavPreconditionFailedException"></exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
/***************************************************************************************************
* Retreive al the information from the request
***************************************************************************************************/
// read the headers
int depth = GetDepthHeader(context.Request);
string timeout = GetTimeoutHeader(context.Request);
string locktoken = GetLockTokenIfHeader(context.Request);
int lockResult;
// Initiate the XmlNamespaceManager and the XmlNodes
XmlNamespaceManager manager;
XmlNode lockscopeNode, locktypeNode, ownerNode;
XmlDocument requestDocument = new XmlDocument();
if (string.IsNullOrEmpty(locktoken))
{
#region New Lock
// try to read the body
try
{
StreamReader reader = new StreamReader(context.Request.InputStream, Encoding.UTF8);
string requestBody = reader.ReadToEnd();
if (!requestBody.Equals("") && requestBody.Length != 0)
{
requestDocument.LoadXml(requestBody);
if (requestDocument.DocumentElement != null &&
requestDocument.DocumentElement.LocalName != "prop" &&
requestDocument.DocumentElement.LocalName != "lockinfo")
{
WebDavServer.Log.Debug("LOCK method without prop or lockinfo element in xml document");
}
manager = new XmlNamespaceManager(requestDocument.NameTable);
manager.AddNamespace("D", "DAV:");
manager.AddNamespace("Office", "schemas-microsoft-com:office:office");
manager.AddNamespace("Repl", "http://schemas.microsoft.com/repl/");
manager.AddNamespace("Z", "urn:schemas-microsoft-com:");
// Get the lockscope, locktype and owner as XmlNodes from the XML document
lockscopeNode = requestDocument.DocumentElement.SelectSingleNode("D:lockscope", manager);
locktypeNode = requestDocument.DocumentElement.SelectSingleNode("D:locktype", manager);
ownerNode = requestDocument.DocumentElement.SelectSingleNode("D:owner", manager);
}
else
{
throw new WebDavPreconditionFailedException();
}
}
catch (Exception ex)
{
WebDavServer.Log.Warn(ex.Message);
throw;
}
/***************************************************************************************************
* Lock the file or folder
***************************************************************************************************/
// Get the parent collection of the item
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
WebDavLockScope lockscope = (lockscopeNode.InnerXml.StartsWith("<D:exclusive"))
? WebDavLockScope.Exclusive
: WebDavLockScope.Shared;
//Only lock available at this time is a Write Lock according to RFC
WebDavLockType locktype = (locktypeNode.InnerXml.StartsWith("<D:write")) ? WebDavLockType.Write : WebDavLockType.Write;
string lockuser = ownerNode.InnerText;
WindowsIdentity Identity = (WindowsIdentity)Thread.GetData(Thread.GetNamedDataSlot(Constants.HttpUser));
lockResult = WebDavStoreItemLock.Lock(context.Request.Url, lockscope, locktype, Identity.Name, ref timeout,
out locktoken, requestDocument, depth);
// Get the item from the collection
try
{
GetItemFromCollection(collection, context.Request.Url);
}
catch (Exception)
{
lockResult = (int)HttpStatusCode.Created;
}
#endregion
}
else
{
#region Refreshing a lock
//Refresh lock will ref us back the original XML document which was used to request this lock, from
//this we will grab the data we need to build the response to the lock refresh request.
lockResult = WebDavStoreItemLock.RefreshLock(context.Request.Url, locktoken, ref timeout, out requestDocument);
if (requestDocument == null)
{
context.SetStatusCode(409);
return;
}
try
{
if (requestDocument.DocumentElement != null &&
requestDocument.DocumentElement.LocalName != "prop" &&
requestDocument.DocumentElement.LocalName != "lockinfo")
{
WebDavServer.Log.Debug("LOCK method without prop or lockinfo element in xml document");
}
manager = new XmlNamespaceManager(requestDocument.NameTable);
manager.AddNamespace("D", "DAV:");
manager.AddNamespace("Office", "schemas-microsoft-com:office:office");
manager.AddNamespace("Repl", "http://schemas.microsoft.com/repl/");
manager.AddNamespace("Z", "urn:schemas-microsoft-com:");
// Get the lockscope, locktype and owner as XmlNodes from the XML document
lockscopeNode = requestDocument.DocumentElement.SelectSingleNode("D:lockscope", manager);
locktypeNode = requestDocument.DocumentElement.SelectSingleNode("D:locktype", manager);
ownerNode = requestDocument.DocumentElement.SelectSingleNode("D:owner", manager);
}
catch (Exception ex)
{
WebDavServer.Log.Warn(ex.Message);
throw;
}
#endregion
}
/***************************************************************************************************
* Create the body for the response
***************************************************************************************************/
// Create the basic response XmlDocument
XmlDocument responseDoc = new XmlDocument();
const string responseXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><D:prop xmlns:D=\"DAV:\"><D:lockdiscovery><D:activelock/></D:lockdiscovery></D:prop>";
responseDoc.LoadXml(responseXml);
// Select the activelock XmlNode
XmlNode activelock = responseDoc.DocumentElement.SelectSingleNode("D:lockdiscovery/D:activelock", manager);
// Import the given nodes
activelock.AppendChild(responseDoc.ImportNode(lockscopeNode, true));
activelock.AppendChild(responseDoc.ImportNode(locktypeNode, true));
activelock.AppendChild(responseDoc.ImportNode(ownerNode, true));
// Add the additional elements, e.g. the header elements
// The timeout element
WebDavProperty timeoutProperty = new WebDavProperty("timeout", timeout);// timeout);
activelock.AppendChild(timeoutProperty.ToXmlElement(responseDoc));
// The depth element
WebDavProperty depthProperty = new WebDavProperty("depth", (depth == 0 ? "0" : "Infinity"));
activelock.AppendChild(depthProperty.ToXmlElement(responseDoc));
// The locktoken element
WebDavProperty locktokenProperty = new WebDavProperty("locktoken", string.Empty);
XmlElement locktokenElement = locktokenProperty.ToXmlElement(responseDoc);
WebDavProperty hrefProperty = new WebDavProperty("href", locktoken);//"opaquelocktoken:e71d4fae-5dec-22df-fea5-00a0c93bd5eb1");
locktokenElement.AppendChild(hrefProperty.ToXmlElement(responseDoc));
activelock.AppendChild(locktokenElement);
/***************************************************************************************************
* Send the response
***************************************************************************************************/
// convert the StringBuilder
string resp = responseDoc.InnerXml;
byte[] responseBytes = Encoding.UTF8.GetBytes(resp);
context.SetStatusCode(lockResult);
context.Response.StatusDescription = HttpWorkerRequest.GetStatusDescription(lockResult);
// set the headers of the response
context.Response.ContentLength64 = responseBytes.Length;
context.Response.AppendHeader("ContentType", "text/xml");
// the body
context.Response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
}
/// <summary>
/// Builds the <see cref="XmlDocument" /> containing the response body
/// </summary>
/// <param name="context">The <see cref="IHttpListenerContext" /></param>
/// <param name="propname">The boolean defining the Propfind propname request</param>
/// <returns>
/// The <see cref="XmlDocument" /> containing the response body
/// </returns>
private XmlDocument ResponseDocument(IWebDavContext context, bool propname)
{
// Create the basic response XmlDocument
XmlDocument responseDoc = new XmlDocument();
const string responseXml = "<?xml version=\"1.0\"?><D:multistatus xmlns:D=\"DAV:\"></D:multistatus>";
responseDoc.LoadXml(responseXml);
// Generate the manager
XmlNamespaceManager manager = new XmlNamespaceManager(responseDoc.NameTable);
manager.AddNamespace("D", "DAV:");
manager.AddNamespace("Office", "schemas-microsoft-com:office:office");
manager.AddNamespace("Repl", "http://schemas.microsoft.com/repl/");
manager.AddNamespace("Z", "urn:schemas-microsoft-com:");
int count = 0;
foreach (IWebDavStoreItem webDavStoreItem in _webDavStoreItems)
{
// Create the response element
WebDavProperty responseProperty = new WebDavProperty("response", string.Empty);
XmlElement responseElement = responseProperty.ToXmlElement(responseDoc);
// The href element
Uri result;
if (count == 0)
{
Uri.TryCreate(_requestUri, string.Empty, out result);
}
else
{
Uri.TryCreate(_requestUri, webDavStoreItem.Name, out result);
}
WebDavProperty hrefProperty = new WebDavProperty("href", result.AbsoluteUri);
responseElement.AppendChild(hrefProperty.ToXmlElement(responseDoc));
count++;
// The propstat element
WebDavProperty propstatProperty = new WebDavProperty("propstat", string.Empty);
XmlElement propstatElement = propstatProperty.ToXmlElement(responseDoc);
// The prop element
WebDavProperty propProperty = new WebDavProperty("prop", string.Empty);
XmlElement propElement = propProperty.ToXmlElement(responseDoc);
//All properties but lockdiscovery and supportedlock can be handled here.
foreach (WebDavProperty davProperty in _requestedProperties.Where(d => d.Name != "lockdiscovery" && d.Name != "supportedlock"))
propElement.AppendChild(PropChildElement(davProperty, responseDoc, webDavStoreItem, propname));
//Since lockdiscovery returns an xml tree, we need to process it seperately.
if (_requestedProperties.FirstOrDefault(d => d.Name == "lockdiscovery") != null)
propElement.AppendChild(LockDiscovery(result, ref responseDoc));
//Since supportedlock returns an xml tree, we need to process it seperately.
if (_requestedProperties.FirstOrDefault(d => d.Name == "supportedlock") != null)
propElement.AppendChild(SupportedLocks(ref responseDoc));
// Add the prop element to the propstat element
propstatElement.AppendChild(propElement);
// The status element
WebDavProperty statusProperty = new WebDavProperty("status",
"HTTP/1.1 " + context.Response.StatusCode + " " +
HttpWorkerRequest.GetStatusDescription(context.Response.StatusCode));
propstatElement.AppendChild(statusProperty.ToXmlElement(responseDoc));
// Add the propstat element to the response element
responseElement.AppendChild(propstatElement);
// Add the response element to the multistatus element
responseDoc.DocumentElement.AppendChild(responseElement);
}
return responseDoc;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropPatchHandler"/> class.
/// </summary>
/// <param name="fileSystem">The root file system</param>
/// <param name="context">The WebDAV request context</param>
public PropPatchHandler([NotNull] IFileSystem fileSystem, [NotNull] IWebDavContext context)
{
_fileSystem = fileSystem;
_context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropFindHandler"/> class.
/// </summary>
/// <param name="fileSystem">The root file system</param>
/// <param name="context">The WebDAV request context</param>
/// <param name="options">The options for this handler</param>
public PropFindHandler([NotNull] IFileSystem fileSystem, [NotNull] IWebDavContext context, [CanBeNull] IOptions <PropFindHandlerOptions> options)
{
_options = options?.Value ?? new PropFindHandlerOptions();
_context = context;
FileSystem = fileSystem;
}
public PropertyCollector([NotNull] PropFindHandler handler, [NotNull] IWebDavContext host, [NotNull][ItemNotNull] params IPropertyFilter[] filters)
{
_handler = handler;
_host = host;
_filters = filters;
}
/// <summary>
/// Sends the response
/// </summary>
/// <param name="context">The <see cref="IWebDavContext" /> containing the response</param>
/// <param name="responseDocument">The <see cref="XmlDocument" /> containing the response body</param>
private static void MakeResponse(IWebDavContext context, XmlDocument responseDocument)
{
// convert the XmlDocument
byte[] responseBytes = Encoding.UTF8.GetBytes(responseDocument.InnerXml);
// HttpStatusCode doesn't contain WebDav status codes, but HttpWorkerRequest can handle these WebDav status codes
context.SetStatusCode((int)WebDavStatusCode.MultiStatus);
context.Response.ContentLength64 = responseBytes.Length;
context.Response.AppendHeader("Content-Type", "text/xml");
context.Response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
}
/// <inheritdoc />
public virtual Task CreatePropertiesAsync(ICollection collection, IPropertyStore propertyStore, IWebDavContext context, CancellationToken cancellationToken)
{
return(CreateGenericPropertiesAsync(collection, propertyStore, context, cancellationToken));
}
/// <inheritdoc />
public virtual async Task CreatePropertiesAsync(IDocument document, IPropertyStore propertyStore, IWebDavContext context, CancellationToken cancellationToken)
{
if (context.RequestHeaders.Headers.TryGetValue("Content-Type", out var contentTypeValues))
{
var contentType = contentTypeValues.FirstOrDefault();
if (!string.IsNullOrEmpty(contentType))
{
var contentTypeProperty = new GetContentTypeProperty(document, propertyStore);
await contentTypeProperty.SetValueAsync(contentType, cancellationToken);
}
}
await CreateGenericPropertiesAsync(document, propertyStore, context, cancellationToken);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IHttpListenerContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
/// <exception cref="WebDAVSharp.Server.Exceptions.WebDavUnauthorizedException"></exception>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
Context = context;
/***************************************************************************************************
* Retreive all the information from the request
***************************************************************************************************/
// Read the headers, ...
bool isPropname = false;
int depth = GetDepthHeader(context.Request);
_requestUri = GetRequestUri(context.Request.Url.ToString());
try
{
_webDavStoreItems = GetWebDavStoreItems(context.Request.Url.GetItem(store, context), depth);
}
catch (UnauthorizedAccessException)
{
throw new WebDavUnauthorizedException();
}
// Get the XmlDocument from the request
XmlDocument requestDoc = GetXmlDocument(context.Request);
// See what is requested
_requestedProperties = new List<WebDavProperty>();
if (requestDoc.DocumentElement != null)
{
if (requestDoc.DocumentElement.LocalName != "propfind")
WebDavServer.Log.Debug("PROPFIND method without propfind in xml document");
else
{
XmlNode n = requestDoc.DocumentElement.FirstChild;
if (n == null)
WebDavServer.Log.Debug("propfind element without children");
else
{
switch (n.LocalName)
{
case "allprop":
_requestedProperties = GetAllProperties();
break;
case "propname":
isPropname = true;
_requestedProperties = GetAllProperties();
break;
case "prop":
foreach (XmlNode child in n.ChildNodes)
_requestedProperties.Add(new WebDavProperty(child.LocalName, "", child.NamespaceURI));
break;
default:
_requestedProperties.Add(new WebDavProperty(n.LocalName, "", n.NamespaceURI));
break;
}
}
}
}
else
_requestedProperties = GetAllProperties();
/***************************************************************************************************
* Create the body for the response
***************************************************************************************************/
XmlDocument responseDoc = ResponseDocument(context, isPropname);
/***************************************************************************************************
* Send the response
***************************************************************************************************/
MakeResponse(context, responseDoc);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebDavControllerBase"/> class.
/// </summary>
/// <param name="context">The WebDAV request context</param>
/// <param name="dispatcher">The WebDAV HTTP method dispatcher</param>
/// <param name="responseLogger">The logger for the <see cref="WebDavIndirectResult"/></param>
public WebDavControllerBase(IWebDavContext context, IWebDavDispatcher dispatcher, ILogger <WebDavIndirectResult> responseLogger = null)
{
_context = context;
_dispatcher = dispatcher;
_responseLogger = responseLogger;
}
/// <summary>
/// Initializes a new instance of the <see cref="MkColHandler"/> class.
/// </summary>
/// <param name="rootFileSystem">The root file system</param>
/// <param name="context">The WebDAV request context</param>
/// <param name="entryPropertyInitializer">The property initializer</param>
public MkColHandler(IFileSystem rootFileSystem, IWebDavContext context, IEntryPropertyInitializer entryPropertyInitializer)
{
_rootFileSystem = rootFileSystem;
_context = context;
_entryPropertyInitializer = entryPropertyInitializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="MoveHandler"/> class.
/// </summary>
/// <param name="rootFileSystem">The root file system</param>
/// <param name="host">The WebDAV server context</param>
/// <param name="options">The options for the <c>MOVE</c> handler</param>
/// <param name="logger">The logger for this handler</param>
/// <param name="serviceProvider">The service provider used to lazily query the <see cref="IRemoteMoveTargetActionsFactory"/> implementation</param>
public MoveHandler(IFileSystem rootFileSystem, IWebDavContext host, IOptions <MoveHandlerOptions> options, ILogger <MoveHandler> logger, IServiceProvider serviceProvider)
: base(rootFileSystem, host, logger)
{
_serviceProvider = serviceProvider;
_options = options?.Value ?? new MoveHandlerOptions();
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="context">The
/// <see cref="IWebDavContext" /> object containing both the request and response
/// objects to use.</param>
/// <param name="store">The <see cref="IWebDavStore" /> that the <see cref="WebDavServer" /> is hosting.</param>
public void ProcessRequest(IWebDavContext context, IWebDavStore store)
{
/***************************************************************************************************
* Retreive al the information from the request
***************************************************************************************************/
// Get the URI to the location
Uri requestUri = context.Request.Url;
// Initiate the XmlNamespaceManager and the XmlNodes
XmlNamespaceManager manager = null;
XmlNode propNode = null;
// try to read the body
try
{
StreamReader reader = new StreamReader(context.Request.InputStream, Encoding.UTF8);
string requestBody = reader.ReadToEnd();
if (!String.IsNullOrEmpty(requestBody))
{
XmlDocument requestDocument = new XmlDocument();
requestDocument.LoadXml(requestBody);
if (requestDocument.DocumentElement != null)
{
if (requestDocument.DocumentElement.LocalName != "propertyupdate")
{
WebDavServer.Log.Debug("PROPPATCH method without propertyupdate element in xml document");
}
manager = new XmlNamespaceManager(requestDocument.NameTable);
manager.AddNamespace("D", "DAV:");
manager.AddNamespace("Office", "schemas-microsoft-com:office:office");
manager.AddNamespace("Repl", "http://schemas.microsoft.com/repl/");
manager.AddNamespace("Z", "urn:schemas-microsoft-com:");
propNode = requestDocument.DocumentElement.SelectSingleNode("D:set/D:prop", manager);
}
}
}
catch (Exception ex)
{
WebDavServer.Log.Warn(ex.Message);
}
/***************************************************************************************************
* Take action
***************************************************************************************************/
// Get the parent collection of the item
IWebDavStoreCollection collection = GetParentCollection(store, context, context.Request.Url);
// Get the item from the collection
IWebDavStoreItem item = GetItemFromCollection(collection, context.Request.Url);
FileInfo fileInfo = new FileInfo(item.ItemPath);
if (propNode != null && fileInfo.Exists)
{
foreach (XmlNode node in propNode.ChildNodes)
{
switch (node.LocalName)
{
case "Win32CreationTime":
fileInfo.CreationTime = Convert.ToDateTime(node.InnerText).ToUniversalTime();
break;
case "Win32LastAccessTime":
fileInfo.LastAccessTime = Convert.ToDateTime(node.InnerText).ToUniversalTime();
break;
case "Win32LastModifiedTime":
fileInfo.LastWriteTime = Convert.ToDateTime(node.InnerText).ToUniversalTime();
break;
case "Win32FileAttributes":
//todo Win32FileAttributes
//fileInfo.Attributes =
//fileInfo.Attributes = Convert.ToDateTime(node.InnerText);
break;
}
}
}
/***************************************************************************************************
* Create the body for the response
***************************************************************************************************/
// Create the basic response XmlDocument
XmlDocument responseDoc = new XmlDocument();
const string responseXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><D:multistatus " +
"xmlns:Z=\"urn:schemas-microsoft-com:\" xmlns:D=\"DAV:\">" +
"<D:response></D:response></D:multistatus>";
responseDoc.LoadXml(responseXml);
// Select the response node
XmlNode responseNode = responseDoc.DocumentElement.SelectSingleNode("D:response", manager);
// Add the elements
// The href element
WebDavProperty hrefProperty = new WebDavProperty("href", requestUri.ToString());
responseNode.AppendChild(hrefProperty.ToXmlElement(responseDoc));
// The propstat element
WebDavProperty propstatProperty = new WebDavProperty("propstat", string.Empty);
XmlElement propstatElement = propstatProperty.ToXmlElement(responseDoc);
// The propstat/status element
WebDavProperty statusProperty = new WebDavProperty("status", "HTTP/1.1 " + context.Response.StatusCode + " " +
HttpWorkerRequest.GetStatusDescription(context.Response.StatusCode));
propstatElement.AppendChild(statusProperty.ToXmlElement(responseDoc));
// The other propstat children
foreach (WebDavProperty property in from XmlNode child in propNode.ChildNodes
where child.Name.ToLower()
.Contains("creationtime") || child.Name.ToLower()
.Contains("fileattributes") || child.Name.ToLower()
.Contains("lastaccesstime") || child.Name.ToLower()
.Contains("lastmodifiedtime")
let node = propNode.SelectSingleNode(child.Name, manager)
select new WebDavProperty(child.LocalName, string.Empty, node != null ? node.NamespaceURI : string.Empty))
propstatElement.AppendChild(property.ToXmlElement(responseDoc));
responseNode.AppendChild(propstatElement);
/***************************************************************************************************
* Send the response
***************************************************************************************************/
// convert the StringBuilder
string resp = responseDoc.InnerXml;
byte[] responseBytes = Encoding.UTF8.GetBytes(resp);
// HttpStatusCode doesn't contain WebDav status codes, but HttpWorkerRequest can handle these WebDav status codes
context.SetStatusCode((int)WebDavStatusCode.MultiStatus);
// set the headers of the response
context.Response.ContentLength64 = responseBytes.Length;
context.Response.AppendHeader("Content-Type", "text/xml");
// the body
context.Response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
context.Response.Close();
}
