Archivo

Entradas Etiquetadas ‘Bash’

mayúsculas y minúsculas en BASH (toupper(), tolower()) [copia y pega]

Martes, 13 de Marzo de 2012 Gaspar Fernández Sin comentarios

mayuscula En ocasiones, es muy útil crear scripts en bash, aunque en ocasiones debemos controlar las mayúsculas y minúsculas, por ejemplo renombrando archivos, escribiendo informes o para ajustarse a diferentes convenciones a la hora de hacer un programa. Aquí dejo ejemplos de funciones tipo strtoupper(), strtolower(), por decir un equivalente en PHP.

Hay opciones, la elección de alguna de estas opciones depende del entorno en que nos encontremos, ya sea BASH, algún otro clon, y dispongamos de awk o tr.

La primera de ellas es para poner un texto en mayúsculas:

1
2
3
4
function uppercase()
{
    echo "$1" | awk '{print toupper($0)}'
}

Otra opción puede ser:

1
2
3
4
function uppercase()
{
    echo "$1" | tr 'a-z' 'A-Z'
}

Si usamos la versión 4.0 o superior de BASH, que ya tiene un tiempo, podemos hacer lo siguiente:

1
2
3
4
function uppercase()
{
    echo "${^^*}"
}

La segunda de ellas para poner un texto en minúsculas:

1
2
3
4
function lowercase()
{
    echo "$1" | awk '{print tolowe($0)}'
}

Otra opción puede ser:

1
2
3
4
function lowercase()
{
    echo "$1" | tr 'A-Z' 'a-z'
}

Si usamos bash 4.0 o superior podemos hacerlo mucho más fácil!

1
2
3
4
function lowercase()
{
     echo "${1,,*}"
}

Números grandes en C usando GMP. Resolución del primer reto de #tuentiContest (Super Hard Sum)

Viernes, 24 de Junio de 2011 Gaspar Fernández Sin comentarios

Aquí llega mi primera aportación a las soluciones de los retos del I concurso de programación de Tuenti. La utilización de números grandes es algo que siempre me llamó la atención, y normalmente utilizo bc cuando necesito algún cálculo. Este reto se podía resolver con bash/sed/bc y, aunque varios lenguajes permiten la utilización de números de precisión arbitraria “de serie”  como python y Java, yo decidí hacerlo en C, utilizando la biblioteca GMP.

En un lenguaje como C, es normal que no podamos utilizar números de precisión arbitraria con los operadores normales (+, -, *,…), en este caso tendremos que hacer llamadas a funciones de la biblioteca para realizar las operaciones, tampoco podremos utilizar un printf() normal para mostrarlos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/**
*************************************************************
* @file hardsum.c
* @brief Tuenti Contest Test Phase
* Sum numbers separated by space line by line
*
* @author Gaspar Fernández <blakeyed@totaki.com>
* @version 0.0.2
* @date 12 jun 2011
*
* http://totaki.com/poesiabinaria
*
*************************************************************/


#include <stdio.h>
#include <string.h>
#include <gmp.h>

/* Huge string */
#define STRSIZE 1000

int main()
{
  char bigstr[STRSIZE];
  mpz_t tmp, sum;
  char * token;

  /* Initialize gmp numbers */
  mpz_init(tmp);
  mpz_init(sum);
 
  /* Read until EOF in stdin */
  while (fgets(bigstr, STRSIZE, stdin)!=NULL)
    {
      /* reset sum */
      mpz_set_si(sum, 0);
      token=strtok(bigstr, " \n");
      while (token!=NULL)
        {
          gmp_sscanf(token, "%Zd", &tmp); /* Extract number from token string */
          mpz_add(sum, sum, tmp);         /* Adds numbers */
          token=strtok(NULL, " \n");
        }
      gmp_printf("%Zd\n", sum);
    }

   return 0;
}

Para compilar, debemos incluir gmp:

$ gcc -o hardsum hardsum.c -lgmp

Para utilizar este tipo de variables numéricas, primero tendremos que inicializarlas con mpz_init(), otras funciones interesantes son:

  • mpz_set_si(): inicializa el número con un valor entero.
  • gmp_sscanf(): igual que scanf(), pero con la posibilidad de utilizar estas nuevas variables.
  • mpz_add(): realiza la suma de dos números
  • gmp_printf(): igual que printf(), pero con la posibilidad de utilizar estas nuevas variables.

GMP tiene muchísimas funciones para realizar gran cantidad de operaciones, se puede consultar la documentación aquí.

Now playing… para mplayer

Domingo, 14 de Noviembre de 2010 Gaspar Fernández Sin comentarios

screenshot-14-11-2010-201150Se trata de un script para bash que representará en pantalla información del archivo que se está reproduciendo al mismo tiempo que este se visualiza. Perfecto para un sistema mediacenter.

Requerimientos:

  • bash >=3.0
  • mplayer
  • xosd
  • utilidades de sistema utilizadas: date, sed, tr, cut, sleep

Entre sus características destaca la escritura de un archivo: $HOME/.videolog con los archivos que se reproducen. Uno de los posibles usos es la descarga de muchos vídeos de youtube en un directorio concreto, posterior visualización y borrado de cada uno de los archivos tras su visionado.

Además, si el archivo de audio o vídeo a reproducir contiene metadatos de Artista y Título, se visualizará la información de estos metadatos siempre que no estén en la lista negra (variable $ARTISTAS_PROHIBIDOS), en otro caso visualizaremos el nombre del archivo arreglado (eliminando las cadenas que aparecen en la variable FILENAME_RECORTADO, aquí podemos incluir extensiones o pequeñas anotaciones sobre la calidad o resolución de un vídeo).

Se recomienda modificar XOSD_OPTIONS_ARTISTA, XOSD_OPTIONS_TITULO, XOSD_OPTIONS_INFO y XOSD_OPTIONS_DURACION de acuerdo a los tipos de letra, colores y todo lo que se desee. Dejo una pequeña referencia de las opciones de osd_cat:

–pos Posición del texto: top(arriba), middle(en medio de la pantalla), bottom(abajo)
-A Alineación del texto: left(izquierda), center(centrado), right(derecha)
-c Color: puede ser en notación html #rrggbb o por su nombre
-s Offset o desplazamiento de la sombra
-o Offset o desplazamiento desde la parte superior o inferior de la pantalla
-d Tiempo en segundos que se mantendrá el texto en la pantalla
-f Tipo de letra. Para ver los tipos de letra disponibles ejecutar xfontsel.

Inicio del archivo: mplayernp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
#!/bin/bash

##########################################################################
#
# MPLAYER NOW PLAYING version 0.1
# Copyright (C) 2010 by Gaspar Fernández <gaspy at totaki.com>
# http://totaki.com/poesiabinaria
#
##########################################################################

#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License.

#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.

#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.

XOSD_OPTIONS_ARTISTA="--pos=bottom -A left -c #fff -o -110 -s 2 -d 10 -f -*-utopia-*-*-*-*-*-520-*-*-*-*-*-*"
XOSD_OPTIONS_TITULO="--pos=bottom -A left -c #fff -o -100 -s 2 -d 10 -f -*-utopia-*-*-*-*-*-420-*-*-*-*-*-*"
XOSD_OPTIONS_INFO="--pos=bottom -A left -c #fff -s 2 -o -80 -d 10 -f -*-utopia-*-*-*-*-*-320-*-*-*-*-*-*"
XOSD_OPTIONS_DURACION="--pos=bottom -A left -c #fff -s 2 -o -60 -d 10 -f -*-utopia-*-*-*-*-*-220-*-*-*-*-*-*"

# Si precalculamos esto, damos velocidad
ESCAPE=`echo -e "\e"`

ARTISTAS_PROHIBIDOS=("virtualdub")
FILENAME_RECORTADO=(".avi" ".flv" ".mp3" ".mp4")

function print_info()
{
    artist="$1"
    title="$2"
    filename="$3"
    width="$4"
    height="$5"
    fps="$6"
    minutos="${7/./,}"      # Si nuestra locale es es_ES debemos sustituir puntos por comas
    segundos="${8/./,}"
    if [[ -n $artist ]]
    then
    artist_text=${info_val[$artist]}
    for proh in ${ARTISTAS_PROHIBIDOS[*]}
    do
        if [[ `echo $artist_text | tr [:upper:] [:lower:]` =~ $proh ]]
        then
        artist="";
        title="";
        break;
        fi
    done
    fi

    if [[ -n $artist ]]
    then
    echo $artist_text | osd_cat $XOSD_OPTIONS_ARTISTA &
    fi
    if [[ -n $title ]]
    then
    title_text=${info_val[$title]}
    echo $title_text | osd_cat $XOSD_OPTIONS_TITULO &
    else
    # Si no tenemos la codificación correcta configurada, esto puede saltar
#   fname=`basename "$filename"`
#   dname=`dirname "$filename"`
#   defname=`ls "$dname/$fname"*`
#   defname=`basename "$defname"`
    defname=`basename "$filename"`
    for recorte in ${FILENAME_RECORTADO[*]}
    do
        defname=${defname/$recorte/}
    done
    echo $defname | osd_cat $XOSD_OPTIONS_TITULO &
    fi
    if [[ -n $fps ]]
    then
    echo $width"x"$height"@"$fps | osd_cat $XOSD_OPTIONS_INFO &
    fi
    duracion=`printf "%1.0f:%1.0f" "$minutos" "$segundos"`
    echo $duracion | osd_cat $XOSD_OPTIONS_DURACION &

    echo "`date +"%d/%m/%Y %H:%M"` Media: $filename Dur: $duracion" >> $HOME/.videolog

}

function keyvalue()
{
    key=`echo "$1" | cut -d= -f1`
    value=`echo "$1" | cut -d= -f2`

    res[0]=$key;
    if [[ -n $value ]]
    then
    res[1]=$value;
    else
    res[1]="0";
    fi

    if [[ -n `echo $key | grep "ID_CLIP_INFO_NAME\|ID_CLIP_INFO_VALUE"` ]]
    then
    # Si tenemos un ID_CLIP_INFO_NAMEx o ID_CLIP_INFO_VALUEx extraemos el x
    info=(`echo $key | sed -n -e "s/\([a-zA-Z_]*\)\([0-9]*\)/\1\n\2/p"`)
   
    res[0]=${info[0]}
    res[2]=${info[1]}
    fi
    echo -e ${res[0]}"\n"${res[1]}"\n"${res[2]}"\n"


}

function tituladora()
{

artist="";
title="";
while read -n 200 dato 
do
    if [[ -n `echo $dato | grep ID_` ]] # Extraemos información de mplayer
    then
    OLD_IFS=$IFS;
    IFS="
"
;
    kval=( `keyvalue $dato` );
#   echo ${kval[0]} "********"
    IFS=$OLD_IFS

    case ${kval[0]} in
        "ID_FILENAME")
        filename="${kval[1]}"          
        ;;
        "ID_VIDEO_WIDTH")
        width=${kval[1]}
        ;;
        "ID_VIDEO_HEIGHT")
        height=${kval[1]}
        ;;
        "ID_VIDEO_FPS")
        fps=${kval[1]}
        ;;
        "ID_LENGTH")
        seconds=${kval[1]};
        # Extrae la duración en minutos y segundos
        duration=( `echo "scale=0; $seconds / 60; scale=0; $seconds % 60" | bc` )
        ;;
        "ID_CLIP_INFO_NAME")
        if [[ `echo ${kval[1]} | tr [:upper:] [:lower:]` == "artist" ]]
            then
#           echo "ARTISTA CAPTURADO "${kval[2]};
            artist=${kval[2]} # Donde encontramos el artista
        else
            if [[ `echo ${kval[1]} | tr [:upper:] [:lower:]` == "title" ]]
            then
            title=${kval[2]} # Donde encontramos el artista
#           echo "TITULO CAPTURADO"
            fi
        fi
        ;;
        "ID_CLIP_INFO_VALUE")
        # Almacenamos el valor obtenido
#       echo "ALMACENO EN "${kval[2]} "ESTO" ${kval[1]} "**" ${kval[0]} ${kval[2]} = ${kval[1]}
        info_val[${kval[2]}]="${kval[1]}"
        ;;
    esac
#   echo ${info_val[@]}
    else
    # Si encontramos caracteres de control....
    if [[ $dato =~ $ESCAPE ]]
    then

        # Tal vez podamos comentar esto para dar velocidad --- INICIO
        if [[ $dato =~ "Position" ]]
        then       
        printf "%s\n" "$dato"
        else
        printf "%s" "$dato"
        fi
        # Tal vez podamos comentar esto para dar velocidad --- INICIO
    else
        if [[ ${dato:0:3} == "AO:" ]] # Aquí empieza el Audio... saltaremos tanto para archivos de audio como
                                      # para vídeos / películas... que también tengan audio
        then
        # Empieza la reproducción
        sleep 1 && print_info "$artist" "$title" "$filename" "$width" "$height" "$fps" "${duration[0]}" "${duration[1]}"
        fi

        echo $dato;
    fi
    fi
done
}
mplayer -identify $@ | tituladora

Por último, para utilizar este programa, podemos crear un alias a mplayer:

alias mplayer=”mplayernp”

Para finalizar dejo algúnos ejemplo de uso (son válidos también para mplayer, ya que mplayernp pasa los comandos tal cual a mplayer:

1
2
# Para reproducir archivos dentro de un directorio con orden aleatorio y en pantalla completa
mplayernp -fs `ls /directorio/*.avi | sort -R`

Vídeo de la foto: El Hombre de Negro - Greenfield

Descargar álbumes Picasa sin Picasa, sin Java y sin ningún programa extra

Martes, 15 de Junio de 2010 Gaspar Fernández 2 comentarios

fotofotoUn buen sistema para compartir fotos es Picasa, de Google; aunque puede que no seamos usuarios de Google, ni tengamos el programa instalado en nuestro equipo, pero queramos descargar un álbum de fotos por completo.

Presento otro de mis scripts rápidos (no está optimizado, tal vez sea lento, pero hace el apaño) para descargar las fotos de un álbum Picasa. Lo que necesitamos es el RSS del álbum, lo descargamos en algún directorio y ejecutamos el siguiente script:

1
2
3
4
for i in `sed -e 's/\/>/\/>\n/g' archivo.rss | sed -n -e 's/.*<media:content url='"'"'\(.*\)'"'"' height=.*/\1/p'`
do
  wget $i;
done

Donde archivo.rss es el archivo que acabamos de descargarnos. Sólo utilizamos sed para parsear mínimamente el rss y wget para descargar las fotos.

El parseo no es del todo óptimo, primero introducimos saltos de línea y luego, leemos todo lo que empiece por

Foto: dariuszman86 (Flickr)

Uso de llaves en BASH

Sábado, 15 de Mayo de 2010 Gaspar Fernández 1 comentario

llaves
Leo en el blog de Thalskarth (proveniente de Tux Files, que a su vez venía de Slice of Linux) un truco para hacer copias de seguridad de un archivo con bash de la siguiente forma:

cp archivo{,.bk}

Lo que hacemos es parecido a escribir esto otro:

cp archivo archivo.bk

Por lo que podemos intuir fácilmente para qué valen las llaves en este contexto: replicar alternativas. Es decir escribiremos lo que hay antes de la llave, y lo terminaremos con cada una de las opciones de dentro de las llaves que están separadas por comas. Y lo más fácil para entender esto es utilizar echo.
Probaremos lo siguiente:

$ echo “Voy a pintar mi casa de “{verde,azul,rojo,amarillo}
Voy a pintar mi casa de verde Voy a pintar mi casa de azul Voy a pintar mi casa de rojo Voy a pintar mi casa de amarillo

Bien, el mensaje se replica con un espacio entre réplicas. Podemos ahora probar algo más:

$ echo -e “Voy a pintar mi casa de “{verde,azul,rojo,amarillo}”.\n”
Voy a pintar mi casa de verde.
Voy a pintar mi casa de azul.
Voy a pintar mi casa de rojo.
Voy a pintar mi casa de amarillo.

Además, podemos ver que la llave no tiene por qué estar al final del parámetro, podemos ponerla en mitad y sigue funcionando. Hay un espacio al principio de la línea, como mencioné antes, las frases irán separadas por un espacio (es normal, las llaves nos sirven para introducir nuevos parámetros). Podremos solucionarlo con \b (backspace).

echo -e “\bVoy a pintar mi casa de “{verde,azul,rojo,amarillo}”.\n”
Voy a pintar mi casa de verde.
Voy a pintar mi casa de azul.
Voy a pintar mi casa de rojo.
Voy a pintar mi casa de amarillo.

Antes de nada un apunte, no debemos dejar espacios dentro de las llaves, ni entre las comas, ni dentro de cada opción, no olvidemos que son parámetros, aunque sí que podríamos poner un espacio si éste va entre comillas (igual que ocurre con los parámetros).

Crear PDFs

Y a partir de aquí, sólo necesitamos imaginación, por ejemplo podemos ver cómo lo usamos para crear un pdf con imágenes en jpeg (de una carpeta llamadas test-N.jpg). Lo creamos con ImageMagick y sólo queremos de la 1 a la 12:

$ convert test-{?.,10.,11.,12.}jpg todos.pdf

Aunque hay un método mejor, {} (las llaves) soportan rangos, por lo que podemos hacer:

$ convert test-{1..12}.jpg todos.pdf

Comprimir directorios

Podemos, por ejemplo crear un archivo comprimido de un directorio con el mismo nombre de la siguiente manera:

$ tar cvjf test{.tar.bz2,/}

como sustitución a:

$ tar cvjf test.tar.bz2 test/

Diferencias

Encontrar la diferencia de un archivo con su backup (suponemos que el backup es el mismo nombre terminado en ~ (tilde de la ñ):

$ diff test{,~}

O para diferencias rutas (recordemos que podemos poner llaves entre parámetros:

$ diff ~/proyectos/www/{proyecto1,proyecto2}/www/lib/my_lib.h

Que es lo mismo que:

$ diff ~/proyectos/www/proyecto1/www/lib/my_lib.h ~/proyectos/www/proyecto2/www/lib/my_lib.h

Lectura de datos en scripts

Para leer desde la entrada estandar tenemos read, y si queremos introducir cada palabra en una variable podemos usar read palabra1 palabra2 palabra3, y si queremos que estas variables tengan un prefijo común:

$ read palabra{A,B,C}

Combinaciones y juegos

Vamos a hacer múltiples sumas con bc:

$ echo -e {1..4}”+”{4..1}”\n” | bc

Esto pondrá en pantalla el resultado de: 1+4, 1+3, 1+2, 1+1, …, 4+3, 4+2, 4+1.
Con esto vemos que los rangos no sólo van en incremento sino también en decremento.
Pero aún más si hacemos:

echo test{a..z}

Nos completará con testa testb testc…testx, testy, testz

Por último, un ejemplo más complicado, y que, aunque pocas veces nos sirva (más que nada por no acordarnos), ahí queda, llaves anidadas:

$ echo test-{1{10..12},3{9..1}}
test-110 test-111 test-112 test-39 test-38 test-37 test-36 test-35 test-34 test-33 test-32 test-31

Tenemos la posibilidad de introducir opciones dentro de otras opciones y todas se representarán seguidas. ¿Tal vez nos sirva alguna vez para crear un fichero de texto con datos de prueba? Para crear un archivo con temperaturas de varias ciudades:

$ echo -e “\b”{”Madrid 1″{1..4},”Barcelona 1″{3..5},”Malaga “{19..22},”Sevilla 2″{3..4}}”\n” > test

Esto creará un fichero llamado test con el siguiente contenido:

Madrid 11
Madrid 12
Madrid 13
Madrid 14
Barcelona 13
Barcelona 14
Barcelona 15
Malaga 19
Malaga 20
Malaga 21
Malaga 22
Sevilla 23
Sevilla 24

Foto: bohman (Flickr)

Aprovechando el return de la función main()

Viernes, 16 de Abril de 2010 Gaspar Fernández Sin comentarios

turn

Imaginamos que en la realización de nuestro shell-script utilizamos un pequeño programa que hemos hecho en C (por ejemplo) y, además de su salida por pantalla, debemos tener también otro valor de retorno (ya sea un código de error, un número de veces que se ha realizado una acción, etc). Es decir, nuestro int main() { return X; }.

Para ello tenemos este programa:

1
2
3
4
int main()
{
  return 4;
}

Lo llamamos test.c y lo compilamos:

$ gcc -o test test.c

y justo después de ejecutar el programa, debemos leer el valor de $?, lo suyo es almacenarlo en una variable, ya que cuando llamemos a otro programa, se almacenará el valor de retorno del nuevo programa:

$ ./test
$ val=$?
$ if (( $val == 2 )); then echo “DOS”; else if (( $val == 4 )); then echo “CUATRO”; fi; fi

Foto: Lel4nd (Flickr)

Categories: Bash, C/C++, Linux Tags: , , , ,

Control-D para terminar la entrada estándar (EOF stdin)

Viernes, 16 de Abril de 2010 Gaspar Fernández Sin comentarios

A veces, con muchos comandos, por ejemplo sort, tail, cat, read, o muchos otros programas que leen datos de un fichero que luego procesan, tenemos la necesidad de utilizarlos con la entrada estándar del sistema, ya sea para hacer una prueba rápida, evitar tener que escribir un fichero o cualquier otra cosa.

Pero podemos estar introduciendo texto para esos comandos de forma indefinida:

$sort
estrella
mar
troglodita
alienígena
carpa
kiosko
gatillo

¿La forma de dejar de introducir texto? Control-D es un EOF de la stdin para el comando en cuestión que estemos ejecutando.

Eso sí, Control-D, también vale para cerrar la sesión, y si nos aficionamos mucho a utilizarlo, tal vez nos llevemos algún disgusto si la pulsamos cuando no debemos. Para ello podemos escribir en el terminal:

$ set -o ignoreeof

Así cuando pulsemos Control-D a destiempo nos dirá que para cerrar el shell escribamos exit.
Por supuesto esta línea anteriormente descrita podemos escribirla en ~/.bashrc y no tendremos que escribirla más.

Categories: Linux Tags: , , , , , ,

Un fondo de escritorio para Linuxeros

Domingo, 14 de Marzo de 2010 Gaspar Fernández 2 comentarios

Acabo de verlo en MuyLinux y me ha encantado. Lo han sacado de Be Linux My Friend. Es una chuleta para la línea de comandos, con todas esas órdenes útiles que vamos a necesitar.
Dada su distribución, bien podemos tener iconos de escritorio a la izquierda o un emulador de terminal para ir practicando :)
Encontramos los comandos básicos para manejo de ficheros, búsquedas procesos, compresión, instalación de programas, permisos, y más.
cli_commands-1400x900

Categories: Bash, General Tags: , , ,

Club2020 de Vodafone… enviar SMS desde la consola

Miércoles, 16 de Diciembre de 2009 Gaspar Fernández Sin comentarios

club2020No vengo a hablaros de la empresa Vodafone, ni del concurso (que podéis entrar desde este enlace y no tenéis que ser de Vodafone). Es un concurso rasca y gana (aunque cada cierto tiempo hay concursos parecidos; en el que uno de los premios son SMS gratis.

Hasta ahí bien, el problema viene a la hora de gastar los SMS, y es que mientras entro en la web (todo hecho en flash), se carga la intro, me la salto, se carga la web, me identifico, pulso en enviar mensajes, escribo el número, el mensaje y envío echo unos 3 minutos, y para el SMS tardo menos desde el móvil.

He hecho un pequeño script para consola que lo hace todo solo, y además en unos 10 segundos (como mucho) está mandado el mensaje… esto también nos permitirá enviar muchos mensajes seguidos (y si queremos usarlo para felicitar las fiestas, nos vendrá genial).

Nota: Antes de postear el código, quiero decir una cosa (NO hago comprobación de las letras de los mensajes, que son algo menos de 160 caracteres), ni de los parámetros (explicados al final) devuelvo el texto de enviado y no enviado, aunque eso no significa que se haga de verdad (ya sabéis cómo andan los SMS incluso en este 2009); por otra parte, si Vodafone corta el servicio o introduce alguna modificación en la página… ¡mala suerte! se nos acabó esto, pero quise compartir este código (y tal vez podamos hacer más cosa en el futuro con él).

Nota 2: Requiere cURL (sin él habría sido una matanza de código)

Nota 3: No está muy comentado, pero si hay alguna duda, siempre tendremos los manuales de cURL, de bash, y los comentarios en este post :)

Ahí va:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#!/bin/bash

MOVIL_USR={mi movil}
CLAVE_USR={mi clave club2020}

function strpos()
{
str=${1/$2*/}
if [[ -z "$1" ]]; then
cad1l=0
else
cad1l=`expr length "$1"`
fi

if [[ -z "$str" ]]; then
donde=0;
else
donde=`expr length "$str"`
fi
if (( $donde &lt; $cad1l )); then
echo $donde
else
echo -1
fi
}

echo "Identificándonse en el sistema..."
#Envio de datos
login="accion=login&amp;clave%5Fusr="$CLAVE_USR"&amp;movil%5Fusr="$MOVIL_USR
data=`curl -s -L -b cookies.txt -c cookies.txt "http://club2020.mi.vodafone.es/rascaygana/actuar.php?"$login`

# Usé esto para obtener los datos a mano hace un rato
#echo $data&gt;tmp
#data=`cat tmp`

# Almacenamos en un array  los datos que nos ha mandado la web
i=1
datos[${i}]=`echo $data | cut -d"&amp;" -f $i`;

while [[ -n ${datos[${i}]} ]]; do let i=$i+1; datos[$i]=`echo $data | cut -d"&amp;" -f $i`; done
#Recorremos el array para mirar las opciones recibidas
datosrecibidos=${#datos[*]}

for ((i=0;i&lt;$datosrecibidos;i++)); do
if (( `strpos ${datos[${i}]} =` &gt; -1 )); then
combo=${datos[${i}]}
clave=`echo $combo | cut -d"=" -f1`
valor=`echo $combo | cut -d"=" -f2`
if [[ $clave == "usuario" ]]; then
usuario=$valor;
elif [[ $clave == "nombre" ]]; then
nombre=$valor;
elif [[ $clave == "tarjetas" ]]; then
tarjetas=$valor;
elif [[ $clave == "mensajes" ]]; then
mensajes=$valor;
fi
fi
done

echo "Hola "$nombre" te quedan "$mensajes" mensajes y tienes "$tarjetas" por rascar"
mensaje=$2
destinatario=$1
echo "Enviando mensaje: "$mensaje" a "$destinatario"..."
postdata="accion=mandarSms&amp;mensaje="$mensaje"&amp;destinatario="$destinatario"&amp;firma="$usuario

#Envio de datos
result=`curl -s -L -b cookies.txt -c cookies.txt -d "$postdata" 'http://club2020.mi.vodafone.es/rascaygana/actuar.php'`

#echo $result &gt; tmp2
result="retorno"`cat tmp2`
i=1
resdata[${i}]=`echo $result | cut -d"&amp;" -f $i`;

while [[ -n ${resdata[${i}]} ]]; do let i=$i+1; resdata[$i]=`echo $result | cut -d"&amp;" -f $i`; done
#Recorremos el array para mirar las opciones recibidas
resdatarecibidos=${#resdata[*]}

for ((i=0;i&lt;$resdatarecibidos;i++)); do
if (( `strpos "${resdata[${i}]}" =` &gt; -1 )); then
combo=${resdata[${i}]}
clave=`echo $combo | cut -d"=" -f1`
valor=`echo $combo | cut -d"=" -f2`
if [[ $clave == "error" ]]; then
error=$valor;
elif [[ $clave == "mensajes" ]]; then
mensajes=$valor;
fi

fi

done

echo "Resultado de la operación: "$error" Quedan "$mensajes" mensajes"
echo "Cerrando sesión..."

#Envio de datos
curl -s -L -b cookies.txt -c cookies.txt 'http://club2020.mi.vodafone.es/rascaygana/actuar.php?accion=logout' &gt;/dev/null

Si guardamos este archivo como sms2020 y le damos permiso de ejecución, el primer parámetro es el móvil del destinatario, y el segundo el mensaje (entrecomilladlo si tiene espacios). Además, en la parte de arriba del archivo encontramos MOVIL_USR y CLAVE_USR, tendréis que poner vuestro número de móvil y vuestra clave del club2020 (para poder identificaros en el sistema).
Nota 4: Pude optimizar un poco el código, pero como había prisa y no sé lo que durará esto, no quise calentarme mucho el coco.
Nota 5: Para registrase: seguid este link (así me dais sms gratis a mí también, porque los demás premios nunca tocan).

Visita otras webs de la red