Xinqi Bao's Git

projects / slstatus.git / blob


08866d2c823ea0f71218aa2839f108220da7072e
[slstatus.git] / slstatus.c
1 /* See LICENSE file for copyright and license details. */
2
3 #include <alsa/asoundlib.h>
4 #include <arpa/inet.h>
5 #include <fcntl.h>
6 #include <ifaddrs.h>
7 #include <limits.h>
8 #include <linux/wireless.h>
9 #include <locale.h>
10 #include <netdb.h>
11 #include <pwd.h>
12 #include <stdarg.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <sys/ioctl.h>
17 #include <sys/stat.h>
18 #include <sys/statvfs.h>
19 #include <sys/socket.h>
20 #include <sys/sysinfo.h>
21 #include <sys/types.h>
22 #include <time.h>
23 #include <unistd.h>
24 #include <X11/Xlib.h>
25
26 #undef strlcat
27 #undef strlcpy
28
29 #include "strlcat.h"
30 #include "strlcpy.h"
31
32 typedef char *(*op_fun)();
33 struct arg {
34 op_fun func;
35 const char *format;
36 const char *args;
37 };
38
39 static void setstatus(const char *);
40 static char *smprintf(const char *, ...);
41 static char *battery_perc(const char *);
42 static char *cpu_perc(void);
43 static char *datetime(const char *);
44 static char *disk_free(const char *);
45 static char *disk_perc(const char *);
46 static char *disk_total(const char *);
47 static char *disk_used(const char *);
48 static char *entropy(void);
49 static char *gid(void);
50 static char *hostname(void);
51 static char *ip(const char *);
52 static char *load_avg(void);
53 static char *ram_free(void);
54 static char *ram_perc(void);
55 static char *ram_used(void);
56 static char *ram_total(void);
57 static char *run_command(const char *);
58 static char *temp(const char *);
59 static char *uid(void);
60 static char *uptime(void);
61 static char *username(void);
62 static char *vol_perc(const char *);
63 static char *wifi_perc(const char *);
64 static char *wifi_essid(const char *);
65
66 static Display *dpy;
67
68 #include "config.h"
69
70 static void
71 setstatus(const char *str)
72 {
73 /* set WM_NAME via X11 */
74 XStoreName(dpy, DefaultRootWindow(dpy), str);
75 XSync(dpy, False);
76 }
77
78 static char *
79 smprintf(const char *fmt, ...)
80 {
81 va_list ap;
82 char tmp[120];
83 char *ret = NULL;
84
85 va_start(ap, fmt);
86 vsnprintf(tmp, sizeof(tmp)-1, fmt, ap);
87 tmp[strlen(tmp)+1] = '\0';
88
89 if (asprintf(&ret, "%s", tmp) < 0)
90 return NULL;
91
92 va_end(ap);
93 return ret;
94 }
95
96 static char *
97 battery_perc(const char *battery)
98 {
99 int now, full, perc;
100 char batterynowfile[64];
101 char batteryfullfile[64];
102 FILE *fp;
103
104 strlcpy(batterynowfile, BATTERY_PATH, sizeof(batterynowfile));
105 strlcat(batterynowfile, battery, sizeof(batterynowfile));
106 strlcat(batterynowfile, "/", sizeof(batterynowfile));
107 strlcat(batterynowfile, BATTERY_NOW, sizeof(batterynowfile));
108
109 strlcpy(batteryfullfile, BATTERY_PATH, sizeof(batteryfullfile));
110 strlcat(batteryfullfile, battery, sizeof(batteryfullfile));
111 strlcat(batteryfullfile, "/", sizeof(batteryfullfile));
112 strlcat(batteryfullfile, BATTERY_FULL, sizeof(batteryfullfile));
113
114 if (!(fp = fopen(batterynowfile, "r"))) {
115 fprintf(stderr, "Error opening battery file: %s.\n", batterynowfile);
116 return smprintf(UNKNOWN_STR);
117 }
118
119 fscanf(fp, "%i", &now);
120 fclose(fp);
121
122 if (!(fp = fopen(batteryfullfile, "r"))) {
123 fprintf(stderr, "Error opening battery file.\n");
124 return smprintf(UNKNOWN_STR);
125 }
126
127 fscanf(fp, "%i", &full);
128 fclose(fp);
129
130 perc = now / (full / 100);
131
132 return smprintf("%d%%", perc);
133 }
134
135 static char *
136 cpu_perc(void)
137 {
138 int perc;
139 long double a[4], b[4];
140 FILE *fp;
141
142 if (!(fp = fopen("/proc/stat","r"))) {
143 fprintf(stderr, "Error opening stat file.\n");
144 return smprintf(UNKNOWN_STR);
145 }
146
147 fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2], &a[3]);
148 fclose(fp);
149
150 /* wait a second (for avg values) */
151 sleep(1);
152
153 if (!(fp = fopen("/proc/stat","r"))) {
154 fprintf(stderr, "Error opening stat file.\n");
155 return smprintf(UNKNOWN_STR);
156 }
157
158 fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &b[0], &b[1], &b[2], &b[3]);
159 fclose(fp);
160 perc = 100 * ((b[0]+b[1]+b[2]) - (a[0]+a[1]+a[2])) / ((b[0]+b[1]+b[2]+b[3]) - (a[0]+a[1]+a[2]+a[3]));
161 return smprintf("%d%%", perc);
162 }
163
164 static char *
165 datetime(const char *timeformat)
166 {
167 time_t t;
168 char timestr[80];
169
170 t = time(NULL);
171 if (strftime(timestr, sizeof(timestr), timeformat, localtime(&t)) == 0)
172 return smprintf(UNKNOWN_STR);
173
174 return smprintf("%s", timestr);
175 }
176
177 static char *
178 disk_free(const char *mountpoint)
179 {
180 struct statvfs fs;
181
182 if (statvfs(mountpoint, &fs) < 0) {
183 fprintf(stderr, "Could not get filesystem info.\n");
184 return smprintf(UNKNOWN_STR);
185 }
186 return smprintf("%f", (float)fs.f_bsize * (float)fs.f_bfree / 1024 / 1024 / 1024);
187 }
188
189 static char *
190 disk_perc(const char *mountpoint)
191 {
192 int perc = 0;
193 struct statvfs fs;
194
195 if (statvfs(mountpoint, &fs) < 0) {
196 fprintf(stderr, "Could not get filesystem info.\n");
197 return smprintf(UNKNOWN_STR);
198 }
199
200 perc = 100 * (1.0f - ((float)fs.f_bfree / (float)fs.f_blocks));
201 return smprintf("%d%%", perc);
202 }
203
204 static char *
205 disk_total(const char *mountpoint)
206 {
207 struct statvfs fs;
208
209 if (statvfs(mountpoint, &fs) < 0) {
210 fprintf(stderr, "Could not get filesystem info.\n");
211 return smprintf(UNKNOWN_STR);
212 }
213
214 return smprintf("%f", (float)fs.f_bsize * (float)fs.f_blocks / 1024 / 1024 / 1024);
215 }
216
217 static char *
218 disk_used(const char *mountpoint)
219 {
220 struct statvfs fs;
221
222 if (statvfs(mountpoint, &fs) < 0) {
223 fprintf(stderr, "Could not get filesystem info.\n");
224 return smprintf(UNKNOWN_STR);
225 }
226
227 return smprintf("%f", (float)fs.f_bsize * ((float)fs.f_blocks - (float)fs.f_bfree) / 1024 / 1024 / 1024);
228 }
229
230 static char *
231 entropy(void)
232 {
233 int entropy = 0;
234 FILE *fp;
235
236 if (!(fp = fopen("/proc/sys/kernel/random/entropy_avail", "r"))) {
237 fprintf(stderr, "Could not open entropy file.\n");
238 return smprintf(UNKNOWN_STR);
239 }
240
241 fscanf(fp, "%d", &entropy);
242 fclose(fp);
243 return smprintf("%d", entropy);
244 }
245
246 static char *
247 gid(void)
248 {
249 gid_t gid = getgid();
250 return smprintf("%d", gid);
251 }
252
253 static char *
254 hostname(void)
255 {
256 char hostname[HOST_NAME_MAX];
257 FILE *fp;
258
259 if (!(fp = fopen("/proc/sys/kernel/hostname", "r"))) {
260 fprintf(stderr, "Could not open hostname file.\n");
261 return smprintf(UNKNOWN_STR);
262 }
263
264 fscanf(fp, "%s\n", hostname);
265 fclose(fp);
266 return smprintf("%s", hostname);
267 }
268
269 static char *
270 ip(const char *interface)
271 {
272 struct ifaddrs *ifaddr, *ifa;
273 int s;
274 char host[NI_MAXHOST];
275
276 if (getifaddrs(&ifaddr) == -1) {
277 fprintf(stderr, "Error getting IP address.\n");
278 return smprintf(UNKNOWN_STR);
279 }
280
281 /* get the ip address */
282 for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
283 if (ifa->ifa_addr == NULL)
284 continue;
285
286 s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
287
288 if ((strcmp(ifa->ifa_name, interface) == 0) && (ifa->ifa_addr->sa_family == AF_INET)) {
289 if (s != 0) {
290 fprintf(stderr, "Error getting IP address.\n");
291 return smprintf(UNKNOWN_STR);
292 }
293 return smprintf("%s", host);
294 }
295 }
296
297 /* free the address */
298 freeifaddrs(ifaddr);
299
300 return smprintf(UNKNOWN_STR);
301 }
302
303 static char *
304 load_avg(void)
305 {
306 double avgs[3];
307
308 if (getloadavg(avgs, 3) < 0) {
309 fprintf(stderr, "Error getting load avg.\n");
310 return smprintf(UNKNOWN_STR);
311 }
312
313 return smprintf("%.2f %.2f %.2f", avgs[0], avgs[1], avgs[2]);
314 }
315
316 static char *
317 ram_free(void)
318 {
319 long free;
320 FILE *fp;
321
322 if (!(fp = fopen("/proc/meminfo", "r"))) {
323 fprintf(stderr, "Error opening meminfo file.\n");
324 return smprintf(UNKNOWN_STR);
325 }
326
327 fscanf(fp, "MemFree: %ld kB\n", &free);
328 fclose(fp);
329 return smprintf("%f", (float)free / 1024 / 1024);
330 }
331
332 static char *
333 ram_perc(void)
334 {
335 int perc;
336 long total, free, buffers, cached;
337 FILE *fp;
338
339 if (!(fp = fopen("/proc/meminfo", "r"))) {
340 fprintf(stderr, "Error opening meminfo file.\n");
341 return smprintf(UNKNOWN_STR);
342 }
343
344 fscanf(fp, "MemTotal: %ld kB\n", &total);
345 fscanf(fp, "MemFree: %ld kB\n", &free);
346 fscanf(fp, "MemAvailable: %ld kB\nBuffers: %ld kB\n", &buffers, &buffers);
347 fscanf(fp, "Cached: %ld kB\n", &cached);
348
349 fclose(fp);
350 perc = 100 * ((total - free) - (buffers + cached)) / total;
351 return smprintf("%d%%", perc);
352 }
353
354 static char *
355 ram_total(void)
356 {
357 long total;
358 FILE *fp;
359
360 if (!(fp = fopen("/proc/meminfo", "r"))) {
361 fprintf(stderr, "Error opening meminfo file.\n");
362 return smprintf(UNKNOWN_STR);
363 }
364
365 fscanf(fp, "MemTotal: %ld kB\n", &total);
366 fclose(fp);
367 return smprintf("%f", (float)total / 1024 / 1024);
368 }
369
370 static char *
371 ram_used(void)
372 {
373 long free, total, buffers, cached, used;
374 FILE *fp;
375
376 if (!(fp = fopen("/proc/meminfo", "r"))) {
377 fprintf(stderr, "Error opening meminfo file.\n");
378 return smprintf(UNKNOWN_STR);
379 }
380
381 fscanf(fp, "MemTotal: %ld kB\n", &total);
382 fscanf(fp, "MemFree: %ld kB\n", &free);
383 fscanf(fp, "MemAvailable: %ld kB\nBuffers: %ld kB\n", &buffers, &buffers);
384 fscanf(fp, "Cached: %ld kB\n", &cached);
385
386 fclose(fp);
387 used = total - free - buffers - cached;
388 return smprintf("%f", (float)used / 1024 / 1024);
389 }
390
391 static char *
392 run_command(const char* command)
393 {
394 int good;
395 FILE *fp;
396 char buffer[64];
397
398 if (!(fp = popen(command, "r"))) {
399 fprintf(stderr, "Could not get command output for: %s.\n", command);
400 return smprintf(UNKNOWN_STR);
401 }
402
403 fgets(buffer, sizeof(buffer) - 1, fp);
404 pclose(fp);
405 for (int i = 0 ; i != sizeof(buffer); i++) {
406 if (buffer[i] == '\0') {
407 good = 1;
408 break;
409 }
410 }
411 if (good)
412 buffer[strlen(buffer) - 1] = '\0';
413 return smprintf("%s", buffer);
414 }
415
416 static char *
417 temp(const char *file)
418 {
419 int temperature;
420 FILE *fp;
421
422 if (!(fp = fopen(file, "r"))) {
423 fprintf(stderr, "Could not open temperature file.\n");
424 return smprintf(UNKNOWN_STR);
425 }
426
427 fscanf(fp, "%d", &temperature);
428 fclose(fp);
429 return smprintf("%d°C", temperature / 1000);
430 }
431
432 static char *
433 uptime(void)
434 {
435 struct sysinfo info;
436 int hours = 0;
437 int minutes = 0;
438
439 sysinfo(&info);
440 hours = info.uptime / 3600;
441 minutes = (info.uptime - hours * 3600 ) / 60;
442
443 return smprintf("%dh %dm", hours, minutes);
444 }
445
446 static char *
447 username(void)
448 {
449 register struct passwd *pw;
450 register uid_t uid;
451
452 uid = geteuid();
453 pw = getpwuid(uid);
454
455 if (pw)
456 return smprintf("%s", pw->pw_name);
457 else {
458 fprintf(stderr, "Could not get username.\n");
459 return smprintf(UNKNOWN_STR);
460 }
461
462 return smprintf(UNKNOWN_STR);
463 }
464
465 static char *
466 uid(void)
467 {
468 register uid_t uid;
469
470 uid = geteuid();
471
472 if (uid)
473 return smprintf("%d", uid);
474 else {
475 fprintf(stderr, "Could not get uid.\n");
476 return smprintf(UNKNOWN_STR);
477 }
478
479 return smprintf(UNKNOWN_STR);
480 }
481
482
483 static char *
484 vol_perc(const char *soundcard)
485 {
486 int mute = 0;
487 long vol = 0, max = 0, min = 0;
488 snd_mixer_t *handle;
489 snd_mixer_elem_t *pcm_mixer, *mas_mixer;
490 snd_mixer_selem_id_t *vol_info, *mute_info;
491
492 snd_mixer_open(&handle, 0);
493 snd_mixer_attach(handle, soundcard);
494 snd_mixer_selem_register(handle, NULL, NULL);
495 snd_mixer_load(handle);
496
497 snd_mixer_selem_id_malloc(&vol_info);
498 snd_mixer_selem_id_malloc(&mute_info);
499 if (vol_info == NULL || mute_info == NULL) {
500 fprintf(stderr, "Could not get alsa volume.\n");
501 return smprintf(UNKNOWN_STR);
502 }
503 snd_mixer_selem_id_set_name(vol_info, ALSA_CHANNEL);
504 snd_mixer_selem_id_set_name(mute_info, ALSA_CHANNEL);
505 pcm_mixer = snd_mixer_find_selem(handle, vol_info);
506 mas_mixer = snd_mixer_find_selem(handle, mute_info);
507
508 snd_mixer_selem_get_playback_volume_range((snd_mixer_elem_t *)pcm_mixer, &min, &max);
509 snd_mixer_selem_get_playback_volume((snd_mixer_elem_t *)pcm_mixer, SND_MIXER_SCHN_MONO, &vol);
510 snd_mixer_selem_get_playback_switch(mas_mixer, SND_MIXER_SCHN_MONO, &mute);
511
512 if (vol_info)
513 snd_mixer_selem_id_free(vol_info);
514 if (mute_info)
515 snd_mixer_selem_id_free(mute_info);
516 if (handle)
517 snd_mixer_close(handle);
518
519 if (!mute)
520 return smprintf("mute");
521 else
522 return smprintf("%d%%", (vol * 100) / max);
523 }
524
525 static char *
526 wifi_perc(const char *wificard)
527 {
528 int bufsize = 255;
529 int strength;
530 char buf[bufsize];
531 char *datastart;
532 char path[64];
533 char status[5];
534 char needle[sizeof wificard + 1];
535 FILE *fp;
536
537 memset(path, 0, sizeof path);
538 strlcat(path, "/sys/class/net/", sizeof(path));
539 strlcat(path, wificard, sizeof(path));
540 strlcat(path, "/operstate", sizeof(path));
541
542 if(!(fp = fopen(path, "r"))) {
543 fprintf(stderr, "Error opening wifi operstate file.\n");
544 return smprintf(UNKNOWN_STR);
545 }
546
547 fgets(status, 5, fp);
548 fclose(fp);
549 if(strcmp(status, "up\n") != 0)
550 return smprintf(UNKNOWN_STR);
551
552 if (!(fp = fopen("/proc/net/wireless", "r"))) {
553 fprintf(stderr, "Error opening wireless file.\n");
554 return smprintf(UNKNOWN_STR);
555 }
556
557 strlcpy(needle, wificard, sizeof(needle));
558 strlcat(needle, ":", sizeof(needle));
559 fgets(buf, bufsize, fp);
560 fgets(buf, bufsize, fp);
561 fgets(buf, bufsize, fp);
562 if ((datastart = strstr(buf, needle)) != NULL) {
563 datastart = strstr(buf, ":");
564 sscanf(datastart + 1, " %*d %d %*d %*d %*d %*d %*d %*d %*d %*d", &strength);
565 }
566
567 fclose(fp);
568 return smprintf("%d%%", strength);
569 }
570
571 static char *
572 wifi_essid(const char *wificard)
573 {
574 char id[IW_ESSID_MAX_SIZE+1];
575 int sockfd;
576 struct iwreq wreq;
577
578 memset(&wreq, 0, sizeof(struct iwreq));
579 wreq.u.essid.length = IW_ESSID_MAX_SIZE+1;
580 sprintf(wreq.ifr_name, wificard);
581 if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
582 fprintf(stderr, "Cannot open socket for interface: %s\n", wificard);
583 return smprintf(UNKNOWN_STR);
584 }
585 wreq.u.essid.pointer = id;
586 if (ioctl(sockfd,SIOCGIWESSID, &wreq) == -1) {
587 fprintf(stderr, "Get ESSID ioctl failed for interface %s\n", wificard);
588 return smprintf(UNKNOWN_STR);
589 }
590
591 if (strcmp((char *)wreq.u.essid.pointer, "") == 0)
592 return smprintf(UNKNOWN_STR);
593 else
594 return smprintf("%s", (char *)wreq.u.essid.pointer);
595 }
596
597 int
598 main(void)
599 {
600 size_t i;
601 char status_string[4096];
602 char *res, *element;
603 struct arg argument;
604
605 if (!(dpy = XOpenDisplay(0x0))) {
606 fprintf(stderr, "Cannot open display!\n");
607 exit(1);
608 }
609
610 for (;;) {
611 memset(status_string, 0, sizeof(status_string));
612 for (i = 0; i < sizeof(args) / sizeof(args[0]); ++i) {
613 argument = args[i];
614 if (argument.args == NULL)
615 res = argument.func();
616 else
617 res = argument.func(argument.args);
618 element = smprintf(argument.format, res);
619 if (element == NULL) {
620 element = smprintf(UNKNOWN_STR);
621 fprintf(stderr, "Failed to format output.\n");
622 }
623 strlcat(status_string, element, sizeof(status_string));
624 free(res);
625 free(element);
626 }
627
628 setstatus(status_string);
629 sleep(UPDATE_INTERVAL -1);
630 }
631
632 XCloseDisplay(dpy);
633 return 0;
634 }