You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
411 lines
11 KiB
411 lines
11 KiB
/*++
|
|
|
|
Copyright (c) 1991-1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
csc.c
|
|
|
|
Abstract:
|
|
|
|
These are the server service API RPC client stubs for CSC
|
|
|
|
--*/
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <rpcutil.h>
|
|
#include <lmcons.h>
|
|
#include <lmerr.h>
|
|
#include <lmapibuf.h>
|
|
#include <lmshare.h>
|
|
#include "cscp.h"
|
|
|
|
static FARPROC pCSCFindFirstFile = NULL;
|
|
static FARPROC pCSCFindNextFile = NULL;
|
|
static FARPROC pCSCFindClose = NULL;
|
|
static FARPROC pCSCIsServerOffline = NULL;
|
|
|
|
//
|
|
// Load the cscdll.dll library, and pull out the functions that we need.
|
|
//
|
|
GetCSCEntryPoints()
|
|
{
|
|
HANDLE hMod;
|
|
|
|
if( pCSCFindFirstFile == NULL ) {
|
|
|
|
//
|
|
// Get the entry points in reverse order for multithread protection
|
|
//
|
|
hMod = LoadLibrary(L"cscdll.dll");
|
|
if( hMod == NULL ) {
|
|
return 0;
|
|
}
|
|
|
|
pCSCFindClose = GetProcAddress(hMod,"CSCFindClose");
|
|
if( pCSCFindClose == NULL ) {
|
|
return 0;
|
|
}
|
|
|
|
pCSCFindNextFile = GetProcAddress(hMod,"CSCFindNextFileW" );
|
|
if( pCSCFindNextFile == NULL ) {
|
|
return 0;
|
|
}
|
|
|
|
pCSCIsServerOffline = GetProcAddress(hMod, "CSCIsServerOfflineW" );
|
|
if( pCSCIsServerOffline == NULL ) {
|
|
return 0;
|
|
}
|
|
|
|
pCSCFindFirstFile = GetProcAddress(hMod,"CSCFindFirstFileW" );
|
|
}
|
|
return pCSCFindFirstFile != 0;
|
|
}
|
|
|
|
//
|
|
// return TRUE if we think this server is in the offline state
|
|
//
|
|
BOOLEAN
|
|
CSCIsServerOffline(
|
|
IN LPWSTR servername
|
|
)
|
|
{
|
|
BOOL isOffline;
|
|
|
|
if( GetCSCEntryPoints() &&
|
|
pCSCIsServerOffline( servername, &isOffline ) &&
|
|
isOffline == TRUE ) {
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Emulate NetShareEnum() for offline servers
|
|
//
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
CSCNetShareEnum (
|
|
IN LPWSTR servername,
|
|
IN DWORD level,
|
|
OUT LPBYTE *bufptr,
|
|
OUT LPDWORD entriesread,
|
|
OUT LPDWORD totalentries
|
|
)
|
|
{
|
|
HANDLE hFind = INVALID_HANDLE_VALUE;
|
|
WIN32_FIND_DATAW sFind32;
|
|
DWORD dwError, dwStatus, dwPinCount, dwHintFlags;
|
|
FILETIME ftOrgTime;
|
|
NET_API_STATUS apiStatus;
|
|
LPWSTR server, share;
|
|
PBYTE outbuf = NULL, endp;
|
|
DWORD count, numFound, sharelen;
|
|
|
|
if( (level != 0 && level != 1) ) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
try {
|
|
|
|
if (servername[0] != L'\\')
|
|
{
|
|
// OK
|
|
}
|
|
else if ((servername[0] == L'\\') && (servername[1] == L'\\'))
|
|
{
|
|
servername += 2;
|
|
}
|
|
else{
|
|
apiStatus = ERROR_NOT_SUPPORTED;
|
|
goto try_exit;
|
|
}
|
|
|
|
|
|
count = 1024;
|
|
|
|
retry:
|
|
numFound = 0;
|
|
|
|
//
|
|
// Allocate space for the results
|
|
//
|
|
if( outbuf != NULL ) {
|
|
NetApiBufferFree( outbuf );
|
|
outbuf = NULL;
|
|
count *= 2;
|
|
}
|
|
apiStatus = NetApiBufferAllocate( count, &outbuf );
|
|
|
|
if( apiStatus != NO_ERROR ) {
|
|
goto try_exit;
|
|
}
|
|
endp = outbuf + count;
|
|
|
|
RtlZeroMemory( outbuf, count );
|
|
|
|
//
|
|
// See if we can enumerate the cached servers and shares
|
|
//
|
|
if( hFind != INVALID_HANDLE_VALUE ) {
|
|
pCSCFindClose( hFind );
|
|
hFind = INVALID_HANDLE_VALUE;
|
|
}
|
|
hFind = (HANDLE)pCSCFindFirstFile( NULL,
|
|
&sFind32,
|
|
&dwStatus,
|
|
&dwPinCount,
|
|
&dwHintFlags,
|
|
&ftOrgTime
|
|
);
|
|
|
|
if( hFind == INVALID_HANDLE_VALUE ) {
|
|
NetApiBufferFree( outbuf );
|
|
apiStatus = ERROR_NOT_SUPPORTED;
|
|
goto try_exit;
|
|
}
|
|
|
|
do {
|
|
//
|
|
// For each entry, take a look to see if it's one that we want. If
|
|
// it is one, pack the results into the output buffer. If the output
|
|
// buffer is too small, grow the buffer and start over again.
|
|
//
|
|
|
|
//
|
|
// The name returned should be \\server\sharename
|
|
//
|
|
if( sFind32.cFileName[0] != L'\\' || sFind32.cFileName[1] != L'\\' ||
|
|
sFind32.cFileName[2] == L'\0' ) {
|
|
|
|
//
|
|
// We got a strange server name entry
|
|
//
|
|
continue;
|
|
}
|
|
|
|
server = &sFind32.cFileName[2];
|
|
|
|
for( share = server; *share && *share != '\\'; share++ );
|
|
|
|
if( share[0] != '\\' ) {
|
|
//
|
|
// No share component?
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// NULL terminate the servername
|
|
//
|
|
*share++ = L'\0';
|
|
|
|
if( lstrcmpiW( servername, server ) ) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// We've found an entry for this server!
|
|
//
|
|
|
|
for( sharelen = 0; share[sharelen]; sharelen++ ) {
|
|
if( share[ sharelen ] == L'\\' )
|
|
break;
|
|
}
|
|
|
|
if( sharelen == 0 ) {
|
|
//
|
|
// No share component?
|
|
//
|
|
continue;
|
|
}
|
|
|
|
sharelen *= sizeof( WCHAR ); // it's UNICODE
|
|
sharelen += sizeof( WCHAR ); // the NULL
|
|
|
|
if( level == 0 ) {
|
|
PSHARE_INFO_0 s0 = (PSHARE_INFO_0)outbuf + numFound;;
|
|
|
|
if( (PBYTE)(endp - sharelen) < (PBYTE)(s0 + sizeof( s0 )) ) {
|
|
goto retry;
|
|
}
|
|
|
|
endp -= sharelen;
|
|
RtlCopyMemory( endp, share, sharelen );
|
|
s0->shi0_netname = (LPWSTR)endp;
|
|
|
|
} else {
|
|
PSHARE_INFO_1 s1 = (PSHARE_INFO_1)outbuf + numFound;
|
|
|
|
if( (PBYTE)(endp - sharelen) < (PBYTE)(s1 + sizeof( s1 )) ) {
|
|
goto retry;
|
|
}
|
|
|
|
endp -= sharelen;
|
|
RtlCopyMemory( endp, share, sharelen );
|
|
|
|
s1->shi1_netname = (LPWSTR)endp;
|
|
s1->shi1_type = STYPE_DISKTREE;
|
|
s1->shi1_remark = (LPWSTR)(endp + sharelen - sizeof(WCHAR));
|
|
}
|
|
|
|
numFound++;
|
|
|
|
} while( pCSCFindNextFile(hFind, &sFind32, &dwStatus, &dwPinCount, &dwHintFlags, &ftOrgTime) );
|
|
|
|
pCSCFindClose(hFind);
|
|
|
|
apiStatus = NERR_Success;
|
|
|
|
if( numFound == 0 ) {
|
|
NetApiBufferFree( outbuf );
|
|
outbuf = NULL;
|
|
}
|
|
|
|
*bufptr = outbuf;
|
|
|
|
*entriesread = numFound;
|
|
|
|
*totalentries = numFound;
|
|
|
|
try_exit:;
|
|
|
|
} except( EXCEPTION_EXECUTE_HANDLER ) {
|
|
|
|
if( outbuf ) {
|
|
NetApiBufferFree( outbuf );
|
|
}
|
|
|
|
if( hFind != INVALID_HANDLE_VALUE ) {
|
|
pCSCFindClose( hFind );
|
|
}
|
|
|
|
apiStatus = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return apiStatus;
|
|
}
|
|
|
|
//
|
|
// Emulate NetShareGetInfo() for an offline server
|
|
//
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
CSCNetShareGetInfo (
|
|
IN LPTSTR servername,
|
|
IN LPTSTR netname,
|
|
IN DWORD level,
|
|
OUT LPBYTE *bufptr
|
|
)
|
|
{
|
|
HANDLE hFind = INVALID_HANDLE_VALUE;
|
|
WIN32_FIND_DATAW sFind32;
|
|
DWORD dwError, dwStatus, dwPinCount, dwHintFlags;
|
|
FILETIME ftOrgTime;
|
|
NET_API_STATUS apiStatus = ERROR_NOT_SUPPORTED;
|
|
LPWSTR server, share;
|
|
DWORD netNameSize;
|
|
|
|
if( (level != 0 && level != 1) ) {
|
|
return ERROR_NOT_SUPPORTED;
|
|
}
|
|
|
|
try {
|
|
|
|
hFind = (HANDLE)pCSCFindFirstFile( NULL,
|
|
&sFind32,
|
|
&dwStatus,
|
|
&dwPinCount,
|
|
&dwHintFlags,
|
|
&ftOrgTime
|
|
);
|
|
|
|
if( hFind == INVALID_HANDLE_VALUE ) {
|
|
goto try_exit;
|
|
}
|
|
|
|
//
|
|
// Loop through the entries until we find one we want
|
|
//
|
|
do {
|
|
|
|
server = &sFind32.cFileName[0];
|
|
|
|
for( share = server; *share && *share != '\\'; share++ );
|
|
|
|
if( share[0] != '\\' ) {
|
|
//
|
|
// No share component?
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// NULL terminate the servername
|
|
//
|
|
*share++ = L'\0';
|
|
|
|
if( lstrcmpiW( servername, server ) || lstrcmpiW( share, netname ) ) {
|
|
continue;
|
|
}
|
|
|
|
for( netNameSize = 0; netname[ netNameSize ]; netNameSize++ )
|
|
;
|
|
|
|
netNameSize += 1;
|
|
netNameSize *= sizeof( WCHAR );
|
|
|
|
//
|
|
// Got the match!
|
|
//
|
|
if( level == 0 ) {
|
|
PSHARE_INFO_0 s0;
|
|
|
|
apiStatus = NetApiBufferAllocate( sizeof(*s0) + netNameSize, &s0 );
|
|
if( apiStatus == NO_ERROR ) {
|
|
s0->shi0_netname = (LPTSTR)(s0 + 1);
|
|
RtlCopyMemory( s0->shi0_netname, netname, netNameSize );
|
|
*bufptr = (LPBYTE)s0;
|
|
apiStatus = NERR_Success;
|
|
}
|
|
|
|
} else {
|
|
PSHARE_INFO_1 s1;
|
|
|
|
apiStatus = NetApiBufferAllocate( sizeof(*s1) + netNameSize, &s1 );
|
|
if( apiStatus == NO_ERROR ) {
|
|
s1->shi1_netname = (LPTSTR)(s1 + 1);
|
|
RtlCopyMemory( s1->shi1_netname, netname, netNameSize );
|
|
s1->shi1_type = STYPE_DISKTREE;
|
|
s1->shi1_remark = s1->shi1_netname + netNameSize/sizeof(WCHAR) - sizeof(WCHAR);
|
|
*bufptr = (LPBYTE)s1;
|
|
apiStatus = NERR_Success;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
} while( pCSCFindNextFile(hFind,&sFind32,&dwStatus,&dwPinCount,&dwHintFlags, &ftOrgTime) );
|
|
|
|
pCSCFindClose( hFind );
|
|
|
|
try_exit:;
|
|
|
|
} except ( EXCEPTION_EXECUTE_HANDLER ) {
|
|
|
|
if( hFind != INVALID_HANDLE_VALUE ) {
|
|
pCSCFindClose( hFind );
|
|
}
|
|
|
|
apiStatus = ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
return apiStatus;
|
|
}
|