ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/libstatgrab/tools.c

Comparing projects/libstatgrab/src/libstatgrab/tools.c (file contents):
Revision 1.24 by tdb, Mon Jan 19 16:49:21 2004 UTC vs.
Revision 1.43 by tdb, Tue Apr 6 14:52:58 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 33 | Line 33
33		#include <regex.h>
34		#ifdef ALLBSD
35		#include <fcntl.h>
36	+	#endif
37	+	#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
38		#include <kvm.h>
39	+	#include <paths.h>
40		#endif
41	<	#ifdef NETBSD
41	>	#if defined(NETBSD) || defined(OPENBSD)
42		#include <uvm/uvm_extern.h>
43	+	#include <sys/param.h>
44	+	#include <sys/sysctl.h>
45		#endif
46
47		#include "tools.h"
48
49		#ifdef SOLARIS
50	+	#ifdef HAVE_LIBDEVINFO_H
51		#include <libdevinfo.h>
52	+	#endif
53		#include <kstat.h>
54		#include <unistd.h>
55		#include <ctype.h>
#	Line 54 | Line 61
61		#include <dirent.h>
62		#endif
63
64	<	#ifdef SOLARIS
64	>	#if defined(SOLARIS) && defined(HAVE_LIBDEVINFO_H)
65		struct map{
66		char *bsd;
67		char *svr;
#	Line 64 | Line 71 | struct map{
71		typedef struct map mapping_t;
72
73		static mapping_t *mapping = NULL;
74	+	#endif
75
76	<	char *get_svr_from_bsd(char *bsd){
76	>	#ifdef SOLARIS
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)
81		if(!strcmp(map_ptr->bsd, bsd)) return map_ptr->svr;
82	<
82	>	#endif
83		return bsd;
84		}
85	+	#endif
86
87	<	void add_mapping(char *bsd, char *svr){
87	>	#if defined(SOLARIS) && defined(HAVE_LIBDEVINFO_H)
88	>	static void add_mapping(char *bsd, char *svr){
89		mapping_t *map_ptr;
90		mapping_t *map_end_ptr;
91
80	–	bsd = strdup(bsd);
81	–	svr = strdup(svr);
82	–
92		if (mapping == NULL){
93		mapping = malloc(sizeof(mapping_t));
94		if (mapping == NULL) return;
#	Line 102 | 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 150 | Line 160 | char *read_dir(char *disk_path){
160		}
161
162
163	<
154	<	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 172 | 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 192 | 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 204 | 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 251 | 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 264 | 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 296 | Line 305 | static long long atoll(const char *s) {
305		}
306		#endif
307
299	–	#ifndef HAVE_STRLCPY
308		/*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
309
310		/*
#	Line 320 | 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 343 | 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		}
346	–	#endif
354
348	–	#ifndef HAVE_STRLCAT
355		/*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
356
357		/*
#	Line 371 | 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 397 | 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 409 | Line 433 | long long get_ll_match(char *line, regmatch_t *match){
433		return num;
434		}
435
436	<	#ifdef ALLBSD
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 420 | 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	<	#ifdef NETBSD
462	<	struct uvmexp *get_uvmexp() {
463	<	static u_long addr = 0;
464	<	static struct uvmexp uvm;
465	<	kvm_t *kvmd = get_kvm();
461	>	#if defined(NETBSD) || defined(OPENBSD)
462	>	struct uvmexp *sg_get_uvmexp() {
463	>	int mib[2];
464	>	size_t size;
465	>	static struct uvmexp *uvm = NULL;
466	>	struct uvmexp *new;
467
468	<	if (kvmd == NULL) {
468	>	mib[0] = CTL_VM;
469	>	mib[1] = VM_UVMEXP;
470	>
471	>	if (sysctl(mib, 2, NULL, &size, NULL, 0) < 0) {
472		return NULL;
473		}
474
475	<	if (addr == 0) {
476	<	struct nlist symbols[] = {
477	<	{ "_uvmexp" },
438	<	{ NULL }
439	<	};
440	<
441	<	if (kvm_nlist(kvmd, symbols) != 0) {
442	<	return NULL;
443	<	}
444	<	addr = symbols[0].n_value;
475	>	new = realloc(uvm, size);
476	>	if (new == NULL) {
477	>	return NULL;
478		}
479	+	uvm = new;
480
481	<	if (kvm_read(kvmd, addr, &uvm, sizeof uvm) != sizeof uvm) {
481	>	if (sysctl(mib, 2, uvm, &size, NULL, 0) < 0) {
482		return NULL;
483		}
484	<	return &uvm;
484	>
485	>	return uvm;
486		}
487		#endif
488
489	<	int statgrab_init(){
490	<	#ifdef ALLBSD
491	<	{
492	<	kvm_t *kvmd = get_kvm();
458	<	if (kvmd == NULL) return 1;
489	>	int sg_init(){
490	>	#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
491	>	if (sg_get_kvm() == NULL) {
492	>	return 1;
493		}
494	<	#endif
495	<	#ifdef NETBSD
462	<	{
463	<	struct uvmexp *uvm = get_uvmexp();
464	<	if (uvm == NULL) return 1;
494	>	if (sg_get_kvm2() == NULL) {
495	>	return 1;
496		}
497		#endif
498	+	#if defined(NETBSD) || defined(OPENBSD)
499	+	/* This should always succeed, but it seems that on some
500	+	* versions of NetBSD the first call to get_uvmexp will return
501	+	* a non-filled-in structure; this is a workaround for that.
502	+	*/
503	+	if (sg_get_uvmexp() == NULL) return 1;
504	+	#endif
505		#ifdef SOLARIS
506		/* On solaris 7, this will fail if you are not root. But, everything
507		* will still work, just no disk mappings. So we will ignore the exit
508		* status of this, and carry on merrily.
509		*/
510	+	#ifdef HAVE_LIBDEVINFO_H
511		build_mapping();
512		#endif
513	+	#endif
514		return 0;
515		}
516
517	<	int statgrab_drop_privileges() {
517	>	int sg_drop_privileges() {
518		if (setegid(getgid()) != 0) return -1;
519		if (seteuid(getuid()) != 0) return -1;
520		return 0;

Diff Legend

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