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

static inttest_base64 (void){  int len;  char *in, *out;  /* base64 */  out = tr_base64_encode ("YOYO!", -1, &len);  check_streq ("WU9ZTyE=", out);  check_int_eq (8, len);  in = tr_base64_decode (out, -1, &len);  check_streq ("YOYO!", in);  check_int_eq (5, len);  tr_free (in);  tr_free (out);  out = tr_base64_encode (NULL, 0, &len);  check (out == NULL);  check_int_eq (0, len);  return 0;}

voidtr_upnpClose (tr_upnp * handle){    assert (!handle->isMapped);    assert ((handle->state == TR_UPNP_IDLE)          || (handle->state == TR_UPNP_ERR)          || (handle->state == TR_UPNP_DISCOVER));    if (handle->hasDiscovered)        FreeUPNPUrls (&handle->urls);    tr_free (handle);}

static boolcreate_hardlink (const char * dst_path, const char * src_path){#ifndef _WIN32  return link (src_path, dst_path) != -1;#else  wchar_t * wide_src_path = tr_win32_utf8_to_native (src_path, -1);  wchar_t * wide_dst_path = tr_win32_utf8_to_native (dst_path, -1);  bool ret = CreateHardLinkW (wide_dst_path, wide_src_path, NULL);  tr_free (wide_dst_path);  tr_free (wide_src_path);  return ret;#endif}

/* TODO: resume peers6 */static voidsavePeers( tr_benc *          dict,           const tr_torrent * tor ){    tr_pex *  pex = NULL;    const int count = tr_peerMgrGetPeers( tor->session->peerMgr,                                          tor->info.hash, &pex );    if( count > 0 )        tr_bencDictAddRaw( dict, KEY_PEERS, pex, sizeof( tr_pex ) * count );    tr_free( pex );}

static voidwebseed_free( struct tr_webseed * w ){    tr_torrent * tor = tr_torrentFindFromId( w->session, w->torrent_id );    const tr_info * inf = tr_torrentInfo( tor );    tr_file_index_t i;    for( i=0; i<inf->fileCount; ++i )        tr_free( w->file_urls[i] );    tr_free( w->file_urls );    /* webseed destruct */    event_free( w->timer );    tr_bandwidthDestruct( &w->bandwidth );    tr_free( w->base_url );    /* parent class destruct */    tr_peerDestruct( tor, &w->parent );    tr_free( w );}

voidtr_ptrArrayDestruct( tr_ptrArray * p, PtrArrayForeachFunc func ){    assert( p );    assert( p->items || !p->n_items );    if( func )        tr_ptrArrayForeach( p, func );    tr_free( p->items );    memset( p, ~0, sizeof( tr_ptrArray ) );}

static ThreadFuncReturnTypeThreadFunc( void * _t ){    tr_thread * t = _t;    t->func( t->arg );    tr_free( t );#ifdef WIN32    _endthreadex( 0 );    return 0;#endif}

voidlibttest_session_close (tr_session * session){  char * sandbox;  sandbox = tr_strdup (tr_sessionGetConfigDir (session));  tr_sessionClose (session);  tr_logFreeQueue (tr_logGetQueue ());  session = NULL;  libtest_sandbox_destroy (sandbox);  tr_free (sandbox);}

voidtr_ctorSetFilesWanted( tr_ctor                * ctor,                       const tr_file_index_t  * files,                       tr_file_index_t          fileCount,                       tr_bool                  wanted ){    tr_file_index_t ** myfiles = wanted ? &ctor->want : &ctor->notWant;    tr_file_index_t * mycount = wanted ? &ctor->wantSize : &ctor->notWantSize;    tr_free( *myfiles );    *myfiles = tr_memdup( files, sizeof(tr_file_index_t)*fileCount );    *mycount = fileCount;}

static intflushContiguous( tr_cache * cache, int pos, int n ){    int i;    int err = 0;    uint8_t * buf = tr_new( uint8_t, n * MAX_BLOCK_SIZE );    uint8_t * walk = buf;    struct cache_block ** blocks = (struct cache_block**) tr_ptrArrayBase( &cache->blocks );    struct cache_block * b = blocks[pos];    tr_torrent * tor             = b->tor;    const tr_piece_index_t piece = b->piece;    const uint32_t offset        = b->offset;//fprintf( stderr, "flushing %d contiguous blocks [%d-%d) from cache to disk/n", n, pos, n+pos );    for( i=pos; i<pos+n; ++i ) {        b = blocks[i];        memcpy( walk, b->buf, b->length );        walk += b->length;        tr_free( b->buf );        tr_free( b );    }    tr_ptrArrayErase( &cache->blocks, pos, pos+n );#if 0    tr_tordbg( tor, "Writing to disk piece %d, offset %d, len %d", (int)piece, (int)offset, (int)(walk-buf) );    tr_ndbg( MY_NAME, "Removing %d blocks from cache, rank: %d - %d left", n, rank, tr_ptrArraySize(&cache->blocks) );    fprintf( stderr, "%s - Writing to disk piece %d, offset %d, len %d/n", tr_torrentName(tor), (int)piece, (int)offset, (int)(walk-buf) );    fprintf( stderr, "%s - Removing %d blocks from cache; %d left/n", MY_NAME, n, tr_ptrArraySize(&cache->blocks) );#endif    err = tr_ioWrite( tor, piece, offset, walk-buf, buf );    tr_free( buf );    ++cache->disk_writes;    cache->disk_write_bytes += walk-buf;    return err;}

/* returns 0 on success, or an errno on failure */static intreadOrWriteBytes( const tr_torrent * tor,                  int                ioMode,                  tr_file_index_t    fileIndex,                  uint64_t           fileOffset,                  void *             buf,                  size_t             buflen ){    const tr_info * info = &tor->info;    const tr_file * file = &info->files[fileIndex];    typedef size_t ( *iofunc )( int, void *, size_t );    iofunc          func = ioMode ==                           TR_IO_READ ? (iofunc)read : (iofunc)write;    char          * path;    struct stat     sb;    int             fd = -1;    int             err;    int             fileExists;    assert( tor->downloadDir && *tor->downloadDir );    assert( fileIndex < info->fileCount );    assert( !file->length || ( fileOffset < file->length ) );    assert( fileOffset + buflen <= file->length );    path = tr_buildPath( tor->downloadDir, file->name, NULL );    fileExists = !stat( path, &sb );    tr_free( path );    if( !file->length )        return 0;    if( ( ioMode == TR_IO_READ ) && !fileExists ) /* does file exist? */        err = errno;    else if( ( fd = tr_fdFileCheckout ( tor->downloadDir, file->name, ioMode == TR_IO_WRITE, !file->dnd, file->length ) ) < 0 )        err = errno;    else if( tr_lseek( fd, (int64_t)fileOffset, SEEK_SET ) == -1 )        err = errno;    else if( func( fd, buf, buflen ) != buflen )        err = errno;    else        err = 0;    if( ( !err ) && ( !fileExists ) && ( ioMode == TR_IO_WRITE ) )        tr_statsFileCreated( tor->session );    if( fd >= 0 )        tr_fdFileReturn( fd );    return err;}

static voidonFileAdded (tr_session * session, const char * dir, const char * file){    char * filename = tr_buildPath (dir, file, NULL);    tr_ctor * ctor = tr_ctorNew (session);    int err = tr_ctorSetMetainfoFromFile (ctor, filename);    if (!err)    {        tr_torrentNew (ctor, &err, NULL);        if (err == TR_PARSE_ERR)            tr_logAddError ("Error parsing .torrent file /"%s/"", file);        else        {            bool trash = false;            int test = tr_ctorGetDeleteSource (ctor, &trash);            tr_logAddInfo ("Parsing .torrent file successful /"%s/"", file);            if (!test && trash)            {                tr_logAddInfo ("Deleting input .torrent file /"%s/"", file);                if (tr_remove (filename))                    tr_logAddError ("Error deleting .torrent file: %s", tr_strerror (errno));            }            else            {                char * new_filename = tr_strdup_printf ("%s.added", filename);                tr_rename (filename, new_filename);                tr_free (new_filename);            }        }    }    tr_ctorFree (ctor);    tr_free (filename);}

static boolpath_contains_no_symlinks (const char * path){  const char * p = path;  while (*p != '/0')    {      tr_sys_path_info info;      char * pathPart;      const char * slashPos = strchr (p, '/');#ifdef _WIN32      const char * backslashPos = strchr (p, '//');      if (slashPos == NULL || (backslashPos != NULL && backslashPos < slashPos))        slashPos = backslashPos;#endif      if (slashPos == NULL)        slashPos = p + strlen (p) - 1;      pathPart = tr_strndup (path, slashPos - path + 1);      if (!tr_sys_path_get_info (pathPart, TR_SYS_PATH_NO_FOLLOW, &info, NULL) ||          (info.type != TR_SYS_PATH_IS_FILE && info.type != TR_SYS_PATH_IS_DIRECTORY))        {          tr_free (pathPart);          return false;        }      tr_free (pathPart);      p = slashPos + 1;    }  return true;}

static bool testFileExistsAndConsistsOfThisString(tr_torrent const* tor, tr_file_index_t fileIndex, char const* str){    char* path;    size_t const str_len = strlen(str);    bool success = false;    path = tr_torrentFindFile(tor, fileIndex);    if (path != NULL)    {        TR_ASSERT(tr_sys_path_exists(path, NULL));        size_t contents_len;        uint8_t* contents = tr_loadFile(path, &contents_len, NULL);        success = contents != NULL && str_len == contents_len && memcmp(contents, str, contents_len) == 0;        tr_free(contents);        tr_free(path);    }    return success;}

static uint8_t*loadResumeFile( const tr_torrent * tor,                size_t *           len ){    uint8_t *    ret = NULL;    const char * cacheDir = tr_getResumeDir( tor->session );    const char * hash = tor->info.hashString;    if( !ret && tor->session->tag )    {        char * path = tr_strdup_printf( "%s" TR_PATH_DELIMITER_STR "%s-%s", cacheDir, hash, tor->session->tag );        ret = tr_loadFile( path, len );        tr_free( path );    }    if( !ret )    {        char * path = tr_buildPath( cacheDir, hash, NULL );        ret = tr_loadFile( path, len );        tr_free( path );    }    return ret;}

bool tr_sha1_final(tr_sha1_ctx_t handle, uint8_t* hash){    bool ret = true;    if (hash != NULL)    {        TR_ASSERT(handle != NULL);        ret = check_result(API(ShaFinal)(handle, hash));    }    tr_free(handle);    return ret;}

static voidbitfieldToBenc( const tr_bitfield * b, tr_benc * benc ){    if( tr_bitfieldHasAll( b ) )        tr_bencInitStr( benc, "all", 3 );    else if( tr_bitfieldHasNone( b ) )        tr_bencInitStr( benc, "none", 4 );    else {        size_t byte_count = 0;        uint8_t * raw = tr_bitfieldGetRaw( b, &byte_count );        tr_bencInitRaw( benc, raw, byte_count );        tr_free( raw );    }}

static void savePeers(tr_variant* dict, tr_torrent const* tor){    int count;    tr_pex* pex;    count = tr_peerMgrGetPeers((tr_torrent*)tor, &pex, TR_AF_INET, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS);    if (count > 0)    {        tr_variantDictAddRaw(dict, TR_KEY_peers2, pex, sizeof(tr_pex) * count);    }    tr_free(pex);    count = tr_peerMgrGetPeers((tr_torrent*)tor, &pex, TR_AF_INET6, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS);    if (count > 0)    {        tr_variantDictAddRaw(dict, TR_KEY_peers2_6, pex, sizeof(tr_pex) * count);    }    tr_free(pex);}

static void blocklistLoad(tr_blocklistFile* b){    tr_sys_file_t fd;    uint64_t byteCount;    tr_sys_path_info info;    char* base;    tr_error* error = NULL;    char const* err_fmt = _("Couldn't read /"%1$s/": %2$s");    blocklistClose(b);    if (!tr_sys_path_get_info(b->filename, 0, &info, NULL))    {        return;    }    byteCount = info.size;    if (byteCount == 0)    {        return;    }    fd = tr_sys_file_open(b->filename, TR_SYS_FILE_READ, 0, &error);    if (fd == TR_BAD_SYS_FILE)    {        tr_logAddError(err_fmt, b->filename, error->message);        tr_error_free(error);        return;    }    b->rules = tr_sys_file_map_for_reading(fd, 0, byteCount, &error);    if (b->rules == NULL)    {        tr_logAddError(err_fmt, b->filename, error->message);        tr_sys_file_close(fd, NULL);        tr_error_free(error);        return;    }    b->fd = fd;    b->byteCount = byteCount;    b->ruleCount = byteCount / sizeof(struct tr_ipv4_range);    base = tr_sys_path_basename(b->filename, NULL);    tr_logAddInfo(_("Blocklist /"%s/" contains %zu entries"), base, b->ruleCount);    tr_free(base);}

voidtr_fdClose( void ){    int i = 0;    for( i = 0; i < TR_MAX_OPEN_FILES; ++i )        if( fileIsOpen( &gFd->open[i] ) )            TrCloseFile( i );    tr_lockFree( gFd->lock );    tr_free( gFd );    gFd = NULL;}

static voidloadCumulativeStats( const tr_session * session,                     tr_session_stats * setme ){    tr_benc top;    char * filename;    bool loaded = false;    filename = getFilename( session );    loaded = !tr_bencLoadFile( &top, TR_FMT_JSON, filename );    tr_free( filename );    if( !loaded )    {        filename = getOldFilename( session );        loaded = !tr_bencLoadFile( &top, TR_FMT_BENC, filename );        tr_free( filename );    }    if( loaded )    {        int64_t i;        if( tr_bencDictFindInt( &top, "downloaded-bytes", &i ) )            setme->downloadedBytes = (uint64_t) i;        if( tr_bencDictFindInt( &top, "files-added", &i ) )            setme->filesAdded = (uint64_t) i;        if( tr_bencDictFindInt( &top, "seconds-active", &i ) )            setme->secondsActive = (uint64_t) i;        if( tr_bencDictFindInt( &top, "session-count", &i ) )            setme->sessionCount = (uint64_t) i;        if( tr_bencDictFindInt( &top, "uploaded-bytes", &i ) )            setme->uploadedBytes = (uint64_t) i;        tr_bencFree( &top );    }}

static CURL *createEasy( tr_session * s, struct tr_web_task * task ){    const tr_address * addr;    CURL * e = curl_easy_init( );    const long verbose = getenv( "TR_CURL_VERBOSE" ) != NULL;    if( !task->range && s->isProxyEnabled ) {        const long proxyType = getCurlProxyType( s->proxyType );        curl_easy_setopt( e, CURLOPT_PROXY, s->proxy );        curl_easy_setopt( e, CURLOPT_PROXYAUTH, CURLAUTH_ANY );        curl_easy_setopt( e, CURLOPT_PROXYPORT, s->proxyPort );        curl_easy_setopt( e, CURLOPT_PROXYTYPE, proxyType );    }    if( !task->range && s->isProxyAuthEnabled ) {        char * str = tr_strdup_printf( "%s:%s", s->proxyUsername,                                                s->proxyPassword );        curl_easy_setopt( e, CURLOPT_PROXYUSERPWD, str );        tr_free( str );    }    curl_easy_setopt( e, CURLOPT_AUTOREFERER, 1L );    curl_easy_setopt( e, CURLOPT_ENCODING, "gzip;q=1.0, deflate, identity" );    curl_easy_setopt( e, CURLOPT_FOLLOWLOCATION, 1L );    curl_easy_setopt( e, CURLOPT_MAXREDIRS, -1L );    curl_easy_setopt( e, CURLOPT_NOSIGNAL, 1L );    curl_easy_setopt( e, CURLOPT_PRIVATE, task );#ifdef USE_LIBCURL_SOCKOPT    curl_easy_setopt( e, CURLOPT_SOCKOPTFUNCTION, sockoptfunction );    curl_easy_setopt( e, CURLOPT_SOCKOPTDATA, task );#endif    curl_easy_setopt( e, CURLOPT_SSL_VERIFYHOST, 0L );    curl_easy_setopt( e, CURLOPT_SSL_VERIFYPEER, 0L );    curl_easy_setopt( e, CURLOPT_TIMEOUT, getTimeoutFromURL( task->url ) );    curl_easy_setopt( e, CURLOPT_URL, task->url );    curl_easy_setopt( e, CURLOPT_USERAGENT, TR_NAME "/" SHORT_VERSION_STRING );    curl_easy_setopt( e, CURLOPT_VERBOSE, verbose );    curl_easy_setopt( e, CURLOPT_WRITEDATA, task );    curl_easy_setopt( e, CURLOPT_WRITEFUNCTION, writeFunc );    if(( addr = tr_sessionGetPublicAddress( s, TR_AF_INET )))        curl_easy_setopt( e, CURLOPT_INTERFACE, tr_ntop_non_ts( addr ) );    if( task->range )        curl_easy_setopt( e, CURLOPT_RANGE, task->range );    return e;}

voidtr_sessionGetSettings( tr_session * s, struct tr_benc * d ){    int i, n=0;    char * freeme[16];    assert( tr_bencIsDict( d ) );    tr_bencDictReserve( d, 30 );    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );    tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            s->useLazyBitfield );    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 tr_getMessageLevel( ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          s->openFileLimit );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        tr_sessionGetPeerLimit( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       s->peerLimitPerTorrent );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                tr_sessionGetPeerPort( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     s->randomPortLow );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    s->randomPortHigh );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          s->peerSocketTOS );    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              s->isPexEnabled );    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          tr_sessionIsPortForwardingEnabled( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            s->preallocationMode );    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    s->proxy );    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       s->isProxyAuthEnabled );    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            s->isProxyEnabled );    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           s->proxyPassword );    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               s->proxyPort );    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               s->proxyType );    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           s->proxyUsername );    tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO,                 s->desiredRatio );    tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED,            s->isRatioLimited );    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        tr_sessionIsRPCPasswordEnabled( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              tr_sessionIsRPCEnabled( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 tr_sessionGetRPCPort( s ) );    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             freeme[n++] = tr_sessionGetRPCUsername( s ) );    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            freeme[n++] = tr_sessionGetRPCWhitelist( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    tr_sessionGetRPCWhitelistEnabled( s ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );    tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );    for( i=0; i<n; ++i )        tr_free( freeme[i] );}

static __inline__ void__clear_stm(stm_info *stm){	int32_t fileds;	stm_into_pri *f;	for (fileds = 0; fileds < stm->fields; ++fileds)	{		f = &stm->pri_fields[fileds];		if (f->data)		{			tr_free(f->data, f->size);		}	}}

static voidloadCumulativeStats (const tr_session * session, tr_session_stats * setme){  tr_variant top;  char * filename;  bool loaded = false;  filename = getFilename (session);  loaded = !tr_variantFromFile (&top, TR_VARIANT_FMT_JSON, filename);  tr_free (filename);  if (!loaded)    {      filename = getOldFilename (session);      loaded = !tr_variantFromFile (&top, TR_VARIANT_FMT_BENC, filename);      tr_free (filename);    }  if (loaded)    {      int64_t i;      if (tr_variantDictFindInt (&top, TR_KEY_downloaded_bytes, &i))        setme->downloadedBytes = (uint64_t) i;      if (tr_variantDictFindInt (&top, TR_KEY_files_added, &i))        setme->filesAdded = (uint64_t) i;      if (tr_variantDictFindInt (&top, TR_KEY_seconds_active, &i))        setme->secondsActive = (uint64_t) i;      if (tr_variantDictFindInt (&top, TR_KEY_session_count, &i))        setme->sessionCount = (uint64_t) i;      if (tr_variantDictFindInt (&top, TR_KEY_uploaded_bytes, &i))        setme->uploadedBytes = (uint64_t) i;      tr_variantFree (&top);    }}

static uint64_tparseDownloadDir( tr_torrent *    tor,                  const uint8_t * buf,                  uint32_t        len ){    uint64_t ret = 0;    if( buf && *buf && len )    {        tr_free( tor->downloadDir );        tor->downloadDir = tr_strndup( (char*)buf, len );        ret = TR_FR_DOWNLOAD_DIR;    }    return ret;}