1004 lines
33 KiB
C++
1004 lines
33 KiB
C++
/* Copyright (C) 2004 Bart 'plors' Hakvoort
|
|
* Copyright (C) 2008, 2009, 2010, 2011 Curtis Gedak
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "Utils.h"
|
|
#include "GParted_Core.h"
|
|
#include "PipeCapture.h"
|
|
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <glibmm/regex.h>
|
|
#include <locale.h>
|
|
#include <uuid/uuid.h>
|
|
#include <cerrno>
|
|
#include <sys/statvfs.h>
|
|
#include <glibmm/ustring.h>
|
|
#include <glibmm/stringutils.h>
|
|
#include <glibmm/shell.h>
|
|
#include <glibmm/fileutils.h>
|
|
#include <gtkmm/main.h>
|
|
#include <gtkmm/enums.h>
|
|
#include <gtkmm/stock.h>
|
|
#include <gtkmm/stockitem.h>
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <algorithm>
|
|
|
|
|
|
namespace GParted
|
|
{
|
|
|
|
const Glib::ustring DEV_MAPPER_PATH = "/dev/mapper/";
|
|
|
|
Sector Utils::round( double double_value )
|
|
{
|
|
// Reference:
|
|
// How can I convert a floating-point value to an integer in C?
|
|
// https://www.cs.tut.fi/~jkorpela/round.html
|
|
if ( double_value >= 0.0 )
|
|
return static_cast<Sector>( double_value + 0.5 );
|
|
else
|
|
return static_cast<Sector>( double_value - 0.5 );
|
|
}
|
|
|
|
Gtk::Label * Utils::mk_label( const Glib::ustring & text
|
|
, bool use_markup
|
|
, bool wrap
|
|
, bool selectable
|
|
, Gtk::Align valign
|
|
)
|
|
{
|
|
Gtk::Label *label = manage(new Gtk::Label(text));
|
|
|
|
label->set_xalign(0.0);
|
|
label->set_valign(valign);
|
|
label ->set_use_markup( use_markup ) ;
|
|
if (wrap)
|
|
{
|
|
label->set_line_wrap(true);
|
|
label->set_max_width_chars(40);
|
|
}
|
|
label ->set_selectable( selectable ) ;
|
|
|
|
return label ;
|
|
}
|
|
|
|
|
|
Gtk::Image* Utils::mk_image(const Gtk::StockID& stock_id, Gtk::IconSize icon_size)
|
|
{
|
|
Gtk::Image *image = Gtk::manage(new Gtk::Image(stock_id, icon_size));
|
|
|
|
// Ensure icon size
|
|
int width = 0;
|
|
int height = 0;
|
|
if (Gtk::IconSize::lookup(icon_size, width, height) && width > 0 && height > 0)
|
|
{
|
|
int pixel_size = std::min(width, height);
|
|
image->set_pixel_size(pixel_size);
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
|
|
Glib::RefPtr<Gdk::Pixbuf> Utils::mk_pixbuf(Gtk::Widget& widget,
|
|
const Gtk::StockID& stock_id,
|
|
Gtk::IconSize icon_size)
|
|
{
|
|
Glib::RefPtr<Gdk::Pixbuf> theme_icon = widget.render_icon_pixbuf(stock_id, icon_size);
|
|
|
|
// Ensure icon size
|
|
int width = 0;
|
|
int height = 0;
|
|
if (Gtk::IconSize::lookup(icon_size, width, height) && width > 0 && height > 0)
|
|
{
|
|
int pixel_size = std::min(width, height);
|
|
if (theme_icon->get_width() > pixel_size || theme_icon->get_height() > pixel_size)
|
|
return theme_icon->scale_simple(pixel_size, pixel_size, Gdk::INTERP_BILINEAR);
|
|
}
|
|
|
|
return theme_icon;
|
|
}
|
|
|
|
|
|
Glib::ustring Utils::get_stock_label(const Gtk::StockID& stock_id)
|
|
{
|
|
Gtk::StockItem stock_item;
|
|
|
|
if (Gtk::Stock::lookup(stock_id, stock_item))
|
|
return stock_item.get_label();
|
|
|
|
return "";
|
|
}
|
|
|
|
|
|
Glib::ustring Utils::num_to_str( Sector number )
|
|
{
|
|
std::stringstream ss ;
|
|
ss << number ;
|
|
return ss .str() ;
|
|
}
|
|
|
|
// Use palette from GNOME Human Interface Guidelines as a starting point.
|
|
// [+] Lighter or darker shade of an existing colour in the GNOME palette.
|
|
// [*] Colour not from the GNOME palette.
|
|
// http://developer.gnome.org/hig-book/2.32/design-color.html.en
|
|
// http://web.archive.org/web/20130922173112/https://developer.gnome.org/hig-book/stable/design-color.html.en
|
|
Glib::ustring Utils::get_color(FSType fstype)
|
|
{
|
|
switch (fstype)
|
|
{
|
|
case FS_UNSUPPORTED: return "#000000"; // Black (never displayed)
|
|
case FS_UNALLOCATED: return "#A9A9A9"; // Medium Grey [*]
|
|
case FS_UNKNOWN: return "#000000"; // Black
|
|
case FS_UNFORMATTED: return "#000000"; // Black
|
|
case FS_CLEARED: return "#000000"; // Black
|
|
case FS_OTHER: return "#000000"; // Black (never displayed)
|
|
case FS_EXTENDED: return "#95E3E5"; // Cyan Hilight [*]
|
|
case FS_BTRFS: return "#E58749"; // Orange Medium [*]
|
|
case FS_EXFAT: return "#267726"; // Accent Green Dark
|
|
case FS_EXT2: return "#7590AE"; // Blue Medium
|
|
case FS_EXT3: return "#4B6983"; // Blue Dark
|
|
case FS_EXT4: return "#314E6C"; // Blue Shadow
|
|
case FS_F2FS: return "#DF421E"; // Accent Red
|
|
case FS_FAT16: return "#60C160"; // Accent Green Hilight [+]
|
|
case FS_FAT32: return "#46A046"; // Accent Green
|
|
case FS_HFS: return "#D59FD4"; // Magenta Hilight [*]
|
|
case FS_HFSPLUS: return "#B173B0"; // Magenta Medium [*]
|
|
case FS_JFS: return "#D6B129"; // Accent Yellow Dark [+]
|
|
case FS_LINUX_SWAP: return "#C1665A"; // Red Medium
|
|
case FS_LUKS: return "#625B81"; // Purple Dark
|
|
case FS_LVM2_PV: return "#B39169"; // Face Skin Dark
|
|
case FS_MINIX: return "#9DB8D2"; // Blue Highlight
|
|
case FS_NILFS2: return "#990000"; // Accent Red Dark
|
|
case FS_NTFS: return "#70D2B1"; // Aquamarine Medium [*]
|
|
case FS_REISER4: return "#887FA3"; // Purple Medium
|
|
case FS_REISERFS: return "#ADA7C8"; // Purple Hilight
|
|
case FS_UDF: return "#105210"; // Accent Green Shadow [+]
|
|
case FS_XFS: return "#EED680"; // Accent Yellow
|
|
case FS_APFS: return "#874986"; // Magenta Dark [*]
|
|
case FS_ATARAID: return "#5A4733"; // Brown Dark [+]
|
|
case FS_BCACHE: return "#E0C39E"; // Face Skin Medium
|
|
case FS_BITLOCKER: return "#494066"; // Purple Shadow
|
|
case FS_GRUB2_CORE_IMG: return "#666666"; // Dark Gray [*]
|
|
case FS_ISO9660: return "#D3D3D3"; // Light Gray [*]
|
|
case FS_JBD: return "#314E6C"; // Blue Shadow
|
|
case FS_LINUX_SWRAID: return "#826647"; // Face Skin Shadow
|
|
case FS_LINUX_SWSUSPEND: return "#884631"; // Red Dark
|
|
case FS_REFS: return "#3EA281"; // Aquamarine Dark [*]
|
|
case FS_UFS: return "#AA8F2C"; // Accent Yellow Shadow [+]
|
|
case FS_ZFS: return "#C26825"; // Orange Dark [*]
|
|
case FS_USED: return "#F8F8BA"; // Light Tan Yellow [*]
|
|
case FS_UNUSED: return "#FFFFFF"; // White
|
|
default: return "#000000"; // Black
|
|
}
|
|
}
|
|
|
|
|
|
Glib::RefPtr<Gdk::Pixbuf> Utils::get_color_as_pixbuf(FSType fstype, int width, int height)
|
|
{
|
|
Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create( Gdk::COLORSPACE_RGB, false, 8, width, height ) ;
|
|
|
|
if ( pixbuf )
|
|
{
|
|
std::stringstream hex(get_color(fstype).substr(1) + "00");
|
|
unsigned long dec ;
|
|
hex >> std::hex >> dec ;
|
|
|
|
pixbuf ->fill( dec ) ;
|
|
}
|
|
|
|
return pixbuf ;
|
|
}
|
|
|
|
int Utils::get_max_partition_name_length( Glib::ustring & tabletype )
|
|
{
|
|
// Partition name size found or confirmed by looking at *_partition_set_name()
|
|
// functions in the relevant libparted label modules:
|
|
// dvh.c, gpt.c, mac.c, pc98.c, rdb.c (amiga)
|
|
// http://git.savannah.gnu.org/cgit/parted.git/tree/libparted/labels
|
|
//
|
|
// Table Max Units
|
|
// type length Reference
|
|
// ----- ------ ---------
|
|
// amiga 32 ASCII characters
|
|
// dvh 8 ASCII characters
|
|
// gpt 36 UTF-16LE code points
|
|
// http://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_entries
|
|
// mac 32 ASCII characters
|
|
// http://en.wikipedia.org/wiki/Apple_Partition_Map#Layout
|
|
// pc98 16 ASCII characters
|
|
//
|
|
// Found issues:
|
|
// 1) amiga - Setting partition name to 32 chars is silent ignored. Setting to 31
|
|
// chars or less works.
|
|
// 2) dvh - Probably by design, setting names on primary partitions is
|
|
// successfully ignored with this libparted message:
|
|
// failed to set dvh partition name to NAME:
|
|
// Only logical partitions (boot files) have a name.
|
|
// Setting names on logical partitions works.
|
|
// 3) mac - Setting partition name to 32 chars core dumps in libparted. Setting
|
|
// to 31 chars or less works.
|
|
//
|
|
// Suspect usage of these partition tables types other than GPT is *VERY* low.
|
|
// Given the above issues which need a little coding around, leave support of
|
|
// naming for partition table types other than GPT disabled. Mostly just to
|
|
// reduce ongoing testing effort, at least until there is any user demand for it.
|
|
|
|
if ( tabletype == "amiga" ) return 0; // Disabled
|
|
else if ( tabletype == "dvh" ) return 0; // Disabled
|
|
else if ( tabletype == "gpt" ) return 36;
|
|
else if ( tabletype == "mac" ) return 0; // Disabled
|
|
else if ( tabletype == "pc98" ) return 0; // Disabled
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int Utils::get_filesystem_label_maxlength(FSType fstype)
|
|
{
|
|
switch (fstype)
|
|
{
|
|
//All file systems commented out are not supported for labelling
|
|
// by either the new partition or label partition operations.
|
|
case FS_BTRFS : return 255 ;
|
|
case FS_EXFAT : return 11;
|
|
case FS_EXT2 : return 16 ;
|
|
case FS_EXT3 : return 16 ;
|
|
case FS_EXT4 : return 16 ;
|
|
// mkfs.f2fs supports labels up to 512 characters, however only blkid is
|
|
// used to read the label and that only displays the first 127 characters.
|
|
case FS_F2FS : return 127;
|
|
case FS_FAT16 : return 11 ;
|
|
case FS_FAT32 : return 11 ;
|
|
//mkfs.hfsplus can create hfs and hfs+ file systems with labels up to 255
|
|
// characters. However there is no specific tool to read the labels and
|
|
// blkid, the only tool currently available, only display the first 27
|
|
// and 63 character respectively.
|
|
// Reference:
|
|
// util-linux-2.20.1/libblkid/src/superblocks/hfs.c:struct hfs_mdb
|
|
case FS_HFS : return 27 ;
|
|
case FS_HFSPLUS : return 63 ;
|
|
//mkfs.jfs and jfs_tune can create and update labels to 16 characters but
|
|
// only displays the first 11 characters. This is because version 1 jfs
|
|
// file systems only have an 11 character field for the label but version
|
|
// 2 jfs has extra fields containing a 16 character label. mkfs.jfs
|
|
// writes the extra fields containing the 16 character label, but then
|
|
// sets it to version 1 jfs. It does this to be backwardly compatible
|
|
// with jfs before 1.0.18, released May 2002. Blkid does display the
|
|
// full 16 character label by just ignoring the file system version.
|
|
// As using jfs_tune to get the label stick with an 11 character limit.
|
|
// References:
|
|
// jfsutils-1.1.15/tune/tune.c:main()
|
|
// jfsutils-1.1.15/mkfs/mkfs.c:create_aggregate()
|
|
// http://jfs.cvs.sourceforge.net/viewvc/jfs/jfsutils/NEWS?revision=HEAD
|
|
case FS_JFS : return 11 ;
|
|
case FS_LINUX_SWAP : return 15 ;
|
|
//case FS_LVM2_PV : return ;
|
|
case FS_MINIX : return 0; // MINIX doesn't support labelling.
|
|
case FS_NILFS2 : return 80 ;
|
|
case FS_NTFS : return 128 ;
|
|
case FS_REISER4 : return 16 ;
|
|
case FS_REISERFS : return 16 ;
|
|
case FS_UDF : return 126; // and only 63 if label contains character above U+FF
|
|
case FS_XFS : return 12 ;
|
|
|
|
default : return 30 ;
|
|
}
|
|
}
|
|
|
|
|
|
// Return libparted file system name / GParted display name
|
|
const Glib::ustring Utils::get_filesystem_string(FSType fstype)
|
|
{
|
|
switch (fstype)
|
|
{
|
|
case FS_UNSUPPORTED: return "unsupported"; // Never displayed
|
|
case FS_UNALLOCATED:
|
|
/* TO TRANSLATORS: unallocated
|
|
* means that this space on the disk device is
|
|
* outside any partition, so is in other words
|
|
* unallocated.
|
|
*/
|
|
return _("unallocated");
|
|
case FS_UNKNOWN:
|
|
/* TO TRANSLATORS: unknown
|
|
* means that this space within this partition does
|
|
* not contain a file system known to GParted, and
|
|
* is in other words unknown.
|
|
*/
|
|
return _("unknown");
|
|
case FS_UNFORMATTED:
|
|
/* TO TRANSLATORS: unformatted
|
|
* means that when the new partition is created by
|
|
* GParted the space within it will not be formatted
|
|
* with a file system.
|
|
*/
|
|
return _("unformatted");
|
|
case FS_OTHER:
|
|
/* TO TRANSLATORS: other
|
|
* name shown in the File System Support dialog to list
|
|
* actions which can be performed on other file systems
|
|
* not specifically listed as supported.
|
|
*/
|
|
return _("other");
|
|
case FS_CLEARED:
|
|
/* TO TRANSLATORS: cleared
|
|
* means that all file system signatures in the partition
|
|
* will be cleared by GParted.
|
|
*/
|
|
return _("cleared");
|
|
case FS_EXTENDED: return "extended";
|
|
case FS_BTRFS: return "btrfs";
|
|
case FS_EXFAT: return "exfat";
|
|
case FS_EXT2: return "ext2";
|
|
case FS_EXT3: return "ext3";
|
|
case FS_EXT4: return "ext4";
|
|
case FS_F2FS: return "f2fs";
|
|
case FS_FAT16: return "fat16";
|
|
case FS_FAT32: return "fat32";
|
|
case FS_HFS: return "hfs";
|
|
case FS_HFSPLUS: return "hfs+";
|
|
case FS_JFS: return "jfs";
|
|
case FS_LINUX_SWAP: return "linux-swap";
|
|
case FS_LUKS: return "luks";
|
|
case FS_LVM2_PV: return "lvm2 pv";
|
|
case FS_MINIX: return "minix";
|
|
case FS_NILFS2: return "nilfs2";
|
|
case FS_NTFS: return "ntfs";
|
|
case FS_REISER4: return "reiser4";
|
|
case FS_REISERFS: return "reiserfs";
|
|
case FS_UDF: return "udf";
|
|
case FS_XFS: return "xfs";
|
|
case FS_APFS: return "apfs";
|
|
case FS_ATARAID: return "ataraid";
|
|
case FS_BCACHE: return "bcache";
|
|
case FS_BITLOCKER: return "bitlocker";
|
|
case FS_GRUB2_CORE_IMG: return "grub2 core.img";
|
|
case FS_ISO9660: return "iso9660";
|
|
case FS_JBD: return "jbd";
|
|
case FS_LINUX_SWRAID: return "linux-raid";
|
|
case FS_LINUX_SWSUSPEND: return "linux-suspend";
|
|
case FS_REFS: return "refs";
|
|
case FS_UFS: return "ufs";
|
|
case FS_ZFS: return "zfs";
|
|
case FS_USED: return _("used");
|
|
case FS_UNUSED: return _("unused");
|
|
default: return "";
|
|
}
|
|
}
|
|
|
|
const Glib::ustring Utils::get_encrypted_string()
|
|
{
|
|
/* TO TRANSLATORS: means that this is an encrypted file system */
|
|
return "[" + Glib::ustring( _("Encrypted") ) + "]";
|
|
}
|
|
|
|
const Glib::ustring Utils::get_filesystem_string( bool encrypted, FSType fstype )
|
|
{
|
|
if ( encrypted )
|
|
return get_encrypted_string() + " " + get_filesystem_string( fstype );
|
|
else
|
|
return get_filesystem_string( fstype );
|
|
}
|
|
|
|
// Return Linux kernel name only for mountable file systems.
|
|
// (Identical to a subset of the libparted names except that it's hfsplus instead of hfs+).
|
|
const Glib::ustring Utils::get_filesystem_kernel_name( FSType fstype )
|
|
{
|
|
switch ( fstype )
|
|
{
|
|
case FS_BTRFS : return "btrfs";
|
|
case FS_EXFAT : return "exfat";
|
|
case FS_EXT2 : return "ext2";
|
|
case FS_EXT3 : return "ext3";
|
|
case FS_EXT4 : return "ext4";
|
|
case FS_F2FS : return "f2fs";
|
|
case FS_FAT16 : return "fat16";
|
|
case FS_FAT32 : return "fat32";
|
|
case FS_HFS : return "hfs";
|
|
case FS_HFSPLUS : return "hfsplus";
|
|
case FS_JFS : return "jfs";
|
|
case FS_MINIX : return "minix";
|
|
case FS_NILFS2 : return "nilfs2";
|
|
case FS_NTFS : return "ntfs";
|
|
case FS_REISER4 : return "reiser4";
|
|
case FS_REISERFS : return "reiserfs";
|
|
case FS_UDF : return "udf";
|
|
case FS_XFS : return "xfs";
|
|
default : return "";
|
|
}
|
|
}
|
|
|
|
|
|
const Glib::ustring Utils::get_filesystem_software(FSType fstype)
|
|
{
|
|
switch (fstype)
|
|
{
|
|
case FS_BTRFS: return "btrfs-progs / btrfs-tools";
|
|
case FS_EXFAT: return "exfatprogs";
|
|
case FS_EXT2: return "e2fsprogs";
|
|
case FS_EXT3: return "e2fsprogs";
|
|
case FS_EXT4: return "e2fsprogs v1.41+";
|
|
case FS_F2FS: return "f2fs-tools";
|
|
case FS_FAT16: return "dosfstools, mtools";
|
|
case FS_FAT32: return "dosfstools, mtools";
|
|
case FS_HFS: return "hfsutils";
|
|
case FS_HFSPLUS: return "hfsprogs";
|
|
case FS_JFS: return "jfsutils";
|
|
case FS_LINUX_SWAP: return "util-linux";
|
|
case FS_LUKS: return "cryptsetup, dmsetup";
|
|
case FS_LVM2_PV: return "lvm2";
|
|
case FS_MINIX: return "util-linux";
|
|
case FS_NILFS2: return "nilfs-utils / nilfs-tools";
|
|
case FS_NTFS: return "ntfs-3g / ntfsprogs";
|
|
case FS_REISER4: return "reiser4progs";
|
|
case FS_REISERFS: return "reiserfsprogs / reiserfs-utils";
|
|
case FS_UDF: return "udftools";
|
|
case FS_XFS: return "xfsprogs, xfsdump";
|
|
default: return "";
|
|
}
|
|
}
|
|
|
|
|
|
// Return the encryption mapping name GParted will use when opening it, given it's block
|
|
// device name.
|
|
// E.g., generate_encryption_mapping_name("/dev/sdb1") -> "sdb1_crypt"
|
|
const Glib::ustring Utils::generate_encryption_mapping_name(const Glib::ustring& path)
|
|
{
|
|
Glib::ustring mapping_name = path;
|
|
|
|
Glib::ustring::size_type last_slash = path.rfind("/");
|
|
if (last_slash != Glib::ustring::npos)
|
|
mapping_name = path.substr(last_slash + 1);
|
|
|
|
return mapping_name + "_crypt";
|
|
}
|
|
|
|
|
|
//Report whether or not the kernel supports a particular file system
|
|
bool Utils::kernel_supports_fs( const Glib::ustring & fs )
|
|
{
|
|
bool fs_supported = false ;
|
|
|
|
//Read /proc/filesystems and check for the file system name.
|
|
// Will succeed for compiled in drivers and already loaded
|
|
// moduler drivers. If not found, try loading the driver
|
|
// as a module and re-checking /proc/filesystems.
|
|
std::ifstream input ;
|
|
std::string line ;
|
|
input .open( "/proc/filesystems" ) ;
|
|
if ( input )
|
|
{
|
|
while ( input >> line )
|
|
if ( line == fs )
|
|
{
|
|
fs_supported = true ;
|
|
break ;
|
|
}
|
|
input .close() ;
|
|
}
|
|
if ( fs_supported )
|
|
return true ;
|
|
|
|
Glib::ustring output, error ;
|
|
execute_command( "modprobe " + Glib::shell_quote( fs ), output, error, true );
|
|
|
|
input .open( "/proc/filesystems" ) ;
|
|
if ( input )
|
|
{
|
|
while ( input >> line )
|
|
if ( line == fs )
|
|
{
|
|
fs_supported = true ;
|
|
break ;
|
|
}
|
|
input .close() ;
|
|
}
|
|
|
|
return fs_supported ;
|
|
}
|
|
|
|
//Report if kernel version is >= (major, minor, patch)
|
|
bool Utils::kernel_version_at_least( int major_ver, int minor_ver, int patch_ver )
|
|
{
|
|
int actual_major_ver, actual_minor_ver, actual_patch_ver ;
|
|
if ( ! get_kernel_version( actual_major_ver, actual_minor_ver, actual_patch_ver ) )
|
|
return false ;
|
|
bool result = ( actual_major_ver > major_ver )
|
|
|| ( actual_major_ver == major_ver && actual_minor_ver > minor_ver )
|
|
|| ( actual_major_ver == major_ver && actual_minor_ver == minor_ver && actual_patch_ver >= patch_ver ) ;
|
|
return result ;
|
|
}
|
|
|
|
Glib::ustring Utils::format_size( Sector sectors, Byte_Value sector_size )
|
|
{
|
|
std::stringstream ss ;
|
|
ss << std::setiosflags( std::ios::fixed ) << std::setprecision( 2 ) ;
|
|
|
|
if ( (sectors * sector_size) < KIBIBYTE )
|
|
{
|
|
ss << sector_to_unit( sectors, sector_size, UNIT_BYTE ) ;
|
|
return Glib::ustring::compose( _("%1 B"), ss .str() ) ;
|
|
}
|
|
else if ( (sectors * sector_size) < MEBIBYTE )
|
|
{
|
|
ss << sector_to_unit( sectors, sector_size, UNIT_KIB ) ;
|
|
return Glib::ustring::compose( _("%1 KiB"), ss .str() ) ;
|
|
}
|
|
else if ( (sectors * sector_size) < GIBIBYTE )
|
|
{
|
|
ss << sector_to_unit( sectors, sector_size, UNIT_MIB ) ;
|
|
return Glib::ustring::compose( _("%1 MiB"), ss .str() ) ;
|
|
}
|
|
else if ( (sectors * sector_size) < TEBIBYTE )
|
|
{
|
|
ss << sector_to_unit( sectors, sector_size, UNIT_GIB ) ;
|
|
return Glib::ustring::compose( _("%1 GiB"), ss .str() ) ;
|
|
}
|
|
else
|
|
{
|
|
ss << sector_to_unit( sectors, sector_size, UNIT_TIB ) ;
|
|
return Glib::ustring::compose( _("%1 TiB"), ss .str() ) ;
|
|
}
|
|
}
|
|
|
|
Glib::ustring Utils::format_time( std::time_t seconds )
|
|
{
|
|
Glib::ustring time ;
|
|
|
|
if ( seconds < 0 )
|
|
{
|
|
time = "-";
|
|
seconds = -seconds;
|
|
}
|
|
|
|
int unit = static_cast<int>( seconds / 3600 ) ;
|
|
if ( unit < 10 )
|
|
time += "0" ;
|
|
time += num_to_str( unit ) + ":" ;
|
|
seconds %= 3600 ;
|
|
|
|
unit = static_cast<int>( seconds / 60 ) ;
|
|
if ( unit < 10 )
|
|
time += "0" ;
|
|
time += num_to_str( unit ) + ":" ;
|
|
seconds %= 60 ;
|
|
|
|
if ( seconds < 10 )
|
|
time += "0" ;
|
|
time += num_to_str( seconds ) ;
|
|
|
|
return time ;
|
|
}
|
|
|
|
double Utils::sector_to_unit( Sector sectors, Byte_Value sector_size, SIZE_UNIT size_unit )
|
|
{
|
|
switch ( size_unit )
|
|
{
|
|
case UNIT_BYTE :
|
|
return sectors * sector_size ;
|
|
|
|
case UNIT_KIB :
|
|
return sectors / ( static_cast<double>( KIBIBYTE ) / sector_size );
|
|
case UNIT_MIB :
|
|
return sectors / ( static_cast<double>( MEBIBYTE ) / sector_size );
|
|
case UNIT_GIB :
|
|
return sectors / ( static_cast<double>( GIBIBYTE ) / sector_size );
|
|
case UNIT_TIB :
|
|
return sectors / ( static_cast<double>( TEBIBYTE ) / sector_size );
|
|
|
|
default:
|
|
return sectors ;
|
|
}
|
|
}
|
|
|
|
int Utils::execute_command( const Glib::ustring & command )
|
|
{
|
|
Glib::ustring dummy ;
|
|
return execute_command(command, nullptr, dummy, dummy);
|
|
}
|
|
|
|
class CommandStatus
|
|
{
|
|
public:
|
|
bool running;
|
|
int pipecount;
|
|
int exit_status;
|
|
bool foreground;
|
|
Glib::Mutex mutex;
|
|
Glib::Cond cond;
|
|
void store_exit_status( GPid pid, int status );
|
|
void execute_command_eof();
|
|
};
|
|
|
|
void CommandStatus::store_exit_status( GPid pid, int status )
|
|
{
|
|
exit_status = Utils::decode_wait_status( status );
|
|
running = false;
|
|
if (pipecount == 0) // pipes finished first
|
|
{
|
|
if (foreground)
|
|
Gtk::Main::quit();
|
|
else {
|
|
mutex.lock();
|
|
cond.signal();
|
|
mutex.unlock();
|
|
}
|
|
}
|
|
Glib::spawn_close_pid( pid );
|
|
}
|
|
|
|
void CommandStatus::execute_command_eof()
|
|
{
|
|
if (--pipecount)
|
|
return; // wait for second pipe to eof
|
|
if ( !running ) // already got exit status
|
|
{
|
|
if (foreground)
|
|
Gtk::Main::quit();
|
|
else {
|
|
mutex.lock();
|
|
cond.signal();
|
|
mutex.unlock();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void set_locale()
|
|
{
|
|
setenv( "LC_ALL", "C", 1 );
|
|
}
|
|
|
|
static void _store_exit_status( GPid pid, gint status, gpointer data )
|
|
{
|
|
CommandStatus *sp = (CommandStatus *)data;
|
|
sp->store_exit_status( pid, status );
|
|
}
|
|
|
|
int Utils::execute_command( const Glib::ustring & command,
|
|
Glib::ustring & output,
|
|
Glib::ustring & error,
|
|
bool use_C_locale )
|
|
{
|
|
return execute_command(command, nullptr, output, error, use_C_locale);
|
|
}
|
|
|
|
int Utils::execute_command( const Glib::ustring & command,
|
|
const char * input,
|
|
Glib::ustring & output,
|
|
Glib::ustring & error,
|
|
bool use_C_locale )
|
|
{
|
|
Glib::Pid pid;
|
|
int in = -1;
|
|
// set up pipes for capture
|
|
int out, err;
|
|
CommandStatus status;
|
|
// spawn external process
|
|
status.running = true;
|
|
status.pipecount = 2;
|
|
status.foreground = (Glib::Thread::self() == GParted_Core::mainthread);
|
|
try {
|
|
Glib::spawn_async_with_pipes(
|
|
std::string( "." ),
|
|
Glib::shell_parse_argv( command ),
|
|
Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH,
|
|
use_C_locale ? sigc::ptr_fun( set_locale ) : sigc::slot< void >(),
|
|
&pid,
|
|
(input != nullptr) ? &in : 0,
|
|
&out,
|
|
&err );
|
|
} catch (Glib::SpawnError &e) {
|
|
std::cerr << e.what() << std::endl;
|
|
return Utils::get_failure_status( e );
|
|
}
|
|
fcntl( out, F_SETFL, O_NONBLOCK );
|
|
fcntl( err, F_SETFL, O_NONBLOCK );
|
|
g_child_watch_add( pid, _store_exit_status, &status );
|
|
//Lock mutex so we have time to setup pipecapture for output and error streams
|
|
// before connecting the input/output signal handler
|
|
if( !status.foreground )
|
|
status.mutex.lock();
|
|
PipeCapture outputcapture( out, output );
|
|
PipeCapture errorcapture( err, error );
|
|
outputcapture.signal_eof.connect( sigc::mem_fun( status, &CommandStatus::execute_command_eof ) );
|
|
errorcapture.signal_eof.connect( sigc::mem_fun( status, &CommandStatus::execute_command_eof ) );
|
|
outputcapture.connect_signal();
|
|
errorcapture.connect_signal();
|
|
|
|
if (input != nullptr && in != -1)
|
|
{
|
|
// Write small amount of input to pipe to the child process. Linux will
|
|
// always accept up 4096 bytes without blocking. See pipe(7).
|
|
size_t len = strlen( input );
|
|
ssize_t written = write( in, input, len );
|
|
if ( written == -1 || (size_t)written < len )
|
|
std::cerr << "Write to child failed: " << Glib::strerror( errno ) << std::endl;
|
|
close( in );
|
|
}
|
|
|
|
if( status.foreground)
|
|
Gtk::Main::run();
|
|
else {
|
|
status.cond.wait( status.mutex );
|
|
status.mutex.unlock();
|
|
}
|
|
close( out );
|
|
close( err );
|
|
return status.exit_status;
|
|
}
|
|
|
|
// Return shell style exit status when failing to execute a command. 127 for command not
|
|
// found and 126 otherwise.
|
|
// NOTE:
|
|
// Together get_failure_status() and decode_wait_status() provide complete shell style
|
|
// exit status handling. See bash(1) manual page, EXIT STATUS section for details.
|
|
int Utils::get_failure_status( Glib::SpawnError & e )
|
|
{
|
|
if ( e.code() == Glib::SpawnError::NOENT )
|
|
return 127;
|
|
return 126;
|
|
}
|
|
|
|
// Return shell style decoding of waitpid(2) encoded exit statuses. Return command exit
|
|
// status or 128 + signal number when terminated by a signal.
|
|
int Utils::decode_wait_status( int wait_status )
|
|
{
|
|
if ( WIFEXITED( wait_status ) )
|
|
return WEXITSTATUS( wait_status );
|
|
else if ( WIFSIGNALED( wait_status ) )
|
|
return 128 + WTERMSIG( wait_status );
|
|
|
|
// Other cases of WIFSTOPPED() and WIFCONTINUED() occur when the process is
|
|
// stopped or resumed by signals. Should be impossible as this function is only
|
|
// called after the process has exited.
|
|
std::cerr << "Unexpected wait status " << wait_status << std::endl;
|
|
return 255;
|
|
}
|
|
|
|
Glib::ustring Utils::regexp_label( const Glib::ustring & text
|
|
, const Glib::ustring & pattern
|
|
)
|
|
{
|
|
//Extract text from a regular sub-expression or pattern.
|
|
// E.g., "text we don't want (text we want)"
|
|
std::vector<Glib::ustring> results;
|
|
Glib::RefPtr<Glib::Regex> myregexp =
|
|
Glib::Regex::create( pattern
|
|
, Glib::REGEX_CASELESS | Glib::REGEX_MULTILINE
|
|
);
|
|
|
|
results = myregexp ->split( text );
|
|
|
|
if ( results .size() >= 2 )
|
|
return results[ 1 ] ;
|
|
else
|
|
return "" ;
|
|
}
|
|
|
|
Glib::ustring Utils::trim( const Glib::ustring & src, const Glib::ustring & c /* = " \t\r\n" */ )
|
|
{
|
|
//Trim leading and trailing whitespace from string
|
|
Glib::ustring::size_type p2 = src.find_last_not_of(c);
|
|
if (p2 == Glib::ustring::npos) return Glib::ustring();
|
|
Glib::ustring::size_type p1 = src.find_first_not_of(c);
|
|
if (p1 == Glib::ustring::npos) p1 = 0;
|
|
return src.substr(p1, (p2-p1)+1);
|
|
}
|
|
|
|
|
|
// Return string with optional trailing new line character removed.
|
|
Glib::ustring Utils::trim_trailing_new_line(const Glib::ustring& src)
|
|
{
|
|
Glib::ustring::size_type len = src.length();
|
|
if (len > 0 && src[len-1] == '\n')
|
|
len --;
|
|
return src.substr(0, len);
|
|
}
|
|
|
|
|
|
// Return portion of string after the last carriage return character or
|
|
// the whole string when there is no carriage return character.
|
|
Glib::ustring Utils::last_line( const Glib::ustring & src )
|
|
{
|
|
Glib::ustring::size_type p = src.find_last_of( '\n' );
|
|
if ( p == Glib::ustring::npos )
|
|
return src;
|
|
return src.substr( p+1 );
|
|
}
|
|
|
|
Glib::ustring Utils::get_lang()
|
|
{
|
|
//Extract base language from string that may look like "en_CA.UTF-8"
|
|
// and return in the form "en-CA"
|
|
Glib::ustring lang = setlocale(LC_CTYPE, nullptr);
|
|
|
|
//Strip off anything after the period "." or at sign "@"
|
|
lang = Utils::regexp_label( lang .c_str(), "^([^.@]*)") ;
|
|
|
|
//Convert the underscore "_" to a hyphen "-"
|
|
Glib::ustring sought = "_" ;
|
|
Glib::ustring replacement = "-" ;
|
|
//NOTE: Application crashes if string replace is called and sought is not found,
|
|
// so we need to only perform replace if the sought is found.
|
|
if ( lang .find(sought) != Glib::ustring::npos )
|
|
lang .replace( lang .find(sought), sought .size(), replacement ) ;
|
|
|
|
return lang ;
|
|
}
|
|
|
|
//Extract a list of tokens from any number of background separator characters
|
|
// E.g., tokenize(str=" word1 word2 ", tokens, delimiters=" ")
|
|
// -> tokens=["word1","word2]
|
|
//The tokenize method copied and adapted from:
|
|
// http://www.linuxselfhelp.com/HOWTO/C++Programming-HOWTO-7.html
|
|
void Utils::tokenize( const Glib::ustring& str,
|
|
std::vector<Glib::ustring>& tokens,
|
|
const Glib::ustring& delimiters = " " )
|
|
{
|
|
// Skip delimiters at beginning.
|
|
Glib::ustring::size_type lastPos = str.find_first_not_of(delimiters, 0);
|
|
// Find first "non-delimiter".
|
|
Glib::ustring::size_type pos = str.find_first_of(delimiters, lastPos);
|
|
|
|
while (Glib::ustring::npos != pos || Glib::ustring::npos != lastPos)
|
|
{
|
|
// Found a token, add it to the vector.
|
|
tokens.push_back(str.substr(lastPos, pos - lastPos));
|
|
// Skip delimiters. Note the "not_of"
|
|
lastPos = str.find_first_not_of(delimiters, pos);
|
|
// Find next "non-delimiter"
|
|
pos = str.find_first_of(delimiters, lastPos);
|
|
}
|
|
}
|
|
|
|
//Split string on every delimiter, appending to the vector. Inspired by:
|
|
// http://stackoverflow.com/questions/236129/how-to-split-a-string-in-c/3616605#3616605
|
|
// E.g. using Utils::split(str, result, ":") for str -> result
|
|
// "" -> [] "a" -> ["a"] "::" -> ["","",""] ":a::bb" -> ["","a","","bb"]
|
|
void Utils::split( const Glib::ustring& str,
|
|
std::vector<Glib::ustring>& result,
|
|
const Glib::ustring& delimiters )
|
|
{
|
|
//Special case zero length string to empty vector
|
|
if ( str == "" )
|
|
return ;
|
|
Glib::ustring::size_type fromPos = 0 ;
|
|
Glib::ustring::size_type delimPos = str.find_first_of( delimiters );
|
|
while ( Glib::ustring::npos != delimPos )
|
|
{
|
|
Glib::ustring word( str, fromPos, delimPos - fromPos ) ;
|
|
result .push_back( word ) ;
|
|
fromPos = delimPos + 1 ;
|
|
delimPos = str.find_first_of( delimiters, fromPos ) ;
|
|
}
|
|
Glib::ustring word( str, fromPos ) ;
|
|
result. push_back( word ) ;
|
|
}
|
|
|
|
|
|
// Create a new UUID
|
|
Glib::ustring Utils::generate_uuid(void)
|
|
{
|
|
uuid_t uuid;
|
|
char uuid_str[UUID_STRING_LENGTH+1];
|
|
|
|
uuid_generate(uuid);
|
|
uuid_unparse(uuid,uuid_str);
|
|
|
|
return uuid_str;
|
|
}
|
|
|
|
//Wrapper around statvfs() system call to get mounted file system size
|
|
// and free space, both in bytes.
|
|
int Utils::get_mounted_filesystem_usage( const Glib::ustring & mountpoint,
|
|
Byte_Value & fs_size, Byte_Value & fs_free,
|
|
Glib::ustring & error_message )
|
|
{
|
|
struct statvfs sfs ;
|
|
int ret ;
|
|
ret = statvfs( mountpoint .c_str(), &sfs ) ;
|
|
if ( ret == 0 )
|
|
{
|
|
fs_size = static_cast<Byte_Value>( sfs .f_blocks ) * sfs .f_frsize ;
|
|
fs_free = static_cast<Byte_Value>( sfs .f_bfree ) * sfs .f_bsize ;
|
|
}
|
|
else
|
|
error_message = "statvfs(\"" + mountpoint + "\"): " + Glib::strerror( errno ) ;
|
|
|
|
return ret ;
|
|
}
|
|
|
|
|
|
// Report whether the kernel considers the device busy or not.
|
|
bool Utils::is_dev_busy(const Glib::ustring& path)
|
|
{
|
|
int fd = open(path.c_str(), O_RDONLY|O_EXCL);
|
|
if (fd == -1 && errno == EBUSY)
|
|
return true;
|
|
else if (fd >= 0)
|
|
close(fd);
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Return the first path that is a directory, or the empty string.
|
|
const Glib::ustring& Utils::first_directory(const std::vector<Glib::ustring>& paths)
|
|
{
|
|
for (unsigned int i = 0; i < paths.size(); i++)
|
|
if (file_test(paths[i], Glib::FILE_TEST_IS_DIR))
|
|
return paths[i];
|
|
|
|
static const Glib::ustring not_found;
|
|
return not_found;
|
|
}
|
|
|
|
|
|
//Round down to multiple of rounding_size
|
|
Byte_Value Utils::floor_size( Byte_Value value, Byte_Value rounding_size )
|
|
{
|
|
return value / rounding_size * rounding_size ;
|
|
}
|
|
|
|
//Round up to multiple of rounding_size
|
|
Byte_Value Utils::ceil_size( Byte_Value value, Byte_Value rounding_size )
|
|
{
|
|
return ( value + rounding_size - 1LL ) / rounding_size * rounding_size ;
|
|
}
|
|
|
|
//private functions ...
|
|
|
|
//Read kernel version, reporting success or failure
|
|
bool Utils::get_kernel_version( int & major_ver, int & minor_ver, int & patch_ver )
|
|
{
|
|
static bool read_file = false ;
|
|
static int read_major_ver = 0 ;
|
|
static int read_minor_ver = 0 ;
|
|
static int read_patch_ver = 0 ;
|
|
static bool success = false ;
|
|
|
|
if ( ! read_file )
|
|
{
|
|
std::ifstream input( "/proc/version" ) ;
|
|
std::string line ;
|
|
if ( input )
|
|
{
|
|
getline( input, line ) ;
|
|
int assigned = sscanf( line .c_str(), "Linux version %d.%d.%d",
|
|
&read_major_ver, &read_minor_ver, &read_patch_ver ) ;
|
|
success = ( assigned >= 2 ) ; //At least 2 kernel version components read
|
|
input .close() ;
|
|
}
|
|
read_file = true ;
|
|
}
|
|
if ( success )
|
|
{
|
|
major_ver = read_major_ver ;
|
|
minor_ver = read_minor_ver ;
|
|
patch_ver = read_patch_ver ;
|
|
}
|
|
return success ;
|
|
}
|
|
|
|
} //GParted..
|