private static void OnNotifyChangeCompleted(NTStatus status, byte[] buffer, object context)
{
SMB2AsyncContext asyncContext = (SMB2AsyncContext)context;
// Wait until the interim response has been sent
lock (asyncContext)
{
SMB2ConnectionState connection = asyncContext.Connection;
connection.RemoveAsyncContext(asyncContext);
SMB2Session session = connection.GetSession(asyncContext.SessionID);
if (session != null)
{
OpenFileObject openFile = session.GetOpenFileObject(asyncContext.FileID);
if (openFile != null)
{
connection.LogToServer(Severity.Verbose, "NotifyChange: Monitoring of '{0}{1}' completed. NTStatus: {2}. AsyncID: {3}", openFile.ShareName, openFile.Path, status, asyncContext.AsyncID);
}
if (status == NTStatus.STATUS_SUCCESS ||
status == NTStatus.STATUS_NOTIFY_CLEANUP ||
status == NTStatus.STATUS_NOTIFY_ENUM_DIR)
{
ChangeNotifyResponse response = new ChangeNotifyResponse();
response.Header.Status = status;
response.Header.IsAsync = true;
response.Header.IsSigned = session.SigningRequired;
response.Header.AsyncID = asyncContext.AsyncID;
response.Header.SessionID = asyncContext.SessionID;
response.OutputBuffer = buffer;
SMBServer.EnqueueResponse(connection, response);
}
else
{
// [MS-SMB2] If the object store returns an error, the server MUST fail the request with the error code received.
ErrorResponse response = new ErrorResponse(SMB2CommandName.ChangeNotify);
response.Header.Status = status;
response.Header.IsAsync = true;
response.Header.IsSigned = session.SigningRequired;
response.Header.AsyncID = asyncContext.AsyncID;
SMBServer.EnqueueResponse(connection, response);
}
}
}
}
internal static SMB2Command GetCancelResponse(CancelRequest request, SMB2ConnectionState state)
{
SMB2Session session = state.GetSession(request.Header.SessionID);
if (request.Header.IsAsync)
{
SMB2AsyncContext context = state.GetAsyncContext(request.Header.AsyncID);
if (context != null)
{
ISMBShare share = session.GetConnectedTree(context.TreeID);
OpenFileObject openFile = session.GetOpenFileObject(context.FileID);
NTStatus status = share.FileStore.Cancel(context.IORequest);
if (openFile != null)
{
state.LogToServer(Severity.Information, "Cancel: Requested cancel on '{0}{1}'. NTStatus: {2}, AsyncID: {3}.", share.Name, openFile.Path, status, context.AsyncID);
}
if (status == NTStatus.STATUS_SUCCESS ||
status == NTStatus.STATUS_CANCELLED ||
status == NTStatus.STATUS_NOT_SUPPORTED) // See ChangeNotifyHelper.cs
{
state.RemoveAsyncContext(context);
// [MS-SMB2] If the target request is successfully canceled, the target request MUST be failed by sending
// an ERROR response packet [..] with the status field of the SMB2 header set to STATUS_CANCELLED.
ErrorResponse response = new ErrorResponse(request.CommandName, NTStatus.STATUS_CANCELLED);
response.Header.IsAsync = true;
response.Header.AsyncID = context.AsyncID;
return(response);
}
// [MS-SMB2] If the target request is not successfully canceled [..] no response is sent.
// Note: Failing to respond might cause the client to disconnect the connection as per [MS-SMB2] 3.2.6.1 Request Expiration Timer Event
return(null);
}
else
{
// [MS-SMB2] If a request is not found [..] no response is sent.
return(null);
}
}
else
{
// [MS-SMB2] the SMB2 CANCEL Request MUST use an ASYNC header for canceling requests that have received an interim response.
// [MS-SMB2] If the target request is not successfully canceled [..] no response is sent.
return(null);
}
}
/// <remarks>
/// 'NoRemoteChangeNotify' can be set in the registry to prevent the client from sending ChangeNotify requests altogether.
/// </remarks>
internal static SMB2Command GetChangeNotifyInterimResponse(ChangeNotifyRequest request, ISMBShare share, SMB2ConnectionState state)
{
SMB2Session session = state.GetSession(request.Header.SessionID);
OpenFileObject openFile = session.GetOpenFileObject(request.FileId);
bool watchTree = (request.Flags & ChangeNotifyFlags.WatchTree) > 0;
SMB2AsyncContext asyncContext = state.CreateAsyncContext(request.FileId, state, request.Header.SessionID, request.Header.TreeID);
// We have to make sure that we don't send an interim response after the final response.
lock (asyncContext)
{
NTStatus status = share.FileStore.NotifyChange(out asyncContext.IORequest, openFile.Handle, request.CompletionFilter, watchTree, (int)request.OutputBufferLength, OnNotifyChangeCompleted, asyncContext);
if (status == NTStatus.STATUS_PENDING)
{
state.LogToServer(Severity.Verbose, "NotifyChange: Monitoring of '{0}{1}' started. AsyncID: {2}.", share.Name, openFile.Path, asyncContext.AsyncID);
}
else if (status == NTStatus.STATUS_NOT_SUPPORTED)
{
// [MS-SMB2] If the underlying object store does not support change notifications, the server MUST fail this request with STATUS_NOT_SUPPORTED.
// Unfortunately, Windows 7 / 8 / 10 will immediately retry sending another ChangeNotify request upon getting STATUS_NOT_SUPPORTED,
// To prevent flooding, we must return a valid interim response (Status set to STATUS_PENDING and SMB2_FLAGS_ASYNC_COMMAND bit is set in Flags).
status = NTStatus.STATUS_PENDING;
}
else
{
state.RemoveAsyncContext(asyncContext);
}
ErrorResponse response = new ErrorResponse(request.CommandName, status);
if (status == NTStatus.STATUS_PENDING)
{
response.Header.IsAsync = true;
response.Header.AsyncID = asyncContext.AsyncID;
}
return(response);
}
}