END_TEST
START_TEST(test_integer)
{
#define OVERSIZE ":19223372036854775807\r\n"
#define INVALID1 ":123lOl456\r\n"
#define INVALID2 ":\r\n"
struct element el_c, el_p;
int ret;
struct int_pair {
char *serialized;
uint64_t num;
} pairs[3] = {
{":-1\r\n", -1},
{":9223372036854775807\r\n", 9223372036854775807},
{":128\r\n", 128}
};
test_reset();
for (int i = 0; i < 3; i++) {
size_t len = strlen(pairs[i].serialized);
buf_reset(buf);
el_c.type = ELEM_INT;
el_c.num = pairs[i].num;
ret = compose_element(&buf, &el_c);
ck_assert(ret == len);
ck_assert_int_eq(cc_bcmp(buf->rpos, pairs[i].serialized, len), 0);
el_p.type = ELEM_UNKNOWN;
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_OK);
ck_assert(buf->rpos == buf->wpos);
ck_assert(el_p.type == ELEM_INT);
ck_assert(el_p.num == pairs[i].num);
}
buf_reset(buf);
buf_write(buf, OVERSIZE, sizeof(OVERSIZE) - 1);
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_EOVERSIZE);
buf_reset(buf);
buf_write(buf, INVALID1, sizeof(INVALID1) - 1);
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_EINVALID);
buf_reset(buf);
buf_write(buf, INVALID2, sizeof(INVALID2) - 1);
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_EINVALID);
#undef INVALID2
#undef INVALID1
#undef OVERSIZE
}
void parse_element(char *tok)
{
int len;
char *p;
if(tok == NULL) return;
if((p = strstr(tok, "<br>")) != NULL) {
char prev[LINE_LEN];
// deal with string ahead of <br>
if(tok != p) {
memcpy(prev, tok, p - tok);
prev[p - tok] = '\0';
parse_element(prev);
}
// deal with <br>
printf("\n");
pos = 0;
// deal with string ahead of <br>
parse_element(p + 4);
return;
}
if((p = strstr(tok, "<hr>")) != NULL) {
char prev[LINE_LEN];
// deal with string ahead of <hr>
if(tok != p) {
memcpy(prev, tok, p - tok);
prev[p - tok] = '\0';
parse_element(prev);
}
// deal with <hr>
display_hr();
// deal with string ahead of <hr>
parse_element(p + 4);
return;
}
// Now we only need to deal with words
len = strlen(tok);
if((pos+len) >= LINE_LEN) {
printf("\n");
pos = 0;
}
if(pos != 0) {
printf(" ");
pos++;
}
printf("%s", tok);
pos += strlen(tok);
}
LVAVSPresetContainer *lvavs_preset_container_from_xml_node(LVAVSPresetContainer *cont, xmlNodePtr node) {
xmlNodePtr child;
LVAVSPresetElement *element;
int i;
for(child = node->children; child; child = child->next)
{
if (xmlIsBlankNode (child) || child->type != XML_ELEMENT_NODE)
continue;
if(xmlStrcmp(child->name, (xmlChar *)"container_child") == 0) {
LVAVSPresetContainer *cont2 = lvavs_preset_container_new();
VisParamContainer *pcont = visual_param_container_new();
LVAVS_PRESET_ELEMENT(cont2)->pcont = pcont;
visual_param_container_add_many(pcont, container_params);
visual_list_add(cont->members, cont2);
lvavs_preset_container_from_xml_node(cont2, child);
}
for(i = 0; id_to_name_map[i] != NULL; i++)
if (xmlStrcmp (child->name,
(const xmlChar *) id_to_name_map[i]) == 0)
break;
if(id_to_name_map[i] == NULL)
continue;
element = lvavs_preset_element_new(LVAVS_PRESET_ELEMENT_TYPE_PLUGIN, (char*)child->name);
if(parse_element(child, element))
visual_list_add(cont->members, element);
}
return cont;
}
END_TEST
START_TEST(test_error)
{
#define ERR "something is wrong"
#define SERIALIZED "-" ERR "\r\n"
struct element el_c, el_p;
int ret;
int len = sizeof(SERIALIZED) - 1;
char *pos;
test_reset();
/* compose */
el_c.type = ELEM_ERR;
el_c.bstr = str2bstr(ERR);
ret = compose_element(&buf, &el_c);
ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret);
ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0);
/* parse */
pos = buf->rpos + 1;
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_OK);
ck_assert(buf->rpos == buf->wpos);
ck_assert(el_p.type == ELEM_ERR);
ck_assert(el_p.bstr.len == sizeof(ERR) - 1);
ck_assert(el_p.bstr.data == pos);
#undef SERIALIZED
#undef ERR
}
tree
xml_html_parser::parse_doctype () {
s += 9;
tree dt= tuple ("doctype");
skip_space ();
dt << parse_name ();
skip_space ();
if (test (s, "SYSTEM")) dt << parse_system ();
else if (test (s, "PUBLIC")) dt << parse_public ();
skip_space ();
if (test (s, "[")) {
s += 1;
while (s) {
skip_space ();
if (test (s, "]")) { s += 1; break; }
else if (test (s, "<!ELEMENT")) dt << parse_element ();
else if (test (s, "<!ATTLIST")) dt << parse_cdata ();
else if (test (s, "<!ENTITY")) parse_entity_decl ();
else if (test (s, "<!NOTATION")) a << parse_notation ();
else if (test (s, "<?")) dt << parse_pi ();
else if (test (s, "<!--")) dt << parse_comment ();
else if (s[0] == '&' || s[0] == '%') (void) parse_entity ();
else s += 1;
}
}
skip_space ();
if (test (s, ">")) s += 1;
return dt;
}
bool
window_part::parse_element(const char*& p)
{
char ch = *p;
switch (ch)
{
case '.':
{
partition pt = {leaf, 0};
m_index.add(pt);
p ++;
return true;
}
case 'h':
case 'v':
{
partition pt0 = {(ch == 'h' ? short(horizontal) : short(vertical))};
unsigned n = m_index.size();
m_index.add(pt0);
p ++;
unsigned count = 0;
while (parse_element(p))
{
count ++;
}
m_index[n].childs_number = count;
return true;
}
case '(':
{
p ++;
if (!parse_element(p))
break;
if (*p == ')')
{
p ++;
return true;
}
}
default:
/* */ ;
}
return false;
}
END_TEST
START_TEST(test_bulk_string)
{
#define BULK "foo bar\r\n"
#define SERIALIZED "$9\r\n" BULK "\r\n"
#define EMPTY "$0\r\n\r\n"
struct element el_c, el_p;
int ret;
int len = sizeof(SERIALIZED) - 1;
test_reset();
/* compose */
el_c.type = ELEM_BULK;
el_c.bstr = str2bstr(BULK);
ret = compose_element(&buf, &el_c);
ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret);
ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0);
/* parse */
ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK);
ck_assert(buf->rpos == buf->wpos);
ck_assert(el_p.type == ELEM_BULK);
ck_assert(el_p.bstr.len == sizeof(BULK) - 1);
ck_assert(el_p.bstr.data + el_p.bstr.len == buf->rpos - CRLF_LEN);
ck_assert(buf->rpos == buf->wpos);
/* empty string */
buf_reset(buf);
len = sizeof(EMPTY) - 1;
el_c.bstr = null_bstring;
ret = compose_element(&buf, &el_c);
ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret);
ck_assert_int_eq(cc_bcmp(buf->rpos, EMPTY, ret), 0);
ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK);
ck_assert(el_p.bstr.len == 0);
#undef EMPTY
#undef SERIALIZED
#undef BULK
}
static int parse_node(xmlNodePtr node, simple_binary_t **otabxml)
{
int status = 0;
/* Call for the parser function of the node type. */
switch (node->type) {
case XML_ELEMENT_NODE:
status = parse_element(node, otabxml);
break;
case XML_TEXT_NODE:
case XML_COMMENT_NODE:
case XML_PI_NODE:
/* Text nodes, comments and PIs are ignored. */
break;
/*
* XML has also many other node types, these are not needed with
* OTA. Therefore they are assumed to be an error.
*/
default:
error(0, "OTA compiler: Unknown XML node in the OTA source.");
return -1;
break;
}
/*
* If node is an element with content, it will need an end tag after it's
* children. The status for it is returned by parse_element.
*/
switch (status) {
case 0:
if (node->children != NULL)
if (parse_node(node->children, otabxml) == -1)
return -1;
break;
case 1:
if (node->children != NULL)
if (parse_node(node->children, otabxml) == -1)
return -1;
parse_end(otabxml);
break;
case -1: /* Something went wrong in the parsing. */
return -1;
default:
warning(0,"OTA compiler: undefined return value in a parse function.");
return -1;
break;
}
if (node->next != NULL)
if (parse_node(node->next, otabxml) == -1)
return -1;
return 0;
}
LVAVSPreset *lvavs_preset_new_from_preset (char *filename)
{
LVAVSPreset *preset = NULL;
LVAVSPresetElement *element;
LVAVSPresetContainer *cont;
xmlDocPtr doc;
xmlNodePtr cur;
int i;
doc = xmlParseFile(filename);
if(doc == NULL) {
return NULL;
}
cur = xmlDocGetRootElement (doc);
if(!cur) {
xmlFreeDoc(doc);
fprintf(stderr, "No root element\n");
return NULL;
}
if(xmlStrcmp(cur->name, (const xmlChar *) "pipeline_preset") != 0)
{
xmlFreeDoc(doc);
fprintf(stderr, "Bad opening node in preset file %s. Looking for 'pipeline_preset' but got '%s'.", filename, cur->name);
return NULL;
}
preset = lvavs_preset_new ();
preset->main = lvavs_preset_container_new();
VisParamContainer *pcont = visual_param_container_new();
visual_param_container_add_many(pcont, container_params);
LVAVS_PRESET_ELEMENT(preset->main)->pcont = pcont;
for (cur = cur->children; cur; cur = cur->next)
{
if(xmlStrcmp(cur->name, (const xmlChar *)"container_main") == 0)
{
xmlNodePtr child;
LVAVSPresetContainer *cont = lvavs_preset_container_new();
LVAVS_PRESET_ELEMENT(cont)->pcont = pcont;
visual_list_add(preset->main->members, cont);
cont = lvavs_preset_container_from_xml_node(cont, cur);
}
if(xmlStrcmp(cur->name, (const xmlChar *)"params") == 0)
{
parse_element(cur, LVAVS_PRESET_ELEMENT(preset->main));
}
}
xmlFreeDoc (doc);
return preset;
}
std::vector<XMLElement_Ptr> XMLParser::parse_elements()
{
std::vector<XMLElement_Ptr> elements;
XMLElement_Ptr element;
while(element = parse_element())
{
elements.push_back(element);
}
return elements;
}
unsigned char *skip_table(unsigned char *html, unsigned char *eof)
{
int level = 1;
unsigned char *name;
int namelen;
r:
while (html < eof && (*html != '<' || parse_element(html, eof, &name, &namelen, NULL, &html))) html++;
if (html >= eof) return eof;
if (namelen == 5 && !casecmp(name, "TABLE", 5)) level++;
if (namelen == 6 && !casecmp(name, "/TABLE", 6)) if (!--level) return html;
goto r;
}
bool
window_part::parse(const char* str)
{
const char* p = str;
m_index.clear();
parse_element(p);
bool success = (*p == 0);
if (!success)
parse_reset();
split();
return success;
}
void dicom_load(const char *path, dicom_t *dicom,
char *out_buffer, int buffer_size)
{
FILE *in = fopen(path, "rb");
int state = 0;
const char *uid_name;
element_t element = {
.buffer = out_buffer,
.buffer_size = buffer_size,
};
if (!parse_preamble(in)) {
state |= STATE_IMPLICIT_VR;
}
while (true) {
if (!parse_element(in, state, &element)) break;
#define S(attr, tag_, v_) \
if (element.tag.v == tag_.v) \
dicom->attr = element.value.v_;
S(instance_number, TAG_INSTANCE_NUMBER, is);
S(slice_location, TAG_SLICE_LOCATION, ds);
S(samples_per_pixel, TAG_SAMPLES_PER_PIXEL, us);
S(rows, TAG_ROWS, us);
S(columns, TAG_COLUMNS, us);
S(bits_allocated, TAG_BITS_ALLOCATED, us);
S(bits_stored, TAG_BITS_STORED, us);
S(high_bit, TAG_HIGH_BIT, us);
#undef S
if (element.tag.v == TAG_PIXEL_DATA.v)
dicom->data_size = element.length;
if (element.tag.v == TAG_TRANSFER_SYNTAX_UID.v) {
uid_name = get_uid_name(element.value.ui);
if (uid_name && strstr(uid_name, "Implicit")) {
state |= STATE_IMPLICIT_VR;
}
if (!streq(element.value.ui, "1.2.840.10008.1.2.1")) {
LOG_E("format not supported: %s", uid_name);
CHECK(false);
}
}
}
fclose(in);
}
/**
* \brief Load IPFIX elements
*
* \warning When function fails to load all elements, content of ipfix_group
* will not be defined and should be destroyed using elements_destroy().
* \param[in] file_descriptor Opened file with XML specification of IPFIX elems.
* \param[out] ipfix_groups Structure with elements description
* \return 0 on success. Otherwise returns non-zero value.
*/
int elements_load(int file_descriptor, struct elem_groups *ipfix_groups)
{
// Create an iterator over IPFIX elements in XML document
struct elem_xml_iter *iter = elem_iter_init(file_descriptor);
if (!iter) {
// Failed to init iterator
return 1;
}
unsigned int count = 0;
bool failed = false;
xmlNodePtr node;
// Iterate over all elements and fill structures
while((node = elem_iter_next(iter)) != NULL) {
ipfix_element_t *new_item = parse_element(node);
if (!new_item) {
// Failed to create new element description
failed = true;
break;
}
if (elem_add_element(ipfix_groups, new_item) != 0) {
failed = true;
break;
}
++count;
}
elem_iter_destroy(iter);
if (failed) {
return 1;
}
elem_sort(ipfix_groups);
if (elem_make_name_indexes(ipfix_groups)) {
return 1;
}
if (elem_duplication_check(ipfix_groups)) {
// Duplication found
return 1;
}
// All elements successfully loaded
MSG_INFO(msg_module, "Description of %u IPFIX elements loaded.", count);
return 0;
}
View* XmlParser::parse(const string& xml)
{
TiXmlDocument doc(xml);
if (!doc.LoadFile())
{
return NULL;
}
TiXmlElement *re = doc.RootElement();
if (!re)
{
return NULL;
}
return parse_element(re);
}
END_TEST
START_TEST(test_unfin_token)
{
char *token[13] = {
"+hello ",
"-err",
"-err\r",
":5",
":5\r",
"$5",
"$5\r",
"$5\r\n",
"$5\r\nabc",
"$5\r\nabcde\r",
"*5",
"*5\r",
};
char *pos;
size_t len;
for (int i = 0; i < 10; i++) {
struct element el;
len = strlen(token[i]);
buf_reset(buf);
buf_write(buf, token[i], len);
pos = buf->rpos;
ck_assert_int_eq(parse_element(&el, buf), PARSE_EUNFIN);
ck_assert(buf->rpos == pos);
}
for (int i = 10; i < 12; i++) {
int64_t nelem;
len = strlen(token[i]);
buf_reset(buf);
buf_write(buf, token[i], len);
pos = buf->rpos;
ck_assert_int_eq(token_array_nelem(&nelem, buf), PARSE_EUNFIN);
ck_assert(buf->rpos == pos);
}
}
int main(int argc, char **argv)
{
char *line = NULL;
char *tok;
size_t len = 0;
ssize_t read;
int rtval;
while((read = getline(&line, &len, stdin)) != -1) {
if(0 == strcmp(line, "\n"))
continue;
tok = strtok(line, DELIMITERS);
while(tok != NULL) {
parse_element(tok);
tok = strtok(NULL, DELIMITERS);
}
}
printf("\n");
free(line);
return 0;
}
END_TEST
START_TEST(test_nil_bulk)
{
#define NIL_BULK "$-1\r\n"
size_t len = sizeof(NIL_BULK) - 1;
struct element el_c, el_p;
test_reset();
el_c.type = ELEM_NIL;
ck_assert_int_eq(compose_element(&buf, &el_c), len);
ck_assert_int_eq(buf_rsize(buf), len);
ck_assert_int_eq(cc_bcmp(buf->rpos, NIL_BULK, len), 0);
el_p.type = ELEM_UNKNOWN;
ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK);
ck_assert_int_eq(el_p.type, ELEM_NIL);
#undef NIL_BULK
}
View* XmlParser::parse_element(TiXmlElement *e, View *parent /* = NULL */)
{
if (!e)
{
return NULL;
}
View *view = ResourceCreator::instance().get_view(e->Value());
if (!view)
{
return NULL;
}
if (parent)
{
view->set_parent(parent);
parent->push_child(view);
}
TiXmlAttribute *a = e->FirstAttribute();
PropMap props;
while(a)
{
props.insert(make_pair(a->Name(), a->Value()));
a = a->Next();
}
view->parse(props);
TiXmlNode *node = e->FirstChild();
if (!node)
{
return view;
}
TiXmlElement *sub = node->ToElement();
while (sub)
{
View* sv = parse_element(sub, view);
sub = sub->NextSiblingElement();
}
return view;
}
void
window_part::parse_reset()
{
const char* p = ".";
parse_element(p);
}
static bool parse_element(FILE *in, int state, element_t *out)
{
tag_t tag;
element_t item;
int length;
char vr[3] = " ";
char tmp_buff[128];
bool extra_len = false;
int i;
if (remain_size(in) == 0) return false;
tag.group = READ(uint16_t, in);
tag.element = READ(uint16_t, in);
// The meta data is always in explicit form.
if (tag.group == 0x0002) state &= ~STATE_IMPLICIT_VR;
if (state & STATE_IMPLICIT_VR) {
length = READ(uint32_t, in);
// XXX: Handle this with a static table.
if (tag.v == TAG_INSTANCE_NUMBER.v) sprintf(vr, "IS");
if (tag.v == TAG_SLICE_LOCATION.v) sprintf(vr, "DS");
if (tag.v == TAG_SAMPLES_PER_PIXEL.v) sprintf(vr, "US");
if (tag.v == TAG_ROWS.v) sprintf(vr, "US");
if (tag.v == TAG_COLUMNS.v) sprintf(vr, "US");
if (tag.v == TAG_BITS_ALLOCATED.v) sprintf(vr, "US");
if (tag.v == TAG_BITS_STORED.v) sprintf(vr, "US");
if (tag.v == TAG_HIGH_BIT.v) sprintf(vr, "US");
if (tag.v == TAG_PIXEL_DATA.v) sprintf(vr, "OB");
} else {
fread(vr, 2, 1, in);
for (i = 0; i < ARRAY_SIZE(EXTRA_LEN_VRS); i++) {
if (strncmp(vr, EXTRA_LEN_VRS[i], 2) == 0) {
extra_len = true;
break;
}
}
if (extra_len) {
READ(uint16_t, in); // Reserved 2 bytes
length = READ(uint32_t, in);
} else {
length = READ(uint16_t, in);
}
}
LOG_V("(%.4x, %.4x) %s, length:%d", tag.group, tag.element, vr, length);
// Read a sequence of undefined length.
if (length == 0xffffffff && (streq(vr, "SQ") || streq(vr, "OW"))) {
while (true) {
parse_element(in, STATE_SEQUENCE_ITEM | STATE_IMPLICIT_VR, &item);
if (item.tag.v == TAG_SEQ_DEL.v) {
break;
}
if (item.tag.v != TAG_ITEM.v)
LOG_E("Expected item tag");
}
}
if (state & STATE_SEQUENCE_ITEM && length == 0xffffffff) {
while (true) {
parse_element(in, 0, &item);
if (item.tag.v == TAG_ITEM_DEL.v) {
break;
}
}
}
if (out) {
out->tag = tag;
out->length = length;
memcpy(out->vr, vr, 2);
}
// For the moment we just skip the data.
if (length != 0xffffffff) {
CHECK(length >= 0);
if (length > remain_size(in)) {
CHECK(false);
}
if (out && length == 2 && strncmp(vr, "US", 2) == 0) {
out->value.us = READ(uint16_t, in);
} else if (out && strncmp(vr, "IS", 2) == 0) {
CHECK(length < sizeof(tmp_buff) - 1);
fread(tmp_buff, length, 1, in);
tmp_buff[length] = '\0';
sscanf(tmp_buff, "%d", &out->value.is);
} else if (out && strncmp(vr, "DS", 2) == 0) {
CHECK(length < sizeof(tmp_buff) - 1);
fread(tmp_buff, length, 1, in);
tmp_buff[length] = '\0';
sscanf(tmp_buff, "%f", &out->value.ds);
} else if (out && strncmp(vr, "UI", 2) == 0) {
CHECK(length < sizeof(out->value.ui) - 1);
fread(out->value.ui, length, 1, in);
out->value.ui[length] = '\0';
} else if (out && tag.v == TAG_PIXEL_DATA.v && out->buffer) {
CHECK(out->buffer_size >= length);
fread(out->buffer, length, 1, in);
} else {
// Skip the data.
fseek(in, length, SEEK_CUR);
}
}
if (tag.group == 0) return false;
return true;
}
static void parse(rapidxml::xml_node<>* node, configuration const& config, documentation& doc, bool member = false)
{
if (node != NULL)
{
bool recurse = false;
bool is_member = member;
std::string nodename = node->name();
if (nodename == "doxygen")
{
recurse = true;
}
else if (nodename == "sectiondef")
{
std::string kind = get_attribute(node, "kind");
if (kind == "func"
|| kind == "define"
|| kind == "enum"
)
{
recurse = true;
}
else if (boost::starts_with(kind, "public"))
{
recurse = true;
is_member = true;
}
}
else if (nodename == "compounddef")
{
std::string kind = get_attribute(node, "kind");
if (kind == "group")
{
recurse = true;
}
else if (kind == "struct")
{
recurse = true;
doc.cos.is_class = false;
parse_element(node->first_node(), config, "", doc.cos);
}
else if (kind == "class")
{
recurse = true;
doc.cos.is_class = true;
parse_element(node->first_node(), config, "", doc.cos);
}
}
else if (nodename == "memberdef")
{
std::string kind = get_attribute(node, "kind");
if (kind == "function")
{
function f;
parse_element(node->first_node(), config, "", f);
parse_function(node->first_node(), config, "", f);
if (member)
{
f.type = boost::equals(f.name, doc.cos.name)
? function_constructor
: function_member;
doc.cos.functions.push_back(f);
}
else
{
f.type = function_free;
doc.functions.push_back(f);
}
}
else if (kind == "define")
{
function f;
f.type = function_define;
parse_element(node->first_node(), config, "", f);
parse_function(node->first_node(), config, "", f);
doc.functions.push_back(f);
}
else if (kind == "enum")
{
enumeration e;
parse_element(node->first_node(), config, "", e);
parse_enumeration(node->first_node(), config, "", e);
doc.enumerations.push_back(e);
}
else if (kind == "typedef")
{
if (boost::equals(get_attribute(node, "prot"), "public"))
{
std::string name = parse_named_node(node->first_node(), "name");
doc.cos.typedefs.push_back(base_element(name));
}
}
else if (kind == "variable")
{
if (boost::equals(get_attribute(node, "static"), "yes")
&& boost::equals(get_attribute(node, "mutable"), "no")
&& boost::equals(get_attribute(node, "prot"), "public"))
{
std::string name = parse_named_node(node->first_node(), "name");
doc.cos.variables.push_back(base_element(name));
}
}
}
else if (nodename == "compoundname")
{
std::string name = node->value();
if (name.find("::") != std::string::npos)
{
doc.cos.fullname = name;
// For a class, it should have "boost::something::" before
// set its name without namespace
doc.cos.name = keep_after(name, "::");
}
}
else if (nodename == "basecompoundref")
{
base_class bc;
bc.name = node->value();
bc.derivation = get_attribute(node, "prot");
bc.virtuality = get_attribute(node, "virt");
doc.cos.base_classes.push_back(bc);
}
else
{
//std::cout << nodename << " ignored." << std::endl;
}
if (recurse)
{
// First recurse into childnodes, then handle next siblings
parse(node->first_node(), config, doc, is_member);
}
parse(node->next_sibling(), config, doc, is_member);
}
}
static void parse_element(rapidxml::xml_node<>* node, configuration const& config, std::string const& parent, Element& el)
{
if (node != NULL)
{
std::string name = node->name();
std::string full = parent + "." + name;
if (full == ".briefdescription.para")
{
parse_para(node, el.brief_description, el.skip);
}
else if (full == ".detaileddescription.para")
{
std::string para;
parse_para(node, para, el.skip);
if (!para.empty() && !el.detailed_description.empty())
{
el.detailed_description += "\n\n";
}
el.detailed_description += para;
}
else if (full == ".location")
{
std::string loc = get_attribute(node, "file");
// Location of (header)file. It is a FULL path, so find the start
// and strip the rest
std::size_t pos = loc.rfind(config.start_include);
if (pos != std::string::npos)
{
loc = loc.substr(pos);
}
el.location = loc;
el.line = atol(get_attribute(node, "line").c_str());
}
else if (full == ".detaileddescription.para.qbk")
{
el.qbk_markup.push_back(markup(node->value()));
}
else if (full == ".detaileddescription.para.qbk.after.synopsis")
{
el.qbk_markup.push_back(markup(markup_after, markup_synopsis, node->value()));
}
else if (full == ".detaileddescription.para.qbk.before.synopsis")
{
el.qbk_markup.push_back(markup(markup_before, markup_synopsis, node->value()));
}
else if (full == ".detaileddescription.para.qbk.distinguish")
{
el.additional_description = node->value();
boost::trim(el.additional_description);
}
else if (full == ".templateparamlist")
{
parse_parameter_list(node->first_node(), el.template_parameters);
}
else if (full == ".detaileddescription.para.parameterlist")
{
std::string kind = get_attribute(node, "kind");
if (kind == "param")
{
parse_parameter_list(node->first_node(), el.parameters);
}
else if (kind == "templateparam")
{
parse_parameter_list(node->first_node(), el.template_parameters);
}
}
parse_element(node->first_node(), config, full, el);
parse_element(node->next_sibling(), config, parent, el);
}
}
struct table *parse_table(unsigned char *html, unsigned char *eof, unsigned char **end, struct rgb *bgcolor, int sh, struct s_e **bad_html, int *bhp)
{
int qqq;
struct table *t;
struct table_cell *cell;
unsigned char *t_name, *t_attr, *en;
int t_namelen;
int x = 0, y = -1;
int p = 0;
unsigned char *lbhp = NULL;
int l_al = AL_LEFT;
int l_val = VAL_MIDDLE;
int csp, rsp;
int group = 0;
int i, j, k;
struct rgb l_col;
int c_al = AL_TR, c_val = VAL_TR, c_width = W_AUTO, c_span = 0;
memcpy(&l_col, bgcolor, sizeof(struct rgb));
*end = html;
if (bad_html) {
*bad_html = DUMMY;
*bhp = 0;
}
if (!(t = new_table())) return NULL;
se:
en = html;
see:
html = en;
if (bad_html && !p && !lbhp) {
if (!(*bhp & (ALLOC_GR-1))) {
if ((unsigned)*bhp > MAXINT / sizeof(struct s_e) - ALLOC_GR) overalloc();
*bad_html = mem_realloc(*bad_html, (*bhp + ALLOC_GR) * sizeof(struct s_e));
}
lbhp = (*bad_html)[(*bhp)++].s = html;
}
while (html < eof && *html != '<') html++;
if (html >= eof) {
if (p) CELL(t, x, y)->end = html;
if (lbhp) (*bad_html)[*bhp-1].e = html;
goto scan_done;
}
if (html + 2 <= eof && (html[1] == '!' || html[1] == '?')) {
html = skip_comment(html, eof);
goto se;
}
if (parse_element(html, eof, &t_name, &t_namelen, &t_attr, &en)) {
html++;
goto se;
}
if (t_namelen == 5 && !casecmp(t_name, "TABLE", 5)) {
en = skip_table(en, eof);
goto see;
}
if (t_namelen == 6 && !casecmp(t_name, "/TABLE", 6)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (p) CELL(t, x, y)->end = html;
if (lbhp) (*bad_html)[*bhp-1].e = html;
goto scan_done;
}
if (t_namelen == 8 && !casecmp(t_name, "COLGROUP", 8)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
c_al = AL_TR;
c_val = VAL_TR;
c_width = W_AUTO;
get_align(t_attr, &c_al);
get_valign(t_attr, &c_val);
get_c_width(t_attr, &c_width, sh);
if ((c_span = get_num(t_attr, "span")) == -1) c_span = 1;
goto see;
}
if (t_namelen == 9 && !casecmp(t_name, "/COLGROUP", 9)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
c_span = 0;
c_al = AL_TR;
c_val = VAL_TR;
c_width = W_AUTO;
goto see;
}
if (t_namelen == 3 && !casecmp(t_name, "COL", 3)) {
int sp, wi, al, val;
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
if ((sp = get_num(t_attr, "span")) == -1) sp = 1;
wi = c_width;
al = c_al;
val = c_val;
get_align(t_attr, &al);
get_valign(t_attr, &val);
get_c_width(t_attr, &wi, sh);
new_columns(t, sp, wi, al, val, !!c_span);
c_span = 0;
goto see;
}
if (t_namelen == 3 && (!casecmp(t_name, "/TR", 3) || !casecmp(t_name, "/TD", 3) || !casecmp(t_name, "/TH", 3))) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (p) CELL(t, x, y)->end = html, p = 0;
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
}
if (t_namelen == 2 && !casecmp(t_name, "TR", 2)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (p) CELL(t, x, y)->end = html, p = 0;
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
if (group) group--;
l_al = AL_LEFT;
l_val = VAL_MIDDLE;
memcpy(&l_col, bgcolor, sizeof(struct rgb));
get_align(t_attr, &l_al);
get_valign(t_attr, &l_val);
get_bgcolor(t_attr, &l_col);
y++, x = 0;
goto see;
}
if (t_namelen == 5 && ((!casecmp(t_name, "THEAD", 5)) || (!casecmp(t_name, "TBODY", 5)) || (!casecmp(t_name, "TFOOT", 5)))) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
group = 2;
}
if (t_namelen != 2 || (casecmp(t_name, "TD", 2) && casecmp(t_name, "TH", 2))) goto see;
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
if (p) CELL(t, x, y)->end = html, p = 0;
if (y == -1) y = 0, x = 0;
nc:
cell = new_cell(t, x, y);
if (cell->used) {
if (cell->colspan == -1) goto see;
x++;
goto nc;
}
cell->mx = x;
cell->my = y;
cell->used = 1;
cell->start = en;
p = 1;
cell->align = l_al;
cell->valign = l_val;
if ((cell->b = upcase(t_name[1]) == 'H')) cell->align = AL_CENTER;
if (group == 1) cell->group = 1;
if (x < t->c) {
if (t->cols[x].align != AL_TR) cell->align = t->cols[x].align;
if (t->cols[x].valign != VAL_TR) cell->valign = t->cols[x].valign;
}
memcpy(&cell->bgcolor, &l_col, sizeof(struct rgb));
get_align(t_attr, &cell->align);
get_valign(t_attr, &cell->valign);
get_bgcolor(t_attr, &cell->bgcolor);
if ((csp = get_num(t_attr, "colspan")) == -1) csp = 1;
if (!csp) csp = -1;
if ((rsp = get_num(t_attr, "rowspan")) == -1) rsp = 1;
if (!rsp) rsp = -1;
if (csp >= 0 && rsp >= 0 && csp * rsp > 100000) {
if (csp > 10) csp = -1;
if (rsp > 10) rsp = -1;
}
cell->colspan = csp;
cell->rowspan = rsp;
if (csp == 1) {
int w = W_AUTO;
get_c_width(t_attr, &w, sh);
if (w != W_AUTO) set_td_width(t, x, w, 0);
}
qqq = t->x;
for (i = 1; csp != -1 ? i < csp : x + i < qqq; i++) {
struct table_cell *sc = new_cell(t, x + i, y);
if (sc->used) {
csp = i;
for (k = 0; k < i; k++) CELL(t, x + k, y)->colspan = csp;
break;
}
sc->used = sc->spanned = 1;
sc->rowspan = rsp;
sc->colspan = csp;
sc->mx = x;
sc->my = y;
}
qqq = t->y;
for (j = 1; rsp != -1 ? j < rsp : y + j < qqq; j++) {
for (k = 0; k < i; k++) {
struct table_cell *sc = new_cell(t, x + k, y + j);
if (sc->used) {
int l, m;
if (sc->mx == x && sc->my == y) continue;
/*internal("boo");*/
for (l = 0; l < k; l++) memset(CELL(t, x + l, y + j), 0, sizeof(struct table_cell));
rsp = j;
for (l = 0; l < i; l++) for (m = 0; m < j; m++) CELL(t, x + l, y + m)->rowspan = j;
goto brk;
}
sc->used = sc->spanned = 1;
sc->rowspan = rsp;
sc->colspan = csp;
sc->mx = x;
sc->my = y;
}
}
brk:
goto see;
scan_done:
*end = html;
for (x = 0; x < t->x; x++) for (y = 0; y < t->y; y++) {
struct table_cell *c = CELL(t, x, y);
if (!c->spanned) {
if (c->colspan == -1) c->colspan = t->x - x;
if (c->rowspan == -1) c->rowspan = t->y - y;
}
}
if ((unsigned)t->y > MAXINT / sizeof(int)) overalloc();
t->r_heights = mem_alloc(t->y * sizeof(int));
memset(t->r_heights, 0, t->y * sizeof(int));
for (x = 0; x < t->c; x++) if (t->cols[x].width != W_AUTO) set_td_width(t, x, t->cols[x].width, 1);
set_td_width(t, t->x, W_AUTO, 0);
return t;
}
void
html_textarea(struct html_context *html_context, unsigned char *attr,
unsigned char *html, unsigned char *eof, unsigned char **end)
{
struct form_control *fc;
unsigned char *p, *t_name, *wrap_attr;
int t_namelen;
int cols, rows;
int i;
html_focusable(html_context, attr);
while (html < eof && (*html == '\n' || *html == '\r')) html++;
p = html;
while (p < eof && *p != '<') {
pp:
p++;
}
if (p >= eof) {
*end = eof;
return;
}
if (parse_element(p, eof, &t_name, &t_namelen, NULL, end)) goto pp;
if (c_strlcasecmp(t_name, t_namelen, (const unsigned char *)"/TEXTAREA", 9)) goto pp;
fc = init_form_control(FC_TEXTAREA, attr, html_context);
if (!fc) return;
fc->id = get_attr_val(attr, (unsigned char *)"id", html_context->doc_cp);
fc->name = get_attr_val(attr, (unsigned char *)"name", html_context->doc_cp);
fc->default_value = convert_string(NULL, html, p - html,
html_context->doc_cp,
CSM_DEFAULT, NULL, NULL, NULL);
for (p = fc->default_value; p && p[0]; p++) {
/* FIXME: We don't cope well with entities here. Bugzilla uses
* inside of textarea and we fail miserably upon that
* one. --pasky */
if (p[0] == '\r') {
if (p[1] == '\n'
|| (p > fc->default_value && p[-1] == '\n')) {
memmove(p, p + 1, strlen((const char *)p));
p--;
} else {
p[0] = '\n';
}
}
}
cols = get_num(attr, (unsigned char *)"cols", html_context->doc_cp);
if (cols <= 0)
cols = html_context->options->default_form_input_size;
cols++; /* Add 1 column, other browsers may have different
behavior here (mozilla adds 2) --Zas */
if (cols > html_context->options->box.width)
cols = html_context->options->box.width;
fc->cols = cols;
rows = get_num(attr, (unsigned char *)"rows", html_context->doc_cp);
if (rows <= 0) rows = 1;
if (rows > html_context->options->box.height)
rows = html_context->options->box.height;
fc->rows = rows;
html_context->options->needs_height = 1;
wrap_attr = get_attr_val(attr, (unsigned char *)"wrap", html_context->doc_cp);
if (wrap_attr) {
if (!c_strcasecmp((const char *)wrap_attr, "hard")
|| !c_strcasecmp((const char *)wrap_attr, "physical")) {
fc->wrap = FORM_WRAP_HARD;
} else if (!c_strcasecmp((const char *)wrap_attr, "soft")
|| !c_strcasecmp((const char *)wrap_attr, "virtual")) {
fc->wrap = FORM_WRAP_SOFT;
} else if (!c_strcasecmp((const char *)wrap_attr, "none")
|| !c_strcasecmp((const char *)wrap_attr, "off")) {
fc->wrap = FORM_WRAP_NONE;
}
mem_free(wrap_attr);
} else if (has_attr(attr, (unsigned char *)"nowrap", html_context->doc_cp)) {
fc->wrap = FORM_WRAP_NONE;
} else {
fc->wrap = FORM_WRAP_SOFT;
}
fc->maxlength = get_num(attr, (unsigned char *)"maxlength", html_context->doc_cp);
if (fc->maxlength == -1) fc->maxlength = INT_MAX;
if (rows > 1) ln_break(html_context, 1);
else put_chrs(html_context, (unsigned char *)" ", 1);
html_stack_dup(html_context, ELEMENT_KILLABLE);
format.form = fc;
format.style.attr |= AT_BOLD;
for (i = 0; i < rows; i++) {
int j;
for (j = 0; j < cols; j++)
put_chrs(html_context, (unsigned char *)"_", 1);
if (i < rows - 1)
ln_break(html_context, 1);
}
pop_html_element(html_context);
if (rows > 1)
ln_break(html_context, 1);
else
put_chrs(html_context, (unsigned char *)" ", 1);
html_context->special_f(html_context, SP_CONTROL, fc);
}
END_TEST
/*
* request
*/
START_TEST(test_quit)
{
#define QUIT "quit"
#define SERIALIZED "*1\r\n$4\r\n" QUIT "\r\n"
#define INVALID "*2\r\n$4\r\n" QUIT "\r\n$3\r\nnow\r\n"
int ret;
struct element *el;
test_reset();
req->type = REQ_QUIT;
el = array_push(req->token);
el->type = ELEM_BULK;
el->bstr = (struct bstring){sizeof(QUIT) - 1, QUIT};
ret = compose_req(&buf, req);
ck_assert_int_eq(ret, sizeof(SERIALIZED) - 1);
ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0);
el->type = ELEM_UNKNOWN; /* this effectively resets *el */
request_reset(req);
ck_assert_int_eq(parse_req(req, buf), PARSE_OK);
ck_assert_int_eq(req->type, REQ_QUIT);
ck_assert_int_eq(req->token->nelem, 1);
el = array_first(req->token);
ck_assert_int_eq(el->type, ELEM_BULK);
ck_assert_int_eq(cc_bcmp(el->bstr.data, QUIT, sizeof(QUIT) - 1), 0);
/* invalid number of arguments */
test_reset();
buf_write(buf, INVALID, sizeof(INVALID) - 1);
ck_assert_int_eq(parse_req(req, buf), PARSE_EINVALID);
#undef INVALID
#undef SERIALIZED
#undef QUIT
}
END_TEST
START_TEST(test_ping)
{
#define PING "ping"
#define VAL "hello"
#define S_PING "*1\r\n$4\r\n" PING "\r\n"
#define S_ECHO "*2\r\n$4\r\n" PING "\r\n$5\r\nhello\r\n"
int ret;
struct element *el;
test_reset();
/* simple ping */
buf_write(buf, S_PING, sizeof(S_PING) - 1);
ck_assert_int_eq(parse_req(req, buf), PARSE_OK);
ck_assert_int_eq(req->type, REQ_PING);
/* ping as echo */
test_reset();
req->type = REQ_PING;
el = array_push(req->token);
el->type = ELEM_BULK;
el->bstr = (struct bstring){sizeof(PING) - 1, PING};
el = array_push(req->token);
el->type = ELEM_BULK;
el->bstr = (struct bstring){sizeof(VAL) - 1, VAL};
ret = compose_req(&buf, req);
ck_assert_int_eq(ret, sizeof(S_ECHO) - 1);
ck_assert_int_eq(cc_bcmp(buf->rpos, S_ECHO, ret), 0);
el->type = ELEM_UNKNOWN; /* resets *el */
request_reset(req);
ck_assert_int_eq(parse_req(req, buf), PARSE_OK);
ck_assert_int_eq(req->type, REQ_PING);
ck_assert_int_eq(req->token->nelem, 2);
el = array_first(req->token);
ck_assert_int_eq(el->type, ELEM_BULK);
ck_assert_int_eq(cc_bcmp(el->bstr.data, PING, sizeof(PING) - 1), 0);
el = array_get(req->token, 1);
ck_assert_int_eq(el->type, ELEM_BULK);
ck_assert_int_eq(cc_bcmp(el->bstr.data, VAL, sizeof(VAL) - 1), 0);
#undef S_ECHO
#undef ECHO
#undef S_PING
#undef QUIT
}
END_TEST
START_TEST(test_unfin_req)
{
char *token[4] = {
"*2\r\n",
"*2\r\n$3\r\n",
"*2\r\n$3\r\nfoo\r\n",
"*2\r\n$3\r\nfoo\r\n$3\r\n",
};
for (int i = 0; i < 4; i++) {
char *pos;
size_t len;
len = strlen(token[i]);
buf_reset(buf);
buf_write(buf, token[i], len);
pos = buf->rpos;
ck_assert_int_eq(parse_req(req, buf), PARSE_EUNFIN);
ck_assert(buf->rpos == pos);
}
}
END_TEST
/*
* response
*/
START_TEST(test_ok)
{
#define OK "OK"
#define SERIALIZED "+" OK "\r\n"
int ret;
struct element *el;
test_reset();
rsp->type = ELEM_STR;
el = array_push(rsp->token);
el->type = ELEM_STR;
el->bstr = (struct bstring){sizeof(OK) - 1, OK};
ret = compose_rsp(&buf, rsp);
ck_assert_int_eq(ret, sizeof(SERIALIZED) - 1);
ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0);
el->type = ELEM_UNKNOWN; /* resets *el */
response_reset(rsp);
ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_OK);
ck_assert_int_eq(rsp->type, ELEM_STR);
ck_assert_int_eq(rsp->token->nelem, 1);
el = array_first(rsp->token);
ck_assert_int_eq(el->type, ELEM_STR);
ck_assert_int_eq(cc_bcmp(el->bstr.data, OK, sizeof(OK) - 1), 0);
#undef SERIALIZED
#undef OK
}
END_TEST
START_TEST(test_array_reply)
{
#define SERIALIZED "*5\r\n:-10\r\n$-1\r\n-ERR invalid arg\r\n+foo\r\n$5\r\nHELLO\r\n"
size_t len = sizeof(SERIALIZED) - 1;
struct element *el;
test_reset();
buf_write(buf, SERIALIZED, len);
ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_OK);
ck_assert_int_eq(rsp->type, ELEM_ARRAY);
ck_assert_int_eq(rsp->token->nelem, 5);
el = array_first(rsp->token);
ck_assert_int_eq(el->type, ELEM_INT);
el = array_get(rsp->token, 1);
ck_assert_int_eq(el->type, ELEM_NIL);
el = array_get(rsp->token, 2);
ck_assert_int_eq(el->type, ELEM_ERR);
el = array_get(rsp->token, 3);
ck_assert_int_eq(el->type, ELEM_STR);
el = array_get(rsp->token, 4);
ck_assert_int_eq(el->type, ELEM_BULK);
ck_assert_int_eq(el->bstr.len, 5);
ck_assert_int_eq(cc_bcmp(el->bstr.data, "HELLO", 5), 0);
ck_assert_int_eq(buf_rsize(buf), 0);
ck_assert_int_eq(compose_rsp(&buf, rsp), len);
ck_assert_int_eq(buf_rsize(buf), len);
ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, len), 0);
#undef SERIALIZED
}
END_TEST
/*
* edge cases
*/
START_TEST(test_empty_buf)
{
struct element el;
test_reset();
ck_assert(!token_is_array(buf));
ck_assert_int_eq(parse_element(&el, buf), PARSE_EUNFIN);
ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_EUNFIN);
ck_assert_int_eq(parse_req(req, buf), PARSE_EUNFIN);
}
END_TEST
/*
* request/response pool
*/
START_TEST(test_req_pool_basic)
{
#define POOL_SIZE 10
int i;
struct request *reqs[POOL_SIZE];
request_options_st options = {
.request_ntoken = {.type = OPTION_TYPE_UINT, .val.vuint = REQ_NTOKEN},
.request_poolsize = {.type = OPTION_TYPE_UINT, .val.vuint = POOL_SIZE}};
request_setup(&options, NULL);
for (i = 0; i < POOL_SIZE; i++) {
reqs[i] = request_borrow();
ck_assert_msg(reqs[i] != NULL, "expected to borrow a request");
}
ck_assert_msg(request_borrow() == NULL, "expected request pool to be depleted");
for (i = 0; i < POOL_SIZE; i++) {
request_return(&reqs[i]);
ck_assert_msg(reqs[i] == NULL, "expected request to be nulled after return");
}
request_teardown();
#undef POOL_SIZE
}
END_TEST
START_TEST(test_rsp_pool_basic)
{
#define POOL_SIZE 10
int i;
struct response *rsps[POOL_SIZE];
response_options_st options = {
.response_ntoken = {.type = OPTION_TYPE_UINT, .val.vuint = RSP_NTOKEN},
.response_poolsize = {.type = OPTION_TYPE_UINT, .val.vuint = POOL_SIZE}};
response_setup(&options, NULL);
for (i = 0; i < POOL_SIZE; i++) {
rsps[i] = response_borrow();
ck_assert_msg(rsps[i] != NULL, "expected to borrow a response");
}
ck_assert_msg(response_borrow() == NULL, "expected response pool to be depleted");
for (i = 0; i < POOL_SIZE; i++) {
response_return(&rsps[i]);
ck_assert_msg(rsps[i] == NULL, "expected response to be nulled after return");
}
response_teardown();
#undef POOL_SIZE
}
END_TEST
/*
* test suite
*/
static Suite *
redis_suite(void)
{
Suite *s = suite_create(SUITE_NAME);
/* token */
TCase *tc_token = tcase_create("token");
suite_add_tcase(s, tc_token);
tcase_add_test(tc_token, test_simple_string);
tcase_add_test(tc_token, test_error);
tcase_add_test(tc_token, test_integer);
tcase_add_test(tc_token, test_bulk_string);
tcase_add_test(tc_token, test_array);
tcase_add_test(tc_token, test_nil_bulk);
tcase_add_test(tc_token, test_unfin_token);
/* basic requests */
TCase *tc_request = tcase_create("request");
suite_add_tcase(s, tc_request);
tcase_add_test(tc_request, test_quit);
tcase_add_test(tc_request, test_ping);
tcase_add_test(tc_request, test_unfin_req);
/* basic responses */
TCase *tc_response = tcase_create("response");
suite_add_tcase(s, tc_response);
tcase_add_test(tc_response, test_ok);
tcase_add_test(tc_response, test_array_reply);
/* edge cases */
TCase *tc_edge = tcase_create("edge cases");
suite_add_tcase(s, tc_edge);
tcase_add_test(tc_edge, test_empty_buf);
/* req/rsp objects, pooling */
TCase *tc_pool = tcase_create("request/response pool");
suite_add_tcase(s, tc_pool);
tcase_add_test(tc_pool, test_req_pool_basic);
tcase_add_test(tc_pool, test_rsp_pool_basic);
return s;
}
/* TODO(yao): move main to a different file, keep most test files main-less */
int
main(void)
{
int nfail;
/* setup */
test_setup();
Suite *suite = redis_suite();
SRunner *srunner = srunner_create(suite);
srunner_set_log(srunner, DEBUG_LOG);
srunner_run_all(srunner, CK_ENV); /* set CK_VEBOSITY in ENV to customize */
nfail = srunner_ntests_failed(srunner);
srunner_free(srunner);
/* teardown */
test_teardown();
return (nfail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int eeprom(int argc, char *argv[])
{
int i, len, ret;
unsigned char buf[58], *p;
struct eth_device dev = {
.iobase = CONFIG_SMC91111_BASE
};
app_startup(argv);
if (get_version() != XF_VERSION) {
printf("Wrong XF_VERSION.\n");
printf("Application expects ABI version %d\n", XF_VERSION);
printf("Actual U-Boot ABI version %d\n", (int)get_version());
return 1;
}
return crcek();
if ((SMC_inw (&dev, BANK_SELECT) & 0xFF00) != 0x3300) {
printf("SMSC91111 not found.\n");
return 2;
}
/* Called without parameters - print MAC address */
if (argc < 2) {
verify_macaddr(&dev, NULL);
return 0;
}
/* Print help message */
if (argv[1][1] == 'h') {
printf("VoiceBlue EEPROM writer\n");
printf("Built: %s at %s\n", U_BOOT_DATE, U_BOOT_TIME);
printf("Usage:\n\t<mac_address> [<element_1>] [<...>]\n");
return 0;
}
/* Try to parse information elements */
len = sizeof(buf);
p = buf;
for (i = 2; i < argc; i++) {
ret = parse_element(argv[i], p, len);
switch (ret) {
case -1:
printf("Element %d: malformed\n", i - 1);
return 3;
case -2:
printf("Element %d: odd character count\n", i - 1);
return 3;
case -3:
printf("Out of EEPROM memory\n");
return 3;
default:
p += ret;
len -= ret;
}
}
/* First argument (MAC) is mandatory */
set_mac(&dev, argv[1]);
if (verify_macaddr(&dev, argv[1])) {
printf("*** MAC address does not match! ***\n");
return 4;
}
while (len--)
*p++ = 0;
write_data(&dev, (u16 *)buf, sizeof(buf) >> 1);
return 0;
}
/*
* Prepares a template file.
*/
static apr_status_t parse_template (parser_rec *p) {
apr_status_t status;
apr_finfo_t finfo;
apr_file_t *file;
apr_size_t size;
/* read file */
if ((status = apr_stat(&finfo, p->filename, APR_FINFO_SIZE, p->pool))
!= APR_SUCCESS) {
p->err = apr_psprintf(p->pool, "file '%s' does not exist",
p->filename);
return status;
}
if ((status = apr_file_open(&file, p->filename, APR_READ, 0, p->pool))
!= APR_SUCCESS) {
p->err = apr_psprintf(p->pool, "file '%s' cannot be opened",
p->filename);
return status;
}
apr_pool_cleanup_register(p->pool, file, file_close,
apr_pool_cleanup_null);
p->buf = apr_palloc(p->pool, finfo.size + 1);
size = finfo.size;
if ((status = apr_file_read(file, p->buf, &size)) != APR_SUCCESS) {
p->err = apr_psprintf(p->pool, "file '%s' cannot be read",
p->filename);
return status;
}
if ((status = apr_file_close(file)) != APR_SUCCESS) {
p->err = apr_psprintf(p->pool, "file '%s' cannot be closed",
p->filename);
return status;
}
apr_pool_cleanup_kill(p->pool, file, file_close);
p->buf[size] = '\0';
/* no parse? */
if ((p->flags & TEMPLATE_FPARSE) == 0) {
p->pos = p->buf + size;
p->begin = p->buf;
parse_raw(p);
return APR_SUCCESS;
}
/* process elements and substitution, treat all else as raw */
p->pos = p->buf;
p->begin = p->pos;
while (*p->pos != '\0') {
switch (*p->pos) {
case '<':
if ((p->pos[1] == 'l' && p->pos[2] == ':')
|| (p->pos[1] == '/'
&& p->pos[2] == 'l'
&& p->pos[3] == ':')) {
parse_raw(p);
if ((status = parse_element(p))
!= APR_SUCCESS) {
return status;
}
p->begin = p->pos;
} else {
p->pos++;
}
break;
case '$':
switch (p->pos[1]) {
case '{':
case '[':
parse_raw(p);
if ((status = parse_sub(p)) != APR_SUCCESS) {
return status;
}
p->begin = p->pos;
break;
case '$':
p->pos++;
parse_raw(p);
p->pos++;
p->begin = p->pos;
break;
default:
p->pos++;
}
break;
default:
p->pos++;
}
}
parse_raw(p);
return APR_SUCCESS;
}
static void
do_html_select(unsigned char *attr, unsigned char *html,
unsigned char *eof, unsigned char **end,
struct html_context *html_context)
{
struct conv_table *ct = (struct conv_table *)html_context->special_f(html_context, SP_TABLE, NULL);
struct form_control *fc;
struct string lbl = NULL_STRING, orig_lbl = NULL_STRING;
unsigned char **values = NULL;
unsigned char **labels;
unsigned char *name, *t_attr, *en;
int namelen;
int nnmi = 0;
int order = 0;
int preselect = -1;
int group = 0;
int i, max_width;
int closing_tag;
html_focusable(html_context, attr);
init_menu(&lnk_menu);
se:
en = html;
see:
html = en;
while (html < eof && *html != '<') html++;
if (html >= eof) {
abort:
*end = html;
if (lbl.source) done_string(&lbl);
if (orig_lbl.source) done_string(&orig_lbl);
if (values) {
int j;
for (j = 0; j < order; j++)
mem_free_if(values[j]);
mem_free(values);
}
destroy_menu(&lnk_menu);
*end = en;
return;
}
if (lbl.source) {
unsigned char *q, *s = en;
int l = html - en;
while (l && isspace(s[0])) s++, l--;
while (l && isspace(s[l-1])) l--;
q = convert_string(ct, s, l,
html_context->options->cp,
CSM_DEFAULT, NULL, NULL, NULL);
if (q) add_to_string(&lbl, q), mem_free(q);
add_bytes_to_string(&orig_lbl, s, l);
}
if (html + 2 <= eof && (html[1] == '!' || html[1] == '?')) {
html = skip_comment(html, eof);
goto se;
}
if (parse_element(html, eof, &name, &namelen, &t_attr, &en)) {
html++;
goto se;
}
if (!namelen) goto see;
if (name[0] == '/') {
namelen--;
if (!namelen) goto see;
name++;
closing_tag = 1;
} else {
closing_tag = 0;
}
if (closing_tag && !c_strlcasecmp(name, namelen, (const unsigned char *)"SELECT", 6)) {
add_select_item(&lnk_menu, &lbl, &orig_lbl, values, order, nnmi);
goto end_parse;
}
if (!c_strlcasecmp(name, namelen, (const unsigned char *)"OPTION", 6)) {
add_select_item(&lnk_menu, &lbl, &orig_lbl, values, order, nnmi);
if (!closing_tag) {
unsigned char *value, *label;
if (has_attr(t_attr, (unsigned char *)"disabled", html_context->doc_cp))
goto see;
if (preselect == -1
&& has_attr(t_attr, (unsigned char *)"selected", html_context->doc_cp))
preselect = order;
value = get_attr_val(t_attr, (unsigned char *)"value", html_context->doc_cp);
if (!mem_align_alloc(&values, order, order + 1, 0xFF))
goto abort;
values[order++] = value;
label = get_attr_val(t_attr, (unsigned char *)"label", html_context->doc_cp);
if (label) new_menu_item(&lnk_menu, label, order - 1, 0);
if (!value || !label) {
init_string(&lbl);
init_string(&orig_lbl);
nnmi = !!label;
}
}
goto see;
}
if (!c_strlcasecmp(name, namelen, (const unsigned char *)"OPTGROUP", 8)) {
add_select_item(&lnk_menu, &lbl, &orig_lbl, values, order, nnmi);
if (group) new_menu_item(&lnk_menu, NULL, -1, 0), group = 0;
if (!closing_tag) {
unsigned char *label;
label = get_attr_val(t_attr, (unsigned char *)"label", html_context->doc_cp);
if (!label) {
label = stracpy((const unsigned char *)"");
if (!label) goto see;
}
new_menu_item(&lnk_menu, label, -1, 0);
group = 1;
}
}
goto see;
end_parse:
*end = en;
if (!order) goto abort;
labels = (unsigned char **)mem_calloc(order, sizeof(unsigned char *));
if (!labels) goto abort;
fc = init_form_control(FC_SELECT, attr, html_context);
if (!fc) {
mem_free(labels);
goto abort;
}
fc->id = get_attr_val(attr, (unsigned char *)"id", html_context->doc_cp);
fc->name = get_attr_val(attr, (unsigned char *)"name", html_context->doc_cp);
fc->default_state = preselect < 0 ? 0 : preselect;
fc->default_value = order ? stracpy(values[fc->default_state]) : stracpy((const unsigned char *)"");
fc->nvalues = order;
fc->values = values;
fc->menu = detach_menu(&lnk_menu);
fc->labels = labels;
menu_labels(fc->menu, (unsigned char *)"", labels);
put_chrs(html_context, (unsigned char *)"[", 1);
html_stack_dup(html_context, ELEMENT_KILLABLE);
format.form = fc;
format.style.attr |= AT_BOLD;
max_width = 0;
for (i = 0; i < order; i++) {
if (!labels[i]) continue;
#ifdef CONFIG_UTF8
if (html_context->options->utf8)
int_lower_bound(&max_width,
utf8_ptr2cells(labels[i], NULL));
else
#endif /* CONFIG_UTF8 */
int_lower_bound(&max_width, strlen((const char *)labels[i]));
}
for (i = 0; i < max_width; i++)
put_chrs(html_context, (unsigned char *)"_", 1);
pop_html_element(html_context);
put_chrs(html_context, (unsigned char *)"]", 1);
html_context->special_f(html_context, SP_CONTROL, fc);
}
void
html_option(struct html_context *html_context, unsigned char *a,
unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5)
{
struct form_control *fc;
unsigned char *val;
if (!format.select) return;
val = get_attr_val(a, (unsigned char *)"value", html_context->doc_cp);
if (!val) {
struct string str;
unsigned char *p, *r;
unsigned char *name;
int namelen;
for (p = a - 1; *p != '<'; p--);
if (!init_string(&str)) goto end_parse;
if (parse_element(p, html_context->eoff, NULL, NULL, NULL, &p)) {
INTERNAL("parse element failed");
val = str.source;
goto end_parse;
}
se:
while (p < html_context->eoff && isspace(*p)) p++;
while (p < html_context->eoff && !isspace(*p) && *p != '<') {
sp:
add_char_to_string(&str, *p ? *p : ' '), p++;
}
r = p;
val = str.source; /* Has to be before the possible 'goto end_parse' */
while (r < html_context->eoff && isspace(*r)) r++;
if (r >= html_context->eoff) goto end_parse;
if (r - 2 <= html_context->eoff && (r[1] == '!' || r[1] == '?')) {
p = skip_comment(r, html_context->eoff);
goto se;
}
if (parse_element(r, html_context->eoff, &name, &namelen, NULL, &p)) goto sp;
if (namelen < 6) goto se;
if (name[0] == '/') name++, namelen--;
if (c_strlcasecmp(name, namelen, (const unsigned char *)"OPTION", 6)
&& c_strlcasecmp(name, namelen, (const unsigned char *)"SELECT", 6)
&& c_strlcasecmp(name, namelen, (const unsigned char *)"OPTGROUP", 8))
goto se;
}
end_parse:
fc = init_form_control(FC_CHECKBOX, a, html_context);
if (!fc) {
mem_free_if(val);
return;
}
fc->id = get_attr_val(a, (unsigned char *)"id", html_context->doc_cp);
fc->name = null_or_stracpy(format.select);
fc->default_value = val;
fc->default_state = has_attr(a, (unsigned char *)"selected", html_context->doc_cp);
fc->mode = has_attr(a, (unsigned char *)"disabled", html_context->doc_cp)
? FORM_MODE_DISABLED
: format.select_disabled;
put_chrs(html_context, (unsigned char *)" ", 1);
html_stack_dup(html_context, ELEMENT_KILLABLE);
format.form = fc;
format.style.attr |= AT_BOLD;
put_chrs(html_context, (unsigned char *)"[ ]", 3);
pop_html_element(html_context);
put_chrs(html_context, (unsigned char *)" ", 1);
html_context->special_f(html_context, SP_CONTROL, fc);
}
