int sr_meta_write(srmeta *m, srmetastmt *s)
{
if (m->flags & SR_RO) {
sr_error(s->r->e, "%s is read-only", s->path);
return -1;
}
switch (m->type) {
case SS_U32:
if (s->valuetype == SS_I64) {
*((uint32_t*)m->value) = *(int64_t*)s->value;
} else if (s->valuetype == SS_U32) {
*((uint32_t*)m->value) = *(uint32_t*)s->value;
} else if (s->valuetype == SS_U64) {
*((uint32_t*)m->value) = *(uint64_t*)s->value;
} else {
goto bad_type;
}
break;
case SS_U64:
if (s->valuetype == SS_I64) {
*((uint64_t*)m->value) = *(int64_t*)s->value;
} else if (s->valuetype == SS_U32) {
*((uint64_t*)m->value) = *(uint32_t*)s->value;
} else if (s->valuetype == SS_U64) {
*((uint64_t*)m->value) = *(uint64_t*)s->value;
} else {
goto bad_type;
}
break;
case SS_STRINGPTR: {
char **string = m->value;
if (s->valuetype == SS_STRING) {
char *sz = s->value;
if (s->valuesize > 0) {
sz = ss_malloc(s->r->a, s->valuesize);
if (ssunlikely(sz == NULL))
return sr_oom(s->r->e);
memcpy(sz, s->value, s->valuesize);
}
if (*string)
ss_free(s->r->a, *string);
*string = sz;
} else {
goto bad_type;
}
break;
}
default:
assert(0);
return -1;
}
return 0;
bad_type:
return sr_error(s->r->e, "bad meta write type (%s) for (%s) %s",
ss_typeof(s->valuetype),
ss_typeof(m->type), s->path);
}
int sr_confexec(srconf *start, srconfstmt *s)
{
if (s->op == SR_SERIALIZE)
return sr_confexec_serialize(start, s, NULL);
char path[256];
snprintf(path, sizeof(path), "%s", s->path);
char *ptr = NULL;
char *token;
token = strtok_r(path, ".", &ptr);
if (ssunlikely(token == NULL))
return -1;
srconf *c = start;
while (c) {
if (strcmp(token, c->key) != 0) {
c = c->next;
continue;
}
if (c->flags & SR_NS) {
token = strtok_r(NULL, ".", &ptr);
if (ssunlikely(token == NULL))
{
if (s->op == SR_WRITE && c->type != SS_UNDEF) {
int rc = sr_conf_write_cast(c->type, s->valuetype);
if (ssunlikely(rc == -1))
goto bad_type;
}
s->match = c;
if (c->function)
return c->function(c, s);
/* not supported */
goto bad_path;
}
c = (srconf*)c->value;
continue;
}
s->match = c;
token = strtok_r(NULL, ".", &ptr);
if (ssunlikely(token != NULL))
goto bad_path;
return c->function(c, s);
}
bad_path:
return sr_error(s->r->e, "bad configuration path: %s", s->path);
bad_type:
return sr_error(s->r->e, "incompatible type (%s) for (%s) %s",
ss_typeof(s->valuetype),
ss_typeof(c->type), s->path);
}
int sr_conf_write(srconf *m, srconfstmt *s)
{
if (m->flags & SR_RO) {
sr_error(s->r->e, "%s is read-only", s->path);
return -1;
}
switch (m->type) {
case SS_U32:
if (s->valuetype == SS_I64) {
sscastu32(m->value) = sscasti64(s->value);
} else
if (s->valuetype == SS_U32) {
sscastu32(m->value) = sscastu32(s->value);
} else
if (s->valuetype == SS_U64) {
sscastu32(m->value) = sscastu64(s->value);
} else {
goto bad_type;
}
break;
case SS_U64:
if (s->valuetype == SS_I64) {
sscastu64(m->value) = sscasti64(s->value);
} else
if (s->valuetype == SS_U32) {
sscastu64(m->value) = sscastu32(s->value);
} else
if (s->valuetype == SS_U64) {
sscastu64(m->value) = sscastu64(s->value);
} else {
goto bad_type;
}
break;
case SS_STRINGPTR: {
char **string = m->value;
if (s->valuetype == SS_STRING) {
char *sz = s->value;
if (s->valuesize > 0) {
sz = ss_malloc(s->r->a, s->valuesize);
if (ssunlikely(sz == NULL))
return sr_oom(s->r->e);
memcpy(sz, s->value, s->valuesize);
}
if (*string)
ss_free(s->r->a, *string);
*string = sz;
} else {
goto bad_type;
}
break;
}
default:
goto bad_type;
}
return 0;
bad_type:
return sr_error(s->r->e, "configuration write bad type (%s) for (%s) %s",
ss_typeof(s->valuetype),
ss_typeof(m->type), s->path);
}
int sr_conf_read(srconf *m, srconfstmt *s)
{
switch (m->type) {
case SS_U32:
s->valuesize = sizeof(uint32_t);
if (s->valuetype == SS_I64) {
sscasti64(s->value) = sscastu32(m->value);
} else
if (s->valuetype == SS_U32) {
sscastu32(s->value) = sscastu32(m->value);
} else
if (s->valuetype == SS_U64) {
sscastu64(s->value) = sscastu32(m->value);
} else {
goto bad_type;
}
break;
case SS_U64:
s->valuesize = sizeof(uint64_t);
if (s->valuetype == SS_I64) {
sscasti64(s->value) = sscastu64(m->value);
} else
if (s->valuetype == SS_U32) {
sscastu32(s->value) = sscastu64(m->value);
} else
if (s->valuetype == SS_U64) {
sscastu64(s->value) = sscastu64(m->value);
} else {
goto bad_type;
}
break;
case SS_STRING: {
if (s->valuetype != SS_STRING)
goto bad_type;
char **result = s->value;
*result = NULL;
s->valuesize = 0;
char *string = m->value;
if (string == NULL)
break;
int size = strlen(string) + 1;
s->valuesize = size;
*result = malloc(size);
if (ssunlikely(*result == NULL))
return sr_oom(s->r->e);
memcpy(*result, string, size);
break;
}
case SS_STRINGPTR: {
if (s->valuetype != SS_STRING)
goto bad_type;
char **result = s->value;
*result = NULL;
s->valuesize = 0;
char **string = m->value;
if (*string == NULL)
break;
int size = strlen(*string) + 1;
s->valuesize = size;
*result = malloc(size);
if (ssunlikely(*result == NULL))
return sr_oom(s->r->e);
memcpy(*result, *string, size);
break;
}
case SS_OBJECT:
if (s->valuetype != SS_STRING)
goto bad_type;
*(void**)s->value = m->value;
s->valuesize = sizeof(void*);
break;
default:
goto bad_type;
}
return 0;
bad_type:
return sr_error(s->r->e, "configuration read bad type (%s) -> (%s) %s",
ss_typeof(s->valuetype),
ss_typeof(m->type), s->path);
}
int sr_meta_read(srmeta *m, srmetastmt *s)
{
switch (m->type) {
case SS_U32:
s->valuesize = sizeof(uint32_t);
if (s->valuetype == SS_I64) {
*(int64_t*)s->value = *(uint32_t*)m->value;
} else if (s->valuetype == SS_U32) {
*(uint32_t*)s->value = *(uint32_t*)m->value;
} else if (s->valuetype == SS_U64) {
*(uint64_t*)s->value = *(uint32_t*)m->value;
} else {
goto bad_type;
}
break;
case SS_U64:
s->valuesize = sizeof(uint64_t);
if (s->valuetype == SS_I64) {
*(int64_t*)s->value = *(uint64_t*)m->value;
} else if (s->valuetype == SS_U32) {
*(uint32_t*)s->value = *(uint64_t*)m->value;
} else if (s->valuetype == SS_U64) {
*(uint64_t*)s->value = *(uint64_t*)m->value;
} else {
goto bad_type;
}
break;
case SS_STRING: {
if (s->valuetype != SS_STRING)
goto bad_type;
char **result = s->value;
*result = NULL;
s->valuesize = 0;
char *string = m->value;
if (string == NULL)
break;
int size = strlen(string) + 1;
s->valuesize = size;
*result = malloc(size);
if (ssunlikely(*result == NULL))
return sr_oom(s->r->e);
memcpy(*result, string, size);
break;
}
case SS_STRINGPTR: {
if (s->valuetype != SS_STRING)
goto bad_type;
char **result = s->value;
*result = NULL;
s->valuesize = 0;
char **string = m->value;
if (*string == NULL)
break;
int size = strlen(*string) + 1;
s->valuesize = size;
*result = malloc(size);
if (ssunlikely(*result == NULL))
return sr_oom(s->r->e);
memcpy(*result, *string, size);
break;
}
case SS_OBJECT:
if (s->valuetype != SS_STRING)
goto bad_type;
*(void**)s->value = m->value;
s->valuesize = sizeof(void*);
break;
default:
assert(0);
return -1;
}
return 0;
bad_type:
return sr_error(s->r->e, "bad meta read type (%s) -> (%s) %s",
ss_typeof(s->valuetype),
ss_typeof(m->type), s->path);
return 0;
}
