neon-jbj.patch

   1 diff -urN neon-0.24.7.org/src/ne_request.c neon-0.24.7/src/ne_request.c
   2 --- neon-0.24.7.org/src/ne_request.c    2004-07-05 11:49:05.000000000 +0200
   3 +++ neon-0.24.7/src/ne_request.c        2004-11-21 01:33:48.000000000 +0100
   4 @@ -110,6 +110,8 @@
   5
   6      size_t body_size, body_progress;
   7
   8 +    int chunked;       /* send request incrementally chunked */
   9 +
  10      /* temporary store for response lines. */
  11      char respbuf[BUFSIZ];
  12
  13 @@ -445,6 +447,29 @@
  14      return ret;
  15  }
  16
  17 +int ne_send_request_chunk(ne_request *req, const char *buffer, size_t size)
  18 +{
  19 +    char chunksize[20];
  20 +    int ret;
  21 +
  22 +    ne_snprintf(chunksize, sizeof chunksize, "%x%s", size, EOL);
  23 +    chunksize[sizeof(chunksize)-1] = '\0';
  24 +
  25 +    ret = ne_sock_fullwrite(req->session->socket, chunksize, strlen(chunksize));
  26 +
  27 +    if (!ret && size > 0)
  28 +       ret = ne_sock_fullwrite(req->session->socket, buffer, size);
  29 +
  30 +    if (!ret)
  31 +       ret = ne_sock_fullwrite(req->session->socket, EOL, sizeof(EOL)-1);
  32 +
  33 +    /* XXX Final EOL on last 0 byte chunk? perhaps call ne_finish_request? */
  34 +    if (!ret && size == 0)
  35 +       ret = ne_sock_fullwrite(req->session->socket, EOL, sizeof(EOL)-1);
  36 +
  37 +    return ret;
  38 +}
  39 +
  40  /* Lob the User-Agent, connection and host headers in to the request
  41   * headers */
  42  static void add_fixed_headers(ne_request *req)
  43 @@ -832,6 +857,11 @@
  44      return readlen;
  45  }
  46
  47 +void ne_set_request_chunked(ne_request *req, int chunked)
  48 +{
  49 +       req->chunked = chunked;
  50 +}
  51 +
  52  /* Build the request string, returning the buffer. */
  53  static ne_buffer *build_request(ne_request *req)
  54  {
  55 @@ -978,6 +1008,10 @@
  56         int aret = aborted(req, _("Could not send request"), ret);
  57         return RETRY_RET(retry, ret, aret);
  58      }
  59 +
  60 +    /* Return with request in progress if sending incrementally chunked body. */
  61 +    if (req->chunked)
  62 +       return ret;
  63
  64      if (!req->use_expect100 && req->body_size > 0) {
  65         /* Send request body, if not using 100-continue. */
  66 @@ -1154,36 +1188,10 @@
  67      }
  68  }
  69
  70 -int ne_begin_request(ne_request *req)
  71 +int ne_finish_request(ne_request *req)
  72  {
  73      struct body_reader *rdr;
  74 -    struct host_info *host;
  75 -    ne_buffer *data;
  76      const ne_status *const st = &req->status;
  77 -    int ret;
  78 -
  79 -    /* Resolve hostname if necessary. */
  80 -    host = req->session->use_proxy?&req->session->proxy:&req->session->server;
  81 -    if (host->address == NULL)
  82 -       HTTP_ERR(lookup_host(req->session, host));
  83 -
  84 -    req->resp.mode = R_TILLEOF;
  85 -
  86 -    /* FIXME: Determine whether to use the Expect: 100-continue header. */
  87 -    req->use_expect100 = (req->session->expect100_works > -1) &&
  88 -       (req->body_size > HTTP_EXPECT_MINSIZE) && req->session->is_http11;
  89 -
  90 -    /* Build the request string, and send it */
  91 -    data = build_request(req);
  92 -    DEBUG_DUMP_REQUEST(data->data);
  93 -    ret = send_request(req, data);
  94 -    /* Retry this once after a persistent connection timeout. */
  95 -    if (ret == NE_RETRY && !req->session->no_persist) {
  96 -       NE_DEBUG(NE_DBG_HTTP, "Persistent connection timed out, retrying.\n");
  97 -       ret = send_request(req, data);
  98 -    }
  99 -    ne_buffer_destroy(data);
 100 -    if (ret != NE_OK) return ret;
 101
 102      /* Determine whether server claims HTTP/1.1 compliance. */
 103      req->session->is_http11 = (st->major_version == 1 &&
 104 @@ -1206,9 +1214,9 @@
 105      }
 106  #endif
 107
 108 -    /* HEAD requests and 204, 205, 304 responses have no response body,
 109 +    /* HEAD requests and 201, 204, 205, 304 responses have no response body,
 110       * regardless of what headers are present. */
 111 -    if (req->method_is_head || st->code==204 || st->code==205 || st->code==304)
 112 +    if (req->method_is_head || st->code==201 || st->code==204 || st->code==205 || st->code==304)
 113         req->resp.mode = R_NO_BODY;
 114
 115      /* Prepare for reading the response entity-body.  Call each of the
 116 @@ -1224,6 +1232,42 @@
 117      return NE_OK;
 118  }
 119
 120 +int ne_begin_request(ne_request *req)
 121 +{
 122 +    struct body_reader *rdr;
 123 +    struct host_info *host;
 124 +    ne_buffer *data;
 125 +    const ne_status *const st = &req->status;
 126 +    int ret;
 127 +
 128 +    /* Resolve hostname if necessary. */
 129 +    host = req->session->use_proxy?&req->session->proxy:&req->session->server;
 130 +    if (host->address == NULL)
 131 +       HTTP_ERR(lookup_host(req->session, host));
 132 +
 133 +    req->resp.mode = R_TILLEOF;
 134 +
 135 +    /* Build the request string, and send it */
 136 +    data = build_request(req);
 137 +    DEBUG_DUMP_REQUEST(data->data);
 138 +    ret = send_request(req, data);
 139 +    /* Retry this once after a persistent connection timeout. */
 140 +    if (ret == NE_RETRY && !req->session->no_persist && !req->chunked) {
 141 +       NE_DEBUG(NE_DBG_HTTP, "Persistent connection timed out, retrying.\n");
 142 +       ret = send_request(req, data);
 143 +    }
 144 +    ne_buffer_destroy(data);
 145 +    if (ret != NE_OK) return ret;
 146 +
 147 +    /* Return with request in progress if sending incrementally chunked body. */
 148 +    if (req->chunked)
 149 +       return ret;     /* XXX perhaps NE_INPROGRESS? */
 150 +
 151 +    ret = ne_finish_request(req);
 152 +
 153 +    return ret;
 154 +}
 155 +
 156  int ne_end_request(ne_request *req)
 157  {
 158      struct hook *hk;
 159 diff -urN neon-0.24.7.org/src/ne_request.h neon-0.24.7/src/ne_request.h
 160 --- neon-0.24.7.org/src/ne_request.h    2003-10-22 22:47:05.000000000 +0200
 161 +++ neon-0.24.7/src/ne_request.h        2004-11-21 01:35:15.000000000 +0100
 162 @@ -258,6 +258,20 @@
 163  void ne_set_request_private(ne_request *req, const char *id, void *priv);
 164  void *ne_get_request_private(ne_request *req, const char *id);
 165
 166 +/* Mark the request body as incrementally chunked. */
 167 +void ne_set_request_chunked(ne_request *req, int chunked)
 168 +      /*@modifies req @*/;
 169 +
 170 +/* Send request body chunk.
 171 + * Return 0 on success, else NE_* return. */
 172 +int ne_send_request_chunk(ne_request *req, const char *buffer, size_t size)
 173 +      /*@modifies req @*/;
 174 +
 175 +/* Finish incrementally chunked request. */
 176 +int ne_finish_request(ne_request *req)
 177 +      /*@globals internalState @*/
 178 +      /*@modifies req, internalState @*/;
 179 +
 180  END_NEON_DECLS
 181
 182  #endif /* NE_REQUEST_H */