static bool srprs_key(const char** ptr, cbuf* key, bool* del)
{
const char* pos = *ptr;
const char* closing_bracket_pos = NULL;
size_t closing_bracket_idx = 0;
if (!srprs_skipws(&pos) || !srprs_char(&pos, '[')) {
return false;
}
*del = srprs_char(&pos, '-');
cbuf_clear(key);
while (true) {
while (srprs_charsetinv(&pos, "]\\", key))
;
switch (*pos) {
case ']':
closing_bracket_idx = cbuf_getpos(key);
closing_bracket_pos = pos;
cbuf_putc(key, ']');
pos++;
break;
case '\\':
cbuf_putc(key, '\\');
/* n++; */
/* cbuf_puts(subkeyidx, cbuf_getpos(key), sizeof(size_t)) */
while (srprs_char(&pos,'\\'))
;
break;
case '\0':
if (closing_bracket_pos == NULL) {
return false;
}
/* remove trailing backslash (if any) */
if (*(closing_bracket_pos-1)=='\\') {
closing_bracket_idx--;
}
cbuf_setpos(key, closing_bracket_idx);
*ptr = closing_bracket_pos+1;
return true;
default:
assert(false);
}
}
}
static bool act_val_dw(struct reg_parse* p, uint32_t val)
{
assert(p->valtype == REG_DWORD);
assert(p->state == STATE_KEY_OPEN);
cbuf_clear(p->valblob);
if (cbuf_putdw(p->valblob, val) < 0) {
return false;
}
return value_callback(p);
}
cbuf* cbuf_new(const void* ctx)
{
cbuf* s = talloc(ctx, cbuf);
if (s == NULL)
return NULL;
s->size = 32;
s->buf = (char *)talloc_size(s, s->size);
if (s->size && (s->buf == NULL)) {
talloc_free(s);
return NULL;
}
return cbuf_clear(s);
}
static cio_err_t on_client_read(cio_handle_t* h, cio_dispatcher_t* d, void* p)
{
struct eyed_server* server = p;
int count;
unsigned char buf[512];
DEBUG_ENTER();
count = recv(h->fd, buf, sizeof(buf), 0);
if (count <= 0)
return CIO_ERR_CLOSE;
#if 0
/* consume data
*/
cbuf_push_back(&h->buf_in, (unsigned char*)buf, count);
cbuf_clear(&h->buf_in);
#endif /* 0 */
handle_request(server->cam_dev, h, NULL);
return CIO_ERR_SUCCESS;
}
int reg_parse_line(struct reg_parse* parser, const char* line)
{
const char* pos;
bool del=false;
cbuf* tmp=cbuf_clear(parser->tmp);
bool cb_ok = true;
bool cont = true;
if (!line) {
return -4;
}
parser->linenum++;
pos = line;
switch (parser->state) {
case STATE_VAL_HEX_CONT:
if (srprs_val_hex_values(&pos, parser->valblob, &cont)) {
cb_ok = act_val_hex(parser, parser->valblob, cont);
}
goto done;
case STATE_VAL_SZ_CONT:
if (srprs_quoted_string(&pos, parser->valblob, &cont)) {
cb_ok = act_val_sz(parser, parser->valblob, cont);
}
goto done;
default:
cont = false;
}
if ( !srprs_skipws(&pos) ) {
return -4;
}
/* empty line ?*/
if ( srprs_eol(&pos, NULL) ) {
return 0;
}
/* key line ?*/
else if (srprs_key(&pos, tmp, &del)) {
cb_ok = act_key(parser, tmp, del);
}
/* comment line ? */
else if (srprs_comment(&pos, tmp)) {
cb_ok = act_comment(parser, cbuf_gets(tmp, 0));
}
/* head line */
else if ((parser->linenum == 1) && srprs_line(&pos, tmp) ) {
/* cb_ok = act_head(parser, cbuf_gets(tmp, 0)); */
}
/* value line ?*/
else if (srprs_val_name(&pos, tmp)) {
uint32_t dw;
cbuf_swap(parser->valname, tmp);
cbuf_clear(tmp);
if (parser->state != STATE_KEY_OPEN) {
DEBUG(0, ("value \"%s\" without a key at line: %i",
cbuf_gets(parser->valname, 0), parser->linenum));
return -3;
}
if (!srprs_skipws(&pos)) {
return -4;
}
if (srprs_char(&pos, '-')) {
cb_ok = act_val_del(parser);
}
else if (srprs_val_dword(&pos, &parser->valtype, &dw)) {
cb_ok = act_val_dw(parser, dw);
}
else if (srprs_val_sz(&pos, &parser->valtype, tmp, &cont)) {
cb_ok = act_val_sz(parser, tmp, cont);
}
else if (srprs_val_hex(&pos, &parser->valtype, tmp, &cont)){
cb_ok = act_val_hex(parser, tmp, cont);
}
else {
DEBUG(0, ("value \"%s\" parse error"
"at line: %i pos: %li : %s",
cbuf_gets(parser->valname, 0), parser->linenum,
(long int)(pos-line), pos));
return -3;
}
}
else {
DEBUG(0, ("unrecognized line %i : %s\n", parser->linenum, line));
return -3;
}
done:
if (!cb_ok)
return -2;
if (!srprs_skipws(&pos) || !srprs_eol(&pos, NULL)) {
DEBUG(0, ("trailing garbage at line: %i pos: %li : %s\n",
parser->linenum, (long int)(pos-line), pos));
return -1;
}
return 0;
}
