static int
__pmAuthServerSetAttributes(sasl_conn_t *conn, __pmHashCtl *attrs)
{
const void *property = NULL;
char *username;
int sts;
sts = sasl_getprop(conn, SASL_USERNAME, &property);
username = (char *)property;
if (sts == SASL_OK && username) {
int len = strlen(username);
pmNotifyErr(LOG_INFO,
"Successful authentication for user \"%s\"\n",
username);
if ((username = strdup(username)) == NULL) {
pmNoMem("__pmAuthServerSetAttributes",
len, PM_RECOV_ERR);
return -ENOMEM;
}
} else {
pmNotifyErr(LOG_ERR,
"Authentication complete, but no username\n");
return -ESRCH;
}
if ((sts = __pmHashAdd(PCP_ATTR_USERNAME, username, attrs)) < 0)
return sts;
return __pmSetUserGroupAttributes(username, attrs);
}
int
pmiGetHandle(const char *name, const char *instance)
{
int sts;
pmi_handle tmp;
pmi_handle *hp;
if (current == NULL)
return PM_ERR_NOCONTEXT;
sts = make_handle(name, instance, &tmp);
if (sts != 0)
return current->last_sts = sts;
current->nhandle++;
current->handle = (pmi_handle *)realloc(current->handle, current->nhandle*sizeof(pmi_handle));
if (current->handle == NULL) {
pmNoMem("pmiGetHandle: pmi_handle", current->nhandle*sizeof(pmi_handle), PM_FATAL_ERR);
}
hp = ¤t->handle[current->nhandle-1];
hp->midx = tmp.midx;
hp->inst = tmp.inst;
return current->last_sts = current->nhandle;
}
static void *
parseAlloc(const char *func, size_t need)
{
void *tmp;
if ((tmp = malloc(need)) == NULL)
pmNoMem(func, need, PM_FATAL_ERR);
return tmp;
}
int
pmiSetTimezone(const char *value)
{
if (current == NULL)
return PM_ERR_NOCONTEXT;
current->timezone = strdup(value);
if (current->timezone == NULL) {
pmNoMem("pmiSetTimezone", strlen(value)+1, PM_FATAL_ERR);
}
return current->last_sts = 0;
}
void
reset_profile(void)
{
if ((profile = (pmProfile *)realloc(profile, sizeof(pmProfile))) == NULL) {
pmNoMem("reset_profile", sizeof(pmProfile), PM_FATAL_ERR);
exit(1);
}
ctxp->c_instprof = profile;
memset(profile, 0, sizeof(pmProfile));
profile->state = PM_PROFILE_INCLUDE; /* default global state */
profile_changed = 1;
}
int
pmiAddInstance(pmInDom indom, const char *instance, int inst)
{
pmi_indom *idp;
const char *p;
char *np;
int spaced;
int i;
int j;
if (current == NULL)
return PM_ERR_NOCONTEXT;
for (i = 0; i < current->nindom; i++) {
if (current->indom[i].indom == indom)
break;
}
if (i == current->nindom) {
/* extend indom table */
current->nindom++;
current->indom = (pmi_indom *)realloc(current->indom, current->nindom*sizeof(pmi_indom));
if (current->indom == NULL) {
pmNoMem("pmiAddInstance: pmi_indom", current->nindom*sizeof(pmi_indom), PM_FATAL_ERR);
}
current->indom[i].indom = indom;
current->indom[i].ninstance = 0;
current->indom[i].name = NULL;
current->indom[i].inst = NULL;
current->indom[i].namebuflen = 0;
current->indom[i].namebuf = NULL;
}
idp = ¤t->indom[i];
/*
* duplicate external instance identifier would be bad, but need
* to honour unique to first space rule ...
* duplicate instance internal identifier is also not allowed
*/
for (p = instance; *p && *p != ' '; p++)
;
spaced = (*p == ' ') ? p - instance + 1: 0; /* +1 => *must* compare the space too */
for (j = 0; j < idp->ninstance; j++) {
if (spaced) {
if (strncmp(instance, idp->name[j], spaced) == 0)
return current->last_sts = PMI_ERR_DUPINSTNAME;
} else {
if (strcmp(instance, idp->name[j]) == 0)
return current->last_sts = PMI_ERR_DUPINSTNAME;
}
if (inst == idp->inst[j]) {
return current->last_sts = PMI_ERR_DUPINSTID;
}
}
/* add instance marks whole indom as needing to be written */
idp->meta_done = 0;
idp->ninstance++;
idp->name = (char **)realloc(idp->name, idp->ninstance*sizeof(char *));
if (idp->name == NULL) {
pmNoMem("pmiAddInstance: name", idp->ninstance*sizeof(char *), PM_FATAL_ERR);
}
idp->inst = (int *)realloc(idp->inst, idp->ninstance*sizeof(int));
if (idp->inst == NULL) {
pmNoMem("pmiAddInstance: inst", idp->ninstance*sizeof(int), PM_FATAL_ERR);
}
idp->namebuf = (char *)realloc(idp->namebuf, idp->namebuflen+strlen(instance)+1);
if (idp->namebuf == NULL) {
pmNoMem("pmiAddInstance: namebuf", idp->namebuflen+strlen(instance)+1, PM_FATAL_ERR);
}
strcpy(&idp->namebuf[idp->namebuflen], instance);
idp->namebuflen += strlen(instance)+1;
idp->inst[idp->ninstance-1] = inst;
/* in case namebuf moves, need to redo name[] pointers */
np = idp->namebuf;
for (j = 0; j < current->indom[i].ninstance; j++) {
idp->name[j] = np;
np += strlen(np)+1;
}
return current->last_sts = 0;
}
int
pmiAddMetric(const char *name, pmID pmid, int type, pmInDom indom, int sem, pmUnits units)
{
int m;
int item;
int cluster;
size_t size;
pmi_metric *mp;
if (current == NULL)
return PM_ERR_NOCONTEXT;
if (valid_pmns_name(name) == 0)
return current->last_sts = PMI_ERR_BADMETRICNAME;
for (m = 0; m < current->nmetric; m++) {
if (strcmp(name, current->metric[m].name) == 0) {
/* duplicate metric name is not good */
return current->last_sts = PMI_ERR_DUPMETRICNAME;
}
if (pmid == current->metric[m].pmid) {
/* duplicate metric pmID is not good */
return current->last_sts = PMI_ERR_DUPMETRICID;
}
}
/*
* basic sanity check of metadata ... we do not check later so this
* needs to be robust
*/
switch (type) {
case PM_TYPE_32:
case PM_TYPE_U32:
case PM_TYPE_64:
case PM_TYPE_U64:
case PM_TYPE_FLOAT:
case PM_TYPE_DOUBLE:
case PM_TYPE_STRING:
break;
default:
return current->last_sts = PMI_ERR_BADTYPE;
}
switch (sem) {
case PM_SEM_INSTANT:
case PM_SEM_COUNTER:
case PM_SEM_DISCRETE:
break;
default:
return current->last_sts = PMI_ERR_BADSEM;
}
current->nmetric++;
size = current->nmetric * sizeof(pmi_metric);
current->metric = (pmi_metric *)realloc(current->metric, size);
if (current->metric == NULL) {
pmNoMem("pmiAddMetric: pmi_metric", size, PM_FATAL_ERR);
}
mp = ¤t->metric[current->nmetric-1];
if (pmid != PM_ID_NULL) {
mp->pmid = pmid;
} else {
/* choose a PMID on behalf of the caller - check boundaries first */
item = cluster = current->nmetric;
if (item >= (1<<22)) { /* enough room for unique item:cluster? */
current->nmetric--;
return current->last_sts = PMI_ERR_DUPMETRICID; /* wrap */
}
item %= (1<<10);
cluster >>= 10;
mp->pmid = pmID_build(PMI_DOMAIN, cluster, item);
}
mp->name = strdup(name);
if (mp->name == NULL) {
pmNoMem("pmiAddMetric: name", strlen(name)+1, PM_FATAL_ERR);
}
mp->desc.pmid = mp->pmid;
mp->desc.type = type;
mp->desc.indom = indom;
mp->desc.sem = sem;
mp->desc.units = units;
mp->meta_done = 0;
return current->last_sts = 0;
}
int
pmiStart(const char *archive, int inherit)
{
pmi_context *old_current;
char *np;
int c = current - context_tab;
ncontext++;
context_tab = (pmi_context *)realloc(context_tab, ncontext*sizeof(context_tab[0]));
if (context_tab == NULL) {
pmNoMem("pmiStart: context_tab", ncontext*sizeof(context_tab[0]), PM_FATAL_ERR);
}
old_current = &context_tab[c];
current = &context_tab[ncontext-1];
current->state = CONTEXT_START;
current->archive = strdup(archive);
if (current->archive == NULL) {
pmNoMem("pmiStart", strlen(archive)+1, PM_FATAL_ERR);
}
current->hostname = NULL;
current->timezone = NULL;
current->result = NULL;
memset((void *)¤t->logctl, 0, sizeof(current->logctl));
memset((void *)¤t->archctl, 0, sizeof(current->archctl));
current->archctl.ac_log = ¤t->logctl;
if (inherit && old_current != NULL) {
current->nmetric = old_current->nmetric;
if (old_current->metric != NULL) {
int m;
current->metric = (pmi_metric *)malloc(current->nmetric*sizeof(pmi_metric));
if (current->metric == NULL) {
pmNoMem("pmiStart: pmi_metric", current->nmetric*sizeof(pmi_metric), PM_FATAL_ERR);
}
for (m = 0; m < current->nmetric; m++) {
current->metric[m].name = old_current->metric[m].name;
current->metric[m].pmid = old_current->metric[m].pmid;
current->metric[m].desc = old_current->metric[m].desc;
current->metric[m].meta_done = 0;
}
}
else
current->metric = NULL;
current->nindom = old_current->nindom;
if (old_current->indom != NULL) {
int i;
current->indom = (pmi_indom *)malloc(current->nindom*sizeof(pmi_indom));
if (current->indom == NULL) {
pmNoMem("pmiStart: pmi_indom", current->nindom*sizeof(pmi_indom), PM_FATAL_ERR);
}
for (i = 0; i < current->nindom; i++) {
int j;
current->indom[i].indom = old_current->indom[i].indom;
current->indom[i].ninstance = old_current->indom[i].ninstance;
current->indom[i].meta_done = 0;
if (old_current->indom[i].ninstance > 0) {
current->indom[i].name = (char **)malloc(current->indom[i].ninstance*sizeof(char *));
if (current->indom[i].name == NULL) {
pmNoMem("pmiStart: name", current->indom[i].ninstance*sizeof(char *), PM_FATAL_ERR);
}
current->indom[i].inst = (int *)malloc(current->indom[i].ninstance*sizeof(int));
if (current->indom[i].inst == NULL) {
pmNoMem("pmiStart: inst", current->indom[i].ninstance*sizeof(int), PM_FATAL_ERR);
}
current->indom[i].namebuflen = old_current->indom[i].namebuflen;
current->indom[i].namebuf = (char *)malloc(old_current->indom[i].namebuflen);
if (current->indom[i].namebuf == NULL) {
pmNoMem("pmiStart: namebuf", old_current->indom[i].namebuflen, PM_FATAL_ERR);
}
np = current->indom[i].namebuf;
for (j = 0; j < current->indom[i].ninstance; j++) {
strcpy(np, old_current->indom[i].name[j]);
current->indom[i].name[j] = np;
np += strlen(np)+1;
current->indom[i].inst[j] = old_current->indom[i].inst[j];
}
}
else {
current->indom[i].name = NULL;
current->indom[i].inst = NULL;
current->indom[i].namebuflen = 0;
current->indom[i].namebuf = NULL;
}
}
}
else
current->indom = NULL;
current->nhandle = old_current->nhandle;
if (old_current->handle != NULL) {
int h;
current->handle = (pmi_handle *)malloc(current->nhandle*sizeof(pmi_handle));
if (current->handle == NULL) {
pmNoMem("pmiStart: pmi_handle", current->nhandle*sizeof(pmi_handle), PM_FATAL_ERR);
}
for (h = 0; h < current->nhandle; h++) {
current->handle[h].midx = old_current->handle[h].midx;
current->handle[h].inst = old_current->handle[h].inst;
}
}
else
current->handle = NULL;
current->last_stamp = old_current->last_stamp;
}
else {
current->nmetric = 0;
current->metric = NULL;
current->nindom = 0;
current->indom = NULL;
current->nhandle = 0;
current->handle = NULL;
current->last_stamp.tv_sec = current->last_stamp.tv_usec = 0;
}
return ncontext;
}
