programa < fichero.txt

while (getchar()!='\n');

/*
 * Cifrado de Vigenere
 *
 * Linea de comandos: nombre_programa -a alfabeto -[c|f] cadena|fichero -k clave -s [fichero_salida | std]
 *
 * Cifra los caracteres de la cadena (parametros -c "Cadena") o el fichero (parametros -f nombre_del_fichero)
 * que coincidan con los del alfabeto (- que se le pasa, utilizando la clave dada (parametros -k clave)
 *
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_STRLEN 256
 
/*
 * Las siguientes constantes sirven para decidir si la funcion vigenere actuara sobre una cadena o un fichero
 */
#define IN_CADENA  0
#define IN_FICHERO 1
 
/*
 * Constantes para decidir si la funcion vigenere cifrara o descifrara la entrada
 */
#define ACCION_CIFRAR    0
#define ACCION_DESCIFRAR 1
 
/*
 * vigenere(tipo entrada (cadena o fichero), cadena con texto o nombre de fichero con el input,
 * alfabeto, clave, cifrar|descifrar, fichero de salida (stdin o nombre de arcivo))
 *
 * valor de retorno: 0 si algo falla, 1 si todo va bien.
 */
 
 unsigned long flen(FILE *f)
{
    unsigned long pos,len;
 
    pos = ftell(f);
    fseek(f,0,SEEK_END);
    len = ftell(f);
    fseek(f,pos,SEEK_SET);
 
    return len;
}
 
int vigenere(int modo_input, char *cadena, char *alfabeto, char *clave, char accion, FILE *salida)
{
    FILE *entrada = NULL;
    unsigned long longitud,tam_bloque,tam_clave,tam_alfabeto;
    char *lector,*busqueda;
    int *desplazamiento,i,indice = 0;
 
    /* comprobamos que en alfabeto no haya letras repetidas */
    for(i = 0 ; alfabeto[i] ; i++)
        if(strchr(alfabeto + i + 1,alfabeto[i]))
            return 0;
 
    /* comprobamos que los caractreres de la clave esten en el alfabeto */
    for(i = 0 ; clave[i] ; i++)
        if(!strchr(alfabeto,clave[i]))
            return 0;
 
    if(modo_input == IN_CADENA)
        longitud = strlen(cadena);
    else if(modo_input == IN_FICHERO)
    {
        if(!(entrada = fopen(cadena,"rb")))
            return 0;
 
        longitud = flen(entrada);
    }
    else
        return 0;
 
    tam_alfabeto = strlen(alfabeto);
    tam_clave = tam_bloque = strlen(clave);
 
    if(!(lector = malloc(tam_bloque * sizeof(char))))
        return 0;
 
    if(!(desplazamiento = malloc(tam_bloque * sizeof(int))))
    {
        free(lector);
        return 0;
    }
 
    for(i = 0 ; clave[i] ; i++)
    {
        if(!(busqueda = strchr(alfabeto,clave[i])))
        {
            free(lector);
            free(desplazamiento);
 
            return 0;
        }
 
        if(accion == ACCION_CIFRAR)
            desplazamiento[i] = busqueda - alfabeto;
        else if(accion == ACCION_DESCIFRAR)
            desplazamiento[i] = alfabeto - busqueda; /* el desplazamiento de descifrado es el opuesto del de cifrado */
        else
        {
            free(lector);
            free(desplazamiento);
 
            return 0;
        }
    }
 
    if(modo_input == IN_CADENA)
    {
        while(longitud)
        {
            if(longitud < tam_bloque)
                tam_bloque = longitud;
 
            memcpy(lector,cadena,tam_bloque * sizeof(char));
 
            for(i = 0 ; i < tam_bloque ; i++)
            {
                if(busqueda = strchr(alfabeto,lector[i]))
                {
                    lector[i] = alfabeto[((busqueda - alfabeto) + desplazamiento[indice] + tam_alfabeto) % tam_alfabeto];
                    indice = (indice + 1) % tam_clave;
                }
            }
 
            fwrite(lector , tam_bloque*sizeof(char) , 1 , salida);
 
            if((tam_bloque == tam_clave) && (longitud > tam_bloque))
                cadena += tam_bloque;
 
            longitud -= tam_bloque;
        }
    }
    else if(modo_input == IN_FICHERO)
    {
        while(longitud)
        {
            if(longitud < tam_bloque)
                tam_bloque = longitud;
 
            fread(lector,tam_bloque * sizeof(char),1,entrada);
 
            for(i = 0 ; i < tam_bloque ; i++)
            {
                if(busqueda = strchr(alfabeto,lector[i]))
                {
                    lector[i] = alfabeto[((busqueda - alfabeto) + desplazamiento[indice] + tam_alfabeto) % tam_alfabeto];
                    indice = (++indice) % tam_clave;
                }
            }
 
            fwrite(lector , tam_bloque*sizeof(char) , 1 , salida);
 
            longitud -= tam_bloque;
        }
    }
    else
    {
        if(entrada)
            fclose(entrada);
 
        free(lector);
        free(desplazamiento);
 
        return 0;
    }
 
    if(entrada)
        fclose(entrada);
 
    free(lector);
    free(desplazamiento);
 
    return 1;
}
 
int main(int argc, char *argv[])
{
    char error[] = "%s [+|-]c (cifrar|descifrar) -a alfabeto -[s|f] [cadena|fichero] -k clave -o [fichero_salida|std]\n";
    char alfabeto[MAX_STRLEN] = "", fentrada[MAX_STRLEN] = "", clave[MAX_STRLEN] = "", fsalida[MAX_STRLEN] = "";
    char *texto = NULL,*ftemp = NULL;
    int sobreescribir = 0, modo = ACCION_CIFRAR + ACCION_DESCIFRAR + 1, i, j;
    FILE *f;
 
    if(argc != 10)
    {
        fprintf(stderr,error,argv[0]);
        return 1;
    }
 
    for(i = 1 ; i < 10 ; i += 2)
    {
        if(!strcmp(argv[i],"-a"))
        {
            if(strlen(alfabeto))
            {
                fprintf(stderr,"-a: Parametro repetido\n");
                return 2;
            }
 
            if(!strlen(argv[i + 1]))
            {
                fprintf(stderr,"-a: Alfabeto vacio no permitido\n");
                return 3;
            }
 
            for(j = 0 ; argv[i + 1][j] ; j++)
            {
                if(strchr(argv[i + 1] + j + 1, argv[i + 1][j]))
                {
                    fprintf(stderr,"-a: No se permiten caracteres repetidos en el alfabeto\n");
                    return 4;
                }
            }
 
            if(strlen(argv[i + 1]) >= MAX_STRLEN)
            {
                fprintf(stderr,"-a: El alfabeto es demasiado largo. Se truncara a partir del caracter %d.\n",MAX_STRLEN);
 
                strncpy(alfabeto, argv[i + 1], 255);
                alfabeto[255] = '\0';
            }
            else
                strcpy(alfabeto,argv[i + 1]);
        }
        else if(!strcmp(argv[i],"-s"))
        {
            if(texto || strlen(fentrada))
            {
                fprintf(stderr,"-s: Parametro -[s|f] repetido\n");
                return 5;
            }
 
            texto = argv[i + 1];
        }
        else if(!strcmp(argv[i],"-f"))
        {
            if(texto || strlen(fentrada))
            {
                fprintf(stderr,"-f: Parametro -[s|f] repetido\n");
                return 6;
            }
 
            if(strlen(argv[i + 1]) >= MAX_STRLEN)
            {
                fprintf(stderr,"-f: El nombre del fichero de entrada no debe exceder los %d caracteres\n",MAX_STRLEN);
                return 7;
            }
 
            if(!strlen(argv[i + 1]))
            {
                fprintf(stderr,"-f: El nombre del fichero de entrada no puede estar vacio\n");
                return 8;
            }
 
            strcpy(fentrada,argv[i + 1]);
        }
        else if(!strcmp(argv[i],"-k"))
        {
            if(strlen(clave))
            {
                fprintf(stderr,"-k: Parametro -k repetido\n");
                return 9;
            }
 
            if(!strlen(argv[i + 1]))
            {
                fprintf(stderr,"-k: No se permiten claves vacias");
                return 10;
            }
 
            if(strlen(argv[i + 1]) >= MAX_STRLEN)
            {
                fprintf(stderr,"-k: La clave no debe exceder los %d caracteres\n",MAX_STRLEN);
                return 11;
            }
 
            if(!strlen(argv[i + 1]))
            {
                fprintf(stderr,"-k: La clave no puede ser vacia\n");
                return 12;
            }
 
            strcpy(clave,argv[i + 1]);
        }
        else if(!strcmp(argv[i],"-o"))
        {
            if(strlen(fsalida))
            {
                fprintf(stderr,"-o: Parametro -o repetido\n");
                return 13;
            }
 
            if(strlen(argv[i + 1]) >= MAX_STRLEN)
            {
                fprintf(stderr,"-o: El nombre del fichero de salida no debe exceder los %d caracteres\n",MAX_STRLEN);
                return 14;
            }
 
            if(!strlen(argv[i + 1]))
            {
                fprintf(stderr,"-o: El nombre del fichero de salida no puede estar vacio\n");
                return 15;
            }
 
            strcpy(fsalida,argv[i + 1]);
        }
        else if(!strcmp(argv[i],"-c"))
        {
            if(!(modo ^ ACCION_CIFRAR) || !(modo ^ ACCION_DESCIFRAR))
            {
                fprintf(stderr,"-c: Parametro [+|-]c repetido\n");
                return 16;
            }
 
            modo = ACCION_DESCIFRAR;
            i--; /* este argumento no tiene asociado un parametro */
        }
        else if(!strcmp(argv[i],"+c"))
        {
            if(!(modo ^ ACCION_CIFRAR) || !(modo ^ ACCION_DESCIFRAR))
            {
                fprintf(stderr,"+c: Parametro [+|-]c repetido\n");
                return 17;
            }
 
            modo = ACCION_CIFRAR;
            i--; /* este argumento no tiene asociado un parametro */
        }
        else
        {
            fprintf(stderr,error,argv[0]);
            return 18;
        }
    }
 
    //comprobar que los caracteres de la clave estan en el alfabeto
    for(i = 0 ;  clave[i] ; i++)
    {
        if(!strchr(alfabeto,clave[i]))
        {
            fprintf(stderr,"La clave contiene caracteres que no aparecen en el alfabeto\n");
            return 19;
        }
    }
 
    if(!strcmp(fsalida,"std"))
    {
        f = stdout;
    }
    else
    {
        if(f = fopen(fsalida,"r"))
        {
            char opcion;
 
            do{
                printf("El fichero de salida ya existe. Deseas sobreescribirlo? (S/N) ");
                opcion = getchar();
 
                if(opcion > 'Z')
                    opcion += 'S' - 's';
 
                while(getchar() != '\n');
 
            }while(opcion!= 'S' && opcion!='N');
 
            if(opcion == 'S')
            {
                fclose(f);
 
                ftemp = tmpnam(NULL);
 
                if(!(f = fopen(ftemp,"wb")))
                {
                    fprintf(stderr,"%s: Error al abrir el fichero de salida\n",argv[0]);
                    return 20;
                }
                sobreescribir = 1;
            }
            else
            {
                fclose(f);
                return 0;
            }
        }
        else
            f = fopen(fsalida,"wb");
    }
 
    //si fsalida == std llamar a vigenere con los parametro y fsalida stdout
    if(texto)
    {
        if(!vigenere(IN_CADENA,texto,alfabeto,clave,modo,f))
        {
            fprintf(stderr,"%s no ha podido cifrar la informacion dada\n",argv[0]);
            return 21;
        }
    }
    else
    {
        if(!vigenere(IN_FICHERO,fentrada,alfabeto,clave,modo,f))
        {
            fprintf(stderr,"%s no ha podido cifrar la informacion dada\n",argv[0]);
            return 21;
        }
    }
 
    if(strcmp(fsalida,"std"))
        fclose(f);
 
    if(sobreescribir)
    {
        remove(fentrada);
        rename(ftemp,fentrada);
        remove(ftemp);
    }
 
    return 0;
}