host/c%2B%2B/Host.cpp

#include <iostream.h>
#include <unistd.h> // linux header for the sleep function
#include <stdlib.h> // itoa()
#include <time.h>
#include "SysMon.h"
// #include "Config.h" - redefinition error - turns out i don't need it
#ifndef  XMLFORMATTER_H         /* Has the file been INCLUDE'd already? */
    #define  XMLFORMATTER_H  yes
    #include "XMLFormatter.h"
#endif

using std::string;

int main(){
        
        // list of local variables
        int noErrors = 1;
        int reloadConfig = 0;
        
        // print some extra info..
        int debug = 0;
        
        // create a new connection with the Config Host
        // values hard coded for the moment
        std::cout << "C Host starting..\n";
        
        std::cout << "Attemping to load config\n";
        Config config("raptor.ukc.ac.uk",4567,debug);           // host, port, debug (0/1)
        
        std::cout << "Creating data collector\n";
        SysMon sysMon(config, debug);
        
        std::cout << "Configuring UDPUpdateTime\n";
        int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
        if (  UDPUpdateTime == -1 ){
                if ( debug == 1 ){
                        std::cout << "Using Default time!\n";
                        UDPUpdateTime = 5;
                } // if
        } // if
                        
                        
        std::cout << "Configuring TCPUpdateTime\n";
        int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
        if ( TCPUpdateTime  == -1){
                if ( debug == 1 ){
                        std::cout << "Using Default time!\n";
                        TCPUpdateTime = 10;
                } // if
        } // if
        
        std::cout << "Configuring AveragerUpdateTime\n";
        int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
        if ( AveragerUpdateTime == -1){
                if ( debug == 1 ){
                        std::cout << "Using Default time!\n";
                } // if
                AveragerUpdateTime = 2;
        } // if
        
        std::cout << "Configuring Filter Retry Tolerances\n";
        int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
        if ( MaxFilterRetrys == -1){
                if ( debug == 1 ){
                        std::cout << "Using Default Tolerance\n";
                } // if
                MaxFilterRetrys = 5;
        } // if
        
        
        std::cout << "Configuring Alerter\n";
        // Set the values at which the Alerter should kick in. and how many packets it should
        // send
        
        // now do the data collection
        
        std::cout << "Starting Data Collection\n";
        // work out which is closer, the next heartbeat or the next data collection
        long localTime = time(NULL);
        // std::cout << "#";
        int nextUDPTime = localTime + UDPUpdateTime;
        int nextAveragerTime = localTime + AveragerUpdateTime;
        int nextTCPTime = localTime + TCPUpdateTime;
        long sequence = 0;
                
        int nextAction = 0;
        while ( noErrors == 1){
                // firstly check we haven't got to reload our config
                if ( reloadConfig == 1 ){
                        // reload the config by starting a new
                        std::cout << "Forcing reload of Configuration\n";
                        config = Config("raptor.ukc.ac.uk",4567,debug);
                        
                        std::cout << "Configuring UDPUpdateTime\n";
                        int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
                        if (  UDPUpdateTime == -1 ){
                                if ( debug == 1 ){
                                        std::cout << "Using Default time!\n";
                                        UDPUpdateTime = 5;
                                } // if
                        } // if
                                        
                                        
                        std::cout << "Configuring TCPUpdateTime\n";
                        int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
                        if ( TCPUpdateTime  == -1){
                                if ( debug == 1 ){
                                        std::cout << "Using Default time!\n";
                                        TCPUpdateTime = 10;
                                } // if
                        } // if
                        
                        std::cout << "Configuring AveragerUpdateTime\n";
                        int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
                        if ( AveragerUpdateTime == -1){
                                if ( debug == 1 ){
                                        std::cout << "Using Default time!\n";
                                } // if
                                AveragerUpdateTime = 2;
                        } // if
                        
                        std::cout << "Configuring Filter Retry Tolerances\n";
                        int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
                        if ( MaxFilterRetrys == -1){
                                if ( debug == 1 ){
                                        std::cout << "Using Default Tolerance\n";
                                } // if
                                MaxFilterRetrys = 5;
                        } // if
                        
                } // if reloadconfig
                
                
                localTime = time(NULL);
                //  std::cout << ".";
                // keep going while no non-fatal errors have occurred
                int waitTime = 0;
                
                if ( nextTCPTime  <= nextAveragerTime ){
                        // std::cout << "-";
                        if ( nextTCPTime >= nextUDPTime ){
                                // std::cout << "}";
                                nextAction = 3;
                                waitTime = nextUDPTime - localTime;
                        } else {
                                // set the heartbeat to be the next item
                                // std::cout << "{";
                                nextAction = 1;
                                waitTime = nextTCPTime - localTime;
                        } // if
                } else {
                        // std::cout << "+";
                        if ( nextAveragerTime >=  nextUDPTime ){
                                // std::cout << "[";
                                nextAction = 3;
                                waitTime = nextUDPTime - localTime;
                        } else {
                                // set grabstats to be in the next action
                                // std::cout << "]";
                                nextAction = 2;
                                waitTime = nextAveragerTime - localTime;
                        } // if
                } // if
                
                // sleep until this time only if it is greater than 1!
                if ( waitTime >= 1 ){
                        // need to output \n to std::cout or the wait is infinate!!!! ?????
                        // will core dump if debug = 0
                        sleep(waitTime); /// crashes here
                        
                } 
                
                
                localTime = time(NULL);
                int con = -1;
                int conCount = 0;
                
                // do the action
                switch (nextAction){
                        case 1: std::cout << "Scheduled TCP Heartbeat Connection" << endl; 
                                nextTCPTime = localTime + TCPUpdateTime; 
                                // connect to the filter - should do all the talking within config.
                                con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());                             
                                conCount = 0;
                                while (( con != 0 ) && ( conCount < MaxFilterRetrys )){
                                        int con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());                          
                                        conCount++;
                                }
                                // if con != 0, then we must reconnect to the main filter manager and 
                                // reload our config!
                                if ( con == 0 ){
                                        // run the chat script
                                        int result = config.chatHeartBeat();
                                        if ( result != 0 ){
                                                // gotta reload our config
                                                reloadConfig = 1;
                                        } // if
                                } else {
                                        // set the config to be reloaded next time
                                        reloadConfig = 1;
                                } // if con =!= 0
                                
                                break;
                        case 2: nextAveragerTime = localTime + AveragerUpdateTime; 
                                if ( sysMon.collect() > 0 ){
                                        // suggests that there should be an alert
                                        std::cout << "Alert Status" << endl;                                    
                                }
                                break;
                        default: std::cout << "Scheduled UDP Connection" << endl; 
                                 nextUDPTime = localTime + UDPUpdateTime; 
                                 // package up the system data
                                 string host = (config.getSmallNet())->getHostName();
                                 string ip = (config.getSmallNet())->getHostIP();
                                 
                                 char * buffer;
                                 buffer = l64a( sequence );
                                 char * seq = buffer;
                                 buffer = l64a( localTime );
                                 char * date = buffer;
                                 
                                                                                                 
                                 string attributes = "type=\"data\" machine_name=\""+host+"\" ip=\""+ip+"\" date=\""+date+"\" seq_no=\""+seq+"\"";

                                 XMLFormatter xml("packet",attributes);
                                 // put in the data
                                 xml.addString(sysMon.getData());
                                 (config.getSmallNet())->sendUPDPacket(config.getUDPFilterName(), config.getUDPFilterPort(), xml.returnXML());
                                 
                                 break;
                } // switch
                
        } // while
        
        std::cout << "A fatal error occurred which caused this program to quit\n";
        std::cout << "It is suggested that all belly button lint should be removed\n";
        std::cout << "prior to use of this program\n";
        std::cout << "Oh and BTW, All you BASE are belong to us!\n";
        std::cout << "Error Code: " << noErrors << "\n";
        
        return 0;
        
} // main
Revision:	1.2
Committed:	Mon Mar 5 12:40:32 2001 UTC (23 years, 8 months ago) by ab11
Branch:	MAIN
Changes since 1.1:	+121 -34 lines
Log Message:	Added support for Heartbeats - still sending incorrect date and sequence due to l64a function doing something silly
#	User	Rev	Content
1	ab11	1.1	#include <iostream.h>
2			#include <unistd.h> // linux header for the sleep function
3	ab11	1.2	#include <stdlib.h> // itoa()
4	ab11	1.1	#include <time.h>
5			#include "SysMon.h"
6			// #include "Config.h" - redefinition error - turns out i don't need it
7			#ifndef XMLFORMATTER_H /* Has the file been INCLUDE'd already? */
8			#define XMLFORMATTER_H yes
9			#include "XMLFormatter.h"
10			#endif
11
12			using std::string;
13
14			int main(){
15
16			// list of local variables
17			int noErrors = 1;
18	ab11	1.2	int reloadConfig = 0;
19	ab11	1.1
20			// print some extra info..
21			int debug = 0;
22
23			// create a new connection with the Config Host
24			// values hard coded for the moment
25			std::cout << "C Host starting..\n";
26
27			std::cout << "Attemping to load config\n";
28	ab11	1.2	Config config("raptor.ukc.ac.uk",4567,debug); // host, port, debug (0/1)
29	ab11	1.1
30			std::cout << "Creating data collector\n";
31			SysMon sysMon(config, debug);
32
33			std::cout << "Configuring UDPUpdateTime\n";
34			int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
35			if ( UDPUpdateTime == -1 ){
36			if ( debug == 1 ){
37			std::cout << "Using Default time!\n";
38			UDPUpdateTime = 5;
39			} // if
40			} // if
41
42	ab11	1.2
43	ab11	1.1	std::cout << "Configuring TCPUpdateTime\n";
44			int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
45			if ( TCPUpdateTime == -1){
46			if ( debug == 1 ){
47			std::cout << "Using Default time!\n";
48			TCPUpdateTime = 10;
49			} // if
50			} // if
51
52			std::cout << "Configuring AveragerUpdateTime\n";
53			int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
54			if ( AveragerUpdateTime == -1){
55			if ( debug == 1 ){
56			std::cout << "Using Default time!\n";
57			} // if
58			AveragerUpdateTime = 2;
59			} // if
60
61	ab11	1.2	std::cout << "Configuring Filter Retry Tolerances\n";
62			int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
63			if ( MaxFilterRetrys == -1){
64			if ( debug == 1 ){
65			std::cout << "Using Default Tolerance\n";
66			} // if
67			MaxFilterRetrys = 5;
68			} // if
69
70
71	ab11	1.1	std::cout << "Configuring Alerter\n";
72			// Set the values at which the Alerter should kick in. and how many packets it should
73			// send
74
75			// now do the data collection
76
77	ab11	1.2	std::cout << "Starting Data Collection\n";
78	ab11	1.1	// work out which is closer, the next heartbeat or the next data collection
79	ab11	1.2	long localTime = time(NULL);
80			// std::cout << "#";
81	ab11	1.1	int nextUDPTime = localTime + UDPUpdateTime;
82			int nextAveragerTime = localTime + AveragerUpdateTime;
83			int nextTCPTime = localTime + TCPUpdateTime;
84	ab11	1.2	long sequence = 0;
85
86	ab11	1.1	int nextAction = 0;
87			while ( noErrors == 1){
88	ab11	1.2	// firstly check we haven't got to reload our config
89			if ( reloadConfig == 1 ){
90			// reload the config by starting a new
91			std::cout << "Forcing reload of Configuration\n";
92			config = Config("raptor.ukc.ac.uk",4567,debug);
93
94			std::cout << "Configuring UDPUpdateTime\n";
95			int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
96			if ( UDPUpdateTime == -1 ){
97			if ( debug == 1 ){
98			std::cout << "Using Default time!\n";
99			UDPUpdateTime = 5;
100			} // if
101			} // if
102
103
104			std::cout << "Configuring TCPUpdateTime\n";
105			int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
106			if ( TCPUpdateTime == -1){
107			if ( debug == 1 ){
108			std::cout << "Using Default time!\n";
109			TCPUpdateTime = 10;
110			} // if
111			} // if
112
113			std::cout << "Configuring AveragerUpdateTime\n";
114			int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
115			if ( AveragerUpdateTime == -1){
116			if ( debug == 1 ){
117			std::cout << "Using Default time!\n";
118			} // if
119			AveragerUpdateTime = 2;
120			} // if
121
122			std::cout << "Configuring Filter Retry Tolerances\n";
123			int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
124			if ( MaxFilterRetrys == -1){
125			if ( debug == 1 ){
126			std::cout << "Using Default Tolerance\n";
127			} // if
128			MaxFilterRetrys = 5;
129			} // if
130
131			} // if reloadconfig
132
133
134			localTime = time(NULL);
135			// std::cout << ".";
136	ab11	1.1	// keep going while no non-fatal errors have occurred
137			int waitTime = 0;
138
139			if ( nextTCPTime <= nextAveragerTime ){
140	ab11	1.2	// std::cout << "-";
141	ab11	1.1	if ( nextTCPTime >= nextUDPTime ){
142	ab11	1.2	// std::cout << "}";
143	ab11	1.1	nextAction = 3;
144	ab11	1.2	waitTime = nextUDPTime - localTime;
145	ab11	1.1	} else {
146			// set the heartbeat to be the next item
147	ab11	1.2	// std::cout << "{";
148	ab11	1.1	nextAction = 1;
149	ab11	1.2	waitTime = nextTCPTime - localTime;
150	ab11	1.1	} // if
151			} else {
152	ab11	1.2	// std::cout << "+";
153	ab11	1.1	if ( nextAveragerTime >= nextUDPTime ){
154	ab11	1.2	// std::cout << "[";
155	ab11	1.1	nextAction = 3;
156	ab11	1.2	waitTime = nextUDPTime - localTime;
157	ab11	1.1	} else {
158			// set grabstats to be in the next action
159	ab11	1.2	// std::cout << "]";
160	ab11	1.1	nextAction = 2;
161	ab11	1.2	waitTime = nextAveragerTime - localTime;
162	ab11	1.1	} // if
163			} // if
164
165			// sleep until this time only if it is greater than 1!
166			if ( waitTime >= 1 ){
167			// need to output \n to std::cout or the wait is infinate!!!! ?????
168	ab11	1.2	// will core dump if debug = 0
169	ab11	1.1	sleep(waitTime); /// crashes here
170	ab11	1.2
171	ab11	1.1	}
172
173	ab11	1.2
174	ab11	1.1	localTime = time(NULL);
175	ab11	1.2	int con = -1;
176			int conCount = 0;
177
178	ab11	1.1	// do the action
179			switch (nextAction){
180	ab11	1.2	case 1: std::cout << "Scheduled TCP Heartbeat Connection" << endl;
181	ab11	1.1	nextTCPTime = localTime + TCPUpdateTime;
182	ab11	1.2	// connect to the filter - should do all the talking within config.
183			con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());
184			conCount = 0;
185			while (( con != 0 ) && ( conCount < MaxFilterRetrys )){
186			int con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());
187			conCount++;
188			}
189			// if con != 0, then we must reconnect to the main filter manager and
190			// reload our config!
191			if ( con == 0 ){
192			// run the chat script
193			int result = config.chatHeartBeat();
194			if ( result != 0 ){
195			// gotta reload our config
196			reloadConfig = 1;
197			} // if
198			} else {
199			// set the config to be reloaded next time
200			reloadConfig = 1;
201			} // if con =!= 0
202
203	ab11	1.1	break;
204	ab11	1.2	case 2: nextAveragerTime = localTime + AveragerUpdateTime;
205	ab11	1.1	if ( sysMon.collect() > 0 ){
206			// suggests that there should be an alert
207	ab11	1.2	std::cout << "Alert Status" << endl;
208	ab11	1.1	}
209			break;
210	ab11	1.2	default: std::cout << "Scheduled UDP Connection" << endl;
211	ab11	1.1	nextUDPTime = localTime + UDPUpdateTime;
212			// package up the system data
213	ab11	1.2	string host = (config.getSmallNet())->getHostName();
214			string ip = (config.getSmallNet())->getHostIP();
215
216			char * buffer;
217			buffer = l64a( sequence );
218			char * seq = buffer;
219			buffer = l64a( localTime );
220			char * date = buffer;
221
222
223			string attributes = "type=\"data\" machine_name=\""+host+"\" ip=\""+ip+"\" date=\""+date+"\" seq_no=\""+seq+"\"";
224	ab11	1.1
225			XMLFormatter xml("packet",attributes);
226			// put in the data
227			xml.addString(sysMon.getData());
228			(config.getSmallNet())->sendUPDPacket(config.getUDPFilterName(), config.getUDPFilterPort(), xml.returnXML());
229
230			break;
231			} // switch
232
233			} // while
234
235			std::cout << "A fatal error occurred which caused this program to quit\n";
236			std::cout << "It is suggested that all belly button lint should be removed\n";
237	ab11	1.2	std::cout << "prior to use of this program\n";
238			std::cout << "Oh and BTW, All you BASE are belong to us!\n";
239	ab11	1.1	std::cout << "Error Code: " << noErrors << "\n";
240
241			return 0;
242
243			} // main