home *** CD-ROM | disk | FTP | other *** search
/ Hall of Fame / HallofFameCDROM.cdr / lant / wt4lan.arc / WAIT4LAN.C < prev    next >
C/C++ Source or Header  |  1991-04-23  |  9KB  |  368 lines
  1. /*****************************************************************************
  2. * WAIT4LAN is designed to make it easier to start up a peer network where
  3. * the machines on the network log into each other's drives.  WAIT4LAN
  4. * waits for the server software to be loaded on each of the other machines
  5. * on the network before it exits.  In this way it is possible to
  6. * make sure all of the machines are in "sync" before continuing the
  7. * AUTOEXEC.BAT files.
  8. *
  9. * WAIT4LAN has been tested on LANtastic networks.  It should work
  10. * on other NetBIOS based peer networks.
  11. *
  12. * 
  13. * The syntax for WAIT4LAN is:
  14. * 
  15. *      WAIT4LAN [-waittime] node1 [node2 ...]
  16. * 
  17. * where:
  18. * 
  19. *      waittime is the number of seconds WAIT4LAN will wait before
  20. *      giving up (default is 180 seconds).
  21. * 
  22. *      node1, node2, ... are the names of the other servers on the 
  23. *      network ("node1" is the name assigned by the server software 
  24. *      when it is loaded).
  25. * 
  26. * 
  27. * WAIT4LAN returns an errorlevel of 0 if all of the nodes are active,
  28. * an errorlevel of 1 if one or more are inactive after the waittime
  29. * as elapsed.
  30. * 
  31. * 
  32. * The program is fully protected by copyright and all rights are 
  33. * reserved.  This program is distributed as "POSTware".  If you 
  34. * find the program useful please send a post card to:
  35. *
  36. *     Ken Brown
  37. *     5707 Jamestown Rd Apt 2
  38. *     Hyattsville, MD  20782
  39. *
  40. * No registration is required.
  41. * 
  42. * 
  43. * 
  44. *****************************************************************************/
  45.  
  46. #include <stdio.h>
  47. #include <stdlib.h>
  48. #include <string.h>
  49. #include <malloc.h>
  50. #include <dos.h>
  51.  
  52.  
  53. #define TRUE      1
  54. #define FALSE     0
  55.  
  56. #define EOS       '\0'
  57.  
  58. #define ADAPTER_STATUS  0x33
  59.  
  60.  
  61. /* NetBIOS data structure */
  62.  
  63. struct NCB {
  64.    char Command;
  65.    char RetCode;
  66.    char Lsn;
  67.    char Num;
  68.    char far *Buffer;
  69.    int  Length;
  70.    char CallName[16];
  71.    char Name[16];
  72.    char Rto;
  73.    char Sto;
  74.    void (far *Post)();
  75.    char LanaNum;
  76.    char CmdCplt;
  77.    char Reserved[14];
  78.    };
  79.  
  80.  
  81.  
  82. struct NODE_LIST {
  83.    char  *NodeName;
  84.    int   ActiveStatusFlag;
  85.    };
  86.  
  87.  
  88. /* Global variables */
  89.  
  90. struct NODE_LIST NodeList[16];
  91. struct NCB Ncb;
  92.  
  93. char  ProgramName[14],
  94.       AdapterStatusBuffer[512];
  95.  
  96.  
  97. main(int argc, char *argv[])
  98. {
  99.    int   NodeCounter,
  100.          InactiveNodeCount,
  101.          Counter,
  102.          WaitTime,
  103.          KeyPressed;
  104.    char  *WaitPtr,
  105.          *StrPtr;
  106.    long  StartTime,
  107.          CurrentTime,
  108.          EndTime;
  109.    char  far *NetBiosInterrupt;
  110.  
  111.  
  112.    if(_osmajor < 3) {
  113.       printf("\nDOS 3.0 or later required\n");
  114.       exit(1);
  115.       }
  116.    else {
  117.       StrPtr = strrchr(argv[0],'\\');
  118.       if(StrPtr == NULL) {
  119.          strcpy(ProgramName,argv[0]);
  120.          }
  121.       else {
  122.          StrPtr++;
  123.          strcpy(ProgramName,StrPtr);
  124.          }
  125.       StrPtr = strchr(ProgramName,'.');
  126.       if(StrPtr != NULL) {
  127.          *StrPtr = EOS;
  128.          }
  129.       }
  130.  
  131.    printf("%s v1.0 (10/7/89)  Copyright 1989, Ken Brown\n",ProgramName);
  132.    printf("Startup utility for LANtastic networks\n");
  133.  
  134.    if(argc == 1) {
  135.       usage();
  136.       }
  137.  
  138.    WaitTime = -1;
  139.  
  140.  
  141.    /* Check that interrupt 5C is nonzero, if so assume that NetBios
  142.       is loaded */
  143.  
  144.    NetBiosInterrupt = _dos_getvect(0x5C);
  145.  
  146.    if(NetBiosInterrupt == NULL) {
  147.       printf("\nNetBIOS not loaded\n");
  148.       exit(1);
  149.       }
  150.  
  151.  
  152.    /* Parse the command line arguements */
  153.    NodeCounter = 0;
  154.  
  155.    for(Counter = 1; Counter < argc; Counter++) {
  156.       if(*argv[Counter] == '-') {
  157.             if(WaitTime > 0) {
  158.                 usage();
  159.                 }
  160.          WaitPtr = argv[Counter];
  161.          WaitPtr++;
  162.          if(*WaitPtr < '0' || *WaitPtr > '9') {
  163.             usage();
  164.             }
  165.          WaitTime = atoi(WaitPtr);
  166.          continue;
  167.          }
  168.       StrPtr = argv[Counter];
  169.       while(*StrPtr == '\\' && *StrPtr != EOS) {
  170.          StrPtr++;
  171.          }
  172.       if(*StrPtr == EOS) {
  173.          continue;
  174.          }
  175.       if((NodeList[NodeCounter].NodeName = strdup(StrPtr)) == NULL) {
  176.          printf("\nOut of memory, can not continue\n");
  177.          exit(1);
  178.          }
  179.       NodeList[NodeCounter].ActiveStatusFlag = FALSE;
  180.       NodeCounter += 1;
  181.       if(NodeCounter >= 16) {
  182.          printf("\nWarning, a maximun of 16 nodes may be checked\n");
  183.          NodeCounter = 16;
  184.          break;
  185.          }
  186.       }
  187.  
  188.    /* The default wait time is 180 seconds (3 minutes), if WaitTime
  189.       has not been set assume the default */
  190.  
  191.    if(WaitTime < 0) {
  192.       WaitTime = 180;
  193.       }
  194.  
  195.    InactiveNodeCount = NodeCounter;
  196.  
  197.    printf("\nChecking status of the following nodes\n");
  198.    for(Counter = 0; Counter < NodeCounter; Counter++) {
  199.       strupr(NodeList[Counter].NodeName);
  200.       printf("\t%s\n",NodeList[Counter].NodeName);
  201.       }
  202.  
  203.    printf("\nProgram will wait up to %d seconds, press ESC to exit early\n\n",WaitTime);
  204.  
  205.    /* Start the timer */
  206.  
  207.    time(&StartTime);
  208.    CurrentTime = StartTime;
  209.    EndTime = StartTime + (long)WaitTime;
  210.  
  211.  
  212.    /* Until the timer counts down and while there are still
  213.       inactive nodes, keep looping and checking */
  214.  
  215.    while(CurrentTime < EndTime && InactiveNodeCount > 0) {
  216.  
  217.       for(Counter = 0; Counter < NodeCounter; Counter++) {
  218.  
  219.          if(NodeList[Counter].ActiveStatusFlag == FALSE) {
  220.             printf("Checking %s, ",NodeList[Counter].NodeName);
  221.  
  222.             if(kbhit() != 0) {
  223.                KeyPressed = getch();
  224.                if(KeyPressed == 27) {
  225.                   printf("\n%s cancelled\n\n",ProgramName);
  226.                   exit(1);
  227.                   }
  228.                }
  229.  
  230.             /* Check to see it the node is active (by doing a
  231.                status check for the network adapter) */
  232.  
  233.             if(CheckNodeStatus(NodeList[Counter].NodeName) == TRUE) {
  234.                /* If CheckNodeStatus() returns TRUE change the
  235.                   node status and decrement the InactiveNodeCount */
  236.                NodeList[Counter].ActiveStatusFlag = TRUE;
  237.                InactiveNodeCount -= 1;
  238.                printf("node is active\n");
  239.                }
  240.             else {
  241.                printf("node is not active\n");
  242.                }
  243.             }
  244.          }
  245.       /* Wait a couple of seconds before starting over */
  246.       if(InactiveNodeCount > 0) {
  247.          Sleep(2);
  248.          }
  249.       time(&CurrentTime);
  250.       }
  251.  
  252.  
  253.    /* If the count is zero, we found all of the nodes, if not
  254.       we timed out waiting for one or more nodes which never
  255.       came on line */
  256.  
  257.    if(InactiveNodeCount == 0) {
  258.       exit(0);
  259.       }
  260.    else {
  261.       printf("\n\nThe following nodes are inactive:\n");
  262.       for(Counter = 0; Counter < NodeCounter; Counter++) {
  263.          if(NodeList[Counter].ActiveStatusFlag == FALSE) {
  264.             printf("\t%s\n",NodeList[Counter].NodeName);
  265.             }
  266.          }
  267.       printf("\n");
  268.       exit(1);
  269.       }
  270.  
  271. }
  272.  
  273.  
  274. usage()
  275. {
  276.    printf("\nSyntax: %s [-waittime] node1 [node2 ...]\n",ProgramName);
  277.    exit(1);
  278. }
  279.  
  280. Sleep(int Seconds)
  281. {
  282.    int   KeyPressed;
  283.    long  StartTime,
  284.          CurrentTime,
  285.          EndTime;
  286.  
  287.    time(&StartTime);
  288.    CurrentTime = StartTime;
  289.    EndTime = StartTime + (long)Seconds;
  290.  
  291.    while(CurrentTime < EndTime) {
  292.       if(kbhit() != 0) {
  293.          KeyPressed = getch();
  294.          if(KeyPressed == 27) {
  295.             printf("\n%s cancelled\n\n",ProgramName);
  296.             exit(1);
  297.             }
  298.          }
  299.       time(&CurrentTime);
  300.       }
  301.  
  302. }
  303.  
  304.  
  305. /* CheckNodeStatus() does a NetBIOS "Check Adapter Status" call
  306.    to see if a node is active.  Because the name used is the
  307.    name which is loaded into the name table by the server software,
  308.    the check will fail until after the server software loads
  309.    on the node in question. */
  310.  
  311. CheckNodeStatus(char *NodeName)
  312. {
  313.    union REGS inregs, outregs;
  314.  
  315.    struct SREGS sregs;
  316.  
  317.    segread(&sregs);
  318.    sregs.es = sregs.ds;
  319.  
  320.     ClearNCB(&Ncb);
  321.     Ncb.Command = ADAPTER_STATUS;
  322.     Ncb.Buffer = (char far *)AdapterStatusBuffer;
  323.     memset(AdapterStatusBuffer,'\0',512);
  324.     Ncb.Length = 512;
  325.     if(NodeName == NULL) {
  326.         memcpy(Ncb.CallName,"****************",16);
  327.         }
  328.     else {
  329.         memcpy(Ncb.CallName,NodeName,strlen(NodeName));
  330.         }
  331.  
  332.     inregs.x.bx = &Ncb;
  333.    int86x(0x5C,&inregs,&outregs,&sregs);
  334.  
  335.  
  336.    /* A RetCode of 0 means that the Adapter Status call succeeded,
  337.       any thing else means it failed */
  338.  
  339.     switch (Ncb.RetCode) {
  340.         case 0:
  341.          return TRUE;
  342.             break;
  343.         default:
  344.          return FALSE;
  345.             break;
  346.         }
  347.  
  348. }
  349.  
  350. ClearNCB(struct NCB *NcbPtr)
  351. {
  352.     NcbPtr->Command = 0;
  353.     NcbPtr->RetCode = 0xFF;
  354.     NcbPtr->Lsn = 0;
  355.     NcbPtr->Num = 0;
  356.     NcbPtr->Buffer = NULL;
  357.     NcbPtr->Length = 0;
  358.     NcbPtr->Rto = 0;
  359.     NcbPtr->Sto = 0;
  360.     NcbPtr->Post = NULL;
  361.     NcbPtr->LanaNum = 0;
  362.     NcbPtr->CmdCplt = 0;
  363.     memset(NcbPtr->CallName,' ',16);
  364.     memset(NcbPtr->Name,' ',16);
  365.     memset(NcbPtr->Reserved,'\0',14);
  366. }
  367.  
  368.