/*++
Copyright (c) 1987-92 Microsoft Corporation
Module Name:
Transact.c
Abstract:
RxpTransactSmb (analogous to the LanMan 2.x transact routine) performs a
transaction FSCTL to the redirector.
Author:
John Rogers (JohnRo) 01-Apr-1991 (NT version only)
Environment:
Only runs under NT, although the interface is portable (Win/32).
Requires ANSI C extensions: slash-slash comments, long external names.
Revision History:
various
Original code (from LanMan 2.x).
01-Apr-91 JohnRo
Converted code from LanMan (OS/2) to NT.
02-Apr-1991 JohnRo
Moved NetpRdrFsControlTree to <netlibnt.h>.
17-Apr-1991 JohnRo
Fixed memory leaks (especially with pipe name).
Quiet debug output by default.
Reduced recompile hits from header files.
03-May-1991 JohnRo
Pass UNC server name for ease of use. Use Unicode transitional types.
Use UNREFERENCED_PARAMETER() macro.
15-May-1991 JohnRo
Use FORMAT_LPVOID instead of FORMAT_POINTER, for maximum portability.
22-May-1991 JohnRo
Use correct string handling functions to allow UNICODE.
Use NetpDbgReasonable().
14-Jul-1991 JohnRo
Don't do assert on server name.
17-Jul-1991 JohnRo
Extracted RxpDebug.h from Rxp.h.
04-Oct-1991 JohnRo
Generate NERR_BadTransactConfig when IPC$ isn't shared.
Clarified a debug output message. Use TEXT() macro.
01-Nov-1991 JohnRo
Don't let the new (paranoid) RxpFatalErrorCode() prevent debug output.
16-Jan-1992 JohnRo
The redirector always expects UNICODE for the transact parm name.
31-Mar-1992 JohnRo
Prevent too large size requests.
22-Sep-1992 JohnRo
RAID 6739: Browser too slow when not logged into browsed domain.
--*/
// These must be included first:
#include <nt.h> // Needed by netlibnt.h.
#include <rxp.h> // RpcXlate's private header file.
// These may be included in any order:
#include <apiworke.h> // REM_APITXT, APIEXTR.
#include <lmerr.h> // NERR_ and ERROR_ equates.
#include <names.h> // NetpIsComputerNameValid().
#include <netdebug.h> // NetpAssert(), NetpKdPrint(()), FORMAT_ equates.
#include <netlib.h> // NetpMoveMemory(), etc.
#include <ntddnfs.h> // TRANSACTION_REQUEST, etc.
#include <prefix.h> // PREFIX_ equates.
#include <rxpdebug.h> // IF_DEBUG().
#include <tstring.h> // STRCAT(), STRCPY(), STRLEN().
#include <lmuse.h>
#ifdef CDEBUG
#include <apinums.h> // API_WServerGetInfo, etc.
#include <netlib.h> // NetpPackString().
#include <smbgtpt.h> // SmbGetUshort().
#include <server.h> // SERVER_INFO_100.
#endif // CDEBUG
#include <netlibnt.h> // NetpRdrFsControlTree().
NET_API_STATUS
RxpTransactSmb(
IN LPTSTR UncServerName,
IN LPTSTR TransportName OPTIONAL,
IN LPVOID SendParmPtr,
IN DWORD SendParmLen,
IN LPVOID SendDataPtr OPTIONAL,
IN DWORD SendDataLen,
OUT LPVOID RetParmPtr OPTIONAL,
IN DWORD RetParmLen,
OUT LPVOID RetDataPtr OPTIONAL,
IN OUT LPDWORD RetDataLen,
IN BOOL NoPermissionRequired
)
/*++
Routine Description:
RxpTransactSmb takes the caller's parameters and builds a transaction
SMB which is sent to a remote machine. This routine waits for the
response to this SMB and returns the status from it.
Arguments:
UncServerName - Server name to transact with (including \\).
SendParmPtr - Pointer to send parameters.
SendParmLen - Length of send parameters.
SendDataPtr - Optional pointer to send data.
SendDataLen - Send data length.
RetParmPtr - Optional pointer to buffer for return parameters.
RetParmLen - Expected length of return parameters.
RetDataPtr - Optional pointer to buffer for return data.
RetDataLen - IN: Expected length of return data.
OUT: Received length of return data.
NoPermissionRequired - TRUE if this is a no permission required API. (I.e.
TRUE if the null session may be used.)
Return Value:
(various values as returned by the remote API, plus values which can
be generated by this routine)
--*/
/*
* Note 1: how the packet is build and sized.
*
* The paramater buffer for the transaction consists of the
* transaction parameter structure, followed by the name of the
* target pipe and the password, which is always NULL. The pipe
* name and password are ASCIZ strings.
*
* We build the pipe by taking the canonicalized server name, and
* appending the text REM_APITXT (see net/inc/apiworke.h). This text
* contains the pipe suffix (\pipe\lanman) plus TWO nulls, one to
* terminate the pipe name and one to terminate the (empty) password.
*
* So, the maximum buffer size is as shown below for the allocation
* of ioctl_buf. UNCLEN is the max len of the canonicalized
* UncServerName and includes the two leading slashes, but not any
* terminating NUL. The terminating NUL, as well as the pipe suffix
* and the emptry password, are accounted for in APIEXTR.
*
* Our actual size is the same, except substitute the length of the
* canonicalized UncServerName for UNCLEN. This is how ParmRktLen is
* calculated.
*
*/
{
#ifndef CDEBUG
PLMR_TRANSACTION FsctlParms; // Parms to tell redir what to do.
DWORD FsctlParmSize; // Size of FsctlParms and strings.
LPTSTR TreeConnName; // LM-style server & share name.
#endif // ndef CDEBUG
NET_API_STATUS Status;
//
// MOD 06/11/91 RLF
// Create DWORD variable to avoid indirection every time RetDataLen accessed
//
DWORD InputRetDataLen = *RetDataLen;
//
// MOD 06/11/91 RLF
//
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: entered, servername='"
FORMAT_LPTSTR "'...\n", UncServerName));
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: SendParm at " FORMAT_LPVOID
", len=" FORMAT_DWORD " (partial):\n",
(LPVOID) SendParmPtr, SendParmLen));
if (SendParmPtr != NULL) {
NetpDbgHexDump(SendParmPtr, NetpDbgReasonable(SendParmLen));
}
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: SendData at " FORMAT_LPVOID
", len=" FORMAT_DWORD " (partial):\n",
(LPVOID) SendDataPtr, SendDataLen));
if (SendDataPtr != NULL) {
NetpDbgHexDump(SendDataPtr, NetpDbgReasonable(SendDataLen));
}
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: RetParmPtr at " FORMAT_LPVOID
", len=" FORMAT_DWORD ".\n", (LPVOID) RetParmPtr, RetParmLen));
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: (old) RetData at " FORMAT_LPVOID ", "
"len=" FORMAT_DWORD " (partial):\n",
(LPVOID) RetDataPtr, InputRetDataLen));
if (RetDataPtr != NULL) {
NetpDbgHexDump(RetDataPtr, NetpDbgReasonable(InputRetDataLen));
}
}
NetpAssert( SendParmLen <= MAX_TRANSACT_SEND_PARM_SIZE );
NetpAssert( SendDataLen <= MAX_TRANSACT_SEND_DATA_SIZE );
NetpAssert( RetParmLen <= MAX_TRANSACT_RET_PARM_SIZE );
NetpAssert( InputRetDataLen <= MAX_TRANSACT_RET_DATA_SIZE );
// Assumes that isremote(UncServerName) has already checked for
// a NULL and empty string.
if ((UncServerName == NULL) || (UncServerName[0] == 0)) {
NetpBreakPoint();
return (NERR_InternalError);
}
if (! NetpIsUncComputerNameValid(UncServerName)) {
return (NERR_InvalidComputer);
}
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: pipe name is '" FORMAT_LPWSTR
"'.\n", REM_APITXT));
}
#ifndef CDEBUG
//
// Build NT-style name for what we're connecting to. Note that there is
// NOT a pair of backslashes anywhere in this name.
//
{
DWORD NameSize =
// /Device/LanManRedirector /server /IPC$\0
( strlen(DD_NFS_DEVICE_NAME) + STRLEN(UncServerName)-1 + 6 )
* sizeof(TCHAR);
TreeConnName = NetpMemoryAllocate( NameSize );
}
if (TreeConnName == NULL) {
return (ERROR_NOT_ENOUGH_MEMORY);
}
//
// Build the tree connect name.
//
(void) STRCPY(TreeConnName, UncServerName); // copy "\\server",
(void) STRCAT(TreeConnName, (LPTSTR) TEXT("\\IPC$")); // then "\share".
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: TreeConnName is '" FORMAT_LPTSTR
"'.\n", TreeConnName));
}
// Set FsctlParmSize and allocate fsctl structure.
FsctlParmSize = sizeof(LMR_TRANSACTION) + (APIEXTR);
FsctlParms = NetpMemoryAllocate(FsctlParmSize);
if (FsctlParms == NULL) {
NetpMemoryFree(TreeConnName);
return (ERROR_NOT_ENOUGH_MEMORY);
}
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: allocated " FORMAT_DWORD
" bytes for fsctl parms at "
FORMAT_LPVOID ".\n", FsctlParmSize, (LPVOID) FsctlParms));
}
FsctlParms->Type = TRANSACTION_REQUEST;
FsctlParms->Size = FsctlParmSize;
FsctlParms->Version = TRANSACTION_VERSION;
FsctlParms->NameLength = APIEXTR-sizeof(WCHAR);
FsctlParms->NameOffset = sizeof(LMR_TRANSACTION);
NetpMoveMemory(
NetpPointerPlusSomeBytes(
FsctlParms,
sizeof(LMR_TRANSACTION)), // dest
REM_APITXT, // src (always UNICODE)
APIEXTR-sizeof(WCHAR)); // len (don't copy null)
FsctlParms->ResponseExpected = TRUE;
FsctlParms->Timeout = REM_API_TIMEOUT; // Timeout time in milliseconds.
FsctlParms->SetupWords = 0;
FsctlParms->SetupOffset = 0;
FsctlParms->MaxSetup = 0;
FsctlParms->ParmLength = SendParmLen;
FsctlParms->ParmPtr = SendParmPtr;
FsctlParms->MaxRetParmLength = RetParmLen;
NetpAssert(SendParmPtr == RetParmPtr);
FsctlParms->DataLength = SendDataLen;
FsctlParms->DataPtr = SendDataPtr;
FsctlParms->MaxRetDataLength = InputRetDataLen;
FsctlParms->RetDataPtr = RetDataPtr;
//
// Do the FSCTL!
//
Status = NetpRdrFsControlTree(
TreeConnName, // tree connect name
TransportName, // Transport name.
USE_IPC, // Connection type
FSCTL_LMR_TRANSACT, // fsctl function code
NULL, // security descriptor
FsctlParms, // input buffer
FsctlParmSize, // input buffer length
FsctlParms, // output buffer
FsctlParmSize, // output buffer length
NoPermissionRequired);
if (Status == ERROR_BAD_NET_NAME) {
Status = NERR_BadTransactConfig;
}
if (RxpFatalErrorCode(Status)) {
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: returning fatal status="
FORMAT_API_STATUS ".\n", Status));
}
NetpMemoryFree(FsctlParms);
NetpMemoryFree(TreeConnName);
return (Status);
}
//
// MOD 06/11/91 RLF
// Return the received data length in *RetDataLen
//
*RetDataLen = FsctlParms->MaxRetDataLength;
NetpAssert( *RetDataLen <= MAX_TRANSACT_RET_DATA_SIZE );
//
// MOD 06/11/91 RLF
//
NetpMemoryFree(FsctlParms);
NetpMemoryFree(TreeConnName);
#else // def CDEBUG
{
DWORD ApiNumber;
ApiNumber = (DWORD) SmbGetUshort((LPWORD) SendParmPtr);
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: pretending success for API "
FORMAT_DWORD ".\n", ApiNumber));
}
SmbPutUshort((LPWORD) RetParmPtr, (WORD) NERR_Success);
switch (ApiNumber) {
case API_NetRemoteTOD :
{
UCHAR BogusTime[] = {
0xD0, 0xAE, 0xB2, 0x28, // 21-Aug-1991 (6:20PM)
0x44, 0x33, 0x22, 0x11, // msec (anything)
3, // hours
30, // minutes
15, // seconds
55, // hundredths of seconds
0xFF, 0xFF, // timezone (unknown)
0xA6, 0x00, // clock interval (60 Hz)
10, // day
1, // month
0xC7, 0x07, // year
4}; // weekday
NetpAssert(RetDataPtr != NULL);
NetpAssert(InputRetDataLen != 0);
NetpMoveMemory(
RetDataPtr, // dest
BogusTime, // src (bogus)
InputRetDataLen); // len
break;
}
case API_WServerGetInfo :
{
LPVOID FixedDataEnd = NetpPointerPlusSomeBytes(
RetDataPtr,
sizeof(SERVER_INFO_100));
LPBYTE LastString = NetpPointerPlusSomeBytes(
RetDataPtr,
InputRetDataLen);
LPSERVER_INFO_100 p = RetDataPtr;
NetpAssert(RetDataPtr != NULL);
NetpAssert(InputRetDataLen != 0);
p->sv100_name = (LPTSTR) TEXT("\\\\bogus\\name");
if (NetpPackString(
& p->sv100_name, // in out
FixedDataEnd, // in
& LastString) == 0) { // in out
NetpBreakPoint();
return (NERR_InternalError);
}
break;
}
}
}
#endif // def CDEBUG
Status = (DWORD) SmbGetUshort((LPWORD) RetParmPtr);
IF_DEBUG(TRANSACT) {
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: returning status="
FORMAT_API_STATUS ".\n", Status));
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: RetParm at " FORMAT_LPVOID
", len=" FORMAT_DWORD " (partial):\n",
(LPVOID) RetParmPtr, RetParmLen));
if (RetParmPtr != NULL) {
NetpDbgHexDump(RetParmPtr, NetpDbgReasonable(RetParmLen));
}
NetpKdPrint(( PREFIX_NETAPI
"RxpTransactSmb: (new) RetData at " FORMAT_LPVOID ", "
"len=" FORMAT_DWORD " (partial):\n",
(LPVOID) RetDataPtr, InputRetDataLen));
if (RetDataPtr != NULL) {
NetpDbgHexDump(RetDataPtr, NetpDbgReasonable(InputRetDataLen));
}
}
return (Status);
} // RxpTransactSmb