← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/net-snmp/gutsy-security

« back to all changes in this revision

Viewing changes to agent/mibgroup/host/hr_filesys.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2004-09-13 12:06:21 UTC
  • Revision ID: james.westby@ubuntu.com-20040913120621-g952ntonlleihcvm
Tags: upstream-5.1.1
Import upstream version 5.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
agent/mibgroup/host/hr_filesys.c
 
1
/*
 
2
 *  Host Resources MIB - File System device group implementation - hr_filesys.c
 
3
 *
 
4
 */
 
5
 
 
6
#include <net-snmp/net-snmp-config.h>
 
7
#include "host_res.h"
 
8
#include "hr_filesys.h"
 
9
#include "hr_storage.h"
 
10
#include <net-snmp/utilities.h>
 
11
 
 
12
#if HAVE_MNTENT_H
 
13
#include <mntent.h>
 
14
#endif
 
15
#if HAVE_SYS_MNTENT_H
 
16
#include <sys/mntent.h>
 
17
#endif
 
18
#if HAVE_SYS_MNTTAB_H
 
19
#include <sys/mnttab.h>
 
20
#endif
 
21
#if HAVE_SYS_STATVFS_H
 
22
#include <sys/statvfs.h>
 
23
#endif
 
24
#if HAVE_SYS_VFS_H
 
25
#include <sys/vfs.h>
 
26
#endif
 
27
#ifdef HAVE_SYS_PARAM_H
 
28
#include <sys/param.h>
 
29
#endif
 
30
#ifdef HAVE_SYS_MOUNT_H
 
31
#include <sys/mount.h>
 
32
#endif
 
33
 
 
34
#include <ctype.h>
 
35
#if HAVE_STRING_H
 
36
#include <string.h>
 
37
#endif
 
38
#if HAVE_STDLIB_H
 
39
#include <stdlib.h>
 
40
#endif
 
41
 
 
42
#if defined(bsdi4) || defined(freebsd3) || defined(freebsd4) || defined(freebsd5)
 
43
#if HAVE_GETFSSTAT
 
44
#if defined(MFSNAMELEN)
 
45
#define MOUNT_NFS       "nfs"
 
46
#define MNTTYPE_UFS     "ufs"
 
47
#define BerkelyFS
 
48
#define MNTTYPE_FFS     "ffs"
 
49
#define MNTTYPE_NFS     "nfs"
 
50
#define MNTTYPE_NFS3    "nfs"
 
51
#define MNTTYPE_MFS     "mfs"
 
52
#define MNTTYPE_MSDOS   "msdos"
 
53
#define MNTTYPE_LFS     "lfs"
 
54
#define MNTTYPE_FDESC   "fdesc"
 
55
#define MNTTYPE_PORTAL  "portal"
 
56
#define MNTTYPE_NULL    "null"
 
57
#define MNTTYPE_UMAP    "umap"
 
58
#define MNTTYPE_KERNFS  "kernfs"
 
59
#define MNTTYPE_PROCFS  "procfs"
 
60
#define MNTTYPE_AFS     "afs"
 
61
#define MNTTYPE_CD9660  "cd9660"
 
62
#define MNTTYPE_UNION   "union"
 
63
#define MNTTYPE_ADOSFS  "adosfs"
 
64
#define MNTTYPE_EXT2FS  "ext2fs"
 
65
#define MNTTYPE_CFS     "coda"
 
66
#define MNTTYPE_NTFS    "ntfs"
 
67
#endif
 
68
#endif
 
69
#endif                          /* freebsd3 */
 
70
 
 
71
#define HRFS_MONOTONICALLY_INCREASING
 
72
 
 
73
        /*********************
 
74
         *
 
75
         *  Kernel & interface information,
 
76
         *   and internal forward declarations
 
77
         *
 
78
         *********************/
 
79
 
 
80
#ifdef solaris2
 
81
 
 
82
struct mnttab   HRFS_entry_struct;
 
83
struct mnttab  *HRFS_entry = &HRFS_entry_struct;
 
84
#define HRFS_name       mnt_special
 
85
#define HRFS_mount      mnt_mountp
 
86
#define HRFS_type       mnt_fstype
 
87
#define HRFS_statfs     statvfs
 
88
 
 
89
#elif defined(HAVE_GETFSSTAT)
 
90
static struct statfs *fsstats = 0;
 
91
static int      fscount;
 
92
struct statfs  *HRFS_entry;
 
93
#define HRFS_statfs     statfs
 
94
#ifdef MFSNAMELEN
 
95
#define HRFS_type       f_fstypename
 
96
#else
 
97
#define HRFS_type       f_type
 
98
#endif
 
99
#define HRFS_mount      f_mntonname
 
100
#define HRFS_name       f_mntfromname
 
101
 
 
102
#elif defined(dynix)
 
103
 
 
104
struct mntent  *HRFS_entry;
 
105
#define HRFS_name       mnt_fsname
 
106
#define HRFS_mount      mnt_dir
 
107
#define HRFS_type       mnt_type
 
108
#define HRFS_statfs     statvfs
 
109
 
 
110
#else
 
111
 
 
112
struct mntent  *HRFS_entry;
 
113
#define HRFS_name       mnt_fsname
 
114
#define HRFS_mount      mnt_dir
 
115
#define HRFS_type       mnt_type
 
116
#define HRFS_statfs     statfs
 
117
 
 
118
#ifdef linux
 
119
#define MNTTYPE_CD9660  "iso9660"
 
120
#define MNTTYPE_EXT2FS  "ext2"
 
121
#define MNTTYPE_EXT3FS  "ext3"
 
122
#define MNTTYPE_SMBFS   "smbfs"
 
123
#define MNTTYPE_MSDOS   "msdos"
 
124
#define MNTTYPE_FAT32   "vfat"
 
125
#define MNTTYPE_NTFS    "ntfs"
 
126
#endif  /* linux */
 
127
 
 
128
#endif
 
129
 
 
130
#define FULL_DUMP       0
 
131
#define PART_DUMP       1
 
132
 
 
133
 
 
134
extern void     Init_HR_FileSys(void);
 
135
extern int      Get_Next_HR_FileSys(void);
 
136
char           *cook_device(char *);
 
137
static u_char  *when_dumped(char *filesys, int level, size_t * length);
 
138
int             header_hrfilesys(struct variable *, oid *, size_t *, int,
 
139
                                 size_t *, WriteMethod **);
 
140
 
 
141
        /*********************
 
142
         *
 
143
         *  Initialisation & common implementation functions
 
144
         *
 
145
         *********************/
 
146
 
 
147
#define HRFSYS_INDEX            1
 
148
#define HRFSYS_MOUNT            2
 
149
#define HRFSYS_RMOUNT           3
 
150
#define HRFSYS_TYPE             4
 
151
#define HRFSYS_ACCESS           5
 
152
#define HRFSYS_BOOT             6
 
153
#define HRFSYS_STOREIDX         7
 
154
#define HRFSYS_FULLDUMP         8
 
155
#define HRFSYS_PARTDUMP         9
 
156
 
 
157
struct variable4 hrfsys_variables[] = {
 
158
    {HRFSYS_INDEX, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 1}},
 
159
    {HRFSYS_MOUNT, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 2}},
 
160
    {HRFSYS_RMOUNT, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 3}},
 
161
    {HRFSYS_TYPE, ASN_OBJECT_ID, RONLY, var_hrfilesys, 2, {1, 4}},
 
162
    {HRFSYS_ACCESS, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 5}},
 
163
    {HRFSYS_BOOT, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 6}},
 
164
    {HRFSYS_STOREIDX, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 7}},
 
165
    {HRFSYS_FULLDUMP, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 8}},
 
166
    {HRFSYS_PARTDUMP, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 9}},
 
167
};
 
168
oid             hrfsys_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 8 };
 
169
 
 
170
void
 
171
init_hr_filesys(void)
 
172
{
 
173
    REGISTER_MIB("host/hr_filesys", hrfsys_variables, variable4,
 
174
                 hrfsys_variables_oid);
 
175
}
 
176
 
 
177
/*
 
178
 * header_hrfilesys(...
 
179
 * Arguments:
 
180
 * vp     IN      - pointer to variable entry that points here
 
181
 * name    IN/OUT  - IN/name requested, OUT/name found
 
182
 * length  IN/OUT  - length of IN/OUT oid's 
 
183
 * exact   IN      - TRUE if an exact match was requested
 
184
 * var_len OUT     - length of variable or 0 if function returned
 
185
 * write_method
 
186
 * 
 
187
 */
 
188
 
 
189
int
 
190
header_hrfilesys(struct variable *vp,
 
191
                 oid * name,
 
192
                 size_t * length,
 
193
                 int exact, size_t * var_len, WriteMethod ** write_method)
 
194
{
 
195
#define HRFSYS_ENTRY_NAME_LENGTH        11
 
196
    oid             newname[MAX_OID_LEN];
 
197
    int             fsys_idx, LowIndex = -1;
 
198
    int             result;
 
199
 
 
200
    DEBUGMSGTL(("host/hr_filesys", "var_hrfilesys: "));
 
201
    DEBUGMSGOID(("host/hr_filesys", name, *length));
 
202
    DEBUGMSG(("host/hr_filesys", " %d\n", exact));
 
203
 
 
204
    memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
 
205
    /*
 
206
     * Find "next" file system entry 
 
207
     */
 
208
 
 
209
    Init_HR_FileSys();
 
210
    for (;;) {
 
211
        fsys_idx = Get_Next_HR_FileSys();
 
212
        if (fsys_idx == -1)
 
213
            break;
 
214
        newname[HRFSYS_ENTRY_NAME_LENGTH] = fsys_idx;
 
215
        result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
 
216
        if (exact && (result == 0)) {
 
217
            LowIndex = fsys_idx;
 
218
            break;
 
219
        }
 
220
        if ((!exact && (result < 0)) &&
 
221
            (LowIndex == -1 || fsys_idx < LowIndex)) {
 
222
            LowIndex = fsys_idx;
 
223
#ifdef HRFS_MONOTONICALLY_INCREASING
 
224
            break;
 
225
#endif
 
226
        }
 
227
    }
 
228
 
 
229
    if (LowIndex == -1) {
 
230
        DEBUGMSGTL(("host/hr_filesys", "... index out of range\n"));
 
231
        return (MATCH_FAILED);
 
232
    }
 
233
 
 
234
    memcpy((char *) name, (char *) newname,
 
235
           (vp->namelen + 1) * sizeof(oid));
 
236
    *length = vp->namelen + 1;
 
237
    *write_method = 0;
 
238
    *var_len = sizeof(long);    /* default to 'long' results */
 
239
 
 
240
    DEBUGMSGTL(("host/hr_filesys", "... get filesys stats "));
 
241
    DEBUGMSGOID(("host/hr_filesys", name, *length));
 
242
    DEBUGMSG(("host/hr_filesys", "\n"));
 
243
 
 
244
    return LowIndex;
 
245
}
 
246
 
 
247
 
 
248
oid             fsys_type_id[] = { 1, 3, 6, 1, 2, 1, 25, 3, 9, 1 };     /* hrFSOther */
 
249
int             fsys_type_len =
 
250
    sizeof(fsys_type_id) / sizeof(fsys_type_id[0]);
 
251
 
 
252
        /*********************
 
253
         *
 
254
         *  System specific implementation functions
 
255
         *
 
256
         *********************/
 
257
 
 
258
 
 
259
u_char         *
 
260
var_hrfilesys(struct variable *vp,
 
261
              oid * name,
 
262
              size_t * length,
 
263
              int exact, size_t * var_len, WriteMethod ** write_method)
 
264
{
 
265
    int             fsys_idx;
 
266
    static char     string[1024];
 
267
    char           *mnt_type;
 
268
 
 
269
    fsys_idx =
 
270
        header_hrfilesys(vp, name, length, exact, var_len, write_method);
 
271
    if (fsys_idx == MATCH_FAILED)
 
272
        return NULL;
 
273
 
 
274
 
 
275
    switch (vp->magic) {
 
276
    case HRFSYS_INDEX:
 
277
        long_return = fsys_idx;
 
278
        return (u_char *) & long_return;
 
279
    case HRFSYS_MOUNT:
 
280
        snprintf(string, sizeof(string), HRFS_entry->HRFS_mount);
 
281
        string[ sizeof(string)-1 ] = 0;
 
282
        *var_len = strlen(string);
 
283
        return (u_char *) string;
 
284
    case HRFSYS_RMOUNT:
 
285
        if (Check_HR_FileSys_NFS()) {
 
286
            snprintf(string, sizeof(string), HRFS_entry->HRFS_name);
 
287
            string[ sizeof(string)-1 ] = 0;
 
288
        } else
 
289
            string[0] = '\0';
 
290
        *var_len = strlen(string);
 
291
        return (u_char *) string;
 
292
 
 
293
    case HRFSYS_TYPE:
 
294
        if (Check_HR_FileSys_NFS())
 
295
            fsys_type_id[fsys_type_len - 1] = 14;
 
296
        else {
 
297
        /*
 
298
         * Not sufficient to identity the file
 
299
         *   type precisely, but it's a start.
 
300
         */
 
301
#if HAVE_GETFSSTAT && !defined(MFSNAMELEN)
 
302
        switch (HRFS_entry->HRFS_type) {
 
303
        case MOUNT_UFS:
 
304
            fsys_type_id[fsys_type_len - 1] = 3;
 
305
            break;
 
306
        case MOUNT_NFS:
 
307
            fsys_type_id[fsys_type_len - 1] = 14;
 
308
            break;
 
309
        case MOUNT_MFS:
 
310
            fsys_type_id[fsys_type_len - 1] = 8;
 
311
            break;
 
312
        case MOUNT_MSDOS:
 
313
            fsys_type_id[fsys_type_len - 1] = 5;
 
314
            break;
 
315
        case MOUNT_LFS:
 
316
            fsys_type_id[fsys_type_len - 1] = 1;
 
317
            break;
 
318
        case MOUNT_LOFS:
 
319
            fsys_type_id[fsys_type_len - 1] = 1;
 
320
            break;
 
321
        case MOUNT_FDESC:
 
322
            fsys_type_id[fsys_type_len - 1] = 1;
 
323
            break;
 
324
        case MOUNT_PORTAL:
 
325
            fsys_type_id[fsys_type_len - 1] = 1;
 
326
            break;
 
327
        case MOUNT_NULL:
 
328
            fsys_type_id[fsys_type_len - 1] = 1;
 
329
            break;
 
330
        case MOUNT_UMAP:
 
331
            fsys_type_id[fsys_type_len - 1] = 1;
 
332
            break;
 
333
        case MOUNT_KERNFS:
 
334
            fsys_type_id[fsys_type_len - 1] = 1;
 
335
            break;
 
336
        case MOUNT_PROCFS:
 
337
            fsys_type_id[fsys_type_len - 1] = 1;
 
338
            break;
 
339
        case MOUNT_AFS:
 
340
            fsys_type_id[fsys_type_len - 1] = 16;
 
341
            break;
 
342
        case MOUNT_CD9660:
 
343
            fsys_type_id[fsys_type_len - 1] = 12;
 
344
            break;
 
345
        case MOUNT_UNION:
 
346
            fsys_type_id[fsys_type_len - 1] = 1;
 
347
            break;
 
348
        case MOUNT_DEVFS:
 
349
            fsys_type_id[fsys_type_len - 1] = 1;
 
350
            break;
 
351
#ifdef MOUNT_EXT2FS
 
352
        case MOUNT_EXT2FS:
 
353
            fsys_type_id[fsys_type_len - 1] = 23;
 
354
            break;
 
355
#endif
 
356
#ifdef MOUNT_TFS
 
357
        case MOUNT_TFS:
 
358
            fsys_type_id[fsys_type_len - 1] = 15;
 
359
            break;
 
360
#endif
 
361
        }
 
362
#else
 
363
        mnt_type = HRFS_entry->HRFS_type;
 
364
        if (mnt_type == NULL)
 
365
            fsys_type_id[fsys_type_len - 1] = 2;        /* unknown */
 
366
#ifdef MNTTYPE_HFS
 
367
        else if (!strcmp(mnt_type, MNTTYPE_HFS))
 
368
#ifdef BerkelyFS
 
369
            fsys_type_id[fsys_type_len - 1] = 3;
 
370
#else                           /* SysV */
 
371
            fsys_type_id[fsys_type_len - 1] = 4;
 
372
#endif
 
373
#endif
 
374
#ifdef MNTTYPE_UFS
 
375
        else if (!strcmp(mnt_type, MNTTYPE_UFS))
 
376
#if (defined(BerkelyFS) && !defined(MNTTYPE_HFS)) || defined(solaris2)
 
377
            fsys_type_id[fsys_type_len - 1] = 3;
 
378
#else                           /* SysV */
 
379
            fsys_type_id[fsys_type_len - 1] = 4;        /* or 3? XXX */
 
380
#endif
 
381
#endif
 
382
#ifdef MNTTYPE_SYSV
 
383
        else if (!strcmp(mnt_type, MNTTYPE_SYSV))
 
384
            fsys_type_id[fsys_type_len - 1] = 4;
 
385
#endif
 
386
#ifdef MNTTYPE_PC
 
387
        else if (!strcmp(mnt_type, MNTTYPE_PC))
 
388
            fsys_type_id[fsys_type_len - 1] = 5;
 
389
#endif
 
390
#ifdef MNTTYPE_MSDOS
 
391
        else if (!strcmp(mnt_type, MNTTYPE_MSDOS))
 
392
            fsys_type_id[fsys_type_len - 1] = 5;
 
393
#endif
 
394
#ifdef MNTTYPE_FAT32
 
395
        else if (!strcmp(mnt_type, MNTTYPE_FAT32))
 
396
            fsys_type_id[fsys_type_len - 1] = 22;
 
397
#endif
 
398
#ifdef MNTTYPE_CDFS
 
399
        else if (!strcmp(mnt_type, MNTTYPE_CDFS))
 
400
#ifdef RockRidge
 
401
            fsys_type_id[fsys_type_len - 1] = 13;
 
402
#else                           /* ISO 9660 */
 
403
            fsys_type_id[fsys_type_len - 1] = 12;
 
404
#endif
 
405
#endif
 
406
#ifdef MNTTYPE_HSFS
 
407
        else if (!strcmp(mnt_type, MNTTYPE_HSFS))
 
408
            fsys_type_id[fsys_type_len - 1] = 13;
 
409
#endif
 
410
#ifdef MNTTYPE_ISO9660
 
411
        else if (!strcmp(mnt_type, MNTTYPE_ISO9660))
 
412
            fsys_type_id[fsys_type_len - 1] = 12;
 
413
#endif
 
414
#ifdef MNTTYPE_CD9660
 
415
        else if (!strcmp(mnt_type, MNTTYPE_CD9660))
 
416
            fsys_type_id[fsys_type_len - 1] = 12;
 
417
#endif
 
418
#ifdef MNTTYPE_SMBFS
 
419
        else if (!strcmp(mnt_type, MNTTYPE_SMBFS))
 
420
            fsys_type_id[fsys_type_len - 1] = 14;
 
421
#endif
 
422
#ifdef MNTTYPE_NFS
 
423
        else if (!strcmp(mnt_type, MNTTYPE_NFS))
 
424
            fsys_type_id[fsys_type_len - 1] = 14;
 
425
#endif
 
426
#ifdef MNTTYPE_NFS3
 
427
        else if (!strcmp(mnt_type, MNTTYPE_NFS3))
 
428
            fsys_type_id[fsys_type_len - 1] = 14;
 
429
#endif
 
430
#ifdef MNTTYPE_MFS
 
431
        else if (!strcmp(mnt_type, MNTTYPE_MFS))
 
432
            fsys_type_id[fsys_type_len - 1] = 8;
 
433
#endif
 
434
#ifdef MNTTYPE_EXT2FS
 
435
        else if (!strcmp(mnt_type, MNTTYPE_EXT2FS))
 
436
            fsys_type_id[fsys_type_len - 1] = 23;
 
437
#endif
 
438
#ifdef MNTTYPE_EXT3FS
 
439
        else if (!strcmp(mnt_type, MNTTYPE_EXT3FS))
 
440
            fsys_type_id[fsys_type_len - 1] = 23;
 
441
#endif
 
442
#ifdef MNTTYPE_NTFS
 
443
        else if (!strcmp(mnt_type, MNTTYPE_NTFS))
 
444
            fsys_type_id[fsys_type_len - 1] = 9;
 
445
#endif
 
446
        else
 
447
            fsys_type_id[fsys_type_len - 1] = 1;        /* Other */
 
448
#endif                          /* HAVE_GETFSSTAT */
 
449
        }
 
450
 
 
451
        *var_len = sizeof(fsys_type_id);
 
452
        return (u_char *) fsys_type_id;
 
453
 
 
454
    case HRFSYS_ACCESS:
 
455
#if HAVE_GETFSSTAT
 
456
        long_return = HRFS_entry->f_flags & MNT_RDONLY ? 2 : 1;
 
457
#elif defined(cygwin)
 
458
        long_return = 1;
 
459
#else
 
460
        if (hasmntopt(HRFS_entry, "ro") != NULL)
 
461
            long_return = 2;    /* Read Only */
 
462
        else
 
463
            long_return = 1;    /* Read-Write */
 
464
#endif
 
465
        return (u_char *) & long_return;
 
466
    case HRFSYS_BOOT:
 
467
        if (HRFS_entry->HRFS_mount[0] == '/' &&
 
468
            HRFS_entry->HRFS_mount[1] == 0)
 
469
            long_return = 1;    /* root is probably bootable! */
 
470
        else
 
471
            long_return = 2;    /* others probably aren't */
 
472
        return (u_char *) & long_return;
 
473
    case HRFSYS_STOREIDX:
 
474
        long_return = fsys_idx + HRS_TYPE_FIXED_MAX;
 
475
        return (u_char *) & long_return;
 
476
    case HRFSYS_FULLDUMP:
 
477
        return when_dumped(HRFS_entry->HRFS_name, FULL_DUMP, var_len);
 
478
    case HRFSYS_PARTDUMP:
 
479
        return when_dumped(HRFS_entry->HRFS_name, PART_DUMP, var_len);
 
480
    default:
 
481
        DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrfilesys\n",
 
482
                    vp->magic));
 
483
    }
 
484
    return NULL;
 
485
}
 
486
 
 
487
 
 
488
        /*********************
 
489
         *
 
490
         *  Internal implementation functions
 
491
         *
 
492
         *********************/
 
493
 
 
494
static int      HRFS_index;
 
495
#ifndef HAVE_GETFSSTAT
 
496
static FILE    *fp;
 
497
#endif
 
498
 
 
499
void
 
500
Init_HR_FileSys(void)
 
501
{
 
502
#if HAVE_GETFSSTAT
 
503
    fscount = getfsstat(NULL, 0, MNT_NOWAIT);
 
504
    if (fsstats)
 
505
        free((char *) fsstats);
 
506
    fsstats = NULL;
 
507
    fsstats = malloc(fscount * sizeof(*fsstats));
 
508
    getfsstat(fsstats, fscount * sizeof(*fsstats), MNT_NOWAIT);
 
509
    HRFS_index = 0;
 
510
#else
 
511
    HRFS_index = 1;
 
512
    if (fp != NULL)
 
513
        fclose(fp);
 
514
    fp = fopen(ETC_MNTTAB, "r");
 
515
#endif
 
516
}
 
517
 
 
518
const char     *HRFS_ignores[] = {
 
519
#ifdef MNTTYPE_IGNORE
 
520
    MNTTYPE_IGNORE,
 
521
#endif
 
522
#ifdef MNTTYPE_SWAP
 
523
    MNTTYPE_SWAP,
 
524
#endif
 
525
#ifdef MNTTYPE_PROC
 
526
    MNTTYPE_PROC,
 
527
#endif
 
528
#ifdef MNTTYPE_PROCFS
 
529
    MNTTYPE_PROCFS,
 
530
#endif
 
531
#ifdef MNTTYPE_AUTOFS
 
532
    MNTTYPE_AUTOFS,
 
533
#else
 
534
    "autofs",
 
535
#endif
 
536
#ifdef linux
 
537
    "devpts",
 
538
    "devfs",
 
539
    "usbdevfs",
 
540
    "tmpfs",
 
541
    "shm",
 
542
#endif
 
543
#ifdef solaris2
 
544
    "mntfs",
 
545
    "proc",
 
546
    "fd",
 
547
#endif
 
548
    0
 
549
};
 
550
 
 
551
int
 
552
Get_Next_HR_FileSys(void)
 
553
{
 
554
#if HAVE_GETFSSTAT
 
555
    if (HRFS_index >= fscount)
 
556
        return -1;
 
557
    HRFS_entry = fsstats + HRFS_index;
 
558
    return ++HRFS_index;
 
559
#else
 
560
    const char    **cpp;
 
561
    /*
 
562
     * XXX - According to RFC 1514, hrFSIndex must
 
563
     *   "remain constant at least from one re-initialization
 
564
     *    of the agent to the next re-initialization."
 
565
     *
 
566
     *  This simple-minded counter doesn't handle filesystems
 
567
     *    being un-mounted and re-mounted.
 
568
     *  Options for fixing this include:
 
569
     *       - keeping a history of previous indices used
 
570
     *       - calculating the index from filesystem
 
571
     *              specific information
 
572
     *
 
573
     *  Note: this index is also used as hrStorageIndex
 
574
     *     which is assumed to be less than HRS_TYPE_FS_MAX
 
575
     *     This assumption may well be broken if the second
 
576
     *     option above is followed.  Consider indexing the
 
577
     *     non-filesystem-based storage entries first in this
 
578
     *     case, and assume hrStorageIndex > HRS_TYPE_FS_MIN
 
579
     *     (for file-system based storage entries)
 
580
     *
 
581
     *  But at least this gets us started.
 
582
     */
 
583
 
 
584
    if (fp == NULL)
 
585
        return -1;
 
586
 
 
587
#ifdef solaris2
 
588
    if (getmntent(fp, HRFS_entry) != 0)
 
589
        return -1;
 
590
#else
 
591
    HRFS_entry = getmntent(fp);
 
592
    if (HRFS_entry == NULL)
 
593
        return -1;
 
594
#endif                          /* solaris2 */
 
595
 
 
596
    for (cpp = HRFS_ignores; *cpp != NULL; ++cpp)
 
597
        if (!strcmp(HRFS_entry->HRFS_type, *cpp))
 
598
            return Get_Next_HR_FileSys();
 
599
 
 
600
    return HRFS_index++;
 
601
#endif                          /* HAVE_GETFSSTAT */
 
602
}
 
603
 
 
604
/*
 
605
 * this function checks whether the current file system (info can be found
 
606
 * in HRFS_entry) is a NFS file system
 
607
 * HRFS_entry must be valid prior to calling this function
 
608
 * returns 1 if NFS file system, 0 otherwise
 
609
 */
 
610
int
 
611
Check_HR_FileSys_NFS (void)
 
612
{
 
613
#if HAVE_GETFSSTAT
 
614
#if defined(MFSNAMELEN)
 
615
    if (!strcmp(HRFS_entry->HRFS_type, MOUNT_NFS))
 
616
#else
 
617
    if (HRFS_entry->HRFS_type == MOUNT_NFS)
 
618
#endif
 
619
#else /* HAVE_GETFSSTAT */
 
620
    if ( HRFS_entry->HRFS_type != NULL && (
 
621
#if defined(MNTTYPE_NFS)
 
622
        !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS) ||
 
623
#else
 
624
        !strcmp( HRFS_entry->HRFS_type, "nfs") ||
 
625
#endif
 
626
#if defined(MNTTYPE_NFS3)
 
627
            !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS3) ||
 
628
#endif
 
629
#if defined(MNTTYPE_SMBFS)
 
630
            !strcmp( HRFS_entry->HRFS_type, MNTTYPE_SMBFS) ||
 
631
#endif
 
632
#if defined(MNTTYPE_LOFS)
 
633
            !strcmp( HRFS_entry->HRFS_type, MNTTYPE_LOFS) ||
 
634
#endif
 
635
            /*
 
636
             * MVFS is Rational ClearCase's view file system
 
637
             * it is similiar to NFS file systems in that it is mounted
 
638
             * locally or remotely from the ClearCase server
 
639
             */
 
640
            !strcmp( HRFS_entry->HRFS_type, "mvfs")))
 
641
#endif /* HAVE_GETFSSTAT */
 
642
        return 1;       /* NFS file system */
 
643
 
 
644
    return 0;           /* no NFS file system */
 
645
}
 
646
 
 
647
void
 
648
End_HR_FileSys(void)
 
649
{
 
650
#ifdef HAVE_GETFSSTAT
 
651
    if (fsstats)
 
652
        free((char *) fsstats);
 
653
    fsstats = NULL;
 
654
#else
 
655
    if (fp != NULL)
 
656
        fclose(fp);
 
657
    fp = NULL;
 
658
#endif
 
659
}
 
660
 
 
661
 
 
662
static u_char  *
 
663
when_dumped(char *filesys, int level, size_t * length)
 
664
{
 
665
    time_t          dumpdate = 0, tmp;
 
666
    FILE           *dump_fp;
 
667
    char            line[1024];
 
668
    char           *cp1, *cp2, *cp3;
 
669
 
 
670
    /*
 
671
     * Look for the relevent entries in /etc/dumpdates
 
672
     *
 
673
     * This is complicated by the fact that disks are
 
674
     *   mounted using block devices, but dumps are
 
675
     *   done via the raw character devices.
 
676
     * Thus the device names in /etc/dumpdates and
 
677
     *   /etc/mnttab don't match.
 
678
     *   These comparisons are therefore made using the
 
679
     *   final portion of the device name only.
 
680
     */
 
681
 
 
682
    if (*filesys == '\0')       /* No filesystem name? */
 
683
        return date_n_time(NULL, length);
 
684
    cp1 = strrchr(filesys, '/');        /* Find the last element of the current FS */
 
685
 
 
686
    if (cp1 == NULL)
 
687
        cp1 = filesys;
 
688
 
 
689
    if ((dump_fp = fopen("/etc/dumpdates", "r")) == NULL)
 
690
        return date_n_time(NULL, length);
 
691
 
 
692
    while (fgets(line, sizeof(line), dump_fp) != NULL) {
 
693
        cp2 = strchr(line, ' ');        /* Start by looking at the device name only */
 
694
        if (cp2 != NULL) {
 
695
            *cp2 = '\0';
 
696
            cp3 = strrchr(line, '/');   /* and find the last element */
 
697
            if (cp3 == NULL)
 
698
                cp3 = line;
 
699
 
 
700
            if (strcmp(cp1, cp3) != 0)  /* Wrong FS */
 
701
                continue;
 
702
 
 
703
            ++cp2;
 
704
            while (isspace(*cp2))
 
705
                ++cp2;          /* Now find the dump level */
 
706
 
 
707
            if (level == FULL_DUMP) {
 
708
                if (*(cp2++) != '0')
 
709
                    continue;   /* Not interested in partial dumps */
 
710
                while (isspace(*cp2))
 
711
                    ++cp2;
 
712
 
 
713
                dumpdate = ctime_to_timet(cp2);
 
714
                fclose(dump_fp);
 
715
                return date_n_time(&dumpdate, length);
 
716
            } else {            /* Partial Dump */
 
717
                if (*(cp2++) == '0')
 
718
                    continue;   /* Not interested in full dumps */
 
719
                while (isspace(*cp2))
 
720
                    ++cp2;
 
721
 
 
722
                tmp = ctime_to_timet(cp2);
 
723
                if (tmp > dumpdate)
 
724
                    dumpdate = tmp;     /* Remember the 'latest' partial dump */
 
725
            }
 
726
        }
 
727
    }
 
728
 
 
729
    fclose(dump_fp);
 
730
 
 
731
    return date_n_time(&dumpdate, length);
 
732
}
 
733
 
 
734
 
 
735
#define RAW_DEVICE_PREFIX       "/dev/rdsk"
 
736
#define COOKED_DEVICE_PREFIX    "/dev/dsk"
 
737
 
 
738
char           *
 
739
cook_device(char *dev)
 
740
{
 
741
    static char     cooked_dev[SNMP_MAXPATH+1];
 
742
 
 
743
    if (!strncmp(dev, RAW_DEVICE_PREFIX, strlen(RAW_DEVICE_PREFIX))) {
 
744
        strncpy(cooked_dev, COOKED_DEVICE_PREFIX, sizeof(cooked_dev)-1);
 
745
        cooked_dev[ sizeof(cooked_dev)-1 ] = 0;
 
746
        strncat(cooked_dev, dev + strlen(RAW_DEVICE_PREFIX),
 
747
                sizeof(cooked_dev)-strlen(cooked_dev)-1);
 
748
        cooked_dev[ sizeof(cooked_dev)-1 ] = 0;
 
749
    } else {
 
750
        strncpy(cooked_dev, dev, sizeof(cooked_dev)-1);
 
751
        cooked_dev[ sizeof(cooked_dev)-1 ] = 0;
 
752
    }
 
753
 
 
754
    return (cooked_dev);
 
755
}
 
756
 
 
757
 
 
758
int
 
759
Get_FSIndex(char *dev)
 
760
{
 
761
    int             iindex;
 
762
 
 
763
    Init_HR_FileSys();
 
764
 
 
765
    while ((iindex = Get_Next_HR_FileSys()) != -1)
 
766
        if (!strcmp(HRFS_entry->HRFS_name, cook_device(dev))) {
 
767
            End_HR_FileSys();
 
768
            return iindex;
 
769
        }
 
770
 
 
771
    End_HR_FileSys();
 
772
    return 0;
 
773
}
 
774
 
 
775
long
 
776
Get_FSSize(char *dev)
 
777
{
 
778
    struct HRFS_statfs statfs_buf;
 
779
 
 
780
    Init_HR_FileSys();
 
781
 
 
782
    while (Get_Next_HR_FileSys() != -1)
 
783
        if (!strcmp(HRFS_entry->HRFS_name, cook_device(dev))) {
 
784
            End_HR_FileSys();
 
785
 
 
786
            if (HRFS_statfs(HRFS_entry->HRFS_mount, &statfs_buf) != -1)
 
787
                /*
 
788
                 * with large file systems the following calculation produces
 
789
                 * an overflow:
 
790
                 * (statfs_buf.f_blocks*statfs_buf.f_bsize)/1024
 
791
                 *
 
792
                 * assumption: f_bsize is either 512 or a multiple of 1024
 
793
                 * in case of 512 (f_blocks/2) is returned
 
794
                 * otherwise (f_blocks*(f_bsize/1024)) is returned
 
795
                 */
 
796
                if (statfs_buf.f_bsize == 512)
 
797
                    return (statfs_buf.f_blocks/2);
 
798
                else
 
799
                    return (statfs_buf.f_blocks*(statfs_buf.f_bsize/1024));
 
800
            else
 
801
                return -1;
 
802
        }
 
803
 
 
804
    End_HR_FileSys();
 
805
    return 0;
 
806
}