void
preinitObject()
{
CONFIG_VARIABLE_SETTABLE(idleTime, CONFIG_TIME, configIntSetter,
"Time to remain idle before writing out.");
CONFIG_VARIABLE_SETTABLE(maxWriteoutWhenIdle, CONFIG_INT, configIntSetter,
"Amount of data to write at a time when idle.");
CONFIG_VARIABLE_SETTABLE(maxObjectsWhenIdle, CONFIG_INT, configIntSetter,
"Number of objects to write at a time "
"when idle.");
CONFIG_VARIABLE_SETTABLE(cacheIsShared, CONFIG_BOOLEAN, configIntSetter,
"If false, ignore s-maxage and private.");
CONFIG_VARIABLE_SETTABLE(mindlesslyCacheVary, CONFIG_BOOLEAN,
configIntSetter,
"If true, mindlessly cache negotiated objects.");
CONFIG_VARIABLE(objectHashTableSize, CONFIG_INT,
"Size of the object hash table (0 = auto).");
CONFIG_VARIABLE(objectHighMark, CONFIG_INT,
"High object count mark.");
CONFIG_VARIABLE(publicObjectLowMark, CONFIG_INT,
"Low object count mark (0 = auto).");
CONFIG_VARIABLE_SETTABLE(maxExpiresAge, CONFIG_TIME, configIntSetter,
"Max age for objects with Expires header.");
CONFIG_VARIABLE_SETTABLE(maxAge, CONFIG_TIME, configIntSetter,
"Max age for objects without Expires header.");
CONFIG_VARIABLE_SETTABLE(maxAgeFraction, CONFIG_FLOAT, configFloatSetter,
"Fresh fraction of modification time.");
CONFIG_VARIABLE_SETTABLE(maxNoModifiedAge, CONFIG_TIME, configIntSetter,
"Max age for objects without Last-modified.");
CONFIG_VARIABLE_SETTABLE(dontCacheCookies, CONFIG_BOOLEAN, configIntSetter,
"Work around cachable cookies.");
}
void preinitChunks()
{
CONFIG_VARIABLE(chunkLowMark, CONFIG_INT,
"Low mark for chunk memory (0 = auto).");
CONFIG_VARIABLE(chunkCriticalMark, CONFIG_INT,
"Critical mark for chunk memory (0 = auto).");
CONFIG_VARIABLE(chunkHighMark, CONFIG_INT,
"High mark for chunk memory.");
}
void
preinitSplitTunneling(void)
{
CONFIG_VARIABLE(splitTunnelingDnsServer, CONFIG_ATOM_LOWER,
"The name server to use with split tunneling over SOCKS.");
CONFIG_VARIABLE(splitTunnelingFile, CONFIG_ATOM,
"Local networks file for split tunneling");
CONFIG_VARIABLE(psiphonServer, CONFIG_ATOM_LOWER,
"Local networks file for split tunneling");
return;
}
void preinitDns()
{
assert(sizeof(struct in_addr) == 4);
CONFIG_VARIABLE(dnsGethostbynameTtl, CONFIG_TIME,
"TTL for gethostbyname addresses.");
}
void
preinitLog()
{
CONFIG_VARIABLE_SETTABLE(logLevel, CONFIG_HEX, configIntSetter,
"Logging level (max = " STR(LOGGING_MAX) ").");
CONFIG_VARIABLE(logFile, CONFIG_ATOM, "Log file (stderr if empty).");
logF = stderr;
}
void preinitLocal()
{
atomInitForbidden = internAtom("init-forbidden");
atomReopenLog = internAtom("reopen-log");
atomDiscardObjects = internAtom("discard-objects");
atomWriteoutObjects = internAtom("writeout-objects");
atomFreeChunkArenas = internAtom("free-chunk-arenas");
CONFIG_VARIABLE(disableLocalInterface, CONFIG_BOOLEAN,
"Disable the local configuration pages.");
CONFIG_VARIABLE(disableConfiguration, CONFIG_BOOLEAN,
"Disable reconfiguring Polipo at runtime.");
CONFIG_VARIABLE(disableIndexing, CONFIG_BOOLEAN,
"Disable indexing of the local cache.");
CONFIG_VARIABLE(disableServersList, CONFIG_BOOLEAN,
"Disable the list of known servers.");
}
void
preinitHttpParser()
{
CONFIG_VARIABLE_SETTABLE(censorReferer, CONFIG_TRISTATE, configIntSetter,
"Censor referer headers.");
censoredHeaders = makeAtomList(NULL, 0);
if(censoredHeaders == NULL) {
do_log(L_ERROR, "Couldn't allocate censored atoms.\n");
exit(1);
}
CONFIG_VARIABLE(censoredHeaders, CONFIG_ATOM_LIST_LOWER,
"Headers to censor.");
CONFIG_VARIABLE_SETTABLE(laxHttpParser, CONFIG_BOOLEAN, configIntSetter,
"Ignore unknown HTTP headers.");
}
void
preinitDns()
{
#ifdef HAVE_IPv6
int fd;
#endif
assert(sizeof(struct in_addr) == 4);
#ifdef HAVE_IPv6
assert(sizeof(struct in6_addr) == 16);
#endif
#ifndef NO_STANDARD_RESOLVER
CONFIG_VARIABLE(dnsGethostbynameTtl, CONFIG_TIME,
"TTL for gethostbyname addresses.");
#endif
#ifdef HAVE_IPv6
fd = socket(PF_INET6, SOCK_STREAM, 0);
if(fd < 0) {
if(errno == EPROTONOSUPPORT || errno == EAFNOSUPPORT) {
dnsQueryIPv6 = 0;
} else {
do_log_error(L_WARN, errno, "DNS: couldn't create socket");
}
} else {
close(fd);
}
#endif
#ifndef NO_FANCY_RESOLVER
parseResolvConf("/etc/resolv.conf");
if(dnsNameServer == NULL || dnsNameServer->string[0] == '\0')
dnsNameServer = internAtom("127.0.0.1");
CONFIG_VARIABLE(dnsMaxTimeout, CONFIG_TIME,
"Max timeout for DNS queries.");
CONFIG_VARIABLE(dnsNegativeTtl, CONFIG_TIME,
"TTL for negative DNS replies with no TTL.");
CONFIG_VARIABLE(dnsNameServer, CONFIG_ATOM_LOWER,
"The name server to use.");
#ifndef NO_STANDARD_RESOLVER
CONFIG_VARIABLE(dnsUseGethostbyname, CONFIG_TETRASTATE,
"Use the system resolver.");
#endif
#endif
#ifdef HAVE_IPv6
CONFIG_VARIABLE(dnsQueryIPv6, CONFIG_TETRASTATE,
"Query for IPv6 addresses.");
#endif
}
void
preinitIo()
{
#ifdef HAVE_IPV6_PREFER_TEMPADDR
CONFIG_VARIABLE_SETTABLE(useTemporarySourceAddress, CONFIG_TRISTATE,
configIntSetter,
"Prefer IPv6 temporary source address.");
#endif
CONFIG_VARIABLE(proxyOutgoingAddress, CONFIG_ATOM_LOWER,
"The IP address which the proxy connects from.");
#ifdef HAVE_WINSOCK
/* Load the winsock dll */
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD(2, 2);
int err = WSAStartup( wVersionRequested, &wsaData );
if (err != 0) {
do_log_error(L_ERROR, err, "Couldn't load winsock dll");
exit(-1);
}
#endif
return;
}
void
preinitHttp()
{
proxyAddress = internAtom("127.0.0.1");
CONFIG_VARIABLE_SETTABLE(disableProxy, CONFIG_BOOLEAN, configIntSetter,
"Whether to be a web server only.");
CONFIG_VARIABLE_SETTABLE(proxyOffline, CONFIG_BOOLEAN, configIntSetter,
"Avoid contacting remote servers.");
CONFIG_VARIABLE_SETTABLE(relaxTransparency, CONFIG_TRISTATE,
configIntSetter,
"Avoid contacting remote servers.");
CONFIG_VARIABLE(proxyPort, CONFIG_INT,
"The TCP port on which the proxy listens.");
CONFIG_VARIABLE(proxyAddress, CONFIG_ATOM_LOWER,
"The IP address on which the proxy listens.");
CONFIG_VARIABLE_SETTABLE(proxyName, CONFIG_ATOM_LOWER, configAtomSetter,
"The name by which the proxy is known.");
CONFIG_VARIABLE_SETTABLE(clientTimeout, CONFIG_TIME,
timeoutSetter, "Client-side timeout.");
CONFIG_VARIABLE_SETTABLE(serverTimeout, CONFIG_TIME,
timeoutSetter, "Server-side timeout.");
CONFIG_VARIABLE_SETTABLE(serverIdleTimeout, CONFIG_TIME,
timeoutSetter, "Server-side idle timeout.");
CONFIG_VARIABLE(authRealm, CONFIG_ATOM,
"Authentication realm.");
CONFIG_VARIABLE(displayName, CONFIG_ATOM,
"Server name displayed on error pages.");
CONFIG_VARIABLE(authCredentials, CONFIG_PASSWORD,
"username:password.");
CONFIG_VARIABLE(parentAuthCredentials, CONFIG_PASSWORD,
"username:password.");
CONFIG_VARIABLE(allowedClients, CONFIG_ATOM_LIST_LOWER,
"Networks from which clients are allowed to connect.");
CONFIG_VARIABLE(tunnelAllowedPorts, CONFIG_INT_LIST,
"Ports to which tunnelled connections are allowed.");
CONFIG_VARIABLE(allowedPorts, CONFIG_INT_LIST,
"Ports to which connections are allowed.");
CONFIG_VARIABLE(expectContinue, CONFIG_TRISTATE,
"Send Expect-Continue to servers.");
CONFIG_VARIABLE(bigBufferSize, CONFIG_INT,
"Size of big buffers (max size of headers).");
CONFIG_VARIABLE_SETTABLE(disableVia, CONFIG_BOOLEAN, configIntSetter,
"Don't use Via headers.");
CONFIG_VARIABLE(dontTrustVaryETag, CONFIG_TRISTATE,
"Whether to trust the ETag when there's Vary.");
preinitHttpParser();
}
int
main(int argc, char **argv)
{
FdEventHandlerPtr listener;
int i;
int rc;
int expire = 0, printConfig = 0;
initAtoms();
CONFIG_VARIABLE(daemonise, CONFIG_BOOLEAN, "Run as a daemon");
CONFIG_VARIABLE(pidFile, CONFIG_ATOM, "File with pid of running daemon.");
preinitChunks();
preinitLog();
preinitObject();
preinitIo();
preinitDns();
preinitServer();
preinitHttp();
preinitDiskcache();
preinitLocal();
preinitForbidden();
preinitSocks();
preinitOffline();
i = 1;
while(i < argc) {
if(argv[i][0] != '-')
break;
if(strcmp(argv[i], "--") == 0) {
i++;
break;
} else if(strcmp(argv[i], "-h") == 0) {
usage(argv[0]);
exit(0);
} else if(strcmp(argv[i], "-v") == 0) {
printConfig = 1;
i++;
} else if(strcmp(argv[i], "-x") == 0) {
expire = 1;
i++;
} else if(strcmp(argv[i], "-c") == 0) {
i++;
if(i >= argc) {
usage(argv[0]);
exit(1);
}
if(configFile)
releaseAtom(configFile);
configFile = internAtom(argv[i]);
i++;
} else {
usage(argv[0]);
exit(1);
}
}
if(configFile)
configFile = expandTilde(configFile);
if(configFile == NULL) {
configFile = expandTilde(internAtom("~/.polipo"));
if(configFile)
if(access(configFile->string, F_OK) < 0) {
releaseAtom(configFile);
configFile = NULL;
}
}
if(configFile == NULL) {
if(access("/etc/polipo/config", F_OK) >= 0)
configFile = internAtom("/etc/polipo/config");
if(configFile && access(configFile->string, F_OK) < 0) {
releaseAtom(configFile);
configFile = NULL;
}
}
rc = parseConfigFile(configFile);
if(rc < 0)
exit(1);
while(i < argc) {
rc = parseConfigLine(argv[i], "command line", 0, 0);
if(rc < 0)
exit(1);
i++;
}
initChunks();
initLog();
initObject();
if(!expire && !printConfig)
initEvents();
initIo();
initDns();
initHttp();
initServer();
initDiskcache();
initForbidden();
initSocks();
initOffline();
if(printConfig) {
printConfigVariables(stdout, 0);
exit(0);
}
if(expire) {
expireDiskObjects();
exit(0);
}
if(daemonise)
do_daemonise(logFile == NULL || logFile->length == 0);
if(pidFile)
writePid(pidFile->string);
listener = create_listener(proxyAddress->string,
proxyPort, httpAccept, NULL);
if(!listener) {
if(pidFile) unlink(pidFile->string);
exit(1);
}
eventLoop();
if(pidFile) unlink(pidFile->string);
return 0;
}
int psiphonMain(
int bindAll,
int proxyPortParam,
int localParentProxyPortParam)
{
FdEventHandlerPtr listener;
initAtoms();
CONFIG_VARIABLE(daemonise, CONFIG_BOOLEAN, "Run as a daemon");
CONFIG_VARIABLE(pidFile, CONFIG_ATOM, "File with pid of running daemon.");
preinitChunks();
preinitLog();
preinitObject();
preinitIo();
preinitDns();
preinitServer();
preinitHttp();
preinitDiskcache();
preinitLocal();
preinitForbidden();
preinitSocks();
const int MAX_SIZE = 80;
char proxyAddressParamLine[MAX_SIZE];
char proxyPortParamLine[MAX_SIZE];
char localParentProxyPortParamLine[MAX_SIZE];
snprintf(
proxyAddressParamLine,
MAX_SIZE,
(0 == bindAll) ? "proxyAddress=127.0.0.1" : "proxyAddress=0.0.0.0");
snprintf(
proxyPortParamLine,
MAX_SIZE,
"proxyPort=%d",
proxyPortParam);
snprintf(
localParentProxyPortParamLine,
MAX_SIZE,
"socksParentProxy=127.0.0.1:%d",
localParentProxyPortParam);
if (0 > parseConfigLine(proxyAddressParamLine, "psiphon", 0, 0)
|| 0 > parseConfigLine(proxyPortParamLine, "psiphon", 0, 0)
|| 0 > parseConfigLine(localParentProxyPortParamLine, "psiphon", 0, 0)
|| 0 > parseConfigLine("disableLocalInterface=true", "psiphon", 0, 0)
|| 0 > parseConfigLine("logLevel=1", "psiphon", 0, 0)
/* Allow HTTPS on all ports */
|| 0 > parseConfigLine("tunnelAllowedPorts=1-65535", "psiphon", 0, 0))
{
return -1;
}
initChunks();
initLog();
initObject();
initEvents();
initIo();
initDns();
initHttp();
initServer();
initDiskcache();
initForbidden();
initSocks();
listener = create_listener(
proxyAddress->string,
proxyPort,
httpAccept,
NULL);
if (!listener)
{
return -1;
}
eventLoop();
return 0;
}
