Faq

file1_tmp.sh
file2_tmp.sh
...
file99_tmp.sh

 rename 's/_tmp//' *.sh

To redirect the standard error of a shell command, just use the following syntax:

ls file-that-does-not-exist 2>&1 | grep file

Or even better not to have on the terminal the standard error just throw it in /dev/null

ls file-that-does-not-exist 2>/dev/null

The standard open or standard streams that are automatically opened are:

• 0 standard input
• 1 standard output
• 2 standard error

With Bash to explicitly declare an array you have to use

declare -A mioarray

To have the value of element 5 just write

echo $[mioarray[5]

While to change the value you have to write

mioarray[5]='new value'

${mioarray[*]} o ${mioarray[@]} is expanded by all array values while $[#mionome[@]} is expanded with the length of the array

What can we do with the arrays? For example, store the output of a command whose line we would like to go to a different item.

IFS=$'\n' mioarray=($(ls -alh))

At this point we can print output as

 IFS=$'\n' echo "${mioarray[*]}"

Attention: Double quotes are important for not having the output on a single line.

Doing so we could do several tests on the same captured output once.

To declare an associative array, you must do so

declare -A mioarray

and as an index you can use a string, this means that

mioarray[test]='aa'
echo ${mioarray[test]} # returns 'aa'

Suppose we are working on a bash script and that for some need, not too difficult from reality, it is essential to have to convert a number or a decimal variable into a binary number.

There are of course several solutions but the one I propose does not make use of external programs but it is bash in all respects.

First we need to know the maximum value of the binary number to be obtained in Bash or in how many bits it can be included.

We consider that we are talking about a byte and therefore 8 bits and that its binary range will go from 00000000 to 11111111 (from 0 to 255) then we can write:

bin=({0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1})
echo ${bin[*]}

The more is done, in fact, to have the result for example of the number 125 or 78 in binary is enough

echo ${bin[125]}
01111101
echo ${bin[78]}
01001110

If the range of the binary number changes, for example if we double or quadruple it is enough that we define the bin variable with one or two more blocks of the type {0..1}.

So summing up, the bin variable will have to contain as many blocks {0..1} based on the maximum binary number to be obtained, that is, if the maximum number is 2ⁿ -1 then it will take n groups {0..1}.

As an example if n=10 and therefore 2¹⁰ -1=1023 the blocks will be 10

bin=({0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1})
echo ${bin[1023]}
1111111111

As for the faq with the conversion to binary, also in this we make use of the fantastic bash braces extensions to convert to hexadecimal.

So, always considering the bash faq on the binary we start initially by converting a decimal number between 0 and 255 which corresponds to a hexadecimal digit between 0 and FF:

hex=({{0..9},{a..f}}{{0..9},{a..f}})
echo ${hex[*]}

At this point to get the result of the number 200 or 21 is enough

echo ${hex[200]}
c8
echo ${hex[21]}
15

If the range of the hexadecimal number changes, for example if we double or quadruple it is enough that we define the hex variable with one or two more blocks of the type {0..9}, {a..f}.

So summing up, the hex variable will have to contain many blocks {0..9}, {a..f} based on the maximum binary number to be obtained, that is, if the maximum number is 16ⁿ -1 then it will take n groups {0. .9}, {a..f}.

As an example if n=4 and therefore 16⁴ -1=65535 the blocks will be 4

hex=({{0..9},{a..f}}{{0..9},{a..f}}{{0..9},{a..f}}{{0..9},{a..f}})
echo ${hex[60000]}
ea60
echo ${hex[37]}
0025

To switch from an IPV4 netmask to the equivalent CIDR it might occur to do the simplest thing, that is to use a nested “case” block or “if” to obtain the equivalent CIDR so much so that the available netmasks or CIDR are only 32 and that is

If we want instead create a function that converts the netmask to CIDR we need to know how to convert a decimal number to binary first.

fromNetmaskToCidr() {
  local netmask=$1
  local bin=({0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1}{0..1})
  local b=''
  local n
  local cidr
  for n in ${netmask//./ }; do
    if [ $n -gt 255 ]; then
      echo -e "\t[ERROR] netmask $netmask format error in '.$n'. I will use .255 insted of .$n"
      n=255
    fi
    if [ $n -ne 0 -a $n -ne 128 -a $n -ne 192 -a $n -ne 224 -a $n -ne 240 -a $n -ne 248 -a $n -ne 252 -a $n -ne 254 -a $n -ne 255 ]; then
      echo -e "\t[ERROR] netmask $netmask format error in '.$n' (it must be 0,128,192,224,240,248,252,254,255). I will use .255 insted of .$n"
      n=255
    fi
    # $b is the binary of $netmask
    b=${b}${bin[$n]}
  done
  # remove right "0" bits from $b
  b=${b/%0*}
  cidr=${#b}
  echo $cidr
}

What we do is convert the 4 octets of the netmask into binary and put them in series in the only variable “b” then remove the 0 bits present on the right of the overall binary number.
Finally, just count the number of bits left to get the CIDR which will then be returned on exit.

References

• netmask;
• Classless Inter-Domain Routing (CIDR);
• IPV4;
• octets.

Suppose you want to add a disk or partition in the Linux LVM handler and create a volume group named “quollvg” with a logical volume called “quolllv” of size 50GB.

Check the list of disks with the command:

fidisk -l

Suppose that /dev/sdb is the disk you want to add

We launch the command (lvm)

pvcreate /dev/sdb

If we are going to use a partition, such as disk 1, after creating and associating type 83 (LVM) we use the command:

pvcreate /dev/sdb1

At this point we create the volume group and the logical volume, format and mount the new disk:

vgcreate quollvg /dev/sdb
lvcreate -L 50G -n quolllv quollvg
mkdir /quolllv
mkfs.ext4dev -m 1 /dev/quolvg/quollv
mount /dev/mapper/quollvg-quolllv /quolllv

To see the status of logical volume and volume group:

lvdisplay
vgdisplay

Supponiamo di aver un volume group LVM di nome “quollvg” pieno o quasi pieno e di voler aggiungere dell’altro spazio avendo a disposizione un altro disco o un’altra partizione libera.

Supponiamo che il disco libero sia /dev/sdc (o /dev/sdc1) allora quello che dobbiamo fare è semplicemente:

pvcreate /dev/sdc
vgextend quollvg /dev/sdc

Supponiamo di voler aumentare di 10G la dimensione della partizione ext4 del volume logico “quolllv” appartenente al volume group “quollvg”.

Per prima cosa controlliamo che il volume group “quollvg” abbia almeno 10GB liberi (sarebbe bene per un system administrator lasciare sempre libero in ogni volume group almeno dal 3% al 5% dello spazio nel caso in cui serva fare una snap per il backup o per qualche altro motivo)

vgdisplay quollvg

e controllare la sezione “Free PE / Size” per verificare che ci sia spazio disponibile.

Usare il comando per allargare il logical volume “quolllv“:

lvresize -L +10G /dev/quollvg/quolllv

A questo punto il logical volume “quolllv” è più grande di 10GB; bisogna quindi farlo sapere anche al file system ext4:

resize2fs /dev/mapper/quollvg-quolllv

Il resize2fs viene fatto anche caldo (a disco montato) quindi non preoccupatevi se è occupato da altro e non può esser smontato

Supponiamo di voler creare una snapshot del logical volume “quolllv” già esistente appartenente al volume group “quollvg“.

Controlliamo prima che ci sia spazio a sufficienza nel volume group:

vgdisplay quollvg

Controlliamo che “Free PE / Size” non sia tutto già occupato e supponiamo di avere 5GB di spazio da poter utilizzare per la snapshot:

lvcreate -L +5G -s -n "quolllv_snap" /dev/quollvg/quolllv

A questo punto abbiamo a disposizione la snapshot come verificabile digitando il comando:

lvdisplay

Possiamo quindi montarla ed utilizzarla:

mkdir /snap
mount /dev/mapper/quollvg-quolllv_snap /snap

Dopo averci lavorato (ad esempio dopo il backup) possiamo tranquillamente eliminare la snapshot:

umount /snap
lvremove -f /dev/quollvg/quolllv_snap
rmdir /snap

Let’s consider the case where the signed document is a pdf (document.pdf.p7m).

To extract the content file we use the openssl command with the smime parameter for signature verification (-verify)

openssl smime -verify -noverify -in document.pdf.p7m -inform DER -out document.pdf

For more information, see the articol

Let’s consider the case where the signed document is a pdf (document.pdf.p7m).

To extract the certificate used to sign the p7m we use the openssl command with the pkcs parameter

openssl pkcs7 -inform DER -in document.pdf.p7m -print_certs -out cert.pem

The certificate will be extracted in the cert.pem file. If you want to display textually enough the certificate command x509

openssl x509 -in cert.pem -text -noout