自学教程：C++ yaz_log函数代码示例

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);}

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;}

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;}

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 requeststatic 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;}