mon_dtracepipe.c

Go to the documentation of this file.

/*
    clsync - file tree sync utility based on inotify/kqueue
 
    Copyright (C) 2013-2014 Dmitry Yu Okunev <dyokunev@ut.mephi.ru> 0x8E30679C
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "common.h"
#include "malloc.h"
#include "error.h"
#include "indexes.h"
#include "sync.h"
#include "mon_dtracepipe.h"
 
#define DTRACE_SCRIPT "BEGIN\
{\
    dir = $1;\
    dirlen = strlen(dir);\
}\
\
syscall::open*:entry\
/\
arg1 & (O_WRONLY|O_RDWR) &&\
    substr(copyinstr(arg0),0,dirlen)==dir\
/\
{\
    printf("%s\n",copyinstr(arg0));\
}\
\
syscall::mkdir*:entry\
/\
    substr(copyinstr(arg0),0,dirlen)==dir\
/\
{\
    printf("%s\n",copyinstr(arg0));\
}"
 
struct mondata {
    FILE *pipe;
};
typedef struct mondata mondata_t;
 
#define DTRACEPIPE_INIT_ERROR {\
        free(ctx_p->fsmondata);\
        ctx_p->fsmondata = NULL;\
        return -1;\
    }
 
int dtracepipe_init ( ctx_t *ctx_p )
{
    char cmd[BUFSIZ];
    ctx_p->fsmondata = xcalloc ( sizeof ( mondata_t ), 1 );
    mondata_t *mondata = ctx_p->fsmondata;
 
    if ( snprintf ( cmd, "%s -n '%s' '%s'", DTRACE_PATH, DTRACE_SCRIPT, ) >= BUFSIZ ) {
        errno = EMSGSIZE;
        error ( "Too long cmd." );
        DTRACEPIPE_INIT_ERROR;
    }
 
    FILE *pipe = popen ( cmd, "r" );
 
    if ( pipe == NULL ) {
        error ( "Cannot popen(\""DTRACE_PATH"\", \"r\")" );
        DTRACEPIPE_INIT_ERROR;
    }
 
    if ( setvbuf ( pipe, NULL, _IONBF, 0 ) ) {
        error ( "Cannot set unbuffered mode for pipe of \""DTRACE_PATH"\" process" );
        DTRACEPIPE_INIT_ERROR;
    }
 
    mondata->pipe = pipe;
    return 0;
}
 
char  *dtracepipe_wait_line = NULL;
size_t dtracepipe_wait_line_siz;
int dtracepipe_wait ( struct ctx *ctx_p, struct indexes *indexes_p, struct timeval *timeout_p )
{
    mondata_t *mondata = ctx_p->fsmondata;
    struct timeval timeout_abs, tv_abs;
    int dontwait = 0;
    struct dtracepipe_event *event_p = &mondata->event;
 
    if ( timeout_p->tv_sec == 0 && timeout_p->tv_usec == 0 )
        dontwait = 1;
 
    if ( !dontwait ) {
        gettimeofday ( &tv_abs, NULL );
        timeradd ( &tv_abs, timeout_p, &timeout_abs );
    }
 
    int pipe_fd = fileno ( mondata->pipe );
 
    while ( 42 ) {
        int path_count;
 
        // Checking if there already a recond in mondata
        if ( *event_p->path ) {
            debug ( 2, "we have an event. return 1." );
            return 1;
        }
 
        // Getting a record
        {
            debug ( 3, "select() with timeout %li.%06li secs (dontwait == %u).", timeout_p->tv_sec, timeout_p->tv_usec, dontwait );
            fd_set rfds;
            FD_ZERO ( &rfds );
            FD_SET ( pipe_fd, &rfds );
            int rc = select ( pipe_fd + 1, &rfds, NULL, NULL, timeout_p );
 
            if ( rc == 0 || rc == -1 )
                return rc;
 
            line_len = getline ( &dtracepipe_wait_line, &dtracepipe_wait_line_siz, mondata->pipe );
 
            if ( line_len == -1 ) {
                error ( "Cannot read line from \""DTRACE_PATH"\" pipe [using getline()]" );
                return -1;
            }
 
            if ( !dontwait ) {
                debug ( 5, "old timeout_p->: tv_sec == %lu; tv_usec == %lu", timeout_p->tv_sec, timeout_p->tv_usec );
                gettimeofday ( &tv_abs, NULL );
 
                if ( timercmp ( &timeout_abs, &tv_abs, < ) )
                    timersub ( &timeout_abs, &tv_abs, timeout_p );
                else
                    memset ( timeout_p, 0, sizeof ( *timeout_p ) );
 
                debug ( 5, "new timeout_p->: tv_sec == %lu; tv_usec == %lu", timeout_p->tv_sec, timeout_p->tv_usec );
            }
        }
        // Parsing the record
        path_count = 0;
        debug ( 3, "parsing the event" );
 
        while ( au_parsed < au_len ) {
            if ( au_fetch_tok ( &tok, &au_buf[au_parsed], au_len - au_parsed ) == -1 )
                return -1;
 
            au_parsed += tok.len;
 
            switch ( tok.id ) {
                case AUT_HEADER32:
                case AUT_HEADER32_EX:
                case AUT_HEADER64:
                case AUT_HEADER64_EX: {
                        event_p->type = tok.tt.hdr32.e_type;
                        path_count = 0;
                        break;
                    }
 
                case AUT_PATH: {
                        char *ptr;
                        int dir_wd, dir_iswatched;
                        ptr = memrchr ( tok.tt.path.path, '/', tok.tt.path.len );
#ifdef PARANOID
 
                        if ( ptr == NULL )
                            critical ( "relative path received from au_fetch_tok(): \"%s\" (len: %u)", tok.tt.path.path, tok.tt.path.len );
 
#endif
                        debug ( 6, "Event on \"%s\".", tok.tt.path.path );
                        *ptr = 0;
                        dir_wd = indexes_fpath2wd ( indexes_p, tok.tt.path.path );
                        dir_iswatched = ( dir_wd != -1 );
                        debug ( 7, "Directory is \"%s\". dir_wd == %i; dir_iswatched == %u", tok.tt.path.path, dir_wd, dir_iswatched );
                        *ptr = '/';
 
                        if ( dir_iswatched ) {
                            debug ( 5, "Event on \"%s\" is watched. Pushing. path_count == %u", tok.tt.path.path, path_count );
 
                            switch ( path_count ) {
                                case 0:
                                    memcpy ( event_p->path,    tok.tt.path.path, tok.tt.path.len + 1 );
                                    break;
 
                                case 1:
                                    memcpy ( event_p->path_to, tok.tt.path.path, tok.tt.path.len + 1 );
                                    break;
#ifdef PARANOID
 
                                default:
                                    warning ( "To many paths on BSM event: \"%s\" (already count: %u)", tok.tt.path.path, path_count );
                                    break;
#endif
                            }
                        }
 
                        path_count++;
                        break;
                    }
 
                default:
                    continue;
            }
        }
 
        // Cleanup
        debug ( 4, "clean up" );
        free ( au_buf );
        au_buf    = NULL;
        au_len    = 0;
        au_parsed = 0;
    }
 
    return -1;
}
int dtracepipe_handle ( struct ctx *ctx_p, struct indexes *indexes_p )
{
    return -1;
}
int dtracepipe_add_watch_dir ( struct ctx *ctx_p, struct indexes *indexes_p, const char *const accpath )
{
    return -1;
}
int dtracepipe_deinit ( ctx_t *ctx_p )
{
    mondata_t *mondata = ctx_p->fsmondata;
    free ( dtracepipe_wait_line );
    free ( mondata );
    return -1;
}