void
nsHttpConnectionInfo::SetOriginServer(const nsACString &host, int32_t port)
{
mOrigin = host;
mOriginPort = port == -1 ? DefaultPort() : port;
BuildHashKey();
}
void
nsHttpConnectionInfo::SetOriginServer(const nsACString &host, int32_t port)
{
mHost = host;
mPort = port == -1 ? DefaultPort() : port;
//
// build hash key:
//
// the hash key uniquely identifies the connection type. two connections
// are "equal" if they end up talking the same protocol to the same server
// and are both used for anonymous or non-anonymous connection only;
// anonymity of the connection is setup later from nsHttpChannel::AsyncOpen
// where we know we use anonymous connection (LOAD_ANONYMOUS load flag)
//
const char *keyHost;
int32_t keyPort;
if (mUsingHttpProxy && !mUsingConnect) {
keyHost = ProxyHost();
keyPort = ProxyPort();
}
else {
keyHost = Host();
keyPort = Port();
}
mHashKey.AssignLiteral("....");
mHashKey.Append(keyHost);
mHashKey.Append(':');
mHashKey.AppendInt(keyPort);
if (mUsingHttpProxy)
mHashKey.SetCharAt('P', 0);
if (mUsingSSL)
mHashKey.SetCharAt('S', 1);
// NOTE: for transparent proxies (e.g., SOCKS) we need to encode the proxy
// info in the hash key (this ensures that we will continue to speak the
// right protocol even if our proxy preferences change).
//
// NOTE: for SSL tunnels add the proxy information to the cache key.
// We cannot use the proxy as the host parameter (as we do for non SSL)
// because this is a single host tunnel, but we need to include the proxy
// information so that a change in proxy config will mean this connection
// is not reused
if ((!mUsingHttpProxy && ProxyHost()) ||
(mUsingHttpProxy && mUsingConnect)) {
mHashKey.AppendLiteral(" (");
mHashKey.Append(ProxyType());
mHashKey.Append(':');
mHashKey.Append(ProxyHost());
mHashKey.Append(':');
mHashKey.AppendInt(ProxyPort());
mHashKey.Append(')');
}
}
UDPWrapper::UDPWrapper(int indx, const char* const _name) :
ControllerEmu::ControlGroup(_name,GROUP_TYPE_UDPWII),
inst(NULL), index(indx),
updIR(false),updAccel(false),
updButt(false),udpEn(false)
, port(DefaultPort(indx))
{
//PanicAlert("UDPWrapper #%d ctor",index);
}
void UDPWrapper::SaveConfig(IniFile::Section *sec, const std::string& defdev, const std::string& base )
{
ControlGroup::SaveConfig(sec,defdev,base);
std::string group( base + name ); group += "/";
sec->Set((group + "Enable").c_str(), (int)udpEn, 0);
sec->Set((group + "Port").c_str(), port, DefaultPort(index));
sec->Set((group + "Update_Accel").c_str(), (int)updAccel, 1);
sec->Set((group + "Update_IR").c_str(), (int)updIR, 1);
sec->Set((group + "Update_Butt").c_str(), (int)updButt, 1);
sec->Set((group + "Update_Nunchuk").c_str(), (int)updNun, 1);
sec->Set((group + "Update_NunchukAccel").c_str(), (int)updNunAccel, 0);
}
void
nsHttpConnectionInfo::SetOriginServer(const nsACString &host, PRInt32 port)
{
mHost = host;
mPort = port == -1 ? DefaultPort() : port;
//
// build hash key:
//
// the hash key uniquely identifies the connection type. two connections
// are "equal" if they end up talking the same protocol to the same server
// and are both used for anonymous or non-anonymous connection only;
// anonymity of the connection is setup later from nsHttpChannel::AsyncOpen
// where we know we use anonymous connection (LOAD_ANONYMOUS load flag)
//
const char *keyHost;
PRInt32 keyPort;
if (mUsingHttpProxy && !mUsingSSL) {
keyHost = ProxyHost();
keyPort = ProxyPort();
}
else {
keyHost = Host();
keyPort = Port();
}
mHashKey.AssignLiteral("...");
mHashKey.Append(keyHost);
mHashKey.Append(':');
mHashKey.AppendInt(keyPort);
if (mUsingHttpProxy)
mHashKey.SetCharAt('P', 0);
if (mUsingSSL)
mHashKey.SetCharAt('S', 1);
// NOTE: for transparent proxies (e.g., SOCKS) we need to encode the proxy
// type in the hash key (this ensures that we will continue to speak the
// right protocol even if our proxy preferences change).
if (!mUsingHttpProxy && ProxyHost()) {
mHashKey.AppendLiteral(" (");
mHashKey.Append(ProxyType());
mHashKey.Append(')');
}
}
nsHttpConnectionInfo::nsHttpConnectionInfo(const nsACString &originHost,
int32_t originPort,
const nsACString &npnToken,
const nsACString &username,
nsProxyInfo *proxyInfo,
const NeckoOriginAttributes &originAttributes,
const nsACString &routedHost,
int32_t routedPort)
{
mEndToEndSSL = true; // so DefaultPort() works
mRoutedPort = routedPort == -1 ? DefaultPort() : routedPort;
if (!originHost.Equals(routedHost) || (originPort != routedPort)) {
mRoutedHost = routedHost;
}
Init(originHost, originPort, npnToken, username, proxyInfo, originAttributes, true);
}
char *HTTP_Open(URL *Url)
{
char *msg=NULL;
char *proxy=NULL;
char *server_host=NULL;
int server_port=-1;
/* Sort out the host. */
if(!IsLocalNetHost(Url->host))
proxy=ConfigStringURL(Proxies,Url);
if(proxy)
{
if(proxyUrl)
FreeURL(proxyUrl);
proxyUrl=NULL;
proxyUrl=CreateURL("http",proxy,"/",NULL,NULL,NULL);
server_host=proxyUrl->host;
server_port=proxyUrl->port;
}
else
{
server_host=Url->host;
server_port=Url->port;
}
if(server_port==-1)
server_port=DefaultPort(Url);
/* Open the connection. */
server=OpenClientSocket(server_host,server_port);
if(server==-1)
msg=GetPrintMessage(Warning,"Cannot open the HTTP connection to %s port %d; [%!s].",server_host,server_port);
else
{
init_io(server);
configure_io_timeout(server,ConfigInteger(SocketTimeout),ConfigInteger(SocketTimeout));
}
return(msg);
}
void UDPWrapper::LoadConfig(IniFile::Section *sec, const std::string& defdev, const std::string& base )
{
ControlGroup::LoadConfig(sec,defdev,base);
std::string group( base + name ); group += "/";
int _updAccel,_updIR,_updButt,_udpEn,_updNun,_updNunAccel;
sec->Get((group + "Enable").c_str(),&_udpEn, 0);
sec->Get((group + "Port").c_str(), &port, DefaultPort(index));
sec->Get((group + "Update_Accel").c_str(), &_updAccel, 1);
sec->Get((group + "Update_IR").c_str(), &_updIR, 1);
sec->Get((group + "Update_Butt").c_str(), &_updButt, 1);
sec->Get((group + "Update_Nunchuk").c_str(), &_updNun, 1);
sec->Get((group + "Update_NunchukAccel").c_str(), &_updNunAccel, 0);
udpEn=(_udpEn>0);
updAccel=(_updAccel>0);
updIR=(_updIR>0);
updButt=(_updButt>0);
updNun=(_updNun>0);
updNunAccel=(_updNunAccel>0);
Refresh();
}
URL *CreateURL(const char *proto,const char *hostport,const char *path,const char *args,const char *user,const char *pass)
{
URL *Url=(URL*)malloc(sizeof(URL));
int n=0,i;
char *colon,*temp;
/* Original URL */
Url->original_name=malloc(strlen(proto)+strlen(hostport)+strlen(path)+(args?strlen(args):0)+8);
Url->original_path=malloc(strlen(path)+1);
strcpy(Url->original_path,path);
if(args)
{
Url->original_args=malloc(strlen(args)+1);
strcpy(Url->original_args,args);
}
else
Url->original_args=NULL;
strcpy(Url->original_name,proto);
n=strlen(proto);
strcpy(Url->original_name+n,"://");
n+=3;
strcpy(Url->original_name+n,hostport);
n+=strlen(hostport);
Url->original_pathp=Url->original_name+n;
strcpy(Url->original_name+n,path);
n+=strlen(path);
if(args)
{
strcpy(Url->original_name+n,"?");
strcpy(Url->original_name+n+1,args);
}
/* proto = Url->proto */
Url->proto=(char*)malloc(strlen(proto)+1);
for(i=0;proto[i];i++)
Url->proto[i]=tolower(proto[i]);
Url->proto[i]=0;
/* hostport = Url->hostport */
temp=URLDecodeGeneric(hostport);
for(i=0;temp[i];i++)
if(isalpha(temp[i]))
temp[i]=tolower(temp[i]);
else if(!isalnum(temp[i]) && temp[i]!=':' && temp[i]!='-' &&
temp[i]!='.' && temp[i]!='[' && temp[i]!=']')
{temp[i]=0;break;}
Url->hostport=CanonicaliseHost(temp);
free(temp);
/* path = Url->path */
temp=URLDecodeGeneric(path);
CanonicaliseName(temp);
Url->path=URLEncodePath(temp);
free(temp);
/* args = Url->args */
if(args && *args)
Url->args=URLRecodeFormArgs(args);
else
Url->args=NULL;
/* user, pass = Url->user, Url->pass */
if(user) /* allow empty usernames */
Url->user=URLDecodeGeneric(user);
else
Url->user=NULL;
if(pass && *pass)
Url->pass=URLDecodeGeneric(pass);
else
Url->pass=NULL;
/* Hostname, port = Url->host, Url->port */
if(*Url->hostport=='[')
{
char *square=strchr(Url->hostport,']');
colon=strchr(square,':');
}
else
colon=strchr(Url->hostport,':');
if(colon)
{
int defport=DefaultPort(Url);
if(defport && atoi(colon+1)==defport)
*colon=0;
}
if(colon && *colon)
{
Url->host=(char*)malloc(colon-Url->hostport+1);
*colon=0;
strcpy(Url->host,Url->hostport);
*colon=':';
Url->port=atoi(colon+1);
}
else
{
Url->host=Url->hostport;
Url->port=-1;
}
/* Canonical URL = Url->name (and pointers Url->hostp, Url->pathp). */
Url->name=(char*)malloc(strlen(Url->proto)+
strlen(Url->hostport)+
strlen(Url->path)+
(Url->args?strlen(Url->args):0)+
8);
strcpy(Url->name,Url->proto);
n=strlen(Url->proto);
strcpy(Url->name+n,"://");
n+=3;
Url->hostp=Url->name+n;
strcpy(Url->name+n,Url->hostport);
n+=strlen(Url->hostport);
Url->pathp=Url->name+n;
strcpy(Url->name+n,Url->path);
n+=strlen(Url->path);
if(Url->args)
{
strcpy(Url->name+n,"?");
strcpy(Url->name+n+1,Url->args);
}
/* File name = Url->file */
if(Url->user)
{
char *encuserpass;
Url->file=(char*)malloc(strlen(Url->name)+
3*strlen(Url->user)+
(Url->pass?3*strlen(Url->pass):0)+
8);
n=Url->hostp-Url->name;
strncpy(Url->file,Url->name,(size_t)n);
encuserpass=URLEncodePassword(Url->user);
strcpy(Url->file+n,encuserpass);
n+=strlen(encuserpass);
free(encuserpass);
if(Url->pass)
{
encuserpass=URLEncodePassword(Url->pass);
strcpy(Url->file+n,":");
strcpy(Url->file+n+1,encuserpass);
n+=strlen(encuserpass)+1;
free(encuserpass);
}
strcpy(Url->file+n,"@");
strcpy(Url->file+n+1,Url->hostp);
}
else
Url->file=Url->name;
/* Host directory = Url->private_dir - Private data */
Url->private_dir=NULL;
/* Cache filename = Url->private_file - Private data */
Url->private_file=NULL;
/* Proxyable link = Url->private_link - Private data */
Url->private_link=NULL;
return(Url);
}
