465 lines
9.2 KiB
C
465 lines
9.2 KiB
C
#pragma GCC diagnostic ignored "-Wunused-function"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <dirent.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/sysinfo.h>
|
|
#include <pci/pci.h>
|
|
|
|
#define BUF_SIZE 50
|
|
#define COLS 8
|
|
#define ROWS 100
|
|
|
|
//for easier checks
|
|
#define SUPPORTED_OS "xadurm"
|
|
#define ARCH_BASED "axmr"
|
|
#define DEBIAN_BASED "du"
|
|
#define OS_TABLE "a:Arch|x:Artix|r:Arco|m:Manjaro|u:Ubuntu|d:Debian"
|
|
|
|
//ascii art header file
|
|
#include "logos.h"
|
|
|
|
|
|
// standardish functions
|
|
void read_line(char x);
|
|
void cache_info(char **cpu_name, char **gpu);
|
|
static int count_files(DIR *package_dir);
|
|
|
|
// 'get info' functions
|
|
static char *get_sys(char *s_os, char *os_name);
|
|
static char *get_kernel(char *kern_name);
|
|
static char *get_uptime(char *uptime);
|
|
static char *get_RAM(char *ram_info);
|
|
static char *get_cpu(char *cpuname);
|
|
static char *get_gpu(char *gpu);
|
|
static char *get_packages(char *package_count);
|
|
|
|
// final function
|
|
void concatenate_print(char *os, char *cpu_name, char *gpu);
|
|
|
|
// easier if global, don't hate me
|
|
char sys;
|
|
int logo_number = 0;
|
|
|
|
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]){
|
|
|
|
|
|
char *os_name = NULL,
|
|
*cpu_name = NULL,
|
|
*gpu = NULL,
|
|
*s_os = SUPPORTED_OS,
|
|
*os = malloc(BUF_SIZE);
|
|
|
|
|
|
|
|
// if cache file exits, read it, otherwise cache info
|
|
cache_info(&cpu_name, &gpu);
|
|
os = get_sys(s_os, os_name);
|
|
|
|
|
|
// check if custom ascii art argument is passed
|
|
if ( argv[1] != NULL ) {
|
|
|
|
if ( strchr(SUPPORTED_OS, *(argv[1] + 1)) )
|
|
logo_number = (int) (strchr(s_os, *(argv[1] + 1) ) - s_os);
|
|
|
|
else {
|
|
fprintf(stderr, "\n\nArgument not supported\n\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
concatenate_print( os, cpu_name, gpu);
|
|
|
|
|
|
free(os_name);
|
|
free(cpu_name);
|
|
free(gpu);
|
|
free(os);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void read_line(char x) {
|
|
int c;
|
|
while (( c = getchar()) != x && c != EOF) {}
|
|
}
|
|
|
|
|
|
|
|
|
|
void truncate_spaces(char *str) {
|
|
int src = 0, dst = 0, index, i = -1;
|
|
|
|
while(*(str + dst) == ' ') dst++;
|
|
|
|
while(*(str + dst) != '\0') {
|
|
*(str + src) = *(str + dst);
|
|
if(*(str + (dst++)) == ' ')
|
|
while(*(str + dst) == ' ') dst++;
|
|
|
|
src++;
|
|
}
|
|
|
|
*(str + src) = '\0';
|
|
|
|
i = 0;
|
|
while(str[i] != '\0'){
|
|
if(str[i] != ' ' && str[i] != '\t' && str[i] != '\n'){
|
|
index= i;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
|
|
str[index + 1] = '\0';
|
|
}
|
|
|
|
|
|
|
|
void cache_info(char **cpu_name, char **gpu) {
|
|
|
|
char *cache_path = malloc(BUF_SIZE * 2);
|
|
FILE *f_cache = NULL;
|
|
|
|
// construct path to file
|
|
snprintf(cache_path, BUF_SIZE * 2, "%s/.local/share/fetchy.cache", getenv("HOME"));
|
|
|
|
if( (f_cache = fopen(cache_path, "r")) ){
|
|
|
|
char *line = malloc(BUF_SIZE * 4);
|
|
*cpu_name = malloc(BUF_SIZE * 4);
|
|
*gpu = malloc(BUF_SIZE * 4);
|
|
|
|
//get CPU
|
|
fgets(line, BUF_SIZE * 4, f_cache);
|
|
truncate_spaces(line);
|
|
snprintf(*cpu_name, BUF_SIZE * 4, "\x1b[36mCPU\x1b[0m -> %s", strchr(line, ':') +2);
|
|
|
|
//get GPU
|
|
fgets(line, BUF_SIZE * 4, f_cache);
|
|
truncate_spaces(line);
|
|
snprintf(*gpu, BUF_SIZE * 4, "\x1b[36mGPU\x1b[0m -> %s", strchr(line, ':') +2);
|
|
|
|
|
|
fclose(f_cache);
|
|
free(line);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
f_cache = fopen(cache_path, "w");
|
|
|
|
if( f_cache == NULL ){
|
|
printf("\nCan't open cache file.\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// Write info to file
|
|
fprintf(f_cache, "CPU : %s\n", get_cpu(*cpu_name));
|
|
fprintf(f_cache, "GPU : %s\n", get_gpu(*gpu));
|
|
|
|
fclose(f_cache);
|
|
|
|
|
|
|
|
printf("\n FILE CACHING DONE!!\n");
|
|
printf("Caching occurs only once,\n");
|
|
printf("every subsequent execution will\n");
|
|
printf("run program normally. Enjoy!\n\n");
|
|
|
|
|
|
cache_info(cpu_name, gpu);
|
|
}
|
|
free(cache_path);
|
|
}
|
|
|
|
|
|
|
|
static int count_files(DIR *package_dir) {
|
|
|
|
struct dirent * entry;
|
|
int file_count = 0;
|
|
|
|
while ((entry = readdir(package_dir)) != NULL) {
|
|
if (entry->d_type == DT_DIR) {
|
|
file_count++;
|
|
}
|
|
}
|
|
closedir(package_dir);
|
|
|
|
return file_count;
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *get_sys(char *s_os, char *os_name) {
|
|
|
|
char *name = malloc(BUF_SIZE);
|
|
FILE *f_sys_name = fopen("/etc/issue", "rt");
|
|
os_name = malloc(BUF_SIZE);
|
|
|
|
if( f_sys_name == NULL ){
|
|
fprintf(stderr, "\nCan't get os name\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
|
|
fscanf(f_sys_name, "%s %*s", name);
|
|
fclose(f_sys_name);
|
|
truncate_spaces(name);
|
|
|
|
|
|
sys = *(strstr(OS_TABLE, name) - 2);
|
|
logo_number = (int) (strchr(s_os, sys) - s_os);
|
|
|
|
|
|
if( sys == 'r' )
|
|
snprintf(os_name, BUF_SIZE, "\x1b[36mOS\x1b[0m -> %s", name); // Arco has a retarded name to be honest, without a space
|
|
else
|
|
snprintf(os_name, BUF_SIZE, "\x1b[36mOS\x1b[0m -> %s Linux", name);
|
|
|
|
|
|
free(name);
|
|
return os_name;
|
|
}
|
|
|
|
|
|
|
|
static char *get_cpu(char *cpu_name){
|
|
|
|
char *line = malloc(BUF_SIZE * 4);
|
|
cpu_name = malloc(BUF_SIZE * 4);
|
|
|
|
FILE *cpu = fopen("/proc/cpuinfo", "rt");
|
|
|
|
|
|
if( cpu == NULL ){
|
|
printf("\nCan't get cpu info\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// Skip first four lines, cpu info is on fifth
|
|
for(int i = 0; i < 5; i++)
|
|
fgets(line, BUF_SIZE * 4, cpu);
|
|
|
|
|
|
snprintf(cpu_name, BUF_SIZE * 4, "%s", strchr(line, ':') +2);
|
|
truncate_spaces(cpu_name);
|
|
|
|
|
|
fclose(cpu);
|
|
free(line);
|
|
|
|
return cpu_name;
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *get_gpu(char *gpu){
|
|
|
|
gpu = malloc(BUF_SIZE);
|
|
|
|
// https://github.com/pciutils/pciutils/blob/master/example.c
|
|
char buffer[BUF_SIZE];
|
|
struct pci_access * pacc = pci_alloc();
|
|
|
|
pci_init(pacc);
|
|
pci_scan_bus(pacc);
|
|
struct pci_dev * dev = pacc -> devices;
|
|
|
|
while (dev) {
|
|
pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS);
|
|
if (dev -> device_class == 768) {
|
|
break;
|
|
}
|
|
dev = dev -> next;
|
|
}
|
|
|
|
char * model = pci_lookup_name(pacc, buffer, sizeof(buffer), PCI_LOOKUP_DEVICE, dev -> vendor_id, dev -> device_id);
|
|
|
|
pci_cleanup(pacc);
|
|
|
|
char * vendor = "unknown vendor";
|
|
|
|
switch(dev -> vendor_id){
|
|
case 4098:
|
|
vendor = "AMD";
|
|
break;
|
|
case 4318:
|
|
vendor = "NVIDIA";
|
|
break;
|
|
case 32902:
|
|
vendor = "Intel";
|
|
break;
|
|
}
|
|
|
|
snprintf(gpu, BUF_SIZE, "%s %s", vendor, model);
|
|
|
|
return gpu;
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *get_kernel(char *kern_name){
|
|
|
|
kern_name = malloc(BUF_SIZE);
|
|
|
|
struct utsname u_info;
|
|
uname(&u_info);
|
|
|
|
snprintf(kern_name, BUF_SIZE, "\x1b[36mKERN\x1b[0m -> Linux %s", u_info.release);
|
|
|
|
return kern_name;
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *get_uptime(char *uptime){
|
|
|
|
uptime = malloc(BUF_SIZE);
|
|
unsigned int sec;
|
|
short hr, min;
|
|
struct sysinfo sys_info;
|
|
|
|
sysinfo(&sys_info);
|
|
|
|
sec = sys_info.uptime;
|
|
hr = (sec/60/60%24);
|
|
min = (sec/60%60);
|
|
|
|
snprintf(uptime, BUF_SIZE, "\x1b[36mUPT\x1b[0m -> %hd h, %hd min", hr, min);
|
|
return uptime;
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *get_packages(char *package_count){
|
|
|
|
int pkg_count = 0;
|
|
package_count = malloc(BUF_SIZE);
|
|
|
|
|
|
if( strchr(ARCH_BASED, sys) )
|
|
pkg_count = count_files(opendir("/var/lib/pacman/local"));
|
|
|
|
else if( strchr(DEBIAN_BASED, sys) )
|
|
pkg_count = count_files(opendir("/usr/bin")) + count_files(opendir("/sbin")); // still not sure where to look
|
|
|
|
|
|
|
|
else{
|
|
printf("\n\n\aUnable to find package list\n\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
snprintf(package_count, BUF_SIZE, "\x1b[36mPKGS\x1b[0m -> %d", pkg_count);
|
|
|
|
|
|
return package_count;
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *get_RAM(char *ram_info){
|
|
|
|
int bar_percent;
|
|
|
|
float total,
|
|
free_mem,
|
|
used,
|
|
real_percent;
|
|
|
|
ram_info = malloc(BUF_SIZE * 3);
|
|
|
|
char *line = malloc(BUF_SIZE * 3),
|
|
bar[] = "[----------]";
|
|
|
|
FILE *RAM = fopen("/proc/meminfo", "rt");
|
|
|
|
|
|
// Get total amount of RAM
|
|
fgets(line, BUF_SIZE * 3, RAM);
|
|
truncate_spaces(line);
|
|
sscanf(line, " MemTotal: %f", &total);
|
|
|
|
// throw away second line of file
|
|
fgets(line, BUF_SIZE * 3, RAM);
|
|
|
|
// Get free memory
|
|
fgets(line, BUF_SIZE * 3, RAM);
|
|
truncate_spaces(line);
|
|
sscanf(line, " MemAvailable: %f", &free_mem);
|
|
|
|
fclose(RAM);
|
|
|
|
|
|
used = total - free_mem;
|
|
real_percent = (used / total) * 100;
|
|
bar_percent = (real_percent / 10 + 0.25);
|
|
|
|
|
|
for(int i = 1; i <= bar_percent; i++){
|
|
bar[i] = '*';
|
|
}
|
|
|
|
|
|
snprintf(ram_info, BUF_SIZE * 3, "\x1b[36mRAM\x1b[0m -> %.2f GB of %.2f GB, %s -> %.2f %%", used / 1000000,
|
|
total / 1000000,
|
|
bar, real_percent);
|
|
|
|
free(line);
|
|
return ram_info;
|
|
}
|
|
|
|
|
|
|
|
void concatenate_print(char *os, char *cpu_name, char *gpu){
|
|
|
|
|
|
char *uptime = NULL,
|
|
*kern_name = NULL,
|
|
*ram_info = NULL,
|
|
*package_count = NULL;
|
|
|
|
|
|
strcat( (logo + logo_number)->logo[0], os);
|
|
strcat( (logo + logo_number)->logo[1], get_kernel(kern_name));
|
|
strcat( (logo + logo_number)->logo[2], get_uptime(uptime));
|
|
strcat( (logo + logo_number)->logo[3], get_packages(package_count));
|
|
strcat( (logo + logo_number)->logo[4], cpu_name);
|
|
strcat( (logo + logo_number)->logo[5], gpu);
|
|
strcat( (logo + logo_number)->logo[6], get_RAM(ram_info));
|
|
|
|
printf("\n");
|
|
for(int i = 0; i < COLS ; i++)
|
|
printf("%s\n", (logo + logo_number)->logo[i]);
|
|
|
|
|
|
free(uptime);
|
|
free(ram_info);
|
|
free(package_count);
|
|
free(kern_name);
|
|
}
|