Turned flags to bool types for PeerDigest, RefreshPattern,

ClientHttpRequest, fde, fqdncache_entry, ipcache_entry, HelperServerBase

diff --git a/src/PeerDigest.h b/src/PeerDigest.h
index e7be003dc317eabf3f715b70ba246ebbceb85c95..189a861583e633018718cfd147dd78a69fe44def 100644 (file)
--- a/src/PeerDigest.h
+++ b/src/PeerDigest.h
@@ -104,9 +104,9 @@ public:
     const char *req_result;     /**< text status of the last request */
 
     struct {
-        unsigned int needed:1;          /**< there were requests for this digest */
-        unsigned int usable:1;          /**< can be used for lookups */
-        unsigned int requested:1;       /**< in process of receiving [fresh] digest */
+        bool needed;          /**< there were requests for this digest */
+        bool usable;          /**< can be used for lookups */
+        bool requested;       /**< in process of receiving [fresh] digest */
     } flags;
 
     struct {

diff --git a/src/RefreshPattern.h b/src/RefreshPattern.h
index b0c7b04bc90699d95822e78c097aa3cd2d4dbd58..d14e1f1e8656c5b1337cfe65a39c5aab9aa02c27 100644 (file)
--- a/src/RefreshPattern.h
+++ b/src/RefreshPattern.h
@@ -41,18 +41,18 @@ public:
     RefreshPattern *next;
 
     struct {
-        unsigned int icase:1;
-        unsigned int refresh_ims:1;
-        unsigned int store_stale:1;
+        bool icase;
+        bool refresh_ims;
+        bool store_stale;
 #if USE_HTTP_VIOLATIONS
-        unsigned int override_expire:1;
-        unsigned int override_lastmod:1;
-        unsigned int reload_into_ims:1;
-        unsigned int ignore_reload:1;
-        unsigned int ignore_no_store:1;
-        unsigned int ignore_must_revalidate:1;
-        unsigned int ignore_private:1;
-        unsigned int ignore_auth:1;
+        bool override_expire;
+        bool override_lastmod;
+        bool reload_into_ims;
+        bool ignore_reload;
+        bool ignore_no_store;
+        bool ignore_must_revalidate;
+        bool ignore_private;
+        bool ignore_auth;
 #endif
     } flags;
     int max_stale;

diff --git a/src/cache_cf.cc b/src/cache_cf.cc
index cc45babfbd07a7475d95e7791a195f65d01c5cd1..e9df3560bc3ac41e19853bee38f32f093950bc69 100644 (file)
--- a/src/cache_cf.cc
+++ b/src/cache_cf.cc
@@ -2867,41 +2867,41 @@ parse_refreshpattern(RefreshPattern ** head)
     t->max = max;
 
     if (flags & REG_ICASE)
-        t->flags.icase = 1;
+        t->flags.icase = true;
 
     if (refresh_ims)
-        t->flags.refresh_ims = 1;
+        t->flags.refresh_ims = true;
 
     if (store_stale)
-        t->flags.store_stale = 1;
+        t->flags.store_stale = true;
 
     t->max_stale = max_stale;
 
 #if USE_HTTP_VIOLATIONS
 
     if (override_expire)
-        t->flags.override_expire = 1;
+        t->flags.override_expire = true;
 
     if (override_lastmod)
-        t->flags.override_lastmod = 1;
+        t->flags.override_lastmod = true;
 
     if (reload_into_ims)
-        t->flags.reload_into_ims = 1;
+        t->flags.reload_into_ims = true;
 
     if (ignore_reload)
-        t->flags.ignore_reload = 1;
+        t->flags.ignore_reload = true;
 
     if (ignore_no_store)
-        t->flags.ignore_no_store = 1;
+        t->flags.ignore_no_store = true;
 
     if (ignore_must_revalidate)
-        t->flags.ignore_must_revalidate = 1;
+        t->flags.ignore_must_revalidate = true;
 
     if (ignore_private)
-        t->flags.ignore_private = 1;
+        t->flags.ignore_private = true;
 
     if (ignore_auth)
-        t->flags.ignore_auth = 1;
+        t->flags.ignore_auth = true;
 
 #endif
 

diff --git a/src/client_side.cc b/src/client_side.cc
index 9c316eb48d9459ab8c565c2f0e7099753452c232..b285d38b6ace1d66f2f87ae7660c770a4f7e0b3a 100644 (file)
--- a/src/client_side.cc
+++ b/src/client_side.cc
@@ -2030,7 +2030,7 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, char *url,
     char *host;
     char ipbuf[MAX_IPSTRLEN];
 
-    http->flags.accel = 1;
+    http->flags.accel = true;
 
     /* BUG: Squid cannot deal with '*' URLs (RFC2616 5.1.2) */
 
@@ -2316,7 +2316,7 @@ parseHttpRequest(ConnStateData *csd, HttpParser *hp, HttpRequestMethod * method_
         http->uri = xstrdup(internalLocalUri(NULL, url));
         // We just re-wrote the URL. Must replace the Host: header.
         //  But have not parsed there yet!! flag for local-only handling.
-        http->flags.internal = 1;
+        http->flags.internal = true;
 
     } else if (csd->port->accel || csd->switchedToHttps()) {
         /* accelerator mode */
@@ -2692,11 +2692,11 @@ clientProcessRequest(ConnStateData *conn, HttpParser *hp, ClientSocketContext *c
     if (internalCheck(request->urlpath.termedBuf())) {
         if (internalHostnameIs(request->GetHost()) &&
                 request->port == getMyPort()) {
-            http->flags.internal = 1;
+            http->flags.internal = true;
         } else if (Config.onoff.global_internal_static && internalStaticCheck(request->urlpath.termedBuf())) {
             request->SetHost(internalHostname());
             request->port = getMyPort();
-            http->flags.internal = 1;
+            http->flags.internal = true;
         }
     }
 
@@ -2984,7 +2984,7 @@ ConnStateData::clientReadRequest(const CommIoCbParams &io)
             }
 
             /* It might be half-closed, we can't tell */
-            fd_table[io.conn->fd].flags.socket_eof = 1;
+            fd_table[io.conn->fd].flags.socket_eof = true;
 
             commMarkHalfClosed(io.conn->fd);
 

diff --git a/src/client_side_reply.cc b/src/client_side_reply.cc
index 146f1ca317f110b80bf481c1edadec2e1c4ff0d2..126bb06b2d9b5e4dd1510e800450040a9d7847fb 100644 (file)
--- a/src/client_side_reply.cc
+++ b/src/client_side_reply.cc
@@ -778,7 +778,7 @@ void
 clientReplyContext::purgeRequestFindObjectToPurge()
 {
     /* Try to find a base entry */
-    http->flags.purging = 1;
+    http->flags.purging = true;
     lookingforstore = 1;
 
     // TODO: can we use purgeAllCached() here instead of doing the
@@ -2026,7 +2026,7 @@ clientReplyContext::processReplyAccessResult(const allow_t &accessAllowed)
     if (http->request->method == Http::METHOD_HEAD) {
         /* do not forward body for HEAD replies */
         body_size = 0;
-        http->flags.done_copying = 1;
+        http->flags.done_copying = true;
         flags.complete = 1;
     }
 

diff --git a/src/client_side_request.cc b/src/client_side_request.cc
index c00bf07a625e27a9da427b1b6de88a3daec9727f..5f66755111e6a6bd50d79d443aa291fe3075debc 100644 (file)
--- a/src/client_side_request.cc
+++ b/src/client_side_request.cc
@@ -364,7 +364,7 @@ clientBeginRequest(const HttpRequestMethod& method, char const *url, CSCB * stre
     /* Set flags */
     /* internal requests only makes sense in an
      * accelerator today. TODO: accept flags ? */
-    http->flags.accel = 1;
+    http->flags.accel = true;
     /* allow size for url rewriting */
     url_sz = strlen(url) + Config.appendDomainLen + 5;
     http->uri = (char *)xcalloc(url_sz, 1);

diff --git a/src/client_side_request.h b/src/client_side_request.h
index a05177f87e43b9af2779998581ca66ce07169f1c..a5c08211162b12304f2e7c5dd2348fca6df9b156 100644 (file)
--- a/src/client_side_request.h
+++ b/src/client_side_request.h
@@ -113,12 +113,12 @@ public:
     AccessLogEntry::Pointer al; ///< access.log entry
 
     struct {
-        unsigned int accel:1;
-        unsigned int intercepted:1;
-        unsigned int spoof_client_ip:1;
-        unsigned int internal:1;
-        unsigned int done_copying:1;
-        unsigned int purging:1;
+        bool accel;
+        //bool intercepted; //XXX: it's apparently never used.
+        //bool spoof_client_ip; //XXX: it's apparently never used.
+        bool internal;
+        bool done_copying;
+        bool purging;
     } flags;
 
     struct {

diff --git a/src/comm.cc b/src/comm.cc
index 5a87c69189b45e9d2b45f218b0f2d185e294205d..0110ba31455bdfdc6b3d8a5242f6e7649045fc61 100644 (file)
--- a/src/comm.cc
+++ b/src/comm.cc
@@ -206,7 +206,7 @@ comm_empty_os_read_buffers(int fd)
     /* prevent those nasty RST packets */
     char buf[SQUID_TCP_SO_RCVBUF];
 
-    if (fd_table[fd].flags.nonblocking == 1) {
+    if (fd_table[fd].flags.nonblocking) {
         while (FD_READ_METHOD(fd, buf, SQUID_TCP_SO_RCVBUF) > 0) {};
     }
 #endif
@@ -504,7 +504,7 @@ comm_set_transparent(int fd)
         debugs(50, DBG_IMPORTANT, "comm_open: setsockopt(IP_TRANSPARENT) on FD " << fd << ": " << xstrerror());
     } else {
         /* mark the socket as having transparent options */
-        fd_table[fd].flags.transparent = 1;
+        fd_table[fd].flags.transparent = true;
     }
 #else
     debugs(50, DBG_CRITICAL, "WARNING: comm_open: setsockopt(IP_TRANSPARENT) not supported on this platform");
@@ -711,24 +711,24 @@ comm_import_opened(const Comm::ConnectionPointer &conn,
     comm_init_opened(conn, 0, 0, note, AI);
 
     if (!(conn->flags & COMM_NOCLOEXEC))
-        fd_table[conn->fd].flags.close_on_exec = 1;
+        fd_table[conn->fd].flags.close_on_exec = true;
 
     if (conn->local.GetPort() > (unsigned short) 0) {
 #if _SQUID_WINDOWS_
         if (AI->ai_socktype != SOCK_DGRAM)
 #endif
-            fd_table[conn->fd].flags.nolinger = 1;
+            fd_table[conn->fd].flags.nolinger = true;
     }
 
     if ((conn->flags & COMM_TRANSPARENT))
-        fd_table[conn->fd].flags.transparent = 1;
+        fd_table[conn->fd].flags.transparent = true;
 
     if (conn->flags & COMM_NONBLOCKING)
-        fd_table[conn->fd].flags.nonblocking = 1;
+        fd_table[conn->fd].flags.nonblocking = true;
 
 #ifdef TCP_NODELAY
     if (AI->ai_socktype == SOCK_STREAM)
-        fd_table[conn->fd].flags.nodelay = 1;
+        fd_table[conn->fd].flags.nodelay = true;
 #endif
 
     /* no fd_table[fd].flags. updates needed for these conditions:
@@ -829,7 +829,7 @@ comm_connect_addr(int sock, const Ip::Address &address)
     errno = 0;
 
     if (!F->flags.called_connect) {
-        F->flags.called_connect = 1;
+        F->flags.called_connect = true;
         ++ statCounter.syscalls.sock.connects;
 
         x = connect(sock, AI->ai_addr, AI->ai_addrlen);
@@ -1110,7 +1110,7 @@ _comm_close(int fd, char const *file, int line)
 
     PROF_start(comm_close);
 
-    F->flags.close_request = 1;
+    F->flags.close_request = true;
 
 #if USE_SSL
     if (F->ssl) {
@@ -1287,7 +1287,7 @@ commSetNoLinger(int fd)
     if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *) &L, sizeof(L)) < 0)
         debugs(50, 0, "commSetNoLinger: FD " << fd << ": " << xstrerror());
 
-    fd_table[fd].flags.nolinger = 1;
+    fd_table[fd].flags.nolinger = true;
 }
 
 static void
@@ -1351,7 +1351,7 @@ commSetNonBlocking(int fd)
 #if _SQUID_CYGWIN_
     }
 #endif
-    fd_table[fd].flags.nonblocking = 1;
+    fd_table[fd].flags.nonblocking = true;
 
     return 0;
 }
@@ -1378,7 +1378,7 @@ commUnsetNonBlocking(int fd)
         return COMM_ERROR;
     }
 
-    fd_table[fd].flags.nonblocking = 0;
+    fd_table[fd].flags.nonblocking = false;
     return 0;
 }
 
@@ -1397,7 +1397,7 @@ commSetCloseOnExec(int fd)
     if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0)
         debugs(50, 0, "FD " << fd << ": set close-on-exec failed: " << xstrerror());
 
-    fd_table[fd].flags.close_on_exec = 1;
+    fd_table[fd].flags.close_on_exec = true;
 
 #endif
 }
@@ -1411,7 +1411,7 @@ commSetTcpNoDelay(int fd)
     if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &on, sizeof(on)) < 0)
         debugs(50, DBG_IMPORTANT, "commSetTcpNoDelay: FD " << fd << ": " << xstrerror());
 
-    fd_table[fd].flags.nodelay = 1;
+    fd_table[fd].flags.nodelay = true;
 }
 
 #endif

diff --git a/src/comm/ConnOpener.cc b/src/comm/ConnOpener.cc
index 669a07d1fddb3417806fe79b4fa195cc06d5ef4e..1a72d7abec2c55210949f4a9fb138b461582e453 100644 (file)
--- a/src/comm/ConnOpener.cc
+++ b/src/comm/ConnOpener.cc
@@ -220,7 +220,7 @@ Comm::ConnOpener::connected()
      *       Also, legacy code still depends on comm_local_port() with no access to Comm::Connection
      *       when those are done comm_local_port can become one of our member functions to do the below.
      */
-    fd_table[conn_->fd].flags.open = 1;
+    fd_table[conn_->fd].flags.open = true;
     fd_table[conn_->fd].local_addr = conn_->local;
 }
 

diff --git a/src/comm/ModPoll.cc b/src/comm/ModPoll.cc
index 1347bd8839df22102a5959be5e282accdcb32c88..e7bbe182b80df8b56594a670284b8298a4251ae3 100644 (file)
--- a/src/comm/ModPoll.cc
+++ b/src/comm/ModPoll.cc
@@ -502,7 +502,7 @@ Comm::DoSelect(int msec)
                 if ((hdl = F->read_handler)) {
                     PROF_start(comm_read_handler);
                     F->read_handler = NULL;
-                    F->flags.read_pending = 0;
+                    F->flags.read_pending = false;
                     hdl(fd, F->read_data);
                     PROF_stop(comm_read_handler);
                     ++ statCounter.select_fds;

diff --git a/src/disk.cc b/src/disk.cc
index b14a538f11fd55b109a381dab816faadce8a08e1..fc9567e26f8d14923213142cae2d178ab5dc2332 100644 (file)
--- a/src/disk.cc
+++ b/src/disk.cc
@@ -125,7 +125,7 @@ file_close(int fd)
         while (!diskWriteIsComplete(fd))
             diskHandleWrite(fd, NULL);
 #else
-        F->flags.close_request = 1;
+        F->flags.close_request = true;
         debugs(6, 2, "file_close: FD " << fd << ", delaying close");
         PROF_stop(file_close);
         return;
@@ -223,7 +223,7 @@ diskHandleWrite(int fd, void *notused)
     _fde_disk *fdd = &F->disk;
     dwrite_q *q = fdd->write_q;
     int status = DISK_OK;
-    int do_close;
+    bool do_close;
 
     if (NULL == q)
         return;
@@ -232,7 +232,7 @@ diskHandleWrite(int fd, void *notused)
 
     debugs(6, 3, "diskHandleWrite: FD " << fd);
 
-    F->flags.write_daemon = 0;
+    F->flags.write_daemon = false;
 
     assert(fdd->write_q != NULL);
 
@@ -332,7 +332,7 @@ diskHandleWrite(int fd, void *notused)
         /* another block is queued */
         diskCombineWrites(fdd);
         Comm::SetSelect(fd, COMM_SELECT_WRITE, diskHandleWrite, NULL, 0);
-        F->flags.write_daemon = 1;
+        F->flags.write_daemon = true;
     }
 
     do_close = F->flags.close_request;

diff --git a/src/fd.cc b/src/fd.cc
index 2dca81d55e892859cc2f7a9258f79a74f3e8d226..29fac197e487f83a71de75a0728437b0399cabce 100644 (file)
--- a/src/fd.cc
+++ b/src/fd.cc
@@ -106,7 +106,7 @@ fd_close(int fd)
     fde *F = &fd_table[fd];
 
     assert(fd >= 0);
-    assert(F->flags.open == 1);
+    assert(F->flags.open);
 
     if (F->type == FD_FILE) {
         assert(F->read_handler == NULL);
@@ -116,7 +116,7 @@ fd_close(int fd)
     debugs(51, 3, "fd_close FD " << fd << " " << F->desc);
     Comm::SetSelect(fd, COMM_SELECT_READ, NULL, NULL, 0);
     Comm::SetSelect(fd, COMM_SELECT_WRITE, NULL, NULL, 0);
-    F->flags.open = 0;
+    F->flags.open = false;
     fdUpdateBiggest(fd, 0);
     --Number_FD;
     *F = fde();
@@ -220,7 +220,7 @@ fd_open(int fd, unsigned int type, const char *desc)
     assert(!F->flags.open);
     debugs(51, 3, "fd_open() FD " << fd << " " << desc);
     F->type = type;
-    F->flags.open = 1;
+    F->flags.open = true;
     F->epoll_state = 0;
 #if _SQUID_WINDOWS_
 

diff --git a/src/fde.h b/src/fde.h
index 5263a1399c27ee4f899032a643890bdd3f63dfda..126b2e0b3e2c1602ca5dad7df5d7cf32f3a4a078 100644 (file)
--- a/src/fde.h
+++ b/src/fde.h
@@ -86,19 +86,19 @@ public:
     char desc[FD_DESC_SZ];
 
     struct _fde_flags {
-        unsigned int open:1;
-        unsigned int close_request:1; // file_ or comm_close has been called
-        unsigned int write_daemon:1;
-        unsigned int socket_eof:1;
-        unsigned int nolinger:1;
-        unsigned int nonblocking:1;
-        unsigned int ipc:1;
-        unsigned int called_connect:1;
-        unsigned int nodelay:1;
-        unsigned int close_on_exec:1;
-        unsigned int read_pending:1;
-        unsigned int write_pending:1;
-        unsigned int transparent:1;
+        bool open;
+        bool close_request; ///< true if file_ or comm_close has been called
+        bool write_daemon;
+        bool socket_eof;
+        bool nolinger;
+        bool nonblocking;
+        bool ipc;
+        bool called_connect;
+        bool nodelay;
+        bool close_on_exec;
+        bool read_pending;
+        //bool write_pending; //XXX seems not to be used
+        bool transparent;
     } flags;
 
     int64_t bytes_read;

diff --git a/src/fqdncache.cc b/src/fqdncache.cc
index 7428be0a81afed25df8a00a5482d3be26ee7215d..d4c4535eb398319891bb96dbb59fa02965bde3f9 100644 (file)
--- a/src/fqdncache.cc
+++ b/src/fqdncache.cc
@@ -116,8 +116,8 @@ public:
     unsigned short locks;
 
     struct {
-        unsigned int negcached:1;
-        unsigned int fromhosts:1;
+        bool negcached;
+        bool fromhosts;
     } flags;
 
     int age() const; ///< time passed since request_time or -1 if unknown
@@ -428,7 +428,7 @@ fqdncacheParse(fqdncache_entry *f, const rfc1035_rr * answers, int nr, const cha
     int ttl = 0;
     const char *name = (const char *)f->hash.key;
     f->expires = squid_curtime + Config.negativeDnsTtl;
-    f->flags.negcached = 1;
+    f->flags.negcached = true;
 
     if (nr < 0) {
         debugs(35, 3, "fqdncacheParse: Lookup of '" << name << "' failed (" << error_message << ")");
@@ -485,7 +485,7 @@ fqdncacheParse(fqdncache_entry *f, const rfc1035_rr * answers, int nr, const cha
 
     f->expires = squid_curtime + ttl;
 
-    f->flags.negcached = 0;
+    f->flags.negcached = false;
 
     return f->name_count;
 }
@@ -827,7 +827,7 @@ fqdncacheAddEntryFromHosts(char *addr, wordlist * hostnames)
 
     fce->name_count = j;
     fce->names[j] = NULL;      /* it's safe */
-    fce->flags.fromhosts = 1;
+    fce->flags.fromhosts = true;
     fqdncacheAddEntry(fce);
     fqdncacheLockEntry(fce);
 }

diff --git a/src/helper.cc b/src/helper.cc
index 0d5a5bd0cdb98f77dad33ec31676fdf944b020e5..65868525bbbb662a7f23c2527f377d8d81591d36 100644 (file)
--- a/src/helper.cc
+++ b/src/helper.cc
@@ -102,7 +102,7 @@ HelperServerBase::closePipesSafely()
     shutdown(writePipe->fd, SD_BOTH);
 #endif
 
-    flags.closing = 1;
+    flags.closing = true;
     if (readPipe->fd == writePipe->fd)
         readPipe->fd = -1;
     else
@@ -131,7 +131,7 @@ HelperServerBase::closeWritePipeSafely()
     shutdown(writePipe->fd, (readPipe->fd == writePipe->fd ? SD_BOTH : SD_SEND));
 #endif
 
-    flags.closing = 1;
+    flags.closing = true;
     if (readPipe->fd == writePipe->fd)
         readPipe->fd = -1;
     writePipe->close();
@@ -347,7 +347,7 @@ helperStatefulOpenServers(statefulhelper * hlp)
         helper_stateful_server *srv = cbdataAlloc(helper_stateful_server);
         srv->hIpc = hIpc;
         srv->pid = pid;
-        srv->flags.reserved = 0;
+        srv->flags.reserved = false;
         srv->initStats();
         srv->index = k;
         srv->addr = hlp->addr;
@@ -476,7 +476,7 @@ helperStatefulReleaseServer(helper_stateful_server * srv)
 
     ++ srv->stats.releases;
 
-    srv->flags.reserved = 0;
+    srv->flags.reserved = false;
     if (srv->parent->OnEmptyQueue != NULL && srv->data)
         srv->parent->OnEmptyQueue(srv->data);
 
@@ -622,7 +622,7 @@ helperShutdown(helper * hlp)
 
         assert(hlp->childs.n_active > 0);
         -- hlp->childs.n_active;
-        srv->flags.shutdown = 1;       /* request it to shut itself down */
+        srv->flags.shutdown = true;    /* request it to shut itself down */
 
         if (srv->flags.closing) {
             debugs(84, 3, "helperShutdown: " << hlp->id_name << " #" << srv->index + 1 << " is CLOSING.");
@@ -659,7 +659,7 @@ helperStatefulShutdown(statefulhelper * hlp)
 
         assert(hlp->childs.n_active > 0);
         -- hlp->childs.n_active;
-        srv->flags.shutdown = 1;       /* request it to shut itself down */
+        srv->flags.shutdown = true;    /* request it to shut itself down */
 
         if (srv->flags.busy) {
             debugs(84, 3, "helperStatefulShutdown: " << hlp->id_name << " #" << srv->index + 1 << " is BUSY.");
@@ -885,7 +885,7 @@ helperReturnBuffer(int request_number, helper_server * srv, helper * hlp, char *
     if (!srv->flags.shutdown) {
         helperKickQueue(hlp);
     } else if (!srv->flags.closing && !srv->stats.pending) {
-        srv->flags.closing=1;
+        srv->flags.closing=true;
         srv->writePipe->close();
     }
 }
@@ -1050,7 +1050,7 @@ helperStatefulHandleRead(const Comm::ConnectionPointer &conn, char *buf, size_t
         // only skip off the \0's _after_ passing its location in HelperReply above
         t += skip;
 
-        srv->flags.busy = 0;
+        srv->flags.busy = false;
         /**
          * BUG: the below assumes that only one response per read() was received and discards any octets remaining.
          *      Doing this prohibits concurrency support with multiple replies per read().
@@ -1291,7 +1291,7 @@ helperDispatchWriteDone(const Comm::ConnectionPointer &conn, char *buf, size_t l
     srv->writebuf->clean();
     delete srv->writebuf;
     srv->writebuf = NULL;
-    srv->flags.writing = 0;
+    srv->flags.writing = false;
 
     if (flag != COMM_OK) {
         /* Helper server has crashed */
@@ -1302,7 +1302,7 @@ helperDispatchWriteDone(const Comm::ConnectionPointer &conn, char *buf, size_t l
     if (!srv->wqueue->isNull()) {
         srv->writebuf = srv->wqueue;
         srv->wqueue = new MemBuf;
-        srv->flags.writing = 1;
+        srv->flags.writing = true;
         AsyncCall::Pointer call = commCbCall(5,5, "helperDispatchWriteDone",
                                              CommIoCbPtrFun(helperDispatchWriteDone, srv));
         Comm::Write(srv->writePipe, srv->writebuf->content(), srv->writebuf->contentSize(), call, NULL);
@@ -1345,7 +1345,7 @@ helperDispatch(helper_server * srv, helper_request * r)
         assert(NULL == srv->writebuf);
         srv->writebuf = srv->wqueue;
         srv->wqueue = new MemBuf;
-        srv->flags.writing = 1;
+        srv->flags.writing = true;
         AsyncCall::Pointer call = commCbCall(5,5, "helperDispatchWriteDone",
                                              CommIoCbPtrFun(helperDispatchWriteDone, srv));
         Comm::Write(srv->writePipe, srv->writebuf->content(), srv->writebuf->contentSize(), call, NULL);
@@ -1397,8 +1397,8 @@ helperStatefulDispatch(helper_stateful_server * srv, helper_stateful_request * r
         return;
     }
 
-    srv->flags.busy = 1;
-    srv->flags.reserved = 1;
+    srv->flags.busy = true;
+    srv->flags.reserved = true;
     srv->request = r;
     srv->dispatch_time = current_time;
     AsyncCall::Pointer call = commCbCall(5,5, "helperStatefulDispatchWriteDone",

diff --git a/src/helper.h b/src/helper.h
index 48af9159767c4a6b3aae242f4370db1bab21c351..34dfd8465e80f9a322ddcc26698c65f696cd5292 100644 (file)
--- a/src/helper.h
+++ b/src/helper.h
@@ -132,11 +132,11 @@ public:
     dlink_node link;
 
     struct _helper_flags {
-        unsigned int busy:1;
-        unsigned int writing:1;
-        unsigned int closing:1;
-        unsigned int shutdown:1;
-        unsigned int reserved:1;
+        bool busy;
+        bool writing;
+        bool closing;
+        bool shutdown;
+        bool reserved;
     } flags;
 
     struct {

diff --git a/src/ipc_win32.cc b/src/ipc_win32.cc
index bb97d1a1b95cdb6b170bec3aa497bb2d6ce6a118..88db17c7180ecfc305da970a5742daae1a93134e 100644 (file)
--- a/src/ipc_win32.cc
+++ b/src/ipc_win32.cc
@@ -321,13 +321,10 @@ ipcCreate(int type, const char *prog, const char *const args[], const char *name
     if (wfd)
         *wfd = pwfd;
 
-    fd_table[prfd].flags.ipc = 1;
-
-    fd_table[pwfd].flags.ipc = 1;
-
-    fd_table[crfd].flags.ipc = 1;
-
-    fd_table[cwfd].flags.ipc = 1;
+    fd_table[prfd].flags.ipc = true;
+    fd_table[pwfd].flags.ipc = true;
+    fd_table[crfd].flags.ipc = true;
+    fd_table[cwfd].flags.ipc = true;
 
     if (Config.sleep_after_fork) {
         /* XXX emulation of usleep() */

diff --git a/src/ipcache.cc b/src/ipcache.cc
index 2d1071da714d8393846b671b245ed0053c53ad25..fa1b53aaa43f5f88577d91ed0d0c1e95a6dbf57e 100644 (file)
--- a/src/ipcache.cc
+++ b/src/ipcache.cc
@@ -113,8 +113,8 @@ public:
     dlink_node lru;
     unsigned short locks;
     struct {
-        unsigned int negcached:1;
-        unsigned int fromhosts:1;
+        bool negcached;
+        bool fromhosts;
     } flags;
 
     int age() const; ///< time passed since request_time or -1 if unknown
@@ -473,7 +473,7 @@ ipcacheParse(ipcache_entry *i, const rfc1035_rr * answers, int nr, const char *e
     int cname_found = 0;
 
     i->expires = squid_curtime + Config.negativeDnsTtl;
-    i->flags.negcached = 1;
+    i->flags.negcached = true;
     safe_free(i->addrs.in_addrs);
     assert(i->addrs.in_addrs == NULL);
     safe_free(i->addrs.bad_mask);
@@ -585,7 +585,7 @@ ipcacheParse(ipcache_entry *i, const rfc1035_rr * answers, int nr, const char *e
 
     i->expires = squid_curtime + ttl;
 
-    i->flags.negcached = 0;
+    i->flags.negcached = false;
 
     return i->addrs.count;
 }
@@ -1218,7 +1218,7 @@ ipcacheAddEntryFromHosts(const char *name, const char *ipaddr)
     i->addrs.bad_mask = (unsigned char *)xcalloc(1, sizeof(unsigned char));
     i->addrs.in_addrs[0] = ip;
     i->addrs.bad_mask[0] = FALSE;
-    i->flags.fromhosts = 1;
+    i->flags.fromhosts = true;
     ipcacheAddEntry(i);
     ipcacheLockEntry(i);
     return 0;

diff --git a/src/peer_digest.cc b/src/peer_digest.cc
index 3cfe453178e7dd80caaac58773b98bbc27164d86..6e58defbe7338c3b884ff5231f026158a82912d9 100644 (file)
--- a/src/peer_digest.cc
+++ b/src/peer_digest.cc
@@ -180,7 +180,7 @@ peerDigestNeeded(PeerDigest * pd)
     assert(!pd->flags.needed);
     assert(!pd->cd);
 
-    pd->flags.needed = 1;
+    pd->flags.needed = true;
     pd->times.needed = squid_curtime;
     peerDigestSetCheck(pd, 0); /* check asap */
 }
@@ -322,7 +322,7 @@ peerDigestRequest(PeerDigest * pd)
     StoreIOBuffer tempBuffer;
 
     pd->req_result = NULL;
-    pd->flags.requested = 1;
+    pd->flags.requested = true;
 
     /* compute future request components */
 
@@ -836,7 +836,7 @@ peerDigestReqFinish(DigestFetchState * fetch, char *buf,
     /* must go before peerDigestPDFinish */
 
     if (pdcb_valid) {
-        fetch->pd->flags.requested = 0;
+        fetch->pd->flags.requested = false;
         fetch->pd->req_result = reason;
     }
 
@@ -887,14 +887,14 @@ peerDigestPDFinish(DigestFetchState * fetch, int pcb_valid, int err)
             pd->cd = NULL;
         }
 
-        pd->flags.usable = 0;
+        pd->flags.usable = false;
 
         if (!pcb_valid)
             peerDigestNotePeerGone(pd);
     } else {
         assert(pcb_valid);
 
-        pd->flags.usable = 1;
+        pd->flags.usable = true;
 
         /* XXX: ugly condition, but how? */
 

diff --git a/src/ssl/support.cc b/src/ssl/support.cc
index 9580cb31f1031f24db73ac86a1c9d7e7d1a0055b..c738c2fb425be618e2587672739025841d73510f 100644 (file)
--- a/src/ssl/support.cc
+++ b/src/ssl/support.cc
@@ -1118,9 +1118,9 @@ ssl_read_method(int fd, char *buf, int len)
 
     if (i > 0 && SSL_pending(ssl) > 0) {
         debugs(83, 2, "SSL FD " << fd << " is pending");
-        fd_table[fd].flags.read_pending = 1;
+        fd_table[fd].flags.read_pending = true;
     } else
-        fd_table[fd].flags.read_pending = 0;
+        fd_table[fd].flags.read_pending = false;
 
     return i;
 }