Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (13 years ago)
Author:
charles
Message:

run libT, cli, daemon, gtk through the source-code formatter "uncrustify" as promised/threatened

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/fdlimit.c

    r6638 r6795  
    2424
    2525#ifndef WIN32
    26 #define HAVE_GETRLIMIT
     26 #define HAVE_GETRLIMIT
    2727#endif
    2828
     
    3737#include <sys/stat.h>
    3838#ifdef HAVE_GETRLIMIT
    39 #include <sys/time.h> /* getrlimit */
    40 #include <sys/resource.h> /* getrlimit */
     39 #include <sys/time.h> /* getrlimit */
     40 #include <sys/resource.h> /* getrlimit */
    4141#endif
    4242#include <unistd.h>
     
    5454#include "utils.h"
    5555
    56 #if SIZEOF_VOIDP==8
    57 #define TR_UINT_TO_PTR(i) (void*)((uint64_t)i)
     56#if SIZEOF_VOIDP == 8
     57 #define TR_UINT_TO_PTR( i ) (void*)( (uint64_t)i )
    5858#else
    59 #define TR_UINT_TO_PTR(i) ((void*)((uint32_t)i))
    60 #endif
    61 
    62 #define dbgmsg(fmt...) tr_deepLog( __FILE__, __LINE__, NULL, ##fmt )
     59 #define TR_UINT_TO_PTR( i ) ( (void*)( (uint32_t)i ) )
     60#endif
     61
     62#define dbgmsg( fmt... ) tr_deepLog( __FILE__, __LINE__, NULL, ## fmt )
    6363
    6464/**
     
    7676struct tr_openfile
    7777{
    78     unsigned int  isCheckedOut : 1;
    79     unsigned int  isWritable : 1;
    80     unsigned int  closeWhenDone : 1;
    81     char          filename[MAX_PATH_LENGTH];
    82     int           fd;
    83     uint64_t      date;
     78    unsigned int    isCheckedOut : 1;
     79    unsigned int    isWritable    : 1;
     80    unsigned int    closeWhenDone : 1;
     81    char            filename[MAX_PATH_LENGTH];
     82    int             fd;
     83    uint64_t        date;
    8484};
    8585
    8686struct tr_fd_s
    8787{
    88     int                  reserved;
    89     int                  normal;
    90     int                  normalMax;
    91     tr_lock            * lock;
    92     struct tr_openfile   open[TR_MAX_OPEN_FILES];
     88    int                   reserved;
     89    int                   normal;
     90    int                   normalMax;
     91    tr_lock *            lock;
     92    struct tr_openfile    open[TR_MAX_OPEN_FILES];
    9393};
    9494
     
    102102
    103103static tr_errno
    104 TrOpenFile( int           i,
    105             const char  * folder,
    106             const char  * torrentFile,
    107             int           write )
     104TrOpenFile( int          i,
     105            const char * folder,
     106            const char * torrentFile,
     107            int          write )
    108108{
    109109    struct tr_openfile * file = &gFd->open[i];
    110     int flags;
    111     char filename[MAX_PATH_LENGTH];
    112     struct stat sb;
     110    int                  flags;
     111    char                 filename[MAX_PATH_LENGTH];
     112    struct stat          sb;
    113113
    114114    /* confirm the parent folder exists */
     
    117117
    118118    /* create subfolders, if any */
    119     tr_buildPath ( filename, sizeof(filename), folder, torrentFile, NULL );
    120     if( write ) {
    121         char * tmp = tr_strdup( filename );
    122         const int err = tr_mkdirp( dirname(tmp), 0777 ) ? errno : 0;
     119    tr_buildPath ( filename, sizeof( filename ), folder, torrentFile, NULL );
     120    if( write )
     121    {
     122        char *    tmp = tr_strdup( filename );
     123        const int err = tr_mkdirp( dirname( tmp ), 0777 ) ? errno : 0;
    123124        tr_free( tmp );
    124125        if( err )
     
    127128
    128129    /* open the file */
    129     flags = write ? (O_RDWR | O_CREAT) : O_RDONLY;
     130    flags = write ? ( O_RDWR | O_CREAT ) : O_RDONLY;
    130131#ifdef O_LARGEFILE
    131132    flags |= O_LARGEFILE;
     
    135136#endif
    136137    file->fd = open( filename, flags, 0666 );
    137     if( file->fd == -1 ) {
     138    if( file->fd == -1 )
     139    {
    138140        const int err = errno;
    139         tr_err( _( "Couldn't open \"%1$s\": %2$s" ), filename, tr_strerror(err) );
     141        tr_err( _( "Couldn't open \"%1$s\": %2$s" ), filename,
     142               tr_strerror( err ) );
    140143        return tr_ioErrorFromErrno( err );
    141144    }
     
    167170fileIsCheckedOut( const struct tr_openfile * o )
    168171{
    169     return fileIsOpen(o) && o->isCheckedOut;
     172    return fileIsOpen( o ) && o->isCheckedOut;
    170173}
    171174
    172175int
    173176tr_fdFileCheckout( const char * folder,
    174                    const char * torrentFile, 
     177                   const char * torrentFile,
    175178                   int          write )
    176179{
    177     int i, winner = -1;
     180    int                  i, winner = -1;
    178181    struct tr_openfile * o;
    179     char filename[MAX_PATH_LENGTH];
     182    char                 filename[MAX_PATH_LENGTH];
    180183
    181184    assert( folder && *folder );
    182185    assert( torrentFile && *torrentFile );
    183     assert( write==0 || write==1 );
    184 
    185     tr_buildPath ( filename, sizeof(filename), folder, torrentFile, NULL );
    186     dbgmsg( "looking for file '%s', writable %c", filename, write?'y':'n' );
     186    assert( write == 0 || write == 1 );
     187
     188    tr_buildPath ( filename, sizeof( filename ), folder, torrentFile, NULL );
     189    dbgmsg( "looking for file '%s', writable %c", filename,
     190            write ? 'y' : 'n' );
    187191
    188192    tr_lockLock( gFd->lock );
    189193
    190194    /* Is it already open? */
    191     for( i=0; i<TR_MAX_OPEN_FILES; ++i )
     195    for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
    192196    {
    193197        o = &gFd->open[i];
     
    199203            continue;
    200204
    201         if( fileIsCheckedOut( o ) ) {
     205        if( fileIsCheckedOut( o ) )
     206        {
    202207            dbgmsg( "found it!  it's open, but checked out.  waiting..." );
    203208            tr_lockUnlock( gFd->lock );
     
    208213        }
    209214
    210         if( write && !o->isWritable ) {
    211             dbgmsg( "found it!  it's open and available, but isn't writable. closing..." );
     215        if( write && !o->isWritable )
     216        {
     217            dbgmsg(
     218                "found it!  it's open and available, but isn't writable. closing..." );
    212219            TrCloseFile( i );
    213220            break;
     
    219226    }
    220227
    221     dbgmsg( "it's not already open.  looking for an open slot or an old file." );
     228    dbgmsg(
     229        "it's not already open.  looking for an open slot or an old file." );
    222230    while( winner < 0 )
    223231    {
     
    225233
    226234        /* look for the file that's been open longest */
    227         for( i=0; i<TR_MAX_OPEN_FILES; ++i )
     235        for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
    228236        {
    229237            o = &gFd->open[i];
    230238
    231             if( !fileIsOpen( o ) ) {
     239            if( !fileIsOpen( o ) )
     240            {
    232241                winner = i;
    233242                dbgmsg( "found an empty slot in %d", winner );
     
    235244            }
    236245
    237             if( date > o->date ) {
     246            if( date > o->date )
     247            {
    238248                date = o->date;
    239249                winner = i;
     
    241251        }
    242252
    243         if( winner >= 0 ) {
    244             if( fileIsOpen( &gFd->open[winner] ) ) {
    245                 dbgmsg( "closing file '%s', slot #%d", gFd->open[winner].filename, winner );
     253        if( winner >= 0 )
     254        {
     255            if( fileIsOpen( &gFd->open[winner] ) )
     256            {
     257                dbgmsg( "closing file '%s', slot #%d",
     258                        gFd->open[winner].filename,
     259                        winner );
    246260                TrCloseFile( winner );
    247261            }
    248         } else {
    249             dbgmsg( "everything's full!  waiting for someone else to finish something" );
     262        }
     263        else
     264        {
     265            dbgmsg(
     266                "everything's full!  waiting for someone else to finish something" );
    250267            tr_lockUnlock( gFd->lock );
    251268            tr_wait( 200 );
     
    259276    {
    260277        const tr_errno err = TrOpenFile( winner, folder, torrentFile, write );
    261         if( err ) {
     278        if( err )
     279        {
    262280            tr_lockUnlock( gFd->lock );
    263281            return err;
    264282        }
    265283
    266         dbgmsg( "opened '%s' in slot %d, write %c", filename, winner, write?'y':'n' );
     284        dbgmsg( "opened '%s' in slot %d, write %c", filename, winner,
     285                write ? 'y' : 'n' );
    267286        tr_strlcpy( o->filename, filename, sizeof( o->filename ) );
    268287        o->isWritable = write;
     
    281300{
    282301    int i;
     302
    283303    tr_lockLock( gFd->lock );
    284304
    285     for( i=0; i<TR_MAX_OPEN_FILES; ++i )
     305    for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
    286306    {
    287307        struct tr_openfile * o = &gFd->open[i];
     
    293313        if( o->closeWhenDone )
    294314            TrCloseFile( i );
    295        
     315
    296316        break;
    297317    }
    298    
     318
    299319    tr_lockUnlock( gFd->lock );
    300320}
     
    304324{
    305325    int i;
     326
    306327    tr_lockLock( gFd->lock );
    307328
    308     for( i=0; i<TR_MAX_OPEN_FILES; ++i )
     329    for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
    309330    {
    310331        struct tr_openfile * o = &gFd->open[i];
    311         if( !fileIsOpen(o) || strcmp(filename,o->filename) )
     332        if( !fileIsOpen( o ) || strcmp( filename, o->filename ) )
    312333            continue;
    313334
    314335        dbgmsg( "tr_fdFileClose closing '%s'", filename );
    315336
    316         if( !o->isCheckedOut ) {
     337        if( !o->isCheckedOut )
     338        {
    317339            dbgmsg( "not checked out, so closing it now... '%s'", filename );
    318340            TrCloseFile( i );
    319         } else {
    320             dbgmsg( "flagging file '%s', slot #%d to be closed when checked in", gFd->open[i].filename, i );
     341        }
     342        else
     343        {
     344            dbgmsg(
     345                "flagging file '%s', slot #%d to be closed when checked in",
     346                gFd->open[i].filename, i );
    321347            o->closeWhenDone = 1;
    322348        }
    323349    }
    324    
     350
    325351    tr_lockUnlock( gFd->lock );
    326352}
     
    335361
    336362static void
    337 setSocketPriority( int fd, int isReserved )
     363setSocketPriority( int fd,
     364                   int isReserved )
    338365{
    339366    if( isReserved )
    340         tr_list_append( &reservedSockets, TR_UINT_TO_PTR(fd) );
     367        tr_list_append( &reservedSockets, TR_UINT_TO_PTR( fd ) );
    341368}
    342369
     
    344371socketWasReserved( int fd )
    345372{
    346     return tr_list_remove_data( &reservedSockets, TR_UINT_TO_PTR(fd) ) != NULL;
     373    return tr_list_remove_data( &reservedSockets,
     374                               TR_UINT_TO_PTR( fd ) ) != NULL;
    347375}
    348376
     
    354382
    355383int
    356 tr_fdSocketCreate( int type, int isReserved )
     384tr_fdSocketCreate( int type,
     385                   int isReserved )
    357386{
    358387    int s = -1;
     388
    359389    tr_lockLock( gFd->lock );
    360390
    361391    if( isReserved || ( gFd->normal < getSocketMax( gFd ) ) )
    362392        if( ( s = socket( AF_INET, type, 0 ) ) < 0 )
    363             tr_err( _( "Couldn't create socket: %s" ), tr_strerror( sockerrno ) );
     393            tr_err( _( "Couldn't create socket: %s" ),
     394                   tr_strerror( sockerrno ) );
    364395
    365396    if( s > -1 )
     
    381412
    382413int
    383 tr_fdSocketAccept( int b, struct in_addr * addr, tr_port_t * port )
    384 {
    385     int s = -1;
    386     unsigned int len;
     414tr_fdSocketAccept( int              b,
     415                   struct in_addr * addr,
     416                   tr_port_t *      port )
     417{
     418    int                s = -1;
     419    unsigned int       len;
    387420    struct sockaddr_in sock;
    388421
     
    423456    tr_lockLock( gFd->lock );
    424457
    425     if( s >= 0 ) {
     458    if( s >= 0 )
     459    {
    426460        socketClose( s );
    427461        if( socketWasReserved( s ) )
     
    457491        getrlimit( RLIMIT_NOFILE, &rlim );
    458492        rlim.rlim_cur = MIN( rlim.rlim_max,
    459                (rlim_t)(globalPeerLimit + NOFILE_BUFFER) );
     493                            (rlim_t)( globalPeerLimit + NOFILE_BUFFER ) );
    460494        setrlimit( RLIMIT_NOFILE, &rlim );
    461495        gFd->normalMax = rlim.rlim_cur - NOFILE_BUFFER;
     
    467501    tr_dbg( "%d usable file descriptors", globalPeerLimit );
    468502
    469     for( i=0; i<TR_MAX_OPEN_FILES; ++i )
     503    for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
    470504        gFd->open[i].fd = -1;
    471505}
     
    476510    int i = 0;
    477511
    478     for( i=0; i<TR_MAX_OPEN_FILES; ++i )
     512    for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
    479513        if( fileIsOpen( &gFd->open[i] ) )
    480514            TrCloseFile( i );
     
    489523tr_fdSetPeerLimit( uint16_t n )
    490524{
    491     assert( gFd!=NULL && "tr_fdInit() must be called first!" );
     525    assert( gFd != NULL && "tr_fdInit() must be called first!" );
    492526    gFd->normalMax = n;
    493527}
     
    498532    return gFd ? gFd->normalMax : -1;
    499533}
     534
Note: See TracChangeset for help on using the changeset viewer.