{
if (pools.size()) {
storeAppendPrintf(entry, "%s %d\n", name, (int)pools.size());
- for (unsigned int i = 0; i < pools.size(); i++)
+ for (unsigned int i = 0; i < pools.size(); ++i)
pools[i].dump(entry, i);
}
}
}
unsigned short pools_;
ConfigParser::ParseUShort(&pools_);
- for (int i = 0; i < pools_; i++) {
+ for (int i = 0; i < pools_; ++i) {
pools.push_back(ClientDelayPool());
}
}
void ClientDelayConfig::clean()
{
- for (unsigned int i = 0; i < pools.size(); i++) {
+ for (unsigned int i = 0; i < pools.size(); ++i) {
aclDestroyAccessList(&pools[i].access);
}
}
fn = ++t;
while (*t && *t != '\"' && *t != '\'')
- t++;
+ ++t;
*t = '\0';
const char * next = s+1; // may point to 0
memmove(s, next, strlen(next) + 1);
}
- s++;
+ ++s;
}
if (*s != '"') {
const char *s = var.termedBuf();
bool needQuote = false;
- for (const char *l = s; !needQuote && *l != '\0'; l++ )
+ for (const char *l = s; !needQuote && *l != '\0'; ++l )
needQuote = !isalnum(*l);
if (!needQuote)
quotedStr.clean();
quotedStr.append('"');
- for (; *s != '\0'; s++) {
+ for (; *s != '\0'; ++s) {
if (*s == '"' || *s == '\\')
quotedStr.append('\\');
quotedStr.append(*s);
storeAppendPrintf(entry, "%s %d\n", name, DelayPools::pools());
- for (i = 0; i < DelayPools::pools(); i++)
+ for (i = 0; i < DelayPools::pools(); ++i)
DelayPools::delay_data[i].dump (entry, i);
}
return DelayId();
}
- for (pool = 0; pool < DelayPools::pools(); pool++) {
+ for (pool = 0; pool < DelayPools::pools(); ++pool) {
/* pools require explicit 'allow' to assign a client into them */
if (!DelayPools::delay_data[pool].access) {
return 0;
}
- p++;
+ ++p;
/* do we have last-pos ? */
if (p - field >= flen) {
else if (!httpHdrRangeRespSpecParseInit(&range->spec, str, p - str))
return 0;
- p++;
+ ++p;
if (*p == '*')
range->elength = range_spec_unknown;
if (!httpHeaderParseOffset(field, &offset))
return false;
- p++;
+ ++p;
/* do we have last-pos ? */
if (p - field < flen) {
if ((p = strchr(item, '=')) && (p - item < ilen)) {
vlen = ilen - (p + 1 - item);
ilen = p - item;
- p++;
+ ++p;
}
/* decrease ilen to still match the token for ';' qualified non '=' statments */
if (type != SC_OTHER)
debugs(90, 2, "hdr sc: ignoring duplicate control-directive: near '" << item << "' in '" << str << "'");
- ScFieldsInfo[type].stat.repCount++;
+ ++ ScFieldsInfo[type].stat.repCount;
continue;
}
if (flag == SC_CONTENT)
packerPrintf(p, "=\"" SQUIDSTRINGPH "\"", SQUIDSTRINGPRINT(content_));
- pcount++;
+ ++pcount;
}
}
/* init header stats */
assert(HttpHeaderStatCount == hoReply + 1);
- for (i = 0; i < HttpHeaderStatCount; i++)
+ for (i = 0; i < HttpHeaderStatCount; ++i)
httpHeaderStatInit(HttpHeaderStats + i, HttpHeaderStats[i].label);
HttpHeaderStats[hoRequest].owner_mask = &RequestHeadersMask;
if (0 != entries.count)
HttpHeaderStats[owner].hdrUCountDistr.count(entries.count);
- HttpHeaderStats[owner].destroyedCount++;
+ ++ HttpHeaderStats[owner].destroyedCount;
HttpHeaderStats[owner].busyDestroyedCount += entries.count > 0;
assert(header_start && header_end);
debugs(55, 7, "parsing hdr: (" << this << ")" << std::endl << getStringPrefix(header_start, header_end));
- HttpHeaderStats[owner].parsedCount++;
+ ++ HttpHeaderStats[owner].parsedCount;
char *nulpos;
if ((nulpos = (char*)memchr(header_start, '\0', header_end - header_start))) {
field_end = field_ptr;
- field_ptr++; /* Move to next line */
+ ++field_ptr; /* Move to next line */
if (field_end > this_line && field_end[-1] == '\r') {
field_end--; /* Ignore CR LF */
assert(pos);
assert(*pos >= HttpHeaderInitPos && *pos < (ssize_t)entries.count);
- for ((*pos)++; *pos < (ssize_t)entries.count; (*pos)++) {
+ for (++(*pos); *pos < (ssize_t)entries.count; ++(*pos)) {
if (entries.items[*pos])
return (HttpHeaderEntry*)entries.items[*pos];
}
debugs(55, 7, HERE << this << " adding entry: " << e->id << " at " << entries.count);
if (CBIT_TEST(mask, e->id))
- Headers[e->id].stat.repCount++;
+ ++ Headers[e->id].stat.repCount;
else
CBIT_SET(mask, e->id);
debugs(55, 7, HERE << this << " adding entry: " << e->id << " at " << entries.count);
if (CBIT_TEST(mask, e->id))
- Headers[e->id].stat.repCount++;
+ ++ Headers[e->id].stat.repCount;
else
CBIT_SET(mask, e->id);
cc = NULL;
}
- HttpHeaderStats[owner].ccParsedCount++;
+ ++ HttpHeaderStats[owner].ccParsedCount;
if (cc)
httpHdrCcUpdateStats(cc, &HttpHeaderStats[owner].ccTypeDistr);
HttpHdrSc *sc = httpHdrScParseCreate(s);
- ++HttpHeaderStats[owner].ccParsedCount;
+ ++ HttpHeaderStats[owner].ccParsedCount;
if (sc)
sc->updateStats(&HttpHeaderStats[owner].scTypeDistr);
return NULL;
/* skip white space */
- for (; field && xisspace(*field); field++);
+ for (; field && xisspace(*field); ++field);
if (!*field) /* no authorization cookie */
return NULL;
value = aValue;
- Headers[id].stat.aliveCount++;
+ ++ Headers[id].stat.aliveCount;
debugs(55, 9, "created HttpHeaderEntry " << this << ": '" << name << " : " << value );
}
const char *value_start = field_start + name_len + 1; /* skip ':' */
/* note: value_end == field_end */
- HeaderEntryParsedCount++;
+ ++ HeaderEntryParsedCount;
/* do we have a valid field name within this field? */
/* trim field value */
while (value_start < field_end && xisspace(*value_start))
- value_start++;
+ ++value_start;
while (value_start < field_end && xisspace(field_end[-1]))
field_end--;
/* set field value */
value.limitInit(value_start, field_end - value_start);
- Headers[id].stat.seenCount++;
+ ++ Headers[id].stat.seenCount;
debugs(55, 9, "parsed HttpHeaderEntry: '" << name << ": " << value << "'");
static void
httpHeaderNoteParsedEntry(http_hdr_type id, String const &context, int error)
{
- Headers[id].stat.parsCount++;
+ ++ Headers[id].stat.parsCount;
if (error) {
- Headers[id].stat.errCount++;
+ ++ Headers[id].stat.errCount;
debugs(55, 2, "cannot parse hdr field: '" << Headers[id].name << ": " << context << "'");
}
}
HttpHeaderStats[0].busyDestroyedCount =
HttpHeaderStats[hoRequest].busyDestroyedCount + HttpHeaderStats[hoReply].busyDestroyedCount;
- for (i = 1; i < HttpHeaderStatCount; i++) {
+ for (i = 1; i < HttpHeaderStatCount; ++i) {
httpHeaderStatDump(HttpHeaderStats + i, e);
storeAppendPrintf(e, "%s\n", "<br>");
}
while (*pos != '"' && len > (pos-start)) {
if (*pos =='\r') {
- pos++;
+ ++pos;
if ((pos-start) > len || *pos != '\n') {
debugs(66, 2, HERE << "failed to parse a quoted-string header field with '\\r' octet " << (start-pos)
<< " bytes into '" << start << "'");
}
if (*pos == '\n') {
- pos++;
+ ++pos;
if ( (pos-start) > len || (*pos != ' ' && *pos != '\t')) {
debugs(66, 2, HERE << "failed to parse multiline quoted-string header field '" << start << "'");
val->clean();
}
// TODO: replace the entire LWS with a space
val->append(" ");
- pos++;
+ ++pos;
debugs(66, 2, HERE << "len < pos-start => " << len << " < " << (pos-start));
continue;
}
bool quoted = (*pos == '\\');
if (quoted) {
- pos++;
+ ++pos;
if (!*pos || (pos-start) > len) {
debugs(66, 2, HERE << "failed to parse a quoted-string header field near '" << start << "'");
val->clean();
}
end = pos;
while (end < (start+len) && *end != '\\' && *end != '\"' && (unsigned char)*end > 0x1F && *end != 0x7F)
- end++;
+ ++end;
if (((unsigned char)*end <= 0x1F && *end != '\r' && *end != '\n') || *end == 0x7F) {
debugs(66, 2, HERE << "failed to parse a quoted-string header field with CTL octet " << (start-pos)
<< " bytes into '" << start << "'");
HeaderManglers::~HeaderManglers()
{
- for (int i = 0; i < HDR_ENUM_END; i++)
+ for (int i = 0; i < HDR_ENUM_END; ++i)
header_mangler_clean(known[i]);
typedef ManglersByName::iterator MBNI;
void
HeaderManglers::dumpAccess(StoreEntry * entry, const char *name) const
{
- for (int i = 0; i < HDR_ENUM_END; i++) {
+ for (int i = 0; i < HDR_ENUM_END; ++i) {
header_mangler_dump_access(entry, name, known[i],
httpHeaderNameById(i));
}
void
HeaderManglers::dumpReplacement(StoreEntry * entry, const char *name) const
{
- for (int i = 0; i < HDR_ENUM_END; i++) {
+ for (int i = 0; i < HDR_ENUM_END; ++i) {
header_mangler_dump_replacement(entry, name, known[i],
httpHeaderNameById(i));
}
*blk_end = *blk_start;
- for (nnl = 0; nnl == 0; (*parse_start)++) {
+ for (nnl = 0; nnl == 0; ++(*parse_start)) {
if (**parse_start == '\r')
(void) 0;
else if (**parse_start == '\n')
- nnl++;
+ ++nnl;
else
break;
}
*blk_end = *blk_start + slen;
while (**blk_end == '\r') /* CR */
- (*blk_end)++;
+ ++(*blk_end);
if (**blk_end == '\n') /* LF */
- (*blk_end)++;
+ ++(*blk_end);
*parse_start = *blk_end;
HttpMsg *
HttpMsg::_lock()
{
- lock_count++;
+ ++lock_count;
return this;
}
"Whitespace bytes received ahead of method. " <<
"Ignored due to relaxed_header_parser.");
// Be tolerant of prefix spaces (other bytes are valid method values)
- for (; req.start < bufsiz && buf[req.start] == ' '; req.start++);
+ for (; req.start < bufsiz && buf[req.start] == ' '; ++req.start);
}
req.end = -1;
- for (int i = 0; i < bufsiz; i++) {
+ for (int i = 0; i < bufsiz; ++i) {
// track first and last whitespace (SP only)
if (buf[i] == ' ') {
last_whitespace = i;
if (buf[i + 1] == '\n' || buf[i + 1] == '\r')
line_end = i - 1;
while (i < bufsiz - 1 && buf[i + 1] == '\r')
- i++;
+ ++i;
if (buf[i + 1] == '\n') {
req.end = i + 1;
return -1;
}
int maj = 0;
- for (; i <= line_end && (isdigit(buf[i])) && maj < 65536; i++) {
+ for (; i <= line_end && (isdigit(buf[i])) && maj < 65536; ++i) {
maj = maj * 10;
maj = maj + (buf[i]) - '0';
}
return -1;
}
int min = 0;
- for (; i <= line_end && (isdigit(buf[i])) && min < 65536; i++) {
+ for (; i <= line_end && (isdigit(buf[i])) && min < 65536; ++i) {
min = min * 10;
min = min + (buf[i]) - '0';
}
while (xisspace(*end)) // find prev non-space
end--;
- end++; // back to space
+ ++end; // back to space
if (2 != sscanf(ver + 5, "%d.%d", &http_ver.major, &http_ver.minor)) {
debugs(73, 1, "parseRequestLine: Invalid HTTP identifier.");
while (w) {
char *s;
- for (s = w->key; *s; s++)
+ for (s = w->key; *s; ++s)
*s = xtoupper(*s);
AddExtension(w->key);
assert(hash_lookup(table, p) == NULL);
LeakFinderPtr *c = new LeakFinderPtr(p, file, line);
hash_join(table, c);
- count++;
+ ++count;
return p;
}
case CD_PARENT_HIT:
case CD_SIBLING_HIT:
- statCounter.cd.times_used++;
+ ++ statCounter.cd.times_used;
break;
#endif
case FIRST_PARENT_MISS:
case CLOSEST_PARENT_MISS:
- statCounter.icp.times_used++;
+ ++ statCounter.icp.times_used;
i = &someEntry->ping;
if (clientPingHasFinished(i))
statCounter.icp.querySvcTime.count(tvSubUsec(i->start, i->stop));
if (i->timeout)
- statCounter.icp.query_timeouts++;
+ ++ statCounter.icp.query_timeouts;
break;
case CLOSEST_PARENT:
case CLOSEST_DIRECT:
- statCounter.netdb.times_used++;
+ ++ statCounter.netdb.times_used;
break;
clientUpdateStatCounters(logType);
if (request->errType != ERR_NONE)
- statCounter.client_http.errors++;
+ ++ statCounter.client_http.errors;
clientUpdateStatHistCounters(logType,
tvSubMsec(start_time, current_time));
while (*t) {
if (!xisspace(*t))
*q++ = *t;
- t++;
+ ++t;
}
*q = '\0';
http->log_uri = xstrndup(rfc1738_escape_unescaped(tmp_uri), MAX_URL);
commSetTcpKeepalive(params.conn->fd, s->tcp_keepalive.idle, s->tcp_keepalive.interval, s->tcp_keepalive.timeout);
}
- incoming_sockets_accepted++;
+ ++ incoming_sockets_accepted;
// Socket is ready, setup the connection manager to start using it
ConnStateData *connState = connStateCreate(params.conn, s);
ch.src_addr = params.conn->remote;
ch.my_addr = params.conn->local;
- for (unsigned int pool = 0; pool < pools.size(); pool++) {
+ for (unsigned int pool = 0; pool < pools.size(); ++pool) {
/* pools require explicit 'allow' to assign a client into them */
if (pools[pool].access) {
commSetTcpKeepalive(params.conn->fd, s->tcp_keepalive.idle, s->tcp_keepalive.interval, s->tcp_keepalive.timeout);
}
- incoming_sockets_accepted++;
+ ++incoming_sockets_accepted;
// Socket is ready, setup the connection manager to start using it
ConnStateData *connState = connStateCreate(params.conn, s);
AddOpenedHttpSocket(const Comm::ConnectionPointer &conn)
{
bool found = false;
- for (int i = 0; i < NHttpSockets && !found; i++) {
+ for (int i = 0; i < NHttpSockets && !found; ++i) {
if ((found = HttpSockets[i] < 0))
HttpSockets[i] = conn->fd;
}
#endif
// TODO see if we can drop HttpSockets array entirely */
- for (int i = 0; i < NHttpSockets; i++) {
+ for (int i = 0; i < NHttpSockets; ++i) {
HttpSockets[i] = -1;
}
assert(data == COMMIO_FD_READCB(fd));
assert(ccb->active());
/* Attempt a read */
- statCounter.syscalls.sock.reads++;
+ ++ statCounter.syscalls.sock.reads;
errno = 0;
int retval;
retval = FD_READ_METHOD(fd, ccb->buf, ccb->size);
int
comm_udp_recvfrom(int fd, void *buf, size_t len, int flags, Ip::Address &from)
{
- statCounter.syscalls.sock.recvfroms++;
+ ++ statCounter.syscalls.sock.recvfroms;
int x = 0;
struct addrinfo *AI = NULL;
static comm_err_t
commBind(int s, struct addrinfo &inaddr)
{
- statCounter.syscalls.sock.binds++;
+ ++ statCounter.syscalls.sock.binds;
if (bind(s, inaddr.ai_addr, inaddr.ai_addrlen) == 0) {
debugs(50, 6, "commBind: bind socket FD " << s << " to " << fd_table[s].local_addr);
PROF_start(comm_open);
/* Create socket for accepting new connections. */
- statCounter.syscalls.sock.sockets++;
+ ++ statCounter.syscalls.sock.sockets;
/* Setup the socket addrinfo details for use */
addr.GetAddrInfo(AI);
if (!F->flags.called_connect) {
F->flags.called_connect = 1;
- statCounter.syscalls.sock.connects++;
+ ++ statCounter.syscalls.sock.connects;
x = connect(sock, AI->ai_addr, AI->ai_addrlen);
fd_close(params.fd); /* update fdstat */
close(params.fd);
- statCounter.syscalls.sock.closes++;
+ ++ statCounter.syscalls.sock.closes;
/* When one connection closes, give accept() a chance, if need be */
Comm::AcceptLimiter::Instance().kick();
struct addrinfo *AI = NULL;
PROF_start(comm_udp_sendto);
- statCounter.syscalls.sock.sendtos++;
+ ++ statCounter.syscalls.sock.sendtos;
debugs(50, 3, "comm_udp_sendto: Attempt to send UDP packet to " << to_addr <<
" using FD " << fd << " using Port " << comm_local_port(fd) );
int fd;
fde *F = NULL;
- for (fd = 0; fd <= Biggest_FD; fd++) {
+ for (fd = 0; fd <= Biggest_FD; ++fd) {
F = &fd_table[fd];
if (!F->flags.open)
fde *F = NULL;
AsyncCall::Pointer callback;
- for (fd = 0; fd <= Biggest_FD; fd++) {
+ for (fd = 0; fd <= Biggest_FD; ++fd) {
F = &fd_table[fd];
if (writeTimedOut(fd)) {
PROF_start(comm_open);
/* Create socket for accepting new connections. */
- statCounter.syscalls.sock.sockets++;
+ ++ statCounter.syscalls.sock.sockets;
/* Setup the socket addrinfo details for use */
struct addrinfo AI;
return;
}
- for (i = 0; i < MAX_DEBUG_SECTIONS; i++)
+ for (i = 0; i < MAX_DEBUG_SECTIONS; ++i)
Debug::Levels[i] = l;
}
struct syslog_facility_name *n;
- for (n = syslog_facility_names; n->name; n++) {
+ for (n = syslog_facility_names; n->name; ++n) {
if (strcmp(n->name, facility) == 0) {
syslog_facility = n->facility;
return;
return;
}
- for (i = 0; i < MAX_DEBUG_SECTIONS; i++)
+ for (i = 0; i < MAX_DEBUG_SECTIONS; ++i)
Debug::Levels[i] = 0;
if (options) {
Ctx
ctx_enter(const char *descr)
{
- Ctx_Current_Level++;
+ ++Ctx_Current_Level;
if (Ctx_Current_Level <= CTX_MAX_LEVEL)
Ctx_Descrs[Ctx_Current_Level] = descr;
ctx_print(void)
{
/* lock so _db_print will not call us recursively */
- Ctx_Lock++;
+ ++Ctx_Lock;
/* ok, user saw [0,Ctx_Reported_Level] descriptions */
/* first inform about entries popped since user saw them */
/* report new contexts that were pushed since last report */
while (Ctx_Reported_Level < Ctx_Current_Level) {
- Ctx_Reported_Level++;
- Ctx_Valid_Level++;
+ ++Ctx_Reported_Level;
+ ++Ctx_Valid_Level;
_db_print("ctx: enter level %2d: '%s'\n", Ctx_Reported_Level,
ctx_get_descr(Ctx_Reported_Level));
}
storeAppendPrintf(sentry, "\t\tCurrent:");
- for (unsigned int i = 0; i < buckets.size(); i++) {
+ for (unsigned int i = 0; i < buckets.size(); ++i) {
storeAppendPrintf(sentry, " %d:", buckets.key_map[i]);
buckets.values[i].stats(sentry);
}
fd = open(path, mode, 0644);
- statCounter.syscalls.disk.opens++;
+ ++ statCounter.syscalls.disk.opens;
if (fd < 0) {
debugs(50, 3, "file_open: error opening file " << path << ": " << xstrerror());
fd_close(fd);
- statCounter.syscalls.disk.closes++;
+ ++ statCounter.syscalls.disk.closes;
PROF_stop(file_close);
}
debugs(6, 3, "diskHandleWrite: FD " << fd << " len = " << len);
- statCounter.syscalls.disk.writes++;
+ ++ statCounter.syscalls.disk.writes;
fd_bytes(fd, len, FD_WRITE);
#endif
debugs(6, 3, "diskHandleRead: FD " << fd << " seeking to offset " << ctrl_dat->offset);
lseek(fd, ctrl_dat->offset, SEEK_SET); /* XXX ignore return? */
- ++statCounter.syscalls.disk.seeks;
+ ++ statCounter.syscalls.disk.seeks;
F->disk.offset = ctrl_dat->offset;
}
if (len > 0)
F->disk.offset += len;
- statCounter.syscalls.disk.reads++;
+ ++ statCounter.syscalls.disk.reads;
fd_bytes(fd, len, FD_READ);
void
safeunlink(const char *s, int quiet)
{
- statCounter.syscalls.disk.unlinks++;
+ ++ statCounter.syscalls.disk.unlinks;
if (unlink(s) < 0 && !quiet)
debugs(50, 1, "safeunlink: Couldn't delete " << s << ": " << xstrerror());
// TODO generate a test packet to probe this NS from EDNS size and ability.
#endif
debugs(78, 3, "idnsAddNameserver: Added nameserver #" << nns << " (" << A << ")");
- nns++;
+ ++nns;
}
static void
strcpy(searchpath[npc].domain, buf);
Tolower(searchpath[npc].domain);
debugs(78, 3, "idnsAddPathComponent: Added domain #" << npc << ": " << searchpath[npc].domain);
- npc++;
+ ++npc;
}
if (RegQueryInfoKey(hndKey, NULL, NULL, NULL, &InterfacesCount, &MaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
keyname = (char *) xmalloc(++MaxSubkeyLen);
- for (i = 0; i < (int) InterfacesCount; i++) {
+ for (i = 0; i < (int) InterfacesCount; ++i) {
DWORD j;
j = MaxSubkeyLen;
if (RegEnumKeyEx(hndKey, i, keyname, &j, NULL, NULL, NULL, &ftLastWriteTime) == ERROR_SUCCESS) {
storeAppendPrintf(sentry, "IP ADDRESS # QUERIES # REPLIES\n");
storeAppendPrintf(sentry, "---------------------------------------------- --------- ---------\n");
- for (i = 0; i < nns; i++) {
+ for (i = 0; i < nns; ++i) {
storeAppendPrintf(sentry, "%-45s %9d %9d\n", /* Let's take the maximum: (15 IPv4/45 IPv6) */
nameservers[i].S.NtoA(buf,MAX_IPSTRLEN),
nameservers[i].nqueries,
storeAppendPrintf(sentry, "\nRcode Matrix:\n");
storeAppendPrintf(sentry, "RCODE");
- for (i = 0; i < MAX_ATTEMPT; i++)
+ for (i = 0; i < MAX_ATTEMPT; ++i)
storeAppendPrintf(sentry, " ATTEMPT%d", i + 1);
storeAppendPrintf(sentry, " PROBLEM\n");
- for (j = 0; j < MAX_RCODE; j++) {
+ for (j = 0; j < MAX_RCODE; ++j) {
if (j > 10 && j < 16)
continue; // unassigned by IANA.
storeAppendPrintf(sentry, "%5d", j);
- for (i = 0; i < MAX_ATTEMPT; i++)
+ for (i = 0; i < MAX_ATTEMPT; ++i)
storeAppendPrintf(sentry, " %8d", RcodeMatrix[j][i]);
storeAppendPrintf(sentry, " : %s\n",Rcodes[j]);
if (npc) {
storeAppendPrintf(sentry, "\nSearch list:\n");
- for (i=0; i < npc; i++)
+ for (i=0; i < npc; ++i)
storeAppendPrintf(sentry, "%s\n", searchpath[i].domain);
storeAppendPrintf(sentry, "\n");
x = comm_udp_sendto(DnsSocketA, nameservers[ns].S, q->buf, q->sz);
}
- q->nsends++;
+ ++ q->nsends;
q->sent_t = current_time;
fd_bytes(DnsSocketA, x, FD_WRITE);
}
- nameservers[ns].nqueries++;
+ ++ nameservers[ns].nqueries;
q->queue_t = current_time;
dlinkAdd(q, &q->lru, &lru_list);
q->pending = 1;
{
int i;
- for (i = 0; i < nns; i++) {
+ for (i = 0; i < nns; ++i) {
if (nameservers[i].S != from)
continue;
unsigned short first_id = id;
while (idnsFindQuery(id)) {
- id++;
+ ++id;
if (id == first_id) {
debugs(78, 1, "idnsQueryID: Warning, too many pending DNS requests");
// the altered NS was limiting the whole group.
max_shared_edns = q->edns_seen;
// may be limited by one of the others still
- for (int i = 0; i < nns; i++)
+ for (int i = 0; i < nns; ++i)
max_shared_edns = min(max_shared_edns, nameservers[i].last_seen_edns);
} else {
nameservers[from_ns].last_seen_edns = q->edns_seen;
q->rcode = -n;
debugs(78, 3, "idnsGrokReply: error " << rfc1035ErrorMessage(n) << " (" << q->rcode << ")");
- if (q->rcode == 2 && ++q->attempt < MAX_ATTEMPT) {
+ if (q->rcode == 2 && (++ q->attempt) < MAX_ATTEMPT) {
/*
* RCODE 2 is "Server failure - The name server was
* unable to process this query due to a problem with
strcat(q->name, ".");
strcat(q->name, searchpath[q->domain].domain);
debugs(78, 3, "idnsGrokReply: searchpath used for " << q->name);
- q->domain++;
+ ++ q->domain;
} else {
- q->attempt++;
+ ++ q->attempt;
}
rfc1035MessageDestroy(&message);
ns = idnsFromKnownNameserver(from);
if (ns >= 0) {
- nameservers[ns].nreplies++;
+ ++ nameservers[ns].nreplies;
}
// Before unknown_nameservers check to avoid flooding cache.log on attacks,
if (rcode < MAX_RCODE)
if (attempt < MAX_ATTEMPT)
- RcodeMatrix[rcode][attempt]++;
+ ++ RcodeMatrix[rcode][attempt];
}
/* ====================================================================== */
memDataInit(MEM_IDNS_QUERY, "idns_query", sizeof(idns_query), 0);
memset(RcodeMatrix, '\0', sizeof(RcodeMatrix));
idns_lookup_hash = hash_create((HASHCMP *) strcmp, 103, hash_string);
- init++;
+ ++init;
}
#if WHEN_EDNS_RESPONSES_ARE_PARSED
DnsSocketB = -1;
}
- for (int i = 0; i < nns; i++) {
+ for (int i = 0; i < nns; ++i) {
if (nsvc *vc = nameservers[i].vc) {
if (Comm::IsConnOpen(vc->conn))
vc->conn->close();
q->xact_id.change();
q->query_id = idnsQueryID();
- for (i = 0; i < strlen(name); i++)
+ for (i = 0; i < strlen(name); ++i)
if (name[i] == '.')
- nd++;
+ ++nd;
if (Config.onoff.res_defnames && npc > 0 && name[strlen(name)-1] != '.') {
q->do_searchpath = 1;
case DNS_REQ:
- for (i = 0; i < nns; i++)
+ for (i = 0; i < nns; ++i)
n += nameservers[i].nqueries;
Answer = snmp_var_new_integer(Var->name, Var->name_length,
break;
case DNS_REP:
- for (i = 0; i < nns; i++)
+ for (i = 0; i < nns; ++i)
n += nameservers[i].nreplies;
Answer = snmp_var_new_integer(Var->name, Var->name_length,
continue;
}
printf(" %s", ntoabuf);
- i++;
+ ++i;
aiptr = aiptr->ai_next;
}
if (_SQUID_RES_NSADDR_COUNT == MAXNS) {
fprintf(stderr, "Too many -s options, only %d are allowed\n", MAXNS);
} else {
- _SQUID_RES_NSADDR_COUNT++;
+ ++ _SQUID_RES_NSADDR_COUNT;
memcpy(&_SQUID_RES_NSADDR6_LIST(_SQUID_RES_NSADDR6_COUNT++), &((struct sockaddr_in6*)AI->ai_addr)->sin6_addr, sizeof(struct in6_addr));
}
#else
if (error_text) {
int i;
- for (i = ERR_NONE + 1; i < error_page_count; i++)
+ for (i = ERR_NONE + 1; i < error_page_count; ++i)
safe_free(error_text[i]);
safe_free(error_text);
{
int i;
- for (i = 0; i < error_hard_text_count; i++)
+ for (i = 0; i < error_hard_text_count; ++i)
if (error_hard_text[i].type == type)
return error_hard_text[i].text;
if (!pos) {
/* skip any initial whitespace. */
- while (pos < hdr.size() && xisspace(hdr[pos])) pos++;
+ while (pos < hdr.size() && xisspace(hdr[pos]))
+ ++pos;
} else {
// IFF we terminated the tag on whitespace or ';' we need to skip to the next ',' or end of header.
- while (pos < hdr.size() && hdr[pos] != ',') pos++;
- if (hdr[pos] == ',') pos++;
+ while (pos < hdr.size() && hdr[pos] != ',')
+ ++pos;
+ if (hdr[pos] == ',')
+ ++pos;
}
/*
if (*dt != '-' && *dt != '*' && (*dt < 'a' || *dt > 'z') )
invalid_byte = true;
else
- dt++; // move to next destination byte.
+ ++dt; // move to next destination byte.
}
- pos++;
+ ++pos;
}
*dt++ = '\0'; // nul-terminated the filename content string before system use.
static int
errorPageId(const char *page_name)
{
- for (int i = 0; i < ERR_MAX; i++) {
+ for (int i = 0; i < ERR_MAX; ++i) {
if (strcmp(err_type_str[i], page_name) == 0)
return i;
}
- for (size_t j = 0; j < ErrorDynamicPages.size(); j++) {
+ for (size_t j = 0; j < ErrorDynamicPages.size(); ++j) {
if (strcmp(ErrorDynamicPages.items[j]->page_name, page_name) == 0)
return j + ERR_MAX;
}
anEntry->def = this;
hash_join(cache, anEntry);
dlinkAdd(anEntry, &anEntry->lru, &lru_list);
- cache_entries++;
+ ++cache_entries;
}
void
if (desc)
xstrncpy(F->desc, desc, FD_DESC_SZ);
- Number_FD++;
+ ++Number_FD;
}
void
int i;
fde *F;
- for (i = 0; i < Squid_MaxFD; i++) {
+ for (i = 0; i < Squid_MaxFD; ++i) {
F = &fd_table[i];
if (!F->flags.open)
storeAppendPrintf(dumpEntry, "---- ------ ---- -------- -------- --------------------- ------------------------------\n");
#endif
- for (i = 0; i < Squid_MaxFD; i++) {
+ for (i = 0; i < Squid_MaxFD; ++i) {
fd_table[i].dumpStats(*dumpEntry, i);
}
}
void
fde::noteUse(PconnPool *pool)
{
- pconn.uses++;
+ ++ pconn.uses;
pconn.pool = pool;
}
bitmap[file_number >> LONG_BIT_SHIFT] |= bitmask;
- usedSlots_++;
+ ++usedSlots_;
return file_number;
}
word = suggestion >> LONG_BIT_SHIFT;
- for (unsigned int count = 0; count < nwords; count++) {
+ for (unsigned int count = 0; count < nwords; ++count) {
if (bitmap[word] != ALL_ONES)
break;
word = (word + 1) % nwords;
}
- for (unsigned char bit = 0; bit < BITS_IN_A_LONG; bit++) {
+ for (unsigned char bit = 0; bit < BITS_IN_A_LONG; ++bit) {
suggestion = ((unsigned long) word << LONG_BIT_SHIFT) | bit;
if (!testBit(suggestion)) {
if (!serverConn->getPeer())
serverConn->peerType = HIER_DIRECT;
#endif
- n_tries++;
+ ++n_tries;
request->flags.pinned = 1;
if (pinned_connection->pinnedAuth())
request->flags.auth = 1;
if (openedPconn) {
serverConn = temp;
debugs(17, 3, HERE << "reusing pconn " << serverConnection());
- n_tries++;
+ ++n_tries;
if (!serverConnection()->getPeer())
- origin_tries++;
+ ++origin_tries;
comm_add_close_handler(serverConnection()->fd, fwdServerClosedWrapper, this);
#endif
if (serverConnection()->getPeer() != NULL) {
- serverConnection()->getPeer()->stats.fetches++;
+ ++ serverConnection()->getPeer()->stats.fetches;
request->peer_login = serverConnection()->getPeer()->login;
request->peer_domain = serverConnection()->getPeer()->domain;
httpStart(this);
int j;
storeAppendPrintf(s, "Status");
- for (j = 0; j <= MAX_FWD_STATS_IDX; j++) {
- storeAppendPrintf(s, "\ttry#%d", j + 1);
+ for (j = 1; j < MAX_FWD_STATS_IDX; ++j) {
+ storeAppendPrintf(s, "\ttry#%d", j);
}
storeAppendPrintf(s, "\n");
- for (i = 0; i <= (int) HTTP_INVALID_HEADER; i++) {
+ for (i = 0; i <= (int) HTTP_INVALID_HEADER; ++i) {
if (FwdReplyCodes[0][i] == 0)
continue;
storeAppendPrintf(s, "%3d", i);
- for (j = 0; j <= MAX_FWD_STATS_IDX; j++) {
+ for (j = 0; j <= MAX_FWD_STATS_IDX; ++j) {
storeAppendPrintf(s, "\t%d", FwdReplyCodes[j][i]);
}
if (tries > MAX_FWD_STATS_IDX)
tries = MAX_FWD_STATS_IDX;
- FwdReplyCodes[tries][status]++;
+ ++ FwdReplyCodes[tries][status];
}
/**** PRIVATE NON-MEMBER FUNCTIONS ********************************************/
int k;
hash_remove_link(fqdn_table, (hash_link *) f);
- for (k = 0; k < (int) f->name_count; k++)
+ for (k = 0; k < (int) f->name_count; ++k)
safe_free(f->names[k]);
debugs(35, 5, "fqdncacheRelease: Released FQDN record for '" << hashKeyStr(&f->hash) << "'.");
fqdncacheRelease(f);
- removed++;
+ ++removed;
}
debugs(35, 9, "fqdncache_purgelru: removed " << removed << " entries");
debugs(35, 3, "fqdncacheParse: " << nr << " answers for '" << name << "'");
assert(answers);
- for (k = 0; k < nr; k++) {
+ for (k = 0; k < nr; ++k) {
if (answers[k]._class != RFC1035_CLASS_IN)
continue;
generic_cbdata *c;
addr.NtoA(name,MAX_IPSTRLEN);
debugs(35, 4, "fqdncache_nbgethostbyaddr: Name '" << name << "'.");
- FqdncacheStats.requests++;
+ ++FqdncacheStats.requests;
if (name[0] == '\0') {
debugs(35, 4, "fqdncache_nbgethostbyaddr: Invalid name!");
debugs(35, 4, "fqdncache_nbgethostbyaddr: HIT for '" << name << "'");
if (f->flags.negcached)
- FqdncacheStats.negative_hits++;
+ ++ FqdncacheStats.negative_hits;
else
- FqdncacheStats.hits++;
+ ++ FqdncacheStats.hits;
f->handler = handler;
}
debugs(35, 5, "fqdncache_nbgethostbyaddr: MISS for '" << name << "'");
- FqdncacheStats.misses++;
+ ++ FqdncacheStats.misses;
f = fqdncacheCreateEntry(name);
f->handler = handler;
f->handlerData = cbdataReference(handlerData);
}
addr.NtoA(name,MAX_IPSTRLEN);
- FqdncacheStats.requests++;
+ ++ FqdncacheStats.requests;
f = fqdncache_get(name);
if (NULL == f) {
fqdncacheRelease(f);
f = NULL;
} else if (f->flags.negcached) {
- FqdncacheStats.negative_hits++;
+ ++ FqdncacheStats.negative_hits;
// ignore f->error_message: the caller just checks FQDN cache presence
return NULL;
} else {
- FqdncacheStats.hits++;
+ ++ FqdncacheStats.hits;
f->lastref = squid_curtime;
// ignore f->error_message: the caller just checks FQDN cache presence
return f->names[0];
/* no entry [any more] */
- FqdncacheStats.misses++;
+ ++ FqdncacheStats.misses;
if (flags & FQDN_LOOKUP_IF_MISS) {
fqdncache_nbgethostbyaddr(addr, NULL, NULL);
ttl,
(int) f->name_count);
- for (k = 0; k < (int) f->name_count; k++)
+ for (k = 0; k < (int) f->name_count; ++k)
storeAppendPrintf(sentry, " %s", f->names[k]);
storeAppendPrintf(sentry, "\n");
fqdncache_entry *f = (fqdncache_entry *)data;
int k;
- for (k = 0; k < (int) f->name_count; k++)
+ for (k = 0; k < (int) f->name_count; ++k)
safe_free(f->names[k]);
safe_free(f->hash.key);
while (hostnames) {
fce->names[j] = xstrdup(hostnames->key);
Tolower(fce->names[j]);
- j++;
+ ++j;
hostnames = hostnames->next;
if (j >= FQDN_MAX_NAMES)
{
const char *url = entry->url();
debugs(9, 3, HERE << "'" << url << "'" );
- statCounter.server.all.requests++;
- statCounter.server.ftp.requests++;
+ ++ statCounter.server.all.requests;
+ ++ statCounter.server.ftp.requests;
theSize = -1;
mdtm = -1;
{
int i;
- for (i = 0; i < 12; i++)
+ for (i = 0; i < 12; ++i)
if (!strcasecmp(buf, Month[i]))
return 1;
xfree(xbuf);
/* locate the Month field */
- for (i = 3; i < n_tokens - 2; i++) {
+ for (i = 3; i < n_tokens - 2; ++i) {
char *size = tokens[i - 1];
char *month = tokens[i];
char *day = tokens[i + 1];
copyFrom += strlen(tbuf);
while (strchr(w_space, *copyFrom))
- copyFrom++;
+ ++copyFrom;
} else {
/* XXX assumes a single space between date and filename
* suggested by: Nathan.Bailey@cc.monash.edu.au and
ct += strlen(tokens[2]);
while (xisspace(*ct))
- ct++;
+ ++ct;
if (!*ct)
ct = NULL;
ct = strstr(ct, ",");
if (ct) {
- ct++;
+ ++ct;
}
}
found:
- for (i = 0; i < n_tokens; i++)
+ for (i = 0; i < n_tokens; ++i)
xfree(tokens[i]);
if (!p->name)
html->init();
html->Printf("<tr class=\"entry\"><td colspan=\"5\">%s</td></tr>\n", line);
- for (p = line; *p && xisspace(*p); p++);
+ for (p = line; *p && xisspace(*p); ++p);
if (*p && !xisspace(*p))
flags.listformat_unknown = 1;
debugs(9, 3, HERE << (unsigned long int)len << " bytes to play with");
line = (char *)memAllocate(MEM_4K_BUF);
- end++;
+ ++end;
s = sbuf;
s += strspn(s, crlf);
DelayId delayId = entry->mem_obj->mostBytesAllowed();
delayId.bytesIn(io.size);
#endif
- IOStats.Ftp.reads++;
+ ++ IOStats.Ftp.reads;
- for (j = io.size - 1, bin = 0; j; bin++)
+ for (j = io.size - 1, bin = 0; j; ++bin)
j >>= 1;
- IOStats.Ftp.read_hist[bin]++;
+ ++ IOStats.Ftp.read_hist[bin];
}
if (io.flag != COMM_OK) {
unsigned const char *p;
unsigned char *r;
- for (p = (unsigned const char *)buf, n = 1; *p; n++, p++)
+ for (p = (unsigned const char *)buf, n = 1; *p; ++n, ++p)
if (*p == 255)
- n++;
+ ++n;
ret = (char *)xmalloc(n);
- for (p = (unsigned const char *)buf, r=(unsigned char *)ret; *p; p++) {
+ for (p = (unsigned const char *)buf, r=(unsigned char *)ret; *p; ++p) {
*r++ = *p;
if (*p == 255)
}
debugs(9, 3, HERE << len << " bytes to play with");
- end++;
+ ++end;
s = sbuf;
s += strspn(s, crlf);
debugs(9, 3, HERE);
if (ftpState->flags.pasv_only)
- ftpState->login_att++;
+ ++ ftpState->login_att;
if (code == 220) {
if (ftpState->ctrl.message) {
p = path = xstrdup(ftpState->request->urlpath.termedBuf());
if (*p == '/')
- p++;
+ ++p;
while (*p) {
d = p;
* which means close data + control without self-destructing and re-open from scratch. */
debugs(9, 5, HERE << "scanning: " << ftpState->ctrl.last_reply);
buf = ftpState->ctrl.last_reply;
- while (buf != NULL && *buf != '\0' && *buf != '\n' && *buf != '(') ++buf;
- if (buf != NULL && *buf == '\n') ++buf;
+ while (buf != NULL && *buf != '\0' && *buf != '\n' && *buf != '(')
+ ++buf;
+ if (buf != NULL && *buf == '\n')
+ ++buf;
if (buf == NULL || *buf == '\0') {
/* handle broken server (RFC 2428 says MUST specify supported protocols in 522) */
request[0] = '\0';
if (path && (*path == '/'))
- path++;
+ ++path;
if (!path || !*path) {
*type_id = GOPHER_DIRECTORY;
int left = len - (pos - inbuf);
lpos = (char *)memchr(pos, '\n', left);
if (lpos) {
- lpos++; /* Next line is after \n */
+ ++lpos; /* Next line is after \n */
llen = lpos - pos;
} else {
llen = left;
if (flag == COMM_OK && len > 0) {
AsyncCall::Pointer nil;
commSetConnTimeout(conn, Config.Timeout.read, nil);
- IOStats.Gopher.reads++;
+ ++IOStats.Gopher.reads;
- for (clen = len - 1, bin = 0; clen; bin++)
+ for (clen = len - 1, bin = 0; clen; ++bin)
clen >>= 1;
- IOStats.Gopher.read_hist[bin]++;
+ ++IOStats.Gopher.read_hist[bin];
HttpRequest *req = gopherState->fwd->request;
if (req->hier.bodyBytesRead < 0)
const char *t = strchr(gopherState->request, '?');
if (t != NULL)
- t++; /* skip the ? */
+ ++t; /* skip the ? */
else
t = "";
debugs(10, 3, "gopherStart: " << entry->url() );
- statCounter.server.all.requests++;
+ ++ statCounter.server.all.requests;
- statCounter.server.other.requests++;
+ ++ statCounter.server.other.requests;
/* Parse url. */
gopher_request_parse(fwd->request,
assert(nargs <= HELPER_MAX_ARGS);
- for (k = 0; k < need_new; k++) {
+ for (k = 0; k < need_new; ++k) {
getCurrentTime();
rfd = wfd = -1;
pid = ipcCreate(hlp->ipc_type,
continue;
}
- hlp->childs.n_running++;
- hlp->childs.n_active++;
+ ++ hlp->childs.n_running;
+ ++ hlp->childs.n_active;
CBDATA_INIT_TYPE(helper_server);
srv = cbdataAlloc(helper_server);
srv->hIpc = hIpc;
assert(nargs <= HELPER_MAX_ARGS);
- for (int k = 0; k < need_new; k++) {
+ for (int k = 0; k < need_new; ++k) {
getCurrentTime();
int rfd = -1;
int wfd = -1;
continue;
}
- hlp->childs.n_running++;
- hlp->childs.n_active++;
+ ++ hlp->childs.n_running;
+ ++ hlp->childs.n_active;
CBDATA_INIT_TYPE(helper_stateful_server);
helper_stateful_server *srv = cbdataAlloc(helper_stateful_server);
srv->hIpc = hIpc;
if (!srv->flags.reserved)
return;
- srv->stats.releases++;
+ ++ srv->stats.releases;
srv->flags.reserved = 0;
if (srv->parent->OnEmptyQueue != NULL && srv->data)
}
}
- for (i = 0; i < concurrency; i++) {
+ for (i = 0; i < concurrency; ++i) {
if ((r = srv->requests[i])) {
void *cbdata;
srv->stats.pending--;
- hlp->stats.replies++;
+ ++ hlp->stats.replies;
srv->answer_time = current_time;
i = strtol(msg, &msg, 10);
while (*msg && xisspace(*msg))
- msg++;
+ ++msg;
}
helperReturnBuffer(i, srv, hlp, msg, t);
srv->roffset = 0;
helperStatefulRequestFree(r);
srv->request = NULL;
- hlp->stats.replies++;
+ ++ hlp->stats.replies;
srv->answer_time = current_time;
hlp->stats.avg_svc_time =
Math::intAverage(hlp->stats.avg_svc_time,
{
dlink_node *link = (dlink_node *)memAllocate(MEM_DLINK_NODE);
dlinkAddTail(r, link, &hlp->queue);
- hlp->stats.queue_size++;
+ ++ hlp->stats.queue_size;
/* do this first so idle=N has a chance to grow the child pool before it hits critical. */
if (hlp->childs.needNew() > 0) {
{
dlink_node *link = (dlink_node *)memAllocate(MEM_DLINK_NODE);
dlinkAddTail(r, link, &hlp->queue);
- hlp->stats.queue_size++;
+ ++ hlp->stats.queue_size;
/* do this first so idle=N has a chance to grow the child pool before it hits critical. */
if (hlp->childs.needNew() > 0) {
return;
}
- for (slot = 0; slot < (hlp->childs.concurrency ? hlp->childs.concurrency : 1); slot++) {
+ for (slot = 0; slot < (hlp->childs.concurrency ? hlp->childs.concurrency : 1); ++slot) {
if (!srv->requests[slot]) {
ptr = &srv->requests[slot];
break;
debugs(84, 5, "helperDispatch: Request sent to " << hlp->id_name << " #" << srv->index + 1 << ", " << strlen(r->buf) << " bytes");
- srv->stats.uses++;
- hlp->stats.requests++;
+ ++ srv->stats.uses;
+ ++ hlp->stats.requests;
}
static void
hlp->id_name << " #" << srv->index + 1 << ", " <<
(int) strlen(r->buf) << " bytes");
- srv->stats.uses++;
- hlp->stats.requests++;
+ ++ srv->stats.uses;
+ ++ hlp->stats.requests;
}
debugs(31, 3, "htcpHexdump " << tag);
memset(hex, '\0', 80);
- for (i = 0; i < sz; i++) {
+ for (i = 0; i < sz; ++i) {
k = i % 16;
snprintf(&hex[k * 3], 4, " %02x", (int) *(s + i));
if (comm_udp_sendto(htcpOutgoingConn->fd, to, buf, len) < 0)
debugs(31, 3, HERE << htcpOutgoingConn << " sendto: " << xstrerror());
else
- statCounter.htcp.pkts_sent++;
+ ++statCounter.htcp.pkts_sent;
}
/*
while ((e = storeGetPublicByRequest(request)) != NULL) {
if (e != NULL) {
htcpClrStoreEntry(e);
- released++;
+ ++released;
}
}
debugs(31, 3, "htcpRecv: FD " << fd << ", " << len << " bytes from " << from );
if (len)
- statCounter.htcp.pkts_recv++;
+ ++statCounter.htcp.pkts_recv;
htcpHandleMsg(buf, len, from);
{
if (flags.keepalive)
if (_peer)
- _peer->stats.n_keepalives_sent++;
+ ++ _peer->stats.n_keepalives_sent;
if (reply->keep_alive) {
if (_peer)
- _peer->stats.n_keepalives_recv++;
+ ++ _peer->stats.n_keepalives_recv;
if (Config.onoff.detect_broken_server_pconns
&& reply->bodySize(request->method) == -1 && !flags.chunked) {
kb_incr(&(statCounter.server.all.kbytes_in), len);
kb_incr(&(statCounter.server.http.kbytes_in), len);
- IOStats.Http.reads++;
+ ++ IOStats.Http.reads;
- for (clen = len - 1, bin = 0; clen; bin++)
+ for (clen = len - 1, bin = 0; clen; ++bin)
clen >>= 1;
- IOStats.Http.read_hist[bin]++;
+ ++ IOStats.Http.read_hist[bin];
// update peer response time stats (%<pt)
const timeval &sent = request->hier.peer_http_request_sent;
return;
}
- statCounter.server.all.requests++;
- statCounter.server.http.requests++;
+ ++ statCounter.server.all.requests;
+ ++ statCounter.server.http.requests;
/*
* We used to set the read timeout here, but not any more.
}
Comm::SetSelect(fd, COMM_SELECT_WRITE, icpUdpSendQueue, NULL, 0);
- statCounter.icp.replies_queued++;
+ ++statCounter.icp.replies_queued;
} else {
/* don't queue it */
- statCounter.icp.replies_dropped++;
+ ++statCounter.icp.replies_dropped;
}
return x;
break;
}
- (*N)++;
+ ++(*N);
icpCount(buf, RECV, (size_t) len, 0);
buf[len] = '\0';
debugs(12, 4, "icpHandleUdp: FD " << sock << ": received " <<
return;
if (SENT == which) {
- statCounter.icp.pkts_sent++;
+ ++statCounter.icp.pkts_sent;
kb_incr(&statCounter.icp.kbytes_sent, len);
if (ICP_QUERY == icp->opcode) {
- statCounter.icp.queries_sent++;
+ ++statCounter.icp.queries_sent;
kb_incr(&statCounter.icp.q_kbytes_sent, len);
} else {
- statCounter.icp.replies_sent++;
+ ++statCounter.icp.replies_sent;
kb_incr(&statCounter.icp.r_kbytes_sent, len);
/* this is the sent-reply service time */
statCounter.icp.replySvcTime.count(delay);
}
if (ICP_HIT == icp->opcode)
- statCounter.icp.hits_sent++;
+ ++statCounter.icp.hits_sent;
} else if (RECV == which) {
- statCounter.icp.pkts_recv++;
+ ++statCounter.icp.pkts_recv;
kb_incr(&statCounter.icp.kbytes_recv, len);
if (ICP_QUERY == icp->opcode) {
- statCounter.icp.queries_recv++;
+ ++statCounter.icp.queries_recv;
kb_incr(&statCounter.icp.q_kbytes_recv, len);
} else {
- statCounter.icp.replies_recv++;
+ ++statCounter.icp.replies_recv;
kb_incr(&statCounter.icp.r_kbytes_recv, len);
/* statCounter.icp.querySvcTime set in clientUpdateCounters */
}
if (ICP_HIT == icp->opcode)
- statCounter.icp.hits_recv++;
+ ++statCounter.icp.hits_recv;
}
}
close(t3);
/* Make sure all other filedescriptors are closed */
- for (x = 3; x < SQUID_MAXFD; x++)
+ for (x = 3; x < SQUID_MAXFD; ++x)
close(x);
#if HAVE_SETSID
si.dwFlags = STARTF_USESTDHANDLES;
/* Make sure all other valid handles are not inerithable */
- for (x = 3; x < Squid_MaxFD; x++) {
+ for (x = 3; x < Squid_MaxFD; ++x) {
if ((F = _get_osfhandle(x)) == -1)
continue;
ipcacheRelease(i);
- removed++;
+ ++removed;
}
debugs(14, 9, "ipcache_purgelru: removed " << removed << " entries");
int j, k;
i->addrs.in_addrs = static_cast<Ip::Address *>(xcalloc(ipcount, sizeof(Ip::Address)));
- for (int l = 0; l < ipcount; l++)
+ for (int l = 0; l < ipcount; ++l)
i->addrs.in_addrs[l].SetEmpty(); // perform same init actions as constructor would.
i->addrs.bad_mask = (unsigned char *)xcalloc(ipcount, sizeof(unsigned char));
memset(i->addrs.bad_mask, 0, sizeof(unsigned char) * ipcount);
- for (j = 0, k = 0; k < ipcount; k++) {
+ for (j = 0, k = 0; k < ipcount; ++k) {
if ( i->addrs.in_addrs[j] = A[k] )
- j++;
+ ++j;
else
debugs(14, 1, "ipcacheParse: Invalid IP address '" << A[k] << "' in response to '" << name << "'");
}
debugs(14, 3, "ipcacheParse: " << nr << " answers for '" << name << "'");
assert(answers);
- for (k = 0; k < nr; k++) {
+ for (k = 0; k < nr; ++k) {
if (Ip::EnableIpv6 && answers[k].type == RFC1035_TYPE_AAAA) {
if (answers[k].rdlength != sizeof(struct in6_addr)) {
debugs(14, 1, "ipcacheParse: Invalid IPv6 address in response to '" << name << "'");
continue;
}
- na++;
- IpcacheStats.rr_aaaa++;
+ ++na;
+ ++IpcacheStats.rr_aaaa;
continue;
}
debugs(14, 1, "ipcacheParse: Invalid IPv4 address in response to '" << name << "'");
continue;
}
- na++;
- IpcacheStats.rr_a++;
+ ++na;
+ ++IpcacheStats.rr_a;
continue;
}
/* With A and AAAA, the CNAME does not necessarily come with additional records to use. */
if (answers[k].type == RFC1035_TYPE_CNAME) {
cname_found=1;
- IpcacheStats.rr_cname++;
+ ++IpcacheStats.rr_cname;
continue;
}
debugs(14, 1, "ipcacheParse: No Address records in response to '" << name << "'");
i->error_message = xstrdup("No Address records");
if (cname_found)
- IpcacheStats.cname_only++;
+ ++IpcacheStats.cname_only;
return 0;
}
i->addrs.in_addrs = static_cast<Ip::Address *>(xcalloc(na, sizeof(Ip::Address)));
- for (int l = 0; l < na; l++)
+ for (int l = 0; l < na; ++l)
i->addrs.in_addrs[l].SetEmpty(); // perform same init actions as constructor would.
i->addrs.bad_mask = (unsigned char *)xcalloc(na, sizeof(unsigned char));
- for (j = 0, k = 0; k < nr; k++) {
+ for (j = 0, k = 0; k < nr; ++k) {
if (answers[k].type == RFC1035_TYPE_A) {
if (answers[k].rdlength != sizeof(struct in_addr))
i->addrs.in_addrs[j] = temp;
debugs(14, 3, "ipcacheParse: " << name << " #" << j << " " << i->addrs.in_addrs[j]);
- j++;
+ ++j;
} else if (Ip::EnableIpv6 && answers[k].type == RFC1035_TYPE_AAAA) {
if (answers[k].rdlength != sizeof(struct in6_addr))
i->addrs.in_addrs[j] = temp;
debugs(14, 3, "ipcacheParse: " << name << " #" << j << " " << i->addrs.in_addrs[j] );
- j++;
+ ++j;
}
if (ttl == 0 || (int) answers[k].ttl < ttl)
ttl = answers[k].ttl;
{
ipcache_entry *i;
static_cast<generic_cbdata *>(data)->unwrap(&i);
- IpcacheStats.replies++;
+ ++IpcacheStats.replies;
const int age = i->age();
statCounter.dns.svcTime.count(age);
const ipcache_addrs *addrs = NULL;
generic_cbdata *c;
debugs(14, 4, "ipcache_nbgethostbyname: Name '" << name << "'.");
- IpcacheStats.requests++;
+ ++IpcacheStats.requests;
if (name == NULL || name[0] == '\0') {
debugs(14, 4, "ipcache_nbgethostbyname: Invalid name!");
- IpcacheStats.invalid++;
+ ++IpcacheStats.invalid;
const DnsLookupDetails details("Invalid hostname", -1); // error, no lookup
if (handler)
handler(NULL, details, handlerData);
if ((addrs = ipcacheCheckNumeric(name))) {
debugs(14, 4, "ipcache_nbgethostbyname: BYPASS for '" << name << "' (already numeric)");
- IpcacheStats.numeric_hits++;
+ ++IpcacheStats.numeric_hits;
const DnsLookupDetails details(NULL, -1); // no error, no lookup
if (handler)
handler(addrs, details, handlerData);
debugs(14, 4, "ipcache_nbgethostbyname: HIT for '" << name << "'");
if (i->flags.negcached)
- IpcacheStats.negative_hits++;
+ ++IpcacheStats.negative_hits;
else
- IpcacheStats.hits++;
+ ++IpcacheStats.hits;
i->handler = handler;
}
debugs(14, 5, "ipcache_nbgethostbyname: MISS for '" << name << "'");
- IpcacheStats.misses++;
+ ++IpcacheStats.misses;
i = ipcacheCreateEntry(name);
i->handler = handler;
i->handlerData = cbdataReference(handlerData);
ipcache_addrs *addrs;
assert(name);
debugs(14, 3, "ipcache_gethostbyname: '" << name << "', flags=" << std::hex << flags);
- IpcacheStats.requests++;
+ ++IpcacheStats.requests;
i = ipcache_get(name);
if (NULL == i) {
ipcacheRelease(i);
i = NULL;
} else if (i->flags.negcached) {
- IpcacheStats.negative_hits++;
+ ++IpcacheStats.negative_hits;
// ignore i->error_message: the caller just checks IP cache presence
return NULL;
} else {
- IpcacheStats.hits++;
+ ++IpcacheStats.hits;
i->lastref = squid_curtime;
// ignore i->error_message: the caller just checks IP cache presence
return &i->addrs;
/* no entry [any more] */
if ((addrs = ipcacheCheckNumeric(name))) {
- IpcacheStats.numeric_hits++;
+ ++IpcacheStats.numeric_hits;
return addrs;
}
- IpcacheStats.misses++;
+ ++IpcacheStats.misses;
if (flags & IP_LOOKUP_IF_MISS)
ipcache_nbgethostbyname(name, NULL, NULL);
/** \par
* Cached entries have IPs listed with a BNF of: ip-address '-' ('OK'|'BAD') */
- for (k = 0; k < count; k++) {
+ for (k = 0; k < count; ++k) {
/* Display tidy-up: IPv6 are so big make the list vertical */
if (k == 0)
storeAppendPrintf(sentry, " %45.45s-%3s\n",
ia = &i->addrs;
}
- for (k = 0; k < ia->count; k++) {
+ for (k = 0; k < ia->count; ++k) {
if (++ia->cur == ia->count)
ia->cur = 0;
/* All bad, reset to All good */
debugs(14, 3, "ipcacheCycleAddr: Changing ALL " << name << " addrs from BAD to OK");
- for (k = 0; k < ia->count; k++)
+ for (k = 0; k < ia->count; ++k)
ia->bad_mask[k] = 0;
ia->badcount = 0;
ia = &i->addrs;
- for (k = 0; k < (int) ia->count; k++) {
+ for (k = 0; k < (int) ia->count; ++k) {
if (addr == ia->in_addrs[k] )
break;
}
/** Marks the given address as BAD */
if (!ia->bad_mask[k]) {
ia->bad_mask[k] = TRUE;
- ia->badcount++;
+ ++ia->badcount;
i->expires = min(squid_curtime + max((time_t)60, Config.negativeDnsTtl), i->expires);
debugs(14, 2, "ipcacheMarkBadAddr: " << name << " " << addr );
}
/* All bad, reset to All good */
debugs(14, 3, "ipcacheMarkAllGood: Changing ALL " << name << " addrs to OK (" << ia->badcount << "/" << ia->count << " bad)");
- for (k = 0; k < ia->count; k++)
+ for (k = 0; k < ia->count; ++k)
ia->bad_mask[k] = 0;
ia->badcount = 0;
ia = &i->addrs;
- for (k = 0; k < (int) ia->count; k++) {
+ for (k = 0; k < (int) ia->count; ++k) {
if (addr == ia->in_addrs[k])
break;
}
return NULL;
while (xisspace(*p))
- p++;
+ ++p;
if (strncasecmp(p, name, namelen))
continue;
q += namelen;
- if (*q == ':')
- q++, got = 1;
+ if (*q == ':') {
+ ++q;
+ got = 1;
+ }
- while (xisspace(*q))
- q++, got = 1;
+ while (xisspace(*q)) {
+ ++q;
+ got = 1;
+ }
if (got && prefix) {
/* we could process list entries here if we had strcasestr(). */
break;
}
- e++;
+ ++e;
}
PROF_stop(headersEnd);
return;
}
- for (i = 0; i < (int) ia->count; i++) {
+ for (i = 0; i < (int) ia->count; ++i) {
debugs(7, 9, "Listening for ICP requests on " << ia->in_addrs[i] );
if ( ! ia->in_addrs[i].IsIPv4() ) {
projects / thirdparty / squid.git / commitdiff
