/*
* Asynchronously create a new http connection for 'Url'
* We'll set some socket parameters; the rest will be set later
* when the IP is known.
* ( Data1 = Web structure )
* Return value: 0 on success, -1 otherwise
*/
static int Http_get(ChainLink *Info, void *Data1)
{
SocketData_t *S;
char *hostname;
S = a_Klist_get_data(ValidSocks, VOIDP2INT(Info->LocalKey));
/* Reference Web data */
S->web = Data1;
/* Reference Info data */
S->Info = Info;
/* Proxy support */
if (Http_must_use_proxy(S->web->url)) {
hostname = dStrdup(URL_HOST(HTTP_Proxy));
S->port = URL_PORT(HTTP_Proxy);
S->flags |= HTTP_SOCKET_USE_PROXY;
} else {
hostname = dStrdup(URL_HOST(S->web->url));
S->port = URL_PORT(S->web->url);
S->flags &= ~HTTP_SOCKET_USE_PROXY;
}
/* Let the user know what we'll do */
MSG_BW(S->web, 1, "DNS resolving %s", URL_HOST_(S->web->url));
/* Let the DNS engine resolve the hostname, and when done,
* we'll try to connect the socket from the callback function */
a_Dns_resolve(hostname, Http_dns_cb, Info->LocalKey);
dFree(hostname);
return 0;
}
void SimFieldDictionary::setFieldValue(StringTableEntry slotName, const char *value)
{
U32 bucket = getHashValue(slotName);
Entry **walk = &mHashTable[bucket];
while(*walk && (*walk)->slotName != slotName)
walk = &((*walk)->next);
Entry *field = *walk;
if( !value || !*value )
{
if(field)
{
mVersion++;
if( field->value )
dFree(field->value);
*walk = field->next;
freeEntry(field);
}
}
else
{
if(field)
{
if( field->value )
dFree(field->value);
field->value = dStrdup(value);
}
else
addEntry( bucket, slotName, 0, dStrdup( value ) );
}
}
ExecuteThread(const char *_executable, const char *_args /* = NULL */, const char *_directory /* = NULL */) : Thread(0, NULL, false, true)
{
zargs = dStrdup(_args);
directory = dStrdup(_directory);
executable = dStrdup(_executable);
start();
}
/*
* If the url belongs to a dpi server, return its name.
*/
static int Capi_url_uses_dpi(DilloUrl *url, char **server_ptr)
{
char *p, *server = NULL, *url_str = URL_STR(url);
Dstr *tmp;
if ((dStrncasecmp(url_str, "http:", 5) == 0) ||
(dStrncasecmp(url_str, "about:", 6) == 0)) {
/* URL doesn't use dpi (server = NULL) */
} else if (dStrncasecmp(url_str, "dpi:/", 5) == 0) {
/* dpi prefix, get this server's name */
if ((p = strchr(url_str + 5, '/')) != NULL) {
server = dStrndup(url_str + 5, (uint_t)(p - url_str - 5));
} else {
server = dStrdup("?");
}
if (strcmp(server, "bm") == 0) {
dFree(server);
server = dStrdup("bookmarks");
}
} else if ((p = strchr(url_str, ':')) != NULL) {
tmp = dStr_new("proto.");
dStr_append_l(tmp, url_str, p - url_str);
server = tmp->str;
dStr_free(tmp, 0);
}
return ((*server_ptr = server) ? 1 : 0);
}
static void expires_server_ahead()
{
char *string;
time_t t = time(NULL)+1000;
char *server_date = dStrdup(ctime(&t));
time_t expt = t + 1000;
char *exp_date = dStrdup(ctime(&expt));
string = dStrconcat("name=val; expires=", exp_date, NULL);
a_Cookies_set(string, "e2000s1000.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "e2000s1000.com", "/");
a_Cookies_set(string, "e2000s1000s.com", "/", server_date);
expect(__LINE__, "Cookie: name=val\r\n", "http", "e2000s1000s.com", "/");
expt = t - 500; /* past for the server, future for us */
dFree(exp_date);
exp_date = dStrdup(ctime(&expt));
string = dStrconcat("name=val; expires=", exp_date, NULL);
a_Cookies_set(string, "e500s1000.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "e500s1000.com", "/");
a_Cookies_set(string, "e500s1000s.com", "/", server_date);
expect(__LINE__, "", "http", "e500s1000s.com", "/");
expt = t; /* expire at future-for-us server date */
dFree(exp_date);
exp_date = dStrdup(ctime(&expt));
string = dStrconcat("name=val; expires=", exp_date, NULL);
a_Cookies_set(string, "e1000s1000.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "e1000s1000.com", "/");
a_Cookies_set(string, "e1000s1000s.com", "/", server_date);
expect(__LINE__, "", "http", "e1000s1000s.com", "/");
expt = time(NULL); /* now */
dFree(exp_date);
exp_date = dStrdup(ctime(&expt));
string = dStrconcat("name=val; expires=", exp_date, NULL);
a_Cookies_set(string, "e0s1000.com", "/", NULL);
expect(__LINE__, "", "http", "e0s1000.com", "/");
a_Cookies_set(string, "e0s1000s.com", "/", server_date);
expect(__LINE__, "", "http", "e0s1000s.com", "/");
dFree(exp_date);
dFree(server_date);
}
/*
* Change Content-Type for cache entry found by url.
* from = { "http" | "meta" }
* Return new content type.
*/
const char *a_Cache_set_content_type(const DilloUrl *url, const char *ctype,
const char *from)
{
const char *curr;
char *major, *minor, *charset;
CacheEntry_t *entry = Cache_entry_search(url);
dReturn_val_if_fail (entry != NULL, NULL);
_MSG("a_Cache_set_content_type {%s} {%s}\n", ctype, URL_STR(url));
curr = Cache_current_content_type(entry);
if (entry->TypeMeta || (*from == 'h' && entry->TypeHdr) ) {
/* Type is already been set. Do nothing.
* BTW, META overrides TypeHdr */
} else {
if (*from == 'h') {
/* Content-Type from HTTP header */
entry->TypeHdr = dStrdup(ctype);
} else {
/* Content-Type from META */
entry->TypeMeta = dStrdup(ctype);
}
if (a_Misc_content_type_cmp(curr, ctype)) {
/* ctype gives one different from current */
a_Misc_parse_content_type(ctype, &major, &minor, &charset);
if (*from == 'm' && charset &&
((!major || !*major) && (!minor || !*minor))) {
/* META only gives charset; use detected MIME type too */
entry->TypeNorm = dStrconcat(entry->TypeDet, ctype, NULL);
} else if (*from == 'm' &&
!dStrnAsciiCasecmp(ctype, "text/xhtml", 10)) {
/* WORKAROUND: doxygen uses "text/xhtml" in META */
entry->TypeNorm = dStrdup(entry->TypeDet);
}
if (charset) {
if (entry->CharsetDecoder)
a_Decode_free(entry->CharsetDecoder);
entry->CharsetDecoder = a_Decode_charset_init(charset);
curr = Cache_current_content_type(entry);
/* Invalidate UTF8Data */
dStr_free(entry->UTF8Data, 1);
entry->UTF8Data = NULL;
}
dFree(major); dFree(minor); dFree(charset);
}
}
return curr;
}
ColladaAppNode::ColladaAppNode(const domNode* node, ColladaAppNode* parent)
: p_domNode(node), appParent(parent), nodeExt(new ColladaExtension_node(node)),
lastTransformTime(TSShapeLoader::DefaultTime-1), defaultTransformValid(false),
invertMeshes(false)
{
mName = dStrdup(_GetNameOrId(node));
mParentName = dStrdup(parent ? parent->getName() : "ROOT");
// Extract user properties from the <node> extension as whitespace separated
// "name=value" pairs
char* properties = dStrdup(nodeExt->user_properties);
char* pos = properties;
char* end = properties + dStrlen( properties );
while ( pos < end )
{
// Find the '=' character to separate the name and value pair
char* split = dStrchr( pos, '=' );
if ( !split )
break;
// Get the name (whitespace trimmed string up to the '=')
// and value (whitespace trimmed string after the '=')
*split = '\0';
char* name = TrimFirstWord( pos );
char* value = TrimFirstWord( split + 1 );
mProps.insert(StringTable->insert(name), dAtof(value));
pos = value + dStrlen( value ) + 1;
}
dFree( properties );
// Create vector of transform elements
for (S32 iChild = 0; iChild < node->getContents().getCount(); iChild++) {
switch (node->getContents()[iChild]->getElementType()) {
case COLLADA_TYPE::TRANSLATE:
case COLLADA_TYPE::ROTATE:
case COLLADA_TYPE::SCALE:
case COLLADA_TYPE::SKEW:
case COLLADA_TYPE::MATRIX:
case COLLADA_TYPE::LOOKAT:
nodeTransforms.increment();
nodeTransforms.last().element = node->getContents()[iChild];
break;
}
}
}
/*
* Test proxy settings and check the no_proxy domains list
* Return value: whether to use proxy or not.
*/
static int Http_must_use_proxy(const DilloUrl *url)
{
char *np, *p, *tok;
int ret = 0;
if (HTTP_Proxy) {
ret = 1;
if (prefs.no_proxy) {
const char *host = URL_HOST(url);
size_t host_len = strlen(host);
np = dStrdup(prefs.no_proxy);
for (p = np; (tok = dStrsep(&p, " ")); ) {
int start = host_len - strlen(tok);
if (start >= 0 && dStrAsciiCasecmp(host + start, tok) == 0) {
/* no_proxy token is suffix of host string */
ret = 0;
break;
}
}
dFree(np);
}
}
_MSG("Http_must_use_proxy: %s\n %s\n", URL_STR(url), ret ? "YES":"NO");
return ret;
}
SimpleMessageEvent(const char *message = NULL)
{
if(message)
msg = dStrdup(message);
else
msg = NULL;
}
/*
* Create a new connection data structure
*/
static capi_conn_t *
Capi_conn_new(DilloUrl *url, void *bw, char *server, char *datastr)
{
capi_conn_t *conn;
conn = dNew(capi_conn_t, 1);
conn->url = url ? a_Url_dup(url) : NULL;
conn->bw = bw;
conn->server = dStrdup(server);
conn->datastr = dStrdup(datastr);
conn->SockFD = -1;
conn->Flags = (strcmp(server, "http") != 0) ? PENDING : 0;
conn->InfoSend = NULL;
conn->InfoRecv = NULL;
conn->Ref = 0; /* Reference count */
return conn;
}
void Tokenizer::setSingleTokens(const char* singleTokens)
{
if (mSingleTokens)
SAFE_DELETE(mSingleTokens);
if (singleTokens)
mSingleTokens = dStrdup(singleTokens);
}
void GuiTextListCtrl::addEntry(U32 id, const char *text)
{
Entry e;
e.text = dStrdup(text);
e.id = id;
e.active = true;
mList.push_back(e);
setSize(Point2I(1, mList.size()));
}
static void maxage()
{
time_t t = time(NULL)+1000;
char *server_date = dStrdup(ctime(&t));
a_Cookies_set("name=val; max-age=0", "maxage0.com", "/", NULL);
expect(__LINE__, "", "http", "maxage0.com", "/");
a_Cookies_set("name=val; max-age=-0", "maxage-0.com", "/", NULL);
expect(__LINE__, "", "http", "maxage-0.com", "/");
a_Cookies_set("name=val; max-age=100", "maxage100.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxage100.com", "/");
a_Cookies_set("name=val; max-age=-100", "maxage-100.com", "/", NULL);
expect(__LINE__, "", "http", "maxage-100.com", "/");
a_Cookies_set("name=val; max-age=2000000000", "maxage2bil.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxage2bil.com", "/");
a_Cookies_set("name=val; max-age=3000000000", "maxage3bil.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxage3bil.com", "/");
a_Cookies_set("name=val; max-age=7000000000", "maxage7bil.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxage7bil.com", "/");
a_Cookies_set("name=val; max-age=-2000000000", "maxage-2bil.com", "/",NULL);
expect(__LINE__, "", "http", "maxage-2bil.com", "/");
a_Cookies_set("name=val; max-age=-3000000000", "maxage-3bil.com", "/",NULL);
expect(__LINE__, "", "http", "maxage-3bil.com", "/");
a_Cookies_set("name=val; max-age=-7000000000", "maxage-7bil.com", "/",NULL);
expect(__LINE__, "", "http", "maxage-7bil.com", "/");
/* just having a server date shouldn't matter */
a_Cookies_set("name=val; max-age=0", "maxage0s.com", "/", server_date);
expect(__LINE__, "", "http", "maxage0s.com", "/");
a_Cookies_set("name=val; max-age=100", "maxage100s.com", "/", server_date);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxage100s.com", "/");
a_Cookies_set("name=val; max-age=-100", "maxage-100s.com", "/",server_date);
expect(__LINE__, "", "http", "maxage-100s.com", "/");
/* MAX-AGE and EXPIRES */
a_Cookies_set("name=val; max-age=90; expires=Wed Jan 20 01:26:32 2010",
"maxagelater.com", "/", NULL);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxagelater.com", "/");
a_Cookies_set("name=val; max-age=90; expires=Wed Jan 20 01:26:32 2010",
"maxagelaters.com", "/", server_date);
expect(__LINE__, "Cookie: name=val\r\n", "http", "maxagelaters.com", "/");
dFree(server_date);
}
RemoteCommandEvent::RemoteCommandEvent(S32 argc, const char **argv, NetConnection *conn)
{
mArgc = argc;
for(S32 i = 0; i < argc; i++)
{
if(argv[i][0] == StringTagPrefixByte)
{
char buffer[256];
mTagv[i+1] = NetStringHandle(dAtoi(argv[i]+1));
if(conn)
{
dSprintf(buffer + 1, sizeof(buffer) - 1, "%d", conn->getNetSendId(mTagv[i+1]));
buffer[0] = StringTagPrefixByte;
mArgv[i+1] = dStrdup(buffer);
}
}
else
mArgv[i+1] = dStrdup(argv[i]);
}
}
void RemoteCommandEvent::unpack(NetConnection* conn, BitStream *bstream)
{
mArgc = bstream->readInt(CommandArgsBits);
// read it out backwards
for(S32 i = 0; i < mArgc; i++)
{
conn->unpackString(bstream, mBuf);
mArgv[i+1] = dStrdup(mBuf);
}
}
/// Strip the path from the input filename
char* dStripPath(const char* filename)
{
const char* itr = filename + dStrlen(filename);
while(--itr != filename) {
if (*itr == '/' || *itr == '\\') {
itr++;
break;
}
}
return dStrdup(itr);
}
bool GFXGLShader::_loadShaderFromStream( GLuint shader,
const Torque::Path &path,
FileStream *s,
const Vector<GFXShaderMacro> ¯os )
{
Vector<char*> buffers;
Vector<U32> lengths;
// The GLSL version declaration must go first!
const char *versionDecl = "#version 120\r\n\r\n";
buffers.push_back( dStrdup( versionDecl ) );
lengths.push_back( dStrlen( versionDecl ) );
// Now add all the macros.
for( U32 i = 0; i < macros.size(); i++ )
{
String define = String::ToString( "#define %s %s\n", macros[i].name.c_str(), macros[i].value.c_str() );
buffers.push_back( dStrdup( define.c_str() ) );
lengths.push_back( define.length() );
}
// Now finally add the shader source.
U32 shaderLen = s->getStreamSize();
char *buffer = _handleIncludes(path, s);
if ( !buffer )
return false;
buffers.push_back(buffer);
lengths.push_back(shaderLen);
glShaderSource(shader, buffers.size(), (const GLchar**)const_cast<const char**>(buffers.address()), NULL);
// Cleanup the shader source buffer.
for ( U32 i=0; i < buffers.size(); i++ )
dFree( buffers[i] );
glCompileShader(shader);
return true;
}
//-----------------------------------------------------------------------------
/// Finds and sets the current working directory.
/// Torque tries to automatically detect whether you have placed the game files
/// inside or outside the application's bundle. It checks for the presence of
/// the file 'main.cs'. If it finds it, Torque will assume that the other game
/// files are there too. If Torque does not see 'main.cs' inside its bundle, it
/// will assume the files are outside the bundle.
/// Since you probably don't want to copy the game files into the app every time
/// you build, you will want to leave them outside the bundle for development.
///
/// Android reads all assets out of compressed bundle so we dont realy have an executable path
StringTableEntry Platform::getExecutablePath()
{
if(platState.mainDotCsDir)
return platState.mainDotCsDir;
char* ret = NULL;
if(StringTable)
platState.mainDotCsDir = StringTable->insert(".");
else
ret = dStrdup(".");
return ret ? ret : platState.mainDotCsDir;
}
/*
* Determine whether the user needs to authenticate.
*/
static int Auth_do_auth_required(const AuthParse_t *auth_parse,
const DilloUrl *url)
{
/*
* TO DO: I dislike the way that this code must decide whether we
* sent authentication during the request and trust us to resend it
* after the reload. Could it be more robust if every DilloUrl
* recorded its authentication, and whether it was accepted? (JCH)
*/
AuthHost_t *host;
AuthRealm_t *realm;
/*
* The size of the following comments reflects the concerns in the
* TO DO at the top of this function. It should not be so hard to
* explain why code is correct! (JCH)
*/
/*
* If we have authentication but did not send it (because we did
* not know this path was in the realm) then we update the realm.
* We do not re-authenticate because our authentication is probably
* OK. Thanks to the updated realm the forthcoming reload will
* make us send the authentication. If our authentication is not
* OK the server will challenge us again after the reload and then
* we will re-authenticate.
*/
if ((host = Auth_host_by_url(url)) &&
(realm = Auth_realm_by_name(host, auth_parse->realm))) {
if (!Auth_realm_includes_path(realm, URL_PATH(url))) {
_MSG("Auth_do_auth_required: updating realm '%s' with URL '%s'\n",
auth_parse->realm, URL_STR(url));
Auth_realm_add_path(realm, URL_PATH(url));
return 0;
}
if (auth_parse->type == DIGEST && auth_parse->stale) {
/* we do have valid credentials but our nonce is old */
dFree((void *)realm->nonce);
realm->nonce = dStrdup(auth_parse->nonce);
return 0;
}
}
/*
* Either we had no authentication or we sent it and the server
* rejected it, so we must re-authenticate.
*/
return 1;
}
/*! Scans a service directory in dpi_dir and fills dpi_attr
* \Note
* Caller must allocate memory for dpi_attr.
* \Return
* \li 0 on success
* \li -1 on failure
* \todo
* Add other file types, but first we need to add files associated with a dpi
* to the design.
*/
int get_dpi_attr(char *dpi_dir, char *service, struct dp *dpi_attr)
{
char *service_dir = NULL;
struct stat statinfo;
enum file_type ftype;
int ret = -1;
DIR *dir_stream;
struct dirent *dir_entry = NULL;
service_dir = dStrconcat(dpi_dir, "/", service, NULL);
if (stat(service_dir, &statinfo) == -1) {
ERRMSG("get_dpi_attr", "stat", errno);
MSG_ERR("file=%s\n", service_dir);
} else if ((dir_stream = opendir(service_dir)) == NULL) {
ERRMSG("get_dpi_attr", "opendir", errno);
} else {
/* Scan the directory looking for dpi files.
* (currently there's only the dpi program, but in the future
* there may also be helper scripts.) */
while ( (dir_entry = readdir(dir_stream)) != NULL) {
if (dir_entry->d_name[0] == '.')
continue;
ftype = get_file_type(dir_entry->d_name);
switch (ftype) {
case DPI_FILE:
dpi_attr->path =
dStrconcat(service_dir, "/", dir_entry->d_name, NULL);
dpi_attr->id = dStrdup(service);
dpi_attr->port = 0;
dpi_attr->pid = 1;
if (strstr(dpi_attr->path, ".filter") != NULL)
dpi_attr->filter = 1;
else
dpi_attr->filter = 0;
ret = 0;
break;
default:
break;
}
}
closedir(dir_stream);
if (ret != 0)
MSG_ERR("get_dpi_attr: No dpi plug-in in %s/%s\n",
dpi_dir, service);
}
dFree(service_dir);
return ret;
}
void HTTPObject::post(const char *host, const char *path, const char *query, const char *post)
{
if(mHostName)
dFree(mHostName);
if(mPath)
dFree(mPath);
if(mQuery)
dFree(mQuery);
if(mPost)
dFree(mPost);
if(mBufferSave)
dFree(mBufferSave);
mBufferSave = 0;
mHostName = dStrdup(host);
mPath = dStrdup(path);
if(query && query[0])
mQuery = dStrdup(query);
else
mQuery = NULL;
mPost = dStrdup(post);
connect(host);
}
/*
* Return a new string for the request used to tunnel HTTPS through a proxy.
* As of 2009, the best reference appears to be section 5 of RFC 2817.
*/
char *a_Http_make_connect_str(const DilloUrl *url)
{
Dstr *dstr;
const char *auth1;
int auth_len;
char *auth2, *proxy_auth, *retstr;
dReturn_val_if_fail(Http_must_use_proxy(url), NULL);
dstr = dStr_new("");
auth1 = URL_AUTHORITY(url);
auth_len = strlen(auth1);
if (auth_len > 0 && !isdigit(auth1[auth_len - 1]))
/* if no port number, add HTTPS port */
auth2 = dStrconcat(auth1, ":443", NULL);
else
auth2 = dStrdup(auth1);
proxy_auth = HTTP_Proxy_Auth_base64 ?
dStrconcat ("Proxy-Authorization: Basic ",
HTTP_Proxy_Auth_base64, "\r\n", NULL) :
dStrdup("");
dStr_sprintfa(
dstr,
"CONNECT %s HTTP/1.1\r\n"
"Host: %s\r\n"
"%s"
"\r\n",
auth2,
auth2,
proxy_auth);
dFree(auth2);
dFree(proxy_auth);
retstr = dstr->str;
dStr_free(dstr, 0);
return retstr;
}
void RemoteCommandEvent::process(NetConnection *conn)
{
static char idBuf[10];
// de-tag the command name
for(S32 i = mArgc - 1; i >= 0; i--)
{
char *arg = mArgv[i+1];
if(*arg == StringTagPrefixByte)
{
// it's a tag:
U32 localTag = dAtoi(arg + 1);
NetStringHandle tag = conn->translateRemoteStringId(localTag);
NetStringTable::expandString( tag,
mBuf,
sizeof(mBuf),
(mArgc - 1) - i,
(const char**)(mArgv + i + 2) );
dFree(mArgv[i+1]);
mArgv[i+1] = dStrdup(mBuf);
}
}
const char *rmtCommandName = dStrchr(mArgv[1], ' ') + 1;
if(conn->isConnectionToServer())
{
dStrcpy(mBuf, "clientCmd");
dStrcat(mBuf, rmtCommandName);
char *temp = mArgv[1];
mArgv[1] = mBuf;
Con::execute(mArgc, (const char **) mArgv+1);
mArgv[1] = temp;
}
else
{
dStrcpy(mBuf, "serverCmd");
dStrcat(mBuf, rmtCommandName);
char *temp = mArgv[1];
dSprintf(idBuf, sizeof(idBuf), "%d", conn->getId());
mArgv[0] = mBuf;
mArgv[1] = idBuf;
Con::execute(mArgc+1, (const char **) mArgv);
mArgv[1] = temp;
}
}
void GuiTextListCtrl::setEntry(U32 id, const char *text)
{
S32 e = findEntryById(id);
if(e == -1)
addEntry(id, text);
else
{
dFree(mList[e].text);
mList[e].text = dStrdup(text);
// Still have to call this to make sure cells are wide enough for new values:
setSize( Point2I( 1, mList.size() ) );
}
setUpdate();
}
/*! Register a service
* Retrieves attributes for "service" and stores them
* in dpi_attr. It looks for "service" in ~/.dillo/dpi
* first, and then in the system wide dpi directory.
* Caller must allocate memory for dpi_attr.
* \Return
* \li 0 on success
* \li -1 on failure
*/
int register_service(struct dp *dpi_attr, char *service)
{
char *user_dpi_dir, *dpidrc, *user_service_dir, *dir = NULL;
int ret = -1;
user_dpi_dir = dStrconcat(dGethomedir(), "/", dotDILLO_DPI, NULL);
user_service_dir =
dStrconcat(dGethomedir(), "/", dotDILLO_DPI, "/", service, NULL);
dpidrc = dStrconcat(dGethomedir(), "/", dotDILLO_DPIDRC, NULL);
if (access(dpidrc, F_OK) == -1) {
if (access(DPIDRC_SYS, F_OK) == -1) {
ERRMSG("register_service", "Error ", 0);
MSG_ERR("\n - There is no %s or %s file\n", dpidrc,
DPIDRC_SYS);
dFree(user_dpi_dir);
dFree(user_service_dir);
dFree(dpidrc);
return(-1);
}
dFree(dpidrc);
dpidrc = dStrdup(DPIDRC_SYS);
}
/* Check home dir for dpis */
if (access(user_service_dir, F_OK) == 0) {
get_dpi_attr(user_dpi_dir, service, dpi_attr);
ret = 0;
} else { /* Check system wide dpis */
if ((dir = get_dpi_dir(dpidrc)) != NULL) {
if (access(dir, F_OK) == 0) {
get_dpi_attr(dir, service, dpi_attr);
ret = 0;
} else {
ERRMSG("register_service", "get_dpi_attr failed", 0);
}
} else {
ERRMSG("register_service", "dpi_dir: Error getting dpi dir.", 0);
}
}
dFree(user_dpi_dir);
dFree(user_service_dir);
dFree(dpidrc);
dFree(dir);
return ret;
}
void GuiTextListCtrl::insertEntry(U32 id, const char *text, S32 index)
{
Entry e;
e.text = dStrdup(text);
e.id = id;
e.active = true;
if(!mList.size())
mList.push_back(e);
else
{
if(index > mList.size())
index = mList.size();
mList.insert(index);
mList[index] = e;
}
setSize(Point2I(1, mList.size()));
}
/*
* Make the HTTP header's Referer line according to preferences
* (default is "host" i.e. "scheme://hostname/" )
*/
static char *Http_get_referer(const DilloUrl *url)
{
char *referer = NULL;
if (!strcmp(prefs.http_referer, "host")) {
referer = dStrconcat("Referer: ", URL_SCHEME(url), "://",
URL_AUTHORITY(url), "/", "\r\n", NULL);
} else if (!strcmp(prefs.http_referer, "path")) {
referer = dStrconcat("Referer: ", URL_SCHEME(url), "://",
URL_AUTHORITY(url),
URL_PATH_(url) ? URL_PATH(url) : "/", "\r\n", NULL);
}
if (!referer)
referer = dStrdup("");
_MSG("http, referer='%s'\n", referer);
return referer;
}
/*
* Return the authorization header for an HTTP query.
* request_uri is a separate argument because we want it precisely as
* formatted in the request.
*/
char *a_Auth_get_auth_str(const DilloUrl *url, const char *request_uri)
{
char *ret = NULL;
AuthHost_t *host;
AuthRealm_t *realm;
if ((host = Auth_host_by_url(url)) &&
(realm = Auth_realm_by_path(host, URL_PATH(url)))) {
if (realm->type == BASIC)
ret = dStrdup(realm->authorization);
else if (realm->type == DIGEST)
ret = a_Digest_authorization_hdr(realm, url, request_uri);
else
MSG("a_Auth_get_auth_str() got an unknown realm type: %i.\n",
realm->type);
}
return ret;
}
/*! Get dpi directory path from dpidrc
* \Return
* dpi directory on success, NULL on failure
* \Important
* The dpi_dir definition in dpidrc must have no leading white space.
*/
char *get_dpi_dir(char *dpidrc)
{
FILE *In;
int len;
char *rcline = NULL, *value = NULL, *p;
if ((In = fopen(dpidrc, "r")) == NULL) {
ERRMSG("dpi_dir", "fopen", errno);
MSG_ERR(" - %s\n", dpidrc);
return (NULL);
}
while ((rcline = dGetline(In)) != NULL) {
if (strncmp(rcline, "dpi_dir", 7) == 0)
break;
dFree(rcline);
}
fclose(In);
if (!rcline) {
ERRMSG("dpi_dir", "Failed to find a dpi_dir entry in dpidrc", 0);
MSG_ERR("Put your dillo plugins path in %s\n", dpidrc);
MSG_ERR("e.g. dpi_dir=/usr/local/lib/dillo/dpi\n");
MSG_ERR("with no leading spaces.\n");
value = NULL;
} else {
len = (int) strlen(rcline);
if (len && rcline[len - 1] == '\n')
rcline[len - 1] = 0;
if ((p = strchr(rcline, '='))) {
while (*++p == ' ');
value = dStrdup(p);
} else {
ERRMSG("dpi_dir", "strchr", 0);
MSG_ERR(" - '=' not found in %s\n", rcline);
value = NULL;
}
}
dFree(rcline);
return (value);
}
static HostConnection_t *Http_host_connection_get(const char *host)
{
int i;
HostConnection_t *hc;
for (i = 0; i < dList_length(host_connections); i++) {
hc = (HostConnection_t*) dList_nth_data(host_connections, i);
if (dStrAsciiCasecmp(host, hc->host) == 0)
return hc;
}
hc = dNew0(HostConnection_t, 1);
Http_socket_queue_init(&hc->queue);
hc->host = dStrdup(host);
dList_append(host_connections, hc);
return hc;
}
