Con bucle while:

while read i
do
comando $i
done < archivo

Con bucle for:

Debemos cambiar el caracter de separador de campo por defecto antes de entrar en el bucle:

oldIFS=$IFS      # conserva el separador de campo
IFS=$’\n’             # nuevo separador de campo, el caracter fin de línea
for línea in $(cat archivo)
do
comando
done
IFS=$old_IFS     # restablece el separador de campo predeterminado

El caracter de retorno de carro en vim se expresa como “\r”.

Por ejemplo para sustituir todas las “,” por retornos de carro podríamos usar:

:1,$ s/,/\r/g

Primero debemos saber cual es el path donde debemos configurar el fichero. Para ello ejecutamos:

$ kde4-config –path services

Una vez que sabemos cual es el directorio creamos un fichero .desktop para configurar el servicemenu:

p.ej:

$ vi adjunto.desktop

[Desktop Entry]
Type=Service
ServiceTypes=KonqPopupMenu/Plugin,all/allfiles
Actions=SendAttach

[Desktop Action SendAttach]
Name=Send as attach
Name[es]=Enviar como fichero adjunto
Icon=kmail
Exec=kmail –composer –attach

Pasos a realizar:
1.- Ampliar el disco desde las opciones de la VM.
2.- Comprobar en el Windows que efectivamente se ha aumentado el tamaño del disco y que aparece sin particionar
3.- Reiniciar ordenadamente el Windows
4.- Arrancar la VM con un LiveCD de Linux
5.- Instalar las “ntfsprogs”
6.- Comprobar el estado actual de las particiones del disco con fdisk -l :

debian:~# fdisk -l

Disk /dev/sda: 62.2 GB, 62277025792 bytes
255 heads, 63 sectors/track, 7571 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0xb1cfb1cf

Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1        5222    41945683+   7  HPFS/NTFS

En este caso por ejemplo el disco tiene 62.2 GB  de tamaño total pero la partición es de (5222 cilindros * 8225280 bytes = 40962 MB)

Comprobar el estado de la partición NTFS y del disco con:

debian:~# ntfsresize -i /dev/sda1
ntfsresize v2.0.0 (libntfs 10:0:0)
Device name        : /dev/sda1
NTFS volume version: 3.1
Cluster size       : 4096 bytes
Current volume size: 42952376832 bytes (42953 MB)
Current device size: 42952379904 bytes (42953 MB)
Checking filesystem consistency …
100.00 percent completed
Accounting clusters …
Space in use       : 42888 MB (99.8%)
Collecting resizing constraints …
You might resize at 42887487488 bytes or 42888 MB (freeing 65 MB).
Please make a test run using both the -n and -s options before real resizing!

Vemos que el volumen ocupa lo mismo que el dispositivo por lo que no podemos aumentar el tamaño. Para ello debemos aumentar el tamaño de la partición primero con:

debian:~# fdisk /dev/sda

The number of cylinders for this disk is set to 7571.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of LILO)
2) booting and partitioning software from other OSs
(e.g., DOS FDISK, OS/2 FDISK)

Command (m for help): p

Disk /dev/sda: 62.2 GB, 62277025792 bytes
255 heads, 63 sectors/track, 7571 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0xb1cfb1cf

Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1        5222    41945683+   7  HPFS/NTFS

Command (m for help): d
Selected partition 1

Command (m for help): n
Command action
e   extended
p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-7571, default 1): 1
Last cylinder or +size or +sizeM or +sizeK (1-7571, default 7571):
Using default value 7571

Command (m for help): t
Selected partition 1
Hex code (type L to list codes): 7
Changed system type of partition 1 to 7 (HPFS/NTFS)

Command (m for help): a
Partition number (1-4): 1

Command (m for help): p

Disk /dev/sda: 62.2 GB, 62277025792 bytes
255 heads, 63 sectors/track, 7571 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0xb1cfb1cf

Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1        7571    60814026    7  HPFS/NTFS

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

Comprobamos de nuevo los tamaños de la partición y del disco:

debian:~# ntfsresize -i /dev/sda1
ntfsresize v2.0.0 (libntfs 10:0:0)
Device name        : /dev/sda1
NTFS volume version: 3.1
Cluster size       : 4096 bytes
Current volume size: 42952376832 bytes (42953 MB)
Current device size: 62273562624 bytes (62274 MB)
Checking filesystem consistency …
100.00 percent completed
Accounting clusters …
Space in use       : 42888 MB (99.8%)
Collecting resizing constraints …
You might resize at 42887487488 bytes or 42888 MB (freeing 65 MB).
Please make a test run using both the -n and -s options before real resizing!

Ahora vemos que la partición ocupa menos que lo que tiene el disco.

Probamos la ampliación de la partición con:

debian:~# ntfsresize -n -s62200M /dev/sda1
ntfsresize v2.0.0 (libntfs 10:0:0)
Device name        : /dev/sda1
NTFS volume version: 3.1
Cluster size       : 4096 bytes
Current volume size: 42952376832 bytes (42953 MB)
Current device size: 62273562624 bytes (62274 MB)
New volume size    : 62199992832 bytes (62200 MB)
Checking filesystem consistency …
100.00 percent completed
Accounting clusters …
Space in use       : 42888 MB (99.8%)
Collecting resizing constraints …
Schedule chkdsk for NTFS consistency check at Windows boot time …
Resetting $LogFile … (this might take a while)
Updating $BadClust file …
Updating $Bitmap file …
Updating Boot record …
The read-only test run ended successfully.

Como vemos que está todo correcto procedemos a realizar la ampliación definitiva:

debian:~# ntfsresize -s62200M /dev/sda1
ntfsresize v2.0.0 (libntfs 10:0:0)
Device name        : /dev/sda1
NTFS volume version: 3.1
Cluster size       : 4096 bytes
Current volume size: 42952376832 bytes (42953 MB)
Current device size: 62273562624 bytes (62274 MB)
New volume size    : 62199992832 bytes (62200 MB)
Checking filesystem consistency …
100.00 percent completed
Accounting clusters …
Space in use       : 42888 MB (99.8%)
Collecting resizing constraints …
WARNING: Every sanity check passed and only the dangerous operations left.
Make sure that important data has been backed up! Power outage or computer
crash may result major data loss!
Are you sure you want to proceed (y/[n])? y
Schedule chkdsk for NTFS consistency check at Windows boot time …
Resetting $LogFile … (this might take a while)
Updating $BadClust file …
Updating $Bitmap file …
Updating Boot record …
Syncing device …
Successfully resized NTFS on device ‘/dev/sda1′.

Rebotamos la VM:

debian:~# reboot

Al inicio del Windows se forzará la comprobación del disco con CHKDSK. Debemos dejar que se complete y se reinicie automáticamente.

Cuando haya reiniciado ya tendremos ampliada la partición.

Extraer el último campo de una cadena:

$ cat cadena |  awk ‘{print $NF}’

Lo podemos hacer mediante el programa “multitail”:
#multitail /var/log/messages /var/log/auth.log (Mostrar los dos logs en horizontal)

#multitail -s 2 /var/log/messages /var/log/auth.log (Mostrar los dos logs en vertical)

$ cat tst
a
a
b
c
c
d

$ uniq -d tst        //Muestra las líneas duplicadas
a
c

$ uniq -u tst        //Muestra las líneas no duplicadas
b
d

$ uniq tst           //Borra las líneas duplicadas
a
b
c
d

Establecemos la siguiente variable de entorno:

export HISTTIMEFORMAT=’%F %T ‘

1. fdisk -l

2. Buscamos los discos que tiene al RAID:
mdadm –detail /dev/md0
(o md1 o el metadispositivo que sea)

3. Paramos el RAID
mdadm –stop /dev/md0

4. Desmontamos el sistema de ficheros

5. Reseteamos el superbloque de cada unidad:
mdadm –zero-superblock /dev/sda (o hda, … )
mdadm –zero-superblock /dev/sdX…

$ vi -x fichero_cifrado

$ ulimit -a (Muestra los límites actuales)

Limitar a 20 los procesos de un usuario:

Añadimos en /etc/security/limits.conf:

$ usuario hard nproc 20

Limitar a 50 los procesos creados por los usuarios de un grupo determinado:

@grupo hard nproc 50

Limitar que cualquier usuario sólo pueda estar logado 3 veces:

* hard maxlogins 3

# nslookup
> set type=mx
> server <dominio>

Para mostrar los recursos compartidos de un servidor usamo:

smbclient  -L \\\\servidor\\ -U usuario@dominio

Para acceder a algún recurso compartido:

smbclient  \\\\servidor\\ruta\al\recurso -U usuario@dominio

Para montar un recurso compartido:

Desde consola:

# aptitude install smbfs

# mount -t cifs //netbiosname/sharename /media/sharename -o username=winusername

# mount -t cifs //netbiosname/sharename /media/sharename -o username=winusername,password=winpassword,iocharset=utf8,file_mode=0777,dir_mode=0777

o bien:
# smbmount  //servidor/recurso  /punto/montaje/local  -o user=usuario@dominio
Desde el fstab:

añadimos:

//ntserver/share /mnt/samba smbfs username=username,password=password 0 0

tune2fs – Modificar parámetros de particiones ext2 / ext3

hdparm -tT /dev/sda  -  Medir el rendimiento de un disco

hdparm -i /dev/hda   -  Información sobre la unidad

hdparm -I /dev/hda   -  Información sobre la unidad pero mas verboso

$ssh USUARIO@SERVIDOR “cd /tmp/kk && tar cvz *” > backup.$( date +%y%m%d ).tgz

$ echo -e “GET / HTTP/1.0\n\n\n” | openssl s_client -connect servidor:443 -quiet

$for i in *.pdf; do DESTINO=`pdfinfo $i |grep Title|sed s/”Title:          “//| sed s/’ ‘/’_'/g|sed s/’_'$//g`.pdf; mv $i $DESTINO; done

El comando a usar es xset

Con xset -q obtenemos todos los parámetros disponibles.

Por ejemplo para desactivar el DPMS (opción de ahorro de energía de la pantalla) usaremos xset -dpms.

cat /proc/acpi/thermal_zone/*/temperature

Para preparar el kernel para que admita las sysrq:

echo 1 > /proc/sys/kernel/sysrq

Podemos reiniciar la máquina ejecutando:

echo b > /proc/sysrq-trigger

#!/bin/bash
xhost +
DISPLAY=:0 kdialog –msgbox “Mensaje de prueba”

Programas a usar:

- cp
- dd
- hdparm
- Bonnie++

* 1ª prueba – Resultados de lectura con hdparm:

#hdparm -t /dev/sda

/dev/sda:
Timing buffered disk reads:  304 MB in  3.01 seconds = 100.84 MB/sec

* 2ª prueba – Resultados obtenidos con Bonnie++:

# bonnie++ -u root -d /media/disk/bonnie/ > resultados_bonnie

- La opción -u es obligatoria si lo ejecutamos como root
- La opción -d especifica el directorio en el dispositivo que vamos a testear
- Bonnie++ necesita el doble de la RAM disponible en disco para ejecutarse
- Podemos convertir la salida de Bonnie++ a HTML con la herramienta bon_csv2html incluida en el paquete de Bonnie++:

$ echo amule,1G,7235,96,14431,29,6365,13,8660,94,15455,14,114.1,1,16,10180,98,+++++,+++,15966,99,9428,90,+++++,+++,16314,99 | bon_csv2html > bonnie_amule.html

* 3ª Prueba – Creación de un fichero muy grande (10 GB p.ej.) con distintos tamaños de bloques:

TAMAÑO BLOQUE    CANTIDAD DE BLOQUES
1024        10000000
2048        5000000
4096        2500000
8192        1250000
16384        625000
32768        312500

Lo podemos hacer con un script como el siguiente:

#!/bin/bash

dd if=/dev/zero of=/media/disk/test bs=1024 count=10000000
rm /media/disk/test
dd if=/dev/zero of=/media/disk/test bs=2048 count=5000000
rm /media/disk/test
dd if=/dev/zero of=/media/disk/test bs=4096 count=2500000
rm /media/disk/test
dd if=/dev/zero of=/media/disk/test bs=8192 count=1250000
rm /media/disk/test
dd if=/dev/zero of=/media/disk/test bs=16384 count=625000
rm /media/disk/test
dd if=/dev/zero of=/media/disk/test bs=32768 count=312500
rm /media/disk/test

Las velocidades irán saliendo por stdout a medida que se van creando los ficheros aunque también podemos redirigirlo a un fichero.

* 4ª Prueba – Creación, copia y borrado de ficheros grandes, medianos y pequeños con distintos tamaños de bloque:

Para esta prueba se han utilizado los siguientes ficheros:

- 1 fichero de 2 GB
- 1000 ficheros de 1 MB
- 2000 ficheros de 512 KB
- 15000 ficheros de 64 KB

Creación:

- 1 fichero de 2 GB:
$ time dd if=/dev/zero of=test bs=1024 count=2000000

- 1000 ficheros de 1 MB (Total 1 GB)
$ time for i in $(seq 1 1000); do dd if=/dev/zero of=fichero$i bs=1024 count=1024; done

- 2000 ficheros de 512 KB (Total 1 GB)
$ time for i in $(seq 1 2000); do dd if=/dev/zero of=fichero$i bs=512 count=1024; done

- 15000 ficheros de 64 KB (Total 1 GB)
$ time for i in $(seq 1 15000); do dd if=/dev/zero of=fichero$i bs=64 count=1024;done

Copiado:

$ time cp fichero2GB fichero2GBcopia
$ time cp ficheros1MB/* ficheros1MBcopia/
$ time cp ficheros512KB/* ficheros512KBcopia/
$ time cp ficheros64KB/* ficheros64KBcopia/

Borrado:

$ time rm ficheros2GB
$ time rm ficheros1MB/*
$ time rm ficheros512KB/*
$ time rm ficheros64KB/*

Mostrar todas las Service Console de un servidor ESX:

esxcfg-vswif -l

Deshabilitar una de las Service Console:

esxcfg-vswif -s vswif0

Borrar una de las Service Console

esxcfg-vswif -d vswif0

Crear un disco sin Thin Provisioning:

# vmkfstools -c 50G -d thick /vmfs/volumes/san/vm/thick.vmdk

Crear un disco con Thin Provisioning:

# vmkfstools -c 50G -d thin /vmfs/volumes/san/vm/thin.vmdk

El espacio real que ocupa no aparce con un "ls -lh" sino con un "du -sh".

Clona un disco existente a otro con Thin Provisioning:

# vmkfstools -i /vmfs/volumes/vmfs_volume/VM_name/large_disk.vmdk -d thin /vmfs/volumes/vmfs_volume/VM_name/new_thin_disk.vmdk

#enable
#configure terminal
#line console 0
#exec-timeout <minutos> (0 implica sin timeout)

Creamos un fichero llamado “sender_canonical” en /etc/postfix que contenga:

usuario_a_mapear@dominio_a_mapear  cuenta_de_envio@dominio_de_envio

Por ejemplo:

apache@localhost.localdomain apache@webserver.com

Ejecutamos:

# postmap sender_canonical

Incluimod la siguiente fila en el main.cf:

sender_canonical_maps = hash:/etc/postfix/sender_canonical

Por último ejecutamos:

# postfix reload

postsuper -d numero (eliminar el mensaje)
postsuper -d ALL (eliminar todos los mensajes)
postsuper -r Number (Encolar de nuevo el mensaje)
postsuper -r ALL (Encolar de nuevo todos los mensajes)
postqueue -p (Mostrar la cola de correo por pantalla)
postqueue -f (Hacer un flush de la cola de correo, intentar enviar todos los correos)

El puerto que utiliza el iSCSI es el 3260

Para descubrir un target de iSCSI:

# iscsiadm -m discovery -t sendtargets -p 172.17.1.119

Para ver los targets que se han descubierto:

# iscsiadm -m discovery

Si queremos ver la información almacenada de alguno de los targets:

# iscsiadm -m node –targetname iqn.1992-08.com.netapp:sn.99908572

Para hacer login en el dispositivo iSCSI:

# iscsiadm -m node –targetname iqn.1992-08.com.netapp:sn.99908572 -p 172.17.1.119 -l

Para hacer logout:

# iscsiadm -m node –targetname iqn.1992-08.com.netapp:sn.99908572 -p 172.17.1.119 -u

Obtener información del RAID:

# cat /proc/mdstat

Detalles de las unidades RAID:

# mdadm –query /dev/md0

# mdadm –detail /dev/md0

Detalles de las unidades físicas:

# mdadm –query /dev/sdb1

# mdadm –examine /dev/sdb1

Administración de una RAID y sus discos

* Establecer un disco como faulty/failed:

$ sudo mdadm –fail /dev/md0 /dev/sdb1

No utilizar en RAID0 ó RAID en modo linear. Pueden perderse los datos!

* Quitar un disco fallido de una RAID:

$ sudo mdadm –remove /dev/md0 /dev/sdb1

* Limpiar cualquier información previa de un disco RAID (Ej. al reutilizar un disco de otra raid antigua)

$ sudo mdadm –zero-superblock /dev/sdb1

* Añadir un disco a la RAID

$ sudo mdadm –add /dev/md0 /dev/sdb1

* Añadir soporte “bitmap” a un RAID

$ sudo mdadm –grow /dev/mdX –bitmap=internal

* Quitar el soporte de “bitmap” a un RAID

$ sudo mdadm –grow /dev/mdX –bitmap=none

El fichero de configuración de sudo está en /etc/sudoers

Para editarlo ejecutamos como root “visudo”

Un ejemplo del fichero de configuración es:

**********************************
Defaults env_reset,authenticate,passwd_timeout = 1,passwd_tries = 1,insults,timestamp_timeout=0

root ALL=(ALL) ALL
prueba ALL=(root) ALL

**********************************
usuario host = (nivel_de_ejecucion) comando

El usuario prueba puede ejecutar en cualquier host, con privilegios de root, cualquier comando.

env_reset – resetea las variables de entorno necesarias
authenticate – fuerza que los usuarios se autentifiquen
passwd_timeout = 1 – Tiempo en minutos para introducir la password
passwd_tries = 1 – Número de intentos
insults – Insulta si la pass no es correcta
timestamp_timeout=0 – Tiempo hasta que vuelva a pedir de nuevo la pass (0 es siempre para que la pida siempre)

En Debian, si el usuario está dentro del grupo sudoers, no pedirá la contraseña aunque así esté configurado.

#ssh -vvv -L puerto_tunel:IP_Tunel:puerto_destino IP_destino

#ssh -vvv -L 80:172.22.44.108:80 172.22.44.106

La conexión se realizará posteriormente a http://localhost

SERVIDOR  <——–>  TUNEL  <——–>  CLIENTE
(P.ej: Servidor X)
(Puerto 6000)

ssh -R puerto_tunel:servidor:puerto_servidor -f -N cliente

Desde la máquina local hacemos:

#ssh -L puerto_local:maquina_tercera:puerto_maquina_tercera usuario@maquina_segunda_con_acceso_a_tercera

#ssh -L 80:172.19.5.2:80 usuario@172.19.1.227

Luego haremos las conexiones a http://localhost

La finalidad de los identificadores universales es la posiblidad de identificar información sin una coordinación centralizada. Es el caso por ejemplo de computación distribuida donde podemos usar un UUID para identificar una partición. Los sistemas de ficheros ext2/ext3 usan UUID para identificar las particiones.

De esta forma podemos tener un entorno heterogéneo de tecnologías de almacenamiento (SAN, DAS, iSCSI, …) sin que sea muy complejo el mantenimiento de los mismos (fstab).

No obstante no suele ser muy util en el caso de un equipo de escritorio.

¿Cómo obtenemos el UUID de una determinada partición?

# vol_id –uuid {/dev/device}

Para listar todos los UUIDS:

# blkid

¿Cómo podemos usar los UUIDS?

Los añadimos en el fstab usando la siguiente sintaxis:

UUID={NUESTRO-UID}    {/path/to/mount/point}               {file-system-type}    defaults,errors=remount-ro 0       1

Historial de comandos – q:

Comentar la linea de un codigo C al pulsar ‘v’  -  :map v I//

Mostrar/quitar el numero de cada línea:  :set number  |  :set nonumber

Mostrar/quitar permanentemente el numero de línea:  :set ruler  |  :set noruler

Mostrar todos los parámetros disponibles:  :set all

Tabular a izquierda y derecha:  >  |  <

$(cd /tmp/ && touch kk) – Va al directorio tmp, crea el fichero kk y vuelve al directorio donde estábamos.

$look cadena – Busca esa cadena en las palabras del diccionario

$gpg -c file – Encriptar archivo

$gpg file.gpg – Desencriptar archivo

$tar -c pruebadir/ | gzip >> prueba.tar.gz  -  Crear un .tar.gz al vuelo

$netstat -tupl  -  Listar los servicios de internet de un sistema

$netstat -tup  -  Listar las conexiones activas de/hacia un sistema

$ls -lSr  -  Mostrar archivos de menor a mayor tamaño

$dpkg-query -W -f=’${Installed-Size;10}\t${Package}\n’ | sort -k1,1n (Paquetes instalados por tamaño)

$lsof -p $$  -  Listar las rutas que abrió el id de proceso

$lsof ~  -  Listar procesos que solicitaron apertura de rutas

$ps -e -o pcpu,cpu,nice,state,cputime,args –sort pcpu | sed ‘/^ 0.0 /d’  -  Listar procesos por % de CPU

$ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS  -  Listar procesos por uso de memoria

$last reboot  -  Ver historia de reencendido del sistema

$free -m  -  Ver cantidad de RAM libre (-m muestra en MB)

kdialog –title “Añadiendo feed a Akregator” –radiolist “Seleccione el grupo en el que incluir el feed:” Linux “Linux” on Tecnologia  “Tecnologia” off Iphone “Iphone” off Seguridad “Seguridad” off Blogs “Blogs” off` – Crear ventana con lista de selección

$for i in *.*; do mv “$i” `echo $i|tr ‘ ‘ ‘_’`; done  -  Sustituir espacios por guiones en una serie de ficheros

#lspci -v
#cat /proc/cpuinfo
#cat /proc/meminfo
#dmidecode

Usamos el comando sysctl:

#sysctl -a : Muestra todos los parámetros configurables del kernel
#sysctl cadena : Muestra todos los parámetros configurables qu empiecen por “cadena”
#sysctl -n : Saca sólo los valores de las variables o parámetros
#sysctl -N : Saca sólo los nombres de las variables o parámetros
#sysctl -w variable=valor : Cambia el valor de una variable. Por ejemplo:
#sysctl -w net.ipv6.conf.all.forwarding=1

Sysctl toma los valores en el arranque del fichero /etc/sysctl.conf.

Podemos cargar en cualquier momento este fichero con la opción: #sysctl -p

Uno de los parámetros existentes es “kernel.shmax” con un valor por defecto en Debian de 33554432 bytes (32 MB) y se refiere al tamaño máximo del segmento de memoria compartida. (Un valor orientativo podría ser RAM*0,5)

Un buen programa para generar ruido blanco en Linux es Whitenoise (http://pessimization.com/software/whitenoise/).

Por ejemplo para emular el sonido del interior de una cabina de avión:

whitenoise -F 4 -c 0.1 -r 11025

Con k3b deberemos añadirle el siguiente parámetro al comando growisofs:

-use-the-force-luke=break:1913760

Si queremos hacerlo desde la consola usaremos el siguiente comando:

$growisofs -use-the-force-luke=break:1913760 -dvd-compat -speed=2 -Z /dev/hdd=image.iso

hdd – Unidad de DVD
image.iso – Imagen del juego

#tcpdump -A – Muestra el contenido de los paquetes en formato ASCII

#tcpdump -X – Muestra el contenido de los paquetes en formato ASCII y en hexadecimal

Podemos quitar el modulo ehci-hcd

#rmmod ehci-hcd

De esta forma el USB se convertirá enUSB 1.0. ( 9 Mbps )

Otra posible solución es montar el dispositivo de manera síncrona:

/dev/sda1 /media/sda1 auto sync,noauto,user,exec 0 0

1. Arrancamos en modo a prueba de fallos; #Montamos la unidad raiz como /a
2. cd /a/platform/i86pc ; mv boot_archive boot_archive_bad
3. cd /
4. bootadm update-archive -R /a
5. shutdown -i 6

mac Fichero.ape Fichero.wav -d

lame –preset standard Fichero.wav

mp3splt Fichero.mp3 -c Fichero.cue

1.- about:config

2.- right-click

3.- choose New –> String

4.- new string: network.protocol-handler.app.mailto

5.- new value: /usr/bin/kmail

Usaremos el programa “iperf”

Una vez instalado en ambos hosts usaremos uno como servidor ejecutando:

$ iperf -s

Y otro como cliente con:

$ iperf -c nodo1

Configurando IPerf.

Podemos configurar tanto el cliente como el servidor para personalizar un poco las mediciones.

Como servidor.

A parte de la opción -s que deja a IPref a la escucha, podemos usar:

* -D como servicio
* -R remover servicio
* -u recibir datagramas UDP en vez de TCP por defecto.
* -P x número de conexiones simultáneas
* -m muestra MTU (depende del sistema operativo )
* -w specifica el tamaño de Ventana (TCP window size). Muy útil para ir calculando nuestro tamaño de ventana más óptimo según las mediciones de ancho de banda.
* -f[bkmBKB] mostrar resultados en bits/s, kilobits/s, megabytes/s, Bytes/s, KiloBytes/s, MegaBytes/s (s=segundos). Tanto en cliente como servidor:

>iperf -c 192.168.1.250 -f B
————————————————————
Client connecting to 192.168.1.250, TCP port 5001
TCP window size: 64512 Byte (default)
————————————————————
[844] local 192.168.1.30 port 3591 connected with 192.168.1.250 port 5001
[ ID] Interval Transfer Bandwidth
[844] 0.0-10.0 sec 118792192 Bytes 11860687 Bytes/sec

Como cliente.

Lo más básico es -c IP pero podemos establecer otras opciones, las más importantes:

* -f[bkmBKB] (igual que lo comentado como servidor)
* -w (lo mismio que para servidor)
* -m muestra MTU (depende del sistema operativo)
* -T ttl especifica valor TTL
* -i segundos especifica un intervalo, medido en segundos, en el cual se volverá a realizar la medición.
* -t segundos tiempo duración transmisión. Hace más fiable la medida.

>iperf -c 192.168.1.250 -t 60
————————————————————
Client connecting to 192.168.1.250, TCP port 5001
TCP window size: 63.0 KByte (default)
————————————————————
[844] local 192.168.1.30 port 3670 connected with 192.168.1.250 port 5001
[ ID] Interval Transfer Bandwidth
[844] 0.0-60.0 sec 669 MBytes 93.5 Mbits/sec

* -p especifica puerto en el que escucha el servidor
* -u envio de UDP en vez de TCP por defecto. Podemos medir también pérdida de paquetes

#ndd -get /dev/hme link_status

o

#kstat -p | grep link_ | grep bge

Deshabilitar el inicio automático del entorno gráfico CDE en el arranque:

#/usr/dt/bin/dtconfig -d   (Ver /usr/dt/bin/dtconfig –help para mas detalles)

Configurar la mascara de una interfaz de red física:

Modificamos el fichero /etc/inet/netmask y le añadimos una línea como la siguiente:

172.22.44.0     255.255.255.0

Cambiar el hostname:

Debemos modificarlo en los siguientes ficheros:

/etc/nodename
/etc/hostname.*interface
/etc/inet/hosts
/etc/inet/ipnodes

y renombramos el directorio bajo /var/crash

# cd /var/crash
# mv oldname newname

Rebotamos el servidor.

Monstar ISO:

# lofiadm -a /software/isos/belenix.iso /dev/lofi/1

# mount -F hsfs -o ro /dev/lofi/1 /mnt

Mirror entre 2 discos internos, utilizando Solaris Volume Manager o Disk Suite

Mirror entre 2 discos internos, utilizando Solaris Volume Manager o Disk Suite en versiones anteriores a solaris 9. Este procedimiento fue probado en Solaris 8, Solaris 9 y Solaris 10.
En este ejemplo, el equipo tiene 2 discos internos de 72 gb.
Vamos a usar el disco c1t0d0 como disco primario y el c1t1d0 como disco de mirror.
Como primer paso ejecutamos el comando format para ver el nombre de los discos a mirrorear.
format ( a continuacion, la salida del comando)
AVAILABLE DISK SELECTIONS:
0. c1t0d0
/pci@1c,600000/scsi@2/sd@0,0
1. c1t1d0
/pci@1c,600000/scsi@2/sd@1,0
Specify disk (enter its number):

Selecciono el disco a verificar,y tipeo part y luego print, para chequear las particiones usadas en el disco elegido.
El disco c1t0d0, tiene 3 particiones usadas, el slice 0 para el fs /, el slice 1 para el swap y el slice 3 para el fs /u00. Se necesita como minimo 2 State Database REplicas por disco. que es donde DiskSuite va a almacenar los datos de configuracion e informacion de Disksuite o Solaris Volume Manager.
Por eso voy a usar el slice 6 y 7 del disco, con 25 mb para cada slice. Para esta tarea uso el comando format.
Posteriormente, voy a copiar toda la informacion contenida en el disco c1t0d0 (slices,tamaño,etc) en el disco que se usara como mirror, en este caso el c1t1d0
prtvtoc /dev/rdsk/c1t0d0s2 | fmthard -s – /dev/rdsk/c1t1d0s2
Chequeo que lo haya hecho con el comando format.
Luego de eso, creo los state databse replicas, de la siguiente manera
metadb -a -f -c 2 /dev/dsk/c1t0d0s6 /dev/dsk/c1t1d0s6
metadb -a -f -c 2 /dev/dsk/c1t0d0s7 /dev/dsk/c1t1d0s7

donde -a significa adding
-f significa force, porque es la primera vez que se esta creando las bases.
-c 2 ( con espacio entre la c y el 2), significa que crea 2 databases en cada slices.

metainit -f d10 1 1 c1t0d0s0

metainit -f d20 1 1 c1t1d0s0

metainit d30 -m d10

Luego hago una copia del archivo original /etc/vfstab
cd /etc
cp vfstab vfstab.antesdeponer.DiskSuite
more vfstab
#device         device          mount           FS      fsck    mount   mount
#to mount       to fsck         point           type    pass    at boot options
#
fd      -       /dev/fd fd      -       no      -
/proc   -       /proc   proc    -       no      -
/dev/dsk/c1t0d0s1       -       -       swap    -       no      -
/dev/dsk/c1t0d0s0       /dev/rdsk/c1t0d0s0      /       ufs     1       no      -
swap    -       /tmp    tmpfs   -       yes     -

Luego con el comando metaroot agrego en el vfstab el metadevice d30 que sera el nuevo punto de montaje del filesystem / ( root)
metaroot d30
cat /etc/vfstab
#device         device          mount           FS      fsck    mount   mount
#to mount       to fsck         point           type    pass    at boot options
#
fd      -       /dev/fd fd      -       no      -
/proc   -       /proc   proc    -       no      -
/dev/dsk/c1t0d0s1       -       -       swap    -       no      -
/dev/md/dsk/d30 /dev/md/rdsk/d30        /       ufs     1       no      -
swap    -       /tmp    tmpfs   -       yes     -

Continuo con el mirror de los demas slices

metainit -f d11 1 1 c1t0d0s1
metainit -f d21 1 1 c1t1d0s1
metainit d31 -m d11

metainit -f d12 1 1 c1t0d0s3
metainit -f d22 1 1 c1t1d0s3
metainit d32 -m d12

Con el siguiente comando, creo un hotspare pool, de esta manera evito warnings en el messages. metainit hotsp01
Agrego en el vfstab todos los fs que quedaron con disksuite como por ejemplo el slice 3 que es el /u00 /dev/md/dsk/d32 5271150 9 5218430 1% /u00
rebooteo
lockfs -fa
init 6

luego continuo con la ultima parte del mirror, que consiste en atachar los submirror al mirror
metattach d30 d20
metattach d31 d21
metattach d32 d22

Por ultimo, instalo el sector de booteo en el disco que sera utilizado como mirror,y seteo parametros en la eeprom con el comando eeprom

installboot /usr/platform/`uname -i`/lib/fs/ufs/bootblk /dev/rdsk/c1t1d0s0
eeprom “boot-device=disk0 disk1″
eeprom use-nvramrc?=false

#update-rc.d -f exim4 remove

$ sed -i s/cadena_a_buscar/cadena_a_sustituir

Capturar el tráfico con destino una red determinada:

tcpdump dst net 192.168.1.0

Capturar el tráfifco con origen una red determinada

tcpdump src net 192.168.1.0/28

Capturar el trafico con origen y destino una red determinada

tcpdump dst net 192.168.1.0

Capturar todo el tráfico con destino al puerto 23

tcpdump dst port 23

Capturar todo el tráfico con destino o origen puerto 80

tcpdump port 23

Capturar el todo los paquetes icmp

tcpdump ip proto \\ip

Capturar todo el tráfico udp

tcpdump ip proto \\udp
tcpdump udp

Capturar todo tráfico ip

tcpdump -n ether proto \\ip
tcpdump -n ipi

Capturar el tráfico Web

tcpdump tcp and port 80

Capturar las peticiones de DNS

tcpdump udp and dst port 53

Capturar el tráfico al puerto telnet o SSH

tcpdump tcp and \(port 22 or port 23\)

Capturar todo el tráfico excepto el web

tcpdump tcp and not port 80
tcpdump tcp and ! port 80

Podemos especificar la interfaz por la que capturar el tráfico con:

tcpdump -i eth0 port 80

alias webshare=’python -c “import SimpleHTTPServer;SimpleHTTPServer.test()”‘