modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Services/Smb/Client/TransportMux.sg

2480 lines
106 KiB
Plaintext
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
//
// Microsoft Research Singularity
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: Services/Smb/Client/TransportMux.sg
//
// Note:
//
// This file contains the implementation of the SMB Client Transport
// Multiplexer. The mux runs on a single thread, and its purpose is to
// manage access to the TCP/IP connection to the SMB server.
//
using System;
using System.Text;
using System.Collections;
using System.Threading;
using System.Runtime.InteropServices;
using Microsoft.SingSharp;
using Microsoft.Singularity;
using Microsoft.Singularity.Directory;
using Microsoft.Singularity.Channels;
using Microsoft.Singularity.Security;
using NetStack.Contracts;
using Smb.Protocol;
using Smb.PublicChannels;
using Smb.PrivateChannels;
using Smb.Shared;
namespace Smb.Client
{
class TransportMux : ITracked
{
/// <summary>
/// This method creates a new TransportMux instance.
/// </summary>
public static void Run(
[Claims]ServiceProviderContract.Exp! namespace_provider,
[Claims]SmbClientControllerContract.Exp! controller,
[Claims]SmbMuxNotifier.Imp! notifier,
string! serverName,
string! resourceName)
{
TransportMux mux = new TransportMux(
namespace_provider,
controller,
notifier,
serverName,
resourceName);
try {
mux.ThreadMain();
}
finally {
mux.Dispose();
}
}
TransportMux(
[Claims]ServiceProviderContract.Exp! namespace_provider,
[Claims]SmbClientControllerContract.Exp! controller,
[Claims]SmbMuxNotifier.Imp! notifier,
string! serverName,
string! resourceName)
{
_ServerHostName = serverName;
_ServerResourceName = resourceName;
_notifier = notifier;
_notifier_can_send = true;
_namespace_provider = namespace_provider;
_controller = controller;
_recvBuffer = new byte[400];
_recvDataLength = 0;
}
readonly SmbMuxNotifier.Imp! _notifier;
static bool _dump_received_messages;
static bool _dump_sent_messages;
// These come from the command-line when the service was started.
readonly string! _ServerHostName;
readonly string! _ServerResourceName;
// Once we have connected, negotiated, and connected to the tree, this tuple contains
// the values we should use. MuxId will always be zero.
MuxTuple _treeTuple;
// I don't like this flag.
// If set, it means a protocol violation occurred, and so we need to tear down the connection.
// I want a cleaner way to do this.
bool _connection_failed;
// key: MuxTuple
// value: Transactor
readonly Hashtable/*<MuxTuple, Transactor!>*/! _transactors = new Hashtable();
/// <summary>
/// This endpoint map contains transactor endpoints that are in the "Ready" state.
/// We listen for the Request message in this state, meaning a transactor client
/// (which is anything that can issue SMB transactions, such as a DirectoryServiceContract
/// worker thread or a FileContract worker thread) wants to start a request.
/// </summary>
EMap<SmbTransactor.Exp:Ready, Transactor!>! _readyTransactors =
new EMap<SmbTransactor.Exp:Ready, Transactor!>();
/// <summary>
/// The TCP connection to the SMB server. In the Disconnected state, this field is null.
/// In all other states (except possibly during state transitions), this field is non-null.
/// </summary>
TcpConnectionContract.Imp _connection;
// This endpoint is connected to SmbClientManager. This thread receives control
// requests on the endpoint.
readonly SmbClientControllerContract.Exp! _controller;
// This endpoint represents our registration of the SMB namespace with the global
// Singularity directory service. This is how we receive filesystem requests.
readonly ServiceProviderContract.Exp! _namespace_provider;
// The set of clients that have opened our published service control channel.
// This allows clients to send control requests to the SMB client.
ESet<SmbClientControlContract.Exp:Ready>! _control_clients = new ESet<SmbClientControlContract.Exp:Ready>();
// The last known status (snapshot) of the connection.
ClientStatusSnapshot _mux_status;
// Sequence number, identifies version of _mux_state
long _mux_status_version;
// Sequence number, identifies the last version of _mux_state we have sent to main thread
long _notifier_mux_status_version;
// If true, then _notifier is in a state that allows us to send a message.
bool _notifier_can_send;
// If true, SmbClientManager has requested that this process stop.
bool _service_stopping;
int _MaxSmbRequestLength = 1024;
// The credentials that we actually selected and used during authentication.
// This is set during SessionSetupAndConnectBasic.
string _SelectedCredentialsName;
// This value is returned from the server to the client in response to the NEGOTIATE message.
string _ReceivedServerDomainNameFromNegotiate;
string _ReceivedServerMachineName;
// These values are received from the server in response to the SESSION SETUP message.
string _ReceivedServerOperatingSystem;
string _ReceivedServerPrimaryDomainName;
// This could just as well be called the DisconnectedStateLoop.
void ThreadMain()
{
expose(this)
{
_service_stopping = false;
// bool want_connect = false;
bool want_connect = true;
try {
SetMuxStatusDisconnected(SmbReasonDisconnected.Idle);
for (;;) {
if (want_connect) {
want_connect = false;
goto start_connect;
}
//
// At this point, we are in the Disconnected state.
// New transactors can be created.
//
disconnected_state:
Disconnect();
_connection_failed = false;
for (;;) {
if (_service_stopping) {
DebugLine("TransportMux - main thread exiting");
return;
}
switch receive {
case _notifier.Ack():
AckNotifier();
break;
case _controller.ChannelClosed():
DebugLine("Controller channel has closed!!");
goto thread_quit;
case _controller.Bind(ServiceContract.Exp:Start! exp):
ControllerBind(exp);
break;
case _controller.Stop():
DebugLine("Received Stop request on controller channel");
_service_stopping = true;
Disconnect();
return;
case _namespace_provider.Connect(ServiceContract.Exp:Start! exp):
// A client wants to connect to the mount point namespace provider.
// We're not connected to the server right now. If the namespace client
// is a valid client (a supported contract), then we'll try to connect
// to the SMB server in response to this request. If not, we don't
// accept the client, and we don't attempt to connect to the SMB server.
if (NamespaceConnect(_namespace_provider, exp)) {
DebugLine("Namespace client is now connected.");
goto start_connect;
}
else {
DebugLine("Namespace client could not be connected.");
}
break;
}
}
//
// At this point, we want to connect to the remote peer.
// Ask the Connector helper class to start connecting for us.
//
start_connect:
if (ConnectAndNegotiate()) {
goto connected_state;
}
else {
goto disconnected_state;
}
connected_state:
ConnectedReceiveLoop();
}
thread_quit:
Disconnect();
}
catch (Exception ex) {
DebugLine("Exception reached top of thread frame in multiplexer thread!");
Util.ShowExceptionDebug(ex, "TransportMultiplexer failed");
}
}
}
void ControllerBind([Claims]ServiceContract.Exp:Start! exp)
{
expose (this)
{
SmbClientControlContract.Exp typed_exp = exp as SmbClientControlContract.Exp;
if (typed_exp != null) {
if (TraceSwitches.ShowControlMessages) {
DebugLine("CONTROL: A control client has connected");
}
typed_exp.SendSuccess();
_control_clients.Add(typed_exp);
_controller.SendOk();
}
else {
if (TraceSwitches.ShowControlMessages) {
DebugLine("CONTROL: A control client connected, but offered an unsupported contract type.");
}
_controller.SendRequestFailed(SmbErrorCode.InternalError, null);
delete exp;
}
}
}
bool NamespaceConnect(ServiceProviderContract.Exp! provider, [Claims]ServiceContract.Exp:Start! exp)
{
DirectoryServiceContract.Exp dir_exp = exp as DirectoryServiceContract.Exp;
if (dir_exp != null) {
if (TraceSwitches.ShowDirectoryMessages) {
DebugLine("CONTROL: A namespace client has connected");
}
SmbTransactor.Imp transactor = CreateTransactor();
if (transactor == null) {
DebugLine("Failed to bind namespace client because we failed to create a transactor.");
provider.SendNackConnect(exp);
return false;
}
DirectoryClient.StartServiceThread(transactor, dir_exp, "/");
provider.SendAckConnect();
return true;
}
else {
DebugLine("CONTROL: A namespace client connected, but offered an unsupported contract.");
provider.SendNackConnect(exp);
return false;
}
}
void Disconnect()
{
expose (this)
{
DebugLine("--- ENTERING DISCONNECTED STATE ---");
// Reject all transactors.
foreach (Transactor! tran in _transactors.Values) {
tran.Dispose();
}
_transactors.Clear();
_readyTransactors.Dispose();
_readyTransactors = new EMap<SmbTransactor.Exp:Ready, Transactor!>();
if (_connection != null) {
delete _connection;
_connection = null;
}
_SelectedCredentialsName = null;
_ReceivedServerOperatingSystem = null;
_ReceivedServerDomainNameFromNegotiate = null;
_ReceivedServerPrimaryDomainName = null;
_ReceivedServerMachineName = null;
}
}
void ConnectedReceiveLoop()
{
expose(this)
{
DebugLine("--- ENTERING CONNECTED STATE ---");
assert _connection != null;
// The TCP channel is now connected. However, we still have a lot of work to do before we can
// communicate with the server. We need to send a SETUP message, and we need to authenticate.
// We do this on another thread.
_connectionCanSend = true;
for (;;) {
assert _connection != null;
if (_connectionCanSend) {
SendQueuedTransactions();
}
if (_connection_failed) {
DebugLine("_connect_failed is set -- going to disconnect state.");
goto disconnect;
}
switch receive {
case _namespace_provider.Connect(ServiceContract.Exp:Start! exp):
// A client wants to connect to the mount point namespace provider.
// We're in the connected state, so this is easy.
NamespaceConnect(_namespace_provider, exp);
break;
case _notifier.Ack():
AckNotifier();
break;
case _controller.Bind(ServiceContract.Exp:Start! exp):
ControllerBind(exp);
break;
case _controller.Stop():
DebugLine("Received Stop request on controller channel");
_service_stopping = true;
Disconnect();
return;
break;
case transactor.Request(byte[]! in ExHeap request) in _readyTransactors ~> tran:
StartRequest(transactor, tran, request);
break;
case transactor.ChannelClosed() in _readyTransactors ~> tran:
// A transactor has disconnected.
delete transactor;
DeleteTransactorState(tran);
break;
case transactor.AddTransactor() in _readyTransactors ~> tran:
SmbTransactor.Imp new_transactor = CreateTransactor();
if (new_transactor != null) {
transactor.SendAckAddTransactor(new_transactor);
}
else {
transactor.SendNakAddTransactor();
}
_readyTransactors.Add(transactor, tran);
break;
case _connection.NoData():
// This is not an error. It just means that the read poll did not return any data.
// Because this is part of a polling cycle, we don't bother printing any debug spew.
assert !_connectionCanSend;
_connectionCanSend = true;
// DebugLine("connection.NoData: no data available from TCP");
break;
case _connection.NoMoreData():
assert !_connectionCanSend;
_connectionCanSend = true;
DebugLine("connection.NoMoreData: peer has closed our receive path");
SetMuxStatusDisconnected(SmbReasonDisconnected.TransportFailure);
goto disconnect;
case _connection.CantSend():
assert !_connectionCanSend;
_connectionCanSend = true;
DebugLine("connection.CantSend: peer has closed our transmit path");
SetMuxStatusDisconnected(SmbReasonDisconnected.TransportFailure);
goto disconnect;
case _connection.Data(byte[]! in ExHeap data):
assert !_connectionCanSend;
_connectionCanSend = true;
// DebugLine("connection.Data: length = " + data.Length);
ProcessReceivedData(data, data.Length);
break;
case _connection.DataIsAvailable(bool available):
assert !_connectionCanSend;
_connectionCanSend = true;
// DebugLine("connection.DataIsAvailable(" + available + ")");
break;
case _connection.OK():
// from write result
// DebugLine("connection.OK()");
_connectionCanSend = true;
break;
}
}
disconnect:
assert _connection != null;
delete _connection;
_connection = null;
}
}
void SetMuxStatus(ClientStatusSnapshot! status)
{
if (TraceSwitches.ShowMuxStatusChanges)
DebugLine("SetMuxState: conn state = " + SmbDebug.EnumToString(status.ConnectionStatus));
_mux_status = status;
++_mux_status_version;
SendToNotifier();
}
void SetMuxStatus(SmbClientConnectionStatus connectionStatus)
{
ClientStatusSnapshot status = new ClientStatusSnapshot();
status.ConnectionStatus = connectionStatus;
status.ReasonDisconnected = SmbReasonDisconnected.Invalid;
status.ServerMachineName = null;
status.ServerDomainName = null;
status.ServerOperatingSystem = null;
SetMuxStatus(status);
}
void SetMuxStatusConnected()
{
ClientStatusSnapshot status = new ClientStatusSnapshot();
status.ConnectionStatus = SmbClientConnectionStatus.Connected;
status.ReasonDisconnected = SmbReasonDisconnected.Invalid;
status.ServerMachineName = _ReceivedServerMachineName;
status.ServerDomainName = _ReceivedServerPrimaryDomainName;
status.ServerOperatingSystem = _ReceivedServerOperatingSystem;
status.ActiveCredentialsName = _SelectedCredentialsName;
SetMuxStatus(status);
}
void SetMuxStatusDisconnected(SmbReasonDisconnected reason)
{
ClientStatusSnapshot status = new ClientStatusSnapshot();
status.ConnectionStatus = SmbClientConnectionStatus.Disconnected;
status.ReasonDisconnected = reason;
status.ServerMachineName = null;
status.ServerDomainName = null;
status.ServerOperatingSystem = null;
status.ActiveCredentialsName = null;
SetMuxStatus(status);
}
void SetMuxStatusDisconnected(SmbReasonDisconnected reason, Exception! ex)
{
ClientStatusSnapshot status = new ClientStatusSnapshot();
status.ConnectionStatus = SmbClientConnectionStatus.Disconnected;
status.ReasonDisconnected = reason;
status.ServerMachineName = null;
status.ServerDomainName = null;
status.ServerOperatingSystem = null;
SetMuxStatus(status);
// -XXX- Currently, we don't do anything with the exception.
// -XXX- Would be good to log it, report it, etc.
DebugLine("Mux status -> Disconnected");
Util.ShowExceptionDebug(ex);
}
// This method checks to see if we can (and should) send any notification messages
// to the notifier channel. The "main" thread holds the exp end of the notifier
// channel, and this thread (the mux) sends notifications to the main thread.
void SendToNotifier()
{
expose (this) {
if (!_notifier_can_send) {
// The _notifier endpoint is busy.
if (TraceSwitches.ShowNotifierMessages)
DebugLine("SendToNotifier - notifier is busy, can't send right now");
return;
}
if (_notifier_mux_status_version < _mux_status_version) {
if (TraceSwitches.ShowNotifierMessages)
DebugLine("Sending StatusChanged to notifier");
assert _mux_status != null;
_notifier.SendStatusChanged(_mux_status.ToExchange());
_notifier_can_send = false;
_notifier_mux_status_version = _mux_status_version;
return;
}
}
}
void AckNotifier()
{
if (TraceSwitches.ShowNotifierMessages) {
DebugLine("Received Ack from notifier channel");
}
assert !_notifier_can_send;
_notifier_can_send = true;
SendToNotifier();
}
byte[]! _recvBuffer = new byte[0x800];
int _recvDataLength = 0;
const int SmbFramingHeaderLength = 4; // length is in bytes
void ProcessReceivedData(
[Claims]byte[]! in ExHeap buffer,
int bufferLength)
requires bufferLength >= 0;
requires bufferLength <= buffer.Length;
{
// Check to see whether the fragment buffer contains any data.
// If it does, then we have already received part of an SMB message, but not all of it.
// Assemble the full message before continuing.
//
// If _recvBuffer contains any data (_recvDataLength > 0), then that existing
// partial message has its start aligned with _recvBuffer. So we never have to
// deal with finding the start of a message.
if (_recvDataLength != 0) {
int concatLength = bufferLength + _recvDataLength;
if (TraceSwitches.ShowSmbReassembly) {
DebugLine("concatenating fragment: previous fragment length = 0x{0:x} recv'd data length = 0x{1:x} total length = 0x{2:x}",
_recvDataLength, bufferLength, concatLength);
}
byte[]! in ExHeap concatBuffer = new[ExHeap] byte[concatLength];
Bitter.FromByteArray(concatBuffer, 0, _recvDataLength, _recvBuffer, 0);
Bitter.Copy(concatBuffer, _recvDataLength, bufferLength, buffer, 0);
delete buffer;
buffer = concatBuffer;
bufferLength = concatLength;
_recvDataLength = 0;
}
// scan from 0 to bufferLength within buffer
int parseOffset = 0;
for (;;) {
assert parseOffset <= bufferLength;
int remaining = bufferLength - parseOffset;
if (remaining == 0) {
if (TraceSwitches.ShowSmbReassembly)
DebugLine("no more data in receive buffer");
_receiveBufferPool.Recycle(buffer);
return;
}
bool too_short;
int nextMessageOffset;
int smbLength;
if (SmbFramingHeaderLength < 4) {
if (TraceSwitches.ShowSmbReassembly)
DebugLine("too little data to parse -- storing in fragment buffer");
too_short = true;
smbLength = -1;
nextMessageOffset = -1;
}
else {
smbLength = (buffer[parseOffset + 1] << 16)
+ (buffer[parseOffset + 2] << 8)
+ (buffer[parseOffset + 3]);
nextMessageOffset = parseOffset + SmbFramingHeaderLength + smbLength;
if (nextMessageOffset > bufferLength) {
// not enough data for a complete message
too_short = true;
}
else {
too_short = false;
}
}
if (too_short) {
if (remaining > _recvBuffer.Length) {
_recvBuffer = new byte[remaining + 0x100];
}
if (TraceSwitches.ShowSmbReassembly)
DebugLine("too little data to parse -- storing 0x{0:x} bytes in fragment buffer", remaining);
Bitter.ToByteArray(buffer, parseOffset, remaining, _recvBuffer, 0);
_recvDataLength = remaining;
_receiveBufferPool.Recycle(buffer);
return;
}
try {
ProcessReceivedMessage(buffer, parseOffset, smbLength + SmbFramingHeaderLength);
}
catch (Exception ex) {
Util.ShowExceptionDebug(ex, "Error occurred while parsing received SMB message.");
}
assert nextMessageOffset <= buffer.Length;
assert nextMessageOffset > parseOffset;
if (nextMessageOffset == bufferLength) {
// DebugLine("SMB message ended on TCP message boundary (this is the easy case)");
_receiveBufferPool.Recycle(buffer);
return;
}
parseOffset = nextMessageOffset;
}
}
void Transactor_EnterReceiveState(
/*[Claims]*/ Transactor! tran,
TransactorState tstate)
requires tstate == TransactorState.WaitingReceiveResponse
|| tstate == TransactorState.WaitingReceivePrimaryTransactionResponse
|| tstate == TransactorState.WaitingReceiveSecondaryTransactionResponse;
{
tran.State = tstate;
}
///
//<summary>
// <para>
// This method processes a single SMB message that has been received from the SMB server.
// The caller of this method (ProcessReceivedData) has already located the SMB message
// within a (potentially) larger buffer, and has verified the 'SMB' 0xFF signature.
// </para>
// <para>
// The purpose of this method is to match up a received SMB message to our internal state
// for that request (a Transactor), and to advance the state of that transactor. Depending
// on the kind of request, the request will either be completed immediately (within the
// scope of this method call), or will require further processing.
// </para>
//</summary>
//<param name="buffer">
// The buffer containing this SMB message, and potentially other SMB messages.
// This method does not claim ownership of the buffer, so we must copy any data
// out of the buffer. Zero-copy is desirable, but is for future study.
//</param>
//<param name="offset">
// The index of the first byte of the SMB message within 'buffer'. The message begins with the
// SMB "framing" header (4 bytes).
//</param>
//<param name="length">
// The length of the SMB message within the buffer. This value is NOT the same as the decoded
// length value stored in the first four bytes (the framing header).
//</param>
//
void ProcessReceivedMessage(byte[]! in ExHeap buffer, int offset, int length)
{
if (TraceSwitches.ShowSmbMessageDetails) {
DebugLine("------------------ RECEIVED SMB MESSAGE --------------------------");
SmbDebug.DumpMessage(buffer, offset, length);
}
if (length < SmbProtocol.SmbHeaderSize) {
DebugLine("WARNING! Protocol violation: Received an SMB header indicates a message that is too small to be meaningful, length = ", length);
DebugLine("The message will be ignored, and the connection will otherwise not be affected.");
return;
}
ref SmbHeader header = ref buffer[offset];
if (!(header.Signature0 == 0xff
&& header.Signature1 == (byte)'S'
&& header.Signature2 == (byte)'M'
&& header.Signature3 == (byte)'B'))
{
DebugLine("ERROR! Protocol violation: Received an SMB message with an invalid SMB signature.");
DebugLine("This usually means the client and server have gotten out of sync on message boundaries.");
DebugLine("The connection will be terminated.");
_connection_failed = true;
return;
}
if (TraceSwitches.ShowSmbMessageOneLineSummaries) {
string! cmdname = SmbDebug.GetSmbMessageSummary(buffer, offset);
if (header.IsError) {
DebugLine("Received <-- " + cmdname + " ERROR: " + header.GetErrorText());
}
else {
DebugLine("Received <-- " + cmdname);
}
}
//
// Find the transactor that sent this request by its mux tuple.
// In most circumstances, the mux tuple of a response will match exactly the mux tuple of the request.
// However, for some requests, only part of the tuple will match. This is really annoying.
//
Transactor tran = FindMatchingTransactor(ref header);
if (tran == null) {
// FindMatchingTransactor has already complained enough.
return;
}
Transactor_ProcessReceivedMessage(tran, buffer, offset, length);
}
void Transactor_ProcessReceivedMessage(
[Claims]Transactor! tran,
byte[]! in ExHeap buffer, int offset, int length)
{
Transactor.TrackedData tracked = tran.AcquireData();
try {
ref SmbHeader header = ref buffer[offset];
switch (tran.State) {
case TransactorState.Ready:
DebugLine(tran, "Received SMB message, but this transactor is idle!");
DebugLine(tran, "Ignoring message.");
break;
case TransactorState.WaitingSendRequest:
case TransactorState.WaitingSendPrimaryTransactionRequest:
case TransactorState.WaitingSendSecondaryTransactionRequest:
DebugLine(tran, "Received SMB message, but this transactor is not expecting a message yet!");
DebugLine(tran, "The transactor is in a 'send' state, not a receive state.");
DebugLine(tran, "I'll probably regret this later, but the message will be ignored.");
break;
case TransactorState.WaitingReceiveResponse:
{
// We have received the response for a "simple" SMB request/response exchange.
// Next, route the received message to the holder of the import endpoint of the
// transactor, and mark our transactor state as "ready".
// DebugLine("Received SMB message matching simple SMB request.");
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendResponse_Copy(tran, exp, buffer, offset, length);
Transactor_EnterReadyState(exp, tran);
break;
}
case TransactorState.WaitingReceiveInterimTransactionResponse:
{
// This transactor is performing a SMB_TRANSACTION2 request. The primary transaction
// request has been sent, and now we have received the interim server response. If this
// response is an error, then the transaction fails immediately. If this response is a
// "go ahead" code, then we have permission from the server to send the rest of the
// transaction's request fragments (the "secondary transaction requests").
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, "Received interim server response");
if (header.IsError) {
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Server indicates ERROR -- transaction fails immediately.");
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendResponse_Copy(tran, exp, buffer, offset, length);
Transactor_EnterReadyState(exp, tran);
}
else {
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Server says go ahead with request fragments");
Transactor_EnqueueForSend(tran, TransactorState.WaitingSendSecondaryTransactionRequest);
}
break;
}
case TransactorState.WaitingReceivePrimaryTransactionResponse:
{
// We've received the primary response to a SMB_TRANSACTION2 exchange.
// This response may have further responses (fragments), or may be the only response.
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, "Received Primary Transaction Response");
if (header.IsError) {
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Response indicates ERROR");
// DebugStub.Break();
//
// We're receiving SMB TRANSACTION2 respones from XP that don't match anything rational,
// when the transaction fails. So for now, we treat any primary transaction response
// that has an error code in the SMB header as the only fragment that we will receive.
//
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendResponse_Copy(tran, exp, buffer, offset, length);
Transactor_EnterReadyState(exp, tran);
break;
}
if (length < sizeof(SmbTransaction2Response)) {
// This message is too small to be a valid transaction response.
// It may be an error response from an older SMB server.
if (TraceSwitches.ShowTransactionFragmentationReassembly) {
DebugLine(tran, " Response is too short to be a valid TRANSACTION2 response!");
DebugLine(tran, " Completing request immediately.");
}
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendResponse_Copy(tran, exp, buffer, offset, length);
Transactor_EnterReadyState(exp, tran);
}
else {
ref SmbTransaction2Response response = ref buffer[offset];
int totalParameterCount = ByteOrder.LeToHost(response.Transaction.TotalParameterCount);
int totalDataCount = ByteOrder.LeToHost(response.Transaction.TotalDataCount);
int parameterOffset = ByteOrder.LeToHost(response.Transaction.ParameterOffset);
int dataOffset = ByteOrder.LeToHost(response.Transaction.DataOffset);
int parameterCount = ByteOrder.LeToHost(response.Transaction.ParameterCount);
int dataCount = ByteOrder.LeToHost(response.Transaction.DataCount);
if (totalParameterCount > parameterCount || totalDataCount > dataCount) {
if (TraceSwitches.ShowTransactionFragmentationReassembly) {
DebugLine(tran, " Response indicates server will fragment transaction response.");
DebugLine(tran, " Parameters: {0}/{1} Data: {2}/{3}",
parameterCount, totalParameterCount, dataCount, totalDataCount);
}
// Compute the length of a buffer that will contain the entire, assembled
// response message.
// int assembledResponseLength = Util.Align4(sizeof(SmbTransaction2Response)) + totalParameterCount + totalDataCount;
int hypotheticalParameterEnd = SmbHeader.FramingHeaderLength + parameterOffset + totalParameterCount;
int hypotheticalDataEnd = SmbHeader.FramingHeaderLength + dataOffset + totalDataCount;
int hypotheticalMessageLength = Util.Align4(Math.Max(hypotheticalParameterEnd, hypotheticalDataEnd));
int assembledResponseLength = hypotheticalMessageLength;
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Reassembly buffer length: " + assembledResponseLength);
if (assembledResponseLength < length) {
// Uhhhhh, this doesn't make any sense!
DebugLine(tran, "*** Internal error! Reassembly buffer is shorter than the first packet buffer?!");
DebugStub.Break();
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendRequestFailed(tran, exp, SmbTransactionError.InternalError);
Transactor_EnterReadyState(exp, tran);
break;
}
// Allocate the buffer used to reassemble the entire transaction response.
byte[]! in ExHeap reassemblyBuffer = new[ExHeap] byte[assembledResponseLength];
Bitter.Copy(reassemblyBuffer, 0, length, buffer, offset);
#if INCREDIBLY_NOISY
if (TraceSwitches.ShowTransactionFragmentationReassemblyVerbose) {
DebugLine(tran, "Contents of primary transaction response:");
Util.DumpBuffer(buffer, offset, length);
DebugLine(tran, "Contents of parameter fragment portion:");
Util.DumpBuffer(buffer, offset + SmbHeader.FramingHeaderLength + parameterOffset, parameterCount);
DebugLine(tran, "Contents of data fragment portion:");
Util.DumpBuffer(buffer, offset + SmbHeader.FramingHeaderLength + dataOffset, dataCount);
}
#endif
// Set up the transactor state for reassembly.
expose(tracked) {
delete tracked.ResponseReassemblyBuffer;
tracked.ResponseReassemblyBuffer = reassemblyBuffer;
}
tracked.Transaction_ReceivedParameterBytes = parameterCount;
tracked.Transaction_ReceivedDataBytes = dataCount;
tracked.Transaction_ReceivedFragmentCount = 1;
tracked.Transaction_DataOffset = SmbHeader.FramingHeaderLength + dataOffset;
tracked.Transaction_ParameterOffset = SmbHeader.FramingHeaderLength + parameterOffset;
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Waiting for more fragments");
Transactor_EnterReceiveState(tran, TransactorState.WaitingReceiveSecondaryTransactionResponse);
// DebugStub.Break();
}
else {
if (TraceSwitches.ShowTransactionFragmentationReassembly) {
DebugLine(tran, " Response indicates no fragmentation necessary");
DebugLine(tran, " Completing request immediately.");
}
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendResponse_Copy(tran, exp, buffer, offset, length);
Transactor_EnterReadyState(exp, tran);
}
}
break;
}
case TransactorState.WaitingReceiveSecondaryTransactionResponse:
{
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, "Received Secondary Transaction Response");
// Is this the last one? Are we done yet?
ref SmbTransaction2Response response = ref buffer[offset];
int totalParameterCount = ByteOrder.LeToHost(response.Transaction.TotalParameterCount);
int totalDataCount = ByteOrder.LeToHost(response.Transaction.TotalDataCount);
int parameterCount = ByteOrder.LeToHost(response.Transaction.ParameterCount);
int dataCount = ByteOrder.LeToHost(response.Transaction.DataCount);
int parameterDisplacement = ByteOrder.LeToHost(response.Transaction.ParameterDisplacement);
int dataDisplacement = ByteOrder.LeToHost(response.Transaction.DataDisplacement);
int parameterOffset = ByteOrder.LeToHost(response.Transaction.ParameterOffset);
int dataOffset = ByteOrder.LeToHost(response.Transaction.DataOffset);
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, "Reassembling fragment #" + tracked.Transaction_ReceivedFragmentCount);
// DebugStub.Break();
tracked.Transaction_ReceivedFragmentCount++;
expose (tracked)
{
assert tracked.ResponseReassemblyBuffer != null;
// -XXX- Need to validate the offsets/lengths/etc.
// -XXX- Bitter.Copy will validate them, but will throw exceptions.
// DebugStub.Break();
if (parameterCount != 0) {
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Reassembled {0}/{1} parameter bytes at offset {2}", parameterCount, totalParameterCount, parameterDisplacement);
Bitter.Copy(
tracked.ResponseReassemblyBuffer,
tracked.Transaction_ParameterOffset + parameterDisplacement,
parameterCount,
buffer,
offset + SmbHeader.FramingHeaderLength + parameterOffset);
if (TraceSwitches.ShowTransactionFragmentationReassemblyVerbose) {
DebugLine(tran, "Contents of parameter fragment portion:");
Util.DumpBuffer(buffer, offset + SmbHeader.FramingHeaderLength + parameterOffset, parameterCount);
}
tracked.Transaction_ReceivedParameterBytes += parameterCount;
}
if (dataCount != 0) {
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Reassembled {0}/{1} data bytes at offset {2}", dataCount, totalDataCount, dataDisplacement);
Bitter.Copy(
tracked.ResponseReassemblyBuffer,
tracked.Transaction_DataOffset + dataDisplacement,
dataCount,
buffer,
offset + SmbHeader.FramingHeaderLength + dataOffset);
if (TraceSwitches.ShowTransactionFragmentationReassemblyVerbose) {
DebugLine(tran, "Contents of data fragment portion:");
Util.DumpBuffer(buffer, offset + SmbHeader.FramingHeaderLength + dataOffset, dataCount);
}
tracked.Transaction_ReceivedDataBytes += dataCount;
}
}
bool last = false;
if (parameterCount == 0 && dataCount == 0) {
// Ummmm, the server is crazy.
DebugLine(tran, "*** Received transaction fragment with both ParameterCount == 0 and DataCount == 0!");
DebugLine(tran, "*** I think this is a protocol violation. Completing the transaction.");
last = true;
}
if (tracked.Transaction_ReceivedParameterBytes >= totalParameterCount
&& tracked.Transaction_ReceivedDataBytes >= totalDataCount)
{
if (TraceSwitches.ShowTransactionFragmentationReassembly) {
DebugLine(tran, "We have apparently received all of the transaction response fragments.");
}
if (TraceSwitches.ShowTransactionFragmentationReassemblyVerbose) {
DebugLine(tran, "Reassembled transaction response:");
expose (tracked) { Util.DumpBuffer(tracked.ResponseReassemblyBuffer); }
}
// DebugStub.Break();
last = true;
}
if (last) {
if (TraceSwitches.ShowTransactionFragmentationReassembly)
DebugLine(tran, " Last fragment!");
byte[] in ExHeap! reassembledResponseBuffer = (!)tracked.ExtractResponseReassemblyBuffer();
SmbTransactor.Exp! exp = (!)tracked.AcquireEndpoint();
Transactor_SendResponse_ClaimsBuffer(tran, exp, reassembledResponseBuffer);
Transactor_EnterReadyState(exp, tran);
}
else {
Transactor_EnterReceiveState(tran, TransactorState.WaitingReceiveSecondaryTransactionResponse);
}
break;
}
default:
DebugLine(tran, "INTERNAL ERROR -- TRANSACTOR IS IN UNRECOGNIZED STATE!");
DebugStub.Break();
break;
}
}
finally {
tran.ReleaseData(tracked);
}
}
void Transactor_SendResponse_ClaimsBuffer(Transactor! tran, SmbTransactor.Exp! exp, [Claims]byte[]! in ExHeap response)
{
exp.SendResponse(response);
}
void Transactor_SendRequestFailed(Transactor! tran, SmbTransactor.Exp! exp, SmbTransactionError error)
{
DebugLine(tran, "Sending RequestFailed: " + error.ToString());
exp.SendRequestFailed(error);
}
void Transactor_SendResponse_Copy(Transactor! tran, SmbTransactor.Exp! exp, byte[]! in ExHeap buffer, int offset, int length)
{
byte[]! in ExHeap response = new[ExHeap] byte[length];
Bitter.Copy(response, 0, length, buffer, offset);
Transactor_SendResponse_ClaimsBuffer(tran, exp, response);
}
void DumpTransactorTable()
{
DebugLine("Contents of _transactors:");
foreach (DictionaryEntry entry in _transactors) {
MuxTuple tuple = (MuxTuple)entry.Key;
Transactor! tran = (!)(Transactor)entry.Value;
if (tuple != tran.Tuple) {
DebugLine("!!! Transactor key mismatch! Key={0} tran.Tuple={1}", tuple.ToString(), tran.Tuple.ToString());
DebugStub.Break();
}
DebugLine(" " + tran.ToString());
}
}
Transactor FindMatchingTransactor(ref SmbHeader header)
{
MuxTuple tuple = MuxTuple.FromSmbHeader(header);
object boxed_tuple = (object)tuple;
Transactor tran = (Transactor)_transactors[boxed_tuple];
if (tran != null) {
return tran;
}
#if DEBUG
DebugLine("!!! Received SMB message, but the mux tuple does not match any active transactor! tuple=" + MuxTuple.FromSmb(ref header).ToString());
DumpTransactorTable();
DebugStub.Break();
// for dbg only
DebugLine("tuple hash code: 0x{0:x8}", tuple.GetHashCode());
DebugLine("Key search:");
foreach (object! key in _transactors.Keys) {
bool is_equal_1 = key.Equals(boxed_tuple);
bool is_equal_2 = boxed_tuple.Equals(key);
assert is_equal_1 == is_equal_2;
DebugLine(" key: hash code 0x{0:x8} tuple {1} equal? {2} {3}", key.GetHashCode(), key.ToString(),
Util.YesNoString(is_equal_1),
Util.YesNoString(is_equal_2));
}
#endif
return null;
}
const int SmbMessageMinimumLength = 0x1a;
// 0: 4-byte signature: 0xff 'S' 'M' 'B'
// 4: 1-byte command, 3-byte status
// 8: 1-byte status, 1-byte flags, 2-byte FLAGS2
// c: 8-byte "EXTRA"
// 12: tid
// 14: pid
// 16: uid
// 18: mid
// 1a: -- end --
const int NativeSmbPort = 445;
// if true, then we can send a message on the TCP connection channel.
// if false, then we can only wait for a response.
bool _connectionCanSend;
const int ReceiveBufferSize = 0x400;
// contains _TRef<byte[] in ExHeap>, each of which contains a buffer
// all of the slots within [0,_freeReceiveBufferCount) are non-null, and contain a valid
// (acquirable) byte[] buffer.
//
// the slots from _freeReceiveBuffers[_freeReceiveBufferCount] to _freeReceiveBuffers[length - 1]
// are either null, or have been acquired.
readonly BufferPool! _receiveBufferPool = new BufferPool(0x40, 0x400);
// Because TcpConnectionContract is half-duplex, we have to poll.
const int PollTimeoutMs = 100;
void SendQueuedTransactions()
// requires _connection != null;
{
// if we cannot send on the connection, then this method can't do anything.
expose(this) {
if (_connection == null)
return;
}
if (!_connectionCanSend)
return;
while (_connectionCanSend && _queuedTransactors.Count != 0) {
Transactor! tran = (!)(Transactor)_queuedTransactors.Dequeue();
assert tran.InQueue;
tran.InQueue = false;
Transactor_SendData(tran);
}
if (_connectionCanSend) {
//
// Issue a read (receive). Because the TcpConnectionContract is half-duplex, we have to use polling
// with timeouts to multiplex send/receive path. Yick.
//
bool wait = true;
// if (_queuedTransactors.Count != 0)
// wait = false;
expose (this) {
if (wait) {
// blocking read
// DebugLine("issuing blocking read (SendPollRead)");
_connection.SendPollRead(PollTimeoutMs);
}
else {
// non-blocking read
// DebugLine("issuing nonblocking read (SendRead)");
_connection.SendRead();
}
}
_connectionCanSend = false;
}
}
void Transactor_SendData(Transactor! tran)
requires _connectionCanSend;
{
Transactor.TrackedData tracked = tran.AcquireData();
switch (tran.State) {
case TransactorState.WaitingSendRequest:
{
// It's a "simple" request. Just send the request body.
// Ownership of the buffer moves from the transactor client, to the mux, to TCP/IP.
byte[]! in ExHeap request;
expose (tracked) {
assert tracked.RequestBuffer != null;
request = tracked.RequestBuffer;
tracked.RequestBuffer = null;
}
if (TraceSwitches.ShowSmbMessageDetails) {
DebugLine(tran, "sending request to TCP/IP, length = " + request.Length);
SmbDebug.DumpMessage(request, 0, request.Length);
}
if (TraceSwitches.ShowSmbMessageOneLineSummaries) {
DebugLine(tran, "Sending --> " + SmbDebug.GetSmbMessageSummary(request, 0));
}
SendData(request);
Transactor_EnterReceiveState(tran, TransactorState.WaitingReceiveResponse);
break;
}
case TransactorState.WaitingSendPrimaryTransactionRequest:
{
// It's a "transaction" style request. Next, we need to determine whether the
// entire transaction request can fit inside a single SMB message. If so, the
// next step is to wait for the transaction response. If not, then the next
// step is to wait for the "interim server response".
expose (tracked) {
assert tracked.RequestBuffer != null;
if (tracked.RequestBuffer.Length <= _MaxSmbRequestLength) {
// The transaction request is small enough to fit in a single SMB request.
byte[]! in ExHeap request = tracked.RequestBuffer;
tracked.RequestBuffer = null;
SendData(request);
Transactor_EnterReceiveState(tran, TransactorState.WaitingReceivePrimaryTransactionResponse);
}
else {
// Need to segment the request.
// int primaryRequestLength = _MaxSmbRequestLength;
DebugLine("Transaction segmentation NYI");
DebugStub.Break();
}
}
break;
}
case TransactorState.WaitingSendSecondaryTransactionRequest:
DebugLine("Transaction segmentation not yet implemented");
DebugStub.Break();
break;
}
tran.ReleaseData(tracked);
}
void SendData([Claims]byte[]! in ExHeap buffer)
{
expose(this)
{
assert _connectionCanSend;
assert _connection != null;
_connection.SendWrite(buffer);
// Since we have sent a message on the TCP/IP channel, we cannot send any more
// messages until we receive a message.
_connectionCanSend = false;
}
}
// Contains Transactor.
// All instances in this list are in the state "Active", and are waiting to be transmitted.
readonly Queue!/*<Transactor!>*/ _queuedTransactors = new Queue();
void Transactor_EnqueueForSend(
Transactor! tran,
TransactorState tstate)
requires tstate == TransactorState.WaitingSendRequest
|| tstate == TransactorState.WaitingSendPrimaryTransactionRequest
|| tstate == TransactorState.WaitingSendSecondaryTransactionRequest;
requires !tran.InQueue;
{
if (!(tstate == TransactorState.WaitingSendRequest
|| tstate == TransactorState.WaitingSendPrimaryTransactionRequest
|| tstate == TransactorState.WaitingSendSecondaryTransactionRequest)) {
DebugLine(tran, "ILLEGAL STATE FOR ENQUEUING A TRANSACTOR FOR SEND!");
DebugStub.Break();
throw new Exception("Illegal state for enqueuing a transactor for send!");
}
assert !tran.InQueue;
tran.InQueue = true;
tran.State = tstate;
_queuedTransactors.Enqueue(tran);
}
// Examines the request to start a transaction, validates some parameters and information about the request.
// Moves a request from the idle to the queued state.
void StartRequest(
[Claims]SmbTransactor.Exp:WaitingRequestResponse! tran_exp,
[Claims]Transactor! tran,
[Claims]byte[]! in ExHeap request)
requires tran.State == TransactorState.Ready;
{
int length = request.Length;
if (length < sizeof(SmbHeader)) { // SmbProtocol.SmbHeaderSize) {
DebugLine("SMB message is too small to be valid.");
goto validation_failed;
}
ref SmbHeader header = ref request[0];
int smbLength = length - 4;
header.FrameLength0 = 0;
header.FrameLength1 = (byte)((smbLength >> 16) & 0xff);
header.FrameLength2 = (byte)((smbLength >> 8) & 0xff);
header.FrameLength3 = (byte)(smbLength & 0xff);
//
// Fill in the mux tuple.
// The transactor client doesn't need to do this.
//
header.TreeId = (ushort)tran.Tuple.TreeId;
header.ProcessId = (ushort)tran.Tuple.ProcessId;
header.UserId = (ushort)tran.Tuple.UserId;
header.MuxId = (ushort)tran.Tuple.MuxId;
header.Signature0 = 0xff;
header.Signature1 = (byte)'S';
header.Signature2 = (byte)'M';
header.Signature3 = (byte)'B';
header.Flags1 = (byte)tran._smbFlag1;
header.Flags2 = (ushort)tran._smbFlag2;
// DebugLine(tran, "idle -> queued, request length = " + length.ToString());
tran.Command = (SmbCommand)header.Command;
Transactor.TrackedData tracked = tran.AcquireData();
TransactorState nextstate;
if (tran.Command == SmbCommand.Transaction2) {
// SMB defines the SMB_TRANSACTION2 command, which has a more complex message pattern
// than the simple request/response pattern that most commands use. SMB allows for
// fragmentation of SMB_TRANSACTION2 requests and responses.
// DebugLine("Starting SMB_TRANSACTION2 request");
tracked.TransactionRequestFragmentByteIndex = -1;
nextstate = TransactorState.WaitingSendPrimaryTransactionRequest;
}
else {
tracked.TransactionRequestFragmentByteIndex = -1;
nextstate = TransactorState.WaitingSendRequest;
}
expose (tracked) {
// Transfer ownership of the SmbTransactor.Exp endpoint to the Transactor instance.
delete tracked.Exp;
tracked.Exp = tran_exp;
// Transfer ownership of the request buffer from the caller to the Transactor instance.
delete tracked.RequestBuffer;
tracked.RequestBuffer = request;
tracked.RequestLength = length;
}
tran.ReleaseData(tracked);
// Queue this transactor for access to the send path of the socket.
Transactor_EnqueueForSend(tran, nextstate);
return;
validation_failed:
DebugLine(tran, "Rejecting request -- parameter validation failed");
DebugStub.Break();
tran_exp.SendRequestFailed(SmbTransactionError.InvalidParameters);
delete request;
Transactor_EnterReadyState(tran_exp, tran);
return;
}
void Transactor_EnterReadyState([Claims]SmbTransactor.Exp! exp, Transactor! tran)
{
expose(this)
{
// assert tran.Exp == null;
tran.State = TransactorState.Ready;
_readyTransactors.Add(exp, tran);
}
}
void DeleteTransactorState(Transactor! tran)
{
// DebugLine(tran, "deleting transactor");
object boxed_tuple = (object)tran.Tuple;
_transactors.Remove(boxed_tuple);
// -XXX- Need to scan the send queue!
tran.Dispose();
// DebugLine(tran, "deleted transactor");
}
int _nextMuxId;
int AllocateMuxId()
{
int firstMuxId = _nextMuxId;
for (;;) {
int muxId = _nextMuxId;
_nextMuxId++;
if (_nextMuxId > 0xff)
_nextMuxId = 1;
MuxTuple tuple = this._treeTuple;
tuple.MuxId = muxId;
object boxed_tuple = tuple;
if (_transactors[boxed_tuple] == null) {
// DebugLine("Allocated mux ID: " + muxId);
return muxId;
}
if (_nextMuxId == firstMuxId) {
DebugLine("No mux IDs are available.");
return -1;
}
}
}
// This method runs on the mux thread, and it handles the SmbTransportMux.AddTransactor message.
// This message is sent by other threads to this thread, in order to request that the mux create
// a new transactor. A transactor is anything that can send requests to the mux, and then wait
// for responses (a transaction).
//
// This method checks the hashtable of transactors to see if there are any tuple collisions
SmbTransactor.Imp CreateTransactor()
{
SmbTransactor.Imp! transactor_imp;
SmbTransactor.Exp! transactor_exp;
SmbTransactor.NewChannel(out transactor_imp, out transactor_exp);
if (CreateTransactor(transactor_exp)) {
return transactor_imp;
}
else {
delete transactor_imp;
return null;
}
}
bool CreateTransactor([Claims]SmbTransactor.Exp! transactor_exp)
{
expose (this)
{
int muxId = AllocateMuxId();
if (muxId == -1) {
DebugLine("Failed to create transactor -- no mux IDs are available.");
delete transactor_exp;
return false;
}
MuxTuple tuple = _treeTuple;
tuple.MuxId = muxId;
object boxed_tuple = (object)tuple;
if (_transactors[boxed_tuple] != null) {
DebugLine("Internal error - mux tuple is in use, even though we called AllocateMuxId!");
delete transactor_exp;
return false;
}
Transactor tran = new Transactor(tuple);
tran._smbFlag1 = (SmbFlag1)0;
tran._smbFlag2 = SmbFlag2.KnowsLongNames
| SmbFlag2.AllPathsAreLongNames
| SmbFlag2.UsingNtStatus
| SmbFlag2.UnicodeStrings;
_transactors[boxed_tuple] = tran;
Transactor_EnterReadyState(transactor_exp, tran);
if (TraceSwitches.ShowTransactorMessages)
DebugLine(tran, "Transactor created");
return true;
}
}
void DebugLine(string! msg)
{
SmbDebug.WriteLine("MUX: " + msg);
}
void DebugLine(string! format, params object[] args)
{
DebugLine(String.Format(format, args));
}
void DebugLine(Transactor! tran, string msg)
{
SmbDebug.WriteLine(tran.DebugPrefix + msg);
}
void DebugLine(Transactor! tran, string format, params object[] args)
{
DebugLine(tran, String.Format(format, args));
}
const string OSName = "MSR Singularity";
const string LanManName = "smbclient";
SmbFlag1 _flags1;
SmbFlag2 _flags2;
int _treeId;
int _processId;
int _muxId;
int _userId;
TcpConnectionContract.Imp:ReadyState! CreateTcpConnection()
{
//
// We invoke this synchronously, so we trust the TCP/IP stack not to delay us for an inordinate time.
//
TcpConnectionContract.Imp:ReadyState! connection = NetUtil.CreateTcpConnection();
return connection;
}
//
//This method handles connecting to an SMB server and negotiating for access to the file service.
//It handles name resolution, connecting the transport layer (TCP/IP), authentication, and connecting
//to the SMB file service. Once this method returns (successfully), the SMB connection is ready
//for general use by transactor clients.
//
//This method (any any methods it calls) do need to pay attention to certain messages from the
//SmbClientManager process. Currently, there are several important call paths (such as WaitResponse)
//which do NOT receive any messages from the control client. This needs to be fixed.
//
bool ConnectAndNegotiate()
{
expose(this)
{
DebugLine("--- CONNECTING TO SERVER ---");
SetMuxStatus(SmbClientConnectionStatus.TransportConnecting);
if (_connection != null) {
delete _connection;
_connection = null;
}
//
// -XXX- I *really* want a better solution than this. I don't want to block this thread
// -XXX- while waiting for TCP/IP to connect.
//
try {
TcpConnectionContract.Imp:Connected! connection = NetUtil.ConnectAny(_ServerHostName, NativeSmbPort);
delete _connection;
_connection = connection;
_connectionCanSend = true;
}
catch (Exception ex) {
DebugLine("Failed to connect to server.");
Util.ShowExceptionDebug(ex);
SetMuxStatusDisconnected(SmbReasonDisconnected.TransportConnectFailed);
return false;
}
_flags1 =
SmbFlag1.CaseInsensitive
| SmbFlag1.CanonicalizedPaths;
_flags2 =
SmbFlag2.KnowsLongNames
| SmbFlag2.KnowsExtendedAttributes
| SmbFlag2.AllPathsAreLongNames
// | SmbFlag2.AwareOfExtendedSecurity
| SmbFlag2.UsingNtStatus
| SmbFlag2.UnicodeStrings;
_treeId = 1;
_processId = 0xffef;
_userId = 0;
_muxId = 0;
SetMuxStatus(SmbClientConnectionStatus.Negotiating);
try {
Negotiate();
}
catch (Exception ex) {
SetMuxStatusDisconnected(SmbReasonDisconnected.NegotiationFailed, ex);
Disconnect();
return false;
}
SetMuxStatus(SmbClientConnectionStatus.Authenticating);
try {
SessionSetupAndConnectBasic();
}
catch (Exception ex) {
SetMuxStatusDisconnected(SmbReasonDisconnected.AuthenticationFailed, ex);
Disconnect();
return false;
}
try {
TreeConnect();
}
catch (Exception ex) {
SetMuxStatusDisconnected(SmbReasonDisconnected.ResourceConnectFailed, ex);
Disconnect();
return false;
}
DebugLine("Negotiation completed successfully");
SetMuxStatusConnected();
SmbMuxTuple tree;
tree.ProcessId = _processId;
tree.UserId = _userId;
tree.MuxId = _muxId;
tree.TreeId = _treeId;
_treeTuple = tree;
return true;
}
}
void TreeConnect()
{
ByteWriter data = new ByteWriter();
string! unc = Program.UncPath;
// yes, SMB mixes ASCII and UNICODE! yes, it drives me crazy!
// "password", really just alignment padding
data.WriteZero(1);
WriteSmbStringUnicode(data, unc, true);
// "?????" means "any type of service"
WriteSmbStringAscii(data, "?????", true);
int messageLength = sizeof(SmbTreeConnectAndX) + data.Length;
byte[]! in ExHeap request_encoded = new[ExHeap] byte[messageLength];
try {
ref SmbTreeConnectAndX request = ref request_encoded[0];
request = new SmbTreeConnectAndX();
PrepareHeader(ref request.Header, SmbCommand.TreeConnectAndX, 4);
request.AndXCommand = 0xff; // no AndX
request.AndXOffset = 0;
request.AndXReserved = 0;
request.ByteCount = (ushort)data.Length;
request.PasswordLength = 1;
data.CopyTo(request_encoded, sizeof(SmbTreeConnectAndX));
}
catch {
delete request_encoded;
throw;
}
if (TraceSwitches.ShowNegotiation)
DebugLine("Sending TreeConnectAndX");
byte[]! in ExHeap response_encoded = ExecuteSynchronousCommand(request_encoded);
try {
ref SmbHeader response = ref response_encoded[0];
if (response.IsError) {
DebugLine("Received TREE CONNECT response - FAILURE");
DebugLine("Error: " + response.GetErrorText());
throw new Exception("Tree connect FAILED: " + response.GetErrorText());
}
if (TraceSwitches.ShowNegotiation)
DebugLine("Received TREE CONNECT response - successful");
// I don't like this. We receive a different mux tuple from the server in response
// to TreeConnectAndX (the tree ID is different; it has been assigned by the server).
// So for now, we just change our tree ID. This means that the SMB client is restricted
// to servicing a single tree connection. I want this to change in the future, so that
// a single SMB client connection can carry requests for multiple different tree connections.
// This may be a dream, maybe even a bad one, but I want readers to be aware of this issue.
this._treeId = response.TreeId;
}
finally {
delete response_encoded;
}
}
void PrepareHeader(ref SmbHeader header, SmbCommand command, int parameterCount)
requires parameterCount >= 0;
requires parameterCount < 256;
{
header.SetSignature();
header.Command = (byte)command;
header.ParameterCount = (byte)parameterCount;
header.TreeId = (ushort)_treeId;
header.UserId = (ushort)_userId;
header.ProcessId = (ushort)_processId;
header.MuxId = (ushort)_muxId;
header.Flags1 = (byte)_flags1;
header.Flags2 = (ushort)_flags2;
}
// This method waits to receive one SMB message from the server.
// This is for use ONLY during initial negotation.
byte[]! in ExHeap WaitResponse()
// requires _connection != null;
{
expose(this)
{
assert _connection != null;
for (;;) {
if (_connectionCanSend) {
// Yes, we "poll" with a time-out.
// I don't like this, but it's our only option until we have full duplex channels,
// or a 2-channel TCP implementation.
_connection.SendPollRead(100);
_connectionCanSend = false;
}
switch receive {
case _connection.Data(byte[]! in ExHeap data):
assert !_connectionCanSend;
_connectionCanSend = true;
// DebugLine("Received data on socket: length = " + data.Length);
byte[] in ExHeap response = ProcessReceivedData(data);
if (response != null)
return response;
break;
case _connection.ChannelClosed():
throw new Exception("The TCP channel closed before receiving a message.");
case _connection.ConnectionClosed():
throw new Exception("The TCP connection closed before receiving a message.");
case _connection.NoData():
// We get one of these for EVERY polled read.
// Which is quite noisy.
// DebugLine("no data from socket");
_connectionCanSend = true;
break;
case _notifier.Ack():
AckNotifier();
break;
// -XXX- Should add more handlers here, to pay attention to control messages.
}
}
}
}
byte[] in ExHeap ProcessReceivedData([Claims]byte[]! in ExHeap buffer)
{
// Check to see whether the fragment buffer contains any data.
// If it does, then we have already received part of an SMB message, but not all of it.
// Assemble the full message before continuing.
if (_recvDataLength != 0) {
// Already have some data.
// Concatenate the existing data and the newly-received data, and attempt to parse.
// This is inefficient.
int concatLength = buffer.Length + _recvDataLength;
DebugLine("concatenating fragment: previous fragment length = 0x{0:x} recv'd data length = 0x{1:x} total length = 0x{2:x}",
_recvDataLength, buffer.Length, concatLength);
byte[]! in ExHeap concatBuffer = new[ExHeap] byte[concatLength];
// Bitter.Copy(concatBuffer, 0, _recvDataLength, _recvBuffer, 0);
Bitter.FromByteArray(concatBuffer, 0, _recvDataLength, _recvBuffer, 0);
Bitter.Copy(concatBuffer, _recvDataLength, buffer.Length, buffer, 0);
_recvDataLength = 0;
delete buffer;
buffer = concatBuffer;
}
//
// Have we received enough data to parse a complete message?
//
if (buffer.Length >= sizeof(SmbHeader)) {
ref SmbHeader header = ref buffer[0];
int messageLength = header.TotalMessageLength;
int remaining = buffer.Length - messageLength;
if (remaining > 0) {
DebugLine("Buffer received from TCP contains SMB message (plus " + remaining + " bytes)");
byte[]! in ExHeap response = new[ExHeap] byte[messageLength];
Bitter.Copy(response, 0, messageLength, buffer, 0);
// Store the remaining data in the fragment buffer.
AppendReceiveBuffer(buffer, messageLength, remaining);
delete buffer;
ValidateSmbMessage(response);
return response;
}
else if (remaining == 0) {
// Exact fit.
// This will probably be common.
// DebugLine("Buffer received from TCP contains exactly one SMB message (easy case).");
ValidateSmbMessage(buffer);
return buffer;
}
else {
// Not enough data for a complete message.
// Store it in the fragment buffer.
DebugLine("Buffer received from TCP does not contain the entire SMB message (need " + (-remaining) + " bytes).");
AppendReceiveBuffer(buffer, 0, buffer.Length);
delete buffer;
return null;
}
}
else {
// Not enough data for a complete message.
// Store it in the fragment buffer.
DebugLine("Buffer received from TCP does not contain the entire SMB message (header is incomplete).");
AppendReceiveBuffer(buffer, 0, buffer.Length);
delete buffer;
return null;
}
}
//
//This method copies data from a buffer to the end of the "fragment buffer" in the response context.
//
void AppendReceiveBuffer(
byte[]! in ExHeap appendData,
int appendOffset,
int length)
requires length >= 0;
requires appendOffset >= 0;
requires appendOffset <= appendData.Length;
{
if (length == 0)
return;
int finalLength = _recvDataLength + length;
if (finalLength > _recvBuffer.Length) {
int newLength = finalLength * 3 / 2 + 0x20;
DebugLine("Growing receive buffer from " + _recvBuffer.Length + " to " + newLength + " bytes");
byte[] newRecvBuffer = new byte[newLength];
Buffer.BlockCopy(_recvBuffer, 0, newRecvBuffer, 0, _recvDataLength);
// delete _recvBuffer;
_recvBuffer = newRecvBuffer;
}
assert _recvDataLength <= _recvBuffer.Length;
assert finalLength <= _recvBuffer.Length;
Bitter.ToByteArray(appendData, appendOffset, length, _recvBuffer, _recvDataLength);
_recvDataLength = finalLength;
}
void ValidateSmbMessage(byte[]! in ExHeap buffer)
{
if (buffer.Length < sizeof(SmbHeader))
throw new Exception("The message is too short to be a valid SMB message.");
ref SmbHeader header = ref buffer[0];
int messageLength = header.TotalMessageLength;
if (!header.IsSignatureValid()) {
DebugLine("ERROR! Protocol violation: Received an SMB message with an invalid SMB signature.");
DebugLine("This usually means the client and server have gotten out of sync on message boundaries.");
DebugLine("The connection will be terminated.");
throw new Exception("The message does not have a valid SMB signature.");
}
if (buffer.Length < messageLength)
throw new Exception("The message is too short to contain the message whose length is specified in the message header.");
}
#if false
void NegotiateUsingExtendedSecurity()
{
//
// Build the NTLM challenge and send it encapsulated within a SessionSetupAndTreeConnect request.
//
byte[]! hello = _supplicant.GetNegotiate();
DebugLine("Sending NTLM 'hello' blob:");
Util.DumpBuffer(hello);
SendSessionSetupAndConnect(transactor, hello);
//
// Next, we wait for the response to the SessionSetupAndTreeConnect.
// It should contain the NTLM challenge.
//
DebugLine("Waiting for NTLM challenge...");
byte[]! security_challenge;
WaitSessionSetupResponse(transactor, out security_challenge);
DebugLine("Received NTLM challenge:");
Util.DumpBuffer(security_challenge);
DebugStub.Break();
//
// Have the security context generate the response and send it in another SessionSetupAndX request.
//
byte[]! security_response = _supplicant.GetResponse(security_challenge);
DebugLine("Sending this NTLM response:");
Util.DumpBuffer(security_response);
SendSessionSetupAndConnect(transactor, security_response);
//
// Now wait for the final response.
//
byte[]! security_message_ignored;
WaitSessionSetupResponse(transactor, out security_message_ignored);
DebugLine("Final security response received.");
}
#endif
//
//
//This method sends the SMB NEGOTIATE message to the server, and waits for the response.
//If the message cannot be sent, or the response received indicates an error, then this
//method will throw an exception.
//
//
void Negotiate()
{
string![] dialects = { SmbDialect.NTLM012 };
ByteWriter! data = new ByteWriter();
foreach (string! dialect in dialects) {
data.Write(2);
byte[]! dialectbytes = Encoding.ASCII.GetBytes(dialect);
data.Write(dialectbytes);
data.Write(0);
}
SmbNegotiateRequest request = new SmbNegotiateRequest();
PrepareHeader(ref request.Header, SmbCommand.Negotiate, 0);
request.ByteCount = (ushort)data.Length;
byte[]! in ExHeap encoded_request = new[ExHeap] byte[sizeof(SmbNegotiateRequest) + data.Length];
ref SmbNegotiateRequest ref_request = ref encoded_request[0];
ref_request = request;
data.CopyTo(encoded_request, sizeof(SmbNegotiateRequest));
DebugLine("Sending NEGOTIATE request");
byte[]! in ExHeap response_encoded = ExecuteSynchronousCommand(encoded_request);
try {
ref SmbHeader header = ref response_encoded[0];
if (header.IsError) {
DebugLine("Received NEGOTIATE RESPONSE - server indicates FAILURE");
DebugLine("Error: " + header.GetErrorText());
throw new Exception("SMB server rejected NEGOTIATE: " + header.GetErrorText());
}
if (TraceSwitches.ShowNegotiation) {
DebugLine("Received NEGOTIATE RESPONSE - successful");
}
if (header.ParameterCount != 17) {
DebugLine("NEGOTIATE response contains the wrong number of parameter words! Cannot use!");
throw new Exception("NEGOTIATE response contains the wrong number of parameter words");
}
ref SmbNegotiateResponse17 response = ref response_encoded[0];
//DebugLine("EncryptionKeyLength = " + response.EncryptionKeyLength.ToString());
byte[]! response_data = new byte[response.ByteCount];
Bitter.ToByteArray(response_encoded, sizeof(SmbNegotiateResponse17), response.ByteCount, response_data, 0);
ByteReader! response_data_reader = new ByteReader(response_data);
byte[]! key = response_data_reader.ReadBytes(response.EncryptionKeyLength);
this._serverLmChallenge = key;
string! serverDomainName = ReadStringUnicode(response_data_reader);
string! serverHostName = ReadStringUnicode(response_data_reader);
// DebugLine("Server Domain Name = " + serverDomainName);
// DebugLine("Server Host Name = " + serverHostName);
_ReceivedServerDomainNameFromNegotiate = serverDomainName;
_ReceivedServerMachineName = serverHostName;
}
finally {
delete response_encoded;
}
}
static string! ReadStringUnicode(ByteReader! reader)
{
StringBuilder buffer = new StringBuilder();
for (;;) {
byte low = reader.ReadByte();
byte high = reader.ReadByte();
if (low == 0 && high == 0)
return buffer.ToString();
char c = (char)(low + (((ushort)high) << 8));
buffer.Append(c);
}
}
// This field contains the LanMan (LM) challenge, received from the server.
// We use this value to compute the challenge response, which is what the client
// uses to prove knowledge of the user's password without revealing the password
// in the clear.
byte[] _serverLmChallenge;
#if false
void SendSessionSetupAndConnect(SmbTransactor.Imp! transactor, byte[]! security_blob)
requires security_blob.Length <= ushort.MaxValue;
{
// build header
// don't bother with setting tuple in header, mux will set that for us
SmbSessionSetupAndXRequest13 request = new SmbSessionSetupAndXRequest13();
request.Header.Command = (byte)SmbCommand.SessionSetupAndX;
request.Header.Flags1 = (byte)_flags1;
request.Header.Flags2 = (ushort)_flags2;
// build parameters block
request.Header.ParameterCount = 13;
request.AndXCommand = 0xff;
request.AndXPadding = 0;
request.AndXOffset = 0;
request.MaxBufferSize = 2048;
request.MaxMpxCount = 10;
request.VcNumber = 1;
request.SessionKey = 0;
request.CaseInsensitivePasswordLength = (ushort)lm_response.Length;
request.CaseSensitivePasswordLength = (ushort)nt_response.Length;
request.Reserved = 0;
SmbCapability capabilities =
SmbCapability.Unicode
| SmbCapability.LargeFiles
| SmbCapability.NtSmbs
| SmbCapability.NtFind
| SmbCapability.NtStatus
| SmbCapability.Level2Oplocks;
request.Capabilities = (uint)capabilities;
// build message data
ByteWriter data = new ByteWriter();
data.Write(security_blob);
WriteSmbUnicodeString(data, SmbClientParameters.Username, true);
WriteSmbUnicodeString(data, SmbClientParameters.DomainName, true);
WriteSmbUnicodeString(data, OSName);
WriteSmbUnicodeString(data, LanManName);
int data_length = data.Length;
request.ByteCount = (ushort)data.Length;
int total_length = sizeof(SmbSessionSetupAndXRequest13)
+ data_length; // security_blob.Length;
byte[]! in ExHeap msg = new[ExHeap] byte[total_length];
try {
ref SmbSessionSetupAndXRequest13 request_ref = ref msg[0];
// store values into the ex buffer
request_ref = request;
data.CopyTo(msg, sizeof(SmbSessionSetupAndXRequest13));
DebugLine("Sending SessionSetupAndX message:");
}
catch {
delete msg;
throw;
}
transactor.SendRequest(msg, msg.Length);
}
#endif
byte[]! GetResponse(NtlmSupplicantContract.Imp! ntlm_supplicant, NtlmResponseType type, byte[]! challenge)
{
byte[]! in ExHeap exchallenge = Bitter.FromByteArray(challenge);
ntlm_supplicant.SendGetResponse(exchallenge, type);
switch receive {
case ntlm_supplicant.Response(exresponse):
byte[]! response = Bitter.ToByteArray(exresponse);
delete exresponse;
return response;
case ntlm_supplicant.RequestFailed(error):
throw new CredentialsManagerException("NTLM supplicant failed to return response.", error);
}
}
// This method contacts the Credentials Manager service.
// Therefore, it CAN block indefinitely, depending on behavior outside of this process.
// Should review this.
void GetChallengeResponses(
out string! username,
out string! domain,
out byte[]! nt_response,
out byte[]! lm_response)
{
// We have already received the NTLM challenge (a simple 8-byte nonce) from the SMB
// server in the response to the NEGOTIATE message.
byte[] challenge = _serverLmChallenge;
if (challenge == null)
throw new Exception("The server LM challenge is null. Failed to sample challenge from negotiation response.");
NtlmSupplicantContract.Imp! ntlm_supplicant;
NtlmSupplicantContract.Exp! ntlm_supplicant_exp;
NtlmSupplicantContract.NewChannel(out ntlm_supplicant, out ntlm_supplicant_exp);
string! credentialsName;
string! tag;
try {
try {
string creds = Program.CredentialsName;
if (creds == null || creds.Length == 0) {
// The user did not provide any explicit credentials to use for this SMB client.
// All the Credentials Manager to select the credentials to use.
if (TraceSwitches.ShowAuthenticationMessages) {
DebugLine("No explicitly-selected credentials provided. Using Credentials Manager to select credentials...");
DebugLine("Creating NTLM supplicant...");
}
//
// -XXX- NOTE! We received two values from the server in the response to the NEGOTIATE message.
// -XXX- We should be careful with those values; since they came from the network, they could
// -XXX- contain any garbage, potentially evil. We pass these to the CM service. So either
// -XXX- the SMB client process and/or the CM service should perform some extreme skepticism
// -XXX- on these values.
//
CredentialsManager.CreateSupplicantForProtocol(
"smb",
(!)_ReceivedServerMachineName, // _ServerHostName,
AuthenticationProtocolNames.Ntlm,
(!)_ReceivedServerDomainNameFromNegotiate,
ntlm_supplicant_exp,
out credentialsName,
out tag);
if (TraceSwitches.ShowAuthenticationMessages)
DebugLine("Created NTLM supplicant, selected credentials: " + credentialsName);
}
else {
// The user provided explicit credentials for this SMB client.
// Use the Credentials Manager to create a supplicant, but don't use it
// to select the credentials to use.
if (TraceSwitches.ShowAuthenticationMessages)
DebugLine("Explicit credentials: " + Program.CredentialsName);
credentialsName = Program.CredentialsName;
tag = Program.CredentialsTag;
CredentialsManager.CreateSupplicant(
AuthenticationProtocolNames.Ntlm,
credentialsName,
tag,
ntlm_supplicant_exp);
if (TraceSwitches.ShowAuthenticationMessages)
DebugLine("Supplicant successfully created.");
}
ntlm_supplicant.RecvSuccess();
_SelectedCredentialsName = credentialsName;
}
catch (Exception ex) {
throw new Exception("Negotiation failed, because an authentication supplicant could not be created.", ex);
}
int separator = credentialsName.IndexOf('\\');
if (separator != -1) {
username = credentialsName.Substring(separator + 1);
domain = credentialsName.Substring(0, separator);
}
else {
username = credentialsName;
domain = ".";
}
lm_response = GetResponse(ntlm_supplicant, NtlmResponseType.LanMan, challenge);
nt_response = GetResponse(ntlm_supplicant, NtlmResponseType.WindowsNt, challenge);
}
finally {
delete ntlm_supplicant;
}
}
void SessionSetupAndConnectBasic()
{
// DebugLine("Using basic NTLM negotiation (not NTLMSSP)");
byte[]! lm_response;
byte[]! nt_response;
string! username;
string! domain;
GetChallengeResponses(
out username,
out domain,
out nt_response,
out lm_response);
// build header
// don't bother with setting tuple in header, mux will set that for us
SmbSessionSetupAndXRequest13 request = new SmbSessionSetupAndXRequest13();
PrepareHeader(ref request.Header, SmbCommand.SessionSetupAndX, 13);
// build parameters block
request.AndXCommand = 0xff;
request.AndXPadding = 0;
request.AndXOffset = 0;
request.MaxBufferSize = 2048;
request.MaxMpxCount = 10;
request.VcNumber = 1;
request.SessionKey = 0;
request.CaseInsensitivePasswordLength = (ushort)lm_response.Length;
request.CaseSensitivePasswordLength = (ushort)nt_response.Length;
request.Reserved = 0;
SmbCapability capabilities =
SmbCapability.Unicode
| SmbCapability.LargeFiles
| SmbCapability.NtSmbs
| SmbCapability.NtFind
| SmbCapability.NtStatus
| SmbCapability.Level2Oplocks;
request.Capabilities = (uint)capabilities;
// build message data
ByteWriter data = new ByteWriter();
// data.Write(security_blob);
data.Write(lm_response);
data.Write(nt_response);
data.Write((byte)0); // alignment padding
WriteSmbStringUnicode(data, username, true);
WriteSmbStringUnicode(data, domain, true);
WriteSmbStringUnicode(data, OSName, true);
WriteSmbStringUnicode(data, LanManName, true);
int data_length = data.Length;
//DebugLine("data block:");
//Util.DumpBuffer(data.ToArray());
request.ByteCount = (ushort)data.Length;
int total_length = sizeof(SmbSessionSetupAndXRequest13)
+ data_length; // security_blob.Length;
request.Header.TotalMessageLength = total_length;
byte[]! in ExHeap request_encoded = new[ExHeap] byte[total_length];
try {
ref SmbSessionSetupAndXRequest13 request_ref = ref request_encoded[0];
// store values into the ex buffer
request_ref = request;
data.CopyTo(request_encoded, sizeof(SmbSessionSetupAndXRequest13));
}
catch {
delete request_encoded;
throw;
}
if (TraceSwitches.ShowNegotiationVerbose)
DebugLine("Sending SESSION SETUP");
byte[]! in ExHeap response_encoded = ExecuteSynchronousCommand(request_encoded);
try {
ref SmbHeader responseHeader = ref response_encoded[0];
if (responseHeader.IsError) {
// The usual reason is that authentication failed (bogus credentials).
// DebugStub.Break();
DebugLine("Received SESSION SETUP response message, and server indicates FAILURE.");
DebugLine("Error: " + responseHeader.GetErrorText());
throw new Exception("The SessionSetupAndTreeConnect message failed. The server rejected the request with an error: " + responseHeader.GetErrorText());
}
if (TraceSwitches.ShowNegotiation)
DebugLine("Received SESSION SETUP response (successful)");
// ref SmbSessionSetupResponse response = ref response_encoded[0];
ExByteReader reader = new ExByteReader(0, response_encoded.Length);
reader.Skip(sizeof(SmbSessionSetupAndXResponse) + 1); // +1 for alignment
string! nativeOs = reader.ReadStringUnicode(response_encoded);
string! nativeLanMan = reader.ReadStringUnicode(response_encoded);
string! primaryDomain = reader.ReadStringUnicode(response_encoded);
_ReceivedServerOperatingSystem = nativeOs;
_ReceivedServerPrimaryDomainName = primaryDomain;
// The response contains a DIFFERENT user ID (in the mux tuple) than the request.
// This is how we learn the user ID, so that we can send it in future requests.
_userId = responseHeader.UserId;
if (TraceSwitches.ShowNegotiationVerbose) {
DebugLine(" Native OS: " + nativeOs);
DebugLine(" Native Lan Man: " + nativeLanMan);
DebugLine(" Primary Domain: " + primaryDomain);
DebugLine(" UserID = 0x{0:x4}", responseHeader.UserId);
}
}
finally {
delete response_encoded;
}
}
static void WriteSmbStringUnicode(ByteWriter! writer, string! text, bool terminate)
{
// writer.Write((byte)SmbEncodingFormat.String);
// writer.Write((byte)0);
for (int i = 0; i < text.Length; i++) {
char c = text[i];
writer.Write((byte)(c & 0xff));
writer.Write((byte)(c >> 8));
}
if (terminate) {
writer.Write((byte)0);
writer.Write((byte)0);
}
}
static void WriteSmbStringAscii(ByteWriter! writer, string! text, bool terminate)
{
// writer.Write((byte)SmbEncodingFormat.String);
for (int i = 0; i < text.Length; i++) {
char c = text[i];
writer.Write((byte)(c & 0xff));
}
if (terminate) {
writer.Write((byte)0);
}
}
byte[]! in ExHeap ExecuteSynchronousCommand([Claims]byte[]! in ExHeap request)
{
SendSmbMessage(request);
return WaitResponse();
}
void SendSmbMessage([Claims]byte[]! in ExHeap request)
// requires _connection != null;
{
if (request.Length < sizeof(SmbHeader))
throw new Exception("Message is too short to be a valid SMB message.");
ref SmbHeader header = ref request[0];
header.SetSignature();
header.TotalMessageLength = request.Length;
SendDataSynchronous(request);
}
void SendDataSynchronous([Claims]byte[]! in ExHeap data)
// requires _connection != null;
{
expose(this)
{
assert _connection != null;
_connection.SendWrite(data);
switch receive {
case _connection.OK():
break;
case _connection.ChannelClosed():
throw new Exception("TCP channel closed");
case _connection.ConnectionClosed():
throw new Exception("TCP connection closed");
}
}
}
enum SmbEncodingFormat
{
DataBlock = 1,
Dialect = 2, // null terminated string, always 8-bit encoding, never unicode
Pathname = 3, // null terminated string
String = 4, // null terminated string
}
void ITracked.Release() {}
void ITracked.Acquire() {}
void ITracked.Expose() {}
void ITracked.UnExpose() {}
public void Dispose()
{
_readyTransactors.Dispose();
delete _namespace_provider;
delete _connection;
delete _notifier;
_control_clients.Dispose();
delete _controller;
}
}
}
Reference in New Issue View Git Blame Copy Permalink