if (!key)
return false;
if (!value) {
- debugs(3, DBG_CRITICAL, "Error while parsing key=value token. Value missing after: " << key);
+ debugs(3, DBG_CRITICAL, "ERROR: Failure while parsing key=value token. Value missing after: " << key);
return false;
}
if (readRequest != NULL) {
const uint32_t lcount = readRequest->unlock();
if (lcount == 0)
- debugs(79, DBG_IMPORTANT, "invariant check failed: readRequest reference count is 0");
+ debugs(79, DBG_IMPORTANT, "ERROR: invariant check failed: readRequest reference count is 0");
}
if (M->status < 0) {
if (writeRequest != NULL) {
const uint32_t lcount = writeRequest->unlock();
if (lcount == 0)
- debugs(79, DBG_IMPORTANT, "invariant check failed: writeRequest reference count is 0");
+ debugs(79, DBG_IMPORTANT, "ERROR: invariant check failed: writeRequest reference count is 0");
}
if (M->status < 0) {
if (++filter >= filter_limit) {
filter_limit += filter;
filter = 0;
- debugs(43, DBG_IMPORTANT, "squidaio_queue_request: WARNING - Queue congestion (growing to " << filter_limit << ")");
+ debugs(43, DBG_IMPORTANT, "WARNING: squidaio_queue_request: Queue congestion (growing to " << filter_limit << ")");
}
}
if (squid_curtime >= (last_warn + 15) &&
squid_curtime >= (high_start + 5)) {
- debugs(43, DBG_IMPORTANT, "squidaio_queue_request: WARNING - Disk I/O overloading");
+ debugs(43, DBG_IMPORTANT, "WARNING: squidaio_queue_request: Disk I/O overloading");
if (squid_curtime >= (high_start + 15))
debugs(43, DBG_IMPORTANT, "squidaio_queue_request: Queue Length: current=" <<
if (++filter >= filter_limit) {
filter_limit += filter;
filter = 0;
- debugs(43, DBG_IMPORTANT, "squidaio_queue_request: WARNING - Queue congestion (growing to " << filter_limit << ")");
+ debugs(43, DBG_IMPORTANT, "WARNING: squidaio_queue_request: Queue congestion (growing to " << filter_limit << ")");
}
}
if (squid_curtime >= (last_warn + 15) &&
squid_curtime >= (high_start + 5)) {
- debugs(43, DBG_IMPORTANT, "squidaio_queue_request: WARNING - Disk I/O overloading");
+ debugs(43, DBG_IMPORTANT, "WARNING: squidaio_queue_request: Disk I/O overloading");
if (squid_curtime >= (high_start + 15))
debugs(43, DBG_IMPORTANT, "squidaio_queue_request: Queue Length: current=" <<
} catch (const Queue::Full &) {
// The worker pop queue should not overflow because the worker can
// push only if pendingRequests() is less than QueueCapacity.
- debugs(47, DBG_IMPORTANT, "BUG: Worker I/O pop queue for " <<
+ debugs(47, DBG_IMPORTANT, "ERROR: Squid BUG: Worker I/O pop queue for " <<
DbName << " overflow: " <<
SipcIo(workerId, ipcIo, KidIdentifier)); // TODO: report queue len
const ssize_t written =
pwrite(fd, aRequest->buf, aRequest->len, aRequest->offset);
if (written < 0) {
- debugs(79, DBG_IMPORTANT, HERE << "error: " << xstrerr(errno));
+ debugs(79, DBG_IMPORTANT, "ERROR: " << xstrerr(errno));
error_ = true;
} else if (static_cast<size_t>(written) != aRequest->len) {
debugs(79, DBG_IMPORTANT, HERE << "problem: " << written << " < " << aRequest->len);
if (error) {
++errcount;
- debugs(1, DBG_CRITICAL, "Select loop Error. Retry " << errcount);
+ debugs(1, DBG_CRITICAL, "ERROR: Select loop Error. Retry " << errcount);
} else
errcount = 0;
FwdState::completed()
{
if (flags.forward_completed) {
- debugs(17, DBG_IMPORTANT, HERE << "FwdState::completed called on a completed request! Bad!");
+ debugs(17, DBG_IMPORTANT, "ERROR: FwdState::completed called on a completed request! Bad!");
return;
}
if (e == nullptr)
continue;
if (!Http::any_valid_header(e->id)) {
- debugs(55, DBG_CRITICAL, "BUG: invalid entry (" << e->id << "). Ignored.");
+ debugs(55, DBG_CRITICAL, "ERROR: Squid BUG: invalid entry (" << e->id << "). Ignored.");
} else {
if (owner <= hoReply)
HttpHeaderStats[owner].fieldTypeDistr.count(e->id);
return nullptr; // reject if we cannot strip
debugs(55, Config.onoff.relaxed_header_parser <= 0 ? 1 : 2,
- "NOTICE: Whitespace after header name in '" << getStringPrefix(field_start, field_end-field_start) << "'");
+ "WARNING: Whitespace after header name in '" << getStringPrefix(field_start, field_end-field_start) << "'");
while (name_len > 0 && xisspace(field_start[name_len - 1]))
--name_len;
++end; // back to space
if (2 != sscanf(ver + 5, "%d.%d", &http_ver.major, &http_ver.minor)) {
- debugs(73, DBG_IMPORTANT, "parseRequestLine: Invalid HTTP identifier.");
+ debugs(73, DBG_IMPORTANT, "ERROR: parseRequestLine: Invalid HTTP identifier.");
return false;
}
} else {
MemObject::storeId() const
{
if (!storeId_.size()) {
- debugs(20, DBG_IMPORTANT, "Bug: Missing MemObject::storeId value");
+ debugs(20, DBG_IMPORTANT, "ERROR: Squid BUG: Missing MemObject::storeId value");
dump();
storeId_ = "[unknown_URI]";
}
CharacterSet::DIGIT + CharacterSet("specials", "-_");
const auto specialIndex = key.findFirstNotOf(allowedSpecials);
if (specialIndex != SBuf::npos) {
- debugs(28, DBG_CRITICAL, "Warning: used special character '" <<
+ debugs(28, DBG_CRITICAL, "WARNING: used special character '" <<
key[specialIndex] << "' within annotation name. " <<
"Future Squid versions will not support this.");
}
else {
assert(method == Note::Value::mhReplace);
if (Note::Pointer oldNote = find(SBuf(k, keyLen)))
- debugs(28, DBG_CRITICAL, "Warning: annotation configuration with key " << k <<
+ debugs(28, DBG_CRITICAL, "WARNING: annotation configuration with key " << k <<
" already exists and will be overwritten");
}
SBuf key(k, keyLen);
{
/* VOID is reserved, and new types have to be added as classes */
if (type <= STORE_META_VOID || type >= STORE_META_END + 10) {
- debugs(20, DBG_CRITICAL, "storeSwapMetaUnpack: bad type (" << type << ")!");
+ debugs(20, DBG_CRITICAL, "ERROR: storeSwapMetaUnpack: bad type (" << type << ")!");
return false;
}
type == STORE_META_KEY_SHA ||
type == STORE_META_HITMETERING ||
type == STORE_META_VALID) {
- debugs(20, DBG_CRITICAL, "Obsolete and unused type (" << type << ") in disk metadata");
+ debugs(20, DBG_CRITICAL, "ERROR: Obsolete and unused type (" << type << ") in disk metadata");
return false;
}
break;
default:
- debugs(20, DBG_CRITICAL, "Attempt to create unknown concrete StoreMeta");
+ debugs(20, DBG_CRITICAL, "ERROR: Attempt to create unknown concrete StoreMeta");
return NULL;
}
while (1) {
Result = NotifyAddrChange(NULL, NULL);
if (Result != NO_ERROR) {
- debugs(1, DBG_IMPORTANT, "NotifyAddrChange error " << Result);
+ debugs(1, DBG_IMPORTANT, "ERROR: NotifyAddrChange error " << Result);
return 1;
}
debugs(1, DBG_IMPORTANT, "Notification of IP address change received, requesting Squid reconfiguration ...");
if (NotifyAddrChange_thread == NULL) {
status = GetLastError();
NotifyAddrChange_thread = INVALID_HANDLE_VALUE;
- debugs(1, DBG_IMPORTANT, "Failed to start IP monitor thread.");
+ debugs(1, DBG_IMPORTANT, "ERROR: Failed to start IP monitor thread.");
} else
debugs(1, 2, "Starting IP monitor thread [" << threadID << "] ...");
}
if (!SetServiceStatus(svcHandle, &svcStatus)) {
status = GetLastError();
- debugs(1, DBG_IMPORTANT, "SetServiceStatus error " << status);
+ debugs(1, DBG_IMPORTANT, "ERROR: SetServiceStatus error " << status);
}
debugs(1, DBG_IMPORTANT, "Leaving Squid service");
if (!SetServiceStatus(svcHandle, &svcStatus)) {
status = GetLastError();
- debugs(1, DBG_IMPORTANT, "SetServiceStatus error " << status);
+ debugs(1, DBG_IMPORTANT, "ERROR: SetServiceStatus error " << status);
}
break;
if (!SetServiceStatus(svcHandle, &svcStatus)) {
status = GetLastError();
- debugs(1, DBG_IMPORTANT, "SetServiceStatus error " << status);
+ debugs(1, DBG_IMPORTANT, "ERROR: SetServiceStatus error " << status);
}
debugs(1, DBG_IMPORTANT, "Leaving Squid service");
/* snarf the ACL name */
if ((t = ConfigParser::NextToken()) == NULL) {
- debugs(28, DBG_CRITICAL, "aclParseAclLine: missing ACL name.");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseAclLine: missing ACL name.");
parser.destruct();
return;
}
const char *theType;
if ((theType = ConfigParser::NextToken()) == NULL) {
- debugs(28, DBG_CRITICAL, "aclParseAclLine: missing ACL type.");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseAclLine: missing ACL type.");
parser.destruct();
return;
}
debugs(28, DBG_CRITICAL, "WARNING: 'myip' ACL is not reliable for interception proxies. Please use 'myportname' instead.");
p = p->next;
}
- debugs(28, DBG_IMPORTANT, "UPGRADE: ACL 'myip' type is has been renamed to 'localip' and matches the IP the client connected to.");
+ debugs(28, DBG_IMPORTANT, "WARNING: UPGRADE: ACL 'myip' type has been renamed to 'localip' and matches the IP the client connected to.");
theType = "localip";
} else if (strcmp(theType, "myport") == 0) {
AnyP::PortCfgPointer p = HttpPortList;
p = p->next;
}
theType = "localport";
- debugs(28, DBG_IMPORTANT, "UPGRADE: ACL 'myport' type is has been renamed to 'localport' and matches the port the client connected to.");
+ debugs(28, DBG_IMPORTANT, "WARNING: UPGRADE: ACL 'myport' type has been renamed to 'localport' and matches the port the client connected to.");
} else if (strcmp(theType, "proto") == 0 && strcmp(aclname, "manager") == 0) {
// ACL manager is now a built-in and has a different type.
- debugs(28, DBG_PARSE_NOTE(DBG_IMPORTANT), "UPGRADE: ACL 'manager' is now a built-in ACL. Remove it from your config file.");
+ debugs(28, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: UPGRADE: ACL 'manager' is now a built-in ACL. Remove it from your config file.");
return; // ignore the line
} else if (strcmp(theType, "clientside_mark") == 0) {
- debugs(28, DBG_IMPORTANT, "UPGRADE: ACL 'clientside_mark' type has been renamed to 'client_connection_mark'.");
+ debugs(28, DBG_IMPORTANT, "WARNING: UPGRADE: ACL 'clientside_mark' type has been renamed to 'client_connection_mark'.");
theType = "client_connection_mark";
}
return;
if (A->empty()) {
- debugs(28, DBG_CRITICAL, "Warning: empty ACL: " << A->cfgline);
+ debugs(28, DBG_CRITICAL, "WARNING: empty ACL: " << A->cfgline);
}
if (!A->valid()) {
debugs(28, 5, "aclParseArpData: " << t);
if (sscanf(t, "%[0-9a-fA-F:]", buf) != 1) {
- debugs(28, DBG_CRITICAL, "aclParseArpData: Bad ethernet address: '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseArpData: Bad ethernet address: '" << t << "'");
delete q;
return NULL;
}
if (!q->decode(buf)) {
debugs(28, DBG_CRITICAL, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(28, DBG_CRITICAL, "aclParseArpData: Ignoring invalid ARP acl entry: can't parse '" << buf << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseArpData: Ignoring invalid ARP acl entry: cannot parse '" << buf << "'");
delete q;
return NULL;
}
delete asState;
return;
} else if (result.flags.error) {
- debugs(53, DBG_IMPORTANT, "asHandleReply: Called with Error set and size=" << (unsigned int) result.length);
+ debugs(53, DBG_IMPORTANT, "ERROR: asHandleReply: Called with Error set and size=" << (unsigned int) result.length);
delete asState;
return;
} else if (e->mem().baseReply().sline.status() != Http::scOkay) {
return 0; // we have warned about the missing request earlier
if (!checklist->request->masterXaction) {
- debugs(28, DBG_IMPORTANT, "BUG: at_step GeneratingCONNECT ACL is missing master transaction info. Assuming mismatch.");
+ debugs(28, DBG_IMPORTANT, "ERROR: Squid BUG: at_step GeneratingCONNECT ACL is missing master transaction info. Assuming mismatch.");
return 0;
}
debugs(28, 5, "aclParseEuiData: " << t);
if (sscanf(t, "%[0-9a-fA-F:]", buf) != 1) {
- debugs(28, DBG_CRITICAL, "aclParseEuiData: Bad EUI-64 address: '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseEuiData: Bad EUI-64 address: '" << t << "'");
delete q;
return NULL;
}
if (!q->decode(buf)) {
debugs(28, DBG_CRITICAL, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(28, DBG_CRITICAL, "aclParseEuiData: Ignoring invalid EUI-64 acl entry: can't parse '" << buf << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseEuiData: Ignoring invalid EUI-64 acl entry: cannot parse '" << buf << "'");
delete q;
return NULL;
}
return;
++count;
- debugs(28, Important(58), "ALE missing " << msg);
+ debugs(28, Important(58), "ERROR: ALE missing " << msg);
}
void
if ((t = ConfigParser::NextToken()) == NULL) {
debugs(28, DBG_CRITICAL, "aclParseDenyInfoLine: " << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(28, DBG_CRITICAL, "aclParseDenyInfoLine: missing 'error page' parameter.");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseDenyInfoLine: missing 'error page' parameter.");
return;
}
if (!t) {
debugs(28, DBG_CRITICAL, "aclParseAccessLine: " << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(28, DBG_CRITICAL, "aclParseAccessLine: missing 'allow' or 'deny'.");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseAccessLine: missing 'allow' or 'deny'.");
return;
}
ACL *a = ACL::FindByName(t);
if (a == NULL) {
- debugs(28, DBG_CRITICAL, "ACL not found: " << t);
+ debugs(28, DBG_CRITICAL, "ERROR: ACL not found: " << t);
self_destruct();
return count; // not reached
}
RangeType temp(port1, port2+1);
ranges.push_back(temp);
} else {
- debugs(28, DBG_CRITICAL, "ACLIntRange::parse: Invalid port value");
+ debugs(28, DBG_CRITICAL, "ERROR: ACLIntRange::parse: Invalid port value");
self_destruct();
}
}
if (strcmp(addr1, "::1") == 0) {
debugs(28, DBG_IMPORTANT, "aclIpParseIpData: IPv6 has not been enabled in host DNS resolver.");
} else {
- debugs(28, DBG_CRITICAL, "aclIpParseIpData: Bad host/IP: '" << addr1 <<
+ debugs(28, DBG_CRITICAL, "ERROR: aclIpParseIpData: Bad host/IP: '" << addr1 <<
"' in '" << t << "', flags=" << hints.ai_flags <<
" : (" << errcode << ") " << gai_strerror(errcode) );
self_destruct();
freeaddrinfo(hp);
if (*Q != NULL) {
- debugs(28, DBG_CRITICAL, "aclIpParseIpData: Bad host/IP: '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclIpParseIpData: Bad host/IP: '" << t << "'");
self_destruct();
return NULL;
}
/* Decode addr1 */
if (!*addr1 || !(q->addr1 = addr1)) {
- debugs(28, DBG_CRITICAL, "aclIpParseIpData: unknown first address in '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclIpParseIpData: unknown first address in '" << t << "'");
delete q;
self_destruct();
return NULL;
if (!*addr2)
q->addr2.setAnyAddr();
else if (!(q->addr2=addr2) ) {
- debugs(28, DBG_CRITICAL, "aclIpParseIpData: unknown second address in '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclIpParseIpData: unknown second address in '" << t << "'");
delete q;
self_destruct();
return NULL;
/* Decode mask (NULL or empty means a exact host mask) */
if (!DecodeMask(mask, q->mask, iptype)) {
- debugs(28, DBG_CRITICAL, "aclParseIpData: unknown netmask '" << mask << "' in '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseIpData: unknown netmask '" << mask << "' in '" << t << "'");
delete q;
self_destruct();
return NULL;
changed += q->addr2.applyMask(q->mask);
if (changed)
- debugs(28, DBG_CRITICAL, "aclIpParseIpData: WARNING: Netmask masks away part of the specified IP in '" << t << "'");
+ debugs(28, DBG_CRITICAL, "WARNING: aclIpParseIpData: Netmask masks away part of the specified IP in '" << t << "'");
debugs(28,9, HERE << "Parsed: " << q->addr1 << "-" << q->addr2 << "/" << q->mask << "(/" << q->mask.cidr() <<")");
char *t = ConfigParser::strtokFile();
if (!t) {
- debugs(28, DBG_PARSE_NOTE(DBG_IMPORTANT), "ACL random missing pattern");
+ debugs(28, DBG_PARSE_NOTE(DBG_IMPORTANT), "ERROR: ACL random missing pattern");
return;
}
default:
debugs(28, DBG_CRITICAL, "" << cfg_filename << " line " << config_lineno <<
": " << config_input_line);
- debugs(28, DBG_CRITICAL, "aclParseTimeSpec: Bad Day '" << *t << "'" );
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseTimeSpec: Bad Day '" << *t << "'" );
break;
}
}
/* assume its time-of-day spec */
if ((sscanf(t, "%d:%d-%d:%d", &h1, &m1, &h2, &m2) < 4) || (!((h1 >= 0 && h1 < 24) && ((h2 >= 0 && h2 < 24) || (h2 == 24 && m2 == 0)) && (m1 >= 0 && m1 < 60) && (m2 >= 0 && m2 < 60)))) {
- debugs(28, DBG_CRITICAL, "aclParseTimeSpec: Bad time range '" << t << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: aclParseTimeSpec: Bad time range '" << t << "'");
self_destruct();
if (q != this)
if (strcmp(option, "0") == 0) { // backward compatibility
name = "bypass";
value = "off";
- debugs(3, DBG_PARSE_NOTE(DBG_IMPORTANT), "UPGRADE: Please use 'bypass=off' option to disable service bypass");
+ debugs(3, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: UPGRADE: Please use 'bypass=off' option to disable service bypass");
} else if (strcmp(option, "1") == 0) { // backward compatibility
name = "bypass";
value = "on";
- debugs(3, DBG_PARSE_NOTE(DBG_IMPORTANT), "UPGRADE: Please use 'bypass=on' option to enable service bypass");
+ debugs(3, DBG_PARSE_NOTE(DBG_IMPORTANT), "WARNING: UPGRADE: Please use 'bypass=on' option to enable service bypass");
} else {
char *eq = strstr(option, "=");
const char *sffx = strstr(option, "://");
Adaptation::ServiceConfig::grokExtension(const char *name, const char *value)
{
// we do not accept extensions by default
- debugs(3, DBG_CRITICAL, cfg_filename << ':' << config_lineno << ": " <<
+ debugs(3, DBG_CRITICAL, "ERROR: " << cfg_filename << ':' << config_lineno << ": " <<
"ERROR: unknown adaptation service option: " <<
name << '=' << value);
return false;
found = (*cfged)->cfg().uri == loaded->second->uri().c_str();
}
if (!found)
- debugs(93, DBG_IMPORTANT, "Warning: loaded eCAP service has no matching " <<
+ debugs(93, DBG_IMPORTANT, "WARNING: loaded eCAP service has no matching " <<
"ecap_service config option: " << loaded->second->uri());
}
}
void Adaptation::Icap::History::stop(const char *context)
{
if (!concurrencyLevel) {
- debugs(93, DBG_IMPORTANT, HERE << "Internal error: poor history accounting " << this);
+ debugs(93, DBG_IMPORTANT, "ERROR: Squid BUG: poor history accounting " << this);
return;
}
if (eventFind(&ServiceRep_noteTimeToUpdate, this))
eventDelete(&ServiceRep_noteTimeToUpdate, this);
else
- debugs(93, DBG_IMPORTANT, "XXX: ICAP service lost an update event.");
+ debugs(93, DBG_IMPORTANT, "ERROR: Squid BUG: ICAP service lost an update event.");
updateScheduled = false;
}
Adaptation::Icap::ServiceRep &s = service();
if (ia == NULL) {
- debugs(44, DBG_IMPORTANT, "ICAP: Unknown service host: " << s.cfg().host);
+ debugs(44, DBG_IMPORTANT, "ERROR: ICAP: Unknown service host: " << s.cfg().host);
#if WHEN_IPCACHE_NBGETHOSTBYNAME_USES_ASYNC_CALLS
dieOnConnectionFailure(); // throws
/* WWW authorization on accelerated requests */
headertype = Http::HdrType::AUTHORIZATION;
} else if (request->flags.intercepted || request->flags.interceptTproxy) {
- debugs(28, DBG_IMPORTANT, "NOTICE: Authentication not applicable on intercepted requests.");
+ debugs(28, DBG_IMPORTANT, "WARNING: Authentication not applicable on intercepted requests.");
return ACCESS_DENIED;
} else {
/* Proxy authorization on proxy requests */
ACLProxyAuth::valid() const
{
if (authenticateSchemeCount() == 0) {
- debugs(28, DBG_CRITICAL, "Can't use proxy auth because no authentication schemes were compiled.");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot use proxy auth because no authentication schemes were compiled.");
return false;
}
if (authenticateActiveSchemeCount() == 0) {
- debugs(28, DBG_CRITICAL, "Can't use proxy auth because no authentication schemes are fully configured.");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot use proxy auth because no authentication schemes are fully configured.");
return false;
}
} else if (strcmp(param_str, "utf8") == 0) {
parse_onoff(&utf8);
} else {
- debugs(29, DBG_CRITICAL, "Unrecognised " << scheme->type() << " auth scheme parameter '" << param_str << "'");
+ debugs(29, DBG_CRITICAL, "ERROR: Unrecognised " << scheme->type() << " auth scheme parameter '" << param_str << "'");
}
}
}
if (last_broken_addr != request->client_addr) {
- debugs(29, DBG_IMPORTANT, "Digest POST bug detected from " <<
+ debugs(29, DBG_IMPORTANT, "ERROR: User agent Digest Authentication POST bug detected from " <<
request->client_addr << " using '" <<
(useragent ? useragent : "-") <<
"'. Please upgrade browser. See Bug #630 for details.");
try { \
code \
} catch (...) { \
- debugs(0, DBG_IMPORTANT, "BUG: ignoring exception;" << \
+ debugs(0, DBG_IMPORTANT, "ERROR: Squid BUG: ignoring exception;" << \
Debug::Extra << "bug location: " << Here() << \
Debug::Extra << "ignored exception: " << CurrentException); \
}
}
} catch (...) {
// fatal for now
- debugs(3, DBG_CRITICAL, "configuration error: " << CurrentException);
+ debugs(3, DBG_CRITICAL, "ERROR: configuration failure: " << CurrentException);
self_destruct();
}
}
if ((t = ConfigParser::NextToken()) == NULL) {
debugs(3, DBG_CRITICAL, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(3, DBG_CRITICAL, "parse_http_header_access: missing header name.");
+ debugs(3, DBG_CRITICAL, "ERROR: parse_http_header_access: missing header name.");
return;
}
if ((t = ConfigParser::NextToken()) == NULL) {
debugs(3, DBG_CRITICAL, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(3, DBG_CRITICAL, "parse_http_header_replace: missing header name.");
+ debugs(3, DBG_CRITICAL, "ERROR: parse_http_header_replace: missing header name.");
return;
}
Auth::Scheme::Pointer theScheme = Auth::Scheme::Find(type_str);
if (theScheme == NULL) {
- debugs(3, DBG_CRITICAL, "Parsing Config File: Unknown authentication scheme '" << type_str << "'.");
+ debugs(3, DBG_CRITICAL, "ERROR: Failure while parsing Config File: Unknown authentication scheme '" << type_str << "'.");
self_destruct();
return;
}
) {
debugs(22, DBG_PARSE_NOTE(2), "UPGRADE: refresh_pattern option '" << token << "' is obsolete. Remove it.");
} else
- debugs(22, DBG_CRITICAL, "refreshAddToList: Unknown option '" << pattern << "': " << token);
+ debugs(22, DBG_CRITICAL, "ERROR: refreshAddToList: Unknown option '" << pattern << "': " << token);
}
if ((errcode = regcomp(&comp, pattern, flags)) != 0) {
char errbuf[256];
regerror(errcode, &comp, errbuf, sizeof errbuf);
debugs(22, DBG_CRITICAL, "" << cfg_filename << " line " << config_lineno << ": " << config_input_line);
- debugs(22, DBG_CRITICAL, "refreshAddToList: Invalid regular expression '" << pattern << "': " << errbuf);
+ debugs(22, DBG_CRITICAL, "ERROR: refreshAddToList: Invalid regular expression '" << pattern << "': " << errbuf);
xfree(pattern);
return;
}
} else if (strncmp(token, "key=", 4) == 0) {
s->secure.parse(token);
} else if (strncmp(token, "version=", 8) == 0) {
- debugs(3, DBG_PARSE_NOTE(1), "UPGRADE WARNING: '" << token << "' is deprecated " <<
+ debugs(3, DBG_PARSE_NOTE(1), "WARNING: UPGRADE: '" << token << "' is deprecated " <<
"in " << cfg_directive << ". Use 'options=' instead.");
s->secure.parse(token);
} else if (strncmp(token, "options=", 8) == 0) {
} else if (strncmp(token, "clientca=", 9) == 0) {
s->secure.parse(token);
} else if (strncmp(token, "cafile=", 7) == 0) {
- debugs(3, DBG_PARSE_NOTE(1), "UPGRADE WARNING: '" << token << "' is deprecated " <<
+ debugs(3, DBG_PARSE_NOTE(1), "WARNING: UPGRADE: '" << token << "' is deprecated " <<
"in " << cfg_directive << ". Use 'tls-cafile=' instead.");
s->secure.parse(token);
} else if (strncmp(token, "capath=", 7) == 0) {
const auto colonPos = basic_cookie.find(':');
if (colonPos == SBuf::npos) {
- debugs(16, DBG_IMPORTANT, "CacheManager::ParseHeaders: unknown basic_cookie format '" << basic_cookie << "'");
+ debugs(16, DBG_IMPORTANT, "ERROR: CacheManager::ParseHeaders: unknown basic_cookie format '" << basic_cookie << "'");
return;
}
debugs(33, 3, HERE << clientConnection);
if (isOpen())
- debugs(33, DBG_IMPORTANT, "BUG: ConnStateData did not close " << clientConnection);
+ debugs(33, DBG_IMPORTANT, "ERROR: Squid BUG: ConnStateData did not close " << clientConnection);
if (!flags.swanSang)
- debugs(33, DBG_IMPORTANT, "BUG: ConnStateData was not destroyed properly; " << clientConnection);
+ debugs(33, DBG_IMPORTANT, "ERROR: Squid BUG: ConnStateData was not destroyed properly; " << clientConnection);
if (bodyPipe != NULL)
stopProducingFor(bodyPipe, false);
static bool reported = false;
if (!reported) {
- debugs(33, DBG_IMPORTANT, "NOTICE: Path MTU discovery disabling is not supported on your platform.");
+ debugs(33, DBG_IMPORTANT, "WARNING: Path MTU discovery disabling is not supported on your platform.");
reported = true;
}
#endif
else if (http->storeEntry()->timestamp > 0)
hdr->putTime(Http::HdrType::DATE, http->storeEntry()->timestamp);
else {
- debugs(88,DBG_IMPORTANT,"BUG 3279: HTTP reply without Date:");
+ debugs(88, DBG_IMPORTANT, "ERROR: Squid BUG #3279: HTTP reply without Date:");
/* dump something useful about the problem */
http->storeEntry()->dump(DBG_IMPORTANT);
}
request->hier.notePeerWrite();
if (io.flag) {
- debugs(11, DBG_IMPORTANT, "sentRequestBody error: FD " << io.fd << ": " << xstrerr(io.xerrno));
+ debugs(11, DBG_IMPORTANT, "ERROR: sentRequestBody failure: FD " << io.fd << ": " << xstrerr(io.xerrno));
ErrorState *err;
err = new ErrorState(ERR_WRITE_ERROR, Http::scBadGateway, fwd->request, fwd->al);
err->xerrno = io.xerrno;
if (io.flag != Comm::OK) {
debugs(50, ignoreErrno(io.xerrno) ? 3 : DBG_IMPORTANT,
- "FTP control reply read error: " << xstrerr(io.xerrno));
+ "ERROR: FTP control reply read failure: " << xstrerr(io.xerrno));
if (ignoreErrno(io.xerrno)) {
scheduleReadControlReply(0);
/* handle broken servers (RFC 2428 says OK code for EPSV MUST be 229 not 200) */
/* vsftpd for one send '200 EPSV ALL ok.' without even port info.
* Its okay to re-send EPSV 1/2 but nothing else. */
- debugs(9, DBG_IMPORTANT, "Broken FTP Server at " << ctrl.conn->remote << ". Wrong accept code for EPSV");
+ debugs(9, DBG_IMPORTANT, "ERROR: Broken FTP Server at " << ctrl.conn->remote << ". Wrong accept code for EPSV");
} else {
debugs(9, 2, "EPSV not supported by remote end");
}
if (buf == NULL || *buf == '\0') {
/* handle broken server (RFC 2428 says MUST specify supported protocols in 522) */
- debugs(9, DBG_IMPORTANT, "Broken FTP Server at " << ctrl.conn->remote << ". 522 error missing protocol negotiation hints");
+ debugs(9, DBG_IMPORTANT, "ERROR: Broken FTP Server at " << ctrl.conn->remote << ". 522 error missing protocol negotiation hints");
return sendPassive();
} else if (strcmp(buf, "(1)") == 0) {
state = SENT_EPSV_2; /* simulate having sent and failed EPSV 2 */
int n = sscanf(buf, "(%c%c%c%hu%c)", &h1, &h2, &h3, &port, &h4);
if (n < 4 || h1 != h2 || h1 != h3 || h1 != h4) {
- debugs(9, DBG_IMPORTANT, "Invalid EPSV reply from " <<
+ debugs(9, DBG_IMPORTANT, "ERROR: Invalid EPSV reply from " <<
ctrl.conn->remote << ": " <<
ctrl.last_reply);
return;
if (io.flag) {
- debugs(9, DBG_IMPORTANT, "FTP command write error: " << io.conn << ": " << xstrerr(io.xerrno));
+ debugs(9, DBG_IMPORTANT, "ERROR: FTP command write failure: " << io.conn << ": " << xstrerr(io.xerrno));
failed(ERR_WRITE_ERROR, io.xerrno);
/* failed closes ctrl.conn and frees ftpState */
return;
if (io.flag != Comm::OK) {
debugs(50, ignoreErrno(io.xerrno) ? 3 : DBG_IMPORTANT,
- "FTP data read error: " << xstrerr(io.xerrno));
+ "ERROR: FTP data read failure: " << xstrerr(io.xerrno));
if (ignoreErrno(io.xerrno)) {
maybeReadVirginBody();
debugs(9, 3, entry->url());
if (Comm::IsConnOpen(ctrl.conn)) {
- debugs(9, DBG_IMPORTANT, "Internal bug: FTP Gateway left open " <<
+ debugs(9, DBG_IMPORTANT, "ERROR: Squid BUG: FTP Gateway left open " <<
"control channel " << ctrl.conn);
}
if (!Comm::IsConnOpen(conn)) {
conn->fd = comm_open_listener(SOCK_STREAM, IPPROTO_TCP, conn->local, conn->flags, note);
if (!Comm::IsConnOpen(conn)) {
- debugs(5, DBG_CRITICAL, HERE << "comm_open_listener failed:" << conn->local << " error: " << errno);
+ debugs(5, DBG_CRITICAL, "ERROR: comm_open_listener failed:" << conn->local << " error: " << errno);
return;
}
debugs(9, 3, HERE << "Unconnected data socket created on " << conn);
// accept if either our data or ctrl connection is talking to this remote peer.
if (data.conn->remote != io.conn->remote && ctrl.conn->remote != io.conn->remote) {
debugs(9, DBG_IMPORTANT,
- "FTP data connection from unexpected server (" <<
+ "ERROR: FTP data connection from unexpected server (" <<
io.conn->remote << "), expecting " <<
data.conn->remote << " or " << ctrl.conn->remote);
debugs(9, 3, "ftpReadStor: accepting data channel");
listenForDataChannel(data.conn);
} else {
- debugs(9, DBG_IMPORTANT, HERE << "Unexpected reply code "<< std::setfill('0') << std::setw(3) << code);
+ debugs(9, DBG_IMPORTANT, "ERROR: Unexpected reply code "<< std::setfill('0') << std::setw(3) << code);
ftpFail(this);
}
}
* not be seeing this condition any more because we'll only
* send REST if we know the theSize and if it is less than theSize.
*/
- debugs(0,DBG_CRITICAL,HERE << "Whoops! " <<
+ debugs(0, DBG_CRITICAL, "ERROR: " <<
" current offset=" << getCurrentOffset() <<
", but theSize=" << theSize <<
". assuming full content response");
/* doneWithServer() only checks BOTH channels are closed. */
if (!Comm::IsConnOpen(ctrl.conn)) {
- debugs(9, DBG_IMPORTANT, "WARNING! FTP Server Control channel is closed, but Data channel still active.");
+ debugs(9, DBG_IMPORTANT, "WARNING: FTP Server Control channel is closed, but Data channel still active.");
debugs(9, 2, caller_name << ": attempted on a closed FTP channel.");
return false;
}
if (getsockname(fd, addr->ai_addr, &(addr->ai_addrlen)) ) {
int xerrno = errno;
- debugs(50, DBG_IMPORTANT, MYNAME << "Failed to retrieve TCP/UDP port number for socket: FD " << fd << ": " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: " << MYNAME << "Failed to retrieve TCP/UDP port number for socket: FD " << fd << ": " << xstrerr(xerrno));
Ip::Address::FreeAddr(addr);
return 0;
}
return Comm::OK;
}
int xerrno = errno;
- debugs(50, DBG_CRITICAL, MYNAME << "Cannot bind socket FD " << s << " to " << fd_table[s].local_addr << ": " << xstrerr(xerrno));
+ debugs(50, DBG_CRITICAL, "ERROR: " << MYNAME << "Cannot bind socket FD " << s << " to " << fd_table[s].local_addr << ": " << xstrerr(xerrno));
return Comm::COMM_ERROR;
}
if ( !(flags & COMM_DOBIND) && addr.isAnyAddr() )
debugs(5, DBG_IMPORTANT,"WARNING: Squid is attempting to bind() port " << addr << " without being a listener.");
if ( addr.isNoAddr() )
- debugs(5,0,"CRITICAL: Squid is attempting to bind() port " << addr << "!!");
+ debugs(5, DBG_CRITICAL, "ERROR: Squid is attempting to bind() port " << addr << "!!");
#if defined(SO_REUSEPORT)
if (flags & COMM_REUSEPORT) {
/* The following fails because ipc.c is doing calls to pipe() to create sockets! */
if (!isOpen(fd)) {
- debugs(50, DBG_IMPORTANT, HERE << "BUG 3556: FD " << fd << " is not an open socket.");
+ debugs(50, DBG_IMPORTANT, "ERROR: Squid BUG #3556: FD " << fd << " is not an open socket.");
// XXX: do we need to run close(fd) or fd_close(fd) here?
return;
}
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
int xerrno = errno;
- debugs(50, DBG_CRITICAL, MYNAME << "FD " << fd << ": set close-on-exec failed: " << xstrerr(xerrno));
+ debugs(50, DBG_CRITICAL, "ERROR: " << MYNAME << "FD " << fd << ": set close-on-exec failed: " << xstrerr(xerrno));
}
fd_table[fd].flags.close_on_exec = true;
/* handle errors */
if (do_poll.dp_fds[i].revents & (POLLERR | POLLHUP | POLLNVAL)) {
- debugs(
- 5,
- DEBUG_DEVPOLL ? 0 : 8,
- HERE << "devpoll event error: fd " << fd
+ debugs(5, DEBUG_DEVPOLL ? 0 : 8,
+ "ERROR: devpoll event failure: fd " << fd
);
continue;
}
if (epoll_ctl(kdpfd, epoll_ctl_type, fd, &ev) < 0) {
int xerrno = errno;
- debugs(5, DEBUG_EPOLL ? 0 : 8, "epoll_ctl(," << epolltype_atoi(epoll_ctl_type) <<
+ debugs(5, DEBUG_EPOLL ? 0 : 8, "ERROR: epoll_ctl(," << epolltype_atoi(epoll_ctl_type) <<
",,): failed on FD " << fd << ": " << xstrerr(xerrno));
}
}
return true;
if (last_warn + 15 < squid_curtime) {
- debugs(5, DBG_CRITICAL, "WARNING! Your cache is running out of filedescriptors");
+ debugs(5, DBG_CRITICAL, "WARNING: Your cache is running out of filedescriptors");
last_warn = squid_curtime;
}
errno = 0;
if (rename(from, to) == -1) {
const auto saved_errno = errno;
- debugs(0, DBG_IMPORTANT, "log rotation failed: " << xstrerr(saved_errno));
+ debugs(0, DBG_IMPORTANT, "ERROR: log rotation failed: " << xstrerr(saved_errno));
}
}
errno = 0;
if (remove(to) == -1) {
const auto saved_errno = errno;
- debugs(0, DBG_IMPORTANT, "removal of log file " << to << " failed: " << xstrerr(saved_errno));
+ debugs(0, DBG_IMPORTANT, "ERROR: removal of log file " << to << " failed: " << xstrerr(saved_errno));
}
TheLog.clear(); // Windows cannot rename() open files
#endif
errno = 0;
if (rename(from, to) == -1) {
const auto saved_errno = errno;
- debugs(0, DBG_IMPORTANT, "renaming file " << from << " to "
+ debugs(0, DBG_IMPORTANT, "ERROR: renaming file " << from << " to "
<< to << "failed: " << xstrerr(saved_errno));
}
}
void
xassert(const char *msg, const char *file, int line)
{
- debugs(0, DBG_CRITICAL, "assertion failed: " << file << ":" << line << ": \"" << msg << "\"");
+ debugs(0, DBG_CRITICAL, "FATAL: assertion failed: " << file << ":" << line << ": \"" << msg << "\"");
if (!shutting_down)
abort();
break;
default:
- debugs(78, DBG_IMPORTANT, "Failed to read nameserver from Registry: Unknown System Type.");
+ debugs(78, DBG_IMPORTANT, "ERROR: Failed to read nameserver from Registry: Unknown System Type.");
}
return result;
char buf[MAX_IPSTRLEN] = "";
if (vc->ns < nameservers.size())
nameservers[vc->ns].S.toStr(buf,MAX_IPSTRLEN);
- debugs(78, DBG_IMPORTANT, HERE << "Failed to connect to nameserver " << buf << " using TCP.");
+ debugs(78, DBG_IMPORTANT, "ERROR: Failed to connect to nameserver " << buf << " using TCP.");
return;
}
if (!vc) {
char buf[MAX_IPSTRLEN];
- debugs(78, DBG_IMPORTANT, "idnsSendQuery: Failed to initiate TCP connection to nameserver " << nameservers[nsn].S.toStr(buf,MAX_IPSTRLEN) << "!");
+ debugs(78, DBG_IMPORTANT, "ERROR: idnsSendQuery: Failed to initiate TCP connection to nameserver " << nameservers[nsn].S.toStr(buf,MAX_IPSTRLEN) << "!");
return;
}
++id;
if (id == first_id) {
- debugs(78, DBG_IMPORTANT, "idnsQueryID: Warning, too many pending DNS requests");
+ debugs(78, DBG_IMPORTANT, "WARNING: idnsQueryID: too many pending DNS requests");
break;
}
}
int n = rfc1035MessageUnpack(buf, sz, &message);
if (message == NULL) {
- debugs(78, DBG_IMPORTANT, "idnsGrokReply: Malformed DNS response");
+ debugs(78, DBG_IMPORTANT, "ERROR: idnsGrokReply: Malformed DNS response");
return;
}
#endif
if (!nsFound) {
- debugs(78, DBG_IMPORTANT, "Warning: Could not find any nameservers. Trying to use localhost");
+ debugs(78, DBG_IMPORTANT, "WARNING: Could not find any nameservers. Trying to use localhost");
#if _SQUID_WINDOWS_
debugs(78, DBG_IMPORTANT, "Please check your TCP-IP settings or /etc/resolv.conf file");
#else
/** test error_default_language location */
if (!loaded() && Config.errorDefaultLanguage) {
if (!tryLoadTemplate(Config.errorDefaultLanguage)) {
- debugs(1, (templateCode < TCP_RESET ? DBG_CRITICAL : 3), "Unable to load default error language files. Reset to backups.");
+ debugs(1, (templateCode < TCP_RESET ? DBG_CRITICAL : 3), "ERROR: Unable to load default error language files. Reset to backups.");
}
}
#endif
if (!tempParser->parse("<div>", 5,0) ||
!tempParser->parse(s + 3, strlen(s) - 3, 0) ||
!tempParser->parse("</div>",6,1)) {
- debugs(86, DBG_CRITICAL, "ESIContext::parserComment: Parsing fragment '" << s + 3 << "' failed.");
+ debugs(86, DBG_CRITICAL, "ERROR: ESIContext::parserComment: Parsing fragment '" << s + 3 << "' failed.");
setError();
char tempstr[1024];
snprintf(tempstr, 1023, "ESIContext::parserComment: Parse error at line %ld:\n%s\n",
break;
case ESI_PROCESS_FAILED:
- debugs(86, DBG_CRITICAL, "esiProcess: tree Processed FAILED");
+ debugs(86, DBG_CRITICAL, "ERROR: esiProcess: tree Processed FAILED");
setError();
setErrorMessage("esiProcess: ESI template Processing failed.");
if (dynamic_cast<esiAttempt*>(element.getRaw())) {
if (attempt.getRaw()) {
- debugs(86, DBG_IMPORTANT, "esiTryAdd: Failed for " << this << " - try already has an attempt node (section 3.4)");
+ debugs(86, DBG_IMPORTANT, "ERROR: esiTryAdd: Failed for " << this << " - try already has an attempt node (section 3.4)");
return false;
}
if (dynamic_cast<esiExcept*>(element.getRaw())) {
if (except.getRaw()) {
- debugs(86, DBG_IMPORTANT, "esiTryAdd: Failed for " << this << " - try already has an except node (section 3.4)");
+ debugs(86, DBG_IMPORTANT, "ERROR: esiTryAdd: Failed for " << this << " - try already has an except node (section 3.4)");
return false;
}
return true;
}
- debugs(86, DBG_IMPORTANT, "esiTryAdd: Failed to add element " << element.getRaw() << " to try " << this << ", incorrect element type (see section 3.4)");
+ debugs(86, DBG_IMPORTANT, "ERROR: esiTryAdd: Failed to add element " << element.getRaw() << " to try " << this << ", incorrect element type (see section 3.4)");
return false;
}
esiProcessResult_t rv = ESI_PROCESS_PENDING_MAYFAIL;
if (!attempt.getRaw()) {
- debugs(86, DBG_CRITICAL, "esiTryProcess: Try has no attempt element - ESI template is invalid (section 3.4)");
+ debugs(86, DBG_CRITICAL, "ERROR: esiTryProcess: Try has no attempt element - ESI template is invalid (section 3.4)");
return ESI_PROCESS_FAILED;
}
if (!except.getRaw()) {
- debugs(86, DBG_CRITICAL, "esiTryProcess: Try has no except element - ESI template is invalid (section 3.4)");
+ debugs(86, DBG_CRITICAL, "ERROR: esiTryProcess: Try has no except element - ESI template is invalid (section 3.4)");
return ESI_PROCESS_FAILED;
}
/* Some elements require specific parents */
if (!(dynamic_cast<esiWhen*>(element.getRaw()) || dynamic_cast<esiOtherwise*>(element.getRaw()))) {
- debugs(86, DBG_CRITICAL, "esiChooseAdd: invalid child node for esi:choose (section 3.3)");
+ debugs(86, DBG_CRITICAL, "ERROR: esiChooseAdd: invalid child node for esi:choose (section 3.3)");
return false;
}
if (s == end || errno) {
/* Couldn't convert to float */
- debugs(86, DBG_IMPORTANT, "failed to convert '" << s << "' to float ");
+ debugs(86, DBG_IMPORTANT, "ERROR: failed to convert '" << s << "' to float ");
*endptr = origs;
} else {
debugs(86,6, "found " << rv.value.floating << " of length " << end - s);
if (s == end || errno) {
/* Couldn't convert to int */
- debugs(86, DBG_IMPORTANT, "failed to convert '" << s << "' to int ");
+ debugs(86, DBG_IMPORTANT, "ERROR: failed to convert '" << s << "' to int ");
*endptr = origs;
} else {
debugs(86,6, "found " << rv.value.integral << " of length " << end - s);
++t;
if (!*t) {
- debugs(86, DBG_IMPORTANT, "missing end \' in '" << s << "'");
+ debugs(86, DBG_IMPORTANT, "ERROR: missing end \' in '" << s << "'");
*endptr = origs;
} else {
*endptr = t + 1;
rv.precedence = 5;
rv.eval = evalequals;
} else {
- debugs(86, DBG_IMPORTANT, "invalid expr '" << s << "'");
+ debugs(86, DBG_IMPORTANT, "ERROR: invalid expr '" << s << "'");
*endptr = origs;
}
} else if ('<' == *s) {
rv.precedence = 1;
rv.eval = evalexpr;
} else {
- debugs(86, DBG_IMPORTANT, "invalid expr '" << s << "'");
+ debugs(86, DBG_IMPORTANT, "ERROR: invalid expr '" << s << "'");
*endptr = origs;
}
/* cleanup candidate and stack */
dumpstack(stack, *stackdepth);
cleanmember(candidate);
- debugs(86, DBG_IMPORTANT, "invalid expression");
+ debugs(86, DBG_IMPORTANT, "ERROR: invalid expression");
return 0;
}
} else {
s = end;
} else {
assert (s == end);
- debugs(86, DBG_IMPORTANT, "failed parsing expression");
+ debugs(86, DBG_IMPORTANT, "ERROR: failed parsing expression");
return 0;
}
}
if (stack[stackdepth - 2].
eval(stack, &stackdepth, stackdepth - 2, &rv)) {
/* special case - leading operator failed */
- debugs(86, DBG_IMPORTANT, "invalid expression");
+ debugs(86, DBG_IMPORTANT, "ERROR: invalid expression");
return 0;
}
}
return;
case STREAM_FAILED:
- debugs(86, DBG_IMPORTANT, "ESI subrequest failed transfer");
+ debugs(86, DBG_IMPORTANT, "ERROR: ESI subrequest failed transfer");
esiStream->include->includeFail (esiStream);
esiStream->finished = 1;
httpRequestFree (http);
debugs(86, 5, "ESIIncludeStart: Starting subrequest with url '" << tempUrl << "'");
const MasterXaction::Pointer mx = new MasterXaction(XactionInitiator::initEsi);
if (clientBeginRequest(Http::METHOD_GET, tempUrl, esiBufferRecipient, esiBufferDetach, stream.getRaw(), &tempheaders, stream->localbuffer->buf, HTTP_REQBUF_SZ, mx)) {
- debugs(86, DBG_CRITICAL, "starting new ESI subrequest failed");
+ debugs(86, DBG_CRITICAL, "ERROR: starting new ESI subrequest failed");
}
tempheaders.clean();
flags.onerrorcontinue = 1;
} else {
/* ignore mistyped attributes */
- debugs(86, DBG_IMPORTANT, "invalid value for onerror='" << attr[i+1] << "'");
+ debugs(86, DBG_IMPORTANT, "ERROR: invalid value for onerror='" << attr[i+1] << "'");
}
} else {
/* ignore mistyped attributes. TODO:? error on these for user feedback - config parameter needed
* 'this.finish' while the subrequest is still not completed.
*/
if (parent.getRaw() == NULL) {
- debugs (86, 0, "ESIInclude::subRequestDone: Sub request completed "
+ debugs(86, DBG_CRITICAL, "ERROR: Squid Bug #951: ESIInclude::subRequestDone: Sub request completed "
"after finish() called and parent unlinked. Unable to "
"continue handling the request, and may be memory leaking. "
"See http://www.squid-cache.org/bugs/show_bug.cgi?id=951 - we "
int a1 = 0, a2 = 0, a3 = 0, a4 = 0, a5 = 0, a6 = 0;
if (sscanf(asc, "%x:%x:%x:%x:%x:%x", &a1, &a2, &a3, &a4, &a5, &a6) != 6) {
- debugs(28, DBG_CRITICAL, "Decode EUI-48: Invalid ethernet address '" << asc << "'");
+ debugs(28, DBG_CRITICAL, "ERROR: Decode EUI-48: Invalid ethernet address '" << asc << "'");
clear();
return false; /* This is not valid address */
}
int tmpSocket = socket(AF_INET,SOCK_STREAM,0);
if (tmpSocket < 0) {
int xerrno = errno;
- debugs(28, DBG_IMPORTANT, "Attempt to open socket for EUI retrieval failed: " << xstrerr(xerrno));
+ debugs(28, DBG_IMPORTANT, "ERROR: Attempt to open socket for EUI retrieval failed: " << xstrerr(xerrno));
clear();
return false;
}
if (ioctl(tmpSocket, SIOCGIFCONF, &ifc) < 0) {
int xerrno = errno;
- debugs(28, DBG_IMPORTANT, "Attempt to retrieve interface list failed: " << xstrerr(xerrno));
+ debugs(28, DBG_IMPORTANT, "ERROR: Attempt to retrieve interface list failed: " << xstrerr(xerrno));
clear();
close(tmpSocket);
return false;
int xerrno = errno;
// Query failed. Do not log failed lookups or "device not supported"
if (ENXIO != xerrno && ENODEV != xerrno)
- debugs(28, DBG_IMPORTANT, "ARP query " << ipAddr << " failed: " << ifr->ifr_name << ": " << xstrerr(xerrno));
+ debugs(28, DBG_IMPORTANT, "ERROR: ARP query " << ipAddr << " failed: " << ifr->ifr_name << ": " << xstrerr(xerrno));
continue;
}
int tmpSocket = socket(AF_INET,SOCK_STREAM,0);
if (tmpSocket < 0) {
int xerrno = errno;
- debugs(28, DBG_IMPORTANT, "Attempt to open socket for EUI retrieval failed: " << xstrerr(xerrno));
+ debugs(28, DBG_IMPORTANT, "ERROR: Attempt to open socket for EUI retrieval failed: " << xstrerr(xerrno));
clear();
return false;
}
#endif
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
- debugs(28, DBG_CRITICAL, "Can't estimate ARP table size!");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot estimate ARP table size!");
clear();
return false;
}
if ((buf = (char *)xmalloc(needed)) == NULL) {
- debugs(28, DBG_CRITICAL, "Can't allocate temporary ARP table!");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot allocate temporary ARP table!");
clear();
return false;
}
if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
- debugs(28, DBG_CRITICAL, "Can't retrieve ARP table!");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot retrieve ARP table!");
xfree(buf);
clear();
return false;
/* Get size of Windows ARP table */
if (GetIpNetTable(NetTable, &ipNetTableLen, FALSE) != ERROR_INSUFFICIENT_BUFFER) {
- debugs(28, DBG_CRITICAL, "Can't estimate ARP table size!");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot estimate ARP table size!");
clear();
return false;
}
/* Allocate space for ARP table and assign pointers */
if ((NetTable = (PMIB_IPNETTABLE)xmalloc(ipNetTableLen)) == NULL) {
- debugs(28, DBG_CRITICAL, "Can't allocate temporary ARP table!");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot allocate temporary ARP table!");
clear();
return false;
}
/* Get actual ARP table */
if ((dwNetTable = GetIpNetTable(NetTable, &ipNetTableLen, FALSE)) != NO_ERROR) {
- debugs(28, DBG_CRITICAL, "Can't retrieve ARP table!");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot retrieve ARP table!");
xfree(NetTable);
clear();
return false;
#if USE_AUTH
if (data->def->require_auth) {
if (authenticateSchemeCount() == 0) {
- debugs(28, DBG_CRITICAL, "Can't use proxy auth because no authentication schemes were compiled.");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot use proxy auth because no authentication schemes were compiled.");
return false;
}
if (authenticateActiveSchemeCount() == 0) {
- debugs(28, DBG_CRITICAL, "Can't use proxy auth because no authentication schemes are fully configured.");
+ debugs(28, DBG_CRITICAL, "ERROR: Cannot use proxy auth because no authentication schemes are fully configured.");
return false;
}
}
if (tokenArray)
tokens.emplace_back(TokenNamespace(nsName, tokenArray));
else
- debugs(0, DBG_CRITICAL, "BUG: format tokens for '" << nsName << "' missing!");
+ debugs(0, DBG_CRITICAL, "ERROR: Squid BUG: format tokens for '" << nsName << "' missing!");
}
void
Rock::SwapDir::diskFull()
{
- debugs(20, DBG_IMPORTANT, "BUG: No space left with rock cache_dir: " <<
+ debugs(20, DBG_IMPORTANT, "ERROR: Squid BUG: No space left with rock cache_dir: " <<
filePath);
}
if (!td) {
int xerrno = errno;
- debugs(47, DBG_IMPORTANT, MYNAME << "error in opendir (" << fullpath << "): " << xstrerr(xerrno));
+ debugs(47, DBG_IMPORTANT, "ERROR: " << MYNAME << "in opendir (" << fullpath << "): " << xstrerr(xerrno));
} else {
entry = readdir(td); /* skip . and .. */
entry = readdir(td);
if (fd < 0) {
int xerrno = errno;
- debugs(47, DBG_IMPORTANT, MYNAME << "error opening " << fullfilename << ": " << xstrerr(xerrno));
+ debugs(47, DBG_IMPORTANT, "ERROR: " << MYNAME << "opening " << fullfilename << ": " << xstrerr(xerrno));
} else
++store_open_disk_fd;
std::setfill('0') << std::hex << std::uppercase << std::setw(8) << swap_filen);
if (theFile->error()) {
- debugs(79, DBG_IMPORTANT,HERE << "avoid write on theFile with error");
+ debugs(79, DBG_IMPORTANT, "ERROR: avoid write on theFile with error");
debugs(79, DBG_IMPORTANT,HERE << "calling free_func for " << (void*) buf);
free_func((void*)buf);
return false;
auto &q = pending_writes.front();
if (theFile->error()) {
- debugs(79, DBG_IMPORTANT, MYNAME << " avoid write on theFile with error");
+ debugs(79, DBG_IMPORTANT, "ERROR: " << MYNAME << "avoid write on theFile with error");
pending_writes.pop();
return;
}
if (swaplog_fd < 0) {
int xerrno = errno;
- debugs(50, DBG_IMPORTANT, "ERROR opening swap log " << logPath << ": " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: opening swap log " << logPath << ": " << xstrerr(xerrno));
fatal("UFSSwapDir::openLog: Failed to open swap log.");
}
if (fseek(fp, header.record_size, SEEK_SET) != 0)
return NULL;
- debugs(47, DBG_IMPORTANT, "Rejecting swap file v1 to avoid cache " <<
+ debugs(47, DBG_IMPORTANT, "ERROR: Rejecting swap file v1 to avoid cache " <<
"index corruption. Forcing a full cache index rebuild. " <<
"See Squid bug #3441.");
return NULL;
// TODO: v3: write to disk in network-order bytes for the larger fields?
- debugs(47, DBG_IMPORTANT, "Unknown swap file version: " << header.version);
+ debugs(47, DBG_IMPORTANT, "ERROR: Unknown swap file version: " << header.version);
return NULL;
}
errno = 0;
if (lseek(fd, fdd->write_q->file_offset, SEEK_SET) == -1) {
int xerrno = errno;
- debugs(50, DBG_IMPORTANT, "error in seek for FD " << fd << ": " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: in seek for FD " << fd << ": " << xstrerr(xerrno));
// XXX: handle error?
}
}
if (!ignoreErrno(errno)) {
status = errno == ENOSPC ? DISK_NO_SPACE_LEFT : DISK_ERROR;
int xerrno = errno;
- debugs(50, DBG_IMPORTANT, "diskHandleWrite: FD " << fd << ": disk write error: " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: diskHandleWrite: FD " << fd << ": disk write failure: " << xstrerr(xerrno));
/*
* If there is no write callback, then this file is
if (lseek(fd, ctrl_dat->offset, SEEK_SET) == -1) {
xerrno = errno;
// shouldn't happen, let's detect that
- debugs(50, DBG_IMPORTANT, "error in seek for FD " << fd << ": " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: in seek for FD " << fd << ": " << xstrerr(xerrno));
// XXX handle failures?
}
++ statCounter.syscalls.disk.seeks;
if (unlink(s) < 0 && !quiet) {
int xerrno = errno;
- debugs(50, DBG_IMPORTANT, "safeunlink: Couldn't delete " << s << ": " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: safeunlink: Could not delete " << s << ": " << xstrerr(xerrno));
}
}
return true;
int xerrno = errno;
- debugs(21, (errno == ENOENT ? 2 : DBG_IMPORTANT), "Cannot rename " << from << " to " << to << ": " << xstrerr(xerrno));
+ debugs(21, (errno == ENOENT ? 2 : DBG_IMPORTANT), "ERROR: Cannot rename " << from << " to " << to << ": " << xstrerr(xerrno));
return false;
}
}
if (flag != Comm::OK) {
- debugs(50, DBG_IMPORTANT, MYNAME << "error reading: " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: " << MYNAME << "reading: " << xstrerr(xerrno));
if (ignoreErrno(xerrno)) {
AsyncCall::Pointer call = commCbCall(5,4, "gopherReadReply",
if (!srv->stats.pending && !srv->stats.timedout) {
/* someone spoke without being spoken to */
- debugs(84, DBG_IMPORTANT, "helperHandleRead: unexpected read from " <<
+ debugs(84, DBG_IMPORTANT, "ERROR: helperHandleRead: unexpected read from " <<
hlp->id_name << " #" << srv->index << ", " << (int)len <<
" bytes '" << srv->rbuf << "'");
if (srv->stats.timedout) {
debugs(84, 3, "Timedout reply received for request-ID: " << i << " , ignore");
} else {
- debugs(84, DBG_IMPORTANT, "helperHandleRead: unexpected reply on channel " <<
+ debugs(84, DBG_IMPORTANT, "ERROR: helperHandleRead: unexpected reply on channel " <<
i << " from " << hlp->id_name << " #" << srv->index <<
" '" << srv->rbuf << "'");
}
if (r == NULL) {
/* someone spoke without being spoken to */
- debugs(84, DBG_IMPORTANT, "helperStatefulHandleRead: unexpected read from " <<
+ debugs(84, DBG_IMPORTANT, "ERROR: helperStatefulHandleRead: unexpected read from " <<
hlp->id_name << " #" << srv->index << ", " << (int)len <<
" bytes '" << srv->rbuf << "'");
const uint64_t reqId = ++srv->nextRequestId;
if (!cbdataReferenceValid(r->request.data)) {
- debugs(84, DBG_IMPORTANT, "helperDispatch: invalid callback data");
+ debugs(84, DBG_IMPORTANT, "ERROR: helperDispatch: invalid callback data");
delete r;
return;
}
statefulhelper *hlp = srv->parent;
if (!cbdataReferenceValid(r->request.data)) {
- debugs(84, DBG_IMPORTANT, "helperStatefulDispatch: invalid callback data");
+ debugs(84, DBG_IMPORTANT, "ERROR: helperStatefulDispatch: invalid callback data");
delete r;
hlp->cancelReservation(srv->reservationId);
return;
} else if (strncmp(token, "idle=", 5) == 0) {
n_idle = xatoui(token + 5);
if (n_idle < 1) {
- debugs(0, DBG_CRITICAL, "WARNING OVERRIDE: Using idle=0 for helpers causes request failures. Overriding to use idle=1 instead.");
+ debugs(0, DBG_CRITICAL, "WARNING: OVERRIDE: Using idle=0 for helpers causes request failures. Overriding to use idle=1 instead.");
n_idle = 1;
}
} else if (strncmp(token, "concurrency=", 12) == 0) {
/* simple sanity. */
if (n_startup > n_max) {
- debugs(0, DBG_CRITICAL, "WARNING OVERRIDE: Capping startup=" << n_startup << " to the defined maximum (" << n_max <<")");
+ debugs(0, DBG_CRITICAL, "WARNING: OVERRIDE: Capping startup=" << n_startup << " to the defined maximum (" << n_max <<")");
n_startup = n_max;
}
if (n_idle > n_max) {
- debugs(0, DBG_CRITICAL, "WARNING OVERRIDE: Capping idle=" << n_idle << " to the defined maximum (" << n_max <<")");
+ debugs(0, DBG_CRITICAL, "WARNING: OVERRIDE: Capping idle=" << n_idle << " to the defined maximum (" << n_max <<")");
n_idle = n_max;
}
static int warnedCount = 0;
if (warnedCount++ < 100) {
const SBuf url(entry ? SBuf(entry->url()) : request->effectiveRequestUri());
- debugs(11, DBG_IMPORTANT, "Warning: likely forwarding loop with " << url);
+ debugs(11, DBG_IMPORTANT, "WARNING: likely forwarding loop with " << url);
}
}
debugs(58, 9, "success (" << hdr_len << " bytes) near '" << buf << "'");
if (hdr_sz != (int)hdr_len) {
- debugs(58, DBG_IMPORTANT, "internal Http::Message::parse vs. headersEnd error: " <<
+ debugs(58, DBG_IMPORTANT, "ERROR: internal Http::Message::parse vs. headersEnd failure: " <<
hdr_sz << " != " << hdr_len);
hdr_sz = (int)hdr_len; // because old http.cc code used hdr_len
}
if (packedStatus == Http::scNone) {
static unsigned int reports = 0;
if (++reports <= 100)
- debugs(57, DBG_IMPORTANT, "BUG: the internalized response lacks status-code");
+ debugs(57, DBG_IMPORTANT, "ERROR: Squid BUG: the internalized response lacks status-code");
packedStatus = Http::scInternalServerError;
packedReason = Http::StatusCodeString(packedStatus); // ignore custom reason_ (if any)
}
SBuf methodFound;
if (!tok.prefix(methodFound, CharacterSet::TCHAR, maxMethodLength)) {
- debugs(33, ErrorLevel(), "invalid request-line: missing or malformed method");
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: missing or malformed method");
parseStatusCode = Http::scBadRequest;
return false;
}
SBuf uriFound;
if (!tok.prefix(uriFound, RequestTargetCharacters())) {
parseStatusCode = Http::scBadRequest;
- debugs(33, ErrorLevel(), "invalid request-line: missing or malformed URI");
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: missing or malformed URI");
return false;
}
if (uriFound.length() > maxUriLength) {
// RFC 7230 section 3.1.1 mandatory (MUST) 414 response
parseStatusCode = Http::scUriTooLong;
- debugs(33, ErrorLevel(), "invalid request-line: " << uriFound.length() <<
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: " << uriFound.length() <<
"-byte URI exceeds " << maxUriLength << "-byte limit");
return false;
}
return true;
}
- debugs(33, ErrorLevel(), "invalid request-line: not HTTP");
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: not HTTP");
parseStatusCode = Http::scBadRequest;
return false;
}
Http::One::RequestParser::skipDelimiter(const size_t count, const char *where)
{
if (count <= 0) {
- debugs(33, ErrorLevel(), "invalid request-line: missing delimiter " << where);
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: missing delimiter " << where);
parseStatusCode = Http::scBadRequest;
return false;
}
// tolerant parser allows multiple whitespace characters between request-line fields
if (count > 1 && !Config.onoff.relaxed_header_parser) {
- debugs(33, ErrorLevel(), "invalid request-line: too many delimiters " << where);
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: too many delimiters " << where);
parseStatusCode = Http::scBadRequest;
return false;
}
(void)tok.skipAllTrailing(CharacterSet::CR); // optional; multiple OK
} else {
if (!tok.skipOneTrailing(CharacterSet::CR)) {
- debugs(33, ErrorLevel(), "invalid request-line: missing CR before LF");
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: missing CR before LF");
parseStatusCode = Http::scBadRequest;
return false;
}
return -1; // blame a bad method (or its delimiter)
// assume it is the URI
- debugs(74, ErrorLevel(), "invalid request-line: URI exceeds " <<
+ debugs(74, ErrorLevel(), "ERROR: invalid request-line: URI exceeds " <<
Config.maxRequestHeaderSize << "-byte limit");
parseStatusCode = Http::scUriTooLong;
return -1;
return -1;
if (!tok.atEnd()) {
- debugs(33, ErrorLevel(), "invalid request-line: garbage after URI");
+ debugs(33, ErrorLevel(), "ERROR: invalid request-line: garbage after URI");
parseStatusCode = Http::scBadRequest;
return -1;
}
&from->ai_addrlen);
if (n <= 0) {
- debugs(42, DBG_CRITICAL, HERE << "Error when calling recvfrom() on ICMP socket.");
+ debugs(42, DBG_CRITICAL, "ERROR: when calling recvfrom() on ICMP socket.");
Ip::Address::FreeAddr(from);
return;
}
preply.psize = n - iphdrlen - (sizeof(icmpEchoData) - MAX_PKT4_SZ);
if (preply.psize < 0) {
- debugs(42, DBG_CRITICAL, HERE << "Malformed ICMP packet.");
+ debugs(42, DBG_CRITICAL, "ERROR: Malformed ICMP packet.");
Ip::Address::FreeAddr(from);
return;
}
&from->ai_addrlen);
if (n <= 0) {
- debugs(42, DBG_CRITICAL, HERE << "Error when calling recvfrom() on ICMPv6 socket.");
+ debugs(42, DBG_CRITICAL, "ERROR: when calling recvfrom() on ICMPv6 socket.");
Ip::Address::FreeAddr(from);
return;
}
pecho.payload,
pecho.psize);
} else {
- debugs(42, DBG_IMPORTANT, HERE << " IP has unknown Type. " << pecho.to );
+ debugs(42, DBG_IMPORTANT, "ERROR: IP has unknown Type. " << pecho.to );
}
}
if (send(socket_to_squid, &preply, len, 0) < 0) {
int xerrno = errno;
- debugs(42, DBG_CRITICAL, "pinger: FATAL error on send: " << xstrerr(xerrno));
+ debugs(42, DBG_CRITICAL, "FATAL: pinger: send failure: " << xstrerr(xerrno));
Close();
exit(EXIT_FAILURE);
}
break;
default:
- debugs(37, DBG_IMPORTANT, HERE << "Bad opcode: " << preply.opcode << " from " << F);
+ debugs(37, DBG_IMPORTANT, "ERROR: Bad opcode: " << preply.opcode << " from " << F);
break;
}
}
x = (net_db_name *) hash_lookup(host_table, hostname);
if (x == NULL) {
- debugs(38, DBG_IMPORTANT, "netdbSendPing: net_db_name list bug: " << hostname << " not found");
+ debugs(38, DBG_IMPORTANT, "ERROR: Squid BUG: net_db_name list bug: " << hostname << " not found");
xfree(hostname);
return;
}
break;
default:
- debugs(38, DBG_IMPORTANT, "netdbExchangeHandleReply: corrupt data, aborting");
+ debugs(38, DBG_IMPORTANT, "ERROR: netdbExchangeHandleReply: corrupt data, aborting");
delete ex;
return;
}
HttpRequestPointer req(HttpRequest::FromUrlXXX(uri, mx));
if (!req) {
- debugs(38, DBG_IMPORTANT, MYNAME << ": Bad URI " << uri);
+ debugs(38, DBG_IMPORTANT, "ERROR: " << MYNAME << ": Bad URI " << uri);
return;
}
icmp4_worker = icmp4.Open();
if (icmp4_worker < 0) {
- debugs(42, DBG_CRITICAL, "pinger: Unable to start ICMP pinger.");
+ debugs(42, DBG_CRITICAL, "ERROR: pinger: Unable to start ICMP pinger.");
}
max_fd = max(max_fd, icmp4_worker);
#if USE_IPV6
icmp6_worker = icmp6.Open();
if (icmp6_worker <0 ) {
- debugs(42, DBG_CRITICAL, "pinger: Unable to start ICMPv6 pinger.");
+ debugs(42, DBG_CRITICAL, "ERROR: pinger: Unable to start ICMPv6 pinger.");
}
max_fd = max(max_fd, icmp6_worker);
#endif
if (x < 0) {
int xerrno = errno;
- debugs(42, DBG_CRITICAL, HERE << " FATAL Shutdown. select()==" << x << ", ERR: " << xstrerr(xerrno));
+ debugs(42, DBG_CRITICAL, "FATAL: select()==" << x << ", ERR: " << xstrerr(xerrno));
control.Close();
exit(EXIT_FAILURE);
}
break;
default:
- debugs(12, DBG_CRITICAL, "icpHandleIcpV2: UNKNOWN OPCODE: " << header.opcode << " from " << from);
+ debugs(12, DBG_CRITICAL, "ERROR: icpHandleIcpV2: Unknown opcode: " << header.opcode << " from " << from);
break;
}
break;
default:
- debugs(12, DBG_CRITICAL, "icpHandleIcpV3: UNKNOWN OPCODE: " << header.opcode << " from " << from);
+ debugs(12, DBG_CRITICAL, "ERROR: icpHandleIcpV3: Unknown opcode: " << header.opcode << " from " << from);
break;
}
}
}
// else fall through to ACCESS_DUNNO failure below
} else {
- debugs(28, DBG_IMPORTANT, HERE << "Can't start ident lookup. No client connection" );
+ debugs(28, DBG_IMPORTANT, "ERROR: Cannot start ident lookup. No client connection" );
// fall through to ACCESS_DUNNO failure below
}
return getReverseString6(buf, mSocketAddr_.sin6_addr);
}
- debugs(14, DBG_CRITICAL, "Unable to convert '" << toStr(buf,MAX_IPSTRLEN) << "' to the rDNS type requested.");
+ debugs(14, DBG_CRITICAL, "ERROR: Unable to convert '" << toStr(buf,MAX_IPSTRLEN) << "' to the rDNS type requested.");
buf[0] = '\0';
if ( family == AF_INET && !isIPv4()) {
// TODO INET6: caller using the wrong socket type!
- debugs(14, DBG_CRITICAL, HERE << "Ip::Address::getSockAddr : Cannot convert non-IPv4 to IPv4. from " << *this);
+ debugs(14, DBG_CRITICAL, "ERROR: Ip::Address::getSockAddr : Cannot convert non-IPv4 to IPv4. from " << *this);
assert(false);
}
buf.sin_port = mSocketAddr_.sin6_port;
map6to4( mSocketAddr_.sin6_addr, buf.sin_addr);
} else {
- debugs(14, DBG_CRITICAL, HERE << "Ip::Address::getSockAddr : Cannot convert non-IPv4 to IPv4. from " << *this );
+ debugs(14, DBG_CRITICAL, "ERROR: Ip::Address::getSockAddr : Cannot convert non-IPv4 to IPv4. from " << *this );
memset(&buf,0xFFFFFFFF,sizeof(struct sockaddr_in));
assert(false);
// default:
// non-compatible IPv6 Pure Address
- debugs(14, DBG_IMPORTANT, HERE << "Ip::Address::getInAddr : Cannot convert non-IPv4 to IPv4. IPA=" << *this);
+ debugs(14, DBG_IMPORTANT, "ERROR: Ip::Address::getInAddr : Cannot convert non-IPv4 to IPv4. IPA=" << *this);
memset(&buf,0xFFFFFFFF,sizeof(struct in_addr));
assert(false);
return false;
}
} else {
int xerrno = errno;
- debugs(33, DBG_IMPORTANT, "QOS: error in getsockopt(IP_PKTOPTIONS) on " << server << " " << xstrerr(xerrno));
+ debugs(33, DBG_IMPORTANT, "ERROR: QOS: getsockopt(IP_PKTOPTIONS) failure on " << server << " " << xstrerr(xerrno));
}
} else {
int xerrno = errno;
- debugs(33, DBG_IMPORTANT, "QOS: error in setsockopt(IP_RECVTOS) on " << server << " " << xstrerr(xerrno));
+ debugs(33, DBG_IMPORTANT, "ERROR: QOS: setsockopt(IP_RECVTOS) failure on " << server << " " << xstrerr(xerrno));
}
#else
(void)server;
errno = 0;
if (setsockopt(fds[0], SOL_SOCKET, SO_SNDBUF, (void *) &buflen, sizeof(buflen)) == -1) {
xerrno = errno;
- debugs(54, DBG_IMPORTANT, "setsockopt failed: " << xstrerr(xerrno));
+ debugs(54, DBG_IMPORTANT, "ERROR: setsockopt failed: " << xstrerr(xerrno));
errno = 0;
}
if (setsockopt(fds[0], SOL_SOCKET, SO_RCVBUF, (void *) &buflen, sizeof(buflen)) == -1) {
xerrno = errno;
- debugs(54, DBG_IMPORTANT, "setsockopt failed: " << xstrerr(xerrno));
+ debugs(54, DBG_IMPORTANT, "ERROR: setsockopt failed: " << xstrerr(xerrno));
errno = 0;
}
if (setsockopt(fds[1], SOL_SOCKET, SO_SNDBUF, (void *) &buflen, sizeof(buflen)) == -1) {
xerrno = errno;
- debugs(54, DBG_IMPORTANT, "setsockopt failed: " << xstrerr(xerrno));
+ debugs(54, DBG_IMPORTANT, "ERROR: setsockopt failed: " << xstrerr(xerrno));
errno = 0;
}
if (setsockopt(fds[1], SOL_SOCKET, SO_RCVBUF, (void *) &buflen, sizeof(buflen)) == -1) {
xerrno = errno;
- debugs(54, DBG_IMPORTANT, "setsockopt failed: " << xstrerr(xerrno));
+ debugs(54, DBG_IMPORTANT, "ERROR: setsockopt failed: " << xstrerr(xerrno));
errno = 0;
}
fd_open(prfd = pwfd = fds[0], FD_PIPE, "IPC UNIX STREAM Parent");
hello_buf[x] = '\0';
if (x < 0) {
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: hello read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: hello read test failed");
debugs(54, DBG_CRITICAL, "--> read: " << xstrerr(xerrno));
return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
} else if (strcmp(hello_buf, hello_string)) {
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: hello read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: hello read test failed");
debugs(54, DBG_CRITICAL, "--> read returned " << x);
debugs(54, DBG_CRITICAL, "--> got '" << rfc1738_escape(hello_buf) << "'");
return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
if (x < 0) {
xerrno = errno;
debugs(54, DBG_CRITICAL, "sendto FD " << cwfd << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: hello write test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: hello write test failed");
_exit(1);
}
} else {
if (write(cwfd, hello_string, strlen(hello_string) + 1) < 0) {
xerrno = errno;
debugs(54, DBG_CRITICAL, "write FD " << cwfd << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: hello write test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: hello write test failed");
_exit(1);
}
}
CacheManager::GetInstance()->createRequestedAction(request.params);
AsyncJob::Start(new Mgr::Inquirer(action, request, strands_));
} catch (const std::exception &ex) {
- debugs(54, DBG_IMPORTANT, "BUG: cannot aggregate mgr:" <<
+ debugs(54, DBG_IMPORTANT, "ERROR: Squid BUG: cannot aggregate mgr:" <<
request.params.actionName << ": " << ex.what());
// TODO: Avoid half-baked Connections or teach them how to close.
::close(request.conn->fd);
if (fdnNone < fdNoteId && fdNoteId < fdnEnd)
return FdNotes[fdNoteId];
- debugs(54, DBG_IMPORTANT, HERE << "salvaged bug: wrong fd_note ID: " << fdNoteId);
+ debugs(54, DBG_IMPORTANT, "ERROR: Squid BUG: wrong fd_note ID: " << fdNoteId);
return FdNotes[fdnNone];
}
++statCounter.hitValidation.failures;
- debugs(54, DBG_IMPORTANT, "BUG: purging corrupted cache entry " << fileno <<
+ debugs(54, DBG_IMPORTANT, "ERROR: Squid BUG: purging corrupted cache entry " << fileno <<
" from " << path <<
" expected swap_file_sz=" << expectedByteCount <<
" actual swap_file_sz=" << actualByteCount <<
}
if (crfd < 0) {
- debugs(54, DBG_CRITICAL, "ipcCreate: Failed to create child FD.");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: Failed to create child FD.");
return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
}
if (pwfd < 0) {
- debugs(54, DBG_CRITICAL, "ipcCreate: Failed to create server FD.");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: Failed to create server FD.");
return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
}
if (x < 0) {
int xerrno = errno;
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: hello read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: hello read test failed");
debugs(54, DBG_CRITICAL, "--> read: " << xstrerr(xerrno));
CloseHandle((HANDLE) thread);
return ipcCloseAllFD(prfd, pwfd, -1, -1);
} else if (strcmp(hello_buf, hello_string)) {
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: hello read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: hello read test failed");
debugs(54, DBG_CRITICAL, "--> read returned " << x);
debugs(54, DBG_CRITICAL, "--> got '" << rfc1738_escape(hello_buf) << "'");
CloseHandle((HANDLE) thread);
if (x < 0) {
int xerrno = errno;
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: OK write test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: OK write test failed");
debugs(54, DBG_CRITICAL, "--> read: " << xstrerr(xerrno));
CloseHandle((HANDLE) thread);
return ipcCloseAllFD(prfd, pwfd, -1, -1);
if (x < 0) {
int xerrno = errno;
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: OK read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: OK read test failed");
debugs(54, DBG_CRITICAL, "--> read: " << xstrerr(xerrno));
CloseHandle((HANDLE) thread);
return ipcCloseAllFD(prfd, pwfd, -1, -1);
} else if (!strcmp(hello_buf, err_string)) {
- debugs(54, DBG_CRITICAL, "ipcCreate: PARENT: OK read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: PARENT: OK read test failed");
debugs(54, DBG_CRITICAL, "--> read returned " << x);
debugs(54, DBG_CRITICAL, "--> got '" << rfc1738_escape(hello_buf) << "'");
CloseHandle((HANDLE) thread);
if (x < 0) {
int xerrno = errno;
debugs(54, DBG_CRITICAL, "sendto FD " << cwfd << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: hello write test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: hello write test failed");
}
return x;
if (x < 0) {
int xerrno = errno;
debugs(54, DBG_CRITICAL, "sendto FD " << cwfd << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: hello write test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: hello write test failed");
goto cleanup;
}
if (x < 0) {
int xerrno = errno;
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: OK read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: OK read test failed");
debugs(54, DBG_CRITICAL, "--> read: " << xstrerr(xerrno));
goto cleanup;
} else if (strcmp(buf1, ok_string)) {
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: OK read test failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: OK read test failed");
debugs(54, DBG_CRITICAL, "--> read returned " << x);
debugs(54, DBG_CRITICAL, "--> got '" << rfc1738_escape(hello_buf) << "'");
goto cleanup;
crfd_ipc = cwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, buf1);
if (crfd_ipc < 0) {
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: Failed to create child FD for " << prog << ".");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: Failed to create child FD for " << prog << ".");
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
prfd_ipc = pwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, buf1);
if (pwfd_ipc < 0) {
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: Failed to create server FD for " << prog << ".");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: Failed to create server FD for " << prog << ".");
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
if (x < (ssize_t)sizeof(wpi)) {
int xerrno = errno;
debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: write FD " << c2p[1] << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: " << prog << ": socket exchange failed");
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
if (x < 0) {
int xerrno = errno;
debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: read FD " << p2c[0] << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: " << prog << ": socket exchange failed");
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
} else if (strncmp(buf1, ok_string, strlen(ok_string))) {
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: " << prog << ": socket exchange failed");
debugs(54, DBG_CRITICAL, "--> read returned " << x);
buf1[x] = '\0';
debugs(54, DBG_CRITICAL, "--> got '" << rfc1738_escape(buf1) << "'");
if (x < (ssize_t)sizeof(PS_ipc)) {
int xerrno = errno;
debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: write FD " << c2p[1] << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: " << prog << ": socket exchange failed");
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
if (x < 0) {
int xerrno = errno;
debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: read FD " << p2c[0] << ": " << xstrerr(xerrno));
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: " << prog << ": socket exchange failed");
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
} else if (strncmp(buf1, ok_string, strlen(ok_string))) {
- debugs(54, DBG_CRITICAL, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
+ debugs(54, DBG_CRITICAL, "ERROR: ipcCreate: CHILD: " << prog << ": socket exchange failed");
debugs(54, DBG_CRITICAL, "--> read returned " << x);
buf1[x] = '\0';
debugs(54, DBG_CRITICAL, "--> got '" << rfc1738_escape(buf1) << "'");
void
ipcache_entry::latestError(const char *text, const int debugLevel)
{
- debugs(14, debugLevel, "DNS error while resolving " << name() << ": " << text);
+ debugs(14, debugLevel, "ERROR: DNS failure while resolving " << name() << ": " << text);
safe_free(error_message);
error_message = xstrdup(text);
}
char buf[MAX_IPSTRLEN];
if (!sentry) {
- debugs(14, DBG_CRITICAL, HERE << "CRITICAL: sentry is NULL!");
+ debugs(14, DBG_CRITICAL, "ERROR: sentry is NULL!");
return;
}
if (!i) {
- debugs(14, DBG_CRITICAL, HERE << "CRITICAL: ipcache_entry is NULL!");
+ debugs(14, DBG_CRITICAL, "ERROR: ipcache_entry is NULL!");
storeAppendPrintf(sentry, "CRITICAL ERROR\n");
return;
}
if (strchr(ipaddr, ':') && strspn(ipaddr, "0123456789abcdefABCDEF:") == strlen(ipaddr)) {
debugs(14, 3, "ipcacheAddEntryFromHosts: Skipping IPv6 address '" << ipaddr << "'");
} else {
- debugs(14, DBG_IMPORTANT, "ipcacheAddEntryFromHosts: Bad IP address '" << ipaddr << "'");
+ debugs(14, DBG_IMPORTANT, "ERROR: ipcacheAddEntryFromHosts: Bad IP address '" << ipaddr << "'");
}
return 1;
if (1 == i->flags.fromhosts) {
ipcacheUnlockEntry(i);
} else if (i->locks > 0) {
- debugs(14, DBG_IMPORTANT, "ipcacheAddEntryFromHosts: can't add static entry for locked name '" << name << "'");
+ debugs(14, DBG_IMPORTANT, "ERROR: ipcacheAddEntryFromHosts: cannot add static entry for locked name '" << name << "'");
return 1;
} else {
ipcacheRelease(i);
if (fatal_flag)
fatalf("logfileOpen: %s: couldn't open!\n", path);
else
- debugs(50, DBG_IMPORTANT, "logfileOpen: " << path << ": couldn't open!");
+ debugs(50, DBG_IMPORTANT, "ERROR: logfileOpen: " << path << ": could not open!");
lf->f_close(lf);
delete lf;
return NULL;
ll->flush_pending = 1;
return;
}
- debugs(50, DBG_IMPORTANT,"logfileHandleWrite: " << lf->path << ": error writing (" << xstrerr(xerrno) << ")");
+ debugs(50, DBG_IMPORTANT, "ERROR: logfileHandleWrite: " << lf->path << ": error writing (" << xstrerr(xerrno) << ")");
/* XXX should handle this better */
fatal("I don't handle this error well!");
}
{
l_daemon_t *ll = static_cast<l_daemon_t *>(lf->data);
if (commUnsetNonBlocking(ll->wfd)) {
- debugs(50, DBG_IMPORTANT, "Logfile Daemon: Couldn't set the pipe blocking for flush! You're now missing some log entries.");
+ debugs(50, DBG_IMPORTANT, "ERROR: Logfile Daemon: Could not set the pipe blocking for flush! You are now missing some log entries.");
return;
}
while (ll->bufs.head != NULL) {
if (!strcmp(s, p->name) || !strcasecmp(s, p->name + 4))
return p->value;
- debugs(1, DBG_IMPORTANT, "Unknown syslog facility/priority '" << s << "'");
+ debugs(1, DBG_IMPORTANT, "ERROR: Unknown syslog facility/priority '" << s << "'");
return 0;
}
if (lf->flags.fatal) {
fatalf("Invalid UDP logging address '%s'\n", lf->path);
} else {
- debugs(50, DBG_IMPORTANT, "Invalid UDP logging address '" << lf->path << "'");
+ debugs(50, DBG_IMPORTANT, "ERROR: Invalid UDP logging address '" << lf->path << "'");
safe_free(strAddr);
return FALSE;
}
if (lf->flags.fatal) {
fatalf("Unable to open UDP socket for logging\n");
} else {
- debugs(50, DBG_IMPORTANT, "Unable to open UDP socket for logging");
+ debugs(50, DBG_IMPORTANT, "ERROR: Unable to open UDP socket for logging");
return FALSE;
}
} else if (!comm_connect_addr(ll->fd, addr)) {
if (lf->flags.fatal) {
fatalf("Unable to connect to %s for UDP log: %s\n", lf->path, xstrerr(xerrno));
} else {
- debugs(50, DBG_IMPORTANT, "Unable to connect to " << lf->path << " for UDP log: " << xstrerr(xerrno));
+ debugs(50, DBG_IMPORTANT, "ERROR: Unable to connect to " << lf->path << " for UDP log: " << xstrerr(xerrno));
return FALSE;
}
}
}
if (!drops || dieOnError) {
- debugs(MY_DEBUG_SECTION,
- dieOnError ? DBG_CRITICAL : DBG_IMPORTANT,
- "tcp:" << remote << " logger " << bufferCapacity << "-byte " <<
+ debugs(MY_DEBUG_SECTION, dieOnError ? DBG_CRITICAL : DBG_IMPORTANT,
+ "ERROR: tcp:" << remote << " logger " << bufferCapacity << "-byte " <<
"buffer overflowed; cannot fit " <<
(bufferedSize+len-bufferCapacity) << " bytes");
}
if (params.flag != Comm::OK) {
const double delay = 0.5; // seconds
if (connectFailures++ % 100 == 0) {
- debugs(MY_DEBUG_SECTION, DBG_IMPORTANT, "tcp:" << remote <<
+ debugs(MY_DEBUG_SECTION, DBG_IMPORTANT, "ERROR: tcp:" << remote <<
" logger connection attempt #" << connectFailures <<
" failed. Will keep trying every " << delay << " seconds.");
}
if (lf->flags.fatal) {
fatalf("Invalid TCP logging address '%s'\n", lf->path);
} else {
- debugs(50, DBG_IMPORTANT, "Invalid TCP logging address '" << lf->path << "'");
+ debugs(50, DBG_IMPORTANT, "ERROR: Invalid TCP logging address '" << lf->path << "'");
safe_free(strAddr);
return FALSE;
}
strPools[i]->zeroBlocks(false);
if (strPools[i]->objectSize() != PoolAttrs[i].obj_size)
- debugs(13, DBG_IMPORTANT, "NOTICE: " << PoolAttrs[i].name <<
+ debugs(13, DBG_IMPORTANT, "WARNING: " << PoolAttrs[i].name <<
" is " << strPools[i]->objectSize() <<
" bytes instead of requested " <<
PoolAttrs[i].obj_size << " bytes");
xstrncpy(chopbuf, buf, BUFSIZ);
if ((pattern = strtok(chopbuf, w_space)) == NULL) {
- debugs(25, DBG_IMPORTANT, "mimeInit: parse error: '" << buf << "'");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: parse failure: '" << buf << "'");
continue;
}
if ((type = strtok(NULL, w_space)) == NULL) {
- debugs(25, DBG_IMPORTANT, "mimeInit: parse error: '" << buf << "'");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: parse failure: '" << buf << "'");
continue;
}
if ((icon = strtok(NULL, w_space)) == NULL) {
- debugs(25, DBG_IMPORTANT, "mimeInit: parse error: '" << buf << "'");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: parse failure: '" << buf << "'");
continue;
}
if ((encoding = strtok(NULL, w_space)) == NULL) {
- debugs(25, DBG_IMPORTANT, "mimeInit: parse error: '" << buf << "'");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: parse failure: '" << buf << "'");
continue;
}
if ((mode = strtok(NULL, w_space)) == NULL) {
- debugs(25, DBG_IMPORTANT, "mimeInit: parse error: '" << buf << "'");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: parse failure: '" << buf << "'");
continue;
}
else if (!strcmp(option, "+view"))
view_option = 1;
else
- debugs(25, DBG_IMPORTANT, "mimeInit: unknown option: '" << buf << "' (" << option << ")");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: unknown option: '" << buf << "' (" << option << ")");
}
if (regcomp(&re, pattern, re_flags) != 0) {
- debugs(25, DBG_IMPORTANT, "mimeInit: regcomp error: '" << buf << "'");
+ debugs(25, DBG_IMPORTANT, "ERROR: mimeInit: regcomp failure: '" << buf << "'");
continue;
}
struct ip_mreq mr;
if (ia == NULL) {
- debugs(7, DBG_CRITICAL, "comm_join_mcast_groups: Unknown host");
+ debugs(7, DBG_CRITICAL, "ERROR: comm_join_mcast_groups: Unknown host");
return;
}
#if USE_HTCP
if (p->options.htcp && !p->options.htcp_only_clr) {
if (Config.Port.htcp <= 0) {
- debugs(15, DBG_CRITICAL, "HTCP is disabled! Cannot send HTCP request to peer.");
+ debugs(15, DBG_CRITICAL, "ERROR: HTCP is disabled! Cannot send HTCP request to peer.");
continue;
}
#endif
{
if (Config.Port.icp <= 0 || !Comm::IsConnOpen(icpOutgoingConn)) {
- debugs(15, DBG_CRITICAL, "ICP is disabled! Cannot send ICP request to peer.");
+ debugs(15, DBG_CRITICAL, "ERROR: ICP is disabled! Cannot send ICP request to peer.");
continue;
} else {
}
if (!mem->ircb_data) {
- debugs(12, DBG_IMPORTANT, "BUG: missing ICP callback data for " << *entry);
+ debugs(12, DBG_IMPORTANT, "ERROR: Squid BUG: missing ICP callback data for " << *entry);
neighborCountIgnored(p);
return;
}
} else if (opcode == ICP_MISS_NOFETCH) {
mem->ping_reply_callback(p, ntype, AnyP::PROTO_ICP, header, mem->ircb_data);
} else {
- debugs(15, DBG_CRITICAL, "neighborsUdpAck: Unexpected ICP reply: " << opcode_d);
+ debugs(15, DBG_CRITICAL, "ERROR: neighborsUdpAck: Unexpected ICP reply: " << opcode_d);
}
}
void
peerConnectFailed(CachePeer *p)
{
- debugs(15, DBG_IMPORTANT, "TCP connection to " << p->host << "/" << p->http_port << " failed");
+ debugs(15, DBG_IMPORTANT, "ERROR: TCP connection to " << p->host << "/" << p->http_port << " failed");
peerConnectFailedSilent(p);
}
}
if (!mem->ircb_data) {
- debugs(12, DBG_IMPORTANT, "BUG: missing HTCP callback data for " << *e);
+ debugs(12, DBG_IMPORTANT, "ERROR: Squid BUG: missing HTCP callback data for " << *e);
neighborCountIgnored(p);
return;
}
/* there are some things we cannot do yet */
if (cblock.hash_func_count != CacheDigestHashFuncCount) {
- debugs(72, DBG_CRITICAL, "" << host << " digest: unsupported #hash functions: " <<
+ debugs(72, DBG_CRITICAL, "ERROR: " << host << " digest: unsupported #hash functions: " <<
cblock.hash_func_count << " ? " << CacheDigestHashFuncCount << ".");
return 0;
}
const auto bit_util = pd->cd->usedMaskPercent();
if (bit_util > 65.0) {
- debugs(72, DBG_CRITICAL, "Warning: " << pd->host <<
+ debugs(72, DBG_CRITICAL, "WARNING: " << pd->host <<
" peer digest has too many bits on (" << bit_util << "%).");
return 0;
}
}
if (acl_checklist) {
- debugs(44, DBG_IMPORTANT, "BUG: peer selector gone while waiting for a slow ACL");
+ debugs(44, DBG_IMPORTANT, "ERROR: Squid BUG: peer selector gone while waiting for a slow ACL");
delete acl_checklist;
}
size_t replySize = 0;
if (const char *t = strchr(res, ' ')) {
static int warn = 0;
- debugs(61, (!(warn++%50)? DBG_CRITICAL:2), "UPGRADE WARNING: URL rewriter reponded with garbage '" << t <<
+ debugs(61, (!(warn++%50)? DBG_CRITICAL:2), "WARNING: UPGRADE: URL rewriter reponded with garbage '" << t <<
"'. Future Squid will treat this as part of the URL.");
replySize = t - res;
} else
if (*result == '!') {
static int urlgroupWarning = 0;
if (!urlgroupWarning++)
- debugs(85, DBG_IMPORTANT, "UPGRADE WARNING: URL rewriter using obsolete Squid-2 urlgroup feature needs updating.");
+ debugs(85, DBG_IMPORTANT, "WARNING: UPGRADE: URL rewriter using obsolete Squid-2 urlgroup feature needs updating.");
if (char *t = strchr(result+1, '!')) {
*t = '\0';
newReply.notes.add("urlgroup", result+1);
else if (!strcmp(keytype, "LRU"))
heap_data->keyfunc = HeapKeyGen_StoreEntry_LRU;
else {
- debugs(81, DBG_CRITICAL, "createRemovalPolicy_heap: Unknown key type \"" << keytype << "\". Using LRU");
+ debugs(81, DBG_CRITICAL, "ERROR: createRemovalPolicy_heap: Unknown key type \"" << keytype << "\". Using LRU");
heap_data->keyfunc = HeapKeyGen_StoreEntry_LRU;
}
#else
(void)topError;
// TLS I/O code path should never be reachable without a TLS/SSL library.
- debugs(1, DBG_CRITICAL, ForceAlert << "BUG: " <<
+ debugs(1, DBG_CRITICAL, ForceAlert << "ERROR: Squid BUG: " <<
"Unexpected TLS I/O in Squid built without a TLS/SSL library");
assert(false); // we want a stack trace which fatal() does not produce
return IoResult(nullptr); // not reachable
if (!ctx || !Security::CreateClientSession(ctx, serverConnection(), "server https start")) {
const auto xerrno = errno;
if (!ctx) {
- debugs(83, DBG_IMPORTANT, "Error initializing TLS connection: No security context.");
+ debugs(83, DBG_IMPORTANT, "ERROR: initializing TLS connection: No security context.");
} // else CreateClientSession() did the appropriate debugs() already
const auto anErr = new ErrorState(ERR_SOCKET_FAILURE, Http::scInternalServerError, request.getRaw(), al);
anErr->xerrno = xerrno;
!(result.errorDetail && result.errorDetail->errorNo() == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY))
return handleMissingCertificates(result);
- debugs(83, DBG_IMPORTANT, "BUG: Honoring unexpected SSL_connect() error: X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
+ debugs(83, DBG_IMPORTANT, "ERROR: Squid BUG: Honoring unexpected SSL_connect() failure: X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
// fall through to regular error handling
}
#endif
KeyData &t = certs.back();
t.privateKeyFile = SBuf(token + 4);
} else if (strncmp(token, "version=", 8) == 0) {
- debugs(0, DBG_PARSE_NOTE(1), "UPGRADE WARNING: SSL version= is deprecated. Use options= and tls-min-version= to limit protocols instead.");
+ debugs(0, DBG_PARSE_NOTE(1), "WARNING: UPGRADE: SSL version= is deprecated. Use options= and tls-min-version= to limit protocols instead.");
sslVersion = xatoi(token + 8);
} else if (strncmp(token, "min-version=", 12) == 0) {
tlsMinVersion = SBuf(token + 12);
} else if (strncmp(token, "dhparams=", 9) == 0) {
if (!eecdhCurve.isEmpty()) {
- debugs(83, DBG_PARSE_NOTE(1), "UPGRADE WARNING: EECDH settings in tls-dh= override dhparams=");
+ debugs(83, DBG_PARSE_NOTE(1), "WARNING: UPGRADE: EECDH settings in tls-dh= override dhparams=");
return;
}
if (!session) {
errCode = ERR_get_error();
errAction = "failed to allocate handle";
- debugs(83, DBG_IMPORTANT, "TLS error: " << errAction << ": " << Security::ErrorString(errCode));
+ debugs(83, DBG_IMPORTANT, "ERROR: TLS failure: " << errAction << ": " << Security::ErrorString(errCode));
}
#elif USE_GNUTLS
gnutls_session_t tmp;
if (errCode != GNUTLS_E_SUCCESS) {
session.reset();
errAction = "failed to initialize session";
- debugs(83, DBG_IMPORTANT, "TLS error: " << errAction << ": " << Security::ErrorString(errCode));
+ debugs(83, DBG_IMPORTANT, "ERROR: TLS failure: " << errAction << ": " << Security::ErrorString(errCode));
}
#endif /* USE_GNUTLS */
int fd;
if (ia == NULL) {
- debugs(27, DBG_IMPORTANT, "send_announce: Unknown host '" << host << "'");
+ debugs(27, DBG_IMPORTANT, "ERROR: send_announce: Unknown host '" << host << "'");
return;
}
const char *const note = uri.c_str();
comm_open_listener(SOCK_STREAM, IPPROTO_TCP, conn, note);
if (!Comm::IsConnOpen(conn)) {
- debugs(5, DBG_CRITICAL, "comm_open_listener failed for FTP data: " <<
+ debugs(5, DBG_CRITICAL, "ERROR: comm_open_listener failed for FTP data: " <<
conn->local << " error: " << errno);
writeCustomReply(451, "Internal error");
return 0;
setTimeTicks(asTimeTicks() + var.asTimeTicks());
break;
default:
- debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
+ debugs(49, DBG_CRITICAL, "ERROR: Unsupported type: " << type);
throw TexcHere("Unsupported type");
break;
}
setTimeTicks(asTimeTicks() / num);
break;
default:
- debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
+ debugs(49, DBG_CRITICAL, "ERROR: Unsupported type: " << type);
throw TexcHere("Unsupported type");
break;
}
case SMI_TIMETICKS:
return asTimeTicks() < var.asTimeTicks();
default:
- debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
+ debugs(49, DBG_CRITICAL, "ERROR: Unsupported type: " << type);
throw TexcHere("Unsupported type");
break;
}
case SMI_TIMETICKS:
return asTimeTicks() > var.asTimeTicks();
default:
- debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
+ debugs(49, DBG_CRITICAL, "ERROR: Unsupported type: " << type);
throw TexcHere("Unsupported type");
break;
}
Http::ContentLengthInterpreter interpreter;
// no applyStatusCodeRules() -- error templates lack HTTP status code
if (!parser.parse(s, e - s, interpreter)) {
- debugs(83, DBG_IMPORTANT, HERE <<
- "WARNING! parse error on:" << s);
+ debugs(83, DBG_IMPORTANT, "WARNING: parse error on:" << s);
return false;
}
const String errorName = parser.getByName("name");
if (!errorName.size()) {
- debugs(83, DBG_IMPORTANT, HERE <<
- "WARNING! invalid or no error detail name on:" << s);
+ debugs(83, DBG_IMPORTANT, "WARNING: invalid or no error detail name on:" << s);
return false;
}
if (ssl_error != SSL_ERROR_NONE) {
if (theDetails->getErrorDetail(ssl_error)) {
- debugs(83, DBG_IMPORTANT, HERE <<
- "WARNING! duplicate entry: " << errorName);
+ debugs(83, DBG_IMPORTANT, "WARNING: duplicate entry: " << errorName);
return false;
}
// TODO: Validate "descr" and "detail" field values.
if (!detailsParseOk || !descrParseOk) {
- debugs(83, DBG_IMPORTANT, HERE <<
- "WARNING! missing important field for detail error: " << errorName);
+ debugs(83, DBG_IMPORTANT, "WARNING: missing important field for detail error: " << errorName);
return false;
}
} else if (!Ssl::ErrorIsOptional(errorName.termedBuf())) {
- debugs(83, DBG_IMPORTANT, HERE <<
- "WARNING! invalid error detail name: " << errorName);
+ debugs(83, DBG_IMPORTANT, "WARNING: invalid error detail name: " << errorName);
return false;
}
assert(crtdvdData->ssl.get());
Ssl::CertValidationResponse::Pointer validationResponse = new Ssl::CertValidationResponse(crtdvdData->ssl);
if (reply.result == ::Helper::BrokenHelper) {
- debugs(83, DBG_IMPORTANT, "\"ssl_crtvd\" helper error response: " << reply.other().content());
+ debugs(83, DBG_IMPORTANT, "ERROR: \"ssl_crtvd\" helper error response: " << reply.other().content());
validationResponse->resultCode = ::Helper::BrokenHelper;
} else if (!reply.other().hasContent()) {
debugs(83, DBG_IMPORTANT, "\"ssl_crtvd\" helper returned NULL response");
} else if (replyMsg.parse(reply.other().content(), reply.other().contentSize()) != Ssl::CrtdMessage::OK ||
!replyMsg.parseResponse(*validationResponse) ) {
debugs(83, DBG_IMPORTANT, "WARNING: Reply from ssl_crtvd for " << " is incorrect");
- debugs(83, DBG_IMPORTANT, "Certificate cannot be validated. ssl_crtvd response: " << replyMsg.getBody());
+ debugs(83, DBG_IMPORTANT, "ERROR: Certificate cannot be validated. ssl_crtvd response: " << replyMsg.getBody());
validationResponse->resultCode = ::Helper::BrokenHelper;
} else
validationResponse->resultCode = reply.result;
if (!e) {
e = BN_new();
if (!e || !BN_set_word(e, RSA_F4)) {
- debugs(83, DBG_IMPORTANT, "ssl_temp_rsa_cb: Failed to set exponent for key " << keylen);
+ debugs(83, DBG_IMPORTANT, "ERROR: ssl_temp_rsa_cb: Failed to set exponent for key " << keylen);
BN_free(e);
e = nullptr;
return nullptr;
break;
default:
- debugs(83, DBG_IMPORTANT, "ssl_temp_rsa_cb: Unexpected key length " << keylen);
+ debugs(83, DBG_IMPORTANT, "ERROR: ssl_temp_rsa_cb: Unexpected key length " << keylen);
return NULL;
}
if (rsa == NULL) {
- debugs(83, DBG_IMPORTANT, "ssl_temp_rsa_cb: Failed to generate key " << keylen);
+ debugs(83, DBG_IMPORTANT, "ERROR: ssl_temp_rsa_cb: Failed to generate key " << keylen);
return NULL;
}
if (const char *err_descr = Ssl::GetErrorDescr(error_no))
debugs(83, 5, err_descr << ": " << buffer);
else
- debugs(83, DBG_IMPORTANT, "SSL unknown certificate error " << error_no << " in " << buffer);
+ debugs(83, DBG_IMPORTANT, "ERROR: SSL unknown certificate error " << error_no << " in " << buffer);
// Check if the certificate error can be bypassed.
// Infinity validation loop errors can not bypassed.
// assume each flag is exclusive; flags creator must check this assumption
if (flags & SSL_FLAG_DONT_VERIFY_PEER) {
debugs(83, DBG_IMPORTANT, "SECURITY WARNING: Peer certificates are not verified for validity!");
- debugs(83, DBG_IMPORTANT, "UPGRADE NOTICE: The DONT_VERIFY_PEER flag is deprecated. Remove the clientca= option to disable client certificates.");
+ debugs(83, DBG_IMPORTANT, "WARNING: UPGRADE: The DONT_VERIFY_PEER flag is deprecated. Remove the clientca= option to disable client certificates.");
mode = SSL_VERIFY_NONE;
}
else if (flags & SSL_FLAG_DELAYED_AUTH) {
{
const BIO_Pointer in(BIO_new_file(certsFile, "r"));
if (!in) {
- debugs(83, DBG_IMPORTANT, "Failed to open '" << certsFile << "' to load certificates");
+ debugs(83, DBG_IMPORTANT, "ERROR: Failed to open '" << certsFile << "' to load certificates");
return false;
}
X509_STORE_CTX *storeCtx = X509_STORE_CTX_new();
if (!storeCtx) {
- debugs(83, DBG_IMPORTANT, "Failed to allocate STORE_CTX object");
+ debugs(83, DBG_IMPORTANT, "ERROR: Failed to allocate STORE_CTX object");
return nullptr;
}
}
} else {
const auto ssl_error = ERR_get_error();
- debugs(83, DBG_IMPORTANT, "Failed to initialize STORE_CTX object: " << Security::ErrorString(ssl_error));
+ debugs(83, DBG_IMPORTANT, "ERROR: Failed to initialize STORE_CTX object: " << Security::ErrorString(ssl_error));
}
X509_STORE_CTX_free(storeCtx);
l = &CountHourHist[hours];
} else {
- debugs(18, DBG_IMPORTANT, "statAvgDump: Invalid args, minutes=" << minutes << ", hours=" << hours);
+ debugs(18, DBG_IMPORTANT, "ERROR: statAvgDump: Invalid args, minutes=" << minutes << ", hours=" << hours);
return;
}
mem_hdr::unlink(mem_node *aNode)
{
if (aNode->write_pending) {
- debugs(0, DBG_CRITICAL, "cannot unlink mem_node " << aNode << " while write_pending");
+ debugs(0, DBG_CRITICAL, "ERROR: cannot unlink mem_node " << aNode << " while write_pending");
return false;
}
mem_node *p = getBlockContainingLocation(target.offset);
if (!p) {
- debugs(19, DBG_IMPORTANT, "memCopy: could not find start of " << target.range() <<
+ debugs(19, DBG_IMPORTANT, "ERROR: memCopy: could not find start of " << target.range() <<
" in memory.");
debugDump();
fatal_dump("Squid has attempted to read data from memory that is not present. This is an indication of of (pre-3.0) code that hasn't been updated to deal with sparse objects in memory. Squid should coredump.allowing to review the cause. Immediately preceding this message is a dump of the available data in the format [start,end). The [ means from the value, the ) means up to the value. I.e. [1,5) means that there are 4 bytes of data, at offsets 1,2,3,4.\n");
if (!found) {
// !found should imply hittingRequiresCollapsing() regardless of writer presence
if (!entry.hittingRequiresCollapsing()) {
- debugs(20, DBG_IMPORTANT, "BUG: missing ENTRY_REQUIRES_COLLAPSING for " << entry);
+ debugs(20, DBG_IMPORTANT, "ERROR: Squid BUG: missing ENTRY_REQUIRES_COLLAPSING for " << entry);
throw TextException("transients entry missing ENTRY_REQUIRES_COLLAPSING", Here());
}
auto &sd = SwapDirByIndex(dirn);
if (sd.writeCleanStart() < 0) {
- debugs(20, DBG_IMPORTANT, "log.clean.start() failed for dir #" << sd.index);
+ debugs(20, DBG_IMPORTANT, "ERROR: log.clean.start() failed for dir #" << sd.index);
continue;
}
}
if (copyInto.offset == 0 && len > 0 && rep && rep->sline.status() == Http::scNone) {
/* Our structure ! */
if (!entry->mem_obj->adjustableBaseReply().parseCharBuf(copyInto.data, headersEnd(copyInto.data, len))) {
- debugs(90, DBG_CRITICAL, "Could not parse headers from on disk object");
+ debugs(90, DBG_CRITICAL, "ERROR: Could not parse headers from on disk object");
} else {
parsed_header = 1;
}
debugs(20, 3, *e << " " << e->getMD5Text());
if (!e->hasDisk()) {
- debugs(20, DBG_IMPORTANT, "BUG: Attempt to swap in a not-stored entry " << *e << ". Salvaged.");
+ debugs(20, DBG_IMPORTANT, "ERROR: Squid BUG: Attempt to swap in a not-stored entry " << *e << ". Salvaged.");
return;
}
if (e->swapoutFailed()) {
- debugs(20, DBG_IMPORTANT, "BUG: Attempt to swap in a failed-to-store entry " << *e << ". Salvaged.");
+ debugs(20, DBG_IMPORTANT, "ERROR: Squid BUG: Attempt to swap in a failed-to-store entry " << *e << ". Salvaged.");
return;
}
if (setgid(Config2.effectiveGroupID) < 0) {
int xerrno = errno;
- debugs(50, DBG_CRITICAL, "ALERT: setgid: " << xstrerr(xerrno));
+ debugs(50, DBG_CRITICAL, "ERROR: setgid: " << xstrerr(xerrno));
}
}
if (setgid(Config2.effectiveGroupID) < 0) {
int xerrno = errno;
- debugs(50, DBG_CRITICAL, "ALERT: setgid: " << xstrerr(xerrno));
+ debugs(50, DBG_CRITICAL, "ERROR: setgid: " << xstrerr(xerrno));
}
if (initgroups(Config.effectiveUser, Config2.effectiveGroupID) < 0) {
- debugs(50, DBG_CRITICAL, "ALERT: initgroups: unable to set groups for User " <<
+ debugs(50, DBG_CRITICAL, "ERROR: initgroups: unable to set groups for User " <<
Config.effectiveUser << " and Group " <<
(unsigned) Config2.effectiveGroupID << "");
}
}
#endif /* RLIMIT_DATA */
if (Config.max_filedescriptors > Squid_MaxFD) {
- debugs(50, DBG_IMPORTANT, "NOTICE: Could not increase the number of filedescriptors");
+ debugs(50, DBG_IMPORTANT, "WARNING: Could not increase the number of filedescriptors");
}
#if HAVE_SETRLIMIT && defined(RLIMIT_VMEM) && !_SQUID_CYGWIN_
if (bytes_written < 0) {
int xerrno = errno;
- debugs(2, DBG_IMPORTANT, "unlinkdUnlink: write FD " << unlinkd_wfd << " failed: " << xstrerr(xerrno));
+ debugs(2, DBG_IMPORTANT, "ERROR: unlinkdUnlink: write FD " << unlinkd_wfd << " failed: " << xstrerr(xerrno));
safeunlink(path, 0);
return;
} else if (bytes_written != l) {
if (hIpc) {
if (WaitForSingleObject(hIpc, 5000) != WAIT_OBJECT_0) {
getCurrentTime();
- debugs(2, DBG_IMPORTANT, "unlinkdClose: WARNING: (unlinkd," << pid << "d) didn't exit in 5 seconds");
+ debugs(2, DBG_IMPORTANT, "WARNING: unlinkdClose: (unlinkd," << pid << "d) didn't exit in 5 seconds");
}
CloseHandle(hIpc);
}
if (srv->wccp2_security_type != WCCP2_MD5_SECURITY) {
- debugs(80, DBG_IMPORTANT, "wccp2_check_security: invalid security option");
+ debugs(80, DBG_IMPORTANT, "ERROR: wccp2_check_security: invalid security option");
return 0;
}
break;
default:
- debugs(80, DBG_IMPORTANT, "Unknown record type in WCCPv2 Packet (" << ntohs(itemHeader->type) << ").");
+ debugs(80, DBG_IMPORTANT, "ERROR: Unknown record type in WCCPv2 Packet (" << ntohs(itemHeader->type) << ").");
}
offset += itemSize;
}
if (service_list_ptr == NULL) {
- debugs(80, DBG_IMPORTANT, "WCCPv2 Unknown service received from router (" << service_info->service_id << ")");
+ debugs(80, DBG_IMPORTANT, "ERROR: WCCPv2 Unknown service received from router (" << service_info->service_id << ")");
return;
}
if (ntohl(security_info->security_option) != ntohl(service_list_ptr->security_info->security_option)) {
- debugs(80, DBG_IMPORTANT, "Invalid security option in WCCPv2 Packet (" << ntohl(security_info->security_option) << " vs " << ntohl(service_list_ptr->security_info->security_option) << ").");
+ debugs(80, DBG_IMPORTANT, "ERROR: Invalid security option in WCCPv2 Packet (" << ntohl(security_info->security_option) << " vs " << ntohl(service_list_ptr->security_info->security_option) << ").");
return;
}
if (!wccp2_check_security(service_list_ptr, (char *) security_info, (char *) &wccp2_i_see_you, len)) {
- debugs(80, DBG_IMPORTANT, "Received WCCPv2 Packet failed authentication");
+ debugs(80, DBG_IMPORTANT, "ERROR: Received WCCPv2 Packet failed authentication");
return;
}
/* TODO: check return/forwarding methods */
if (router_capability_header == NULL) {
if ((Config.Wccp2.return_method != WCCP2_PACKET_RETURN_METHOD_GRE) || (Config.Wccp2.forwarding_method != WCCP2_FORWARDING_METHOD_GRE)) {
- debugs(80, DBG_IMPORTANT, "wccp2HandleUdp: fatal error - A WCCP router does not support the forwarding method specified, only GRE supported");
+ debugs(80, DBG_IMPORTANT, "ERROR: wccp2HandleUdp: fatal error - A WCCP router does not support the forwarding method specified, only GRE supported");
wccp2ConnectionClose();
return;
}
case WCCP2_CAPABILITY_FORWARDING_METHOD:
if (!(ntohl(router_capability_element->capability_value) & Config.Wccp2.forwarding_method)) {
- debugs(80, DBG_IMPORTANT, "wccp2HandleUdp: fatal error - A WCCP router has specified a different forwarding method " << ntohl(router_capability_element->capability_value) << ", expected " << Config.Wccp2.forwarding_method);
+ debugs(80, DBG_IMPORTANT, "ERROR: wccp2HandleUdp: fatal error - A WCCP router has specified a different forwarding method " << ntohl(router_capability_element->capability_value) << ", expected " << Config.Wccp2.forwarding_method);
wccp2ConnectionClose();
return;
}
case WCCP2_CAPABILITY_ASSIGNMENT_METHOD:
if (!(ntohl(router_capability_element->capability_value) & Config.Wccp2.assignment_method)) {
- debugs(80, DBG_IMPORTANT, "wccp2HandleUdp: fatal error - A WCCP router has specified a different assignment method " << ntohl(router_capability_element->capability_value) << ", expected "<< Config.Wccp2.assignment_method);
+ debugs(80, DBG_IMPORTANT, "ERROR: wccp2HandleUdp: fatal error - A WCCP router has specified a different assignment method " << ntohl(router_capability_element->capability_value) << ", expected "<< Config.Wccp2.assignment_method);
wccp2ConnectionClose();
return;
}
case WCCP2_CAPABILITY_RETURN_METHOD:
if (!(ntohl(router_capability_element->capability_value) & Config.Wccp2.return_method)) {
- debugs(80, DBG_IMPORTANT, "wccp2HandleUdp: fatal error - A WCCP router has specified a different return method " << ntohl(router_capability_element->capability_value) << ", expected " << Config.Wccp2.return_method);
+ debugs(80, DBG_IMPORTANT, "ERROR: wccp2HandleUdp: fatal error - A WCCP router has specified a different return method " << ntohl(router_capability_element->capability_value) << ", expected " << Config.Wccp2.return_method);
wccp2ConnectionClose();
return;
}
break; // ignore silently for now
default:
- debugs(80, DBG_IMPORTANT, "Unknown capability type in WCCPv2 Packet (" << ntohs(router_capability_element->capability_type) << ").");
+ debugs(80, DBG_IMPORTANT, "ERROR: Unknown capability type in WCCPv2 Packet (" << ntohs(router_capability_element->capability_type) << ").");
}
router_capability_data_current += elementSize;
/* Snarf the method */
if ((t = ConfigParser::NextToken()) == NULL) {
- debugs(80, DBG_CRITICAL, "wccp2_*_method: missing setting.");
+ debugs(80, DBG_CRITICAL, "ERROR: wccp2_*_method: missing setting.");
self_destruct();
return;
}
} else if (strcmp(t, "l2") == 0 || strcmp(t, "2") == 0) {
*method = WCCP2_METHOD_L2;
} else {
- debugs(80, DBG_CRITICAL, "wccp2_*_method: unknown setting, got " << t );
+ debugs(80, DBG_CRITICAL, "ERROR: wccp2_*_method: unknown setting, got " << t );
self_destruct();
}
}
/* Snarf the method */
if ((t = ConfigParser::NextToken()) == NULL) {
- debugs(80, DBG_CRITICAL, "wccp2_assignment_method: missing setting.");
+ debugs(80, DBG_CRITICAL, "ERROR: wccp2_assignment_method: missing setting.");
self_destruct();
return;
}
} else if (strcmp(t, "mask") == 0 || strcmp(t, "2") == 0) {
*method = WCCP2_ASSIGNMENT_METHOD_MASK;
} else {
- debugs(80, DBG_CRITICAL, "wccp2_assignment_method: unknown setting, got " << t );
+ debugs(80, DBG_CRITICAL, "ERROR: wccp2_assignment_method: unknown setting, got " << t );
self_destruct();
}
}
/* Snarf the type */
if ((t = ConfigParser::NextToken()) == NULL) {
- debugs(80, DBG_CRITICAL, "wccp2ParseServiceInfo: missing service info type (standard|dynamic)");
+ debugs(80, DBG_CRITICAL, "ERROR: wccp2ParseServiceInfo: missing service info type (standard|dynamic)");
self_destruct();
return;
}
} else if (strcmp(t, "dynamic") == 0) {
service = WCCP2_SERVICE_DYNAMIC;
} else {
- debugs(80, DBG_CRITICAL, "wccp2ParseServiceInfo: bad service info type (expected standard|dynamic, got " << t << ")");
+ debugs(80, DBG_CRITICAL, "ERROR: wccp2ParseServiceInfo: bad service info type (expected standard|dynamic, got " << t << ")");
self_destruct();
return;
}
projects / thirdparty / squid.git / commitdiff
