diff options
Diffstat (limited to 'private/os2/client/dllnet16.c')
| -rw-r--r-- | private/os2/client/dllnet16.c | 5295 |
1 files changed, 5295 insertions, 0 deletions
diff --git a/private/os2/client/dllnet16.c b/private/os2/client/dllnet16.c new file mode 100644 index 000000000..e6d972815 --- /dev/null +++ b/private/os2/client/dllnet16.c @@ -0,0 +1,5295 @@ +/*++ + +Copyright (c) 1992 Microsoft Corporation + +Module Name: + + dllnet16.c + +Abstract: + + This module implements 32 bit equivalents of OS/2 V1.21 + LANMAN API Calls. + The APIs are called from 16->32 thunks (i386\doscalls.asm). + +Author: + + Beni Lavi (BeniL) 15-Jan-1992 + +Revision History: + +--*/ + +#define INCL_OS2V20_ERRORS +#define INCL_OS2V20_ERRORMSG +#define INCL_OS2V20_MEMORY +#define INCL_OS2V20_TASKING +#define UNICODE 1 +#include <stdlib.h> +#include "os2dll.h" +#include "os2dll16.h" +#define WIN32_ONLY +#include "netrqust.h" +#include "os2net16.h" +#include <nb30.h> +#include "nb30p.h" +#define APINAMES +#include <apinums.h> // API_W numbers +// #include <rxp.h> // RxpTransactSmb + +#if DBG +extern USHORT Os2DebugTID; +#endif + +// +// some constants +// + +// +// LanMan API related constants +// + +#define LARGE_BUFFER_SIZE 16384 // used for copying large user buffer to internal buffer +#define SMALL_BUFFER_SIZE 4096 // used for copying small user buffer to internal buffer +#define PREFMAXLEN 8192 // parameter used to control internal LanMan buffer size + +// +// Netbios API related constants +// + +#define USERS_STACK_SIZE 4096 // stack size for user's Netbios 3.0 post routine +#define NETBIOS2_SEMANTICS_SIGNATURE 0xF91E0873 // used as a special flag for Net16bios + +/* + We need a hard coded maximum parallel asynch ncbs limit for netbios 2 + requests. The reason is a problem with the NT netbios driver -- Once + you fill up some maximal number (observed - 0xac) of ncbs, and run out + of memory, it is no longer possible to send even a cancel request for + those ncbs. On Os/2 it is still possible to cancel the pending requests. + Some programs try to test the driver's limits by issuing a lot of ncbs, + and when they get an error, they cancel them all. This will fail due to + the above reason. Limiting artificially to a smaller number will allow + the cancel ncbs to go through. Note that if more than one process fills + up the driver at the same time, this per-process limit will not do any good. + Let's hope this situation is unlikely. +*/ +#define MAX_ASYNCH_NCBS 0x80L + + +// +// macro to probe string arguments passed to APIs +// +#define PROBE_STRING(s) ((VOID) ((s) == NULL ? 0 : strlen(s))) + + +// +// Extended NCB to be passed to Win32 Netbios API +// It contains parameters that are needed by the ASYNCH processing +// +typedef struct _NCBX { + NCB n; + PNCB original_pncb; // Original Os/2 program NCB + ULONG original_ncb_post; // Os/2 program 16 bit far pointer post address + // or a semaphore handle to clear + HANDLE Net16BiosHasCompleted; // an event used to sync the post routine with Net16bios +} NCBX, *PNCBX; + + +// +// some important service names for LanMan related APIs +// +static CHAR N_LanmanWorkstati[] = "LanmanWorkstati"; +static CHAR N_LanmanWorkstation[] = "LanmanWorkstation"; +static CHAR N_LanmanServer[] = "LanmanServer"; +static CHAR N_Workstation[] = "Workstation"; +static CHAR N_Server[] = "Server"; + + +// +// netbios related global variables +// + +BOOLEAN Od2Netbios2Initialized = FALSE; // netbios 2 initialization flag +RTL_CRITICAL_SECTION Od2NbSyncCrit; // This CS is used to protect several data structures + // It's initialized/cleanedup from dllnb.c + +// +// Od2LanaEnum holds the permanent enumeration of lana numbers (received from server) +// Od2LanaState is a per-lana flag that has the following value: +// bit 0 -- 1 if the lana is open/0 if the lana is closed +// bit 1 -- 1 if the lana has been opened by this process before/0 if not (and therefore may need a reset thru the server) +// +static LANA_ENUM Od2LanaEnum; +static UCHAR Od2LanaState[MAX_LANA]; +HANDLE Od2NbDev; // handle to NT netbios driver +LONG Od2MaxAsynchNcbs; // a counter for implementing max asynch ncbs limit +PVOID Od2Nb2Heap; // special heap for netbios 2 requests + +// +// a flag indicating if we've already attached the win32 netbios worker thread to our subsystem +// +static BOOLEAN Od2WorkerThreadIsAttached = FALSE; +static SEL Od2UserStackSel, // selector for netbios post routine user's stack + Od2UserStackAlias; // code alias for Od2UserStackSel + + +// imports + +APIRET +DosCreateCSAlias( + IN SEL selDS, + OUT PSEL pselCS + ); + +APIRET +GetSystemDirectoryW( + LPWSTR lpBuffer, + ULONG uSize + ); + +VOID +Od2JumpTo16NetBiosPostDispatcher( + IN PVOID pUsersPostRoutine, // CS:IP format + IN PVOID UserStackFlat, // Flat pointer to user stack + IN USHORT UserStackSize, // User stack size + IN SEL UserStackSel, // Data selector to user stack + IN SEL UserStackAlias, // Code selector to user stack + IN PVOID pNcb, // 16 bit SEG:OFF ptr to NCB + IN UCHAR NcbRetCode // return code from NCB + ); + +APIRET +Od2AttachWinThreadToOs2(VOID); + +UCHAR +Od2Netbios( + IN PNCB pncb, + IN HANDLE hDev, + OUT PBOOLEAN WillPost OPTIONAL + ); + +// +// the following 2 are imported from win32 +// + +LONG +InterlockedIncrement( + PLONG lpAddend + ); + +LONG +InterlockedDecrement( + PLONG lpAddend + ); + + +// +// the following is from net\inc\rxp.h +// +APIRET +RxpTransactSmb( + IN LPTSTR UncServerName, + IN LPTSTR TransportName, + IN LPVOID SendParmPtr, + IN DWORD SendParmSize, + IN LPVOID SendDataPtr OPTIONAL, + IN DWORD SendDataSize, + OUT LPVOID RetParmPtr OPTIONAL, + IN DWORD RetParmSize, + OUT LPVOID RetDataPtr OPTIONAL, + IN OUT LPDWORD RetDataSize, + IN BOOL NoPermissionRequired + ); + +APIRET +VrRemoteApi( + IN DWORD ApiNumber, + IN LPSTR ServerNamePointer, + IN LPSTR ParameterDescriptor, + IN LPSTR DataDescriptor, + IN LPSTR AuxDescriptor, + IN BOOL NullSessionFlag + ); + +APIRET +VrEncryptSES( + IN LPSTR ServerNamePointer, + IN LPSTR passwordPointer, // Input password (Not encripted) + IN LPSTR encryptedLmOwfPassword // output password (encripted) + ); + + + + +//***************************************************************************** +// +//Following are a number of Unicode conversion routines used in the LanMan APIs +// +//***************************************************************************** + + +// +// Get the length of a Unicode string (Adjusted) +// +ULONG +UWstrlen(LPWSTR s) +{ + ULONG i = 0; + + if (s == NULL) { + return(0); + } + + while (*s++ != UNICODE_NULL) { + i++; + } + return(i); +} + + +ULONG +UTstrlen(LPTSTR s) +{ + ULONG i = 0; + + if (s == NULL) { + return(0); + } + + while (*s++ != 0) { + i++; + } + return(i); +} + + +// +// Copy a Unicode string to Ansi string +// +PCHAR +UW2ANSIstrcpy(PCHAR d, LPWSTR s) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = '\0'; + return(d); + } + + RtlInitUnicodeString(&str_u, (PWSTR) s); + + str_a.Buffer = d; + str_a.MaximumLength = 0xffff; + + Od2UnicodeStringToMBString(&str_a, &str_u, FALSE); + + d[str_a.Length] = '\0'; + + return(d); +} + + +PCHAR +UT2ANSIstrcpy(PCHAR d, LPTSTR s) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = '\0'; + return(d); + } + + RtlInitUnicodeString(&str_u, (PWSTR) s); + + str_a.Buffer = d; + str_a.MaximumLength = 0xffff; + + Od2UnicodeStringToMBString(&str_a, &str_u, FALSE); + + d[str_a.Length] = '\0'; + + return(d); +} + + +// +// Copy a Unicode string to Ansi string with a limit on the # of copied chars +// +PCHAR +UW2ANSIstrncpy(PCHAR d, LPWSTR s, ULONG Limit) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = '\0'; + return(d); + } + + RtlInitUnicodeString(&str_u, (PWSTR) s); + + str_a.Buffer = d; + str_a.MaximumLength = (USHORT) Limit; + + if (Od2UnicodeStringToMBString(&str_a, &str_u, FALSE) == NO_ERROR) { + + if ((ULONG) str_a.Length < Limit) { + d[str_a.Length] = '\0'; + } + + } else { + + if (Od2UnicodeStringToMBString(&str_a, &str_u, TRUE) == NO_ERROR) { + + RtlMoveMemory(d, str_a.Buffer, Limit); + Od2FreeMBString(&str_a); + + } else { + d[0] = '\0'; + } + } + + return(d); +} + + +PCHAR +UT2ANSIstrncpy(PCHAR d, LPTSTR s, ULONG Limit) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = '\0'; + return(d); + } + + RtlInitUnicodeString(&str_u, (PWSTR) s); + + str_a.Buffer = d; + str_a.MaximumLength = (USHORT) Limit; + + if (Od2UnicodeStringToMBString(&str_a, &str_u, FALSE) == NO_ERROR) { + + if ((ULONG) str_a.Length < Limit) { + d[str_a.Length] = '\0'; + } + + } else { + + if (Od2UnicodeStringToMBString(&str_a, &str_u, TRUE) == NO_ERROR) { + + RtlMoveMemory(d, str_a.Buffer, Limit); + Od2FreeMBString(&str_a); + + } else { + d[0] = '\0'; + } + } + + return(d); +} + + +// +// Copy an ANSI string to Unicode string +// +LPWSTR +ANSI2UWstrcpy(LPWSTR d, PCHAR s) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = UNICODE_NULL; + return(d); + } + + Od2InitMBString(&str_a, (PCSZ) s); + + str_u.Buffer = (PWSTR) d; + str_u.MaximumLength = 0xffff; + + Od2MBStringToUnicodeString(&str_u, &str_a, FALSE); + + d[str_u.Length/sizeof(WCHAR)] = UNICODE_NULL; + + return(d); +} + + +LPTSTR +ANSI2UTstrcpy(LPTSTR d, PCHAR s) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = UNICODE_NULL; + return(d); + } + + Od2InitMBString(&str_a, (PCSZ) s); + + str_u.Buffer = (PWSTR) d; + str_u.MaximumLength = 0xffff; + + Od2MBStringToUnicodeString(&str_u, &str_a, FALSE); + + d[str_u.Length/sizeof(WCHAR)] = 0; + + return(d); +} + + +// +// Copy an Ansi string to a Unicode string with a limit on the # of copied chars +// +LPWSTR +ANSI2UWstrncpy(LPWSTR d, PCHAR s, ULONG Limit) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = UNICODE_NULL; + return(d); + } + + Od2InitMBString(&str_a, s); + + str_u.Buffer = (PWSTR) d; + str_u.MaximumLength = (USHORT) (Limit * sizeof(WCHAR)); + + if (Od2MBStringToUnicodeString(&str_u, &str_a, FALSE) == NO_ERROR) { + + if (str_u.Length < str_u.MaximumLength) { + d[str_u.Length/sizeof(WCHAR)] = UNICODE_NULL; + } + + } else { + + if (Od2MBStringToUnicodeString(&str_u, &str_a, TRUE) == NO_ERROR) { + + RtlMoveMemory(d, str_u.Buffer, Limit * sizeof(WCHAR)); + RtlFreeUnicodeString(&str_u); + + } else { + d[0] = UNICODE_NULL; + } + } + + return(d); +} + + +LPTSTR +ANSI2UTstrncpy(LPTSTR d, PCHAR s, ULONG Limit) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + *d = 0; + return(d); + } + + Od2InitMBString(&str_a, s); + + str_u.Buffer = (PWSTR) d; + str_u.MaximumLength = (USHORT) (Limit * sizeof(WCHAR)); + + if (Od2MBStringToUnicodeString(&str_u, &str_a, FALSE) == NO_ERROR) { + + if (str_u.Length < str_u.MaximumLength) { + d[str_u.Length/sizeof(WCHAR)] = 0; + } + + } else { + + if (Od2MBStringToUnicodeString(&str_u, &str_a, TRUE) == NO_ERROR) { + + RtlMoveMemory(d, str_u.Buffer, Limit * sizeof(WCHAR)); + RtlFreeUnicodeString(&str_u); + + } else { + d[0] = 0; + } + } + + return(d); +} + + +LPTSTR +ANSI2UTmemcpy(LPTSTR d, PCHAR s, ULONG count) +{ + ANSI_STRING str_a; + UNICODE_STRING str_u; + + if (s == NULL) { + return(d); + } + + str_a.Buffer = s; + str_a.MaximumLength = str_a.Length = (USHORT) count; + + str_u.Buffer = (PWSTR) d; + str_u.MaximumLength = 0xffff; + + Od2MBStringToUnicodeString(&str_u, &str_a, FALSE); + + return(d); +} + + + +//***************************************************************************** +// +//Following are the LanMan API +// +//***************************************************************************** + +// Most LanMan APIs are implemented with the following sequence: +// copy input from user's buffer to internal buffer while convertine ansi to unicode +// call win32 lanman api +// copy output from lanman api internal buffer to user's buffer +// +// for Enum type APIs, a loop is used to get as much data as possible. + + + +// a small macro to copy a string from the internal net buffer to user's buffer +#define CopyUW2ANSI(d, s) \ + StringLen = UWstrlen(s) + 1; \ + CurEndOfBuffer -= StringLen; \ + d = (char *)FLATTOFARPTR(CurEndOfBuffer); \ + UW2ANSIstrcpy(CurEndOfBuffer, s); + + +APIRET +Od2QueryNPHInfo( + HPIPE hpipe, + PULONG pCollectDataTime, + PULONG pMaxCollectionCount + ) +{ + NTSTATUS Status; + APIRET RetCode; + IO_STATUS_BLOCK IoStatusBlock; + PFILE_HANDLE hFileRecord; + FILE_PIPE_REMOTE_INFORMATION PipeRemoteInfoBuf; + LARGE_INTEGER LargeCollectDataTime; + #if DBG + PSZ RoutineName; + RoutineName = "Od2QueryNPHInfo"; + #endif + + AcquireFileLockShared( + #if DBG + RoutineName + #endif + ); + + // + // Check for invalid handle. + // + RetCode = DereferenceFileHandle(hpipe, &hFileRecord); + if (RetCode) { + ReleaseFileLockShared( + #if DBG + RoutineName + #endif + ); + return ERROR_INVALID_HANDLE; + } + + ReleaseFileLockShared( + #if DBG + RoutineName + #endif + ); + + if (hFileRecord->FileType != FILE_TYPE_NMPIPE) { +#if DBG + IF_OD2_DEBUG( PIPES ) { + KdPrint(("DosQueryPNHState: File Type != NMPIPE hpipe %d\n", + hpipe)); + } +#endif + return ERROR_BAD_PIPE; + } + + Status = NtQueryInformationFile(hFileRecord->NtHandle, + &IoStatusBlock, + &PipeRemoteInfoBuf, + sizeof(FILE_PIPE_REMOTE_INFORMATION), + FilePipeRemoteInformation); + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( PIPES ) { + KdPrint(("DosQueryPNHState: NtqueryInformation error: Status %ld\n", + Status)); + } +#endif + return ERROR_BAD_PIPE; // BUGBUG bogus + } + + // + // Translate Information to OS/2 style values + // + + LargeCollectDataTime = RtlExtendedLargeIntegerDivide( + PipeRemoteInfoBuf.CollectDataTime, 10000, NULL); + *pCollectDataTime = LargeCollectDataTime.LowPart; + *pMaxCollectionCount = PipeRemoteInfoBuf.MaximumCollectionCount; + + return (NO_ERROR); +} + + +APIRET +Net16GetDCName( + IN PCHAR pszServer, + IN PCHAR pszDomain, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer + ) +{ + WCHAR Server[UNCLEN]; + WCHAR Domain[DNLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszDomain); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + ANSI2UWstrncpy(Server, pszServer, UNCLEN); + ANSI2UWstrncpy(Domain, pszDomain, DNLEN); + + rc = NetGetDCName(Server, Domain, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + if (UWstrlen((LPWSTR) BufPtr) + 1 > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UW2ANSIstrcpy((PCHAR) pbBuffer, (LPWSTR) BufPtr); + + NetApiBufferFree(BufPtr); + + return(NO_ERROR); +} + + +APIRET +Net16HandleGetInfo( + IN HANDLE hHandle, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + NET_API_STATUS rc; + struct handle_info_1 *pOs2Info1; + ULONG CharTime; + ULONG CharCount; + + if (sLevel != 1) { + return(ERROR_INVALID_PARAMETER); + } + + try { + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + *pcbTotalAvail = sizeof(struct handle_info_1); + if (sizeof(struct handle_info_1) > cbBuffer) { + return(NERR_BufTooSmall); + } + + rc = Od2QueryNPHInfo(hHandle, &CharTime, &CharCount); + if (rc != NO_ERROR) { + return (rc); + } + pOs2Info1 = (struct handle_info_1*)pbBuffer; + pOs2Info1->hdli1_chartime = CharTime; + pOs2Info1->hdli1_charcount = (unsigned short)CharCount; + + return(NO_ERROR); +} + + +APIRET +Net16ServerDiskEnum( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcEntriesRead, + OUT PUSHORT pcTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PWCHAR pInfo; + PCHAR pOs2Info; + ULONG OutBufSize; + DWORD EntriesRead; + DWORD i; + DWORD ResumeHandle; + DWORD TotalEntries; + ULONG StringLen; + int TotalAvailNotSet = TRUE; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcTotalAvail,sizeof(*pcTotalAvail),1); + Od2ProbeForWrite(pcEntriesRead,sizeof(*pcEntriesRead),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 0) { + return(ERROR_INVALID_PARAMETER); + } + + OutBufSize = cbBuffer; + ResumeHandle = 0; + pOs2Info = (PCHAR)pbBuffer; + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + rc = ERROR_MORE_DATA; + + while (rc == ERROR_MORE_DATA) { + + rc = NetServerDiskEnum(Server, 0, &BufPtr, PREFMAXLEN, + &EntriesRead, &TotalEntries, &ResumeHandle); + + if ((rc != NO_ERROR) && (rc != ERROR_MORE_DATA)) { + return(rc); + } + + if (TotalAvailNotSet) { + *pcTotalAvail = (USHORT) TotalEntries; + *pcEntriesRead = 0; + TotalAvailNotSet = FALSE; + } + + pInfo = (PWCHAR) BufPtr; + + for (i = 0; i < EntriesRead; i++) { + + StringLen = UWstrlen(pInfo) + 1; + + if ((StringLen + 1) > OutBufSize) { + if (cbBuffer > 0) { // if 0 length buffer, unable to return anything + *pOs2Info = '\0'; // The terminating NUL + } + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= StringLen; + + UW2ANSIstrcpy(pOs2Info, pInfo); + + pOs2Info += strlen(pOs2Info) + 1; + pInfo += StringLen; + + (*pcEntriesRead)++; + } + *pOs2Info = '\0'; // The terminating NUL + NetApiBufferFree(BufPtr); + } + + return(rc); +} + + +APIRET +Net16ServerEnum2( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcEntriesRead, + OUT PUSHORT pcTotalAvail, + IN ULONG flServerType, + IN PCHAR pszDomain + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Domain[CNLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSERVER_INFO_101 pInfo101; + struct server_info_0 *pOs2Info0; + struct server_info_1 *pOs2Info1; + PCHAR pEndOfBuffer; + ULONG StringLen; + DWORD ResumeHandle; + ULONG OutBufSize; + DWORD EntriesRead; + DWORD TotalEntries; + DWORD i; + int TotalAvailNotSet = TRUE; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszDomain); + Od2ProbeForWrite(pcTotalAvail,sizeof(*pcTotalAvail),1); + Od2ProbeForWrite(pcEntriesRead,sizeof(*pcEntriesRead),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1)) { + return(ERROR_INVALID_PARAMETER); + } + + pEndOfBuffer = pbBuffer + cbBuffer; + OutBufSize = cbBuffer; + ResumeHandle = 0; + pOs2Info0 = (struct server_info_0 *)pbBuffer; + pOs2Info1 = (struct server_info_1 *)pbBuffer; + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(Domain, pszDomain, CNLEN); + rc = ERROR_MORE_DATA; + + while (rc == ERROR_MORE_DATA) { + + rc = NetServerEnum(Server, 101L, &BufPtr, PREFMAXLEN, + &EntriesRead, &TotalEntries, + flServerType, Domain, &ResumeHandle); + + if ((rc != NO_ERROR) && (rc != ERROR_MORE_DATA)) { + return(rc); + } + + if (TotalAvailNotSet) { + *pcTotalAvail = (USHORT) TotalEntries; + *pcEntriesRead = 0; + TotalAvailNotSet = FALSE; + } + + pInfo101 = (PSERVER_INFO_101) BufPtr; + + for (i = 0; i < EntriesRead; i++) { + if (sLevel == 0) { + if (sizeof(struct server_info_0) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct server_info_0); + + UT2ANSIstrncpy(pOs2Info0->sv0_name, (pInfo101 + i)->sv101_name, CNLEN_LM20); + pOs2Info0->sv0_name[CNLEN_LM20] = '\0'; + pOs2Info0++; + } + else if (sLevel == 1) { + StringLen = UTstrlen((pInfo101 + i)->sv101_comment) + 1; + if ((sizeof(struct server_info_1) + StringLen) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct server_info_1) + StringLen; + + UT2ANSIstrncpy(pOs2Info1->sv1_name, (pInfo101 + i)->sv101_name, CNLEN_LM20); + pOs2Info1->sv1_name[CNLEN_LM20] = '\0'; + pEndOfBuffer -= StringLen; + UT2ANSIstrcpy(pEndOfBuffer, (pInfo101 + i)->sv101_comment); + pOs2Info1->sv1_comment = (char *)FLATTOFARPTR(pEndOfBuffer); + + pOs2Info1->sv1_version_major = (unsigned char)(pInfo101 + i)->sv101_version_major; + pOs2Info1->sv1_version_minor = (unsigned char)(pInfo101 + i)->sv101_version_minor; + pOs2Info1->sv1_type = (pInfo101 + i)->sv101_type; + pOs2Info1++; + } + (*pcEntriesRead)++; + } + + NetApiBufferFree(BufPtr); + } + + return(rc); +} + + +APIRET +Net16ServerGetInfo( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + LPBYTE BufPtr1; + LPBYTE BufPtr2; + NET_API_STATUS rc; + PSERVER_INFO_102 pInfo102; + PSERVER_INFO_502 pInfo502; + struct server_info_0 *pOs2Info0; + struct server_info_1 *pOs2Info1; + struct server_info_2 *pOs2Info2; + struct server_info_3 *pOs2Info3; + PCHAR pStrings; + PCHAR pEndOfBuffer; + ULONG StringLen; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel > 3) { +#if DBG + KdPrint(("NetServerGetInfo: non supported sLevel %d\n", sLevel)); +#endif + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + rc = NetServerGetInfo(Server, 102L, &BufPtr1); + + if (rc != NO_ERROR) { + return(rc); + } + + rc = NetServerGetInfo(Server, 502L, &BufPtr2); + + if (rc != NO_ERROR) { + NetApiBufferFree(BufPtr1); + return(rc); + } + + RtlZeroMemory(pbBuffer, cbBuffer); + pInfo102 = (PSERVER_INFO_102) BufPtr1; + pInfo502 = (PSERVER_INFO_502) BufPtr2; + pEndOfBuffer = pbBuffer + cbBuffer; + pOs2Info0 = (struct server_info_0 *)pbBuffer; + pOs2Info1 = (struct server_info_1 *)pbBuffer; + pOs2Info2 = (struct server_info_2 *)pbBuffer; + pOs2Info3 = (struct server_info_3 *)pbBuffer; + + switch (sLevel) { + + case 0: + + *pcbTotalAvail = (USHORT)(sizeof(struct server_info_0)); + if (sizeof(struct server_info_0) > cbBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + break; + + case 1: + + pStrings = pbBuffer + sizeof(struct server_info_1); + + StringLen = UTstrlen(pInfo102->sv102_comment) + 1; + *pcbTotalAvail = (USHORT)(StringLen + sizeof(struct server_info_1)); + if (pStrings + StringLen > pEndOfBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + break; + + case 2: + + pStrings = pbBuffer + sizeof(struct server_info_2); + + StringLen = UTstrlen(pInfo102->sv102_userpath) + 1; + *pcbTotalAvail = (USHORT)(StringLen + sizeof(struct server_info_2)); + if (pStrings + StringLen > pEndOfBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + break; + + case 3: + + pStrings = pbBuffer + sizeof(struct server_info_3); + + StringLen = UTstrlen(pInfo102->sv102_userpath) + 1; + *pcbTotalAvail = (USHORT)(StringLen + sizeof(struct server_info_3)); + if (pStrings + StringLen > pEndOfBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + break; + } + + switch (sLevel) { + + case 3: + + /* + pOs2Info3->sv3_auditedevents = pInfo403->sv403_auditedevents; + pOs2Info3->sv3_autoprofile = (unsigned short)pInfo403->sv403_autoprofile; + + StringLen = UTstrlen(pInfo403->sv403_autopath) + 1; + UT2ANSIstrcpy(pStrings, pInfo403->sv403_autopath); + pOs2Info3->sv3_autopath = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + */ + + case 2: + + /* + pOs2Info2->sv2_ulist_mtime = pInfo403->sv403_ulist_mtime; + pOs2Info2->sv2_glist_mtime = pInfo403->sv403_glist_mtime; + pOs2Info2->sv2_alist_mtime = pInfo403->sv403_alist_mtime; + */ + pOs2Info2->sv2_users = (unsigned short)pInfo102->sv102_users; + pOs2Info2->sv2_disc = (unsigned short)pInfo102->sv102_disc; + + /* + StringLen = UTstrlen(pInfo403->sv403_alerts) + 1; + UT2ANSIstrcpy(pStrings, pInfo403->sv403_alerts); + pOs2Info2->sv2_alerts = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + pOs2Info2->sv2_security = (unsigned short)pInfo403->sv403_security; + pOs2Info2->sv2_auditing = 0; + pOs2Info2->sv2_numadmin = (unsigned short)pInfo403->sv403_numadmin; + pOs2Info2->sv2_lanmask = (unsigned short)pInfo403->sv403_lanmask; + */ + pOs2Info2->sv2_hidden = (unsigned short)pInfo102->sv102_hidden; + pOs2Info2->sv2_announce = (unsigned short)pInfo102->sv102_announce; + pOs2Info2->sv2_anndelta = (unsigned short)pInfo102->sv102_anndelta; + + /* + UT2ANSIstrncpy(pOs2Info2->sv2_guestacct, pInfo403->sv403_guestacct, UNLEN_LM20); + pOs2Info2->sv2_guestacct[UNLEN_LM20] = '\0'; + */ + + StringLen = UTstrlen(pInfo102->sv102_userpath) + 1; + UT2ANSIstrcpy(pStrings, pInfo102->sv102_userpath); + pOs2Info2->sv2_userpath = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + +// PQPQ pOs2Info2->sv2_chdevs = (unsigned short)pInfo403->sv403_chdevs; + pOs2Info2->sv2_chdevs = 100; + /* + pOs2Info2->sv2_chdevq = (unsigned short)pInfo403->sv403_chdevq; + pOs2Info2->sv2_chdevjobs = (unsigned short)pInfo403->sv403_chdevjobs; + pOs2Info2->sv2_connections = (unsigned short)pInfo403->sv403_connections; + pOs2Info2->sv2_shares = (unsigned short)pInfo403->sv403_shares; + pOs2Info2->sv2_openfiles = (unsigned short)pInfo403->sv403_openfiles; + */ + pOs2Info2->sv2_sessopens = (unsigned short)pInfo502->sv502_sessopens; + pOs2Info2->sv2_sessvcs = (unsigned short)pInfo502->sv502_sessvcs; + /* + pOs2Info2->sv2_sessreqs = (unsigned short)pInfo403->sv403_sessreqs; + */ + pOs2Info2->sv2_opensearch = (unsigned short)pInfo502->sv502_opensearch; + /* + pOs2Info2->sv2_activelocks = (unsigned short)pInfo403->sv403_activelocks; + pOs2Info2->sv2_numreqbuf = (unsigned short)pInfo403->sv403_numreqbuf; + */ + pOs2Info2->sv2_sizreqbuf = (unsigned short)pInfo502->sv502_sizreqbuf; + /* + pOs2Info2->sv2_numbigbuf = (unsigned short)pInfo403->sv403_numbigbuf; + pOs2Info2->sv2_numfiletasks= (unsigned short)pInfo403->sv403_numfiletasks; + pOs2Info2->sv2_alertsched = (unsigned short)pInfo403->sv403_alertsched; + pOs2Info2->sv2_erroralert = (unsigned short)pInfo403->sv403_erroralert; + pOs2Info2->sv2_logonalert = (unsigned short)pInfo403->sv403_logonalert; + pOs2Info2->sv2_accessalert = (unsigned short)pInfo403->sv403_accessalert; + pOs2Info2->sv2_diskalert = (unsigned short)pInfo403->sv403_diskalert; + pOs2Info2->sv2_netioalert = (unsigned short)pInfo403->sv403_netioalert; + pOs2Info2->sv2_maxauditsz = (unsigned short)pInfo403->sv403_maxauditsz; + + StringLen = UTstrlen(pInfo403->sv403_srvheuristics) + 1; + UT2ANSIstrcpy(pStrings, pInfo403->sv403_srvheuristics); + pOs2Info2->sv2_srvheuristics = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + */ + + case 1: + + StringLen = UTstrlen(pInfo102->sv102_comment) + 1; + UT2ANSIstrcpy(pStrings, pInfo102->sv102_comment); + pOs2Info1->sv1_comment = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + pOs2Info1->sv1_version_major = (unsigned char)pInfo102->sv102_version_major; + pOs2Info1->sv1_version_minor = (unsigned char)pInfo102->sv102_version_minor; + pOs2Info1->sv1_type = (unsigned long)pInfo102->sv102_type; + + case 0: + + UT2ANSIstrncpy(pOs2Info0->sv0_name, pInfo102->sv102_name, CNLEN_LM20); + pOs2Info0->sv0_name[CNLEN_LM20] = '\0'; + break; + } + + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + + return(NO_ERROR); +} + + +APIRET +Net16ServiceControl( + IN PCHAR pszServer, + IN PCHAR pszService, + IN ULONG fbOpCode, + IN ULONG fbArg, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Service[SNLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSERVICE_INFO_2 pInfo2; + struct service_info_2 *pOs2Info2; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszService); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + // OS/2 services are limited to 15 chars + // workaround an important NT service whose name is longer than 15 chars + + if (!_stricmp(pszService, N_Workstation)) { + ANSI2UTstrcpy(Service, N_LanmanWorkstation); + } + if (!_stricmp(pszService, N_Server)) { + ANSI2UTstrcpy(Service, N_LanmanServer); + } + else { + ANSI2UTstrncpy(Service, pszService, SNLEN); + } + + rc = NetServiceControl(Server, Service, fbOpCode, fbArg, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + if (sizeof(struct service_info_2) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + pInfo2 = (PSERVICE_INFO_2) BufPtr; + pOs2Info2 = (struct service_info_2 *)pbBuffer; + UT2ANSIstrncpy(pOs2Info2->svci2_name, pInfo2->svci2_name, SNLEN_LM20); + pOs2Info2->svci2_name[SNLEN_LM20] = '\0'; + if (!_stricmp(N_LanmanWorkstati, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Workstation); + } + else if (!_stricmp(N_LanmanServer, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Server); + } + UT2ANSIstrncpy(pOs2Info2->svci2_text, pInfo2->svci2_text, STXTLEN_LM20); + pOs2Info2->svci2_text[STXTLEN_LM20] = '\0'; + pOs2Info2->svci2_status = (unsigned short)pInfo2->svci2_status; + pOs2Info2->svci2_code = (unsigned long)pInfo2->svci2_code; + pOs2Info2->svci2_pid = (unsigned short)pInfo2->svci2_pid; + + NetApiBufferFree(BufPtr); + + return(NO_ERROR); +} + + +APIRET +Net16ServiceEnum( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcEntriesRead, + OUT PUSHORT pcTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSERVICE_INFO_0 pInfo0; + PSERVICE_INFO_1 pInfo1; + PSERVICE_INFO_2 pInfo2; + struct service_info_0 *pOs2Info0; + struct service_info_1 *pOs2Info1; + struct service_info_2 *pOs2Info2; + DWORD ResumeHandle; + ULONG OutBufSize; + DWORD EntriesRead; + DWORD TotalEntries; + DWORD i; + int TotalAvailNotSet = TRUE; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcTotalAvail,sizeof(*pcTotalAvail),1); + Od2ProbeForWrite(pcEntriesRead,sizeof(*pcEntriesRead),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 2)) { + return(ERROR_INVALID_PARAMETER); + } + + OutBufSize = cbBuffer; + ResumeHandle = 0; + pOs2Info0 = (struct service_info_0 *)pbBuffer; + pOs2Info1 = (struct service_info_1 *)pbBuffer; + pOs2Info2 = (struct service_info_2 *)pbBuffer; + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + rc = ERROR_MORE_DATA; + + while (rc == ERROR_MORE_DATA) { + + rc = NetServiceEnum(Server, sLevel, &BufPtr, PREFMAXLEN, + &EntriesRead, &TotalEntries, &ResumeHandle); + + if ((rc != NO_ERROR) && (rc != ERROR_MORE_DATA)) { + return(rc); + } + + if (TotalAvailNotSet) { + *pcTotalAvail = (USHORT) TotalEntries; + *pcEntriesRead = 0; + TotalAvailNotSet = FALSE; + } + + for (i = 0; i < EntriesRead; i++) { + if (sLevel == 0) { + if (sizeof(struct service_info_0) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct service_info_0); + + pInfo0 = (PSERVICE_INFO_0) BufPtr + i; + UT2ANSIstrncpy(pOs2Info0->svci0_name, pInfo0->svci0_name, SNLEN_LM20); + pOs2Info0->svci0_name[SNLEN_LM20] = '\0'; + if (!_stricmp(N_LanmanWorkstati, pOs2Info0->svci0_name)) { + strcpy(pOs2Info0->svci0_name, N_Workstation); + } + else if (!_stricmp(N_LanmanServer, pOs2Info0->svci0_name)) { + strcpy(pOs2Info0->svci0_name, N_Server); + } + + pOs2Info0++; + } + else if (sLevel == 1) { + if (sizeof(struct service_info_1) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct service_info_1); + + pInfo1 = (PSERVICE_INFO_1) BufPtr + i; + UT2ANSIstrncpy(pOs2Info1->svci1_name, pInfo1->svci1_name, SNLEN_LM20); + pOs2Info1->svci1_name[SNLEN_LM20] = '\0'; + if (!_stricmp(N_LanmanWorkstati, pOs2Info1->svci1_name)) { + strcpy(pOs2Info1->svci1_name, N_Workstation); + } + else if (!_stricmp(N_LanmanServer, pOs2Info1->svci1_name)) { + strcpy(pOs2Info1->svci1_name, N_Server); + } + + pOs2Info1->svci1_status = (unsigned short)pInfo1->svci1_status; + pOs2Info1->svci1_code = (unsigned long)pInfo1->svci1_code; + pOs2Info1->svci1_pid = (unsigned short)pInfo1->svci1_pid; + + pOs2Info1++; + } + else { /* sLevel == 2 */ + if (sizeof(struct service_info_2) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct service_info_2); + + pInfo2 = (PSERVICE_INFO_2) BufPtr + i; + UT2ANSIstrncpy(pOs2Info2->svci2_name, pInfo2->svci2_name, SNLEN_LM20); + pOs2Info2->svci2_name[SNLEN_LM20] = '\0'; + if (!_stricmp(N_LanmanWorkstati, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Workstation); + } + else if (!_stricmp(N_LanmanServer, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Server); + } + + pOs2Info2->svci2_status = (unsigned short)pInfo2->svci2_status; + pOs2Info2->svci2_code = (unsigned long)pInfo2->svci2_code; + pOs2Info2->svci2_pid = (unsigned short)pInfo2->svci2_pid; + + UT2ANSIstrncpy(pOs2Info2->svci2_text, pInfo2->svci2_text, STXTLEN_LM20); + pOs2Info2->svci2_name[STXTLEN_LM20] = '\0'; + + pOs2Info2++; + } + (*pcEntriesRead)++; + } + + NetApiBufferFree(BufPtr); + } + + return(NO_ERROR); +} + + +APIRET +Net16ServiceGetInfo( + IN PCHAR pszServer, + IN PCHAR pszService, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Service[SNLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSERVICE_INFO_2 pInfo2; + struct service_info_2 *pOs2Info2; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszService); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 2)) { + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + // OS/2 services are limited to 15 chars + // workaround an important NT service whose name is longer than 15 chars + + if (!_stricmp(pszService, N_Workstation)) { + ANSI2UTstrcpy(Service, N_LanmanWorkstation); + } + if (!_stricmp(pszService, N_Server)) { + ANSI2UTstrcpy(Service, N_LanmanServer); + } + else { + ANSI2UTstrncpy(Service, pszService, SNLEN); + } + + rc = NetServiceGetInfo(Server, Service, 2L, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + pOs2Info2 = (struct service_info_2 *)pbBuffer; + pInfo2 = (PSERVICE_INFO_2) BufPtr; + + switch (sLevel) { + case 0: + *pcbTotalAvail = (USHORT)sizeof(struct service_info_0); + break; + + case 1: + *pcbTotalAvail = (USHORT)sizeof(struct service_info_1); + break; + + case 2: + *pcbTotalAvail = (USHORT)sizeof(struct service_info_2); + break; + } + + if (sizeof(struct service_info_0) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UT2ANSIstrncpy(pOs2Info2->svci2_name, pInfo2->svci2_name, SNLEN_LM20); + pOs2Info2->svci2_name[SNLEN_LM20] = '\0'; + if (!_stricmp(N_LanmanWorkstati, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Workstation); + } + else if (!_stricmp(N_LanmanServer, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Server); + } + + if (sLevel >= 1) { + if (sizeof(struct service_info_1) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + pOs2Info2->svci2_status = (unsigned short)pInfo2->svci2_status; + pOs2Info2->svci2_code = (unsigned long)pInfo2->svci2_code; + pOs2Info2->svci2_pid = (unsigned short)pInfo2->svci2_pid; + } + + if (sLevel >= 2) { + if (sizeof(struct service_info_2) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UT2ANSIstrncpy(pOs2Info2->svci2_text, pInfo2->svci2_text, STXTLEN_LM20); + pOs2Info2->svci2_text[STXTLEN_LM20] = '\0'; + } + + NetApiBufferFree(BufPtr); + + return(NO_ERROR); +} + + +APIRET +Net16ServiceInstall( + IN PCHAR pszServer, + IN PCHAR pszService, + IN PCHAR pszCmdArgs, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Service[SNLEN]; + TCHAR *CmdArgs; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSERVICE_INFO_2 pInfo2; + struct service_info_2 *pOs2Info2; + DWORD Argc; + DWORD TotalSizeOfStrings; + PCHAR pStrings; + PCHAR pszTmpCmdArgs; + LPTSTR StartOfString; + ULONG i; + LPTSTR Argv[64]; + + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszService); + PROBE_STRING(pszCmdArgs); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sizeof(struct service_info_2) > cbBuffer) { + return(NERR_BufTooSmall); + } + + pOs2Info2 = (struct service_info_2 *)pbBuffer; + + if (pszCmdArgs == NULL) { + pszTmpCmdArgs = ""; + } + else { + pszTmpCmdArgs = pszCmdArgs; + } + + Argc = 0; + pStrings = pszTmpCmdArgs; + + while (*pStrings) { + pStrings += strlen(pStrings) + 1; + Argc++; + } + pStrings++; // for the terminating nul character + + if (Argc > 64) { + return(ERROR_ACCESS_DENIED); + } + + TotalSizeOfStrings = pStrings - pszTmpCmdArgs; + + CmdArgs = (TCHAR *) RtlAllocateHeap(Od2Heap, 0, TotalSizeOfStrings * sizeof(TCHAR)); + + if (CmdArgs == NULL) { + return(ERROR_NOT_ENOUGH_MEMORY); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + // OS/2 services are limited to 15 chars + // workaround an important NT service whose name is longer than 15 chars + + if (!_stricmp(pszService, N_Workstation)) { + ANSI2UTstrcpy(Service, N_LanmanWorkstation); + } + if (!_stricmp(pszService, N_Server)) { + ANSI2UTstrcpy(Service, N_LanmanServer); + } + else { + ANSI2UTstrncpy(Service, pszService, SNLEN); + } + + ANSI2UTmemcpy(CmdArgs, pszTmpCmdArgs, TotalSizeOfStrings); + + StartOfString = CmdArgs; + for (i = 0; i < Argc; i++) { + Argv[i] = StartOfString; + while (*StartOfString++ != L'\0') { + ; + } + } + + rc = NetServiceInstall(Server, Service, Argc, Argv, &BufPtr); + + RtlFreeHeap(Od2Heap, 0, CmdArgs); + + if (rc != NO_ERROR) { + return(rc); + } + + pInfo2 = (PSERVICE_INFO_2) BufPtr; + + UT2ANSIstrncpy(pOs2Info2->svci2_name, pInfo2->svci2_name, SNLEN_LM20); + pOs2Info2->svci2_name[SNLEN_LM20] = '\0'; + if (!_stricmp(N_LanmanWorkstati, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Workstation); + } + else if (!_stricmp(N_LanmanServer, pOs2Info2->svci2_name)) { + strcpy(pOs2Info2->svci2_name, N_Server); + } + pOs2Info2->svci2_status = (unsigned short)pInfo2->svci2_status; + pOs2Info2->svci2_code = (unsigned long)pInfo2->svci2_code; + pOs2Info2->svci2_pid = (unsigned short)pInfo2->svci2_pid; + UT2ANSIstrncpy(pOs2Info2->svci2_text, pInfo2->svci2_text, STXTLEN_LM20); + pOs2Info2->svci2_text[STXTLEN_LM20] = '\0'; + + NetApiBufferFree(BufPtr); + + return(NO_ERROR); +} + + +APIRET +Net16ShareEnum( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcEntriesRead, + OUT PUSHORT pcTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSHARE_INFO_2 pInfo2; + struct share_info_0 *pOs2Info0; + struct share_info_1 *pOs2Info1; + struct share_info_2 *pOs2Info2; + PCHAR pEndOfBuffer; + ULONG StringLen; + DWORD ResumeHandle; + ULONG OutBufSize; + DWORD EntriesRead; + DWORD TotalEntries; + DWORD i; + int TotalAvailNotSet = TRUE; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcTotalAvail,sizeof(*pcTotalAvail),1); + Od2ProbeForWrite(pcEntriesRead,sizeof(*pcEntriesRead),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 2)) { + return(ERROR_INVALID_PARAMETER); + } + + pEndOfBuffer = pbBuffer + cbBuffer; + OutBufSize = cbBuffer; + ResumeHandle = 0; + pOs2Info0 = (struct share_info_0 *)pbBuffer; + pOs2Info1 = (struct share_info_1 *)pbBuffer; + pOs2Info2 = (struct share_info_2 *)pbBuffer; + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + rc = ERROR_MORE_DATA; + + while (rc == ERROR_MORE_DATA) { + + rc = NetShareEnum(Server, 2L, &BufPtr, PREFMAXLEN, + &EntriesRead, &TotalEntries, &ResumeHandle); + + if ((rc != NO_ERROR) && (rc != ERROR_MORE_DATA)) { + return(rc); + } + + if (TotalAvailNotSet) { + *pcTotalAvail = (USHORT) TotalEntries; + *pcEntriesRead = 0; + TotalAvailNotSet = FALSE; + } + + for (i = 0; i < EntriesRead; i++) { + pInfo2 = (PSHARE_INFO_2) BufPtr + i; + if (sLevel == 0) { + if (sizeof(struct share_info_0) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct share_info_0); + + UT2ANSIstrncpy(pOs2Info0->shi0_netname, pInfo2->shi2_netname, NNLEN_LM20); + pOs2Info0->shi0_netname[NNLEN_LM20] = '\0'; + pOs2Info0++; + } + else if (sLevel == 1) { + StringLen = UTstrlen(pInfo2->shi2_remark) + 1; + if ((sizeof(struct share_info_1) + StringLen) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct share_info_1) + StringLen; + + UT2ANSIstrncpy(pOs2Info1->shi1_netname, pInfo2->shi2_netname, NNLEN_LM20); + pOs2Info1->shi1_netname[NNLEN_LM20] = '\0'; + pEndOfBuffer -= StringLen; + UT2ANSIstrcpy(pEndOfBuffer, pInfo2->shi2_remark); + pOs2Info1->shi1_remark = (char *)FLATTOFARPTR(pEndOfBuffer); + + pOs2Info1->shi1_type = (unsigned short)pInfo2->shi2_type; + pOs2Info1++; + } + else { + StringLen = UTstrlen(pInfo2->shi2_remark) + 1 + + UTstrlen(pInfo2->shi2_path) + 1 ; + if ((sizeof(struct share_info_2) + StringLen) > OutBufSize) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + OutBufSize -= sizeof(struct share_info_2) + StringLen; + + UT2ANSIstrncpy(pOs2Info2->shi2_netname, pInfo2->shi2_netname, NNLEN_LM20); + pOs2Info2->shi2_netname[NNLEN_LM20] = '\0'; + UT2ANSIstrncpy(pOs2Info2->shi2_passwd, pInfo2->shi2_passwd, SHPWLEN_LM20); + pOs2Info2->shi2_passwd[SHPWLEN_LM20] = '\0'; + pEndOfBuffer -= UTstrlen(pInfo2->shi2_remark) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo2->shi2_remark); + pOs2Info2->shi2_remark = (char *)FLATTOFARPTR(pEndOfBuffer); + pEndOfBuffer -= UTstrlen(pInfo2->shi2_path) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo2->shi2_path); + pOs2Info2->shi2_path = (char *)FLATTOFARPTR(pEndOfBuffer); + + pOs2Info2->shi2_type = (unsigned short)pInfo2->shi2_type; + pOs2Info2->shi2_permissions = (unsigned short)pInfo2->shi2_permissions; + pOs2Info2->shi2_max_uses = (unsigned short)pInfo2->shi2_max_uses; + pOs2Info2->shi2_current_uses = (unsigned short)pInfo2->shi2_current_uses; + pOs2Info2++; + } + (*pcEntriesRead)++; + } + + NetApiBufferFree(BufPtr); + } + + return(NO_ERROR); +} + + +APIRET +Net16ShareGetInfo( + IN PCHAR pszServer, + IN PCHAR pszNetName, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + TCHAR NetName[NNLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PSHARE_INFO_2 pInfo2; + PCHAR pEndOfBuffer; + ULONG TotalStringLen; + ULONG StringLen; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszNetName); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 3)) { + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(NetName, pszNetName, NNLEN); + + rc = NetShareGetInfo(Server, NetName, 2L, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + pEndOfBuffer = pbBuffer; + pInfo2 = (PSHARE_INFO_2) BufPtr; + + if (sLevel == 0) { + struct share_info_0 *pOs2Info0; + + *pcbTotalAvail = (USHORT)sizeof(struct share_info_0); + if (sizeof(struct share_info_0) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + pOs2Info0 = (struct share_info_0 *)pbBuffer; + UT2ANSIstrncpy(pOs2Info0->shi0_netname, pInfo2->shi2_netname, NNLEN_LM20); + pOs2Info0->shi0_netname[NNLEN_LM20] = '\0'; + } + else if (sLevel == 1) { + struct share_info_1 *pOs2Info1; + + TotalStringLen = UTstrlen(pInfo2->shi2_remark) + 1; + *pcbTotalAvail = (USHORT)(TotalStringLen + sizeof(struct share_info_1)); + if ((sizeof(struct share_info_1) + TotalStringLen) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + pOs2Info1 = (struct share_info_1 *)pbBuffer; + UT2ANSIstrncpy(pOs2Info1->shi1_netname, pInfo2->shi2_netname, NNLEN_LM20); + pOs2Info1->shi1_netname[NNLEN_LM20] = '\0'; + pEndOfBuffer += sizeof(struct share_info_1); + StringLen = UTstrlen(pInfo2->shi2_remark) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo2->shi2_remark); + pOs2Info1->shi1_remark = (char *)FLATTOFARPTR(pEndOfBuffer); + pEndOfBuffer += StringLen; + + pOs2Info1->shi1_type = (unsigned short)pInfo2->shi2_type; + } + else { + struct share_info_2 *pOs2Info2; + + TotalStringLen = UTstrlen(pInfo2->shi2_remark) + 1 + + UTstrlen(pInfo2->shi2_path) + 1 ; + *pcbTotalAvail = (USHORT)(TotalStringLen + sizeof(struct share_info_2)); + if ((sizeof(struct share_info_2) + TotalStringLen) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + pOs2Info2 = (struct share_info_2 *)pbBuffer; + UT2ANSIstrncpy(pOs2Info2->shi2_netname, pInfo2->shi2_netname, NNLEN_LM20); + pOs2Info2->shi2_netname[NNLEN_LM20] = '\0'; + UT2ANSIstrncpy(pOs2Info2->shi2_passwd, pInfo2->shi2_passwd, SHPWLEN_LM20); + pOs2Info2->shi2_passwd[SHPWLEN_LM20] = '\0'; + pEndOfBuffer += sizeof(struct share_info_2); + StringLen = UTstrlen(pInfo2->shi2_remark) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo2->shi2_remark); + pOs2Info2->shi2_remark = (char *)FLATTOFARPTR(pEndOfBuffer); + pEndOfBuffer += StringLen; + StringLen = UTstrlen(pInfo2->shi2_path) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo2->shi2_path); + pOs2Info2->shi2_path = (char *)FLATTOFARPTR(pEndOfBuffer); + pEndOfBuffer += StringLen; + + pOs2Info2->shi2_type = (unsigned short)pInfo2->shi2_type; + pOs2Info2->shi2_permissions = (unsigned short)pInfo2->shi2_permissions; + pOs2Info2->shi2_max_uses = (unsigned short)pInfo2->shi2_max_uses; + pOs2Info2->shi2_current_uses = (unsigned short)pInfo2->shi2_current_uses; + } + + NetApiBufferFree(BufPtr); + + return(NO_ERROR); +} + + +APIRET +Net16UseAdd( + IN PCHAR pszServer, + IN LONG sLevel, + IN PCHAR pbBuffer, + IN ULONG cbBuffer + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Local[DEVLEN]; + TCHAR Remote[RMLEN]; + TCHAR Password[PWLEN]; + USE_INFO_1 Info1; + struct use_info_1 *pInfo1; + + try { + PROBE_STRING(pszServer); + Od2ProbeForRead(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 1) { + return(ERROR_INVALID_PARAMETER); + } + + if (cbBuffer < sizeof(struct use_info_1)) { + return(NERR_BufTooSmall); + } + + pInfo1 = (struct use_info_1 *) pbBuffer; + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(Local, pInfo1->ui1_local, DEVLEN); + Info1.ui1_local = Local; + ANSI2UTstrncpy(Remote, FARPTRTOFLAT(pInfo1->ui1_remote), RMLEN); + Info1.ui1_remote = Remote; + + if (pInfo1->ui1_password == NULL) { + Info1.ui1_password = NULL; + } + else { + ANSI2UTstrncpy(Password, FARPTRTOFLAT(pInfo1->ui1_password), PWLEN); + Info1.ui1_password = Password; + } + + Info1.ui1_status = pInfo1->ui1_status; + Info1.ui1_asg_type = pInfo1->ui1_asg_type; + Info1.ui1_refcount = pInfo1->ui1_refcount; + Info1.ui1_usecount = pInfo1->ui1_usecount; + + return (NetUseAdd(Server, sLevel, (LPBYTE)&Info1, NULL)); +} + + +APIRET +Net16UseDel( + IN PCHAR pszServer, + IN PCHAR pszUseName, + IN ULONG usForce + ) +{ + TCHAR Server[UNCLEN]; + TCHAR UseName[RMLEN]; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszUseName); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(UseName, pszUseName, RMLEN); + + return (NetUseDel(Server, UseName, usForce)); +} + + +APIRET +Net16UseEnum( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcEntriesRead, + OUT PUSHORT pcTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + struct use_info_0 *pOs2Info0; + struct use_info_1 *pOs2Info1; + PUSE_INFO_0 pInfo0; + PUSE_INFO_1 pInfo1; + DWORD EntriesRead; + DWORD ResumeHandle; + DWORD TotalAvail; + DWORD i; + ULONG RemoteNameLen; + ULONG PasswordNameLen; + PCHAR CurEndOfBuffer; + ULONG OutBufSize; + int TotalAvailNotSet = TRUE; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcEntriesRead,sizeof(*pcEntriesRead),1); + Od2ProbeForWrite(pcTotalAvail,sizeof(*pcTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1)) { + return(ERROR_INVALID_PARAMETER); + } + + OutBufSize = cbBuffer; + CurEndOfBuffer = pbBuffer + cbBuffer; + pOs2Info0 = (struct use_info_0 *)pbBuffer; + pOs2Info1 = (struct use_info_1 *)pbBuffer; + + ResumeHandle = 0; + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + rc = ERROR_MORE_DATA; + + while (rc == ERROR_MORE_DATA) { + + rc = NetUseEnum(Server, sLevel, &BufPtr, PREFMAXLEN, + &EntriesRead, &TotalAvail, &ResumeHandle); + + if ((rc != NO_ERROR) && (rc != ERROR_MORE_DATA)) { + return(rc); + } + + if (TotalAvailNotSet) { + *pcTotalAvail = (USHORT) TotalAvail; + *pcEntriesRead = 0; + TotalAvailNotSet = FALSE; + } + + for (i = 0; i < EntriesRead; i++) { + if (sLevel == 0) { + pInfo0 = (PUSE_INFO_0) BufPtr + i; + RemoteNameLen = UTstrlen(pInfo0->ui0_remote) + 1; + if ((sizeof(struct use_info_0) + RemoteNameLen) > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= sizeof(struct use_info_0) + RemoteNameLen; + UT2ANSIstrncpy(pOs2Info0->ui0_local, pInfo0->ui0_local, DEVLEN_LM20); + pOs2Info0->ui0_local[DEVLEN_LM20] = '\0'; + CurEndOfBuffer -= RemoteNameLen; + UT2ANSIstrcpy(CurEndOfBuffer, pInfo0->ui0_remote); + pOs2Info0->ui0_remote = (char *)FLATTOFARPTR(CurEndOfBuffer); + + pOs2Info0++; + } + else { + pInfo1 = (PUSE_INFO_1) BufPtr + i; + RemoteNameLen = UTstrlen(pInfo1->ui1_remote) + 1; + PasswordNameLen = UTstrlen(pInfo1->ui1_password) + 1; + if ((sizeof(struct use_info_1) + RemoteNameLen + PasswordNameLen) > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= sizeof(struct use_info_1) + RemoteNameLen + PasswordNameLen; + UT2ANSIstrncpy(pOs2Info1->ui1_local, pInfo1->ui1_local, DEVLEN_LM20); + pOs2Info1->ui1_local[DEVLEN_LM20] = '\0'; + CurEndOfBuffer -= RemoteNameLen; + UT2ANSIstrcpy(CurEndOfBuffer, pInfo1->ui1_remote); + pOs2Info1->ui1_remote = (char *)FLATTOFARPTR(CurEndOfBuffer); + CurEndOfBuffer -= PasswordNameLen; + UT2ANSIstrcpy(CurEndOfBuffer, pInfo1->ui1_password); + pOs2Info1->ui1_password = (char *)FLATTOFARPTR(CurEndOfBuffer); + pOs2Info1->ui1_status = (unsigned short)pInfo1->ui1_status; + pOs2Info1->ui1_asg_type = (short)pInfo1->ui1_asg_type; + pOs2Info1->ui1_refcount = (unsigned short)pInfo1->ui1_refcount; + pOs2Info1->ui1_usecount = (unsigned short)pInfo1->ui1_usecount; + + pOs2Info1++; + } + (*pcEntriesRead)++; + } + + NetApiBufferFree(BufPtr); + } + + return(rc); +} + + +APIRET +Net16UseGetInfo( + IN PCHAR pszServer, + IN PCHAR pszUseName, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + TCHAR UseName[RMLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PCHAR pEndOfBuffer; + ULONG TotalStringLen; + ULONG StringLen; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszUseName); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1)) { + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(UseName, pszUseName, RMLEN); + + rc = NetUseGetInfo(Server, UseName, sLevel, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + pEndOfBuffer = pbBuffer; + + if (sLevel == 0) { + PUSE_INFO_0 pInfo0 = (PUSE_INFO_0) BufPtr; + struct use_info_0 *pOs2Info0 = (struct use_info_0 *)pbBuffer; + + TotalStringLen = UTstrlen(pInfo0->ui0_remote) + 1; + *pcbTotalAvail = (USHORT)(TotalStringLen + sizeof(struct use_info_0)); + if ((ULONG) *pcbTotalAvail > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UT2ANSIstrncpy(pOs2Info0->ui0_local, pInfo0->ui0_local, DEVLEN_LM20); + pOs2Info0->ui0_local[DEVLEN_LM20] = '\0'; + pEndOfBuffer += sizeof(struct use_info_0); + StringLen = TotalStringLen; + UT2ANSIstrcpy(pEndOfBuffer, pInfo0->ui0_remote); + pOs2Info0->ui0_remote = (char *)FLATTOFARPTR(pEndOfBuffer); + } + else { + PUSE_INFO_1 pInfo1 = (PUSE_INFO_1) BufPtr; + struct use_info_1 *pOs2Info1 = (struct use_info_1 *)pbBuffer; + + TotalStringLen = UTstrlen(pInfo1->ui1_remote) + 1 + + UTstrlen(pInfo1->ui1_password) + 1; + *pcbTotalAvail = (USHORT)(TotalStringLen + sizeof(struct use_info_1)); + if ((ULONG) *pcbTotalAvail > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UT2ANSIstrncpy(pOs2Info1->ui1_local, pInfo1->ui1_local, DEVLEN_LM20); + pOs2Info1->ui1_local[DEVLEN_LM20] = '\0'; + pEndOfBuffer += sizeof(struct use_info_1); + StringLen = UTstrlen(pInfo1->ui1_remote) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo1->ui1_remote); + pOs2Info1->ui1_remote = (char *)FLATTOFARPTR(pEndOfBuffer); + pEndOfBuffer += StringLen; + StringLen = UTstrlen(pInfo1->ui1_password) + 1; + UT2ANSIstrcpy(pEndOfBuffer, pInfo1->ui1_password); + pOs2Info1->ui1_password = (char *)FLATTOFARPTR(pEndOfBuffer); + pEndOfBuffer += StringLen; + + pOs2Info1->ui1_status = (unsigned short)pInfo1->ui1_status; + pOs2Info1->ui1_asg_type = (short)pInfo1->ui1_asg_type; + pOs2Info1->ui1_refcount = (unsigned short)pInfo1->ui1_refcount; + pOs2Info1->ui1_usecount = (unsigned short)pInfo1->ui1_usecount; + } + + NetApiBufferFree(BufPtr); + return(rc); +} + + +APIRET +Net16UserEnum( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcEntriesRead, + OUT PUSHORT pcTotalAvail + ) +{ + WCHAR Server[UNCLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + struct user_info_0 *pOs2Info0; + struct user_info_1 *pOs2Info1; + struct user_info_2 *pOs2Info2; + struct user_info_10 *pOs2Info10; + PUSER_INFO_0 pInfo0; + PUSER_INFO_1 pInfo1; + PUSER_INFO_2 pInfo2; + PUSER_INFO_10 pInfo10; + PCHAR CurEndOfBuffer; + ULONG StringLen; + DWORD EntriesRead; + DWORD ResumeHandle; + DWORD TotalEntries; + ULONG OutBufSize; + int TotalAvailNotSet = TRUE; + DWORD i; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcEntriesRead,sizeof(*pcEntriesRead),1); + Od2ProbeForWrite(pcTotalAvail,sizeof(*pcTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 2) && + (sLevel != 10)) { + return(ERROR_INVALID_PARAMETER); + } + + OutBufSize = cbBuffer; + CurEndOfBuffer = pbBuffer + cbBuffer; + ResumeHandle = 0; + pOs2Info0 = (struct user_info_0 *)pbBuffer; + pOs2Info1 = (struct user_info_1 *)pbBuffer; + pOs2Info2 = (struct user_info_2 *)pbBuffer; + pOs2Info10 = (struct user_info_10 *)pbBuffer; + + + ANSI2UWstrncpy(Server, pszServer, UNCLEN); + + rc = ERROR_MORE_DATA; + + while (rc == ERROR_MORE_DATA) { + + rc = NetUserEnum(Server, sLevel, + FILTER_TEMP_DUPLICATE_ACCOUNT | FILTER_NORMAL_ACCOUNT, + &BufPtr, + PREFMAXLEN, + &EntriesRead, &TotalEntries, &ResumeHandle); + + if ((rc != NO_ERROR) && (rc != ERROR_MORE_DATA)) { + return(rc); + } + + if (TotalAvailNotSet) { + *pcTotalAvail = (USHORT) TotalEntries; + *pcEntriesRead = 0; + TotalAvailNotSet = FALSE; + } + + for (i = 0; i < EntriesRead; i++) { + if (sLevel == 0) { + pInfo0 = (PUSER_INFO_0) BufPtr + i; + if (sizeof(struct user_info_0) > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= sizeof(struct user_info_0); + UW2ANSIstrncpy(pOs2Info0->usri0_name, pInfo0->usri0_name, UNLEN_LM20); + pOs2Info0->usri0_name[UNLEN_LM20] = '\0'; + + pOs2Info0++; + } + else if (sLevel == 1) { + pInfo1 = (PUSER_INFO_1) BufPtr + i; + StringLen = sizeof(struct user_info_1) + + UWstrlen(pInfo1->usri1_home_dir) + 1 + + UWstrlen(pInfo1->usri1_comment) + 1 + + UWstrlen(pInfo1->usri1_script_path) + 1; + if (StringLen > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= StringLen; + UW2ANSIstrncpy(pOs2Info1->usri1_name, pInfo1->usri1_name, UNLEN_LM20); + pOs2Info1->usri1_name[UNLEN_LM20] = '\0'; + UW2ANSIstrncpy(pOs2Info1->usri1_password, pInfo1->usri1_password, ENCRYPTED_PWLEN_LM20); + pOs2Info1->usri1_password[ENCRYPTED_PWLEN_LM20] = '\0'; + + pOs2Info1->usri1_password_age = (long)pInfo1->usri1_password_age; + pOs2Info1->usri1_priv = (unsigned short)pInfo1->usri1_priv; + + CopyUW2ANSI(pOs2Info1->usri1_home_dir, pInfo1->usri1_home_dir); + CopyUW2ANSI(pOs2Info1->usri1_comment, pInfo1->usri1_comment); + CopyUW2ANSI(pOs2Info1->usri1_script_path, pInfo1->usri1_script_path); + + pOs2Info1++; + } + else if (sLevel == 2) { + pInfo2 = (PUSER_INFO_2) BufPtr + i; + StringLen = sizeof(struct user_info_2) + + UWstrlen(pInfo2->usri2_home_dir) + 1 + + UWstrlen(pInfo2->usri2_comment) + 1 + + UWstrlen(pInfo2->usri2_script_path) + 1 + + UWstrlen(pInfo2->usri2_full_name) + 1 + + UWstrlen(pInfo2->usri2_usr_comment) + 1 + + UWstrlen(pInfo2->usri2_parms) + 1 + + UWstrlen(pInfo2->usri2_workstations) + 1 + + strlen(pInfo2->usri2_logon_hours) + 1 + + UWstrlen(pInfo2->usri2_logon_server) + 1; + if (StringLen > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= StringLen; + UW2ANSIstrncpy(pOs2Info2->usri2_name, pInfo2->usri2_name, UNLEN_LM20); + pOs2Info2->usri2_name[UNLEN_LM20] = '\0'; + UW2ANSIstrncpy(pOs2Info2->usri2_password, pInfo2->usri2_password, ENCRYPTED_PWLEN_LM20); + pOs2Info2->usri2_password[ENCRYPTED_PWLEN_LM20] = '\0'; + pOs2Info2->usri2_password_age = (long)pInfo2->usri2_password_age; + pOs2Info2->usri2_priv = (unsigned short)pInfo2->usri2_priv; + + CopyUW2ANSI(pOs2Info2->usri2_home_dir, pInfo2->usri2_home_dir); + CopyUW2ANSI(pOs2Info2->usri2_comment, pInfo2->usri2_comment); + CopyUW2ANSI(pOs2Info2->usri2_script_path, pInfo2->usri2_script_path); + + pOs2Info2->usri2_auth_flags = (unsigned long)pInfo2->usri2_auth_flags; + + CopyUW2ANSI(pOs2Info2->usri2_full_name, pInfo2->usri2_full_name); + CopyUW2ANSI(pOs2Info2->usri2_usr_comment, pInfo2->usri2_usr_comment); + CopyUW2ANSI(pOs2Info2->usri2_parms, pInfo2->usri2_parms); + CopyUW2ANSI(pOs2Info2->usri2_workstations, pInfo2->usri2_workstations); + + pOs2Info2->usri2_last_logon = (long)pInfo2->usri2_last_logon; + pOs2Info2->usri2_last_logoff = (long)pInfo2->usri2_last_logoff; + pOs2Info2->usri2_acct_expires = (long)pInfo2->usri2_acct_expires; + pOs2Info2->usri2_max_storage = (unsigned long)pInfo2->usri2_max_storage; + pOs2Info2->usri2_units_per_week = (unsigned short)pInfo2->usri2_units_per_week; + StringLen = strlen(pInfo2->usri2_logon_hours) + 1; + CurEndOfBuffer -= StringLen; + pOs2Info2->usri2_logon_hours = (char *)FLATTOFARPTR(CurEndOfBuffer); + RtlMoveMemory(CurEndOfBuffer, pInfo2->usri2_logon_hours, StringLen); + pOs2Info2->usri2_bad_pw_count = (unsigned short)pInfo2->usri2_bad_pw_count; + pOs2Info2->usri2_num_logons = (unsigned short)pInfo2->usri2_num_logons; + + CopyUW2ANSI(pOs2Info2->usri2_logon_server, pInfo2->usri2_logon_server); + + pOs2Info2->usri2_country_code = (unsigned short)pInfo2->usri2_country_code; + pOs2Info2->usri2_code_page = (unsigned short)pInfo2->usri2_code_page; + + pOs2Info2++; + } + else if (sLevel == 10) { + pInfo10 = (PUSER_INFO_10) BufPtr + i; + StringLen = sizeof(struct user_info_10) + + UWstrlen(pInfo10->usri10_comment) + 1 + + UWstrlen(pInfo10->usri10_usr_comment) + 1 + + UWstrlen(pInfo10->usri10_full_name) + 1; + if (StringLen > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= StringLen; + UW2ANSIstrncpy(pOs2Info10->usri10_name, pInfo10->usri10_name, UNLEN_LM20); + pOs2Info10->usri10_name[UNLEN_LM20] = '\0'; + + CopyUW2ANSI(pOs2Info10->usri10_comment, pInfo10->usri10_comment); + CopyUW2ANSI(pOs2Info10->usri10_usr_comment, pInfo10->usri10_usr_comment); + CopyUW2ANSI(pOs2Info10->usri10_full_name, pInfo10->usri10_full_name); + + pOs2Info10++; + } +#if 0 + else if (sLevel == 11) { + pInfo11 = (PUSER_INFO_11) BufPtr + i; + StringLen = sizeof(struct user_info_11) + + UWstrlen(pInfo11->usri11_comment) + 1 + + UWstrlen(pInfo11->usri11_usr_comment) + 1 + + UWstrlen(pInfo11->usri11_full_name) + 1 + + UWstrlen(pInfo11->usri11_home_dir) + 1 + + UWstrlen(pInfo11->usri11_parms) + 1 + + UWstrlen(pInfo11->usri11_logon_server) + 1 + + UWstrlen(pInfo11->usri11_workstations) + 1 + + strlen(pInfo11->usri11_logon_hours) + 1; + if (StringLen > OutBufSize ) { + NetApiBufferFree(BufPtr); + return(ERROR_MORE_DATA); + } + + OutBufSize -= StringLen; + UW2ANSIstrncpy(pOs2Info11->usri11_name, pInfo11->usri11_name, UNLEN_LM20); + pOs2Info11->usri11_name[UNLEN_LM20] = '\0'; + + CopyUW2ANSI(pOs2Info11->usri11_comment, pInfo11->usri11_comment); + CopyUW2ANSI(pOs2Info11->usri11_usr_comment, pInfo11->usri11_usr_comment); + CopyUW2ANSI(pOs2Info11->usri11_full_name, pInfo11->usri11_full_name); + + pOs2Info11->usri11_priv = (unsigned short)pInfo11->usri11_priv; + pOs2Info11->usri11_auth_flags = (unsigned long)pInfo11->usri11_auth_flags; + pOs2Info11->usri11_password_age = (long)pInfo11->usri11_password_age; + + CopyUW2ANSI(pOs2Info11->usri11_home_dir, pInfo11->usri11_home_dir); + CopyUW2ANSI(pOs2Info11->usri11_parms, pInfo11->usri11_parms); + + pOs2Info11->usri11_last_logon = (long)pInfo11->usri11_last_logon; + pOs2Info11->usri11_last_logoff = (long)pInfo11->usri11_last_logoff; + pOs2Info11->usri11_bad_pw_count = (unsigned short)pInfo11->usri11_bad_pw_count; + pOs2Info11->usri11_num_logons = (unsigned short)pInfo11->usri11_num_logons; + + CopyUW2ANSI(pOs2Info11->usri11_logon_server, pInfo11->usri11_logon_server); + + pOs2Info11->usri11_country_code = (unsigned short)pInfo11->usri11_country_code; + + CopyUW2ANSI(pOs2Info11->usri11_workstations, pInfo11->usri11_workstations); + + pOs2Info11->usri11_max_storage = (unsigned long)pInfo11->usri11_max_storage; + pOs2Info11->usri11_units_per_week = (unsigned short)pInfo11->usri11_units_per_week; + + StringLen = strlen(pInfo11->usri11_logon_hours) + 1; + CurEndOfBuffer -= StringLen; + pOs2Info11->usri11_logon_hours = (char *)FLATTOFARPTR(CurEndOfBuffer); + RtlMoveMemory(CurEndOfBuffer, pInfo11->usri11_logon_hours, StringLen); + + pOs2Info11->usri11_code_page = (unsigned short)pInfo11->usri11_code_page; + + pOs2Info11++; + } +#endif + (*pcEntriesRead)++; + } + + NetApiBufferFree(BufPtr); + } + + return(rc); +} + + +APIRET +Net16WkstaGetInfo( + IN PCHAR pszServer, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + LPBYTE BufPtr1; + LPBYTE BufPtr2; + NET_API_STATUS rc; + PWKSTA_INFO_101 pInfo101; + PWKSTA_USER_INFO_1 pInfo1; + struct wksta_info_0 *pOs2Info0; + struct wksta_info_1 *pOs2Info1; + struct wksta_info_10 *pOs2Info10; + PCHAR pStrings; + WCHAR LanRoot[CCHMAXPATH]; + PCHAR pEndOfBuffer; + ULONG StringLen; + ULONG TotalStringLen; + + try { + PROBE_STRING(pszServer); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 10)) { + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + rc = NetWkstaGetInfo(Server, 101L, &BufPtr1); + + if (rc != NO_ERROR) { + return(rc); + } + + rc = NetWkstaUserGetInfo(NULL, 1L, &BufPtr2); + + if (rc != NO_ERROR) { + NetApiBufferFree(BufPtr1); + return(rc); + } + + RtlZeroMemory(pbBuffer, cbBuffer); + pEndOfBuffer = pbBuffer + cbBuffer; + pInfo101 = (PWKSTA_INFO_101) BufPtr1; + pInfo1 = (PWKSTA_USER_INFO_1) BufPtr2; + + if (sLevel == 0) { + pOs2Info0 = (struct wksta_info_0 *)pbBuffer; + + // + // note about wkix_root - NT returns an empty field. + // We should return system directory + // in case of lacal machine, and NULL + // in case of remote call. + // + if ((pszServer == NULL) || (*pszServer == (CHAR) NULL)) { + StringLen = GetSystemDirectoryW(LanRoot, sizeof(LanRoot)) + 1; + LanRoot[StringLen] = UNICODE_NULL; + } + else { + StringLen = 1; + LanRoot[0] = UNICODE_NULL; + } + TotalStringLen = UTstrlen(LanRoot) + 1 + + UTstrlen(pInfo101->wki101_computername) + 1 + + UTstrlen(pInfo101->wki101_langroup) + 1 + + UTstrlen(pInfo1->wkui1_username) + 1 + + UTstrlen(pInfo1->wkui1_logon_server) + 1 + 2; + *pcbTotalAvail = (USHORT)(sizeof(struct wksta_info_0) + TotalStringLen); + pStrings = (PCHAR)(pOs2Info0 + 1); + if (pStrings + TotalStringLen > pEndOfBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + + UT2ANSIstrcpy(pStrings, LanRoot); + pOs2Info0->wki0_root = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo101->wki101_computername) + 1; + UT2ANSIstrcpy(pStrings, pInfo101->wki101_computername); + pOs2Info0->wki0_computername = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo101->wki101_langroup) + 1; + UT2ANSIstrcpy(pStrings, pInfo101->wki101_langroup); + pOs2Info0->wki0_langroup = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + pOs2Info0->wki0_ver_major = (unsigned char)pInfo101->wki101_ver_major; + pOs2Info0->wki0_ver_minor = (unsigned char)pInfo101->wki101_ver_minor; + + StringLen = UTstrlen(pInfo1->wkui1_username) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_username); + pOs2Info0->wki0_username = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + strcpy(pStrings, "\\\\"); + StringLen = UTstrlen(pInfo1->wkui1_logon_server) + 1 + 2; + UT2ANSIstrcpy(pStrings + 2, pInfo1->wkui1_logon_server); + pOs2Info0->wki0_logon_server = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + } + else if (sLevel == 1) { + pOs2Info1 = (struct wksta_info_1 *)pbBuffer; + + // + // note about wkix_root - NT returns an empty field. + // We should return system directory + // in case of lacal machine, and NULL + // in case of remote call. + // + if ((pszServer == NULL) || (*pszServer == (CHAR) NULL)) { + StringLen = GetSystemDirectoryW(LanRoot, sizeof(LanRoot)) + 1; + LanRoot[StringLen] = UNICODE_NULL; + } + else { + StringLen = 1; + LanRoot[0] = UNICODE_NULL; + } + TotalStringLen = UTstrlen(LanRoot) + 1 + + UTstrlen(pInfo101->wki101_computername) + 1 + + UTstrlen(pInfo101->wki101_langroup) + 1 + + UTstrlen(pInfo1->wkui1_username) + 1 + + UTstrlen(pInfo1->wkui1_logon_server) + 1 + 2 + + UTstrlen(pInfo1->wkui1_logon_domain) + 1 + + UTstrlen(pInfo1->wkui1_oth_domains) + 1; + *pcbTotalAvail = (USHORT)(sizeof(struct wksta_info_1) + TotalStringLen); + pStrings = (PCHAR)(pOs2Info1 + 1); + if (pStrings + TotalStringLen > pEndOfBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + + UT2ANSIstrcpy(pStrings, LanRoot); + pOs2Info1->wki1_root = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo101->wki101_computername) + 1; + UT2ANSIstrcpy(pStrings, pInfo101->wki101_computername); + pOs2Info1->wki1_computername = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo101->wki101_langroup) + 1; + UT2ANSIstrcpy(pStrings, pInfo101->wki101_langroup); + pOs2Info1->wki1_langroup = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + pOs2Info1->wki1_ver_major = (unsigned char)pInfo101->wki101_ver_major; + pOs2Info1->wki1_ver_minor = (unsigned char)pInfo101->wki101_ver_minor; + + StringLen = UTstrlen(pInfo1->wkui1_username) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_username); + pOs2Info1->wki1_username = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + strcpy(pStrings, "\\\\"); + StringLen = UTstrlen(pInfo1->wkui1_logon_server) + 1 + 2; + UT2ANSIstrcpy(pStrings + 2, pInfo1->wkui1_logon_server); + pOs2Info1->wki1_logon_server = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo1->wkui1_logon_domain) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_logon_domain); + pOs2Info1->wki1_logon_domain = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo1->wkui1_oth_domains) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_oth_domains); + pOs2Info1->wki1_oth_domains = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + } + else if (sLevel == 10) { + pOs2Info10 = (struct wksta_info_10 *)pbBuffer; + TotalStringLen = UTstrlen(pInfo101->wki101_computername) + 1 + + UTstrlen(pInfo1->wkui1_username) + 1 + + UTstrlen(pInfo101->wki101_langroup) + 1 + + UTstrlen(pInfo1->wkui1_logon_domain) + 1 + + UTstrlen(pInfo1->wkui1_oth_domains) + 1; + *pcbTotalAvail = (USHORT)(sizeof(struct wksta_info_10) + TotalStringLen); + pStrings = (PCHAR)(pOs2Info10 + 1); + if (pStrings + TotalStringLen > pEndOfBuffer) { + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + return(NERR_BufTooSmall); + } + + StringLen = UTstrlen(pInfo101->wki101_computername) + 1; + UT2ANSIstrcpy(pStrings, pInfo101->wki101_computername); + pOs2Info10->wki10_computername = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo1->wkui1_username) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_username); + pOs2Info10->wki10_username = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo101->wki101_langroup) + 1; + UT2ANSIstrcpy(pStrings, pInfo101->wki101_langroup); + pOs2Info10->wki10_langroup = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + pOs2Info10->wki10_ver_major = (unsigned char)pInfo101->wki101_ver_major; + pOs2Info10->wki10_ver_minor = (unsigned char)pInfo101->wki101_ver_minor; + + StringLen = UTstrlen(pInfo1->wkui1_logon_domain) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_logon_domain); + pOs2Info10->wki10_logon_domain = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + + StringLen = UTstrlen(pInfo1->wkui1_oth_domains) + 1; + UT2ANSIstrcpy(pStrings, pInfo1->wkui1_oth_domains); + pOs2Info10->wki10_oth_domains = (char *)FLATTOFARPTR(pStrings); + pStrings += StringLen; + } + + NetApiBufferFree(BufPtr1); + NetApiBufferFree(BufPtr2); + + return(NO_ERROR); +} + + +APIRET +Net16AccessAdd( + IN PCHAR pszServer, + IN LONG sLevel, + IN PCHAR pbBuffer, + IN ULONG cbBuffer + ) +{ + TCHAR Server[UNCLEN]; + PCHAR Buffer; + PCHAR ResourceName; + LPTSTR pStrings; + ULONG StringLen; + PACCESS_INFO_1 pInfo1; + PACCESS_LIST pInfo; + struct access_info_1 *pOs2Info1; + struct access_list *pOs2Info; + int i; + NET_API_STATUS rc; + + try { + PROBE_STRING(pszServer); + Od2ProbeForRead(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 1) { + return(ERROR_INVALID_PARAMETER); + } + + Buffer = (PCHAR) RtlAllocateHeap(Od2Heap, 0, LARGE_BUFFER_SIZE); + + if (Buffer == NULL) { + return(ERROR_NOT_ENOUGH_MEMORY); + } + + pOs2Info1 = (struct access_info_1 *) pbBuffer; + pOs2Info = (struct access_list *) (pOs2Info1 + 1); + pInfo1 = (PACCESS_INFO_1) Buffer; + pInfo = (PACCESS_LIST) (pInfo1 + 1); + pStrings = (LPTSTR)(pInfo + (pOs2Info1->acc1_count * sizeof(ACCESS_LIST))); + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + ResourceName = FARPTRTOFLAT(pOs2Info1->acc1_resource_name); + pInfo1->acc1_resource_name = pStrings; + StringLen = strlen(ResourceName) + 1; + ANSI2UTstrcpy(pStrings, ResourceName); + pStrings += StringLen; + + pInfo1->acc1_attr = pOs2Info1->acc1_attr; + pInfo1->acc1_count = pOs2Info1->acc1_count; + + for (i = 0; i < pOs2Info1->acc1_count; i++) { + pInfo->acl_access = pOs2Info->acl_access; + pInfo->acl_ugname = pStrings; + ANSI2UTstrcpy(pStrings, pOs2Info->acl_ugname); + pStrings += UNLEN_LM20+1; + pInfo++; + pOs2Info++; + } + + rc = NetAccessAdd(Server, sLevel, Buffer, NULL); + + RtlFreeHeap(Od2Heap, 0, Buffer); + + return(rc); +} + + +APIRET +Net16AccessSetInfo( + IN PCHAR pszServer, + IN PCHAR pszResource, + IN LONG sLevel, + IN PCHAR pbBuffer, + IN ULONG cbBuffer, + IN LONG sParmNum + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Resource[NNLEN]; + PCHAR Buffer = NULL; + NET_API_STATUS rc; + ACCESS_INFO_1002 AccessInfo1002; + PCHAR ResourceName; + LPTSTR pStrings; + ULONG StringLen; + PACCESS_INFO_1 pInfo1; + PACCESS_LIST pInfo; + struct access_info_1 *pOs2Info1; + struct access_list *pOs2Info; + int i; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszResource); + Od2ProbeForRead(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 1) { + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(Resource, pszResource, NNLEN); + + if (sParmNum == ACCESS_ATTR_PARMNUM) { + AccessInfo1002.acc1002_attr = *(PSHORT) pbBuffer; + rc = NetAccessSetInfo(Server, Resource, (ULONG) 1002, (PCHAR) &AccessInfo1002, NULL); + } else { + + Buffer = (PCHAR) RtlAllocateHeap(Od2Heap, 0, LARGE_BUFFER_SIZE); + + if (Buffer == NULL) { + return(ERROR_NOT_ENOUGH_MEMORY); + } + + pOs2Info1 = (struct access_info_1 *) pbBuffer; + pOs2Info = (struct access_list *) (pOs2Info1 + 1); + pInfo1 = (PACCESS_INFO_1) Buffer; + pInfo = (PACCESS_LIST) (pInfo1 + 1); + pStrings = (LPTSTR)(pInfo + (pOs2Info1->acc1_count * sizeof(ACCESS_LIST))); + + ResourceName = FARPTRTOFLAT(pOs2Info1->acc1_resource_name); + pInfo1->acc1_resource_name = pStrings; + StringLen = strlen(ResourceName) + 1; + ANSI2UTstrcpy(pStrings, ResourceName); + pStrings += StringLen; + + pInfo1->acc1_attr = pOs2Info1->acc1_attr; + pInfo1->acc1_count = pOs2Info1->acc1_count; + + for (i = 0; i < pOs2Info1->acc1_count; i++) { + pInfo->acl_access = pOs2Info->acl_access; + pInfo->acl_ugname = pStrings; + ANSI2UTstrcpy(pStrings, pOs2Info->acl_ugname); + pStrings += UNLEN_LM20+1; + pInfo++; + pOs2Info++; + } + rc = NetAccessSetInfo(Server, Resource, sLevel, Buffer, NULL); + + RtlFreeHeap(Od2Heap, 0, Buffer); + } + + return(rc); +} + + +APIRET +Net16AccessGetInfo( + IN PCHAR pszServer, + IN PCHAR pszResource, + IN LONG sLevel, + OUT PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + TCHAR Server[UNCLEN]; + ANSI_STRING Str_MB; + UNICODE_STRING Str_U; + LPBYTE BufPtr; + NET_API_STATUS rc; + APIRET RetCode; + PACCESS_INFO_0 pInfo0; + PACCESS_INFO_1 pInfo1; + PACCESS_LIST pInfo; + struct access_info_0 *pOs2Info0; + struct access_info_1 *pOs2Info1; + struct access_list *pOs2Info; + ULONG strucsize; + ULONG Length; + ULONG FullLength; + ULONG StringLen; + ULONG AclsThatFit; + ULONG Count; + PCHAR pScratch; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszResource); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16AccessGetInfo: Invalid level = %d\n", sLevel)); + } +#endif + return(ERROR_INVALID_LEVEL); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + // + // Since Resource can be a very long string (up to PATHLEN), we allocate + // space for it on the heap instead of the stack, which might be too short + // + + if (pszResource != NULL) { + + Or2InitMBString(&Str_MB, pszResource); + + if ((RetCode = Or2MBStringToUnicodeString(&Str_U, &Str_MB, TRUE)) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16AccessGetInfo: Unicode converstion of Resource failed, RetCode = %x\n", RetCode)); + } +#endif + return(ERROR_NOT_ENOUGH_MEMORY); + } + + Str_U.Buffer[Str_U.Length/sizeof(WCHAR)] = UNICODE_NULL; + + } else { + + Str_U.Buffer = NULL; + } + + rc = NetAccessGetInfo(Server, (LPTSTR) Str_U.Buffer, sLevel, &BufPtr); + + if (Str_U.Buffer != NULL) { + RtlFreeUnicodeString(&Str_U); + } + + if (rc != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16AccessGetInfo: System function returned %lx\n", rc)); + } +#endif + return((APIRET)rc); + } + + if (sLevel == 0) { + + strucsize = sizeof(struct access_info_0); + pInfo0 = (PACCESS_INFO_0) BufPtr; + + RtlInitUnicodeString(&Str_U, pInfo0->acc0_resource_name); + + if (Str_U.Buffer == NULL) { + + StringLen = 0; + + } else { + + if ((RetCode = Or2UnicodeStringToMBString(&Str_MB, &Str_U, TRUE)) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16AccessGetInfo: Unicode converstion of returned resource name failed, RetCode = %x\n", RetCode)); + } +#endif + NetApiBufferFree(BufPtr); + return(ERROR_NOT_ENOUGH_MEMORY); + } + + StringLen = Str_MB.Length + 1; + } + + *pcbTotalAvail = (USHORT) (strucsize + StringLen); + + if (cbBuffer < strucsize + StringLen) { + if (StringLen != 0) { + Or2FreeMBString(&Str_MB); + } + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + pOs2Info0 = (struct access_info_0 *) pbBuffer; + + if (StringLen) { + + pScratch = (PCHAR) (pOs2Info0 + 1); + pOs2Info0->acc0_resource_name = (PVOID) FLATTOFARPTR(pScratch); + RtlMoveMemory(pScratch, Str_MB.Buffer, StringLen); + Or2FreeMBString(&Str_MB); + + } else { + + pOs2Info0->acc0_resource_name = NULL; + } + + } else { // sLevel == 1 + + strucsize = sizeof(struct access_info_1); + pInfo1 = (PACCESS_INFO_1) BufPtr; + + RtlInitUnicodeString(&Str_U, pInfo1->acc1_resource_name); + + if (Str_U.Buffer == NULL) { + + StringLen = 0; + + } else { + + if ((RetCode = Or2UnicodeStringToMBString(&Str_MB, &Str_U, TRUE)) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16AccessGetInfo: Unicode converstion of returned resource name failed, RetCode = %x\n", RetCode)); + } +#endif + NetApiBufferFree(BufPtr); + return(ERROR_NOT_ENOUGH_MEMORY); + } + + StringLen = Str_MB.Length + 1; + } + + AclsThatFit = (ULONG) pInfo1->acc1_count; + FullLength = Length = AclsThatFit * sizeof(struct access_list); + + *pcbTotalAvail = (USHORT) (strucsize + FullLength + StringLen); + + if (cbBuffer < strucsize + StringLen) { + if (StringLen != 0) { + Or2FreeMBString(&Str_MB); + } + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + if (cbBuffer < strucsize + StringLen + Length) { + + // + // Cut the info down to size... + // + + AclsThatFit = (cbBuffer - strucsize - StringLen) / sizeof(struct access_list); + + Length = AclsThatFit * sizeof(struct access_list); + + rc = ERROR_MORE_DATA; + } + + pOs2Info1 = (struct access_info_1 *) pbBuffer; + + if (StringLen) { + + pScratch = pbBuffer + strucsize + Length; + pOs2Info1->acc1_resource_name = (PVOID) FLATTOFARPTR(pScratch); + RtlMoveMemory(pScratch, Str_MB.Buffer, StringLen); + Or2FreeMBString(&Str_MB); + + } else { + + pOs2Info1->acc1_resource_name = NULL; + } + + pOs2Info1->acc1_attr = (SHORT) pInfo1->acc1_attr; + pOs2Info1->acc1_count = (SHORT) AclsThatFit; + + // + // Fill in the ACL structures + // + + pInfo = (PACCESS_LIST) (pInfo1 + 1); + pOs2Info = (struct access_list *) (pOs2Info1 + 1); + + for (Count = 0; Count < AclsThatFit; Count++) { + + pOs2Info[Count].acl_access = (SHORT) pInfo[Count].acl_access; + UT2ANSIstrncpy(pOs2Info[Count].acl_ugname, pInfo[Count].acl_ugname, LM20_UNLEN); + pOs2Info[Count].acl_ugname[LM20_UNLEN] = '\0'; + } + + } + + NetApiBufferFree(BufPtr); + return((APIRET)rc); +} + + +APIRET +Net16AccessDel( + IN PCHAR pszServer, + IN PCHAR pszResource + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Resource[NNLEN]; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszResource); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(Resource, pszResource, NNLEN); + + return (NetAccessDel(Server, Resource)); +} + + +APIRET +Net16ShareAdd( + IN PCHAR pszServer, + IN LONG sLevel, + IN PCHAR pbBuffer, + IN ULONG cbBuffer + ) +{ + TCHAR Server[UNCLEN]; + PCHAR Buffer; + NET_API_STATUS rc; + LPTSTR pStrings; + PSHARE_INFO_2 pInfo2; + struct share_info_2 *pOs2Info2; + + try { + PROBE_STRING(pszServer); + Od2ProbeForRead(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 2) { + return(ERROR_INVALID_PARAMETER); + } + + Buffer = (PCHAR) RtlAllocateHeap(Od2Heap, 0, SMALL_BUFFER_SIZE); + + if (Buffer == NULL) { + return(ERROR_NOT_ENOUGH_MEMORY); + } + + pOs2Info2 = (struct share_info_2 *) pbBuffer; + pInfo2 = (PSHARE_INFO_2) Buffer; + pStrings = (LPTSTR) (pInfo2 + 1); + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + + pInfo2->shi2_netname = pStrings; + ANSI2UTstrcpy(pStrings, pOs2Info2->shi2_netname); + pStrings += strlen(pOs2Info2->shi2_netname) + 1; + + pInfo2->shi2_remark = pStrings; + ANSI2UTstrcpy(pStrings, FARPTRTOFLAT(pOs2Info2->shi2_remark)); + pStrings += strlen(FARPTRTOFLAT(pOs2Info2->shi2_remark)) + 1; + + pInfo2->shi2_path = pStrings; + ANSI2UTstrcpy(pStrings, FARPTRTOFLAT(pOs2Info2->shi2_path)); + pStrings += strlen(FARPTRTOFLAT(pOs2Info2->shi2_path)) + 1; + + pInfo2->shi2_passwd = pStrings; + ANSI2UTstrcpy(pStrings, pOs2Info2->shi2_passwd); + pStrings += strlen(pOs2Info2->shi2_passwd) + 1; + + pInfo2->shi2_type = pOs2Info2->shi2_type; + pInfo2->shi2_permissions = pOs2Info2->shi2_permissions; + pInfo2->shi2_max_uses = pOs2Info2->shi2_max_uses; + pInfo2->shi2_current_uses = pOs2Info2->shi2_current_uses; + + rc = NetShareAdd(Server, sLevel, Buffer, NULL); + + RtlFreeHeap(Od2Heap, 0, Buffer); + + return(rc); +} + + +APIRET +Net16ShareDel( + IN PCHAR pszServer, + IN PCHAR pszNetName, + IN ULONG usReserved + ) +{ + TCHAR Server[UNCLEN]; + TCHAR NetName[NNLEN]; + + UNREFERENCED_PARAMETER(usReserved); + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszNetName); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(NetName, pszNetName, NNLEN); + + return (NetShareDel(Server, NetName, 0L)); +} + + +APIRET +Net16UserGetInfo( + IN PCHAR pszServer, + IN PCHAR pszUserName, + IN LONG sLevel, + IN PCHAR pbBuffer, + IN ULONG cbBuffer, + OUT PUSHORT pcbTotalAvail + ) +{ + WCHAR Server[UNCLEN]; + WCHAR UserName[UNLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PUSER_INFO_0 pInfo0; + PUSER_INFO_1 pInfo1; + PUSER_INFO_2 pInfo2; + PUSER_INFO_10 pInfo10; + PUSER_INFO_11 pInfo11; + struct user_info_0 *pOs2Info0; + struct user_info_1 *pOs2Info1; + struct user_info_2 *pOs2Info2; + struct user_info_10 *pOs2Info10; + struct user_info_11 *pOs2Info11; + PCHAR CurEndOfBuffer; + ULONG StringLen; + ULONG TotalStringLen; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszUserName); + Od2ProbeForWrite(pcbTotalAvail,sizeof(*pcbTotalAvail),1); + Od2ProbeForWrite(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((sLevel != 0) && (sLevel != 1) && (sLevel != 2) && + (sLevel != 10) && (sLevel != 11)) { + return(ERROR_INVALID_PARAMETER); + } + + ANSI2UWstrncpy(Server, pszServer, UNCLEN); + ANSI2UWstrncpy(UserName, pszUserName, UNLEN); + + rc = NetUserGetInfo(Server, UserName, sLevel, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + CurEndOfBuffer = pbBuffer + cbBuffer; + + if (sLevel == 0) { + pInfo0 = (PUSER_INFO_0) BufPtr; + pOs2Info0 = (struct user_info_0 *)pbBuffer; + *pcbTotalAvail = (USHORT)sizeof(struct user_info_0); + if ((ULONG)sizeof(struct user_info_0) > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + UW2ANSIstrncpy(pOs2Info0->usri0_name, pInfo0->usri0_name, UNLEN_LM20); + pOs2Info0->usri0_name[UNLEN_LM20] = '\0'; + } + else if (sLevel == 1) { + pInfo1 = (PUSER_INFO_1) BufPtr; + pOs2Info1 = (struct user_info_1 *)pbBuffer; + TotalStringLen = sizeof(struct user_info_1) + + UWstrlen(pInfo1->usri1_home_dir) + 1 + + UWstrlen(pInfo1->usri1_comment) + 1 + + UWstrlen(pInfo1->usri1_script_path) + 1; + *pcbTotalAvail = (USHORT)TotalStringLen; + if (TotalStringLen > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UW2ANSIstrncpy(pOs2Info1->usri1_name, pInfo1->usri1_name, UNLEN_LM20); + pOs2Info1->usri1_name[UNLEN_LM20] = '\0'; + + UW2ANSIstrncpy(pOs2Info1->usri1_password, pInfo1->usri1_password, ENCRYPTED_PWLEN_LM20); + pOs2Info1->usri1_password[ENCRYPTED_PWLEN_LM20] = '\0'; + + CopyUW2ANSI(pOs2Info1->usri1_home_dir, pInfo1->usri1_home_dir); + CopyUW2ANSI(pOs2Info1->usri1_comment, pInfo1->usri1_comment); + CopyUW2ANSI(pOs2Info1->usri1_script_path, pInfo1->usri1_script_path); + + pOs2Info1->usri1_password_age = (long)pInfo1->usri1_password_age; + pOs2Info1->usri1_priv = (unsigned short)pInfo1->usri1_priv; + pOs2Info1->usri1_flags = (unsigned short)pInfo1->usri1_flags; + } + else if (sLevel == 2) { + pInfo2 = (PUSER_INFO_2) BufPtr; + pOs2Info2 = (struct user_info_2 *)pbBuffer; + TotalStringLen = sizeof(struct user_info_2) + + UWstrlen(pInfo2->usri2_home_dir) + 1 + + UWstrlen(pInfo2->usri2_comment) + 1 + + UWstrlen(pInfo2->usri2_script_path) + 1 + + UWstrlen(pInfo2->usri2_full_name) + 1 + + UWstrlen(pInfo2->usri2_usr_comment) + 1 + + UWstrlen(pInfo2->usri2_parms) + 1 + + UWstrlen(pInfo2->usri2_workstations) + 1 + + strlen(pInfo2->usri2_logon_hours) + + UWstrlen(pInfo2->usri2_logon_server) + 1; + *pcbTotalAvail = (USHORT)TotalStringLen; + if (TotalStringLen > cbBuffer) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UW2ANSIstrncpy(pOs2Info2->usri2_name, pInfo2->usri2_name, UNLEN_LM20); + pOs2Info2->usri2_name[UNLEN_LM20] = '\0'; + + UW2ANSIstrncpy(pOs2Info2->usri2_password, pInfo2->usri2_password, ENCRYPTED_PWLEN_LM20); + pOs2Info2->usri2_password[ENCRYPTED_PWLEN_LM20] = '\0'; + + CopyUW2ANSI(pOs2Info2->usri2_home_dir, pInfo2->usri2_home_dir); + CopyUW2ANSI(pOs2Info2->usri2_comment, pInfo2->usri2_comment); + CopyUW2ANSI(pOs2Info2->usri2_script_path, pInfo2->usri2_script_path); + CopyUW2ANSI(pOs2Info2->usri2_full_name, pInfo2->usri2_full_name); + CopyUW2ANSI(pOs2Info2->usri2_usr_comment, pInfo2->usri2_usr_comment); + CopyUW2ANSI(pOs2Info2->usri2_parms, pInfo2->usri2_parms); + CopyUW2ANSI(pOs2Info2->usri2_workstations, pInfo2->usri2_workstations); + CopyUW2ANSI(pOs2Info2->usri2_logon_server, pInfo2->usri2_logon_server); + StringLen = strlen(pInfo2->usri2_logon_hours) + 1; + CurEndOfBuffer -= StringLen; + pOs2Info2->usri2_logon_hours = (char *)FLATTOFARPTR(CurEndOfBuffer); + RtlMoveMemory(CurEndOfBuffer, pInfo2->usri2_logon_hours, StringLen); + + pOs2Info2->usri2_password_age = (long)pInfo2->usri2_password_age; + pOs2Info2->usri2_priv = (unsigned short)pInfo2->usri2_priv; + pOs2Info2->usri2_flags = (unsigned short)pInfo2->usri2_flags; + pOs2Info2->usri2_auth_flags = (unsigned long)pInfo2->usri2_auth_flags; + pOs2Info2->usri2_last_logon = (long)pInfo2->usri2_last_logon; + pOs2Info2->usri2_last_logoff = (long)pInfo2->usri2_last_logoff; + pOs2Info2->usri2_acct_expires = (long)pInfo2->usri2_acct_expires; + pOs2Info2->usri2_max_storage = (unsigned long)pInfo2->usri2_max_storage; + pOs2Info2->usri2_units_per_week = (unsigned short)pInfo2->usri2_units_per_week; + pOs2Info2->usri2_bad_pw_count = (unsigned short)pInfo2->usri2_bad_pw_count; + pOs2Info2->usri2_num_logons = (unsigned short)pInfo2->usri2_num_logons; + pOs2Info2->usri2_country_code = (unsigned short)pInfo2->usri2_country_code; + pOs2Info2->usri2_code_page = (unsigned short)pInfo2->usri2_code_page; + } + else if (sLevel == 10) { + pInfo10 = (PUSER_INFO_10) BufPtr; + pOs2Info10 = (struct user_info_10 *)pbBuffer; + TotalStringLen = sizeof(struct user_info_10) + + UWstrlen(pInfo10->usri10_comment) + 1 + + UWstrlen(pInfo10->usri10_usr_comment) + 1 + + UWstrlen(pInfo10->usri10_full_name) + 1; + *pcbTotalAvail = (USHORT)TotalStringLen; + if (TotalStringLen > cbBuffer ) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UW2ANSIstrncpy(pOs2Info10->usri10_name, pInfo10->usri10_name, UNLEN_LM20); + pOs2Info10->usri10_name[UNLEN_LM20] = '\0'; + + CopyUW2ANSI(pOs2Info10->usri10_comment, pInfo10->usri10_comment); + CopyUW2ANSI(pOs2Info10->usri10_usr_comment, pInfo10->usri10_usr_comment); + CopyUW2ANSI(pOs2Info10->usri10_full_name, pInfo10->usri10_full_name); + } + else if (sLevel == 11) { + pInfo11 = (PUSER_INFO_11) BufPtr; + pOs2Info11 = (struct user_info_11 *)pbBuffer; + TotalStringLen = sizeof(struct user_info_11) + + UWstrlen(pInfo11->usri11_comment) + 1 + + UWstrlen(pInfo11->usri11_usr_comment) + 1 + + UWstrlen(pInfo11->usri11_full_name) + 1 + + UWstrlen(pInfo11->usri11_home_dir) + 1 + + UWstrlen(pInfo11->usri11_parms) + 1 + + UWstrlen(pInfo11->usri11_logon_server) + 1 + + UWstrlen(pInfo11->usri11_workstations) + 1 + + strlen(pInfo11->usri11_logon_hours); + *pcbTotalAvail = (USHORT)TotalStringLen; + if (TotalStringLen > cbBuffer ) { + NetApiBufferFree(BufPtr); + return(NERR_BufTooSmall); + } + + UW2ANSIstrncpy(pOs2Info11->usri11_name, pInfo11->usri11_name, UNLEN_LM20); + pOs2Info11->usri11_name[UNLEN_LM20] = '\0'; + + CopyUW2ANSI(pOs2Info11->usri11_comment, pInfo11->usri11_comment); + CopyUW2ANSI(pOs2Info11->usri11_usr_comment, pInfo11->usri11_usr_comment); + CopyUW2ANSI(pOs2Info11->usri11_full_name, pInfo11->usri11_full_name); + + pOs2Info11->usri11_priv = (unsigned short)pInfo11->usri11_priv; + pOs2Info11->usri11_auth_flags = (unsigned long)pInfo11->usri11_auth_flags; + pOs2Info11->usri11_password_age = (long)pInfo11->usri11_password_age; + + CopyUW2ANSI(pOs2Info11->usri11_home_dir, pInfo11->usri11_home_dir); + CopyUW2ANSI(pOs2Info11->usri11_parms, pInfo11->usri11_parms); + + pOs2Info11->usri11_last_logon = (long)pInfo11->usri11_last_logon; + pOs2Info11->usri11_last_logoff = (long)pInfo11->usri11_last_logoff; + pOs2Info11->usri11_bad_pw_count = (unsigned short)pInfo11->usri11_bad_pw_count; + pOs2Info11->usri11_num_logons = (unsigned short)pInfo11->usri11_num_logons; + + CopyUW2ANSI(pOs2Info11->usri11_logon_server, pInfo11->usri11_logon_server); + + pOs2Info11->usri11_country_code = (unsigned short)pInfo11->usri11_country_code; + + CopyUW2ANSI(pOs2Info11->usri11_workstations, pInfo11->usri11_workstations); + + pOs2Info11->usri11_max_storage = (unsigned long)pInfo11->usri11_max_storage; + pOs2Info11->usri11_units_per_week = (unsigned short)pInfo11->usri11_units_per_week; + + StringLen = strlen(pInfo11->usri11_logon_hours) + 1; + CurEndOfBuffer -= StringLen; + pOs2Info11->usri11_logon_hours = (char *)FLATTOFARPTR(CurEndOfBuffer); + RtlMoveMemory(CurEndOfBuffer, pInfo11->usri11_logon_hours, StringLen); + + pOs2Info11->usri11_code_page = (unsigned short)pInfo11->usri11_code_page; + } + + + NetApiBufferFree(BufPtr); + + return(NO_ERROR); +} + + +APIRET +Net16MessageBufferSend( + IN PSZ pszServer, + IN PSZ pszRecipient, + IN PBYTE pbBuffer, + IN ULONG cbBuffer + ) +{ + TCHAR Server[UNCLEN]; + TCHAR Recipient[CNLEN+1]; + ANSI_STRING Tmp_MB; + UNICODE_STRING Tmp_U; + APIRET rc; + + try { + PROBE_STRING(pszServer); + PROBE_STRING(pszRecipient); + Od2ProbeForRead(pbBuffer,cbBuffer,1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + ANSI2UTstrncpy(Server, pszServer, UNCLEN); + ANSI2UTstrncpy(Recipient, pszRecipient, CNLEN+1); + + // + // We now need to convert the message buffer + // itself to unicode... + // + + Tmp_MB.Buffer = (PCHAR) pbBuffer; + Tmp_MB.MaximumLength = Tmp_MB.Length = (USHORT) cbBuffer; + + rc = Od2MBStringToUnicodeString( + &Tmp_U, + &Tmp_MB, + TRUE); + + if (rc != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16MessageBufferSend: Failed to convert buffer to unicode, rc = %lx\n", rc)); + } +#endif + return(rc); + } + + rc = (APIRET) NetMessageBufferSend(Server, Recipient, NULL, (PBYTE) Tmp_U.Buffer, (ULONG) Tmp_U.Length); + + RtlFreeUnicodeString(&Tmp_U); + + return(rc); +} + + +//***************************************************************************** +// +//Following is the implementation of the Netbios APIs +// +//***************************************************************************** + + +#if 1 +#if DBG +// This is a small debug routine to dump a buffer +static +VOID +Od2BufDbgPrint( + PBYTE p, + ULONG c + ) +{ + ULONG i, m; + + for (i=0; i < c; i++) { + m = i%16; + + if (m == 0) { + KdPrint((" ")); + } + + KdPrint(("%2.2x ",p[i])); + + if (m == 15) { + KdPrint(("\n")); + } + } + + if (m != 15) { + KdPrint(("\n")); + } +} + +// This is a small debug routine to print an NCB +static +VOID +Od2NcbDbgPrint( + IN PNCB pNcb, + IN PNCB pOs2Ncb, + IN ULONG EntryPoint + ) +{ + CHAR CallName[NCBNAMSZ+1]; + CHAR Name[NCBNAMSZ+1]; + UCHAR SynchCommand = pNcb->ncb_command & ~ASYNCH; + UCHAR Asynch = pNcb->ncb_command & ASYNCH; + + switch (EntryPoint) { + case 1: + KdPrint(("BEFORE, User Ncb addr = %lx\n", (ULONG)pOs2Ncb)); + break; + case 2: + KdPrint(("AFTER\n")); + break; + case 3: + KdPrint(("POST-END\n")); + break; + } + + memcpy(CallName, pNcb->ncb_callname, NCBNAMSZ); + CallName[NCBNAMSZ] = '\0'; + memcpy(Name, pNcb->ncb_name, NCBNAMSZ); + Name[NCBNAMSZ] = '\0'; + KdPrint(("Netbios call frame:\n")); + KdPrint(("------------------\n")); + if (EntryPoint != 3) { + KdPrint(("TID : 0x%lx\n", NtCurrentTeb()->EnvironmentPointer ? Od2CurrentThreadId() : -1)); + } + KdPrint(("Command: 0x%x\n", pNcb->ncb_command)); + KdPrint(("Retcode: 0x%x\n", pNcb->ncb_retcode)); + KdPrint(("LSN : 0x%x\n", pNcb->ncb_lsn)); + KdPrint(("NUM : 0x%x\n", pNcb->ncb_num)); + KdPrint(("LanaNum: 0x%x\n", pNcb->ncb_lana_num)); + KdPrint(("Length : 0x%x\n", pNcb->ncb_length)); + KdPrint(("Callnam: %s\n", CallName)); + KdPrint(("Name : %s\n", Name)); + if (EntryPoint == 1 && Asynch) { + KdPrint(("Post : 0x%lx\n", (ULONG)pOs2Ncb->ncb_post)); + } + + switch (EntryPoint) { + case 1: + if (SynchCommand != NCBSEND && + SynchCommand != NCBCHAINSEND) { + return; + } + break; + case 2: + if (Asynch) { + return; + } + case 3: + if (SynchCommand != NCBRECV) { + return; + } + } + + KdPrint(("Buffer : \n")); + Od2BufDbgPrint((PBYTE) pNcb->ncb_buffer, (ULONG) pNcb->ncb_length); + if (SynchCommand == NCBCHAINSEND || + SynchCommand == NCBCHAINSENDNA) { + + ULONG l = (ULONG) (*(PUSHORT)pNcb->ncb_callname); + + KdPrint(("Length2: 0x%lx\n", l)); + KdPrint(("Buffer2: \n")); + + Od2BufDbgPrint(*(PBYTE *)&pNcb->ncb_callname[2], l); + + } + +} +#endif +#endif + + +// This routine transfers results from a completed internal NCB to the user's NCB +static +VOID +Od2CopyNcbResults( + OUT PNCB Dest, + IN PNCB Src, + IN BOOLEAN Nb2Semantics + ) +{ + UCHAR SynchCommand = Src->ncb_command & ~ASYNCH; + + // + // For Netbios 3.0 just copy the NCB block + // + if (!Nb2Semantics) { + RtlMoveMemory(Dest, Src, sizeof(NCB)); + return; + } + + // + // Netbios 2.0 + + Dest->ncb_lsn = Src->ncb_lsn; + Dest->ncb_num = Src->ncb_num; + Dest->ncb_length = Src->ncb_length; + if (SynchCommand != NCBCHAINSEND && SynchCommand != NCBCHAINSENDNA) { + RtlMoveMemory(Dest->ncb_callname, Src->ncb_callname, NCBNAMSZ); + } + Dest->ncb_rto = Src->ncb_rto; + Dest->ncb_sto = Src->ncb_sto; + + // + // Translate an error code in a special case where netbios 2 + // doesn't return an error + // + + if (SynchCommand == NCBHANGUP && + Src->ncb_retcode == NRC_SNUMOUT) { + + Dest->ncb_retcode = NRC_GOODRET; + Dest->ncb_cmd_cplt = NRC_GOODRET; + } else { + Dest->ncb_retcode = Src->ncb_retcode; + Dest->ncb_cmd_cplt = Src->ncb_cmd_cplt; + } +} + + +// This is the post routine which is used by NetBiosSubmit +// It clears the user's semaphore (after doing the internal copy and cleanup) +static +VOID +_stdcall +Od2NetBiosSemaphoreClearPostRoutine( + IN PNCB pNcb + ) +{ + // A user's command has completed. copy the result to his NCB and clear his semaphore. + + PNCB pOs2Ncb = ((PNCBX)pNcb)->original_pncb; // get user's NCB + HSYSSEM hUsersSemaphore = (HSYSSEM) ((PNCBX)pNcb)->original_ncb_post; // and semaphore handle + HANDLE Net16BiosHasCompleted = ((PNCBX)pNcb)->Net16BiosHasCompleted; // and notification event + APIRET RetCode; + + // Wait for Net16Bios to complete its job + + (VOID) NtWaitForSingleObject(Net16BiosHasCompleted, FALSE, NULL); + (VOID) NtClose(Net16BiosHasCompleted); + + (VOID) InterlockedIncrement(&Od2MaxAsynchNcbs); + + // Check if user's NCB space is still valid + + try { + Od2ProbeForWrite(pOs2Ncb, sizeof(NCB), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + // invalidate user's cancellation address + *(PNCB *)pOs2Ncb->ncb_reserve = NULL; + + // copy the results to the user's NCB + + Od2CopyNcbResults(pOs2Ncb, pNcb, TRUE); + +#if 1 +#if DBG + IF_OD2_DEBUG( NET ) { + Od2NcbDbgPrint(pNcb, pOs2Ncb, 3); + } +#endif +#endif + + // free our internal NCB + + RtlFreeHeap(Od2Nb2Heap, 0, pNcb); + + if (hUsersSemaphore == NULL) { + return; + } + + // clear user's semaphore + + if ((RetCode = DosSemClear(FARPTRTOFLAT(hUsersSemaphore))) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2NetBiosSemaphoreClearPostRoutine: Failed to Clear User Semaphore RetCode = %d\n", RetCode)); + } +#endif + } +} + + +// This is the post routine which is used by Netbios (= 3.0) +// It calls the user's post routine (after doing the internal copy and cleanup) +static +VOID +_stdcall +Od2NetBiosPostRoutine( + IN PNCB pNcb + ) +{ + // + // A user's command has completed. copy the result to his NCB and launch his post routine. + // + + PNCB pOs2Ncb = ((PNCBX)pNcb)->original_pncb; // get user's NCB + PVOID pUsersPostRoutine = (PVOID) ((PNCBX)pNcb)->original_ncb_post; // and post routine address + HANDLE Net16BiosHasCompleted = ((PNCBX)pNcb)->Net16BiosHasCompleted; // and notification event + APIRET RetCode; + BOOLEAN SpecialThread; // used to indicate a special addname thread + SEL TmpUserStackSel; // selector for netbios post routine user's stack in addname threads + SEL TmpUserStackAlias; // code alias for TmpUserStackSel + UCHAR SynchCommand; + + // + // Wait for Net16Bios to complete its job + // + + (VOID) NtWaitForSingleObject(Net16BiosHasCompleted, FALSE, NULL); + (VOID) NtClose(Net16BiosHasCompleted); + + // + // Grab the command for later + // + + SynchCommand = pNcb->ncb_command & ~ASYNCH; + + // + // Check if user's NCB space is still valid + // + + try { + Od2ProbeForWrite(pOs2Ncb, sizeof(NCB), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + // + // invalidate user's cancellation address + // + + *(PNCB *)pOs2Ncb->ncb_reserve = NULL; + + // + // copy the results to the user's NCB + // + + Od2CopyNcbResults(pOs2Ncb, pNcb, FALSE); + +#if 1 +#if DBG + IF_OD2_DEBUG( NET ) { + Od2NcbDbgPrint(pNcb, pOs2Ncb, 3); + } +#endif +#endif + + // + // free our internal NCB + // + + RtlFreeHeap(Od2Heap, 0, pNcb); + + if (pUsersPostRoutine == NULL) { + return; + } + + // + // Figure out if this is a special netbios addname thread. + // It must be attached separatly. If the TEB already has + // an environment then this is the worker thread, and it + // has already been attached. + // It is possible that this is the worker thread even though + // it's an addname-type command (this happens in case the + // worker fails to create an addname thread). This is OK + // The worker will be attached and detached now, and later + // re-attached if needed. + // + + if (NtCurrentTeb()->EnvironmentPointer == NULL && + (SynchCommand == NCBADDNAME || + SynchCommand == NCBADDGRNAME || + SynchCommand == NCBASTAT) + ) { + + SpecialThread = TRUE; + + } else { + + SpecialThread = FALSE; + } + + if (SpecialThread || + !Od2WorkerThreadIsAttached) { + + // + // Do this only one time for worker thread, or + // once for every special addname thread + // This code adopts the thread and makes it + // an OS/2 thread. + // + + // + // attach the thread to server tables + // + + if ((RetCode = Od2AttachWinThreadToOs2()) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2NetBiosPostRoutine: Failed to attach to Os2, RetCode = %d\n", RetCode)); + } +#endif + return; + } + + // + // allocate a stack + // + + if ((RetCode = DosAllocSeg(USERS_STACK_SIZE, &TmpUserStackSel, SEG_NONSHARED)) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2NetBiosPostRoutine: Failed to allocate stack for user, unable to launch\n")); + KdPrint((" user's post routine. DosAllocSeg rc = %u\n", RetCode)); + } +#endif + (VOID) Od2DosExit(EXIT_THREAD, 0L, 0xF0000000L); // this detaches the thread + return; + } + + if ((RetCode = DosCreateCSAlias(TmpUserStackSel, &TmpUserStackAlias)) != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2NetBiosPostRoutine: Failed to code alias user's stack, DosCreateCSAlias rc = %u\n", RetCode)); + } +#endif + (VOID) DosFreeSeg(TmpUserStackSel); + (VOID) Od2DosExit(EXIT_THREAD, 0L, 0xF0000000L); // this detaches the thread + return; + } + + if (!SpecialThread) { + + Od2UserStackSel = TmpUserStackSel; + Od2UserStackAlias = TmpUserStackAlias; + Od2WorkerThreadIsAttached = TRUE; + } + + } else { + + TmpUserStackSel = Od2UserStackSel; + TmpUserStackAlias = Od2UserStackAlias; + } + + // set up and run user's post routine + + Od2JumpTo16NetBiosPostDispatcher(pUsersPostRoutine, // 16-bit routine to jump to + SELTOFLAT(TmpUserStackSel), // flat ptr to user stack + USERS_STACK_SIZE, // stack size + TmpUserStackSel, // selector to user stack + TmpUserStackAlias, // code alias for user stack + (PVOID)FLATTOFARPTR(pOs2Ncb), // pointer to user's NCB + // pass it thru ES:BX + pOs2Ncb->ncb_retcode // pass through AX + ); + + if (SpecialThread) { + + // + // Deallocate stack and detach thread. + // The worker thread always remains attached. + // + + (VOID) DosFreeSeg(TmpUserStackAlias); + (VOID) DosFreeSeg(TmpUserStackSel); + (VOID) Od2DosExit(EXIT_THREAD, 0L, 0xF0000000L); // this only detaches the thread + } +} + + + +// This is the master Netbios 3.0 API. It checks the user's parameters, +// copies the NCB to an internal aligned NCB and calls win32 Netbios. +// some internal paramaters are attached to the NCB (see NCBX) on async calls + +APIRET +Net16bios( + IN PNCB pOs2Ncb + ) +{ + PNCB pNcb; + PNCB pCancelNcb; + UCHAR rc; + UCHAR SynchCommand; + UCHAR Asynch; + HANDLE Net16BiosHasCompleted; + BOOLEAN Nb2Semantics; + BOOLEAN WillPost; + PVOID NbHeap; + NTSTATUS Status; + + try { + Od2ProbeForWrite(pOs2Ncb, sizeof(NCB), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + pOs2Ncb->ncb_retcode = NRC_PENDING; + pOs2Ncb->ncb_cmd_cplt = NRC_PENDING; + + SynchCommand = pOs2Ncb->ncb_command & ~ASYNCH; + Asynch = pOs2Ncb->ncb_command & ASYNCH; + + if (*(PULONG)&pOs2Ncb->ncb_reserve[4] == NETBIOS2_SEMANTICS_SIGNATURE) { + *(PULONG)&pOs2Ncb->ncb_reserve[4] = 0; + Nb2Semantics = TRUE; + } else { + Nb2Semantics = FALSE; + } + + // + // Allocate internal NCB + // + + if (Nb2Semantics) { + NbHeap = Od2Nb2Heap; + } else { + NbHeap = Od2Heap; + } + + pNcb = (PNCB) RtlAllocateHeap(NbHeap, 0, sizeof(NCBX)); + + ASSERT(((ULONG)pNcb & 3) == 0); // pointer must be DWORD aligned + + if (pNcb == NULL) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16bios: Failed to RtlAllocateHeap internal NCB\n")); + } +#endif + pOs2Ncb->ncb_retcode = NRC_NORES; + pOs2Ncb->ncb_cmd_cplt = NRC_NORES; + // BUGBUG: should call post routine here if asynch. + return(NRC_NORES); + } + + RtlMoveMemory(pNcb, pOs2Ncb, sizeof(NCB)); + + // + // If it is a netbios 2 reset then modify the new NCB to the protect mode parameters + // + // Note: this is not currently used, since we allow open for NB_REGULAR only + // + if (Nb2Semantics && + SynchCommand == NCBRESET) { + if (pNcb->ncb_lsn == 0) { + pNcb->ncb_callname[0] = 6; + } else { + pNcb->ncb_callname[0] = pNcb->ncb_lsn; + } + if (pNcb->ncb_num == 0) { + pNcb->ncb_callname[1] = 12; + } else { + pNcb->ncb_callname[1] = pNcb->ncb_num; + } + pNcb->ncb_callname[2] = 16; + pNcb->ncb_callname[3] = 1; + pNcb->ncb_lsn = 0; + } + + // Check user's input + + switch (SynchCommand) { + case NCBSEND: + case NCBSENDNA: + case NCBDGSEND: + case NCBDGSENDBC: + + if (pNcb->ncb_buffer != NULL) { + + pNcb->ncb_buffer = FARPTRTOFLAT(pNcb->ncb_buffer); + + try { + Od2ProbeForRead(pNcb->ncb_buffer, pNcb->ncb_length, 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + } + break; + + case NCBCHAINSEND: + case NCBCHAINSENDNA: + + if (pNcb->ncb_buffer != NULL) { + + PCHAR TmpPtr; + + pNcb->ncb_buffer = FARPTRTOFLAT(pNcb->ncb_buffer); + + try { + Od2ProbeForRead(pNcb->ncb_buffer, pNcb->ncb_length, 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if ((TmpPtr = *(PCHAR *)&pOs2Ncb->ncb_callname[2]) != NULL) { + + TmpPtr = FARPTRTOFLAT(TmpPtr); + + try { + Od2ProbeForRead(TmpPtr, *(PUSHORT)pNcb->ncb_callname, 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + *(PCHAR *)&pNcb->ncb_callname[2] = TmpPtr; + } + } + break; + + case NCBFINDNAME: + case NCBRECV: + case NCBRECVANY: + case NCBDGRECV: + case NCBDGRECVBC: + case NCBASTAT: + case NCBSSTAT: + + if (pNcb->ncb_buffer != NULL) { + + pNcb->ncb_buffer = FARPTRTOFLAT(pNcb->ncb_buffer); + + try { + Od2ProbeForWrite(pNcb->ncb_buffer, pNcb->ncb_length, 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + } + break; + + case NCBCANCEL: + + if (pNcb->ncb_buffer != NULL) { + + // + // Note: no need to call post routine on error + // return from here, because the cancel command + // is not allowed to be asynch. + // + + pCancelNcb = (PNCB) FARPTRTOFLAT(pNcb->ncb_buffer); + + try { + Od2ProbeForWrite(pCancelNcb, sizeof(NCB), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (pCancelNcb->ncb_cmd_cplt != NRC_PENDING) { // is the command still pending? +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16bios: Got request to cancel a non-pending NCB, ignoring it\n")); + } +#endif + RtlFreeHeap(NbHeap, 0, pNcb); + pOs2Ncb->ncb_retcode = NRC_CANCEL; + pOs2Ncb->ncb_cmd_cplt = NRC_CANCEL; + return(NRC_CANCEL); + } + + pNcb->ncb_buffer = *(PUCHAR *)pCancelNcb->ncb_reserve; + + if (pNcb->ncb_buffer == NULL) { // assume we've just completed it + // this is reasonable, since cmd_cplt == NRC_PENDING +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16bios: NCB completed during request to cancel\n")); + } +#endif + RtlFreeHeap(NbHeap, 0, pNcb); + pOs2Ncb->ncb_retcode = NRC_CANOCCR; + pOs2Ncb->ncb_cmd_cplt = NRC_CANOCCR; + return(NRC_CANOCCR); + } + + try { + Od2ProbeForWrite(pNcb->ncb_buffer, sizeof(NCBX), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + + // + // The user gave an invalid address + // + +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16bios: Got an invalid NCB address to cancel, ignoring it\n")); + } +#endif + RtlFreeHeap(NbHeap, 0, pNcb); + pOs2Ncb->ncb_retcode = NRC_BADDR; + pOs2Ncb->ncb_cmd_cplt = NRC_BADDR; + return(NRC_BADDR); + } + } + break; + } + + RtlZeroMemory(pNcb->ncb_reserve, 14); + + // + // Set up async processing + // + + if (Asynch) { + + Status = NtCreateEvent(&Net16BiosHasCompleted, + EVENT_ALL_ACCESS, + NULL, + NotificationEvent, + FALSE); + + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Net16Bios: Can't create an event for synchronization of post routine, rc = %X\n", Status)); + } +#endif + RtlFreeHeap(NbHeap, 0, pNcb); + pOs2Ncb->ncb_retcode = NRC_OSRESNOTAV; + pOs2Ncb->ncb_cmd_cplt = NRC_OSRESNOTAV; + // BUGBUG: should call post routine here. + return(NRC_OSRESNOTAV); + } + + // BUGBUG: we must make sure the event is properly cleaned up if the thread terminates + // between here and the point it's signalled. + + ((PNCBX)pNcb)->original_pncb = pOs2Ncb; + ((PNCBX)pNcb)->original_ncb_post = (ULONG) pNcb->ncb_post; + ((PNCBX)pNcb)->Net16BiosHasCompleted = Net16BiosHasCompleted; + *(PNCB *)pOs2Ncb->ncb_reserve = pNcb; + + if (Nb2Semantics) { + pNcb->ncb_post = Od2NetBiosSemaphoreClearPostRoutine; + } else { + pNcb->ncb_post = Od2NetBiosPostRoutine; + } + } else { + pNcb->ncb_post = NULL; + } + +#if 1 +#if DBG + IF_OD2_DEBUG( NET ) { + Od2NcbDbgPrint(pNcb, pOs2Ncb, 1); + } +#endif +#endif + + // + // and go do it + // + + if (Nb2Semantics) { + + rc = Od2Netbios(pNcb, Od2NbDev, &WillPost); + + } else { + + rc = Netbios(pNcb); + + // + // The following are the cases where win32 netbios does not call + // the post routine when called asynch: + // 1) bad ncb alignment (NRC_BADDR) -- won't happen + // 2) ncb_event and ncb_post both given (NRC_ILLCMD) -- won't happen + // 3) returns NRC_OPENERR + // this happens when win32 can't open \device\netbios + // or can't create a reserved event for sync processing. + // 4) sometimes when returns NRC_SYSTEM + // if win32 returns -- no post routine + // this happens when can't create worker thread + // or when can't create related events + // (event, addnameevent) + // if driver returns -- will call post routine + // 5) an access violation after chain send ncb completion when copying + // BigBuffer back to user space, or accessing the ncb + // internals (post, event). + // + // The only case we can't be sure about is NRC_SYSTEM. In this + // case it is better to assume the post routine will get called. + // the only damage that can be incurred in this way is that the + // ncb remains left behind on NbHeap, and Net16BiosHasCompleted + // event is not deleted. this isn't too bad, assuming this is + // a rare problem. + // + + if (Asynch && rc != NRC_OPENERR) { + WillPost = TRUE; + } else { + WillPost = FALSE; + } + } + + // copy results from internal NCB to user's NCB + + Od2CopyNcbResults(pOs2Ncb, pNcb, Nb2Semantics); + +#if 1 +#if DBG + IF_OD2_DEBUG( NET ) { + Od2NcbDbgPrint(pNcb, pOs2Ncb, 2); + KdPrint(("rc : %d\n", rc)); + } +#endif +#endif + +// Note that if the command was a CANCEL, the post routine of the cancelled NCB still gets called, +// and will clean up the cancelled NCB as needed + + if (Asynch) { + if (WillPost) { + (VOID) NtSetEvent(Net16BiosHasCompleted, NULL); + } else { + (VOID) NtClose(Net16BiosHasCompleted); + RtlFreeHeap(NbHeap, 0, pNcb); + if (Nb2Semantics) { + (VOID) InterlockedIncrement(&Od2MaxAsynchNcbs); + } + } + } else { + RtlFreeHeap(NbHeap, 0, pNcb); + } + + return((APIRET) rc); +} + + +//******************* +// Following are old Netbios APIs (lanman 2.x). We create a fictional logical network +// for each lan adapter in the system. This is done by using NCBENUM. NCBENUM gives +// us a list of all valid lana numbers in the system. We assign NET1 to the 1st lana +// NET2 to the 2nd lana and so on. The "default device" for NetBiosOpen and Submit is always +// NET DEFAULT_NET. +// The device handle which is used to operate a logical network is simply the NET +// number + 1. Handle 0 is equivalent to the default net. +//******************* + + +ULONG +Od2NetNumberToLanaIndex( + IN ULONG NetNumber + ) +{ + if (NetNumber == 0L) { // use default net ? + if (Od2LanaEnum.length >= DEFAULT_NET) { + return((ULONG)(DEFAULT_NET - 1)); + } else { + return(0L); + } + } else { + if ((ULONG)Od2LanaEnum.length >= NetNumber) { + return(NetNumber - 1); + } else { + return((ULONG)-1); + } + } +} + + +NTSTATUS +Od2ActivateLana( + IN ULONG NetNumber, + OUT PULONG pLanaIndex OPTIONAL + ) +{ + // + // This routine takes a net number, and makes sure netbios 2 is initialized + // and ready on that lana. overall netbios 2 initialization is done if necessary. + // if NetNumber is (-1), overall initialization is done, but not for a particular + // lana. + // + + OS2_API_MSG m; + POS2_NETBIOS_MSG a = &m.u.Netbios2Request; + BOOLEAN InCrit = FALSE; + ULONG LanaIndex; + PVOID BaseAddress; + APIRET RetCode; + BOOLEAN RemoveLDTEntry = FALSE; + + if (!Od2Netbios2Initialized) { + + RtlEnterCriticalSection(&Od2NbSyncCrit); + + if (!Od2Netbios2Initialized) { // check again in case we just did it + + // + // allocate a special heap to hold the netbios 2 packets. + // we allocate this as a shared memory object in order that + // the heap have a unique address within each process. no + // sharing of memory is actually being done. the reason + // unique addresses are necessary is because the netbios + // driver gets confused about cancel requests when 2 processes + // have the same netbios packet address. + // + + RetCode = DosAllocSharedMem( + &BaseAddress, + NULL, // no name + 0x10000L, // reserve 64K for the heap + OBJ_GIVEABLE | PAG_READ | PAG_WRITE, + FALSE // Don't create LDT entry + ); + + if (RetCode != NO_ERROR) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2ActivateLana: DosAllocSharedMem failed, RetCode = %x\n", RetCode)); + } +#endif + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(STATUS_NO_MEMORY); + } + + Od2Nb2Heap = RtlCreateHeap( + HEAP_GROWABLE, + BaseAddress, + 0x10000L, // initial reserved amount + 0L, // initial commit = 1 page + NULL, // standard lock + 0L); // reserved + + if (Od2Nb2Heap == NULL) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2ActivateLana: RtlCreateHeap failed\n")); + } +#endif + DosFreeMem(BaseAddress, &RemoveLDTEntry); + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(STATUS_NO_MEMORY); + } + + // + // call server to get initial device handle, lana enumeration + // initialize internal lanastate + // + + if (NetNumber == (ULONG)-1) { + a->RequestType = NB2_INIT; + } else { + a->RequestType = NB2_INIT_LANA; + a->NetNumber = (UCHAR) NetNumber; + } + + m.ReturnedErrorValue = NO_ERROR; + Od2CallSubsystem(&m, NULL, Os2Netbios2Reqst, sizeof(*a)); + + if (!NT_SUCCESS(a->ReturnStatus)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("Od2ActivateLana: Call to server for init failed, Status = %lx\n", a->ReturnStatus)); + } +#endif + RtlDestroyHeap(Od2Nb2Heap); + DosFreeMem(BaseAddress, &RemoveLDTEntry); + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(a->ReturnStatus); + } + + Od2LanaEnum.length = a->LanaEnumLength; + RtlMoveMemory(Od2LanaEnum.lana, a->LanaEnum, MAX_LANA); + RtlZeroMemory(Od2LanaState, sizeof(Od2LanaState)); + Od2NbDev = a->hDev; + Od2MaxAsynchNcbs = (LONG) MAX_ASYNCH_NCBS; + + Od2Netbios2Initialized = TRUE; + + if (NetNumber != (ULONG)-1) { + if (a->RetCode != NB2ERR_INVALID_LANA) { + + LanaIndex = Od2NetNumberToLanaIndex(NetNumber); + + Od2LanaState[LanaIndex] |= 0x1; + + if (ARGUMENT_PRESENT(pLanaIndex)) { + *pLanaIndex = LanaIndex; + } + } else { + if (ARGUMENT_PRESENT(pLanaIndex)) { + *pLanaIndex = (ULONG) -1; + } + } + } + + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(STATUS_SUCCESS); + + } + + InCrit = TRUE; + } + + if (NetNumber == (ULONG)-1) { + if (InCrit) { + RtlLeaveCriticalSection(&Od2NbSyncCrit); + } + return(STATUS_SUCCESS); + } + + LanaIndex = Od2NetNumberToLanaIndex(NetNumber); + + if (LanaIndex == (ULONG)-1) { + + if (ARGUMENT_PRESENT(pLanaIndex)) { + *pLanaIndex = (ULONG) -1; + } + if (InCrit) { + RtlLeaveCriticalSection(&Od2NbSyncCrit); + } + return(STATUS_SUCCESS); + } + + if (!(Od2LanaState[LanaIndex] & 0x1)) { + + if (!InCrit) { + + RtlEnterCriticalSection(&Od2NbSyncCrit); + InCrit = TRUE; + + if (Od2LanaState[LanaIndex] & 0x1) { // check again in case we just did it + goto Od2LanaNumGood; + } + } + + // + // call server to init lana + // + + if (Od2LanaState[LanaIndex] & 0x2) { + Od2LanaState[LanaIndex] &= ~0x2; + Od2LanaState[LanaIndex] |= 0x1; + goto Od2LanaNumGood; + } + + a->RequestType = NB2_LANA; + a->NetNumber = (UCHAR) NetNumber; + + m.ReturnedErrorValue = NO_ERROR; + Od2CallSubsystem(&m, NULL, Os2Netbios2Reqst, sizeof(*a)); + + if (!NT_SUCCESS(a->ReturnStatus)) { + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(a->ReturnStatus); + } + + if (a->RetCode != NB2ERR_INVALID_LANA) { + + Od2LanaState[LanaIndex] |= 0x1; + goto Od2LanaNumGood; + + } else { + if (ARGUMENT_PRESENT(pLanaIndex)) { + *pLanaIndex = (ULONG) -1; + } + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(STATUS_SUCCESS); + } + } + +Od2LanaNumGood: + + if (ARGUMENT_PRESENT(pLanaIndex)) { + *pLanaIndex = LanaIndex; + } + + if (InCrit) { + RtlLeaveCriticalSection(&Od2NbSyncCrit); + } + + return(STATUS_SUCCESS); +} + + +APIRET +Net16BiosClose( + ULONG hDevName + ) +{ +// NCB Ncb; + ULONG LanaIndex; + +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosClose() called, hDevName = %lu\n", hDevName)); + } +#endif + + if (hDevName == 0) { + return(NERR_Success); // dummy close for the "default handle" + } + + if (!Od2Netbios2Initialized) { // we haven't been initialized at all + return(NERR_NetNotStarted); + } + + LanaIndex = Od2NetNumberToLanaIndex(hDevName); + + if (LanaIndex == (ULONG)-1) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosClose: invalid hDevName = %lu\n", hDevName)); + } +#endif + return(ERROR_INVALID_HANDLE); + } + + // + // check if it's already closed... + // + + if (!(Od2LanaState[LanaIndex] & 0x1)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosClose: already closed hDevName = %lu\n", hDevName)); + } +#endif + return(ERROR_INVALID_HANDLE); + } + + RtlEnterCriticalSection(&Od2NbSyncCrit); + + // + // recheck in case we just closed it. + // + + if (!(Od2LanaState[LanaIndex] & 0x1)) { + RtlLeaveCriticalSection(&Od2NbSyncCrit); +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosClose: already closed hDevName = %lu\n", hDevName)); + } +#endif + return(ERROR_INVALID_HANDLE); + } + + // + // we mark the lana as pseudo-closed. It won't be used anymore + // until it's reopened. + // + + Od2LanaState[LanaIndex] &= ~0x1; + Od2LanaState[LanaIndex] |= 0x2; + + + // + // BUGBUG: We can no longer reset the adapter in order to + // cancel all pending ncbs on a particular lana. Currently, + // there is no other way to do this, so we skip cancelling + // pending ncbs, and hope there won't be a problem. + // + // Note: a way to do this might be to issue an NtCancelIoFile() + // from the netbios worker thread. But this will cancel on all + // lana. + // + +#if 0 + // Reset the corresponding adapter so all pending NCBs get cancelled + + RtlZeroMemory(&Ncb, sizeof(NCB)); + Ncb.ncb_command = NCBRESET; + Ncb.ncb_lana_num = Od2LanaEnum.lana[LanaIndex]; + + Net16bios(&Ncb); + + if (Ncb.ncb_retcode != NRC_GOODRET) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosClose: Unable to reset adapter %lu, retcode = %x\n", (ULONG)Ncb.ncb_lana_num, (ULONG)Ncb.ncb_retcode)); + } +#endif + } +#endif + + RtlLeaveCriticalSection(&Od2NbSyncCrit); + return(NERR_Success); +} + + +APIRET +Net16BiosEnum( + PCHAR pszServer, + LONG sLevel, + PCHAR pbBuffer, + ULONG cbBuffer, + PUSHORT pcEntriesRead, + PUSHORT pcTotalAvail + ) +{ + NTSTATUS Status; + ULONG strucsiz; + UCHAR i; + struct netbios_info_0 nb0; + struct netbios_info_1 nb1; + + try { + if ((pszServer != NULL) && (*pszServer != '\0')) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosEnum() for a remote server is not implemented yet\n")); + } +#endif + return(ERROR_NOT_SUPPORTED); + } + + Od2ProbeForWrite(pbBuffer, cbBuffer, 1); + Od2ProbeForWrite(pcEntriesRead, sizeof(USHORT), 1); + Od2ProbeForWrite(pcTotalAvail, sizeof(USHORT), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 0 && sLevel != 1) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosEnum() Level %d not legal\n", sLevel)); + } +#endif + return(ERROR_INVALID_LEVEL); + } + + Status = Od2ActivateLana( + (ULONG) -1, + NULL); + + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosEnum() Od2ActivateLana failed, Status = %lx\n", Status)); + } +#endif + return(NERR_NetNotStarted); + } + + *pcTotalAvail = (USHORT) Od2LanaEnum.length; + *pcEntriesRead = 0; + + strucsiz = sLevel == 0 ? sizeof(nb0) : sizeof(nb1); + + for (i = 0; i < Od2LanaEnum.length && cbBuffer >= strucsiz; i++) { + if (sLevel == 0) { + RtlZeroMemory(&nb0, strucsiz); + strcpy(nb0.nb0_net_name, "NET"); + _itoa((int)i+1, &nb0.nb0_net_name[3], 10); + RtlMoveMemory(pbBuffer, &nb0, strucsiz); + } else { // sLevel == 1 + RtlZeroMemory(&nb1, strucsiz); + strcpy(nb1.nb1_net_name, "NET"); + _itoa((int)i+1, &nb1.nb1_net_name[3], 10); + strcpy(nb1.nb1_driver_name, "VrtWnNB$"); + nb1.nb1_lana_num = Od2LanaEnum.lana[i]; + + // put some fictive information in it... + + nb1.nb1_driver_type = NB_TYPE_NCB; + nb1.nb1_net_status = NB_OPEN_REGULAR|NB_LAN_MANAGED; + nb1.nb1_net_bandwidth = 10000000L; + nb1.nb1_max_sess = 255; + nb1.nb1_max_ncbs = 255; + nb1.nb1_max_names = 255; + + RtlMoveMemory(pbBuffer, &nb1, strucsiz); + } + pbBuffer += strucsiz; + cbBuffer -= strucsiz; + (*pcEntriesRead)++; + } + + if (*pcEntriesRead < (USHORT)Od2LanaEnum.length) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosEnum: returning ERROR_MORE_DATA\n")); + } +#endif + return(ERROR_MORE_DATA); + } + return(NERR_Success); +} + + +APIRET +Net16BiosGetInfo( + PCHAR pszServer, + PCHAR pszNetBiosName, + LONG sLevel, + PCHAR pbBuffer, + ULONG cbBuffer, + PUSHORT pcbTotalAvail + ) +{ + NTSTATUS Status; + ULONG strucsiz; + ULONG NetNumber; + ULONG LanaIndex; + struct netbios_info_0 nb0; + struct netbios_info_1 nb1; + + try { + if ((pszServer != NULL) && (*pszServer != '\0')) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosGetInfo() for a remote server is not implemented yet\n")); + } +#endif + return(ERROR_NOT_SUPPORTED); + } + + PROBE_STRING(pszNetBiosName); + Od2ProbeForWrite(pbBuffer, cbBuffer, 1); + Od2ProbeForWrite(pcbTotalAvail, sizeof(USHORT), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (sLevel != 0 && sLevel != 1) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosGetInfo() Level %d not legal\n", sLevel)); + } +#endif + return(ERROR_INVALID_LEVEL); + } + + strucsiz = sLevel == 0 ? sizeof(nb0) : sizeof(nb1); + + if (cbBuffer < strucsiz) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosGetInfo: user buffer too small\n")); + } +#endif + return(NERR_BufTooSmall); + } + + if (pszNetBiosName == NULL || *pszNetBiosName == '\0') { + NetNumber = 0; + } else { + if (_strnicmp(pszNetBiosName, "NET", 3)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosGetInfo: Bad network name: %s\n", pszNetBiosName)); + } +#endif + return(ERROR_BAD_NETPATH); + } + + NetNumber = atol(pszNetBiosName+3); + } + + Status = Od2ActivateLana( + (ULONG) -1, + NULL); + + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosGetInfo() Od2ActivateLana failed, Status = %lx\n", Status)); + } +#endif + return(NERR_NetNotStarted); + } + + LanaIndex = Od2NetNumberToLanaIndex(NetNumber); + + if (LanaIndex == (ULONG) -1) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosGetInfo: Bad network name: %s\n", pszNetBiosName)); + } +#endif + return(ERROR_BAD_NETPATH); + } + + *pcbTotalAvail = (USHORT) strucsiz; + + if (sLevel == 0) { + RtlZeroMemory(&nb0, strucsiz); + strcpy(nb0.nb0_net_name, pszNetBiosName); + RtlMoveMemory(pbBuffer, &nb0, strucsiz); + } else { // sLevel == 1 + RtlZeroMemory(&nb1, strucsiz); + strcpy(nb1.nb1_net_name, pszNetBiosName); + strcpy(nb1.nb1_driver_name, "VrtWnNB$"); + nb1.nb1_lana_num = Od2LanaEnum.lana[LanaIndex]; + + // put some fictive information in it... + + nb1.nb1_driver_type = NB_TYPE_NCB; + nb1.nb1_net_status = NB_OPEN_REGULAR|NB_LAN_MANAGED; + nb1.nb1_net_bandwidth = 10000000L; + nb1.nb1_max_sess = 255; + nb1.nb1_max_ncbs = 255; + nb1.nb1_max_names = 255; + + RtlMoveMemory(pbBuffer, &nb1, strucsiz); + } + + return(NERR_Success); +} + + +APIRET +Net16BiosOpen( + PCHAR pszDevName, + PCHAR pszReserved, + ULONG usOpenOpt, + PUSHORT phDevName + ) +{ + NTSTATUS Status; + ULONG NetNumber; + ULONG LanaIndex; + + UNREFERENCED_PARAMETER(pszReserved); + +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen() called\n")); + } +#endif + + try { + PROBE_STRING(pszDevName); + Od2ProbeForWrite(phDevName, sizeof(USHORT), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (usOpenOpt < NB_REGULAR || + usOpenOpt > NB_EXCLUSIVE) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen() illegal usOpenOpt = %lx\n", usOpenOpt)); + } +#endif + return(ERROR_INVALID_PARAMETER); + } + + if (usOpenOpt != NB_REGULAR) { // we only support NB_REGULAR for now +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen() unsupported usOpenOpt = %lx\n", usOpenOpt)); + } +#endif + return(ERROR_ACCESS_DENIED); + } + + if (pszDevName == NULL || *pszDevName == '\0') { + NetNumber = 0L; + } else { + if (_strnicmp(pszDevName, "NET", 3)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen: Bad network name: %s\n", pszDevName)); + } +#endif + return(ERROR_BAD_NETPATH); + } + + NetNumber = atol(pszDevName+3); + } + + if (NetNumber > 0xffL) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen: Bad network name: %s\n", pszDevName)); + } +#endif + return(ERROR_BAD_NETPATH); + } + + Status = Od2ActivateLana( + NetNumber, + &LanaIndex); + + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen() Od2ActivateLana failed, Status = %lx\n", Status)); + } +#endif + return(NERR_NetNotStarted); + } + + if (LanaIndex == (ULONG) -1) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosOpen: Bad network name: %s\n", pszDevName)); + } +#endif + return(ERROR_BAD_NETPATH); + } + + if (NetNumber != 0) { + *phDevName = (USHORT) NetNumber; + } else { + if (Od2LanaEnum.length >= DEFAULT_NET) { + *phDevName = (USHORT) DEFAULT_NET; + } else { + *phDevName = (USHORT) 1; + } + } + + return(NERR_Success); +} + + +// Old lanman NetBiosSubmit. Generally depends on the newer Netbios 3.0 (Net16bios) +// however, this implements the following differences: +// +// - on async requests, a semaphore is cleared instead of calling a post routine +// - implements the possiblity of NCB chaining which is unavailable with Net16bios +// - does an automatic open of the default lana if necessary +// + +APIRET +Net16BiosSubmit( + IN ULONG hDevName, + IN ULONG NcbOpt, + IN OUT PVOID pNCB + ) +{ + PNCB pNcb; + PCHAR OrigSegBase; + NTSTATUS Status; + ULONG LanaIndex; + BOOLEAN FirstRound; + BOOLEAN CancelChain; + USHORT Link; + UCHAR OrigLanaNum; + UCHAR SynchCommand; + UCHAR Asynch; + UCHAR rc; + +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit() called\n")); + } +#endif + + if (NcbOpt > 3) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit called with an invalid NcbOpt = %lu\n", NcbOpt)); + } +#endif + return(ERROR_INVALID_PARAMETER); + } + + if (hDevName > 0xffL) { + + LanaIndex = (ULONG)-1; + + } else if (hDevName == 0L) { // use default net? + + // + // do a default open of device handle 0 + // + + Status = Od2ActivateLana( + hDevName, + &LanaIndex); + + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit: Od2ActivateLana failed, Status= %lx\n", Status)); + } +#endif + return(NERR_NetNotStarted); + } + + } else { + + // + // Initialize, and check if the handle is open + // + + Status = Od2ActivateLana( + (ULONG) -1, + NULL); + + if (!NT_SUCCESS(Status)) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit: Od2ActivateLana failed, Status= %lx\n", Status)); + } +#endif + return(NERR_NetNotStarted); + } + + LanaIndex = Od2NetNumberToLanaIndex(hDevName); + + if (LanaIndex != (ULONG) -1) { + + if (!(Od2LanaState[LanaIndex] & 0x1)) { // lana closed? + LanaIndex = (ULONG) -1; + } + } + + } + + if (LanaIndex == (ULONG) -1) { +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit: Bad handle, hDevName = %lu\n", hDevName)); + } +#endif + return(ERROR_INVALID_HANDLE); + } + + // + // NcbOpt == 1 implies that we should retry the NCB on some types of errors. + // Since the LanMan programmer's reference does not document which errors cause a + // retry, we shall not retry anything for the present + // + + for (FirstRound = TRUE, CancelChain = FALSE; ; FirstRound = FALSE) { + + if (NcbOpt > 1) { + + if (FirstRound) { + OrigSegBase = SELTOFLAT(FLATTOSEL(pNCB)); + } + + try { + Link = *(PUSHORT)pNCB; + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (Link == 0xffff) { + if (FirstRound) { + return(NERR_Success); + } else { + break; + } + } + + pNcb = (PNCB)((PCHAR)pNCB+sizeof(USHORT)); + pNCB = (PVOID)(OrigSegBase + Link); + + try { + Od2ProbeForWrite(pNcb, sizeof(NCB), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + + if (CancelChain) { + pNcb->ncb_retcode = NRC_CMDCAN; + pNcb->ncb_cmd_cplt = NRC_CMDCAN; + continue; + } + } else { + if (FirstRound) { + pNcb = (PNCB) pNCB; + + try { + Od2ProbeForWrite(pNcb, sizeof(NCB), 1); + } except( EXCEPTION_EXECUTE_HANDLER ) { + Od2ExitGP(); + } + } + } + + pNcb->ncb_retcode = NRC_PENDING; + pNcb->ncb_cmd_cplt = NRC_PENDING; + + SynchCommand = pNcb->ncb_command & ~ASYNCH; + Asynch = pNcb->ncb_command & ASYNCH; + + // + // If it is a netbios 2 reset - disallow, since we only allow open for NB_REGULAR. + // + + if (SynchCommand == NCBRESET) { + pNcb->ncb_retcode = NRC_ILLCMD; + pNcb->ncb_cmd_cplt = NRC_ILLCMD; + rc = NRC_ILLCMD; + goto ErrorHandling; + } + + if (Asynch) { + + LONG Count; + + Count = InterlockedDecrement(&Od2MaxAsynchNcbs); + + if (Count < 0) { + + (VOID) InterlockedIncrement(&Od2MaxAsynchNcbs); +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit: max asynch ncb count exceeded\n")); + } +#endif + pNcb->ncb_retcode = NRC_NORES; + pNcb->ncb_cmd_cplt = NRC_NORES; + rc = NRC_NORES; + goto ErrorHandling; + + } + } + + // + // switch lananum to represent the "device driver" + // originally this was done only if the lananum is 0, + // but it is now done always + // + + OrigLanaNum = pNcb->ncb_lana_num; + pNcb->ncb_lana_num = Od2LanaEnum.lana[LanaIndex]; + + // + // mark this as a netbios 2 ncb for special processing + // + + *(PULONG)&pNcb->ncb_reserve[4] = NETBIOS2_SEMANTICS_SIGNATURE; + + Net16bios(pNcb); + + rc = pNcb->ncb_retcode; + pNcb->ncb_lana_num = OrigLanaNum; + +ErrorHandling: + + if (NcbOpt == 0) { + break; + } else if (NcbOpt == 1) { + + // for implementing error-retry on a single NCB, check the error code here + // and if it should be retried simply "continue" instead of "break" + break; + + } else if (NcbOpt == 3) { // stop on error + CancelChain = TRUE; + } + + // if proceed-on-error, continue the loop + } + + switch (rc) { + case NRC_GOODRET: + case NRC_PENDING: + return(NERR_Success); + + default: +#if DBG + IF_OD2_DEBUG( NET ) { + KdPrint(("NetBiosSubmit: Final return code = %x\n", (ULONG)rc)); + } +#endif + return((APIRET)rc | 0x100); + } +} + +APIRET +DosINetTransaction( + IN LPSTR ServerName, + IN LPBYTE SendParmBuffer, + IN DWORD SendParmBufLen, + IN LPBYTE SendDataBuffer, + IN DWORD SendDataBufLen, + OUT LPBYTE ReceiveParmBuffer, + IN DWORD ReceiveParmBufLen, + IN LPBYTE ReceiveDataBuffer, + IN OUT LPDWORD ReceiveDataBufLen, + IN BOOL NullSessionFlag + ) + +/*++ + +Routine Description: + + Sends a transaction request to a server and receives a response + +Arguments: + + ServerName - to send request to + SendParmBuffer - send parameters + SendParmBufLen - length of send parameters + SendDataBuffer - send data + SendDataBufLen - length of send data + ReceiveParmBuffer - receive parameter buffer + ReceiveParmBufLen - length of receive parameter buffer + ReceiveDataBuffer - where to receive data + ReceiveDataBufLen - length of data buffer + NullSessionFlag - set if we are to use a null session + +Return Value: + + APIRET + Success - NERR_Success + Failure - + +--*/ + +{ + APIRET status; + + status = RxpTransactSmb((USHORT *)ServerName, + + // + // BUGBUG - transport name? + // + + (LPTSTR)NULL, + SendParmBuffer, + SendParmBufLen, + SendDataBuffer, + SendDataBufLen, + ReceiveParmBuffer, + ReceiveParmBufLen, + ReceiveDataBuffer, + ReceiveDataBufLen, + NullSessionFlag + ); + + return status; +} + + +APIRET +DosIRemoteApi( + IN DWORD ApiNumber, + IN LPSTR ServerNamePointer, + IN LPSTR ParameterDescriptor, + IN LPSTR DataDescriptor, + IN LPSTR AuxDescriptor, + IN ULONG NullSessionFlag + ) +{ + APIRET rc; + +#if DBG + USHORT tid, pid; + + IF_OD2_DEBUG ( APIS ) { + pid = (USHORT)(Od2Process->Pib.ProcessId); + tid = (USHORT)(Od2CurrentThreadId()); + + if ((Os2DebugTID == 0) || (Os2DebugTID == tid)) + { + KdPrint(("[PID %d: TID %d] %s\n", + pid, tid, Os2NetAPIName[ApiNumber])); + } + } +#endif + + rc = VrRemoteApi( + ApiNumber, + ServerNamePointer, + ParameterDescriptor, + DataDescriptor, + AuxDescriptor, + (UCHAR)NullSessionFlag + ); + return rc; +} + +APIRET + VrEncryptSES( + IN LPSTR ServerNamePointer, + IN LPSTR passwordPointer, // Input password (Not encripted) + IN LPSTR encryptedLmOwfPassword // output password (encripted) + ); + +APIRET +DosIEncryptSES( + IN LPSTR ServerNamePointer, + IN LPSTR passwordPointer, // Input password (Not encripted) + IN LPSTR encryptedLmOwfPassword // output password (encripted) + ) +{ + APIRET rc; + + rc = VrEncryptSES(ServerNamePointer, passwordPointer, + encryptedLmOwfPassword); + return(rc); +} + +APIRET +NetIWkstaGetUserInfo (LPBYTE UserName, LPBYTE LogonServer, + LPBYTE LogonDomain, LPBYTE OtherDomains, LPBYTE WsName) +{ + //TCHAR Server[UNCLEN]; + LPBYTE BufPtr; + NET_API_STATUS rc; + PWKSTA_USER_INFO_1 pInfo1; + PWKSTA_INFO_100 pInfo2; + + rc = NetWkstaUserGetInfo(NULL, 1L, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + pInfo1 = (PWKSTA_USER_INFO_1) BufPtr; + + UT2ANSIstrcpy(UserName, pInfo1->wkui1_username); + + strcpy(LogonServer, "\\\\"); + UT2ANSIstrcpy(LogonServer + 2, pInfo1->wkui1_logon_server); + + UT2ANSIstrcpy(LogonDomain, pInfo1->wkui1_logon_domain); + + UT2ANSIstrcpy(OtherDomains, pInfo1->wkui1_oth_domains); + + NetApiBufferFree(BufPtr); + + rc = NetWkstaGetInfo(0L, 100L, &BufPtr); + + if (rc != NO_ERROR) { + return(rc); + } + + pInfo2 = (PWKSTA_INFO_100) BufPtr; + + UT2ANSIstrcpy(WsName, pInfo2->wki100_computername); + + NetApiBufferFree(BufPtr); + + return NO_ERROR; + +} |