PicciHud/mywiki
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Eliminato diversi file md

Browse Source
This commit is contained in:
piccihud 2024-11-23 16:58:39 +01:00
parent 8fa42bbe38
commit 49de36fa07
24 changed files with 0 additions and 2304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

264
container/snikket.md
View File

@ -1,264 +0,0 @@
# Snikket
Si tratta di un progetto che, tramite l'utilizzo di container Docker, permette di installare un servizio su un server fisico o virtuale per configurarlo in modo da riuscire a gestire autonomamente la messaggistica tramite il protocollo XMPP.
## DNS
```bash
# Domain TTL Class Type Target
chat.example.com. 300 IN A 203.0.113.123
groups.chat.example.com 300 IN CNAME chat.example.com.
share.chat.example.com 300 IN CNAME chat.example.com.
```
## Docker
```bash
apt update && apt upgrade
```
Per Debian, seguire le istruzioni alla pagina [ufficiale](https://docs.docker.com/install/linux/docker-ce/debian/). In particolare:
```bash
# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
# Add the repository to Apt sources:
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
# To install the latest version, run:
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
# Verify that the installation is successful by running the hello-world image:
sudo docker run hello-world
```
## Installazione di Snikket
```bash
mkdir /etc/snikket
cd /etc/snikket
# And then download our docker-compose.yml file:
curl -o docker-compose.yml https://snikket.org/service/resources/docker-compose
```
Quindi creare il file di configurazione di Snikket:
```bash
vim /etc/snikket
# The primary domain of your Snikket instance
SNIKKET_DOMAIN=chat.example.com
# An email address where the admin can be contacted
# (also used to register your Let's Encrypt account to obtain certificates)
SNIKKET_ADMIN_EMAIL=you@example.com
```
### Firewall
```bash
ufw default allow outgoing && ufw default deny incoming
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 5222/tcp
ufw allow 5269/tcp
ufw allow 5000/tcp
ufw allow 3478
ufw allow 3479
ufw allow 5349
ufw allow 5350
ufw allow 49152:65535/udp
```
Questo il risultato:
```bash
> ufw status numbered
Status: active
To Action From
-- ------ ----
[ 1] 22/tcp ALLOW IN Anywhere
[ 2] 80/tcp ALLOW IN Anywhere
[ 3] 443/tcp ALLOW IN Anywhere
[ 4] 5222/tcp ALLOW IN Anywhere
[ 5] 5269/tcp ALLOW IN Anywhere
[ 6] 5000/tcp ALLOW IN Anywhere
[ 7] 3478 ALLOW IN Anywhere
[ 8] 3479 ALLOW IN Anywhere
[ 9] 5349 ALLOW IN Anywhere
[10] 5350 ALLOW IN Anywhere
[11] 49152:65535/udp ALLOW IN Anywhere
[12] 1222/tcp (v6) ALLOW IN Anywhere (v6)
[13] 80/tcp (v6) ALLOW IN Anywhere (v6)
[14] 443/tcp (v6) ALLOW IN Anywhere (v6)
[15] 5222/tcp (v6) ALLOW IN Anywhere (v6)
[16] 5269/tcp (v6) ALLOW IN Anywhere (v6)
[17] 5000/tcp (v6) ALLOW IN Anywhere (v6)
[18] 3478 (v6) ALLOW IN Anywhere (v6)
[19] 3479 (v6) ALLOW IN Anywhere (v6)
[20] 5349 (v6) ALLOW IN Anywhere (v6)
[21] 5350 (v6) ALLOW IN Anywhere (v6)
[22] 49152:65535/udp (v6) ALLOW IN Anywhere (v6)
```
In particolare:
**TCP only**
|||
|--------|---------------------------------------------------------------------|
| 80/443 | Web Interface And Group File Sharing Service (HTTP(S)) |
| 5222 | Client App Connections (Client to Server) (XMPP-c2s) |
| 5269 | Federation With Other Snikket Servers (Server to Server) (XMPP-s2s) |
| 5000 | File Transfer Proxy (proxy65) |
**TCP and UDP**
|||
|-----------|------------------------------------------------------------------------------------|
| 3478/3479 | Audio/Video Data Proxy Negotiation and IP discovery (STUN/TURN) |
| 5349/5350 | Audio/Video Data Proxy Negotiations and IP Discovery over TLS (STUN/TURN over TLS) |
**UDP only**
|||
|-------------|-----------------------------------------------|
| 49152-65535 | Audio/Video Data Proxy (Turn Data, see below) |
Avviare il servizio col comando:
```bash
docker compose up -d
```
### Creazione utente admin
```bash
docker exec snikket create-invite --admin --group default
Viene generato un link utilizzabile una sola volta. Tutti gli altri utenti possono essere creati dal pannello di controllo una volta eseguito l’accesso.
```
## Troubleshooting
[https://snikket.org/service/help/setup/troubleshooting/](https://snikket.org/service/help/setup/troubleshooting/)
```bash
# Checking for errors
cd /etc/snikket
docker-compose exec snikket_certs cat /var/log/letsencrypt/errors.log
# Force the renewal of certificates
cd /etc/snikket
docker-compose exec snikket_certs su letsencrypt -- -c "certbot renew --config-dir /snikket/letsencrypt --cert-path /etc/ssl/certbot --force-renew"
```
## Analisi docker-compose.yml
```bash
> cat /etc/snikket/docker-compose.yml
version: "3.3"
services:
# nome del servizio
snikket_proxy:
container_name: snikket-proxy
image: snikket/snikket-web-proxy:beta
# file con le variabili
env_file: snikket.conf
# Se si usa la modalità di rete host per un container, lo stack di rete del container non è isolato dall'host e al container non viene assegnato un proprio indirizzo IP. Per esempio, se si esegue un container che si lega alla porta 80 e si usa la rete host, l'applicazione del container è disponibile sulla porta 80 dell'indirizzo IP dell'host.
network_mode: host
# I volumi memorizzano e gestiscono i dati persistenti generati dai container effimeri. Consentono la persistenza dei dati anche dopo la rimozione o l’aggiornamento di un container.
volumes:
# Il volume snikket_data viene montato nella directory /snikket del container snikket_proxy
- snikket_data:/snikket
- acme_challenges:/var/www/html/.well-known/acme-challenge
# La clausola restart: "unless-stopped" indica il comportamento di riavvio del servizio in caso di interruzione o arresto.
# Nel caso di restart: "unless-stopped", Docker riavvierà automaticamente il container a meno che non venga esplicitamente arrestato dall'utente. Questa opzione è utile per garantire che il servizio torni in esecuzione automaticamente dopo eventuali problemi o riavvii del sistema. Tuttavia, se l'utente decide di arrestare manualmente il container, questa istruzione impedisce il riavvio automatico.
restart: "unless-stopped"
snikket_certs:
container_name: snikket-certs
image: snikket/snikket-cert-manager:beta
env_file: snikket.conf
volumes:
- snikket_data:/snikket
- acme_challenges:/var/www/.well-known/acme-challenge
restart: "unless-stopped"
snikket_portal:
container_name: snikket-portal
image: snikket/snikket-web-portal:beta
network_mode: host
env_file: snikket.conf
restart: "unless-stopped"
snikket_server:
container_name: snikket
image: snikket/snikket-server:beta
network_mode: host
volumes:
- snikket_data:/snikket
env_file: snikket.conf
restart: "unless-stopped"
volumes:
acme_challenges:
snikket_data:
```
### cli dei volumi
```bash
> docker volume help
Usage: docker volume COMMAND
Manage volumes
Commands:
create Create a volume
inspect Display detailed information on one or more volumes
ls List volumes
prune Remove all unused local volumes
rm Remove one or more volumes
```
## Comandi docker compose (in riferimento ai volumi)
Docker Compose fornisce diversi comandi che aiutano a gestire in modo efficace l’applicazione e le sue risorse. Nel dettaglio questi comandi e il loro rapporto con i volumi:
- `docker compose up`: crea e avvia l’applicazione, compresi i servizi, le reti e i volumi. Se si definisce un volume denominato nel file docker-compose.yml prima che esista, questo comando lo creerà automaticamente.
- `docker compose down`: arresta e rimuove i servizi e le reti dell’applicazione. Per impostazione predefinita, non rimuove i volumi denominati. Per rimuovere i volumi denominati, usare il flag `--volumes` o `-v`.
- `docker compose ps`: elenca i container e il loro stato attuale, comprese le informazioni relative ai volumi.
- `docker compose config`: convalida e visualizza la configurazione effettiva generata dal file docker-compose.yml, comprese le definizioni dei volumi.
## Update Snikket
```bash
cd /etc/snikket
docker compose down
docker compose pull
docker compose up -d
```
Per maggiori dettagli: [https://snikket.org/service/help/setup/upgrading/](https://snikket.org/service/help/setup/upgrading/)
## Collegamenti
- [https://clarintuxmail.eu.org/articles/server3.html](https://clarintuxmail.eu.org/articles/server3.html)
- [https://snikket.org/service/quickstart/](https://snikket.org/service/quickstart/)
- [https://docs.lugbz.org/install-snikket.html](https://docs.lugbz.org/install-snikket.html)
- [https://wiki.xmpp-it.net/index.php/Installazione_di_un_server_Snikket](https://wiki.xmpp-it.net/index.php/Installazione_di_un_server_Snikket)
- [https://snikket.org/service/help/advanced/firewall/](https://snikket.org/service/help/advanced/firewall/)
- [https://snikket.org/](https://snikket.org/)

0
linux/ansible.md
View File

BIN
linux/asset/calcurse/calcurse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 103 KiB

153
linux/borg.md
View File

@ -1,153 +0,0 @@
# borgbackup
In Debian e derivate, installare il pacchetto col comando:
```bash
$ sudo apt install borgbackup -y
```
## Inizializzazione del repository
Per inizializzare il repository, criptato tramite una password:
```bash
$ borg init --encryption=keyfile /path/to/repo
```
## Backup
Per eseguire un backup manualmente
```bash
$ borg create --stats --list --progress /path/to/repo::25-11-2023 /path/to/source/
```
dove `--stats` permette di stampare statistiche aggiuntive sull'archivio, mentre l'opzione `--list` di visualizzare la lista degli oggetti inseriti nell'archivio.
Col flag `--compression` è possibile impostare anche il livello di compressione. Vedere: [Backup compression](https://borgbackup.readthedocs.io/en/stable/quickstart.html#backup-compression)
È possibile anche visualizzare la lista dei backup:
```bash
borg list /path/to/repo
```
## Restore
Per ripristinare un backup, nella cartella corrente:
```bash
$ borg extract -v --list /path/to/repo/::25-11-2023
```
L'opzione `--dry-run` permette di vedere cosa verrebbe estratto, ma senza che sia veramente estratto.
Ulteriori esempi:
```bash
# Extract entire archive
$ borg extract /path/to/repo::my-files
# Extract entire archive and list files while processing
$ borg extract --list /path/to/repo::my-files
# Verify whether an archive could be successfully extracted, but do not write files to disk
$ borg extract --dry-run /path/to/repo::my-files
# Extract the "src" directory
$ borg extract /path/to/repo::my-files home/USERNAME/src
# Extract the "src" directory but exclude object files
$ borg extract /path/to/repo::my-files home/USERNAME/src --exclude '*.o'
```
## Montare l'archivio
```bash
$ mkdir /tmp/borg/
$ borg mount /path/to/repo /tmp/borg/
$ ls -l /tmp/borg/
```
## Retention
Col comando `borg prune` è possibile stabilire una politica di conservazione dei backup ([https://borgbackup.readthedocs.io/en/stable/usage/prune.html](https://borgbackup.readthedocs.io/en/stable/usage/prune.html))
Ad esempio:
```bash
# Keep 7 end of day, 4 additional end of week archives, and an end of month archive for every month:
borg prune --list --stats --force --keep-daily=7 --keep-weekly=4 --keep-monthly=-1 /path/to/repo
borg prune -v /path/to/repo --stats \
--keep-hourly=12 --keep-daily=60 --keep-weekly=12 --keep-monthly=24
```
## Script
Ecco un semplice esempio:
```bash
#!/bin/bash
# Percorsi
REPO_PATH=/media/user/Backup/Snapshot/
DATA_PATH=~/
LOG_FILE=~/logs/borg_backup.log
export BORG_PASSPHRASE='*****************************************************'
# Inizializzazione di Borg
borg init --encryption=keyfile /media/user/Backup/Snapshot/
# Creazione del backup con Borg
if borg create --stats --list --progress --compression lz4 \
--exclude 'home/*/*.log.*' \
--exclude 'home/*/jd2/' \
--exclude-caches \
--exclude '*.deb' \
--exclude 'home/*/.cargo/' \
--exclude 'home/*/VirtualBoxVMs/' \
--exclude 'home/*/iso/' \
--exclude 'home/*/Trash/' \
$REPO_PATH::{now:'%H:%M_%d-%m-%Y'} $DATA_PATH; then
echo "$(date '+%H:%M:%S %d %b %Y'): Backup con Borg completato con SUCCESSO." >> $LOG_FILE
else
echo "$(date '+%H:%M:%S %d %b %Y'): ERRORE durante la creazione del backup con Borg." >> $LOG_FILE
exit 1
fi
# This command frees repository space by compacting segments
borg compact $REPO_PATH
# Pulizia del repository
# Keep 7 end of day, 4 additional end of week archives, and an end of month archive for every month:
borg prune --list --stats --force \
--keep-daily=7 --keep-weekly=4 --keep-monthly=-1 $REPO_PATH && borg list $REPO_PATH >> $LOG_FILE
exit 0;
```
Per il montaggio:
```bash
#! /bin/bash
# Configurazione
export BORG_PASSPHRASE='***********************************************************'
REPO_PATH="/media/user/Backup/Snapshot"
TMP_DIR="/tmp/borg"
# Creazione della directory temporanea
mkdir -p $TMP_DIR 2> /dev/null
borg mount $REPO_PATH $TMP_DIR && ls -l $TMP_DIR
exit 0
```
## Collegamenti
- [https://borgbackup.readthedocs.io/en/stable/quickstart.html#automating-backups](https://borgbackup.readthedocs.io/en/stable/quickstart.html#automating-backups)
- [https://ostechnix.com/backup-restore-files-borg-linux/](https://ostechnix.com/backup-restore-files-borg-linux/)
- [https://wiki.archlinux.org/title/Borg_backup](https://wiki.archlinux.org/title/Borg_backup)

154
linux/calcurse.md
View File

@ -1,154 +0,0 @@
# Calcurse
Calcurse è un calendario e un'applicazione di pianificazione per la riga di comando. Aiuta a tenere traccia di eventi, appuntamenti e attività quotidiane. Supporta la sincronizzazione tramite protocollo
CalDAV.
Maggiori informazioni: [Calcurse](https://calcurse.org/)
## Installazione
```bash
cd ~
wget -c https://calcurse.org/files/calcurse-4.8.0.tar.gz
```
Quindi procedere coi seguenti comandi:
```bash
tar xvf calcurse-4.8.0.tar.gz
cd calcurse-4.8.0/
# Se non presente, installare la seguente libreria
# sudo apt install install libncursesw5-dev
./configure
make
sudo make install
```
Ora è possibile eseguire il programma:
```bash
calcurse
```
Premendo il tasto `C` si accede alla configurazione.
```bash
cat ~/.calcurse/conf
appearance.calendarview=monthly
appearance.compactpanels=no
appearance.defaultpanel=calendar
appearance.layout=4
appearance.headerline=yes
appearance.eventseparator=yes
appearance.dayseparator=yes
appearance.emptyline=yes
appearance.emptyday=--
appearance.notifybar=yes
appearance.sidebarwidth=3
appearance.theme=magenta on default
appearance.todoview=hide-completed
appearance.headingpos=right-justified
daemon.enable=no
daemon.log=no
format.inputdate=1
format.notifydate=%a %F
format.notifytime=%T
format.outputdate=%D
format.dayheading=%B %e, %Y
general.autogc=no
general.autosave=yes
general.confirmdelete=yes
general.confirmquit=yes
general.firstdayofweek=monday
general.multipledays=yes
general.periodicsave=0
general.systemevents=yes
notification.command=printf '\a'
notification.notifyall=flagged-only
notification.warning=300
format.appointmenttime=%H:%M
```
## Configurazione
```bash
cd ~
calcurse -C .calcurse/
cd .calcurse/caldav/
vim config
[General]
Binary = calcurse
Hostname = murena.io
Path = /remote.php/dav/calendars/login@e.email/personal
AuthMethod = basic
InsecureSSL = No
HTTPS = Yes
SyncFilter = cal,todo
DryRun = No
Verbose = No
[Auth]
Username = user@e.email
Password = *******************
# Quindi abilitare la sincronizzazione
calcurse-caldav --init=two-way
```
### Sincronizzazione
Le modifiche vengono caricate in remoto e scaricate in locale col comando:
```bash
calcurse-caldav
```
Per la sincronizzazione automatica è possibile abilitare un cronjob ogni 5 minuti, oppure crearsi un alias, in questo modo:
```bash
cd ~
vim .bashrc
alias cc="calcurse-caldav >> ~/calcurse.log && calcurse -q"
source .bashrc
```
oppure:
```
crontab -e
*/5 * * * * echo -e "\n" >> ~/calcurse.log && date >> ~/calcurse.log && calcurse-caldav >> ~/calcurse.log
```
![calcurse](./asset/calcurse/calcurse.png)
## Comandi rapidi
```bash
calcurse -a # stampa gli appuntamenti del giorno
calcurse -d n # stampa gli appuntamenti da oggi e per gli "n" giorni successivi
calcurse -d 3
calcurse -d gg/mm/aaaa # stampa gli appuntamenti per uno specifico giorno ù
calcurse -d 13/12/2022
calcurse -n # stampa il prossimo appuntamento entro le 24 ore (quello più vicino)
calcurse -t(n) # stampa la lista delle attività. Opzionalmente si può indicare il livello di priorità
calcurse t2 # stampa attività di priorità 2)
```
## Collegamenti
- [https://community.e.foundation/t/calendar-sync-ecloud-x-calcurse-calcurse-caldav/33134](https://community.e.foundation/t/calendar-sync-ecloud-x-calcurse-calcurse-caldav/33134)
- [https://calcurse.org/files/calcurse-caldav.html](https://calcurse.org/files/calcurse-caldav.html)
- [https://calcurse.org/files/manual.html](https://calcurse.org/files/manual.html)
- [https://github.com/lfos/calcurse/issues/301](https://github.com/lfos/calcurse/issues/301)
- [https://github.com/lfos/calcurse/blob/pu/contrib/caldav/config.sample](https://github.com/lfos/calcurse/blob/pu/contrib/caldav/config.sample)
- [https://github.com/lfos/calcurse](https://github.com/lfos/calcurse)

49
linux/chroot.md
View File

@ -1,49 +0,0 @@
# chroot
Un chroot è un'operazione che cambia la directory radice per il processo in esecuzione e i suoi figli. Questo ambiente modificato è chiamato chroot jail.
Il cambio di root viene comunemente effettuato per eseguire la manutenzione su sistemi in cui l'avvio e/o l'accesso non sono più possibili. Esempi comuni sono:
- Reinstallazione del boot loader;
- Ricostruzione dell'immagine initramfs;
- Ripristino di una password dimenticata.
## Procedura
- avviare una live;
- montare la partizione danneggiata, nella quale risiede il sistema, nella cartella `/mnt`;
- se le cartelle `/boot` o `/var` si trovassero in una partizione separata è necessario montarle dentro la cartella `/mnt`, ad esempio:
```bash
sudo mount /dev/sda3 /mnt/var
sudo mount /dev/sda1 /mnt/boot
```
- montare i restanti device:
```bash
sudo mount --bind /dev /mnt/dev # sudo mount --rbind /dev /mnt/dev
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys /mnt/sys
```
- Il parametro `--bind` fa sì che i contenuti di /dev siano accessibili anche in /mnt/dev
- L'approccio con `--rbind` è più flessibile perché monta ricorsivamente tutto il contenuto della directory specificata, mentre `--bind` monta solo la directory stessa;
- Se si utilizza un sistema UEFI, è necessario accedere anche alle variabili EFI:
```bash
sudo mount --rbind /sys/firmware/efi/efivars sys/firmware/efi/efivars/
```
- Lanciare il comando chroot specificando la cartella di destinazione e la shell da usare
```bash
sudo chroot /mnt /bin/bash
```
- Nel caso si volesse riparare la configurazione del bootloader:
```bash
sudo grub-install
sudo update-grub2
```
## Collegamenti
- [https://wiki.archlinux.org/title/Chroot](https://wiki.archlinux.org/title/Chroot)
- [https://informatizzati.org/?view=article&id=341:accesso-ad-una-installazione-di-linux-con-chroot](https://informatizzati.org/?view=article&id=341:accesso-ad-una-installazione-di-linux-con-chroot)
- [https://wiki.ubuntu-it.org/AmministrazioneSistema/Chroot](https://wiki.ubuntu-it.org/AmministrazioneSistema/Chroot)

41
linux/cli/chatgpt.md
View File

@ -1,41 +0,0 @@
# tgpt
`tgpt` è uno programma cli multipiattaforma che consente di utilizzare ChatG
PT 3.5 senza API KEY.
## Installazione e aggiornamento
```bash
curl -sSL https://raw.githubusercontent.com/aandrew-me/tgpt/main/install | bash -s /usr/local/bin
```
## Sintassi
```bash
> tgpt -h
Usage: tgpt [Flag] [Prompt]
Flags:
-s, --shell Generate and Execute shell commands. (Experimental)
-c, --code Generate Code. (Experimental)
Options:
-f, --forget Forget Chat ID
-v, --version Print version
-h, --help Print help message
-i, --interactive Start normal interactive mode
-m, --multiline Start multi-line interactive mode
-cl, --changelog See changelog of versions
-u, --update Update program
Examples:
tgpt "What is internet?"
tgpt -f
tgpt -m
tgpt -s "How to update my system?"
```
## Collegamenti
- [https://github.com/aandrew-me/tgpt](https://github.com/aandrew-me/tgpt)

122
linux/cli/ddg.md
View File

@ -1,122 +0,0 @@
# ddgr
Si tratta di un utility da linea di comando per ricercare su DuckDuckgo.
## Installazione
```bash
cd
mkdir git/
cd git/
git clone https://github.com/jarun/ddgr.git
cd ddgr/
sudo make install
```
## Sintassi
```bash
usage: ddgr [-h] [-n N] [-r REG] [--colorize [{auto,always,never}]] [-C]
[--colors COLORS] [-j] [-t SPAN] [-w SITE] [-x] [-p URI]
[--unsafe] [--noua] [--json] [--gb] [--np] [--url-handler UTIL]
[--show-browser-logs] [-v] [-d]
[KEYWORD [KEYWORD ...]]
DuckDuckGo from the terminal.
positional arguments:
KEYWORD search keywords
optional arguments:
-h, --help show this help message and exit
-n N, --num N show N (0<=N<=25) results per page (default 10); N=0
shows actual number of results fetched per page
-r REG, --reg REG region-specific search e.g. 'us-en' for US (default);
visit https://duckduckgo.com/params
--colorize [{auto,always,never}]
whether to colorize output; defaults to 'auto', which
enables color when stdout is a tty device; using
--colorize without an argument is equivalent to
--colorize=always
-C, --nocolor equivalent to --colorize=never
--colors COLORS set output colors (see man page for details)
-j, --ducky open the first result in a web browser; implies --np
-t SPAN, --time SPAN time limit search [d (1 day), w (1 wk), m (1 month), y (1 year)]
-w SITE, --site SITE search sites using DuckDuckGo
-x, --expand Show complete url in search results
-p URI, --proxy URI tunnel traffic through an HTTPS proxy; URI format:
[http[s]://][user:pwd@]host[:port]
--unsafe disable safe search
--noua disable user agent
--json output in JSON format; implies --np
--gb, --gui-browser open a bang directly in gui browser
--np, --noprompt perform search and exit, do not prompt
--rev, --reverse list entries in reversed order
--url-handler UTIL custom script or cli utility to open results
--show-browser-logs do not suppress browser output (stdout and stderr)
-v, --version show program's version number and exit
-d, --debug enable debugging
omniprompt keys:
n, p, f fetch the next, prev or first set of search results
index open the result corresponding to index in browser
o [index|range|a ...] open space-separated result indices, ranges or all
O [index|range|a ...] like key 'o', but try to open in a GUI browser
d keywords new DDG search for 'keywords' with original options
should be used to search omniprompt keys and indices
x toggle url expansion
c index copy url to clipboard
q, ^D, double Enter exit ddgr
? show omniprompt help
* other inputs are considered as new search keywords
```
## Configurazione
Alias per la ricerca in italiano:
```bash
alias dd='ddgr --colorize always --reg it-it'
```
## Utilizzo
```bash
> dd Wikipedia Linux
1. Linux [it.wikipedia.org]
GNU/Linux, comunemente noto come Linux, è una famiglia di sistemi operativi liberi e open source di tipo
Unix-like, pubblicati in varie distribuzioni, aventi la caratteristica comune di utilizzare come nucleo il
kernel Linux: oggi molte importanti società nel campo dell'informatica come: Google, Microsoft, Amazon, IBM,
Oracle, Hewlett-Packard ...
2. Linux [en.wikipedia.org]
Linux (/ ˈ l iː n ʊ k s / LEE-nuuks or / ˈ l ɪ n ʊ k s / LIN-uuks) is a family of open-source Unix-like
operating systems based on the Linux kernel, an operating system kernel first released on September 17, 1991,
by Linus Torvalds. Linux is typically packaged as a Linux distribution, which includes the kernel and
supporting system software and libraries, many of which are provided by ...
3. Distribuzione Linux [it.wikipedia.org]
Una distribuzione Linux, in informatica, è una distribuzione software di un sistema operativo realizzato a
partire dal kernel Linux, un sistema di base GNU e solitamente anche diversi altri applicativi. Tali
distribuzioni appartengono quindi alla sottofamiglia dei sistemi operativi GNU e, più in generale, alla
famiglia dei sistemi ...
```
Premere il numero corrispondente per aprire il collegamento nel browser predefinito dal sistema.
### bang
```bash
> ddgr \!amazonit emacs manuale
```
e viene immediatamente aperta la rispettiva ricerca nel browser. Per la lista completa delle `bangs`:
[https://duckduckgo.com/bangs](https://duckduckgo.com/bangs)
## Collegamenti
- [https://github.com/jarun/ddgr](https://github.com/jarun/ddgr)

100
linux/diff.md
View File

@ -1,100 +0,0 @@
# Confrontare file
Il comando `diff` confronta due file e produce una lista delle loro differenze. Per essere più precisi, produce un elenco delle modifiche che dovrebbero essere apportate al primo file, per farlo corrispondere al secondo file.
```bash
diff file1 file2
```
Ecco un esempio:
```bash
> cat file1
file1
> cat file2
file2
file3
file1
> diff file1 file2
0a1,2
> file2
> file3
```
Ogni differenza è elencata a sua volta in una singola colonna e ogni differenza viene etichettata. L'etichetta è composta da due numeri che circondano una lettera, come nell'esempio `0a1`.
Il primo numero è il numero di riga in file1, e il secondo numero è il numero di riga in file2. La lettera nel mezzo può essere:
- `c`: la riga nel primo file deve essere modificata per corrispondere alla riga nel secondo file;
- `d`: la riga nel primo file deve essere eliminata;
- `a`: il contenuto extra deve essere aggiunto al primo file per farlo corrispondere al secondo file.
I parametri `-s` e `-q` indicano, rispettivamente, se i due file sono identici ovvero differenti:
```bash
> diff -s file2 file3
I file file2 e file3 sono identici
> diff -q file1 file2
I file file1 e file2 sono diversi
```
## Una vista alternativa
```bash
> diff -y -W 70 file1 file3
> file2
file5 | file3
file1 file1
file4 <
```
L'opzione `-y` (side by side) utilizza un layout diverso per mostrare le differenze tra i file. Spesso è conveniente specificare la larghezza `-W` per limitare il numero di colonne visualizzate.
Il primo file viene visualizzato a sinistra mentre il secondo è mostrato sulla destra. Le righe di ogni file vengono visualizzate fianco a fianco.
Ci sono caratteri indicatori accanto alle varie righe:
- `|`: una riga che è differente nel secondo file;
- `<`: una riga che non è presente nel secondo file;
- `>`: una riga che non è presente nel primo file
## Uno spruzzo di colore
```bash
sudo apt-get install colordiff
```
Il comando `colordiff` aggiunge colore all'output di `diff`.
## Confrontare directories
Il comando diff permette anche di confrontare cartelle tra loro. La sintassi è molto semplice:
```bash
diff -r dir1 dir2
```
Vengono mostrati i nomi dei file/directories differenti e le differenze tra i files. Con l'opzione `-q` viene mostrato solo il nome dei files diversi.
```bash
ls -R
.:
dir1 dir2
./dir1:
file1
./dir2:
colordiff -rq dir1 dir2
Solo in dir1: file1
```
## Vimdiff
Per chi utilizza vim, esiste `vimdiff` [https://linuxhandbook.com/vimdiff/](https://linuxhandbook.com/vimdiff/).
## Collegamenti
- [https://www.howtogeek.com/410532/how-to-compare-two-text-files-in-the-linux-terminal/](https://www.howtogeek.com/410532/how-to-compare-two-text-files-in-the-linux-terminal/)
- [https://linuxhandbook.com/compare-directories/](https://linuxhandbook.com/compare-directories/)
- [https://youtu.be/Eb8S_KkmLS8](https://youtu.be/Eb8S_KkmLS8)

19
linux/epson_wf2510.md
View File

@ -1,19 +0,0 @@
# Epson WF2510
Qui i driver: [Epson WF2510](https://download.ebz.epson.net/dsc/search/01/search/searchModule)
## Installazione
```bash
> sudo apt install ./epson-inkjet-printer-escpr_1.7.21-1lsb3.2_amd64.deb
Lettura elenco dei pacchetti... Fatto
Generazione albero delle dipendenze
Lettura informazioni sullo stato... Fatto
È utile eseguire "apt --fix-broken install" per correggere ciò.
I seguenti pacchetti hanno dipendenze non soddisfatte:
epson-inkjet-printer-escpr : Dipende: lsb (>= 3.2) ma non è installato
E: Dipendenze non soddisfatte. Provare "apt --fix-broken install" senza pacchetti (o specificare una soluzione).
> sudo apt --fix-broken install
```

143
linux/find.md
View File

@ -1,143 +0,0 @@
# find
Il comando **find** permette di cercare files e non solo da riga di comando.
Se il percorso del file non è specificato, viene ricercato nella directory corrente e nelle sue sottodirectory.
Questa la sua struttura generale:
```bash
find path pattern
```
## Ricercare un file per nome
```bash
find -iname abc.txt
```
In questo modo, viene cercato il file abc.txt (-i sta per insensitive) nella cartella corrente.
### Specificare il tipo del pattern
```bash
find /etc -type f -name "*.conf"
```
dove il tipo del file può essere:
| -type | Descrizione |
|-------|-------------|
| f | File |
| d | Directory |
| l | Link |
## Ricercare in più cartelle
```bash
find ~/Desktop/example1/ ~/Desktop/example2/ -name 'abc*.*'
```
## size
Ricercare solo file più grandi di...
```bash
find -size +2000M
```
## Esclusione di alcuni file dalla ricerca
Il comando find può anche escludere alcuni tipi di file dal risultato della ricerca:
```bash
find -name '*abc*' -type f \( ! -name '*.msi' \)
```
Nell'esempio, vengono esclusi tutti i file *\*abc\*.msi*
## exec
È possibile eseguire comandi sui risultati di find.
La sintassi di base per eseguire la ricerca con exec è la seguente:
```bash
find [path] [arguments] -exec [command] {} \;
```
- *[comand]* il comando da eseguire;
- *{}* è un segnaposto per i risultati dati dal comando find;
- *\;* che per ogni risultato trovato, il [comand] viene eseguito, ossia, come se fossero passati in questo modo:
```bash
ls file1.txt
ls file2.txt
ls file3.txt
```
### Alcuni esempi
Rinominare i file
```bash
> sudo find . -type f -name file\* -exec ls -l {} \;
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file2.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file7.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file4.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file8.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file10.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file1.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file9.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file5.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file3.txt
-rw-r--r-- 1 davide davide 0 9 apr 15.50 ./file6.txt
> sudo find . -type f -name file\* -exec mv {} {}_renamed \;
> ll
Permissions Size User Date Modified Name
.rw-r--r-- 0 davide 9 apr 15:50  file1.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file2.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file3.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file4.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file5.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file6.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file7.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file8.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file9.txt_renamed
.rw-r--r-- 0 davide 9 apr 15:50  file10.txt_renamed
```
Eliminare i file più grandi di...
```bash
find ~/Desktop -size +100M -exec rm {} \;
```
Modificare proprietario dei file:
```bash
> sudo find . -type f -name file\* -exec chown root:root {} \;
> ll
Permissions Size User Date Modified Name
.rw-r--r-- 0 root 9 apr 15:50  file1.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file2.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file3.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file4.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file5.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file6.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file7.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file8.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file9.txt_renamed
.rw-r--r-- 0 root 9 apr 15:50  file10.txt_renamed
```
Eliminare tutti i file corrispondenti ad un pattern di ricerca:
```bash
> sudo find . -type f -name file\* -exec rm -rf {} \;
> ll
```
## Collegamenti
- [https://linuxhandbook.com/find-files-by-name/](https://linuxhandbook.com/find-files-by-name/)
- [https://linuxhandbook.com/find-exec-command/](https://linuxhandbook.com/find-exec-command/)
- [https://www.ionos.it/digitalguide/server/configurazione/comando-find-di-linux/](https://www.ionos.it/digitalguide/server/configurazione/comando-find-di-linux/)

272
linux/processes.md
View File

@ -1,272 +0,0 @@
# Monitorare i processi di sistema
Il comando `ps` visualizza un elenco dei processi avviati dall'utente che ha eseguito il comando.
```bash
ps
PID TTY TIME CMD
59401 pts/2 00:00:00 bash
59409 pts/2 00:00:00 ps
```
Le quattro colonne sono:
- `PID`: il numero ID del processo;
- `TTY`: il nome della shell a cui l'utente è connesso;
- `TIME`: il tempo di elaborazione della CPU utilizzato dal processo;
- `CMD`: il nome del comando che ha avviato il processo
Con l'opzione `-e` vengono elencati i processi di tutti gli utenti:
```bash
ps -e | less
PID TTY TIME CMD
1 ? 00:00:02 systemd
2 ? 00:00:00 kthreadd
3 ? 00:00:00 rcu_gp
4 ? 00:00:00 rcu_par_gp
5 ? 00:00:00 slub_flushwq
6 ? 00:00:00 netns
8 ? 00:00:00 kworker/0:0H-events_highpri
10 ? 00:00:00 mm_percpu_wq
11 ? 00:00:00 rcu_tasks_kthread
12 ? 00:00:00 rcu_tasks_rude_kthread
13 ? 00:00:00 rcu_tasks_trace_kthread
14 ? 00:00:00 ksoftirqd/0
15 ? 00:00:16 rcu_preempt
```
## Gerarchia dei processi
È possibile vedere quali processi ne hanno avviati altri con l'opzione `-H` (hierarchy). La rientranza indica i processi figli:
```bash
ps -eH | less
PID TTY TIME CMD
945 ? 00:00:00 sddm
971 tty7 00:13:47 Xorg
1398 ? 00:00:00 sddm-helper
1431 ? 00:00:00 startplasma-x11
1507 ? 00:00:00 ssh-agent
1618 ? 00:00:00 plasma_session
1658 ? 00:08:12 kwin_x11
1694 ? 00:00:03 ksmserver
1718 ? 00:03:31 plasmashell
1720 ? 00:00:03 kaccess
1721 ? 00:00:01 xembedsniproxy
1722 ? 00:00:03 org_kde_powerde
1723 ? 00:00:02 polkit-kde-auth
1737 ? 00:00:01 gmenudbusmenupr
1742 ? 00:00:03 DiscoverNotifie
1758 ? 00:00:02 kalendarac
1763 ? 00:00:10 nextcloud
1773 ? 00:00:00 agent
956 ? 00:00:00 sshd
```
L'opzione `--forest` aggiunge chiarezza nella visualizzazione della parentela:
```bash
ps -eH --forest | less
PID TTY TIME CMD
945 ? 00:00:00 sddm
971 tty7 00:13:54 \_ Xorg
1398 ? 00:00:00 \_ sddm-helper
1431 ? 00:00:00 \_ startplasma-x11
1507 ? 00:00:00 \_ ssh-agent
1618 ? 00:00:00 \_ plasma_session
1658 ? 00:08:17 \_ kwin_x11
1694 ? 00:00:03 \_ ksmserver
1718 ? 00:03:34 \_ plasmashell
1720 ? 00:00:03 \_ kaccess
1721 ? 00:00:02 \_ xembedsniproxy
1722 ? 00:00:03 \_ org_kde_powerde
1723 ? 00:00:02 \_ polkit-kde-auth
1737 ? 00:00:02 \_ gmenudbusmenupr
1742 ? 00:00:03 \_ DiscoverNotifie
1758 ? 00:00:02 \_ kalendarac
1763 ? 00:00:10 \_ nextcloud
1773 ? 00:00:00 \_ agent
956 ? 00:00:00 sshd
```
## Ottenere più informazioni
Utilizzando l'opzione `-F` (extra full-format) vengono mostrate più colonne e quindi maggiori informazioni:
```bash
UID PID PPID C SZ RSS PSR STIME TTY TIME CMD
root 1 0 0 44388 11208 1 08:14 ? 00:00:02 /lib/systemd/systemd splash --system --deserialize 17
root 2 0 0 0 0 1 08:14 ? 00:00:00 [kthreadd]
root 3 2 0 0 0 0 08:14 ? 00:00:00 [rcu_gp]
root 4 2 0 0 0 0 08:14 ? 00:00:00 [rcu_par_gp]
root 5 2 0 0 0 0 08:14 ? 00:00:00 [slub_flushwq]
root 6 2 0 0 0 0 08:14 ? 00:00:00 [netns]
root 8 2 0 0 0 0 08:14 ? 00:00:00 [kworker/0:0H-events_highpri]
root 10 2 0 0 0 0 08:14 ? 00:00:00 [mm_percpu_wq]
root 11 2 0 0 0 0 08:14 ? 00:00:00 [rcu_tasks_kthread]
root 12 2 0 0 0 0 08:14 ? 00:00:00 [rcu_tasks_rude_kthread]
root 13 2 0 0 0 0 08:14 ? 00:00:00 [rcu_tasks_trace_kthread]
root 14 2 0 0 0 0 08:14 ? 00:00:01 [ksoftirqd/0]
root 15 2 0 0 0 2 08:14 ? 00:00:17 [rcu_preempt]
root 16 2 0 0 0 0 08:14 ? 00:00:00 [migration/0]
root 18 2 0 0 0 0 08:14 ? 00:00:00 [cpuhp/0]
root 19 2 0 0 0 1 08:14 ? 00:00:00 [cpuhp/1]
```
Le colonne visualizzate ora sono:
- `UID`: l'ID utente del proprietario del processo;
- `PID`: l'ID del processo;
- `PPID`: ID del processo genitore;
- `C`: il numero di figli;
- `PSR`: il processore (cpu) a cui è assegnato il processo;
- `STIME`: ora di inizio. Il momento in cui è iniziato il processo;
- `TTY`: il nome della shell a cui l'utente è connesso;
- `TIME`: il tempo di elaborazione della CPU utilizzato dal processo;
- `CMD`: il nome del comando che ha avviato il processo
## Vedere processi di un particolare utente
Per vedere i processi di un particolare utente:
```bash
ps -u davide
PID TTY TIME CMD
1400 ? 00:00:00 systemd
1401 ? 00:00:00 (sd-pam)
1417 ? 00:00:13 pipewire
1418 ? 00:00:01 wireplumber
1419 ? 00:00:15 pipewire-pulse
1420 ? 00:00:12 dbus-daemon
1430 ? 00:00:02 kwalletd5
1431 ? 00:00:00 startplasma-x11
1507 ? 00:00:00 ssh-agent
1524 ? 00:01:03 ibus-daemon
1527 ? 00:00:00 ibus-dconf
1529 ? 00:00:10 ibus-ui-gtk3
1530 ? 00:00:09 ibus-extension-
1532 ? 00:00:00 ibus-x11
1537 ? 00:00:00 ibus-portal
1557 ? 00:00:00 at-spi-bus-laun
1563 ? 00:00:01 dbus-daemon
1573 ? 00:00:05 at-spi2-registr
1582 ? 00:00:10 ibus-engine-sim
1618 ? 00:00:00 plasma_session
1622 ? 00:00:00 start_kdeinit
1623 ? 00:00:00 kdeinit5
1624 ? 00:00:02 klauncher
1658 ? 00:08:31 kwin_x11
1679 ? 00:00:05 kglobalaccel5
1691 ? 00:00:00 dconf-service
1694 ? 00:00:03 ksmserver
```
## Ordinare i processi
Con l'opzione `-o` è possibile selezionare le colonne che si desidera includere nell'output del comando `ps`, mentre l'opzione `--sort` permette di ordinare l'output in base al parametro specificato:
```bash
ps -eo pid,pcpu,pmem,args --sort -pcpu,pmem | head -10
PID %CPU %MEM COMMAND
59079 9.0 0.3 vim processes.md
59118 7.6 4.2 $HOME/.config/coc/extensions/node_modules/coc-ltex/lib/ltex-ls-15.2.0/jdk-11.0.12+7/bin/java -Xms64m -Xmx512m -classpath $HOME/.config/coc/extensions/node_modules/coc-ltex/lib/ltex-ls-15.2.0/etc:$HOME/.config/coc/extensions/node_modules/coc-ltex/lib/ltex-ls-15.2.0/lib/* -Dapp.name=ltex-ls -Dapp.pid=59118 -Dapp.repo=$HOME/.config/coc/extensions/node_modules/coc-ltex/lib/ltex-ls-15.2.0/lib -Dapp.home=$HOME/.config/coc/extensions/node_modules/coc-ltex/lib/ltex-ls-15.2.0 -Dbasedir=$HOME/.config/coc/extensions/node_modules/coc-ltex/lib/ltex-ls-15.2.0 org.bsplines.ltexls.LtexLanguageServerLauncher
26789 4.6 4.0 /usr/lib/firefox-esr/firefox-esr
59080 3.3 1.4 node --no-warnings $HOME/.vim/bundle/coc.nvim/build/index.js
971 2.8 0.7 /usr/lib/xorg/Xorg -nolisten tcp -auth /var/run/sddm/{49eaf0ba-ce00-4efc-8197-fdf9e6e8c827} -background none -noreset -displayfd 17 -seat seat0 vt7
1658 1.7 0.7 /usr/bin/kwin_x11
26918 1.0 2.0 /usr/lib/firefox-esr/firefox-esr -contentproc -childID 1 -isForBrowser -prefsLen 34960 -prefMapSize 222095 -jsInitLen 277276 -parentBuildID 20230214011352 -appDir /usr/lib/firefox-esr/browser 26789 true tab
32110 1.0 4.4 /usr/bin/telegram-desktop --
58902 0.8 1.3 /usr/lib/firefox-esr/firefox-esr -contentproc -childID 170 -isForBrowser -prefsLen 41310 -prefMapSize 222095 -jsInitLen 277276 -parentBuildID 20230214011352 -appDir /usr/lib/firefox-esr/browser 26789 true tab
```
## Ricercare un processo
Come il comando grep è utilizzato per trovare stringhe da file ed output, il comando `pgrep` fa lo stesso per i processi.
La sintassi è molto semplice
```bash
pgrep -i -u username process_name
```
dove `-i` attiva l'opzione **case-insensitive**.
### Ottenere il numero di processi di un utente
Per conoscere il numero di processi utilizzati da un utente specifico, utilizzare l'opzione `-c`:
```bash
pgrep -cu davide
112
```
Ad esempio:
```bash
> pgrep -u davide -l
1400 systemd
1401 (sd-pam)
1417 pipewire
1418 wireplumber
1419 pipewire-pulse
1420 dbus-daemon
1430 kwalletd5
1431 startplasma-x11
```
Per trovare quale comando ha avviato il processo in questione basta digitare
```bash
pgrep -u username -a
> pgrep -u davide -a
1400 /lib/systemd/systemd --user
1401 (sd-pam)
1417 /usr/bin/pipewire
1418 /usr/bin/wireplumber
1419 /usr/bin/pipewire-pulse
1420 /usr/bin/dbus-daemon --session --address=systemd: --nofork --nopidfile --systemd-activation --syslog-only
1430 /usr/bin/kwalletd5 --pam-login 7 8
1431 /usr/bin/startplasma-x11
```
### Elencare i processi per nome e PID
```bash
pgrep -u username -l
```
## Uccidere un processo
### Tramite PID
Se, per esempio, si volesse uccidere il processo 1492:
```bash
sudo kill -9 1492
```
### Tramite il nome
```bash
sudo pkill -9 top
```
### Uccidere processi multipli
```bash
sudo killall -9 top
```
## Collegamenti
- [https://www.howtogeek.com/448271/how-to-use-the-ps-command-to-monitor-linux-processes/](https://www.howtogeek.com/448271/how-to-use-the-ps-command-to-monitor-linux-processes/)
- [https://www.howtogeek.com/413213/how-to-kill-processes-from-the-linux-terminal/](https://www.howtogeek.com/413213/how-to-kill-processes-from-the-linux-terminal/)
- [https://linuxhandbook.com/pgrep/](https://linuxhandbook.com/pgrep/)

56
linux/qrcp.md
View File

@ -1,56 +0,0 @@
# Qrcp
Qrcp è un’utility open source che, tramite terminale, permette di scambiare file tra desktop e dispositivi mobile. Basta che i vari device, connessi alla medesima rete Wi-Fi, scansionino un QR code generato appositamente.
## Installazione
```bash
cd ~
mkdir bin/
echo 'export PATH=$PATH:$HOME/bin/' >> .bashrc
wget -c https://github.com/claudiodangelis/qrcp/releases/download/0.9.1/qrcp_0.9.1_linux_i386.tar.gz
tar xf qrcp_0.9.1_linux_i386.tar.gz
mv qrcp bin/
```
### Aprire le porte del Firewall
```bash
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow from 192.168.1.0/24
```
## Funzionamento
### Invio
```bash
qrcp /path/to/file # crea il qr code per inviare il file
qrcp --zip /path/to/file # in alternativa, per condividere il file compresso
```
Successivamente verrà generato il QR code da scansionare con lo smartphone. Una volta completato il download, il server temporaneo appena creato verrà automaticamente interrotto. È possibile anche inviare più di un file alla volta, o un’intera directory:
```bash
qrcp /path/to/file1 qrcp /path/to/file2 #invio di file multipli
qrcp /path/to/directory # condivisione di una directory
```
### Ricezione
È possibile utilizzare qrcp anche per la ricezione dei file, ad esempio:
```bash
qrcp receive # riceve il file nella directory corrente
qrcp receive –output=/path/to/directory # riceve i file in una specifica directory
```
Pagina Github dl progetto: [https://github.com/claudiodangelis/qrcp/releases](https://github.com/claudiodangelis/qrcp/releases)
## Collegamenti
- [https://www.lffl.org/2020/07/qrcp-file-sharing-qr-code.html](https://www.lffl.org/2020/07/qrcp-file-sharing-qr-code.html)

138
linux/rsync.md
View File

@ -1,138 +0,0 @@
## Rsync
`Rsync` può essere utilizzato per il mirroring dei dati (in locale o remoto), i backup incrementali, la copia di file tra i sistemi e come un sostituto per i comandi scp, sftpe cp.
## Installare Rsync
`Rsync` è preinstallato nelle maggiori distribuzioni GNU/Linux, ma si può sempre verificare che sia presente nel sistema col seguente comando:
```bash
rsync --version
```
Se non fosse installato, si può installare facilmente usando il gestore pacchetti della distribuzione.
Per esempio su Debian e derivati:
```bash
sudo apt install rsync
```
## Sintassi
Local to Local: `rsync [OPTION]... [SRC]... DEST`
Local to Remote: `rsync [OPTION]... [SRC]... HOST:DEST`
Remote to Local: `rsync [OPTION]... HOST:SRC... [DEST]`
dove:
`SRC` - Directory sorgente o di origine;
`DEST` - Directory di destinazione;
`HOST` - Hostname remoto o indirizzo IP.
`Rsync` fornisce una serie di opzioni che controllano ogni aspetto del suo comportamento. Le opzioni più utilizzate sono:
-`n`, avvia come simulazione, ovvero mostra solo quello che farebbe senza modificare realmente alcunché. Quest'opzione è FONDAMENTALE, in quanto permette di identificare eventuali comportamenti e/o risultati anomali e quindi di correggere il comando. Si ricordi che un errore nella definizione del comando può comportare la perdita dei dati nella cartella di destinazione o anche in quella sorgente se per esempio si invertono accidentalmente le due. Chiaramente una volta verificato il risultato della sincronizzazione quest'opzione andrà eliminata in modo da far effettivamente sincronizzare le directory;
-`r`, sincronizza anche le sottodirectory e tutti i relativi file;
-`t`, aggiorna anche la data di "Ultima modifica" dei file copiati nella cartella di destinazione;
-`p`, imposta per i file nella cartella di destinazione lo stesso `schema di permessi` di quelli sorgenti;
-`o`, imposta per i file nella cartella di destinazione lo stesso `proprietario` di quelli sorgenti, ove possibile;
-`g`, imposta per i file nella cartella di destinazione lo stesso `gruppo` di quelli sorgenti, ove possibile;
-`a`, (modalità archivio) è equivalente a impostare tutte le opzioni precedenti (`-rtpog`), e inoltre mantiene link simbolici, file speciali e (solo se eseguito come root) file dispositivo. Si possono invece trasformare tutti i link simbolici nei file a cui puntano con l'opzione i `-L`;
-`v`, aumenta il numero di informazioni stampate a video (verbose);
`-P` o `--progress`, mostra un indicatore percentuale del progresso delle operazioni. Implica l'opzione -v, pertanto se si specifica --progress è ridondante specificare anche -v;
`--delete`, elimina nella directory di destinazione tutti i file che non sono presenti nella directory sorgente;
`--exclude-from`, specifica il percorso di un file contenente un elenco di file e cartelle da non includere nelle operazioni di sincronizzazione. Maggiori informazioni nell'apposita sezione.
-`z`, --compress. Questa opzione forzerà `Rsync` a comprimere i dati;
## Utilizzo di base di Rsync
Per copiare un singolo file `localmente` è necessario eseguire il comando seguente:
```bash
rsync -az /opt/filename.zip /tmp/newfilename.zip
```
Se la directory di destinazione non esiste verrà creata.
Vale la pena ricordare che, aggiungendo `/` alla directory di origine, verrà copiato solo il contenuto della directory nella directory di destinazione. Se omessa, `Rsync` copierà la directory di origine all'interno della directory di destinazione.
## Utilizzare Rsync per sincronizzare i dati da e verso una macchina remota
Quando si utilizza `Rsync` per il trasferimento remoto, deve essere installato sia sul computer di origine che su quello di destinazione. Le nuove versioni di `Rsync` sono configurate per utilizzare SSH come shell remota predefinita.
Nel seguente esempio, vine trasferita una directory da un computer locale a un computer remoto:
```bash
rsync -a /opt/media/ host_or_ip:/opt/media/
```
Se non è impostato un accesso SSH senza password al computer remoto, verrà chiesto di inserire la password dell'utente.
Se si desidera trasferire i dati da un server remoto a un computer locale, è *necessario utilizzare la posizione remota* come sorgente:
Se SSH sull'host remoto è in ascolto su una porta diversa dalla 22, è possibile specificare la porta utilizzando l'opzione `-e`:
```bash
rsync -a -e "ssh -p 2322" /opt/media/ host_or_ip:/opt/media/
```
Quando si trasferiscono grandi quantità di dati, si consiglia di eseguire il comando `Rsync` all'interno di `screen` o di utilizzare l'opzione `-P`.
## Escludere file e directory
Esistono due opzioni per escludere file e directory. La prima opzione è utilizzare l'argomento `--exclude` e specificare i file e le directory.
Nel seguente esempio, vengono escluse le directory `node_modules` e `tmp` che si trovano all'interno di `src_directory`:
```bash
rsync -a --exclude=node_modules --exclude=tmp /src_directory/ /dst_directory/
```
La seconda opzione è usare l'argomento `--exclude-from` e specificare i file e le directory che si desidera escludere in un file.
```bash
nano exclude-file.txt
node_modules
tmp
```
Quindi:
```bash
rsync -a --exclude-from='/exclude-file.txt' /src_directory/ /dst_directory/
```
## Backup locale
Ecco un esempio di come utilizzare `Rsync` per un backup locale:
```bash
rsync -aPz --delete --exclude-from='~/exlude.txt' ~/.config ~/bk_config
```
## Collegamenti
- [https://guide.debianizzati.org/index.php/Rsync](https://guide.debianizzati.org/index.php/Rsync)
- [https://wiki.ubuntu-it.org/AmministrazioneSistema/BackupDelSistema/Rsync](https://wiki.ubuntu-it.org/AmministrazioneSistema/BackupDelSistema/Rsync)
- [https://noviello.it/come-usare-Rsync-per-trasferire-file-locali-e-remoti-su-linux/](https://noviello.it/come-usare-`Rsync`-per-trasferire-file-locali-e-remoti-su-linux/)
- [https://wiki.ubuntu-it.org/AmministrazioneSistema/BackupDelSistema/Rsync](https://wiki.ubuntu-it.org/AmministrazioneSistema/BackupDelSistema/Rsync)

84
linux/screen.md
View File

@ -1,84 +0,0 @@
# Screen
Screen è un comando molto utile che dà la possibilità di utilizzare più sessioni di shell:
- non è necessario aprire esplicitamente diverse sessioni per eseguire più operazioni in parallelo;
- aiuta anche a continuare il processo anche se la connessione alla sessione si interrompe. Normalmente quando si esegue un comando se la connessione alla shell si interrompe,
come quando si chiude la finestra, la sessione e tutti i comandi eseguiti dal terminale si interrompono. Screen serve proprio per evitare l'interruzione dei comandi.
## Installazione
```bash
sudo apt install screen
```
## Utilizzo
Avviare una nuova sessione digitando il comando:
```bash
screen
```
Avviare adesso il comando o lo script che si desidera utilizzare:
```bash
./my_script.sh
wget -c https://ftpmirror.gnu.org/gnu/guix/guix-system-install-1.4.0.x86_64-linux.iso
```
Dopo averlo avviato è possibile uscire dalla sessione senza fermare processo. Digitare:
```bash
[CTRL + a]+ d
```
Controllare le sessioni attive tramite il comando:
```bash
screen -ls
```
Ecco un esempio:
```bash
345.tt-3.host (Detached)
567.tty-1.host (Detached)
877.host (Detached)
```
Se si desidera riaprire una sessione specifica, digitare il numero che precede il nome della sessione:
```bash
screen -r 567
```
Nal caso si desiderasse assegnare un nome specifico ad una sessione utilizzare il flag -S:
```bash
screen -S guix
```
Quindi una volta usciti dalla sessione è possibile utilizzare il nome scelto in precedenza per riaprirla:
```bash
screen -r guix
```
## Altri comandi utili
| Shortcut | Funzione |
|----------|----------|
[ ctrl + a ] + d | Uscrire dalla sessione
[ ctrl + a ] + k | kill screen
[ ctrl + a ] + n | prossima sessione
[ ctrl + a ] + p | sessione precedente
[ ctrl + a ] + A | rinominare la sessione
[ ctrl + a ] + ? | tutte le scorciatoie
## Collegamenti
- [https://noviello.it/come-utilizzare-il-comando-screen-per-le-sessioni-su-linux/](https://noviello.it/come-utilizzare-il-comando-screen-per-le-sessioni-su-linux/)
- [https://linuxhandbook.com/screen-command/](https://linuxhandbook.com/screen-command/)
- [https://linuxize.com/post/how-to-use-linux-screen/](https://linuxize.com/post/how-to-use-linux-screen/)

159
linux/security/ssh.md
View File

@ -1,159 +0,0 @@
# Creazione e gestione chiavi SSH
**SSH** è un protocollo client / server utilizzato per i login remoti. Utilizzando la crittografia per l'autenticazione, SSH fornisce un metodo
crittografato per accedere al server o ad un'altra macchina.
## Installazione SSH
```bash
sudo apt install openssh-server
sudo systemctl start ssh
sudo systemctl enable ssh #Abilita SSH all'accensione della macchina
```
## Creazione chiave SSH
Il protocollo SSH utilizza una tecnica di crittografia chiamata crittografia asimmetrica. Fondamentalmente, la crittografia asimmetrica è un sistema che usa una coppia di chiavi, cioè la *chiave pubblica* e quella *privata*.
La chiave pubblica può essere condivisa con chiunque, avendo come scopo principale quello di criptare i dati, convertendo il messaggio in un codice segreto. Questa chiave viene solitamente inviata ad altri sistemi, per esempio i server, per criptare i dati prima di inviarli su Internet.
D’altra parte, la chiave privata è quella che deve rimanere segreta e viene usata per decifrare i dati crittografati con la chiave pubblica. Senza di essa, è impossibile decodificare le informazioni criptate.
Questo metodo permette al client e al server di mantenere un canale di comunicazione sicuro.
Ecco cosa succede in background quando si avvia una connessione SSH ad un server:
- Il client invia la chiave pubblica al server;
- Il server chiede al client di firmare un messaggio casuale criptato con la chiave pubblica usando la chiave privata;
- Il client firma il messaggio e inoltra il risultato al server;
- Viene stabilita una connessione sicura tra il client e il server.
La coppia di chiavi viene creata sulla propria macchina (client) in questo modo:
```bash
→ ssh-keygen -t ed25519 -C "<commento>"
```
- dove `ed25519` indica l’algoritmo utilizzato per creare la firma digitale della coppia di chiavi. Se il sistema lo supporta, ed25519 è il miglior algoritmo per creare coppie di chiavi SSH;
- il flag `-C` è utilizzato per fornire un *commento* personalizzato alla fine della chiave pubblica, che di solito è l’email o l’identificazione del creatore della coppia di chiavi.
Ecco un esempio:
```bash
piccihud@WORKSTATION03:~
→ ssh-keygen -t ed25519 -C "piccihud"
Generating public/private ed25519 key pair.
Enter file in which to save the key (~/.ssh/id_ed25519): ~/.ssh/<file_name>
```
- <file_name> indica il nome del file in cui sarà salvata la chiave.
Poi verrà chiesta una *passphrase* da aggiungere alla coppia di chiavi. Questo aggiunge un ulteriore livello di sicurezza se, in qualsiasi momento, il vostro dispositivo viene compromesso. Non è obbligatorio aggiungere una passphrase, ma è sempre raccomandato.
Questo comando genera due file nella directory selezionata (comunemente ~/.ssh):
- la chiave pubblica con l’estensione `.pub`;
- e quella privata senza estensione.
La chiave pubblica può essere vista con un semplice comando:
```bash
piccihud@WORKSTATION03:~
→ cat /home/piccihud/.ssh/<file_name>.pub
```
## Caricamento della chiave SSH nella macchina remota (server)
L'output del comando precedente deve essere copiato nel file **.ssh/authorized_keys** presente sulla macchina remota.
Per prima cosa, Si accede tramite SSH alla macchina remota:
```bash
→ ssh user@indirizzo_ip
piccihud@WORKSTATION03:~
→ ssh root@10.21.81.138 -p 1220 (per una porta differente dalla 22)
[15:33:25]root@server:~
→ cd .ssh
[15:33:31]root@server:~/.ssh
→ echo ssh-ed25519 ******************************************************* piccihud >> authorized_keys
```
Oppure, se si preferisce, si può utilizzare Nano ovvero Vim. Tramite il comando `cat .ssh/authorized_keys` o `less .ssh/authorized_keys` è possibile vedere la propria chiave nel file di configurazione.
### Configurazione SSH sulla macchina locale
Nel file di configurazione locale, va indicato come raggiungere l'host remoto:
```bash
piccihud@WORKSTATION03:~
→ vim .ssh/config
host <key_name> #il nome della macchina remota alla quale si accederà
hostname 10.21.81.138 #indirizzo ip della macchina remota
user root
IdentityFile ~/.ssh/<file_name> #indicare il percorso della chiave ssh privata
TCPKeepAlive yes
port 22
```
### Accedere alla macchina remota
Per accedere a una macchina server tramite SSH è necessario conoscere l'indirizzo ip di questa macchina e il nome dell'utente. Ciò è possibile scoprirlo con questi semplici comandi:
```bash
→ hostname -I
192.168.0.115
→ whoami
piccihud
```
In assenza della chiave, quindi si può sempre accedere in questo modo:
```bash
→ ssh piccihud@192.168.0.115
```
Altrimenti, per accedere alla macchina basta digitare:
`→ ssh <key_name>`
Ad esempio:
```bash
piccihud@WORKSTATION03:~
→ ssh mnt-bbb
```
## Aggiungere la Chiave SSH all’Account Git
Nelle impostazioni del proprio account, aggiungere la propria chiave pubblica nel campo `SSH and GPG keys`.
![SSH](./asset/git/gitea-ssh.png)
Quindi, configurare il file .ssh/config nella macchina locale:
```bash
# host gitea.it/piccihud
# hostname 10.97.57.55
user <name>
IdentityFile /home/user/.ssh/<file>
TCPKeepAlive yes
port 22
```
Modificare le impostazioni di `git`:
`git config --global --edit`
## Copiare la chiave pubblica in remoto
```bash
ssh-copy-id -i ~/.ssh/id_rsa.pub -p <port_number> <username>@<host>
```
## Collegamenti
- [https://linuxhint.com/enable-ssh-server-debian/](https://linuxhint.com/enable-ssh-server-debian/)
- [https://wiki.debian.org/it/SSH](https://wiki.debian.org/it/SSH)
- [https://docs.github.com/en/authentication/connecting-to-github-with-ssh](https://docs.github.com/en/authentication/connecting-to-github-with-ssh)
- [https://kinsta.com/it/blog/generare-chiavi-ssh/](https://kinsta.com/it/blog/generare-chiavi-ssh/)

46
linux/shered.md
View File

@ -1,46 +0,0 @@
# shered
shred è un comando Unix che permette di cancellare i file sovrascrivendo ripetutamente i blocchi del disco su cui era stato salvato, in modo da rendere più difficile il
ripristino dei dati cancellati.
```bash
shred [OPZIONE]... FILE...
```
## Argomenti
```txt
-f, --force se necessario cambia i permessi per permettere la scrittura
-n, --iterations=N sovrascrive N volte invece che le 3 predefinite
-u, --remove tronca e rimuove il file dopo la sovrascrittura
-v, --verbose indica il progresso
-z, --zero aggiunge una sovrascrittura finale con zeri per nascondere la distruzione
--help mostra questo aiuto ed esce
--version stampa le informazioni sulla versione ed esce
```
Un esempio:
```bash
shred -vuzn 25 *.*
[17:36 dom giu 04]davide@desktop (9819):~
> touch file.txt
[17:36 dom giu 04]davide@desktop (9820):~
> shred -vuz file.txt
shred: file.txt: rimozione
shred: file.txt: rinominato in 00000000
shred: 00000000: rinominato in 0000000
shred: 0000000: rinominato in 000000
shred: 000000: rinominato in 00000
shred: 00000: rinominato in 0000
shred: 0000: rinominato in 000
shred: 000: rinominato in 00
shred: 00: rinominato in 0
shred: file.txt: rimosso
```
## Collegamenti
- [https://it.wikipedia.org/wiki/Shred_(Unix)](https://it.wikipedia.org/wiki/Shred_(Unix))

50
linux/singleusermode.md
View File

@ -1,50 +0,0 @@
# Single User Mode
## Run level
Il runlevel è un concetto tipico dei sistemi UNIX e Unix-like e rappresenta lo stato di attività di una macchina, relativamente ai programmi in esecuzione e ai servizi offerti.
Ogni runlevel è identificato da un numero, solitamente compreso tra 0 e 6, e ad ogni stato associato la macchina esegue script di sistema relativi alle funzionalità assegnate a quel livello.
- Il runlevel 0: serve ad arrestare (halt) il sistema. In sostanza corrisponde ad uno stato in cui nessun programma è in esecuzione (e la macchina è spenta);
- Il runlevel 1: è detto `Single user mode` ("modalità ad utente singolo"). In questo stato non vi sono programmi in esecuzione in background e nessun utente oltre all'amministratore di sistema ha accesso al sistema, per cui esso è sotto il suo pieno controllo;
- Il runlevel 2: avvia la macchina in modalità multiutente con il networking abilitato, ma senza servizi di rete;
- Il runlevel 3: avvia in modalità multiutente con tutte le funzionalità di networking abilitate, e con tutti i relativi servizi attivi;
- Il runlevel 4: generalmente non è utilizzato;
- Il runlevel 5: avvia in modalità multiutente con tutte le funzionalità di networking abilitate come il runlevel 3, e con un server grafico (quasi sempre X Window System) abilitato;
- Il runlevel 6: serve a riavviare (reboot) il sistema. È simile al runlevel 0, con la differenza che al termine dell'inizializzazione, la macchina viene riavviata piuttosto che spenta.
Per conoscere il runlevel attuale e quello precedente si può usare il comando:
```bash
runlevel
```
## GRUB e single user mode
![edit](./asset/runlevel/grubedit.png)
1. Accendere alla console di GRUB premendo `shift` durante l'avvio del sistema;
2. Premere `e`;
3. Andare alla riga che inizia con `linux /boot/vmlinuz`;
4. Sostituire `ro \ console=ttyS0 console=tty0` con `rw init=/bin/bash`
![init](./asset/runlevel/initbash.jpg)
5. Premere F10 per avviare il sistema.
Oppure
- Modify kernel line: add single between `ro quiet` and at the end of this line add `init=/bin/bash`
- Press `F10`
- When the prompt is `root@(none):/#` you have to remount the `/` partition to have read-write access: `mount / -rw -o remount`
- Now you are ready to modify the root password: type `passwd` and change it!
## Collegamenti
- [https://it.wikipedia.org/wiki/Runlevel](https://it.wikipedia.org/wiki/Runlevel)
- [https://en.wikipedia.org/wiki/Single-user_mode](https://en.wikipedia.org/wiki/Single-user_mode)
- [https://askubuntu.com/questions/132965/how-do-i-boot-into-single-user-mode-from-grub](https://askubuntu.com/questions/132965/how-do-i-boot-into-single-user-mode-from-grub)
- [https://www.tecmint.com/boot-into-single-user-mode-in-centos-7/](https://www.tecmint.com/boot-into-single-user-mode-in-centos-7/)
- [https://itgala.xyz/how-to-enter-single-user-mode-in-ubuntu/](https://itgala.xyz/how-to-enter-single-user-mode-in-ubuntu/)
- [https://serverfault.com/questions/482079/debian-boot-to-single-user-mode](https://serverfault.com/questions/482079/debian-boot-to-single-user-mode)

183
linux/telnet.md
View File

@ -1,183 +0,0 @@
# Telnet
Telnet è un protocollo, sviluppato nel 1969, che fornisce un’interfaccia a linea di comando per la comunicazione con un dispositivo o server remoto.
Poiché è stato sviluppato prima dell’adattamento anche ad Internet, TELNET non utilizza alcuna forma di cifratura, il che lo rende obsoleto in termini di sicurezza moderna.
È stato scalzato dal protocollo Secure Shell (SSH), almeno su Internet. Permette di emulare un terminale a distanza, il che significa che permette di eseguire dei comandi
digitati dalla tastiera di un terminale remoto.
## Installazione
```bash
apt install telnet
```
## Esecuzione di Telnet
Il comando per aprire una sessione Telnet è generalmente il seguente:
```bash
telnet ip_server
telnet hostname_server
telnet 125.64.124.77
```
Infine è anche possibile precisare la porta da utilizzare facendo seguire l'indirizzo IP o il nome del server dal numero di porta:
```bash
telnet 125.64.124.77 80
```
## Comandi Telnet
| Comando | Descrizione |
|---------|----------------------------|
| ? | Visualizza l'help |
| close | Termina la sessione Telnet |
## Utilizzare Telnet sulla porta 25 per testare la comunicazione SMTP o per inviare una mail senza client
Digitare:
```bash
telnet mail.server.com 25
```
dove *mail.server.com* rappresenta l'indirizzo del server SMTP (**Simple Mail Transfer Protocol**), mentre 25 è il numero di porta standard utilizzato dai servizi SMTP.
```bash
telnet mail.server.com 25
Trying 80.16.129.75...
Connected to mail.server.com.
Escape character is '^]'.
220 mail.server.com ESMTP MDaemon 19.5.8; Sun, 09 Apr 2023 16:25:59 +0200
```
Si dovrebbe ricevere un messaggio di risposta da parte del server simile a *220 mail.server.com*.
La porta di connessione 25 è quella standard utilizzata dalla maggior parte dei server SMTP, ma alcuni amministratori di rete potrebbero aver configurato un numero di porta differente,
come ad esempio 465 (per utilizzare connessioni sicure) o 587 (per gli utenti che utilizzano Microsoft Outlook).
#### Presentarsi al server
Digitare il comando
```bash
HELO dominio.com
```
dove *dominio.com* è il nome di dominio da cui si invia il messaggio di posta elettronica.
Si dovrebbe ricevere un messaggio di risposta da parte del server simile al seguente:
```bash
250 mail.server.com Hello [dominio.com] pleased to meet you
```
#### Mittente
Digitare il comando:
```bash
mail from: tuoindirizzo@server.com
```
Assicurarsi di lasciare uno spazio vuoto dopo il comando `mail from:`.
Se tutto è corretto, si riceverà un messaggio di risposta da parte del server simile al seguente:
```bash
250 Sender OK
```
#### Destinatario
Digitare il comando
```bash
rcpt to: nomeutente_dest@dominio_dest.com
```
dove *nomeutente_dest@dominio_dest.com* rappresenta l'indirizzo e-mail completo del destinatario del messaggio.
Si riceverà un messaggio di risposta da parte del server simile al seguente:
```bash
250 OK – MAIL FROM tuoindirizzo@server.com
```
#### Testo del messaggio
Per formattare e inviare correttamente il messaggio di posta, utilizzare i seguenti comandi:
```bash
DATA
```
quindi premere [Invio]. Nella linea di comando successiva digitare il comando
```bash
subject: Test
```
per inserire l'oggetto, quindi premere due volte il tasto [Invio].
Digitare il testo del messaggio, poi quando è concluso premere il tasto [Invio].
Digitare `.` una sola volta per indicare che è finito il testo del messaggio, quindi premere il tasto [Invio].
Si dovrebbe vedere un messaggio che conferma che la e-mail è stata accettata o inserita in coda, in attesa di essere elaborata.
Digitare `QUIT` per uscire da Telnet.
Un piccolo esempio riepilogativo:
```bash
$ telnet pippo.zigozago.dg smtp [Invio]
Trying 192.168.1.2...
Connected to pippo.zigozago.dg.
Escape character is '^]'.
220 pippo.zigozago.dg ESMTP Sendmail 8.8.5/8.8.5; Thu, 17 Sep 2023 19:58:15 +0200
HELO zigozago.dg [Invio]
250 pippo.zigozago.dg Hello topolino.zigozago.dg [192.168.1.1], pleased to meet you
MAIL From: <daniele@topolino.zigozago.dg> [Invio]
250 <daniele@topolino.zigozago.dg>... Sender ok
RCPT to: <npapera@topolino.zigozago.dg> [Invio]
250 <npapera@topolino.zigozago.dg>... Recipient ok
DATA [Invio]
354 Enter mail, end with "." on a line by itself
Subject: Saluti. [Invio]
Ciao Nonna Papera, [Invio]
come stai? [Invio]
Io sto bene e mi piacerebbe risentirti. [Invio]
Saluti, [Invio]
Daniele [Invio]
. [Invio]
250 TAA02951 Message accepted for delivery
QUIT [Invio]
221 topolino.zigozago.dg closing connection
Connection closed by foreign host.
```
## Collegamenti
- [https://it.ccm.net/contents/644-utilizzo-di-telnet](https://it.ccm.net/contents/644-utilizzo-di-telnet)
- [https://www.ionos.it/digitalguide/server/tools-o-strumenti/comandi-telnet/](https://www.ionos.it/digitalguide/server/tools-o-strumenti/comandi-telnet/)
- [https://www.aiutocomputerhelp.it/telnet-smtp-inviare-mail-con-telnet/](https://www.aiutocomputerhelp.it/telnet-smtp-inviare-mail-con-telnet/)
- [https://www.wikihow.it/Inviare-una-Email-Usando-Telnet](https://www.wikihow.it/Inviare-una-Email-Usando-Telnet)

83
linux/tree.md
View File

@ -1,83 +0,0 @@
# tree
![FSH](./asset/fsh/fsh.png)
## Installazione
```bash
sudo apt install tree
```
## Utilizzo
### Elencare solo le directory
```bash
tree -d target_directory
tree -d Documenti/
Documenti/
└── repos
├── cineforum
│   ├── Fonts
│   └── Img
├── mywiki
│   └── asset
│   ├── calcurse
│   ├── debian
│   ├── fairphone
│   ├── fstab
│   ├── git
│   ├── kde
│   ├── logseq
│   ├── markdown
│   ├── nas
│   ├── neofetch
│   ├── nextcloud
│   ├── pull-request
│   ├── rofi
│   └── vim
└── notes
22 directories
```
### Elencare i file nascosti
Utilizzare l'opzione `-a`
```bash
tree -a Databases/
Databases/
├── .conf
└── filmdb.sql
1 directory, 2 files
```
### Includere il percorso
```bash
tree -f directory
```
### Elenca file e directory in base al livello
È possibile specificare i livelli aggiungendo il numero del livello all'opzione `-L`:
```bash
tree -L 1 Scaricati/
Scaricati/
├── Download
├── Telegram Desktop
└── zfs.pdf
3 directories, 2 files
```
### Autorizzazioni e dimensione
```bash
tree -ph music
```
## Collegamenti
- [https://linuxhandbook.com/tree-command/](https://linuxhandbook.com/tree-command/)

50
linux/xargs.md
View File

@ -1,50 +0,0 @@
# xargs
Il comando xargs legge righe di testo dallo standard input o dall'output di un altro comando e le esegue. In altre parole, consente all'utente di eseguire righe di comando dallo standard input.
## Sintassi
La sintassi generale di xargs è:
```bash
xargs [opzioni] [comando [arg1 …] ]
```
## Utilizzo
[https://noviello.it/come-creare-ed-eseguire-comandi-dallinput-standard-su-linux-xargs/](https://noviello.it/come-creare-ed-eseguire-comandi-dallinput-standard-su-linux-xargs/)
L'esempio più basilare di utilizzo del comando xargs sarebbe quello di passare diverse stringhe ed eseguire un comando che userà quelle stringhe come argomenti.
```bash
echo "file1 file2 file3" | xargs touch
```
Nell'esempio sopra, il comando touch viene eseguito per ogni argomento, creando tre file.
Un ulteriore esempio:
```bash
$ ls
1.txt 2.txt 3.txt
$ ls | xargs cat
this is file1
this is file2
this is file3
```
Per vedere il comando che xargs sta eseguendo, utilizzare l'opzione `-t`.
```bash
$ ls | xargs -t cat
cat 1.txt 2.txt 3.txt
this is file1
this is file2
this is file3
```
## Collegamenti
- [https://linuxhandbook.com/xargs-command/](https://linuxhandbook.com/xargs-command/)
- [https://it.wikipedia.org/wiki/Xargs](https://it.wikipedia.org/wiki/Xargs)
- [https://www.howtogeek.com/435164/how-to-use-the-xargs-command-on-linux/](https://www.howtogeek.com/435164/how-to-use-the-xargs-command-on-linux/)
- [https://it.linux-console.net/?p=10733](https://it.linux-console.net/?p=10733)

70
linux/xfreerdp.md
View File

@ -1,70 +0,0 @@
# XfreeRDP
`FreeRDP` è l'implementazione libera del protocollo RDP, rilasciato sotto licenza Apache 2.0.
RDP (Remote Desktop Protocol) è un protocollo di rete proprietario sviluppato da Microsoft, che permette la connessione remota da un computer a un altro utilizzando l'interfaccia grafica (GUI) di Windows, usando di default la porta TCP e UDP 3389.
L'applicazione (che usa il protocollo in oggetto) compresa in Microsoft Windows si chiama `Connessione Desktop remoto`.
## Installazione
Su Debian e derivate:
```bash
sudo apt update ; sudo apt install -y freerdp2-x11
```
## Sintassi
```bash
xfreerdp [file] [options] [/v:<server>[:port]]
```
Ecco un esempio:
```bash
xfreerdp /v:[IP_MACCHINA_REMOTA]:[PORTA] /u:[UTENTE] /t:[TITOLO_FINESTRA] /bpp:32 +window-drag +clipboard /cert-ignore /size:1800x1000 /rfx /dynamic-resolution /gfx /encryption-methods:128 /d:[DOMINIO]
```
dove:
`/v`: ip macchina remota : porta (facoltativa);
`/u`: Utente;
`/t`: Titolo della finestra;
`/f`: Fullscreen mode;
`/p`: Password (in chiaro);
`+compression`: (default:off) Compressione;
`/bpp:32`: Serve a specificare l'intensità del colore per una sessione remota o la profondità di
colore. 32bit indica la qualità più alta;
+window-drag Permette il trascinamento dell'intera finestra;
`+clipboard`: Attivare il copia/incolla;
`cert-ignore`: Ignora il certificato;
`/size:1800x1000`: Dimensioni in pixel della finestra;
`/rfx`: Microsoft RemoteFX è una tecnologia che migliora l'esperienza visiva;
`/dynamic-resolution`: Invia aggiornamenti della risoluzione quando la finestra viene ridimensionata;
`-encryption` (default:on)
`/encryption-methods`: [40] [56] [128] Selezionare 128bit i dati vengono crittografati utilizzando una chiave di crittografia a 128 bit. Questo tipo di crittografia potrebbe essere incompatibile con alcuni sistemi;
`/drive:<sharename>,<path>`: reindirizza <path> come cartella condivisa <sharename>;
`/d`: Dominio facoltativo
## Collegamenti
- [https://it.wikipedia.org/wiki/Remote_Desktop_Protocol](https://it.wikipedia.org/wiki/Remote_Desktop_Protocol)
- [https://github.com/awakecoding/FreeRDP-Manuals/blob/master/User/FreeRDP-User-Manual.markdown](https://github.com/awakecoding/FreeRDP-Manuals/blob/master/User/FreeRDP-User-Manual.markdown)
- [https://github.com/FreeRDP/FreeRDP/wiki/CommandLineInterface](https://github.com/FreeRDP/FreeRDP/wiki/CommandLineInterface)
- [https://www.freerdp.com/](https://www.freerdp.com/)

60
linux/zathura.md
View File

@ -1,60 +0,0 @@
---
class: post
title: zathura
date: aaaa-mm-gg
layout: post
author: piccihud
published: false
tags:
- guide
---
# Zathura
Zathura è un visualizzatore di documenti altamente personalizzabile in stile Vim.
## Installazione
```bash
sudo apt install zathura zathura-cb
```
## Scorciatoie
| Comando | |
|-----------------------------|------------------------------------------------|
| J o Page Down | Go to next page |
| K o Page Up | Go to previous page |
| h o k o j o l | Scroll to the left, down, up o right direction |
| Ctrl + F o Ctrl + B o Space | Scroll a full page left, down, up orright |
| gg | Goto to the first page |
| G | Go to last page |
| :X | Go to page X |
| Shift + H | Go to top of the current page |
| Shift + L | Go to bottom of the current page |
| Ctrl + O | Move backward through the jump list |
| Ctrl + I | Move forward through the jump list |
| / o ? | Search fo text |
| N | Search fo the next result |
| Shift + N | Search fo the previous result |
| O o Shift + O | Open document |
| f | Follow links |
| : | Enter command |
| R | Rotate by 90 degrees |
| Ctrl + R | Recolor (grayscale and invert colors) |
| Shift + R | Reload document |
| Tab | Show index and switch to Index mode |
| d | Toggle dual page view |
| F5 | Switch to presentation mode |
| F11 | Switch to fullscreen mode |
| Ctrl + M | Toggle inputbar |
| Ctrl + N | Toggle statusbar |
| + | Zoom in |
| - | Zoom out |
| = | Zoom to the original size |
| :bmark bookmark-name | Set a bookmark |
| :bdelete bookmark-name | Delete a bookmark |
| :blist bookmark-name | List bookmark |
| Q | Quit |
## Collegamenti
- [https://wiki.archlinux.org/title/Zathura](https://wiki.archlinux.org/title/Zathura)

8
linux/zfs.md
View File

@ -1,8 +0,0 @@
# zfs
## Collegamenti
- [https://ubunlog.com/it/sistema-de-archivos-zfs-instalacion/](https://ubunlog.com/it/sistema-de-archivos-zfs-instalacion/)
- [https://blog.miniserver.it/proxmox/stato-del-raid-zfs/](https://blog.miniserver.it/proxmox/stato-del-raid-zfs/)
- [https://www.lffl.org/2020/05/capire-amministrare-zfs.html](https://www.lffl.org/2020/05/capire-amministrare-zfs.html)
- [https://www.lffl.org/2020/05/introduzione-zfs-parte-2.html](https://www.lffl.org/2020/05/introduzione-zfs-parte-2.html)