howmuchuseit.c

   1 /*
   2  *  howmuchuseit.c
   3  *
   4  *  Copyright (C) 2011
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABLILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * General Public License for more details. You should have received a
  15  * copy of the GNU General Public License along with this program; if
  16  * not, write to the Free Software Foundation, Inc, 59 Temple Place -
  17  * Suite 330, Boston, MA 02111-1307, USA.
  18  *
  19  */
  20
  21 #include <sys/select.h>
  22 #include <sys/time.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26 #include <limits.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <time.h>
  30 #include <signal.h>
  31
  32 #include "howmuchuseit.h"
  33
  34 struct context {
  35     FILE *fout;
  36     time_t start;
  37     int is_verbose;
  38     int is_working;
  39 };
  40
  41 struct context *g_ctx = NULL;
  42
  43 void sig_handler(int sig);
  44 void now_not_working(struct context *ctx);
  45
  46 void now_working(struct context *ctx)
  47 {
  48     if (ctx->is_working == 0) {
  49         ctx->start = time(NULL);
  50         if (ctx->is_verbose) {
  51             printf("now is working\n");
  52         }
  53         ctx->is_working = 1;
  54     }
  55 }
  56
  57 void now_not_working(struct context *ctx)
  58 {
  59     time_t curtime;
  60
  61     if (ctx->is_working == 1) {
  62         curtime = time(NULL);
  63         fprintf(ctx->fout, "%ld:%ld\n", (long int)curtime, (long int)(curtime - ctx->start));
  64         fflush(ctx->fout);
  65         if (ctx->is_verbose) {
  66             printf("now not is working\n");
  67         }
  68         ctx->is_working = 0;
  69     }
  70 }
  71
  72
  73 void sig_handler(int sig)
  74 {
  75     if (g_ctx) {
  76         time_t curtime;
  77
  78         now_not_working(g_ctx);
  79         curtime = time(NULL);
  80         fprintf(g_ctx->fout, "# end at %ld\n", (long int)curtime);
  81         fflush(g_ctx->fout);
  82     }
  83
  84     exit (0);
  85 }
  86
  87 int main(int argc, char *argv[])
  88 {
  89     time_t curtime;
  90     struct context ctx;
  91     int inactive_time = 10;
  92     int argd, fd[MAX_FD], fd_n;
  93     char fd_name[MAX_FD][PATH_MAX+1];
  94     int is_daemon = 0;
  95     int is_verbose = 0;
  96     char fd_max = -1, fd_path[PATH_MAX+1], bf[1024];
  97     int i;
  98
  99     fd_set rfds;
 100     struct timeval tv;
 101     int retval;
 102
 103     ctx.is_working = 0;
 104
 105     for (argd = 1 ; argd < argc ; argd++) {
 106         if (strcmp(argv[argd], "-i") == 0) {
 107             if ((argd+1) < argc) {
 108                 inactive_time = atoi(argv[argd+1]);
 109                 argd++;
 110             }
 111         }
 112         else if (strcmp(argv[argd], "-d") == 0) {
 113             is_daemon = 1;
 114         }
 115         else if (strcmp(argv[argd], "-v") == 0) {
 116             is_verbose = 1;
 117         }
 118         else {
 119             break;
 120         }
 121     }
 122
 123     if (is_daemon) {
 124         is_verbose = 0;
 125     }
 126
 127     if (is_daemon) {
 128         if (daemon(0, 0) != 0) {
 129             exit(3);
 130         }
 131     }
 132
 133     for (fd_n = 0; argd < argc ; argd++, fd_n++) {
 134         sprintf(fd_path, "%s/%s", EVENT_PATH, argv[argd]);
 135         strcpy(fd_name[fd_n], argv[argd]);
 136         if ((fd[fd_n] = open(fd_path, O_RDONLY)) == -1) {
 137             exit(1);
 138         }
 139         if (is_verbose) {
 140             printf("[%s] opened for read\n", fd_path);
 141         }
 142         if (fd_max < fd[fd_n]) {
 143             fd_max = fd[fd_n];
 144         }
 145     }
 146
 147     if ((ctx.fout = fopen(OUTPUT_FILE, "a")) == NULL) {
 148         exit(2);
 149     }
 150
 151     curtime = time(NULL);
 152     fprintf(ctx.fout, "# start at %ld\n", (long int)curtime);
 153     fflush(ctx.fout);
 154
 155     ctx.is_verbose = is_verbose;
 156     g_ctx = &ctx;
 157
 158     signal(SIGINT, sig_handler);
 159     signal(SIGTERM, sig_handler);
 160
 161     if (is_verbose) {
 162         printf("[%s] opened for append\n", OUTPUT_FILE);
 163     }
 164
 165     while (1) {
 166         FD_ZERO(&rfds);
 167         for (i = 0 ; i < fd_n ; i++) {
 168             FD_SET(fd[i], &rfds);
 169         }
 170         tv.tv_sec = inactive_time;
 171         tv.tv_usec = 0;
 172
 173         retval = select(fd_max+1, &rfds, NULL, NULL, &tv);
 174            /* Don't rely on the value of tv now! */
 175
 176         if (retval > 0) {
 177             for (i = 0 ; i < fd_n ; i++) {
 178                 if(FD_ISSET(fd[i], &rfds)) {
 179                     if (is_verbose) {
 180                         printf("data from [%s]\n", fd_name[i]);
 181                     }
 182                     read(fd[i], bf, 1024);
 183                 }
 184             }
 185             now_working(&ctx);
 186         }
 187         else if (retval == 0) {
 188             now_not_working(&ctx);
 189
 190
 191         }
 192         if (is_verbose) {
 193             fflush(stdout);
 194         }
 195     }
 196
 197
 198     exit (0);
 199     return (0);
 200 }