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

tr_watchdir_backend *tr_watchdir_kqueue_new (tr_watchdir_t handle){  const char * const path = tr_watchdir_get_path (handle);  struct kevent ke;  tr_watchdir_kqueue * backend;  backend = tr_new0 (tr_watchdir_kqueue, 1);  backend->base.free_func = &tr_watchdir_kqueue_free;  backend->kq = -1;  backend->dirfd = -1;  if ((backend->kq = kqueue ()) == -1)    {      log_error ("Failed to start kqueue");      goto fail;    }  /* Open fd for watching */  if ((backend->dirfd = open (path, O_RDONLY | O_EVTONLY)) == -1)    {      log_error ("Failed to passively watch directory /"%s/": %s", path,                 tr_strerror (errno));      goto fail;    }  /* Register kevent filter with kqueue descriptor */  EV_SET (&ke, backend->dirfd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR,          KQUEUE_WATCH_MASK, 0, NULL);  if (kevent (backend->kq, &ke, 1, NULL, 0, NULL) == -1)    {      log_error ("Failed to set directory event filter with fd %d: %s", backend->kq,                 tr_strerror (errno));      goto fail;    }  /* Create libevent task for event descriptor */  if ((backend->event = event_new (tr_watchdir_get_event_base (handle), backend->kq,                                   EV_READ | EV_ET | EV_PERSIST,                                   &tr_watchdir_kqueue_on_event, handle)) == NULL)    {      log_error ("Failed to create event: %s", tr_strerror (errno));      goto fail;    }  if (event_add (backend->event, NULL) == -1)    {      log_error ("Failed to add event: %s", tr_strerror (errno));      goto fail;    }  /* Trigger one event for the initial scan */  event_active (backend->event, EV_READ, 0);  return BACKEND_DOWNCAST (backend);fail:  tr_watchdir_kqueue_free (BACKEND_DOWNCAST (backend));  return NULL;}

static voidtr_watchdir_inotify_on_event (struct bufferevent * event,                              void               * context){    assert (context != NULL);    const tr_watchdir_t handle = context;    tr_watchdir_inotify * const backend = BACKEND_UPCAST (tr_watchdir_get_backend (handle));    struct inotify_event ev;    size_t nread;    size_t name_size = NAME_MAX + 1;    char * name = tr_new (char, name_size);    /* Read the size of the struct excluding name into buf. Guaranteed to have at       least sizeof (ev) available */    while ((nread = bufferevent_read (event, &ev, sizeof (ev))) != 0)    {        if (nread == (size_t) -1)        {            log_error ("Failed to read inotify event: %s", tr_strerror (errno));            break;        }        if (nread != sizeof (ev))        {            log_error ("Failed to read inotify event: expected %zu, got %zu bytes.",                       sizeof (ev), nread);            break;        }        assert (ev.wd == backend->inwd);        assert ((ev.mask & INOTIFY_WATCH_MASK) != 0);        assert (ev.len > 0);        if (ev.len > name_size)        {            name_size = ev.len;            name = tr_renew (char, name, name_size);        }        /* Consume entire name into buffer */        if ((nread = bufferevent_read (event, name, ev.len)) == (size_t) -1)        {            log_error ("Failed to read inotify name: %s", tr_strerror (errno));            break;        }        if (nread != ev.len)        {            log_error ("Failed to read inotify name: expected %" PRIu32 ", got %zu bytes.",                       ev.len, nread);            break;        }        tr_watchdir_process (handle, name);    }

static voidset_socket_buffers (int fd, int large){    int size, rbuf, sbuf, rc;    socklen_t rbuf_len = sizeof (rbuf), sbuf_len = sizeof (sbuf);    size = large ? RECV_BUFFER_SIZE : SMALL_BUFFER_SIZE;    rc = setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof (size));    if (rc < 0)        tr_logAddNamedError ("UDP", "Failed to set receive buffer: %s",                tr_strerror (errno));    size = large ? SEND_BUFFER_SIZE : SMALL_BUFFER_SIZE;    rc = setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof (size));    if (rc < 0)        tr_logAddNamedError ("UDP", "Failed to set send buffer: %s",                tr_strerror (errno));    if (large) {        rc = getsockopt (fd, SOL_SOCKET, SO_RCVBUF, &rbuf, &rbuf_len);        if (rc < 0)            rbuf = 0;        rc = getsockopt (fd, SOL_SOCKET, SO_SNDBUF, &sbuf, &sbuf_len);        if (rc < 0)            sbuf = 0;        if (rbuf < RECV_BUFFER_SIZE) {            tr_logAddNamedError ("UDP", "Failed to set receive buffer: requested %d, got %d",                    RECV_BUFFER_SIZE, rbuf);#ifdef __linux__            tr_logAddNamedInfo ("UDP",                    "Please add the line "                    "/"net.core.rmem_max = %d/" to /etc/sysctl.conf",                    RECV_BUFFER_SIZE);#endif        }        if (sbuf < SEND_BUFFER_SIZE) {            tr_logAddNamedError ("UDP", "Failed to set send buffer: requested %d, got %d",                    SEND_BUFFER_SIZE, sbuf);#ifdef __linux__            tr_logAddNamedInfo ("UDP",                    "Please add the line "                    "/"net.core.wmem_max = %d/" to /etc/sysctl.conf",                    SEND_BUFFER_SIZE);#endif        }    }}

/** * returns 0 on success, or an errno value on failure. * errno values include ENOENT if the parent folder doesn't exist, * plus the errno values set by tr_mkdirp() and open(). */static intTrOpenFile( int          i,            const char * folder,            const char * torrentFile,            int          doWrite,            int          doPreallocate,            uint64_t     desiredFileSize ){    struct tr_openfile * file = &gFd->open[i];    int                  flags;    char               * filename;    struct stat          sb;    int                  alreadyExisted;    /* confirm the parent folder exists */    if( stat( folder, &sb ) || !S_ISDIR( sb.st_mode ) )        return ENOENT;    /* create subfolders, if any */    filename = tr_buildPath( folder, torrentFile, NULL );    if( doWrite )    {        char * tmp = tr_dirname( filename );        const int err = tr_mkdirp( tmp, 0777 ) ? errno : 0;        tr_free( tmp );        if( err ) {            tr_free( filename );            return err;        }    }    alreadyExisted = !stat( filename, &sb ) && S_ISREG( sb.st_mode );    if( doWrite && !alreadyExisted && doPreallocate )        if( preallocateFile( filename, desiredFileSize ) )            tr_inf( _( "Preallocated file /"%s/"" ), filename );        /* open the file */    flags = doWrite ? ( O_RDWR | O_CREAT ) : O_RDONLY;#ifdef O_LARGEFILE    flags |= O_LARGEFILE;#endif#ifdef WIN32    flags |= O_BINARY;#endif    file->fd = open( filename, flags, 0666 );    if( file->fd == -1 )    {        const int err = errno;        tr_err( _( "Couldn't open /"%1$s/": %2$s" ), filename,               tr_strerror( err ) );        tr_free( filename );        return err;    }    tr_free( filename );    return 0;}

static voidset_system_error (tr_error ** error,                  int         code){  if (error == NULL)    return;  tr_error_set_literal (error, code, tr_strerror (code));}

static voidgotError( tr_peerIo  * io,          short        what,          void       * vhandshake ){    int errcode = errno;    tr_handshake * handshake = vhandshake;    if( io->utp_socket && !io->isIncoming && handshake->state == AWAITING_YB ) {        /* This peer probably doesn't speak uTP. */        tr_torrent *tor =            tr_peerIoHasTorrentHash( io ) ?            tr_torrentFindFromHash( handshake->session,                                    tr_peerIoGetTorrentHash( io ) ) :            NULL;        /* Don't mark a peer as non-uTP unless it's really a connect failure. */        if( tor && ( errcode == ETIMEDOUT || errcode == ECONNREFUSED ) ) {            tr_torrentLock( tor );            tr_peerMgrSetUtpFailed( tor,                                    tr_peerIoGetAddress( io, NULL ),                                    TRUE );            tr_torrentUnlock( tor );        }        if( !tr_peerIoReconnect( handshake->io ) ) {            uint8_t msg[HANDSHAKE_SIZE];            buildHandshakeMessage( handshake, msg );            handshake->haveSentBitTorrentHandshake = 1;            setReadState( handshake, AWAITING_HANDSHAKE );            tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );        }    }    /* if the error happened while we were sending a public key, we might     * have encountered a peer that doesn't do encryption... reconnect and     * try a plaintext handshake */    if( ( ( handshake->state == AWAITING_YB )        || ( handshake->state == AWAITING_VC ) )      && ( handshake->encryptionMode != TR_ENCRYPTION_REQUIRED )      && ( !tr_peerIoReconnect( handshake->io ) ) )    {        uint8_t msg[HANDSHAKE_SIZE];        dbgmsg( handshake, "handshake failed, trying plaintext..." );        buildHandshakeMessage( handshake, msg );        handshake->haveSentBitTorrentHandshake = 1;        setReadState( handshake, AWAITING_HANDSHAKE );        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );    }    else    {        dbgmsg( handshake, "libevent got an error what==%d, errno=%d (%s)",               (int)what, errno, tr_strerror( errno ) );        tr_handshakeDone( handshake, FALSE );    }}

void tr_torrentSaveResume(tr_torrent* tor){    int err;    tr_variant top;    char* filename;    if (!tr_isTorrent(tor))    {        return;    }    tr_variantInitDict(&top, 50); /* arbitrary "big enough" number */    tr_variantDictAddInt(&top, TR_KEY_seeding_time_seconds, tor->secondsSeeding);    tr_variantDictAddInt(&top, TR_KEY_downloading_time_seconds, tor->secondsDownloading);    tr_variantDictAddInt(&top, TR_KEY_activity_date, tor->activityDate);    tr_variantDictAddInt(&top, TR_KEY_added_date, tor->addedDate);    tr_variantDictAddInt(&top, TR_KEY_corrupt, tor->corruptPrev + tor->corruptCur);    tr_variantDictAddInt(&top, TR_KEY_done_date, tor->doneDate);    tr_variantDictAddStr(&top, TR_KEY_destination, tor->downloadDir);    if (tor->incompleteDir != NULL)    {        tr_variantDictAddStr(&top, TR_KEY_incomplete_dir, tor->incompleteDir);    }    tr_variantDictAddInt(&top, TR_KEY_downloaded, tor->downloadedPrev + tor->downloadedCur);    tr_variantDictAddInt(&top, TR_KEY_uploaded, tor->uploadedPrev + tor->uploadedCur);    tr_variantDictAddInt(&top, TR_KEY_max_peers, tor->maxConnectedPeers);    tr_variantDictAddInt(&top, TR_KEY_bandwidth_priority, tr_torrentGetPriority(tor));    tr_variantDictAddBool(&top, TR_KEY_paused, !tor->isRunning && !tor->isQueued);    savePeers(&top, tor);    if (tr_torrentHasMetadata(tor))    {        saveFilePriorities(&top, tor);        saveDND(&top, tor);        saveProgress(&top, tor);    }    saveSpeedLimits(&top, tor);    saveRatioLimits(&top, tor);    saveIdleLimits(&top, tor);    saveFilenames(&top, tor);    saveName(&top, tor);    filename = getResumeFilename(tor);    if ((err = tr_variantToFile(&top, TR_VARIANT_FMT_BENC, filename)) != 0)    {        tr_torrentSetLocalError(tor, "Unable to save resume file: %s", tr_strerror(err));    }    tr_free(filename);    tr_variantFree(&top);}

char *tr_net_strerror (char * buf, size_t buflen, int err){    *buf = '/0';#ifdef WIN32    FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, buflen, NULL);#else    tr_strlcpy (buf, tr_strerror (err), buflen);#endif    return buf;}

static voidblocklistLoad( tr_blocklist * b ){    int          fd;    struct stat  st;    const char * err_fmt = _( "Couldn't read /"%1$s/": %2$s" );    blocklistClose( b );    if( stat( b->filename, &st ) == -1 )        return;    fd = open( b->filename, O_RDONLY );    if( fd == -1 )    {        tr_err( err_fmt, b->filename, tr_strerror( errno ) );        return;    }#ifndef WIN32    b->rules = mmap( NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0 );#else    b->rules = mmap( NULL, st.st_size, 0, 0, fd, 0 );#endif    if( !b->rules )    {        tr_err( err_fmt, b->filename, tr_strerror( errno ) );        close( fd );        return;    }    b->byteCount = st.st_size;    b->ruleCount = st.st_size / sizeof( struct tr_ip_range );    b->fd = fd;    {        char * base = tr_basename( b->filename );        tr_inf( _( "Blocklist /"%s/" contains %'zu entries" ), base, b->ruleCount );        tr_free( base );    }}

static voidmaybeSetCongestionAlgorithm( int socket, const char * algorithm ){    if( algorithm && *algorithm )    {        const int rc = tr_netSetCongestionControl( socket, algorithm );        if( rc < 0 )            tr_ninf( "Net", "Can't set congestion control algorithm '%s': %s",                     algorithm, tr_strerror( errno ));    }}

static voidblocklistLoad (tr_blocklist * b){    int fd;    size_t byteCount;    struct stat st;    const char * err_fmt = _("Couldn't read /"%1$s/": %2$s");    blocklistClose (b);    if (stat (b->filename, &st) == -1)        return;    fd = open (b->filename, O_RDONLY | O_BINARY);    if (fd == -1)    {        tr_err (err_fmt, b->filename, tr_strerror (errno));        return;    }    byteCount = (size_t) st.st_size;    b->rules = mmap (NULL, byteCount, PROT_READ, MAP_PRIVATE, fd, 0);    if (!b->rules)    {        tr_err (err_fmt, b->filename, tr_strerror (errno));        close (fd);        return;    }    b->fd = fd;    b->byteCount = byteCount;    b->ruleCount = byteCount / sizeof (struct tr_ipv4_range);    {        char * base = tr_basename (b->filename);        tr_inf (_("Blocklist /"%s/" contains %zu entries"), base, b->ruleCount);        tr_free (base);    }}

static inttr_daemon( int nochdir, int noclose ){#if defined(USE_OS_DAEMON)    return daemon( nochdir, noclose );#elif defined(USE_TR_DAEMON)    pid_t pid = fork( );    if( pid < 0 )        return -1;    else if( pid > 0 )        _exit( 0 );    else {        pid = setsid( );        if( pid < 0 )            return -1;        pid = fork( );        if( pid < 0 )            return -1;        else if( pid > 0 )            _exit( 0 );        else {            if( !nochdir )                if( chdir( "/" ) < 0 )                    return -1;            umask( (mode_t)0 );            if( !noclose ) {                /* send stdin, stdout, and stderr to /dev/null */                int i;                int fd = open( "/dev/null", O_RDWR, 0 );                if( fd < 0 )                    fprintf( stderr, "unable to open /dev/null: %s/n", tr_strerror(errno) );                for( i=0; i<3; ++i ) {                    if( close( i ) )                        return -1;                    dup2( fd, i );                }                close( fd );            }            return 0;        }    }#else /* USE_NO_DAEMON */    return 0;#endif}

static voidlogVal( const char * func,        int          ret ){    if( ret == NATPMP_TRYAGAIN )        return;    if( ret >= 0 )        tr_ninf( getKey( ), _( "%s succeeded (%d)" ), func, ret );    else        tr_ndbg(             getKey( ),            "%s failed. Natpmp returned %d (%s); errno is %d (%s)",            func, ret, strnatpmperr( ret ), errno, tr_strerror( errno ) );}

static char*tr_getcwd( void ){    char * result;    char buf[2048];#ifdef WIN32    result = _getcwd( buf, sizeof( buf ) );#else    result = getcwd( buf, sizeof( buf ) );#endif    if( result == NULL )    {        fprintf( stderr, "getcwd error: /"%s/"", tr_strerror( errno ) );        *buf = '/0';    }    return tr_strdup( buf );}

voidtr_eventInit (tr_session * session){    tr_event_handle * eh;    session->events = NULL;    eh = tr_new0 (tr_event_handle, 1);    eh->lock = tr_lockNew ();    if (pipe (eh->fds) == -1)      tr_logAddError ("Unable to write to pipe() in libtransmission: %s", tr_strerror(errno));    eh->session = session;    eh->thread = tr_threadNew (libeventThreadFunc, eh);    /* wait until the libevent thread is running */    while (session->events == NULL)        tr_wait_msec (100);}

static struct UPNPDev *tr_upnpDiscover (int msec){    struct UPNPDev * ret = NULL;#if defined (HAVE_MINIUPNP_16)    int err = UPNPDISCOVER_SUCCESS;    ret = upnpDiscover (msec, NULL, NULL, 0, 0, &err);    if (err != UPNPDISCOVER_SUCCESS)#elif defined (HAVE_MINIUPNP_15)    ret = upnpDiscover (msec, NULL, NULL, 0);    if (ret == NULL)#endif        tr_logAddNamedDbg (getKey (), "upnpDiscover failed (errno %d - %s)", errno, tr_strerror (errno));    return ret;}

/* returns 0 on success, or an errno on failure */static intreadOrWritePiece( tr_torrent       * tor,                  int                ioMode,                  tr_piece_index_t   pieceIndex,                  uint32_t           pieceOffset,                  uint8_t          * buf,                  size_t             buflen ){    int             err = 0;    tr_file_index_t fileIndex;    uint64_t        fileOffset;    const tr_info * info = &tor->info;    if( pieceIndex >= tor->info.pieceCount )        return EINVAL;    //if( pieceOffset + buflen > tr_torPieceCountBytes( tor, pieceIndex ) )    //    return EINVAL;    tr_ioFindFileLocation( tor, pieceIndex, pieceOffset,                           &fileIndex, &fileOffset );    while( buflen && !err )    {        const tr_file * file = &info->files[fileIndex];        const uint64_t bytesThisPass = MIN( buflen, file->length - fileOffset );        err = readOrWriteBytes( tor->session, tor, ioMode, fileIndex, fileOffset, buf, bytesThisPass );        buf += bytesThisPass;        buflen -= bytesThisPass;//fprintf( stderr, "++fileIndex to %d/n", (int)fileIndex );        ++fileIndex;        fileOffset = 0;        if( ( err != 0 ) && (ioMode == TR_IO_WRITE ) && ( tor->error != TR_STAT_LOCAL_ERROR ) )        {            char * path = tr_buildPath( tor->downloadDir, file->name, NULL );            tr_torrentSetLocalError( tor, "%s (%s)", tr_strerror( err ), path );            tr_free( path );        }    }    return err;}

static voidtr_watchdir_kqueue_on_event (evutil_socket_t   fd UNUSED,                             short             type UNUSED,                             void            * context){  const tr_watchdir_t handle = context;  tr_watchdir_kqueue * const backend = BACKEND_UPCAST (tr_watchdir_get_backend (handle));  struct kevent ke;  const struct timespec ts = { 0, 0 };  if (kevent (backend->kq, NULL, 0, &ke, 1, &ts) == -1)    {      log_error ("Failed to fetch kevent: %s", tr_strerror (errno));      return;    }  /* Read directory with generic scan */  tr_watchdir_scan (handle, &backend->dir_entries);}

voidtr_torrentSaveResume( tr_torrent * tor ){    int err;    tr_benc top;    char * filename;    if( !tr_isTorrent( tor ) )        return;    tr_bencInitDict( &top, 50 ); /* arbitrary "big enough" number */    tr_bencDictAddInt( &top, KEY_TIME_SEEDING, tor->secondsSeeding );    tr_bencDictAddInt( &top, KEY_TIME_DOWNLOADING, tor->secondsDownloading );    tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE, tor->activityDate );    tr_bencDictAddInt( &top, KEY_ADDED_DATE, tor->addedDate );    tr_bencDictAddInt( &top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur );    tr_bencDictAddInt( &top, KEY_DONE_DATE, tor->doneDate );    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR, tor->downloadDir );    if( tor->incompleteDir != NULL )        tr_bencDictAddStr( &top, KEY_INCOMPLETE_DIR, tor->incompleteDir );    tr_bencDictAddInt( &top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur );    tr_bencDictAddInt( &top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur );    tr_bencDictAddInt( &top, KEY_MAX_PEERS, tor->maxConnectedPeers );    tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority( tor ) );    tr_bencDictAddBool( &top, KEY_PAUSED, !tor->isRunning );    savePeers( &top, tor );    if( tr_torrentHasMetadata( tor ) )    {        saveFilePriorities( &top, tor );        saveDND( &top, tor );        saveProgress( &top, tor );    }    saveSpeedLimits( &top, tor );    saveRatioLimits( &top, tor );    saveIdleLimits( &top, tor );    filename = getResumeFilename( tor );    if(( err = tr_bencToFile( &top, TR_FMT_BENC, filename )))        tr_torrentSetLocalError( tor, "Unable to save resume file: %s", tr_strerror( err ) );    tr_free( filename );    tr_bencFree( &top );}

static struct UPNPDev *tr_upnpDiscover (int msec){  struct UPNPDev * ret;  bool have_err;#if (MINIUPNPC_API_VERSION >= 8) /* adds ipv6 and error args */  int err = UPNPDISCOVER_SUCCESS;  ret = upnpDiscover (msec, NULL, NULL, 0, 0, &err);  have_err = err != UPNPDISCOVER_SUCCESS;#else  ret = upnpDiscover (msec, NULL, NULL, 0);  have_err = ret == NULL;#endif  if (have_err)    tr_logAddNamedDbg (getKey (), "upnpDiscover failed (errno %d - %s)", errno, tr_strerror (errno));  return ret;}

inttr_fdSocketCreate( int type ){    int s = -1;    tr_lockLock( gFd->lock );    if( gFd->socketCount < getSocketMax( gFd ) )        if( ( s = socket( AF_INET, type, 0 ) ) < 0 )            tr_err( _( "Couldn't create socket: %s" ),                   tr_strerror( sockerrno ) );    if( s > -1 )        ++gFd->socketCount;    assert( gFd->socketCount >= 0 );    tr_lockUnlock( gFd->lock );    return s;}

inttr_fdSocketCreate( tr_session * session, int domain, int type ){    int s = -1;    struct tr_fdInfo * gFd;    assert( tr_isSession( session ) );    assert( session->fdInfo != NULL );    gFd = session->fdInfo;    if( gFd->socketCount < gFd->socketLimit )        if( ( s = socket( domain, type, 0 ) ) < 0 )        {            if( sockerrno != EAFNOSUPPORT )                tr_err( _( "Couldn't create socket: %s" ),                        tr_strerror( sockerrno ) );        }    if( s > -1 )        ++gFd->socketCount;    assert( gFd->socketCount >= 0 );    if( s >= 0 )    {        static tr_bool buf_logged = FALSE;        if( !buf_logged )        {            int i;            socklen_t size = sizeof( int );            buf_logged = TRUE;            getsockopt( s, SOL_SOCKET, SO_SNDBUF, &i, &size );            tr_dbg( "SO_SNDBUF size is %d", i );            getsockopt( s, SOL_SOCKET, SO_RCVBUF, &i, &size );            tr_dbg( "SO_RCVBUF size is %d", i );        }    }    return s;}

char* tr_net_strerror(char* buf, size_t buflen, int err){    *buf = '/0';#ifdef _WIN32    DWORD len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, buflen, NULL);    while (len > 0 && buf[len - 1] >= '/0' && buf[len - 1] <= ' ')    {        buf[--len] = '/0';    }#else    tr_strlcpy(buf, tr_strerror(err), buflen);#endif    return buf;}

static voidwatchdir_new_impl (dtr_watchdir * w){    int i;    DIR * odir;    w->inotify_fd = inotify_init ();    if (w->inotify_fd < 0)    {        i = -1;    }    else    {        tr_inf ("Using inotify to watch directory /"%s/"", w->dir);        i = inotify_add_watch (w->inotify_fd, w->dir, DTR_INOTIFY_MASK);    }    if (i < 0)    {        tr_err ("Unable to watch /"%s/": %s", w->dir, tr_strerror (errno));    }    else if ((odir = opendir (w->dir)))    {        struct dirent * d;        while ((d = readdir (odir)))        {            const char * name = d->d_name;            if (!tr_str_has_suffix (name, ".torrent")) /* skip non-torrents */                continue;            tr_inf ("Found new .torrent file /"%s/" in watchdir /"%s/"", name, w->dir);            w->callback (w->session, w->dir, name);        }        closedir (odir);    }}

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 voidwatchdir_new_impl (dtr_watchdir * w){    int i;    tr_sys_dir_t odir;    w->inotify_fd = inotify_init ();    if (w->inotify_fd < 0)    {        i = -1;    }    else    {        tr_logAddInfo ("Using inotify to watch directory /"%s/"", w->dir);        i = inotify_add_watch (w->inotify_fd, w->dir, DTR_INOTIFY_MASK);    }    if (i < 0)    {        tr_logAddError ("Unable to watch /"%s/": %s", w->dir, tr_strerror (errno));    }    else if ((odir = tr_sys_dir_open (w->dir, NULL)) != TR_BAD_SYS_DIR)    {        const char * name;        while ((name = tr_sys_dir_read_name (odir, NULL)) != NULL)        {            if (!tr_str_has_suffix (name, ".torrent")) /* skip non-torrents */                continue;            tr_logAddInfo ("Found new .torrent file /"%s/" in watchdir /"%s/"", name, w->dir);            w->callback (w->session, w->dir, name);        }        tr_sys_dir_close (odir, NULL);    }}

voidtr_runInEventThread (tr_session * session,                     void func (void*), void * user_data){  assert (tr_isSession (session));  assert (session->events != NULL);  if (tr_amInThread (session->events->thread))    {      (func)(user_data);    }  else    {      int fd;      char ch;      ssize_t res_1;      ssize_t res_2;      tr_event_handle * e = session->events;      struct tr_run_data data;      tr_lockLock (e->lock);      fd = e->fds[1];      ch = 'r';      res_1 = pipewrite (fd, &ch, 1);      data.func = func;      data.user_data = user_data;      res_2 = pipewrite (fd, &data, sizeof (data));      tr_lockUnlock (e->lock);      if ((res_1 == -1) || (res_2 == -1))        tr_logAddError ("Unable to write to libtransmisison event queue: %s", tr_strerror(errno));    }}

static voidgotsig (int sig){    switch (sig)    {        case SIGHUP:        {            if (!mySession)            {                tr_logAddInfo ("Deferring reload until session is fully started.");                seenHUP = true;            }            else            {                tr_variant settings;                const char * configDir;                /* reopen the logfile to allow for log rotation */                if (logfileName) {                    logfile = freopen (logfileName, LOGFILE_MODE_STR, logfile);                    if (!logfile)                        fprintf (stderr, "Couldn't reopen /"%s/": %s/n", logfileName, tr_strerror (errno));                }                configDir = tr_sessionGetConfigDir (mySession);                tr_logAddInfo ("Reloading settings from /"%s/"", configDir);                tr_variantInitDict (&settings, 0);                tr_variantDictAddBool (&settings, TR_KEY_rpc_enabled, true);                tr_sessionLoadSettings (&settings, configDir, MY_NAME);                tr_sessionSet (mySession, &settings);                tr_variantFree (&settings);                tr_sessionReloadBlocklists (mySession);            }            break;        }        default:            tr_logAddError ("Unexpected signal (%d) in daemon, closing.", sig);            /* no break */        case SIGINT:        case SIGTERM:            event_base_loopexit(ev_base, NULL);            break;    }}