source/ihost/ihost.c

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <netinet/in.h>
#include "ukcprog.h"
#include <netdb.h>
#include <strings.h>
#include "statgrab.h"

#define RECONFIGURE_RETURN_CODE 2
#define UDP_MAX_PACKET_SIZE 8192

typedef struct{
        int fm_port;
        char *fm_host;
        
        char *my_fqdn;
        char *server_fqdn;
        int server_udp_port;
        int server_tcp_port;
        char *last_modified;
        char *files_list;
        char *key;
        int udp_update_time;
        int tcp_update_time;

}ihost_state_t;

char* sock_comm(FILE *f_r, FILE *f_w, char *sendString){
        char *reply;
        fprintf(f_w, "%s\n", sendString);
        fflush(f_w);
        reply=fpgetline(f_r);
        /* Returns pointer to static buffer */
        return reply;
}       

int ihost_configure(ihost_state_t *ihost_state){
        struct sockaddr_in addr;
        struct in_addr haddr;
        int sd;
        FILE *fm_fd_r, *fm_fd_w;
        char *reply;
        char *reply_ptr;

        /* Check to see if anything needs to be free'd */
        if (ihost_state->my_fqdn!=NULL) free(ihost_state->my_fqdn);
        if (ihost_state->server_fqdn!=NULL) free(ihost_state->server_fqdn);
        if (ihost_state->last_modified!=NULL) free(ihost_state->last_modified);
        if (ihost_state->files_list!=NULL) free(ihost_state->files_list);

        if ((sd = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
                errf("Can't create AF_INET socket (%m)");
                return -1;
        }

        if (get_host_addr(ihost_state->fm_host, &haddr) != 0){
                errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
                return -1;
        }

        memset(&addr, 0, sizeof addr);
        addr.sin_family = AF_INET;
        memcpy(&addr.sin_addr, &haddr, sizeof haddr);
        addr.sin_port =  htons(ihost_state->fm_port);

        if (connect(sd, (struct sockaddr *)&addr, sizeof addr) != 0) {
                errf("Failed to connect to %s on port %d (%m)", ihost_state->fm_host, ihost_state->fm_port);
                return -1;
        }

        /* Need to open 2 files, one for reading one for writing, as it gets confused if we only use 1 :) */
        if ((fm_fd_r=fdopen(sd,"r")) == NULL){
                errf("Failed to open read stream (%m)");
                return -1;
        }

        if ((fm_fd_w=fdopen(dup(sd),"w")) == NULL){
                errf("Failed to open write stream (%m)");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "STARTCONFIG");
        if ((reply==NULL) || (strncasecmp(reply, "OK", 2) != 0) ) {
                errf("Server error");   
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "LASTMODIFIED");
        if((reply== NULL) || (strncasecmp(reply, "ERROR", 5) ==0)){
                errf("Server error (%m)");
                return -1;
        }
        if((ihost_state->last_modified=strdup(reply)) == NULL){
                errf("strdup failed (%m)");
                return -1;
        }
        
        reply=sock_comm(fm_fd_r, fm_fd_w, "FILELIST");
        if((reply== NULL) || (strncasecmp(reply, "ERROR", 5) ==0)){
                errf("Server error (%m)");
                return -1;
        }
        if((ihost_state->files_list=strdup(reply)) == NULL){
                errf("strdup failed (%m)");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "FQDN");
        if((reply== NULL) || (strncasecmp(reply, "ERROR", 5)==0)){
                errf("Server error (%m)");
                return -1;
        }
        if((ihost_state->my_fqdn=strdup(reply)) == NULL){
                errf("strdup failed (%m)");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "UDPUpdateTime");
        if(reply== NULL){
                errf("Server error (%m)");
                return -1;
        }
        if (strncasecmp(reply, "ERROR", 5) != 0){
                ihost_state->udp_update_time=atoi(reply);
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "TCPUpdateTime");
        if(reply== NULL){
                errf("Server error (%m)");
                return -1;
        }
        if (strncasecmp(reply, "ERROR", 5) != 0){
                ihost_state->tcp_update_time=atoi(reply);
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "ENDCONFIG");
        if(reply== NULL){
                errf("Server error (%m)");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "FILTER");
        if((reply== NULL) || (strncasecmp(reply, "ERROR", 5)==0)){
                errf("Server error FILTER failed (%m)");
                return -1;
        }
        reply_ptr=strchr(reply,';');
        if (reply_ptr==NULL){
                errf("Incorrect data returned");
                return -1;
        }
        *reply_ptr='\0';
        if((ihost_state->server_fqdn=strdup(reply)) == NULL){
                errf("strdup failed (%m)");
                return -1;
        }
        reply=reply_ptr + 1;
        reply_ptr=strchr(reply,';');
        if (reply_ptr==NULL){
                errf("Incorrect data returned 2");
                return -1;
        }
        *reply_ptr='\0';
        ihost_state->server_udp_port=atoi(reply);
        reply=reply_ptr+1;
        ihost_state->server_tcp_port=atoi(reply);
        if ((ihost_state->server_tcp_port==0) || (ihost_state->server_udp_port==0)){
                errf("Incorrect data returned 3 ");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "END");
        if((reply== NULL) || (strncasecmp(reply, "ERROR", 5) ==0 )){
                errf("Server error (%m)");
                return -1;
        }

        if(fclose(fm_fd_r) !=0){
                errf("Failed to close read FD (%m)");
                return -1;
        }
        if(fclose(fm_fd_w) !=0){
                errf("Failed to close write FD (%m)");
                return -1;
        }

        return 0;
}

int heartbeat(ihost_state_t *ihost_state){
        struct sockaddr_in addr;
        struct in_addr haddr;
        int sd;
        FILE *fm_fd_r, *fm_fd_w;
        char *reply;
        int exitcode=0;

        if ((sd = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
                errf("Can't create AF_INET socket (%m)");
                return -1;
        }

        if (get_host_addr(ihost_state->server_fqdn, &haddr) != 0){
                errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
                return -1;
        }

        memset(&addr, 0, sizeof addr);
        addr.sin_family = AF_INET;
        memcpy(&addr.sin_addr, &haddr, sizeof haddr);
        addr.sin_port =  htons(ihost_state->server_tcp_port);

        if (connect(sd, (struct sockaddr *)&addr, sizeof addr) != 0) {
                errf("Failed to connect to %s on port %d (%m)", ihost_state->fm_host, ihost_state->fm_port);
                return -1;
        }

        /* Need to open 2 files, one for reading one for writing, as it gets confused if we only use 1 :) */
        if ((fm_fd_r=fdopen(sd,"r")) == NULL){
                errf("Failed to open stream (%m)");
                return -1;
        }

        if ((fm_fd_w=fdopen(dup(sd),"w")) == NULL){
                errf("Failed to open stream (%m)");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "HEARTBEAT");
        if ((reply==NULL) || (strncasecmp(reply, "ERROR", 5) == 0) ) {
                errf("Server error");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "CONFIG");
        if ((reply==NULL) || (strncasecmp(reply, "ERROR", 5) == 0) ) {
                errf("Server error");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, ihost_state->files_list);
        if ((reply==NULL) || (strncasecmp(reply, "OK", 2) != 0) ) {
                errf("Server error");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, ihost_state->last_modified);
        if (reply==NULL) {
                errf("Server error");
                return -1;
        }
        if (strncasecmp(reply, "ERROR", 5) == 0){
        /* Means the config has changed */
                exitcode=RECONFIGURE_RETURN_CODE;
        }
        reply=sock_comm(fm_fd_r, fm_fd_w, "KEY");
        if ((reply==NULL) || (strncasecmp(reply, "ERROR", 5) == 0) ) {
                errf("Server error");
                return -1;
        }
        if (ihost_state->key!=NULL) free(ihost_state->key);
 
        if((ihost_state->key=strdup(reply)) == NULL){
                errf("strdup failed (%m)");
                return -1;
        }

        reply=sock_comm(fm_fd_r, fm_fd_w, "ENDHEARTBEAT");
        if((reply== NULL) || (strncasecmp(reply, "ERROR", 5) ==0 )){
                errf("Server error (%m)");
                return -1;
        }

        if(fclose(fm_fd_r) !=0){
                errf("Failed to close read FD (%m)");
                return -1;
        }
        if(fclose(fm_fd_w) !=0){
                errf("Failed to close write FD (%m)");
                return -1;
        }

        return exitcode;                
}

char *stat_grab(ihost_state_t *ihost_state, int counter){
#define NUM_STATS 9
        char *stats[NUM_STATS];
        char *xml_data=NULL;
        char *xml_data_p;
        int x=0;
        
        stats[0]=get_cpu_stats();
        stats[1]=get_disk_stats();
        stats[2]=get_load_stats();      
        stats[3]=get_memory_stats();
        stats[4]=get_os_info();
        stats[5]=get_page_stats();
        stats[6]=get_process_stats();
        stats[7]=get_swap_stats();
        stats[8]=get_user_stats();

        for(;x<NUM_STATS;x++){
                if(stats[x]==NULL){
                        return NULL;
                }
                if(xml_data==NULL){
                        if((xml_data=strf("%s", stats[x])) == NULL){
                                errf("str failed (%m)");
                                return NULL;
                        }
                }else{
                        xml_data_p=xml_data;
                        if((xml_data=strf("%s%s", xml_data, stats[x])) == NULL){
                                errf("str failed (%m)");
                                return NULL;
                        }
                        free(xml_data_p);
                }
                free(stats[x]);
        }
        xml_data_p=xml_data;
        xml_data=strf("<packet seq_no=\"%d\" machine_name=\"%s\" date=\"%ld\" type=\"data\" ip=\"%s\" key=\"%s\">%s</packet>", counter, ihost_state->my_fqdn, time(NULL), "127.0.0.1", ihost_state->key, xml_data);
        free(xml_data_p); 
        
        return xml_data;
}

int send_stats(ihost_state_t *ihost_state, char *data_stream){
        struct sockaddr_in addr;
        struct in_addr haddr;

        int sd;
        size_t len;

        len=strlen(data_stream);
        if(len>UDP_MAX_PACKET_SIZE){
                errf("Too big to send to server. Please reconfigure client and server and recompile");
                exit(1);
        }
        
        if (get_host_addr(ihost_state->server_fqdn, &haddr) != 0){
                errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
                return -1;
        }

        if((sd=socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
                errf("failed to create UDP socket (%m)");
                return -1;
        }

        memset(&addr, 0, sizeof(addr));
        addr.sin_family=AF_INET;
        memcpy((char *)&addr.sin_addr, &haddr, sizeof haddr);
        addr.sin_port =  htons(ihost_state->server_udp_port);

        if((sendto(sd, data_stream, len, 0, (struct sockaddr *) &addr, sizeof(addr))) != len){
                errf("Send the wrong number of bytes (%m)");
                return -1;
        }

        return 0;       
}

int main(int argc, char **argv){
        ihost_state_t ihost_state;
        int heartbeat_exit;
        int counter=0;
        long udp_time=0, tcp_time=0, cur_time=0;
        int sleep_delay=0;
        char *xml_stats;

        /* NULL'ify so i can tell if i need to free it or not */
        ihost_state.fm_host=NULL;
        ihost_state.my_fqdn=NULL;
        ihost_state.server_fqdn=NULL;
        ihost_state.last_modified=NULL;
        ihost_state.files_list=NULL;
        ihost_state.key=NULL;

        errf_set_progname(argv[0]);
        if(argc!=3){
                errf_usage("<host> <port>");    
                exit(1);
        }

        ihost_state.fm_host=argv[1];
        ihost_state.fm_port=atoi(argv[2]);

        if(ihost_configure(&ihost_state)!=0){
                errf("configure failed");
                /* Ok, ideally we prob should have 2 copies of the structure and carry on if this
                happens.. But we dont :) (at the moment) */
                exit(1);
        }

        /* get starting stats */        
        if((heartbeat(&ihost_state)) == -1){
                errf("inital heartbeat failed (%m)");
                exit(1);
        }

        
        if((xml_stats=stat_grab(&ihost_state, counter)) == NULL){
                errf("Failed to get stats (%m)");
                exit(1);
        }


        for(;;){
                cur_time=time(NULL);
                if(cur_time>=tcp_time){
                        heartbeat_exit=heartbeat(&ihost_state);
                        if(heartbeat_exit==RECONFIGURE_RETURN_CODE){
                                errf("heartbeat needs to be reconfigured");
                                ihost_configure(&ihost_state);
                                /* So udp doesn't wait til next sending before updating */
                                udp_time=0;
                        }
                        if(heartbeat_exit==-1){
                                errf("ah crap");
                                exit(1);
                        }
                        tcp_time=time(NULL)+ihost_state.tcp_update_time;
                }
                if(cur_time>=udp_time){
                        send_stats(&ihost_state, xml_stats);
                        free(xml_stats);
                        if((xml_stats=stat_grab(&ihost_state, counter)) == NULL){
                                errf("Failed to get stats (%m)");
                                exit(1);
                        }
                        udp_time=time(NULL)+ihost_state.udp_update_time;
                }
                if(tcp_time>udp_time){
                        sleep_delay=time(NULL)-tcp_time;
                }else{
                        sleep_delay=time(NULL)-udp_time;
                }
                sleep(sleep_delay);
        }
        return 0;
}

Revision:	1.9
Committed:	Fri May 17 11:21:17 2002 UTC (22 years ago) by pajs
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+132 -20 lines
Log Message:	Now basic working version. Only tested on solaris.
#	User	Rev	Content
1	pajs	1.1	#include <stdio.h>
2			#include <sys/socket.h>
3			#include <stdlib.h>
4			#include <unistd.h>
5			#include <syslog.h>
6			#include <netinet/in.h>
7	pajs	1.9	#include "ukcprog.h"
8	pajs	1.1	#include <netdb.h>
9			#include <strings.h>
10	pajs	1.9	#include "statgrab.h"
11	pajs	1.1
12	pajs	1.4	#define RECONFIGURE_RETURN_CODE 2
13	pajs	1.9	#define UDP_MAX_PACKET_SIZE 8192
14	pajs	1.4
15	pajs	1.1	typedef struct{
16			int fm_port;
17			char *fm_host;
18
19			char *my_fqdn;
20			char *server_fqdn;
21			int server_udp_port;
22			int server_tcp_port;
23	pajs	1.4	char *last_modified;
24	pajs	1.1	char *files_list;
25			char *key;
26			int udp_update_time;
27			int tcp_update_time;
28
29			}ihost_state_t;
30
31	pajs	1.7	char* sock_comm(FILE f_r, FILE f_w, char *sendString){
32	pajs	1.1	char *reply;
33	pajs	1.7	fprintf(f_w, "%s\n", sendString);
34	pajs	1.2	fflush(f_w);
35			reply=fpgetline(f_r);
36	pajs	1.1	/* Returns pointer to static buffer */
37			return reply;
38			}
39
40			int ihost_configure(ihost_state_t *ihost_state){
41			struct sockaddr_in addr;
42			struct in_addr haddr;
43			int sd;
44	pajs	1.2	FILE fm_fd_r, fm_fd_w;
45	pajs	1.1	char *reply;
46	pajs	1.2	char *reply_ptr;
47	pajs	1.1
48	pajs	1.5	/* Check to see if anything needs to be free'd */
49			if (ihost_state->my_fqdn!=NULL) free(ihost_state->my_fqdn);
50			if (ihost_state->server_fqdn!=NULL) free(ihost_state->server_fqdn);
51			if (ihost_state->last_modified!=NULL) free(ihost_state->last_modified);
52			if (ihost_state->files_list!=NULL) free(ihost_state->files_list);
53
54	pajs	1.1	if ((sd = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
55			errf("Can't create AF_INET socket (%m)");
56			return -1;
57			}
58
59			if (get_host_addr(ihost_state->fm_host, &haddr) != 0){
60			errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
61			return -1;
62			}
63
64	pajs	1.9	memset(&addr, 0, sizeof addr);
65	pajs	1.1	addr.sin_family = AF_INET;
66	pajs	1.9	memcpy(&addr.sin_addr, &haddr, sizeof haddr);
67	pajs	1.1	addr.sin_port = htons(ihost_state->fm_port);
68
69			if (connect(sd, (struct sockaddr *)&addr, sizeof addr) != 0) {
70			errf("Failed to connect to %s on port %d (%m)", ihost_state->fm_host, ihost_state->fm_port);
71			return -1;
72			}
73
74	pajs	1.2	/* Need to open 2 files, one for reading one for writing, as it gets confused if we only use 1 :) */
75			if ((fm_fd_r=fdopen(sd,"r")) == NULL){
76	pajs	1.8	errf("Failed to open read stream (%m)");
77	pajs	1.2	return -1;
78			}
79
80			if ((fm_fd_w=fdopen(dup(sd),"w")) == NULL){
81	pajs	1.8	errf("Failed to open write stream (%m)");
82	pajs	1.1	return -1;
83			}
84	pajs	1.2
85	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "STARTCONFIG");
86	pajs	1.1	if ((reply==NULL) \|\| (strncasecmp(reply, "OK", 2) != 0) ) {
87			errf("Server error");
88			return -1;
89			}
90
91	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "LASTMODIFIED");
92	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0)){
93	pajs	1.1	errf("Server error (%m)");
94			return -1;
95			}
96	pajs	1.7	if((ihost_state->last_modified=strdup(reply)) == NULL){
97			errf("strdup failed (%m)");
98	pajs	1.4	return -1;
99			}
100	pajs	1.1
101	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "FILELIST");
102	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0)){
103	pajs	1.1	errf("Server error (%m)");
104			return -1;
105			}
106	pajs	1.7	if((ihost_state->files_list=strdup(reply)) == NULL){
107			errf("strdup failed (%m)");
108	pajs	1.6	return -1;
109			}
110	pajs	1.1
111	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "FQDN");
112	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5)==0)){
113	pajs	1.1	errf("Server error (%m)");
114			return -1;
115			}
116			if((ihost_state->my_fqdn=strdup(reply)) == NULL){
117			errf("strdup failed (%m)");
118			return -1;
119			}
120
121	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "UDPUpdateTime");
122	pajs	1.1	if(reply== NULL){
123			errf("Server error (%m)");
124			return -1;
125			}
126			if (strncasecmp(reply, "ERROR", 5) != 0){
127			ihost_state->udp_update_time=atoi(reply);
128			}
129
130	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "TCPUpdateTime");
131	pajs	1.1	if(reply== NULL){
132			errf("Server error (%m)");
133			return -1;
134			}
135			if (strncasecmp(reply, "ERROR", 5) != 0){
136			ihost_state->tcp_update_time=atoi(reply);
137			}
138
139	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "ENDCONFIG");
140	pajs	1.1	if(reply== NULL){
141			errf("Server error (%m)");
142			return -1;
143			}
144
145	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "FILTER");
146	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5)==0)){
147	pajs	1.9	errf("Server error FILTER failed (%m)");
148	pajs	1.2	return -1;
149			}
150			reply_ptr=strchr(reply,';');
151			if (reply_ptr==NULL){
152			errf("Incorrect data returned");
153			return -1;
154			}
155			*reply_ptr='\0';
156			if((ihost_state->server_fqdn=strdup(reply)) == NULL){
157			errf("strdup failed (%m)");
158			return -1;
159			}
160	pajs	1.8	reply=reply_ptr + 1;
161	pajs	1.2	reply_ptr=strchr(reply,';');
162			if (reply_ptr==NULL){
163			errf("Incorrect data returned 2");
164			return -1;
165			}
166			*reply_ptr='\0';
167			ihost_state->server_udp_port=atoi(reply);
168	pajs	1.8	reply=reply_ptr+1;
169	pajs	1.2	ihost_state->server_tcp_port=atoi(reply);
170			if ((ihost_state->server_tcp_port==0) \|\| (ihost_state->server_udp_port==0)){
171			errf("Incorrect data returned 3 ");
172			return -1;
173			}
174
175	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "END");
176	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0 )){
177			errf("Server error (%m)");
178			return -1;
179			}
180	pajs	1.1
181	pajs	1.2	if(fclose(fm_fd_r) !=0){
182	pajs	1.8	errf("Failed to close read FD (%m)");
183	pajs	1.2	return -1;
184			}
185			if(fclose(fm_fd_w) !=0){
186	pajs	1.8	errf("Failed to close write FD (%m)");
187	pajs	1.2	return -1;
188			}
189	pajs	1.1
190			return 0;
191			}
192	pajs	1.4
193			int heartbeat(ihost_state_t *ihost_state){
194			struct sockaddr_in addr;
195			struct in_addr haddr;
196			int sd;
197			FILE fm_fd_r, fm_fd_w;
198			char *reply;
199			int exitcode=0;
200
201			if ((sd = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
202			errf("Can't create AF_INET socket (%m)");
203			return -1;
204			}
205
206			if (get_host_addr(ihost_state->server_fqdn, &haddr) != 0){
207			errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
208			return -1;
209			}
210
211	pajs	1.9	memset(&addr, 0, sizeof addr);
212	pajs	1.4	addr.sin_family = AF_INET;
213	pajs	1.9	memcpy(&addr.sin_addr, &haddr, sizeof haddr);
214	pajs	1.4	addr.sin_port = htons(ihost_state->server_tcp_port);
215
216			if (connect(sd, (struct sockaddr *)&addr, sizeof addr) != 0) {
217			errf("Failed to connect to %s on port %d (%m)", ihost_state->fm_host, ihost_state->fm_port);
218			return -1;
219			}
220
221			/* Need to open 2 files, one for reading one for writing, as it gets confused if we only use 1 :) */
222			if ((fm_fd_r=fdopen(sd,"r")) == NULL){
223			errf("Failed to open stream (%m)");
224			return -1;
225			}
226
227			if ((fm_fd_w=fdopen(dup(sd),"w")) == NULL){
228			errf("Failed to open stream (%m)");
229			return -1;
230			}
231
232	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "HEARTBEAT");
233	pajs	1.6	if ((reply==NULL) \|\| (strncasecmp(reply, "ERROR", 5) == 0) ) {
234	pajs	1.4	errf("Server error");
235			return -1;
236			}
237	pajs	1.9
238	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "CONFIG");
239	pajs	1.6	if ((reply==NULL) \|\| (strncasecmp(reply, "ERROR", 5) == 0) ) {
240	pajs	1.4	errf("Server error");
241			return -1;
242			}
243
244			reply=sock_comm(fm_fd_r, fm_fd_w, ihost_state->files_list);
245			if ((reply==NULL) \|\| (strncasecmp(reply, "OK", 2) != 0) ) {
246			errf("Server error");
247			return -1;
248			}
249
250			reply=sock_comm(fm_fd_r, fm_fd_w, ihost_state->last_modified);
251			if (reply==NULL) {
252			errf("Server error");
253			return -1;
254			}
255	pajs	1.6	if (strncasecmp(reply, "ERROR", 5) == 0){
256	pajs	1.4	/* Means the config has changed */
257			exitcode=RECONFIGURE_RETURN_CODE;
258			}
259	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "KEY");
260	pajs	1.6	if ((reply==NULL) \|\| (strncasecmp(reply, "ERROR", 5) == 0) ) {
261	pajs	1.4	errf("Server error");
262			return -1;
263			}
264	pajs	1.5	if (ihost_state->key!=NULL) free(ihost_state->key);
265
266	pajs	1.7	if((ihost_state->key=strdup(reply)) == NULL){
267			errf("strdup failed (%m)");
268	pajs	1.4	return -1;
269			}
270
271	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "ENDHEARTBEAT");
272	pajs	1.4	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0 )){
273			errf("Server error (%m)");
274			return -1;
275			}
276
277	pajs	1.6	if(fclose(fm_fd_r) !=0){
278	pajs	1.8	errf("Failed to close read FD (%m)");
279	pajs	1.6	return -1;
280			}
281			if(fclose(fm_fd_w) !=0){
282	pajs	1.8	errf("Failed to close write FD (%m)");
283	pajs	1.6	return -1;
284			}
285
286	pajs	1.4	return exitcode;
287			}
288
289	pajs	1.9	char stat_grab(ihost_state_t ihost_state, int counter){
290			#define NUM_STATS 9
291			char *stats[NUM_STATS];
292			char *xml_data=NULL;
293			char *xml_data_p;
294			int x=0;
295
296			stats[0]=get_cpu_stats();
297			stats[1]=get_disk_stats();
298			stats[2]=get_load_stats();
299			stats[3]=get_memory_stats();
300			stats[4]=get_os_info();
301			stats[5]=get_page_stats();
302			stats[6]=get_process_stats();
303			stats[7]=get_swap_stats();
304			stats[8]=get_user_stats();
305
306			for(;x<NUM_STATS;x++){
307			if(stats[x]==NULL){
308			return NULL;
309			}
310			if(xml_data==NULL){
311			if((xml_data=strf("%s", stats[x])) == NULL){
312			errf("str failed (%m)");
313			return NULL;
314			}
315			}else{
316			xml_data_p=xml_data;
317			if((xml_data=strf("%s%s", xml_data, stats[x])) == NULL){
318			errf("str failed (%m)");
319			return NULL;
320			}
321			free(xml_data_p);
322			}
323			free(stats[x]);
324			}
325			xml_data_p=xml_data;
326			xml_data=strf("<packet seq_no=\"%d\" machine_name=\"%s\" date=\"%ld\" type=\"data\" ip=\"%s\" key=\"%s\">%s</packet>", counter, ihost_state->my_fqdn, time(NULL), "127.0.0.1", ihost_state->key, xml_data);
327			free(xml_data_p);
328
329			return xml_data;
330			}
331
332			int send_stats(ihost_state_t ihost_state, char data_stream){
333			struct sockaddr_in addr;
334			struct in_addr haddr;
335
336			int sd;
337			size_t len;
338
339			len=strlen(data_stream);
340			if(len>UDP_MAX_PACKET_SIZE){
341			errf("Too big to send to server. Please reconfigure client and server and recompile");
342			exit(1);
343			}
344
345			if (get_host_addr(ihost_state->server_fqdn, &haddr) != 0){
346			errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
347			return -1;
348			}
349
350			if((sd=socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
351			errf("failed to create UDP socket (%m)");
352			return -1;
353			}
354
355			memset(&addr, 0, sizeof(addr));
356			addr.sin_family=AF_INET;
357			memcpy((char *)&addr.sin_addr, &haddr, sizeof haddr);
358			addr.sin_port = htons(ihost_state->server_udp_port);
359
360			if((sendto(sd, data_stream, len, 0, (struct sockaddr *) &addr, sizeof(addr))) != len){
361			errf("Send the wrong number of bytes (%m)");
362			return -1;
363			}
364
365			return 0;
366			}
367	pajs	1.1
368	pajs	1.3	int main(int argc, char **argv){
369	pajs	1.2	ihost_state_t ihost_state;
370	pajs	1.6	int heartbeat_exit;
371			int counter=0;
372	pajs	1.9	long udp_time=0, tcp_time=0, cur_time=0;
373			int sleep_delay=0;
374			char *xml_stats;
375	pajs	1.5
376			/* NULL'ify so i can tell if i need to free it or not */
377			ihost_state.fm_host=NULL;
378			ihost_state.my_fqdn=NULL;
379			ihost_state.server_fqdn=NULL;
380			ihost_state.last_modified=NULL;
381			ihost_state.files_list=NULL;
382			ihost_state.key=NULL;
383
384	pajs	1.3	errf_set_progname(argv[0]);
385			if(argc!=3){
386			errf_usage("<host> <port>");
387			exit(1);
388			}
389	pajs	1.2
390	pajs	1.3	ihost_state.fm_host=argv[1];
391			ihost_state.fm_port=atoi(argv[2]);
392	pajs	1.2
393			if(ihost_configure(&ihost_state)!=0){
394			errf("configure failed");
395	pajs	1.6	/* Ok, ideally we prob should have 2 copies of the structure and carry on if this
396			happens.. But we dont :) (at the moment) */
397			exit(1);
398	pajs	1.2	}
399	pajs	1.5
400	pajs	1.9	/* get starting stats */
401			if((heartbeat(&ihost_state)) == -1){
402			errf("inital heartbeat failed (%m)");
403			exit(1);
404			}
405	pajs	1.1
406	pajs	1.9
407			if((xml_stats=stat_grab(&ihost_state, counter)) == NULL){
408			errf("Failed to get stats (%m)");
409			exit(1);
410			}
411
412
413			for(;;){
414			cur_time=time(NULL);
415			if(cur_time>=tcp_time){
416			heartbeat_exit=heartbeat(&ihost_state);
417			if(heartbeat_exit==RECONFIGURE_RETURN_CODE){
418			errf("heartbeat needs to be reconfigured");
419			ihost_configure(&ihost_state);
420			/* So udp doesn't wait til next sending before updating */
421			udp_time=0;
422			}
423			if(heartbeat_exit==-1){
424			errf("ah crap");
425			exit(1);
426			}
427			tcp_time=time(NULL)+ihost_state.tcp_update_time;
428			}
429			if(cur_time>=udp_time){
430			send_stats(&ihost_state, xml_stats);
431			free(xml_stats);
432			if((xml_stats=stat_grab(&ihost_state, counter)) == NULL){
433			errf("Failed to get stats (%m)");
434			exit(1);
435			}
436			udp_time=time(NULL)+ihost_state.udp_update_time;
437			}
438			if(tcp_time>udp_time){
439			sleep_delay=time(NULL)-tcp_time;
440			}else{
441			sleep_delay=time(NULL)-udp_time;
442	pajs	1.6	}
443	pajs	1.9	sleep(sleep_delay);
444	pajs	1.6	}
445	pajs	1.1	return 0;
446			}
447