id.lang \
it.lang \
ja.lang \
+ ka.lang \
ko.lang \
lt.lang \
lv.lang \
/* Password incorrect */
printf("ERR Wrong password\n");
#else
- } else {
+ }
+ else {
/* Password incorrect */
printf("BH message=\"Missing crypto capability\"\n");
#endif
#include "mgr/Registration.h"
#include "neighbors.h"
#include "pconn.h"
-#include "PeerSelectState.h"
#include "PeerPoolMgr.h"
+#include "PeerSelectState.h"
#include "SquidConfig.h"
#include "SquidTime.h"
#include "Store.h"
typedef void (FwdState::*Method)(Ssl::PeerConnectorAnswer &);
FwdStatePeerAnswerDialer(Method method, FwdState *fwd):
- method_(method), fwd_(fwd), answer_() {}
+ method_(method), fwd_(fwd), answer_() {}
/* CallDialer API */
virtual bool canDial(AsyncCall &call) { return fwd_.valid(); }
void dial(AsyncCall &call) { ((&(*fwd_))->*method_)(answer_); }
virtual void print(std::ostream &os) const {
- os << '(' << fwd_.get() << ", " << answer_ << ')'; }
+ os << '(' << fwd_.get() << ", " << answer_ << ')';
+ }
/* Ssl::PeerConnector::CbDialer API */
virtual Ssl::PeerConnectorAnswer &answer() { return answer_; }
};
#endif
-
void
FwdState::abort(void* d)
{
HttpRequest::Pointer requestPointer = request;
AsyncCall::Pointer callback = asyncCall(17,4,
- "FwdState::ConnectedToPeer",
- FwdStatePeerAnswerDialer(&FwdState::connectedToPeer, this));
+ "FwdState::ConnectedToPeer",
+ FwdStatePeerAnswerDialer(&FwdState::connectedToPeer, this));
Ssl::PeerConnector *connector =
new Ssl::PeerConnector(requestPointer, serverConnection(), callback);
AsyncJob::Start(connector); // will call our callback
{
public:
MyAnswerDialer(const JobPointer &aJob, Method aMethod):
-
UnaryMemFunT<PeerPoolMgr, Ssl::PeerConnectorAnswer, Ssl::PeerConnectorAnswer&>(aJob, aMethod, Ssl::PeerConnectorAnswer()) {}
+ UnaryMemFunT<PeerPoolMgr, Ssl::PeerConnectorAnswer, Ssl::PeerConnectorAnswer&>(aJob, aMethod, Ssl::PeerConnectorAnswer()) {}
/* Ssl::PeerConnector::CbDialer API */
virtual Ssl::PeerConnectorAnswer &answer() { return arg1; }
}
bool
-PeerPoolMgr::validPeer() const {
+PeerPoolMgr::validPeer() const
+{
return peer && cbdataReferenceValid(peer) && peer->standby.pool;
}
class CommConnectCbParams;
#if USE_OPENSSL
-namespace Ssl {
- class PeerConnectorAnswer;
+namespace Ssl
+{
+class PeerConnectorAnswer;
}
#endif
return SBuf(tmpbuf);
}
-
/*
* aclIpAddrNetworkCompare - The guts of the comparison for IP ACLs
* matching checks. The first argument (p) is a "host" address,
bool ftpEpsvIsDeprecatedRule = false;
char *t = ConfigParser::PeekAtToken();
- if (!t){
+ if (!t) {
self_destruct();
return;
}
// 2) if this line is "ftp_epsv on|off" and already exist rules of "ftp_epsv allow|deny ..."
// then abort
if ((!ftpEpsvIsDeprecatedRule && FtpEspvDeprecated) ||
- (ftpEpsvIsDeprecatedRule && !FtpEspvDeprecated && *ftp_epsv != NULL)) {
+ (ftpEpsvIsDeprecatedRule && !FtpEspvDeprecated && *ftp_epsv != NULL)) {
debugs(3, DBG_CRITICAL, "FATAL: do not mix \"ftp_epsv on|off\" cfg lines with \"ftp_epsv allow|deny ...\" cfg lines. Update your ftp_epsv rules.");
self_destruct();
}
#include "squid.h"
#include "cbdata.h"
+#include "Generic.h"
#include "mgr/Registration.h"
#include "Store.h"
-#include "Generic.h"
#include <climits>
#if USE_CBDATA_DEBUG
for (int i = 0; i < var.length(); ++i) {
switch (var[i]) {
- case '"':
- case '\\':
- esc += '\\';
- default:
- esc += var[i];
+ case '"':
+ case '\\':
+ esc += '\\';
+ default:
+ esc += var[i];
}
}
{
assert(request);
const Http::StatusCode status = request->flags.needValidation ?
- Http::scGatewayTimeout : Http::scServiceUnavailable;
+ Http::scGatewayTimeout : Http::scServiceUnavailable;
return new ErrorState(type, status, request);
}
case 'M':
if (request) {
- const SBuf &m = request->method.image();
- mb.append(m.rawContent(), m.length());
+ const SBuf &m = request->method.image();
+ mb.append(m.rawContent(), m.length());
} else if (!building_deny_info_url)
p = "[unknown method]";
break;
Eui::Eui64::decode(const char *asc)
{
if (eui64_aton(asc, (struct eui64 *)eui) != 0) {
- debugs(28, 4, "id=" << (void*)this << " decode fail on " << asc);
- return false;
+ debugs(28, 4, "id=" << (void*)this << " decode fail on " << asc);
+ return false;
}
debugs(28, 4, "id=" << (void*)this << " ATON decoded " << asc);
str = request->urlpath.termedBuf();
break;
- case Format::LFT_CLIENT_REQ_METHOD:
- {
- const SBuf &s = request->method.image();
- sb.append(s.rawContent(), s.length());
- }
- str = sb.termedBuf();
- break;
+ case Format::LFT_CLIENT_REQ_METHOD: {
+ const SBuf &s = request->method.image();
+ sb.append(s.rawContent(), s.length());
+ }
+ str = sb.termedBuf();
+ break;
case Format::LFT_ADAPTED_REQUEST_HEADER:
if (format->header_id == -1)
out = "%";
break;
- // XXX: external_acl_type format tokens which are not output by logformat.
- // They are listed here because the switch requires
- // every ByteCode_t to be explicitly enumerated.
- // But do not output due to lack of access to the values.
+ // XXX: external_acl_type format tokens which are not output by logformat.
+ // They are listed here because the switch requires
+ // every ByteCode_t to be explicitly enumerated.
+ // But do not output due to lack of access to the values.
case LFT_EXT_ACL_USER_CERT_RAW:
case LFT_EXT_ACL_USER_CERTCHAIN_RAW:
case LFT_EXT_ACL_USER_CERT:
}
Format::Token::Token() : type(LFT_NONE),
- label(NULL),
- widthMin(-1),
- widthMax(-1),
- quote(LOG_QUOTE_NONE),
- left(false),
- space(false),
- zero(false),
- divisor(1),
- next(NULL)
+ label(NULL),
+ widthMin(-1),
+ widthMax(-1),
+ quote(LOG_QUOTE_NONE),
+ left(false),
+ space(false),
+ zero(false),
+ divisor(1),
+ next(NULL)
{
data.string = NULL;
- data.header.header = NULL;
+ data.header.header = NULL;
data.header.element = NULL;
data.header.separator = ',';
}
-
-
Format::Token::~Token()
{
label = NULL; // drop reference to global static.
}
}
}
- break;
+ break;
}
ftpState->writeCommand(cbuf);
{
switch (status) {
- // 000
+ // 000
case Http::scNone:
return "Init"; /* we init .status with code 0 */
break;
- // 100-199
+ // 100-199
case Http::scContinue:
return "Continue";
break;
return "Processing";
break;
- // 200-299
+ // 200-299
case Http::scOkay:
return "OK";
break;
return "IM Used";
break;
- // 300-399
+ // 300-399
case Http::scMultipleChoices:
return "Multiple Choices";
break;
return "Permanent Redirect";
break;
- // 400-499
+ // 400-499
case Http::scBadRequest:
return "Bad Request";
break;
return "Request Header Fields Too Large";
break;
- // 500-599
+ // 500-599
case Http::scInternalServerError:
return "Internal Server Error";
break;
return "Network Authentication Required";
break;
- // 600+
+ // 600+
case Http::scInvalidHeader:
case Http::scHeaderTooLarge:
// fall through to default.
fatal("Need to add -DMALLOC_DBG when compiling to use -mX option");
#endif
- }
+ }
break;
case 'n':
* A caller with a non-retriable transaction should set keepOpen to false
* and call pop() anyway, even though the caller does not want a pconn.
* This forces us to close an available persistent connection, avoiding
- * creating a growing number of open connections when many transactions
+ * creating a growing number of open connections when many transactions
* create (and push) persistent connections but are not retriable and,
* hence, do not need to pop a connection.
*/
#include "globals.h"
#include "HttpRequest.h"
#include "neighbors.h"
+#include "SquidConfig.h"
#include "ssl/cert_validate_message.h"
#include "ssl/Config.h"
#include "ssl/ErrorDetail.h"
#include "ssl/PeerConnector.h"
#include "ssl/ServerBump.h"
#include "ssl/support.h"
-#include "SquidConfig.h"
CBDATA_NAMESPACED_CLASS_INIT(Ssl, PeerConnector);
HttpRequestPointer &aRequest,
const Comm::ConnectionPointer &aServerConn,
AsyncCall::Pointer &aCallback):
- AsyncJob("Ssl::PeerConnector"),
- request(aRequest),
- serverConn(aServerConn),
- callback(aCallback)
+ AsyncJob("Ssl::PeerConnector"),
+ request(aRequest),
+ serverConn(aServerConn),
+ callback(aCallback)
{
// if this throws, the caller's cb dialer is not our CbDialer
Must(dynamic_cast<CbDialer*>(callback->getDialer()));
int ssl_error = SSL_get_error(ssl, ret);
#ifdef EPROTO
- int sysErrNo = EPROTO;
+ int sysErrNo = EPROTO;
#else
- int sysErrNo = EACCES;
+ int sysErrNo = EACCES;
#endif
- switch (ssl_error) {
+ switch (ssl_error) {
- case SSL_ERROR_WANT_READ:
- Comm::SetSelect(fd, COMM_SELECT_READ, &NegotiateSsl, this, 0);
- return;
+ case SSL_ERROR_WANT_READ:
+ Comm::SetSelect(fd, COMM_SELECT_READ, &NegotiateSsl, this, 0);
+ return;
- case SSL_ERROR_WANT_WRITE:
- Comm::SetSelect(fd, COMM_SELECT_WRITE, &NegotiateSsl, this, 0);
- return;
+ case SSL_ERROR_WANT_WRITE:
+ Comm::SetSelect(fd, COMM_SELECT_WRITE, &NegotiateSsl, this, 0);
+ return;
- case SSL_ERROR_SSL:
- case SSL_ERROR_SYSCALL:
- ssl_lib_error = ERR_get_error();
+ case SSL_ERROR_SSL:
+ case SSL_ERROR_SYSCALL:
+ ssl_lib_error = ERR_get_error();
- // store/report errno when ssl_error is SSL_ERROR_SYSCALL, ssl_lib_error is 0, and ret is -1
- if (ssl_error == SSL_ERROR_SYSCALL && ret == -1 && ssl_lib_error == 0)
- sysErrNo = errno;
+ // store/report errno when ssl_error is SSL_ERROR_SYSCALL, ssl_lib_error is 0, and ret is -1
+ if (ssl_error == SSL_ERROR_SYSCALL && ret == -1 && ssl_lib_error == 0)
+ sysErrNo = errno;
- debugs(83, DBG_IMPORTANT, "Error negotiating SSL on FD " << fd <<
- ": " << ERR_error_string(ssl_lib_error, NULL) << " (" <<
- ssl_error << "/" << ret << "/" << errno << ")");
+ debugs(83, DBG_IMPORTANT, "Error negotiating SSL on FD " << fd <<
+ ": " << ERR_error_string(ssl_lib_error, NULL) << " (" <<
+ ssl_error << "/" << ret << "/" << errno << ")");
- break; // proceed to the general error handling code
+ break; // proceed to the general error handling code
- default:
- break; // no special error handling for all other errors
- }
+ default:
+ break; // no special error handling for all other errors
+ }
ErrorState *const anErr = ErrorState::NewForwarding(ERR_SECURE_CONNECT_FAIL, request.getRaw());
anErr->xerrno = sysErrNo;
ScheduleCallHere(cb);
}
-
void
Ssl::PeerConnector::swanSong()
{
#ifndef SQUID_SSL_PEER_CONNECTOR_H
#define SQUID_SSL_PEER_CONNECTOR_H
-#include "base/AsyncJob.h"
#include "base/AsyncCbdataCalls.h"
+#include "base/AsyncJob.h"
#include "ssl/support.h"
#include <iosfwd>
class HttpRequest;
class ErrorState;
-namespace Ssl {
+namespace Ssl
+{
class ErrorDetail;
class CertValidationResponse;
/// PeerConnector results (supplied via a callback).
/// The connection to peer was secured if and only if the error member is nil.
-class PeerConnectorAnswer {
+class PeerConnectorAnswer
+{
public:
~PeerConnectorAnswer(); ///< deletes error if it is still set
Comm::ConnectionPointer conn; ///< peer connection (secured on success)
\par
* This job never closes the connection, even on errors. If a 3rd-party
* closes the connection, this job simply quits without informing the caller.
-*/
+*/
class PeerConnector: virtual public AsyncJob
{
public:
/// Callback dialier API to allow PeerConnector to set the answer.
- class CbDialer {
+ class CbDialer
+ {
public:
virtual ~CbDialer() {}
/// gives PeerConnector access to the in-dialer answer
/// mimics FwdState to minimize changes to FwdState::initiate/negotiateSsl
Comm::ConnectionPointer const &serverConnection() const { return serverConn; }
- void bail(ErrorState *error); ///< Return an error to the PeerConnector caller
+ void bail(ErrorState *error); ///< Return an error to the PeerConnector caller
/// Callback the caller class, and pass the ready to communicate secure
/// connection or an error if PeerConnector failed.
tests/stub_mem.cc \
tests/stub_mem_node.cc \
tests/stub_mime.cc \
+ tests/stub_neighbors.cc \
tests/stub_pconn.cc \
tests/stub_redirect.cc \
tests/stub_stat.cc \
typedef void (TunnelStateData::*Method)(Ssl::PeerConnectorAnswer &);
MyAnswerDialer(Method method, TunnelStateData *tunnel):
- method_(method), tunnel_(tunnel), answer_() {}
+ method_(method), tunnel_(tunnel), answer_() {}
/* CallDialer API */
virtual bool canDial(AsyncCall &call) { return tunnel_.valid(); }
void dial(AsyncCall &call) { ((&(*tunnel_))->*method_)(answer_); }
virtual void print(std::ostream &os) const {
- os << '(' << tunnel_.get() << ", " << answer_ << ')'; }
+ os << '(' << tunnel_.get() << ", " << answer_ << ')';
+ }
/* Ssl::PeerConnector::CbDialer API */
virtual Ssl::PeerConnectorAnswer &answer() { return answer_; }
}
void
-TunnelStateData::connectToPeer() {
+TunnelStateData::connectToPeer()
+{
const Comm::ConnectionPointer &srv = server.conn;
#if USE_OPENSSL
if (CachePeer *p = srv->getPeer()) {
if (p->use_ssl) {
AsyncCall::Pointer callback = asyncCall(5,4,
- "TunnelStateData::ConnectedToPeer",
- MyAnswerDialer(&TunnelStateData::connectedToPeer, this));
+ "TunnelStateData::ConnectedToPeer",
+ MyAnswerDialer(&TunnelStateData::connectedToPeer, this));
Ssl::PeerConnector *connector =
new Ssl::PeerConnector(request, srv, callback);
AsyncJob::Start(connector); // will call our callback
snprintf(urlbuf, MAX_URL, "%s:%d", request->GetHost(), request->port);
break;
- default:
- {
- portbuf[0] = '\0';
-
- if (request->port != urlDefaultPort(request->url.getScheme()))
- snprintf(portbuf, 32, ":%d", request->port);
-
- snprintf(urlbuf, MAX_URL, "%s://%s%s%s%s" SQUIDSTRINGPH,
- request->url.getScheme().c_str(),
- request->login,
- *request->login ? "@" : null_string,
- request->GetHost(),
- portbuf,
- SQUIDSTRINGPRINT(request->urlpath));
- }
+ default: {
+ portbuf[0] = '\0';
+
+ if (request->port != urlDefaultPort(request->url.getScheme()))
+ snprintf(portbuf, 32, ":%d", request->port);
+
+ snprintf(urlbuf, MAX_URL, "%s://%s%s%s%s" SQUIDSTRINGPH,
+ request->url.getScheme().c_str(),
+ request->login,
+ *request->login ? "@" : null_string,
+ request->GetHost(),
+ portbuf,
+ SQUIDSTRINGPRINT(request->urlpath));
+ }
}
}
snprintf(buf, MAX_URL, "%s:%d", request->GetHost(), request->port);
break;
- default:
- {
- portbuf[0] = '\0';
-
- if (request->port != urlDefaultPort(request->url.getScheme()))
- snprintf(portbuf, 32, ":%d", request->port);
+ default: {
+ portbuf[0] = '\0';
- loginbuf[0] = '\0';
+ if (request->port != urlDefaultPort(request->url.getScheme()))
+ snprintf(portbuf, 32, ":%d", request->port);
- if ((int) strlen(request->login) > 0) {
- strcpy(loginbuf, request->login);
+ loginbuf[0] = '\0';
- if ((t = strchr(loginbuf, ':')))
- *t = '\0';
+ if ((int) strlen(request->login) > 0) {
+ strcpy(loginbuf, request->login);
- strcat(loginbuf, "@");
- }
+ if ((t = strchr(loginbuf, ':')))
+ *t = '\0';
- snprintf(buf, MAX_URL, "%s://%s%s%s" SQUIDSTRINGPH,
- request->url.getScheme().c_str(),
- loginbuf,
- request->GetHost(),
- portbuf,
- SQUIDSTRINGPRINT(request->urlpath));
-
- // strip arguments AFTER a question-mark
- if (Config.onoff.strip_query_terms)
- if ((t = strchr(buf, '?')))
- *(++t) = '\0';
+ strcat(loginbuf, "@");
}
+
+ snprintf(buf, MAX_URL, "%s://%s%s%s" SQUIDSTRINGPH,
+ request->url.getScheme().c_str(),
+ loginbuf,
+ request->GetHost(),
+ portbuf,
+ SQUIDSTRINGPRINT(request->urlpath));
+
+ // strip arguments AFTER a question-mark
+ if (Config.onoff.strip_query_terms)
+ if ((t = strchr(buf, '?')))
+ *(++t) = '\0';
+ }
}
}
{
public:
TheConfig() :
- ioTimeout(120),
- localHost(NULL),
- port(CACHE_HTTP_PORT),
- tlsEnabled(false),
- tlsAnonymous(false)
- {
+ ioTimeout(120),
+ localHost(NULL),
+ port(CACHE_HTTP_PORT),
+ tlsEnabled(false),
+ tlsAnonymous(false) {
params = "NORMAL";
hostname = "localhost";
}
<< "Usage: " << progname << " [Basic Options] [HTTP Options]" << std::endl
<< std::endl;
std::cerr
- << " -s | --quiet Silent. Do not print response message to stdout." << std::endl
- << " -v | --verbose Verbose debugging. Repeat (-vv) to increase output level." << std::endl
- << " Levels:" << std::endl
- << " 1 - Print outgoing request message to stderr." << std::endl
- << " 2 - Print action trace to stderr." << std::endl
- << " --help Display this help text." << std::endl
- << std::endl;
+ << " -s | --quiet Silent. Do not print response message to stdout." << std::endl
+ << " -v | --verbose Verbose debugging. Repeat (-vv) to increase output level." << std::endl
+ << " Levels:" << std::endl
+ << " 1 - Print outgoing request message to stderr." << std::endl
+ << " 2 - Print action trace to stderr." << std::endl
+ << " --help Display this help text." << std::endl
+ << std::endl;
Transport::Config.usage();
Ping::Config.usage();
std::cerr
projects / thirdparty / squid.git / commitdiff
