squid-2.5.STABLE10-errmsg.patch

   1 Index: squid/src/cache_manager.c
   2 diff -c squid/src/cache_manager.c:1.26 squid/src/cache_manager.c:1.26.2.1
   3 *** squid/src/cache_manager.c:1.26      Fri Feb 23 13:59:50 2001
   4 --- squid/src/cache_manager.c   Thu Sep  1 16:14:45 2005
   5 ***************
   6 *** 201,206 ****
   7 --- 201,207 ----
   8       if ((mgr = cachemgrParseUrl(storeUrl(entry))) == NULL) {
   9         err = errorCon(ERR_INVALID_URL, HTTP_NOT_FOUND);
  10         err->url = xstrdup(storeUrl(entry));
  11 +       err->request = requestLink(request);
  12         errorAppendEntry(entry, err);
  13         entry->expires = squid_curtime;
  14         return;
  15 Index: squid/src/forward.c
  16 diff -c squid/src/forward.c:1.82.2.15 squid/src/forward.c:1.82.2.16
  17 *** squid/src/forward.c:1.82.2.15       Fri Mar 25 19:50:53 2005
  18 --- squid/src/forward.c Thu Sep  1 16:14:45 2005
  19 ***************
  20 *** 236,242 ****
  21             request->host);
  22         err = errorCon(ERR_DNS_FAIL, HTTP_SERVICE_UNAVAILABLE);
  23         err->dnsserver_msg = xstrdup(dns_error_message);
  24 -       err->request = requestLink(request);
  25         fwdFail(fwdState, err);
  26         comm_close(server_fd);
  27       } else if (status != COMM_OK) {
  28 --- 236,241 ----
  29 ***************
  30 *** 250,256 ****
  31             err->host = xstrdup(request->host);
  32             err->port = request->port;
  33         }
  34 -       err->request = requestLink(request);
  35         fwdFail(fwdState, err);
  36         if (fs->peer)
  37             peerConnectFailed(fs->peer);
  38 --- 249,254 ----
  39 ***************
  40 *** 282,288 ****
  41       assert(fd == fwdState->server_fd);
  42       if (entry->mem_obj->inmem_hi == 0) {
  43         err = errorCon(ERR_CONNECT_FAIL, HTTP_GATEWAY_TIMEOUT);
  44 -       err->request = requestLink(fwdState->request);
  45         err->xerrno = ETIMEDOUT;
  46         fwdFail(fwdState, err);
  47         /*
  48 --- 280,285 ----
  49 ***************
  50 *** 420,426 ****
  51         debug(50, 4) ("fwdConnectStart: %s\n", xstrerror());
  52         err = errorCon(ERR_SOCKET_FAILURE, HTTP_INTERNAL_SERVER_ERROR);
  53         err->xerrno = errno;
  54 -       err->request = requestLink(fwdState->request);
  55         fwdFail(fwdState, err);
  56         fwdStateFree(fwdState);
  57         return;
  58 --- 417,422 ----
  59 ***************
  60 *** 466,472 ****
  61       ErrorState *err;
  62       debug(17, 3) ("fwdStartFail: %s\n", storeUrl(fwdState->entry));
  63       err = errorCon(ERR_CANNOT_FORWARD, HTTP_SERVICE_UNAVAILABLE);
  64 -     err->request = requestLink(fwdState->request);
  65       err->xerrno = errno;
  66       fwdFail(fwdState, err);
  67       fwdStateFree(fwdState);
  68 --- 462,467 ----
  69 ***************
  70 *** 525,531 ****
  71             debug(17, 1) ("fwdDispatch: Cannot retrieve '%s'\n",
  72                 storeUrl(entry));
  73             err = errorCon(ERR_UNSUP_REQ, HTTP_BAD_REQUEST);
  74 -           err->request = requestLink(request);
  75             fwdFail(fwdState, err);
  76             /*
  77              * Force a persistent connection to be closed because
  78 --- 520,525 ----
  79 ***************
  80 *** 710,716 ****
  81   void
  82   fwdFail(FwdState * fwdState, ErrorState * errorState)
  83   {
  84 -     assert(EBIT_TEST(fwdState->entry->flags, ENTRY_FWD_HDR_WAIT));
  85       debug(17, 3) ("fwdFail: %s \"%s\"\n\t%s\n",
  86         err_type_str[errorState->type],
  87         httpStatusString(errorState->http_status),
  88 --- 704,709 ----
  89 ***************
  90 *** 718,723 ****
  91 --- 711,718 ----
  92       if (fwdState->err)
  93         errorStateFree(fwdState->err);
  94       fwdState->err = errorState;
  95 +     if (!errorState->request)
  96 +       errorState->request = requestLink(fwdState->request);
  97   }
  98
  99   /*
 100 Index: squid/src/ftp.c
 101 diff -c squid/src/ftp.c:1.316.2.28 squid/src/ftp.c:1.316.2.29
 102 *** squid/src/ftp.c:1.316.2.28  Wed Jun 22 04:42:34 2005
 103 --- squid/src/ftp.c     Thu Sep  1 16:14:45 2005
 104 ***************
 105 *** 2491,2497 ****
 106       if (err == NULL)
 107         err = errorCon(ERR_FTP_FAILURE, HTTP_BAD_GATEWAY);
 108       err->xerrno = errno;
 109 -     err->request = requestLink(ftpState->request);
 110       err->ftp.server_msg = ftpState->ctrl.message;
 111       ftpState->ctrl.message = NULL;
 112       if (ftpState->old_request)
 113 --- 2491,2496 ----
 114 Index: squid/src/gopher.c
 115 diff -c squid/src/gopher.c:1.162.2.8 squid/src/gopher.c:1.162.2.9
 116 *** squid/src/gopher.c:1.162.2.8        Tue Jan 11 23:04:01 2005
 117 --- squid/src/gopher.c  Thu Sep  1 16:14:45 2005
 118 ***************
 119 *** 603,614 ****
 120       GopherStateData *gopherState = data;
 121       StoreEntry *entry = gopherState->entry;
 122       debug(10, 4) ("gopherTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
 123 !     if (entry->store_status == STORE_PENDING) {
 124 !       if (entry->mem_obj->inmem_hi == 0) {
 125 !           fwdFail(gopherState->fwdState,
 126 !               errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 127 !       }
 128 !     }
 129       comm_close(fd);
 130   }
 131
 132 --- 603,610 ----
 133       GopherStateData *gopherState = data;
 134       StoreEntry *entry = gopherState->entry;
 135       debug(10, 4) ("gopherTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
 136 !     fwdFail(gopherState->fwdState,
 137 !       errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 138       comm_close(fd);
 139   }
 140
 141 ***************
 142 *** 660,681 ****
 143         debug(50, 1) ("gopherReadReply: error reading: %s\n", xstrerror());
 144         if (ignoreErrno(errno)) {
 145             commSetSelect(fd, COMM_SELECT_READ, gopherReadReply, data, 0);
 146 !       } else if (entry->mem_obj->inmem_hi == 0) {
 147             ErrorState *err;
 148             err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 149             err->xerrno = errno;
 150 !           err->url = xstrdup(storeUrl(entry));
 151 !           errorAppendEntry(entry, err);
 152 !           comm_close(fd);
 153 !       } else {
 154             comm_close(fd);
 155         }
 156       } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
 157 !       ErrorState *err;
 158 !       err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
 159 !       err->xerrno = errno;
 160 !       err->url = xstrdup(gopherState->request);
 161 !       errorAppendEntry(entry, err);
 162         comm_close(fd);
 163       } else if (len == 0) {
 164         /* Connection closed; retrieval done. */
 165 --- 656,670 ----
 166         debug(50, 1) ("gopherReadReply: error reading: %s\n", xstrerror());
 167         if (ignoreErrno(errno)) {
 168             commSetSelect(fd, COMM_SELECT_READ, gopherReadReply, data, 0);
 169 !       } else {
 170             ErrorState *err;
 171             err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 172             err->xerrno = errno;
 173 !           fwdFail(gopherState->fwdState, err);
 174             comm_close(fd);
 175         }
 176       } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
 177 !       fwdFail(gopherState->fwdState, errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE));
 178         comm_close(fd);
 179       } else if (len == 0) {
 180         /* Connection closed; retrieval done. */
 181 ***************
 182 *** 717,728 ****
 183       }
 184       if (errflag) {
 185         ErrorState *err;
 186 !       err = errorCon(ERR_CONNECT_FAIL, HTTP_SERVICE_UNAVAILABLE);
 187         err->xerrno = errno;
 188         err->host = xstrdup(gopherState->req->host);
 189         err->port = gopherState->req->port;
 190         err->url = xstrdup(storeUrl(entry));
 191 !       errorAppendEntry(entry, err);
 192         comm_close(fd);
 193         if (buf)
 194             memFree(buf, MEM_4K_BUF);   /* Allocated by gopherSendRequest. */
 195 --- 706,717 ----
 196       }
 197       if (errflag) {
 198         ErrorState *err;
 199 !       err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY);
 200         err->xerrno = errno;
 201         err->host = xstrdup(gopherState->req->host);
 202         err->port = gopherState->req->port;
 203         err->url = xstrdup(storeUrl(entry));
 204 !       fwdFail(gopherState->fwdState, err);
 205         comm_close(fd);
 206         if (buf)
 207             memFree(buf, MEM_4K_BUF);   /* Allocated by gopherSendRequest. */
 208 ***************
 209 *** 815,830 ****
 210       /* Parse url. */
 211       gopher_request_parse(fwdState->request,
 212         &gopherState->type_id, gopherState->request);
 213 - #if OLD_PARSE_ERROR_CODE
 214 -     if (...) {
 215 -       ErrorState *err;
 216 -       err = errorCon(ERR_INVALID_URL, HTTP_BAD_REQUEST);
 217 -       err->url = xstrdup(storeUrl(entry));
 218 -       errorAppendEntry(entry, err);
 219 -       gopherStateFree(-1, gopherState);
 220 -       return;
 221 -     }
 222 - #endif
 223       comm_add_close_handler(fd, gopherStateFree, gopherState);
 224       if (((gopherState->type_id == GOPHER_INDEX) || (gopherState->type_id == GOPHER_CSO))
 225         && (strchr(gopherState->request, '?') == NULL)) {
 226 --- 804,809 ----
 227 Index: squid/src/http.c
 228 diff -c squid/src/http.c:1.384.2.30 squid/src/http.c:1.384.2.31
 229 *** squid/src/http.c:1.384.2.30 Fri Mar 25 19:50:53 2005
 230 --- squid/src/http.c    Thu Sep  1 16:14:45 2005
 231 ***************
 232 *** 99,108 ****
 233       StoreEntry *entry = httpState->entry;
 234       debug(11, 4) ("httpTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
 235       if (entry->store_status == STORE_PENDING) {
 236 !       if (entry->mem_obj->inmem_hi == 0) {
 237 !           fwdFail(httpState->fwd,
 238 !               errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 239 !       }
 240       }
 241       comm_close(fd);
 242   }
 243 --- 99,106 ----
 244       StoreEntry *entry = httpState->entry;
 245       debug(11, 4) ("httpTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
 246       if (entry->store_status == STORE_PENDING) {
 247 !       fwdFail(httpState->fwd,
 248 !           errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 249       }
 250       comm_close(fd);
 251   }
 252 ***************
 253 *** 616,637 ****
 254             fd, xstrerror());
 255         if (ignoreErrno(errno)) {
 256             commSetSelect(fd, COMM_SELECT_READ, httpReadReply, httpState, 0);
 257 !       } else if (entry->mem_obj->inmem_hi == 0) {
 258             ErrorState *err;
 259             err = errorCon(ERR_READ_ERROR, HTTP_BAD_GATEWAY);
 260 -           err->request = requestLink((request_t *) request);
 261             err->xerrno = errno;
 262             fwdFail(httpState->fwd, err);
 263             comm_close(fd);
 264 -       } else {
 265 -           comm_close(fd);
 266         }
 267       } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
 268 !       ErrorState *err;
 269 !       err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_BAD_GATEWAY);
 270 !       err->xerrno = errno;
 271 !       err->request = requestLink((request_t *) request);
 272 !       fwdFail(httpState->fwd, err);
 273         httpState->eof = 1;
 274         comm_close(fd);
 275       } else if (len == 0) {
 276 --- 614,628 ----
 277             fd, xstrerror());
 278         if (ignoreErrno(errno)) {
 279             commSetSelect(fd, COMM_SELECT_READ, httpReadReply, httpState, 0);
 280 !       } else {
 281             ErrorState *err;
 282             err = errorCon(ERR_READ_ERROR, HTTP_BAD_GATEWAY);
 283             err->xerrno = errno;
 284             fwdFail(httpState->fwd, err);
 285             comm_close(fd);
 286         }
 287       } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
 288 !       fwdFail(httpState->fwd, errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_BAD_GATEWAY));
 289         httpState->eof = 1;
 290         comm_close(fd);
 291       } else if (len == 0) {
 292 ***************
 293 *** 646,663 ****
 294              */
 295             httpProcessReplyHeader(httpState, buf, len);
 296         if (entry->mem_obj->reply->sline.status == HTTP_HEADER_TOO_LARGE) {
 297 -           ErrorState *err;
 298             storeEntryReset(entry);
 299 !           err = errorCon(ERR_TOO_BIG, HTTP_BAD_GATEWAY);
 300 !           err->request = requestLink((request_t *) request);
 301 !           fwdFail(httpState->fwd, err);
 302             httpState->fwd->flags.dont_retry = 1;
 303         } else if (entry->mem_obj->reply->sline.status == HTTP_INVALID_HEADER && !(entry->mem_obj->reply->sline.version.major == 0 && entry->mem_obj->reply->sline.version.minor == 9)) {
 304 -           ErrorState *err;
 305             storeEntryReset(entry);
 306 !           err = errorCon(ERR_INVALID_RESP, HTTP_BAD_GATEWAY);
 307 !           err->request = requestLink((request_t *) request);
 308 !           fwdFail(httpState->fwd, err);
 309             httpState->fwd->flags.dont_retry = 1;
 310         } else {
 311             fwdComplete(httpState->fwd);
 312 --- 637,648 ----
 313              */
 314             httpProcessReplyHeader(httpState, buf, len);
 315         if (entry->mem_obj->reply->sline.status == HTTP_HEADER_TOO_LARGE) {
 316             storeEntryReset(entry);
 317 !           fwdFail(httpState->fwd, errorCon(ERR_TOO_BIG, HTTP_BAD_GATEWAY));
 318             httpState->fwd->flags.dont_retry = 1;
 319         } else if (entry->mem_obj->reply->sline.status == HTTP_INVALID_HEADER && !(entry->mem_obj->reply->sline.version.major == 0 && entry->mem_obj->reply->sline.version.minor == 9)) {
 320             storeEntryReset(entry);
 321 !           fwdFail(httpState->fwd, errorCon(ERR_INVALID_RESP, HTTP_BAD_GATEWAY));
 322             httpState->fwd->flags.dont_retry = 1;
 323         } else {
 324             fwdComplete(httpState->fwd);
 325 ***************
 326 *** 670,691 ****
 327             if (httpState->reply_hdr_state == 2) {
 328                 http_status s = entry->mem_obj->reply->sline.status;
 329                 if (s == HTTP_HEADER_TOO_LARGE) {
 330 -                   ErrorState *err;
 331                     debug(11, 1) ("WARNING: %s:%d: HTTP header too large\n", __FILE__, __LINE__);
 332                     storeEntryReset(entry);
 333 !                   err = errorCon(ERR_TOO_BIG, HTTP_BAD_GATEWAY);
 334 !                   err->request = requestLink((request_t *) request);
 335 !                   fwdFail(httpState->fwd, err);
 336                     httpState->fwd->flags.dont_retry = 1;
 337                     comm_close(fd);
 338                     return;
 339                 }
 340                 if (s == HTTP_INVALID_HEADER && !(entry->mem_obj->reply->sline.version.major == 0 && entry->mem_obj->reply->sline.version.minor == 9)) {
 341 -                   ErrorState *err;
 342                     storeEntryReset(entry);
 343 !                   err = errorCon(ERR_INVALID_RESP, HTTP_BAD_GATEWAY);
 344 !                   err->request = requestLink((request_t *) request);
 345 !                   fwdFail(httpState->fwd, err);
 346                     httpState->fwd->flags.dont_retry = 1;
 347                     comm_close(fd);
 348                     return;
 349 --- 655,670 ----
 350             if (httpState->reply_hdr_state == 2) {
 351                 http_status s = entry->mem_obj->reply->sline.status;
 352                 if (s == HTTP_HEADER_TOO_LARGE) {
 353                     debug(11, 1) ("WARNING: %s:%d: HTTP header too large\n", __FILE__, __LINE__);
 354                     storeEntryReset(entry);
 355 !                   fwdFail(httpState->fwd, errorCon(ERR_TOO_BIG, HTTP_BAD_GATEWAY));
 356                     httpState->fwd->flags.dont_retry = 1;
 357                     comm_close(fd);
 358                     return;
 359                 }
 360                 if (s == HTTP_INVALID_HEADER && !(entry->mem_obj->reply->sline.version.major == 0 && entry->mem_obj->reply->sline.version.minor == 9)) {
 361                     storeEntryReset(entry);
 362 !                   fwdFail(httpState->fwd, errorCon(ERR_INVALID_RESP, HTTP_BAD_GATEWAY));
 363                     httpState->fwd->flags.dont_retry = 1;
 364                     comm_close(fd);
 365                     return;
 366 ***************
 367 *** 804,810 ****
 368   {
 369       HttpStateData *httpState = data;
 370       StoreEntry *entry = httpState->entry;
 371 -     ErrorState *err;
 372       debug(11, 5) ("httpSendComplete: FD %d: size %d: errflag %d.\n",
 373         fd, (int) size, errflag);
 374   #if URL_CHECKSUM_DEBUG
 375 --- 783,788 ----
 376 ***************
 377 *** 818,829 ****
 378       if (errflag == COMM_ERR_CLOSING)
 379         return;
 380       if (errflag) {
 381 !       if (entry->mem_obj->inmem_hi == 0) {
 382 !           err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY);
 383 !           err->xerrno = errno;
 384 !           err->request = requestLink(httpState->orig_request);
 385 !           errorAppendEntry(entry, err);
 386 !       }
 387         comm_close(fd);
 388         return;
 389       } else {
 390 --- 796,805 ----
 391       if (errflag == COMM_ERR_CLOSING)
 392         return;
 393       if (errflag) {
 394 !       ErrorState *err;
 395 !       err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY);
 396 !       err->xerrno = errno;
 397 !       fwdFail(httpState->fwd, err);
 398         comm_close(fd);
 399         return;
 400       } else {
 401 ***************
 402 *** 1264,1270 ****
 403   {
 404       HttpStateData *httpState = data;
 405       StoreEntry *entry = httpState->entry;
 406 -     ErrorState *err;
 407       debug(11, 5) ("httpSendRequestEntry: FD %d: size %d: errflag %d.\n",
 408         fd, (int) size, errflag);
 409       if (size > 0) {
 410 --- 1240,1245 ----
 411 ***************
 412 *** 1275,1286 ****
 413       if (errflag == COMM_ERR_CLOSING)
 414         return;
 415       if (errflag) {
 416 !       if (entry->mem_obj->inmem_hi == 0) {
 417 !           err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY);
 418 !           err->xerrno = errno;
 419 !           err->request = requestLink(httpState->orig_request);
 420 !           errorAppendEntry(entry, err);
 421 !       }
 422         comm_close(fd);
 423         return;
 424       }
 425 --- 1250,1259 ----
 426       if (errflag == COMM_ERR_CLOSING)
 427         return;
 428       if (errflag) {
 429 !       ErrorState *err;
 430 !       err = errorCon(ERR_WRITE_ERROR, HTTP_BAD_GATEWAY);
 431 !       err->xerrno = errno;
 432 !       fwdFail(httpState->fwd, err);
 433         comm_close(fd);
 434         return;
 435       }
 436 Index: squid/src/urn.c
 437 diff -c squid/src/urn.c:1.68.2.3 squid/src/urn.c:1.68.2.4
 438 *** squid/src/urn.c:1.68.2.3    Sun Sep  1 06:38:04 2002
 439 --- squid/src/urn.c     Thu Sep  1 16:14:45 2005
 440 ***************
 441 *** 132,137 ****
 442 --- 132,138 ----
 443         debug(52, 3) ("urnStart: Bad uri-res URL %s\n", urlres);
 444         err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
 445         err->url = xstrdup(urlres);
 446 +       err->request = requestLink(r);
 447         errorAppendEntry(e, err);
 448         return;
 449       }
 450 Index: squid/src/wais.c
 451 diff -c squid/src/wais.c:1.138 squid/src/wais.c:1.138.2.1
 452 *** squid/src/wais.c:1.138      Wed Oct 24 02:19:09 2001
 453 --- squid/src/wais.c    Thu Sep  1 16:14:45 2005
 454 ***************
 455 *** 70,79 ****
 456       StoreEntry *entry = waisState->entry;
 457       debug(24, 4) ("waisTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
 458       if (entry->store_status == STORE_PENDING) {
 459 !       if (entry->mem_obj->inmem_hi == 0) {
 460 !           fwdFail(waisState->fwd,
 461 !               errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 462 !       }
 463       }
 464       comm_close(fd);
 465   }
 466 --- 70,77 ----
 467       StoreEntry *entry = waisState->entry;
 468       debug(24, 4) ("waisTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
 469       if (entry->store_status == STORE_PENDING) {
 470 !       fwdFail(waisState->fwd,
 471 !           errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 472       }
 473       comm_close(fd);
 474   }
 475 ***************
 476 *** 130,149 ****
 477                 waisReadReply, waisState, 0);
 478         } else {
 479             ErrorState *err;
 480 -           EBIT_CLR(entry->flags, ENTRY_CACHABLE);
 481 -           storeReleaseRequest(entry);
 482             err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 483             err->xerrno = errno;
 484 !           err->request = requestLink(waisState->request);
 485 !           errorAppendEntry(entry, err);
 486             comm_close(fd);
 487         }
 488       } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
 489 !       ErrorState *err;
 490 !       err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
 491 !       err->xerrno = errno;
 492 !       err->request = requestLink(waisState->request);
 493 !       errorAppendEntry(entry, err);
 494         comm_close(fd);
 495       } else if (len == 0) {
 496         /* Connection closed; retrieval done. */
 497 --- 128,140 ----
 498                 waisReadReply, waisState, 0);
 499         } else {
 500             ErrorState *err;
 501             err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 502             err->xerrno = errno;
 503 !           fwdFail(waisState->fwd, err);
 504             comm_close(fd);
 505         }
 506       } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
 507 !       fwdFail(waisState->fwd, errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE));
 508         comm_close(fd);
 509       } else if (len == 0) {
 510         /* Connection closed; retrieval done. */
 511 ***************
 512 *** 179,186 ****
 513         ErrorState *err;
 514         err = errorCon(ERR_WRITE_ERROR, HTTP_SERVICE_UNAVAILABLE);
 515         err->xerrno = errno;
 516 !       err->request = requestLink(waisState->request);
 517 !       errorAppendEntry(entry, err);
 518         comm_close(fd);
 519       } else {
 520         /* Schedule read reply. */
 521 --- 170,176 ----
 522         ErrorState *err;
 523         err = errorCon(ERR_WRITE_ERROR, HTTP_SERVICE_UNAVAILABLE);
 524         err->xerrno = errno;
 525 !       fwdFail(waisState->fwd, err);
 526         comm_close(fd);
 527       } else {
 528         /* Schedule read reply. */
 529 Index: squid/src/whois.c
 530 diff -c squid/src/whois.c:1.16 squid/src/whois.c:1.16.2.1
 531 *** squid/src/whois.c:1.16      Fri Apr 13 18:03:24 2001
 532 --- squid/src/whois.c   Thu Sep  1 16:14:45 2005
 533 ***************
 534 *** 109,122 ****
 535             fd, xstrerror());
 536         if (ignoreErrno(errno)) {
 537             commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
 538 !       } else if (mem->inmem_hi == 0) {
 539             ErrorState *err;
 540             err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 541             err->xerrno = errno;
 542             fwdFail(p->fwd, err);
 543             comm_close(fd);
 544 -       } else {
 545 -           comm_close(fd);
 546         }
 547       } else {
 548         fwdComplete(p->fwd);
 549 --- 109,120 ----
 550             fd, xstrerror());
 551         if (ignoreErrno(errno)) {
 552             commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
 553 !       } else {
 554             ErrorState *err;
 555             err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 556             err->xerrno = errno;
 557             fwdFail(p->fwd, err);
 558             comm_close(fd);
 559         }
 560       } else {
 561         fwdComplete(p->fwd);