/*
* Copyright (c) 1998,1999,2000
* Traakan, Inc., Los Altos, CA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Project: NDMJOB
* Ident: $Id: $
*
* Description:
*
*/
#include "ndmlib.h"
#define CFG_BUF_SIZE 512
#define CFG_MAX_SV 32
/* control block */
struct cfg_cb {
FILE * fp;
ndmp9_config_info * config_info;
char buf[CFG_BUF_SIZE];
char * sv[CFG_MAX_SV];
int sc;
int n_error;
};
static int cfg_butype (struct cfg_cb *cb);
static int cfg_fs (struct cfg_cb *cb);
static int cfg_tape (struct cfg_cb *cb);
static int cfg_scsi (struct cfg_cb *cb);
static int cfg_device (struct cfg_cb *cb, u_int *n_device,
ndmp9_device_info **pp);
static int cfg_add_env (struct cfg_cb *cb, u_int *n_env,
ndmp9_pval **pp, char *name, char *value);
int
ndmcfg_load (char *filename, ndmp9_config_info *config_info)
{
FILE * fp;
int rc;
fp = fopen (filename, "r");
if (!fp)
return -1;
rc = ndmcfg_loadfp (fp, config_info);
fclose (fp);
return rc;
}
int
ndmcfg_loadfp (FILE *fp, ndmp9_config_info *config_info)
{
struct cfg_cb _cb, *cb = &_cb;
int rc;
NDMOS_MACRO_ZEROFILL(cb);
cb->fp = fp;
cb->config_info = config_info;
for (;;) {
rc = ndmstz_getstanza (cb->fp, cb->buf, sizeof cb->buf);
if (rc == EOF) {
break;
}
cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);
if (cb->sc < 1) {
continue;
}
if (strcmp (cb->sv[0], "butype") == 0 && cb->sc == 2) {
cfg_butype (cb);
continue;
}
if (strcmp (cb->sv[0], "fs") == 0 && cb->sc == 2) {
cfg_fs (cb);
continue;
}
if (strcmp (cb->sv[0], "tape") == 0 && cb->sc == 2) {
cfg_tape (cb);
continue;
}
if (strcmp (cb->sv[0], "scsi") == 0 && cb->sc == 2) {
cfg_scsi (cb);
continue;
}
/*
* Unrecognized stanzas are deemed for other purposes
* and tolerated.
*/
}
return cb->n_error;
}
/*
* [butype BUTYPE]
* v2attr 0xATTR
* v3attr 0xATTR
* v4attr 0xATTR
* default_env NAME VALUE
*/
static int
cfg_butype (struct cfg_cb *cb)
{
ndmp9_config_info * cfg = cb->config_info;
ndmp9_butype_info * ent = cfg->butype_info.butype_info_val;
int n_ent = cfg->butype_info.butype_info_len;
int i, rc;
if (!ent)
n_ent = 0;
ent = NDMOS_MACRO_NEWN(ndmp9_butype_info, n_ent+1);
if (!ent) {
cb->n_error++;
return -1;
}
for (i = 0; i < n_ent; i++) {
ent[i] = cfg->butype_info.butype_info_val[i];
}
if (cfg->butype_info.butype_info_val) {
NDMOS_API_FREE (cfg->butype_info.butype_info_val);
}
cfg->butype_info.butype_info_val = ent;
cfg->butype_info.butype_info_len = n_ent+1;
ent += n_ent;
NDMOS_MACRO_ZEROFILL (ent);
ent->butype_name = NDMOS_API_STRDUP (cb->sv[1]);
for (;;) {
rc = ndmstz_getline (cb->fp, cb->buf, CFG_BUF_SIZE);
if (rc < 0)
break;
cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);
if (cb->sc < 1) {
continue;
}
if (strcmp (cb->sv[0], "v2attr") == 0 && cb->sc == 2) {
ent->v2attr.valid = NDMP9_VALIDITY_VALID;
ent->v2attr.value = strtol (cb->sv[1], 0, 0);
continue;
}
if (strcmp (cb->sv[0], "v3attr") == 0 && cb->sc == 2) {
ent->v3attr.valid = NDMP9_VALIDITY_VALID;
ent->v3attr.value = strtol (cb->sv[1], 0, 0);
continue;
}
if (strcmp (cb->sv[0], "v4attr") == 0 && cb->sc == 2) {
ent->v4attr.valid = NDMP9_VALIDITY_VALID;
ent->v4attr.value = strtol (cb->sv[1], 0, 0);
continue;
}
if (strcmp (cb->sv[0], "default_env") == 0 && cb->sc == 3) {
cfg_add_env (cb, &ent->default_env.default_env_len,
&ent->default_env.default_env_val,
cb->sv[1], cb->sv[2]);
continue;
}
/*
* Unrecognized lines are deemed version differences
* and tolerated.
*/
}
return 0;
}
/*
* [fs MOUNTPOINT]
* fs_type TYPE
* fs_physical_device DEVICEPATH
* fs_status "COMMENT"
* fs_env NAME VALUE
*/
static int
cfg_fs (struct cfg_cb *cb)
{
ndmp9_config_info * cfg = cb->config_info;
ndmp9_fs_info * ent = cfg->fs_info.fs_info_val;
int n_ent = cfg->fs_info.fs_info_len;
int i, rc;
if (!ent)
n_ent = 0;
ent = NDMOS_MACRO_NEWN(ndmp9_fs_info, n_ent+1);
if (!ent) {
cb->n_error++;
return -1;
}
for (i = 0; i < n_ent; i++) {
ent[i] = cfg->fs_info.fs_info_val[i];
}
if (cfg->fs_info.fs_info_val) {
NDMOS_API_FREE (cfg->fs_info.fs_info_val);
}
cfg->fs_info.fs_info_val = ent;
cfg->fs_info.fs_info_len = n_ent+1;
ent += n_ent;
NDMOS_MACRO_ZEROFILL (ent);
ent->fs_logical_device = NDMOS_API_STRDUP (cb->sv[1]);
for (;;) {
rc = ndmstz_getline (cb->fp, cb->buf, CFG_BUF_SIZE);
if (rc < 0)
break;
cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);
if (cb->sc < 1) {
continue;
}
if (strcmp (cb->sv[0], "fs_type") == 0 && cb->sc == 2) {
ent->fs_type = NDMOS_API_STRDUP (cb->sv[1]);
continue;
}
if (strcmp (cb->sv[0], "fs_physical_device") == 0
&& cb->sc == 2) {
ent->fs_physical_device = NDMOS_API_STRDUP (cb->sv[1]);
continue;
}
if (strcmp (cb->sv[0], "fs_status") == 0 && cb->sc == 2) {
ent->fs_status = NDMOS_API_STRDUP (cb->sv[1]);
continue;
}
if (strcmp (cb->sv[0], "fs_env") == 0 && cb->sc == 3) {
cfg_add_env (cb, &ent->fs_env.fs_env_len,
&ent->fs_env.fs_env_val,
cb->sv[1], cb->sv[2]);
continue;
}
/*
* Unrecognized lines are deemed version differences
* and tolerated.
*/
}
return 0;
}
static int
cfg_tape (struct cfg_cb *cb)
{
ndmp9_config_info * cfg = cb->config_info;
return cfg_device (cb, &cfg->tape_info.tape_info_len,
&cfg->tape_info.tape_info_val);
}
static int
cfg_scsi (struct cfg_cb *cb)
{
ndmp9_config_info * cfg = cb->config_info;
return cfg_device (cb, &cfg->scsi_info.scsi_info_len,
&cfg->scsi_info.scsi_info_val);
}
/*
* [tape IDENT] or [scsi IDENT]
* device DEVICEPATH
* v3attr 0xATTR
* v4attr 0xATTR
* capability NAME VALUE
*/
static int
cfg_device (struct cfg_cb *cb, u_int *n_device, ndmp9_device_info **pp)
{
ndmp9_device_info * ent = *pp;
ndmp9_device_capability *dcap;
int rc;
unsigned int i, n_ent = *n_device;
if (!ent)
n_ent = 0;
for (i = 0; i < n_ent; i++) {
if (strcmp(ent[i].model, (*pp)[i].model) == 0) {
ent += i;
goto got_model;
}
}
ent = NDMOS_MACRO_NEWN(ndmp9_device_info, n_ent+1);
if (!ent) {
cb->n_error++;
return -1;
}
for (i = 0; i < n_ent; i++) {
ent[i] = (*pp)[i];
}
if (*pp) {
NDMOS_API_FREE (*pp);
}
*pp = ent;
*n_device = n_ent+1;
ent += n_ent;
NDMOS_MACRO_ZEROFILL (ent);
ent->model = NDMOS_API_STRDUP (cb->sv[1]);
got_model:
dcap = NDMOS_MACRO_NEWN (ndmp9_device_capability,
ent->caplist.caplist_len+1);
if (!dcap) {
cb->n_error++;
return -1;
}
for (i = 0; i < ent->caplist.caplist_len; i++) {
dcap[i] = ent->caplist.caplist_val[i];
}
if (ent->caplist.caplist_val) {
NDMOS_API_FREE (ent->caplist.caplist_val);
}
ent->caplist.caplist_val = dcap;
dcap += ent->caplist.caplist_len++;
NDMOS_MACRO_ZEROFILL(dcap);
for (;;) {
rc = ndmstz_getline (cb->fp, cb->buf, CFG_BUF_SIZE);
if (rc < 0)
break;
cb->sc = ndmstz_parse (cb->buf, cb->sv, CFG_MAX_SV);
if (cb->sc < 1) {
continue;
}
if (strcmp (cb->sv[0], "device") == 0 && cb->sc == 2) {
dcap->device = NDMOS_API_STRDUP (cb->sv[1]);
continue;
}
if (strcmp (cb->sv[0], "v3attr") == 0 && cb->sc == 2) {
dcap->v3attr.valid = NDMP9_VALIDITY_VALID;
dcap->v3attr.value = strtol (cb->sv[1], 0, 0);
continue;
}
if (strcmp (cb->sv[0], "v4attr") == 0 && cb->sc == 2) {
dcap->v4attr.valid = NDMP9_VALIDITY_VALID;
dcap->v4attr.value = strtol (cb->sv[1], 0, 0);
continue;
}
if (strcmp (cb->sv[0], "capability") == 0 && cb->sc == 3) {
cfg_add_env (cb, &dcap->capability.capability_len,
&dcap->capability.capability_val,
cb->sv[1], cb->sv[2]);
continue;
}
/*
* Unrecognized lines are deemed version differences
* and tolerated.
*/
}
return 0;
}
static int
cfg_add_env (struct cfg_cb *cb, u_int *n_env,
ndmp9_pval **pp, char *name, char *value)
{
ndmp9_pval * ent = *pp;
int n_ent = *n_env;
int i;
if (!ent)
n_ent = 0;
ent = NDMOS_MACRO_NEWN(ndmp9_pval, n_ent+1);
if (!ent) {
cb->n_error++;
return -1;
}
for (i = 0; i < n_ent; i++) {
ent[i] = (*pp)[i];
}
if (*pp) {
NDMOS_API_FREE (*pp);
}
*pp = ent;
*n_env = n_ent+1;
ent += n_ent;
NDMOS_MACRO_ZEROFILL (ent);
ent->name = NDMOS_API_STRDUP (name);
ent->value = NDMOS_API_STRDUP (value);
return 0;
}
#ifdef SELF_TEST
int
main (int argc, char *argv[])
{
ndmp9_config_info config_info;
int rc, i, j, k;
if (argc != 2) {
printf ("usage: %s FILE\n", argv[0]);
return 1;
}
NDMOS_MACRO_ZEROFILL (&config_info);
rc = ndmcfg_load (argv[1], &config_info);
printf ("%d errors\n", rc);
for (i = 0; i < config_info.butype_info.butype_info_len; i++) {
ndmp9_butype_info * bu;
bu = &config_info.butype_info.butype_info_val[i];
printf ("butype[%d] name='%s'\n", i, bu->butype_name);
if (bu->v2attr.valid) {
printf (" v2attr 0x%x\n", bu->v2attr.value);
} else {
printf (" v2attr -invalid-\n");
}
if (bu->v3attr.valid) {
printf (" v3attr 0x%x\n", bu->v3attr.value);
} else {
printf (" v3attr -invalid-\n");
}
if (bu->v4attr.valid) {
printf (" v4attr 0x%x\n", bu->v4attr.value);
} else {
printf (" v4attr -invalid-\n");
}
for (j = 0; j < bu->default_env.default_env_len; j++) {
ndmp9_pval * env;
env = &bu->default_env.default_env_val[j];
printf (" default_env[%d] '%s'='%s'\n",
j, env->name, env->value);
}
}
for (i = 0; i < config_info.fs_info.fs_info_len; i++) {
ndmp9_fs_info * fs;
fs = &config_info.fs_info.fs_info_val[i];
printf ("fs[%d] fs_logical_device='%s'\n",
i, fs->fs_logical_device);
if (fs->fs_physical_device) {
printf (" fs_physical_device '%s'\n",
fs->fs_physical_device);
} else {
printf (" fs_physical_device -null-\n");
}
if (fs->fs_type) {
printf (" fs_type '%s'\n", fs->fs_type);
} else {
printf (" fs_type -null-\n");
}
if (fs->fs_status) {
printf (" fs_status '%s'\n", fs->fs_status);
} else {
printf (" fs_status -null-\n");
}
if (fs->total_size.valid) {
printf (" total_size %llu\n", fs->total_size.value);
} else {
printf (" total_size -invalid-\n");
}
if (fs->used_size.valid) {
printf (" used_size %llu\n", fs->used_size.value);
} else {
printf (" used_size -invalid-\n");
}
if (fs->avail_size.valid) {
printf (" avail_size %llu\n", fs->avail_size.value);
} else {
printf (" avail_size -invalid-\n");
}
if (fs->total_inodes.valid) {
printf (" total_inodes %llu\n",
fs->total_inodes.value);
} else {
printf (" total_inodes -invalid-\n");
}
if (fs->used_inodes.valid) {
printf (" used_inodes %llu\n", fs->used_inodes.value);
} else {
printf (" used_inodes -invalid-\n");
}
for (j = 0; j < fs->fs_env.fs_env_len; j++) {
ndmp9_pval * env;
env = &fs->fs_env.fs_env_val[j];
printf (" fs_env[%d] '%s'='%s'\n",
j, env->name, env->value);
}
}
for (i = 0; i < config_info.tape_info.tape_info_len; i++) {
ndmp9_device_info * dev;
dev = &config_info.tape_info.tape_info_val[i];
printf ("tape[%d] model='%s'\n", i, dev->model);
for (j = 0; j < dev->caplist.caplist_len; j++) {
struct ndmp9_device_capability *dcap;
dcap = &dev->caplist.caplist_val[j];
printf (" capability %d\n", j);
if (dcap->device) {
printf (" device '%s'\n", dcap->device);
} else {
printf (" device -null-\n");
}
if (dcap->v3attr.valid) {
printf (" v3attr 0x%x\n", dcap->v3attr.value);
} else {
printf (" v3attr -invalid-\n");
}
if (dcap->v4attr.valid) {
printf (" v4attr 0x%x\n", dcap->v4attr.value);
} else {
printf (" v4attr -invalid-\n");
}
k = 0;
for (; k < dcap->capability.capability_len; k++) {
ndmp9_pval *env;
env = &dcap->capability.capability_val[k];
printf (" capability[%d] '%s'='%s'\n",
k, env->name, env->value);
}
}
}
for (i = 0; i < config_info.scsi_info.scsi_info_len; i++) {
ndmp9_device_info * dev;
dev = &config_info.scsi_info.scsi_info_val[i];
printf ("scsi[%d] model='%s'\n", i, dev->model);
for (j = 0; j < dev->caplist.caplist_len; j++) {
struct ndmp9_device_capability *dcap;
dcap = &dev->caplist.caplist_val[j];
printf (" capability %d\n", j);
if (dcap->device) {
printf (" device '%s'\n", dcap->device);
} else {
printf (" device -null-\n");
}
if (dcap->v3attr.valid) {
printf (" v3attr 0x%x\n", dcap->v3attr.value);
} else {
printf (" v3attr -invalid-\n");
}
if (dcap->v4attr.valid) {
printf (" v4attr 0x%x\n", dcap->v4attr.value);
} else {
printf (" v4attr -invalid-\n");
}
k = 0;
for (; k < dcap->capability.capability_len; k++) {
ndmp9_pval *env;
env = &dcap->capability.capability_val[k];
printf (" capability[%d] '%s'='%s'\n",
k, env->name, env->value);
}
}
}
return 0;
}
#endif /* SELF_TEST */