static char *
print(char *buf, size_t *len, char * const args[])
{
static char s[2048];
char src[20], dst[20];
struct in_addr saddr, daddr;
FLOWDESC *x;
time_t ts;
if (buf == NULL && args != NULL) {
*len = sprintf(s, PRETTYHDR);
return s;
}
if (buf == NULL && args == NULL) {
*len = 0;
return s;
}
x = (FLOWDESC *) buf;
ts = (time_t)ntohl(x->ts);
saddr.s_addr = N32(x->src_ip);
daddr.s_addr = N32(x->dst_ip);
sprintf(src, "%s", inet_ntoa(saddr));
sprintf(dst, "%s", inet_ntoa(daddr));
*len = sprintf(s, PRETTYFMT,
asctime(localtime(&ts)), (uint) x->proto,
src, (uint) H16(x->src_port),
dst, (uint) H16(x->dst_port),
NTOHLL(x->bytes), NTOHLL(x->pkts));
return s;
};
/**
Convert the IKE Header from Network order to Host order.
@param[in, out] Header The pointer of the IKE_HEADER.
**/
VOID
IkeHdrNetToHost (
IN OUT IKE_HEADER *Header
)
{
Header->InitiatorCookie = NTOHLL (Header->InitiatorCookie);
Header->ResponderCookie = NTOHLL (Header->ResponderCookie);
Header->MessageId = NTOHL (Header->MessageId);
Header->Length = NTOHL (Header->Length);
}
BOOL
VendorGetLock11(
IN PRAM_DATA RamData,
IN PLANSCSI_VENDOR_REQUEST_PDU_HEADER RequestHeader,
OUT PLANSCSI_VENDOR_REPLY_PDU_HEADER ReplyHeader
){
UINT64 vendorParam;
UCHAR lockNo;
PGENERAL_PURPOSE_LOCK gpLock;
DWORD dwWaitResult;
vendorParam = NTOHLL(RequestHeader->VendorParameter);
lockNo = (UCHAR)((vendorParam>>32) & 0x3);
gpLock = &RamData->GPLocks[lockNo];
//
// Acquire the mutex for the lock access
//
dwWaitResult = WaitForSingleObject(RamData->LockMutex, INFINITE);
if(dwWaitResult != WAIT_OBJECT_0)
return FALSE;
//
// Set return counter
//
ReplyHeader->VendorParameter = HTONLL((UINT64)gpLock->Counter);
ReleaseMutex(RamData->LockMutex);
return TRUE;
}
BOOL
VendorFreeLock11(
IN PRAM_DATA RamData,
IN UINT64 SessionId,
IN PLANSCSI_VENDOR_REQUEST_PDU_HEADER RequestHeader,
OUT PLANSCSI_VENDOR_REPLY_PDU_HEADER ReplyHeader
){
UINT64 vendorParam;
UCHAR lockNo;
PGENERAL_PURPOSE_LOCK gpLock;
LONG acquired;
DWORD dwWaitResult;
vendorParam = NTOHLL(RequestHeader->VendorParameter);
lockNo = (UCHAR)((vendorParam>>32) & 0x3);
gpLock = &RamData->GPLocks[lockNo];
// fprintf(stderr, "VendorSetLock11: freeing lock %d.\n", lockNo);
//
// Acquire the mutex for the lock access
//
dwWaitResult = WaitForSingleObject(RamData->LockMutex, INFINITE);
if(dwWaitResult != WAIT_OBJECT_0)
return FALSE;
//
// Set return counter
//
ReplyHeader->VendorParameter = HTONLL((UINT64)gpLock->Counter);
if(SessionId == gpLock->SessionId) {
if(gpLock->Acquired == FALSE) {
fprintf(stderr, "VendorFreeLock11: Already freed\n");
} else {
gpLock->Acquired = FALSE;
// fprintf(stderr, "VendorSetLock11: lock %d freed.\n", lockNo);
}
} else {
//
// Not owner
//
ReleaseMutex(RamData->LockMutex);
fprintf(stderr, "VendorFreeLock11: Not lock owner!\n");
ReplyHeader->Response = LANSCSI_RESPONSE_T_COMMAND_FAILED;
return TRUE;
}
ReleaseMutex(RamData->LockMutex);
return TRUE;
}
int net_if_send_packet_long(int if_id, net_if_eui64_t *target,
const void *payload, size_t payload_len)
{
DEBUG("net_if_send_packet: if_id = %d, target = %016" PRIx64 ", "
"payload = %p, payload_len = %d\n", if_id, NTOHLL(target->uint64), payload,
payload_len);
uint32_t response;
if (if_id < 0 || if_id >= NET_IF_MAX || !interfaces[if_id].initialized) {
DEBUG("Send packet: No interface initialized with ID %d.\n", if_id);
return -1;
}
if (interfaces[if_id].transceivers & (TRANSCEIVER_CC2420 |
TRANSCEIVER_AT86RF231 |
TRANSCEIVER_MC1322X)) {
ieee802154_packet_t p;
memset(&p, 0, sizeof(ieee802154_packet_t));
p.frame.payload = (uint8_t *)payload;
p.frame.payload_len = (uint8_t)payload_len;
p.frame.fcf.src_addr_m = (uint8_t)interfaces[if_id].trans_src_addr_m;
p.frame.fcf.dest_addr_m = IEEE_802154_LONG_ADDR_M;
p.frame.fcf.ack_req = 0;
p.frame.fcf.sec_enb = 0;
p.frame.fcf.frame_type = IEEE_802154_DATA_FRAME;
p.frame.fcf.frame_pend = 0;
p.frame.dest_pan_id = net_if_get_pan_id(if_id);
uint64_t target_h = NTOHLL(target->uint64);
memcpy(p.frame.dest_addr, &target_h, 8);
response = net_if_transceiver_get_set_handler(if_id, SND_PKT, (void *)&p);
}
else {
radio_packet_t p;
memset(&p, 0, sizeof(radio_packet_t));
p.data = (uint8_t *) payload;
p.length = payload_len;
p.dst = NTOHS(target->uint16[3]);
response = net_if_transceiver_get_set_handler(if_id, SND_PKT, (void *)&p);
}
return (response > payload_len) ? (int)payload_len : (int)response;
}
static size_t
load(char * buf, size_t len, timestamp_t * ts)
{
if (len < sizeof(FLOWDESC)) {
ts = 0;
return 0;
}
*ts = NTOHLL(((FLOWDESC *)buf)->ts);
return sizeof(FLOWDESC);
}
static char *
print(__unused void * self, char *buf, size_t *len, char * const args[])
{
static char s[512];
static char * fmt;
FLOWDESC *x;
timestamp_t ts;
time_t t;
char ssid[34];
uint8_t sig, noise;
if (buf == NULL && args != NULL) {
int n;
/* first call of print, process the arguments and return */
for (n = 0; args[n]; n++) {
if (!strcmp(args[n], "format=plain")) {
*len = 0;
fmt = PLAINFMT;
return s;
}
}
/* by default, pretty print */
*len = sprintf(s, PRETTYHDR);
fmt = PRETTYFMT;
return s;
}
if (buf == NULL && args == NULL) {
*len = 0;
return s;
}
x = (FLOWDESC *) buf;
ts = NTOHLL(x->ts);
t = (time_t) TS2SEC(ts);
snprintf(ssid, x->len+1, x->ssid);
sig = (uint8_t)(ntohl(x->signal) / x->samples);
noise = (uint8_t)(ntohl(x->noise) / x->samples);
/* print according to the requested format */
if (fmt == PRETTYFMT) {
char * wepmode = x->wepmode? "Y": "N";
*len = sprintf(s, fmt, asctime(localtime(&t)), (sig-256), (noise-256),
x->channel, x->samples, wepmode, ssid);
} else {
*len = sprintf(s, fmt, (long int) t, x->wepmode,
x->channel, (sig-256), (noise-256), x->samples);
}
return s;
}
int net_if_set_eui64(int if_id, net_if_eui64_t *eui64)
{
if (eui64 == NULL) {
return 0;
}
uint64_t tmp = NTOHLL(eui64->uint64);
if (if_id < 0 || if_id >= NET_IF_MAX || !interfaces[if_id].initialized) {
DEBUG("Set EUI-64: No interface initialized with ID %d.\n", if_id);
return 0;
}
net_if_transceiver_get_set_handler(if_id, SET_LONG_ADDR, (void *) &tmp);
return eui64->uint64 != 0;
}
BOOL
VendorGetLockOwner11(
IN PRAM_DATA RamData,
IN UINT64 SessionId,
IN PLANSCSI_VENDOR_REQUEST_PDU_HEADER RequestHeader,
OUT PLANSCSI_VENDOR_REPLY_PDU_HEADER ReplyHeader
){
UINT64 vendorParam;
UCHAR lockNo;
PGENERAL_PURPOSE_LOCK gpLock;
DWORD dwWaitResult;
vendorParam = NTOHLL(RequestHeader->VendorParameter);
lockNo = (UCHAR)((vendorParam>>32) & 0x3);
gpLock = &RamData->GPLocks[lockNo];
//
// Acquire the mutex for the lock access
//
dwWaitResult = WaitForSingleObject(RamData->LockMutex, INFINITE);
if(dwWaitResult != WAIT_OBJECT_0)
return FALSE;
//
// Set return host mac address if the lock is acquired.
//
if(gpLock->Acquired) {
PUCHAR byteParam;
byteParam = (PUCHAR)&ReplyHeader->VendorParameter;
GetHostMacAddressOfSession(SessionId, byteParam + 2);
} else {
memset( &ReplyHeader->VendorParameter,
0,
sizeof(ReplyHeader->VendorParameter));
}
ReleaseMutex(RamData->LockMutex);
return TRUE;
}
static char *
print(void * self, char *buf, size_t *len, char * const args[])
{
static char s[512];
static char * fmt;
static int granularity = 1;
static int no_records = 0;
static uint64_t bytes = 0;
static uint64_t pkts = 0;
CONFIGDESC * config = CONFIG(self);
FLOWDESC *x;
timestamp_t ts;
time_t t;
int n;
if (buf == NULL && args != NULL) {
/* by default, pretty print */
*len = sprintf(s, PRETTYHDR);
fmt = PRETTYFMT;
/* first call of print, process the arguments and return */
for (n = 0; args[n]; n++) {
if (!strcmp(args[n], "format=plain")) {
*len = 0;
fmt = PLAINFMT;
} else if (!strcmp(args[n], "format=gnuplot")) {
*len = sprintf(s, GNUPLOTHDR);
fmt = GNUPLOTFMT;
} else if (!strncmp(args[n], "granularity=", 10)) {
char * val = index(args[n], '=') + 1;
/* aggregate multiple records into one to reduce
* communication messages.
*/
granularity = MAX(atoi(val) / config->meas_ivl, 1);
} else if (!strcmp(args[n], "format=mbps")) {
*len = 0;
fmt = MBPSFMT;
}
}
return s;
}
if (buf == NULL && args == NULL) {
*len = 0;
if (fmt == GNUPLOTFMT)
*len = sprintf(s, GNUPLOTFOOTER);
return s;
}
x = (FLOWDESC *) buf;
ts = NTOHLL(x->ts);
t = (time_t) TS2SEC(ts);
/* aggregate records if needed */
pkts += ntohl(x->pkts);
bytes += NTOHLL(x->bytes);
no_records++;
if (no_records % granularity != 0) {
*len = 0;
return s;
}
bytes /= granularity;
pkts /= granularity;
/* print according to the requested format */
if (fmt == PRETTYFMT) {
*len = sprintf(s, fmt,
asctime(localtime(&t)), TS2SEC(ts), TS2USEC(ts),
bytes, pkts);
} else if (fmt == GNUPLOTFMT) {
float mbps = 8.0 * (float) bytes / 1000000.0;
*len = sprintf(s, fmt, (long int)t, mbps, pkts);
} else if (fmt == MBPSFMT) {
float mbps = 8.0 * (float) bytes / 1000000.0;
*len = sprintf(s, fmt, mbps);
} else {
*len = sprintf(s, fmt, (long int)t, ts, bytes, pkts);
}
pkts = bytes = 0;
return s;
}
void ng_at86rf2xx_reset(ng_at86rf2xx_t *dev)
{
#if CPUID_ID_LEN
uint8_t cpuid[CPUID_ID_LEN];
eui64_t addr_long;
#endif
/* trigger hardware reset */
gpio_clear(dev->reset_pin);
hwtimer_wait(HWTIMER_TICKS(RESET_DELAY));
gpio_set(dev->reset_pin);
/* reset options and sequence number */
dev->seq_nr = 0;
dev->options = 0;
/* set short and long address */
#if CPUID_ID_LEN
cpuid_get(cpuid);
#if CPUID_ID_LEN < 8
/* in case CPUID_ID_LEN < 8, fill missing bytes with zeros */
for (int i = CPUID_ID_LEN; i < 8; i++) {
cpuid[i] = 0;
}
#else
for (int i = 8; i < CPUID_ID_LEN; i++) {
cpuid[i & 0x07] ^= cpuid[i];
}
#endif
/* make sure we mark the address as non-multicast and not globally unique */
cpuid[0] &= ~(0x01);
cpuid[0] |= 0x02;
/* copy and set long address */
memcpy(&addr_long, cpuid, 8);
ng_at86rf2xx_set_addr_long(dev, NTOHLL(addr_long.uint64.u64));
ng_at86rf2xx_set_addr_short(dev, NTOHS(addr_long.uint16[0].u16));
#else
ng_at86rf2xx_set_addr_long(dev, NG_AT86RF2XX_DEFAULT_ADDR_LONG);
ng_at86rf2xx_set_addr_short(dev, NG_AT86RF2XX_DEFAULT_ADDR_SHORT);
#endif
/* set default PAN id */
ng_at86rf2xx_set_pan(dev, NG_AT86RF2XX_DEFAULT_PANID);
/* set default channel */
ng_at86rf2xx_set_chan(dev, NG_AT86RF2XX_DEFAULT_CHANNEL);
/* set default TX power */
ng_at86rf2xx_set_txpower(dev, NG_AT86RF2XX_DEFAULT_TXPOWER);
/* set default options */
ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_AUTOACK, true);
ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_CSMA, true);
ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_TELL_RX_START, false);
ng_at86rf2xx_set_option(dev, NG_AT86RF2XX_OPT_TELL_RX_END, true);
/* set default protocol */
#ifdef MODULE_NG_SIXLOWPAN
dev->proto = NG_NETTYPE_SIXLOWPAN;
#else
dev->proto = NG_NETTYPE_UNDEF;
#endif
/* enable safe mode (protect RX FIFO until reading data starts) */
ng_at86rf2xx_reg_write(dev, NG_AT86RF2XX_REG__TRX_CTRL_2,
NG_AT86RF2XX_TRX_CTRL_2_MASK__RX_SAFE_MODE);
#ifdef MODULE_NG_AT86RF212B
ng_at86rf2xx_set_freq(dev,NG_AT86RF2XX_FREQ_915MHZ);
#endif
/* don't populate masked interrupt flags to IRQ_STATUS register */
uint8_t tmp = ng_at86rf2xx_reg_read(dev, NG_AT86RF2XX_REG__TRX_CTRL_1);
tmp &= ~(NG_AT86RF2XX_TRX_CTRL_1_MASK__IRQ_MASK_MODE);
ng_at86rf2xx_reg_write(dev, NG_AT86RF2XX_REG__TRX_CTRL_1, tmp);
/* enable interrupts */
ng_at86rf2xx_reg_write(dev, NG_AT86RF2XX_REG__IRQ_MASK,
NG_AT86RF2XX_IRQ_STATUS_MASK__TRX_END);
/* clear interrupt flags */
ng_at86rf2xx_reg_read(dev, NG_AT86RF2XX_REG__IRQ_STATUS);
/* go into RX state */
ng_at86rf2xx_set_state(dev, NG_AT86RF2XX_STATE_RX_AACK_ON);
DEBUG("ng_at86rf2xx_reset(): reset complete.\n");
}
static char *
print(void * self, char *buf, size_t *len, char * const args[])
{
static char s[512];
static char * fmt;
static int granularity = 1;
static int use_bytes = 0;
static int no_records = 0;
static int64_t count[2] = {0, 0};
config_t * cf = CONFIG(self);
FLOWDESC *x;
timestamp_t ts;
time_t t;
int n;
if (buf == NULL && args != NULL) {
/* by default, pretty print */
*len = sprintf(s, PRETTYHDR);
fmt = prettyfmt;
/* first call of print, process the arguments and return */
for (n = 0; args[n]; n++) {
if (!strcmp(args[n], "format=plain")) {
*len = 0;
fmt = plainfmt;
} else if (!strcmp(args[n], "format=gnuplot")) {
fmt = gnuplotfmt;
} else if (!strcmp(args[n], "use-bytes")) {
use_bytes = 1;
} else if (!strncmp(args[n], "granularity=", 10)) {
char * val = index(args[n], '=') + 1;
/* aggregate multiple records into one to reduce
* communication messages.
*/
granularity = MAX(atoi(val) / cf->meas_ivl, 1);
}
}
if (fmt == gnuplotfmt) {
*len = sprintf(s, GNUPLOTHDR, use_bytes? "Mbps" : "packets/sec");
}
return s;
}
if (buf == NULL && args == NULL) {
*len = 0;
if (fmt == gnuplotfmt)
*len = sprintf(s, GNUPLOTFOOTER);
return s;
}
x = (FLOWDESC *) buf;
ts = NTOHLL(x->ts);
t = (time_t) TS2SEC(ts);
/* aggregate records if needed */
count[0] += use_bytes? NTOHLL(x->bytes[0]) : ntohl(x->pkts[0]);
count[1] -= use_bytes? NTOHLL(x->bytes[1]) : ntohl(x->pkts[1]);
no_records++;
if (no_records % granularity != 0) {
*len = 0;
return s;
}
count[0] /= granularity;
count[1] /= granularity;
/* print according to the requested format */
if (fmt == prettyfmt) {
*len = sprintf(s, fmt, asctime(localtime(&t)),
TS2SEC(ts), TS2USEC(ts), count[0], count[1]);
} else if (fmt == gnuplotfmt) {
if (use_bytes) {
float mbps_in = 8.0 * (float) count[0] / 1000000.0;
float mbps_out = 8.0 * (float) count[1] / 1000000.0;
*len = sprintf(s, "%ld %f %f\n", (long int) t, mbps_in, mbps_out);
} else {
*len = sprintf(s, "%ld %u %u\n", (long int) t,
(uint32_t) count[0], (uint32_t) count[1]);
}
} else {
*len = sprintf(s, fmt, (long int)t, ts, count[0], count[1]);
}
count[0] = count[1] = 0;
return s;
}
NTSTATUS
NdasFatSecondaryUserFsCtrl (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for implementing the user's requests made
through NtFsControlFile.
Arguments:
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
ULONG FsControlCode;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB fcb;
PCCB ccb;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
UINT8 *ndfsWinxpRequestData;
LARGE_INTEGER timeOut;
struct FileSystemControl fileSystemControl;
PVOID inputBuffer = NULL;
ULONG inputBufferLength;
PVOID outputBuffer = NULL;
ULONG outputBufferLength;
ULONG bufferLength;
//
// Save some references to make our life a little easier
//
FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
DebugTrace(+1, Dbg,"FatUserFsCtrl...\n", 0);
DebugTrace( 0, Dbg,"FsControlCode = %08lx\n", FsControlCode);
//
// Some of these Fs Controls use METHOD_NEITHER buffering. If the previous mode
// of the caller was userspace and this is a METHOD_NEITHER, we have the choice
// of realy buffering the request through so we can possibly post, or making the
// request synchronous. Since the former was not done by design, do the latter.
//
if (Irp->RequestorMode != KernelMode && (FsControlCode & 3) == METHOD_NEITHER) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
}
//
// Case on the control code.
//
switch ( FsControlCode ) {
case FSCTL_REQUEST_OPLOCK_LEVEL_1:
case FSCTL_REQUEST_OPLOCK_LEVEL_2:
case FSCTL_REQUEST_BATCH_OPLOCK:
case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
case FSCTL_OPBATCH_ACK_CLOSE_PENDING:
case FSCTL_OPLOCK_BREAK_NOTIFY:
case FSCTL_OPLOCK_BREAK_ACK_NO_2:
case FSCTL_REQUEST_FILTER_OPLOCK :
//ASSERT( FALSE );
//Status = STATUS_SUCCESS;
//break;
Status = FatOplockRequest( IrpContext, Irp );
return Status;
case FSCTL_LOCK_VOLUME:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatLockVolume( IrpContext, Irp );
break;
case FSCTL_UNLOCK_VOLUME:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatUnlockVolume( IrpContext, Irp );
break;
case FSCTL_DISMOUNT_VOLUME:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatDismountVolume( IrpContext, Irp );
break;
case FSCTL_MARK_VOLUME_DIRTY:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NdasFatSecondaryUserFsCtrl -> %08lx\n", Status) );
return Status;
//Status = FatDirtyVolume( IrpContext, Irp );
break;
case FSCTL_IS_VOLUME_DIRTY:
Status = FatIsVolumeDirty( IrpContext, Irp );
break;
case FSCTL_IS_VOLUME_MOUNTED:
Status = FatIsVolumeMounted( IrpContext, Irp );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_IS_PATHNAME_VALID:
Status = FatIsPathnameValid( IrpContext, Irp );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_QUERY_RETRIEVAL_POINTERS:
Status = FatQueryRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_QUERY_FAT_BPB:
Status = FatQueryBpb( IrpContext, Irp );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_FILESYSTEM_GET_STATISTICS:
Status = FatGetStatistics( IrpContext, Irp );
break;
case FSCTL_GET_VOLUME_BITMAP:
Status = FatGetVolumeBitmap( IrpContext, Irp );
break;
case FSCTL_GET_RETRIEVAL_POINTERS:
Status = FatGetRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_MOVE_FILE:
FatCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = FatMoveFile( IrpContext, Irp );
break;
case FSCTL_ALLOW_EXTENDED_DASD_IO:
Status = FatAllowExtendedDasdIo( IrpContext, Irp );
break;
default :
DebugTrace(0, Dbg, "Invalid control code -> %08lx\n", FsControlCode );
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
ASSERT( !ExIsResourceAcquiredSharedLite(&volDo->Vcb.Resource) );
if (Status != STATUS_SUCCESS) {
DebugTrace2( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
}
inputBuffer = IrpContext->InputBuffer;
outputBuffer = IrpContext->outputBuffer;
ASSERT( IrpSp->Parameters.FileSystemControl.InputBufferLength ? (inputBuffer != NULL) : (inputBuffer == NULL) );
ASSERT( IrpSp->Parameters.FileSystemControl.OutputBufferLength ? (outputBuffer != NULL) : (outputBuffer == NULL) );
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
return FatFsdPostRequest( IrpContext, Irp );
}
try {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->SessionResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg2, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
NDAS_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_DONT_POST_REQUEST );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
ASSERT( IS_SECONDARY_FILEOBJECT(IrpSp->FileObject) );
typeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &vcb, &fcb, &ccb );
if (FlagOn(ccb->NdasFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
ASSERT( FlagOn(ccb->NdasFatFlags, ND_FAT_CCB_FLAG_CORRUPTED) );
try_return( Status = STATUS_FILE_CORRUPT_ERROR );
}
fileSystemControl.FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
fileSystemControl.InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
fileSystemControl.OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
if (inputBuffer == NULL)
fileSystemControl.InputBufferLength = 0;
if (outputBuffer == NULL)
fileSystemControl.OutputBufferLength = 0;
outputBufferLength = fileSystemControl.OutputBufferLength;
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
inputBufferLength = 0;
} else if (fileSystemControl.FsControlCode == FSCTL_MARK_HANDLE) { // 63
inputBufferLength = 0;
} else {
inputBufferLength = fileSystemControl.InputBufferLength;
}
bufferLength = (inputBufferLength >= outputBufferLength) ? inputBufferLength : outputBufferLength;
secondaryRequest = AllocateWinxpSecondaryRequest( volDo->Secondary,
IRP_MJ_FILE_SYSTEM_CONTROL,
bufferLength );
if (secondaryRequest == NULL) {
NDAS_ASSERT( NDAS_ASSERT_INSUFFICIENT_RESOURCES );
Status = Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
try_return( Status );
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader,
NDFS_COMMAND_EXECUTE,
volDo->Secondary,
IRP_MJ_FILE_SYSTEM_CONTROL,
inputBufferLength );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
INITIALIZE_NDFS_WINXP_REQUEST_HEADER( ndfsWinxpRequestHeader, Irp, IrpSp, ccb->PrimaryFileHandle );
ndfsWinxpRequestHeader->FileSystemControl.OutputBufferLength = fileSystemControl.OutputBufferLength;
ndfsWinxpRequestHeader->FileSystemControl.InputBufferLength = fileSystemControl.InputBufferLength;
ndfsWinxpRequestHeader->FileSystemControl.FsControlCode = fileSystemControl.FsControlCode;
#if 0
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
PMOVE_FILE_DATA moveFileData = inputBuffer;
PFILE_OBJECT moveFileObject;
PCCB moveCcb;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
ASSERT( FALSE );
try_return( Status );
}
ObDereferenceObject( moveFileObject );
moveCcb = moveFileObject->FsContext2;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.FileHandle = moveCcb->PrimaryFileHandle;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.StartingVcn = moveFileData->StartingVcn.QuadPart;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.StartingLcn = moveFileData->StartingLcn.QuadPart;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.ClusterCount = moveFileData->ClusterCount;
} else
#endif
if (fileSystemControl.FsControlCode == FSCTL_MARK_HANDLE) { // 63
PMARK_HANDLE_INFO markHandleInfo = inputBuffer;
PFILE_OBJECT volumeFileObject;
PCCB volumeCcb;
Status = ObReferenceObjectByHandle( markHandleInfo->VolumeHandle,
FILE_READ_DATA,
0,
KernelMode,
&volumeFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
try_return( Status );
}
ObDereferenceObject( volumeFileObject );
volumeCcb = volumeFileObject->FsContext2;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.UsnSourceInfo = markHandleInfo->UsnSourceInfo;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.VolumeHandle = volumeCcb->PrimaryFileHandle;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.HandleInfo = markHandleInfo->HandleInfo;
} else {
ndfsWinxpRequestData = (UINT8 *)(ndfsWinxpRequestHeader+1);
if (inputBufferLength)
RtlCopyMemory( ndfsWinxpRequestData, inputBuffer, inputBufferLength );
}
ASSERT( !ExIsResourceAcquiredSharedLite(&IrpContext->Vcb->Resource) );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDASFAT_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
if (Status != STATUS_SUCCESS) {
secondaryRequest = NULL;
try_return( Status = STATUS_IO_DEVICE_ERROR );
}
KeClearEvent( &secondaryRequest->CompleteEvent );
if (secondaryRequest->ExecuteStatus != STATUS_SUCCESS) {
if (IrpContext->OriginatingIrp)
PrintIrp( Dbg2, "secondaryRequest->ExecuteStatus != STATUS_SUCCESS", NULL, IrpContext->OriginatingIrp );
DebugTrace2( 0, Dbg2, ("secondaryRequest->ExecuteStatus != STATUS_SUCCESS file = %s, line = %d\n", __FILE__, __LINE__) );
NDAS_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
SetFlag( IrpContext->NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_DONT_POST_REQUEST );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
Status = Irp->IoStatus.Status = NTOHL(ndfsWinxpReplytHeader->Status4);
Irp->IoStatus.Information = NTOHL(ndfsWinxpReplytHeader->Information32);
if (FsControlCode == FSCTL_GET_NTFS_VOLUME_DATA && Status != STATUS_SUCCESS)
DebugTrace2( 0, Dbg2, ("FSCTL_GET_NTFS_VOLUME_DATA: Status = %x, Irp->IoStatus.Information = %d\n", Status, Irp->IoStatus.Information) );
if (NTOHL(secondaryRequest->NdfsReplyHeader.MessageSize4) - sizeof(NDFS_REPLY_HEADER) - sizeof(NDFS_WINXP_REPLY_HEADER)) {
ASSERT( Irp->IoStatus.Status == STATUS_SUCCESS || Irp->IoStatus.Status == STATUS_BUFFER_OVERFLOW );
ASSERT( Irp->IoStatus.Information );
ASSERT( Irp->IoStatus.Information <= outputBufferLength );
ASSERT( outputBuffer );
RtlCopyMemory( outputBuffer,
(UINT8 *)(ndfsWinxpReplytHeader+1),
Irp->IoStatus.Information );
}
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE && Status != STATUS_SUCCESS)
DebugTrace2( 0, Dbg2, ("NtfsDefragFile: status = %x\n", Status) );
#if 0
if (Status == STATUS_SUCCESS && fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
PMOVE_FILE_DATA moveFileData = inputBuffer;
PFILE_OBJECT moveFileObject;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB moveFcb;
PSCB moveScb;
PCCB moveCcb;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
try_return( Status );
}
ObDereferenceObject( moveFileObject );
typeOfOpen = NtfsDecodeFileObject( IrpContext, moveFileObject, &vcb, &moveFcb, &moveScb, &moveCcb, TRUE );
if (typeOfOpen == UserFileOpen && FlagOn(volDo->NdasFatFlags, ND_FAT_DEVICE_FLAG_DIRECT_RW) && ndfsWinxpReplytHeader->FileInformationSet && NTOHLL(ndfsWinxpReplytHeader->AllocationSize8)) {
PNDFS_FAT_MCB_ENTRY mcbEntry;
ULONG index;
VCN testVcn;
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING );
NtfsAcquireFcbWithPaging( IrpContext, moveFcb, 0 );
NtfsAcquireNtfsMcbMutex( &moveScb->Mcb );
mcbEntry = (PNDFS_FAT_MCB_ENTRY)( ndfsWinxpReplytHeader+1 );
if (moveScb->Header.AllocationSize.QuadPart) {
NtfsRemoveNtfsMcbEntry( &moveScb->Mcb, 0, 0xFFFFFFFF );
}
for (index=0, testVcn=0; index < NTOHL(ndfsWinxpReplytHeader->NumberOfMcbEntry4); index++) {
ASSERT( mcbEntry[index].Vcn == testVcn );
testVcn += (LONGLONG)mcbEntry[index].ClusterCount;
NtfsAddNtfsMcbEntry( &moveScb->Mcb,
mcbEntry[index].Vcn,
(mcbEntry[index].Lcn << vcb->AllocationSupport.LogOfBytesPerSector),
(LONGLONG)mcbEntry[index].ClusterCount,
TRUE );
}
ASSERT( LlBytesFromClusters(vcb, testVcn) == NTOHLL(ndfsWinxpReplytHeader->AllocationSize8) );
if (moveScb->Header.AllocationSize.QuadPart != NTOHLL(ndfsWinxpReplytHeader->AllocationSize8))
SetFlag( moveScb->ScbState, SCB_STATE_TRUNCATE_ON_CLOSE );
moveScb->Header.FileSize.LowPart = NTOHLL(ndfsWinxpReplytHeader->FileSize8);
moveScb->Header.AllocationSize.QuadPart = NTOHLL(ndfsWinxpReplytHeader->AllocationSize8);
ASSERT( moveScb->Header.AllocationSize.QuadPart >= moveScb->Header.FileSize.LowPart );
if (moveFileObject->SectionObjectPointer->DataSectionObject != NULL && moveFileObject->PrivateCacheMap == NULL) {
CcInitializeCacheMap( moveFileObject,
(PCC_FILE_SIZES)&moveScb->Header.AllocationSize,
FALSE,
&NtfsData.CacheManagerCallbacks,
moveScb );
//CcSetAdditionalCacheAttributes( fileObject, TRUE, TRUE );
}
if (CcIsFileCached(moveFileObject)) {
NtfsSetBothCacheSizes( moveFileObject,
(PCC_FILE_SIZES)&scb->Header.AllocationSize,
moveScb );
}
NtfsReleaseNtfsMcbMutex( &moveScb->Mcb );
NtfsReleaseFcb( IrpContext, moveFcb );
}
}
#endif
try_exit: NOTHING;
} finally {
if (secondarySessionResourceAcquired == TRUE) {
SecondaryReleaseResourceLite( IrpContext, &volDo->SessionResource );
}
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
}
FatCompleteRequest( IrpContext, Irp, Status );
DebugTrace(-1, Dbg, "FatUserFsCtrl -> %08lx\n", Status );
return Status;
}
NTSTATUS
DispatchRequest (
IN PPRIMARY_SESSION PrimarySession
)
{
NTSTATUS status;
IN PNDFS_REQUEST_HEADER ndfsRequestHeader;
ASSERT( NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2) < PrimarySession->SessionContext.SessionSlotCount );
RtlCopyMemory( PrimarySession->Thread.SessionSlot[NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2)].RequestMessageBuffer,
&PrimarySession->Thread.NdfsRequestHeader,
sizeof(NDFS_REQUEST_HEADER) );
ndfsRequestHeader
= (PNDFS_REQUEST_HEADER)PrimarySession->Thread.SessionSlot[NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2)].RequestMessageBuffer;
ASSERT (PrimarySession->ReceiveOverlapped.Request[0].IoStatusBlock.Information == sizeof(NDFS_REQUEST_HEADER) );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_NOISE,
("DispatchRequest: PrimarySession = %p, ndfsRequestHeader->Command = %d\n",
PrimarySession, ndfsRequestHeader->Command) );
switch (ndfsRequestHeader->Command) {
case NDFS_COMMAND_NEGOTIATE: {
PNDFS_REQUEST_NEGOTIATE ndfsRequestNegotiate;
PNDFS_REPLY_HEADER ndfsReplyHeader;
PNDFS_REPLY_NEGOTIATE ndfsReplyNegotiate;
if (PrimarySession->Thread.SessionState != SESSION_CLOSE) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) == sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_REQUEST_NEGOTIATE) );
ndfsRequestNegotiate = (PNDFS_REQUEST_NEGOTIATE)(ndfsRequestHeader+1);
status = RecvMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->RecvNdasFcStatistics,
NULL,
(UINT8 *)ndfsRequestNegotiate,
sizeof(NDFS_REQUEST_NEGOTIATE) );
if (status != STATUS_SUCCESS) {
ASSERT( LFS_BUG );
break;
}
PrimarySession->SessionContext.Flags = ndfsRequestNegotiate->Flags;
ndfsReplyHeader = (PNDFS_REPLY_HEADER)(ndfsRequestNegotiate+1);
RtlCopyMemory( ndfsReplyHeader->Protocol, NDFS_PROTOCOL, sizeof(ndfsReplyHeader->Protocol) );
ndfsReplyHeader->Status = NDFS_SUCCESS;
ndfsReplyHeader->Flags = PrimarySession->SessionContext.Flags;
ndfsReplyHeader->Uid2 = 0;
ndfsReplyHeader->Tid2 = 0;
ndfsReplyHeader->Mid2 = 0;
ndfsReplyHeader->MessageSize4 = HTONL((UINT32)(sizeof(NDFS_REPLY_HEADER)+sizeof(NDFS_REPLY_NEGOTIATE)));
ndfsReplyNegotiate = (PNDFS_REPLY_NEGOTIATE)(ndfsReplyHeader+1);
if (NTOHS(ndfsRequestNegotiate->NdfsMajorVersion2) == NDFS_PROTOCOL_MAJOR_3 &&
NTOHS(ndfsRequestNegotiate->NdfsMinorVersion2) == NDFS_PROTOCOL_MINOR_0 &&
NTOHS(ndfsRequestNegotiate->OsMajorType2) == OS_TYPE_WINDOWS &&
NTOHS(ndfsRequestNegotiate->OsMinorType2) == OS_TYPE_WINXP) {
PrimarySession->SessionContext.NdfsMajorVersion = NTOHS(ndfsRequestNegotiate->NdfsMajorVersion2);
PrimarySession->SessionContext.NdfsMinorVersion = NTOHS(ndfsRequestNegotiate->NdfsMinorVersion2);
ndfsReplyNegotiate->Status = NDFS_NEGOTIATE_SUCCESS;
ndfsReplyNegotiate->NdfsMajorVersion2 = HTONS(PrimarySession->SessionContext.NdfsMajorVersion);
ndfsReplyNegotiate->NdfsMinorVersion2 = HTONS(PrimarySession->SessionContext.NdfsMinorVersion);
ndfsReplyNegotiate->OsMajorType2 = HTONS(OS_TYPE_WINDOWS);
ndfsReplyNegotiate->OsMinorType2 = HTONS(OS_TYPE_WINXP);
ndfsReplyNegotiate->SessionKey4 = HTONL(PrimarySession->SessionContext.SessionKey);
ndfsReplyNegotiate->MaxBufferSize4 = HTONL(PrimarySession->SessionContext.PrimaryMaxDataSize);
RtlCopyMemory( ndfsReplyNegotiate->ChallengeBuffer,
&PrimarySession,
sizeof(PPRIMARY_SESSION) );
ndfsReplyNegotiate->ChallengeLength2 = HTONS((UINT16)(sizeof(PPRIMARY_SESSION)));
PrimarySession->Thread.SessionState = SESSION_NEGOTIATE;
} else {
ndfsReplyNegotiate->Status = NDFS_NEGOTIATE_UNSUCCESSFUL;
}
status = SendMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->SendNdasFcStatistics,
NULL,
(UINT8 *)ndfsReplyHeader,
NTOHL(ndfsReplyHeader->MessageSize4) );
if (status != STATUS_SUCCESS) {
break;
}
break;
}
case NDFS_COMMAND_SETUP: {
PNDFS_REQUEST_SETUP ndfsRequestSetup;
PNDFS_REPLY_HEADER ndfsReplyHeader;
PNDFS_REPLY_SETUP ndfsReplySetup;
UINT8 ndfsReplySetupStatus;
unsigned char idData[1];
MD5_CTX context;
UINT8 responseBuffer[16];
if (PrimarySession->Thread.SessionState != SESSION_NEGOTIATE) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) == sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_REQUEST_SETUP) );
ndfsRequestSetup = (PNDFS_REQUEST_SETUP)(ndfsRequestHeader+1);
status = RecvMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->RecvNdasFcStatistics,
NULL,
(UINT8 *)ndfsRequestSetup,
sizeof(NDFS_REQUEST_SETUP) );
if (status != STATUS_SUCCESS) {
ASSERT( LFS_BUG );
break;
}
do {
ASSERT( PrimarySession->NetdiskPartition == NULL );
if (NTOHL(ndfsRequestSetup->SessionKey4) != PrimarySession->SessionContext.SessionKey) {
ndfsReplySetupStatus = NDFS_SETUP_UNSUCCESSFUL;
break;
}
RtlCopyMemory( PrimarySession->NetDiskAddress.Node,
ndfsRequestSetup->NetdiskNode,
6 );
PrimarySession->NetDiskAddress.Port = ndfsRequestSetup->NetdiskPort2;//HTONS(ndfsRequestSetup->NetDiskPort);
PrimarySession->UnitDiskNo = NTOHS(ndfsRequestSetup->UnitDiskNo2);
RtlCopyMemory( PrimarySession->NdscId, ndfsRequestSetup->NdscId, NDSC_ID_LENGTH);
if (PrimarySession->SessionContext.NdfsMinorVersion == NDFS_PROTOCOL_MINOR_0) {
status = NetdiskManager_GetPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
&PrimarySession->NetDiskAddress,
PrimarySession->UnitDiskNo,
PrimarySession->NdscId,
NULL,
PrimarySession->IsLocalAddress,
&PrimarySession->NetdiskPartition,
&PrimarySession->NetdiskPartitionInformation,
&PrimarySession->FileSystemType );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("PRIM:SETUP:MIN1 PrimarySession->NetdiskPartition = %p netDiskPartitionInfo.StartingOffset = %I64x\n",
PrimarySession->NetdiskPartition, PrimarySession->StartingOffset.QuadPart) );
if (status != STATUS_SUCCESS) {
ndfsReplySetupStatus = NDFS_SETUP_UNSUCCESSFUL;
break;
}
} else {
NDAS_BUGON( FALSE );
}
MD5Init( &context );
/* id byte */
idData[0] = (unsigned char)PrimarySession->SessionContext.SessionKey;
MD5Update( &context, idData, 1 );
MD5Update( &context,
PrimarySession->NetdiskPartitionInformation.NetdiskInformation.Password,
8 );
MD5Update( &context, &(UCHAR)PrimarySession, sizeof(PPRIMARY_SESSION) );
MD5Final( responseBuffer, &context );
if (!RtlEqualMemory(ndfsRequestSetup->ResponseBuffer,
responseBuffer,
16)) {
NDAS_BUGON( LFS_BUG );
ndfsReplySetupStatus = NDFS_SETUP_UNSUCCESSFUL;
break;
}
ndfsReplySetupStatus = NDFS_SETUP_SUCCESS;
} while(0);
ndfsReplyHeader = (PNDFS_REPLY_HEADER)(ndfsRequestSetup+1);
RtlCopyMemory( ndfsReplyHeader->Protocol, NDFS_PROTOCOL, sizeof(ndfsReplyHeader->Protocol) );
ndfsReplyHeader->Status = NDFS_SUCCESS;
ndfsReplyHeader->Flags = 0;
ndfsReplyHeader->Uid2 = 0;
ndfsReplyHeader->Tid2 = 0;
ndfsReplyHeader->Mid2 = 0;
ndfsReplyHeader->MessageSize4 = HTONL((UINT32)(sizeof(NDFS_REPLY_HEADER)+sizeof(NDFS_REPLY_SETUP)));
if (ndfsReplySetupStatus == NDFS_SETUP_SUCCESS) {
if (NTOHL(ndfsRequestSetup->MaxBufferSize4)) {
if (PrimarySession->NetdiskPartition->FileSystemType == LFS_FILE_SYSTEM_NDAS_NTFS ||
GlobalLfs.NdasFatRwIndirect == FALSE && PrimarySession->NetdiskPartition->FileSystemType == LFS_FILE_SYSTEM_NDAS_FAT ||
GlobalLfs.NdasNtfsRwIndirect == FALSE && PrimarySession->NetdiskPartition->FileSystemType == LFS_FILE_SYSTEM_NDAS_NTFS) {
PrimarySession->SessionContext.SecondaryMaxDataSize = NTOHL(ndfsRequestSetup->MaxBufferSize4);
} else {
PrimarySession->SessionContext.SecondaryMaxDataSize =
(NTOHL(ndfsRequestSetup->MaxBufferSize4) <= PrimarySession->SessionContext.SecondaryMaxDataSize) ?
NTOHL(ndfsRequestSetup->MaxBufferSize4) : PrimarySession->SessionContext.SecondaryMaxDataSize;
}
//
// Initialize transport context for traffic control
//
InitTransCtx(&PrimarySession->Thread.TransportCtx, PrimarySession->SessionContext.SecondaryMaxDataSize);
}
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("NDFS_COMMAND_SETUP: PrimarySession->NetdiskPartition->FileSystemType = %d "
"ndfsRequestSetup->MaxBufferSize = %x PrimaryMaxDataSize:%x SecondaryMaxDataSize:%x \n",
PrimarySession->NetdiskPartition->FileSystemType, NTOHL(ndfsRequestSetup->MaxBufferSize4),
PrimarySession->SessionContext.PrimaryMaxDataSize,
PrimarySession->SessionContext.SecondaryMaxDataSize) );
ndfsReplyHeader->Uid2 = HTONS(PrimarySession->SessionContext.Uid);
ndfsReplyHeader->Tid2 = HTONS(PrimarySession->SessionContext.Tid);
} else {
if (PrimarySession->NetdiskPartition) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
PrimarySession->NetdiskPartition,
PrimarySession->IsLocalAddress );
PrimarySession->NetdiskPartition = NULL;
}
}
ndfsReplySetup = (PNDFS_REPLY_SETUP)(ndfsReplyHeader+1);
ndfsReplySetup->Status = ndfsReplySetupStatus;
status = SendMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->SendNdasFcStatistics,
NULL,
(UINT8 *)ndfsReplyHeader,
NTOHL(ndfsReplyHeader->MessageSize4) );
if (status != STATUS_SUCCESS) {
break;
}
if (ndfsReplySetupStatus == NDFS_SETUP_SUCCESS)
PrimarySession->Thread.SessionState = SESSION_SETUP;
break;
}
case NDFS_COMMAND_TREE_CONNECT:{
PNDFS_REQUEST_TREE_CONNECT ndfsRequestTreeConnect;
PNDFS_REPLY_HEADER ndfsReplyHeader;
PNDFS_REPLY_TREE_CONNECT ndfsReplyTreeConnect;
UINT8 ndfsReplyTreeConnectStatus;
if (!(PrimarySession->Thread.SessionState == SESSION_SETUP && \
NTOHS(ndfsRequestHeader->Uid2) == PrimarySession->SessionContext.Uid)) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) == sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_REQUEST_TREE_CONNECT) );
ndfsRequestTreeConnect = (PNDFS_REQUEST_TREE_CONNECT)(ndfsRequestHeader+1);
status = RecvMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->RecvNdasFcStatistics,
NULL,
(UINT8 *)ndfsRequestTreeConnect,
sizeof(NDFS_REQUEST_TREE_CONNECT) );
if (status != STATUS_SUCCESS) {
ASSERT( LFS_BUG );
break;
}
do {
NTSTATUS getVolumeInformationStatus;
PNETDISK_PARTITION netdiskPartition;
ndfsReplyHeader = (PNDFS_REPLY_HEADER)(ndfsRequestTreeConnect+1);
RtlCopyMemory( ndfsReplyHeader->Protocol, NDFS_PROTOCOL, sizeof(ndfsReplyHeader->Protocol) );
ndfsReplyHeader->Status = NDFS_SUCCESS;
ndfsReplyHeader->Flags = 0;
ndfsReplyHeader->Uid2 = HTONS(PrimarySession->SessionContext.Uid);
ndfsReplyHeader->Tid2 = 0;
ndfsReplyHeader->Mid2 = 0;
ndfsReplyHeader->MessageSize4 = HTONL((UINT32)(sizeof(NDFS_REPLY_HEADER)+sizeof(NDFS_REPLY_TREE_CONNECT)));
PrimarySession->StartingOffset.QuadPart = NTOHLL(ndfsRequestTreeConnect->StartingOffset8);
status = NetdiskManager_GetPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
&PrimarySession->NetDiskAddress,
PrimarySession->UnitDiskNo,
PrimarySession->NdscId,
&PrimarySession->StartingOffset,
PrimarySession->IsLocalAddress,
&netdiskPartition,
&PrimarySession->NetdiskPartitionInformation,
&PrimarySession->FileSystemType );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE,
("PRIM:TREE_CONNECT: netdiskPartition = %p netDiskPartitionInfo.StartingOffset = %I64x\n",
netdiskPartition, PrimarySession->StartingOffset.QuadPart) );
if (status != STATUS_SUCCESS) {
if (status == STATUS_UNRECOGNIZED_VOLUME) {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE,
("PRIM:TREE_CONNECT: Partition is not available\n") );
ndfsReplyTreeConnectStatus = NDFS_TREE_CONNECT_NO_PARTITION;
} else {
ndfsReplyTreeConnectStatus = NDFS_TREE_CONNECT_UNSUCCESSFUL;
}
break;
}
if (FlagOn(netdiskPartition->Flags, NETDISK_PARTITION_FLAG_MOUNT_CORRUPTED)) {
ndfsReplyTreeConnectStatus = NDFS_TREE_CORRUPTED;
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
netdiskPartition,
PrimarySession->IsLocalAddress );
break;
}
if (netdiskPartition->FileSystemType == LFS_FILE_SYSTEM_NTFS && IS_WINDOWSXP_OR_LATER()) {
getVolumeInformationStatus =
GetVolumeInformation( PrimarySession,
&netdiskPartition->NetdiskPartitionInformation.VolumeName );
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_TRACE,
("PRIM:TREE_CONNECT: getVolumeInformationStatus = %x\n",
getVolumeInformationStatus) );
if (getVolumeInformationStatus != STATUS_SUCCESS) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
netdiskPartition,
PrimarySession->IsLocalAddress );
ndfsReplyTreeConnectStatus = NDFS_TREE_CONNECT_UNSUCCESSFUL;
break;
}
}
if (PrimarySession->NetdiskPartition) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
PrimarySession->NetdiskPartition,
PrimarySession->IsLocalAddress );
PrimarySession->NetdiskPartition = NULL;
} else {
NDAS_BUGON( FALSE );
}
PrimarySession->NetdiskPartition = netdiskPartition;
PrimarySession->SessionContext.Tid = PrimarySession->NetdiskPartition->Tid;
ndfsReplyHeader->Tid2 = HTONS(PrimarySession->SessionContext.Tid);
ndfsReplyTreeConnectStatus = NDFS_TREE_CONNECT_SUCCESS;
} while(0);
ndfsReplyTreeConnect = (PNDFS_REPLY_TREE_CONNECT)(ndfsReplyHeader+1);
ndfsReplyTreeConnect->Status = ndfsReplyTreeConnectStatus;
ndfsReplyTreeConnect->SessionSlotCount = SESSION_SLOT_COUNT;
ndfsReplyTreeConnect->BytesPerFileRecordSegment4 = HTONL(PrimarySession->Thread.BytesPerFileRecordSegment);
ndfsReplyTreeConnect->BytesPerSector4 = HTONL(PrimarySession->Thread.BytesPerSector);
ndfsReplyTreeConnect->BytesPerCluster4 = HTONL(PrimarySession->Thread.BytesPerCluster);
status = SendMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->SendNdasFcStatistics,
NULL,
(UINT8 *)ndfsReplyHeader,
NTOHL(ndfsReplyHeader->MessageSize4) );
if (status != STATUS_SUCCESS) {
break;
}
if (ndfsReplyTreeConnectStatus == NDFS_TREE_CONNECT_SUCCESS) {
status = PrimarySessionTakeOver( PrimarySession );
if (status == STATUS_INVALID_DEVICE_REQUEST) {
PrimarySession->Thread.SessionState = SESSION_TREE_CONNECT;
} else {
SPY_LOG_PRINT( LFS_DEBUG_PRIMARY_INFO,
("PrimarySessionTakeOver: Success PrimarySession = %p status = %x\n",
PrimarySession, status) );
if (PrimarySession->NetdiskPartition) {
NetdiskManager_ReturnPrimaryPartition( GlobalLfs.NetdiskManager,
PrimarySession,
PrimarySession->NetdiskPartition,
PrimarySession->IsLocalAddress );
PrimarySession->NetdiskPartition = NULL;
}
if (status == STATUS_SUCCESS) {
PrimarySession->ConnectionFileHandle = NULL;
PrimarySession->ConnectionFileObject = NULL;
} else {
DisconnectFromSecondary( PrimarySession );
}
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_DISCONNECTED );
PrimarySession->Thread.SessionState = SESSION_CLOSED;
}
}
status = STATUS_SUCCESS;
break;
}
case NDFS_COMMAND_LOGOFF: {
PNDFS_REQUEST_LOGOFF ndfsRequestLogoff;
PNDFS_REPLY_HEADER ndfsReplyHeader;
PNDFS_REPLY_LOGOFF ndfsReplyLogoff;
if(PrimarySession->SessionContext.NdfsMinorVersion == NDFS_PROTOCOL_MINOR_0) {
if(PrimarySession->Thread.SessionState != SESSION_TREE_CONNECT) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
}
if (!(NTOHS(ndfsRequestHeader->Uid2) == PrimarySession->SessionContext.Uid &&
NTOHS(ndfsRequestHeader->Tid2) == PrimarySession->SessionContext.Tid)) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) == sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_REQUEST_LOGOFF) );
ndfsRequestLogoff = (PNDFS_REQUEST_LOGOFF)(ndfsRequestHeader+1);
status = RecvMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->RecvNdasFcStatistics,
NULL,
(UINT8 *)ndfsRequestLogoff,
sizeof(NDFS_REQUEST_LOGOFF) );
if (status != STATUS_SUCCESS) {
//ASSERT( LFS_BUG );
break;
}
ndfsReplyHeader = (PNDFS_REPLY_HEADER)(ndfsRequestLogoff+1);
RtlCopyMemory( ndfsReplyHeader->Protocol, NDFS_PROTOCOL, sizeof(ndfsReplyHeader->Protocol) );
ndfsReplyHeader->Status = NDFS_SUCCESS;
ndfsReplyHeader->Flags = 0;
ndfsReplyHeader->Uid2 = HTONS(PrimarySession->SessionContext.Uid);
ndfsReplyHeader->Tid2 = 0;
ndfsReplyHeader->Mid2 = 0;
ndfsReplyHeader->MessageSize4 = HTONL((UINT32)(sizeof(NDFS_REPLY_HEADER)+sizeof(NDFS_REPLY_LOGOFF)));
ndfsReplyLogoff = (PNDFS_REPLY_LOGOFF)(ndfsReplyHeader+1);
if (NTOHL(ndfsRequestLogoff->SessionKey4) != PrimarySession->SessionContext.SessionKey) {
ndfsReplyLogoff->Status = NDFS_LOGOFF_UNSUCCESSFUL;
} else {
ndfsReplyLogoff->Status = NDFS_LOGOFF_SUCCESS;
}
status = SendMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->SendNdasFcStatistics,
NULL,
(UINT8 *)ndfsReplyHeader,
NTOHL(ndfsReplyHeader->MessageSize4) );
if (status != STATUS_SUCCESS) {
break;
}
PrimarySession->Thread.SessionState = SESSION_CLOSED;
break;
}
case NDFS_COMMAND_EXECUTE: {
UINT16 mid;
if(PrimarySession->SessionContext.NdfsMinorVersion == NDFS_PROTOCOL_MINOR_0) {
if (PrimarySession->Thread.SessionState != SESSION_TREE_CONNECT) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
}
if (!(NTOHS(ndfsRequestHeader->Uid2) == PrimarySession->SessionContext.Uid &&
NTOHS(ndfsRequestHeader->Tid2) == PrimarySession->SessionContext.Tid)) {
ASSERT( LFS_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
mid = NTOHS(ndfsRequestHeader->Mid2);
PrimarySession->Thread.SessionSlot[mid].RequestMessageBufferLength = sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_WINXP_REQUEST_HEADER) + DEFAULT_MAX_DATA_SIZE;
RtlZeroMemory( &PrimarySession->Thread.SessionSlot[mid].RequestMessageBuffer[sizeof(NDFS_REQUEST_HEADER)],
PrimarySession->Thread.SessionSlot[mid].RequestMessageBufferLength - sizeof(NDFS_REQUEST_HEADER) );
PrimarySession->Thread.SessionSlot[mid].ReplyMessageBufferLength = sizeof(NDFS_REPLY_HEADER) + sizeof(NDFS_WINXP_REPLY_HEADER) + DEFAULT_MAX_DATA_SIZE;
RtlZeroMemory( PrimarySession->Thread.SessionSlot[mid].ReplyMessageBuffer,
PrimarySession->Thread.SessionSlot[mid].ReplyMessageBufferLength );
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) >= sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_WINXP_REQUEST_HEADER) );
status = ReceiveNtfsWinxpMessage(PrimarySession, mid );
if (status != STATUS_SUCCESS)
break;
if (PrimarySession->Thread.SessionSlot[mid].State != SLOT_WAIT) {
break;
}
PrimarySession->Thread.SessionSlot[mid].State = SLOT_EXECUTING;
PrimarySession->Thread.IdleSlotCount --;
if (PrimarySession->SessionContext.SessionSlotCount == 1) {
ASSERT( mid == 0 );
DispatchWinXpRequestWorker( PrimarySession, mid );
PrimarySession->Thread.SessionSlot[mid].State = SLOT_WAIT;
PrimarySession->Thread.IdleSlotCount ++;
if (PrimarySession->Thread.SessionSlot[mid].Status == STATUS_SUCCESS) {
PNDFS_REPLY_HEADER ndfsReplyHeader;
ndfsReplyHeader = (PNDFS_REPLY_HEADER)PrimarySession->Thread.SessionSlot[mid].ReplyMessageBuffer;
PrimarySession->Thread.SessionSlot[mid].Status =
SendNdfsWinxpMessage( PrimarySession,
ndfsReplyHeader,
PrimarySession->Thread.SessionSlot[mid].NdfsWinxpReplyHeader,
PrimarySession->Thread.SessionSlot[mid].ReplyDataSize,
mid );
}
if (PrimarySession->Thread.SessionSlot[mid].ExtendWinxpRequestMessagePool) {
ExFreePool( PrimarySession->Thread.SessionSlot[mid].ExtendWinxpRequestMessagePool );
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpRequestMessagePool = NULL;
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePoolLength = 0;
}
if (PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePool) {
ExFreePool( PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePool );
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePool = NULL;
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePoolLength = 0;
}
if (PrimarySession->Thread.SessionSlot[mid].Status == STATUS_PENDING)
NDAS_BUGON( FALSE );
if (PrimarySession->Thread.SessionSlot[mid].Status != STATUS_SUCCESS) {
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
status = PrimarySession->Thread.SessionSlot[mid].Status;
break;
}
status = STATUS_SUCCESS;
break;
}
NDAS_BUGON( FALSE );
if (mid == 0)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker0,
PrimarySession );
if (mid == 1)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker1,
PrimarySession );
if (mid == 2)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker2,
PrimarySession );
if (mid == 3)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker3,
PrimarySession );
ExQueueWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem, DelayedWorkQueue );
status = STATUS_PENDING;
break;
}
default:
ASSERT( LFS_LPX_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
return status;
}
void at86rf2xx_reset(at86rf2xx_t *dev)
{
eui64_t addr_long;
at86rf2xx_hardware_reset(dev);
/* Reset state machine to ensure a known state */
at86rf2xx_reset_state_machine(dev);
/* reset options and sequence number */
dev->netdev.seq = 0;
dev->netdev.flags = 0;
/* get an 8-byte unique ID to use as hardware address */
luid_get(addr_long.uint8, IEEE802154_LONG_ADDRESS_LEN);
/* make sure we mark the address as non-multicast and not globally unique */
addr_long.uint8[0] &= ~(0x01);
addr_long.uint8[0] |= (0x02);
/* set short and long address */
at86rf2xx_set_addr_long(dev, NTOHLL(addr_long.uint64.u64));
at86rf2xx_set_addr_short(dev, NTOHS(addr_long.uint16[0].u16));
/* set default PAN id */
at86rf2xx_set_pan(dev, AT86RF2XX_DEFAULT_PANID);
/* set default channel */
at86rf2xx_set_chan(dev, AT86RF2XX_DEFAULT_CHANNEL);
/* set default TX power */
at86rf2xx_set_txpower(dev, AT86RF2XX_DEFAULT_TXPOWER);
/* set default options */
at86rf2xx_set_option(dev, AT86RF2XX_OPT_AUTOACK, true);
at86rf2xx_set_option(dev, AT86RF2XX_OPT_CSMA, true);
at86rf2xx_set_option(dev, AT86RF2XX_OPT_TELL_RX_START, false);
at86rf2xx_set_option(dev, AT86RF2XX_OPT_TELL_RX_END, true);
#ifdef MODULE_NETSTATS_L2
at86rf2xx_set_option(dev, AT86RF2XX_OPT_TELL_TX_END, true);
#endif
/* set default protocol */
#ifdef MODULE_GNRC_SIXLOWPAN
dev->netdev.proto = GNRC_NETTYPE_SIXLOWPAN;
#elif MODULE_GNRC
dev->netdev.proto = GNRC_NETTYPE_UNDEF;
#endif
/* enable safe mode (protect RX FIFO until reading data starts) */
at86rf2xx_reg_write(dev, AT86RF2XX_REG__TRX_CTRL_2,
AT86RF2XX_TRX_CTRL_2_MASK__RX_SAFE_MODE);
#ifdef MODULE_AT86RF212B
at86rf2xx_set_page(dev, 0);
#endif
/* don't populate masked interrupt flags to IRQ_STATUS register */
uint8_t tmp = at86rf2xx_reg_read(dev, AT86RF2XX_REG__TRX_CTRL_1);
tmp &= ~(AT86RF2XX_TRX_CTRL_1_MASK__IRQ_MASK_MODE);
at86rf2xx_reg_write(dev, AT86RF2XX_REG__TRX_CTRL_1, tmp);
/* disable clock output to save power */
tmp = at86rf2xx_reg_read(dev, AT86RF2XX_REG__TRX_CTRL_0);
tmp &= ~(AT86RF2XX_TRX_CTRL_0_MASK__CLKM_CTRL);
tmp &= ~(AT86RF2XX_TRX_CTRL_0_MASK__CLKM_SHA_SEL);
tmp |= (AT86RF2XX_TRX_CTRL_0_CLKM_CTRL__OFF);
at86rf2xx_reg_write(dev, AT86RF2XX_REG__TRX_CTRL_0, tmp);
/* enable interrupts */
at86rf2xx_reg_write(dev, AT86RF2XX_REG__IRQ_MASK,
AT86RF2XX_IRQ_STATUS_MASK__TRX_END);
/* clear interrupt flags */
at86rf2xx_reg_read(dev, AT86RF2XX_REG__IRQ_STATUS);
/* go into RX state */
at86rf2xx_set_state(dev, AT86RF2XX_STATE_RX_AACK_ON);
DEBUG("at86rf2xx_reset(): reset complete.\n");
}
void at86rf2xx_reset(at86rf2xx_t *dev)
{
#if CPUID_LEN
uint8_t cpuid[CPUID_LEN];
eui64_t addr_long;
#endif
at86rf2xx_hardware_reset(dev);
/* Reset state machine to ensure a known state */
at86rf2xx_reset_state_machine(dev);
/* reset options and sequence number */
dev->seq_nr = 0;
dev->options = 0;
/* set short and long address */
#if CPUID_LEN
cpuid_get(cpuid);
#if CPUID_LEN < 8
/* in case CPUID_LEN < 8, fill missing bytes with zeros */
for (int i = CPUID_LEN; i < 8; i++) {
cpuid[i] = 0;
}
#else
for (int i = 8; i < CPUID_LEN; i++) {
cpuid[i & 0x07] ^= cpuid[i];
}
#endif
/* make sure we mark the address as non-multicast and not globally unique */
cpuid[0] &= ~(0x01);
cpuid[0] |= 0x02;
/* copy and set long address */
memcpy(&addr_long, cpuid, 8);
at86rf2xx_set_addr_long(dev, NTOHLL(addr_long.uint64.u64));
at86rf2xx_set_addr_short(dev, NTOHS(addr_long.uint16[0].u16));
#else
at86rf2xx_set_addr_long(dev, AT86RF2XX_DEFAULT_ADDR_LONG);
at86rf2xx_set_addr_short(dev, AT86RF2XX_DEFAULT_ADDR_SHORT);
#endif
/* set default PAN id */
at86rf2xx_set_pan(dev, AT86RF2XX_DEFAULT_PANID);
/* set default channel */
at86rf2xx_set_chan(dev, AT86RF2XX_DEFAULT_CHANNEL);
/* set default TX power */
at86rf2xx_set_txpower(dev, AT86RF2XX_DEFAULT_TXPOWER);
/* set default options */
at86rf2xx_set_option(dev, AT86RF2XX_OPT_AUTOACK, true);
at86rf2xx_set_option(dev, AT86RF2XX_OPT_CSMA, true);
at86rf2xx_set_option(dev, AT86RF2XX_OPT_TELL_RX_START, false);
at86rf2xx_set_option(dev, AT86RF2XX_OPT_TELL_RX_END, true);
/* set default protocol */
#ifdef MODULE_GNRC_SIXLOWPAN
dev->proto = GNRC_NETTYPE_SIXLOWPAN;
#else
dev->proto = GNRC_NETTYPE_UNDEF;
#endif
/* enable safe mode (protect RX FIFO until reading data starts) */
at86rf2xx_reg_write(dev, AT86RF2XX_REG__TRX_CTRL_2,
AT86RF2XX_TRX_CTRL_2_MASK__RX_SAFE_MODE);
#ifdef MODULE_AT86RF212B
at86rf2xx_set_page(dev, 0);
#endif
/* don't populate masked interrupt flags to IRQ_STATUS register */
uint8_t tmp = at86rf2xx_reg_read(dev, AT86RF2XX_REG__TRX_CTRL_1);
tmp &= ~(AT86RF2XX_TRX_CTRL_1_MASK__IRQ_MASK_MODE);
at86rf2xx_reg_write(dev, AT86RF2XX_REG__TRX_CTRL_1, tmp);
/* disable clock output to save power */
tmp = at86rf2xx_reg_read(dev, AT86RF2XX_REG__TRX_CTRL_0);
tmp &= ~(AT86RF2XX_TRX_CTRL_0_MASK__CLKM_CTRL);
tmp &= ~(AT86RF2XX_TRX_CTRL_0_MASK__CLKM_SHA_SEL);
tmp |= (AT86RF2XX_TRX_CTRL_0_CLKM_CTRL__OFF);
at86rf2xx_reg_write(dev, AT86RF2XX_REG__TRX_CTRL_0, tmp);
/* enable interrupts */
at86rf2xx_reg_write(dev, AT86RF2XX_REG__IRQ_MASK,
AT86RF2XX_IRQ_STATUS_MASK__TRX_END);
/* clear interrupt flags */
at86rf2xx_reg_read(dev, AT86RF2XX_REG__IRQ_STATUS);
/* go into RX state */
at86rf2xx_set_state(dev, AT86RF2XX_STATE_RX_AACK_ON);
DEBUG("at86rf2xx_reset(): reset complete.\n");
}
static NTSTATUS
NdasNtfsSecondaryUserFsRequest (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG FsControlCode;
ULONG FsControlCodeFunction;
PIO_STACK_LOCATION IrpSp;
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB fcb;
PSCB scb;
PCCB ccb;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
UINT8 *ndfsWinxpRequestData;
LARGE_INTEGER timeOut;
struct FileSystemControl fileSystemControl;
PVOID inputBuffer = NULL;
ULONG inputBufferLength;
PVOID outputBuffer = NULL;
ULONG outputBufferLength;
ULONG bufferLength;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
PAGED_CODE();
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
IrpSp = IoGetCurrentIrpStackLocation( Irp );
FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
FsControlCodeFunction = (FsControlCode & 0x00003FFC) >> 2;
DebugTrace( +1, Dbg, ("NtfsUserFsRequest, FsControlCode = %08lx, FsControlCodeFunction = %d\n", FsControlCode, FsControlCodeFunction) );
switch ( FsControlCode ) {
case FSCTL_REQUEST_OPLOCK_LEVEL_1:
case FSCTL_REQUEST_OPLOCK_LEVEL_2:
case FSCTL_REQUEST_BATCH_OPLOCK:
case FSCTL_REQUEST_FILTER_OPLOCK:
case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
case FSCTL_OPLOCK_BREAK_NOTIFY:
case FSCTL_OPBATCH_ACK_CLOSE_PENDING :
case FSCTL_OPLOCK_BREAK_ACK_NO_2:
ASSERT( FALSE );
//Status = NtfsOplockRequest( IrpContext, Irp );
break;
case FSCTL_LOCK_VOLUME:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsLockVolume( IrpContext, Irp );
break;
case FSCTL_UNLOCK_VOLUME:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsUnlockVolume( IrpContext, Irp );
break;
case FSCTL_DISMOUNT_VOLUME: {
#if 0
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
#else
BOOLEAN secondaryCreateResourceAcquired = FALSE;
ASSERT( IS_WINDOWSVISTA_OR_LATER() );
do {
BOOLEAN secondaryRecoveryResourceAcquired;
DebugTrace( 0, Dbg, ("%s: IRP_MN_QUERY_REMOVE_DEVICE volDo = %p, NetdiskEnableMode = %d\n",
__FUNCTION__, volDo, volDo->NetdiskEnableMode) );
secondaryRecoveryResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->RecoveryResource,
FALSE );
if (secondaryRecoveryResourceAcquired == FALSE) {
Status = STATUS_ACCESS_DENIED;
break;
}
SecondaryReleaseResourceLite( IrpContext, &volDo->RecoveryResource );
ExAcquireFastMutex( &volDo->Secondary->FastMutex );
if (!volDo->Secondary->TryCloseActive) {
volDo->Secondary->TryCloseActive = TRUE;
ExReleaseFastMutex( &volDo->Secondary->FastMutex );
Secondary_Reference( volDo->Secondary );
//NtfsDebugTraceLevel |= DEBUG_TRACE_CLOSE;
SecondaryTryClose( &IrpContext, volDo->Secondary );
//NtfsDebugTraceLevel &= ~DEBUG_TRACE_CLOSE;
} else {
ExReleaseFastMutex( &volDo->Secondary->FastMutex );
}
if (volDo->Vcb.SecondaryCloseCount) {
LARGE_INTEGER interval;
// Wait all files closed
interval.QuadPart = (-1 * NANO100_PER_SEC); //delay 1 seconds
KeDelayExecutionThread(KernelMode, FALSE, &interval);
}
CcWaitForCurrentLazyWriterActivity();
secondaryCreateResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->CreateResource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
if (secondaryCreateResourceAcquired == FALSE) {
Status = STATUS_ACCESS_DENIED;
break;
}
if (volDo->Vcb.SecondaryCloseCount) {
LONG ccbCount;
PLIST_ENTRY ccbListEntry;
PVOID restartKey;
PFCB fcb;
ExAcquireFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
for (ccbCount = 0, ccbListEntry = volDo->Secondary->RecoveryCcbQueue.Flink;
ccbListEntry != &volDo->Secondary->RecoveryCcbQueue;
ccbListEntry = ccbListEntry->Flink, ccbCount++);
ExReleaseFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
ASSERT( !IsListEmpty(&volDo->Secondary->RecoveryCcbQueue) );
ASSERT( ccbCount == volDo->Vcb.SecondaryCloseCount );
DebugTrace( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE: Vcb->SecondaryCloseCount = %d, Vcb->SecondaryCleanupCount = %d, Vcb->CloseCount = %d, ccbCount = %d\n",
volDo->Vcb.SecondaryCloseCount, volDo->Vcb.SecondaryCleanupCount, volDo->Vcb.CloseCount, ccbCount) );
restartKey = NULL;
fcb = NdasNtfsGetNextFcbTableEntry( &volDo->Vcb, &restartKey );
ASSERT( fcb != NULL || !IsListEmpty(&volDo->Secondary->DeletedFcbQueue) );
Status = STATUS_ACCESS_DENIED;
break;
} else {
Status = STATUS_SUCCESS;
SetFlag( volDo->Secondary->Flags, SECONDARY_FLAG_DISMOUNTING );
}
} while(0);
if (Status != STATUS_SUCCESS) {
if (secondaryCreateResourceAcquired) {
SecondaryReleaseResourceLite( IrpContext, &volDo->CreateResource );
secondaryCreateResourceAcquired = FALSE;
}
NtfsCompleteRequest( IrpContext, Irp, Status );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
}
Status = NtfsDismountVolume( IrpContext, Irp );
SecondaryReleaseResourceLite( IrpContext, &volDo->CreateResource );
return Status;
#endif
break;
}
case FSCTL_IS_VOLUME_MOUNTED:
Status = NtfsIsVolumeMounted( IrpContext, Irp );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_MARK_VOLUME_DIRTY:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsDirtyVolume( IrpContext, Irp );
break;
case FSCTL_IS_PATHNAME_VALID:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_SUCCESS );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_QUERY_RETRIEVAL_POINTERS:
Status = NtfsQueryRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_GET_COMPRESSION:
//NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
//DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
//return Status;
Status = NtfsGetCompression( IrpContext, Irp );
break;
case FSCTL_SET_COMPRESSION:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
Status = NtfsSetCompression( IrpContext, Irp );
break;
case FSCTL_MARK_AS_SYSTEM_HIVE:
Status = NtfsMarkAsSystemHive( IrpContext, Irp );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_FILESYSTEM_GET_STATISTICS:
Status = NtfsGetStatistics( IrpContext, Irp );
break;
case FSCTL_GET_NTFS_VOLUME_DATA:
Status = NtfsGetVolumeData( IrpContext, Irp );
break;
case FSCTL_GET_VOLUME_BITMAP:
Status = NtfsGetVolumeBitmap( IrpContext, Irp );
break;
case FSCTL_GET_RETRIEVAL_POINTERS:
Status = NtfsGetRetrievalPointers( IrpContext, Irp );
break;
case FSCTL_GET_NTFS_FILE_RECORD:
Status = NtfsGetMftRecord( IrpContext, Irp );
break;
case FSCTL_MOVE_FILE:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
Status = NtfsDefragFile( IrpContext, Irp );
if (Status == STATUS_SUCCESS) {
PMOVE_FILE_DATA moveFileData = IrpContext->InputBuffer;
PFILE_OBJECT moveFileObject;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
break;
}
ObDereferenceObject( moveFileObject );
if (!IS_SECONDARY_FILEOBJECT(moveFileObject)) {
ASSERT( FALSE );
Status = STATUS_INVALID_PARAMETER;
}
}
if (Status != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("NtfsDefragFile: status = %x\n", Status) );
break;
case FSCTL_IS_VOLUME_DIRTY:
Status = NtfsIsVolumeDirty( IrpContext, Irp );
break;
case FSCTL_ALLOW_EXTENDED_DASD_IO:
Status = NtfsSetExtendedDasdIo( IrpContext, Irp );
break;
case FSCTL_SET_REPARSE_POINT:
Status = NtfsSetReparsePoint( IrpContext, Irp );
break;
case FSCTL_GET_REPARSE_POINT:
Status = NtfsGetReparsePoint( IrpContext, Irp );
break;
case FSCTL_DELETE_REPARSE_POINT:
Status = NtfsDeleteReparsePoint( IrpContext, Irp );
break;
case FSCTL_SET_OBJECT_ID:
Status = NtfsSetObjectId( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_GET_OBJECT_ID:
Status = NtfsGetObjectId( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_DELETE_OBJECT_ID:
Status = NtfsDeleteObjectId( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_SET_OBJECT_ID_EXTENDED:
Status = NtfsSetObjectIdExtendedInfo( IrpContext, Irp ); // In ObjIdSup.c
break;
case FSCTL_CREATE_OR_GET_OBJECT_ID:
Status = NtfsCreateOrGetObjectId( IrpContext, Irp );
if (IrpSp->Parameters.FileSystemControl.InputBufferLength)
IrpContext->InputBuffer = Irp->AssociatedIrp.SystemBuffer;
else
IrpContext->InputBuffer = NULL;
break;
case FSCTL_READ_USN_JOURNAL:
Status = NtfsReadUsnJournal( IrpContext, Irp, TRUE ); // In UsnSup.c
break;
case FSCTL_CREATE_USN_JOURNAL:
Status = NtfsCreateUsnJournal( IrpContext, Irp );
break;
case FSCTL_ENUM_USN_DATA:
Status = NtfsReadFileRecordUsnData( IrpContext, Irp );
break;
case FSCTL_READ_FILE_USN_DATA:
Status = NtfsReadFileUsnData( IrpContext, Irp );
break;
case FSCTL_WRITE_USN_CLOSE_RECORD:
Status = NtfsWriteUsnCloseRecord( IrpContext, Irp );
break;
case FSCTL_QUERY_USN_JOURNAL:
Status = NtfsQueryUsnJournal( IrpContext, Irp );
break;
case FSCTL_DELETE_USN_JOURNAL:
Status = NtfsDeleteUsnJournal( IrpContext, Irp );
break;
case FSCTL_MARK_HANDLE:
Status = NtfsMarkHandle( IrpContext, Irp );
if (Status == STATUS_SUCCESS) {
PMARK_HANDLE_INFO markHandleInfo = inputBuffer;
PFILE_OBJECT volumeFileObject;
Status = ObReferenceObjectByHandle( markHandleInfo->VolumeHandle,
FILE_READ_DATA,
0,
KernelMode,
&volumeFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
break;
}
ObDereferenceObject( volumeFileObject );
if (!IS_SECONDARY_FILEOBJECT(volumeFileObject)) {
Status = STATUS_INVALID_PARAMETER;
}
}
break;
case FSCTL_SECURITY_ID_CHECK:
Status = NtfsBulkSecurityIdCheck( IrpContext, Irp );
break;
case FSCTL_FIND_FILES_BY_SID:
Status = NtfsFindFilesOwnedBySid( IrpContext, Irp );
break;
case FSCTL_SET_SPARSE :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsSetSparse( IrpContext, Irp );
break;
case FSCTL_SET_ZERO_DATA :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
Status = NtfsZeroRange( IrpContext, Irp );
break;
case FSCTL_QUERY_ALLOCATED_RANGES :
Status = NtfsQueryAllocatedRanges( IrpContext, Irp );
break;
case FSCTL_ENCRYPTION_FSCTL_IO :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsEncryptionFsctl( IrpContext, Irp );
break;
case FSCTL_SET_ENCRYPTION :
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsSetEncryption( IrpContext, Irp );
break;
case FSCTL_READ_RAW_ENCRYPTED:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsReadRawEncrypted( IrpContext, Irp );
break;
case FSCTL_WRITE_RAW_ENCRYPTED:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsWriteRawEncrypted( IrpContext, Irp );
break;
case FSCTL_EXTEND_VOLUME:
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_ACCESS_DENIED );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
//Status = NtfsExtendVolume( IrpContext, Irp );
break;
case FSCTL_READ_FROM_PLEX:
Status = NtfsReadFromPlex( IrpContext, Irp );
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
break;
case FSCTL_FILE_PREFETCH:
Status = NtfsPrefetchFile( IrpContext, Irp );
break;
default :
DebugTrace( 0, DEBUG_TRACE_ALL, ("NtfsUserFsRequest: Invalid control code FsControlCode = %08lx, FsControlCodeFunction = %d\n",
FsControlCode, FsControlCodeFunction) );
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
break;
}
ASSERT( !ExIsResourceAcquiredSharedLite(&volDo->Vcb.Resource) );
if (Status != STATUS_SUCCESS) {
DebugTrace( -1, Dbg, ("NtfsUserFsRequest -> %08lx\n", Status) );
return Status;
}
if (IrpSp->Parameters.FileSystemControl.InputBufferLength >= volDo->Secondary->Thread.SessionContext.SecondaryMaxDataSize ||
IrpSp->Parameters.FileSystemControl.OutputBufferLength >= volDo->Secondary->Thread.SessionContext.PrimaryMaxDataSize) {
ASSERT( FALSE );
NtfsCompleteRequest( IrpContext, Irp, Status = STATUS_INVALID_DEVICE_REQUEST );
return Status;
}
inputBuffer = IrpContext->InputBuffer;
outputBuffer = IrpContext->outputBuffer;
ASSERT( IrpSp->Parameters.FileSystemControl.InputBufferLength ? (inputBuffer != NULL) : (inputBuffer == NULL) );
ASSERT( IrpSp->Parameters.FileSystemControl.OutputBufferLength ? (outputBuffer != NULL) : (outputBuffer == NULL) );
ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL );
if (!FlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT)) {
return NtfsPostRequest( IrpContext, Irp );
}
try {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->SessionResource,
BooleanFlagOn(IrpContext->State, IRP_CONTEXT_STATE_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg2, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
NtfsRaiseStatus( IrpContext, STATUS_CANT_WAIT, NULL, NULL );
}
ASSERT( IS_SECONDARY_FILEOBJECT(IrpSp->FileObject) );
typeOfOpen = NtfsDecodeFileObject( IrpContext, IrpSp->FileObject, &vcb, &fcb, &scb, &ccb, TRUE );
if (FlagOn(ccb->NdasNtfsFlags, ND_NTFS_CCB_FLAG_UNOPENED)) {
ASSERT( FlagOn(ccb->NdasNtfsFlags, ND_NTFS_CCB_FLAG_CORRUPTED) );
try_return( Status = STATUS_FILE_CORRUPT_ERROR );
}
fileSystemControl.FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
fileSystemControl.InputBufferLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
fileSystemControl.OutputBufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
if (inputBuffer == NULL)
fileSystemControl.InputBufferLength = 0;
if (outputBuffer == NULL)
fileSystemControl.OutputBufferLength = 0;
outputBufferLength = fileSystemControl.OutputBufferLength;
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
inputBufferLength = 0;
} else if(fileSystemControl.FsControlCode == FSCTL_MARK_HANDLE) { // 63
inputBufferLength = 0;
} else {
inputBufferLength = fileSystemControl.InputBufferLength;
}
bufferLength = (inputBufferLength >= outputBufferLength) ? inputBufferLength : outputBufferLength;
secondaryRequest = AllocateWinxpSecondaryRequest( volDo->Secondary,
IRP_MJ_FILE_SYSTEM_CONTROL,
bufferLength );
if (secondaryRequest == NULL) {
Status = Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
try_return( Status );
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader,
NDFS_COMMAND_EXECUTE,
volDo->Secondary,
IRP_MJ_FILE_SYSTEM_CONTROL,
inputBufferLength );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
INITIALIZE_NDFS_WINXP_REQUEST_HEADER( ndfsWinxpRequestHeader, Irp, IrpSp, ccb->PrimaryFileHandle );
ndfsWinxpRequestHeader->FileSystemControl.OutputBufferLength = fileSystemControl.OutputBufferLength;
ndfsWinxpRequestHeader->FileSystemControl.InputBufferLength = fileSystemControl.InputBufferLength;
ndfsWinxpRequestHeader->FileSystemControl.FsControlCode = fileSystemControl.FsControlCode;
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
PMOVE_FILE_DATA moveFileData = inputBuffer;
PFILE_OBJECT moveFileObject;
PCCB moveCcb;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
ASSERT( FALSE );
try_return( Status );
}
ObDereferenceObject( moveFileObject );
moveCcb = moveFileObject->FsContext2;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.FileHandle = moveCcb->PrimaryFileHandle;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.StartingVcn = moveFileData->StartingVcn.QuadPart;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.StartingLcn = moveFileData->StartingLcn.QuadPart;
ndfsWinxpRequestHeader->FileSystemControl.FscMoveFileData.ClusterCount = moveFileData->ClusterCount;
} else if(fileSystemControl.FsControlCode == FSCTL_MARK_HANDLE) { // 63
PMARK_HANDLE_INFO markHandleInfo = inputBuffer;
PFILE_OBJECT volumeFileObject;
PCCB volumeCcb;
Status = ObReferenceObjectByHandle( markHandleInfo->VolumeHandle,
FILE_READ_DATA,
0,
KernelMode,
&volumeFileObject,
NULL );
if (Status != STATUS_SUCCESS) {
try_return( Status );
}
ObDereferenceObject( volumeFileObject );
volumeCcb = volumeFileObject->FsContext2;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.UsnSourceInfo = markHandleInfo->UsnSourceInfo;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.VolumeHandle = volumeCcb->PrimaryFileHandle;
ndfsWinxpRequestHeader->FileSystemControl.FscMarkHandleInfo.HandleInfo = markHandleInfo->HandleInfo;
} else {
ndfsWinxpRequestData = (UINT8 *)(ndfsWinxpRequestHeader+1);
if(inputBufferLength)
RtlCopyMemory( ndfsWinxpRequestData, inputBuffer, inputBufferLength );
}
ASSERT( !ExIsResourceAcquiredSharedLite(&IrpContext->Vcb->Resource) );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDASNTFS_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
if(Status != STATUS_SUCCESS) {
secondaryRequest = NULL;
try_return( Status = STATUS_IO_DEVICE_ERROR );
}
KeClearEvent( &secondaryRequest->CompleteEvent );
if (secondaryRequest->ExecuteStatus != STATUS_SUCCESS) {
if (IrpContext->OriginatingIrp)
PrintIrp( Dbg2, "secondaryRequest->ExecuteStatus != STATUS_SUCCESS", NULL, IrpContext->OriginatingIrp );
DebugTrace( 0, Dbg2, ("secondaryRequest->ExecuteStatus != STATUS_SUCCESS file = %s, line = %d\n", __FILE__, __LINE__) );
NtfsRaiseStatus( IrpContext, STATUS_CANT_WAIT, NULL, NULL );
}
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
Status = Irp->IoStatus.Status = NTOHL(ndfsWinxpReplytHeader->Status4);
Irp->IoStatus.Information = NTOHL(ndfsWinxpReplytHeader->Information32);
if (FsControlCode == FSCTL_GET_NTFS_VOLUME_DATA && Status != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("FSCTL_GET_NTFS_VOLUME_DATA: Status = %x, Irp->IoStatus.Information = %d\n", Status, Irp->IoStatus.Information) );
if (NTOHL(secondaryRequest->NdfsReplyHeader.MessageSize4) - sizeof(NDFS_REPLY_HEADER) - sizeof(NDFS_WINXP_REPLY_HEADER)) {
ASSERT( Irp->IoStatus.Status == STATUS_SUCCESS || Irp->IoStatus.Status == STATUS_BUFFER_OVERFLOW );
ASSERT( Irp->IoStatus.Information );
ASSERT( Irp->IoStatus.Information <= outputBufferLength );
ASSERT( outputBuffer );
RtlCopyMemory( outputBuffer,
(UINT8 *)(ndfsWinxpReplytHeader+1),
Irp->IoStatus.Information );
}
if (fileSystemControl.FsControlCode == FSCTL_MOVE_FILE && Status != STATUS_SUCCESS)
DebugTrace( 0, Dbg2, ("NtfsDefragFile: status = %x\n", Status) );
if (Status == STATUS_SUCCESS && fileSystemControl.FsControlCode == FSCTL_MOVE_FILE) { // 29
PMOVE_FILE_DATA moveFileData = inputBuffer;
PFILE_OBJECT moveFileObject;
TYPE_OF_OPEN typeOfOpen;
PVCB vcb;
PFCB moveFcb;
PSCB moveScb;
PCCB moveCcb;
Status = ObReferenceObjectByHandle( moveFileData->FileHandle,
FILE_READ_DATA,
0,
KernelMode,
&moveFileObject,
NULL );
if(Status != STATUS_SUCCESS) {
try_return( Status );
}
ObDereferenceObject( moveFileObject );
typeOfOpen = NtfsDecodeFileObject( IrpContext, moveFileObject, &vcb, &moveFcb, &moveScb, &moveCcb, TRUE );
if (typeOfOpen == UserFileOpen && ndfsWinxpReplytHeader->FileInformationSet && NTOHLL(ndfsWinxpReplytHeader->AllocationSize8)) {
PNDFS_NTFS_MCB_ENTRY mcbEntry;
ULONG index;
VCN testVcn;
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ACQUIRE_PAGING );
NtfsAcquireFcbWithPaging( IrpContext, moveFcb, 0 );
NtfsAcquireNtfsMcbMutex( &moveScb->Mcb );
mcbEntry = (PNDFS_NTFS_MCB_ENTRY)( ndfsWinxpReplytHeader+1 );
if (moveScb->Header.AllocationSize.QuadPart) {
NtfsRemoveNtfsMcbEntry( &moveScb->Mcb, 0, 0xFFFFFFFF );
}
for (index=0, testVcn=0; index < NTOHL(ndfsWinxpReplytHeader->NumberOfMcbEntry4); index++) {
ASSERT( mcbEntry[index].Vcn == testVcn );
testVcn += (LONGLONG)mcbEntry[index].ClusterCount;
NtfsAddNtfsMcbEntry( &moveScb->Mcb,
mcbEntry[index].Vcn,
mcbEntry[index].Lcn,
(LONGLONG)mcbEntry[index].ClusterCount,
TRUE );
}
ASSERT( LlBytesFromClusters(vcb, testVcn) == NTOHLL(ndfsWinxpReplytHeader->AllocationSize8) );
if (moveScb->Header.AllocationSize.QuadPart != NTOHLL(ndfsWinxpReplytHeader->AllocationSize8))
SetFlag( moveScb->ScbState, SCB_STATE_TRUNCATE_ON_CLOSE );
moveScb->Header.FileSize.QuadPart = NTOHLL(ndfsWinxpReplytHeader->FileSize8);
moveScb->Header.AllocationSize.QuadPart = NTOHLL(ndfsWinxpReplytHeader->AllocationSize8);
ASSERT( moveScb->Header.AllocationSize.QuadPart >= moveScb->Header.FileSize.QuadPart );
if (moveFileObject->SectionObjectPointer->DataSectionObject != NULL && moveFileObject->PrivateCacheMap == NULL) {
CcInitializeCacheMap( moveFileObject,
(PCC_FILE_SIZES)&moveScb->Header.AllocationSize,
FALSE,
&NtfsData.CacheManagerCallbacks,
moveScb );
}
if (CcIsFileCached(moveFileObject)) {
NtfsSetBothCacheSizes( moveFileObject,
(PCC_FILE_SIZES)&scb->Header.AllocationSize,
moveScb );
}
NtfsReleaseNtfsMcbMutex( &moveScb->Mcb );
NtfsReleaseFcb( IrpContext, moveFcb );
}
}
try_exit: NOTHING;
} finally {
if (secondarySessionResourceAcquired == TRUE) {
SecondaryReleaseResourceLite( IrpContext, &volDo->SessionResource );
}
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
}
NtfsCompleteRequest( IrpContext, Irp, Status );
return Status;
}
static char *
print(char *buf, size_t *len, char * const args[])
{
static char s[512];
static char * fmt;
FLOWDESC *x;
timestamp_t ts;
time_t t;
char ssid[34];
int hh, mm, ss;
if (buf == NULL && args != NULL) {
int n;
/* first call of print, process the arguments and return */
for (n = 0; args[n]; n++) {
if (!strcmp(args[n], "format=plain")) {
*len = 0;
fmt = PLAINFMT;
return s;
}
}
/* by default, pretty print */
*len = sprintf(s, PRETTYHDR);
fmt = PRETTYFMT;
return s;
}
if (buf == NULL && args == NULL) {
*len = 0;
return s;
}
x = (FLOWDESC *) buf;
ts = NTOHLL(x->ts);
hh = (TS2SEC(ts) % 86400) /3600;
mm = (TS2SEC(ts) % 3600) / 60;
ss = TS2SEC(ts) % 60;
t = (time_t) TS2SEC(ts);
snprintf(ssid, x->len+1, x->ssid);
if (fmt == PRETTYFMT) {
int n;
*len = sprintf(s, fmt, hh, mm, ss, TS2USEC(ts),
ntohl(x->signal)-256, ntohl(x->noise)-256);
for (n = 0; n < MAC_ADDR_SIZE; n++)
*len += sprintf(s + *len, "%02x%s", x->addr[n],
n < (MAC_ADDR_SIZE-1) ? ":": " ");
switch (ntohl(x->phytype)) {
case PHYTYPE_FHSS_DOT11_97:
*len += sprintf(s + *len, "%-15s", "FHSS 802.11 97");
break;
case PHYTYPE_DSSS_DOT11_97:
*len += sprintf(s + *len, "%-15s", "DSSS 802.11 97");
break;
case PHYTYPE_IRBASEBAND:
*len += sprintf(s + *len, "%-15s", "IR BASEBAND");
break;
case PHYTYPE_DSSS_DOT11_B:
*len += sprintf(s + *len, "%-15s", "DSSS 802.11b");
break;
case PHYTYPE_PBCC_DOT11_B:
*len += sprintf(s + *len, "%-15s", "PBCC 802.11b");
break;
case PHYTYPE_OFDM_DOT11_G:
*len += sprintf(s + *len, "%-15s", "OFDM 802.11g");
break;
case PHYTYPE_PBCC_DOT11_G:
*len += sprintf(s + *len, "%-15s", "PBCC 802.11g");
break;
case PHYTYPE_OFDM_DOT11_A:
*len += sprintf(s + *len, "%-15s", "OFDM 802.11a");
break;
default:
*len += sprintf(s + *len, "%-15s", "FOREIGN");
break;
}
switch(ntohl(x->encoding)) {
case UNKNOWN_ENCODING:
*len += sprintf(s + *len, "%-10s", "UNKNOWN");
break;
case CCK_ENCODING:
*len += sprintf(s + *len, "%-10s", "CCK");
break;
case PBCC_ENCODING:
*len += sprintf(s + *len, "%-10s", "PBCC");
break;
case OFDM_ENCODING:
*len += sprintf(s + *len, "%-10s", "OFDM");
break;
default:
*len += sprintf(s + *len, "%-10s", "FOREIGN");
break;
}
*len += sprintf(s + *len, " %-3d%-7s %-5d %-32s", x->bivl, "ms",
x->channel, ssid);
*len += sprintf(s + *len, "\n");
} else {
*len = sprintf(s, fmt, (long int) t, (ntohl(x->signal)-256),
(ntohl(x->noise)-256), x->bivl, x->channel, ssid);
}
return s;
}
BOOL
VendorSetLock11(
IN PRAM_DATA_OLD RamData,
IN UINT64 SessionId,
IN PLANSCSI_VENDOR_REQUEST_PDU_HEADER RequestHeader,
OUT PLANSCSI_VENDOR_REPLY_PDU_HEADER ReplyHeader
){
UINT64 vendorParam;
UCHAR lockNo;
PGENERAL_PURPOSE_LOCK gpLock;
LONG acquired;
DWORD dwWaitResult;
vendorParam = NTOHLL(RequestHeader->VendorParameter);
lockNo = (UCHAR)((vendorParam>>32) & 0x3);
gpLock = &RamData->GPLocks[lockNo];
fprintf(stderr, "VendorSetLock11: Acquiring lock %d.\n", lockNo);
//
// Acquire the mutex for the lock access
//
dwWaitResult = WaitForSingleObject(RamData->LockMutex, INFINITE);
if(dwWaitResult != WAIT_OBJECT_0)
return FALSE;
if(gpLock->Acquired == FALSE) {
//
// GP lock acquired
//
gpLock->Acquired = TRUE;
gpLock->Counter ++;
gpLock->SessionId = SessionId;
//
// Set return counter
//
ReplyHeader->VendorParameter = HTONLL((UINT64)gpLock->Counter);
fprintf(stderr, "VendorSetLock11: lock %d acquired(%ld).\n", lockNo, gpLock->SessionId);
//
// GP lock Already acquired by others
//
} else {
//
// Set return counter
//
ReplyHeader->VendorParameter = HTONLL((UINT64)gpLock->Counter);
ReleaseMutex(RamData->LockMutex);
fprintf(stderr, "VendorSetLock11: Lock contention!\n");
ReplyHeader->Response = LANSCSI_RESPONSE_T_SET_SEMA_FAIL;
return TRUE;
}
ReleaseMutex(RamData->LockMutex);
return TRUE;
}
int
VenderCommand(
SOCKET connsock,
UCHAR cOperation,
unsigned _int64 *pParameter
)
{
_int8 PduBuffer[MAX_REQUEST_SIZE];
PLANSCSI_VENDER_REQUEST_PDU_HEADER pRequestHeader;
PLANSCSI_VENDER_REPLY_PDU_HEADER pReplyHeader;
LANSCSI_PDU pdu;
int iResult;
memset(PduBuffer, 0, MAX_REQUEST_SIZE);
pRequestHeader = (PLANSCSI_VENDER_REQUEST_PDU_HEADER)PduBuffer;
pRequestHeader->Opcode = VENDER_SPECIFIC_COMMAND;
pRequestHeader->F = 1;
pRequestHeader->HPID = htonl(HPID);
pRequestHeader->RPID = htons(RPID);
pRequestHeader->CPSlot = 0;
pRequestHeader->DataSegLen = 0;
pRequestHeader->AHSLen = 0;
pRequestHeader->CSubPacketSeq = 0;
pRequestHeader->PathCommandTag = htonl(++iTag);
pRequestHeader->VenderID = ntohs(NKC_VENDER_ID);
pRequestHeader->VenderOpVersion = VENDER_OP_CURRENT_VERSION;
pRequestHeader->VenderOp = cOperation;
pRequestHeader->VenderParameter = *pParameter;
TRACE("VenderCommand: Operation %d, Parameter %I64d\n", cOperation, NTOHLL(*pParameter));
// Send Request.
pdu.pH2RHeader = (PLANSCSI_H2R_PDU_HEADER)pRequestHeader;
if(SendRequest(connsock, &pdu) != 0) {
PrintError(WSAGetLastError(), "VenderCommand: Send First Request ");
return -1;
}
// Read Request.
iResult = ReadReply(connsock, (PCHAR)PduBuffer, &pdu);
if(iResult == SOCKET_ERROR) {
fprintf(stderr, "[LanScsiCli]VenderCommand: Can't Read Reply.\n");
return -1;
}
// Check Request Header.
pReplyHeader = (PLANSCSI_VENDER_REPLY_PDU_HEADER)pdu.pR2HHeader;
if((pReplyHeader->Opcode != VENDER_SPECIFIC_RESPONSE)
|| (pReplyHeader->F == 0)) {
fprintf(stderr, "[LanScsiCli]VenderCommand: BAD Reply Header. %d 0x%x\n", pReplyHeader->Opcode, pReplyHeader->F);
return -1;
}
if(pReplyHeader->Response != LANSCSI_RESPONSE_SUCCESS) {
fprintf(stderr, "[LanScsiCli]VenderCommand: Failed.\n");
return -1;
}
*pParameter = pReplyHeader->VenderParameter;
return 0;
}
