ReadWriteResponseHelper.cs 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. /* Copyright (C) 2014-2017 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  2. *
  3. * You can redistribute this program and/or modify it under the terms of
  4. * the GNU Lesser Public License as published by the Free Software Foundation,
  5. * either version 3 of the License, or (at your option) any later version.
  6. */
  7. using System;
  8. using System.Collections.Generic;
  9. using System.IO;
  10. using System.Text;
  11. using SMBLibrary.RPC;
  12. using SMBLibrary.SMB1;
  13. using SMBLibrary.Services;
  14. using Utilities;
  15. namespace SMBLibrary.Server.SMB1
  16. {
  17. public class ReadWriteResponseHelper
  18. {
  19. internal static SMB1Command GetReadResponse(SMB1Header header, ReadRequest request, ISMBShare share, SMB1ConnectionState state)
  20. {
  21. SMB1Session session = state.GetSession(header.UID);
  22. OpenFileObject openFile = session.GetOpenFileObject(request.FID);
  23. if (openFile == null)
  24. {
  25. header.Status = NTStatus.STATUS_INVALID_HANDLE;
  26. return null;
  27. }
  28. byte[] data;
  29. header.Status = ReadFile(out data, openFile, request.ReadOffsetInBytes, request.CountOfBytesToRead, state);
  30. if (header.Status != NTStatus.STATUS_SUCCESS)
  31. {
  32. return new ErrorResponse(request.CommandName);
  33. }
  34. ReadResponse response = new ReadResponse();
  35. response.Bytes = data;
  36. response.CountOfBytesReturned = (ushort)data.Length;
  37. return response;
  38. }
  39. internal static SMB1Command GetReadResponse(SMB1Header header, ReadAndXRequest request, ISMBShare share, SMB1ConnectionState state)
  40. {
  41. SMB1Session session = state.GetSession(header.UID);
  42. OpenFileObject openFile = session.GetOpenFileObject(request.FID);
  43. if (openFile == null)
  44. {
  45. header.Status = NTStatus.STATUS_INVALID_HANDLE;
  46. return null;
  47. }
  48. uint maxCount = request.MaxCount;
  49. if ((share is FileSystemShare) && state.LargeRead)
  50. {
  51. maxCount = request.MaxCountLarge;
  52. }
  53. byte[] data;
  54. header.Status = ReadFile(out data, openFile, (long)request.Offset, (int)maxCount, state);
  55. if (header.Status != NTStatus.STATUS_SUCCESS)
  56. {
  57. return new ErrorResponse(request.CommandName);
  58. }
  59. ReadAndXResponse response = new ReadAndXResponse();
  60. if (share is FileSystemShare)
  61. {
  62. // If the client reads from a disk file, this field MUST be set to -1 (0xFFFF)
  63. response.Available = 0xFFFF;
  64. }
  65. response.Data = data;
  66. return response;
  67. }
  68. public static NTStatus ReadFile(out byte[] data, OpenFileObject openFile, long offset, int maxCount, ConnectionState state)
  69. {
  70. data = null;
  71. string openFilePath = openFile.Path;
  72. Stream stream = openFile.Stream;
  73. if (stream is RPCPipeStream)
  74. {
  75. data = new byte[maxCount];
  76. int bytesRead = stream.Read(data, 0, maxCount);
  77. if (bytesRead < maxCount)
  78. {
  79. // EOF, we must trim the response data array
  80. data = ByteReader.ReadBytes(data, 0, bytesRead);
  81. }
  82. return NTStatus.STATUS_SUCCESS;
  83. }
  84. else // File
  85. {
  86. if (stream == null)
  87. {
  88. state.LogToServer(Severity.Debug, "ReadFile: Cannot read '{0}', Invalid Operation.", openFilePath);
  89. return NTStatus.STATUS_ACCESS_DENIED;
  90. }
  91. int bytesRead;
  92. try
  93. {
  94. stream.Seek(offset, SeekOrigin.Begin);
  95. data = new byte[maxCount];
  96. bytesRead = stream.Read(data, 0, maxCount);
  97. }
  98. catch (IOException ex)
  99. {
  100. ushort errorCode = IOExceptionHelper.GetWin32ErrorCode(ex);
  101. if (errorCode == (ushort)Win32Error.ERROR_SHARING_VIOLATION)
  102. {
  103. // Returning STATUS_SHARING_VIOLATION is undocumented but apparently valid
  104. state.LogToServer(Severity.Debug, "ReadFile: Cannot read '{0}'. Sharing Violation.", openFilePath);
  105. return NTStatus.STATUS_SHARING_VIOLATION;
  106. }
  107. else
  108. {
  109. state.LogToServer(Severity.Debug, "ReadFile: Cannot read '{0}'. Data Error.", openFilePath);
  110. return NTStatus.STATUS_DATA_ERROR;
  111. }
  112. }
  113. catch (ArgumentOutOfRangeException)
  114. {
  115. state.LogToServer(Severity.Debug, "ReadFile: Cannot read '{0}'. Offset Out Of Range.", openFilePath);
  116. return NTStatus.STATUS_DATA_ERROR;
  117. }
  118. catch (UnauthorizedAccessException)
  119. {
  120. state.LogToServer(Severity.Debug, "ReadFile: Cannot read '{0}', Access Denied.", openFilePath);
  121. return NTStatus.STATUS_ACCESS_DENIED;
  122. }
  123. if (bytesRead < maxCount)
  124. {
  125. // EOF, we must trim the response data array
  126. data = ByteReader.ReadBytes(data, 0, bytesRead);
  127. }
  128. return NTStatus.STATUS_SUCCESS;
  129. }
  130. }
  131. internal static SMB1Command GetWriteResponse(SMB1Header header, WriteRequest request, ISMBShare share, SMB1ConnectionState state)
  132. {
  133. SMB1Session session = state.GetSession(header.UID);
  134. OpenFileObject openFile = session.GetOpenFileObject(request.FID);
  135. if (openFile == null)
  136. {
  137. header.Status = NTStatus.STATUS_INVALID_HANDLE;
  138. return new ErrorResponse(request.CommandName);
  139. }
  140. int numberOfBytesWritten;
  141. header.Status = WriteFile(out numberOfBytesWritten, openFile, request.WriteOffsetInBytes, request.Data, state);
  142. if (header.Status != NTStatus.STATUS_SUCCESS)
  143. {
  144. return new ErrorResponse(request.CommandName);
  145. }
  146. WriteResponse response = new WriteResponse();
  147. response.CountOfBytesWritten = (ushort)numberOfBytesWritten;
  148. return response;
  149. }
  150. internal static SMB1Command GetWriteResponse(SMB1Header header, WriteAndXRequest request, ISMBShare share, SMB1ConnectionState state)
  151. {
  152. SMB1Session session = state.GetSession(header.UID);
  153. OpenFileObject openFile = session.GetOpenFileObject(request.FID);
  154. if (openFile == null)
  155. {
  156. header.Status = NTStatus.STATUS_INVALID_HANDLE;
  157. return new ErrorResponse(request.CommandName);
  158. }
  159. int numberOfBytesWritten;
  160. header.Status = WriteFile(out numberOfBytesWritten, openFile, (long)request.Offset, request.Data, state);
  161. if (header.Status != NTStatus.STATUS_SUCCESS)
  162. {
  163. return new ErrorResponse(request.CommandName);
  164. }
  165. WriteAndXResponse response = new WriteAndXResponse();
  166. response.Count = (uint)numberOfBytesWritten;
  167. if (share is FileSystemShare)
  168. {
  169. // If the client wrote to a disk file, this field MUST be set to 0xFFFF.
  170. response.Available = 0xFFFF;
  171. }
  172. return response;
  173. }
  174. public static NTStatus WriteFile(out int numberOfBytesWritten, OpenFileObject openFile, long offset, byte[] data, ConnectionState state)
  175. {
  176. numberOfBytesWritten = 0;
  177. string openFilePath = openFile.Path;
  178. Stream stream = openFile.Stream;
  179. if (stream is RPCPipeStream)
  180. {
  181. stream.Write(data, 0, data.Length);
  182. numberOfBytesWritten = data.Length;
  183. return NTStatus.STATUS_SUCCESS;
  184. }
  185. else // File
  186. {
  187. if (stream == null)
  188. {
  189. state.LogToServer(Severity.Debug, "WriteFile: Cannot write '{0}'. Invalid Operation.", openFilePath);
  190. return NTStatus.STATUS_ACCESS_DENIED;
  191. }
  192. try
  193. {
  194. stream.Seek(offset, SeekOrigin.Begin);
  195. stream.Write(data, 0, data.Length);
  196. numberOfBytesWritten = data.Length;
  197. return NTStatus.STATUS_SUCCESS;
  198. }
  199. catch (IOException ex)
  200. {
  201. ushort errorCode = IOExceptionHelper.GetWin32ErrorCode(ex);
  202. if (errorCode == (ushort)Win32Error.ERROR_DISK_FULL)
  203. {
  204. state.LogToServer(Severity.Debug, "WriteFile: Cannot write '{0}'. Disk Full.", openFilePath);
  205. return NTStatus.STATUS_DISK_FULL;
  206. }
  207. else if (errorCode == (ushort)Win32Error.ERROR_SHARING_VIOLATION)
  208. {
  209. state.LogToServer(Severity.Debug, "WriteFile: Cannot write '{0}'. Sharing Violation.", openFilePath);
  210. // Returning STATUS_SHARING_VIOLATION is undocumented but apparently valid
  211. return NTStatus.STATUS_SHARING_VIOLATION;
  212. }
  213. else
  214. {
  215. state.LogToServer(Severity.Debug, "WriteFile: Cannot write '{0}'. Data Error.", openFilePath);
  216. return NTStatus.STATUS_DATA_ERROR;
  217. }
  218. }
  219. catch (ArgumentOutOfRangeException)
  220. {
  221. state.LogToServer(Severity.Debug, "WriteFile: Cannot write '{0}'. Offset Out Of Range.", openFilePath);
  222. return NTStatus.STATUS_DATA_ERROR;
  223. }
  224. catch (UnauthorizedAccessException)
  225. {
  226. state.LogToServer(Severity.Debug, "WriteFile: Cannot write '{0}'. Access Denied.", openFilePath);
  227. // The user may have tried to write to a readonly file
  228. return NTStatus.STATUS_ACCESS_DENIED;
  229. }
  230. }
  231. }
  232. }
  233. }