int
DAPI_getField (DocObject *doc,
FieldObject *field,
char *fieldname,
char **buffer) {
char path[SHORT_STRING_SIZE]; // ¿ø·¡´Â MAX_PATHKEY_LEN (parser.h)
char* field_value; int field_length;
int ret;
if (doc->p == NULL) {
warn("no parsing result");
return FAIL;
}
/* get field */
strncpy(path, "/Document/", SHORT_STRING_SIZE);
strncat(path, fieldname, SHORT_STRING_SIZE-11);
ret = sb_run_xmlparser_retrieve_field(doc->p, path, &field_value, &field_length);
if (ret != SUCCESS) {
warn("cannot retrieve field[%s]", fieldname);
return FAIL;
}
/* duplicate */
*buffer = (char *)sb_malloc(field_length + 1);
if (*buffer == NULL) {
error("cannot malloc: %s", strerror(errno));
return FALSE;
}
strncpy(*buffer, field_value, field_length);
(*buffer)[field_length] = '\0';
return TRUE;
}
void init_nodes()
{
int i;
if ( nodes_pool == NULL && max_node_count > 0 ) {
nodes_pool= (qpp1_node_t *)
sb_malloc(sizeof(qpp1_node_t)*max_node_count);
} else
for (i = 0; i < max_node_count; i++)
{
if (nodes_pool[i].string != NULL)
{
debug("free(nodes_pool[%d].string[%s])", i, nodes_pool[i].string);
free(nodes_pool[i].string);
nodes_pool[i].string = NULL;
}
}
memset(nodes_pool, 0x00, sizeof(qpp1_node_t)*max_node_count);
for (i = 0; i < max_node_count-1; i++)
{
nodes_pool[i].left = &nodes_pool[i+1];
}
free_nodes = &nodes_pool[0];
qpp1_tree = NULL;
}
int QPP_infixBuffer(char* result, QueryNode postfix[], int numNode)
{
struct qpp_tree_node* operand_stack[ENOUGH_QUERY_STACK_SIZE];
int operand_stack_pos = -1;
int i, j, k;
result[0] = '\0';
for ( i = 0; i < numNode; i++ ) {
struct qpp_tree_node* node = qpp_make_tree_node();
node->expr = &postfix[i];
if ( postfix[i].type == OPERAND ) {
if ( operand_stack_pos >= ENOUGH_QUERY_STACK_SIZE-1 ) {
error("not enough operand stack size");
goto return_error;
}
operand_stack[++operand_stack_pos] = node;
continue;
}
else { // operator
if ( operand_stack_pos < postfix[i].num_of_operands-1 ) {
error("invalid postfix expression");
goto return_error;
}
node->child = (struct qpp_tree_node**)
sb_malloc( sizeof(struct qpp_tree_node*) * postfix[i].num_of_operands );
node->child_count = postfix[i].num_of_operands;
for ( j = operand_stack_pos - postfix[i].num_of_operands + 1, k=0;
j <= operand_stack_pos; j++ ) {
node->child[k++] = operand_stack[j];
}
operand_stack_pos -= (postfix[i].num_of_operands-1);
operand_stack[operand_stack_pos] = node;
}
}
if ( operand_stack_pos != 0 ) {
error("invalid postfix expression");
goto return_error;
}
qpp_print_tree( operand_stack[0], result );
qpp_destroy_tree( operand_stack[0] );
return SUCCESS;
return_error:
QPP_postfixPrint(postfix, numNode);
for ( i = 0; i <= operand_stack_pos; i++ ) {
qpp_destroy_tree( operand_stack[i] );
}
return FAIL;
}
static int document_select(request_rec *r, softbot_handler_rec *s)
{
int rv = 0;
uint32_t docid = 0;
char* OID = 0;
char* DID = 0;
char content_type[SHORT_STRING_SIZE+1];
OID = apr_pstrdup(r->pool, apr_table_get(s->parameters_in, "OID"));
DID = apr_pstrdup(r->pool, apr_table_get(s->parameters_in, "DID"));
if( (OID == NULL || strlen(OID) == 0) &&
(DID == NULL || strlen(DID) == 0) ) {
MSG_RECORD(&s->msg, error, "oid, did is null, get parameter exist with oid or did.");
return FAIL;
}
if (canned_doc == NULL) {
canned_doc = (char *)sb_malloc(DOCUMENT_SIZE);
if (canned_doc == NULL) {
MSG_RECORD(&s->msg, crit, "out of memory: %s", strerror(errno));
return FAIL;
}
}
if(OID != NULL) decodencpy(OID, OID, strlen(OID));
if(DID == NULL) {
rv = sb_run_get_docid(did_db, OID, &docid);
if ( rv < 0 ) {
MSG_RECORD(&s->msg, error, "cannot get docid of OID[%s]", OID);
return FAIL;
}
if( rv == DOCID_NOT_REGISTERED ) {
MSG_RECORD(&s->msg, error, "not registerd OID[%s]", OID);
return FAIL;
}
} else {
docid = atoi(DID);
}
rv = sb_run_cdm_get_xmldoc(cdm_db, docid, canned_doc, DOCUMENT_SIZE);
if ( rv < 0 ) {
MSG_RECORD(&s->msg, error, "cannot get document[%u]", docid);
return FAIL;
}
snprintf( content_type, SHORT_STRING_SIZE, "text/xml; charset=%s", default_charset);
ap_set_content_type(r, content_type);
ap_rprintf(r, "<?xml version=\"1.0\" encoding=\"%s\"?>\n", default_charset);
ap_rwrite(canned_doc, strlen(canned_doc), r);
return SUCCESS;
}
sbtmpfile_t*
sbtmpfile_create_write()
{
sbtmpfile_t* stf = (sbtmpfile_t*) sb_malloc(sizeof(sbtmpfile_t));
stf->f = tmpfile();
if (!stf->f) {
fprintf(stderr, "error creating tmpfile.\n");
exit(EXIT_FAILURE);
} else {
stf->access_mode = SBTMPFILE_WRITE;
}
return stf;
}
sbtmpfile_t*
sbtmpfile_read_from_file(FILE* f)
{
sbtmpfile_t* stf = (sbtmpfile_t*) sb_malloc(sizeof(sbtmpfile_t));
stf->f = f;
if (!stf->f) {
fprintf(stderr, "error opening existing tmpfile.\n");
exit(EXIT_FAILURE);
} else {
fseek(stf->f,0,SEEK_SET); /* seek to the start */
stf->access_mode = SBTMPFILE_READREAD;
}
return stf;
}
int
DAPI_getAbstract (int numRetrievedDoc,
RetrievedDoc aDoc[],
DocObject *docs[]) {
int iResult,
iSize,
i;
VariableBuffer bufs[MAX_NUM_RETRIEVED_DOC];
char *to_parse;
xmlDocPtr xmldoc;
int tmpChar[DOCUMENT_SIZE];
if (numRetrievedDoc > MAX_NUM_RETRIEVED_DOC) {
error("too big number of argument 1; max number of retrieved document is %d",
MAX_NUM_RETRIEVED_DOC);
return FALSE;
}
for (i=0; i<numRetrievedDoc; i++) {
docs[i] = sb_malloc(sizeof(DocObject));
if (docs[i] == NULL) {
error("out of memory");
return FALSE;
}
sb_run_buffer_initbuf(&(bufs[i]));
}
iResult = sb_run_server_canneddoc_get_abstract(numRetrievedDoc, aDoc, bufs);
if (iResult < 0) {
error("cannot retreive canned document from server");
return FALSE;
}
for (i=0; i<numRetrievedDoc; i++) {
docs[i]->dtd = cannedDocDtd;
iSize = sb_run_buffer_getsize(&(bufs[i])); // XXX: deleteme
if (iSize <= 0) {
warn("Document has negative iSize! - skipping");
doc[i]->p = NULL; // mark as absent
continue;
}
if (iSize > DOCUMENT_SIZE-1) iSize = DOCUMENT_SIZE - 1;
bzero(tmpChar, DOCUMENT_SIZE); // XXX
iResult = sb_run_buffer_get(&(bufs[i]), 0, iSize, tmpChar);
tmpChar[iSize] = '\0';
sb_run_buffer_freebuf(&(bufs[i]));
// charset transform
if ((to_parse = EUCKR_TO_UTF8 ((char *)tmpChar)) == NULL) {
error("cannot convert Euc-kr to UTF-8 of document[%ld]", aDoc[i].docId);
continue;
}
xmldoc = xmlParseDoc(to_parse);
free (to_parse);
if (xmldoc == NULL) {
error("cannot parse document[%ld]", aDoc[i].docId);
continue;
}
docs[i]->doc = xmldoc;
docs[i]->root = xmlDocGetRootElement (xmldoc);
if (docs[i]->root == NULL) {
error("cannot get root element object of document[%ld]", aDoc[i].docId);
continue;
}
}
return TRUE;
}
int
DAPI_get (DocId docId,
DocObject **pdoc) {
DocObject *doc;
int iResult,
iSize;
VariableBuffer buf;
char *to_parse;
xmlDocPtr xmldoc;
int tmpChar[DOCUMENT_SIZE];
bzero(tmpChar, DOCUMENT_SIZE);
doc = sb_malloc(sizeof(DocObject));
if (doc == NULL) {
error("cannot allocate memory for DocObject: %s", strerror(errno));
return FALSE;
}
sb_run_buffer_initbuf(&buf);
iResult = sb_run_server_canneddoc_get(docId, &buf);
/* iResult = sb_run_client_canneddoc_get(docId, &buf);*/
if (iResult < 0) {
error("cannot retreive canned document from server");
sb_free(doc);
return FALSE;
}
doc->dtd = cannedDocDtd;
iSize = sb_run_buffer_getsize(&buf);
iResult = sb_run_buffer_get(&buf, 0, iSize, tmpChar);
tmpChar[iSize] = '\0';
sb_run_buffer_freebuf(&buf);
// charset transform
if ((to_parse = EUCKR_TO_UTF8 ((char *)tmpChar)) == NULL) {
sb_free(doc);
error("cannot convert Euc-kr to UTF-8");
return FALSE;
}
/* iSize = strlen(to_parse);*/
/* xmldoc = xmlParseMemory (to_parse, iSize);*/
xmldoc = xmlParseDoc(to_parse);
free (to_parse);
if (xmldoc == NULL) {
error("cannot parse document[%ld]", docId);
sb_free(doc);
return FALSE;
}
doc->doc = xmldoc;
doc->root = xmlDocGetRootElement (xmldoc);
if (doc->root == NULL) {
error("cannot get root element of cannot document[%ld]", docId);
xmlFreeDoc (doc->doc);
sb_free(doc);
return FALSE;
}
*pdoc = doc;
return TRUE;
}
/////////////////////////////////////////////////////////////////////////
// 문서 등록/수정
static int document_insert(request_rec *r, softbot_handler_rec *s)
{
int rv = 0;
uint32_t docid = 0;
uint32_t olddocid = 0;
char* OID = 0;
char* document = NULL;
memfile* request_body = NULL;
OID = apr_pstrdup(r->pool, apr_table_get(s->parameters_in, "OID"));
if(OID == NULL || strlen(OID) == 0) {
MSG_RECORD(&s->msg, error, "oid is null, get parameter exist with oid.");
return FAIL;
}
// 이미 존재하는 문서는 삭제.
rv = sb_run_get_docid(did_db, OID, &docid);
if ( rv == SUCCESS ) document_delete(r, s);
decodencpy(OID, OID, strlen(OID));
rv = sb_run_sbhandler_make_memfile(r, &request_body);
if(rv != SUCCESS) {
MSG_RECORD(&s->msg, error, "cannot get POST data");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
if (canned_doc == NULL) {
canned_doc = (char *)sb_malloc(DOCUMENT_SIZE);
if (canned_doc == NULL) {
MSG_RECORD(&s->msg, crit, "out of memory: %s", strerror(errno));
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
}
if(memfile_getSize(request_body) >= DOCUMENT_SIZE) {
MSG_RECORD(&s->msg, error, "cannot insert document, max size[%d], current size[%ld]",
DOCUMENT_SIZE, memfile_getSize(request_body));
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
rv = memfile_read(request_body, canned_doc, memfile_getSize(request_body));
if(rv != memfile_getSize(request_body)) {
MSG_RECORD(&s->msg, error, "cannot read memfile");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
canned_doc[memfile_getSize(request_body)] = '\0';
debug("memfile_getSize(request_body) = [%ld]", memfile_getSize(request_body));
decodencpy(canned_doc, canned_doc, strlen(canned_doc));
document = strchr(canned_doc, '=');
if(document == NULL || document - canned_doc > 20) {
MSG_RECORD(&s->msg, error, "cannot find body");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
document++;
rv = sb_run_cdm_put_xmldoc(cdm_db, did_db, OID,
document, strlen(document), &docid, &olddocid);
switch ( rv ) {
case CDM2_PUT_NOT_WELL_FORMED_DOC:
//RGLOG_ERROR("cannot register canned document[%s]. not well formed document", OID);
break;
case CDM2_PUT_OID_DUPLICATED:
//RGLOG_INFO("doc[%u] is deleted. OID[%s] is registered by docid[%u]", olddocid, OID, docid);
break;
case SUCCESS:
//RGLOG_INFO("OID[%s] is registered by docid[%u]", OID, docid);
break;
default:
//RGLOG_ERROR("cannot register canned document[%s] because of error(%d)", OID, n);
break;
}
if(request_body != NULL) memfile_free(request_body);
return SUCCESS;
}
static int document_ma(request_rec *r, softbot_handler_rec *s)
{
int rv = 0;
char* metadata = NULL;
char* document = NULL;
char* p = NULL;
void *parser = NULL;
char* field_value; int field_length;
sb4_merge_buffer_t merge_buffer;
memfile* request_body = NULL;
char field_name[MAX_FIELD_NAME_LEN];
int ma_id = 0;
int field_id = 0;
int data_size =0;
uint32_t buffer_size=0;
char *buffer = NULL;
int is_binary = 0;
int is_plantext = 0;
int is_raw_koma_text = 0;
char* contenttype = NULL;
char* rawkomatext = NULL;
char content_type[SHORT_STRING_SIZE+1];
is_binary = equals_content_type(r, "x-softbotd/binary");
contenttype = apr_pstrdup(r->pool, apr_table_get(s->parameters_in, "contenttype"));
if(contenttype == NULL) {
is_plantext = 0; // xml
} else if(strncasecmp("xml", contenttype, 3) == 0) {
is_plantext = 0; // xml
} else if(strncasecmp("text", contenttype, 4) == 0) {
is_plantext = 1; // text
}
rawkomatext = apr_pstrdup(r->pool, apr_table_get(s->parameters_in, "rawkomatext"));
if(rawkomatext == NULL) {
is_raw_koma_text = 0;
} else {
is_raw_koma_text = 1;
}
metadata = apr_pstrdup(r->pool, apr_table_get(s->parameters_in, "metadata"));
if( metadata == NULL || strlen(metadata) == 0 ) {
MSG_RECORD(&s->msg, error, "metadata is null, get parameter exist with metadata.");
return FAIL;
}
if (canned_doc == NULL) {
canned_doc = (char *)sb_malloc(DOCUMENT_SIZE);
if (canned_doc == NULL) {
MSG_RECORD(&s->msg, crit, "out of memory: %s", strerror(errno));
return FAIL;
}
}
if(metadata != NULL) decodencpy(metadata, metadata, strlen(metadata));
rv = sb_run_sbhandler_make_memfile(r, &request_body);
if(rv != SUCCESS) {
MSG_RECORD(&s->msg, error, "can not post data");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
if(memfile_getSize(request_body) >= DOCUMENT_SIZE) {
MSG_RECORD(&s->msg, error, "can not insert document, max size[%d], current size[%ld]",
DOCUMENT_SIZE, memfile_getSize(request_body));
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
rv = memfile_read(request_body, canned_doc, memfile_getSize(request_body));
if(rv != memfile_getSize(request_body)) {
MSG_RECORD(&s->msg, error, "can not read memfile");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
canned_doc[memfile_getSize(request_body)] = '\0';
decodencpy(canned_doc, canned_doc, strlen(canned_doc));
document = strchr(canned_doc, '=');
if(document == NULL || document - canned_doc > 20) {
MSG_RECORD(&s->msg, error, "can not find body");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
document++;
parser = sb_run_xmlparser_parselen("CP949" , (char *)document, strlen(document));
if (parser == NULL) {
MSG_RECORD(&s->msg, error, "cannot parse document");
if(request_body != NULL) memfile_free(request_body);
return FAIL;
}
p = metadata;
merge_buffer.data = NULL;
merge_buffer.data_size = 0;
merge_buffer.allocated_size = 0;
do {
char path[STRING_SIZE];
char *field_id_ptr=0x00;
char fid[3];
int field_id_is_given = 0;
void* tmp_data = NULL;
p = get_field_and_ma_id_from_meta_data(p , field_name, &ma_id);
field_id_ptr = strchr(field_name, '#');
if (field_id_ptr != NULL)
field_id_is_given = 1;
if (field_id_is_given == 1) {
strcpy(fid, field_id_ptr+1);
*field_id_ptr = '\0';
field_id = atol(fid);
}
info("fieldname[%s] id[%d]", field_name, field_id);
sprintf(path, "/Document/%s", field_name);
path[STRING_SIZE-1] = '\0';
rv = sb_run_xmlparser_retrieve_field(parser, path, &field_value, &field_length);
if (field_id_is_given) {
if (rv != SUCCESS) {
warn("cannot retrieve field[%s]", path);
continue;
}
if (field_length == 0) {
continue;
}
} else {
if (rv != SUCCESS) {
warn("cannot retrieve field[%s]", path);
field_id++;
continue;
}
if (field_length == 0) {
field_id++;
continue;
}
}
if ( field_length+1 > buffer_size ) {
buffer = apr_palloc(r->pool, sizeof(char) * (field_length+1));
buffer_size = field_length + 1;
}
memcpy(buffer, field_value, field_length);
buffer[field_length] = '\0';
tmp_data = NULL;
if(is_raw_koma_text) ma_id = 100;
rv = sb_run_rmas_morphological_analyzer(field_id, buffer, &tmp_data,
&data_size, ma_id);
if (rv == FAIL || rv == DECLINE) {
MSG_RECORD(&s->msg, warn, "failed to do morphological analysis - rmas_morphological_analyzer()");
sb_run_xmlparser_free_parser(parser);
return FAIL;
}
info("finished ma: data_size: %d", data_size);
rv = sb_run_rmas_merge_index_word_array( &merge_buffer , tmp_data , data_size);
if (rv == FAIL) {
MSG_RECORD(&s->msg, warn, "failed to do morphological analysis - rmas_merge_index_word_array()");
sb_free(tmp_data);
sb_run_xmlparser_free_parser(parser);
return FAIL;
}
sb_free(tmp_data);
field_id++;
} while (*p);
sb_run_xmlparser_free_parser(parser);
if(is_binary == SUCCESS) {
ap_rwrite(merge_buffer.data, merge_buffer.data_size, r);
} else {
int i;
index_word_t *idx = NULL;
int cnt = merge_buffer.data_size / sizeof(index_word_t);
char tag[5];
if(is_plantext) {
ap_rprintf(r, "%d\n", cnt);
for(i = 0; i < cnt; i++) {
idx = (index_word_t*)merge_buffer.data + i;
memcpy(tag, &idx->attribute, 4);
tag[4] = '\0';
ap_rprintf(r, "%s %d %s\n", idx->word, idx->pos, tag);
}
} else {
snprintf( content_type, SHORT_STRING_SIZE, "text/xml; charset=%s", default_charset);
ap_set_content_type(r, content_type);
ap_rprintf(r, "<?xml version=\"1.0\" encoding=\"%s\"?>\n", default_charset);
ap_rprintf(r, "<items count=\"%d\">", cnt);
for(i = 0; i < cnt; i++) {
idx = (index_word_t*)merge_buffer.data + i;
memcpy(tag, &idx->attribute, 4);
tag[4] = '\0';
ap_rprintf(r, "<word pos = \"%d\" field=\"%d\" tag=\"%s\"><![CDATA[%s]]></word>\n", idx->pos, idx->field, tag, idx->word);
}
ap_rprintf(r, "</items>");
}
}
return SUCCESS;
}
sb_config_t*
sb_config_parse(const char *src, size_t src_len, sb_error_t **err)
{
if (err != NULL && *err != NULL)
return NULL;
size_t current = 0;
size_t start = 0;
sb_trie_t *section = NULL;
char *section_name = NULL;
char *key = NULL;
char *value = NULL;
sb_config_t *rv = sb_malloc(sizeof(sb_config_t));
rv->root = sb_trie_new((sb_free_func_t) sb_trie_free);
sb_configparser_state_t state = CONFIG_START;
while (current < src_len) {
char c = src[current];
bool is_last = current == src_len - 1;
switch (state) {
case CONFIG_START:
if (c == '#' || c == ';') {
while (current < src_len) {
if (src[current] == '\r' || src[current] == '\n')
break;
current++;
}
break;
}
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
break;
if (c == '[') {
state = CONFIG_SECTION_START;
break;
}
if (section != NULL) {
start = current;
state = CONFIG_SECTION_KEY;
continue;
}
if (err != NULL)
*err = sb_error_new_printf(SB_ERROR_CONFIGPARSER,
"File must start with section");
break;
case CONFIG_SECTION_START:
start = current;
state = CONFIG_SECTION;
break;
case CONFIG_SECTION:
if (c == ']') {
section_name = sb_strndup(src + start, current - start);
section = sb_trie_new(free);
sb_trie_insert(rv->root, section_name, section);
free(section_name);
section_name = NULL;
state = CONFIG_START;
break;
}
if (c != '\r' && c != '\n')
break;
if (err != NULL)
*err = sb_error_new_printf(SB_ERROR_CONFIGPARSER,
"Section names can't have new lines");
break;
case CONFIG_SECTION_KEY:
if (c == '=') {
key = sb_strndup(src + start, current - start);
state = CONFIG_SECTION_VALUE_START;
break;
}
if (c != '\r' && c != '\n' && !is_last)
break;
// key without value, should we support it?
if (err != NULL) {
size_t end = is_last && c != '\n' && c != '\r' ? src_len :
current;
key = sb_strndup(src + start, end - start);
*err = sb_error_new_printf(SB_ERROR_CONFIGPARSER,
"Key without value: %s", key);
free(key);
key = NULL;
}
break;
case CONFIG_SECTION_VALUE_START:
start = current;
state = CONFIG_SECTION_VALUE;
break;
case CONFIG_SECTION_VALUE:
if (c == '\r' || c == '\n' || is_last) {
size_t end = is_last && c != '\n' && c != '\r' ? src_len :
current;
value = sb_strndup(src + start, end - start);
sb_trie_insert(section, sb_str_strip(key),
sb_strdup(sb_str_strip(value)));
free(key);
key = NULL;
free(value);
value = NULL;
state = CONFIG_START;
break;
}
break;
}
if (err != NULL && *err != NULL) {
sb_config_free(rv);
rv = NULL;
break;
}
current++;
}
free(section_name);
free(key);
free(value);
return rv;
}
int
DAPI_get (uint32_t docId,
DocObject **pdoc) {
DocObject *doc;
int iResult,
iSize,
size;
VariableBuffer buf;
static char *tmpChar = NULL;
if (tmpChar == NULL) {
tmpChar = (char *)sb_malloc(DOCUMENT_SIZE);
if (tmpChar == NULL) {
crit("out of memory: %s", strerror(errno));
return FALSE;
}
}
doc = sb_malloc(sizeof(DocObject));
if (doc == NULL) {
error("cannot allocate memory for DocObject: %s", strerror(errno));
sb_free(tmpChar);
tmpChar = NULL;
return FALSE;
}
/* get document */
sb_run_buffer_initbuf(&buf);
iResult = sb_run_server_canneddoc_get(docId, &buf);
if (iResult == CDM_DELETED) {
info("deleted document[%u]",(uint32_t)docId);
sb_free(doc);
return DOCAPI_DELETED;
}
if (iResult < 0) {
error("cannot retrieve canned document from server");
sb_free(doc);
return FALSE;
}
iSize = sb_run_buffer_getsize(&buf);
iResult = sb_run_buffer_get(&buf, 0, iSize, tmpChar);
if (iResult < 0) {
error("cannot get document[%u] from variable buffer", docId);
sb_free(doc);
return FALSE;
}
tmpChar[iSize] = '\0';
size = sb_run_buffer_getsize(&buf);
sb_run_buffer_freebuf(&buf);
/* parse */
doc->p = sb_run_xmlparser_parselen("CP949", tmpChar, size);
if (doc->p == NULL) {
error("cannot parse document[%u]", docId);
sb_free(doc);
return FALSE;
}
*pdoc = doc;
return TRUE;
}
int
DAPI_getAbstract (int numRetrievedDoc,
RetrievedDoc aDoc[],
DocObject *docs[]) {
int iResult,
iSize,
i;
VariableBuffer bufs[MAX_NUM_RETRIEVED_DOC];
static char *tmpChar = NULL;
if (tmpChar == NULL) {
tmpChar = (char *)sb_malloc(DOCUMENT_SIZE);
if (tmpChar == NULL) {
crit("out of memory: %s", strerror(errno));
return FALSE;
}
}
if (numRetrievedDoc > MAX_NUM_RETRIEVED_DOC) {
error("too big number of argument 1; max number of retrieved document is %d",
MAX_NUM_RETRIEVED_DOC);
return FALSE;
}
/* get documents */
for (i=0; i<numRetrievedDoc; i++) {
docs[i] = sb_malloc(sizeof(DocObject));
if (docs[i] == NULL) {
error("out of memory: cannot alloc memory for DocObject");
return FALSE;
}
sb_run_buffer_initbuf(&(bufs[i]));
}
iResult = sb_run_server_canneddoc_get_abstract(numRetrievedDoc, aDoc, bufs);
if (iResult < 0) {
error("cannot retreive canned document from server");
return FALSE;
}
for (i=0; i<numRetrievedDoc; i++) {
int size = 0;
if (aDoc[i].docId == 0) continue;
iSize = sb_run_buffer_getsize(&(bufs[i]));
if (iSize <= 0) {
info("size <= 0");
// so that we know that this document isn't there
info("Document has negative iSize! - skipping");
docs[i]->p = NULL;
// make core
// abort();
continue;
}
iResult = sb_run_buffer_get(&(bufs[i]), 0, iSize, tmpChar);
tmpChar[iSize] = '\0';
size = sb_run_buffer_getsize(&(bufs[i]));
sb_run_buffer_freebuf(&(bufs[i]));
docs[i]->p = sb_run_xmlparser_parselen("CP949", tmpChar, size);
if (docs[i]->p == NULL) {
error("cannot parse document[%ld]: charset:%s", aDoc[i].docId, tmpChar);
continue;
}
}
return TRUE;
}
