source/ihost/ihost.c

/* 
 * i-scream central monitoring system
 * Copyright (C) 2000-2002 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <netinet/in.h>
#include "ukcprog.h"
#include <netdb.h>
#include <string.h>
#include "statgrab.h"
#include <time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define versionNo 0.8
#define RECONFIGURE_RETURN_CODE 2
#define UDP_MAX_PACKET_SIZE 8192

typedef struct{
        int fm_port;
        char *fm_host;

        char *my_ip;    
        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;
        struct sockaddr ip;
        int ip_len;
        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;
        }
        ip_len=sizeof ip;
        memset(&ip, 0, ip_len);
        if((getsockname(sd, &ip, &ip_len)) != 0){
                errf("Failed to get IP address (%m)");
                return -1;
        }
        if (ip.sa_family!=AF_INET){
                errf("sa family is wrong type");
                return -1;
        }
        
        if((ihost_state->my_ip=inet_ntoa(((struct sockaddr_in *)&ip)->sin_addr))==NULL){
                errf("Failed to get IP (%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;
        }

        fflush(fm_fd_r);
        fflush(fm_fd_w);

        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), ihost_state->my_ip, 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;
        }

        close(sd);

        return 0;       
}

void usage(char *progname){
        fprintf(stderr, "Usage %s [options] server port\n", progname);
        fprintf(stderr, "Options\n");
        fprintf(stderr, "  -v           Verbose, the more v flags the more verbose, eg -vv\n");
        fprintf(stderr, "  -d           Daemon mode, self backgrounding\n");
        fprintf(stderr, "  -s           Send errors to syslog\n");
        fprintf(stderr, "  -V           Print version number\n");
        fprintf(stderr, "  -h           Prints this help page\n");      
        exit(1);        
}

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

        int cmdopt;
        extern int optind;
        int verbose=0, daemon=0, syslog=0 ;
        
        /* 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]);

        while((cmdopt=getopt(argc, argv, "vdshV")) != -1){
                switch(cmdopt){
                        case 'v':
                                verbose++;
                                break;
                        
                        case 'd':
                                daemon=1;
                                break;
                        
                        case 's':
                                syslog=1;
                                break;
        
                        case 'h':
                                usage(argv[0]);
                                break;
                        case 'V':
                                errf("%s version %f",argv[0], versionNo);
                                break;
                        default:
                                usage(argv[0]);
                                exit(1);
                }
        }

        if(argc!=optind+2){
                usage(argv[0]);
                exit(1);
        }
        ihost_state.fm_host=argv[optind];
        ihost_state.fm_port=atoi(argv[optind+1]);
        if(ihost_state.fm_port==0){
                errf("Invalid port number");
                usage(argv[0]);
        }
        printf("%s\n%d\n",ihost_state.fm_host, ihost_state.fm_port);

        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);
        }

        for(;;){
                cur_time=time(NULL);
                if(cur_time>=tcp_time){
                        /*printf("sending TCP\n");*/
                        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){
                        /*printf("sending UDP\n");*/
                        stat_grab_time=time(NULL);
                        if((xml_stats=stat_grab(&ihost_state, counter++)) == NULL){
                                errf("Failed to get stats (%m)");
                                exit(1);
                        }
                        stat_grab_time=time(NULL)-stat_grab_time;
                        send_stats(&ihost_state, xml_stats);
                        free(xml_stats);
                        udp_time=time(NULL)+ihost_state.udp_update_time-stat_grab_time;
                }

                if(tcp_time<udp_time){
                        sleep_delay=tcp_time-time(NULL);
                }else{
                        sleep_delay=udp_time-time(NULL);
                }

                /*printf("tcp epoc: %ld \t udp epoc: %ld\ntime:%ld \tsleeping: %d\n", tcp_time, udp_time, time(NULL), sleep_delay);*/
                if(sleep_delay>0) sleep(sleep_delay);
        }
        return 0;
}

Revision:	1.17
Committed:	Mon May 20 12:28:46 2002 UTC (22 years, 6 months ago) by pajs
Content type:	text/plain
Branch:	MAIN
Changes since 1.16:	+52 -5 lines
Log Message:	Proper command line parsing, however doesn't do anything with the options yet :)
#	User	Rev	Content
1	tdb	1.11	/*
2			* i-scream central monitoring system
3			* Copyright (C) 2000-2002 i-scream
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* as published by the Free Software Foundation; either version 2
8			* of the License, or (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with this program; if not, write to the Free Software
17			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18			*/
19
20	pajs	1.1	#include <stdio.h>
21			#include <stdlib.h>
22			#include <unistd.h>
23			#include <syslog.h>
24			#include <netinet/in.h>
25	pajs	1.9	#include "ukcprog.h"
26	pajs	1.1	#include <netdb.h>
27	pajs	1.12	#include <string.h>
28	pajs	1.9	#include "statgrab.h"
29	pajs	1.12	#include <time.h>
30	pajs	1.14	#include <sys/socket.h>
31	pajs	1.16	#include <netinet/in.h>
32			#include <arpa/inet.h>
33	pajs	1.1
34	pajs	1.17	#define versionNo 0.8
35	pajs	1.4	#define RECONFIGURE_RETURN_CODE 2
36	pajs	1.9	#define UDP_MAX_PACKET_SIZE 8192
37	pajs	1.4
38	pajs	1.1	typedef struct{
39			int fm_port;
40			char *fm_host;
41	pajs	1.16
42			char *my_ip;
43	pajs	1.1	char *my_fqdn;
44			char *server_fqdn;
45			int server_udp_port;
46			int server_tcp_port;
47	pajs	1.4	char *last_modified;
48	pajs	1.1	char *files_list;
49			char *key;
50			int udp_update_time;
51			int tcp_update_time;
52
53			}ihost_state_t;
54
55	pajs	1.7	char* sock_comm(FILE f_r, FILE f_w, char *sendString){
56	pajs	1.1	char *reply;
57	pajs	1.7	fprintf(f_w, "%s\n", sendString);
58	pajs	1.2	fflush(f_w);
59			reply=fpgetline(f_r);
60	pajs	1.1	/* Returns pointer to static buffer */
61			return reply;
62			}
63
64			int ihost_configure(ihost_state_t *ihost_state){
65			struct sockaddr_in addr;
66			struct in_addr haddr;
67	pajs	1.16	struct sockaddr ip;
68			int ip_len;
69	pajs	1.1	int sd;
70	pajs	1.2	FILE fm_fd_r, fm_fd_w;
71	pajs	1.1	char *reply;
72	pajs	1.2	char *reply_ptr;
73	pajs	1.1
74	pajs	1.5	/* Check to see if anything needs to be free'd */
75			if (ihost_state->my_fqdn!=NULL) free(ihost_state->my_fqdn);
76			if (ihost_state->server_fqdn!=NULL) free(ihost_state->server_fqdn);
77			if (ihost_state->last_modified!=NULL) free(ihost_state->last_modified);
78			if (ihost_state->files_list!=NULL) free(ihost_state->files_list);
79
80	pajs	1.1	if ((sd = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
81			errf("Can't create AF_INET socket (%m)");
82			return -1;
83			}
84
85			if (get_host_addr(ihost_state->fm_host, &haddr) != 0){
86			errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
87			return -1;
88			}
89
90	pajs	1.9	memset(&addr, 0, sizeof addr);
91	pajs	1.1	addr.sin_family = AF_INET;
92	pajs	1.9	memcpy(&addr.sin_addr, &haddr, sizeof haddr);
93	pajs	1.1	addr.sin_port = htons(ihost_state->fm_port);
94
95			if (connect(sd, (struct sockaddr *)&addr, sizeof addr) != 0) {
96			errf("Failed to connect to %s on port %d (%m)", ihost_state->fm_host, ihost_state->fm_port);
97			return -1;
98			}
99
100	pajs	1.2	/* Need to open 2 files, one for reading one for writing, as it gets confused if we only use 1 :) */
101			if ((fm_fd_r=fdopen(sd,"r")) == NULL){
102	pajs	1.8	errf("Failed to open read stream (%m)");
103	pajs	1.2	return -1;
104			}
105
106			if ((fm_fd_w=fdopen(dup(sd),"w")) == NULL){
107	pajs	1.8	errf("Failed to open write stream (%m)");
108	pajs	1.1	return -1;
109			}
110	pajs	1.16	ip_len=sizeof ip;
111			memset(&ip, 0, ip_len);
112			if((getsockname(sd, &ip, &ip_len)) != 0){
113			errf("Failed to get IP address (%m)");
114			return -1;
115			}
116			if (ip.sa_family!=AF_INET){
117			errf("sa family is wrong type");
118			return -1;
119			}
120
121			if((ihost_state->my_ip=inet_ntoa(((struct sockaddr_in *)&ip)->sin_addr))==NULL){
122			errf("Failed to get IP (%m)");
123			return -1;
124			}
125	pajs	1.2
126	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "STARTCONFIG");
127	pajs	1.1	if ((reply==NULL) \|\| (strncasecmp(reply, "OK", 2) != 0) ) {
128			errf("Server error");
129			return -1;
130			}
131
132	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "LASTMODIFIED");
133	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0)){
134	pajs	1.1	errf("Server error (%m)");
135			return -1;
136			}
137	pajs	1.7	if((ihost_state->last_modified=strdup(reply)) == NULL){
138			errf("strdup failed (%m)");
139	pajs	1.4	return -1;
140			}
141	pajs	1.1
142	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "FILELIST");
143	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0)){
144	pajs	1.1	errf("Server error (%m)");
145			return -1;
146			}
147	pajs	1.7	if((ihost_state->files_list=strdup(reply)) == NULL){
148			errf("strdup failed (%m)");
149	pajs	1.6	return -1;
150			}
151	pajs	1.1
152	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "FQDN");
153	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5)==0)){
154	pajs	1.1	errf("Server error (%m)");
155			return -1;
156			}
157			if((ihost_state->my_fqdn=strdup(reply)) == NULL){
158			errf("strdup failed (%m)");
159			return -1;
160			}
161
162	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "UDPUpdateTime");
163	pajs	1.1	if(reply== NULL){
164			errf("Server error (%m)");
165			return -1;
166			}
167			if (strncasecmp(reply, "ERROR", 5) != 0){
168			ihost_state->udp_update_time=atoi(reply);
169			}
170
171	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "TCPUpdateTime");
172	pajs	1.1	if(reply== NULL){
173			errf("Server error (%m)");
174			return -1;
175			}
176			if (strncasecmp(reply, "ERROR", 5) != 0){
177			ihost_state->tcp_update_time=atoi(reply);
178			}
179
180	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "ENDCONFIG");
181	pajs	1.1	if(reply== NULL){
182			errf("Server error (%m)");
183			return -1;
184			}
185
186	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "FILTER");
187	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5)==0)){
188	pajs	1.9	errf("Server error FILTER failed (%m)");
189	pajs	1.2	return -1;
190			}
191			reply_ptr=strchr(reply,';');
192			if (reply_ptr==NULL){
193			errf("Incorrect data returned");
194			return -1;
195			}
196			*reply_ptr='\0';
197			if((ihost_state->server_fqdn=strdup(reply)) == NULL){
198			errf("strdup failed (%m)");
199			return -1;
200			}
201	pajs	1.8	reply=reply_ptr + 1;
202	pajs	1.2	reply_ptr=strchr(reply,';');
203			if (reply_ptr==NULL){
204			errf("Incorrect data returned 2");
205			return -1;
206			}
207			*reply_ptr='\0';
208			ihost_state->server_udp_port=atoi(reply);
209	pajs	1.8	reply=reply_ptr+1;
210	pajs	1.2	ihost_state->server_tcp_port=atoi(reply);
211			if ((ihost_state->server_tcp_port==0) \|\| (ihost_state->server_udp_port==0)){
212			errf("Incorrect data returned 3 ");
213			return -1;
214			}
215
216	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "END");
217	pajs	1.2	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0 )){
218			errf("Server error (%m)");
219			return -1;
220			}
221	pajs	1.1
222	pajs	1.2	if(fclose(fm_fd_r) !=0){
223	pajs	1.8	errf("Failed to close read FD (%m)");
224	pajs	1.2	return -1;
225			}
226			if(fclose(fm_fd_w) !=0){
227	pajs	1.8	errf("Failed to close write FD (%m)");
228	pajs	1.2	return -1;
229			}
230	pajs	1.1
231			return 0;
232			}
233	pajs	1.4
234			int heartbeat(ihost_state_t *ihost_state){
235			struct sockaddr_in addr;
236			struct in_addr haddr;
237			int sd;
238			FILE fm_fd_r, fm_fd_w;
239			char *reply;
240			int exitcode=0;
241
242			if ((sd = socket(AF_INET, SOCK_STREAM, PF_UNSPEC)) < 0) {
243			errf("Can't create AF_INET socket (%m)");
244			return -1;
245			}
246
247			if (get_host_addr(ihost_state->server_fqdn, &haddr) != 0){
248			errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
249			return -1;
250			}
251
252	pajs	1.9	memset(&addr, 0, sizeof addr);
253	pajs	1.4	addr.sin_family = AF_INET;
254	pajs	1.9	memcpy(&addr.sin_addr, &haddr, sizeof haddr);
255	pajs	1.4	addr.sin_port = htons(ihost_state->server_tcp_port);
256
257			if (connect(sd, (struct sockaddr *)&addr, sizeof addr) != 0) {
258			errf("Failed to connect to %s on port %d (%m)", ihost_state->fm_host, ihost_state->fm_port);
259			return -1;
260			}
261
262			/* Need to open 2 files, one for reading one for writing, as it gets confused if we only use 1 :) */
263			if ((fm_fd_r=fdopen(sd,"r")) == NULL){
264			errf("Failed to open stream (%m)");
265			return -1;
266			}
267
268			if ((fm_fd_w=fdopen(dup(sd),"w")) == NULL){
269			errf("Failed to open stream (%m)");
270			return -1;
271			}
272
273	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "HEARTBEAT");
274	pajs	1.6	if ((reply==NULL) \|\| (strncasecmp(reply, "ERROR", 5) == 0) ) {
275	pajs	1.4	errf("Server error");
276			return -1;
277			}
278	pajs	1.9
279	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "CONFIG");
280	pajs	1.6	if ((reply==NULL) \|\| (strncasecmp(reply, "ERROR", 5) == 0) ) {
281	pajs	1.4	errf("Server error");
282			return -1;
283			}
284
285			reply=sock_comm(fm_fd_r, fm_fd_w, ihost_state->files_list);
286			if ((reply==NULL) \|\| (strncasecmp(reply, "OK", 2) != 0) ) {
287			errf("Server error");
288			return -1;
289			}
290
291			reply=sock_comm(fm_fd_r, fm_fd_w, ihost_state->last_modified);
292			if (reply==NULL) {
293			errf("Server error");
294			return -1;
295			}
296	pajs	1.6	if (strncasecmp(reply, "ERROR", 5) == 0){
297	pajs	1.4	/* Means the config has changed */
298			exitcode=RECONFIGURE_RETURN_CODE;
299			}
300	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "KEY");
301	pajs	1.6	if ((reply==NULL) \|\| (strncasecmp(reply, "ERROR", 5) == 0) ) {
302	pajs	1.4	errf("Server error");
303			return -1;
304			}
305	pajs	1.5	if (ihost_state->key!=NULL) free(ihost_state->key);
306
307	pajs	1.7	if((ihost_state->key=strdup(reply)) == NULL){
308			errf("strdup failed (%m)");
309	pajs	1.4	return -1;
310			}
311
312	pajs	1.7	reply=sock_comm(fm_fd_r, fm_fd_w, "ENDHEARTBEAT");
313	pajs	1.4	if((reply== NULL) \|\| (strncasecmp(reply, "ERROR", 5) ==0 )){
314			errf("Server error (%m)");
315			return -1;
316			}
317
318	pajs	1.10	fflush(fm_fd_r);
319			fflush(fm_fd_w);
320
321	pajs	1.6	if(fclose(fm_fd_r) !=0){
322	pajs	1.8	errf("Failed to close read FD (%m)");
323	pajs	1.6	return -1;
324			}
325			if(fclose(fm_fd_w) !=0){
326	pajs	1.8	errf("Failed to close write FD (%m)");
327	pajs	1.6	return -1;
328			}
329
330	pajs	1.4	return exitcode;
331			}
332
333	pajs	1.9	char stat_grab(ihost_state_t ihost_state, int counter){
334			#define NUM_STATS 9
335			char *stats[NUM_STATS];
336			char *xml_data=NULL;
337			char *xml_data_p;
338			int x=0;
339
340			stats[0]=get_cpu_stats();
341			stats[1]=get_disk_stats();
342			stats[2]=get_load_stats();
343			stats[3]=get_memory_stats();
344			stats[4]=get_os_info();
345			stats[5]=get_page_stats();
346			stats[6]=get_process_stats();
347			stats[7]=get_swap_stats();
348			stats[8]=get_user_stats();
349
350			for(;x<NUM_STATS;x++){
351			if(stats[x]==NULL){
352			return NULL;
353			}
354			if(xml_data==NULL){
355			if((xml_data=strf("%s", stats[x])) == NULL){
356			errf("str failed (%m)");
357			return NULL;
358			}
359			}else{
360			xml_data_p=xml_data;
361			if((xml_data=strf("%s%s", xml_data, stats[x])) == NULL){
362			errf("str failed (%m)");
363			return NULL;
364			}
365			free(xml_data_p);
366			}
367			free(stats[x]);
368			}
369			xml_data_p=xml_data;
370	pajs	1.16	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), ihost_state->my_ip, ihost_state->key, xml_data);
371	pajs	1.9	free(xml_data_p);
372
373			return xml_data;
374			}
375
376			int send_stats(ihost_state_t ihost_state, char data_stream){
377			struct sockaddr_in addr;
378			struct in_addr haddr;
379
380			int sd;
381			size_t len;
382
383			len=strlen(data_stream);
384			if(len>UDP_MAX_PACKET_SIZE){
385			errf("Too big to send to server. Please reconfigure client and server and recompile");
386			exit(1);
387			}
388
389			if (get_host_addr(ihost_state->server_fqdn, &haddr) != 0){
390			errf("Failed to resolve address %s (%m)", ihost_state->fm_host);
391			return -1;
392			}
393
394			if((sd=socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
395			errf("failed to create UDP socket (%m)");
396			return -1;
397			}
398
399			memset(&addr, 0, sizeof(addr));
400			addr.sin_family=AF_INET;
401			memcpy((char *)&addr.sin_addr, &haddr, sizeof haddr);
402			addr.sin_port = htons(ihost_state->server_udp_port);
403
404			if((sendto(sd, data_stream, len, 0, (struct sockaddr *) &addr, sizeof(addr))) != len){
405			errf("Send the wrong number of bytes (%m)");
406			return -1;
407			}
408
409	pajs	1.10	close(sd);
410
411	pajs	1.9	return 0;
412			}
413	pajs	1.1
414	pajs	1.17	void usage(char *progname){
415			fprintf(stderr, "Usage %s [options] server port\n", progname);
416			fprintf(stderr, "Options\n");
417			fprintf(stderr, " -v Verbose, the more v flags the more verbose, eg -vv\n");
418			fprintf(stderr, " -d Daemon mode, self backgrounding\n");
419			fprintf(stderr, " -s Send errors to syslog\n");
420			fprintf(stderr, " -V Print version number\n");
421			fprintf(stderr, " -h Prints this help page\n");
422			exit(1);
423			}
424
425	pajs	1.3	int main(int argc, char **argv){
426	pajs	1.2	ihost_state_t ihost_state;
427	pajs	1.6	int heartbeat_exit;
428			int counter=0;
429	pajs	1.10	long udp_time=0, tcp_time=0, stat_grab_time=0, cur_time=0;
430	pajs	1.9	int sleep_delay=0;
431			char *xml_stats;
432	pajs	1.5
433	pajs	1.17	int cmdopt;
434			extern int optind;
435			int verbose=0, daemon=0, syslog=0 ;
436
437	pajs	1.5	/* NULL'ify so i can tell if i need to free it or not */
438			ihost_state.fm_host=NULL;
439			ihost_state.my_fqdn=NULL;
440			ihost_state.server_fqdn=NULL;
441			ihost_state.last_modified=NULL;
442			ihost_state.files_list=NULL;
443			ihost_state.key=NULL;
444
445	pajs	1.3	errf_set_progname(argv[0]);
446	pajs	1.17
447			while((cmdopt=getopt(argc, argv, "vdshV")) != -1){
448			switch(cmdopt){
449			case 'v':
450			verbose++;
451			break;
452
453			case 'd':
454			daemon=1;
455			break;
456
457			case 's':
458			syslog=1;
459			break;
460
461			case 'h':
462			usage(argv[0]);
463			break;
464			case 'V':
465			errf("%s version %f",argv[0], versionNo);
466			break;
467			default:
468			usage(argv[0]);
469			exit(1);
470			}
471			}
472
473			if(argc!=optind+2){
474			usage(argv[0]);
475	pajs	1.3	exit(1);
476			}
477	pajs	1.17	ihost_state.fm_host=argv[optind];
478			ihost_state.fm_port=atoi(argv[optind+1]);
479			if(ihost_state.fm_port==0){
480			errf("Invalid port number");
481			usage(argv[0]);
482			}
483			printf("%s\n%d\n",ihost_state.fm_host, ihost_state.fm_port);
484	pajs	1.2
485			if(ihost_configure(&ihost_state)!=0){
486			errf("configure failed");
487	pajs	1.6	/* Ok, ideally we prob should have 2 copies of the structure and carry on if this
488			happens.. But we dont :) (at the moment) */
489			exit(1);
490	pajs	1.2	}
491	pajs	1.5
492	pajs	1.9	for(;;){
493			cur_time=time(NULL);
494			if(cur_time>=tcp_time){
495	pajs	1.10	/printf("sending TCP\n");/
496	pajs	1.9	heartbeat_exit=heartbeat(&ihost_state);
497			if(heartbeat_exit==RECONFIGURE_RETURN_CODE){
498	pajs	1.10	/errf("heartbeat needs to be reconfigured");/
499	pajs	1.9	ihost_configure(&ihost_state);
500			/* So udp doesn't wait til next sending before updating */
501			udp_time=0;
502			}
503			if(heartbeat_exit==-1){
504			errf("ah crap");
505			exit(1);
506			}
507			tcp_time=time(NULL)+ihost_state.tcp_update_time;
508			}
509	pajs	1.10
510	pajs	1.9	if(cur_time>=udp_time){
511	pajs	1.10	/printf("sending UDP\n");/
512			stat_grab_time=time(NULL);
513	pajs	1.13	if((xml_stats=stat_grab(&ihost_state, counter++)) == NULL){
514	pajs	1.9	errf("Failed to get stats (%m)");
515			exit(1);
516			}
517	pajs	1.10	stat_grab_time=time(NULL)-stat_grab_time;
518			send_stats(&ihost_state, xml_stats);
519			free(xml_stats);
520			udp_time=time(NULL)+ihost_state.udp_update_time-stat_grab_time;
521	pajs	1.9	}
522	pajs	1.10
523			if(tcp_time<udp_time){
524			sleep_delay=tcp_time-time(NULL);
525	pajs	1.9	}else{
526	pajs	1.10	sleep_delay=udp_time-time(NULL);
527	pajs	1.6	}
528	pajs	1.10
529			/printf("tcp epoc: %ld \t udp epoc: %ld\ntime:%ld \tsleeping: %d\n", tcp_time, udp_time, time(NULL), sleep_delay);/
530			if(sleep_delay>0) sleep(sleep_delay);
531	pajs	1.6	}
532	pajs	1.1	return 0;
533			}
534