fastfetch-cli/fastfetch
1
0
Fork 0
mirror of https://github.com/fastfetch-cli/fastfetch.git synced 2026-10-28 15:53:51 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

renamed calculate to detect

Browse Source
This commit is contained in:
Linus Dierheimer
2021-04-28 19:53:30 +02:00
parent b83499d1ec
commit 01ada03c5c
19 changed files with 369 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/common/calculateOS.c
-98
View File
@@ -1,98 +0,0 @@
#include "fastfetch.h"
#include <pthread.h>
const FFOSResult* ffCalculateOS(FFinstance* instance)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFOSResult result;
static bool init = false;
pthread_mutex_lock(&mutex);
if(init)
{
pthread_mutex_unlock(&mutex);
return &result;
}
init = true;
FILE* osRelease = fopen("/etc/os-release", "r");
if(osRelease == NULL)
osRelease = fopen("/usr/lib/os-release", "r");
ffStrbufInitA(&result.error, 64);
if(osRelease == NULL)
{
ffStrbufAppendS(&result.error, "couldn't read /etc/os-release nor /usr/lib/os-release");
return &result;
}
ffStrbufInitA(&result.systemName, 256);
ffStrbufInitA(&result.name, 256);
ffStrbufInitA(&result.prettyName, 256);
ffStrbufInitA(&result.id, 256);
ffStrbufInitA(&result.idLike, 256);
ffStrbufInitA(&result.variant, 256);
ffStrbufInitA(&result.variantID, 256);
ffStrbufInitA(&result.version, 256);
ffStrbufInitA(&result.versionID, 256);
ffStrbufInitA(&result.codename, 256);
ffStrbufInitA(&result.buildID, 256);
ffStrbufInitA(&result.architecture, 256);
ffStrbufInitA(&result.error, 256);
ffStrbufSetS(&result.systemName, instance->state.utsname.sysname);
ffStrbufSetS(&result.architecture, instance->state.utsname.machine);
char* line = NULL;
size_t len = 0;
// Documentation of the fields:
// https://www.freedesktop.org/software/systemd/man/os-release.html
while (getline(&line, &len, osRelease) != -1)
{
sscanf(line, "NAME=%[^\n]", result.name.chars);
sscanf(line, "NAME=\"%[^\"]+", result.name.chars);
sscanf(line, "PRETTY_NAME=%[^\n]", result.prettyName.chars);
sscanf(line, "PRETTY_NAME=\"%[^\"]+", result.prettyName.chars);
sscanf(line, "ID=%[^\n]", result.id.chars);
sscanf(line, "ID=\"%[^\"]+", result.id.chars);
sscanf(line, "ID_LIKE=%[^\n]", result.idLike.chars);
sscanf(line, "ID_LIKE=\"%[^\"]+", result.idLike.chars);
sscanf(line, "VARIANT=%[^\n]", result.variant.chars);
sscanf(line, "VARIANT=\"%[^\"]+", result.variant.chars);
sscanf(line, "VARIANT_ID=%[^\n]", result.variantID.chars);
sscanf(line, "VARIANT_ID=\"%[^\"]+", result.variantID.chars);
sscanf(line, "VERSION=%[^\n]", result.version.chars);
sscanf(line, "VERSION=\"%[^\"]+", result.version.chars);
sscanf(line, "VERSION_ID=%[^\n]", result.versionID.chars);
sscanf(line, "VERSION_ID=\"%[^\"]+", result.versionID.chars);
sscanf(line, "VERSION_CODENAME=%[^\n]", result.codename.chars);
sscanf(line, "VERSION_CODENAME=\"%[^\"]+", result.codename.chars);
sscanf(line, "BUILD_ID=%[^\n]", result.buildID.chars);
sscanf(line, "BUILD_ID=\"%[^\"]+", result.buildID.chars);
}
ffStrbufRecalculateLength(&result.systemName);
ffStrbufRecalculateLength(&result.name);
ffStrbufRecalculateLength(&result.prettyName);
ffStrbufRecalculateLength(&result.id);
ffStrbufRecalculateLength(&result.idLike);
ffStrbufRecalculateLength(&result.variant);
ffStrbufRecalculateLength(&result.variantID);
ffStrbufRecalculateLength(&result.version);
ffStrbufRecalculateLength(&result.versionID);
ffStrbufRecalculateLength(&result.codename);
ffStrbufRecalculateLength(&result.buildID);
ffStrbufRecalculateLength(&result.architecture);
ffStrbufRecalculateLength(&result.error);
if(line != NULL)
free(line);
fclose(osRelease);
pthread_mutex_unlock(&mutex);
return &result;
}
src/common/calculateTerminal.c
-79
View File
@@ -1,79 +0,0 @@
#include "fastfetch.h"
#include <string.h>
#include <unistd.h>
#include <pthread.h>
static void getTerminalName(FFinstance* instance, const char* pid, FFTerminalResult* result)
{
char statFile[234];
sprintf(statFile, "/proc/%s/stat", pid);
FILE* stat = fopen(statFile, "r");
if(stat == NULL)
{
ffStrbufSetF(&result->error, "fopen(\"%s\", \"r\") == NULL", statFile);
return;
}
char name[256];
char ppid[256];
if(fscanf(stat, "%*s (%[^)])%*s%s", name, ppid) != 2)
{
ffStrbufSetS(&result->error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2");
return;
}
fclose(stat);
if (
strcasecmp(name, "bash") == 0 ||
strcasecmp(name, "sh") == 0 ||
strcasecmp(name, "zsh") == 0 ||
strcasecmp(name, "ksh") == 0 ||
strcasecmp(name, "fish") == 0 ||
strcasecmp(name, "sudo") == 0 ||
strcasecmp(name, "su") == 0 ||
strcasecmp(name, "doas") == 0 ||
strcasecmp(name, "strace") == 0 )
{
getTerminalName(instance, ppid, result);
return;
}
char cmdlineFile[234];
sprintf(cmdlineFile, "/proc/%s/cmdline", pid);
ffGetFileContent(cmdlineFile, &result->exeName);
ffStrbufSubstrBeforeFirstC(&result->exeName, '\0');
ffStrbufSubstrAfterLastC(&result->exeName, '/');
ffStrbufSetS(&result->processName, name);
}
const FFTerminalResult* ffCalculateTerminal(FFinstance* instance)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFTerminalResult result;
static bool init = false;
pthread_mutex_lock(&mutex);
if(init)
{
pthread_mutex_unlock(&mutex);
return &result;
}
init = true;
ffStrbufInit(&result.exeName);
ffStrbufInit(&result.processName);
ffStrbufInit(&result.error);
char ppid[256];
sprintf(ppid, "%i", getppid());
getTerminalName(instance, ppid, &result);
pthread_mutex_unlock(&mutex);
return &result;
}
src/common/calculateWM.c
-128
View File
@@ -1,128 +0,0 @@
#include "fastfetch.h"
#include <string.h>
#include <dirent.h>
#include <pthread.h>
const char* ffGetSessionDesktop()
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static char* sessionDesktop = NULL;
pthread_mutex_lock(&mutex);
if(sessionDesktop == NULL)
sessionDesktop = getenv("XDG_CURRENT_DESKTOP");
if(sessionDesktop == NULL)
sessionDesktop = getenv("XDG_SESSION_DESKTOP");
pthread_mutex_unlock(&mutex);
return sessionDesktop;
}
static void getFromProcDir(FFWMResult* result)
{
DIR* proc = opendir("/proc/");
if(proc == NULL)
return;
struct dirent* dirent;
while((dirent = readdir(proc)) != NULL)
{
if(dirent->d_type != DT_DIR)
continue;
char path[20];
sprintf(path, "/proc/%.8s/comm", dirent->d_name);
ffGetFileContent(path, &result->processName);
if(ffStrbufIgnCaseCompS(&result->processName, "kwin_wayland") == 0)
{
ffStrbufSetS(&result->prettyName, "KWin");
ffStrbufSetS(&result->protocolName, "Wayland");
}
else if(ffStrbufIgnCaseCompS(&result->processName, "kwin_x11") == 0)
{
ffStrbufSetS(&result->prettyName, "KWin");
ffStrbufSetS(&result->protocolName, "X11");
}
else if(ffStrbufIgnCaseCompS(&result->processName, "openbox") == 0)
ffStrbufSetS(&result->prettyName, "Openbox");
else if(ffStrbufIgnCaseCompS(&result->processName, "cinnamon") == 0)
ffStrbufSetS(&result->prettyName, "Muffin");
else if(ffStrbufIgnCaseCompS(&result->processName, "xfwm4") == 0)
ffStrbufSetS(&result->prettyName, "XFWM");
else if(ffStrbufIgnCaseCompS(&result->processName, "wayfire") == 0)
ffStrbufSetS(&result->prettyName, "Wayfire");
if(result->prettyName.length > 0)
break;
}
closedir(proc);
}
static void getSessionType(FFstrbuf* sessionType)
{
const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
if (xdgSessionType == NULL)
return;
else if(strcasecmp(xdgSessionType, "wayland") == 0)
ffStrbufSetS(sessionType, "Wayland");
else if(strcasecmp(xdgSessionType, "x11") == 0)
ffStrbufSetS(sessionType, "X11");
else if(strcasecmp(xdgSessionType, "tty") == 0)
ffStrbufSetS(sessionType, "TTY");
else if(strcasecmp(xdgSessionType, "mir") == 0)
ffStrbufSetS(sessionType, "Mir");
else
ffStrbufSetS(sessionType, xdgSessionType);
}
const FFWMResult* ffCalculateWM(FFinstance* instance)
{
UNUSED(instance);
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFWMResult result;
static bool init = false;
pthread_mutex_lock(&mutex);
if(init)
{
pthread_mutex_unlock(&mutex);
return &result;
}
init = true;
ffStrbufInit(&result.processName);
ffStrbufInit(&result.prettyName);
ffStrbufInit(&result.protocolName);
ffStrbufInit(&result.error);
getFromProcDir(&result);
if(result.prettyName.length == 0)
{
const char* sessionDesktop = ffGetSessionDesktop();
ffStrbufSetS(&result.processName, sessionDesktop);
ffStrbufSetS(&result.prettyName, sessionDesktop);
}
if(result.protocolName.length == 0)
getSessionType(&result.protocolName);
if(result.prettyName.length == 0 && result.protocolName.length == 0)
{
ffStrbufClear(&result.processName);
ffStrbufSetS(&result.error, "No WM or WM protocol type found");
}
pthread_mutex_unlock(&mutex);
return &result;
}
src/common/calculateGTK.c → src/common/detectGTK.c
+10 -10
View File
@@ -157,7 +157,7 @@ static void parseGTKConfigFile(FFstrbuf* fileName, FFGTKResult* result)
ffStrbufRecalculateLength(&result->font);
}
static void calculateGTKFromConfigDir(const char* configDir, const char* version, FFGTKResult* result)
static void detectGTKFromConfigDir(const char* configDir, const char* version, FFGTKResult* result)
{
// <configdir>/gtk-<version>.0/settings.ini
FFstrbuf file1;
@@ -206,7 +206,7 @@ static void calculateGTKFromConfigDir(const char* configDir, const char* version
ffStrbufDestroy(&file4);
}
static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult* result)
static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* result)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -239,18 +239,18 @@ static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult*
if(xdgIsDifferent)
{
// $XDG_CONFIG_HOME
calculateGTKFromConfigDir(xdgConfigDir.chars, version, result);
detectGTKFromConfigDir(xdgConfigDir.chars, version, result);
if(allPropertiesSet(result))
return;
}
// /home/<user>/.config
calculateGTKFromConfigDir(configDir.chars, version, result);
detectGTKFromConfigDir(configDir.chars, version, result);
if(allPropertiesSet(result))
return;
// /home/<user>
calculateGTKFromConfigDir(instance->state.passwd->pw_dir, version, result);
detectGTKFromConfigDir(instance->state.passwd->pw_dir, version, result);
if(allPropertiesSet(result))
return;
@@ -259,7 +259,7 @@ static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult*
return;
// /etc
calculateGTKFromConfigDir("/etc/", version, result);
detectGTKFromConfigDir("/etc/", version, result);
}
#define FF_CALCULATE_GTK_IMPL(version) \
@@ -275,21 +275,21 @@ static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult*
ffStrbufInit(&result.theme); \
ffStrbufInit(&result.icons); \
ffStrbufInit(&result.font); \
calculateGTK(instance, #version, &result); \
detectGTK(instance, #version, &result); \
pthread_mutex_unlock(&mutex); \
return &result;
const FFGTKResult* ffCalculateGTK2(FFinstance* instance)
const FFGTKResult* ffDetectGTK2(FFinstance* instance)
{
FF_CALCULATE_GTK_IMPL(2)
}
const FFGTKResult* ffCalculateGTK3(FFinstance* instance)
const FFGTKResult* ffDetectGTK3(FFinstance* instance)
{
FF_CALCULATE_GTK_IMPL(3)
}
const FFGTKResult* ffCalculateGTK4(FFinstance* instance)
const FFGTKResult* ffDetectGTK4(FFinstance* instance)
{
FF_CALCULATE_GTK_IMPL(4)
}
src/common/calculatePlasma.c → src/common/detectPlasma.c
+1 -1
View File
@@ -11,7 +11,7 @@ typedef enum PlasmaCategory
PLASMA_CATEGORY_OTHER
} PlasmaCategory;
const FFPlasmaResult* ffCalculatePlasma(FFinstance* instance)
const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFPlasmaResult result;
src/common/logo.c
+1 -1
View File
@@ -303,7 +303,7 @@ void ffLoadLogo(FFinstance* instance)
ffStrbufDestroy(&content);
}
const FFOSResult* result = ffCalculateOS(instance);
const FFOSResult* result = ffDetectOS(instance);
if(result->id.length > 0)
{
src/common/threading.c
+18 -18
View File
@@ -2,66 +2,66 @@
#include <pthread.h>
static inline void* calculatePlasmaThreadMain(void* instance)
static inline void* detectPlasmaThreadMain(void* instance)
{
ffCalculatePlasma((FFinstance*)instance);
ffDetectPlasma((FFinstance*)instance);
return NULL;
}
static inline void* calculateGTK2ThreadMain(void* instance)
static inline void* detectGTK2ThreadMain(void* instance)
{
ffCalculateGTK2((FFinstance*)instance);
ffDetectGTK2((FFinstance*)instance);
return NULL;
}
static inline void* calculateGTK3ThreadMain(void* instance)
static inline void* detectGTK3ThreadMain(void* instance)
{
ffCalculateGTK3((FFinstance*)instance);
ffDetectGTK3((FFinstance*)instance);
return NULL;
}
static inline void* calculateGTK4ThreadMain(void* instance)
static inline void* detectGTK4ThreadMain(void* instance)
{
ffCalculateGTK4((FFinstance*)instance);
ffDetectGTK4((FFinstance*)instance);
return NULL;
}
static inline void* calculateWMThreadMain(void* instance)
static inline void* detectWMThreadMain(void* instance)
{
ffCalculateWM((FFinstance*)instance);
ffDetectWM((FFinstance*)instance);
return NULL;
}
static inline void* calculateTerminalThreadMain(void* instance)
static inline void* detectTerminalThreadMain(void* instance)
{
ffCalculateTerminal((FFinstance*)instance);
ffDetectTerminal((FFinstance*)instance);
return NULL;
}
static inline void* startThreadsThreadMain(void* instance)
{
pthread_t wmThread;
pthread_create(&wmThread, NULL, calculateWMThreadMain, instance);
pthread_create(&wmThread, NULL, detectWMThreadMain, instance);
pthread_detach(wmThread);
pthread_t gtk2Thread;
pthread_create(&gtk2Thread, NULL, calculateGTK2ThreadMain, instance);
pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
pthread_detach(gtk2Thread);
pthread_t gtk3Thread;
pthread_create(&gtk3Thread, NULL, calculateGTK3ThreadMain, instance);
pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
pthread_detach(gtk3Thread);
pthread_t gtk4Thread;
pthread_create(&gtk4Thread, NULL, calculateGTK4ThreadMain, instance);
pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
pthread_detach(gtk4Thread);
pthread_t terminalThread;
pthread_create(&terminalThread, NULL, calculateTerminalThreadMain, instance);
pthread_create(&terminalThread, NULL, detectTerminalThreadMain, instance);
pthread_detach(terminalThread);
pthread_t plasmaThread;
pthread_create(&plasmaThread, NULL, calculatePlasmaThreadMain, instance);
pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
pthread_detach(plasmaThread);
return NULL;
src/fastfetch.c
+1 -1
View File
@@ -56,7 +56,7 @@ static inline void printHelp()
" -r <?value> --recache <?value>: generate new cached values\n"
" --nocache <?value>: dont use cached values, but also dont overwrite existing ones\n"
" --print-remaining-logo <?value>: print the remaining logo, if it is higher than the number of lines shown\n"
" --multithreading <?value>: use multiple threads to calculate values\n"
" --multithreading <?value>: use multiple threads to detect values\n"
" --load-config <file>: load a config file (+)\n"
"\n"
"Logo options:\n"
src/fastfetch.h
+16 -16
View File
@@ -244,28 +244,28 @@ void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3
void ffGetFont(const char* font, FFstrbuf* name, double* size);
void ffGetFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size);
//common/calculateOS.c
const FFOSResult* ffCalculateOS(FFinstance* instance);
//common/detectPlasma.c
const FFPlasmaResult* ffDetectPlasma(FFinstance* instance);
//common/calculatePlasma.c
const FFPlasmaResult* ffCalculatePlasma(FFinstance* instance);
//common/calculateGTK.c
const FFGTKResult* ffCalculateGTK2(FFinstance* instance);
const FFGTKResult* ffCalculateGTK4(FFinstance* instance);
const FFGTKResult* ffCalculateGTK3(FFinstance* instance);
//common/calculateWM.c
const FFWMResult* ffCalculateWM(FFinstance* instance);
//common/calculateTerminal.c
const char* ffGetSessionDesktop();
const FFTerminalResult* ffCalculateTerminal(FFinstance* instance);
//common/detectGTK.c
const FFGTKResult* ffDetectGTK2(FFinstance* instance);
const FFGTKResult* ffDetectGTK4(FFinstance* instance);
const FFGTKResult* ffDetectGTK3(FFinstance* instance);
/********************/
/* Module functions */
/********************/
//Common
const char* ffGetSessionDesktop();
const FFOSResult* ffDetectOS(FFinstance* instance);
const FFTerminalResult* ffDetectTerminal(FFinstance* instance);
const FFWMResult* ffDetectWM(FFinstance* instance);
//Printing
void ffPrintCustom(FFinstance* instance, const char* key, const char* value);
void ffPrintBreak(FFinstance* instance);
void ffPrintTitle(FFinstance* instance);
src/modules/de.c
+1 -1
View File
@@ -25,7 +25,7 @@ void ffPrintDesktopEnvironment(FFinstance* instance)
return;
}
const FFWMResult* wm = ffCalculateWM(instance);
const FFWMResult* wm = ffDetectWM(instance);
// test if we are running only a WM
if(
src/modules/font.c
+4 -4
View File
@@ -5,10 +5,10 @@
void ffPrintFont(FFinstance* instance)
{
const FFstrbuf* plasma = &ffCalculatePlasma(instance)->font;
const FFstrbuf* gtk2 = &ffCalculateGTK2(instance)->font;
const FFstrbuf* gtk3 = &ffCalculateGTK3(instance)->font;
const FFstrbuf* gtk4 = &ffCalculateGTK4(instance)->font;
const FFstrbuf* plasma = &ffDetectPlasma(instance)->font;
const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->font;
const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->font;
const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->font;
if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
{
src/modules/icons.c
+4 -4
View File
@@ -5,10 +5,10 @@
void ffPrintIcons(FFinstance* instance)
{
const FFstrbuf* plasma = &ffCalculatePlasma(instance)->icons;
const FFstrbuf* gtk2 = &ffCalculateGTK2(instance)->icons;
const FFstrbuf* gtk3 = &ffCalculateGTK3(instance)->icons;
const FFstrbuf* gtk4 = &ffCalculateGTK4(instance)->icons;
const FFstrbuf* plasma = &ffDetectPlasma(instance)->icons;
const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->icons;
const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->icons;
const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->icons;
if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
src/modules/os.c
+98 -1
View File
@@ -1,14 +1,111 @@
#include "fastfetch.h"
#include <pthread.h>
#define FF_OS_MODULE_NAME "OS"
#define FF_OS_NUM_FORMAT_ARGS 12
const FFOSResult* ffDetectOS(FFinstance* instance)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFOSResult result;
static bool init = false;
pthread_mutex_lock(&mutex);
if(init)
{
pthread_mutex_unlock(&mutex);
return &result;
}
init = true;
FILE* osRelease = fopen("/etc/os-release", "r");
if(osRelease == NULL)
osRelease = fopen("/usr/lib/os-release", "r");
ffStrbufInitA(&result.error, 64);
if(osRelease == NULL)
{
ffStrbufAppendS(&result.error, "couldn't read /etc/os-release nor /usr/lib/os-release");
return &result;
}
ffStrbufInitA(&result.systemName, 256);
ffStrbufInitA(&result.name, 256);
ffStrbufInitA(&result.prettyName, 256);
ffStrbufInitA(&result.id, 256);
ffStrbufInitA(&result.idLike, 256);
ffStrbufInitA(&result.variant, 256);
ffStrbufInitA(&result.variantID, 256);
ffStrbufInitA(&result.version, 256);
ffStrbufInitA(&result.versionID, 256);
ffStrbufInitA(&result.codename, 256);
ffStrbufInitA(&result.buildID, 256);
ffStrbufInitA(&result.architecture, 256);
ffStrbufInitA(&result.error, 256);
ffStrbufSetS(&result.systemName, instance->state.utsname.sysname);
ffStrbufSetS(&result.architecture, instance->state.utsname.machine);
char* line = NULL;
size_t len = 0;
// Documentation of the fields:
// https://www.freedesktop.org/software/systemd/man/os-release.html
while (getline(&line, &len, osRelease) != -1)
{
sscanf(line, "NAME=%[^\n]", result.name.chars);
sscanf(line, "NAME=\"%[^\"]+", result.name.chars);
sscanf(line, "PRETTY_NAME=%[^\n]", result.prettyName.chars);
sscanf(line, "PRETTY_NAME=\"%[^\"]+", result.prettyName.chars);
sscanf(line, "ID=%[^\n]", result.id.chars);
sscanf(line, "ID=\"%[^\"]+", result.id.chars);
sscanf(line, "ID_LIKE=%[^\n]", result.idLike.chars);
sscanf(line, "ID_LIKE=\"%[^\"]+", result.idLike.chars);
sscanf(line, "VARIANT=%[^\n]", result.variant.chars);
sscanf(line, "VARIANT=\"%[^\"]+", result.variant.chars);
sscanf(line, "VARIANT_ID=%[^\n]", result.variantID.chars);
sscanf(line, "VARIANT_ID=\"%[^\"]+", result.variantID.chars);
sscanf(line, "VERSION=%[^\n]", result.version.chars);
sscanf(line, "VERSION=\"%[^\"]+", result.version.chars);
sscanf(line, "VERSION_ID=%[^\n]", result.versionID.chars);
sscanf(line, "VERSION_ID=\"%[^\"]+", result.versionID.chars);
sscanf(line, "VERSION_CODENAME=%[^\n]", result.codename.chars);
sscanf(line, "VERSION_CODENAME=\"%[^\"]+", result.codename.chars);
sscanf(line, "BUILD_ID=%[^\n]", result.buildID.chars);
sscanf(line, "BUILD_ID=\"%[^\"]+", result.buildID.chars);
}
ffStrbufRecalculateLength(&result.systemName);
ffStrbufRecalculateLength(&result.name);
ffStrbufRecalculateLength(&result.prettyName);
ffStrbufRecalculateLength(&result.id);
ffStrbufRecalculateLength(&result.idLike);
ffStrbufRecalculateLength(&result.variant);
ffStrbufRecalculateLength(&result.variantID);
ffStrbufRecalculateLength(&result.version);
ffStrbufRecalculateLength(&result.versionID);
ffStrbufRecalculateLength(&result.codename);
ffStrbufRecalculateLength(&result.buildID);
ffStrbufRecalculateLength(&result.architecture);
ffStrbufRecalculateLength(&result.error);
if(line != NULL)
free(line);
fclose(osRelease);
pthread_mutex_unlock(&mutex);
return &result;
}
void ffPrintOS(FFinstance* instance)
{
if(ffPrintFromCache(instance, FF_OS_MODULE_NAME, &instance->config.osKey, &instance->config.osFormat, FF_OS_NUM_FORMAT_ARGS))
return;
const FFOSResult* result = ffCalculateOS(instance);
const FFOSResult* result = ffDetectOS(instance);
if(result->error.length > 0)
{
src/modules/terminal.c
+79 -1
View File
@@ -1,11 +1,89 @@
#include "fastfetch.h"
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#define FF_TERMINAL_MODULE_NAME "Terminal"
#define FF_TERMINAL_NUM_FORMAT_ARGS 3
static void getTerminalName(FFinstance* instance, const char* pid, FFTerminalResult* result)
{
char statFile[234];
sprintf(statFile, "/proc/%s/stat", pid);
FILE* stat = fopen(statFile, "r");
if(stat == NULL)
{
ffStrbufSetF(&result->error, "fopen(\"%s\", \"r\") == NULL", statFile);
return;
}
char name[256];
char ppid[256];
if(fscanf(stat, "%*s (%[^)])%*s%s", name, ppid) != 2)
{
ffStrbufSetS(&result->error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2");
return;
}
fclose(stat);
if (
strcasecmp(name, "bash") == 0 ||
strcasecmp(name, "sh") == 0 ||
strcasecmp(name, "zsh") == 0 ||
strcasecmp(name, "ksh") == 0 ||
strcasecmp(name, "fish") == 0 ||
strcasecmp(name, "sudo") == 0 ||
strcasecmp(name, "su") == 0 ||
strcasecmp(name, "doas") == 0 ||
strcasecmp(name, "strace") == 0 )
{
getTerminalName(instance, ppid, result);
return;
}
char cmdlineFile[234];
sprintf(cmdlineFile, "/proc/%s/cmdline", pid);
ffGetFileContent(cmdlineFile, &result->exeName);
ffStrbufSubstrBeforeFirstC(&result->exeName, '\0');
ffStrbufSubstrAfterLastC(&result->exeName, '/');
ffStrbufSetS(&result->processName, name);
}
const FFTerminalResult* ffDetectTerminal(FFinstance* instance)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFTerminalResult result;
static bool init = false;
pthread_mutex_lock(&mutex);
if(init)
{
pthread_mutex_unlock(&mutex);
return &result;
}
init = true;
ffStrbufInit(&result.exeName);
ffStrbufInit(&result.processName);
ffStrbufInit(&result.error);
char ppid[256];
sprintf(ppid, "%i", getppid());
getTerminalName(instance, ppid, &result);
pthread_mutex_unlock(&mutex);
return &result;
}
void ffPrintTerminal(FFinstance* instance)
{
const FFTerminalResult* result = ffCalculateTerminal(instance);
const FFTerminalResult* result = ffDetectTerminal(instance);
if(result->error.length > 0)
{
src/modules/terminalfont.c
+1 -1
View File
@@ -81,7 +81,7 @@ static void printTTY(FFinstance* instance)
void ffPrintTerminalFont(FFinstance* instance)
{
const FFTerminalResult* result = ffCalculateTerminal(instance);
const FFTerminalResult* result = ffDetectTerminal(instance);
if(result->exeName.length == 0)
{
src/modules/theme.c
+4 -4
View File
@@ -5,10 +5,10 @@
void ffPrintTheme(FFinstance* instance)
{
const FFPlasmaResult* plasma = ffCalculatePlasma(instance);
const FFstrbuf* gtk2 = &ffCalculateGTK2(instance)->theme;
const FFstrbuf* gtk3 = &ffCalculateGTK3(instance)->theme;
const FFstrbuf* gtk4 = &ffCalculateGTK4(instance)->theme;
const FFPlasmaResult* plasma = ffDetectPlasma(instance);
const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->theme;
const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->theme;
const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->theme;
if(plasma->widgetStyle.length == 0 && plasma->colorScheme.length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
{
src/modules/wm.c
+128 -1
View File
@@ -1,11 +1,138 @@
#include "fastfetch.h"
#include <string.h>
#include <dirent.h>
#include <pthread.h>
#define FF_WM_MODULE_NAME "WM"
#define FF_WM_NUM_FORMAT_ARGS 3
const char* ffGetSessionDesktop()
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static char* sessionDesktop = NULL;
pthread_mutex_lock(&mutex);
if(sessionDesktop == NULL)
sessionDesktop = getenv("XDG_CURRENT_DESKTOP");
if(sessionDesktop == NULL)
sessionDesktop = getenv("XDG_SESSION_DESKTOP");
pthread_mutex_unlock(&mutex);
return sessionDesktop;
}
static void getFromProcDir(FFWMResult* result)
{
DIR* proc = opendir("/proc/");
if(proc == NULL)
return;
struct dirent* dirent;
while((dirent = readdir(proc)) != NULL)
{
if(dirent->d_type != DT_DIR)
continue;
char path[20];
sprintf(path, "/proc/%.8s/comm", dirent->d_name);
ffGetFileContent(path, &result->processName);
if(ffStrbufIgnCaseCompS(&result->processName, "kwin_wayland") == 0)
{
ffStrbufSetS(&result->prettyName, "KWin");
ffStrbufSetS(&result->protocolName, "Wayland");
}
else if(ffStrbufIgnCaseCompS(&result->processName, "kwin_x11") == 0)
{
ffStrbufSetS(&result->prettyName, "KWin");
ffStrbufSetS(&result->protocolName, "X11");
}
else if(ffStrbufIgnCaseCompS(&result->processName, "openbox") == 0)
ffStrbufSetS(&result->prettyName, "Openbox");
else if(ffStrbufIgnCaseCompS(&result->processName, "cinnamon") == 0)
ffStrbufSetS(&result->prettyName, "Muffin");
else if(ffStrbufIgnCaseCompS(&result->processName, "xfwm4") == 0)
ffStrbufSetS(&result->prettyName, "XFWM");
else if(ffStrbufIgnCaseCompS(&result->processName, "wayfire") == 0)
ffStrbufSetS(&result->prettyName, "Wayfire");
if(result->prettyName.length > 0)
break;
}
closedir(proc);
}
static void getSessionType(FFstrbuf* sessionType)
{
const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
if (xdgSessionType == NULL)
return;
else if(strcasecmp(xdgSessionType, "wayland") == 0)
ffStrbufSetS(sessionType, "Wayland");
else if(strcasecmp(xdgSessionType, "x11") == 0)
ffStrbufSetS(sessionType, "X11");
else if(strcasecmp(xdgSessionType, "tty") == 0)
ffStrbufSetS(sessionType, "TTY");
else if(strcasecmp(xdgSessionType, "mir") == 0)
ffStrbufSetS(sessionType, "Mir");
else
ffStrbufSetS(sessionType, xdgSessionType);
}
const FFWMResult* ffDetectWM(FFinstance* instance)
{
UNUSED(instance);
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FFWMResult result;
static bool init = false;
pthread_mutex_lock(&mutex);
if(init)
{
pthread_mutex_unlock(&mutex);
return &result;
}
init = true;
ffStrbufInit(&result.processName);
ffStrbufInit(&result.prettyName);
ffStrbufInit(&result.protocolName);
ffStrbufInit(&result.error);
getFromProcDir(&result);
if(result.prettyName.length == 0)
{
const char* sessionDesktop = ffGetSessionDesktop();
ffStrbufSetS(&result.processName, sessionDesktop);
ffStrbufSetS(&result.prettyName, sessionDesktop);
}
if(result.protocolName.length == 0)
getSessionType(&result.protocolName);
if(result.prettyName.length == 0 && result.protocolName.length == 0)
{
ffStrbufClear(&result.processName);
ffStrbufSetS(&result.error, "No WM or WM protocol type found");
}
pthread_mutex_unlock(&mutex);
return &result;
}
void ffPrintWM(FFinstance* instance)
{
const FFWMResult* result = ffCalculateWM(instance);
const FFWMResult* result = ffDetectWM(instance);
if(result->error.length > 0)
{
src/modules/wmtheme.c
+1 -1
View File
@@ -102,7 +102,7 @@ static void printOpenbox(FFinstance* instance)
void ffPrintWMTheme(FFinstance* instance)
{
const FFWMResult* result = ffCalculateWM(instance);
const FFWMResult* result = ffDetectWM(instance);
if(result->prettyName.length == 0)
{