=== modified file 'src/errorpage.cc'
--- src/errorpage.cc	2013-01-28 16:56:05 +0000
+++ src/errorpage.cc	2013-01-30 16:29:12 +0000
@@ -557,143 +557,139 @@
 }
 
 /// \ingroup ErrorPageInternal
 const char *
 errorPageName(int pageId)
 {
     if (pageId >= ERR_NONE && pageId < ERR_MAX)		/* common case */
         return err_type_str[pageId];
 
     if (pageId >= ERR_MAX && pageId - ERR_MAX < (ssize_t)ErrorDynamicPages.size())
         return ErrorDynamicPages.items[pageId - ERR_MAX]->page_name;
 
     return "ERR_UNKNOWN";	/* should not happen */
 }
 
 ErrorState::ErrorState(err_type t, http_status status, HttpRequest * req) :
         type(t),
         page_id(t),
         err_language(NULL),
         httpStatus(status),
 #if USE_AUTH
         auth_user_request (NULL),
 #endif
         request(NULL),
         url(NULL),
         xerrno(0),
         port(0),
         dnsError(),
         ttl(0),
         src_addr(),
         redirect_url(NULL),
         callback(NULL),
         callback_data(NULL),
         request_hdrs(NULL),
         err_msg(NULL),
 #if USE_SSL
         detail(NULL),
 #endif
         detailCode(ERR_DETAIL_NONE)
 {
-    memset(&flags, 0, sizeof(flags));
     memset(&ftp, 0, sizeof(ftp));
 
     if (page_id >= ERR_MAX && ErrorDynamicPages.items[page_id - ERR_MAX]->page_redirect != HTTP_STATUS_NONE)
         httpStatus = ErrorDynamicPages.items[page_id - ERR_MAX]->page_redirect;
 
     if (req != NULL) {
         request = HTTPMSGLOCK(req);
         src_addr = req->client_addr;
     }
 }
 
 void
 errorAppendEntry(StoreEntry * entry, ErrorState * err)
 {
     assert(entry->mem_obj != NULL);
     assert (entry->isEmpty());
     debugs(4, 4, "Creating an error page for entry " << entry <<
            " with errorstate " << err <<
            " page id " << err->page_id);
 
     if (entry->store_status != STORE_PENDING) {
         debugs(4, 2, "Skipping error page due to store_status: " << entry->store_status);
         /*
          * If the entry is not STORE_PENDING, then no clients
          * care about it, and we don't need to generate an
          * error message
          */
         assert(EBIT_TEST(entry->flags, ENTRY_ABORTED));
         assert(entry->mem_obj->nclients == 0);
         delete err;
         return;
     }
 
     if (err->page_id == TCP_RESET) {
         if (err->request) {
             debugs(4, 2, "RSTing this reply");
             err->request->flags.resetTcp = true;
         }
     }
 
     entry->lock();
     entry->buffer();
     entry->replaceHttpReply( err->BuildHttpReply() );
     EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
     entry->flush();
     entry->complete();
     entry->negativeCache();
     entry->releaseRequest();
     entry->unlock();
     delete err;
 }
 
 void
 errorSend(const Comm::ConnectionPointer &conn, ErrorState * err)
 {
     HttpReply *rep;
     debugs(4, 3, HERE << conn << ", err=" << err);
     assert(Comm::IsConnOpen(conn));
 
-    /* moved in front of errorBuildBuf @?@ */
-    err->flags.flag_cbdata = 1;
-
     rep = err->BuildHttpReply();
 
     MemBuf *mb = rep->pack();
     AsyncCall::Pointer call = commCbCall(78, 5, "errorSendComplete",
                                          CommIoCbPtrFun(&errorSendComplete, err));
     Comm::Write(conn, mb, call);
     delete mb;
 
     delete rep;
 }
 
 /**
  \ingroup ErrorPageAPI
  *
  * Called by commHandleWrite() after data has been written
  * to the client socket.
  *
  \note If there is a callback, the callback is responsible for
  *     closing the FD, otherwise we do it ourselves.
  */
 static void
 errorSendComplete(const Comm::ConnectionPointer &conn, char *bufnotused, size_t size, comm_err_t errflag, int xerrno, void *data)
 {
     ErrorState *err = static_cast<ErrorState *>(data);
     debugs(4, 3, HERE << conn << ", size=" << size);
 
     if (errflag != COMM_ERR_CLOSING) {
         if (err->callback) {
             debugs(4, 3, "errorSendComplete: callback");
             err->callback(conn->fd, err->callback_data, size);
         } else {
             debugs(4, 3, "errorSendComplete: comm_close");
             conn->close();
         }
     }
 
     delete err;
 }
 
 ErrorState::~ErrorState()

=== modified file 'src/errorpage.h'
--- src/errorpage.h	2012-10-03 17:32:57 +0000
+++ src/errorpage.h	2013-01-30 16:29:12 +0000
@@ -133,84 +133,80 @@
     /**
      * Map the Error page and deny_info template % codes into textual output.
      *
      * Several of the codes produce blocks of non-URL compatible results.
      * When processing the deny_info location URL they will be skipped.
      *
      * \param token                    The token following % which need to be converted
      * \param building_deny_info_url   Perform special deny_info actions, such as URL-encoding and token skipping.
      * \ allowRecursion   True if the codes which do recursions should converted
      */
     const char *Convert(char token, bool building_deny_info_url, bool allowRecursion);
 
     /**
      * CacheManager / Debug dump of the ErrorState object.
      * Writes output into the given MemBuf.
      \retval 0 successful completion.
      */
     int Dump(MemBuf * mb);
 
 public:
     err_type type;
     int page_id;
     char *err_language;
     http_status httpStatus;
 #if USE_AUTH
     Auth::UserRequest::Pointer auth_user_request;
 #endif
     HttpRequest *request;
     char *url;
     int xerrno;
     unsigned short port;
     String dnsError; ///< DNS lookup error message
     time_t ttl;
 
     Ip::Address src_addr;
     char *redirect_url;
     ERCB *callback;
     void *callback_data;
 
     struct {
-        unsigned int flag_cbdata:1;
-    } flags;
-
-    struct {
         wordlist *server_msg;
         char *request;
         char *reply;
         char *cwd_msg;
         MemBuf *listing;
     } ftp;
 
     char *request_hdrs;
     char *err_msg; /* Preformatted error message from the cache */
 
 #if USE_SSL
     Ssl::ErrorDetail *detail;
 #endif
     /// type-specific detail about the transaction error;
     /// overwrites xerrno; overwritten by detail, if any.
     int detailCode;
 private:
     CBDATA_CLASS2(ErrorState);
 };
 
 /**
  \ingroup ErrorPageAPI
  *
  * This function finds the error messages formats, and stores
  * them in error_text[]
  *
  \par Global effects:
  *            error_text[] - is modified
  */
 void errorInitialize(void);
 
 /// \ingroup ErrorPageAPI
 void errorClean(void);
 
 /**
  * \ingroup ErrorPageAPI
  *
  * This function generates a error page from the info contained
  * by err and then sends it to the client.
  * The callback function errorSendComplete() is called after