自学教程：C++ tr_strdup函数代码示例

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;}

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;}

voidtr_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;}

voidtr_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 voidmetainfoLookupRescan( 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_tsetFromCtor( 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;}

voidtr_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 */

voidtr_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 voidsetSourceFile( 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;}