static int http_parse_arguments(struct http_request *r, NMEM nmem,
const char *args)
{
const char *p2 = args;
while (*p2)
{
struct http_argument *a;
const char *equal = strchr(p2, '=');
const char *eoa = strchr(p2, '&');
if (!equal)
{
yaz_log(YLOG_WARN, "Expected '=' in argument");
return -1;
}
if (!eoa)
eoa = equal + strlen(equal); // last argument
else if (equal > eoa)
{
yaz_log(YLOG_WARN, "Missing '&' in argument");
return -1;
}
a = nmem_malloc(nmem, sizeof(struct http_argument));
a->name = nmem_strdupn(nmem, p2, equal - p2);
a->value = nmem_strdupn(nmem, equal+1, eoa - equal - 1);
urldecode(a->name, a->name);
urldecode(a->value, a->value);
a->next = r->arguments;
r->arguments = a;
p2 = eoa;
while (*p2 == '&')
p2++;
}
return 0;
}
/* Accept a new command connection */
static void http_accept(IOCHAN i, int event)
{
struct sockaddr_in addr;
int fd = iochan_getfd(i);
socklen_t len;
int s;
IOCHAN c;
struct http_channel *ch;
struct conf_server *server = iochan_getdata(i);
len = sizeof addr;
if ((s = accept(fd, (struct sockaddr *) &addr, &len)) < 0)
{
yaz_log(YLOG_WARN|YLOG_ERRNO, "accept");
return;
}
enable_nonblock(s);
yaz_log(YLOG_DEBUG, "New command connection");
c = iochan_create(s, http_io, EVENT_INPUT | EVENT_EXCEPT, "http_session_socket");
ch = http_channel_create(server->http_server, inet_ntoa(addr.sin_addr),
server);
ch->iochan = c;
iochan_setdata(c, ch);
iochan_add(server->iochan_man, c);
}
static int compare(cql_transform_t ct, const char *pqf, const char *cql)
{
int ret = 0;
ODR odr = odr_createmem(ODR_ENCODE);
WRBUF w = wrbuf_alloc();
Z_RPNQuery *q = p_query_rpn(odr, pqf);
if (q)
{
int r = cql_transform_rpn2cql_wrbuf(ct, w, q);
if (r != 0)
{
/* transform error */
yaz_log(YLOG_LOG, "%s -> Error %d", pqf, r);
if (!cql) /* also expected error? */
ret = 1;
}
else if (r == 0)
{
yaz_log(YLOG_LOG, "%s -> %s", pqf, wrbuf_cstr(w));
if (cql && !strcmp(wrbuf_cstr(w), cql))
{
ret = 1;
}
}
}
wrbuf_destroy(w);
odr_destroy(odr);
return ret;
}
struct database *new_database_inherit_settings(const char *id, NMEM nmem, struct settings_array *service_settings)
{
struct database *db;
struct setting *idset;
db = nmem_malloc(nmem, sizeof(*db));
db->id = nmem_strdup(nmem, id);
db->next = 0;
if (service_settings && service_settings->num_settings > 0) {
yaz_log(YLOG_DEBUG, "copying settings from service to database %s settings", db->id);
db->num_settings = service_settings->num_settings;
db->settings = nmem_malloc(nmem, sizeof(*db->settings) * db->num_settings);
// Initialize database settings with service settings
memcpy(db->settings, service_settings->settings, sizeof(*db->settings) * db->num_settings);
}
else {
yaz_log(YLOG_DEBUG, "No service settings to database %s ", db->id);
db->num_settings = PZ_MAX_EOF;
db->settings = nmem_malloc(nmem, sizeof(*db->settings) * db->num_settings);
memset(db->settings, 0, sizeof(*db->settings) * db->num_settings);
}
idset = nmem_malloc(nmem, sizeof(*idset));
idset->precedence = 0;
idset->name = "pz:id";
idset->target = idset->value = db->id;
idset->next = db->settings[PZ_ID];
db->settings[PZ_ID] = idset;
return db;
}
static void xml_config_bend_start(void)
{
if (control_block.xml_config[0])
{
struct gfs_server *gfs = gfs_server_list;
for (; gfs; gfs = gfs->next)
{
yaz_log(YLOG_DEBUG, "xml_config_bend_start config=%s",
gfs->cb.configname);
statserv_setcontrol(&gfs->cb);
if (control_block.bend_start)
{
gfs_server_chdir(gfs);
(control_block.bend_start)(&gfs->cb);
}
}
}
else
{
yaz_log(YLOG_DEBUG, "xml_config_bend_start default config");
statserv_setcontrol(&control_block);
if (control_block.bend_start)
(*control_block.bend_start)(&control_block);
}
}
pp2_charset_t pp2_charset_create_xml(xmlNode *xml_node)
{
#if YAZ_HAVE_ICU
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
while (xml_node && xml_node->type != XML_ELEMENT_NODE)
xml_node = xml_node->next;
chain = icu_chain_xml_config(xml_node, 1, &status);
if (!chain || U_FAILURE(status)){
//xmlDocPtr icu_doc = 0;
//xmlChar *xmlstr = 0;
//int size = 0;
//xmlDocDumpMemory(icu_doc, size);
yaz_log(YLOG_FATAL, "Could not parse ICU chain config:\n"
"<%s>\n ... \n</%s>",
xml_node->name, xml_node->name);
return 0;
}
return pp2_charset_create(chain);
#else // YAZ_HAVE_ICU
yaz_log(YLOG_FATAL, "Error: ICU support requested with element:\n"
"<%s>\n ... \n</%s>",
xml_node->name, xml_node->name);
yaz_log(YLOG_FATAL,
"But no ICU support is compiled into the YAZ library.");
return 0;
#endif // YAZ_HAVE_ICU
}
void http_session_destroy(struct http_session *s)
{
int must_destroy = 0;
http_sessions_t http_sessions = s->http_sessions;
yaz_log(http_sessions->log_level, "Session %u destroy", s->session_id);
yaz_mutex_enter(http_sessions->mutex);
/* only if http_session has no active http sessions on it can be destroyed */
if (s->destroy_counter == s->activity_counter)
{
struct http_session **p = 0;
must_destroy = 1;
for (p = &http_sessions->session_list; *p; p = &(*p)->next)
if (*p == s)
{
*p = (*p)->next;
break;
}
}
yaz_mutex_leave(http_sessions->mutex);
if (must_destroy)
{ /* destroying for real */
yaz_log(http_sessions->log_level, "Session %u destroyed", s->session_id);
iochan_destroy(s->timeout_iochan);
session_destroy(s->psession);
http_session_use(-1);
nmem_destroy(s->nmem);
}
else {
yaz_log(http_sessions->log_level, "Session %u destroying delayed. Active clients (%d-%d). Waiting for new timeout.",
s->session_id, s->activity_counter, s->destroy_counter);
}
}
void yaz_check_print1(int type, const char *file, int line,
const char *expr)
{
const char *msg = "unknown";
int printit = 1;
test_total++;
switch(type)
{
case YAZ_TEST_TYPE_FAIL:
test_failed++;
msg = "FAILED";
if (test_verbose < 1)
printit = 0;
break;
case YAZ_TEST_TYPE_OK:
msg = "ok";
if (test_verbose < 3)
printit = 0;
break;
}
if (printit)
{
fprintf(get_file(), "%s:%d: %s: ", file, line, msg);
fprintf(get_file(), "%s\n", expr);
}
if (log_tests)
{
yaz_log(YLOG_LOG, "%s:%d %s: ", file, line, msg);
yaz_log(YLOG_LOG, "%s", expr);
}
}
static void connection_handler(IOCHAN iochan, int event)
{
struct connection *co = iochan_getdata(iochan);
struct client *cl;
struct host *host = co->host;
yaz_mutex_enter(host->mutex);
cl = co->client;
if (!cl)
{
/* no client associated with it.. We are probably getting
a closed connection from the target.. Or, perhaps, an unexpected
package.. We will just close the connection */
yaz_log(YLOG_LOG, "timeout connection %p event=%d", co, event);
remove_connection_from_host(co);
yaz_mutex_leave(host->mutex);
connection_destroy(co);
}
else if (event & EVENT_TIMEOUT)
{
if (co->state == Conn_Connecting)
{
yaz_log(YLOG_WARN, "%p connect timeout %s", co, client_get_id(cl));
client_set_state(cl, Client_Error);
remove_connection_from_host(co);
yaz_mutex_leave(host->mutex);
connection_destroy(co);
}
else
{
yaz_log(YLOG_LOG, "%p Connection idle timeout %s", co, client_get_id(cl));
remove_connection_from_host(co);
yaz_mutex_leave(host->mutex);
connection_destroy(co);
}
}
else
{
yaz_mutex_leave(host->mutex);
client_lock(cl);
non_block_events(co);
ZOOM_connection_fire_event_socket(co->link, event);
non_block_events(co);
client_unlock(cl);
if (co->link)
{
iochan_setflags(iochan, ZOOM_connection_get_mask(co->link));
iochan_setfd(iochan, ZOOM_connection_get_socket(co->link));
}
}
}
static void check_icu_chain(void)
{
const char *en_str
= "O Romeo, Romeo! wherefore art thou\t Romeo?";
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
const char *xml_str = "<icu locale=\"en\">"
"<transform rule=\"[:Control:] Any-Remove\"/>"
"<tokenize rule=\"l\"/>"
"<transform rule=\"[[:WhiteSpace:][:Punctuation:]] Remove\"/>"
"<display/>"
"<casemap rule=\"l\"/>"
"</icu>";
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
xmlNode *xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
chain = icu_chain_xml_config(xml_node, 0, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
if (!chain)
return;
YAZ_CHECK(icu_chain_assign_cstr(chain, en_str, &status));
while (icu_chain_next_token(chain, &status))
{
yaz_log(YLOG_LOG, "%d '%s' '%s'",
icu_chain_token_number(chain),
icu_chain_token_norm(chain),
icu_chain_token_display(chain));
}
YAZ_CHECK_EQ(icu_chain_token_number(chain), 7);
YAZ_CHECK(icu_chain_assign_cstr(chain, "what is this?", &status));
while (icu_chain_next_token(chain, &status))
{
yaz_log(YLOG_LOG, "%d '%s' '%s'",
icu_chain_token_number(chain),
icu_chain_token_norm(chain),
icu_chain_token_display(chain));
}
YAZ_CHECK_EQ(icu_chain_token_number(chain), 3);
icu_chain_destroy(chain);
}
void perform_getaddrinfo(struct work *w)
{
struct addrinfo hints, *res;
char host[512], *cp;
char *port = 0;
int error;
hints.ai_flags = 0;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = 0;
hints.ai_addrlen = 0;
hints.ai_addr = NULL;
hints.ai_canonname = NULL;
hints.ai_next = NULL;
strncpy(host, w->hostport, sizeof(host)-1);
host[sizeof(host)-1] = 0;
if ((cp = strrchr(host, ':')))
{
*cp = '\0';
port = cp + 1;
}
error = getaddrinfo(host, port ? port : "210", &hints, &res);
if (error)
{
yaz_log(YLOG_WARN, "Failed to resolve %s: %s",
w->hostport, gai_strerror(error));
}
else
{
char n_host[512];
if (getnameinfo((struct sockaddr *) res->ai_addr, res->ai_addrlen,
n_host, sizeof(n_host)-1,
0, 0,
NI_NUMERICHOST) == 0)
{
w->ipport = xmalloc(strlen(n_host) + (port ? strlen(port) : 0) + 2);
strcpy(w->ipport, n_host);
if (port)
{
strcat(w->ipport, ":");
strcat(w->ipport, port);
}
yaz_log(log_level, "Resolved %s -> %s", w->hostport, w->ipport);
}
else
{
yaz_log(YLOG_LOG|YLOG_ERRNO, "getnameinfo failed for %s",
w->hostport);
}
freeaddrinfo(res);
}
}
static void cmd_termlist(struct http_channel *c)
{
struct http_request *rq = c->request;
struct http_response *rs = c->response;
struct http_session *s = locate_session(c);
const char *block = http_argbyname(rq, "block");
const char *report = http_argbyname(rq, "report");
int report_status = 0;
int report_error = 0;
const char *status_message = 0;
int active_clients;
if (report && !strcmp("error", report)) {
report_error = 1;
status_message = "OK";
}
if (report && !strcmp("status", report)) {
report_status = 1;
status_message = "OK";
}
if (!s)
return;
active_clients = session_active_clients(s->psession);
if (block && !strcmp("1", block) && active_clients)
{
// if there is already a watch/block. we do not block this one
if (session_set_watch(s->psession, SESSION_WATCH_TERMLIST,
termlist_result_ready, c, c) != 0)
{
yaz_log(YLOG_WARN, "Session %u: Attempt to block multiple times on termlist block. Not supported!", s->session_id);
if (report_error) {
error(rs, PAZPAR2_ALREADY_BLOCKED, "termlist");
release_session(c, s);
return;
}
else if (report_status) {
status_message = "WARNING (Already blocked on termlist)";
}
else {
yaz_log(YLOG_WARN, "Session %u: Ignoring termlist block. Return current result", s->session_id);
}
}
else
{
yaz_log(c->http_sessions->log_level, "Session %u: Blocking on command termlist", s->session_id);
release_session(c, s);
return;
}
}
termlist_response(c, s, status_message);
release_session(c, s);
}
static int test_icu_casemap(const char *locale, char action,
const char *src8cstr, const char *chk8cstr)
{
int success = 0;
UErrorCode status = U_ZERO_ERROR;
struct icu_buf_utf8 *src8 = icu_buf_utf8_create(0);
struct icu_buf_utf8 *dest8 = icu_buf_utf8_create(0);
struct icu_buf_utf16 *src16 = icu_buf_utf16_create(0);
struct icu_buf_utf16 *dest16 = icu_buf_utf16_create(0);
int src8cstr_len = strlen(src8cstr);
int chk8cstr_len = strlen(chk8cstr);
/* converting to UTF16 */
icu_utf16_from_utf8_cstr(src16, src8cstr, &status);
/* perform case mapping */
icu_utf16_casemap(dest16, src16, locale, action, &status);
/* converting to UTF8 */
icu_utf16_to_utf8(dest8, dest16, &status);
/* determine success */
if (dest8->utf8
&& (dest8->utf8_len == strlen(chk8cstr))
&& !strcmp(chk8cstr, (const char *) dest8->utf8))
success = 1;
else
success = 0;
/* report failures */
if (!success)
{
yaz_log(YLOG_WARN, "test_icu_casemap failed");
yaz_log(YLOG_LOG, "Original string: '%s' (%d)",
src8cstr, src8cstr_len);
yaz_log(YLOG_LOG, "icu_casemap '%s:%c' '%s' (%d)",
locale, action, dest8->utf8, dest8->utf8_len);
yaz_log(YLOG_LOG, "expected string: '%s' (%d)",
chk8cstr, chk8cstr_len);
}
/* clean the buffers */
icu_buf_utf8_destroy(src8);
icu_buf_utf8_destroy(dest8);
icu_buf_utf16_destroy(src16);
icu_buf_utf16_destroy(dest16);
return success;
}
static int test_icu_tokenizer(const char *locale, char action,
const char *src8cstr, int count)
{
int success = 1;
UErrorCode status = U_ZERO_ERROR;
struct icu_buf_utf16 *src16 = icu_buf_utf16_create(0);
struct icu_buf_utf16 *tkn16 = icu_buf_utf16_create(0);
struct icu_buf_utf8 *tkn8 = icu_buf_utf8_create(0);
struct icu_tokenizer *tokenizer = 0;
size_t org_start, org_len;
/* transforming to UTF16 */
icu_utf16_from_utf8_cstr(src16, src8cstr, &status);
icu_check_status(status);
/* set up tokenizer */
tokenizer = icu_tokenizer_create(locale, action, &status);
icu_check_status(status);
YAZ_CHECK(tokenizer);
/* attach text buffer to tokenizer */
icu_tokenizer_attach(tokenizer, src16, &status);
icu_check_status(status);
/* perform work on tokens */
while (icu_tokenizer_next_token(tokenizer, tkn16, &status,
&org_start, &org_len))
{
icu_check_status(status);
/* converting to UTF8 */
icu_utf16_to_utf8(tkn8, tkn16, &status);
}
if (count != icu_tokenizer_token_count(tokenizer))
{
success = 0;
yaz_log(YLOG_LOG, "Tokenizer '%s:%c' Error:", locale, action);
yaz_log(YLOG_LOG, " Input: '%s'", src8cstr);
yaz_log(YLOG_LOG, " Tokens: %d", icu_tokenizer_token_count(tokenizer));
yaz_log(YLOG_LOG, " Expected: %d", count);
}
icu_tokenizer_destroy(tokenizer);
icu_buf_utf16_destroy(src16);
icu_buf_utf16_destroy(tkn16);
icu_buf_utf8_destroy(tkn8);
return success;
}
/*
* Set up a listening endpoint, and give it to the event-handler.
*/
static int add_listener(char *where, int listen_id)
{
COMSTACK l;
void *ap;
IOCHAN lst = NULL;
const char *mode;
if (control_block.dynamic)
mode = "dynamic";
else if (control_block.threads)
mode = "threaded";
else
mode = "static";
yaz_log(log_server, "Adding %s listener on %s id=%d", mode, where,
listen_id);
l = cs_create_host(where, 2, &ap);
if (!l)
{
yaz_log(YLOG_FATAL, "Failed to listen on %s", where);
return -1;
}
if (*control_block.cert_fname)
cs_set_ssl_certificate_file(l, control_block.cert_fname);
if (cs_bind(l, ap, CS_SERVER) < 0)
{
if (cs_errno(l) == CSYSERR)
yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to bind to %s", where);
else
yaz_log(YLOG_FATAL, "Failed to bind to %s: %s", where,
cs_strerror(l));
cs_close(l);
return -1;
}
if (!(lst = iochan_create(cs_fileno(l), listener, EVENT_INPUT |
EVENT_EXCEPT, listen_id)))
{
yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create IOCHAN-type");
cs_close(l);
return -1;
}
iochan_setdata(lst, l); /* user-defined data for listener is COMSTACK */
l->user = lst; /* user-defined data for COMSTACK is listener chan */
/* Add listener to chain */
lst->next = pListener;
pListener = lst;
return 0; /* OK */
}
static void gfs_server_chdir(struct gfs_server *gfs)
{
if (gfs_root_dir[0])
{
if (chdir(gfs_root_dir))
yaz_log(YLOG_WARN|YLOG_ERRNO, "chdir %s", gfs_root_dir);
}
if (gfs->directory)
{
if (chdir(gfs->directory))
yaz_log(YLOG_WARN|YLOG_ERRNO, "chdir %s",
gfs->directory);
}
}
void yaz_mutex_enter(YAZ_MUTEX p)
{
if (p)
{
#ifdef WIN32
EnterCriticalSection(&p->handle);
#elif YAZ_POSIX_THREADS
int r = 1; /* signal : not locked (yet) */
if (p->log_level)
{ /* debugging */
r = pthread_mutex_trylock(&p->handle);
if (r)
{
#if HAVE_SYS_TIME_H
long long d;
struct timeval tv1, tv2;
gettimeofday(&tv1, 0);
#endif
yaz_log(p->log_level,
"yaz_mutex_enter: %p tid=%p name=%s waiting",
p, (void *) pthread_self(), p->name);
#if HAVE_SYS_TIME_H
r = pthread_mutex_lock(&p->handle);
gettimeofday(&tv2, 0);
d = 1000000LL * ((long long) tv2.tv_sec - tv1.tv_sec) +
tv2.tv_usec - tv1.tv_usec;
yaz_log(p->log_level, "yaz_mutex_enter: %p tid=%p name=%s "
"lock delay %lld",
p, (void *) pthread_self(), p->name, d);
#endif
}
else
{
yaz_log(p->log_level, "yaz_mutex_enter: %p tid=%p name=%s lock",
p, (void *) pthread_self(), p->name);
}
}
if (r)
{
r = pthread_mutex_lock(&p->handle);
if (p->log_level)
{
yaz_log(p->log_level, "yaz_mutex_enter: %p tid=%p name=%s lock",
p, (void *) pthread_self(), p->name);
}
}
#endif
}
}
static void bytarget_result_ready(void *data)
{
struct http_channel *c = (struct http_channel *) data;
struct http_session *s = locate_session(c);
const char *status_message = "OK";
if (s) {
yaz_log(c->http_sessions->log_level, "Session %u: bytarget watch released", s->session_id);
bytarget_response(c, s, status_message);
release_session(c, s);
}
else {
yaz_log(c->http_sessions->log_level, "No Session found for released bytarget watch");
}
}
static void enable_nonblock(int sock)
{
int flags;
#ifdef WIN32
flags = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
if (ioctlsocket(sock, FIONBIO, &flags) < 0)
yaz_log(YLOG_FATAL|YLOG_ERRNO, "ioctlsocket");
#else
if ((flags = fcntl(sock, F_GETFL, 0)) < 0)
yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl");
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0)
yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl2");
#endif
}
void icu_buf_utf16_log(const char *lead, struct icu_buf_utf16 *src16)
{
if (src16)
{
struct icu_buf_utf8 *dst8 = icu_buf_utf8_create(0);
UErrorCode status = U_ZERO_ERROR;
icu_utf16_to_utf8(dst8, src16, &status);
yaz_log(YLOG_LOG, "%s=%s", lead, dst8->utf8);
icu_buf_utf8_destroy(dst8);
}
else
{
yaz_log(YLOG_LOG, "%s=NULL", lead);
}
}
static int compare2(cql_transform_t ct, const char *pqf, const char *cql,
int expected_error)
{
int ret = 0;
ODR odr = odr_createmem(ODR_ENCODE);
WRBUF w = wrbuf_alloc();
Z_RPNQuery *q = p_query_rpn(odr, pqf);
if (q)
{
int r = cql_transform_rpn2cql_wrbuf(ct, w, q);
if (r != 0)
{
const char *addinfo = 0;
int err = cql_transform_error(ct, &addinfo);
/* transform error */
yaz_log(YLOG_LOG, "%s -> Error %d", pqf, r);
if (err == 0)
;
else if (err == expected_error)
{
if (addinfo && cql && !strcmp(addinfo, cql))
ret = 1;
else if (!addinfo && !cql)
ret = 1;
}
}
else if (r == 0)
{
yaz_log(YLOG_LOG, "%s -> %s", pqf, wrbuf_cstr(w));
if (!expected_error)
ret = 1;
else if (cql && !strcmp(wrbuf_cstr(w), cql))
{
ret = 1;
}
else
{
yaz_log(YLOG_WARN, " expected: %s", cql ? cql : "null");
yaz_log(YLOG_WARN, " got: %s", wrbuf_cstr(w));
}
}
}
wrbuf_destroy(w);
odr_destroy(odr);
return ret;
}
struct http_session *http_session_create(struct conf_service *service,
http_sessions_t http_sessions,
unsigned int sesid)
{
NMEM nmem = nmem_create();
struct http_session *r = nmem_malloc(nmem, sizeof(*r));
char tmp_str[50];
sprintf(tmp_str, "session#%u", sesid);
r->psession = new_session(nmem, service, sesid);
r->session_id = sesid;
r->timestamp = 0;
r->nmem = nmem;
r->destroy_counter = r->activity_counter = 0;
r->http_sessions = http_sessions;
yaz_mutex_enter(http_sessions->mutex);
r->next = http_sessions->session_list;
http_sessions->session_list = r;
yaz_mutex_leave(http_sessions->mutex);
r->timeout_iochan = iochan_create(-1, session_timeout, 0, "http_session_timeout");
iochan_setdata(r->timeout_iochan, r);
yaz_log(http_sessions->log_level, "Session %u created. timeout chan=%p timeout=%d", sesid, r->timeout_iochan, service->session_timeout);
iochan_settimeout(r->timeout_iochan, service->session_timeout);
iochan_add(service->server->iochan_man, r->timeout_iochan);
http_session_use(1);
return r;
}
static struct http_channel *http_channel_create(http_server_t hs,
const char *addr,
struct conf_server *server)
{
struct http_channel *r;
r = xmalloc(sizeof(struct http_channel));
r->nmem = nmem_create();
r->wrbuf = wrbuf_alloc();
http_server_incref(hs);
r->http_server = hs;
r->http_sessions = hs->http_sessions;
assert(r->http_sessions);
r->server = server;
r->proxy = 0;
r->iochan = 0;
r->iqueue = r->oqueue = 0;
r->state = Http_Idle;
r->keep_alive = 0;
r->request = 0;
r->response = 0;
if (!addr)
{
yaz_log(YLOG_WARN, "Invalid HTTP forward address");
exit(1);
}
strcpy(r->addr, addr);
r->observers = 0;
return r;
}
bend_initresult *bend_init(bend_initrequest *q)
{
bend_initresult *r = (bend_initresult *)
odr_malloc (q->stream, sizeof(*r));
int *counter = (int *) xmalloc (sizeof(int));
*counter = 0;
r->errcode = 0;
r->errstring = 0;
r->handle = counter; /* user handle, in this case a simple int */
q->bend_sort = ztest_sort; /* register sort handler */
q->bend_search = ztest_search; /* register search handler */
q->bend_present = ztest_present; /* register present handle */
q->bend_esrequest = ztest_esrequest;
q->bend_delete = ztest_delete;
q->bend_fetch = ztest_fetch;
q->bend_scan = ztest_scan;
q->bend_explain = ztest_explain;
if (read_conf_file()) {
yaz_log(LOG_LOG,"Can't handle configuration file");
r->errcode = 2;
}
return r;
}
int pp2_charset_fact_define(pp2_charset_fact_t pft,
xmlNode *xml_node, const char *default_id)
{
int r;
pp2_charset_t pct;
xmlChar *id = 0;
assert(xml_node);
pct = pp2_charset_create_xml(xml_node);
if (!pct)
return -1;
if (!default_id)
{
id = xmlGetProp(xml_node, (xmlChar*) "id");
if (!id)
{
yaz_log(YLOG_WARN, "Missing id for icu_chain");
pp2_charset_destroy(pct);
return -1;
}
default_id = (const char *) id;
}
r = pp2_charset_fact_add(pft, pct, default_id);
if (id)
xmlFree(id);
return r;
}
/* retrieval of a single record (present, and piggy back search) */
int ztest_fetch(void *handle, bend_fetch_rr *r)
{
char query[100];
r->errstring = 0;
r->last_in_set = 0;
r->basename = database;
r->output_format = r->request_format;
if (cur_results>=n_results) {
r->errcode=13;
return 0;
} else {
sprintf(query,"query=%s&command=get_notice",ids[cur_results]);
cur_results++;
if (cur_results==n_results)
r->last_in_set=1;
if (http_get(query)) {
r->errcode=2;
return 0;
}
}
yaz_log(LOG_LOG,"sending notice for notice_id %s",ids[cur_results-1]);
r->len = strlen(http_content);
r->record = http_content;
r->output_format = VAL_UNIMARC;
r->errcode = 0;
return 0;
}
void ccl_qual_field(CCL_bibset bibset, const char *cp, const char *qual_name)
{
const char *addinfo;
ccl_qual_field2(bibset, cp, qual_name, &addinfo);
if (addinfo)
yaz_log(YLOG_WARN, "ccl_qual_field2 fail: %s", addinfo);
}
void http_set_proxyaddr(const char *host, struct conf_server *server)
{
const char *p;
short port;
struct hostent *he;
WRBUF w = wrbuf_alloc();
yaz_log(YLOG_LOG, "HTTP backend %s", host);
p = strchr(host, ':');
if (p)
{
port = atoi(p + 1);
wrbuf_write(w, host, p - host);
wrbuf_puts(w, "");
}
else
{
port = 80;
wrbuf_puts(w, host);
}
if (!(he = gethostbyname(wrbuf_cstr(w))))
{
fprintf(stderr, "Failed to lookup '%s'\n", wrbuf_cstr(w));
exit(1);
}
wrbuf_destroy(w);
server->http_server->proxy_addr = xmalloc(sizeof(struct sockaddr_in));
server->http_server->proxy_addr->sin_family = he->h_addrtype;
memcpy(&server->http_server->proxy_addr->sin_addr.s_addr,
he->h_addr_list[0], he->h_length);
server->http_server->proxy_addr->sin_port = htons(port);
}
// Serialize a HTTP request
static struct http_buf *http_serialize_request(struct http_request *r)
{
struct http_channel *c = r->channel;
struct http_header *h;
wrbuf_rewind(c->wrbuf);
wrbuf_printf(c->wrbuf, "%s %s%s%s", r->method, r->path,
*r->search ? "?" : "", r->search);
wrbuf_printf(c->wrbuf, " HTTP/%s\r\n", r->http_version);
for (h = r->headers; h; h = h->next)
wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
wrbuf_puts(c->wrbuf, "\r\n");
if (r->content_buf)
wrbuf_write(c->wrbuf, r->content_buf, r->content_len);
#if 0
yaz_log(YLOG_LOG, "WRITING TO PROXY:\n%s\n----",
wrbuf_cstr(c->wrbuf));
#endif
return http_buf_bywrbuf(c->http_server, c->wrbuf);
}
unsigned int make_sessionid(void)
{
static int seq = 0; /* thread pr */
unsigned int res;
seq++;
if (global_parameters.predictable_sessions)
res = seq;
else
{
#ifdef WIN32
res = seq;
#else
struct timeval t;
if (gettimeofday(&t, 0) < 0)
{
yaz_log(YLOG_WARN|YLOG_ERRNO, "gettimeofday");
exit(1);
}
/* at most 256 sessions per second ..
(long long would be more appropriate)*/
res = t.tv_sec;
res = ((res << 8) | (seq & 0xff)) & ((1U << 31) - 1);
#endif
}
return res;
}
