密码生成器 (C 语言版)

//Parser.h

#ifndef _PARSER_H_
#define _PARSER_H_

#include <ctype.h>

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

#define NO_FILE -1
#define NO_PASSWORD -1
#define NO_POS -1

int getLast (char* , char);

int getFilePos (char** , int);
int getPasswordSize (char** , int);

int getFile (char** , char* , int);

#endif /* _PARSER_H_ */

//Parser.c

#include "Parser.h"

int getLast (char* String , char Char)
{
    //Iterate and get the last instance of the character
    int i = 0;
    int Pos = 0;

    for (i = 0 ; i < strlen (String) ; ++i)
    {
	//Check if current character is the one we are looking for
	if (String [i] == Char)
	{   
	    //Assign to the current position
	    Pos = i;
	}
    }
    
    //Check if we found the character
    if (Pos == 0)
    {
	return NO_POS;
    }    
    else
    {
	return ++Pos;
    }
}

int getFilePos (char** Arguments , int Size)
{
    //Iterate and check whether there are any dashes
    int i = 0;
    int j = 0;
    
    for (i = 0 ; i < Size ; ++i)
    {
	for (j = 0 ; j < strlen (Arguments [i]) ; ++j)
	{
	    //Check if there is any dashes
	    if (Arguments [i][j] == '-')
	    {	
		//Return the string that has the dashes		
		return i;
	    }
	}
    }
    
    return NO_FILE;
}

int getPasswordSize (char** Arguments , int Size)
{
    //Iterate
    int i = 0;
    int j = 0;
    
    for (i = 0 ; i < Size ; ++i)
    {
	//Temp variable
	int Temp = 0;

	for (j = 0 ; j < strlen (Arguments [i]) ; ++j)
	{
	    //If this is not a number then break
	    if (!isdigit (Arguments [i][j]))
	    {
		break;
	    }
	    //Otherwise increment a temp variable
	    else
	    {
		Temp++;
	    }
	}

	//All of the characters in the current string were numbers
	if (Temp == strlen (Arguments [i]))
	{
	    //Return the integer value
	    return atoi (Arguments [i]);
	}
    }
    
    return NO_PASSWORD;
}



int getFile (char** Arguments , char* Buffer , int Size)
{
    //Check if the file exists
    if (getFilePos (Arguments , Size) == NO_FILE)
    {
	return NO_FILE;
    }
    else
    {
	//String containing the file argument
	char* File = Arguments [getFilePos (Arguments , Size)];

	//Copy the rest of the string
	strcpy (Buffer , File + getLast (File , '-'));
	
	//Everything is okay
	return 0;
    }
}

//Generator.h

#ifndef _GENERATOR_H_
#define _GENERATOR_H_

#include <time.h>
#include <stdlib.h>

#include "Parser.h"

#define MAX_PASSWORD_SIZE 500

char randomChar ();

void appendChar (char* , char);
void printPassword (char** , int);

int genPassword (char** , char* , int);

#endif /* _GENERATOR_H_ */

//Generator.c

#include "Generator.h"

char randomChar ()
{
    char Chars [] = 
	"abcdefghijkmnlopqrstuvwxz"
	"ABCDEFGHIJKMNLOPQRSTUVWXYZ"
	"1234567890";
    
    return Chars [rand () % strlen (Chars)];
}

void appendChar (char* Buffer , char Char)
{
    //Buffer size
    int Size = strlen (Buffer);

    //Add the character and the null character
    Buffer [Size] = Char;
}

int genPassword (char** Arguments , char* Buffer , int Size)
{
    //Password Size
    int PasswordSize = getPasswordSize (Arguments , Size);

    //Check if the size is valid
    if (PasswordSize == NO_PASSWORD)
    {
	return NO_PASSWORD;
    }
    if (PasswordSize > MAX_PASSWORD_SIZE)
    {
	return NO_PASSWORD;
    }

    //Iterate and append a character the end of the string
    int i = 0;
    
    for (i = 0 ; i  < PasswordSize ; ++i)
    {
	appendChar (Buffer , randomChar ());
    }
    
    return 0;
}

void printPassword (char** Arguments , int Size)
{
    char Buffer [FILENAME_MAX] = "";
    
    //Check if we could generate a password
    if (genPassword (Arguments , Buffer , Size) == NO_PASSWORD)
    {
	fprintf (stderr , "Invalid password size!! \n");
	return;
    }

    //Check where we are printing to
    if (getFilePos (Arguments , Size) == NO_FILE)
    {
	fprintf (stdout , "%s \n" , Buffer);
    }
    else
    {
	//File path
	char FilePath [FILENAME_MAX] = "";

	//Generate the path
	getFile (Arguments , FilePath , Size);

	//Stream to print to
	FILE* Stream = fopen (FilePath , "a");

	//Check if the stream is valid
	if (Stream == NULL)
	{
	    return;
	}
	//We can write to the file
	else
	{	    
	    //Print it
	    fprintf (Stream , "%s \n" , Buffer);
	    
	    //Close the stream
	    fclose (Stream);
	}
    }
}

//main.c

#include <stdio.h>

#include "Parser.h"
#include "Generator.h"

int main(int argc , char* argv[])
{
    //Check if there are any arguments
    if (argc < 2)
    {
	//Print out usage
	fprintf (stderr , "Usage: %s --File PasswordSize \n \n" , argv [0]);
	fprintf (stderr , "Examples:\n%s --Passwords.txt 34 \n" , argv [0]);
	fprintf (stderr , "%s 7 \n" , argv [0]);
    
        //There was an error!!
	return 1;
    }

    //Seed the generator
    srand ((unsigned) time (NULL));

    //Print password
    printPassword (argv , argc);

    return 0;
}