archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
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.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Tree: b4a8d373d8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b4a8d373d8'
${ noResults }
windows-nt-4.0/private/net/svcdlls/dfs/utest/netdfs.c

904 lines
22 KiB
Raw Blame History

//+----------------------------------------------------------------------------
//
// Copyright (C) 1992, Microsoft Corporation
//
// File: netdfs.c
//
// Contents: Code to test the NetDfsXXX APIs
//
// Classes:
//
// Functions:
//
// History: 10 Jan 95 Milans Created.
//
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <lm.h>
#include <lmdfs.h>
// BUGBUG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
NET_API_STATUS NET_API_FUNCTION
NetDfsGetPathInfo(
IN LPWSTR Path, // Win32 path
IN DWORD Level, // Level of information requested
OUT LPBYTE* Buffer // API allocates and returns buffer with requested info
)
{
return ERROR_INVALID_FUNCTION;
}
typedef ULONG (*API_TEST_FUNC)(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsAdd(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsRemove(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsSetInfo(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsGetInfo(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsGetPathInfo(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsEnum(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsMove(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
ULONG DfsRename(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle);
const struct {
LPWSTR wszApiName;
LPWSTR wszApiComment;
API_TEST_FUNC fnApiTest;
} rgApiInfo[] = {
{ L"NetDfsAdd", L"(flags: -e -v -r [-c] -f)", DfsAdd },
{ L"NetDfsRemove", L"(flags: -e -v -r)", DfsRemove },
{ L"NetDfsSetInfo", L"(flags: -e [-v] [-r] -l -s [1 = offline, 2 = online]) (levels 100, 101)", DfsSetInfo },
{ L"NetDfsGetInfo", L"(flags: -e [-v] [-r] -l) (levels 100, 101)", DfsGetInfo },
{ L"NetDfsGetPathInfo", L"(flags: -e -l) (levels 200, 201, 202)", DfsGetPathInfo },
{ L"NetDfsEnum", L"(flags: -d -l) (levels 1, 2, 3)", DfsEnum },
// Some aliases for convenience...
{ L"Add", L"", DfsAdd },
{ L"Remove", L"", DfsRemove },
{ L"SetInfo", L"", DfsSetInfo },
{ L"GetInfo", L"", DfsGetInfo},
{ L"GetPathInfo", L"", DfsGetPathInfo },
{ L"Enum", L"", DfsEnum}
};
VOID Usage();
BOOLEAN fQuiet = FALSE;
VOID
errmsg( char *text, ULONG code )
{
int i;
char msg[ 100 ];
i = FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM | sizeof( msg ),
NULL,
code,
0,
msg,
sizeof(msg),
NULL );
if( i )
fprintf( stderr, "%s: %s\n", text, msg );
else
fprintf( stderr, "%s: error 0x%X (%u)\n", text, code, code );
}
//+----------------------------------------------------------------------------
//
// Function: main
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//-----------------------------------------------------------------------------
ULONG __cdecl
main(
int argc,
char *argv[])
{
WCHAR wszApiName[32];
WCHAR wszDfsName[32];
WCHAR wszDfsEntryPath[MAX_PATH];
WCHAR wszNewEntryPath[MAX_PATH];
WCHAR wszServerName[80];
WCHAR wszShareName[NNLEN+1];
WCHAR wszComment[80];
DWORD Level;
DWORD Flag;
DWORD State;
DWORD PrefMaxLen;
DWORD ResumeHandle;
int i;
char *curtok;
BOOL fCmdError = FALSE;
//
// Initialize vars to defaults...
//
wszApiName[0] = UNICODE_NULL;
wszDfsName[0] = UNICODE_NULL;
wszDfsEntryPath[0] = UNICODE_NULL;
wszNewEntryPath[0] = UNICODE_NULL;
wszServerName[0] = UNICODE_NULL;
wszShareName[0] = UNICODE_NULL;
wszComment[0] = UNICODE_NULL;
Level = 1;
Flag = 0;
State = 0;
PrefMaxLen = (DWORD) ~0;
ResumeHandle = 0;
//
// Parse out the args...
//
for (i = 1; i < argc && !fCmdError; i++) {
curtok = argv[i];
if (curtok[0] == '-' || curtok[0] == '\\') {
#define NEXT_STRING_ARG(wszDest) \
i++; \
if (i < argc) { \
mbstowcs(wszDest, argv[i], strlen(argv[i]) + 1); \
} else { \
fCmdError = TRUE; \
}
#define NEXT_DWORD_ARG(k) \
i++; \
if (i < argc) { \
k = (DWORD) atoi(argv[i]); \
} else { \
fCmdError = TRUE; \
}
switch (curtok[1]) {
case 'a':
NEXT_STRING_ARG(wszApiName);
break;
case 'c':
NEXT_STRING_ARG(wszComment);
break;
case 'd':
NEXT_STRING_ARG(wszDfsName);
break;
case 'q':
fQuiet = 1 - fQuiet;
break;
case 'e':
NEXT_STRING_ARG(wszDfsEntryPath);
break;
case 'f':
NEXT_DWORD_ARG(Flag);
break;
case 'h':
NEXT_DWORD_ARG(ResumeHandle);
break;
case 'l':
NEXT_DWORD_ARG(Level);
break;
case 'n':
NEXT_STRING_ARG(wszNewEntryPath);
break;
case 'm':
NEXT_DWORD_ARG(PrefMaxLen);
break;
case 'r':
NEXT_STRING_ARG(wszShareName);
break;
case 's':
NEXT_DWORD_ARG(State);
break;
case 'v':
NEXT_STRING_ARG(wszServerName);
break;
default:
fCmdError = TRUE;
break;
}
} else {
fCmdError = TRUE;
}
}
if (wszApiName[0] == UNICODE_NULL) {
fCmdError = TRUE;
}
if (!fCmdError) {
fCmdError = TRUE; // ...because we haven't
// yet found a valid API name
for (i = 0;
i < sizeof(rgApiInfo) / sizeof(rgApiInfo[0]) && fCmdError;
i++) {
if (_wcsicmp( wszApiName, rgApiInfo[i].wszApiName ) == 0) {
return rgApiInfo[i].fnApiTest(
wszDfsName,
wszDfsEntryPath,
wszNewEntryPath,
wszServerName,
wszShareName,
wszComment,
Level,
Flag,
State,
PrefMaxLen,
ResumeHandle);
}
}
}
if (fCmdError) {
Usage();
}
return 1;
}
//+----------------------------------------------------------------------------
//
// Function: DfsAdd
//
// Synopsis: Test function for NetDfsAdd
//
// Arguments:
//
// Returns:
//
//-----------------------------------------------------------------------------
ULONG DfsAdd(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle)
{
NET_API_STATUS status;
if( fQuiet == FALSE ) {
printf("Calling NetDfsAdd...\n");
printf("\tDfsEntryPath: [%ws]\n"
"\tServerName: [%ws]\n"
"\tShareName: [%ws]\n"
"\tComment: [%ws]\n"
"\tFlag: %d\n",
wszDfsEntryPath, wszServerName, wszShareName, wszComment, Flag);
}
status = NetDfsAdd(
wszDfsEntryPath,
wszServerName,
wszShareName,
wszComment,
Flag);
if (status == NERR_Success) {
if( fQuiet == FALSE ) printf("NetDfsAdd succeeded!\n");
} else {
errmsg("NetDfsAdd", status);
}
return status;
}
//+----------------------------------------------------------------------------
//
// Function: DfsRemove
//
// Synopsis: Test function for NetDfsRemove
//
// Arguments:
//
// Returns:
//
//-----------------------------------------------------------------------------
ULONG DfsRemove(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle)
{
NET_API_STATUS status;
if( fQuiet == FALSE ) {
printf("Calling NetDfsRemove...\n");
printf("\tDfsEntryPath: [%ws]\n"
"\tServerName: [%ws]\n"
"\tShareName: [%ws]\n",
wszDfsEntryPath, wszServerName, wszShareName);
}
status = NetDfsRemove(
wszDfsEntryPath,
wszServerName,
wszShareName);
if (status == NERR_Success) {
if( fQuiet == FALSE )printf("NetDfsRemove succeeded!\n");
} else {
errmsg("NetDfsRemove", status);
}
return status;
}
//+----------------------------------------------------------------------------
//
// Function: DfsSetInfo
//
// Synopsis: Test function for NetDfsSetInfo
//
// Arguments:
//
// Returns:
//
//-----------------------------------------------------------------------------
ULONG DfsSetInfo(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle)
{
NET_API_STATUS status;
DFS_INFO_100 DfsInfo;
LPDFS_INFO_100 pDfsInfo0 = (LPDFS_INFO_100) &DfsInfo;
LPDFS_INFO_101 pDfsInfo1 = (LPDFS_INFO_101) &DfsInfo;
if( fQuiet == FALSE ) {
printf("Calling NetDfsSetInfo...\n");
printf("\tDfsEntryPath: [%ws]\n"
"\tServer: [%ws]\n"
"\tShare: [%ws]\n"
"\tLevel: %d\n",
wszDfsEntryPath, wszServerName, wszShareName, Level);
}
if (Level == 100) {
if( fQuiet == FALSE) printf("\tComment: [%ws]\n", wszComment);
pDfsInfo0->Comment = wszComment;
} else if (Level == 101) {
if( fQuiet == FALSE) printf("\tState: %d\n", State);
pDfsInfo1->State = State;
} else {
printf("\tUnrecognized Level, passing garbage for Buffer\n");
}
status = NetDfsSetInfo(
wszDfsEntryPath,
wszServerName,
wszShareName,
Level,
(LPBYTE) &DfsInfo);
if (status == NERR_Success) {
if( fQuiet == FALSE )printf("NetDfsSetInfo succeeded!\n");
} else {
errmsg("NetDfsSetInfo", status);
}
return status;
}
//+----------------------------------------------------------------------------
//
// Function: DfsGetInfo
//
// Synopsis: Test function for NetDfsGetInfo
//
// Arguments:
//
// Returns: Nothing
//
//-----------------------------------------------------------------------------
ULONG DfsGetInfo(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle)
{
NET_API_STATUS status;
LPBYTE Buffer;
DWORD i;
if( fQuiet == FALSE ) {
printf("Calling NetDfsGetInfo...\n");
printf("\tDfsEntryPath: [%ws]\n"
"\tServerName: [%ws]\n"
"\tShareName: [%ws]\n"
"\tLevel: %d\n\n",
wszDfsEntryPath, wszServerName, wszShareName, Level);
}
status = NetDfsGetInfo(
wszDfsEntryPath,
wszServerName,
wszShareName,
Level,
&Buffer);
if (status == NERR_Success) {
LPDFS_INFO_3 pDfsInfoX = (LPDFS_INFO_3) Buffer;
LPDFS_INFO_100 pDfsInfo100 = (LPDFS_INFO_100) Buffer;
LPDFS_INFO_101 pDfsInfo101 = (LPDFS_INFO_101) Buffer;
if( fQuiet == FALSE )printf("NetDfsGetInfo Succeeded!\n");
switch (Level) {
case 1:
case 2:
case 3:
printf("EntryPath: [%ws]\n", pDfsInfoX->EntryPath);
if (Level == 1)
break;
printf("Comment: [%ws]\n", pDfsInfoX->Comment);
printf("State: %d\n", pDfsInfoX->State);
printf("NumberOfStorages: %d\n", pDfsInfoX->NumberOfStorages);
if (Level == 2)
break;
for (i = 0; i < pDfsInfoX->NumberOfStorages; i++) {
printf(" %d. \\\\%ws\\%ws -- State %d\n",
i, pDfsInfoX->Storage[i].ServerName,
pDfsInfoX->Storage[i].ShareName,
pDfsInfoX->Storage[i].State);
}
break;
case 100:
printf("Comment: [%ws]\n", pDfsInfo100->Comment);
break;
case 101:
printf("State: %d\n", pDfsInfo101->State);
break;
default:
printf("Unrecognized Level %d\n", Level);
break;
}
NetApiBufferFree( Buffer );
} else {
errmsg("NetDfsGetInfo", status);
}
return status;
}
//+----------------------------------------------------------------------------
//
// Function: DfsGetPathInfo
//
// Synopsis: Test function for NetDfsGetPathInfo
//
// Arguments:
//
// Returns: Nothing
//
//-----------------------------------------------------------------------------
ULONG DfsGetPathInfo(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle)
{
NET_API_STATUS status;
LPBYTE Buffer;
DWORD i;
printf("BUGUBG: NetDfsGetPathInfo unimplemented\n");
return NO_ERROR;
printf("Calling NetDfsGetPathInfo...\n");
printf("\tDfsEntryPath: [%ws]\n"
"\tLevel: %d\n\n",
wszDfsEntryPath, Level);
status = NetDfsGetPathInfo(
wszDfsEntryPath,
Level,
&Buffer);
if (status == NERR_Success) {
LPDFS_INFO_200 pDfsInfo200 = (LPDFS_INFO_200) Buffer;
LPDFS_INFO_201 pDfsInfo201 = (LPDFS_INFO_201) Buffer;
LPDFS_INFO_202 pDfsInfo202 = (LPDFS_INFO_202) Buffer;
printf("NetDfsGetPathInfo Succeeded!\n");
do // for break
{
printf("PathType: [");
switch (pDfsInfo200->PathType)
{
case DFS_PATH_NONDFS: printf("non-Dfs"); break;
case DFS_PATH_REDIRECTED: printf("redirected"); break;
case DFS_PATH_LOCAL: printf("local"); break;
case DFS_PATH_UNC_IN_DFS: printf("UNC in Dfs"); break;
case DFS_PATH_UNIVERSAL: printf("Universal"); break;
default: printf("UNKNOWN"); break;
}
printf("]\n");
if (Level == 200)
break;
if (pDfsInfo201->PathType != DFS_PATH_NONDFS)
{
printf("DfsUniversalPath: [%ws]\n", pDfsInfo201->DfsUniversalPath);
}
if (Level == 201)
break;
if (pDfsInfo202->PathType != DFS_PATH_NONDFS)
{
printf("EntryPathLen: [%d]\n", pDfsInfo202->EntryPathLen);
}
} while (0);
NetApiBufferFree( Buffer );
} else {
errmsg("NetDfsGetPathInfo", status);
}
return status;
}
//+----------------------------------------------------------------------------
//
// Function: DfsEnum
//
// Synopsis: Test function for NetDfsEnum
//
// Arguments:
//
// Returns: Nothing
//
//-----------------------------------------------------------------------------
ULONG DfsEnum(
LPWSTR wszDfsName,
LPWSTR wszDfsEntryPath,
LPWSTR wszNewEntryPath,
LPWSTR wszServerName,
LPWSTR wszShareName,
LPWSTR wszComment,
DWORD Level,
DWORD Flag,
DWORD State,
DWORD PrefMaxLen,
DWORD ResumeHandle)
{
NET_API_STATUS status;
LPBYTE Buffer;
DWORD EntriesRead;
PDFS_INFO_3 pDfsInfo, pNextDfsInfo;
if( fQuiet == FALSE ) {
printf("Calling NetDfsEnum...\n");
printf("\tDfsName: [%ws]\n"
"\tLevel: %d\n"
"\t PrefMaxLen: %d\n"
"\tResumeHandle: %d\n\n",
wszDfsName, Level, PrefMaxLen, ResumeHandle);
}
status = NetDfsEnum(
wszDfsName,
Level,
PrefMaxLen,
&Buffer,
&EntriesRead,
&ResumeHandle);
if (status == NERR_Success) {
DWORD k, j;
LPDFS_STORAGE_INFO lpStorage;
if( fQuiet == FALSE )printf("NetDfsEnum succeeded!\n");
printf("\tEntries Read = %d\n", EntriesRead);
printf("\tResume Handle = %d\n", ResumeHandle);
printf("\tReturned Entries:\n");
pDfsInfo = (LPDFS_INFO_3) Buffer;
for (k = 0; k < EntriesRead; k++) {
switch (Level) {
case 1:
case 2:
case 3:
printf("\t % 3d. [%ws]\n", k, pDfsInfo->EntryPath);
if (Level == 1) {
pDfsInfo = (LPDFS_INFO_3)
((LPBYTE) pDfsInfo + sizeof(DFS_INFO_1));
break;
}
printf("\t [%ws]\n", pDfsInfo->Comment);
printf("\t State:%d Storages:%d\n",
pDfsInfo->State,
pDfsInfo->NumberOfStorages);
if (Level == 2) {
pDfsInfo = (LPDFS_INFO_3)
((LPBYTE) pDfsInfo + sizeof(DFS_INFO_2));
break;
}
lpStorage = pDfsInfo->Storage;
for (j = 0; j < pDfsInfo->NumberOfStorages; j++) {
printf("\t \\\\%ws\\%ws\n",
lpStorage[j].ServerName,
lpStorage[j].ShareName);
}
pDfsInfo = (LPDFS_INFO_3)
((LPBYTE) pDfsInfo + sizeof(DFS_INFO_3));
break;
default:
printf("Unrecognized Level %d\n", Level);
break;
} // end switch
} // end for
NetApiBufferFree( Buffer );
} else {
errmsg("NetDfsEnum", status);
}
return status;
}
//+----------------------------------------------------------------------------
//
// Function: Usage
//
// Synopsis: Prints out usage command line for this program.
//
// Arguments: None
//
// Returns: Nothing
//
//-----------------------------------------------------------------------------
VOID Usage()
{
ULONG i;
printf("Usage: netdfs -a <api name> [options]\n");
printf("Options:\n");
printf("\t-c Comment -- Comment to pass to API\n");
printf("\t-d DfsName -- Name of Dfs Root\n");
printf("\t-e EntryPath -- Name of Dfs Volume\n");
printf("\t-f Flag -- Flag to pass to NetDfsAdd, 1 = add volume, 2 = add dfs link\n");
printf("\t-h ResumeHandle -- ResumeHandle or State value to pass to API\n");
printf("\t-l Level -- Level of info requested\n");
printf("\t-m PrefMaxLen -- Preferred Maximum Length of return buffer\n");
printf("\t-n NewEntryPath -- NewEntryPath to pass to API\n");
printf("\t-r ShareName -- ShareName to pass to API\n");
printf("\t-s State -- State to pass to NetDfsSetInfo for Level 101\n");
printf("\t-v ServerName -- ServerName to pass to API\n");
printf("\t-q -- quiet mode\n" );
printf("\nValid API names:\n" );
for (i = 0; i < sizeof(rgApiInfo) / sizeof(rgApiInfo[0]) ; i++ ) {
printf( "\t%ws %ws\n", rgApiInfo[i].wszApiName, rgApiInfo[i].wszApiComment );
}
}