/* logcalls.c 
 * by pheisar <pheisar@ccl.pt> 
 * http://www.ccl.pt/~pheisar/pgpkey  
 * 
 * logs specific calls like 'mkdir', 'rmdir', etc, called by users in a logfile (FILENAME). 
 *  
 * note: i wanted to add more log functions for more calls, but i ain't in the mood, so..
 *   do it yourself. 
 *
 * bash# gcc logcalls.c -o logcalls.so -ldl -shared -O2 -s
 * bash# export LD_PRELOAD=/path/to/logcalls.so
 *
 * note: set the FILENAME and LIBPATH constants to fit your system.
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <pwd.h>
#include <sys/time.h>

/* don't want to log a specific call? just define it to 0 */
#define MKDIRX 1
#define RMDIRX 2  
#define LINKX 3
#define OPENX 4 /* not tested */

#define FILENAME "/tmp/logfile"   // logfile
#define LIBPATH "/lib/libc.so.6"  // lib path

FILE *fd; 
int result;
struct passwd *pwd;
struct timeval tm;

/* prototypes */
static void openlog(void);
static void logfunc(int, const char *, const char *, mode_t, int);
void print_time(const struct timeval *);
int mkdir(const char *, mode_t);
int rmdir(const char*);
int link(const char *, const char *);
int my_open(const char *, int);
int (*realmkdir)(const char *, mode_t);
int (*realrmdir)(const char *);
int (*reallink)(const char *, const char *);
int (*realopen)(const char *, int);

//////////////
// logfile  //
//////////////
static void openlog(void)
{
  umask(0);
  fd = fopen(FILENAME, "a");
  if(fd == NULL) {
    perror("fopen()");
    exit(1);
  }
}  
  
//////////////////
// log function //
////////////////// 
static void logfunc(int x, const char *oldpath, const char *pathname, mode_t mode, int result)
{
  openlog();
  
  pwd = getpwuid(getuid());
  if(pwd == NULL) {
    perror("getpwuid()");
    exit(1);
  }
  
  gettimeofday(&tm, 0);

  print_time(&tm);
  fprintf(fd, " - %s(%d) ", pwd->pw_name, pwd->pw_uid);
  fprintf(fd, "called ");
  
  if(x == RMDIRX) fprintf(fd, "rmdir(%s), %s\n", pathname, (!result) ? "success." : "error.");
  if(x == MKDIRX) fprintf(fd, "mkdir(%s, %u), %s\n", pathname, mode, (!result) ? "success." : "error.");
  if(x == LINKX)  fprintf(fd, "link(%s, %s), %s\n", oldpath, pathname, (!result) ? "success." : "error.");
  if(x == OPENX)  fprintf(fd, "open(%s, %d), %s\n", pathname, (!result) ? "success." : "error.");

  fclose(fd);
}

///////////////////////
// mkdir redirection //
/////////////////////// 
int mkdir(const char *pathname, mode_t mode)
{
  void *handle;
  result = 0;
  
  handle = dlopen(LIBPATH, 1);
  if(!handle) {
    fputs(dlerror(), stderr);
    exit(1);
  }
  
  realmkdir = dlsym(handle, "mkdir");
  if(!realmkdir) {
    fputs(dlerror(), stderr);
    exit(1);
  }

  result = realmkdir(pathname, mode);
  
  logfunc(MKDIRX, NULL, pathname, mode, result);

  return result;
}  

///////////////////////
// rmdir redirection //
///////////////////////
int rmdir(const char *pathname)
{
  void *handle;
  result = 0;

  handle = dlopen(LIBPATH, 1);
  if(!handle) {
    fputs(dlerror(), stderr);
    exit(1);
  }

  realrmdir = dlsym(handle, "rmdir");
  if(!realrmdir) {
    fputs(dlerror(), stderr);
    exit(1);
  }

  result = realrmdir(pathname);
  
  logfunc(RMDIRX, NULL, pathname, 0, result);

  return result;
}

//////////////////////
// link redirection //
//////////////////////
int link(const char *oldpath, const char *newpath)
{
  void *handle;

  handle = dlopen(LIBPATH, 1);
  if(!handle) {
    fputs(dlerror(), stderr);
                exit(1);
        }
  
  reallink = dlsym(handle, "link");
  if(!reallink) {
    fputs(dlerror(), stderr);
                exit(1);
        }

  result = reallink(oldpath, newpath);
  
  logfunc(LINKX, oldpath, newpath, 0, result);

  return result;
}  

//////////////////////
// open redirection //
//////////////////////
int my_open(const char *pathname, int flags)
{
  void *handle;
        
        handle = dlopen(LIBPATH, 1);
        if(!handle) {
                fputs(dlerror(), stderr);
                exit(1);
        }

  realopen = dlsym(handle, "open");
  if(!realopen) {
    fputs(dlerror(), stderr);
                exit(1);
        }

  result = realopen(pathname, flags);
  
  logfunc(OPENX, NULL, pathname, 0, result);
  
  return result;
}

///////////////
// timestamp //
///////////////
void print_time(const struct timeval *tm)
{
  register int s;

  s = (tm->tv_sec) % 86400;

  fprintf(fd, "%02d:%02d:%02d", s / 3600, (s % 3600) / 60, s % 60);
}

/* EOF */