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

Comparing projects/libstatgrab/src/libstatgrab/tools.c (file contents):
Revision 1.29 by tdb, Sat Feb 14 12:38:18 2004 UTC vs.
Revision 1.45 by ats, Tue Apr 6 17:55:16 2004 UTC

# Line 1 | Line 1
1   /*
2 < * i-scream central monitoring system
2 > * i-scream libstatgrab
3   * http://www.i-scream.org
4   * Copyright (C) 2000-2004 i-scream
5   *
# Line 34 | Line 34
34   #ifdef ALLBSD
35   #include <fcntl.h>
36   #endif
37 < #ifdef FREEBSD
37 > #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
38   #include <kvm.h>
39 + #include <paths.h>
40   #endif
41   #if defined(NETBSD) || defined(OPENBSD)
42   #include <uvm/uvm_extern.h>
# Line 73 | Line 74 | static mapping_t *mapping = NULL;
74   #endif
75  
76   #ifdef SOLARIS
77 < char *get_svr_from_bsd(char *bsd){
77 > const char *sg_get_svr_from_bsd(const char *bsd){
78   #ifdef HAVE_LIBDEVINFO_H
79          mapping_t *map_ptr;
80          for(map_ptr = mapping; map_ptr != NULL; map_ptr = map_ptr->next)
# Line 84 | Line 85 | char *get_svr_from_bsd(char *bsd){
85   #endif
86  
87   #if defined(SOLARIS) && defined(HAVE_LIBDEVINFO_H)
88 < void add_mapping(char *bsd, char *svr){
88 > static void add_mapping(char *bsd, char *svr){
89          mapping_t *map_ptr;
90          mapping_t *map_end_ptr;
91  
91        bsd = strdup(bsd);
92        svr = strdup(svr);
93
92          if (mapping == NULL){
93                  mapping = malloc(sizeof(mapping_t));
94                  if (mapping == NULL) return;
# Line 113 | Line 111 | void add_mapping(char *bsd, char *svr){
111          }
112  
113          map_ptr->next = NULL;
114 <        map_ptr->bsd = bsd;
115 <        map_ptr->svr = svr;
114 >        map_ptr->bsd = strdup(bsd);
115 >        map_ptr->svr = strdup(svr);
116  
117          return;
118   }
119  
120 < char *read_dir(char *disk_path){
120 >
121 > static char *read_dir(char *disk_path){
122          DIR *dirp;
123          struct dirent *dp;
124          struct stat stbuf;
# Line 161 | Line 160 | char *read_dir(char *disk_path){
160   }
161  
162  
163 <
165 < int get_alias(char *alias){
163 > static int get_alias(char *alias){
164          char file[MAXPATHLEN];
165          di_node_t root_node;
166          di_node_t node;
# Line 173 | Line 171 | int get_alias(char *alias){
171          char *value;
172          int instance;
173          if ((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
174 <                return 1;
174 >                return -1;
175          }
176          node = di_drv_first_node(alias, root_node);
177          while (node != DI_NODE_NIL) {
# Line 183 | Line 181 | int get_alias(char *alias){
181                          minor_name = di_minor_name(minor);
182                          strcpy(tmpnode, alias);
183                          sprintf(tmpnode, "%s%d", tmpnode, instance);
184 <                        strlcpy(file, "/devices", sizeof file);
185 <                        strlcat(file, phys_path, sizeof file);
186 <                        strlcat(file, ":", sizeof file);
187 <                        strlcat(file, minor_name, sizeof file);
184 >                        sg_strlcpy(file, "/devices", sizeof file);
185 >                        sg_strlcat(file, phys_path, sizeof file);
186 >                        sg_strlcat(file, ":", sizeof file);
187 >                        sg_strlcat(file, minor_name, sizeof file);
188                          value = read_dir(file);
189                          if (value != NULL){
190                                  add_mapping(tmpnode, value);
# Line 203 | Line 201 | int get_alias(char *alias){
201  
202  
203   #define BIG_ENOUGH 512
204 < int build_mapping(){
204 > static int build_mapping(){
205          char device_name[BIG_ENOUGH];
206          int x;
207          kstat_ctl_t *kc;
# Line 215 | Line 213 | int build_mapping(){
213          int found;
214  
215          if ((kc = kstat_open()) == NULL) {
216 <                return;
216 >                return -1;
217          }
218  
219          for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
# Line 237 | Line 235 | int build_mapping(){
235                                  if (x>=BIG_ENOUGH){
236                                          /* We've got bigger than we thought was massive */
237                                          /* If we hit this.. Make big enough bigger */
238 <                                        return 1;
238 >                                        return -1;
239                                  }
240                                  if( !strncmp(driver_list[x], device_name, BIG_ENOUGH)){
241                                          found = 1;
# Line 247 | Line 245 | int build_mapping(){
245  
246                          if(!found){
247                                  if((get_alias(device_name)) != 0){
248 <                                        return 1;
248 >                                        return -1;
249                                  }
250                                  strncpy(driver_list[x], device_name, BIG_ENOUGH);
251                                  list_entries++;
# Line 262 | Line 260 | int build_mapping(){
260  
261  
262  
263 < char *f_read_line(FILE *f, const char *string){
263 > char *sg_f_read_line(FILE *f, const char *string){
264          /* Max line length. 8k should be more than enough */
265          static char line[8192];
266  
# Line 275 | Line 273 | char *f_read_line(FILE *f, const char *string){
273          return NULL;
274   }
275  
276 < char *get_string_match(char *line, regmatch_t *match){
276 > char *sg_get_string_match(char *line, regmatch_t *match){
277          int len=match->rm_eo - match->rm_so;
278          char *match_string=malloc(len+1);
279  
# Line 307 | Line 305 | static long long atoll(const char *s) {
305   }
306   #endif
307  
310 #ifndef HAVE_STRLCPY
308   /*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
309  
310   /*
# Line 331 | Line 328 | static long long atoll(const char *s) {
328   * will be copied.  Always NUL terminates (unless siz == 0).
329   * Returns strlen(src); if retval >= siz, truncation occurred.
330   */
331 < size_t strlcpy(char *dst, const char *src, size_t siz){
331 > size_t sg_strlcpy(char *dst, const char *src, size_t siz){
332          register char *d = dst;
333          register const char *s = src;
334          register size_t n = siz;
# Line 354 | Line 351 | size_t strlcpy(char *dst, const char *src, size_t siz)
351  
352          return(s - src - 1);    /* count does not include NUL */
353   }
357 #endif
354  
359 #ifndef HAVE_STRLCAT
355   /*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
356  
357   /*
# Line 382 | Line 377 | size_t strlcpy(char *dst, const char *src, size_t siz)
377   * Returns strlen(src) + MIN(siz, strlen(initial dst)).
378   * If retval >= siz, truncation occurred.
379   */
380 < size_t strlcat(char *dst, const char *src, size_t siz){
380 > size_t sg_strlcat(char *dst, const char *src, size_t siz){
381          register char *d = dst;
382          register const char *s = src;
383          register size_t n = siz;
# Line 408 | Line 403 | size_t strlcat(char *dst, const char *src, size_t siz)
403          return(dlen + (s - src));       /* count does not include NUL */
404   }
405  
406 < #endif
406 > int sg_update_string(char **dest, const char *src) {
407 >        char *new;
408  
409 < long long get_ll_match(char *line, regmatch_t *match){
409 >        if (src == NULL) {
410 >                /* We're being told to set it to NULL. */
411 >                free(*dest);
412 >                *dest = NULL;
413 >                return 0;
414 >        }
415 >
416 >        new = realloc(*dest, strlen(src) + 1);
417 >        if (new == NULL) {
418 >                return -1;
419 >        }
420 >
421 >        strcpy(new, src);
422 >        *dest = new;
423 >        return 0;
424 > }
425 >
426 > long long sg_get_ll_match(char *line, regmatch_t *match){
427          char *ptr;
428          long long num;
429  
# Line 420 | Line 433 | long long get_ll_match(char *line, regmatch_t *match){
433          return num;
434   }
435  
436 < #ifdef FREEBSD
437 < kvm_t *get_kvm() {
436 > #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
437 > kvm_t *sg_get_kvm() {
438          static kvm_t *kvmd = NULL;
439  
440          if (kvmd != NULL) {
# Line 431 | Line 444 | kvm_t *get_kvm() {
444          kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
445          return kvmd;
446   }
447 +
448 + /* Can't think of a better name for this function */
449 + kvm_t *sg_get_kvm2() {
450 +        static kvm_t *kvmd2 = NULL;
451 +
452 +        if (kvmd2 != NULL) {
453 +                return kvmd2;
454 +        }
455 +
456 +        kvmd2 = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
457 +        return kvmd2;
458 + }
459   #endif
460  
461   #if defined(NETBSD) || defined(OPENBSD)
462 < struct uvmexp *get_uvmexp() {
462 > struct uvmexp *sg_get_uvmexp() {
463          int mib[2];
464 <        size_t size;
465 <        static struct uvmexp *uvm = NULL;
464 >        size_t size = sizeof(struct uvmexp);
465 >        static struct uvmexp uvm;
466 >        struct uvmexp *new;
467  
468          mib[0] = CTL_VM;
469          mib[1] = VM_UVMEXP;
470  
471 <        if (sysctl(mib, 2, NULL, &size, NULL, 0) < 0) {
471 >        if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
472                  return NULL;
473          }
474  
475 <        uvm = realloc(uvm, size);
450 <        if (uvm == NULL) {
451 <                return NULL;
452 <        }
453 <
454 <        if (sysctl(mib, 2, uvm, &size, NULL, 0) < 0) {
455 <                return NULL;
456 <        }
457 <
458 <        return uvm;
475 >        return &uvm;
476   }
477   #endif
478  
479 < int statgrab_init(){
480 < #ifdef FREEBSD
481 <        {
482 <                kvm_t *kvmd = get_kvm();
466 <                if (kvmd == NULL) return 1;
479 > int sg_init(){
480 > #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
481 >        if (sg_get_kvm() == NULL) {
482 >                return -1;
483          }
484 < #endif
485 < #ifdef NETBSD
470 <        {
471 <                struct uvmexp *uvm = get_uvmexp();
472 <                if (uvm == NULL) return 1;
484 >        if (sg_get_kvm2() == NULL) {
485 >                return -1;
486          }
487   #endif
488   #ifdef SOLARIS
# Line 484 | Line 497 | int statgrab_init(){
497          return 0;
498   }
499  
500 < int statgrab_drop_privileges() {
500 > int sg_drop_privileges() {
501          if (setegid(getgid()) != 0) return -1;
502          if (seteuid(getuid()) != 0) return -1;
503          return 0;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines