/*++
Copyright (c) 1991-1992 Microsoft Corporation
Module Name:
apiutil.c
Abstract:
Contains functions used by the Messenger API. This file contains the
following functions:
MsgIsValidMsgName
MsgMapNetError
MsgLookupName
message_sec_check
MsgGatherInfo
MsgUnformatName
MsgLookupNameForThisSession
MsgIsSessionInList (HYDRA specific)
MsgAddSessionInList (HYDRA specific)
MsgRemoveSessionFromList (HYDRA specific)
Author:
Dan Lafferty (danl) 22-Jul-1991
Environment:
User Mode -Win32
Notes:
These functions were ported from LM2.0. This file contains functions
from several LM2.0 files. Not all functions were used in this file
since some were made obsolete by the NT Service Model.
The following LM2.0 files were incorportated into this single file:
msgutils.c
msgutil2.c
dupname.c
netname.c
Revision History:
22-Jul-1991 danl
ported from LM2.0
--*/
//
// Includes
//
#include "msrv.h"
#include <tstring.h> // Unicode string macros
#include <lmwksta.h>
#include <lmmsg.h>
#include <smbtypes.h> // needed for smb.h
#include <smb.h> // Server Message Block definitions
#include <icanon.h> // I_NetNameValidate
#include <netlib.h> // NetpCopyStringToBuffer
#include "msgdbg.h" // MSG_LOG
#include "heap.h"
#include "msgdata.h"
#include "apiutil.h"
//
// Table of NetBios mappings to Net Errors.
//
DWORD const mpnetmes[] =
{
0x23, // 00 Number of messages
NERR_NetworkError, // 01 NRC_BUFLEN -> invalid length
0xffffffff, // 02 NRC_BFULL , not expected
NERR_NetworkError, // 03 NRC_ILLCMD -> invalid command
0xffffffff, // 04 not defined
NERR_NetworkError, // 05 NRC_CMDTMO -> network busy
NERR_NetworkError, // 06 NRC_INCOMP -> messgae incomplete
0xffffffff, // 07 NRC_BADDR , not expected
NERR_NetworkError, // 08 NRC_SNUMOUT -> bad session
NERR_NoNetworkResource, // 09 NRC_NORES -> network busy
NERR_NetworkError, // 0a NRC_SCLOSED -> session closed
NERR_NetworkError, // 0b NRC_CMDCAN -> command cancelled
0xffffffff, // 0c NRC_DMAFAIL, unexpected
NERR_AlreadyExists, // 0d NRC_DUPNAME -> already exists
NERR_TooManyNames, // 0e NRC_NAMTFUL -> too many names
NERR_DeleteLater, // 0f NRC_ACTSES -> delete later
0xffffffff, // 10 NRC_INVALID , unexpected
NERR_NetworkError, // 11 NRC_LOCTFUL -> too many sessions
ERROR_REM_NOT_LIST, // 12 NRC_REMTFUL -> remote not listening*/
NERR_NetworkError, // 13 NRC_ILLNN -> bad name
NERR_NameNotFound, // 14 NRC_NOCALL -> name not found
ERROR_INVALID_PARAMETER, // 15 NRC_NOWILD -> bad parameter
NERR_DuplicateName, // 16 NRC_INUSE -> name in use, retry
ERROR_INVALID_PARAMETER, // 17 NRC_NAMERR -> bad parameter
NERR_NetworkError, // 18 NRC_SABORT -> session ended
NERR_DuplicateName, // 19 NRC_NAMCONF -> duplicate name
0xffffffff, // 1a not defined
0xffffffff, // 1b not defined
0xffffffff, // 1c not defined
0xffffffff, // 1d not defined
0xffffffff, // 1e not defined
0xffffffff, // 1f not defined
0xffffffff, // 20 not defined
NERR_NetworkError, // 21 NRC_IFBUSY -> network busy
NERR_NetworkError, // 22 NRC_TOOMANY -> retry later
NERR_NetworkError // 23 NRC_BRIDGE -> bridge error
};
DWORD
MsgIsValidMsgName(
IN LPTSTR name
)
/*++
Routine Description:
Check for a valid messaging name.
This function checks for the validity of a messaging name.
Arguments:
name - pointer to name to validate.
Return Value:
Error code from I_NetNameValidate
--*/
{
TCHAR namebuf[NCBNAMSZ];
DWORD err_code;
//
// Message names cannot be larger than (NCBNAMSZ - 1) characters
//
if (STRLEN(name) > (NCBNAMSZ - 1))
{
return ERROR_INVALID_PARAMETER;
}
STRCPY(namebuf, name);
err_code = I_NetNameValidate(NULL, namebuf, NAMETYPE_COMPUTER, 0L);
if (err_code != 0)
{
return err_code;
}
//
// Any name beginning with a * must be rejected as the message
// server relies on being able to ASTAT the name, and an ASTAT
// name commencing with a * means ASTAT the local card.
//
if(namebuf[0] == TEXT('*'))
{
return ERROR_INVALID_PARAMETER;
}
return NERR_Success;
}
DWORD
MsgMapNetError(
IN UCHAR Code // Error code
)
/*++
Routine Description:
Map NetBios Error code to a message number
Arguments:
code - Error code from NetBios (can be 0)
Return Value:
Message code as defined in msgs.h
--*/
{
DWORD dwCode;
dwCode = 0 | (UCHAR)Code;
if( dwCode == 0) {
return(NERR_Success); // Special case
}
if((dwCode > 0) && (dwCode < mpnetmes[0])) {
return(mpnetmes[dwCode]);
}
return (NERR_NetworkError); // Can't map it!
}
DWORD
MsgLookupName(
IN DWORD net, // The network card to search
IN LPSTR name // Formatted name (Non-unicode)
)
/*++
Routine Description:
This function looks up a formatted name in the name table in the
Message Server's shared data area.
This function looks the given name up in the name table in the shared
data area. In order to match the given name, the first NCBNAMLEN - 1
characters of the name in the name table must be identical to the same
characters in the given name, and the name in the name table must not be
marked as deleted. This function assumes that the shared data area is
accessible and that the global variable, dataPtr, is valid.
Arguments:
name - pointer to formatted name
Return Value:
DWORD - index into table if found, -1 otherwise
--*/
{
DWORD i; // Index
for(i = 0; i < NCBMAX(net); ++i) { // Loop to search for name
if( !memcmp( name, SD_NAMES(net,i), NCBNAMSZ - 1) &&
!(SD_NAMEFLAGS(net,i) & NFDEL) ) {
//
// Return index if match found
//
return(i);
}
}
return(0xffffffff); // No match
}
// For HYDRA, we want to make sure that the name exists for THIS client session.
DWORD
MsgLookupNameForThisSession(
IN DWORD net, // The network card to search
IN LPSTR name, // Formatted name to loook for (Non-unicode)
IN ULONG SessionId // Session Id to look for
)
/*++
Routine Description:
Same as MsgLookupName except that we care about the session Id.
This function looks up a formatted name in the name table in the
Message Server's shared data area. The name found must have the
requested SessionId in its session list to be considered as OK.
Arguments:
name - pointer to formatted name
SessionId - the requested Session Id
Return Value:
DWORD - index into table if found, -1 otherwise
--*/
{
DWORD i; // Index
DWORD dwMsgrState; // messanger state
if (!g_IsTerminalServer) // regular NT case
{
//
// if we are not on HYDRA, forget the SessionId
//
return MsgLookupName(net, name);
}
else // HYDRA case
{
//
// dont try to access table if messanger stop is pending,
// we may not have GlobalData available
//
dwMsgrState = GetMsgrState();
if (RUNNING == dwMsgrState)
{
for(i = 0; i < NCBMAX(net); ++i) { // Loop to search for name
if( !memcmp( name, SD_NAMES(net,i), NCBNAMSZ - 1) &&
!(SD_NAMEFLAGS(net,i) & NFDEL) &&
(MsgIsSessionInList(&(SD_SIDLIST(net,i)), SessionId ))
) {
return (i);
}
}
}
return(0xffffffff); // No match
}
}
// message_sec_check
//
// A common routine to check caller priv/auth against that
// required to call the message apis.
//
//
NET_API_STATUS
message_sec_check(VOID)
{
#ifdef later
//
// API security check. This call can be called by anyone locally,
// but only by admins in the remote case.
I_SecSyncSet(SECSYNC_READER);
if ( ( clevel == ACCESS_REMOTE ) &&
( callinf != NULL ) &&
( CALLER_PRIV(callinf) != USER_PRIV_ADMIN ) )
{
I_SecSyncClear(SECSYNC_READER);
return(ERROR_ACCESS_DENIED);
}
I_SecSyncClear(SECSYNC_READER);
#endif
return (NERR_Success);
}
NET_API_STATUS
MsgGatherInfo (
IN DWORD Level,
IN LPSTR FormattedName,
IN OUT LPBYTE *InfoBufPtr,
IN OUT LPBYTE *StringBufPtr
)
/*++
Routine Description:
Arguments:
Level - Indicates the level of information that is being returned.
FormattedName - This is a name that messages are received by. This
name is formated for NCB transactions. Therefore, it is made
up of ANSI characters that are space padded to fill out a packet
of NCBNAMSZ characters. The last character is always a 03
(indicating a non-forwarded name).
InfoBufPtr - On input, this is a pointer to a pointer to where the
messenger information is to be placed. On successful return, this
location contains a pointer to the location where the next
information will be placed (on the next call to this function).
StringBufPtr - On input, thisis a pointer to a pointer to where the
NUL terminated name string for that info record is to be placed.
On successful return, this location contains a pointer to the
location where the next set of strings will be placed (on the
next call to this function).
Return Value:
NERR_Success - The information was successfully gathered and placed
in the info buffer.
NERR_Internal_Error - The Formatted Name could not be correctly
translated into a meaningful Unicode Name.
ERROR_INVALID_LEVEL - An illegal info level was passed in.
ERROR_NOT_ENOUGH_MEMORY - Not enough room to store gathered information.
--*/
{
NET_API_STATUS status;
BOOL bStatus;
PCHAR fixedDataEnd; // pointer to free space from top of buffer.
LPMSG_INFO_0 infoBuf0;
LPMSG_INFO_1 infoBuf1;
TCHAR unicodeName[NCBNAMSZ];
//
// Convert the name to Unicode
//
status = MsgUnformatName(unicodeName, FormattedName);
if (status != NERR_Success) {
return(status);
}
switch (Level) {
case LEVEL_0:
infoBuf0 = (LPMSG_INFO_0)*InfoBufPtr;
fixedDataEnd = (PCHAR)infoBuf0 + sizeof(MSG_INFO_0);
if( fixedDataEnd >= *StringBufPtr) {
return(ERROR_NOT_ENOUGH_MEMORY);
}
bStatus = NetpCopyStringToBuffer (
unicodeName, // The String
STRLEN(unicodeName), // StringLength
fixedDataEnd, // FixedDataEnd
(PVOID)StringBufPtr, // EndOfVariableData
&infoBuf0->msgi0_name); // VariableDataPointer
if (bStatus == FALSE) {
MSG_LOG(TRACE,"MsgGatherInfo(level0): Not enough room\n",0);
return(ERROR_NOT_ENOUGH_MEMORY);
}
*InfoBufPtr = (LPBYTE)fixedDataEnd;
break;
case LEVEL_1:
infoBuf1 = (LPMSG_INFO_1)*InfoBufPtr;
fixedDataEnd = (PCHAR)infoBuf1 + sizeof(MSG_INFO_1);
if( fixedDataEnd >= *StringBufPtr) {
return(ERROR_NOT_ENOUGH_MEMORY);
}
bStatus = NetpCopyStringToBuffer (
unicodeName, // The String
STRLEN(unicodeName), // StringLength
fixedDataEnd, // FixedDataEnd
(PVOID)StringBufPtr, // EndOfVariableData
&infoBuf1->msgi1_name); // VariableDataPointer
if (bStatus == FALSE) {
MSG_LOG(TRACE,"MsgGatherInfo(level1): Not enough room\n",0);
return(ERROR_NOT_ENOUGH_MEMORY);
}
//
// Set all the forward information to NULL since forwarding
// is not supported.
//
infoBuf1->msgi1_forward_flag = 0;
infoBuf1->msgi1_forward = NULL;
*InfoBufPtr = (LPBYTE)fixedDataEnd;
break;
default:
MSG_LOG(TRACE,"MsgGatherInfo Invalid level\n",0);
return(ERROR_INVALID_LEVEL);
break;
}
return(NERR_Success);
}
NET_API_STATUS
MsgUnformatName(
OUT LPTSTR UnicodeName,
IN LPSTR FormattedName
)
/*++
Routine Description:
This routine creates a Unicode NUL-Terminated version of a NetBios
Formatted name.
Arguments:
UnicodeName - This is a pointer to a location where the un-formatted
NUL terminated Unicode Name is to be copied.
FormattedName - This is a pointer to an NCB formatted name. This
name always contains NCBNAMSZ characters of which the last character
is a code used for a forward/non-forward flag. These strings
are space padded.
Return Value:
NERR_Success - The operation was successful.
NERR_Internal - The operation was unsuccessful.
--*/
{
UNICODE_STRING unicodeString;
OEM_STRING ansiString;
NTSTATUS ntStatus;
int i;
//
// Translate the ansi string in the name table to a unicode name
//
#ifdef UNICODE
unicodeString.Length = (NCBNAMSZ -1) * sizeof(WCHAR);
unicodeString.MaximumLength = NCBNAMSZ * sizeof(WCHAR);
unicodeString.Buffer = (LPWSTR)UnicodeName;
ansiString.Length = NCBNAMSZ-1;
ansiString.MaximumLength = NCBNAMSZ;
ansiString.Buffer = FormattedName;
ntStatus = RtlOemStringToUnicodeString(
&unicodeString, // Destination
&ansiString, // Source
FALSE); // Don't allocate the destination.
if (!NT_SUCCESS(ntStatus)) {
MSG_LOG(ERROR,
"UnformatName:RtlOemStringToUnicodeString Failed rc=%X\n",
ntStatus);
//
// Indicate a failure
//
return(NERR_InternalError);
}
#else
UNUSED (ntStatus);
UNUSED (ansiString);
UNUSED (unicodeString);
strncpy(UnicodeName, FormattedName, NCBNAMSZ-1);
#endif
//
// Remove excess Space characters starting at the back (skipping
// the 03 flag character.
//
i = NCBNAMSZ-2;
while ( UnicodeName[i] == TEXT(' ')) {
UnicodeName[i--] = TEXT('\0');
if (i < 0) {
MSG_LOG(ERROR,
"UnformatName:Nothing but space characters\n",0);
return(NERR_InternalError);
}
}
return(NERR_Success);
}
BOOL
MsgIsSessionInList(
IN PLIST_ENTRY SessionIdList,
IN ULONG SessionId
)
{
BOOL bRet = FALSE;
PLIST_ENTRY pList = SessionIdList;
PMSG_SESSION_ID_ITEM pItem;
while (pList->Flink != SessionIdList) // loop until we find it (or the end of the list)
{
pList = pList->Flink;
pItem = CONTAINING_RECORD(pList, MSG_SESSION_ID_ITEM, List);
if ( (pItem->SessionId == SessionId) || (pItem->SessionId == EVERYBODY_SESSION_ID) )
{
bRet = TRUE; // we found it !
break;
}
}
return bRet;
}
VOID
MsgRemoveSessionFromList(
IN PLIST_ENTRY SessionIdList,
ULONG SessionId
)
{
PLIST_ENTRY pList = SessionIdList;
PMSG_SESSION_ID_ITEM pItem;
while (pList->Flink != SessionIdList) // loop until we find it (or the end of the list)
{
pList = pList->Flink;
pItem = CONTAINING_RECORD(pList, MSG_SESSION_ID_ITEM, List);
if (pItem->SessionId == SessionId)
{
// we found it. Let's remove it
RemoveEntryList(pList);
//Free the memory
LocalFree(pItem);
break;
}
}
}
BOOL
MsgAddSessionInList(
IN PLIST_ENTRY SessionIdList,
ULONG SessionId
)
{
BOOL bRet;
PMSG_SESSION_ID_ITEM pItem;
// allocate a new item
pItem = (PMSG_SESSION_ID_ITEM) LocalAlloc(LMEM_ZEROINIT,sizeof(MSG_SESSION_ID_ITEM));
if (pItem == NULL) // If this happens, we really have big problems...
{
MSG_LOG(ERROR,"MsgAddSessionInList: Unable to allocate memory\n",0);
bRet = FALSE;
}
else // OK
{
bRet = TRUE;
// initialize the item
pItem->SessionId = SessionId;
// insert the item in the list
InsertTailList(SessionIdList, &pItem->List);
}
return bRet;
}