|
|
//============================================================================
// Copyright(c) 1998, Microsoft Corporation
//
// File: winscl.c
//
// Modification History:
//
// 1/14/1998 Ram Cherala (ramc)
// Added this header and made the following changes to make winscl a more
// intuitive and easy tool to use.
// Expanded abbreviations like vers. to the full form words.
// Made all string comparisions case insensitive.
// Made the input choices more obvious - very specifically state what the
// user should be entering as input to commands.
// Printed version IDs in hexadecimal like the WINS snap-in does.
//
// Implementation of winscl command line utility
//============================================================================
#include <stdio.h>
#include <time.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
//#include <windef.h>
#include <winsock.h>
#include "windows.h"
//#include "jet.h"
//#include "winsif.h"
#include "winsintf.h"
//
// This includes wins.h which includes windbg.h
//
// winsdbg.h defines STATIC to nothing now
//
#include "winsthd.h"
#define FILEU "winsu"
#define FILEO "winso"
STATICVOIDGetNameInfo( PWINSINTF_RECORD_ACTION_T pRecAction, WINSINTF_ACT_E Cmd_e );STATICVOIDGetFilterName( LPBYTE pStr, LPDWORD pLen );
STATICDWORDGetStatus( BOOL fPrint, LPVOID pResults, BOOL fNew, BOOL fShort );VOIDChkAdd( PWINSINTF_RECORD_ACTION_T pRow, FILE *pFile, DWORD Add, LPBOOL pfMatch );STATICVOIDWantFile( FILE **ppFile);
STATICDWORDGetDbRecs( WINSINTF_VERS_NO_T LowVersNo, WINSINTF_VERS_NO_T HighVersNo, PWINSINTF_ADD_T pWinsAdd, LPBYTE pTgtAdd, BOOL fSetFilter, LPBYTE pFilterName, DWORD Len, BOOL fAddFilter, DWORD AddFilter, FILE *pFile, BOOL fCountRec );
STATICDWORDGetDbRecsByName( PWINSINTF_ADD_T pWinsAdd, DWORD Location, LPBYTE pName, DWORD NameLen, DWORD NoOfRecsDesired, DWORD TypeOfRecs, BOOL fFilter, DWORD AddFilter ) ;
WINSINTF_VERS_NO_T sTmpVersNo;
STATICDWORDCreateFiles( PWINSINTF_RECS_T pRecs, PWINSINTF_ADD_T pWinsAdd, FILE *pFileU, FILE *pFileO );
STATICDWORDInitFromFile( VOID );
VOIDUsage( VOID );
typedef enum _CMD_E *PCMD_E;
VOIDGetCmdCode( LPBYTE pCmd, PCMD_E pCmd_e );
typedef enum _CMD_E { REG_NAME = 0, QUERY_NAME, DEL_NAME, GET_VERS_CTR_VAL, GET_MAPS, GET_MAPS_OLD, GET_STATS, GET_STATS_OLD, PUSH_TRIGGER, PULL_TRIGGER, STATIC_INIT, DO_CC, DO_SCV, DEL_RANGE_RECS, TOMBSTONE_RANGE_RECS, PULL_RANGE_RECS, GET_RECS_BY_NAME, GET_RECS_BY_VERS, BACKUP_DB, RESTORE_DB,// RESTORE_DB_OLD,
RESET_COUNTERS, COUNT_DB_RECS, GET_WINS_INFO, SEARCH_DB, GET_DOMAIN_NAMES, DEL_WINS, CONNECT_WINS, WINS_ADD, MENU, NOMENU, EXIT, LAST_PSS_ENTRY, GET_MAPS_VERBOSE, REL_NAME, MOD_NAME, SYNC_DB, CHANGE_THDS, SET_PRIORITY_CLASS, MEM_DUMP, BS, SS, TERM_WINS, LAST_ENTRY, INVALID_VALUE, CREATE_LMHOSTS, INIT_FROM_FILE } CMD_E, *PCMD_E;
static char ProgramName[MAX_PATH+1] ;
struct { LPSTR SwitchName; LPSTR ShortName; ULONG SwitchValue; LPSTR SwitchInformation;
} CommandSwitchList[] = { { "REGNAME", "RN", REG_NAME, "Register a name" }, { "QUERYNAME", "QN", QUERY_NAME, "Query a name" }, { "DELNAME", "DN", DEL_NAME, "Delete a name" }, { "GETVERSCTRVAL", "GV", GET_VERS_CTR_VAL, "Get the current version counter value" }, { "GETMAPS", "GM", GET_MAPS, "Get the Owner Id to Maximum Version Number mappings" }, { "GETMAPSWINS3.5", "GMO", GET_MAPS_OLD, "Get the Owner Id to Maximum Version Number mappings (for 3.5 WINS server)" }, { "GETSTATS", "GST", GET_STATS, "Get WINS statistics" }, { "GETSTATSWINS3.5", "GSTO", GET_STATS_OLD, "Get WINS statistics (for 3.5 WINS server)" }, { "PUSHTRIGGER", "PUSHT", PUSH_TRIGGER, "Send a push trigger to another WINS" }, { "PULLTRIGGER", "PULLT", PULL_TRIGGER, "Send a pull trigger to another WINS" }, { "STATICINIT", "SI", STATIC_INIT, "Statically initialize the WINS" }, { "CONSISTENCY_CHECK", "CC", DO_CC, "Initiate consistency check on the WINS - HIGH OVERHEAD OPERATION" }, { "SCAVENGING", "SC", DO_SCV, "Initiate scavenging on the WINS" }, { "DELRANGEOFRECS", "DRR", DEL_RANGE_RECS, "Delete all or a range of records" }, { "TOMBSTONERANGEOFRECS", "TRR", TOMBSTONE_RANGE_RECS, "Tombstone all or a range of records(max 50 at a time)" }, { "PULLRANGERECS", "PRR", PULL_RANGE_RECS, "Pull all or a range of records from another WINS" }, { "GETRECSBYNAME", "GRBN", GET_RECS_BY_NAME, "Get records by name" }, { "GETRECSBYVERS", "GRBV", GET_RECS_BY_VERS, "Get Records by version numbers" }, { "BACKUP", "BK", BACKUP_DB, "Backup the database" }, { "RESTORE", "RS", RESTORE_DB, "Restore the database" },// { "RESTORE_OLD", "RSO", RESTORE_DB_OLD,
// "Restore the db (created by a pre-SUR WINS" },
{ "RESETCOUNTERS", "RC", RESET_COUNTERS, "Reset WINS counters" }, { "COUNTRECS", "CR", COUNT_DB_RECS, "Count the number of records in the database" }, { "GETWINSINFO", "GI", GET_WINS_INFO, "Get Inforomation about WINS" }, { "SEARCHDB", "SDB", SEARCH_DB, "Search the database" }, { "GETDOMAINNAMES", "GD", GET_DOMAIN_NAMES, "Get domain names" }, { "DELWINS", "DW", DEL_WINS, "Delete WINS records and info." }, { "CONWINS", "CW", CONNECT_WINS, "Connect Wins" }, { "WINSADD", "WA", WINS_ADD, "Get Address of current Wins" }, { "MENU", "ME", MENU, "SHOW MENU" }, { "NOMENU", "NOME", NOMENU, "DO NOT SHOW MENU" },//
// NOTE: Any Option below and including "BREAK" will not be displayed
// with _PSS_RELEASE Defined
//
{ "EXIT", "EX", EXIT, "Terminate winscl" }, { NULL, NULL, LAST_PSS_ENTRY, "PSS End Marker" }, { "GETMAPS_VERB", "GM_V", GET_MAPS_VERBOSE, "Get the Owner Id to Max. Vers. No. mappings" }, { "RELEASENAME", "RLN", REL_NAME, "Release a name" }, { "MODIFYNAME", "MN", MOD_NAME, "Modify Name" }, { "SYNCDB", "SDB", SYNC_DB, "Sync. up the db of WINS" }, { "CHANGETHDS", "CT", CHANGE_THDS, "Change the no. of worker threads (query threads)" }, { "SETPRIORITYCLASS", "SPC", SET_PRIORITY_CLASS, "Set the priority class of WINS" }, { "MEMDUMP", "MD", MEM_DUMP, "DUMP MEMORY TO FILE ON WINS MACHINE" }, { "BS", "BS", BS, "MAY DISRUPT OPERATION OF WINS" }, { "SS", "SS", SS, "NOOP" }, { "TERMWINS", "TW", TERM_WINS, "TERMINATE WINS" },
{ NULL, NULL, LAST_ENTRY, "End Marker" } };
#define WINSCLENH TEXT("winsclenh")
BOOL fEnhMode = FALSE;handle_t BindHdl;/////////////
#include <sys\types.h>
#include <sys\stat.h>
FILE *spDbgFile;FILE *spDbgFile2;FILE *spServers;typedef struct { DWORD NoOfOwners; struct { DWORD OwnId; DWORD IpAdd; CHAR asIpAdd[20]; WINSINTF_VERS_NO_T VersNo; BOOL fNameNotFound; BOOL fCommFail; } Maps[30]; } WINS_INFO, *PWINS_INFO;
typedef struct { char Name[18]; BOOL fProb; } NAME_INFO, *PNAME_INFO;
STATUSGetWinsInfo( PWINS_INFO pWinsInfo );
VOIDsync( VOID );
VOIDGetFullName( LPBYTE pName, DWORD SChar, PWINSINTF_RECORD_ACTION_T pRecAction );BOOLReadNameFile( PNAME_INFO *ppFileInfo, LPDWORD pNoOfNames, LPBYTE pNameOfFile);
BOOLBindToWins( LPBYTE asIpAdd, PWINSINTF_BIND_DATA_T pBindData, handle_t *pBindHdl );
#define SUCCESS 0
#define NAME_NOT_FOUND 1
#define FAILURE 2
DWORDQueryWins ( LPBYTE pName, PWINSINTF_RECORD_ACTION_T pRecAction, PWINSINTF_RECORD_ACTION_T *ppRecAction );
VOIDStoreName( PWINSINTF_RECORD_ACTION_T pRecAction, LPBYTE pName );
/////////////////
_cdeclmain(int argc, char **argv){
DWORD Status; WINSINTF_RECORD_ACTION_T RecAction; DWORD Choice; BYTE String[80]; SYSTEMTIME SystemTime; BYTE tgtadd[50]; TCHAR NmsAdd[50]; WINSINTF_ADD_T WinsAdd; WINSINTF_ADD_T OwnAdd; //address of WINS owning records in the db
WINSINTF_RESULTS_T Results; WINSINTF_RESULTS_NEW_T ResultsN; BOOL fExit = FALSE; DWORD i; WINSINTF_RECTYPE_E TypOfRec_e; WINSINTF_STATE_E State_e; DWORD Dynamic; struct in_addr InAddr; WINSINTF_VERS_NO_T MinVersNo, MaxVersNo; DWORD TotalCnt = 0; BOOL fCountRec = FALSE; WINSINTF_BIND_DATA_T BindData; BOOL fIncremental; PWINSINTF_RECORD_ACTION_T pRecAction; FILE *pFileU = NULL; FILE *pFileO = NULL; WINSINTF_RECS_T Recs; BOOL fFileInited = FALSE; LPBYTE *ppStr = argv; DWORD NoOfChars; CMD_E Cmd_e = GET_MAPS; BOOL fInteractive = TRUE; DWORD Access;
try{
NoOfChars = GetEnvironmentVariable(WINSCLENH, (LPTSTR)String, sizeof(String)/sizeof(TCHAR)); //wprintf(L"Environmental string is %s\n", String);
if ((NoOfChars == 1) && !lstrcmpi((LPTSTR)String, TEXT("1"))) { fEnhMode = TRUE; }
sTmpVersNo.LowPart = 1; sTmpVersNo.HighPart = 0;
LABEL: if ((argc >= 2) && (!_strcmpi(*(ppStr + 1), "-?"))) { Usage(); return(1); }
if (argc == 1) { printf("TCP/IP or named pipe. Enter 1 for TCP/IP or 0 for named pipe -- "); scanf("%d", &Choice); } else { if (!_strcmpi (*(ppStr + 1), "T")) { Choice = 1; } else { if (!_strcmpi (*(ppStr + 1), "N")) { Choice = 2; } else { BOOL fUsage = FALSE; TCHAR UserName[100]; DWORD UserNameSize = sizeof(UserName)/sizeof(TCHAR); if (!GetUserName(UserName, &UserNameSize)) { fUsage = TRUE; } else { if (!lstrcmpi(UserName, TEXT("pradeepb"))) {
if (!_strcmpi (*(ppStr + 1), "SYNC") || !_strcmpi(*(ppStr + 1), "SYNCB")) { if (!_strcmpi(*(ppStr + 1), "SYNCB")) { if ((spDbgFile = fopen("nmfl.dbg", "w")) == NULL) { return 1; } if ((spDbgFile2 = fopen("nmfls.dbg", "w")) == NULL) { return 1; } } else { spDbgFile = stdout; spDbgFile2 = stdout; } sync(); return 1; } else { fUsage = TRUE; } } else { fUsage = TRUE; } } if (fUsage) { Usage(); return(1); } } } } if (Choice == 1) { printf("Address of Nameserver to contact-- "); //scanf("%s", NmsAdd);
wscanf(L"%s", NmsAdd); BindData.fTcpIp = TRUE; } else { printf("UNC name of machine-- "); wscanf(L"%s", NmsAdd); BindData.fTcpIp = FALSE; BindData.pPipeName = (LPBYTE)TEXT("\\pipe\\WinsPipe"); } BindData.pServerAdd = (LPBYTE)NmsAdd;
BindHdl = WinsBind(&BindData); if (BindHdl == NULL) { printf("Unable to bind to %s\n", NmsAdd); //wprintf(L"Unable to bind to %s\n", NmsAdd);
goto LABEL; } //find out what type of access do we have
Access = WINS_NO_ACCESS; Status = WinsCheckAccess(BindHdl, &Access); if (WINSINTF_SUCCESS == Status) { printf("*** You have %s access to this server ***\n", (Access ? (Access == WINS_CONTROL_ACCESS ? "Read and Write":"Read Only") : "No"));
}
while(!fExit) { BYTE Cmd[40]; if ((argc == 3) && (Cmd_e != INVALID_VALUE)) { GetCmdCode(*(ppStr + 2), &Cmd_e); argc = 0; fInteractive = FALSE; } else { DWORD LastEntry; if (fInteractive) { LastEntry = (fEnhMode ? LAST_ENTRY : LAST_PSS_ENTRY); for (Cmd_e = 0; Cmd_e < (CMD_E)LastEntry; Cmd_e++) { if (CommandSwitchList[Cmd_e].ShortName != NULL) { printf("%s-%s\n", CommandSwitchList[Cmd_e].ShortName, CommandSwitchList[Cmd_e].SwitchInformation); } } } printf("Command -- "); scanf("%s", Cmd); GetCmdCode(Cmd, &Cmd_e); } if (Cmd_e == COUNT_DB_RECS) { Cmd_e = GET_RECS_BY_VERS; fCountRec = TRUE; }
switch(Cmd_e) { case(REG_NAME):
GetNameInfo(&RecAction, WINSINTF_E_INSERT); RecAction.Cmd_e = WINSINTF_E_INSERT; pRecAction = &RecAction; Status = WinsRecordAction(BindHdl,&pRecAction); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (RecAction.pName != NULL) { WinsFreeMem(RecAction.pName); } if (RecAction.pAdd != NULL) { WinsFreeMem(RecAction.pAdd); } WinsFreeMem(pRecAction); break; case(QUERY_NAME): GetNameInfo(&RecAction, WINSINTF_E_QUERY); RecAction.Cmd_e = WINSINTF_E_QUERY; pRecAction = &RecAction; Status = WinsRecordAction(BindHdl, &pRecAction); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { printf("Name=(%s)\nNodeType=(%d)\nState=(%s)\nTimeStamp=(%.19s)\nOwnerId=(%d)\nType Of Rec=(%s)\nVersion No (%x %x)\nRecord is (%s)\n", pRecAction->pName, pRecAction->NodeTyp, pRecAction->State_e == WINSINTF_E_ACTIVE ? "ACTIVE" : (pRecAction->State_e == WINSINTF_E_RELEASED) ? "RELEASED" : "TOMBSTONE", asctime(localtime(&(pRecAction->TimeStamp))), pRecAction->OwnerId, (pRecAction->TypOfRec_e == WINSINTF_E_UNIQUE) ? "UNIQUE" : (pRecAction->TypOfRec_e == WINSINTF_E_NORM_GROUP) ? "NORMAL GROUP" :(pRecAction->TypOfRec_e == WINSINTF_E_SPEC_GROUP) ? "SPECIAL GROUP" : "MULTIHOMED",
pRecAction->VersNo.HighPart, pRecAction->VersNo.LowPart, pRecAction->fStatic ? "STATIC" : "DYNAMIC" ); if ( (pRecAction->TypOfRec_e == WINSINTF_E_UNIQUE) || (pRecAction->TypOfRec_e == WINSINTF_E_NORM_GROUP) ) {
InAddr.s_addr = htonl(pRecAction->Add.IPAdd); printf("Address is (%s)\n", inet_ntoa(InAddr)); } else { for (i=0; i<pRecAction->NoOfAdds; ) { InAddr.s_addr = htonl((pRecAction->pAdd +i++)->IPAdd); printf("Owner is (%s); ", inet_ntoa(InAddr)); InAddr.s_addr = htonl((pRecAction->pAdd + i++)->IPAdd); printf("Member is (%s)\n", inet_ntoa(InAddr)); } }
} else { if (Status == WINSINTF_FAILURE) { printf("No such name in the database\n"); } } if (RecAction.pName != NULL) { LocalFree(RecAction.pName); } if (RecAction.pAdd != NULL) { LocalFree(RecAction.pAdd); } WinsFreeMem(pRecAction); break;
case(REL_NAME): GetNameInfo(&RecAction, WINSINTF_E_RELEASE); RecAction.Cmd_e = WINSINTF_E_RELEASE; pRecAction = &RecAction; Status = WinsRecordAction(BindHdl, &pRecAction); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (RecAction.pName != NULL) { LocalFree(RecAction.pName); } if (RecAction.pAdd != NULL) { LocalFree(RecAction.pAdd); } WinsFreeMem(pRecAction); break;
//
// Modify a record (timestamp, flag byte)
//
case(MOD_NAME): GetNameInfo(&RecAction, WINSINTF_E_MODIFY); RecAction.Cmd_e = WINSINTF_E_MODIFY;
#if 0
//
// Get the input values
//
time((time_t *)&RecAction.TimeStamp);#endif
printf("Unique/Normal Group record to a Special/Multihomed record or vice-versa DISALLOWED\n"); printf("Type(1-Norm. Grp;2-Spec. Grp.;3-Multihomed; Any other-Unique -> "); scanf("%d", &TypOfRec_e);
if (TypOfRec_e > 3 || TypOfRec_e < 1) { TypOfRec_e = 0; } RecAction.TypOfRec_e = TypOfRec_e;
if ((TypOfRec_e != 1) && (TypOfRec_e != 2)) { printf("Node Type -- P-node (0), H-node (1), B-node (2),default - P node -- "); scanf("%d", &Choice); switch(Choice) { default: case(0): RecAction.NodeTyp = WINSINTF_E_PNODE; break; case(1): RecAction.NodeTyp = WINSINTF_E_HNODE; break; case(2): RecAction.NodeTyp = WINSINTF_E_BNODE; break; } } else { RecAction.NodeTyp = 0; } printf("State-(1-RELEASED;2-TOMBSTONE;3-DELETE;Any other-ACTIVE -> "); scanf("%d", &State_e);
if (State_e != 1 && State_e != 2 && State_e != 3) { State_e = 0; }
RecAction.State_e = State_e;
printf("Do you want it to be dynamic? 1 - yes. "); scanf("%d", &Dynamic); if (Dynamic == 1) { RecAction.fStatic = 0; } else { RecAction.fStatic = 1; }
pRecAction = &RecAction; Status = WinsRecordAction(BindHdl, &pRecAction); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (RecAction.pName != NULL) { LocalFree(RecAction.pName); } if (RecAction.pAdd != NULL) { LocalFree(RecAction.pAdd); } WinsFreeMem(pRecAction); break;
//
// Delete a record
//
case(DEL_NAME): GetNameInfo(&RecAction, WINSINTF_E_DELETE); RecAction.Cmd_e = WINSINTF_E_DELETE; RecAction.State_e = WINSINTF_E_DELETED; pRecAction = &RecAction; Status = WinsRecordAction(BindHdl, &pRecAction); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (RecAction.pName != NULL) { LocalFree(RecAction.pName); } if (RecAction.pAdd != NULL) { LocalFree(RecAction.pAdd); } WinsFreeMem(pRecAction); break;
//
// Get Status
//
case(GET_VERS_CTR_VAL):
{ BYTE NmAdd[30]; Results.AddVersMaps[0].Add.Len = 4; Results.AddVersMaps[0].Add.Type = 0; printf("Address of Nameserver (for max. version no)--"); scanf("%s", NmAdd); Results.AddVersMaps[0].Add.IPAdd = ntohl(inet_addr(NmAdd));
Results.WinsStat.NoOfPnrs = 0; Results.WinsStat.pRplPnrs = NULL; Status = WinsStatus(BindHdl, WINSINTF_E_ADDVERSMAP, &Results); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { printf("IP Address - (%s) - Max. Vers. No - (%x %x)\n", NmAdd, Results.AddVersMaps[0].VersNo.HighPart, Results.AddVersMaps[0].VersNo.LowPart ); }
} break; case(GET_MAPS_OLD): Results.WinsStat.NoOfPnrs = 0; Results.WinsStat.pRplPnrs = 0; (VOID)GetStatus(TRUE, &Results, FALSE, FALSE); break; //
// Get Statistics
//
case(GET_STATS_OLD):#define TMST Results.WinsStat.TimeStamps
#define TIME_ARGS(x) \
TMST.x.wMonth, TMST.x.wDay, TMST.x.wYear, TMST.x.wHour, TMST.x.wMinute, TMST.x.wSecond
Results.WinsStat.NoOfPnrs = 0; Results.WinsStat.pRplPnrs = 0;
Status = WinsStatus(BindHdl, WINSINTF_E_STAT, &Results); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { printf("TIMESTAMPS\n");
printf("WINS STARTED ON %d/%d/%d at %d hrs %d mts %d secs\n",
TMST.WinsStartTime.wMonth, TMST.WinsStartTime.wDay, TMST.WinsStartTime.wYear, TMST.WinsStartTime.wHour, TMST.WinsStartTime.wMinute, TMST.WinsStartTime.wSecond );
printf("LAST INIT OF DB on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGS(LastInitDbTime) ); printf("LAST PLANNED SCV on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGS(LastPScvTime) );
printf("LAST ADMIN TRIGGERED SCV on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGS(LastATScvTime) );
printf("LAST REPLICAS TOMBSTONES SCV on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGS(LastTombScvTime) );
printf("LAST OLD REPLICAS VERIFICATION (SCV) on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGS(LastVerifyScvTime) );
printf("LAST PLANNED REPLICATION on %d/%d/%d at %d hrs %d mts %d secs\n", TMST.LastPRplTime.wMonth, TMST.LastPRplTime.wDay, TMST.LastPRplTime.wYear, TMST.LastPRplTime.wHour, TMST.LastPRplTime.wMinute, TMST.LastPRplTime.wSecond );
printf("LAST ADMIN TRIGGERED REPLICATION on %d/%d/%d at %d hrs %d mts %d secs\n", TMST.LastATRplTime.wMonth, TMST.LastATRplTime.wDay, TMST.LastATRplTime.wYear, TMST.LastATRplTime.wHour, TMST.LastATRplTime.wMinute, TMST.LastATRplTime.wSecond );
printf("LAST RESET OF COUNTERS on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGS(CounterResetTime) );
printf("COUNTERS\n"); printf("\n# of U and G Registration requests = (%d %d)\n# Of Successful/Failed Queries = (%d/%d)\n# Of U and G Refreshes = (%d %d)\n# Of Successful/Failed Releases = (%d/%d)\n# Of U. and G. Conflicts = (%d %d)\n", Results.WinsStat.Counters.NoOfUniqueReg, Results.WinsStat.Counters.NoOfGroupReg, Results.WinsStat.Counters.NoOfSuccQueries, Results.WinsStat.Counters.NoOfFailQueries, Results.WinsStat.Counters.NoOfUniqueRef, Results.WinsStat.Counters.NoOfGroupRef, Results.WinsStat.Counters.NoOfSuccRel, Results.WinsStat.Counters.NoOfFailRel, Results.WinsStat.Counters.NoOfUniqueCnf, Results.WinsStat.Counters.NoOfGroupCnf ); }
if (Results.WinsStat.NoOfPnrs) { printf("WINS partner --\t# of Succ. Repl--\t # of Comm Fails\n"); for (i =0; i < Results.WinsStat.NoOfPnrs; i++) { InAddr.s_addr = htonl( (Results.WinsStat.pRplPnrs + i)->Add.IPAdd); printf("%s\t\t%d\t\t%d\n", inet_ntoa(InAddr), (Results.WinsStat.pRplPnrs + i)->NoOfRpls, (Results.WinsStat.pRplPnrs + i)->NoOfCommFails ); }
WinsFreeMem(Results.WinsStat.pRplPnrs);
} break;
case(GET_STATS):
#define TMSTN ResultsN.WinsStat.TimeStamps
#define TIME_ARGSN(x) \
TMSTN.x.wMonth, TMSTN.x.wDay, TMSTN.x.wYear, TMSTN.x.wHour, TMSTN.x.wMinute, TMSTN.x.wSecond
ResultsN.WinsStat.NoOfPnrs = 0; ResultsN.WinsStat.pRplPnrs = NULL; ResultsN.pAddVersMaps = NULL; Status = WinsStatusNew(BindHdl, WINSINTF_E_STAT, &ResultsN); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { printf("TIMESTAMPS\n"); printf("WINS STARTED ON %d/%d/%d at %d hrs %d mts %d secs\n",
TMSTN.WinsStartTime.wMonth, TMSTN.WinsStartTime.wDay, TMSTN.WinsStartTime.wYear, TMSTN.WinsStartTime.wHour, TMSTN.WinsStartTime.wMinute, TMSTN.WinsStartTime.wSecond );
printf("LAST INIT OF DB on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGSN(LastInitDbTime) ); printf("LAST PLANNED SCV on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGSN(LastPScvTime) );
printf("LAST ADMIN TRIGGERED SCV on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGSN(LastATScvTime) );
printf("LAST REPLICAS TOMBSTONES SCV on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGSN(LastTombScvTime) );
printf("LAST OLD REPLICAS VERIFICATION (SCV) on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGSN(LastVerifyScvTime) );
printf("LAST PLANNED REPLICATION on %d/%d/%d at %d hrs %d mts %d secs\n", TMSTN.LastPRplTime.wMonth, TMSTN.LastPRplTime.wDay, TMSTN.LastPRplTime.wYear, TMSTN.LastPRplTime.wHour, TMSTN.LastPRplTime.wMinute, TMSTN.LastPRplTime.wSecond );
printf("LAST ADMIN TRIGGERED REPLICATION on %d/%d/%d at %d hrs %d mts %d secs\n", TMSTN.LastATRplTime.wMonth, TMSTN.LastATRplTime.wDay, TMSTN.LastATRplTime.wYear, TMSTN.LastATRplTime.wHour, TMSTN.LastATRplTime.wMinute, TMSTN.LastATRplTime.wSecond );
printf("LAST RESET OF COUNTERS on %d/%d/%d at %d hrs %d mts %d secs\n", TIME_ARGSN(CounterResetTime) );
printf("COUNTERS\n"); printf("\n# of U and G Registration requests = (%d %d)\n# Of Successful/Failed Queries = (%d/%d)\n# Of U and G Refreshes = (%d %d)\n# Of Successful/Failed Releases = (%d/%d)\n# Of U. and G. Conflicts = (%d %d)\n", ResultsN.WinsStat.Counters.NoOfUniqueReg, ResultsN.WinsStat.Counters.NoOfGroupReg, ResultsN.WinsStat.Counters.NoOfSuccQueries, ResultsN.WinsStat.Counters.NoOfFailQueries, ResultsN.WinsStat.Counters.NoOfUniqueRef, ResultsN.WinsStat.Counters.NoOfGroupRef, ResultsN.WinsStat.Counters.NoOfSuccRel, ResultsN.WinsStat.Counters.NoOfFailRel, ResultsN.WinsStat.Counters.NoOfUniqueCnf, ResultsN.WinsStat.Counters.NoOfGroupCnf ); }
if (ResultsN.WinsStat.NoOfPnrs) { printf("WINS partner --\t# of Repl --\t # of Comm Fails\n"); for (i =0; i < ResultsN.WinsStat.NoOfPnrs; i++) { InAddr.s_addr = htonl( (ResultsN.WinsStat.pRplPnrs + i)->Add.IPAdd); printf("%s\t\t%d\t\t%d\n", inet_ntoa(InAddr), (ResultsN.WinsStat.pRplPnrs + i)->NoOfRpls, (ResultsN.WinsStat.pRplPnrs + i)->NoOfCommFails ); }
WinsFreeMem(ResultsN.pAddVersMaps); WinsFreeMem(ResultsN.WinsStat.pRplPnrs); } break;
case(PUSH_TRIGGER): WinsAdd.Len = 4; WinsAdd.Type = 0; printf("Address ? "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); printf("Want propagation (default - none) Input 1 for yes? "); scanf("%d", &Choice); Status = WinsTrigger(BindHdl, &WinsAdd, Choice == 1 ? WINSINTF_E_PUSH_PROP : WINSINTF_E_PUSH); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; case(PULL_TRIGGER): WinsAdd.Len = 4; WinsAdd.Type = 0; printf("Address ? "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); Status = WinsTrigger(BindHdl, &WinsAdd, WINSINTF_E_PULL); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; case(STATIC_INIT): printf("Do you wish to specify a data file (1 - yes) -- "); scanf("%d", &Choice); if (Choice == 1) { WCHAR String[80]; BOOL fDel; printf("Enter full file path -- "); wscanf(L"%s", String); printf("Delete file after use. Input 1 for yes 0 for no -- "); scanf("%d", &Choice); fDel = Choice == 1 ? TRUE : FALSE; Status = WinsDoStaticInit(BindHdl, String, fDel); } else { Status = WinsDoStaticInit(BindHdl, (WCHAR *)NULL, FALSE); }
printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; case(DO_CC): { WINSINTF_SCV_REQ_T ScvReq;#if 0
printf("Scavenging/consistency check\nInput 0 for General; 1 for Consistency Chk -- "); scanf("%d", &Choice); ScvReq.Opcode_e = (Choice == 0) ? WINSINTF_E_SCV_GENERAL : WINSINTF_E_SCV_VERIFY;#endif
ScvReq.Opcode_e = WINSINTF_E_SCV_VERIFY;#if 0
if (Choice != 0)#endif
{ printf("Consistency Check all or those older than verify interval\nCAUTION: CONSISTENCY CHECKING ALL REPLICAS IS A NETWORK AND RESOURCE INTENSIVE OPERATION\nInput 1 for consistency checking all.\nAny other for those older than verify interval -- "); scanf("%d", &Choice); ScvReq.Age = (Choice == 1) ? 0 : Choice; }
#if 0
if (ScvReq.Opcode_e != WINSINTF_E_SCV_GENERAL)#endif
{ printf("Do you want to override WINS checking for overload condition ?\nOverload condition is Consistency Check command being repeated within a duration of 1 hour.\nInput 1 for yes. Any other no. will not affect WINS checking -- "); scanf("%d", &Choice); }#if 0
else { Choice = 0; printf("Do you want to override WINS safety checks as regards tombstone deletion.\nWINS normally does not delete tombstones until it has been up and running\nfor a certain duration of time\nInput 1 for overriding the safety checks. Otherwise, input any other no. -- ");
} ScvReq.fForce = (Choice == 1) ? TRUE : FALSE;#endif
ScvReq.fForce = (Choice == 1) ? TRUE : FALSE; Status = WinsDoScavengingNew(BindHdl, &ScvReq); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); } break; case(DO_SCV): Status = WinsDoScavenging(BindHdl ); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; case(DEL_RANGE_RECS): printf("Address of Owner Wins -- "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); WinsAdd.Len = 4; WinsAdd.Type = 0;
printf("Min. Vers. No (<high part> <low part> -- "); scanf("%d %d", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No (<high part> <low part> -- "); scanf("%d %d", &MaxVersNo.HighPart, &MaxVersNo.LowPart);
Status = WinsDelDbRecs(BindHdl, &WinsAdd, MinVersNo, MaxVersNo); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break;
case(TOMBSTONE_RANGE_RECS): printf("Address of Owner Wins -- "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); WinsAdd.Len = 4; WinsAdd.Type = 0;
printf("Min. Vers. No (<high part> <low part> or <0 0> for all -- "); scanf("%lx %lx", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No (<high part> <low part> or <0 0> for all -- "); scanf("%lx %lx", &MaxVersNo.HighPart, &MaxVersNo.LowPart);
Status = WinsTombstoneDbRecs(BindHdl,&WinsAdd, MinVersNo, MaxVersNo); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break;
case(PULL_RANGE_RECS): printf("Address of Wins to pull from -- "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); WinsAdd.Len = 4;
printf("Address of Wins whose recs are to be pulled -- "); scanf("%s", tgtadd); OwnAdd.IPAdd = ntohl(inet_addr(tgtadd)); OwnAdd.Len = 4; OwnAdd.Type = 0;
printf("Min. Vers. No (<high part> <low part> -- "); scanf("%d %d", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No (<high part> <low part> -- "); scanf("%d %d", &MaxVersNo.HighPart, &MaxVersNo.LowPart);
printf("NOTE: If the local WINS contains any record with a VERS. No. > Min. Vers. and < Max. Vers. No, it will be deleted prior to pulling \n"); printf("it will be deleted prior to pulling the range\n"); printf("Process 1 for yes, any other to quit -- "); scanf("%d", &Choice); if (Choice == 1) { Status = WinsPullRange(BindHdl, &WinsAdd, &OwnAdd, MinVersNo, MaxVersNo); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); } break;
case(GET_RECS_BY_VERS): { FILE *pFile; DWORD Len; BOOL fSetFilter;
pFile = NULL; WinsAdd.Len = 4; WinsAdd.Type = 0; printf("Address of owner WINS? "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd));
if (!fCountRec) { printf("Want to specify range -- (input 1) or all (default) -- "); } else { printf("Want to specify range -- (input 1) or count all (default) -- "); } scanf("%d", &Choice); if (Choice != 1) { MinVersNo.LowPart = MinVersNo.HighPart = 0; MaxVersNo.LowPart = MaxVersNo.HighPart = 0; } else { printf("Min. Vers. No (<high part> <low part> -- "); scanf("%d %d", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No (<high part> <low part> -- "); scanf("%d %d", &MaxVersNo.HighPart, &MaxVersNo.LowPart);
}
if (!fCountRec) { printf("Use filter (1 for yes, 0 for no) -- "); scanf("%d", &Choice); if (Choice == 1) { GetFilterName(String, &Len); fSetFilter = TRUE; } else { fSetFilter = FALSE; } WantFile(&pFile); if (pFile != NULL) { GetSystemTime(&SystemTime); fprintf(pFile, "\n*******************************\n\n"); fprintf(pFile, "OWNER WINS = (%s); LOCAL DB OF WINS = (%s)\n", tgtadd, NmsAdd); fprintf(pFile, "Time is %d:%d:%d on %d/%d/%d\n", SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMonth, SystemTime.wDay, SystemTime.wYear); fprintf(pFile, "*******************************\n\n"); } } Status = GetDbRecs( MinVersNo, MaxVersNo, &WinsAdd, tgtadd, fSetFilter, String, Len, FALSE, //fAddFilter
0, //Address
pFile, fCountRec );
printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status);
if (pFile != NULL) { fclose(pFile); } break;
} case(BACKUP_DB): printf(" Full (1) or Incremental (any other) -- "); scanf("%d", &Choice); if (Choice == 1) { fIncremental = FALSE; } else { fIncremental = TRUE; } printf("Backup file path -- "); scanf("%s", String);
Status = WinsBackup(BindHdl, String, (short)fIncremental );
printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status != WINSINTF_SUCCESS) { printf("Check if the backup directory is empty. If not, cleanup and retry\n"); } break; case(RESTORE_DB): { DbVersion Version;
printf("Which version of Databse do you want to restore?\n"); printf("Type 1 for NT3.51, 2 for NT4.0 and 3 for NT5.0 : "); scanf("%d", &Version); if ( Version <= DbVersionMin || Version >= DbVersionMax ) { printf("Invalid choice..\n"); break; } printf("Backup file path -- "); scanf("%s", String); Status = WinsRestoreEx(String, Version); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; } case(CONNECT_WINS): WinsUnbind(&BindData, BindHdl); goto LABEL; break; case(TERM_WINS): printf("You sure ??? (yes - 1) "); scanf("%d", &Choice); if (Choice == 1) { printf("Abrupt Termination ? (yes - 1) "); scanf("%d", &Choice); if (Choice == 1) { Status = WinsTerm(BindHdl, TRUE); } else { Status = WinsTerm(BindHdl, FALSE); } printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); } break; case(SET_PRIORITY_CLASS): printf("Input Priority Class (1-High, any other-Normal) -- "); scanf("%d", &Choice); if (Choice == 1) { Choice = WINSINTF_E_HIGH; } else { Choice = WINSINTF_E_NORMAL; } Status = WinsSetPriorityClass(BindHdl, Choice); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break;
case(RESET_COUNTERS): Status = WinsResetCounters(BindHdl); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; case(CHANGE_THDS): printf("Print the new count of Nbt Threads (1 to %d) -- ", WINSTHD_MAX_NO_NBT_THDS); scanf("%d", &Choice); if ((Choice < 1) || (Choice > WINSTHD_MAX_NO_NBT_THDS)) { printf("Wrong number \n"); break; } Status = WinsWorkerThdUpd(BindHdl, Choice); printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break; case(WINS_ADD): wprintf(L"%s\n", NmsAdd); break; case(MENU): fInteractive = TRUE; break; case(NOMENU): fInteractive = FALSE; break; case(SYNC_DB): WinsAdd.Len = 4; WinsAdd.Type = 0; printf("Address of WINS to sync up with? "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); printf("Address of WINS whose records are to be retrieved ? "); scanf("%s", tgtadd); OwnAdd.IPAdd = ntohl(inet_addr(tgtadd)); WinsSyncUp(BindHdl, &WinsAdd, &OwnAdd); break; case(GET_WINS_INFO):
Status = WinsGetNameAndAdd(BindHdl, &WinsAdd, String); printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { InAddr.s_addr = htonl(WinsAdd.IPAdd); printf("Address is (%s)\nName is (%s)\n", inet_ntoa(InAddr), String); }
break; case(SEARCH_DB): { DWORD Len; BYTE Add[30]; BOOL fAddFilter; DWORD AddFilter; FILE *pFile;
printf("Search by Address or Name (1 for Address, 0 for Name) --" ); scanf("%d", &Choice); if (Choice == 1) { printf("Address (dotted decimal) -- "); scanf("%s", Add); AddFilter = ntohl(inet_addr(Add)); fAddFilter = TRUE; } else { GetFilterName(String, &Len); fAddFilter = FALSE; }
WantFile(&pFile); if (pFile != NULL) { GetSystemTime(&SystemTime); fprintf(pFile, "\n*******************************\n\n"); fprintf(pFile, "Searching Database of WINS with address = (%s)\n", NmsAdd); fprintf(pFile, "Time is %d:%d:%d on %d/%d/%d\n", SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMonth, SystemTime.wDay, SystemTime.wYear); fprintf(pFile, "*******************************\n\n"); } Results.WinsStat.NoOfPnrs = 0; Results.WinsStat.pRplPnrs = 0; if (GetStatus(FALSE, &Results, FALSE, TRUE) == WINSINTF_SUCCESS) { if (Results.NoOfOwners != 0) { for ( i= 0; i < Results.NoOfOwners; i++) { InAddr.s_addr = htonl( Results.AddVersMaps[i].Add.IPAdd);
printf("Searching records owned by %s\n", inet_ntoa(InAddr) );
WinsAdd.Len = 4; WinsAdd.Type = 0; WinsAdd.IPAdd = Results.AddVersMaps[i].Add.IPAdd;
MaxVersNo = Results.AddVersMaps[i].VersNo;
MinVersNo.LowPart = 0; MinVersNo.HighPart = 0;
Status = GetDbRecs( MinVersNo, MaxVersNo, &WinsAdd, inet_ntoa(InAddr), TRUE, //fSetFilter
String, Len, fAddFilter, AddFilter, pFile, //pFile
FALSE //fCountRec
); if (Status != WINSINTF_SUCCESS) { break; }
} } } } break;
case(GET_DOMAIN_NAMES): { WINSINTF_BROWSER_NAMES_T Names; PWINSINTF_BROWSER_INFO_T pInfo; PWINSINTF_BROWSER_INFO_T pInfoSv;
DWORD i;
Names.pInfo = NULL; Status = WinsGetBrowserNames(&BindData, &Names); printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { printf("No Of records returned are %d\n", Names.EntriesRead); pInfoSv = pInfo = Names.pInfo; for(i=0; i < Names.EntriesRead; i++) { printf("Name[%d] = %s\n", i, pInfo->pName ); pInfo++; } WinsFreeMem(pInfoSv); } } break;
case(DEL_WINS):
WinsAdd.Len = 4; WinsAdd.Type = 0; printf("Address of Wins to delete? "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); Status = WinsDeleteWins(BindHdl, &WinsAdd); printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break;
case(CREATE_LMHOSTS): if (GetStatus(FALSE, &Results, FALSE, TRUE) == WINSINTF_SUCCESS) { if (Results.NoOfOwners != 0) { for ( i= 0; i < Results.NoOfOwners; i++) { Recs.pRow = NULL;
InAddr.s_addr = htonl( Results.AddVersMaps[i].Add.IPAdd);
printf(" Will get records owned by %s\n", inet_ntoa(InAddr) );
WinsAdd.Len = 4; WinsAdd.Type = 0; WinsAdd.IPAdd = Results.AddVersMaps[i].Add.IPAdd;
MaxVersNo = Results.AddVersMaps[i].VersNo;
MinVersNo.LowPart = 0; MinVersNo.HighPart = 0;
Status = WinsGetDbRecs(BindHdl, &WinsAdd, MinVersNo, MaxVersNo, &Recs);
if (Status != WINSINTF_SUCCESS) { break; } else { if ((pFileU == NULL) || (pFileO == NULL)) {
pFileU = fopen(FILEU, "a"); if (pFileU == NULL) { printf("Could not open file %s for appending\n", FILEU); break; }
pFileO = fopen(FILEO, "a"); if (pFileO == NULL) { printf("Could not open file %s for appending\n", FILEO); break; } } else { break; } } if(CreateFiles(&Recs, &WinsAdd, pFileU, pFileO) == WINSINTF_SUCCESS) { fclose(pFileU); fclose(pFileO); pFileU = NULL; pFileO = NULL; fFileInited = TRUE; }
} } } else { printf("GetStatus failed\n"); }
break; case(INIT_FROM_FILE): if (fFileInited) { if (InitFromFile() != WINSINTF_SUCCESS) { printf("Init failed\n"); } } else { printf("Use old files (0 for yes) -- "); scanf("%d", &Choice); if (Choice == 0) { if (InitFromFile() != WINSINTF_SUCCESS) { printf("Init failed\n"); } } else { printf("First create file\n"); } } break; case(GET_RECS_BY_NAME): { PWINSINTF_ADD_T pWinsAdd = NULL; BOOL fAlloc = TRUE; BYTE Name[5]; BYTE strAdd[20]; DWORD NoOfRecsDesired; DWORD TypeOfRec; DWORD Location = WINSINTF_BEGINNING; printf ("Want to input Name (0 for yes, 1 for no) -- "); scanf("%d", &Choice); if (Choice == 0) { printf("First char non-printable 0 for no, 1 for yes -- "); scanf("%d", &Choice); if (Choice != 0) { printf("Input 1st char in hex -- "); scanf("%x", &Name[0]); Name[1] = (BYTE)NULL; printf("Name is %s\n", Name); RecAction.pName = Name; RecAction.NameLen = 1; fAlloc = FALSE; } else { GetNameInfo(&RecAction, WINSINTF_E_QUERY); } } else { RecAction.pName = NULL; RecAction.NameLen = 0; } printf("Start from beginning or end of db -- 0 for beginning, 1 for end -"); scanf("%d", &Choice); if (Choice != 0) { Location = WINSINTF_END; }
printf("Recs of all or of a particular owner (0 for all, or 1 for particular owner) -- "); scanf("%d", &Choice); if (Choice != 0) { WinsAdd.Len = 4; WinsAdd.Type = 0; printf("Address of Wins whose records are to be retrieved? "); scanf("%s", tgtadd); WinsAdd.IPAdd = ntohl(inet_addr(tgtadd)); pWinsAdd = &WinsAdd; } printf("Input - No Of Recs desired (Max is 5000 - for max input 0) -- "); scanf("%d", &NoOfRecsDesired); printf("Only static (1), only dynamic (2) or both (4) -- "); scanf("%d", &TypeOfRec); if((TypeOfRec == 1) || (TypeOfRec == 2) || (TypeOfRec == 4)) { BOOL fFilter = FALSE; DWORD AddFilter; printf("Search for records based on IP Address (0 for no, 1 for yes) -- "); scanf("%d", &Choice);
if ( Choice != 0) {
fFilter = TRUE; printf("Input IP address in dotted notation -- "); printf("Address (dotted decimal) -- "); scanf("%s", strAdd); AddFilter = ntohl(inet_addr(strAdd)); } Status = GetDbRecsByName(pWinsAdd, Location, RecAction.pName, RecAction.NameLen, NoOfRecsDesired, TypeOfRec, fFilter, AddFilter); if (fAlloc && (RecAction.pName != NULL)) { WinsFreeMem(RecAction.pName); } printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); } else { printf("Wrong choice\n");
} } break; case(GET_MAPS): case(GET_MAPS_VERBOSE): { WINSINTF_RESULTS_NEW_T ResultsN; Results.WinsStat.NoOfPnrs = 0; Results.WinsStat.pRplPnrs = NULL; (VOID)GetStatus(TRUE, (LPVOID)&ResultsN, TRUE, Cmd_e == GET_MAPS ? TRUE : FALSE ); } break; case(EXIT): fExit = TRUE; break;
case(MEM_DUMP): printf("Mem. Dump - 2; Heap Dump -4; Que Items dump - 8; or combo -- "); scanf("%d", &Choice); Status = WinsSetFlags(BindHdl, Choice); printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); break;
case(BS): Status = WinsSetFlags(BindHdl, 1); printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); printf("Status returned is (%d)\n", Status); break; case(SS): Status = WinsSetFlags(BindHdl, 0); printf("Status returned (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); printf("Status returned is (%d)\n", Status); break;
case(INVALID_VALUE): printf("Wrong cmd\n"); break; } }
WinsUnbind(&BindData, BindHdl);}except(EXCEPTION_EXECUTE_HANDLER){ printf("Execution exception encountered..\n");} return(0);
}
VOIDGetNameInfo( PWINSINTF_RECORD_ACTION_T pRecAction, WINSINTF_ACT_E Cmd_e ){ BYTE tgtadd[30]; BYTE Name[255]; int Choice; int Choice2; DWORD LastChar; size_t Len;
pRecAction->pAdd = NULL; pRecAction->NoOfAdds = 0; pRecAction->fStatic = TRUE;
printf("Name ? "); scanf("%s", Name); _strupr(Name);
if ((Len = strlen(Name)) < 16) { printf("Do you want to input a 16th char (1 for yes, 0 for no) -- "); scanf("%d", &Choice); if (Choice) { printf("16th char in hex -- "); scanf("%x", &LastChar); memset(&Name[Len], (int)' ',16-Len); Name[15] = (BYTE)(LastChar & 0xff); Name[16] = (CHAR)NULL; Len = 16; } else { memset(&Name[Len], (int)' ',16-Len); Name[16] = (CHAR)NULL; Len = 16; } } else { Name[16] = (CHAR)NULL; Len = 16; }
printf("Scope - 1 for yes, 0 for no --"); scanf("%d", &Choice); if (Choice == 1) { Name[Len] = '.'; printf("Enter scope -- "); scanf("%s", &Name[Len + 1]); Len = strlen(Name); }
if (Cmd_e == WINSINTF_E_INSERT) {
Choice = 0; printf("TypeOfRec - Static(0), Dynamic(1) - Default Static -- "); scanf("%d", &Choice); if (1 == Choice) { pRecAction->fStatic = FALSE; } Choice = 0; printf("TypeOfNode - U(0), Norm Grp (1), Spec Grp (2), Multihomed (3) default Unique -- "); scanf("%d", &Choice); switch (Choice) { case(0): default: pRecAction->TypOfRec_e = WINSINTF_E_UNIQUE; break; case(1): pRecAction->TypOfRec_e = WINSINTF_E_NORM_GROUP; break; case(2): pRecAction->TypOfRec_e = WINSINTF_E_SPEC_GROUP; break; case(3): pRecAction->TypOfRec_e = WINSINTF_E_MULTIHOMED; break; } if ((Choice == 2) || (Choice == 3)) { int i; printf("How many addresses do you wish to input (Max %d) -- ", WINSINTF_MAX_MEM); scanf("%d", &Choice2); pRecAction->pAdd = WinsAllocMem( sizeof(WINSINTF_ADD_T) * Choice2); for(i = 0; i < Choice2 && i < WINSINTF_MAX_MEM; i++) { printf("IP Address no (%d) ? ", i); scanf("%s", tgtadd);
(pRecAction->pAdd + i)->IPAdd = ntohl(inet_addr(tgtadd)); (pRecAction->pAdd + i)->Type = 0; (pRecAction->pAdd + i)->Len = 4;
} pRecAction->NoOfAdds = i; } else { printf("IP Address ? "); scanf("%s", tgtadd); pRecAction->Add.IPAdd = ntohl(inet_addr(tgtadd)); pRecAction->Add.Type = 0; pRecAction->Add.Len = 4;// pRecAction->NoOfAdds = 1;
} if ((Choice != 1) && (Choice != 2)) { Choice = 0; printf("Node Type -- P-node (0), H-node (1), B-node (2),default - P node -- "); scanf("%d", &Choice); switch(Choice) { default: case(0): pRecAction->NodeTyp = WINSINTF_E_PNODE; break; case(1): pRecAction->NodeTyp = WINSINTF_E_HNODE; break; case(2): pRecAction->NodeTyp = WINSINTF_E_BNODE; break; } }
}
#if 0
if (Cmd_e == WINSINTF_E_RELEASE) { printf("Want to specify address (pkt add) 1 for yes, 0 for no -- "); scanf("%d", &Choice); if (Choice == 1) { if( ( pRecAction->TypOfRec_e == WINSINTF_E_SPEC_GROUP) || ( pRecAction->TypOfRec_e == WINSINTF_E_MULTIHOMED) ) { pRecAction->pAdd = WinsAllocMem(sizeof(WINSINTF_ADD_T)); printf("IP Address ? -- "); scanf("%s", tgtadd); pRecAction->pAdd->IPAdd = ntohl(inet_addr(tgtadd)); pRecAction->pAdd->Type = 0; pRecAction->pAdd->Len = 4;
} printf("IP Address ? -- "); scanf("%s", tgtadd); pRecAction->Add.IPAdd = ntohl(inet_addr(tgtadd)); pRecAction->Add.Type = 0; pRecAction->Add.Len = 4; } }#endif
pRecAction->pName = WinsAllocMem(Len); (void)memcpy(pRecAction->pName, Name, Len); pRecAction->NameLen = Len; return;}VOIDGetFilterName( LPBYTE pStr, LPDWORD pLen ){
DWORD LastChar; DWORD Choice;
printf("Name ? "); scanf("%s", pStr); if ((*pLen = strlen(pStr)) < 16) { printf("Do you want to input a 16th char (1 for yes, 0 for no) -- "); scanf("%d", &Choice); if (Choice) { printf("16th char in hex -- "); scanf("%x", &LastChar); memset(&pStr[*pLen], (int)' ',16-*pLen); pStr[15] = (BYTE)LastChar && 0xff; pStr[16] = (TCHAR)NULL; *pLen = 16; } } return;}
DWORDGetStatus( BOOL fPrint, LPVOID pResultsA, BOOL fNew, BOOL fShort ){ DWORD Status, i; struct in_addr InAddr; PWINSINTF_RESULTS_T pResults = pResultsA; PWINSINTF_RESULTS_NEW_T pResultsN = pResultsA; PWINSINTF_ADD_VERS_MAP_T pAddVersMaps; DWORD NoOfOwners;
if (!fNew) { Status = WinsStatus(BindHdl, WINSINTF_E_CONFIG, pResultsA); } else { pResultsN->pAddVersMaps = NULL; Status = WinsStatusNew(BindHdl, WINSINTF_E_CONFIG_ALL_MAPS, pResultsN); } printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { if (fPrint) { printf("Refresh Interval = (%d)\n", fNew ? pResultsN->RefreshInterval : pResults->RefreshInterval ); printf("Tombstone Interval = (%d)\n", fNew ? pResultsN->TombstoneInterval : pResults->TombstoneInterval); printf("Tombstone Timeout = (%d)\n", fNew ? pResultsN->TombstoneTimeout : pResults->TombstoneTimeout); printf("Verify Interval = (%d)\n", fNew ? pResultsN->VerifyInterval : pResults->VerifyInterval); if (!fNew) { printf("WINS Priority Class = (%s)\n", pResults->WinsPriorityClass == NORMAL_PRIORITY_CLASS ? "NORMAL" : "HIGH"); printf("No of Worker Thds in WINS = (%d)\n", pResults->NoOfWorkerThds); pAddVersMaps = pResults->AddVersMaps; NoOfOwners = pResults->NoOfOwners; } else { printf("WINS Priority Class = (%s)\n", pResultsN->WinsPriorityClass == NORMAL_PRIORITY_CLASS ? "NORMAL" : "HIGH"); printf("No of Worker Thds in WINS = (%d)\n", pResultsN->NoOfWorkerThds); pAddVersMaps = pResultsN->pAddVersMaps; NoOfOwners = pResultsN->NoOfOwners; }
if (NoOfOwners != 0) { printf("OWNER ID\t\tADDRESS\t\tVERS.NO\n"); printf("--------\t\t-------\t\t-------\n"); for ( i= 0; i < NoOfOwners; i++, pAddVersMaps++) { InAddr.s_addr = htonl( pAddVersMaps->Add.IPAdd);
if (fNew) { if ( (pAddVersMaps->VersNo.HighPart == MAXLONG) && (pAddVersMaps->VersNo.LowPart == MAXULONG) ) { if (!fShort) { printf("%d\t\t%s\t\t", i, inet_ntoa(InAddr)); printf("DELETED. SLOT WILL BE REUSED LATER\n"); } continue; } } if (fShort && pAddVersMaps->VersNo.QuadPart == 0) { continue; } printf("%d\t\t%s\t\t", i, inet_ntoa(InAddr));
printf("%lx %lx\n", pAddVersMaps->VersNo.HighPart, pAddVersMaps->VersNo.LowPart ); } if (fNew) { WinsFreeMem(pResultsN->pAddVersMaps); } } else { printf("The Db is empty\n"); Status = WINSINTF_FAILURE; } } } return(Status);}
DWORDGetDbRecs( WINSINTF_VERS_NO_T LowVersNo, WINSINTF_VERS_NO_T HighVersNo, PWINSINTF_ADD_T pWinsAdd, LPBYTE pTgtAdd, BOOL fSetFilter, LPBYTE pFilterName, DWORD Len, BOOL fAddFilter, DWORD AddFilter, FILE *pFile, BOOL fCountRec ){
WINSINTF_RECS_T Recs; DWORD Choice; DWORD Status = WINSINTF_SUCCESS; DWORD TotalCnt = 0; BOOL fMatch;
while (TRUE) { Recs.pRow = NULL; Status = WinsGetDbRecs(BindHdl, pWinsAdd, LowVersNo, HighVersNo, &Recs); if (!fSetFilter) { printf("Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); }
if (fCountRec) { printf("Total number of records are (%d)\n", Recs.TotalNoOfRecs); break; } if (Status == WINSINTF_SUCCESS) { if (Recs.NoOfRecs > 0) { DWORD i; PWINSINTF_RECORD_ACTION_T pRow = Recs.pRow; TotalCnt += Recs.NoOfRecs;
if (!fSetFilter) { if (pFile == NULL) { printf("Retrieved %d records of WINS\n", Recs.NoOfRecs); } else { fprintf(pFile, "RETRIEVED %d RECORDS OF WINS = (%s) \n", Recs.NoOfRecs, pTgtAdd); }
} for (i=0; i<Recs.NoOfRecs; i++) {
if (fAddFilter) { //
// The address filter was specfied
// If the address matches, then
// fMatch will be TRUE after the
// function returns.
//
fMatch = TRUE; ChkAdd( pRow, pFile, AddFilter, &fMatch ); } else { fMatch = FALSE; }
//
// If the address matched or if no filter
// was specified or if there was a name
// filter and the names matched, print
// out the details
//
if (fMatch || !fSetFilter || ( !fAddFilter && !memcmp(pRow->pName, pFilterName, Len) ) ) { if (pFile == NULL) { printf("-----------------------\n"); printf("Name is (%s). 16th char is (%x)\nNameLen is (%d)\nType is (%s)\nState is (%s)\nVersion No is (%x %x)\nStatic flag is (%d)\nTimestamp is (%.19s)\n", pRow->pName, *(pRow->pName+15),pRow->NameLen, pRow->TypOfRec_e == WINSINTF_E_UNIQUE ? "UNIQUE" : (pRow->TypOfRec_e == WINSINTF_E_NORM_GROUP) ? "NORMAL GROUP" : (pRow->TypOfRec_e == WINSINTF_E_SPEC_GROUP) ? "SPECIAL GROUP" : "MULTIHOMED", pRow->State_e == WINSINTF_E_ACTIVE ? "ACTIVE" : (pRow->State_e == WINSINTF_E_RELEASED) ? "RELEASED" : "TOMBSTONE", pRow->VersNo.HighPart, pRow->VersNo.LowPart, pRow->fStatic, asctime(localtime(&(pRow->TimeStamp)))); } else {
fprintf(pFile, "-----------------------\n"); fprintf(pFile, "Name is (%s). 16th char is (%x)\nNameLen is (%d)\nType is (%s)\nState is (%s)\nVersion No is (%x %x)\nStatic flag is (%d)\nTimestamp is (%.19s)\n", pRow->pName, *(pRow->pName+15),pRow->NameLen, pRow->TypOfRec_e == WINSINTF_E_UNIQUE ? "UNIQUE" : (pRow->TypOfRec_e == WINSINTF_E_NORM_GROUP) ? "NORMAL GROUP" : (pRow->TypOfRec_e == WINSINTF_E_SPEC_GROUP) ? "SPECIAL GROUP" : "MULTIHOMED", pRow->State_e == WINSINTF_E_ACTIVE ? "ACTIVE" : (pRow->State_e == WINSINTF_E_RELEASED) ? "RELEASED" : "TOMBSTONE", pRow->VersNo.HighPart, pRow->VersNo.LowPart, pRow->fStatic, asctime(localtime(&(pRow->TimeStamp))));
} fMatch = FALSE;
ChkAdd( pRow, pFile, AddFilter, &fMatch );
if (pFile == NULL) { printf("-----------------------\n"); } else { fprintf(pFile, "-----------------------\n"); } } pRow++;
} // end of for (all recs)
//
// If a range was chosen and records
// retrieved are == the limit of 100
// and if the Max vers no retrieved
// is less than that specified, ask
// user if he wishes to continue
//
if (!fSetFilter) { printf("Got %d records in this round\n", Recs.NoOfRecs); } if ( (Recs.NoOfRecs < Recs.TotalNoOfRecs) && LiLtr((--pRow)->VersNo, HighVersNo ) ) { if ((pFile == NULL) && (!fSetFilter)) { printf("There may be more. Get them ?? Input 1 for yes, 0 for no -- "); scanf("%d", &Choice); } else { Choice = 1; } if (Choice == 1) { LowVersNo.QuadPart = LiAdd(pRow->VersNo,sTmpVersNo); //Recs.NoOfRecs = 0;
continue; }
}
printf("Total No Of records %s = (%d)\n", fSetFilter ? "searched" : "retrieved", TotalCnt); if (pFile != NULL) { fprintf(pFile, "TOTAL NO OF RECORDS %s = (%d) for WINS (%s)\n", fSetFilter ? "searched" : "retrieved", TotalCnt, pTgtAdd); fprintf(pFile, "++++++++++++++++++++++++++++++\n");
} } else { printf("No records of WINS (%s) in the range requested are there in the local db\n", pTgtAdd);
} } break; } // while (TRUE)
if (Recs.pRow != NULL) { WinsFreeMem(Recs.pRow); } return(Status);} // GetDbRecs
VOIDChkAdd( PWINSINTF_RECORD_ACTION_T pRow, FILE *pFile, DWORD Add, LPBOOL pfMatch ){
struct in_addr InAddr;
if ( (pRow->TypOfRec_e == WINSINTF_E_UNIQUE) || (pRow->TypOfRec_e == WINSINTF_E_NORM_GROUP) ) { InAddr.s_addr = htonl( pRow->Add.IPAdd);
if (*pfMatch) { if (Add == pRow->Add.IPAdd) { return; } else { *pfMatch = FALSE; return; } }
if (pFile == NULL) { printf("IP Address is (%s)\n", inet_ntoa(InAddr) ); } else { fprintf(pFile, "IP Address is (%s)\n", inet_ntoa(InAddr) ); } } else //spec. grp or multihomed
{ DWORD ind; if (!*pfMatch) { if (pFile == NULL) { printf("No. Of Members (%d)\n\n", pRow->NoOfAdds/2); } else { fprintf(pFile, "No. Of Members (%d)\n\n", pRow->NoOfAdds/2); } }
for ( ind=0; ind < pRow->NoOfAdds ; /*no third expr*/ ) { InAddr.s_addr = htonl( (pRow->pAdd + ind++)->IPAdd); if (!*pfMatch) { if (pFile == NULL) { printf("Owner is (%s); ", inet_ntoa(InAddr) ); } else { fprintf(pFile, "Owner is (%s); ", inet_ntoa(InAddr) ); } } InAddr.s_addr = htonl( (pRow->pAdd + ind++)->IPAdd);
if (!*pfMatch) { if (pFile == NULL) { printf("Node is (%s)\n", inet_ntoa(InAddr) ); } else { fprintf(pFile, "Node is (%s)\n", inet_ntoa(InAddr) ); } } if (*pfMatch) { if (Add == (pRow->pAdd + ind - 1)->IPAdd) { return; } else { *pfMatch = FALSE; return; } } }
//
// If there were no members to compare with, then
// let us set *pfMatch to FALSE.
//
if (ind == 0) { if (*pfMatch) { *pfMatch = FALSE; } }
}}
VOIDWantFile( FILE **ppFile){ DWORD Choice; printf("Put records in wins.rec file (1 for yes, 0 for no) -- "); scanf("%d", &Choice); if (Choice != 1) { *ppFile = NULL; } else { *ppFile = fopen("wins.rec", "a"); if (*ppFile == NULL) { printf("Could not open file wins.rec for appending\n"); } } return;}
DWORDCreateFiles( PWINSINTF_RECS_T pRecs, PWINSINTF_ADD_T pWinsAdd, FILE *pFileU, FILE *pFileO ){ DWORD no; PWINSINTF_RECORD_ACTION_T pRow; DWORD i; struct in_addr InAddr;
pRow = pRecs->pRow; InAddr.s_addr = htonl(pWinsAdd->IPAdd); fprintf(pFileU, "##UNIQUE records of WINS with address %s\n\n", inet_ntoa(InAddr)); fprintf(pFileO, "##NON-UNIQUE records of WINS with address %s\n", inet_ntoa(InAddr));
for(no = 0; no < pRecs->NoOfRecs; no++) {
if (pRow->TypOfRec_e == WINSINTF_E_UNIQUE) { InAddr.s_addr = htonl(pRow->Add.IPAdd);
fprintf(pFileU, "%s\t", inet_ntoa(InAddr)); for (i=0; i<pRow->NameLen; i++) { fprintf(pFileU, "%c", *(pRow->pName + i)); } fprintf(pFileU, "\n"); } else { fprintf(pFileO, "%d\t", pRow->NameLen); for (i=0; i<pRow->NameLen; i++) { fprintf(pFileO, "%c", (BYTE)(*(pRow->pName + i))); }
fprintf(pFileO, "\t%d", pRow->TypOfRec_e); if (pRow->TypOfRec_e == WINSINTF_E_NORM_GROUP) { InAddr.s_addr = htonl(pRow->Add.IPAdd); fprintf(pFileO, "\t%s", inet_ntoa(InAddr));
} else { fprintf(pFileO, "\t%d\t", pRow->NoOfAdds); for (i=0; i<pRow->NoOfAdds; i) { InAddr.s_addr = htonl((pRow->pAdd +i++)->IPAdd); fprintf(pFileO, "%s\t", inet_ntoa(InAddr)); InAddr.s_addr = htonl((pRow->pAdd + i++)->IPAdd); fprintf(pFileO, "%s\t", inet_ntoa(InAddr)); } } fprintf(pFileO, "\n"); } pRow++; } fprintf(pFileO, "\n\n\n");
return(WINSINTF_SUCCESS);}
DWORDInitFromFile( VOID ){ FILE *pFileO; WINSINTF_RECORD_ACTION_T RecAction; DWORD NoOfRecs = 0; DWORD i; DWORD RetStat = WINSINTF_SUCCESS; BYTE Add[20];
pFileO = fopen(FILEO, "r"); if (pFileO == NULL) { printf("Could not open file %s\n", FILEO); return(WINSINTF_FAILURE); } while(TRUE) { printf("Record no %d\n", ++NoOfRecs);
if (fscanf(pFileO, "%d\t", &RecAction.NameLen) == EOF) { printf("ERROR reading NameLen\n"); break;
} RecAction.pName = WinsAllocMem(RecAction.NameLen); for(i=0;i<RecAction.NameLen;i++) { if (fscanf(pFileO, "%c", (RecAction.pName + i)) == EOF) { printf("ERROR reading Name. i is %d", i); break; } } if (fscanf(pFileO, "\t%d", &RecAction.TypOfRec_e) == EOF) { printf("ERROR reading TypeOfRec\n"); break; } if (RecAction.TypOfRec_e == WINSINTF_E_NORM_GROUP) { fscanf(pFileO, "%s", Add); RecAction.Add.IPAdd = 0xFFFFFFFF; RecAction.Add.Type = 0; RecAction.Add.Len = 4; RecAction.NoOfAdds = 0; } else { if (fscanf(pFileO, "\t%d\t", &RecAction.NoOfAdds) == EOF) { printf("ERROR reading NoOfAdds"); break; } for (i=0; i<RecAction.NoOfAdds;i++) { BYTE Add[20]; RecAction.pAdd = WinsAllocMem( sizeof(WINSINTF_ADD_T) * RecAction.NoOfAdds);
for(i = 0; i < RecAction.NoOfAdds; i++) { if (fscanf(pFileO, "%s\t", Add) == EOF) { printf("ERROR reading Address"); break; } (RecAction.pAdd + i)->IPAdd = ntohl(inet_addr(Add)); (RecAction.pAdd + i)->Type = 0; (RecAction.pAdd + i)->Len = 4; } } } fscanf(pFileO, "\n"); } // end of while
printf("Name = (%s), TypeOfRec (%s)\n", RecAction.pName, RecAction.TypOfRec_e == WINSINTF_E_NORM_GROUP ? "NORMAL GROUP" : (RecAction.TypOfRec_e ==WINSINTF_E_SPEC_GROUP) ? "SPECIAL GROUP" : "MULTIHOMED"); if (RecAction.TypOfRec_e == WINSINTF_E_NORM_GROUP) { printf("NORM GRP: Address is %x\n", RecAction.Add.IPAdd); } else { for (i=0; i < RecAction.NoOfAdds; i++) { printf("%d -- Owner (%d) is (%p)\t", i, (RecAction.pAdd + i)->IPAdd); printf("%d -- Address (%d) is (%p)\n", ++i, (RecAction.pAdd + i)->IPAdd); }
} return(RetStat);}
DWORDGetDbRecsByName( PWINSINTF_ADD_T pWinsAdd, DWORD Location, LPBYTE pName, DWORD NameLen, DWORD NoOfRecsDesired, DWORD TypeOfRecs, BOOL fFilter, DWORD AddFilter ){ DWORD Status; WINSINTF_RECS_T Recs; DWORD TotalCnt = 0;
Recs.pRow = NULL; Status = WinsGetDbRecsByName(BindHdl, pWinsAdd, Location, pName, NameLen, NoOfRecsDesired, TypeOfRecs, &Recs); printf("Total number of records are (%d)\n", Recs.TotalNoOfRecs); if (Status == WINSINTF_SUCCESS) { if (Recs.NoOfRecs > 0) { DWORD i; PWINSINTF_RECORD_ACTION_T pRow = Recs.pRow; TotalCnt += Recs.NoOfRecs;
printf("Retrieved %d records\n", Recs.NoOfRecs); for (i=0; i<Recs.NoOfRecs; i++) {
printf("-----------------------\n"); printf("Name is (%s). 16th char is (%x)\nNameLen is (%d)\nType is (%s)\nState is (%s)\nVersion No is (%x %x)\nStatic flag is (%d)\nTimestamp is (%.19s)\n", pRow->pName, *(pRow->pName+15),pRow->NameLen, pRow->TypOfRec_e == WINSINTF_E_UNIQUE ? "UNIQUE" : (pRow->TypOfRec_e == WINSINTF_E_NORM_GROUP) ? "NORMAL GROUP" : (pRow->TypOfRec_e == WINSINTF_E_SPEC_GROUP) ? "SPECIAL GROUP" : "MULTIHOMED", pRow->State_e == WINSINTF_E_ACTIVE ? "ACTIVE" : (pRow->State_e == WINSINTF_E_RELEASED) ? "RELEASED" : "TOMBSTONE", pRow->VersNo.HighPart, pRow->VersNo.LowPart, pRow->fStatic, asctime(localtime(&(pRow->TimeStamp))));
ChkAdd( pRow, NULL, AddFilter, &fFilter );
printf("-----------------------\n"); pRow++;
} // end of for (all recs)
} else { printf("No records were retrieved\n");
} } if (Recs.pRow != NULL) { WinsFreeMem(Recs.pRow); } return(Status);}
VOIDUsage( VOID ){ CMD_E i; DWORD LastEntry = (fEnhMode ? LAST_ENTRY : LAST_PSS_ENTRY); printf("winscl {T or N} {CMD}\n"); printf("where\nT -- TCP/IP\nN -- Named Pipe\n"); printf("\n\nCMD is one of the following\n");
for (i = 0; i < (CMD_E)LastEntry; i++) { if (CommandSwitchList[i].SwitchName != NULL) { printf("%s or %s\n", CommandSwitchList[i].SwitchName, CommandSwitchList[i].ShortName); } } return;}
VOIDGetCmdCode( LPBYTE pCmd, PCMD_E pCmd_e ){ CMD_E Cmd_e; *pCmd_e = INVALID_VALUE;
for (Cmd_e = 0; Cmd_e < (fEnhMode ? LAST_ENTRY : LAST_PSS_ENTRY); Cmd_e++) { if (CommandSwitchList[Cmd_e].ShortName != NULL) { if (!_strcmpi(CommandSwitchList[Cmd_e].ShortName, pCmd) || !_strcmpi(CommandSwitchList[Cmd_e].SwitchName, pCmd) ) { *pCmd_e = CommandSwitchList[Cmd_e].SwitchValue; return;
} } } return;
}
#define PRADEEPB_PTM "157.55.80.183"
#define PRADEEPB_486 "157.55.80.182"
//#define RHINO1 PRADEEPB_PTM
//#define RHINO2 PRADEEPB_486
#define RHINO1 "157.55.80.151"
#define RHINO2 "157.55.80.152"
#define RED03NS "157.54.16.159"
VOIDsync(VOID){ handle_t BindHdl; WINSINTF_BIND_DATA_T BindData; PNAME_INFO pNameInfo, pSrvInfo; WINS_INFO WinsInfo; DWORD i, n, t, s; LPBYTE pWinsAdd = RHINO1; DWORD Status; PWINSINTF_RECORD_ACTION_T pSvRecAction = NULL; WINSINTF_RECORD_ACTION_T RecAction; PWINSINTF_RECORD_ACTION_T pRecAction; PWINSINTF_RECORD_ACTION_T pOutRecAction; BOOL fAtLeastOneFound; DWORD NoOfNames, NoOfSrvNames;
if(!ReadNameFile( &pNameInfo, &NoOfNames, "nmfl.txt")) { return; } if(!ReadNameFile( &pSrvInfo, &NoOfSrvNames, "winss.txt")) { return; } WinsInfo.NoOfOwners = NoOfSrvNames; for (i = 0; i < NoOfSrvNames; i++) { strcpy(WinsInfo.Maps[i].asIpAdd, pSrvInfo->Name); WinsInfo.Maps[i].fCommFail = FALSE; WinsInfo.Maps[i].fNameNotFound = FALSE; fprintf(spDbgFile, "WINS server (%d) is (%s)\n", i, WinsInfo.Maps[i].asIpAdd); pSrvInfo++;
}
i = 0;#if 0
do { if (!BindToWins(pWinsAdd, &BindData, &BindHdl)) { fprintf(spDbgFile, "Unable to bind to %s\n", pWinsAdd); return; } fprintf(spDbgFile, "Connected to WINS = (%s)\n", pWinsAdd); //
// Get WINS server info
//
WinsInfo.NoOfOwners = 0;
i++; if (GetWinsInfo(&WinsInfo) != WINSINTF_SUCCESS) { fprintf(spDbgFile, "Comm. Failure with %s\n", pWinsAdd); if (i < 2) { pWinsAdd = RHINO2; } } else { i = 2; } WinsUnbind(&BindData, BindHdl); } while (i < 2);#endif
//
// Loop over all names read in. Query the name from all WINSs that
// we have in our list of WINS owners that we got from RHINO1
//
for (i = 0; (pNameInfo->Name[0] != 0) && (i < NoOfNames); i++, pNameInfo++) {
DWORD LChar; CHAR Name[50]; BOOL fStored; for (s=0; s<2;s++) { LChar = (s==0) ? 0x20 : 0x0;
RecAction.Cmd_e = WINSINTF_E_QUERY;
strcpy(Name, pNameInfo->Name); GetFullName(Name, LChar, &RecAction);
pRecAction = &RecAction;
//
// For a name, loop over all WINS owners
//
fStored = FALSE; fAtLeastOneFound = FALSE; for (n = 0; n < NoOfSrvNames; n++) { DWORD OwnIdOfName;
#if 0
if ( !_strcmpi(WinsInfo.Maps[n].asIpAdd, RHINO1) || !_strcmpi(WinsInfo.Maps[n].asIpAdd, RHINO2) || !_strcmpi(WinsInfo.Maps[n].asIpAdd, RED03NS) )#endif
fprintf(spDbgFile, "BINDING TO WINS = (%s)\n", WinsInfo.Maps[n].asIpAdd); {
//
// Bind to the WINS
//
if (!BindToWins(WinsInfo.Maps[n].asIpAdd, &BindData, &BindHdl)) { fprintf(spDbgFile, "FAILED BINDING\n"); continue; // go on to the next one
}
//
// Query Wins for the name
//
pRecAction = &RecAction; if ((Status = QueryWins(Name, pRecAction, &pOutRecAction)) == NAME_NOT_FOUND) { fprintf(spDbgFile2, "DID NOT FIND NAME = (%s[%x]) in Wins = (%s) db\n", Name, Name[15], WinsInfo.Maps[n].asIpAdd); WinsInfo.Maps[n].fNameNotFound = TRUE; WinsInfo.Maps[n].fCommFail = FALSE; } else { if ( Status == SUCCESS) { fprintf(spDbgFile, "FOUND name = (%s[%x]) in Wins = (%s) db\n", Name, Name[15], WinsInfo.Maps[n].asIpAdd); fAtLeastOneFound = TRUE; if (!fStored) { fStored = TRUE; pSvRecAction = pOutRecAction; } else { WinsFreeMem(pOutRecAction); } WinsInfo.Maps[n].fCommFail = FALSE; WinsInfo.Maps[n].fNameNotFound = FALSE; } else { WinsInfo.Maps[n].fCommFail = TRUE; } } WinsUnbind(&BindData, BindHdl); }#if 0
else { WinsInfo.Maps[n].fCommFail = TRUE; }#endif
}
//#if 0
for (t = 0; t < WinsInfo.NoOfOwners && fAtLeastOneFound; t++) { if (!WinsInfo.Maps[t].fCommFail && WinsInfo.Maps[t].fNameNotFound) { if(BindToWins(WinsInfo.Maps[t].asIpAdd, &BindData, &BindHdl)) { StoreName(pSvRecAction, RecAction.pName); WinsUnbind(&BindData, BindHdl); } } else { continue; } }//#endif
if (RecAction.pName != NULL) { WinsFreeMem(RecAction.pName); RecAction.pName = NULL; } if (pSvRecAction) { WinsFreeMem(pSvRecAction); pSvRecAction = NULL; } } }
fclose(spDbgFile); fclose(spDbgFile2); return;}
VOIDStoreName( PWINSINTF_RECORD_ACTION_T pRecAction, LPBYTE pName ){
DWORD Status; DWORD i;
(void)strncpy(pRecAction->pName, pName, 16); pRecAction->NameLen = 16; pRecAction->Cmd_e = WINSINTF_E_INSERT; if ((pRecAction->TypOfRec_e == WINSINTF_E_SPEC_GROUP) || (pRecAction->TypOfRec_e == WINSINTF_E_MULTIHOMED)) { for (i = 0; i < pRecAction->NoOfAdds; i++) { *(pRecAction->pAdd + i) = *(pRecAction->pAdd + i + 1); i++; } pRecAction->NoOfAdds = pRecAction->NoOfAdds/2; }
fprintf(spDbgFile2, "StoreName:STORING name %s[%x]\n", pRecAction->pName, pRecAction->pName[15]); Status = WinsRecordAction(BindHdl, &pRecAction); fprintf(spDbgFile2, "StoreName:Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); WinsFreeMem(pRecAction); return;}
DWORDQueryWins ( LPBYTE pName, PWINSINTF_RECORD_ACTION_T pRecAction, PWINSINTF_RECORD_ACTION_T *ppRecAct){ DWORD RetStat; struct in_addr InAddr; DWORD i; DWORD Status;
Status = WinsRecordAction(BindHdl, &pRecAction); fprintf(spDbgFile, "Status returned is (%s - %d)\n", Status == 0 ? "SUCCESS" : "FAILURE", Status); if (Status == WINSINTF_SUCCESS) { *ppRecAct = pRecAction; fprintf(spDbgFile, "Name=(%s)\nNodeType=(%d)\nState=(%s)\nTimeStamp=(%.19s)\nOwnerId=(%d)\nType Of Rec=(%s)\nVersion No (%x %x)\nRecord is (%s)\n", pRecAction->pName, pRecAction->NodeTyp, pRecAction->State_e == WINSINTF_E_ACTIVE ? "ACTIVE" : (pRecAction->State_e == WINSINTF_E_RELEASED) ? "RELEASED" : "TOMBSTONE", asctime(localtime(&(pRecAction->TimeStamp))), pRecAction->OwnerId, (pRecAction->TypOfRec_e == WINSINTF_E_UNIQUE) ? "UNIQUE" : (pRecAction->TypOfRec_e == WINSINTF_E_NORM_GROUP) ? "NORMAL GROUP" :(pRecAction->TypOfRec_e == WINSINTF_E_SPEC_GROUP) ? "SPECIAL GROUP" : "MULTIHOMED",
pRecAction->VersNo.HighPart, pRecAction->VersNo.LowPart, pRecAction->fStatic ? "STATIC" : "DYNAMIC" ); if ( (pRecAction->TypOfRec_e == WINSINTF_E_UNIQUE) || (pRecAction->TypOfRec_e == WINSINTF_E_NORM_GROUP) ) {
InAddr.s_addr = htonl(pRecAction->Add.IPAdd); fprintf(spDbgFile, "Address is (%s)\n", inet_ntoa(InAddr)); } else { for (i=0; i<pRecAction->NoOfAdds; ) { InAddr.s_addr = htonl((pRecAction->pAdd +i++)->IPAdd); fprintf(spDbgFile, "Owner is (%s); ", inet_ntoa(InAddr)); InAddr.s_addr = htonl((pRecAction->pAdd + i++)->IPAdd); fprintf(spDbgFile, "Member is (%s)\n", inet_ntoa(InAddr)); } }
RetStat = SUCCESS; } else { if (Status == ERROR_REC_NON_EXISTENT) { fprintf(spDbgFile, "No such name in the db\n"); RetStat = NAME_NOT_FOUND; } else { fprintf(spDbgFile, "Status is (%x)\n", Status); RetStat = FAILURE; } } return RetStat;}
handle_tWinsABind( PWINSINTF_BIND_DATA_T pBindData );BOOLBindToWins( LPBYTE asIpAdd, PWINSINTF_BIND_DATA_T pBindData, handle_t *pBindHdl ){
pBindData->pServerAdd = asIpAdd; pBindData->fTcpIp = TRUE;
*pBindHdl = WinsABind(pBindData); if (pBindHdl == NULL) { fprintf(spDbgFile, "Unable to bind to %s \n", asIpAdd); return (FALSE); } return(TRUE);}
BOOLReadNameFile( PNAME_INFO *ppFileInfo, LPDWORD pNoOfNames, LPBYTE pNameOfFile){ FILE *pFile; struct _stat Stat; PNAME_INFO pFileInfo; DWORD SizeAlloc; *pNoOfNames = 0; if((pFile = fopen(pNameOfFile, "r")) == NULL) { return FALSE; }
if (_stat(pNameOfFile, &Stat) == -1) { return FALSE; } SizeAlloc = Stat.st_size + Stat.st_size/15 * sizeof(NAME_INFO); if (!(pFileInfo = malloc(SizeAlloc))) { return FALSE; } else { fprintf(spDbgFile, "Allocated %d bytes\n", SizeAlloc); } *ppFileInfo = pFileInfo;
memset(pFileInfo, 0, SizeAlloc); //
// Read in names
//
while(fscanf(pFile, "%s\n", pFileInfo->Name) != EOF) { fprintf(spDbgFile, "Name is %s\n", pFileInfo->Name); (*pNoOfNames)++; pFileInfo++; } return(TRUE);}
STATUSGetWinsInfo( PWINS_INFO pWinsInfo){ DWORD Status; WINSINTF_RESULTS_NEW_T Results; PWINSINTF_RESULTS_NEW_T pResultsN = &Results; DWORD NoOfOwners; struct in_addr InAddr; DWORD i, n; PWINSINTF_ADD_VERS_MAP_T pAddVersMaps;
Results.WinsStat.NoOfPnrs = 0; Results.WinsStat.pRplPnrs = NULL;
Results.pAddVersMaps = NULL; Status = WinsStatusNew(BindHdl, WINSINTF_E_CONFIG_ALL_MAPS, pResultsN); if (Status == WINSINTF_SUCCESS) { pAddVersMaps = pResultsN->pAddVersMaps;
if (pResultsN->NoOfOwners != 0) { for (n=0, i= 0; i < pResultsN->NoOfOwners; i++, pAddVersMaps++) { InAddr.s_addr = htonl( pAddVersMaps->Add.IPAdd);
if ( (pAddVersMaps->VersNo.HighPart == MAXLONG) && (pAddVersMaps->VersNo.LowPart == MAXULONG) ) { continue; } if (pAddVersMaps->VersNo.QuadPart == 0) { continue; } fprintf(spDbgFile,"%d\t\t%s\t\t", i, inet_ntoa(InAddr));
fprintf(spDbgFile, "%lu %lu\n", pAddVersMaps->VersNo.HighPart, pAddVersMaps->VersNo.LowPart );
pWinsInfo->Maps[n].OwnId = i; strcpy(pWinsInfo->Maps[n].asIpAdd,inet_ntoa(InAddr)); pWinsInfo->Maps[n].VersNo = pAddVersMaps->VersNo; n++; } pWinsInfo->NoOfOwners = n; //pResultsN->NoOfOwners;
WinsFreeMem(pResultsN->pAddVersMaps); } else { fprintf(spDbgFile, "The Db is empty\n"); } } else { pWinsInfo->NoOfOwners = 0; } return Status;}
VOIDGetFullName( LPBYTE pName, DWORD SChar, PWINSINTF_RECORD_ACTION_T pRecAction ){ size_t Len;
pRecAction->pAdd = NULL; pRecAction->NoOfAdds = 0;
if ((Len = strlen(pName)) < 16) { memset(pName + Len, (int)' ',16-Len); *(pName + 15) = (BYTE)(SChar & 0xff); *(pName + 16) = (CHAR)NULL; Len = 16; } else { *(pName + Len) = (CHAR)NULL; }
pRecAction->pName = WinsAllocMem(Len); (void)memcpy(pRecAction->pName, pName, Len); pRecAction->NameLen = Len; return;}
|
