/// <summary>
/// Create File, named pipe, directory. One transport can only create one file.
/// </summary>
/// <param name="fileName">The file, namedpipe, directory name</param>
/// <param name="desiredAccess">The desired access</param>
/// <param name="impersonationLevel">The impersonation level</param>
/// <param name="fileAttribute">The file attribute, this field is only valid when create file.
/// </param>
/// <param name="createDisposition">Defines the action the server MUST take if the file that is
/// specified in the name field already exists</param>
/// <param name="createOption">Specifies the options to be applied when creating or opening the file</param>
private void InternalCreate(string fileName, NtTransactDesiredAccess desiredAccess,
NtTransactImpersonationLevel impersonationLevel, SMB_EXT_FILE_ATTR fileAttribute,
NtTransactCreateDisposition createDisposition, NtTransactCreateOptions createOption)
{
SmbNtCreateAndxRequestPacket request = smbClient.CreateCreateRequest(
this.treeId,
fileName,
desiredAccess,
fileAttribute,
NtTransactShareAccess.NONE,
createDisposition,
createOption,
impersonationLevel,
CreateFlags.NT_CREATE_REQUEST_EXTENDED_RESPONSE);
if (this.isSignRequired)
{
request.Sign(this.NextSequenceNumber, this.sessionKey);
}
uint status = 0;
SmbNtCreateAndxResponsePacket response =
this.SendAndExpectSmbPacket(request, internalTimeout, out status) as SmbNtCreateAndxResponsePacket;
if (status != 0)
{
throw new InvalidOperationException("Create Failed. ErrorCode: " + status);
}
this.fid = response.SmbParameters.FID;
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbNtCreateAndxRequestPacket(SmbNtCreateAndxRequestPacket packet)
: base(packet)
{
}
/// <summary>
/// find the target packet.
/// </summary>
/// <param name="smbHeader">the header of smb packet</param>
/// <param name="channel">the channel to access bytes</param>
/// <returns>the target packet</returns>
private static SmbPacket FindTheTargetPacket(SmbHeader smbHeader, Channel channel)
{
SmbPacket smbPacket = null;
switch (smbHeader.Command)
{
case SmbCommand.SMB_COM_NEGOTIATE:
smbPacket = new SmbNegotiateRequestPacket();
break;
case SmbCommand.SMB_COM_SESSION_SETUP_ANDX:
SmbHeader_Flags2_Values flags2 = (SmbHeader_Flags2_Values)smbHeader.Flags2;
if ((flags2 & SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
== SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
{
smbPacket = new Smb.SmbSessionSetupAndxRequestPacket();
}
else
{
smbPacket = new Cifs.SmbSessionSetupAndxRequestPacket();
}
break;
case SmbCommand.SMB_COM_TREE_CONNECT_ANDX:
smbPacket = new SmbTreeConnectAndxRequestPacket();
break;
case SmbCommand.SMB_COM_NT_CREATE_ANDX:
smbPacket = new SmbNtCreateAndxRequestPacket();
break;
case SmbCommand.SMB_COM_OPEN_ANDX:
smbPacket = new SmbOpenAndxRequestPacket();
break;
case SmbCommand.SMB_COM_WRITE_ANDX:
smbPacket = new SmbWriteAndxRequestPacket();
break;
case SmbCommand.SMB_COM_READ_ANDX:
smbPacket = new SmbReadAndxRequestPacket();
break;
case SmbCommand.SMB_COM_CLOSE:
smbPacket = new SmbCloseRequestPacket();
break;
case SmbCommand.SMB_COM_TREE_DISCONNECT:
smbPacket = new SmbTreeDisconnectRequestPacket();
break;
case SmbCommand.SMB_COM_LOGOFF_ANDX:
smbPacket = new SmbLogoffAndxRequestPacket();
break;
case SmbCommand.SMB_COM_TRANSACTION:
SMB_COM_TRANSACTION_Request_SMB_Parameters transaction =
channel.Read <SMB_COM_TRANSACTION_Request_SMB_Parameters>();
if (transaction.SetupCount == 0)
{
smbPacket = new SmbTransRapRequestPacket();
}
else
{
smbPacket = FindTheTransactionPacket(
transaction.SetupCount, (TransSubCommand)transaction.Setup[0]);
}
break;
case SmbCommand.SMB_COM_TRANSACTION2:
SMB_COM_TRANSACTION2_Request_SMB_Parameters transaction2 =
channel.Read <SMB_COM_TRANSACTION2_Request_SMB_Parameters>();
smbPacket = FindTheTrans2Packet((Trans2SubCommand)transaction2.Subcommand);
break;
case SmbCommand.SMB_COM_NT_TRANSACT:
SMB_COM_NT_TRANSACT_Request_SMB_Parameters ntTransactoin =
channel.Read <SMB_COM_NT_TRANSACT_Request_SMB_Parameters>();
smbPacket = FindTheNtTransPacket(ntTransactoin.Function, CifsMessageUtils.ToBytesArray <ushort>(ntTransactoin.Setup));
break;
default:
break;
}
return(smbPacket);
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbNtCreateAndxRequestPacket(SmbNtCreateAndxRequestPacket packet)
: base(packet)
{
}
/// <summary>
/// update the context with response packet
/// </summary>
/// <param name="connection">the connection of endpoint</param>
/// <param name="packet">the packet to update the context</param>
private void ResponsePacketUpdateRoleContext(SmbServerConnection connection, SmbPacket packet)
{
SmbHeader smbHeader = packet.SmbHeader;
SmbPacket requestPacket = connection.GetRequestPacket(smbHeader.Mid);
if (requestPacket == null)
{
return;
}
switch (smbHeader.Command)
{
case SmbCommand.SMB_COM_SESSION_SETUP_ANDX:
if (smbHeader.Uid == 0)
{
break;
}
else
{
SmbServerSession session = new SmbServerSession();
session.Uid = smbHeader.Uid;
session.AuthenticationState = SessionState.Complete;
session.Connection = connection;
session.SessionKey = connection.GssApi.SessionKey;
connection.AddSession(session);
}
break;
case SmbCommand.SMB_COM_LOGOFF_ANDX:
if (requestPacket.SmbHeader.Uid == 0)
{
break;
}
else
{
connection.RemoveSession(connection.GetSession(requestPacket.SmbHeader.Uid));
}
break;
case SmbCommand.SMB_COM_TREE_CONNECT_ANDX:
{
SmbTreeConnectAndxRequestPacket request = requestPacket as SmbTreeConnectAndxRequestPacket;
SmbServerTreeConnect treeconnect = new SmbServerTreeConnect();
treeconnect.TreeId = smbHeader.Tid;
treeconnect.Session = connection.GetSession(smbHeader.Uid);
if (treeconnect.Session == null)
{
break;
}
if ((request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) != 0)
{
treeconnect.Path = Encoding.Unicode.GetString(request.SmbData.Path);
}
else
{
treeconnect.Path = Encoding.ASCII.GetString(request.SmbData.Path);
}
treeconnect.Path = treeconnect.Path.TrimEnd('\0');
treeconnect.Session.AddTreeConnect(treeconnect);
}
break;
case SmbCommand.SMB_COM_TREE_DISCONNECT:
if (requestPacket.SmbHeader.Uid != 0)
{
SmbServerSession session = connection.GetSession(requestPacket.SmbHeader.Uid);
if (session == null)
{
break;
}
session.RemoveTreeConnect(session.GetTreeConnect(requestPacket.SmbHeader.Tid));
}
break;
case SmbCommand.SMB_COM_NT_CREATE_ANDX:
{
SmbNtCreateAndxResponsePacket response = packet as SmbNtCreateAndxResponsePacket;
SmbNtCreateAndxRequestPacket request = requestPacket as SmbNtCreateAndxRequestPacket;
SmbServerOpen open = new SmbServerOpen();
open.SmbFid = response.SmbParameters.FID;
open.PathName = SmbMessageUtils.GetString(request.SmbData.FileName,
SmbFlags2.SMB_FLAGS2_UNICODE == (request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE));
open.PathName = open.PathName.TrimEnd('\0');
open.Session = connection.GetSession(smbHeader.Uid);
open.TreeConnect = connection.GetTreeConnect(smbHeader.Tid);
if (open.TreeConnect == null)
{
break;
}
open.TreeConnect.AddOpen(open);
}
break;
case SmbCommand.SMB_COM_OPEN_ANDX:
{
SmbOpenAndxResponsePacket response = packet as SmbOpenAndxResponsePacket;
SmbOpenAndxRequestPacket request = requestPacket as SmbOpenAndxRequestPacket;
SmbServerOpen open = new SmbServerOpen();
open.SmbFid = response.SmbParameters.FID;
open.PathName = SmbMessageUtils.GetString(request.SmbData.FileName,
SmbFlags2.SMB_FLAGS2_UNICODE == (request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE));
open.Session = connection.GetSession(smbHeader.Uid);
open.TreeConnect = connection.GetTreeConnect(smbHeader.Tid);
if (open.TreeConnect == null)
{
break;
}
open.TreeConnect.AddOpen(open);
}
break;
case SmbCommand.SMB_COM_CLOSE:
{
SmbCloseRequestPacket closeRequest = requestPacket as SmbCloseRequestPacket;
SmbServerTreeConnect treeconnect = connection.GetTreeConnect(requestPacket.SmbHeader.Tid);
if (treeconnect == null)
{
break;
}
treeconnect.RemoveOpen(treeconnect.GetOpen(closeRequest.SmbParameters.FID));
}
break;
default:
break;
}
connection.RemoveRequestPacket(packet);
}