mirror of https://github.com/lianthony/NT4.0
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.
1184 lines
25 KiB
1184 lines
25 KiB
/********************************************************************/
|
|
/** Copyright(c) 1989 Microsoft Corporation. **/
|
|
/********************************************************************/
|
|
|
|
//***
|
|
//
|
|
// Filename:
|
|
//
|
|
// Description:
|
|
//
|
|
// History:
|
|
// May 11,1992. NarenG Created original version.
|
|
//
|
|
|
|
#include <client.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
AFP_SERVER_HANDLE hAfpServer;
|
|
|
|
VOID
|
|
DoConnect( VOID );
|
|
|
|
VOID
|
|
DoDisconnect(VOID );
|
|
|
|
VOID
|
|
DoVolumeEnum(VOID );
|
|
|
|
VOID
|
|
DoVolumeSetInfo(VOID );
|
|
|
|
VOID
|
|
DoVolumeGetInfo(VOID );
|
|
|
|
VOID
|
|
DoVolumeDelete(VOID );
|
|
|
|
VOID
|
|
DoVolumeAdd(VOID );
|
|
|
|
VOID
|
|
DoInvalidVolumeEnum(VOID );
|
|
|
|
VOID
|
|
DoInvalidVolumeDelete(VOID );
|
|
|
|
VOID
|
|
DoDirectoryGetInfo(VOID );
|
|
|
|
VOID
|
|
DoDirectorySetInfo(VOID );
|
|
|
|
VOID
|
|
DoServerGetInfo(VOID );
|
|
|
|
VOID
|
|
DoServerSetInfo(VOID );
|
|
|
|
VOID
|
|
DoSessionEnum(VOID );
|
|
|
|
VOID
|
|
DoSessionClose(VOID );
|
|
|
|
VOID
|
|
DoConnectionEnum(VOID );
|
|
|
|
VOID
|
|
DoConnectionClose(VOID );
|
|
|
|
VOID
|
|
DoFileEnum(VOID );
|
|
|
|
VOID
|
|
DoFileClose(VOID );
|
|
|
|
VOID
|
|
DoETCMapGetInfo( VOID );
|
|
|
|
VOID
|
|
DoETCMapAdd( VOID );
|
|
|
|
VOID
|
|
DoETCMapDelete( VOID );
|
|
|
|
VOID
|
|
DoETCMapSetInfo( VOID );
|
|
|
|
VOID
|
|
DoETCMapAssociate( VOID );
|
|
|
|
VOID
|
|
DoMessageSend( VOID );
|
|
|
|
VOID
|
|
DoStatisticsClear( VOID );
|
|
|
|
VOID
|
|
DoProfileClear( VOID );
|
|
|
|
typedef struct _ApiTable {
|
|
|
|
LPSTR lpwsApiName;
|
|
VOID (*DoApi)( VOID );
|
|
|
|
} API_TABLE, *PAPITABLE;
|
|
|
|
API_TABLE AdminApiTable[] = {
|
|
|
|
"AfpAdminConnect ",
|
|
DoConnect,
|
|
|
|
"AfpAdminDisconnect ",
|
|
DoDisconnect,
|
|
|
|
"AfpAdminVolumeEnum ",
|
|
DoVolumeEnum,
|
|
|
|
"AfpAdminVolumeSetInfo ",
|
|
DoVolumeSetInfo,
|
|
|
|
"AfpAdminVolumeGetInfo ",
|
|
DoVolumeGetInfo,
|
|
|
|
"AfpAdminVolumeDelete ",
|
|
DoVolumeDelete,
|
|
|
|
"AfpAdminVolumeAdd ",
|
|
DoVolumeAdd,
|
|
|
|
"AfpAdminInvalidVolumeEnum ",
|
|
DoInvalidVolumeEnum,
|
|
|
|
"AfpAdminInvalidVolumeDelete",
|
|
DoInvalidVolumeDelete,
|
|
|
|
"AfpAdminDirectoryGetInfo ",
|
|
DoDirectoryGetInfo,
|
|
|
|
"AfpAdminDirectorySetInfo ",
|
|
DoDirectorySetInfo,
|
|
|
|
"AfpAdminServerGetInfo ",
|
|
DoServerGetInfo,
|
|
|
|
"AfpAdminServerSetInfo ",
|
|
DoServerSetInfo,
|
|
|
|
"AfpAdminSessionEnum ",
|
|
DoSessionEnum,
|
|
|
|
"AfpAdminSessionClose ",
|
|
DoSessionClose,
|
|
|
|
"AfpAdminConnectionEnum ",
|
|
DoConnectionEnum,
|
|
|
|
"AfpAdminConnectionClose ",
|
|
DoConnectionClose,
|
|
|
|
"AfpAdminFileEnum ",
|
|
DoFileEnum,
|
|
|
|
"AfpAdminFileClose ",
|
|
DoFileClose,
|
|
|
|
"AfpAdminETCMapGetInfo ",
|
|
DoETCMapGetInfo,
|
|
|
|
"AfpAdminETCMapAdd ",
|
|
DoETCMapAdd,
|
|
|
|
"AfpAdminETCMapDelete ",
|
|
DoETCMapDelete,
|
|
|
|
"AfpAdminETCMapSetInfo ",
|
|
DoETCMapSetInfo,
|
|
|
|
"AfpAdminETCMapAssociate ",
|
|
DoETCMapAssociate,
|
|
|
|
"AfpAdminStatisticsClear ",
|
|
DoStatisticsClear,
|
|
|
|
"AfpAdminProfileClear ",
|
|
DoProfileClear,
|
|
|
|
"AfpAdminMessageSend ",
|
|
DoMessageSend,
|
|
|
|
NULL,
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
VOID
|
|
ReadLine( UCHAR Buf[] )
|
|
{
|
|
DWORD i = 0;
|
|
|
|
fflush(stdin);
|
|
while ( ( Buf[i++] = fgetchar() ) != '\n' );
|
|
Buf[--i] = '\0';
|
|
}
|
|
|
|
void
|
|
_cdecl
|
|
main( int argc, char*argv[] )
|
|
{
|
|
DWORD dwRetCode;
|
|
UCHAR chInputBuf[256];
|
|
DWORD dwIndex;
|
|
DWORD dwApiIndex;
|
|
WCHAR wchServerName[256];
|
|
|
|
|
|
printf( "\n\n\t********************************************* \n");
|
|
printf( "\t****** NTSFM Admin. API. test program. ****** \n");
|
|
printf( "\t********************************************* \n\n");
|
|
|
|
if ( argc == 2 )
|
|
mbstowcs( wchServerName, argv[1], sizeof( wchServerName ) );
|
|
else
|
|
wchServerName[0] = TEXT('\0');
|
|
|
|
dwRetCode = AfpAdminConnect( wchServerName, &hAfpServer );
|
|
|
|
if ( argc == 2 )
|
|
printf( "\tConnected with Server %s, Return Code = %d\n\n",
|
|
argv[1], dwRetCode);
|
|
else
|
|
printf( "\tConnected with local Server, Return Code = %d\n\n",
|
|
dwRetCode);
|
|
|
|
while( TRUE ) {
|
|
|
|
for ( dwIndex = 0;
|
|
AdminApiTable[dwIndex].lpwsApiName != NULL;
|
|
dwIndex++)
|
|
printf( " [%02d] %s%c", dwIndex+1,
|
|
AdminApiTable[dwIndex].lpwsApiName, (dwIndex % 2) == 0 ? '\t' : '\n');
|
|
|
|
printf("\n\t\t q to EXIT PROGRAM\n" );
|
|
|
|
do {
|
|
printf( "Api #>" );
|
|
|
|
ReadLine( chInputBuf );
|
|
|
|
if ( chInputBuf[0] == 'q' || chInputBuf[0] == 'Q' )
|
|
ExitProcess(0);
|
|
|
|
dwApiIndex = atoi( chInputBuf );
|
|
|
|
}while( dwApiIndex < 1 || dwApiIndex > dwIndex );
|
|
|
|
AdminApiTable[dwApiIndex-1].DoApi();
|
|
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoConnect( VOID )
|
|
{
|
|
CHAR chServerName[256];
|
|
WCHAR wchServerName[256];
|
|
DWORD dwRetCode;
|
|
|
|
printf("ServerName or ENTER for local>");
|
|
ReadLine( chServerName );
|
|
mbstowcs( wchServerName, chServerName, sizeof( wchServerName ) );
|
|
|
|
dwRetCode = AfpAdminConnect( wchServerName, &hAfpServer );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoDisconnect( VOID )
|
|
{
|
|
AfpAdminDisconnect( hAfpServer );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoVolumeAdd( VOID )
|
|
{
|
|
AFP_VOLUME_INFO AfpVolumeInfo;
|
|
DWORD dwRetCode;
|
|
WCHAR wchVolume[256];
|
|
WCHAR wchPassword[256];
|
|
WCHAR wchPath[256];
|
|
UCHAR chParm[256];
|
|
|
|
|
|
printf( "VolumeName>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchVolume, chParm, sizeof( wchVolume ) );
|
|
AfpVolumeInfo.afpvol_name = wchVolume;
|
|
|
|
printf( "VolumePassword>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchPassword, chParm, sizeof( wchPassword ) );
|
|
AfpVolumeInfo.afpvol_password = wchPassword;
|
|
|
|
printf( "MaxUses>" );
|
|
scanf( "%d", &(AfpVolumeInfo.afpvol_max_uses));
|
|
|
|
printf( "PropsMask>" );
|
|
scanf( "%d", &(AfpVolumeInfo.afpvol_props_mask));
|
|
|
|
printf( "VolumePath>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchPath, chParm, sizeof( wchPath ) );
|
|
AfpVolumeInfo.afpvol_path = wchPath;
|
|
|
|
dwRetCode = AfpAdminVolumeAdd( hAfpServer, (LPBYTE)&AfpVolumeInfo );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoVolumeEnum( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwPrefBufSize;
|
|
DWORD dwIndex;
|
|
PAFP_VOLUME_INFO pAfpVolumeInfo;
|
|
LPBYTE lpbBuffer;
|
|
DWORD dwEntriesRead;
|
|
DWORD dwTotalEntries;
|
|
DWORD dwResumeHandle;
|
|
|
|
printf( "Output buf size (-1 to get all info)>" );
|
|
scanf( "%d", &dwPrefBufSize );
|
|
|
|
if ( dwPrefBufSize != -1 ) {
|
|
printf( "\nResume Handle (should be 0 for first call>" );
|
|
scanf( "%d", &dwResumeHandle );
|
|
}
|
|
else
|
|
dwResumeHandle = 0;
|
|
|
|
dwRetCode = AfpAdminVolumeEnum( hAfpServer,
|
|
&lpbBuffer,
|
|
dwPrefBufSize,
|
|
&dwEntriesRead,
|
|
&dwTotalEntries,
|
|
&dwResumeHandle
|
|
);
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == ERROR_MORE_DATA || dwRetCode == ERROR_SUCCESS ) {
|
|
|
|
printf( "Number of entries read = %d\n", dwEntriesRead );
|
|
printf( "Total available # of entries = %d\n", dwTotalEntries );
|
|
printf( "Resume handle = %d\n", dwResumeHandle );
|
|
|
|
for ( dwIndex = 0,
|
|
pAfpVolumeInfo = (PAFP_VOLUME_INFO)lpbBuffer;
|
|
|
|
dwIndex < dwEntriesRead;
|
|
|
|
pAfpVolumeInfo++, dwIndex ++ ) {
|
|
|
|
printf( "afpvol_name = %ws\n", pAfpVolumeInfo->afpvol_name );
|
|
|
|
printf( "afpvol_max_uses = %d\n", pAfpVolumeInfo->afpvol_max_uses );
|
|
|
|
printf("afpvol_props_mask = %d\n",
|
|
pAfpVolumeInfo->afpvol_props_mask);
|
|
|
|
printf( "afpvol_path = %ws\n", pAfpVolumeInfo->afpvol_path );
|
|
|
|
printf( "afpvol_id = %d\n", pAfpVolumeInfo->afpvol_id );
|
|
printf( "afpvol_curr_uses= %d\n", pAfpVolumeInfo->afpvol_curr_uses);
|
|
|
|
}
|
|
|
|
AfpAdminBufferFree( lpbBuffer );
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DoVolumeSetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_VOLUME_INFO AfpVolumeInfo;
|
|
UCHAR chParm[256];
|
|
WCHAR wchPassword[256];
|
|
WCHAR wchName[256];
|
|
DWORD dwParmNum = 0;
|
|
|
|
printf( "Volume Name >" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchName, chParm, sizeof( wchName ) );
|
|
AfpVolumeInfo.afpvol_name = wchName;
|
|
|
|
printf( "Set Password ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_VOL_PARMNUM_PASSWORD;
|
|
printf( "\nVolume Password>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchPassword, chParm, sizeof( wchPassword ) );
|
|
AfpVolumeInfo.afpvol_password = wchPassword;
|
|
}
|
|
|
|
printf( "Set MaxUses ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_VOL_PARMNUM_MAXUSES;
|
|
printf( "\nMaxUses>" );
|
|
scanf( "%d", &(AfpVolumeInfo.afpvol_max_uses) );
|
|
}
|
|
|
|
printf( "Set PropsMask ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_VOL_PARMNUM_PROPSMASK;
|
|
printf( "\nVolume properties mask>" );
|
|
scanf( "%d", &(AfpVolumeInfo.afpvol_props_mask));
|
|
}
|
|
|
|
dwRetCode = AfpAdminVolumeSetInfo( hAfpServer,
|
|
(LPBYTE)&AfpVolumeInfo,
|
|
dwParmNum );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoVolumeGetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
PAFP_VOLUME_INFO pAfpVolumeInfo;
|
|
UCHAR chParm[256];
|
|
WCHAR wchName[256];
|
|
|
|
printf( "Volume Name >" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchName, chParm, sizeof( wchName ) );
|
|
|
|
|
|
dwRetCode = AfpAdminVolumeGetInfo( hAfpServer,
|
|
(LPWSTR)wchName,
|
|
(LPBYTE*)&pAfpVolumeInfo );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == NO_ERROR ) {
|
|
|
|
printf( "afpvol_name = %ws\n", pAfpVolumeInfo->afpvol_name );
|
|
|
|
printf( "afpvol_max_uses = %d\n", pAfpVolumeInfo->afpvol_max_uses );
|
|
|
|
printf("afpvol_props_mask = %d\n", pAfpVolumeInfo->afpvol_props_mask);
|
|
|
|
printf( "afpvol_path = %ws\n", pAfpVolumeInfo->afpvol_path );
|
|
|
|
printf( "afpvol_id = %d\n", pAfpVolumeInfo->afpvol_id );
|
|
|
|
printf( "afpvol_curr_uses= %d\n", pAfpVolumeInfo->afpvol_curr_uses);
|
|
|
|
AfpAdminBufferFree( pAfpVolumeInfo );
|
|
}
|
|
|
|
|
|
}
|
|
|
|
VOID
|
|
DoVolumeDelete( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
BYTE chParm[256];
|
|
WCHAR wchVolume[256];
|
|
|
|
printf( "VolumeName>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchVolume, chParm, sizeof( wchVolume ) );
|
|
|
|
dwRetCode = AfpAdminVolumeDelete( hAfpServer, wchVolume );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoInvalidVolumeEnum( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwIndex;
|
|
PAFP_VOLUME_INFO pAfpVolumeInfo;
|
|
LPBYTE lpbBuffer;
|
|
DWORD dwEntriesRead;
|
|
|
|
|
|
dwRetCode = AfpAdminInvalidVolumeEnum( hAfpServer,
|
|
&lpbBuffer,
|
|
&dwEntriesRead
|
|
);
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == ERROR_SUCCESS ) {
|
|
|
|
printf( "Number of entries read = %d\n", dwEntriesRead );
|
|
|
|
for ( dwIndex = 0,
|
|
pAfpVolumeInfo = (PAFP_VOLUME_INFO)lpbBuffer;
|
|
|
|
dwIndex < dwEntriesRead;
|
|
|
|
pAfpVolumeInfo++, dwIndex ++ ) {
|
|
|
|
printf( "afpvol_name = %ws\n", pAfpVolumeInfo->afpvol_name );
|
|
|
|
printf( "afpvol_path = %ws\n", pAfpVolumeInfo->afpvol_path );
|
|
|
|
}
|
|
|
|
AfpAdminBufferFree( lpbBuffer );
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DoInvalidVolumeDelete( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
BYTE chParm[256];
|
|
WCHAR wchVolume[256];
|
|
|
|
printf( "VolumeName>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchVolume, chParm, sizeof( wchVolume ) );
|
|
|
|
dwRetCode = AfpAdminInvalidVolumeDelete( hAfpServer, wchVolume );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoDirectoryGetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
PAFP_DIRECTORY_INFO pAfpDirectoryInfo;
|
|
CHAR chParm[256];
|
|
WCHAR wchPath[256];
|
|
|
|
printf( "Absolute path of directory>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchPath, chParm, sizeof( wchPath ) );
|
|
|
|
dwRetCode = AfpAdminDirectoryGetInfo( hAfpServer,
|
|
wchPath,
|
|
(LPBYTE*)&pAfpDirectoryInfo );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == NO_ERROR ) {
|
|
|
|
printf( "afpdir_perms = %d\n",
|
|
pAfpDirectoryInfo->afpdir_perms );
|
|
|
|
printf( "afpdir_owner = " );
|
|
printf( "%ws\n", pAfpDirectoryInfo->afpdir_owner );
|
|
|
|
printf( "afpdir_group = " );
|
|
printf( "%ws\n", pAfpDirectoryInfo->afpdir_group );
|
|
|
|
AfpAdminBufferFree( pAfpDirectoryInfo );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
DoDirectorySetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_DIRECTORY_INFO AfpDirInfo;
|
|
CHAR chParm[256];
|
|
WCHAR wchOwner[256];
|
|
WCHAR wchGroup[256];
|
|
WCHAR wchPath[256];
|
|
DWORD dwParmNum = 0;
|
|
|
|
printf( "Absolute path of directory>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchPath, chParm, sizeof( wchPath ) );
|
|
AfpDirInfo.afpdir_path = wchPath;
|
|
|
|
printf( "Set Owner ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_DIR_PARMNUM_OWNER;
|
|
printf( "\nDir Owner>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchOwner, chParm, sizeof( wchOwner ) );
|
|
AfpDirInfo.afpdir_owner = wchOwner;
|
|
}
|
|
|
|
printf( "Set Group ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_DIR_PARMNUM_GROUP;
|
|
printf( "\nDir Group>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchGroup, chParm, sizeof( wchGroup ) );
|
|
AfpDirInfo.afpdir_group = wchGroup;
|
|
}
|
|
|
|
printf( "Set perms ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_DIR_PARMNUM_PERMS;
|
|
printf( "\nDir perms>" );
|
|
scanf( "%d", &(AfpDirInfo.afpdir_perms));
|
|
|
|
}
|
|
|
|
dwRetCode = AfpAdminDirectorySetInfo( hAfpServer,
|
|
(LPBYTE)&AfpDirInfo,
|
|
dwParmNum );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoServerGetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
PAFP_SERVER_INFO pAfpServerInfo;
|
|
|
|
|
|
dwRetCode = AfpAdminServerGetInfo( hAfpServer,
|
|
(LPBYTE*)&pAfpServerInfo );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == NO_ERROR ) {
|
|
|
|
printf("afpsrv_name = %ws\n", pAfpServerInfo->afpsrv_name );
|
|
printf("afpsrv_max_sessions= %d\n",pAfpServerInfo->afpsrv_max_sessions);
|
|
printf("afpsrv_options = %d\n", pAfpServerInfo->afpsrv_options );
|
|
printf("afpsrv_login_msg = %ws\n", pAfpServerInfo->afpsrv_login_msg );
|
|
|
|
AfpAdminBufferFree( pAfpServerInfo );
|
|
}
|
|
}
|
|
|
|
VOID
|
|
DoServerSetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_SERVER_INFO AfpServerInfo;
|
|
CHAR chParm[256];
|
|
WCHAR wchLoginMsg[256];
|
|
DWORD dwParmNum = 0;
|
|
|
|
printf( "Set logon message ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_SERVER_PARMNUM_LOGINMSG;
|
|
printf( "\nLogin Message>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( wchLoginMsg, chParm, sizeof( wchLoginMsg ) );
|
|
AfpServerInfo.afpsrv_login_msg = wchLoginMsg;
|
|
}
|
|
|
|
printf( "Max Sessions? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_SERVER_PARMNUM_MAX_SESSIONS;
|
|
printf( "\n Max Sessions>" );
|
|
scanf( "%d", &(AfpServerInfo.afpsrv_max_sessions));
|
|
|
|
}
|
|
|
|
printf( "Set Server options ? (Y/N) >" );
|
|
ReadLine( chParm );
|
|
|
|
if ( chParm[0] == 'Y' || chParm[0] == 'y' ) {
|
|
|
|
dwParmNum |= AFP_SERVER_PARMNUM_OPTIONS;
|
|
printf( "\nServer Options>" );
|
|
scanf( "%d", &(AfpServerInfo.afpsrv_options));
|
|
|
|
}
|
|
|
|
dwRetCode = AfpAdminServerSetInfo( hAfpServer,
|
|
(LPBYTE)&AfpServerInfo,
|
|
dwParmNum );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoSessionEnum( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwPrefBufSize;
|
|
DWORD dwIndex;
|
|
PAFP_SESSION_INFO pAfpSessionInfo;
|
|
LPBYTE lpbBuffer;
|
|
DWORD dwEntriesRead;
|
|
DWORD dwTotalEntries;
|
|
DWORD dwResumeHandle;
|
|
|
|
printf( "Output buf size (-1 to get all info)>" );
|
|
scanf( "%d", &dwPrefBufSize );
|
|
|
|
if ( dwPrefBufSize != -1 ) {
|
|
printf( "\nResume Handle (should be 0 for first call>" );
|
|
scanf( "%d", &dwResumeHandle );
|
|
}
|
|
else
|
|
dwResumeHandle = 0;
|
|
|
|
dwRetCode = AfpAdminSessionEnum( hAfpServer,
|
|
&lpbBuffer,
|
|
dwPrefBufSize,
|
|
&dwEntriesRead,
|
|
&dwTotalEntries,
|
|
&dwResumeHandle
|
|
);
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == ERROR_MORE_DATA || dwRetCode == ERROR_SUCCESS ) {
|
|
|
|
printf( "Number of entries read = %d\n", dwEntriesRead );
|
|
printf( "Total available # of entries = %d\n", dwTotalEntries );
|
|
printf( "Resume handle = %d\n", dwResumeHandle );
|
|
|
|
for ( dwIndex = 0,
|
|
pAfpSessionInfo = (PAFP_SESSION_INFO)lpbBuffer;
|
|
|
|
dwIndex < dwEntriesRead;
|
|
|
|
pAfpSessionInfo++, dwIndex ++ ) {
|
|
|
|
printf( "afpsess_id = 0x%x\n", pAfpSessionInfo->afpsess_id );
|
|
|
|
printf( "afpsess_ws_name = %ws\n",
|
|
pAfpSessionInfo->afpsess_ws_name );
|
|
|
|
printf( "afpsess_username = %ws\n",
|
|
pAfpSessionInfo->afpsess_username );
|
|
|
|
printf("afpsess_num_cons = %d\n",
|
|
pAfpSessionInfo->afpsess_num_cons );
|
|
|
|
printf( "afpsess_num_opens = %d\n",
|
|
pAfpSessionInfo->afpsess_num_opens );
|
|
|
|
printf( "afpsess_time = %d\n",
|
|
pAfpSessionInfo->afpsess_time );
|
|
}
|
|
|
|
AfpAdminBufferFree( lpbBuffer );
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DoSessionClose( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwSessionId;
|
|
|
|
printf( "Type in ID. 0 far all>");
|
|
scanf( "%d", &dwSessionId );
|
|
|
|
dwRetCode = AfpAdminSessionClose( hAfpServer, dwSessionId );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoConnectionEnum( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwPrefBufSize;
|
|
DWORD dwIndex;
|
|
PAFP_CONNECTION_INFO pAfpConnInfo;
|
|
LPBYTE lpbBuffer;
|
|
DWORD dwEntriesRead;
|
|
DWORD dwTotalEntries;
|
|
DWORD dwResumeHandle;
|
|
DWORD dwFilter;
|
|
DWORD dwId;
|
|
|
|
printf( "Output buf size (-1 to get all info)>" );
|
|
scanf( "%d", &dwPrefBufSize );
|
|
|
|
if ( dwPrefBufSize != -1 ) {
|
|
printf( "\nResume Handle (should be 0 for first call>" );
|
|
scanf( "%d", &dwResumeHandle );
|
|
}
|
|
else
|
|
dwResumeHandle = 0;
|
|
|
|
printf( "Filter ?( 0 for no filter, filter on volume Id=1, session id=2>" );
|
|
scanf( "%d", &dwFilter );
|
|
|
|
if ( dwFilter ) {
|
|
printf( "Type in Filter ID>");
|
|
scanf( "%d", &dwId );
|
|
}
|
|
|
|
dwRetCode = AfpAdminConnectionEnum( hAfpServer,
|
|
&lpbBuffer,
|
|
dwFilter,
|
|
dwId,
|
|
dwPrefBufSize,
|
|
&dwEntriesRead,
|
|
&dwTotalEntries,
|
|
&dwResumeHandle
|
|
);
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == ERROR_MORE_DATA || dwRetCode == ERROR_SUCCESS ) {
|
|
|
|
printf( "Number of entries read = %d\n", dwEntriesRead );
|
|
printf( "Total available # of entries = %d\n", dwTotalEntries );
|
|
printf( "Resume handle = %d\n", dwResumeHandle );
|
|
|
|
for ( dwIndex = 0,
|
|
pAfpConnInfo = (PAFP_CONNECTION_INFO)lpbBuffer;
|
|
|
|
dwIndex < dwEntriesRead;
|
|
|
|
pAfpConnInfo++, dwIndex ++ ) {
|
|
|
|
printf( "afpconn_id = %d\n", pAfpConnInfo->afpconn_id);
|
|
|
|
printf( "afpconn_username = %ws\n",
|
|
pAfpConnInfo->afpconn_username);
|
|
|
|
printf( "afpconn_volumename = %ws\n",
|
|
pAfpConnInfo->afpconn_volumename);
|
|
|
|
printf( "afpconn_time= %d\n", pAfpConnInfo->afpconn_time);
|
|
printf( "afpconn_num_opens= %d\n", pAfpConnInfo->afpconn_num_opens);
|
|
|
|
|
|
}
|
|
|
|
AfpAdminBufferFree( lpbBuffer );
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DoConnectionClose( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwConnId;
|
|
|
|
printf( "Type in ID. 0 far all>");
|
|
scanf( "%d", &dwConnId );
|
|
|
|
dwRetCode = AfpAdminSessionClose( hAfpServer, dwConnId );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoFileEnum( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwPrefBufSize;
|
|
DWORD dwIndex;
|
|
PAFP_FILE_INFO pAfpFileInfo;
|
|
LPBYTE lpbBuffer;
|
|
DWORD dwEntriesRead;
|
|
DWORD dwTotalEntries;
|
|
DWORD dwResumeHandle;
|
|
|
|
printf( "Output buf size (-1 to get all info)>" );
|
|
scanf( "%d", &dwPrefBufSize );
|
|
|
|
if ( dwPrefBufSize != -1 ) {
|
|
printf( "\nResume Handle (should be 0 for first call>" );
|
|
scanf( "%d", &dwResumeHandle );
|
|
}
|
|
else
|
|
dwResumeHandle = 0;
|
|
|
|
dwRetCode = AfpAdminFileEnum( hAfpServer,
|
|
&lpbBuffer,
|
|
dwPrefBufSize,
|
|
&dwEntriesRead,
|
|
&dwTotalEntries,
|
|
&dwResumeHandle
|
|
);
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == ERROR_MORE_DATA || dwRetCode == ERROR_SUCCESS ) {
|
|
|
|
printf( "Number of entries read = %d\n", dwEntriesRead );
|
|
printf( "Total available # of entries = %d\n", dwTotalEntries );
|
|
printf( "Resume handle = %d\n", dwResumeHandle );
|
|
|
|
for ( dwIndex = 0,
|
|
pAfpFileInfo = (PAFP_FILE_INFO)lpbBuffer;
|
|
|
|
dwIndex < dwEntriesRead;
|
|
|
|
pAfpFileInfo++, dwIndex ++ ) {
|
|
|
|
printf( "afpfile_id = %d\n", pAfpFileInfo->afpfile_id);
|
|
|
|
printf( "afpfile_username = %ws\n", pAfpFileInfo->afpfile_username);
|
|
printf( "afpfile_open_mode= %d\n", pAfpFileInfo->afpfile_open_mode);
|
|
printf( "afpfile_num_locks= %d\n", pAfpFileInfo->afpfile_num_locks);
|
|
printf( "afpfile_path = %ws\n", pAfpFileInfo->afpfile_path);
|
|
|
|
}
|
|
|
|
AfpAdminBufferFree( lpbBuffer );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DoFileClose( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
DWORD dwFileId;
|
|
|
|
printf( "Type in ID. 0 far all>");
|
|
scanf( "%d", &dwFileId );
|
|
|
|
dwRetCode = AfpAdminFileClose( hAfpServer, dwFileId );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
VOID
|
|
DoExit( VOID )
|
|
{
|
|
ExitProcess(0);
|
|
}
|
|
|
|
VOID
|
|
DoETCMapGetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
LPBYTE pbBuffer;
|
|
PAFP_ETCMAP_INFO pETCMap;
|
|
DWORD dwIndex;
|
|
|
|
dwRetCode = AfpAdminETCMapGetInfo( hAfpServer, &pbBuffer );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
if ( dwRetCode == NO_ERROR ) {
|
|
|
|
pETCMap = (PAFP_ETCMAP_INFO)pbBuffer;
|
|
|
|
printf( "Number of type/creators = %d\n",
|
|
pETCMap->afpetc_num_type_creators );
|
|
|
|
for( dwIndex=0; dwIndex<pETCMap->afpetc_num_type_creators; dwIndex++ ){
|
|
|
|
printf( "TYPE = %ws\tCREATOR = %ws\tCOMMENT = %ws\tID = %d\n",
|
|
pETCMap->afpetc_type_creator[dwIndex].afptc_type,
|
|
pETCMap->afpetc_type_creator[dwIndex].afptc_creator,
|
|
pETCMap->afpetc_type_creator[dwIndex].afptc_comment,
|
|
pETCMap->afpetc_type_creator[dwIndex].afptc_id );
|
|
}
|
|
|
|
printf( "Number of extension = %d\n",
|
|
pETCMap->afpetc_num_extensions );
|
|
|
|
for( dwIndex=0; dwIndex<pETCMap->afpetc_num_extensions;dwIndex++ ){
|
|
|
|
printf( "EXTENSION = %ws\tTC_ID = %d\n",
|
|
pETCMap->afpetc_extension[dwIndex].afpe_extension,
|
|
pETCMap->afpetc_extension[dwIndex].afpe_tcid );
|
|
}
|
|
|
|
AfpAdminBufferFree( pETCMap );
|
|
}
|
|
}
|
|
|
|
VOID
|
|
DoETCMapAdd( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_TYPE_CREATOR AfpTypeCreator;
|
|
CHAR chParm[256];
|
|
|
|
printf( "Creator>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_creator,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_creator ) );
|
|
|
|
printf( "Type>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_type,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_type ) );
|
|
|
|
printf( "Comment>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_comment,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_comment ) );
|
|
|
|
dwRetCode = AfpAdminETCMapAdd( hAfpServer, &AfpTypeCreator );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
}
|
|
|
|
VOID
|
|
DoETCMapDelete( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_TYPE_CREATOR AfpTypeCreator;
|
|
CHAR chParm[256];
|
|
|
|
printf( "Creator>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_creator,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_creator ) );
|
|
|
|
printf( "Type>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_type,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_type ) );
|
|
|
|
dwRetCode = AfpAdminETCMapDelete( hAfpServer, &AfpTypeCreator );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
}
|
|
|
|
VOID
|
|
DoETCMapSetInfo( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_TYPE_CREATOR AfpTypeCreator;
|
|
CHAR chParm[256];
|
|
|
|
printf( "Creator>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_creator,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_creator ) );
|
|
|
|
printf( "Type>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_type,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_type ) );
|
|
|
|
printf( "Comment>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_comment,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_comment ) );
|
|
|
|
dwRetCode = AfpAdminETCMapSetInfo( hAfpServer, &AfpTypeCreator );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
}
|
|
|
|
VOID
|
|
DoETCMapAssociate( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
AFP_TYPE_CREATOR AfpTypeCreator;
|
|
AFP_EXTENSION AfpExtension;
|
|
CHAR chParm[256];
|
|
|
|
printf( "Creator>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_creator,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_creator ) );
|
|
|
|
printf( "Type>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpTypeCreator.afptc_type,
|
|
chParm,
|
|
sizeof( AfpTypeCreator.afptc_type ) );
|
|
|
|
printf( "Extension>" );
|
|
ReadLine( chParm );
|
|
mbstowcs( AfpExtension.afpe_extension,
|
|
chParm,
|
|
sizeof( AfpExtension.afpe_extension ) );
|
|
|
|
|
|
dwRetCode = AfpAdminETCMapAssociate( hAfpServer,
|
|
&AfpTypeCreator,
|
|
&AfpExtension );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
|
|
}
|
|
|
|
VOID
|
|
DoStatisticsClear( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
|
|
dwRetCode = AfpAdminStatisticsClear( hAfpServer );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoProfileClear( VOID )
|
|
{
|
|
DWORD dwRetCode;
|
|
|
|
dwRetCode = AfpAdminProfileClear( hAfpServer );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoMessageSend( VOID )
|
|
{
|
|
AFP_MESSAGE_INFO AfpMsgInfo;
|
|
DWORD dwRetCode;
|
|
DWORD dwSessionId;
|
|
CHAR chParm[200];
|
|
WCHAR wchMsg[200];
|
|
|
|
printf( "Type in the session Id to send the message to (0 for all)>" );
|
|
scanf( "%d", &dwSessionId );
|
|
|
|
AfpMsgInfo.afpmsg_session_id = dwSessionId;
|
|
|
|
printf( "Type in the message>");
|
|
ReadLine( chParm );
|
|
|
|
mbstowcs( wchMsg, chParm, sizeof( wchMsg ) );
|
|
|
|
AfpMsgInfo.afpmsg_text = wchMsg;
|
|
|
|
dwRetCode = AfpAdminMessageSend( hAfpServer,
|
|
&AfpMsgInfo );
|
|
|
|
printf( "\nAPI return code = %d\n", dwRetCode );
|
|
}
|