/main.c

/*
Sav-pfsense (C) 2011 Jesús Hernández Gormaz


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, or (at your option) any later version.
  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, write to the Free Software Foundation, Inc., 675 Mass Ave,
  Cambridge, MA 02139, USA.

Este programa es software libre. Puede redistribuirlo y/o modificarlo bajo los
  términos de la Licencia Pública General de GNU según es publicada por la Free
  Software Foundation, bien de la versión 3 de dicha Licencia o bien (según su
  elección) de cualquier versión posterior.
  Este programa se distribuye con la esperanza de que sea útil, pero SIN NINGUNA
  GARANTÍA, incluso sin la garantía MERCANTIL implícita o sin garantizar la
  CONVENIENCIA PARA UN PROPÓSITO PARTICULAR. Para más detalles, véase la Licencia
  Pública General de GNU.
  Debería haber recibido una copia de la Licencia Pública General junto con este
  programa. En caso contrario, escriba a la Free Software Foundation, Inc., en 675
  Mass Ave, Cambridge, MA 02139, EEUU.
*/

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

#include <gtk/gtk.h>

#include "main.h"

/*Entrar al portal de configuración de Pfsense y obtener una cookie de sesion,
   devuelve 0 si todo fue bien, usa wget*/
int obtener_sesion_wget (char *ip);

/*Validarse con un usuario y clave*/
int validar_usuario_wget (char *ip, char *usuario, char *clave);

/*Descarga el rollo de vouchers indicado*/
int descargar_vouchers_wget (char *ip, unsigned int id, char *usuario, char *clave);

/*Formatear vouchers descargados*/
int formatear_vouchers (int id);

/*Muestra un voucher y lo marca como usado, devuelve -1 en caso de que no queden
   vouchers*/
int obtener_voucher (int rollo, char *voucher);

/*Elimina un rollo de vouchers*/
int eliminar_vouchers_wget (char *ip, unsigned int rollo, char *usuario, char *clave);

/*Obtiene un campo oculto del formulario para crear vouchers*/
int obtener_sid_wget (char *ip, char *sid);

/*Crea el numero de rollo de vouchers indicado, indicando los minutos de
   duración, el numero de vouchers y un comentario*/
int crear_vouchers_wget (char *ip, unsigned int rollo, unsigned int minutos,
                         unsigned int numerovouchers, char *comentario,
                         char *usuario, char *clave);

/*Codifica la cadena segun la codificación URL*/
int codificacion_url (char *cadena);

/*Carga la lista local de rollos disponibles y devuelve el puntero al primer
   elemento o NULL si la lista esta vacia*/
listarollos *cargar_lista_local_rollos ();

/*Guarda la lista local de rollos*/
int guardar_lista_local_rollos (listarollos *primero);

/*Agregar un rollo a la lista de rollos, colocandolo en ultimo lugar*/
int agregar_rollo_lista (listarollos **lista, unsigned int rollo, unsigned int minutos, unsigned int numerovouchers, char *comentario);

/*Libera la memoria de la lista de rollos*/
int liberar_lista_rollos (listarollos *primero);

/*Asigna a id la posición en lista del rollo indicado, devuelve -1 si no existe*/
int buscar_id_rollo (listarollos *primero, unsigned int rollo, unsigned int *id);

/*Eliminar un rollo de la lista de rollos*/
int eliminar_rollo_lista (listarollos **lista, unsigned int rollo);

/*Muestra la ventana de configuracion*/
void mostrar_configurar_ip_usuario_clave ();

/*Se ejecuta al hacer click en aceptar en la ventana de configuracion*/
void configurar_ip_usuario_clave (GtkButton *button, gpointer data);

/*Muestra la ventana de peticion de la clave*/
void mostrar_pedir_clave ();

/*Se ejecuta al hacer click en aceptar en la ventana de pedir la clave*/
void obtener_clave_introducida (GtkButton *button, gpointer data);

/*Muestra la ventana de peticion de la clave*/
void mostrar_crear_rollo ();

/*Se ejecuta al hacer click en aceptar en la ventana de pedir la clave*/
void obtener_crear_rollo (GtkButton *button, gpointer data);

/*Muestra la ventana de peticion de la clave*/
void mostrar_voucher_gtk ();

/*Se ejecuta al hacer click en aceptar en la ventana de pedir la clave*/
void obtener_voucher_gtk (GtkButton *button, gpointer data);

/*Funcion que elimina los vouchers y muestra la ventana para volver a crearlos*/
void regenerar_vouchers (GtkButton *button, gpointer data);

/*Variables globales para el funcionamiento*/
gchar *tusuario;
gchar *tclave;
gchar *tip;
listarollos *rollos;
/*Punteros para la entrada de texto para la validacion en pfsense*/
GtkWidget *ip, *usuario, *clave;
/*Puntero a la ventana que usaremos*/
GtkWidget *ventanaprincipal;
GtkWidget *ventanavoucher;
/*Puntero a la etiqueta que muestra el voucher*/
GtkWidget *evoucher;
/*Variable para decidir si la ventana puede cerrarse, por defecto puede cerrarse*/
int bloquearventana=1;

/*Funcion para finalizar el programa con eventos*/
void cerrar_todo ()
  {
    exit (0);
    return;
  }

int main (int argc, char *argv[])
  {
    FILE *archivo=NULL;
    unsigned int suma_clave=0;
    unsigned int suma_comparacion=0;
    char *recorrer_comparacion=NULL;
    char usuariocargado[128];
    char ipcargada[20];
    char control;
    /*Iniciamos GTK*/
    gtk_init (&argc, &argv);
    /*Comprobamos si existe una configuración de Sav-pfsense guardada*/
    archivo = fopen (ARCHIVO_CONFIGURACION, "rb");
    if (archivo == NULL)
      {
        /*Indicamos que bloque la ventana para poder abrirla*/
        bloquearventana = 0;
        /*Abrimos la ventana para configurar Sav-pfsense*/
        mostrar_configurar_ip_usuario_clave ();
      }
    else
      {
        /*Cargamos la configuración*/
        fscanf (archivo, "%u %c %s %s\n", &suma_clave, &control, &usuariocargado[0], &ipcargada[0]);
        fclose (archivo);
        /*Reservamos memoria para almacenar la configuración cargada en los punteros
           globales*/
        tip = (gchar *) malloc (sizeof (char) * (strlen (&ipcargada[0]) + 1) );
        tusuario = (gchar *) malloc (sizeof (char) * (strlen (&usuariocargado[0]) + 1) );
        /*Copiamos la configuracion*/
        strcpy (tip, &ipcargada[0]);
        strcpy (tusuario, &usuariocargado[0]);
        do
          {
            /*Pedimos la clave al usuario*/
            mostrar_pedir_clave ();
            /*Recorremos la clave introducida apra calcular la suma y poder compararlas*/
            recorrer_comparacion = (char *) tclave;
            while (*recorrer_comparacion != '\0')
              {
                suma_comparacion += *recorrer_comparacion % 23;
                recorrer_comparacion ++;
              }
          } while (suma_clave != suma_comparacion);
        
      }
    /*NOTA: Esta versión de la interfaz grafica solo trabajara con un rollo de vouchers*/
    rollos=NULL;
    /*Cargamos los rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Comprobamos que exista algun rollo, si no existe ninguno creamos uno*/
    if (rollos == NULL) mostrar_crear_rollo ();
    /*Mostramos la pantalla donde obtener los vouchers*/
    mostrar_voucher_gtk ();
    return 0;
  }

void mostrar_configurar_ip_usuario_clave ()
  {
    /*Comprobamos si la ventana ha sido bloqueada para abrirla o no*/
    if (bloquearventana != 0) return;
    /*Punteros a las etiquetas de texto*/
    GtkWidget *eip, *eusuario, *eclave;
    /*Puntero para el boton de aceptar*/
    GtkWidget *baceptar;
    /*Punteros a las cajas que usaremos*/
    GtkWidget *cipusuarioc, *controles, *formulario;
    /*Creamos la ventana*/
    ventanaprincipal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    /*Indicamos las dimensiones de la ventana*/
    gtk_window_set_default_size (GTK_WINDOW (ventanaprincipal), 255, 125);
    /*Impedimos que no se redimensione la ventana*/
    gtk_window_set_resizable (GTK_WINDOW (ventanaprincipal), FALSE);
    /*Indicamos el titulo de la ventana*/
    gtk_window_set_title (GTK_WINDOW (ventanaprincipal), "Sav - Configuración");
    /*Centramos la ventana*/
    gtk_window_set_position (GTK_WINDOW (ventanaprincipal), GTK_WIN_POS_CENTER_ALWAYS);
    /*Creamos las etiquetas de texto*/
    eip = gtk_label_new ("Direccion ip: ");
    eusuario = gtk_label_new ("Usuario: ");
    eclave = gtk_label_new ("Clave: ");
    /*Creamos el boton de aceptar*/
    baceptar = gtk_button_new_with_label ("Aceptar");
    /*Creamos la entrada de texto*/
    ip = gtk_entry_new ();
    usuario = gtk_entry_new ();
    clave = gtk_entry_new ();
    /*Creamos la caja de IP, Usuario y Clave*/
    cipusuarioc = gtk_vbox_new (FALSE, 14);
    /*Empaquetamos las etiquetas*/
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eip, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eusuario, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eclave, FALSE, TRUE, 0);
    /*Creamos la caja para los controles*/
    controles = gtk_vbox_new (FALSE, 2);
    /*Empaquetamos los botones*/
    gtk_box_pack_start ( (GtkBox *) controles, ip, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, usuario, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, clave, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, baceptar, FALSE, TRUE, 0 );
    /*Creamos la caja para el formulario*/
    formulario = gtk_hbox_new (FALSE, 3);
    /*Empaquetamos la caja de etiquetas y la de controles*/
    gtk_box_pack_start ( (GtkBox *) formulario, cipusuarioc, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) formulario, controles, FALSE, TRUE, 0);
    /*Empaquetamos una caja dentro de la ventana*/
    gtk_container_add ( (GtkContainer *) ventanaprincipal, formulario);
    /*Conectamos las señales*/
    /*Indicamos que al cerrar la ventana vuelva a abrirla*/
    gtk_signal_connect (GTK_OBJECT (ventanaprincipal), "destroy", G_CALLBACK (mostrar_configurar_ip_usuario_clave), NULL);
    /*Indicamos que funcion ejecutar al hacer click en aceptar*/
    g_signal_connect ( (GObject *) baceptar, "clicked", (GCallback) configurar_ip_usuario_clave, NULL);
    /*Hacemos visible la ventana*/
    gtk_widget_show_all(ventanaprincipal);
    /*Ejecutamos el bucle de GTK*/
    gtk_main();
    return;
  }

void configurar_ip_usuario_clave (GtkButton *button, gpointer data)
  {
    FILE *archivo_datos_conexion;
    /*Variables con las que calcular una suma de control de la clave*/
    unsigned int suma_clave=0;
    char *recorrer_clave;
    /*Obtenemos los datos introducidos*/
    tip = (gchar *) gtk_entry_get_text ( (GtkEntry *) ip);
    tusuario = (gchar *) gtk_entry_get_text ( (GtkEntry *) usuario);
    tclave = (gchar *) gtk_entry_get_text ( (GtkEntry *) clave);
    /*Transformamos el tipo de la clave para recorrerlo byte a byte*/
    recorrer_clave = (char *) tclave;
    /*Indicamos que no se necesita mantener mas la ventana bloqueada*/
    bloquearventana = 1;
    /*Hacemos invisible la ventana*/
    gtk_widget_hide_all(ventanaprincipal);
    /*Finalizamos el bucle GTK*/
    gtk_main_quit();
    /*Recorremos la clave y vamos sumando los valores de los bytes*/
    while (*recorrer_clave != '\0')
      {
        /*Lo sumamos calculando el resto de dividirlo entre 23*/
        suma_clave += *recorrer_clave % 23;
        /*Pasamos al siguiente caracter*/
        recorrer_clave ++;
      }
    /*Abrimos el archivo donde guardar la configuración*/
    archivo_datos_conexion = fopen (ARCHIVO_CONFIGURACION, "wb");
    /*Comprobamos que no hubiese ningun error*/
    if (archivo_datos_conexion == NULL) exit (-1);
    /*Escribimos los datos en el archivo*/
    fprintf (archivo_datos_conexion, "%u %c %s %s\n", suma_clave, 0x00, (char *) tusuario, (char *) tip);
    /*Cerramos el archivo*/
    fclose (archivo_datos_conexion);
    return;
  }

void mostrar_pedir_clave ()
  {
    /*Punteros a las etiquetas de texto*/
    GtkWidget *eip, *eusuario, *eclave;
    /*Puntero para el boton de aceptar*/
    GtkWidget *baceptar;
    /*Punteros a las cajas que usaremos*/
    GtkWidget *cipusuarioc, *controles, *formulario;
    /*Creamos la ventana*/
    ventanaprincipal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    /*Indicamos las dimensiones de la ventana*/
    gtk_window_set_default_size (GTK_WINDOW (ventanaprincipal), 255, 125);
    /*Impedimos que no se redimensione la ventana*/
    gtk_window_set_resizable (GTK_WINDOW (ventanaprincipal), FALSE);
    /*Indicamos el titulo de la ventana*/
    gtk_window_set_title (GTK_WINDOW (ventanaprincipal), "Sav - Autenticación");
    /*Centramos la ventana*/
    gtk_window_set_position (GTK_WINDOW (ventanaprincipal), GTK_WIN_POS_CENTER_ALWAYS);
    /*Creamos las etiquetas de texto*/
    eip = gtk_label_new ("Direccion ip: ");
    eusuario = gtk_label_new ("Usuario: ");
    eclave = gtk_label_new ("Clave: ");
    /*Creamos el boton de aceptar*/
    baceptar = gtk_button_new_with_label ("Validar");
    /*Creamos la entrada de texto*/
    ip = gtk_label_new (tip);
    usuario = gtk_label_new (tusuario);
    clave = gtk_entry_new ();
    /*Creamos la caja de IP, Usuario y Clave*/
    cipusuarioc = gtk_vbox_new (FALSE, 2);
    /*Empaquetamos las etiquetas*/
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eip, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eusuario, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eclave, FALSE, TRUE, 0);
    /*Creamos la caja para los controles*/
    controles = gtk_vbox_new (FALSE, 2);
    /*Empaquetamos los botones*/
    gtk_box_pack_start ( (GtkBox *) controles, ip, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, usuario, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, clave, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, baceptar, FALSE, TRUE, 0 );
    /*Creamos la caja para el formulario*/
    formulario = gtk_hbox_new (FALSE, 3);
    /*Empaquetamos la caja de etiquetas y la de controles*/
    gtk_box_pack_start ( (GtkBox *) formulario, cipusuarioc, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) formulario, controles, FALSE, TRUE, 0);
    /*Empaquetamos una caja dentro de la ventana*/
    gtk_container_add ( (GtkContainer *) ventanaprincipal, formulario);
    /*Conectamos las señales*/
    /*Indicamos que al cerrar la ventana vuelva a abrirla*/
    gtk_signal_connect (GTK_OBJECT (ventanaprincipal), "destroy", G_CALLBACK (cerrar_todo), NULL);
    /*Indicamos que funcion ejecutar al hacer click en aceptar*/
    g_signal_connect ( (GObject *) baceptar, "clicked", (GCallback) obtener_clave_introducida, NULL);
    /*Hacemos visible la ventana*/
    gtk_widget_show_all(ventanaprincipal);
    /*Ejecutamos el bucle de GTK*/
    gtk_main();
    return;
  }

void obtener_clave_introducida (GtkButton *button, gpointer data)
  {
    /*Obtenemos los datos introducidos*/
    tclave = (gchar *) gtk_entry_get_text ( (GtkEntry *) clave);
    /*Hacemos invisible la ventana*/
    gtk_widget_hide_all(ventanaprincipal);
    /*Finalizamos el bucle GTK*/
    gtk_main_quit();
    return;
  }

void mostrar_crear_rollo ()
  {
    /*Punteros a las etiquetas de texto*/
    GtkWidget *eip, *eusuario, *eclave;
    /*Puntero para el boton de aceptar*/
    GtkWidget *baceptar;
    /*Punteros a las cajas que usaremos*/
    GtkWidget *cipusuarioc, *controles, *formulario;
    /*Creamos la ventana*/
    ventanaprincipal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    /*Indicamos las dimensiones de la ventana*/
    gtk_window_set_default_size (GTK_WINDOW (ventanaprincipal), 255, 125);
    /*Impedimos que no se redimensione la ventana*/
    gtk_window_set_resizable (GTK_WINDOW (ventanaprincipal), FALSE);
    /*Indicamos el titulo de la ventana*/
    gtk_window_set_title (GTK_WINDOW (ventanaprincipal), "Sav - Crear vouchers");
    /*Centramos la ventana*/
    gtk_window_set_position (GTK_WINDOW (ventanaprincipal), GTK_WIN_POS_CENTER_ALWAYS);
    /*Creamos las etiquetas de texto*/
    eclave = gtk_label_new ("Minutos: ");
    /*Creamos el boton de aceptar*/
    baceptar = gtk_button_new_with_label ("Crear vouchers");
    /*Creamos la entrada de texto*/
    clave = gtk_entry_new ();
    /*Creamos la caja de IP, Usuario y Clave*/
    cipusuarioc = gtk_vbox_new (FALSE, 2);
    /*Empaquetamos las etiquetas*/
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, eclave, FALSE, TRUE, 0);
    /*Creamos la caja para los controles*/
    controles = gtk_vbox_new (FALSE, 2);
    /*Empaquetamos los botones*/
    gtk_box_pack_start ( (GtkBox *) controles, clave, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) controles, baceptar, FALSE, TRUE, 0 );
    /*Creamos la caja para el formulario*/
    formulario = gtk_hbox_new (FALSE, 3);
    /*Empaquetamos la caja de etiquetas y la de controles*/
    gtk_box_pack_start ( (GtkBox *) formulario, cipusuarioc, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) formulario, controles, FALSE, TRUE, 0);
    /*Empaquetamos una caja dentro de la ventana*/
    gtk_container_add ( (GtkContainer *) ventanaprincipal, formulario);
    /*Conectamos las señales*/
    /*Indicamos que al cerrar la ventana vuelva a abrirla*/
    gtk_signal_connect (GTK_OBJECT (ventanaprincipal), "destroy", G_CALLBACK (cerrar_todo), NULL);
    /*Indicamos que funcion ejecutar al hacer click en aceptar*/
    g_signal_connect ( (GObject *) baceptar, "clicked", (GCallback) obtener_crear_rollo, NULL);
    /*Hacemos visible la ventana*/
    gtk_widget_show_all(ventanaprincipal);
    /*Ejecutamos el bucle de GTK*/
    gtk_main();
    return;
  }

void obtener_crear_rollo (GtkButton *button, gpointer data)
  {
    gchar *minutos=NULL;
    unsigned int iminutos=0;
    /*Obtenemos los datos introducidos*/
    minutos = (gchar *) gtk_entry_get_text ( (GtkEntry *) clave);
    sscanf ( (char *) minutos, "%u", &iminutos);
    /*Creamos el rollo*/
    crear_vouchers_wget (tip, 0, iminutos,
                         1023, "Sav-pfsense",
                         tusuario, tclave);
    gtk_window_set_title (GTK_WINDOW (ventanaprincipal), "Sav - Creando...");
    /*Hacemos invisible la ventana*/
    gtk_widget_hide_all(ventanaprincipal);
    /*Finalizamos el bucle GTK*/
    gtk_main_quit();
    return;
  }

void mostrar_voucher_gtk ()
  {
    /*Punteros a las etiquetas de texto*/
    GtkWidget *eip, *eusuario, *eclave;
    /*Puntero para el boton de aceptar*/
    GtkWidget *baceptar;
    GtkWidget *nuevos;
    /*Punteros a las cajas que usaremos*/
    GtkWidget *cipusuarioc, *controles, *formulario;
    /*Creamos la ventana*/
    ventanavoucher = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    /*Indicamos las dimensiones de la ventana*/
    gtk_window_set_default_size (GTK_WINDOW (ventanavoucher), 555, 125);
    /*Impedimos que no se redimensione la ventana*/
    gtk_window_set_resizable (GTK_WINDOW (ventanavoucher), FALSE);
    /*Indicamos el titulo de la ventana*/
    gtk_window_set_title (GTK_WINDOW (ventanavoucher), "Sav - Voucher");
    /*Creamos las etiquetas de texto*/
    evoucher = gtk_label_new (" ");
    /*Creamos el boton de aceptar*/
    baceptar = gtk_button_new_with_label ("Obtener vouchers");
    nuevos = gtk_button_new_with_label ("Regenerar vouchers");
    /*Creamos la caja de IP, Usuario y Clave*/
    cipusuarioc = gtk_vbox_new (FALSE, 2);
    /*Empaquetamos las etiquetas*/
    gtk_box_pack_start ( (GtkBox *) cipusuarioc, evoucher, FALSE, TRUE, 0);
    /*Creamos la caja para los controles*/
    controles = gtk_hbox_new (FALSE, 2);
    /*Empaquetamos los botones*/
    gtk_box_pack_start ( (GtkBox *) controles, baceptar, FALSE, TRUE, 0 );
    gtk_box_pack_start ( (GtkBox *) controles, nuevos, FALSE, TRUE, 0 );
    /*Creamos la caja para el formulario*/
    formulario = gtk_hbox_new (FALSE, 3);
    /*Empaquetamos la caja de etiquetas y la de controles*/
    gtk_box_pack_start ( (GtkBox *) formulario, cipusuarioc, FALSE, TRUE, 0);
    gtk_box_pack_start ( (GtkBox *) formulario, controles, FALSE, TRUE, 0);
    /*Empaquetamos una caja dentro de la ventana*/
    gtk_container_add ( (GtkContainer *) ventanavoucher, formulario);
    /*Conectamos las señales*/
    /*Indicamos que al cerrar la ventana vuelva a abrirla*/
    gtk_signal_connect (GTK_OBJECT (ventanavoucher), "destroy", G_CALLBACK (cerrar_todo), NULL);
    /*Indicamos que funcion ejecutar al hacer click en aceptar*/
    g_signal_connect ( (GObject *) baceptar, "clicked", (GCallback) obtener_voucher_gtk, NULL);
    g_signal_connect ( (GObject *) nuevos, "clicked", (GCallback) regenerar_vouchers, NULL);
    /*Hacemos visible la ventana*/
    gtk_widget_show_all(ventanavoucher);
    /*Ejecutamos el bucle de GTK*/
    gtk_main();
    return;
  }

void obtener_voucher_gtk (GtkButton *button, gpointer data)
  {
    char voucher[40];
    /*Comprobamos si no quedan vouchers para volver a crearlos*/
    if (obtener_voucher (0, &voucher[0]) != 0)
      {
        gtk_widget_hide_all(ventanavoucher);
        mostrar_crear_rollo ();
        gtk_widget_show_all(ventanavoucher);
      }
    else
      {
        /*Mostramos el voucher*/
        gtk_label_set_text (GTK_LABEL(evoucher), &voucher[0]);
      }
    return;
  }

void regenerar_vouchers (GtkButton *button, gpointer data)
  {
    gtk_widget_hide_all(ventanavoucher);
    /*Eliminamos los vouchers y los volvemos a crear*/
    eliminar_vouchers_wget (tip, 0, tusuario, tclave);
    mostrar_crear_rollo ();
    gtk_widget_show_all(ventanavoucher);
    return;
  }

int obtener_sesion_wget (char *ip)
  {
    char comando[512];
    /*Formamos el comando*/
    sprintf (&comando[0],
             "wget -q -O %s --user-agent %s %s %s http://%s/index.php\0",
             ARCHIVO_PAGINA, NAVEGADOR, OPCIONES_WGET_COOKIES, ARCHIVO_COOKIE,
             ip);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    /*Eliminamos el archivo de la pagina ya que no la necesitamos*/
    remove (ARCHIVO_PAGINA);
    return 0;
  }

int validar_usuario_wget (char *ip, char *usuario, char *clave)
  {
    char comando[512];
    /*Obtenemos una cookie de sesion*/
    obtener_sesion_wget (ip);
    /*Formamos el comando*/
    sprintf (&comando[0],
             "wget -q -O %s --user-agent %s --load-cookies %s %s %s --post-data usernamefld=%s\\&passwordfld=%s\\&login=Login --referer http://%s/index.php http://%s/index.php",
             ARCHIVO_PAGINA, NAVEGADOR, ARCHIVO_COOKIE, OPCIONES_WGET_COOKIES,
             ARCHIVO_COOKIE, usuario, clave, ip, ip);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    sprintf (&comando[0],
             "wget -q -O %s --user-agent %s --load-cookies %s %s %s --referer http://%s/index.php http://%s/",
             ARCHIVO_PAGINA, NAVEGADOR, ARCHIVO_COOKIE, OPCIONES_WGET_COOKIES,
             ARCHIVO_COOKIE, ip, ip);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    /*Eliminamos el archivo de la pagina ya que no la necesitamos*/
    remove (ARCHIVO_PAGINA);
    return 0;
  }

int descargar_vouchers_wget (char *ip, unsigned int id, char *usuario, char *clave)
  {
    char comando[512];
    /*Nos validamos en el portal de administración de Pfsense*/
    validar_usuario_wget (ip, usuario, clave);
    /*Formamos el comando*/
    sprintf (&comando[0],
             "wget -q -O %s%u%s --user-agent %s --load-cookies %s %s %s --referer http://%s/ http://%s/services_captiveportal_vouchers.php?act=csv\\&id=%u",
             PREFIJO_ARCHIVO_VOUCHERS, id, EXTENSION_ARCHIVO_VOUCHERS,
             NAVEGADOR, ARCHIVO_COOKIE, OPCIONES_WGET_COOKIES, ARCHIVO_COOKIE,
             ip, ip, id);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    /*Formateamos los vouchers para simplificar su posterior lectura*/
    formatear_vouchers (id);
    /*Eliminamos la cookie para finalizar la sesion*/
    remove (ARCHIVO_COOKIE);
    return 0;
  }

int formatear_vouchers (int id)
  {
    FILE *vouchers=NULL;
    FILE *formateados=NULL;
    char archivo[512];
    char linea[32];
    char *lineaformateada;
    unsigned int longitud;
    registrovoucher registro;
    /*Formamos la ruta al archivo de los vouchers descargados*/
    sprintf (&archivo[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, id,
             EXTENSION_ARCHIVO_VOUCHERS);
    /*Abrimos el archivo*/
    vouchers = fopen (&archivo[0], "r");
    /*Formamos la ruta al archivo de los vouchers formateados*/
    sprintf (&archivo[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, id, ".dat");
    /*Abrimos el archivo*/
    formateados = fopen (&archivo[0], "wb");
    /*Preparamos el registro como no usado*/
    registro.usado = 0;
    /*Leemos el resto del archivo completo linea a linea*/
    while (fgets (&linea[0], 32, vouchers) != NULL)
      {
        /*Comprobamos si debemos ignorar la linea por estar comentada*/
        if (linea[0] == '#') continue;
        /*Comprobamos si la linea no es un voucher*/
        if (linea[0] != '\"') continue;
        /*Quitamos los dos primeros caracteres, una comilla y un espacio*/
        lineaformateada = &linea[2];
        /*Quitamos la comilla final*/
        longitud = strlen (&linea[0]);
        linea[longitud - 2] = '\0';
        /*Copiamos la cadena fomateada al registro*/
        strcpy (&registro.voucher[0], lineaformateada);
        /*Escribimos el registro*/
        fwrite (&registro, sizeof (registrovoucher), 1, formateados);
      }
    /*Cerramos los archivos*/
    fclose (vouchers);
    fclose (formateados);
    /*Formamos la ruta al archivo de los vouchers descargados*/
    sprintf (&archivo[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, id,
             EXTENSION_ARCHIVO_VOUCHERS);
    /*Eliminamos el archivo descargado*/
    remove (&archivo[0]);
    return 0;
  }

int obtener_voucher (int rollo, char *voucher)
  {
    FILE *vouchers=NULL;
    char archivo[512];
    registrovoucher registro;
    unsigned int id=0;
    listarollos *rollos=NULL;
    /*Cargamos la lista de rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Comprobamos que exista el rollo*/
    if (buscar_id_rollo (rollos, rollo, &id) != 0)
      {
        /*Liberamos la lista de rollos*/
        liberar_lista_rollos (rollos);
        return -1;
      }
    /*Liberamos la lista de rollos*/
    liberar_lista_rollos (rollos);
    rollos = NULL;
    /*Indicamos el valor por defecto, no usado*/
    registro.usado = 0;
    /*Indicamos que no se ha obtenido ningun voucher aun*/
    int obtenido=0;
    /*Formamos la ruta al archivo de los vouchers*/
    sprintf (&archivo[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, id, ".dat");
    /*Abrimos el archivo*/
    vouchers = fopen (&archivo[0], "r+b");
    while (!feof (vouchers) )
      {
        /*Cargamos un voucher*/
        fread (&registro, sizeof (registrovoucher), 1, vouchers );
        /*Comprobamos si ha sido usado*/
        if (registro.usado == 0)
          {
            /*Indicamos que esta usado*/
            registro.usado = 0xff;
            /*Lo guardamos en el archivo*/
            fseek (vouchers, - sizeof (registrovoucher), SEEK_CUR);
            fwrite (&registro, sizeof (registrovoucher), 1, vouchers);
            /*Indicamos que se ha encontrado un voucher*/
            obtenido = 1;
            /*Salimos del bucle*/
            break;
          }
      }
    /*Cerramos el archivo*/
    fclose (vouchers);
    /*comprobamos si se obtuvo un voucher*/
    if (obtenido == 0)
      {
        /*Cargamos la lista de rollos*/
        rollos = cargar_lista_local_rollos ();
        /*Eliminamos el rollo de vouchers por haber gastado ya todos*/
        eliminar_rollo_lista (&rollos, rollo);
        /*Liberamos la lista de rollos*/
        liberar_lista_rollos (rollos);
        rollos = NULL;
        return -1;
      }
    else
      {
        /*copiamos el voucher a la cadena indicada al llamar a la función*/
        strcpy (voucher, &registro.voucher[0]);
      }
    return 0;
  }

int eliminar_vouchers_wget (char *ip, unsigned int rollo, char *usuario, char *clave)
  {
    char comando[512];
    unsigned int id=0;
    listarollos *rollos=NULL;
    /*Cargamos la lista de rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Comprobamos que exista el rollo*/
    if (buscar_id_rollo (rollos, rollo, &id) != 0)
      {
        /*Liberamos la lista de rollos*/
        liberar_lista_rollos (rollos);
        return -1;
      }
    /*Liberamos la lista de rollos*/
    liberar_lista_rollos (rollos);
    rollos = NULL;
    /*Nos validamos en el portal de administración de Pfsense*/
    validar_usuario_wget (ip, usuario, clave);
    /*Formamos el comando*/
    sprintf (&comando[0],
             "wget -q -O %s --user-agent %s --load-cookies %s %s %s --referer http://%s/ http://%s/services_captiveportal_vouchers.php?act=del\\&id=%u",
             ARCHIVO_PAGINA, NAVEGADOR, ARCHIVO_COOKIE, OPCIONES_WGET_COOKIES,
             ARCHIVO_COOKIE, ip, ip, id);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    /*Eliminamos el archivo de la pagina ya que no la necesitamos*/
    remove (ARCHIVO_PAGINA);
    /*Eliminamos la cookie para finalizar la sesion*/
    remove (ARCHIVO_COOKIE);
    /*Cargamos la lista de rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Eliminamos el archivo de vouchers*/
    eliminar_rollo_lista (&rollos, rollo);
    /*Liberamos la lista de rollos*/
    liberar_lista_rollos (rollos);
    rollos = NULL;
    return 0;
  }

int obtener_sid_wget (char *ip, char *sid)
  {
    FILE *pagina=NULL;
    char comando[2048];
    char *auxiliar;
    int longitud;
    /*Indicamos que no hemos encontrado aun el sid*/
    int encontrado=-1;
    /*Formamos el comando*/
    sprintf (&comando[0],
             "wget -q -O %s --user-agent %s --load-cookies %s %s %s --referer http://%s/ http://%s/services_captiveportal_vouchers.php",
             ARCHIVO_PAGINA, NAVEGADOR, ARCHIVO_COOKIE, OPCIONES_WGET_COOKIES,
             ARCHIVO_COOKIE, ip, ip);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    /*Abrimos el archivo*/
    pagina = fopen (ARCHIVO_PAGINA, "r");
    /*Leemos todo el archivo buscando la linea que necesitamos*/
    while (fgets (&comando[0], 1024, pagina) != NULL)
      {
        /*Buscamos sid:*/
        auxiliar = strstr (&comando[0], "sid:");
        /*Comprobamos si lo hemos encontrado*/
        if (auxiliar != NULL)
          {
            /*Indicamos que lo encontramos*/
            encontrado = 0;
            /*Salimos del bucle*/
            break;
          }
      }
    /*Cerramos el archivo*/
    fclose (pagina);
    /*Eliminamos el archivo que ya es innecesario*/
    remove (ARCHIVO_PAGINA);
    /*Comprobamos si se encontro*/
    if (encontrado == 0)
      {
        /*Calculamos la longitud del sid*/
        longitud = strstr (auxiliar, "\"") - auxiliar;
        /*Copiamos el sid*/
        strncpy (sid, auxiliar, longitud);
        /*Indicamos el final de la cadena de caracteres*/
        *(sid + longitud) = '\0';
      }
    return encontrado;
  }

int crear_vouchers_wget (char *ip, unsigned int rollo, unsigned int minutos,
                         unsigned int numerovouchers, char *comentario,
                         char *usuario, char *clave)
  {
    char comando[512];
    char sid[128];
    unsigned int id=0;
    listarollos *rollos=NULL;
    /*Cargamos la lista de rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Comprobamos que no exista ya el rollo que intentamos crear*/
    if (buscar_id_rollo (rollos, rollo, &id) == 0)
      {
        /*Liberamos la lista de rollos*/
        liberar_lista_rollos (rollos);
        return -1;
      }
    /*Liberamos la lista de rollos*/
    liberar_lista_rollos (rollos);
    rollos = NULL;
    /*Nos validamos en el portal de administración de Pfsense*/
    validar_usuario_wget (ip, usuario, clave);
    /*Obtenemos el sid*/
    obtener_sid_wget (ip, &sid[0]);
    /*Lo codificamos para enviarlo por POST*/
    codificacion_url (&sid[0]);
    /*Formamos el comando*/
    sprintf (&comando[0],
             "wget -q -O %s --user-agent %s --load-cookies %s %s %s --post-data __csrf_magic=%s\\&number=%u\\&minutes=%u\\&count=%u\\&comment=%s\\&Submit=Save --referer http://%s/services_captiveportal_vouchers_edit.php http://%s/services_captiveportal_vouchers_edit.php",
             ARCHIVO_PAGINA, NAVEGADOR, ARCHIVO_COOKIE, OPCIONES_WGET_COOKIES,
             ARCHIVO_COOKIE, &sid[0], rollo, minutos, numerovouchers,
             comentario, ip, ip);
    /*Ejecutamos el comando en el sistema*/
    system (&comando[0]);
    /*Eliminamos el archivo que ya es innecesario*/
    remove (ARCHIVO_PAGINA);
    /*Eliminamos la cookie para finalizar la sesion*/
    remove (ARCHIVO_COOKIE);
    /*Cargamos la lista de rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Agregamos el nuevo rollos*/
    agregar_rollo_lista (&rollos, rollo, minutos, numerovouchers, comentario);
    /*Guardamos la lista de rollos*/
    guardar_lista_local_rollos (rollos);
    /*Liberamos la lista de rollos*/
    liberar_lista_rollos (rollos);
    rollos = NULL;
    /*Cargamos la lista de rollos*/
    rollos = cargar_lista_local_rollos ();
    /*Obtenemos el id del rollo*/
    buscar_id_rollo (rollos, rollo, &id);
    /*Liberamos la lista de rollos*/
    liberar_lista_rollos (rollos);
    rollos = NULL;
    /*Descargamos los vouchers creados*/
    descargar_vouchers_wget (ip, id, usuario, clave);
    return 0;
  }

int codificacion_url (char *cadena)
  {
    char auxiliar[128];
    char *recorrer;
    unsigned int i=0;
    /*Recorremos la cadena caracter a caracter*/
    for (recorrer=cadena; *recorrer != '\0'; recorrer++)
      {
        /*Comprobamos de que caracter se trata para codificarlo*/
        if (*recorrer == ':')
          {
            /*Codificamos el caracter*/
            auxiliar[i] = '%';
            i++;
            auxiliar[i] = '3';
            i++;
            auxiliar[i] = 'A';
            i++;
          }
        else if (*recorrer == '/')
          {
            /*Codificamos el caracter*/
            auxiliar[i] = '%';
            i++;
            auxiliar[i] = '2';
            i++;
            auxiliar[i] = 'F';
            i++;
          }
        else if (*recorrer == '.')
          {
            /*Codificamos el caracter*/
            auxiliar[i] = '%';
            i++;
            auxiliar[i] = '2';
            i++;
            auxiliar[i] = 'E';
            i++;
          }
        else if (*recorrer == ',')
          {
            /*Codificamos el caracter*/
            auxiliar[i] = '%';
            i++;
            auxiliar[i] = '2';
            i++;
            auxiliar[i] = 'C';
            i++;
          }
        else
          {
            /*Solo copiamos el caracter*/
            auxiliar[i] = *recorrer;
            i++;
          }
      }
    /*Colocamos el final de la cadena de caracteres*/
    auxiliar[i] = '\0';
    strcpy (cadena, &auxiliar[0]);
    return 0;
  }

listarollos *cargar_lista_local_rollos ()
  {
    FILE *archivo=NULL;
    listarollos *primero=NULL, *nuevo=NULL, *auxiliar=NULL;
    rollovouchers registro;
    unsigned int id=0;
    /*Abrimos el archivo*/
    archivo = fopen (ARCHIVO_ROLLOS, "rb");
    /*Comprobamos si se pudo abrir*/
    if (archivo != NULL)
      {
        /*Leemos el archivo hasta el final*/
        while (!feof (archivo) )
          {
            /*Leemos un registro del archivo y comprobamos que no hubo errores*/
            if (fread (&registro, sizeof (rollovouchers), 1, archivo) != 1) break;
            /*Reservamos memoria para mantenerlo en memoria*/
            nuevo = (listarollos *) malloc (sizeof (listarollos) );
            /*Comprobamos que no haya ningun error*/
            if (nuevo == NULL) exit (-1);
            /*Copiamos los valores leidos*/
            nuevo -> id = id;
            id ++;
            nuevo -> rollo . rollo = registro . rollo;
            nuevo -> rollo . minutos = registro . minutos;
            nuevo -> rollo . numerovouchers = registro . numerovouchers;
            strcpy ( &(nuevo -> rollo . comentario[0]), &(registro . comentario [0]) );
            nuevo -> siguiente = NULL;
            /*Lo añadimos a la lista*/
            if (primero == NULL)
              {
                primero = nuevo;
                auxiliar = nuevo;
                nuevo = NULL;
              }
            else
              {
                /*Lo añadimos al final de la lista*/
                auxiliar -> siguiente = nuevo;
                auxiliar = nuevo;
              }
          }
        /*Cerramos el archivo*/
        fclose (archivo);
      }
    return primero;
  }

int guardar_lista_local_rollos (listarollos *primero)
  {
    FILE *archivo=NULL;
    listarollos *auxiliar=NULL;
    rollovouchers registro;
    /*Eliminamos un posible archivo de respaldo de los rollos*/
    remove (ARCHIVO_RESPALDO_ROLLOS);
    /*Renombramos el archivo existente como copia de respaldo*/
    rename (ARCHIVO_ROLLOS, ARCHIVO_RESPALDO_ROLLOS);
    /*Abrimos el archivo*/
    archivo = fopen (ARCHIVO_ROLLOS, "wb");
    /*Comprobamos si se pudo abrir*/
    if (archivo != NULL)
      {
        /*Recorremos la lista de rollos*/
        for (auxiliar = primero; auxiliar != NULL; auxiliar = auxiliar -> siguiente )
          {
            /*Copiamos los valores a escribir*/
            registro . rollo = auxiliar -> rollo . rollo;
            registro . minutos = auxiliar -> rollo . minutos;
            registro . numerovouchers = auxiliar -> rollo . numerovouchers;
            strcpy (&(registro . comentario [0]), &(auxiliar -> rollo . comentario[0]) );
            /*Escribimos un registro del archivo*/
            fwrite (&registro, sizeof (rollovouchers), 1, archivo);
          }
        /*Cerramos el archivo*/
        fclose (archivo);
        /*Eliminamos el archivo de respaldo de los rollos*/
        remove (ARCHIVO_RESPALDO_ROLLOS);
      }
    else
      {
        /*Eliminamos el archivo de los rollos*/
        remove (ARCHIVO_ROLLOS);
        /*Renombramos el archivo de respaldo para recuperarlo*/
        rename (ARCHIVO_RESPALDO_ROLLOS, ARCHIVO_ROLLOS);
      }
    return 0;
  }

int agregar_rollo_lista (listarollos **lista, unsigned int rollo, unsigned int minutos, unsigned int numerovouchers, char *comentario)
  {
    listarollos *auxiliar=NULL, *nuevo=NULL;
    /*Reservamos memoria para el nuevo rollo*/
    nuevo = (listarollos *) malloc (sizeof (listarollos) );
    /*Comprobamos que no haya ningun error*/
    if (nuevo == NULL) exit (-1);
    /*Copiamos los valores*/
    nuevo -> rollo . rollo = rollo;
    nuevo -> rollo . minutos = minutos;
    nuevo -> rollo . numerovouchers = numerovouchers;
    strcpy ( &(nuevo -> rollo . comentario[0]), comentario);
    nuevo -> siguiente = NULL;
    /*Comprobamos si la lista esta vacia*/
    if (*lista == NULL)
      {
        /*Al ser el primer elemento su numeración en la lista es la 0*/
        nuevo -> id = 0;
        /*Lo incluimos en la lista en la primera posición*/
        *lista = nuevo;
      }
    else
      {
        /*Buscamos el final de la lista*/
        auxiliar = *lista;
        while (auxiliar -> siguiente != NULL) auxiliar = auxiliar -> siguiente;
        /*Calculamos la numeración en lista del nuevo rollo*/
        nuevo -> id = auxiliar -> id + 1;
        /*Lo incluimos en la lista*/
        auxiliar -> siguiente = nuevo;
      }
    /*Guardamos la lista de rollos para mantener la lista de rollos actualziada
       a los cambios hechos*/
    guardar_lista_local_rollos (*lista);
    return 0;
  }

int liberar_lista_rollos (listarollos *primero)
  {
    listarollos *recorrer, *liberar;
    /*Nos situamos al comienzo de la lista*/
    liberar = primero;
    /*Liberamos hasta que no queden elementos*/
    while (liberar != NULL)
      {
        /*Obtenemos el proximo elemento*/
        recorrer = liberar -> siguiente;
        /*Liberamos el actual*/
        free (liberar);
        /*Pasamos al siguiente*/
        liberar = recorrer;
      }
    return 0;
  }

int buscar_id_rollo (listarollos *primero, unsigned int rollo, unsigned int *id)
  {
    int encontrado=-1;
    listarollos *auxiliar;
    /*Recorremos la lista*/
    for (auxiliar = primero; auxiliar != NULL; auxiliar = auxiliar -> siguiente)
      {
        /*Comprobamos si es el rollo que buscamos*/
        if (rollo == auxiliar -> rollo . rollo)
          {
            /*Asignamos el valor de posición en lista*/
            *id = auxiliar -> id;
            /*Indicamos que lo encontramos*/
            encontrado = 0;
          }
      }
    return encontrado;
  }

int eliminar_rollo_lista (listarollos **lista, unsigned int rollo)
  {
    listarollos *recorrer=NULL, *liberar=NULL;
    char archivo[64];
    char archivorenombrado[64];
    /*Comprobamos si es el primer elemento*/
    if ( (*lista) -> rollo . rollo == rollo)
      {
        /*Apuntamos al elemento a liberar*/
        liberar = *lista;
        /*Quitamos el primer elemento*/
        *lista = liberar -> siguiente;
        /*Apuntamos al primer elemento que deberemos corregir la numeración*/
        recorrer = *lista;
      }
    else
      {
        /*Buscamos el rollo anterior al rollo a eliminar*/
        recorrer = *lista;
        while (recorrer -> siguiente -> rollo . rollo != rollo) recorrer = recorrer -> siguiente;
        /*Apuntamos al elemento a liberar*/
        liberar = recorrer -> siguiente;
        /*Lo sacamos de la lista*/
        recorrer -> siguiente = liberar -> siguiente;
        /*Apuntamos al primer elemento que deberemos corregir la numeración*/
        recorrer = recorrer -> siguiente;
      }
    /*Formamos la ruta al archivo del rollo*/
    sprintf (&archivo[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, liberar -> id, ".dat");
    /*Liberamos lamemoria*/
    free (liberar);
    /*Eliminamos el archivo del rollo*/
    remove (&archivo[0]);
    /*Recorremos todos los rollos de la lista a los que hay que corregirles la
       numeración para que sea continua en toda la lista*/
    while (recorrer != NULL)
      {
        /*Formamos la ruta al archivo del rollo*/
        sprintf (&archivo[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, recorrer -> id, ".dat");
        /*Corregimos la númeracion del rollo*/
        recorrer -> id --;
        /*Formamos la ruta al nuevo nombre del archivo del rollo*/
        sprintf (&archivorenombrado[0], "%s%u%s", PREFIJO_ARCHIVO_VOUCHERS, recorrer -> id, ".dat");
        /*Renombramos el archivo*/
        rename (&archivo[0], &archivorenombrado[0]);
        /*Pasamos al siguiente*/
        recorrer = recorrer -> siguiente;
      }
    /*Guardamos la lista de rollos para mantener la lista de rollos actualziada
       a los cambios hechos*/
    guardar_lista_local_rollos (*lista);
    return 0;
  }