Changeset 5167


Ignore:
Timestamp:
Feb 28, 2008, 7:06:23 PM (14 years ago)
Author:
charles
Message:

add win32/posix wrapper function tr_lockfile() to libT and use it in daemon/gtk.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/daemon.c

    r4390 r5167  
    3333#include <errno.h>
    3434#include <event.h>
    35 #include <fcntl.h>
    3635#include <getopt.h>
    3736#include <signal.h>
     
    4342
    4443#include <libtransmission/trcompat.h>
     44#include <libtransmission/platform.h>
    4545#include <libtransmission/version.h>
    4646
     
    5353static void readargs    ( int, char **, int *, int *, char **, char ** );
    5454static int  trylocksock ( const char * );
    55 static int  getlock     ( const char * );
    5655static int  getsock     ( const char * );
    5756static void exitcleanup ( void );
     
    6059static int  savepid     ( const char * );
    6160
    62 static int  gl_lockfd               = -1;
    6361static char gl_lockpath[MAXPATHLEN] = "";
    6462static int  gl_sockfd               = -1;
     
    184182}
    185183
     184static int
     185getlock( const char * filename )
     186{
     187    const int state = tr_lockfile( filename );
     188    const int success = state == TR_LOCKFILE_SUCCESS;
     189
     190    if( !success ) switch( state ) {
     191        case TR_LOCKFILE_EOPEN:
     192            errnomsg( "failed to open file: %s", filename );
     193            break;
     194        case TR_LOCKFILE_ELOCK:
     195            errmsg( "another copy of %s is already running", getmyname() );
     196            break;
     197        default:
     198            errmsg( "unhandled tr_lockfile error: %d", state );
     199            break;
     200    }
     201
     202    return success;
     203}
     204
     205
    186206int
    187207trylocksock( const char * sockpath )
     
    198218
    199219    confpath( path, sizeof path, CONF_FILE_LOCK, 0 );
    200     fd = getlock( path );
    201     if( 0 > fd )
    202     {
    203         return -1;
    204     }
    205     gl_lockfd = fd;
     220    if( !getlock( path ) )
     221        return -1;
    206222    strlcpy( gl_lockpath, path, sizeof gl_lockpath );
    207223
     
    218234    gl_sockfd = fd;
    219235    strlcpy( gl_sockpath, sockpath, sizeof gl_sockpath );
    220 
    221     return fd;
    222 }
    223 
    224 int
    225 getlock( const char * path )
    226 {
    227     struct flock lk;
    228     int          fd;
    229     char         pid[64];
    230 
    231     fd = open( path, O_RDWR | O_CREAT, 0666 );
    232     if( 0 > fd )
    233     {
    234         errnomsg( "failed to open file: %s", path );
    235         return -1;
    236     }
    237 
    238     memset( &lk, 0, sizeof lk );
    239     lk.l_start  = 0;
    240     lk.l_len    = 0;
    241     lk.l_type   = F_WRLCK;
    242     lk.l_whence = SEEK_SET;
    243     if( 0 > fcntl( fd, F_SETLK, &lk ) )
    244     {
    245         if( EAGAIN == errno )
    246         {
    247             errmsg( "another copy of %s is already running", getmyname() );
    248         }
    249         else
    250         {
    251             errnomsg( "failed to obtain lock on file: %s", path );
    252         }
    253         close( fd );
    254         return -1;
    255     }
    256 
    257     ftruncate( fd, 0 );
    258     snprintf( pid, sizeof pid, "%i\n", getpid() );
    259     write( fd, pid, strlen( pid ) );
    260236
    261237    return fd;
     
    306282        unlink( gl_pidfile );
    307283    }
    308     if( 0 <= gl_lockfd )
    309     {
     284
     285    if( *gl_lockpath )
    310286        unlink( gl_lockpath );
    311         close( gl_lockfd );
    312     }
    313287}
    314288
  • trunk/gtk/conf.c

    r5127 r5167  
    2929#include <string.h>
    3030
    31 #include <fcntl.h>
    32 #include <sys/types.h>
    33 #include <sys/stat.h>
    3431#include <unistd.h>
    3532
     
    4037#include <libtransmission/transmission.h>
    4138#include <libtransmission/bencode.h>
     39#include <libtransmission/platform.h>
    4240
    4341#include "conf.h"
     
    7371
    7472/* errstr may be NULL, this might be called before GTK is initialized */
    75 static int
    76 lockfile(const char *file, char **errstr)
    77 {
    78     int fd;
    79     struct flock lk;
    80 
    81     if( errstr )
    82         *errstr = NULL;
    83 
    84     fd = open( file, O_RDWR | O_CREAT, 0666 );
    85     if( fd < 0 )
    86     {
    87         const int savederr = errno;
    88         if( errstr )
    89             *errstr = g_strdup_printf(
    90                           _("Failed to open the file %s for writing:\n%s"),
    91                           file, g_strerror( errno ) );
    92         errno = savederr;
    93         return -1;
    94     }
    95 
    96     memset( &lk, 0,  sizeof( lk ) );
    97     lk.l_start = 0;
    98     lk.l_len = 0;
    99     lk.l_type = F_WRLCK;
    100     lk.l_whence = SEEK_SET;
    101     if( -1 == fcntl( fd, F_SETLK, &lk ) )
    102     {
    103         const int savederr = errno;
    104         if( errstr )
    105             *errstr = ( errno == EAGAIN )
    106                 ? g_strdup_printf( _( "Another copy of %s is already running." ),
    107                                    g_get_application_name( ) )
    108                 : g_strdup_printf( _( "Failed to lock the file %s:\n%s" ),
    109                                   file, g_strerror( errno ) );
    110         close( fd );
    111         errno = savederr;
    112         return -1;
    113     }
    114 
    115     return fd;
     73static gboolean
     74lockfile(const char * filename, char **errstr)
     75{
     76    const int state = tr_lockfile( filename );
     77    const gboolean success = state == TR_LOCKFILE_SUCCESS;
     78
     79    if( errstr ) switch( state ) {
     80        case TR_LOCKFILE_EOPEN:
     81            *errstr = g_strdup_printf( _("Failed to open lockfile %s: %s"),
     82                                       filename, g_strerror( errno ) );
     83            break;
     84        case TR_LOCKFILE_ELOCK:
     85            *errstr = g_strdup_printf( _( "%s is already running." ),
     86                                       g_get_application_name( ) );
     87            break;
     88        case TR_LOCKFILE_SUCCESS:
     89            *errstr = NULL;
     90            break;
     91    }
     92
     93    return success;
    11694}
    11795
     
    135113{
    136114    char * path = getLockFilename( );
    137     int fd = lockfile( path, errstr );
    138     if( fd >= 0 )
     115    const gboolean didLock = lockfile( path, errstr );
     116    if( didLock )
    139117        gl_lockpath = g_strdup( path );
    140118    g_atexit( cf_removelocks );
    141119    g_free( path );
    142     return fd >= 0;
     120    return didLock;
    143121}
    144122
  • trunk/libtransmission/platform.c

    r5164 r5167  
    450450    return buf;
    451451}
     452
     453/***
     454****
     455***/
     456
     457int
     458tr_lockfile( const char * filename )
     459{
     460    int ret;
     461
     462#ifdef WIN32
     463
     464    HANDLE file = CreateFile( filename,
     465                              GENERIC_READ|GENERIC_WRITE,
     466                              FILE_SHARE_READ|FILE_SHARE_WRITE,
     467                              NULL,
     468                              OPEN_ALWAYS,
     469                              FILE_ATTRIBUTE_NORMAL,
     470                              NULL );
     471    if( file == INVALID_HANDLE_VALUE )
     472        ret = TR_LOCKFILE_EOPEN;
     473    else if( !LockFile( file, 0, 0, 1, 1 ) )
     474        ret = TR_LOCKFILE_ELOCK;
     475    else
     476        ret = TR_LOCKFILE_SUCCESS;
     477
     478#else
     479
     480    int fd = open( filename, O_RDWR | O_CREAT, 0666 );
     481    if( fd < 0 )
     482        ret = TR_LOCKFILE_EOPEN;
     483    else {
     484        struct flock lk;
     485        memset( &lk, 0,  sizeof( lk ) );
     486        lk.l_start = 0;
     487        lk.l_len = 0;
     488        lk.l_type = F_WRLCK;
     489        lk.l_whence = SEEK_SET;
     490        if( -1 == fcntl( fd, F_SETLK, &lk ) )
     491            ret = TR_LOCKFILE_ELOCK;
     492        else
     493            ret = TR_LOCKFILE_SUCCESS;
     494    }
     495
     496#endif
     497
     498    return ret;
     499}
  • trunk/libtransmission/platform.h

    r4999 r5167  
    4949int          tr_lockHave       ( const tr_lock * );
    5050
     51
     52enum
     53{
     54  TR_LOCKFILE_SUCCESS,
     55  TR_LOCKFILE_EOPEN,
     56  TR_LOCKFILE_ELOCK
     57};
     58
     59int          tr_lockfile       ( const char * filename );
     60
    5161#endif
Note: See TracChangeset for help on using the changeset viewer.