static const char*
dns_cache_set_name( struct tr_web_task * task, const char * host,
const char * resolved, int ttl )
{
char * ret = NULL;
ttl = MAX( MIN_DNS_CACHE_TIME, ttl );
if( task->session->web != NULL )
{
struct dns_cache_item * item;
tr_ptrArray * cache = &task->session->web->dns_cache;
dns_cache_clear_entry( cache, host );
item = tr_new( struct dns_cache_item, 1 );
item->host = tr_strdup( host );
item->resolved_host = tr_strdup( resolved );
item->expiration = tr_time( ) + ttl;
item->success = TRUE;
tr_ptrArrayInsertSorted( cache, item, dns_cache_compare );
ret = item->resolved_host;
dbgmsg( "adding dns cache entry for \"%s\": %s", host, resolved );
}
return ret;
}
static int
test_strstrip (void)
{
char *in, *out;
/* strstrip */
in = tr_strdup (" test ");
out = tr_strstrip (in);
check (in == out);
check_streq ("test", out);
tr_free (in);
/* strstrip */
in = tr_strdup (" test test ");
out = tr_strstrip (in);
check (in == out);
check_streq ("test test", out);
tr_free (in);
/* strstrip */
in = tr_strdup ("test");
out = tr_strstrip (in);
check (in == out);
check_streq ("test", out);
tr_free (in);
return 0;
}
char *
tr_sys_path_basename (const char * path,
tr_error ** error)
{
if (path == NULL || path[0] == '\0')
return tr_strdup (".");
if (!is_valid_path (path))
{
set_system_error (error, ERROR_PATH_NOT_FOUND);
return NULL;
}
const char * end = path + strlen (path);
while (end > path && is_slash (*(end - 1)))
--end;
if (end == path)
return tr_strdup ("/");
const char * name = end;
while (name > path && *(name - 1) != ':' && !is_slash (*(name - 1)))
--name;
if (name == end)
return tr_strdup ("/");
return tr_strndup (name, end - name);
}
struct tr_web_task *
tr_webRunWithBuffer( tr_session * session,
const char * url,
const char * range,
const char * cookies,
tr_web_done_func done_func,
void * done_func_user_data,
struct evbuffer * buffer )
{
struct tr_web * web = session->web;
if( web != NULL )
{
struct tr_web_task * task = tr_new0( struct tr_web_task, 1 );
task->session = session;
task->url = tr_strdup( url );
task->range = tr_strdup( range );
task->cookies = tr_strdup( cookies);
task->done_func = done_func;
task->done_func_user_data = done_func_user_data;
task->response = buffer ? buffer : evbuffer_new( );
task->freebuf = buffer ? NULL : task->response;
tr_lockLock( web->taskLock );
task->next = web->tasks;
web->tasks = task;
tr_lockUnlock( web->taskLock );
return task;
}
return NULL;
}
static const char *
getHomeDir( void )
{
static char * home = NULL;
if( !home )
{
home = tr_strdup( getenv( "HOME" ) );
if( !home )
{
#ifdef WIN32
char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
*appdata = '\0';
SHGetFolderPath( NULL, CSIDL_MYDOCUMENTS, NULL, 0, appdata );
home = tr_strdup( appdata );
#elif defined( __BEOS__ ) || defined( __AMIGAOS4__ )
home = tr_strdup( "" );
#else
struct passwd * pw = getpwuid( getuid( ) );
if( pw )
home = tr_strdup( pw->pw_dir );
endpwent( );
#endif
}
if( !home )
home = tr_strdup( "" );
}
return home;
}
void
tr_webRunWithBuffer( tr_session * session,
const char * url,
const char * range,
tr_web_done_func done_func,
void * done_func_user_data,
struct evbuffer * buffer )
{
struct tr_web * web = session->web;
if( web != NULL )
{
struct tr_web_task * task = tr_new0( struct tr_web_task, 1 );
task->session = session;
task->url = tr_strdup( url );
task->range = tr_strdup( range );
task->done_func = done_func;
task->done_func_user_data = done_func_user_data;
task->response = buffer ? buffer : evbuffer_new( );
task->freebuf = buffer ? NULL : task->response;
tr_lockLock( web->taskLock );
tr_list_append( &web->tasks, task );
tr_lockUnlock( web->taskLock );
}
}
CPLXMLNode* GMLXercesHandler::AddAttributes(CPLXMLNode* psNode, void* attr)
{
const Attributes* attrs = (const Attributes*) attr;
CPLXMLNode* psLastChild = NULL;
for(unsigned int i=0; i < attrs->getLength(); i++)
{
char* pszName = tr_strdup(attrs->getQName(i));
char* pszValue = tr_strdup(attrs->getValue(i));
CPLXMLNode* psChild = CPLCreateXMLNode(NULL, CXT_Attribute, pszName);
CPLCreateXMLNode(psChild, CXT_Text, pszValue);
CPLFree(pszName);
CPLFree(pszValue);
if (psLastChild == NULL)
psNode->psChild = psChild;
else
psLastChild->psNext = psChild;
psLastChild = psChild;
}
return psLastChild;
}
const char* GMLXercesHandler::GetFID(void* attr)
{
const Attributes* attrs = (const Attributes*) attr;
int nFIDIndex;
XMLCh anFID[100];
tr_strcpy( anFID, "fid" );
nFIDIndex = attrs->getIndex( anFID );
if( nFIDIndex != -1 )
{
char* pszValue = tr_strdup( attrs->getValue( nFIDIndex ) );
osFID.assign(pszValue);
CPLFree(pszValue);
return osFID.c_str();
}
else
{
tr_strcpy( anFID, "gml:id" );
nFIDIndex = attrs->getIndex( anFID );
if( nFIDIndex != -1 )
{
char* pszValue = tr_strdup( attrs->getValue( nFIDIndex ) );
osFID.assign(pszValue);
CPLFree(pszValue);
return osFID.c_str();
}
}
osFID.resize(0);
return NULL;
}
void
tr_sessionSetTorrentFile( tr_session * session,
const char * hashString,
const char * filename )
{
struct tr_metainfo_lookup * l = bsearch( hashString,
session->metainfoLookup,
session->metainfoLookupCount,
sizeof( struct tr_metainfo_lookup ),
compareHashStringToLookupEntry );
if( l )
{
if( l->filename != filename )
{
tr_free( l->filename );
l->filename = tr_strdup( filename );
}
}
else
{
const int n = session->metainfoLookupCount++;
struct tr_metainfo_lookup * node;
session->metainfoLookup = tr_renew( struct tr_metainfo_lookup,
session->metainfoLookup,
session->metainfoLookupCount );
node = session->metainfoLookup + n;
memcpy( node->hashString, hashString, 2 * SHA_DIGEST_LENGTH + 1 );
node->filename = tr_strdup( filename );
metainfoLookupResort( session );
}
}
const char*
tr_getDefaultDownloadDir (void)
{
static char * user_dir = NULL;
if (user_dir == NULL)
{
const char * config_home;
char * config_file;
char * content;
size_t content_len;
/* figure out where to look for user-dirs.dirs */
config_home = getenv ("XDG_CONFIG_HOME");
if (config_home && *config_home)
config_file = tr_buildPath (config_home, "user-dirs.dirs", NULL);
else
config_file = tr_buildPath (getHomeDir (), ".config", "user-dirs.dirs", NULL);
/* read in user-dirs.dirs and look for the download dir entry */
content = (char *) tr_loadFile (config_file, &content_len);
if (content && content_len>0)
{
const char * key = "XDG_DOWNLOAD_DIR=\"";
char * line = strstr (content, key);
if (line != NULL)
{
char * value = line + strlen (key);
char * end = strchr (value, '"');
if (end)
{
*end = '\0';
if (!memcmp (value, "$HOME/", 6))
user_dir = tr_buildPath (getHomeDir (), value+6, NULL);
else if (!strcmp (value, "$HOME"))
user_dir = tr_strdup (getHomeDir ());
else
user_dir = tr_strdup (value);
}
}
}
if (user_dir == NULL)
#ifdef __HAIKU__
user_dir = tr_buildPath (getHomeDir (), "Desktop", NULL);
#else
user_dir = tr_buildPath (getHomeDir (), "Downloads", NULL);
#endif
tr_free (content);
tr_free (config_file);
}
return user_dir;
}
static void
metainfoLookupRescan( tr_session * session )
{
int i;
int n;
struct stat sb;
const char * dirname = tr_getTorrentDir( session );
DIR * odir = NULL;
tr_ctor * ctor = NULL;
tr_list * list = NULL;
assert( tr_isSession( session ) );
/* walk through the directory and find the mappings */
ctor = tr_ctorNew( session );
tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
if( !stat( dirname, &sb ) && S_ISDIR( sb.st_mode ) && ( ( odir = opendir( dirname ) ) ) )
{
struct dirent *d;
for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
{
if( d->d_name && d->d_name[0] != '.' ) /* skip dotfiles, ., and ..
*/
{
tr_info inf;
char * path = tr_buildPath( dirname, d->d_name, NULL );
tr_ctorSetMetainfoFromFile( ctor, path );
if( !tr_torrentParse( session, ctor, &inf ) )
{
tr_list_append( &list, tr_strdup( inf.hashString ) );
tr_list_append( &list, tr_strdup( path ) );
tr_metainfoFree( &inf );
}
tr_free( path );
}
}
closedir( odir );
}
tr_ctorFree( ctor );
n = tr_list_size( list ) / 2;
session->metainfoLookup = tr_new0( struct tr_metainfo_lookup, n );
session->metainfoLookupCount = n;
for( i = 0; i < n; ++i )
{
char * hashString = tr_list_pop_front( &list );
char * filename = tr_list_pop_front( &list );
memcpy( session->metainfoLookup[i].hashString, hashString,
2 * SHA_DIGEST_LENGTH + 1 );
tr_free( hashString );
session->metainfoLookup[i].filename = filename;
}
metainfoLookupResort( session );
tr_dbg( "Found %d torrents in \"%s\"", n, dirname );
}
char* tr_sys_path_dirname(char const* path, tr_error** error)
{
if (path == NULL || path[0] == '\0')
{
return tr_strdup(".");
}
if (!is_valid_path(path))
{
set_system_error(error, ERROR_PATH_NOT_FOUND);
return NULL;
}
bool const is_unc = is_unc_path(path);
if (is_unc && path[2] == '\0')
{
return tr_strdup(path);
}
char const* end = path + strlen(path);
while (end > path && is_slash(*(end - 1)))
{
--end;
}
if (end == path)
{
return tr_strdup("/");
}
char const* name = end;
while (name > path && *(name - 1) != ':' && !is_slash(*(name - 1)))
{
--name;
}
while (name > path && is_slash(*(name - 1)))
{
--name;
}
if (name == path)
{
return tr_strdup(is_unc ? "\\\\" : ".");
}
if (name > path && *(name - 1) == ':' && *name != '\0' && !is_slash(*name))
{
return tr_strdup_printf("%c:.", path[0]);
}
return tr_strndup(path, name - path);
}
char* GMLXercesHandler::GetAttributeValue(void* attr, const char* pszAttributeName)
{
const Attributes* attrs = (const Attributes*) attr;
for(unsigned int i=0; i < attrs->getLength(); i++)
{
char* pszString = tr_strdup(attrs->getQName(i));
if (strcmp(pszString, pszAttributeName) == 0)
{
CPLFree(pszString);
return tr_strdup(attrs->getValue(i));
}
CPLFree(pszString);
}
return NULL;
}
static char *
announceToScrape( const char * announce )
{
char * scrape = NULL;
const char * s;
/* To derive the scrape URL use the following steps:
* Begin with the announce URL. Find the last '/' in it.
* If the text immediately following that '/' isn't 'announce'
* it will be taken as a sign that that tracker doesn't support
* the scrape convention. If it does, substitute 'scrape' for
* 'announce' to find the scrape page. */
if( ( ( s =
strrchr( announce, '/' ) ) ) && !strncmp( ++s, "announce", 8 ) )
{
struct evbuffer * buf = tr_getBuffer( );
evbuffer_add( buf, announce, s - announce );
evbuffer_add( buf, "scrape", 6 );
evbuffer_add_printf( buf, "%s", s + 8 );
scrape = tr_strdup( EVBUFFER_DATA( buf ) );
tr_releaseBuffer( buf );
}
return scrape;
}
static const char *
getOldConfigDir( void )
{
static char * path = NULL;
if( !path )
{
#ifdef __BEOS__
char buf[MAX_PATH_LENGTH];
find_directory( B_USER_SETTINGS_DIRECTORY,
dev_for_path( "/boot" ), true,
buf, sizeof( buf ) );
path = tr_buildPath( buf, "Transmission", NULL );
#elif defined( SYS_DARWIN )
path = tr_buildPath( getHomeDir( ), "Library",
"Application Support",
"Transmission", NULL );
#elif defined( __AMIGAOS4__ )
path = tr_strdup( "PROGDIR:.transmission" );
#elif defined( WIN32 )
char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
path = tr_buildPath( appdata, "Transmission", NULL );
#else
path = tr_buildPath( getHomeDir( ), ".transmission", NULL );
#endif
}
return path;
}
tr_session *
tr_sessionInit( const char * tag,
const char * configDir,
tr_bool messageQueuingEnabled,
tr_benc * clientSettings )
{
tr_session * session;
struct init_data data;
assert( tr_bencIsDict( clientSettings ) );
/* initialize the bare skeleton of the session object */
session = tr_new0( tr_session, 1 );
session->bandwidth = tr_bandwidthNew( session, NULL );
session->lock = tr_lockNew( );
session->tag = tr_strdup( tag );
session->magicNumber = SESSION_MAGIC_NUMBER;
/* start the libtransmission thread */
tr_netInit( ); /* must go before tr_eventInit */
tr_eventInit( session );
assert( session->events != NULL );
/* run the rest in the libtransmission thread */
session->isWaiting = TRUE;
data.session = session;
data.configDir = configDir;
data.messageQueuingEnabled = messageQueuingEnabled;
data.clientSettings = clientSettings;
tr_runInEventThread( session, tr_sessionInitImpl, &data );
while( session->isWaiting )
tr_wait( 100 );
return session;
}
char*
tr_ssha1( const void * plaintext )
{
enum { saltval_len = 8,
salter_len = 64 };
static const char * salter = "0123456789"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"./";
size_t i;
unsigned char salt[saltval_len];
uint8_t sha[SHA_DIGEST_LENGTH];
char buf[2*SHA_DIGEST_LENGTH + saltval_len + 2];
tr_cryptoRandBuf( salt, saltval_len );
for( i=0; i<saltval_len; ++i )
salt[i] = salter[ salt[i] % salter_len ];
tr_sha1( sha, plaintext, strlen( plaintext ), salt, saltval_len, NULL );
tr_sha1_to_hex( &buf[1], sha );
memcpy( &buf[1+2*SHA_DIGEST_LENGTH], &salt, saltval_len );
buf[1+2*SHA_DIGEST_LENGTH + saltval_len] = '\0';
buf[0] = '{'; /* signal that this is a hash. this makes saving/restoring
easier */
return tr_strdup( &buf );
}
char *
tr_sys_path_resolve (const char * path,
tr_error ** error)
{
char * ret = NULL;
char * tmp = NULL;
assert (path != NULL);
#if defined (HAVE_CANONICALIZE_FILE_NAME)
ret = canonicalize_file_name (path);
#endif
#if defined (_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L
/* Better safe than sorry: realpath () officially supports NULL as destination
starting off POSIX.1-2008. */
if (ret == NULL)
ret = realpath (path, NULL);
#endif
if (ret == NULL)
{
tmp = tr_new (char, PATH_MAX);
ret = realpath (path, tmp);
if (ret != NULL)
ret = tr_strdup (ret);
}
void NASReader::CheckForRelations( const char *pszElement,
const Attributes &attrs,
char **ppszCurField )
{
GMLFeature *poFeature = GetState()->m_poFeature;
CPLAssert( poFeature != NULL );
int nIndex;
XMLCh Name[100];
tr_strcpy( Name, "xlink:href" );
nIndex = attrs.getIndex( Name );
if( nIndex != -1 )
{
char *pszHRef = tr_strdup( attrs.getValue( nIndex ) );
if( EQUALN(pszHRef,"urn:adv:oid:", 12 ) )
{
poFeature->AddOBProperty( pszElement, pszHRef );
CPLFree( *ppszCurField );
*ppszCurField = CPLStrdup( pszHRef + 12 );
}
CPLFree( pszHRef );
}
}
static const char*
parseFiles (tr_info * inf, tr_benc * files, const tr_benc * length)
{
int64_t len;
inf->totalSize = 0;
if (tr_bencIsList (files)) /* multi-file mode */
{
tr_file_index_t i;
struct evbuffer * buf = evbuffer_new ();
inf->isMultifile = 1;
inf->fileCount = tr_bencListSize (files);
inf->files = tr_new0 (tr_file, inf->fileCount);
for (i=0; i<inf->fileCount; i++)
{
tr_benc * file;
tr_benc * path;
file = tr_bencListChild (files, i);
if (!tr_bencIsDict (file))
return "files";
if (!tr_bencDictFindList (file, "path.utf-8", &path))
if (!tr_bencDictFindList (file, "path", &path))
return "path";
if (!getfile (&inf->files[i].name, inf->name, path, buf))
return "path";
if (!tr_bencDictFindInt (file, "length", &len))
return "length";
inf->files[i].length = len;
inf->totalSize += len;
}
evbuffer_free (buf);
}
else if (tr_bencGetInt (length, &len)) /* single-file mode */
{
if (path_is_suspicious (inf->name))
return "path";
inf->isMultifile = 0;
inf->fileCount = 1;
inf->files = tr_new0 (tr_file, 1);
inf->files[0].name = tr_strdup (inf->name);
inf->files[0].length = len;
inf->totalSize += len;
}
else
{
return "length";
}
return NULL;
}
char *
tr_sys_path_dirname (const char * path,
tr_error ** error)
{
char drive[_MAX_DRIVE], dir[_MAX_DIR];
assert (path != NULL);
/* TODO: Error handling */
if (_splitpath_s (path, drive, sizeof (drive), dir, sizeof (dir), NULL, 0, NULL, 0) == 0 &&
(*drive != '\0' || *dir != '\0'))
{
const size_t tmp_len = strlen (drive) + strlen (dir) + 2;
char * const tmp = tr_new (char, tmp_len);
if (_makepath_s (tmp, tmp_len, drive, dir, NULL, NULL) == 0)
{
size_t len = strlen(tmp);
while (len > 0 && (tmp[len - 1] == '/' || tmp[len - 1] == '\\'))
tmp[--len] = '\0';
return tmp;
}
tr_free (tmp);
}
return tr_strdup (".");
}
const char*
tr_getDefaultConfigDir( void )
{
static char * s = NULL;
if( !s )
{
if( ( s = getenv( "TRANSMISSION_HOME" ) ) )
{
s = tr_strdup( s );
}
else
{
#ifdef SYS_DARWIN
s = tr_buildPath( getHomeDir( ), "Library",
"Application Support", "Transmission", NULL );
#elif defined( WIN32 )
char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
s = tr_buildPath( appdata, "Transmission", NULL );
#else
if( ( s = getenv( "XDG_CONFIG_HOME" ) ) )
s = tr_buildPath( s, "transmission", NULL );
else
s = tr_buildPath( getHomeDir( ), ".config", "transmission", NULL );
#endif
}
}
return s;
}
static uint64_t
setFromCtor( tr_torrent * tor,
uint64_t fields,
const tr_ctor * ctor,
int mode )
{
uint64_t ret = 0;
if( fields & TR_FR_RUN )
{
uint8_t isPaused;
if( !tr_ctorGetPaused( ctor, mode, &isPaused ) )
{
tor->isRunning = !isPaused;
ret |= TR_FR_RUN;
}
}
if( fields & TR_FR_MAX_PEERS )
if( !tr_ctorGetPeerLimit( ctor, mode, &tor->maxConnectedPeers ) )
ret |= TR_FR_MAX_PEERS;
if( fields & TR_FR_DOWNLOAD_DIR )
{
const char * path;
if( !tr_ctorGetDownloadDir( ctor, mode, &path ) && path && *path )
{
ret |= TR_FR_DOWNLOAD_DIR;
tr_free( tor->downloadDir );
tor->downloadDir = tr_strdup( path );
}
}
return ret;
}
void
tr_tracker_http_scrape (tr_session * session,
const tr_scrape_request * request,
tr_scrape_response_func response_func,
void * response_func_user_data)
{
int i;
struct scrape_data * d;
char * url = scrape_url_new (request);
d = tr_new0 (struct scrape_data, 1);
d->response.url = tr_strdup (request->url);
d->response_func = response_func;
d->response_func_user_data = response_func_user_data;
d->response.row_count = request->info_hash_count;
for (i=0; i<d->response.row_count; ++i)
{
memcpy (d->response.rows[i].info_hash, request->info_hash[i], SHA_DIGEST_LENGTH);
d->response.rows[i].seeders = -1;
d->response.rows[i].leechers = -1;
d->response.rows[i].downloads = -1;
}
tr_strlcpy (d->log_name, request->log_name, sizeof (d->log_name));
dbgmsg (request->log_name, "Sending scrape to libcurl: \"%s\"", url);
tr_webRun (session, url, on_scrape_done, d);
tr_free (url);
}
static int tr_config_add_action(tr_action_t **dest, /* {{{ */
const oconfig_item_t *ci, _Bool may_be_empty) {
tr_action_t *act;
int status;
if (dest == NULL)
return (-EINVAL);
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
ERROR("Target `replace': The `%s' option requires exactly two string "
"arguments.",
ci->key);
return (-1);
}
act = calloc(1, sizeof(*act));
if (act == NULL) {
ERROR("tr_config_add_action: calloc failed.");
return (-ENOMEM);
}
act->replacement = NULL;
act->may_be_empty = may_be_empty;
status = regcomp(&act->re, ci->values[0].value.string, REG_EXTENDED);
if (status != 0) {
char errbuf[1024] = "";
/* regerror assures null termination. */
regerror(status, &act->re, errbuf, sizeof(errbuf));
ERROR("Target `replace': Compiling the regular expression `%s' "
"failed: %s.",
ci->values[0].value.string, errbuf);
sfree(act);
return (-EINVAL);
}
act->replacement = tr_strdup(ci->values[1].value.string);
if (act->replacement == NULL) {
ERROR("tr_config_add_action: tr_strdup failed.");
tr_action_destroy(act);
return (-ENOMEM);
}
/* Insert action at end of list. */
if (*dest == NULL)
*dest = act;
else {
tr_action_t *prev;
prev = *dest;
while (prev->next != NULL)
prev = prev->next;
prev->next = act;
}
return (0);
} /* }}} int tr_config_add_action */
void
tr_tracker_http_scrape( tr_session * session,
const tr_scrape_request * request,
tr_scrape_response_func response_func,
void * response_func_user_data )
{
int i;
struct scrape_data * d;
struct evbuffer * buf = scrape_url_new( request );
const char * url = (const char *) evbuffer_pullup( buf, -1 );
d = tr_new0( struct scrape_data, 1 );
d->response.url = tr_strdup( request->url );
d->response_func = response_func;
d->response_func_user_data = response_func_user_data;
d->response.row_count = request->info_hash_count;
for( i=0; i<d->response.row_count; ++i )
memcpy( d->response.rows[i].info_hash, request->info_hash[i], SHA_DIGEST_LENGTH );
tr_strlcpy( d->log_name, request->log_name, sizeof( d->log_name ) );
dbgmsg( request->log_name, "Sending scrape to libcurl: \"%s\"", url );
tr_webRun( session, url, NULL, NULL, on_scrape_done, d );
evbuffer_free( buf );
}
GMLFeature *NASReader::NextFeature()
{
GMLFeature *poReturn = NULL;
try
{
if( !m_bReadStarted )
{
if( m_poSAXReader == NULL )
SetupParser();
if( !m_poSAXReader->parseFirst( m_pszFilename, m_oToFill ) )
return NULL;
m_bReadStarted = TRUE;
}
while( m_poCompleteFeature == NULL
&& m_poSAXReader->parseNext( m_oToFill ) ) {}
poReturn = m_poCompleteFeature;
m_poCompleteFeature = NULL;
}
catch (const XMLException& toCatch)
{
CPLDebug( "GML",
"Error during NextFeature()! Message:\n%s",
tr_strdup( toCatch.getMessage() ) );
}
return poReturn;
}
static void
setSourceFile( tr_ctor * ctor,
const char * sourceFile )
{
tr_free( ctor->sourceFile );
ctor->sourceFile = tr_strdup( sourceFile );
}
void NASReader::PushFeature( const char *pszElement,
const Attributes &attrs )
{
int iClass;
/* -------------------------------------------------------------------- */
/* Find the class of this element. */
/* -------------------------------------------------------------------- */
for( iClass = 0; iClass < GetClassCount(); iClass++ )
{
if( EQUAL(pszElement,GetClass(iClass)->GetElementName()) )
break;
}
/* -------------------------------------------------------------------- */
/* Create a new feature class for this element, if there is no */
/* existing class for it. */
/* -------------------------------------------------------------------- */
if( iClass == GetClassCount() )
{
CPLAssert( !IsClassListLocked() );
GMLFeatureClass *poNewClass = new GMLFeatureClass( pszElement );
AddClass( poNewClass );
}
/* -------------------------------------------------------------------- */
/* Create a feature of this feature class. */
/* -------------------------------------------------------------------- */
GMLFeature *poFeature = new GMLFeature( GetClass( iClass ) );
/* -------------------------------------------------------------------- */
/* Create and push a new read state. */
/* -------------------------------------------------------------------- */
GMLReadState *poState;
poState = new GMLReadState();
poState->m_poFeature = poFeature;
PushState( poState );
/* -------------------------------------------------------------------- */
/* Check for gml:id, and if found push it as an attribute named */
/* gml_id. */
/* -------------------------------------------------------------------- */
int nFIDIndex;
XMLCh anFID[100];
tr_strcpy( anFID, "gml:id" );
nFIDIndex = attrs.getIndex( anFID );
if( nFIDIndex != -1 )
{
char *pszFID = tr_strdup( attrs.getValue( nFIDIndex ) );
SetFeatureProperty( "gml_id", pszFID );
CPLFree( pszFID );
}
}
char *
tr_http_unescape( const char * str, int len )
{
char * tmp = curl_unescape( str, len );
char * ret = tr_strdup( tmp );
curl_free( tmp );
return ret;
}