First git commit
[howmuchuseit.git] / 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 }