ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/cms/source/ihost/ihost.c
(Generate patch)

Comparing projects/cms/source/ihost/ihost.c (file contents):
Revision 1.31 by pajs, Tue Mar 4 10:44:36 2003 UTC vs.
Revision 1.54 by tdb, Tue May 2 06:49:53 2006 UTC

# Line 1 | Line 1
1   /*
2   * i-scream central monitoring system
3 < * http://www.i-scream.org.uk
4 < * Copyright (C) 2000-2002 i-scream
3 > * http://www.i-scream.org
4 > * Copyright (C) 2000-2004 i-scream
5   *
6   * This program is free software; you can redistribute it and/or
7   * modify it under the terms of the GNU General Public License
# Line 27 | Line 27
27   #include <unistd.h>
28   #include <string.h>
29   #include <sys/types.h>
30 #include <sys/socket.h>
30   #include <stdarg.h>
31   #include <errno.h>
32 + #ifndef WIN32
33 + #include <sys/socket.h>
34   #include <netdb.h>
35 + #include <netinet/in.h>
36 + #else
37 + #include <winsock2.h>
38 + #include <getopt.h>
39 + #endif
40 + #include <time.h>
41  
42 < #include "ukcprog.h"
43 < #include "statgrab.h"
42 > #include <ukcprog.h>
43 > #include <statgrab.h>
44  
45   #define LOG_CRIT 0
46   #define LOG_ERR 1
47 < #define LOG_INFO 2
47 > #define LOG_INFO 2
48   #define LOG_DEBUG 3
49  
50 + #define SERVICENAME "ihost"
51 +
52 + /* Windows printf does not understand %lld, so we have to use %I64d */
53 + #ifdef WIN32
54 + #define LLD "%I64d"
55 + #define OPTSTRING "vVn:i:s:p:w:h"
56 + #define SLEEP 10000
57 + #else
58 + #define LLD "%lld"
59 + #define OPTSTRING "vfVn:i:s:p:h"
60 + #define SLEEP 10
61 + #endif
62 +
63 + /* The "socket" */
64 + #ifdef WIN32
65 + #define IHOST_SOCKET SOCKET
66 + #define CLOSESOCKET(socket) closesocket(socket)
67 + #else
68 + #define IHOST_SOCKET FILE *
69 + #define CLOSESOCKET(socket) fclose(socket)
70 + #endif
71 +
72   typedef struct{
73          int filtermanager_port;
74          char *filtermanager_host;
75  
76          char *host_ip;
77          char *host_fqdn;
78 +        int preset_fqdn;
79 +        int preset_ip;
80  
81          char *server_fqdn;
82          int server_udp_port;
83 <        
83 >
84          /* Weird stuff iscream wants sent to it */
85          char *last_modified;
86          char *file_list;
87  
88          int udp_update_time;
58 //      int config_ttl;
89  
90          time_t config_ttl;
91  
92   }ihost_state_t;
93  
94   typedef struct{
95 <        int verbose;
96 <        int daemon;
95 >        int verbose;
96 >        int daemon;
97  
98          FILE *log;
99 < }ihost_config_t;        
99 > }ihost_config_t;
100  
101   typedef struct{
102          struct sockaddr_in addr;
# Line 74 | Line 104 | typedef struct{
104   }udp_sockinfo_t;
105  
106   ihost_config_t ihost_config;
107 + ihost_state_t ihost_state;
108  
109 + extern int errno;
110 +
111 + #ifdef WIN32
112 + int run_server = 1;
113 + int run_as_service = 0;
114 + SERVICE_STATUS service_status;
115 + SERVICE_STATUS_HANDLE hstatus;
116 + #endif
117 +
118 + /* Taken from the OpenSSH code. Its licence included in function.*/
119 + #ifndef HAVE_STRLCAT
120 +
121 + /*
122 + * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
123 + * All rights reserved.
124 + *
125 + * Redistribution and use in source and binary forms, with or without
126 + * modification, are permitted provided that the following conditions
127 + * are met:
128 + * 1. Redistributions of source code must retain the above copyright
129 + *    notice, this list of conditions and the following disclaimer.
130 + * 2. Redistributions in binary form must reproduce the above copyright
131 + *    notice, this list of conditions and the following disclaimer in the
132 + *    documentation and/or other materials provided with the distribution.
133 + * 3. The name of the author may not be used to endorse or promote products
134 + *    derived from this software without specific prior written permission.
135 + *
136 + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
137 + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
138 + * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
139 + * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
140 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
141 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
142 + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
143 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
144 + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
145 + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
146 + */
147 +
148 + /*
149 + * Appends src to string dst of size siz (unlike strncat, siz is the
150 + * full size of dst, not space left).  At most siz-1 characters
151 + * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
152 + * Returns strlen(src) + MIN(siz, strlen(initial dst)).
153 + * If retval >= siz, truncation occurred.
154 + */
155 + size_t
156 + strlcat(dst, src, siz)
157 +        char *dst;
158 +        const char *src;
159 +        size_t siz;
160 + {
161 +        register char *d = dst;
162 +        register const char *s = src;
163 +        register size_t n = siz;
164 +        size_t dlen;
165 +
166 +        /* Find the end of dst and adjust bytes left but don't go past end */
167 +        while (n-- != 0 && *d != '\0')
168 +                d++;
169 +        dlen = d - dst;
170 +        n = siz - dlen;
171 +
172 +        if (n == 0)
173 +                return(dlen + strlen(s));
174 +        while (*s != '\0') {
175 +                if (n != 1) {
176 +                        *d++ = *s;
177 +                        n--;
178 +                }
179 +                s++;
180 +        }
181 +        *d = '\0';
182 +
183 +        return(dlen + (s - src));       /* count does not include NUL */
184 + }
185 +
186 + #endif
187 + /* End strlcat function taken from OpenSSH */
188 +
189   void log_msg(int level, char *format, ...){
79        extern int errno;
190          int cur_errno;
191          va_list ap;
192  
# Line 91 | Line 201 | void log_msg(int level, char *format, ...){
201                  }else{
202                          fprintf(ihost_config.log, "\n");
203                  }
204 +                fflush(ihost_config.log);
205          }
206   }
207  
97 /* Takes many pointers, checks if they are NULL or not, and then free's them */
98 /* Deprciated - and i only wrote it today! :)
99 void m_free(int num_pointers, ...){
100        int x=0;
101        va_list ap;
102        void *p;
103
104        va_start(ap, num_pointers);
105        for(;x<num_pointers;x++){
106                p=va_arg(ap, void*);
107                if(p!=NULL){
108                        free(p);
109                }
110        }
111        va_end(ap);
112 }
113 */
114
208   int create_udp_sockinfo(udp_sockinfo_t *udp_sockinfo, char *hostname, int port){
209  
210          struct in_addr haddr;
# Line 136 | Line 229 | int create_udp_sockinfo(udp_sockinfo_t *udp_sockinfo,
229          return 0;
230   }
231  
232 < FILE *create_tcp_connection(char *hostname, int port){
232 > IHOST_SOCKET create_tcp_connection(char *hostname, int port){
233 > #ifdef WIN32
234 >        SOCKET sock;
235 > #else
236          int sock;
237 + #endif
238          struct sockaddr_in addr;
239          struct in_addr haddr;
240          FILE *f;
241  
242 <        log_msg(LOG_DEBUG, "Creating tcp socket");      
242 >        log_msg(LOG_DEBUG, "Creating tcp socket");
243          if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP))<0){
244                  log_msg(LOG_CRIT, "Failed to make TCP Socket");
245 <                return NULL;
245 >                goto out;
246          }
247  
248          if((get_host_addr(hostname, &haddr))!=0){
249                  log_msg(LOG_CRIT, "Failed to lookup name for %s", hostname);
250 <                return NULL;
250 >                close(sock);
251 >                goto out;
252          }
253  
254          memset(&addr, 0, sizeof(addr));
# Line 161 | Line 259 | FILE *create_tcp_connection(char *hostname, int port){
259          log_msg(LOG_DEBUG, "Creating a tcp connection");
260          if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) !=0){
261                  log_msg(LOG_CRIT, "Failed to connect to hostname %s on port %d", hostname, port);
262 <                return NULL;
262 >                close(sock);
263 >                goto out;
264          }
265  
266 + #ifndef WIN32
267 + /* Windows does not treat sockets like this :( */
268          if((f=fdopen(sock, "r+"))==NULL){
269                  log_msg(LOG_CRIT, "Failed to connect to open filedescriptor on tcp connection");
270                  close(sock);
# Line 171 | Line 272 | FILE *create_tcp_connection(char *hostname, int port){
272          }
273  
274          return f;
275 + #else
276 +        return sock;
277 + #endif
278 +
279 + out:
280 + #ifdef WIN32
281 +        return 0;
282 + #else
283 +        return NULL;
284 + #endif
285   }
286  
287 + #ifndef WIN32
288   int tcp_comm(FILE *f, char *send, char **response, char *expected){
289  
290          log_msg(LOG_DEBUG, "Sending %s", send);
# Line 181 | Line 293 | int tcp_comm(FILE *f, char *send, char **response, cha
293          *response=fpgetline(f);
294          fseek(f, 0, SEEK_CUR);
295  
296 <        if(*response!=NULL) log_msg(LOG_DEBUG, "Recieved %s", *response);
296 >        if(*response!=NULL) log_msg(LOG_DEBUG, "Received %s", *response);
297  
298          if( (*response==NULL) || (strcmp(*response, "ERROR")==0) ) return -1;
299 +
300 +        if(expected==NULL) return 0;
301 +
302 +        if((strcmp(expected, *response))==0) return 0;
303 +
304 +        log_msg(LOG_DEBUG, "Did not get expected response");
305 +        return -1;
306 + }
307 + #else
308 + int tcp_comm(SOCKET soc, char *sendstr, char **response, char *expected) {
309 +        static char *rec = NULL;
310 +        char sendbuf[128];
311 +        char recbuf[128];
312 +        int bytesRecv;
313 +        char *tmp;
314          
315 +        sprintf(sendbuf, "%s\n", sendstr);
316 +
317 +        log_msg(LOG_DEBUG, "Sending %s", sendstr);
318 +        send(soc, sendbuf, strlen(sendbuf), 0);
319 +        bytesRecv = recv(soc, recbuf, 128, 0);
320 +
321 +        if(bytesRecv != 0 && bytesRecv != SOCKET_ERROR) {
322 +                /* remove \n and copy to a string */
323 +                recbuf[bytesRecv-1] = '\0';
324 +                tmp = realloc(rec, bytesRecv);
325 +                if(tmp == NULL) {
326 +                        free(rec);
327 +                        rec = NULL;
328 +                        log_msg(LOG_CRIT, "out of memory");
329 +                        return -1;
330 +                }
331 +                rec = tmp;
332 +                rec = strcpy(rec, recbuf);
333 +                *response = rec;
334 +                log_msg(LOG_DEBUG, "Received %s", *response);
335 +        } else {
336 +                return -1;
337 +        }
338 +        if(strcmp(*response, "ERROR")==0) return -1;
339 +
340          if(expected==NULL) return 0;
341  
342          if((strcmp(expected, *response))==0) return 0;
# Line 192 | Line 344 | int tcp_comm(FILE *f, char *send, char **response, cha
344          log_msg(LOG_DEBUG, "Did not get expected response");
345          return -1;
346   }
347 + #endif /* WIN32 */
348  
349 < int tcp_comm_strdup(FILE *f, char *send, char **response, char *expected){
350 <        if((tcp_comm(f, send, response, expected))!=0){
349 > int tcp_comm_strdup(IHOST_SOCKET f, char *send, char **response, char *expected)
350 > {
351 >        if((tcp_comm(f, send, response, expected))!=0){
352                  return -1;
353          }
354  
# Line 203 | Line 357 | int tcp_comm_strdup(FILE *f, char *send, char **respon
357  
358          return 0;
359   }
206        
207 int ihost_getconfig(ihost_state_t *ihost_state){
360  
361 <        FILE *tcp_con;
361 > int ihost_getconfig(ihost_state_t *ihost_state){
362 >        IHOST_SOCKET tcp_con;
363          char *response;
364          char *response_ptr;
365  
366          /* Keep these in case of a failure and so it can keep running on the old config */
367 <        char *file_list=NULL;  
367 >        char *file_list=NULL;
368          char *last_modified=NULL;
369          char *host_fqdn=NULL;
370          char *host_ip=NULL;
# Line 220 | Line 373 | int ihost_getconfig(ihost_state_t *ihost_state){
373          int server_udp_port=0;
374          time_t config_ttl=0;
375  
376 <        if((tcp_con=create_tcp_connection(ihost_state->filtermanager_host, ihost_state->filtermanager_port))==NULL){
377 <                goto error;
376 >        if((tcp_con=create_tcp_connection(ihost_state->filtermanager_host, ihost_state->filtermanager_port))
377 > #ifndef WIN32
378 >                        ==NULL
379 > #else
380 >                        ==0
381 > #endif
382 >                        ) {
383 >                return -1;
384          }
385  
386          if(ihost_state->file_list!=NULL || ihost_state->last_modified!=NULL){
387 <                if(tcp_con==NULL){
387 > #ifndef WIN32
388 >                if(tcp_con==NULL)
389 > #else
390 >                if(tcp_con==0)
391 > #endif
392 >                {
393                          goto error;
394 <                }      
395 <        
394 >                }
395 >
396                  if((tcp_comm(tcp_con, "CHECKCONFIG", &response, "OK"))!=0){
397                          goto error;
398                  }
399 <        
399 >
400                  if((tcp_comm(tcp_con, ihost_state->file_list, &response, "OK"))!=0){
401                          goto error;
402                  }
403 <        
403 >
404                  if((tcp_comm(tcp_con, ihost_state->last_modified, &response, "OK"))==0){
405 <                        if((tcp_comm(tcp_con, "END", &response, "OK"))==0){
405 >                        if((tcp_comm(tcp_con, "END", &response, "OK"))!=0){
406                                  goto error;
407                          }
408 <                        fclose(tcp_con);
408 >                        CLOSESOCKET(tcp_con);
409                          return 0;
410                  }else{
411                          if((strcmp(response, "EXPIRED"))!=0){
# Line 260 | Line 424 | int ihost_getconfig(ihost_state_t *ihost_state){
424                  goto error;
425          }
426          last_modified=response;
427 <                        
427 >
428          if((tcp_comm_strdup(tcp_con, "FILELIST", &response, NULL))!=0){
429                  goto error;
430          }
# Line 305 | Line 469 | int ihost_getconfig(ihost_state_t *ihost_state){
469                  }
470                  response_ptr++;
471                  if(response_ptr==NULL){
472 <                        log_msg(LOG_ERR, "Incorrect data sent by server");
473 <                        goto error;
474 <                }
472 >                        log_msg(LOG_ERR, "Incorrect data sent by server");
473 >                        goto error;
474 >                }
475  
476 <                printf("string : %s\n", response_ptr);
313 <                server_udp_port=atoi(response_ptr);
476 >                server_udp_port=atoi(response_ptr);
477  
478                  if (server_udp_port==0){
479                          log_msg(LOG_ERR, "Incorrect data sent by server");
480                          goto error;
481                  }
482          }
483 <        
483 >
484          if((tcp_comm(tcp_con, "END", &response, "OK"))!=0){
485                  goto error;
486          }
487  
488 <        fclose(tcp_con);
488 >        CLOSESOCKET(tcp_con);
489  
490          /* We have the data we need, and its all been read correctly */
491  
492          /* Free the old data before pointing them to the new data. m_free copes should
493           * this already be NULL */
494 <        if(ihost_state->file_list!=NULL) free(ihost_state->file_list);
495 <        if(ihost_state->last_modified!=NULL) free(ihost_state->last_modified);
496 <        if(ihost_state->host_fqdn!=NULL) free(ihost_state->host_fqdn);
334 <        if(ihost_state->server_fqdn!=NULL) free(ihost_state->server_fqdn);
335 <        if(ihost_state->host_ip!=NULL) free(ihost_state->host_ip);
494 >        if(ihost_state->file_list!=NULL) free(ihost_state->file_list);
495 >        if(ihost_state->last_modified!=NULL) free(ihost_state->last_modified);
496 >        if(ihost_state->server_fqdn!=NULL) free(ihost_state->server_fqdn);
497  
498 +        if(ihost_state->preset_fqdn){
499 +                if(host_fqdn != NULL) free(host_fqdn);
500 +        }else{
501 +                if(ihost_state->host_fqdn!=NULL) free(ihost_state->host_fqdn);
502 +                ihost_state->host_fqdn=host_fqdn;
503 +        }
504 +
505 +        if(ihost_state->preset_ip){
506 +                if(host_ip != NULL) free(host_ip);
507 +        }else{
508 +                if(ihost_state->host_ip!=NULL) free(ihost_state->host_ip);
509 +                ihost_state->host_ip=host_ip;
510 +        }
511 +
512 +
513          ihost_state->file_list=file_list;
514          ihost_state->last_modified=last_modified;
339        ihost_state->host_fqdn=host_fqdn;
340        ihost_state->host_ip=host_ip;
515          ihost_state->server_fqdn=server_fqdn;
516          ihost_state->server_udp_port=server_udp_port;
517          ihost_state->udp_update_time=udp_update_time;
# Line 355 | Line 529 | error:
529          if(host_fqdn!=NULL) free(host_fqdn);
530          if(server_fqdn!=NULL) free(server_fqdn);
531          if(host_ip!=NULL) free(host_ip);
532 <        fclose(tcp_con);
532 >        CLOSESOCKET(tcp_con);
533  
534          return -1;
535   }
536  
537   int get_system_stats(int seq_no, ihost_state_t *ihost_state, char *xml, int size){
538          char tmp[size];
539 <        cpu_percent_t *cpu_percent;    
540 <        mem_stat_t *mem_stats;
541 <        load_stat_t *load_stats;
542 <        user_stat_t *user_stats;
543 <        swap_stat_t *swap_stats;
544 <        general_stat_t *general_stats;
545 <        disk_stat_t *disk_stats;
546 <        diskio_stat_t *diskio_stats;
547 <        process_stat_t *process_stats;
548 <        network_stat_t *network_stats;
549 <        page_stat_t *page_stats;
539 >        sg_cpu_percents *cpu_percent;
540 >        sg_mem_stats *mem_stats;
541 >        sg_load_stats *load_stats;
542 >        sg_user_stats *user_stats;
543 >        sg_swap_stats *swap_stats;
544 >        sg_host_info *general_stats;
545 >        sg_fs_stats *disk_stats;
546 >        sg_disk_io_stats *diskio_stats;
547 >        sg_process_count *process_stats;
548 >        sg_network_io_stats *network_stats;
549 >        sg_page_stats *page_stats;
550          int disk_entries=0;
551          int diskio_entries=0;
552          int network_entries=0;
# Line 383 | Line 557 | int get_system_stats(int seq_no, ihost_state_t *ihost_
557  
558          /* Print start of the packet we want */
559          snprintf(xml, size, "<packet seq_no=\"%d\" machine_name=\"%s\" date=\"%ld\" type=\"data\" ip=\"%s\">", \
560 <                 seq_no, ihost_state->host_fqdn, time(NULL), ihost_state->host_ip);
560 >                 seq_no, ihost_state->host_fqdn, (long) time(NULL), ihost_state->host_ip);
561  
562          /* Get cpu stats, check it is correct, then fill in its entry for the xml */
563 <        if((cpu_percent=cpu_percent_usage())==NULL){
564 <                log_msg(LOG_CRIT, "Failed to get cpu statistics");
563 >        if((cpu_percent=sg_get_cpu_percents())==NULL){
564 >                log_msg(LOG_CRIT, "Failed to get cpu statistics: %s (%s)",
565 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
566          }else{
567                  snprintf(tmp, size, \
568                          "<cpu><user>%3.2f</user><kernel>%3.2f</kernel><idle>%3.2f</idle><iowait>%3.2f</iowait><swap>%3.2f</swap></cpu>", \
# Line 400 | Line 575 | int get_system_stats(int seq_no, ihost_state_t *ihost_
575                  if(strlcat(xml, tmp, size) >= size) goto too_big_error;
576          }
577  
578 <        
579 <        /*Get mem stats, and fill in xml */    
580 <        if((mem_stats=get_memory_stats())==NULL){
581 <                log_msg(LOG_CRIT, "Failed to get memory statistics");
578 >
579 >        /*Get mem stats, and fill in xml */
580 >
581 >        if((mem_stats=sg_get_mem_stats())==NULL){
582 >                log_msg(LOG_CRIT, "Failed to get memory statistics: %s (%s)",
583 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
584          }else{
585                  snprintf(tmp, size, \
586 <                        "<memory><total>%lld</total><free>%lld</free><used>%lld</used><cache>%lld</cache></memory>", \
586 >                        "<memory><total>"LLD"</total><free>"LLD"</free><used>"LLD"</used><cache>"LLD"</cache></memory>", \
587                          mem_stats->total, \
588                          mem_stats->free, \
589                          mem_stats->used, \
590                          mem_stats->cache);
591 <                
591 >
592                  if(strlcat(xml, tmp, size) >= size) goto too_big_error;
593          }
594  
595  
596 <        /* Get load stats */    
597 <        if((load_stats=get_load_stats())==NULL){
598 <                log_msg(LOG_CRIT, "Failed to get load statistics");
596 >        /* Get load stats */
597 >
598 >        if((load_stats=sg_get_load_stats())==NULL){
599 >                log_msg(LOG_CRIT, "Failed to get load statistics: %s (%s)",
600 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
601          }else{
602                  snprintf(tmp, size, \
603                          "<load><load1>%.2lf</load1><load5>%.2lf</load5><load15>%.2lf</load15></load>", \
# Line 430 | Line 609 | int get_system_stats(int seq_no, ihost_state_t *ihost_
609  
610  
611          /* get user stats */
612 <        
613 <        if((user_stats=get_user_stats())==NULL){
614 <                log_msg(LOG_CRIT, "Failed to get user statistics");
612 >
613 >        if((user_stats=sg_get_user_stats())==NULL){
614 >                log_msg(LOG_CRIT, "Failed to get user statistics: %s (%s)",
615 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
616          }else{
617  
618                  snprintf(tmp, size, \
619                          "<users><list>%s</list><count>%d</count></users>", \
620                          user_stats->name_list, \
621                          user_stats->num_entries);
622 <                
622 >
623                  if(strlcat(xml, tmp, size) >= size) goto too_big_error;
624          }
625  
626  
627          /* swap stats */
628 <        if((swap_stats=get_swap_stats())==NULL){
629 <                log_msg(LOG_CRIT, "Failed to get swap statistics");    
628 >
629 >        if((swap_stats=sg_get_swap_stats())==NULL){
630 >                log_msg(LOG_CRIT, "Failed to get swap statistics: %s (%s)",
631 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
632          }else{
633                  snprintf(tmp, size, \
634 <                        "<swap><total>%lld</total><used>%lld</used><free>%lld</free></swap>",\
634 >                        "<swap><total>"LLD"</total><used>"LLD"</used><free>"LLD"</free></swap>",\
635                          swap_stats->total, \
636                          swap_stats->used, \
637                          swap_stats->free);
638 <        
638 >
639                  if(strlcat(xml, tmp, size) >= size) goto too_big_error;
640          }
641  
642  
643          /* general stats */
644 <        
645 <        if((general_stats=get_general_stats())==NULL){
646 <                log_msg(LOG_CRIT, "Failed to get general statistics");
644 >
645 >        if((general_stats=sg_get_host_info())==NULL){
646 >                log_msg(LOG_CRIT, "Failed to get host info statistics: %s (%s)",
647 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
648          }else{
649                  snprintf(tmp, size, \
650                          "<os><name>%s</name><release>%s</release><version>%s</version><sysname>%s</sysname><platform>%s</platform><uptime>%ld</uptime></os>", \
# Line 471 | Line 654 | int get_system_stats(int seq_no, ihost_state_t *ihost_
654                          general_stats->hostname, \
655                          general_stats->platform, \
656                          (long)general_stats->uptime);
657 <                
657 >
658                  if(strlcat(xml, tmp, size) >= size) goto too_big_error;
659 <        
659 >
660          }
661  
662 <        
662 >
663          /* process stats */
664 <        if((process_stats=get_process_stats())==NULL){  
665 <                log_msg(LOG_CRIT, "Failed to get general statistics");
664 >
665 >        if((process_stats=sg_get_process_count())==NULL){
666 >                log_msg(LOG_CRIT, "Failed to get process statistics: %s (%s)",
667 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
668          }else{
669                  snprintf(tmp, size, \
670                          "<processes><sleeping>%d</sleeping><cpu>%d</cpu><zombie>%d</zombie><stopped>%d</stopped><total>%d</total></processes>",\
# Line 495 | Line 680 | int get_system_stats(int seq_no, ihost_state_t *ihost_
680  
681  
682          /* Get paging stats */
683 <        if((page_stats=get_page_stats_diff())==NULL){
684 <                log_msg(LOG_CRIT, "Failed to get paging statistics");
683 >
684 >        if((page_stats=sg_get_page_stats_diff())==NULL){
685 >                log_msg(LOG_CRIT, "Failed to get paging statistics: %s (%s)",
686 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
687          }else{
688                  if(page_stats->systime!=0){
689                          x=page_stats->pages_pagein / page_stats->systime;
# Line 506 | Line 693 | int get_system_stats(int seq_no, ihost_state_t *ihost_
693                          y=page_stats->pages_pageout;
694                  }
695                  snprintf(tmp, size, \
696 <                        "<pages><swapins>%lld</swapins><swapouts>%lld</swapouts></pages>", \
696 >                        "<pages><pageins>"LLD"</pageins><pageouts>"LLD"</pageouts></pages>", \
697                          x, \
698                          y);
699 <        
699 >
700                  if(strlcat(xml, tmp, size) >= size) goto too_big_error;
701          }
702  
703  
704          /* get diskio stats */
705 <        
706 <        if((diskio_stats=get_diskio_stats_diff(&diskio_entries))==NULL){
707 <                log_msg(LOG_CRIT, "Failed to get diskio statistics");
705 >
706 >        if((diskio_stats=sg_get_disk_io_stats_diff(&diskio_entries))==NULL){
707 >                log_msg(LOG_CRIT, "Failed to get disk io statistics: %s (%s)",
708 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
709          }else{
710                  strlcat(xml, "<diskio>", size);
711                  for(counter=0;counter<diskio_entries;counter++){
# Line 527 | Line 715 | int get_system_stats(int seq_no, ihost_state_t *ihost_
715                                  y=diskio_stats->write_bytes / diskio_stats->systime;
716                          }else{
717                                  x=diskio_stats->read_bytes;
718 <                                y=diskio_stats->write_bytes;
718 >                                y=diskio_stats->write_bytes;
719                          }
720 <        
720 >
721                          snprintf(tmp, size, \
722 <                                "<p%d name=\"%s\" rbytes=\"%lld\" wbytes=\"%lld\"></p%d>", \
722 >                                "<p%d name=\"%s\" rbytes=\""LLD"\" wbytes=\""LLD"\"></p%d>", \
723                                  counter, \
724                                  diskio_stats->disk_name, \
725                                  x, \
# Line 546 | Line 734 | int get_system_stats(int seq_no, ihost_state_t *ihost_
734  
735          }
736  
737 <        
737 >
738          /* get networks stats */
739 <        
740 <        if((network_stats=get_network_stats_diff(&network_entries))==NULL){
741 <                log_msg(LOG_CRIT, "Failed to get network statistics");
739 >
740 >        if((network_stats=sg_get_network_io_stats_diff(&network_entries))==NULL){
741 >                log_msg(LOG_CRIT, "Failed to get network io statistics: %s (%s)",
742 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
743          }else{
744                  strlcat(xml, "<net>", size);
745                  for(counter=0;counter<network_entries;counter++){
# Line 563 | Line 752 | int get_system_stats(int seq_no, ihost_state_t *ihost_
752                          }
753  
754                          snprintf(tmp, size, \
755 <                                "<p%d name=\"%s\" rx=\"%lld\" tx=\"%lld\"></p%d>", \
755 >                                "<p%d name=\"%s\" rx=\""LLD"\" tx=\""LLD"\"></p%d>", \
756                                  counter, \
757                                  network_stats->interface_name, \
758                                  x, \
# Line 580 | Line 769 | int get_system_stats(int seq_no, ihost_state_t *ihost_
769  
770  
771          /* get disk stats */
772 <        
773 <        if((disk_stats=get_disk_stats(&disk_entries))==NULL){
774 <                log_msg(LOG_CRIT, "Failed to get disk statistics");
772 >
773 >        if((disk_stats=sg_get_fs_stats(&disk_entries))==NULL){
774 >                log_msg(LOG_CRIT, "Failed to get fs statistics: %s (%s)",
775 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
776          }else{
777                  strlcat(xml, "<disk>", size);
778                  for(counter=0;counter<disk_entries;counter++){
779 +                        if(strcmp(disk_stats->fs_type, "nfs") == 0) continue;
780                          snprintf(tmp, size, \
781 <                                "<p%d name=\"%s\" mount=\"%s\" fstype=\"%s\" total=\"%lld\" used=\"%lld\" avail=\"%lld\" totalinodes=\"%lld\" usedinodes=\"%lld\" freeinodes=\"%lld\"></p%d>", \
781 >                                "<p%d name=\"%s\" mount=\"%s\" fstype=\"%s\" total=\""LLD"\" used=\""LLD"\" avail=\""LLD"\" totalinodes=\""LLD"\" usedinodes=\""LLD"\" freeinodes=\""LLD"\"></p%d>", \
782                                  counter, \
783                                  disk_stats->device_name, \
784                                  disk_stats->mnt_point, \
# Line 608 | Line 799 | int get_system_stats(int seq_no, ihost_state_t *ihost_
799                  if(strlcat(xml, "</disk>", size) >= size) goto too_big_error;
800  
801          }
611        
802  
803 +
804          if(strlcat(xml, "</packet>", size) >= size) goto too_big_error;
805  
806          /*If we got to here, it should of all been filled in nicely now */
# Line 621 | Line 812 | too_big_error:
812   }
813  
814  
815 <        
815 >
816 > /* WIN32 NT service stuff */
817 > #ifdef WIN32
818 > void service_stopped() {
819 >        if(run_as_service) {
820 >                service_status.dwCurrentState = SERVICE_STOPPED;
821 >                service_status.dwWin32ExitCode = errno;
822 >                service_status.dwServiceSpecificExitCode = 0;
823 >
824 >                SetServiceStatus(hstatus, &service_status);
825 >        }
826 > }
827 >
828 > void control_handler(DWORD request) {
829 >        switch(request) {
830 >                case SERVICE_CONTROL_STOP:
831 >                case SERVICE_CONTROL_SHUTDOWN:
832 >                        service_status.dwWin32ExitCode = 0;
833 >                        service_status.dwCurrentState = SERVICE_STOP_PENDING;
834 >                        break;
835 >                default:
836 >                        break;
837 >        }
838 >
839 >        SetServiceStatus (hstatus, &service_status);
840 > }
841 >
842 > /* attempt to tell service manager to start our service.
843 > * return 0 on error, 1 on ok
844 > */
845 > int start_service() {
846 >        SC_HANDLE scm;
847 >        SC_HANDLE service;
848 >
849 >        // Open SCM
850 >        if((scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT)) == NULL) {
851 >                log_msg(LOG_CRIT, "Failed to open Service Control Manager");
852 >                return 0;
853 >        }
854 >        // Locate the service
855 >        if((service = OpenService(scm, SERVICENAME, SERVICE_START)) == NULL) {
856 >                log_msg(LOG_CRIT, "Unable to open the service");
857 >                return 0;
858 >        }
859 >        // Start the service
860 >        if(StartService(service, 0, NULL) == 0) {
861 >                log_msg(LOG_CRIT, "Unable to start the service");
862 >                return 0;
863 >        }
864 >        return 1;
865 > }
866 >
867 > int stop_service() {
868 >        SC_HANDLE scm;
869 >        SC_HANDLE service;
870 >        SERVICE_STATUS status;
871 >
872 >        // Open SCM
873 >        if((scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT)) == NULL) {
874 >                log_msg(LOG_CRIT, "Failed to open Service Control Manager");
875 >                return 0;
876 >        }
877 >        // Locate service
878 >        if((service = OpenService(scm, SERVICENAME, SERVICE_STOP)) == NULL) {
879 >                log_msg(LOG_CRIT, "Unable to open the service");
880 >                return 0;
881 >        }
882 >        // Stop the service
883 >        if(!ControlService(service, SERVICE_CONTROL_STOP, &status)) {
884 >                log_msg(LOG_CRIT, "Unable to stop the service");
885 >                return 0;
886 >        }
887 >        return 1;
888 > }
889 >
890 > int register_service(int argc, char **argv) {
891 >        char path[MAX_PATH];
892 >        int cmdline_len;
893 >        int i;
894 >        char *cmdline;
895 >        char *tmp;
896 >        SC_HANDLE scm;
897 >
898 >        if(!GetModuleFileName(NULL, path, MAX_PATH)) {
899 >                log_msg(LOG_CRIT, "GetModuleFileName failed");
900 >                return 0;
901 >        }
902 >
903 >        // Calculate command line length
904 >        // 14 = 10 for " -w service", 2x quote around path and ending \0
905 >        cmdline_len = strlen(path) + 14;
906 >        for (i=0; i<argc; i++) {
907 >                // +1 for space prefix
908 >                cmdline_len += strlen(argv[i]) +1;
909 >        }
910 >
911 >        cmdline = malloc(cmdline_len);
912 >        if(cmdline == NULL) {
913 >                log_msg(LOG_CRIT, "out of memory");
914 >                return 0;
915 >        }
916 >        tmp = malloc(cmdline_len);
917 >        if(tmp == NULL) {
918 >                log_msg(LOG_CRIT, "out of memory");
919 >                free(cmdline);
920 >                return 0;
921 >        }
922 >
923 >        // Compile up the final command line call
924 >        snprintf(cmdline, cmdline_len, "\"%s\" -w service", path);
925 >        for (i=0; i<argc; i++) {
926 >                snprintf(tmp, cmdline_len, " %s", argv[i]);
927 >                strcat(cmdline, tmp);
928 >        }
929 >        free(tmp);
930 >
931 >        // Open SCM
932 >        if((scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE)) == NULL) {
933 >                log_msg(LOG_CRIT, "Unable to open Service Control Manager");
934 >                return 0;
935 >        }
936 >
937 >        // Add the service
938 >        if (CreateService(scm, SERVICENAME, SERVICENAME,
939 >                        SC_MANAGER_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
940 >                        SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, cmdline, NULL,
941 >                        NULL, NULL, NULL, NULL) == NULL) {
942 >                log_msg(LOG_CRIT, "Unable to create service");
943 >                return 0;
944 >        }
945 >
946 >        return 1;
947 > }
948 >
949 > int unregister_service() {
950 >        SC_HANDLE scm;
951 >        SC_HANDLE service;
952 >
953 >        // Open the SCM
954 >        if((scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE)) ==NULL) {
955 >                log_msg(LOG_CRIT, "Unable to open Service Control Manager");
956 >                return 0;
957 >        }
958 >        // Get the service
959 >        if((service = OpenService(scm, SERVICENAME, SC_MANAGER_ALL_ACCESS)) == NULL) {
960 >                log_msg(LOG_CRIT, "Unable to locate the service");
961 >                return 0;
962 >        }
963 >        // Delete service
964 >        if(DeleteService(service) == 0) {
965 >                log_msg(LOG_CRIT, "Unable to remove the service");
966 >                return 0;
967 >        }
968 >        return 1;
969 > }
970 > #endif
971 >
972 >
973 >
974   void usage(char *progname){
975 <        fprintf(stderr, "Usage %s [options] server port\n", progname);
976 <        fprintf(stderr, "Options\n");
977 <        fprintf(stderr, "  -v           Verbose mode,-vv would make even more verbose\n");
978 <        fprintf(stderr, "  -f           Foreground mode, print errors to stderr\n");
979 <        fprintf(stderr, "  -V           Print version number\n");
980 <        fprintf(stderr, "  -h           Prints this help page\n");
981 <        exit(1);
975 >        const char *usage;
976 > #ifdef WIN32
977 >        usage = "Usage %s [-w option] [-v[v]] [-n name] [-i ip] [-s server] [-p port] [-V] [-h]\n\n";
978 > #else
979 >        usage = "Usage %s [-v[v]] [-f] [-n name] [-i ip] [-s server] [-p port] [-V] [-h]\n\n";
980 > #endif
981 >        fprintf(stderr, usage, progname);
982 >        fprintf(stderr, "  -v    Verbose mode, -vv would make even more verbose\n");
983 > #ifndef WIN32
984 >        fprintf(stderr, "  -f    Foreground mode, print errors to stderr\n");
985 > #else
986 >        fprintf(stderr, "  -w    Windows Service options:\n");
987 >        fprintf(stderr, "     start      - start the service\n");
988 >        fprintf(stderr, "     stop       - stop the service\n");
989 >        fprintf(stderr, "     register   - register the service\n");
990 >        fprintf(stderr, "     unregister - unregister the service\n");
991 >        /* service - run as a service, only called by windows service */
992 > #endif
993 >        fprintf(stderr, "  -n    Set the machine name to be reported as\n");
994 >        fprintf(stderr, "  -i    Set the IP to be reported as\n");
995 >        fprintf(stderr, "  -s    Specifies the i-scream server to connect to\n");
996 >        fprintf(stderr, "         default: %s\n", DEF_SERVER_NAME);
997 >        fprintf(stderr, "  -p    Specifies the i-scream server port\n");
998 >        fprintf(stderr, "         default: %d\n", DEF_SERVER_PORT);
999 >        fprintf(stderr, "  -V    Print version number\n");
1000 >        fprintf(stderr, "  -h    Prints this help page\n");
1001 >        fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
1002 >        exit(1);
1003   }
1004  
1005 < int main(int argc, char **argv){
1005 > int run_ihost(){
1006  
637        ihost_state_t ihost_state;
1007          udp_sockinfo_t udp_sockinfo;
1008 <        
640 <        int cmdopt;
641 <        extern int optind;
1008 >
1009          pid_t pid;
1010          FILE *f;
1011          int packet_num=0;
# Line 647 | Line 1014 | int main(int argc, char **argv){
1014          char packet[MAX_UDP_PACKET_SIZE];
1015  
1016          time_t cur_time, sleep_delay, udp_time=0, config_time=0;
1017 + #ifdef WIN32
1018 +        int tries=0;
1019 +        WSADATA wsaData;
1020  
1021 <        /* Set default settings */      
1022 <        ihost_config.verbose=1;
1023 <        ihost_config.daemon=1;
1024 <        /* Set all errors to go down stderr until told otherwise */
1025 <        ihost_config.log=stderr;
1021 >        if(WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) {
1022 >                log_msg(LOG_CRIT, "Failed to init a winsock");
1023 >                service_stopped();
1024 >                exit(1);
1025 >        }
1026 > #endif
1027  
657        /* Blank ihost_state to default settings */
658        ihost_state.filtermanager_host=NULL;
659        ihost_state.host_fqdn=NULL;
660        ihost_state.host_ip=NULL;
661        ihost_state.server_fqdn=NULL;
662        ihost_state.file_list=NULL;
663        ihost_state.last_modified=NULL;
664
665        while((cmdopt=getopt(argc, argv, "vfhV")) != -1){
666                switch(cmdopt){
667                        case 'v':
668                                ihost_config.verbose++;
669                                break;
670
671                        case 'f':
672                                /* Force syslog logging since stderr will be closed in this case */
673                                ihost_config.daemon=0;
674                                break;
675
676                        case 'h':
677                                usage(argv[0]);
678                                break;
679
680                        case 'V':
681                                fprintf(stderr, "%s version %s\n", argv[0], VERSION);
682                                break;
683
684                        default:
685                                usage(argv[0]);
686                                exit(1);
687                }
688        }
689
690        if(argc!=optind+2){
691                usage(argv[0]);
692                exit(1);
693        }
694
695        ihost_state.filtermanager_host=strdup(argv[optind]);
696        ihost_state.filtermanager_port=atoi(argv[optind+1]);
697        
1028          if(gethostbyname(ihost_state.filtermanager_host)==NULL){
1029 +                printf("%s\n", ihost_state.filtermanager_host);
1030                  log_msg(LOG_CRIT, "Failed to lookup hostname. Please check settings");
1031 <                exit(1);
1031 >                goto out;
1032          }
1033          if(ihost_state.filtermanager_port==0){
1034                  log_msg(LOG_ERR, "Invalid port number");
1035 <                exit(1);
1035 >                goto out;
1036          }
1037  
1038 + #ifndef WIN32
1039          if(ihost_config.daemon){
1040                  pid=fork();
1041                  if(pid==-1){
1042                          log_msg(LOG_CRIT, "Failed to background exiting");
1043 <                        exit(1);        
1043 >                        exit(1);
1044                  }else if(pid!=0){
1045 <                        /* Parent process */
1046 <                        return 0;
1047 <                }
1048 <                /* We should now be in the background*/
1049 <                if(setsid()==-1){
1050 <                        log_msg(LOG_CRIT, "setsid failed");
1051 <                        exit(1);
1052 <                }
1053 <        
1045 >                        /* Parent process */
1046 >                        return 0;
1047 >                }
1048 >                /* We should now be in the background*/
1049 >                if(setsid()==-1){
1050 >                        log_msg(LOG_CRIT, "setsid failed");
1051 >                        exit(1);
1052 >                }
1053 >
1054                  if((ihost_config.log=fopen(LOG_FILE, "a"))==NULL){
1055                          ihost_config.log=stderr;
1056                          log_msg(LOG_CRIT, "Failed to open Logfiles %s for writing", LOG_FILE);
1057                          exit(1);
1058                  }
1059  
1060 <                fclose(stdin);
1061 <                fclose(stdout);
1062 <                fclose(stderr);
1060 >                fclose(stdin);
1061 >                fclose(stdout);
1062 >                fclose(stderr);
1063  
1064 <        }
1064 >        }
1065 > #endif
1066  
1067 <        log_msg(LOG_INFO, "Starting ihost");
735 <        
736 <        log_msg(LOG_DEBUG,"Writing PID FILE");
1067 >        log_msg(LOG_INFO, "Starting ihost...");
1068  
1069 <        pid=getpid();
1069 >        log_msg(LOG_DEBUG, "Running sg_init()");
1070 >        if(sg_init()){
1071 >                log_msg(LOG_CRIT, "sg_init failed: %s (%s)",
1072 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
1073 >                goto out;
1074 >        }
1075 >        if(sg_snapshot()) {
1076 >                log_msg(LOG_ERR, "sg_snapshot failed: %s (%s)",
1077 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
1078 >        }
1079  
1080 <        if((f=fopen(PID_FILE,"w")) == NULL){
1081 <                log_msg(LOG_CRIT, "Failed to write PID file");
742 <        }else{
743 <                if((fprintf(f,"%d",(int)pid)) <= 0 ){
744 <                        log_msg(LOG_CRIT, "Failed to write PID file");
745 <                }
746 <                if((fclose(f))!=0){
747 <                        log_msg(LOG_CRIT, "failed to close PID file");
748 <                }
749 <        }
1080 > #ifndef WIN32
1081 >        log_msg(LOG_DEBUG,"Writing PID FILE");
1082  
1083 <        /* Get the initial config from the filter manager. Should this fail,
1083 >        pid=getpid();
1084 >
1085 >        if((f=fopen(PID_FILE,"w")) == NULL){
1086 >                log_msg(LOG_CRIT, "Failed to write PID file");
1087 >        }else{
1088 >                if((fprintf(f,"%d",(int)pid)) <= 0 ){
1089 >                        log_msg(LOG_CRIT, "Failed to write PID file");
1090 >                }
1091 >                if((fclose(f))!=0){
1092 >                        log_msg(LOG_CRIT, "failed to close PID file");
1093 >                }
1094 >        }
1095 > #endif
1096 >
1097 >        /* Get the initial config from the filter manager. Should this fail,
1098           * wait, and then try again. */
1099 +        /* Win32 - for a max of one minute */
1100  
1101 <        get_diskio_stats_diff(&packet_num);
1101 >        sg_get_disk_io_stats_diff(&packet_num);
1102          packet_num=0;
1103  
1104 <        while(ihost_getconfig(&ihost_state)!=0){
1104 >        while(ihost_getconfig(&ihost_state)!=0
1105 > #ifdef WIN32
1106 >                        && (tries<6)
1107 > #endif
1108 >                        ){
1109                  log_msg(LOG_ERR, "Failed to get ihost config");
1110 <                sleep(10);
1110 >                sleep(SLEEP);
1111 > #ifdef WIN32
1112 >                tries++;
1113 > #endif
1114          }
1115  
1116 <        printf("%s\n%d\n", ihost_state.server_fqdn, ihost_state.server_udp_port);
1117 <        while((create_udp_sockinfo(&udp_sockinfo, ihost_state.server_fqdn, ihost_state.server_udp_port))!=0){
1118 <                log_msg(LOG_ERR, "Failed to create udp socket");        
1119 <                sleep(10);
1116 > #ifdef WIN32
1117 >        if (tries == 6) {
1118 >                log_msg(LOG_ERR, "Giving up");
1119 >                goto out;
1120          }
1121 +        tries = 0;
1122 + #endif
1123  
1124 +        while((create_udp_sockinfo(&udp_sockinfo, ihost_state.server_fqdn, ihost_state.server_udp_port))!=0
1125 + #ifdef WIN32
1126 +                        && (tries<6)
1127 + #endif
1128 +                        ){
1129 +                log_msg(LOG_ERR, "Failed to create udp socket");
1130 +                sleep(SLEEP);
1131 + #ifdef WIN32
1132 +                tries++;
1133 + #endif
1134 +        }
1135 +
1136 + #ifdef WIN32
1137 +        if (tries == 6) {
1138 +                log_msg(LOG_ERR, "Giving up");
1139 +                goto out;
1140 +        }
1141 + #endif
1142 +
1143          config_time=time(NULL)+ihost_state.config_ttl;
1144  
1145 + #ifdef WIN32
1146 +        /* Finally, we have started successfully!
1147 +         * We set state to running even for non-service calls so the while
1148 +         * loop works. Bit of a hack ;)
1149 +         */
1150 +        service_status.dwCurrentState = SERVICE_RUNNING;
1151 +        if(run_as_service) {
1152 +                SetServiceStatus(hstatus, &service_status);
1153 +        }
1154 +        printf("started\n");
1155 + #endif
1156 +
1157          /* Now have config.. collect data and send as often as required */
1158 <        for(;;){
1158 > #ifdef WIN32
1159 >        while(service_status.dwCurrentState == SERVICE_RUNNING)
1160 > #else
1161 >        for(;;)
1162 > #endif
1163 >        {
1164                  cur_time=time(NULL);
1165  
1166                  if(cur_time>=udp_time){
1167 +                        if(sg_snapshot()) {
1168 +                                log_msg(LOG_ERR, "sg_snapshot failed: %s (%s)",
1169 +                                        sg_str_error(sg_get_error()), sg_get_error_arg());
1170 +                                continue; /* Could this get ugly? */
1171 +                        }
1172                          if((get_system_stats(packet_num++, &ihost_state, packet, MAX_UDP_PACKET_SIZE))!=0){
1173                                  log_msg(LOG_ERR, "Failed to get system stats");
1174                          }
1175  
1176                          len=strlen(packet);
1177                          log_msg(LOG_DEBUG, "Packet size: %d\nPacket: %s\n", len, packet);
1178 <                        
1178 >
1179                          if((sendto(udp_sockinfo.sock, packet, len, 0, (struct sockaddr *) &udp_sockinfo.addr, sizeof(udp_sockinfo.addr)))!=len){
1180                                  log_msg(LOG_CRIT, "Failed to send packet");
1181                          }
1182                          udp_time=cur_time+ihost_state.udp_update_time;
1183                          log_msg(LOG_DEBUG, "Next packet should be sent on %d", udp_time);
1184                  }
1185 <                
1185 >
1186                  if(cur_time>=config_time){
1187                          if(ihost_getconfig(&ihost_state)!=0){
1188                                  /* If we can't get the config, try again 5 minutes time */
# Line 794 | Line 1191 | int main(int argc, char **argv){
1191                          }else{
1192                                  close(udp_sockinfo.sock);
1193  
1194 <                                while((create_udp_sockinfo(&udp_sockinfo, ihost_state.server_fqdn, ihost_state.server_udp_port))!=0){
1195 <                                        log_msg(LOG_CRIT, "Failed to create udp socket");
1196 <                                        sleep(10);
1194 >                                while((create_udp_sockinfo(&udp_sockinfo, ihost_state.server_fqdn, ihost_state.server_udp_port))!=0){
1195 >                                        log_msg(LOG_CRIT, "Failed to create udp socket");
1196 >                                        sleep(SLEEP);
1197                                  }
1198  
1199                                  config_time=time(NULL)+ihost_state.config_ttl;
# Line 807 | Line 1204 | int main(int argc, char **argv){
1204  
1205                  sleep_delay=udp_time-time(NULL);
1206                  log_msg(LOG_DEBUG, "Sleeping for %d", sleep_delay);
1207 + #ifdef WIN32
1208 +                /* convert to millisecs */
1209 +                sleep_delay *= 1000;
1210 + #endif
1211                  if(sleep_delay>0) sleep(sleep_delay);
1212 <        }
1213 <                        
1212 >        }
1213 >
1214 >        if(sg_shutdown()) {
1215 >                log_msg(LOG_ERR, "sg_shutdown failed: %s (%s)",
1216 >                        sg_str_error(sg_get_error()), sg_get_error_arg());
1217 >        }
1218 >
1219 > #ifdef WIN32
1220 >        WSACleanup();
1221 >        if(run_as_service) {
1222 >                service_status.dwWin32ExitCode = 0;
1223 >                service_status.dwCurrentState = SERVICE_STOPPED;
1224 >                SetServiceStatus(hstatus, &service_status);
1225 >        }
1226 > #endif
1227 >        log_msg(LOG_ERR, "ihost shutdown successfully");
1228 >        fclose(ihost_config.log);
1229 >
1230          return(0);
1231 +
1232 + out:
1233 + #ifdef WIN32
1234 +        WSACleanup();
1235 +        service_stopped();
1236 + #endif
1237 +        exit(1);
1238 + }
1239 +
1240 + #ifdef WIN32
1241 + int service_main(int argc, char **argv) {
1242 +        int error;
1243 +
1244 +        service_status.dwServiceType = SERVICE_WIN32;
1245 +        service_status.dwCurrentState = SERVICE_START_PENDING;
1246 +        service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP |
1247 +                SERVICE_ACCEPT_SHUTDOWN;
1248 +        service_status.dwWin32ExitCode = 0;
1249 +        service_status.dwServiceSpecificExitCode = 0;
1250 +        service_status.dwCheckPoint = 0;
1251 +        service_status.dwWaitHint = 0;
1252 +
1253 +        hstatus = RegisterServiceCtrlHandler(SERVICENAME,
1254 +                        (LPHANDLER_FUNCTION)control_handler);
1255 +        if(hstatus == (SERVICE_STATUS_HANDLE)0) {
1256 +                log_msg(LOG_CRIT, "RegisterServiceCtrlHandle failed");
1257 +                return -1;
1258 +        }
1259 +
1260 +        return run_ihost();
1261 + }
1262 +
1263 +
1264 + void parse_w(int argc, char **argv) {
1265 +        if (strcasecmp(optarg, "start") == 0) {
1266 +                log_msg(LOG_ERR, "Attempting to start service...");
1267 +                run_server = 0;
1268 +                if(start_service())
1269 +                        log_msg(LOG_ERR, "Service started");
1270 +        } else if (strcasecmp(optarg, "stop") == 0) {
1271 +                log_msg(LOG_ERR, "Attempting to stop service...");
1272 +                run_server = 0;
1273 +                if(stop_service())
1274 +                        log_msg(LOG_ERR, "Service stopped");
1275 +        } else if (strcasecmp(optarg, "service") == 0) {
1276 +                run_as_service = 1;
1277 +        } else if (strcasecmp(optarg, "register") == 0) {
1278 +                log_msg(LOG_ERR, "Attempting to register service...");
1279 +                run_server = 0;
1280 +                int i = optind;
1281 +                optind = argc;
1282 +                /* Grab the remaining arguments and use each time the service
1283 +                 * is started */
1284 +                if (register_service(argc-i, &argv[i]))
1285 +                        log_msg(LOG_ERR, "Registered service successfully");
1286 +        } else if (strcasecmp(optarg, "unregister") == 0) {
1287 +                log_msg(LOG_ERR, "Attempting to unregister service...");
1288 +                run_server = 0;
1289 +                if(unregister_service())
1290 +                        log_msg(LOG_ERR, "Unregistered service successfully");
1291 +        } else {
1292 +                fprintf(stderr, "Unknown -w option\n");
1293 +                usage(argv[0]);
1294 +                exit(1);
1295 +        }
1296 + }
1297 + #endif
1298 +
1299 +
1300 + int main(int argc, char **argv){
1301 +        int cmdopt;
1302 +        extern int optind;
1303 +
1304 +        /* Set default settings */
1305 +        ihost_config.verbose=1;
1306 +        ihost_config.daemon=1;
1307 +        /* Set all errors to go down stderr until told otherwise */
1308 +        ihost_config.log=stderr;
1309 +
1310 +        /* Blank ihost_state to default settings */
1311 +        ihost_state.filtermanager_host=DEF_SERVER_NAME;
1312 +        ihost_state.filtermanager_port=DEF_SERVER_PORT;
1313 +        ihost_state.host_fqdn=NULL;
1314 +        ihost_state.host_ip=NULL;
1315 +        ihost_state.preset_fqdn = 0;
1316 +        ihost_state.preset_ip = 0;
1317 +        ihost_state.server_fqdn=NULL;
1318 +        ihost_state.file_list=NULL;
1319 +        ihost_state.last_modified=NULL;
1320 +
1321 +        while((cmdopt=getopt(argc, argv, OPTSTRING)) != -1){
1322 +                switch(cmdopt){
1323 +                        case 'v':
1324 +                                ihost_config.verbose++;
1325 +                                break;
1326 +
1327 + #ifndef WIN32
1328 +                        case 'f':
1329 +                                /* Force syslog logging since stderr will be closed in this case */
1330 +                                ihost_config.daemon=0;
1331 +                                break;
1332 + #endif
1333 +
1334 +                        case 'V':
1335 +                                fprintf(stderr, "%s version %s\n", argv[0], VERSION);
1336 +                                break;
1337 +                        case 'n':
1338 +                                ihost_state.preset_fqdn = 1;
1339 +                                ihost_state.host_fqdn = strdup(optarg);
1340 +                                if(ihost_state.host_fqdn == NULL){
1341 +                                        fprintf(stderr, "Missing hostname\n");
1342 +                                        usage(argv[0]);
1343 +                                }
1344 +                                break;
1345 +                        case 'i':
1346 +                                /* Hmm.. Someone could set any string to be the IP, and it will let it */
1347 +                                ihost_state.preset_ip = 1;
1348 +                                ihost_state.host_ip = strdup(optarg);
1349 +                                if(ihost_state.host_ip == NULL){
1350 +                                        fprintf(stderr, "Missing ip\n");
1351 +                                        usage(argv[0]);
1352 +                                }
1353 +                                break;
1354 +
1355 +                        case 's':
1356 +                                ihost_state.filtermanager_host=strdup(optarg);
1357 +                                break;
1358 +
1359 +                        case 'p':
1360 +                                ihost_state.filtermanager_port=atoi(optarg);
1361 +                                break;
1362 +
1363 + #ifdef WIN32
1364 +                        case 'w':
1365 +                                parse_w(argc, argv);
1366 +                                break;
1367 + #endif
1368 +
1369 +                        case 'h':
1370 +                        default:
1371 +                                usage(argv[0]);
1372 +                                exit(1);
1373 +                }
1374 +        }
1375 +
1376 + #ifdef WIN32
1377 +        if (run_server) {
1378 +                if(run_as_service) {
1379 +                        if((ihost_config.log=fopen(LOG_FILE, "a"))==NULL){
1380 +                                ihost_config.log=stderr;
1381 +                                log_msg(LOG_CRIT, "Failed to open Logfiles %s for writing", LOG_FILE);
1382 +                                exit(1);
1383 +                        }
1384 +                        log_msg(LOG_ERR, "Starting Service-Mode i-host");
1385 +                        SERVICE_TABLE_ENTRY service_table[2];
1386 +                        service_table[0].lpServiceName = SERVICENAME;
1387 +                        service_table[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)service_main;
1388 +                        service_table[1].lpServiceName = NULL;
1389 +                        service_table[1].lpServiceProc = NULL;
1390 +                        return StartServiceCtrlDispatcher(service_table);
1391 +                } else {
1392 +                        log_msg(LOG_ERR, "Starting User-Mode i-host");
1393 +                        return run_ihost();
1394 +                }
1395 +        }
1396 + #else
1397 +        return run_ihost();
1398 + #endif
1399   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines