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.48 by ats, Wed Apr 7 10:33:50 2004 UTC vs.
Revision 1.60 by tdb, Sat Nov 6 19:09:00 2004 UTC

# Line 30 | Line 30
30   #include <stdlib.h>
31   #include <unistd.h>
32   #include <sys/types.h>
33 – #include <regex.h>
33   #ifdef ALLBSD
34   #include <fcntl.h>
35   #endif
# Line 43 | Line 42
42   #include <sys/param.h>
43   #include <sys/sysctl.h>
44   #endif
45 + #ifdef HPUX
46 + #include <sys/param.h>
47 + #include <sys/pstat.h>
48 + #endif
49  
50   #include "tools.h"
51   #include "statgrab.h"
# Line 155 | Line 158 | static char *read_dir(char *disk_path){
158                          file_name[x] = '\0';
159                          if (strcmp(file_name, temp_name) == 0) {
160                                  if (sg_update_string(&svr_name,
161 <                                                     dp->d_name) < 0) {
161 >                                                     dp->d_name) < 0) {
162                                          return NULL;
163                                  }
164                                  closedir(dirp);
# Line 266 | Line 269 | static int build_mapping(){
269  
270   #endif
271  
272 <
270 <
272 > #if defined(LINUX) || defined(CYGWIN)
273   char *sg_f_read_line(FILE *f, const char *string){
274          /* Max line length. 8k should be more than enough */
275          static char line[8192];
# Line 278 | Line 280 | char *sg_f_read_line(FILE *f, const char *string){
280                  }
281          }
282  
283 +        sg_set_error(SG_ERROR_PARSE, NULL);
284          return NULL;
285   }
286  
# Line 291 | Line 294 | char *sg_get_string_match(char *line, regmatch_t *matc
294          return match_string;
295   }
296  
297 <
295 <
297 > /* FIXME do Linux and Cygwin always have atoll? */
298   #ifndef HAVE_ATOLL
299   static long long atoll(const char *s) {
300          long long value = 0;
# Line 313 | Line 315 | static long long atoll(const char *s) {
315   }
316   #endif
317  
318 + long long sg_get_ll_match(char *line, regmatch_t *match){
319 +        char *ptr;
320 +        long long num;
321 +
322 +        ptr=line+match->rm_so;
323 +        num=atoll(ptr);
324 +
325 +        return num;
326 + }
327 + #endif
328 +
329   /*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
330  
331   /*
# Line 337 | Line 350 | static long long atoll(const char *s) {
350   * Returns strlen(src); if retval >= siz, truncation occurred.
351   */
352   size_t sg_strlcpy(char *dst, const char *src, size_t siz){
353 <        register char *d = dst;
354 <        register const char *s = src;
355 <        register size_t n = siz;
353 >        register char *d = dst;
354 >        register const char *s = src;
355 >        register size_t n = siz;
356  
357 <        /* Copy as many bytes as will fit */
358 <        if (n != 0 && --n != 0) {
359 <                do {
360 <                        if ((*d++ = *s++) == 0)
361 <                                break;
362 <                } while (--n != 0);
363 <        }
357 >        /* Copy as many bytes as will fit */
358 >        if (n != 0 && --n != 0) {
359 >                do {
360 >                        if ((*d++ = *s++) == 0)
361 >                                break;
362 >                } while (--n != 0);
363 >        }
364  
365 <        /* Not enough room in dst, add NUL and traverse rest of src */
366 <        if (n == 0) {
367 <                if (siz != 0)
368 <                        *d = '\0';              /* NUL-terminate dst */
369 <                while (*s++)
370 <                        ;
371 <        }
365 >        /* Not enough room in dst, add NUL and traverse rest of src */
366 >        if (n == 0) {
367 >                if (siz != 0)
368 >                        *d = '\0';            /* NUL-terminate dst */
369 >                while (*s++)
370 >                        ;
371 >        }
372  
373 <        return(s - src - 1);    /* count does not include NUL */
373 >        return(s - src - 1);    /* count does not include NUL */
374   }
375  
376   /*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
# Line 386 | Line 399 | size_t sg_strlcpy(char *dst, const char *src, size_t s
399   * If retval >= siz, truncation occurred.
400   */
401   size_t sg_strlcat(char *dst, const char *src, size_t siz){
402 <        register char *d = dst;
403 <        register const char *s = src;
404 <        register size_t n = siz;
405 <        size_t dlen;
402 >        register char *d = dst;
403 >        register const char *s = src;
404 >        register size_t n = siz;
405 >        size_t dlen;
406  
407 <        /* Find the end of dst and adjust bytes left but don't go past end */
408 <        while (n-- != 0 && *d != '\0')
409 <                d++;
410 <        dlen = d - dst;
411 <        n = siz - dlen;
407 >        /* Find the end of dst and adjust bytes left but don't go past end */
408 >        while (n-- != 0 && *d != '\0')
409 >                d++;
410 >        dlen = d - dst;
411 >        n = siz - dlen;
412  
413 <        if (n == 0)
414 <                return(dlen + strlen(s));
415 <        while (*s != '\0') {
416 <                if (n != 1) {
417 <                        *d++ = *s;
418 <                        n--;
419 <                }
420 <                s++;
421 <        }
422 <        *d = '\0';
413 >        if (n == 0)
414 >                return(dlen + strlen(s));
415 >        while (*s != '\0') {
416 >                if (n != 1) {
417 >                        *d++ = *s;
418 >                        n--;
419 >                }
420 >                s++;
421 >        }
422 >        *d = '\0';
423  
424 <        return(dlen + (s - src));       /* count does not include NUL */
424 >        return(dlen + (s - src));       /* count does not include NUL */
425   }
426  
427   int sg_update_string(char **dest, const char *src) {
# Line 431 | Line 444 | int sg_update_string(char **dest, const char *src) {
444          return 0;
445   }
446  
434 – long long sg_get_ll_match(char *line, regmatch_t *match){
435 –        char *ptr;
436 –        long long num;
437 –
438 –        ptr=line+match->rm_so;
439 –        num=atoll(ptr);
440 –
441 –        return num;
442 – }
443 –
447   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
448   kvm_t *sg_get_kvm() {
449          static kvm_t *kvmd = NULL;
# Line 450 | Line 453 | kvm_t *sg_get_kvm() {
453          }
454  
455          kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
456 +        if(kvmd == NULL) {
457 +                sg_set_error(SG_ERROR_KVM_OPENFILES, NULL);
458 +        }
459          return kvmd;
460   }
461  
# Line 462 | Line 468 | kvm_t *sg_get_kvm2() {
468          }
469  
470          kvmd2 = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
471 +        if(kvmd2 == NULL) {
472 +                sg_set_error(SG_ERROR_KVM_OPENFILES, NULL);
473 +        }
474          return kvmd2;
475   }
476   #endif
# Line 477 | Line 486 | struct uvmexp *sg_get_uvmexp() {
486          mib[1] = VM_UVMEXP;
487  
488          if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
489 +                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP");
490                  return NULL;
491          }
492  
# Line 484 | Line 494 | struct uvmexp *sg_get_uvmexp() {
494   }
495   #endif
496  
497 + #ifdef HPUX
498 + struct pst_static *sg_get_pstat_static() {
499 +        static int got = 0;
500 +        static struct pst_static pst;
501 +
502 +        if (!got) {
503 +                if (pstat_getstatic(&pst, sizeof pst, 1, 0) == -1) {
504 +                        sg_set_error_with_errno(SG_ERROR_PSTAT,
505 +                                                "pstat_static");
506 +                        return NULL;
507 +                }
508 +                got = 1;
509 +        }
510 +        return &pst;
511 + }
512 + #endif
513 +
514   int sg_init(){
515 +        sg_set_error(SG_ERROR_NONE, NULL);
516 +
517   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
518          if (sg_get_kvm() == NULL) {
519                  return -1;
# Line 506 | Line 535 | int sg_init(){
535   }
536  
537   int sg_drop_privileges() {
538 <        if (setegid(getgid()) != 0) return -1;
539 <        if (seteuid(getuid()) != 0) return -1;
538 > #ifdef HAVE_SETEGID
539 >        if (setegid(getgid()) != 0) {
540 > #elif defined(HAVE_SETRESGID)
541 >        if (setresgid(getgid(), getgid(), getgid()) != 0) {
542 > #else
543 >        {
544 > #endif
545 >                sg_set_error_with_errno(SG_ERROR_SETEGID, NULL);
546 >                return -1;
547 >        }
548 > #ifdef HAVE_SETEUID
549 >        if (seteuid(getuid()) != 0) {
550 > #elif defined(HAVE_SETRESUID)
551 >        if (setresuid(getuid(), getuid(), getuid()) != 0) {
552 > #else
553 >        {
554 > #endif
555 >                sg_set_error_with_errno(SG_ERROR_SETEUID, NULL);
556 >                return -1;
557 >        }
558          return 0;
559   }
560  
# Line 515 | Line 562 | void *sg_realloc(void *ptr, size_t size) {
562          void *tmp = NULL;
563          tmp = realloc(ptr, size);
564          if(tmp == NULL) {
565 <                sg_set_error(SG_ERROR_MALLOC_FAILED, NULL);
565 >                sg_set_error_with_errno(SG_ERROR_MALLOC, NULL);
566          }
567          return tmp;
568   }
522 –

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines