aolserver/nsd/tclhttp.c

/*
 * The contents of this file are subject to the AOLserver Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://aolserver.com/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is AOLserver Code and related documentation
 * distributed by AOL.
 * 
 * The Initial Developer of the Original Code is America Online,
 * Inc. Portions created by AOL are Copyright (C) 1999 America Online,
 * Inc. All Rights Reserved.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU General Public License (the "GPL"), in which case the
 * provisions of GPL are applicable instead of those above.  If you wish
 * to allow use of your version of this file only under the terms of the
 * GPL and not to allow others to use your version of this file under the
 * License, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the GPL.
 * If you do not delete the provisions above, a recipient may use your
 * version of this file under either the License or the GPL.
 */

/*
 * tclhttp.c --
 *
 *      Support for the ns_http command.
 */

static const char *RCSID = "@(#) $Header: /cvsroot-fuse/aolserver/aolserver/nsd/tclhttp.c,v 1.24 2007/03/12 20:29:44 shmooved Exp $, compiled: " __DATE__ " " __TIME__;

#include "nsd.h"

extern Tcl_ObjCmdProc <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_NsTclHttpObjCmd">NsTclHttpObjCmd</a>;

typedef struct {
    Ns_Task *task;
    SOCKET sock;
    char *error;
    char *next;
    size_t len;
    int status;
    Ns_Time timeout;
    Ns_Time stime;
    Ns_Time etime;
    Tcl_DString ds;
} Http;

/*
 * Local functions defined in this file
 */

static int <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpWaitCmd">HttpWaitCmd</a>(NsInterp *itPtr, int objc, Tcl_Obj **objv);
static int <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpQueueCmd">HttpQueueCmd</a>(NsInterp *itPtr, int objc, Tcl_Obj **objv, int run);
static int <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_SetWaitVar">SetWaitVar</a>(Tcl_Interp *interp, Tcl_Obj *varPtr, Tcl_Obj *valPtr);
static int <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpConnect">HttpConnect</a>(Tcl_Interp *interp, char *method, char *url,
                        Ns_Set *hdrs, Tcl_Obj *bodyPtr, Http **httpPtrPtr);
static char *<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpResult">HttpResult</a>(Tcl_DString ds, int *statusPtr, Ns_Set *hdrs, Tcl_Obj **objPtrPtr);
static void <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpClose">HttpClose</a>(Http *httpPtr);
static void <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpCancel">HttpCancel</a>(Http *httpPtr);
static void <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpAbort">HttpAbort</a>(Http *httpPtr);
static int <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_GetHttp">GetHttp</a>(NsInterp *itPtr, Tcl_Obj *obj, Http **httpPtrPtr);
static Ns_TaskProc <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpProc">HttpProc</a>;

/*
 * Static variables defined in this file.
 */
 
static Ns_TaskQueue *queue;


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_NsTclNHttpObjCmd">NsTclNHttpObjCmd</a> --
 *
 *      Implements the new ns_http to handle HTTP requests.
 *
 * Results:
 *      Standard Tcl result.
 *
 * Side effects:
 *      May queue an HTTP request.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_NsTclNHttpObjCmd">NsTclNHttpObjCmd</a>(ClientData arg, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
{
    NsInterp *itPtr = arg;
    Http *httpPtr;
    Tcl_HashEntry *hPtr;
    Tcl_HashSearch search;
    int run = 0;
    static CONST char *opts[] = {
       "cancel", "cleanup", "run", "queue", "wait", NULL
    };
    enum {
        HCancelIdx, HCleanupIdx, HRunIdx, HQueueIdx, HWaitIdx
    } opt;

    if (objc < 2) {
        Tcl_WrongNumArgs(interp, 1, objv, "option ?args ...?");
        return TCL_ERROR;
    }
    if (Tcl_GetIndexFromObj(interp, objv[1], opts, "option", 0,
                            (int *) &opt) != TCL_OK) {
        return TCL_ERROR;
    }

    switch (opt) {
    case HRunIdx:
        run = 1;
        /* FALLTHROUGH */
    case HQueueIdx:
        return <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpQueueCmd">HttpQueueCmd</a>(itPtr, objc, objv, run);
        break;

    case HWaitIdx:
        return <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpWaitCmd">HttpWaitCmd</a>(itPtr, objc, objv);
        break;

    case HCancelIdx:
        if (objc != 2) {
            Tcl_WrongNumArgs(interp, 2, objv, "id");
            return TCL_ERROR;
        }
        if (!<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_GetHttp">GetHttp</a>(itPtr, objv[2], &httpPtr)) {
            return TCL_ERROR;
        }
        <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpAbort">HttpAbort</a>(httpPtr);
        break;

    case HCleanupIdx:
        hPtr = Tcl_FirstHashEntry(&itPtr->https, &search);
        while (hPtr != NULL) {
            httpPtr = Tcl_GetHashValue(hPtr);
            <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpAbort">HttpAbort</a>(httpPtr);
            hPtr = Tcl_NextHashEntry(&search);
        }
        Tcl_DeleteHashTable(&itPtr->https);
        Tcl_InitHashTable(&itPtr->https, TCL_STRING_KEYS);
        break;
    }
    return TCL_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpQueueCmd">HttpQueueCmd</a> --
 *
 *      Implements "ns_http queue" subcommand.
 *
 * Results:
 *      Standard Tcl result.
 *
 * Side effects:
 *      May queue an HTTP request.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpQueueCmd">HttpQueueCmd</a>(NsInterp *itPtr, int objc, Tcl_Obj **objv, int run)
{
    Tcl_Interp *interp = itPtr->interp;
    int new, i;
    Tcl_HashEntry *hPtr;
    Http *httpPtr;
    char buf[100], *arg, *url;
    char *method = "GET";
    Ns_Set *hdrs = NULL;
    Tcl_Obj *bodyPtr = NULL;
    Ns_Time incr;
    static CONST char *opts[] = {
       "-method", "-timeout", "-body", "-headers", NULL
    };
    enum {
        QMethodIdx, QTimeoutIdx, QBodyIdx, QHeadersIdx
    } opt;

    incr.sec = 2;
    incr.usec = 0;
    for (i = 2; i < objc; ++i) {
        arg = Tcl_GetString(objv[i]);
        if (arg[0] != '-') {
            break;
        }
        if (Tcl_GetIndexFromObj(interp, objv[i], opts, "option", 0,
                            (int *) &opt) != TCL_OK) {
            return TCL_ERROR;
        }
        if ((i + 2) == objc) {
            Tcl_AppendResult(interp, "no argument given to ", opts[opt], NULL);
            return TCL_ERROR;
        }
        ++i;
        switch (opt) {
        case QMethodIdx:
            method = Tcl_GetString(objv[i]);
            break;
        case QTimeoutIdx:
            if (<a href="/cvs/aolserver/aolserver/nsd/tclobj.c#A_Ns_TclGetTimeFromObj">Ns_TclGetTimeFromObj</a>(interp, objv[i], &incr) != TCL_OK) {
                return TCL_ERROR;
            }
            break;
        case QBodyIdx:
            bodyPtr = objv[i];
            break;
        case QHeadersIdx:
            if (<a href="/cvs/aolserver/aolserver/nsd/tclset.c#A_Ns_TclGetSet2">Ns_TclGetSet2</a>(interp, Tcl_GetString(objv[i]),
                                &hdrs) != TCL_OK) {
                return TCL_ERROR;
            }
            break;
        }
    }
    if ((objc - i) != 1) {
        Tcl_WrongNumArgs(interp, 2, objv, "?flags? url");
        return TCL_ERROR;
    }
    url = Tcl_GetString(objv[i]);
    if (!<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpConnect">HttpConnect</a>(interp, method, url, hdrs, bodyPtr, &httpPtr)) {
        return TCL_ERROR;
    }
    Ns_GetTime(&httpPtr->stime);
    httpPtr->timeout = httpPtr->stime;
    Ns_IncrTime(&httpPtr->timeout, incr.sec, incr.usec);
    httpPtr->task = <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskCreate">Ns_TaskCreate</a>(httpPtr->sock, <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpProc">HttpProc</a>, httpPtr);
    if (run) {
        <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskRun">Ns_TaskRun</a>(httpPtr->task);
    } else {
        if (queue == NULL) {
            Ns_MasterLock();
            if (queue == NULL) {
                queue = <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_CreateTaskQueue">Ns_CreateTaskQueue</a>("tclhttp");
            }
            Ns_MasterUnlock();
        }
        if (<a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskEnqueue">Ns_TaskEnqueue</a>(httpPtr->task, queue) != NS_OK) {
            <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpClose">HttpClose</a>(httpPtr);
            Tcl_AppendResult(interp, "could not queue http task", NULL);
            return TCL_ERROR;
        }
    }
    i = itPtr->https.numEntries;
    do {
        sprintf(buf, "http%d", i++);
        hPtr = Tcl_CreateHashEntry(&itPtr->https, buf, &new);
    } while (!new);
    Tcl_SetHashValue(hPtr, httpPtr);
    Tcl_SetResult(interp, buf, TCL_VOLATILE);
    return TCL_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpWaitCmd">HttpWaitCmd</a> --
 *
 *      Implements "ns_http wait" subcommand.
 *
 * Results:
 *      Standard Tcl result.
 *
 * Side effects:
 *      May queue an HTTP request.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpWaitCmd">HttpWaitCmd</a>(NsInterp *itPtr, int objc, Tcl_Obj **objv)
{
    Tcl_Interp *interp = itPtr->interp;
    Tcl_Obj *valPtr;
    Tcl_Obj *elapsedPtr = NULL;
    Tcl_Obj *resultPtr = NULL;
    Tcl_Obj *statusPtr = NULL;
    Tcl_Obj *responsePtr;
    Ns_Set *hdrs = NULL;
    Ns_Time diff;
    char *arg, *content;
    Http *httpPtr;
    int result = TCL_ERROR;
    int i, status;
    static CONST char *opts[] = {
       "-elapsed", "-result", "-headers", "-status", NULL
    };
    enum {
        WElapsedIdx, WResultIdx, WHeadersIdx, WStatusIdx
    } opt;

    for (i = 2; i < objc; ++i) {
        arg = Tcl_GetString(objv[i]);
        if (arg[0] != '-') {
            break;
        }
        if (Tcl_GetIndexFromObj(interp, objv[i], opts, "option", 0,
                            (int *) &opt) != TCL_OK) {
            return TCL_ERROR;
        }
        if (++i == objc) {
            Tcl_AppendResult(interp, "no argument given to ", opts[opt], NULL);
            return TCL_ERROR;
        }
        switch (opt) {
        case WElapsedIdx:
            elapsedPtr = objv[i];
            break;
        case WResultIdx:
            resultPtr = objv[i];
            break;
        case WStatusIdx:
            statusPtr = objv[i];
            break;
        case WHeadersIdx:
            if (<a href="/cvs/aolserver/aolserver/nsd/tclset.c#A_Ns_TclGetSet2">Ns_TclGetSet2</a>(interp, Tcl_GetString(objv[i]),
                                &hdrs) != TCL_OK) {
                return TCL_ERROR;
            }
            break;
        }
    }
    if ((objc - i) != 1) {
        Tcl_WrongNumArgs(interp, 2, objv, "?flags? id");
        return TCL_ERROR;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_GetHttp">GetHttp</a>(itPtr, objv[i], &httpPtr)) {
        return TCL_ERROR;
    }
    if (<a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskWait">Ns_TaskWait</a>(httpPtr->task, NULL) != NS_OK) {
        <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpCancel">HttpCancel</a>(httpPtr);
        Tcl_AppendResult(interp, "timeout waiting for task", NULL);
        return TCL_ERROR;
    }
    result = TCL_ERROR;
    if (elapsedPtr != NULL) {
        Ns_DiffTime(&httpPtr->etime, &httpPtr->stime, &diff);
        valPtr = Tcl_NewObj();
        <a href="/cvs/aolserver/aolserver/nsd/tclobj.c#A_Ns_TclSetTimeObj">Ns_TclSetTimeObj</a>(valPtr, &diff);
        if (!<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_SetWaitVar">SetWaitVar</a>(interp, elapsedPtr, valPtr)) {
            goto err;
        }
    }
    if (httpPtr->error) {
        Tcl_AppendResult(interp, "http failed: ", httpPtr->error, NULL);
        goto err;
    }
    content = <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpResult">HttpResult</a>(httpPtr->ds, &status, hdrs, &responsePtr);
    if (statusPtr != NULL &&
                !<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_SetWaitVar">SetWaitVar</a>(interp, statusPtr, Tcl_NewIntObj(status))) {
        goto err;
    }
    if (resultPtr == NULL) {
            Tcl_SetObjResult(interp, responsePtr);
    } else {
            if (!<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_SetWaitVar">SetWaitVar</a>(interp, resultPtr, responsePtr)) {
                goto err;
            }
        Tcl_SetBooleanObj(Tcl_GetObjResult(interp), 1);
    }
    result = TCL_OK;

err:
    <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpClose">HttpClose</a>(httpPtr);
    return result;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_GetHttp">GetHttp</a> --
 *
 *      Locate and remove the Http struct for a given id.
 *
 * Results:
 *      1 on success, 0 otherwise.
 *
 * Side effects:
 *      Will update given httpPtrPtr with pointer to Http struct.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_GetHttp">GetHttp</a>(NsInterp *itPtr, Tcl_Obj *obj, Http **httpPtrPtr)
{
    Tcl_HashEntry *hPtr;
    char *id;

    id = Tcl_GetString(obj);
    hPtr = Tcl_FindHashEntry(&itPtr->https, id);
    if (hPtr == NULL) {
        Tcl_AppendResult(itPtr->interp, "no such request: ", id, NULL);
        return 0;
    }
    *httpPtrPtr = Tcl_GetHashValue(hPtr);
    Tcl_DeleteHashEntry(hPtr);
    return 1;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_SetWaitVar">SetWaitVar</a> --
 *
 *      Set a variable by name.  Convience routine for for <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpWaitCmd">HttpWaitCmd</a>.
 *
 * Results:
 *      1 on success, 0 otherwise.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_SetWaitVar">SetWaitVar</a>(Tcl_Interp *interp, Tcl_Obj *varPtr, Tcl_Obj *valPtr)
{
    Tcl_Obj *errPtr;

    Tcl_IncrRefCount(valPtr);
    errPtr = Tcl_ObjSetVar2(interp, varPtr, NULL, valPtr,
                               TCL_PARSE_PART1|TCL_LEAVE_ERR_MSG);
    Tcl_DecrRefCount(valPtr);
    return (errPtr ? 1 : 0);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpConnect">HttpConnect</a> --
 *
 *        Open a connection to the given URL host and construct
 *        an Http structure to fetch the file.
 *
 * Results:
 *        1 if successful, 0 otherwise.
 *
 * Side effects:
 *        Updates httpPtrPtr with newly allocated Http struct.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpConnect">HttpConnect</a>(Tcl_Interp *interp, char *method, char *url, Ns_Set *hdrs,
            Tcl_Obj *bodyPtr, Http **httpPtrPtr)
{
    Http *httpPtr = NULL;
    SOCKET sock;
    char *body, *host, *file, *port;
    int i, len;

    if (strncmp(url, "http://", 7) != 0 || url[7] == '\0') {
        Tcl_AppendResult(interp, "invalid url: ", url, NULL);
        return 0;
    }
    host = url + 7;
    file = strchr(host, '/');
    if (file != NULL) {
        *file = '\0';
    }
    port = strchr(host, ':');
    if (port == NULL) {
        i = 80;
    } else {
        *port = '\0';
        i = (int) strtol(port+1, NULL, 10);
    }
    sock = <a href="/cvs/aolserver/aolserver/nsd/sock.c#A_Ns_SockAsyncConnect">Ns_SockAsyncConnect</a>(host, i);
    if (port != NULL) {
        *port = ':';
    }
    if (sock != INVALID_SOCKET) {
        httpPtr = ns_malloc(sizeof(Http));
        httpPtr->sock = sock;
            httpPtr->error = NULL;
        Tcl_DStringInit(&httpPtr->ds);
        if (file != NULL) {
            *file = '/';
        }
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&httpPtr->ds, method);
        <a href="/cvs/aolserver/aolserver/nsd/str.c#A_Ns_StrToUpper">Ns_StrToUpper</a>(<a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringValue">Ns_DStringValue</a>(&httpPtr->ds));
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&httpPtr->ds, " ", file ? file : "/",
                            " HTTP/1.0\r\n", NULL);
        if (file != NULL) {
            *file = '\0';
        }
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&httpPtr->ds,
            "User-Agent: ", <a href="/cvs/aolserver/aolserver/nsd/info.c#A_Ns_InfoServerName">Ns_InfoServerName</a>(), "/",
                            <a href="/cvs/aolserver/aolserver/nsd/info.c#A_Ns_InfoServerVersion">Ns_InfoServerVersion</a>(), "\r\n"
            "Connection: close\r\n"
            "Host: ", host, "\r\n", NULL);
        if (file != NULL) {
            *file = '/';
        }
        if (hdrs != NULL) {
            for (i = 0; i < Ns_SetSize(hdrs); i++) {
                <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&httpPtr->ds,
                    Ns_SetKey(hdrs, i), ": ",
                            Ns_SetValue(hdrs, i), "\r\n", NULL);
            }
        }
            body = NULL;
            if (bodyPtr != NULL) {
                body = Tcl_GetByteArrayFromObj(bodyPtr, &len);
                if (len == 0) {
                        body = NULL;
                }
            }
        if (body != NULL) {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringPrintf">Ns_DStringPrintf</a>(&httpPtr->ds, "Content-Length: %d\r\n", len);
        }
        Tcl_DStringAppend(&httpPtr->ds, "\r\n", 2);
        if (body != NULL) {
            Tcl_DStringAppend(&httpPtr->ds, body, len);
        }
        httpPtr->next = httpPtr->ds.string;
        httpPtr->len = httpPtr->ds.length;
    }
    if (file != NULL) {
        *file = '/';
    }
    if (httpPtr == NULL) {
        Tcl_AppendResult(interp, "connect to \"", url, "\" failed: ",
                         ns_sockstrerror(ns_sockerrno), NULL);
        return 0;
    }
    *httpPtrPtr = httpPtr;
    return 1;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpResult">HttpResult</a> --
 *
 *        <a href="/cvs/aolserver/aolserver/nsd/adpparse.c#A_Parse">Parse</a> an Http response for the result body and headers.
 *
 * Results:
 *        Pointer to body within Http buffer.
 *
 * Side effects:
 *        Will append parsed response headers to given hdrs if
 *        not NULL and set HTTP status code in given statusPtr.
 *
 *----------------------------------------------------------------------
 */

static char *
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpResult">HttpResult</a>(Tcl_DString ds, int *statusPtr, Ns_Set *hdrs, Tcl_Obj **objPtrPtr)
{
    int firsthdr, major, minor, len;
    char *eoh, *body, *p, *response, save;

    response = ds.string;
    body = response;
    eoh = strstr(response, "\r\n\r\n");
    if (eoh != NULL) {
        body = eoh + 4;
            eoh += 2;
    } else {
        eoh = strstr(response, "\n\n");
        if (eoh != NULL) {
            body = eoh + 2;
                eoh += 1;
        }
    }
    
    *objPtrPtr = Tcl_NewByteArrayObj(body, ds.length-(body-response));

    if (eoh == NULL) {
            *statusPtr = 0;
    } else {
            *eoh = '\0';
            sscanf(response, "HTTP/%d.%d %d", &major, &minor, statusPtr);
        if (hdrs != NULL) {
                save = *body;
                *body = '\0';
            firsthdr = 1;
            p = response;
            while ((eoh = strchr(p, '\n')) != NULL) {
                *eoh++ = '\0';
                len = strlen(p);
                if (len > 0 && p[len-1] == '\r') {
                    p[len-1] = '\0';
                }
                if (firsthdr) {
                    if (hdrs->name != NULL) {
                        ns_free(hdrs->name);
                    }
                    hdrs->name = ns_strdup(p);
                    firsthdr = 0;
                } else if (<a href="/cvs/aolserver/aolserver/nsd/request.c#A_Ns_ParseHeader">Ns_ParseHeader</a>(hdrs, p, ToLower) != NS_OK) {
                    break;
                }
                p = eoh;
            }
            *body = save;
        }
    }
    return body;
}


static void
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpClose">HttpClose</a>(Http *httpPtr)
{
    <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskFree">Ns_TaskFree</a>(httpPtr->task);
    Tcl_DStringFree(&httpPtr->ds);
    ns_sockclose(httpPtr->sock);
    ns_free(httpPtr);
}


static void
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpCancel">HttpCancel</a>(Http *httpPtr)
{
    <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskCancel">Ns_TaskCancel</a>(httpPtr->task);
    <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskWait">Ns_TaskWait</a>(httpPtr->task, NULL);
}


static void
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpAbort">HttpAbort</a>(Http *httpPtr)
{
    <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpCancel">HttpCancel</a>(httpPtr);
    <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpClose">HttpClose</a>(httpPtr);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpProc">HttpProc</a> --
 *
 *        Task callback for ns_http connections.
 *
 * Results:
 *        None.
 *
 * Side effects:
 *        Will call <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskCallback">Ns_TaskCallback</a> and <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskDone">Ns_TaskDone</a> to manage state
 *        of task.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/tclhttp.c#A_HttpProc">HttpProc</a>(Ns_Task *task, SOCKET sock, void *arg, int why)
{
    Http *httpPtr = arg;
    char buf[1024];
    int n;

    switch (why) {
    case NS_SOCK_INIT:
        <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskCallback">Ns_TaskCallback</a>(task, NS_SOCK_WRITE, &httpPtr->timeout);
        return;
        break;

    case NS_SOCK_WRITE:
        n = send(sock, httpPtr->next, httpPtr->len, 0);
        if (n < 0) {
            httpPtr->error = "send failed";
        } else {
            httpPtr->next += n;
            httpPtr->len -= n;
            if (httpPtr->len == 0) {
                shutdown(sock, 1);
                Tcl_DStringTrunc(&httpPtr->ds, 0);
                <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskCallback">Ns_TaskCallback</a>(task, NS_SOCK_READ, &httpPtr->timeout);
            }
            return;
        }
        break;

    case NS_SOCK_READ:
        n = recv(sock, buf, sizeof(buf), 0);
        if (n > 0) {
            Tcl_DStringAppend(&httpPtr->ds, buf, n);
            return;
        }
        if (n < 0) {
            httpPtr->error = "recv failed";
        }
        break;

    case NS_SOCK_TIMEOUT:
        httpPtr->error = "timeout";
        break;

    case NS_SOCK_EXIT:
        httpPtr->error = "shutdown";
        break;

    case NS_SOCK_CANCEL:
        httpPtr->error = "cancelled";
        break;
    }

    /*
     * Get completion time and mark task as done.
     */
     
    Ns_GetTime(&httpPtr->etime);
    <a href="/cvs/aolserver/aolserver/nsd/task.c#A_Ns_TaskDone">Ns_TaskDone</a>(httpPtr->task);
}