• 0 Posts
  • 41 Comments
Joined 1 year ago
cake
Cake day: June 16th, 2023

help-circle


  • Here it is:

    #!/usr/bin/zsh
    
    nl=$'\n'
    dnl=$'\n\n'
    
    url=$1
    msgcontent=$url; shift
    argi=1
    for arg ($@); do
        argi=$(($argi + 1))
        msgcontent=${msgcontent}${nl}Argument\ ${argi}': '${arg}
    done
    
    title="${0:A}"
    msg="An application attempted to open a web page:${dnl}\"${msgcontent}\"${dnl}Copy the URL to clipboard?"
    
    kdialog --title $title --yesno $msg
    answer=$?
    
    if [[ $answer = 0 ]]; then wl-copy $url; fi
    

    If you want to translate it to Bash, keep in mind that arrays behave differently between the two shells, and syntax like for arg ($@); do would likely misbehave or not work at all.

    Also, there’s an issue where some applications do something weird, and the URL seems to be a zero-length argument. I have absolutely no idea what’s up with that.


  • You can set some browser-unrelated program or script as your desktop environment’s default browser, for example I wrote a Zsh script that creates a KDE dialog and asks me to copy the URL to the clipboard.

    I’m not currently at my PC, but if you want it I can paste it in a comment here when I get to it - it shouldn’t be too hard to translate it to Bash, either.

    Other than that? /usr/bin/true is a pretty nice default browser for applications to start without your consent, very minimal and lightweight.












  • So, the original content is lost forever?

    No, but it becomes invisible and inaccessible* as long as the filesystem is mounted over it - see this Stack Exchange question and accepted answer.

    The benefits are marginal, for example I can see if a filesystem is mounted by simply typing ll /mnt (ll being an alias of ls -lA) - it comes handy with my system due to how I manage a bunch of virtual machines and their virtual disks, and it’s short and easy to type.
    Some programs may refuse to write inside inaccessible directories, even if the root user can always modify regular files and directories as long as the filesystem supports it.

    It’s not a matter of security, it’s more of a hint that if I’m trying to create something inside those directories then I’m doing something wrong (like forgetting to mount a filesystem) and “permission denied” errors let me know that I am.


  • No, directories without anything mounted on them are normal directories - which checks out, since you can mount anything anywhere; unlike Windows volume letters, which only exist when volumes are mounted or detected by the OS.

    When you mount a filesystem onto a directory, the OS “replaces” its contents AND permissions with that of the filesystem’s root.

    Here’s an example with my setup (hopefully you’re somewhat familiar with Bash and the output of ls -l).

    Imagine some random filesystem in /dev/sda1 owned by “user” which only contains a file named “/Hello World.txt”:

    $ # List permissions of files in /mnt:
    $ # note that none of the directories have read, write nor execute permissions
    $ ls -la /mnt
    drwxr-xr-x   1 root root          168 May 31 23:13 .
    drwxr-xr-x   1 root root          128 May 31 23:14 ..
    d---------   1 root root            0 Aug  1  2020 a/
    d---------   1 root root            0 Feb 11  2022 b/
    d---------   1 root root            0 Aug 11  2021 vdisks/
    
    $ # No read permission on a directory => directory entries cannot be listed
    $ ls /mnt/a
    cannot open directory '/mnt/a': Permission denied
    
    $ sudo mount /dev/sda1 /mnt/a
    
    $ # List again the permissions in /mnt: the root of /dev/sda1
    $ # has rwxr-xr-x (or 755) permissions, which override the 000 of /mnt/a ...
    $ ls -la /mnt
    drwxr-xr-x   1 root root          168 May 31 23:13 .
    drwxr-xr-x   1 root root          128 May 31 23:14 ..
    drwxr-xr-x   1 root root            0 Aug  1  2020 a/
    d---------   1 root root            0 Feb 11  2022 b/
    d---------   1 root root            0 Aug 11  2021 vdisks/
    
    $ # ... and its contents can be accessed by the mounted filesystem's owner:
    $ ls -la /mnt/a
    drwxr-xr-x   1 user user          168 May 31 23:13 .
    drwxr-xr-x   1 root root          168 May 31 23:13 ..
    -rw-r--r-- 1 user user   0 Jul  4 22:13 'Hello World.txt'
    
    $ find /mnt
    /mnt
    /mnt/a
    /mnt/a/Hello World.txt
    find: ‘/mnt/b Permission denied
    find: ‘/mnt/vdisks’: Permission denied
    

    Please note that me setting permissions is just extreme pedantry, it’s not necessary at all and barely changes anything and if you’re still getting familiar with how the Linux VFS and its permissions work you can just ignore all of this.


  • Adding to what the other comment explained:

    I use chown 000 so that regular users fail to access a directory when no filesystem is mounted on it; in practice it never happens, because “regular users” = { me }, but I like being pedantic.

    As for /mnt, it is supposed to be a single temp. mountpoint, but I use it as the parent directory of multiple mountpoints some of which are just for temporary use.


  • I decided to simply create directories within /mnt, chmod 000 them and use them as fixed mountpoints;
    for manual temporary mounts I have /mnt/a, /mnt/b, … /mnt/f, but I never needed to use more than two of them at once.

    While this setup doesn’t really respect the filesystem hierarchy, I wouldn’t have used /mnt at all if I were constrained by its standard purpose since having one available manual mountpoint seems pretty limiting to me.
    Then again, I have 3 physical drives with ~ 10 partitions, plus one removable drive with its own dedicated mountpoint…