Piccolo script scritto di fretta per avere sotto mano la versione fresh di Libreoffice su Fedora invece che quella pacchettizzata. Un giorno ci ritornerò come ho fatto con “Gestione TOTP in bash“

#!/bin/bash
#download.documentfoundation.org

usage() {
cat<<EOF
Usa come: ./libreoffice-update.sh [options]
dove:
    [options]
        -u verifica l esistenza di una nuova versione
        -i <numero_version> installa la nuova versione di libreoffice
        -h stampa questa pagina di help

ESEMPI:
    VERIFICA CHE UN AGGIORNAMENTO SIA DISPONIBILE
    libreoffice-update -u

    INSTALLA L ULTIMA VERSIONE DI LIBREOFFICE
    libreoffice-update -i

    VISUALIZZA l HELP
    libreoffice-update -h
EOF
}

download_lo_suite() {
    echo -n "Inizio download LibreOffice $VERSION... "
    [[ $(aria2c https://download.documentfoundation.org/libreoffice/stable/"$VERSION"/rpm/x86_64/LibreOffice_"$VERSION"_Linux_x86-64_rpm.tar.gz | grep ERROR) ]] \
        && { echo "*** Impossibile scaricare LibreOffice $VERSION ***"; ERROR_CODE=64; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Inizio download LibreOfficeLangack $VERSION... "
    [[ $(aria2c https://download.documentfoundation.org/libreoffice/stable/"$VERSION"/rpm/x86_64/LibreOffice_"$VERSION"_Linux_x86-64_rpm_langpack_it.tar.gz | grep ERROR) ]] \
        && { echo "*** Impossibile scaricare LibreOfficelangPack $VERSION ***"; ERROR_CODE=65; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Inizio download LibreOfficeHelppack $VERSION... "
    [[ $(aria2c https://download.documentfoundation.org/libreoffice/stable/"$VERSION"/rpm/x86_64/LibreOffice_"$VERSION"_Linux_x86-64_rpm_helppack_it.tar.gz | grep ERROR) ]] \
        && { echo "*** Impossibile scaricare LibreOfficeHelppack $VERSION ***"; ERROR_CODE=66; return ${ERROR_CODE}; } \
        || echo -e "Fatto.\n"
}


decomprimi_lo_suite() {
    echo -n "Decompressione tar LibreOffice $VERSION in corso... "
    [[ $(tar -xzf LibreOffice_"$VERSION"_Linux_x86-64_rpm.tar.gz 2>/dev/null) ]] \
        && { echo "*** Impossibile decomprimere il tar di LibreOffice $VERSION ***"; ERROR_CODE=67; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Decompressione tar LibreOfficeLangpack $VERSION in corso... "
    [[ $(tar -xzf LibreOffice_"$VERSION"_Linux_x86-64_rpm_langpack_it.tar.gz  2>/dev/null) ]] \
        && { echo "*** Impossibile decomprimere il tar di LibreOfficeLangpack $VERSION ***"; ERROR_CODE=68; return ${ERROR_CODE}; } \
        || echo "Fatto."

    echo -n "Decompressione tar LibreOfficeHelppack $VERSION in corso... "
    [[ $(tar -xzf LibreOffice_"$VERSION"_Linux_x86-64_rpm_helppack_it.tar.gz 2>/dev/null) ]] \
        && { echo "*** Impossibile decomprimere il tar di LibreOfficeHelppack $VERSION ***"; ERROR_CODE=69; return ${ERROR_CODE}; } \
        || echo -e "Fatto.\n"
        
    [[ $? -gt 0 ]] && return $?
}

install_lo_suite() {
    cd $(tar -tf LibreOffice_"$VERSION"_Linux_x86-64_rpm.tar.gz|head -1) && sudo dnf -y localinstall RPMS/* && cd ..
    cd $(tar -tf LibreOffice_"$VERSION"_Linux_x86-64_rpm_langpack_it.tar.gz|head -1) && sudo dnf -y localinstall RPMS/* && cd ..
    cd $(tar -tf LibreOffice_"$VERSION"_Linux_x86-64_rpm_helppack_it.tar.gz|head -1) && sudo dnf -y localinstall RPMS/* && cd $HOME
}

is_lo_upgradeable() {
    VERSIONE_INSTALLATA=$(dnf info installed|grep -A 2 libreoffice|grep Version|head -n 1|cut -d ":" -f 2|cut -c 2-7)
    VERSIONE_ONLINE=$(curl https://it.libreoffice.org/download/download/ 2>/dev/null|grep "version="|head -n 1|cut -d "&" -f 2|cut -d "=" -f 2)
    echo "VERSIONE INSTALLATA: $VERSIONE_INSTALLATA"
    echo "VERSIONE ONLINE:     $VERSIONE_ONLINE"
    [[ ${VERSIONE_INSTALLATA} == ${VERSIONE_ONLINE} ]] \
        && echo -e "Nessun aggiornamento disponibile." \
        || echo -e "Una nuova versione è disponibile.\n"
}

cleanup() {
    rm -r /tmp/tmp.*
}

remove_old_lo_suite() {
    sudo dnf -y remove libreoffice*
}

install() {
    VERSION=$1
    cd $(mktemp -d)
    ! download_lo_suite && { cleanup; exit ${ERROR_CODE}; }
    ! decomprimi_lo_suite && { cleanup; exit ${ERROR_CODE}; }
    ! remove_old_lo_suite && { cleanup; exit ${ERROR_CODE}; }
    install_lo_suite && cleanup || exit ${ERROR_CODE}?
}

noparam() {
    clear;
    usage
    exit 0
}

main() {
    while getopts "ui:h" opt; do
        case $opt in
            u ) is_lo_upgradeable ;;
            i ) install $OPTARG ;;
            h ) clear;usage; exit;;
            * ) clear;echo -e "[ERRORE] Opzione non valida.";usage; exit 1;;
        esac
    done
    shift $(($OPTIND - 1))
}

[[ $# -eq 0 ]] && noparam || main $*

#bash #libreoffice #scripting

In una giornata in cui avevo un po’ di tempo da investire, ho ripreso la versione 2 dello script “Generazione OTP via bash”, e ho deciso di renderlo un po’ più flessibile introducendo una logica crud. Anzi, il termine corretto dovrebbe essere “dave” (Delete, Add, View, Edit). Che altro aggiungere?

• Il file è ancora un insieme di coppie chiave-valore (nome account e chiave privata).
• Il separatore è il simbolo “:”. Ma può essere configurato cambiando il valore della variabile “DELIMITER”.
• Lo script è discretamente commentato così, in futuro, riuscirò a ricordare perché ho fatto quello che ho fatto (tipo “Memento”).
• Le opzioni di gpg per la cifratura/decifratura del file sono configurabili nello script modificando il valore delle variabili “GPG_ENC_OPTIONS” e “GPG_DEC_OPTIONS”.
• L’uso di getopts, mi rendo conto, è solo un esercizio di stile. Non è molto utile per come l’ho usato, visto che ogni optarg corrisponde ad un’operazione autoconclusiva.
• Ero partito per rimpiazzare ogni costrutto if con combinazioni di lista and / lista or ma le condizioni risultavano talmente complesse da rendere il codice francamente molto più incomprensibile di adesso. In alternativa avrei potuto delegare l’esecuzione delle condizioni ad un insieme di funzioni con una stratificazione tale da ricadere nel punto precedente: offuscamento permanente del codice che va a vanificare l’intenzione iniziale di semplificare il codice e renderlo più leggibile.

#!/usr/local/bin/bash


init() {
    # CODICI D'ERRORE
    DECRYPT_ERR=64
    INVALID_OPTION_ERR=65
    INVALID_ACCOUNT_ERR=66
    ACCOUNT_NOT_FOUND_ERR=67
    ACCOUNT_NAME_EMPTY_ERR=68
    ACCOUNT_EXISTS_ERR=69
    INVALID_KEY_ERR=70

    # Colorscheme
    LIGHT_GREEN='\033[1;32m'
    LIGHT_RED='\033[1;31m'
    NC='\033[0m'

    # Path del file cifrato contentente i codici 2FA
    KEYS_2FA_FILE="<path/file_enc.gpg>"

    # Separatore delle coppie chiave-valore
    DELIMITER=":"

    # path gpg e opzioni di cifratura/decifratura
    GPG_TTY=$(tty)
    export GPG_TTY

    #GPG_COMMAND="/usr/local/bin/gpg"
    GPG_ENC_OPTIONS="--yes -c --s2k-cipher-algo aes256 --s2k-digest-algo sha512 --s2k-mode 3 --s2k-count 260000 - "
    GPG_DEC_OPTIONS='-d'

    # Caratteri consentiti nel nome account
    PATTERN='^[a-zA-Z0-9._-]+$';

    # Su MacOS è disponibile "pbcopy", su *nix "xsel"
    case "$(sysctl hw.targettype 2>/dev/null)" in
        "")
            CLIPBOARD="xsel -bi"
            GPG_COMMAND="/usr/bin/gpg";;
         *)
            CLIPBOARD="pbcopy"
            GPG_COMMAND="/usr/local/bin/gpg";;
    esac

    # Decifra e carica in ram il contenuto del file cifrato.
    echo "Decifratura del file degli account in corso..."
    KEYS_2FA_FILE_DEC=$(${GPG_COMMAND} ${GPG_DEC_OPTIONS} "${KEYS_2FA_FILE}" 2>/dev/null)

    # Se la password non è corretta, restituisce un errore.
    [[ -z "${KEYS_2FA_FILE_DEC}" ]] && { err_msg "${DECRYPT_ERR}" 1; }
    info_msg "Fatto."
}


get_account() {
    ACCOUNT_STDIO="$1"

    # Check nome account vuoto
    [[ -z "${ACCOUNT_STDIO}" ]] && return "${ACCOUNT_NAME_EMPTY_ERR}"

    # Check caratteri invalidi nel nome account
    [[ ! "${ACCOUNT_STDIO}" =~ $PATTERN ]] && return "${INVALID_ACCOUNT_ERR}"

    # Estrae l'elemento contenente l'id dato in input
    OTP_LINE=$(echo "${KEYS_2FA_FILE_DEC}" | grep "${ACCOUNT_STDIO}:")

    # Se l'account non esiste, restituisce un errore
    [[ -z "${OTP_LINE}" ]] && return "${ACCOUNT_NOT_FOUND_ERR}"

    ACCOUNT=$(echo $OTP_LINE | cut -d"${DELIMITER}" -f 1)
    KEY=$(echo $OTP_LINE | cut -d"${DELIMITER}" -f 2)
}


crypt_account_file() {
    ACCOUNT_FILE="$1"
    echo -e "\nCifratura del file degli account in corso..."
    ${GPG_COMMAND} -o "$KEYS_2FA_FILE" ${GPG_ENC_OPTIONS} <<< $(echo -e "${ACCOUNT_FILE}")
}


no_param() {
    clear
    help
    exit 0
}


# Visualizza messaggi di errore su stdio
err_msg() {
    if [[ $# -ne 2 ]]; then
        echo -r"${LIGHT_RED}[DEBUG] [err_msg] Numero di parametri non corretto.${NC}."; exit 1
    else
        case $1 in
            "${DECRYPT_ERR}"            ) echo -e "${LIGHT_RED}[ERRORE] Impossibile decriptare il file.${NC}";;
            "${INVALID_OPTION_ERR}"     ) echo -e "${LIGHT_RED}[ERRORE] Opzione \"$OPTARG\" non valida.${NC}";;
            "${INVALID_ACCOUNT_ERR}"    ) echo -e "${LIGHT_RED}[ERRORE] Rilevati caratteri non consentiti.\nI caratteri ammessi sono: [a-z][A-Z][0-9].-_${NC}";;
            "${ACCOUNT_NOT_FOUND_ERR}"  ) echo -e "${LIGHT_RED}[ERRORE] Account non trovato${NC}";;
            "${ACCOUNT_NAME_EMPTY_ERR}" ) echo -e "${LIGHT_RED}[ERRORE] Nome account vuoto.${NC}";;
            "${ACCOUNT_EXISTS_ERR}"     ) echo -e "${LIGHT_RED}[ERRORE] Nome account già esistente${NC}";;
            "${INVALID_KEY_ERR}"        ) echo -e "${LIGHT_RED}[ERRORE] Chiave privata nulla o non corretta.\nLa chiave privata deve essere base32.\n${NC}";;
            *                           ) echo -e "${LIGHT_RED}[ERRORE] Errore generico.${NC}";;
        esac

        [[ $2 -eq 1 ]] && exit $2;
    fi
}


# Visualizza messaggi info su stdio
info_msg() {
    echo -e "${LIGHT_GREEN}$1${NC}"
}


continue_msg() {
    case $1 in
        "insert"    ) ACTION="creato";;
        "edit"      ) ACTION="modificato";;
        "delete"    ) ACTION="cancellato";;
    esac

    echo -n "L'account \"${ACCOUNT}\" sta per essere ${ACTION}. Vuoi continuare? [y|N]: "; read ANSWER;
}


continue_yn() {
        ANSWER="0"
        while [[ "${ANSWER}" != "y" ]]; do
            [[ -z "${ANSWER}" || "${ANSWER}" == "N" ]] && { echo "Operazione annullata"; exit; }
            [[ "${ANSWER}" != "y" || "${ANSWER}" != "N" ]] && continue_msg "$1"
        done
}


totp() {
    # Se la'ccount non esiste o è invalido, esco con errore
    get_account "$1"; RET_CODE=$?
    case "${RET_CODE}" in
        "${ACCOUNT_NOT_FOUND_ERR}"  ) err_msg "${ACCOUNT_NOT_FOUND_ERR}" 1;;
        "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 1;;
    esac

    echo -e "\nCopia OTP nella clipboard..."
    # Calcola l'otp e lo trasferisce nella clipboard con xsel
    oathtool --totp -b "${KEY}" | $CLIPBOARD
    info_msg "Fatto."
    exit
}


insert() {
    # Se l'account non esiste o è invalido, esco con errore
    get_account "$1"; RET_CODE=$?
    case "${RET_CODE}" in
        0                           ) err_msg "${ACCOUNT_EXISTS_ERR}" 1;;
        "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 1;;
    esac

    ACCOUNT="$1"

    # Inserisci la chiave
    echo -en "Nuovo account: ${ACCOUNT}\nInserisci la nuova chiave privata: "; read KEY
    while [[ -z "${KEY}" || ! $(echo ${KEY} | oathtool -b - 2>/dev/null) ]]; do
        err_msg "${INVALID_KEY_ERR}" 0
        echo -n "Inserisci la chiave privata: "; read KEY
    done

    info_msg "\nNuovo account:        ${ACCOUNT}\nNuova chiave privata: ${KEY}"
    continue_yn "insert"

    # Appendo il nuovo record nel file degli account
    KEYS_2FA_FILE_DEC+="\n${ACCOUNT}${DELIMITER}${KEY}"
    info_msg "L'account \"${ACCOUNT}\" è stato creato con successo."

    # Cifratura del file degli account
    crypt_account_file "${KEYS_2FA_FILE_DEC}"
    info_msg "Fatto."
    exit
}


edit() {
    # Se la'ccount non esiste o è invalido, esco con errore
    get_account "$1"; RET_CODE=$?
    case "${RET_CODE}" in
        "${ACCOUNT_NOT_FOUND_ERR}"  ) err_msg "${ACCOUNT_NOT_FOUND_ERR}" 1;;
        "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 1;;
    esac

    # Faccio una copia dell'account per un eventuale ripristino durante
    # la fase di input
    ACCOUNT_TEMP="${ACCOUNT}"
    ACCOUNT_MOD="${ACCOUNT}"

    # Inserisco il nuovo nome account.
    # 1. Se è vuoto: è la conferma dell'account inserito all'inizio e proseguo
    # 2. Se il nome è invalido: sollevo un'eccezione e reitero
    # 3. Se il nome è valido:
    #    a. Se è un nome nuovo: acquisisco il nuovo nome, recupero nome e chiave dell'account di partenza e proseguo
    #    b. Sè è lo stesso nome di partenza: è la conferma dell'account iniziale e proseguo
    #    c. Se è un altro nome esistente o invalido: come il punto 2.
    while true; do
        echo
        echo -en "Account: ${ACCOUNT}\nInserisci nuovo nome account: "; read ACCOUNT_MOD;
        get_account "${ACCOUNT_MOD}"; RET_CODE=$?
        case "${RET_CODE}" in
            # Punto 1.
            "${ACCOUNT_NAME_EMPTY_ERR}" ) ACCOUNT_MOD="${ACCOUNT}"; break;;
            # Punto 2
            "${INVALID_ACCOUNT_ERR}"    ) err_msg "${INVALID_ACCOUNT_ERR}" 0;;
            # Punto 3a.
            "${ACCOUNT_NOT_FOUND_ERR}"  ) get_account "${ACCOUNT_TEMP}"; break;;
            # Punti 3b e 3c, rispettivamente
            0                           ) [[ "${ACCOUNT_MOD}" == "${ACCOUNT_TEMP}" ]] && break \
                                                                                 || { get_account "${ACCOUNT_TEMP}"; err_msg "${ACCOUNT_EXISTS_ERR}" 0; };;
        esac
    done

    [[ "${ACCOUNT}" != "${ACCOUNT_MOD}" && ! -z "${ACCOUNT_MOD}" ]] && msg="\nL'account \"${ACCOUNT}\" è stato modificato in \"${ACCOUNT_MOD}\"." \
                                                                    || msg="\nNessuna modifica rilevata.\n"
    info_msg "${msg}"

    # Modifica la chiave privata
    KEY_MOD="${KEY}"
    echo

    while true; do
        echo -en "Chiave privata: ${KEY}\nInserisci la nuova chiave privata: "; read KEY_MOD
        if [[ -z $KEY_MOD ]]; then
            KEY_MOD="${KEY}"; break
        elif [[ ! $(echo "${KEY_MOD}" | oathtool -b - 2>/dev/null) ]]; then
            err_msg "${INVALID_KEY_ERR}" 0; KEY_MOD="${KEY}"
        else
            break
        fi
    done

    # Se c'è stata almeno una modifica (account/key), sovrascrivo il record. Altrimenti esco senza fare nulla.
    if [[ "${ACCOUNT}" != "${ACCOUNT_MOD}" || "${KEY}" != "${KEY_MOD}" ]]; then
        # Conferma modifica

        info_msg "\nAccount:              ${ACCOUNT}\nChiave privata:       ${KEY}\nNuovo account:        ${ACCOUNT_MOD}\nNuova chiave privata: ${KEY_MOD}\n"
        continue_yn "edit"

        # Modifica del file degli account
        KEYS_2FA_FILE_DEC_TEMP=$(sed "s/${ACCOUNT}${DELIMITER}${KEY}/${ACCOUNT_MOD}${DELIMITER}${KEY_MOD}/" <<< "${KEYS_2FA_FILE_DEC}")
        info_msg "L'account \"${ACCOUNT}\" è stato modificato con successo."

        # Cifratura del file degli account
        crypt_account_file "${KEYS_2FA_FILE_DEC_TEMP}"
    else
        info_msg "Nessuna modifica rilevata."
    fi
    info_msg "Fatto."
}


delete() {
    if get_account "$1"; then
        # Conferma eliminazione
        info_msg "\nAccount:              ${ACCOUNT}\nChiave privata:       ${KEY}\n"
        continue_yn "delete"

        # Cancellazione account
        KEYS_2FA_FILE_DEC_TEMP=$(sed "/$ACCOUNT/d" <<< "${KEYS_2FA_FILE_DEC}")
        info_msg "L'account \"$ACCOUNT\" è stato eliminato."

        # Cifratura del nuovo file degli account
        crypt_account_file "${KEYS_2FA_FILE_DEC_TEMP}"
        info_msg "Fatto."
    else
        err_msg "${ACCOUNT_NOT_FOUND_ERR}" 1
    fi
}


list() {
    echo
    while read LINE; do
        cut -d"${DELIMITER}" -f 1 <<< "${LINE}"
    done <<< "${KEYS_2FA_FILE_DEC}"
}


help() {
cat<<EOF
Usa come: ./totp.sh [options] ARG
dove:
    [options]
        -l restituisce la lista degli account.
        -t <nome_account> restituisce l'otp per quell'account.
        -i <nome_account> inserisce un nuovo account.
        -d <nome_account> cancella <nome_account>.
        -e <nome_account> modifica <nome_account>.
        -h stampa questa pagina di help.

ESEMPI:
    RESTITUISCE LA LISTA DEGLI ACCOUNT
    totp.sh -l

    INSERISCE UN ACCOUNT
    totp.sh -i dropbox

    CANCELLA UN ACCOUNT
    totp.sh -d megaupload

    MODIFICA UN ACCOUNT
    totp.sh -e paypal

    GENERA OTP
    totp.sh -t firefoxsync
EOF
}


main() {
    init
    while getopts "lt:i:e:d:" opt; do
        case $opt in
            l ) list ;;
            t ) totp $OPTARG ;;
            i ) insert $OPTARG ;;
            e ) edit $OPTARG ;;
            d ) delete $OPTARG ;;
            * ) clear;err_msg "${INVALID_OPTION_ERR}" 1;;
        esac
    done
    shift $(($OPTIND - 1))
}

[[ $# -eq 0 || $# -eq 1 && "$1" == "-h" ]] && no_param || main $*

#bash #totp #cryptography #gpg #scripting

Faccio un po’ d’ordine rispetto all’ultimo post.

brew ha “fattorizzato” la fase di aggiornamento.

Non sono più disponibili le istruzioni esplicite di gestione dei cask perché l’update / upgrade ora comprende formule e cask rendendo il tutto molto più coerente. Quindi:

• brew update : Aggiorna il database interno sulle nuove versioni disponibili per formule e cask
• brew upgrade : Aggiorna formule e cask
• brew upgrade --cask : Aggiorna solo i cask

Per quel che riguarda i cask, sappiamo che l’upgrade di brew prende in considerazione solo i cask che non dispongono della funzionalità di autoupdate o che hanno latest come versione.

Per forzare l’aggiornameno dei cask residui basta una singola istruzione:

brew upgrade --cask -n --greedy|tail -n +2|grep -v latest|cut -d " " -f 1|xargs brew upgrade --cask

• Aggiorna esplicitamente tutti i cask con autoupdate (esclusi i “latest”)

#brew #bash #macos #scripting

Sul Mac trovo comodo usare brew . Permette di gestire tante applicazioni con un gestore di pacchetti.

• Nota positiva: in generale, funziona bene, per quello che lo conosco.
• Nota negativa: in contraddizione col punto precedente, l’upgrade dei cask mi pare faccia cilecca ^[1]

In passato, eseguivo l’update / upgrade delle formule e l’upgrade dei cask. Col tempo, la gestione dei cask è diventata più omogenea con quella delle formule ma l’update / upgrade mi rimane ancora un po’ misterioso.

Eseguendo un brew update && brew upgrade, soprattutto dalle ultime versioni (dalla 3.0.7 in poi di sicuro), l’update sembra fare il suo lavoro e trova un po’ di cask aggiornare.

Càpita però che l’upgrade ne aggiorni qualcuno, un brew upgrade --cask ne aggiorni qualcun altro (senza raggiungere il totale iniziale) e provando a rifare l’update subito dopo (e anche l’upgrade) il sistema rimane intatto come se fosse up-to-date.

Agendo puntualmente sul cask invece, l’aggiornamento parte eccome. Come se fossero rimaste in cache delle informazioni discordanti sullo stato reale dell’applicazione e su quello potenziale.

Ho cercato un po’ in rete, sembra un problema comune.

Al solito, è partito lo script.

#!/usr/bin/bash
echo -e '\E[37;44m'"\033[1m***************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew update *\033[0m"
echo -e '\E[37;44m'"\033[1m***************\033[0m"
brew update
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew upgrade *\033[0m"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
if [[ -z $(brew upgrade) ]]; then
    echo -e "Nothing."
fi
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m***********************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew upgrade --cask *\033[0m"
echo -e '\E[37;44m'"\033[1m***********************\033[0m"
for c in $(brew list --cask -1); do
    printf %-30s "$c"
    info=$(brew info --cask "$c")
     
    current_ver=$(head -n1 <<< "$info" | cut -d " " -f 2)
    installed_ver=$(head -n3 <<< "$info" | tail -n1 | cut -d"/" -f 6 | cut -d " " -f 1)
     
    if [ "$installed_ver" != "$current_ver" ]; then
        answer=""
        while [[ -z $answer ]]; do
         
        read -r -p "$c installed version is '$installed_ver', but the current version is '$current_ver'. Do you want to upgrade $c? ["$'\e[;32;1mYES\e[0m/no] ' answer
 
        case ${answer,,} in
            yes|"")
                brew upgrade --cask --force $c
                answer="yes"
                ;;
            no)
                echo "Installation of $c $current_ver skipped"
                ;;
            *)
                answer=""
                ;;
            esac
        done
    else
        printf ": \033[38;5;70mis up-to-date (ver. $installed_ver)\033[0m\n"
    fi
done
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew cleanup *\033[0m"
echo -e '\E[37;44m'"\033[1m****************\033[0m"
if [[ -z $(brew cleanup) ]]; then
    echo -e "Nothing."
fi
 
 
echo -e "\n"
echo -e '\E[37;44m'"\033[1m***************\033[0m"
echo -e '\E[37;44m'"\033[1m* brew doctor *\033[0m"
echo -e '\E[37;44m'"\033[1m***************\033[0m"
brew doctor

Al di là dello zucchero sintattico, la soluzione è stata brutale e ruvida: un ciclo sulla lista dei cask con il force sull’upgrade (righe 21-50). La cosa ancora più singolare è che in questo modo vengono aggiornati dei cask che non risultavano nemmeno nel primo upgrade.

Sicuramente si potrà fare anche meglio. ^[2]

1. Ho provato a usare brew livecheck per recuperare più elegantemente le info nelle righe 25-26 ma mi dà qualche problema, ogni tanto va in crash. Ho optato per la scansione secca della lista.
2. Non so bene come lavori brew outdated, se soffra degli stessi problemi degli altri comandi (sospetto di sì ma devo verificare).
3. In realtà basterebbe una sola riga:

brew list --cask|xargs brew upgrade --cask

solo che così non riesco a controllare il numero di versione causando un aggiornamento quasi sempre inutile per tutti quei cask che hanno come versione “latest” (come Cisco Webex)

Lo script fa il suo lavoro ma ho trovato anche questa alternativa (decisamente più elegante): https://github.com/buo/homebrew-cask-upgrade

Un comando esterno, brew cu nella sua forma compatta, che sostituisce ed estende le funzionalità di brew upgrade. Avendo aggiornato da poco, non l’ho ancora visto all’opera.

Edit (31/03/2021):

In realtà, leggendo anche il man e il log dell’applicazione su stdout, ho capito che il funzionamento di brew è corretto.

upgrade e outadated prendono in esame solo i cask che non dispongono di autoupdate.

==> Casks with ‘auto_updates’ or ‘version :latest’ will not be upgraded; pass --greedy to upgrade them.

Un atteggiamento prudenziale che è facile comprendere. Laddove sia disponibile una funzionalità di autoupdate, si preferisce che sia l’applicazione stessa a gestire questo aspetto, lasciando a brew upgrade --cask (e ai file .rb di configurazione del cask, di conseguenza) la gestione di tutto il resto.

In questo modo, i cask che possono autoaggiornarsi, possono farlo in autonomia appena possibile, senza dipendere dalla modifica necessaria al file di configurazione che innesca l’aggiornamento.

Volendo bypassare questo comportamento, si può ricorrere all’opzione --greedy che forza l’upgrade sia per le app con autoupdate che per quelle che gestiscono il numero di versione con l’orrendo “latest”

Quindi:

brew outdated --greedy --cask

e

brew upgrade --greedy --cask

permettono rispettivamente:

• di elencare tutti i cask che necessitano di un aggiornamento, compresi quelli con autoupdate e con versione “latest”
• di forzare l’aggiornamento dei cask di cui sopra

Forzando l’aggiornamento in questo modo, si potrà andare incontro ad un disallineamento, tipo:

• sul sistema può essere presente una versione più aggiornata di quanto non dica il file di configurazione
• affidandosi all’autoupdate, l’opzione --greedy continuerà a rilevare comunque un aggiornamento da fare (ecco perché brew preferisce ignorare questo tipo di applicazioni)

N.B. brew cu funziona benissimo permettendo di gestire separatamente sia l’autoupdate che il latest

Note all’articolo

#brew #bash #macos #scripting

Questo script permette di scaricare le puntate intere di Ciao Belli o DeeJay Time da Deejay Reload perché le ascolto offline praticamente da sempre. In alternativa, è possibile ascoltare direttamente il live streaming delle trasmissioni. I pattern che uso per lo scraping sono molto elementari e sono ovviamente sensibili ai minimi cambiamenti che avvengono sulle pagine di Radio Deejay.

La versione attuale è attiva da un paio di mesi a questa parte perché il pattern prima era leggermente diverso. E più si va indietro, più le differenze aumentano. Per dirne una, lo streaming hls è molto recente, Prima di esso, il reload era disponibile solo in mp3. Questa sarà la 15^a versione dello script 🙂

Il download restituisce un file in mp3 o aac. Quest'ultimo ottenuto in maniera rudimentale estrando i singoli segmenti aac ottenuti dall'analisi della playlist hls e ricombinati attraverso ffmpeg.

In linea di principio sarebbe possibile estendere lo script aumentando la scelta delle trasmissioni disponibili e, volendo migliorare l'interazione con l'utente sacrificando l'automatismo e la “scriptabilità”, dotandolo di un menù.

help() {
    echo "$1"
    echo
    echo "Usa come: wget_deejay.sh <YYYYMMDD> <prg> <format>"
    echo "Es. wget_deejay.sh 2019062 cb mp3  [Scarica Ciao Belli in mp3]"
    echo "    wget_deejay.sh 2019062 djt aac [Scarica Deejay Time in aac]"
    echo "    wget_deejay.sh live            [Deejay Live]"
}



download() {
    if [[ ${FMT} == "mp3" || -z ${FMT} ]]; then
        if ! check_and_download_mp3; then
            return 1
        fi
    elif [[ ${FMT} == "aac" ]]; then
        if ! check_aac; then
            return 1
        else
            download_aac
        fi
    else
        help "Formato non corretto."
        return 1
    fi
}



check_and_download_mp3() {
    #if ! wget -q https://${HOST}/${DATA_URL}/episodes/${TITLE}/${DATA}.mp3 -O "${PRG}_${DATA}.mp3"; then
    echo https://${HOST}/${DATA_URL}/episodes/${TITLE}/${TITLE}-${DATA}.mp3
    if ! wget https://${HOST}/${DATA_URL}/episodes/${TITLE}/${TITLE}-${DATA}.mp3 -O "${PRG}_${DATA}.mp3"; then
        help "Puntata di ${TITLE} del ${ERR_DATA}, non trovata."
        return 1
    fi
}



check_aac() {
    #if ! wget -qO- https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-010000/hls-010000.m3u8 1>/dev/null; then
    echo https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-"${TITLE}"-"${DATA}"/hls-"${TITLE}"-"${DATA}".m3u8
    if ! wget -qO- https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-"${TITLE}"-"${DATA}"/hls-"${TITLE}"-"${DATA}".m3u8 1>/dev/null; then
        help "Puntata di ${TITLE} del ${ERR_DATA}, non trovata."
        return 1
    else
        return 0
    fi
}


download_aac() {
    echo -n "Scarico la traccia............. "
    ffmpeg -i https://${HOST}/"${DATA_URL}"/episodes/${TITLE}/hls-"${TITLE}"-"${DATA}"/hls-"${TITLE}"-"${DATA}".m3u8 -c copy $HOME/deejay/"${PRG}_${DATA}".aac 2>/dev/null
    echo "Fatto."

}


DATA=$1
PRG=$2
FMT=$3


if [[ $1 == "live" ]]; then
    mpv http://radiodeejay-lh.akamaihd.net/i/RadioDeejay_Live_1@189857/master.m3u8
else
    case "${PRG}" in
        "cb")
            HOST="media.deejay.it"
            TITLE="ciao_belli"
            ;;
        "djt")
            HOST="media.deejay.it"
            TITLE="deejay_time"

            ;;
        "live")
            TITLE="live"
            ;;
        *)
            help "Programma Deejay mancante o non esistente."
            exit 1
    esac


    DATA_URL="${DATA:0:4}/${DATA:4:2}/${DATA:6:2}"
    ERR_DATA="${DATA:6:2}-${DATA:4:2}-${DATA:0:4}"

    if [[ -z ${DATA:0:4} ]]; then help "Manca l'anno."; exit 1
    elif [[ -z ${DATA:4:2} ]]; then help "Manca il mese."; exit 1
    elif [[ -z ${DATA:6:2} ]]; then help "Manca il giorno."; exit 1
    elif ! download; then exit 1
    fi
fi

#bash #shell #scripting

Per buona parte del mio tempo sul pc apro una shell, per cui trovo comodo spostare il meno possibile le mani dalla tastiera. Usando spesso 2FA, ho pensato ad un modo per avere un OTP usando bash. Il tool che fa al caso mio è oathtool che, per i miei scopi, è sufficiente invocare in questo modo:

oathtool --totp -b <key>

dove <key> è una stringa base32 bella lunga.

Chiaramente non voglio doverla scrivere ogni volta, nè voglio lasciarla in chiaro. Occorre che:

1. la chiave sia cifrata e decifrata solamente quando occorre;
2. l'output non arrivi su stdout per non doverlo copiare a mia volta (e lasciarlo comunque visibile)

Al punto 1. si risponde con gpg o openssl.

Al punto 2. si risponde con xsel (Gnu/Linux) o pbcopy (MacOS) che trasferiscono l'output di un comando nella clipboard.

oathtool --totp -b <<< $(gpg -q --decrypt --pinentry-mode loopback <file_chiave_cifrato>) | xsel -bi

E veniamo quindi alla:

Versione 1

#!/bin/bash

# Path del file cifrato contentente la chiave # supponiamo sia di google
KEY_2FA_FILE="$1"

oathtool --totp -b <<< $(gpg -q --decrypt --pinentry-mode loopback "${KEY_2FA_FILE}") | xsel -bi

Non è nemmeno uno script. Potrebbe essere direttamente un alias.

VANTAGGI

• Estremamente compatto
• Si sfrutta nativamente l'autocomplete col TAB per i file da dare all'input
• L'univocità dei nomi è garantita dal file system

SVANTAGGI

• Crea un file per ogni codice e, alla lunga potrebbe generare confusione
• Necessità di creare una password di cifratura per ogni file (potenzialmente tutte diverse)

Versione 2

Mi occorre quindi un file nome-valore con separatore. Ad es. il simbolo “:”

account_1:JD88EIDIKJDKMDI3IEJDMDKJKDJKDKPA
account_2:JDNBLASPUQRIEKM89478JMFKOVJDOQKJ
account_3:OIJWGDVLOIQ94KDKSUD9KSLWOER9W3ODF
account_4:MVNMWIQPQYSKGPRIGNFG24KFG9E49RPWQ
    
    ...
    
account_n:IWPQSLNCGK49TOWODIR483IRIWOFOPIQO

Nello script, la variabile KEYS_2FA_FILE memorizza il full path del file cifrato dei codici, mentre l'account deve essere fornito in input. In caso contrario, viene restituita la lista degli account disponibili.

Se l'account è valido, il file viene decifrato e viene estratto il corrispondente codice che viene memorizzato direttamente nella clipboard.

#!/usr/bin/bash

# Path del file cifrato contentente i codici 2FA
KEYS_2FA_FILE="<path>/keys_2fa.gpg"

# Acquisisce il nome account
ACCOUNT=$1

# Decifra e carica in ram il contenuto del file cifrato
KEYS_2FA_FILE_DEC=$(gpg --decrypt  --pinentry-mode loopback  "${KEYS_2FA_FILE}" 2>/dev/null)

# Se non c'è nessun argomento, restituisce la lista degli account
if [[ -z "${ACCOUNT}" ]]; then
    while read LINE; do
        cut -d":" -f 1 <<< ${LINE}
    done <<< $(echo "${KEYS_2FA_FILE_DEC}")
    exit
else
    # Estrae l'elemento contenente l'id dato in input
    KEY=$(echo "${KEYS_2FA_FILE_DEC}" | grep ${ACCOUNT} | cut -d":" -f 2)

    # Se la chiave esiste, restituisce l'otp direttamente nella clipboard
    # altrimenti esce con errore
    if [[ -z "${KEY}" ]]; then
        echo "Account non esistente"
        exit 1
    else
        # Calcola l'otp e lo trasferisce nella clipboard con pbcopy
        oathtool --totp -b "${KEY}" | xsel -bi
        echo "Fatto."
    fi
fi

VANTAGGI

• Unico entry-point per la gestione degli account (un'unica password per la cifratura del file
• Più semplice da allocare

SVANTAGGI

• L'univocità degli account deve essere garantita dall'utente.
• Perdita della funzionalità di autocomplete in fase di inserimento dati

Provo ad esplorare anche una struttura differente, più espressiva se vogliamo. Invece di un file nome-valore, uso un json così strutturato:

Versione 3

{
  "accounts": [
    {
      "id": "account_1",
      "secret": "JD88EIDIKJDKMDI3IEJDMDKJKDJKDKPA"
    },
    {
      "id": "account_2",
      "secret": "JDNBLASPUQRIEKM89478JMFKOVJDOQKJ"
    },
    {
      "id": "account_3",
      "secret": "OIJWGDVLOIQ94KDKSUD9KSLWOER9W3ODF"
    },
    {
      "id": "account_4",
      "secret": "MVNMWIQPQYSKGPRIGNFG24KFG9E49RPWQ"
    },
    
    ...
    
    {
      "id": "account_n",
      "secret": "IWPQSLNCGK49TOWODIR483IRIWOFOPIQO"
    }
  ]
}

Un array, accounts, di oggetti nome-valore.

Lo script che fa il parsing e l'estrazione non è molto diverso dal precedente.

#!/usr/local/bin/bash

# Path del file cifrato contentente i codici 2FA
JSON_2FA_FILE=<path>/json_2fa.gpg

# Acquisisce il nome account
ACCOUNT=$1

# Carica in ram il contenuto del file json cifrato
JSON_2FA_FILE_DEC=$(gpg --decrypt  --pinentry-mode loopback  "${JSON_2FA_FILE}" 2>/dev/null)

# Se non c'è nessun argomento, restituisce la lista degli account
# - jq -c '.accounts[]' restituisce una lista contenenente tante linee per quanti sono gli elementi.
# - La lista viene data in pasto al ciclo while attraverso l'operatore <<< (here-string)
# - Da ogni linea viene estratto il valore del campo "id" sempre attraverso l'operatore <<<

if [[ -z "${ACCOUNT}" ]]; then
    while read LINE; do
        jq -r '.id' <<< ${LINE}
    done <<< $(echo "${JSON_2FA_FILE_DEC}" | jq -c '.accounts[]')
    exit
else
    # Estrae dall'array l'elemento contenente l'id dato in input
    KEY=$(jq -r --arg ID ${ACCOUNT} '.accounts[] | select(.id | contains($ID)).secret' <<< ${JSON_2FA_FILE_DEC})

    # Se la chiave esiste, restituisce l'otp direttamente nella clipboard
    # altrimenti esce con errore
    if [[ -z "${KEY}" ]]; then
        echo "Account non esistente"
        exit 1
    else
        # Calcola l'otp e lo trasferisce nella clipboard con xsel
        oathtool --totp -b "${KEY}" | xsel -bi
        echo "Fatto."
    fi
fi

#bash #otp #scripting #shell