//============================================================================ // 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 #include #include #include #include //#include #include #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" STATIC VOID GetNameInfo( PWINSINTF_RECORD_ACTION_T pRecAction, WINSINTF_ACT_E Cmd_e ); STATIC VOID GetFilterName( LPBYTE pStr, LPDWORD pLen ); STATIC DWORD GetStatus( BOOL fPrint, LPVOID pResults, BOOL fNew, BOOL fShort ); VOID ChkAdd( PWINSINTF_RECORD_ACTION_T pRow, FILE *pFile, DWORD Add, LPBOOL pfMatch ); STATIC VOID WantFile( FILE **ppFile ); STATIC DWORD GetDbRecs( 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 ); STATIC DWORD GetDbRecsByName( PWINSINTF_ADD_T pWinsAdd, DWORD Location, LPBYTE pName, DWORD NameLen, DWORD NoOfRecsDesired, DWORD TypeOfRecs, BOOL fFilter, DWORD AddFilter ) ; WINSINTF_VERS_NO_T sTmpVersNo; STATIC DWORD CreateFiles( PWINSINTF_RECS_T pRecs, PWINSINTF_ADD_T pWinsAdd, FILE *pFileU, FILE *pFileO ); STATIC DWORD InitFromFile( VOID ); VOID Usage( VOID ); typedef enum _CMD_E *PCMD_E; VOID GetCmdCode( 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 #include 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; STATUS GetWinsInfo( PWINS_INFO pWinsInfo ); VOID sync( VOID ); VOID GetFullName( LPBYTE pName, DWORD SChar, PWINSINTF_RECORD_ACTION_T pRecAction ); BOOL ReadNameFile( PNAME_INFO *ppFileInfo, LPDWORD pNoOfNames, LPBYTE pNameOfFile ); BOOL BindToWins( LPBYTE asIpAdd, PWINSINTF_BIND_DATA_T pBindData, handle_t *pBindHdl ); #define SUCCESS 0 #define NAME_NOT_FOUND 1 #define FAILURE 2 DWORD QueryWins ( LPBYTE pName, PWINSINTF_RECORD_ACTION_T pRecAction, PWINSINTF_RECORD_ACTION_T *ppRecAction ); VOID StoreName( PWINSINTF_RECORD_ACTION_T pRecAction, LPBYTE pName ); ///////////////// _cdecl main(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)); //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); 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; iNoOfAdds; ) { 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 ( -- "); scanf("%d %d", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No ( -- "); 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 ( or <0 0> for all -- "); scanf("%lx %lx", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No ( 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 ( -- "); scanf("%d %d", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No ( -- "); 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 ( -- "); scanf("%d %d", &MinVersNo.HighPart, &MinVersNo.LowPart); printf("Max. Vers. No ( -- "); 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); } VOID GetNameInfo( 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; } VOID GetFilterName( 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; } DWORD GetStatus( 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); } DWORD GetDbRecs( 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; ipName, 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 VOID ChkAdd( 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; } } } } VOID WantFile( 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; } DWORD CreateFiles( 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; iNameLen; i++) { fprintf(pFileU, "%c", *(pRow->pName + i)); } fprintf(pFileU, "\n"); } else { fprintf(pFileO, "%d\t", pRow->NameLen); for (i=0; iNameLen; 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; iNoOfAdds; 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); } DWORD InitFromFile( 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;iIPAdd = 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); } DWORD GetDbRecsByName( 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; ipName, *(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); } VOID Usage( 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; } VOID GetCmdCode( 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" VOID sync(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; } VOID StoreName( 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; } DWORD QueryWins ( 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; iNoOfAdds; ) { 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_t WinsABind( PWINSINTF_BIND_DATA_T pBindData ); BOOL BindToWins( 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); } BOOL ReadNameFile( 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); } STATUS GetWinsInfo( 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; } VOID GetFullName( 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; }