Merge pull request #545 from fastfetch-cli/dev

CarterLi · web-flow · commit a3f13bdca993 · 2023-08-26T20:31:27.000+08:00
Release v2.0.5
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,13 @@
+# 2.0.5
+
+Bugfixes:
+* Fix segfault when using libxrandr (#544, Display, Linux)
+* Don't print 0px (#544, Cursor)
+
+Features:
+* Add option `--disk-use-available` (#543)
+* Add option `--disk-show-readonly`
+
 # 2.0.4
 
 Bugfixes:
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url
 
 project(fastfetch
-    VERSION 2.0.4
+    VERSION 2.0.5
     LANGUAGES C
     DESCRIPTION "Fast system information tool"
     HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
diff --git a/doc/json_schema.json b/doc/json_schema.json
@@ -884,11 +884,21 @@
                                         "title": "Set if subvolumes should be printed",
                                         "default": false
                                     },
+                                    "showReadOnly": {
+                                        "type": "boolean",
+                                        "title": "Set if read only volumes should be printed",
+                                        "default": false
+                                    },
                                     "showUnknown": {
                                         "type": "boolean",
                                         "title": "Set if unknown (unable to detect sizes) volumes should be printed",
                                         "default": false
                                     },
+                                    "useAvailable": {
+                                        "type": "boolean",
+                                        "title": "Use f_bavail (lpFreeBytesAvailableToCaller for Windows) instead of f_bfree to calculate used bytes",
+                                        "default": false
+                                    },
                                     "key": {
                                         "$ref": "#/$defs/key"
                                     },
diff --git a/src/data/help.txt b/src/data/help.txt
@@ -129,7 +129,9 @@ Module specific options:
     --disk-show-external <?value>:           Set if external volume should be printed. Default is true
     --disk-show-hidden <?value>:             Set if hidden volumes should be printed. Default is false
     --disk-show-subvolumes <?value>:         Set if subvolumes should be printed. Default is false
+    --disk-show-readonly <?value>:           Set if read only volumes should be printed. Default is false
     --disk-show-unknown <?value>:            Set if unknown (unable to detect sizes) volumes should be printed. Default is false
+    --disk-use-available <?value>:           Use f_bavail (lpFreeBytesAvailableToCaller for Windows) instead of f_bfree to calculate used bytes. Default is false
     --bluetooth-show-disconnected: <?value>: Set if disconnected bluetooth devices should be printed. Default is false
     --display-compact-type: <?string>:       Set if all displays should be printed in one line. Default is none
     --display-detect-name: <?value>:         Set if display name should be detected and printed (if supported). Default is false
diff --git a/src/detection/disk/disk.c b/src/detection/disk/disk.c
@@ -7,7 +7,7 @@ static int compareDisks(const void* disk1, const void* disk2)
     return ffStrbufCompAlphabetically(&((const FFDisk*) disk1)->mountpoint, &((const FFDisk*) disk2)->mountpoint);
 }
 
-const char* ffDetectDisks(FFlist* disks)
+const char* ffDetectDisks(FFDiskOptions* options, FFlist* disks)
 {
     const char* error = ffDetectDisksImpl(disks);
 
@@ -22,7 +22,13 @@ const char* ffDetectDisks(FFlist* disks)
     FF_LIST_FOR_EACH(FFDisk, disk, *disks)
     {
         if(disk->bytesTotal == 0)
-            disk->type |= FF_DISK_TYPE_UNKNOWN_BIT;
+            disk->type |= FF_DISK_VOLUME_TYPE_UNKNOWN_BIT;
+        else
+        {
+            disk->bytesUsed = disk->bytesTotal - (
+                options->calcType == FF_DISK_CALC_TYPE_FREE ? disk->bytesFree : disk->bytesAvailable
+            );
+        }
     }
 
     return NULL;
diff --git a/src/detection/disk/disk.h b/src/detection/disk/disk.h
@@ -10,9 +10,11 @@ typedef struct FFDisk
     FFstrbuf mountpoint;
     FFstrbuf filesystem;
     FFstrbuf name;
-    FFDiskType type;
+    FFDiskVolumeType type;
 
     uint64_t bytesUsed;
+    uint64_t bytesFree;
+    uint64_t bytesAvailable;
     uint64_t bytesTotal;
 
     uint32_t filesUsed;
@@ -23,6 +25,6 @@ typedef struct FFDisk
  * Returns a List of FFDisk, sorted alphabetically by mountpoint.
  * If error is not set, disks contains at least one disk.
  */
-const char* ffDetectDisks(FFlist* result /* list of FFDisk */);
+const char* ffDetectDisks(FFDiskOptions* options, FFlist* result /* list of FFDisk */);
 
 #endif
diff --git a/src/detection/disk/disk_apple.m b/src/detection/disk/disk_apple.m
@@ -7,11 +7,11 @@ void detectFsInfo(struct statfs* fs, FFDisk* disk)
 {
     // FreeBSD doesn't support these flags
     if(fs->f_flags & MNT_DONTBROWSE)
-        disk->type = FF_DISK_TYPE_HIDDEN_BIT;
+        disk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;
     else if(fs->f_flags & MNT_REMOVABLE)
-        disk->type = FF_DISK_TYPE_EXTERNAL_BIT;
+        disk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;
     else
-        disk->type = FF_DISK_TYPE_REGULAR_BIT;
+        disk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;
 
     ffStrbufInitS(&disk->name, [NSFileManager.defaultManager displayNameAtPath:@(fs->f_mntonname)].UTF8String);
 }
diff --git a/src/detection/disk/disk_bsd.c b/src/detection/disk/disk_bsd.c
@@ -10,15 +10,15 @@ static void detectFsInfo(struct statfs* fs, FFDisk* disk)
     if(ffStrbufEqualS(&disk->filesystem, "zfs"))
     {
         disk->type = !ffStrStartsWith(fs->f_mntfromname, "zroot/") || ffStrStartsWith(fs->f_mntfromname, "zroot/ROOT/")
-            ? FF_DISK_TYPE_REGULAR_BIT
-            : FF_DISK_TYPE_SUBVOLUME_BIT;
+            ? FF_DISK_VOLUME_TYPE_REGULAR_BIT
+            : FF_DISK_VOLUME_TYPE_SUBVOLUME_BIT;
     }
     else if(!ffStrStartsWith(fs->f_mntfromname, "/dev/"))
-        disk->type = FF_DISK_TYPE_HIDDEN_BIT;
+        disk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;
     else if(!(fs->f_flags & MNT_LOCAL))
-        disk->type = FF_DISK_TYPE_EXTERNAL_BIT;
+        disk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;
     else
-        disk->type = FF_DISK_TYPE_REGULAR_BIT;
+        disk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;
 
     ffStrbufInit(&disk->name);
 }
@@ -45,14 +45,19 @@ const char* ffDetectDisksImpl(FFlist* disks)
         #endif
 
         disk->bytesTotal = fs->f_blocks * fs->f_bsize;
-        disk->bytesUsed = disk->bytesTotal - ((uint64_t)fs->f_bfree * fs->f_bsize);
+        disk->bytesFree = (uint64_t)fs->f_bfree * fs->f_bsize;
+        disk->bytesAvailable = (uint64_t)fs->f_bavail * fs->f_bsize;
+        disk->bytesUsed = 0; // To be filled in ./disk.c
 
         disk->filesTotal = (uint32_t) fs->f_files;
         disk->filesUsed = (uint32_t) (disk->filesTotal - (uint64_t)fs->f_ffree);
 
         ffStrbufInitS(&disk->mountpoint, fs->f_mntonname);
         ffStrbufInitS(&disk->filesystem, fs->f_fstypename);
         detectFsInfo(fs, disk);
+
+        if(fs->f_flags & MNT_RDONLY)
+            disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
     }
 
     return NULL;
diff --git a/src/detection/disk/disk_linux.c b/src/detection/disk/disk_linux.c
@@ -155,11 +155,11 @@ static void detectName(FFDisk* disk, const FFstrbuf* device)
 static void detectType(FF_MAYBE_UNUSED const FFlist* devices, FFDisk* currentDisk, FF_MAYBE_UNUSED const char* options)
 {
     if(ffStrbufEqualS(&currentDisk->mountpoint, "/") || ffStrbufEqualS(&currentDisk->mountpoint, "/storage/emulated"))
-        currentDisk->type = FF_DISK_TYPE_REGULAR_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;
     else if(ffStrbufStartsWithS(&currentDisk->mountpoint, "/mnt/media_rw/"))
-        currentDisk->type = FF_DISK_TYPE_EXTERNAL_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;
     else
-        currentDisk->type = FF_DISK_TYPE_HIDDEN_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;
 }
 
 #else
@@ -191,13 +191,13 @@ static bool isSubvolume(const FFlist* devices)
 static void detectType(const FFlist* devices, FFDisk* currentDisk, const char* options)
 {
     if(isSubvolume(devices))
-        currentDisk->type = FF_DISK_TYPE_SUBVOLUME_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_SUBVOLUME_BIT;
     else if(strstr(options, "nosuid") != NULL || strstr(options, "nodev") != NULL)
-        currentDisk->type = FF_DISK_TYPE_EXTERNAL_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;
     else if(ffStrbufStartsWithS(&currentDisk->mountpoint, "/boot") || ffStrbufStartsWithS(&currentDisk->mountpoint, "/efi"))
-        currentDisk->type = FF_DISK_TYPE_HIDDEN_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;
     else
-        currentDisk->type = FF_DISK_TYPE_REGULAR_BIT;
+        currentDisk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;
 }
 
 #endif
@@ -209,10 +209,15 @@ static void detectStats(FFDisk* disk)
         memset(&fs, 0, sizeof(struct statvfs)); //Set all values to 0, so our values get initialized to 0 too
 
     disk->bytesTotal = fs.f_blocks * fs.f_frsize;
-    disk->bytesUsed = disk->bytesTotal - (fs.f_bfree * fs.f_frsize);
+    disk->bytesFree = fs.f_bfree * fs.f_frsize;
+    disk->bytesAvailable = fs.f_bavail * fs.f_frsize;
+    disk->bytesUsed = 0; // To be filled in ./disk.c
 
     disk->filesTotal = (uint32_t) fs.f_files;
     disk->filesUsed = (uint32_t) (disk->filesTotal - fs.f_ffree);
+
+    if(fs.f_flag & ST_RDONLY)
+        disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
 }
 
 const char* ffDetectDisksImpl(FFlist* disks)
diff --git a/src/detection/disk/disk_windows.c b/src/detection/disk/disk_windows.c
@@ -25,20 +25,25 @@ const char* ffDetectDisksImpl(FFlist* disks)
         FFDisk* disk = ffListAdd(disks);
         ffStrbufInitWS(&disk->mountpoint, mountpoint);
 
-        uint64_t bytesFree;
-        if(!GetDiskFreeSpaceExW(mountpoint, NULL, (PULARGE_INTEGER)&disk->bytesTotal, (PULARGE_INTEGER)&bytesFree))
+        if(!GetDiskFreeSpaceExW(
+            mountpoint,
+            (PULARGE_INTEGER)&disk->bytesAvailable,
+            (PULARGE_INTEGER)&disk->bytesTotal,
+            (PULARGE_INTEGER)&disk->bytesFree
+        ))
         {
             disk->bytesTotal = 0;
-            bytesFree = 0;
+            disk->bytesFree = 0;
+            disk->bytesAvailable = 0;
         }
-        disk->bytesUsed = disk->bytesTotal - bytesFree;
+        disk->bytesUsed = 0; // To be filled in ./disk.c
 
         if(driveType == DRIVE_REMOVABLE || driveType == DRIVE_REMOTE || driveType == DRIVE_CDROM)
-            disk->type = FF_DISK_TYPE_EXTERNAL_BIT;
+            disk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;
         else if(driveType == DRIVE_FIXED)
-            disk->type = FF_DISK_TYPE_REGULAR_BIT;
+            disk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;
         else
-            disk->type = FF_DISK_TYPE_HIDDEN_BIT;
+            disk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;
 
         ffStrbufInit(&disk->filesystem);
         ffStrbufInit(&disk->name);
@@ -47,11 +52,12 @@ const char* ffDetectDisksImpl(FFlist* disks)
         //https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getvolumeinformationa#remarks
         UINT errorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 
+        DWORD diskFlags;
         BOOL result = GetVolumeInformationW(mountpoint,
             diskName, sizeof(diskName) / sizeof(*diskName), //Volume name
             NULL, //Serial number
             NULL, //Max component length
-            NULL, //File system flags
+            &diskFlags, //File system flags
             diskFileSystem, sizeof(diskFileSystem) / sizeof(*diskFileSystem)
         );
         SetErrorMode(errorMode);
@@ -60,6 +66,8 @@ const char* ffDetectDisksImpl(FFlist* disks)
         {
             ffStrbufSetWS(&disk->filesystem, diskFileSystem);
             ffStrbufSetWS(&disk->name, diskName);
+            if(diskFlags & FILE_READ_ONLY_VOLUME)
+                disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
         }
 
         //Unsupported
diff --git a/src/detection/displayserver/linux/xlib.c b/src/detection/displayserver/linux/xlib.c
@@ -116,6 +116,7 @@ typedef struct XrandrData
 {
     FF_LIBRARY_SYMBOL(XInternAtom)
     FF_LIBRARY_SYMBOL(XGetAtomName);
+    FF_LIBRARY_SYMBOL(XFree);
     FF_LIBRARY_SYMBOL(XRRGetScreenInfo)
     FF_LIBRARY_SYMBOL(XRRConfigCurrentConfiguration)
     FF_LIBRARY_SYMBOL(XRRConfigCurrentRate)
@@ -207,16 +208,20 @@ static bool xrandrHandleOutput(XrandrData* data, RROutput output, FFstrbuf* name
     Atom atomEdid = data->ffXInternAtom(data->display, "EDID", true);
     if (atomEdid != None)
     {
-        unsigned long nitems = 0;
+        int actual_format = 0;
+        unsigned long nitems = 0, bytes_after = 0;
+        Atom actual_type = None;
         uint8_t* edidData = NULL;
-        if (data->ffXRRGetOutputProperty(data->display, output, atomEdid, 0, 100, 0, 0, AnyPropertyType, NULL, NULL, &nitems, NULL, &edidData) == Success)
+        if (data->ffXRRGetOutputProperty(data->display, output, atomEdid, 0, 100, false, false, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, &edidData) == Success)
         {
             if (nitems >= 128)
             {
                 ffStrbufClear(name);
                 ffEdidGetName(edidData, name);
             }
         }
+        if (edidData)
+            data->ffXFree(edidData);
     }
     bool res = xrandrHandleCrtc(data, outputInfo->crtc, name, primary);
 
@@ -228,8 +233,9 @@ static bool xrandrHandleOutput(XrandrData* data, RROutput output, FFstrbuf* name
 static bool xrandrHandleMonitor(XrandrData* data, XRRMonitorInfo* monitorInfo)
 {
     bool foundOutput = false;
-
-    FF_STRBUF_AUTO_DESTROY name = ffStrbufCreateS(data->ffXGetAtomName(data->display, monitorInfo->name));
+    char* xname = data->ffXGetAtomName(data->display, monitorInfo->name);
+    FF_STRBUF_AUTO_DESTROY name = ffStrbufCreateS(xname);
+    data->ffXFree(xname);
     for(int i = 0; i < monitorInfo->noutput; i++)
     {
         if(xrandrHandleOutput(data, monitorInfo->outputs[i], &name, monitorInfo->primary))
@@ -341,6 +347,7 @@ void ffdsConnectXrandr(FFDisplayServerResult* result)
 
     FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XInternAtom,);
     FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XGetAtomName,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XFree,);
     FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetScreenInfo,)
     FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRConfigCurrentRate,);
     FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRConfigCurrentConfiguration,);
diff --git a/src/modules/cursor/cursor.c b/src/modules/cursor/cursor.c
@@ -31,7 +31,7 @@ void ffPrintCursor(FFCursorOptions* options)
             ffPrintLogoAndKey(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
             ffStrbufWriteTo(&result.theme, stdout);
 
-            if(result.size.length > 0)
+            if(result.size.length > 0 && !ffStrbufEqualS(&result.size, "0"))
                 printf(" (%spx)", result.size.chars);
 
             putchar('\n');
diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c
diff --git a/src/modules/disk/option.h b/src/modules/disk/option.h

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ static int compareDisks(const void* disk1, const void* disk2)`
`7`	`7`	`return ffStrbufCompAlphabetically(&((const FFDisk) disk1)->mountpoint, &((const FFDisk) disk2)->mountpoint);`
`8`	`8`	`}`
`9`	`9`
`10`		`-const char* ffDetectDisks(FFlist* disks)`
	`10`	`+const char* ffDetectDisks(FFDiskOptions* options, FFlist* disks)`
`11`	`11`	`{`
`12`	`12`	`const char* error = ffDetectDisksImpl(disks);`
`13`	`13`
`@@ -22,7 +22,13 @@ const char* ffDetectDisks(FFlist* disks)`
`22`	`22`	`FF_LIST_FOR_EACH(FFDisk, disk, *disks)`
`23`	`23`	`{`
`24`	`24`	`if(disk->bytesTotal == 0)`
`25`		`- disk->type \|= FF_DISK_TYPE_UNKNOWN_BIT;`
	`25`	`+ disk->type \|= FF_DISK_VOLUME_TYPE_UNKNOWN_BIT;`
	`26`	`+ else`
	`27`	`+ {`
	`28`	`+ disk->bytesUsed = disk->bytesTotal - (`
	`29`	`+ options->calcType == FF_DISK_CALC_TYPE_FREE ? disk->bytesFree : disk->bytesAvailable`
	`30`	`+ );`
	`31`	`+ }`
`26`	`32`	`}`
`27`	`33`
`28`	`34`	`return NULL;`
Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,11 @@ void detectFsInfo(struct statfs* fs, FFDisk* disk)`
`7`	`7`	`{`
`8`	`8`	`// FreeBSD doesn't support these flags`
`9`	`9`	`if(fs->f_flags & MNT_DONTBROWSE)`
`10`		`- disk->type = FF_DISK_TYPE_HIDDEN_BIT;`
	`10`	`+ disk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;`
`11`	`11`	`else if(fs->f_flags & MNT_REMOVABLE)`
`12`		`- disk->type = FF_DISK_TYPE_EXTERNAL_BIT;`
	`12`	`+ disk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;`
`13`	`13`	`else`
`14`		`- disk->type = FF_DISK_TYPE_REGULAR_BIT;`
	`14`	`+ disk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;`
`15`	`15`
`16`	`16`	`ffStrbufInitS(&disk->name, [NSFileManager.defaultManager displayNameAtPath:@(fs->f_mntonname)].UTF8String);`
`17`	`17`	`}`