/*
** Copyright (c) 1999, 2000, 2001, 2002, 2003
** Adel I. Mirzazhanov. All rights reserved
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1.Redistributions of source code must retain the above copyright notice,
** this list of conditions and the following disclaimer.
** 2.Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3.The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
** OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
** GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include <string.h>
#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
#include <strings.h>
#endif
#ifndef APGBFM
#include "fips181.h"
#include "randpass.h"
#endif
#include "base/rand_util.h"
#include "convert.h"
/*
** GLOBALS
*/
/* small letters */
char let[26] =
{
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'w', 'z'
};
/* capital letters */
char clet[26] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'W', 'Z'
};
/*
** FUNCTIONS
*/
/*
** decapitalize() - This routine replaces all capital letters
** to small letters in the word:
** INPUT:
** char * - word.
** OUTPUT:
** none.
** NOTES:
** none.
*/
void
decapitalize (char *word)
{
int i = 0; /* counter */
int j = 0; /* counter */
int str_len = (int) strlen(word);
for(j = 0; j < str_len; j++)
for(i=0; i < 26; i++)
if(word[j] == clet[i])
word[j] = let[i];
}
#ifndef APGBFM
/*
** capitalize() - This routine designed to modify sullable like this:
** adel ----> Adel
** dot ----> Dot
** etc.
** INPUT:
** char * - syllable.
** OUTPUT:
** none.
** NOTES:
** none.
*/
void
capitalize (char *syllable)
{
char tmp = 0x00;
int i = 0;
if (base::RandInt(0, 1) == 1)
{
(void)memcpy((void *)&tmp, (void *)syllable, sizeof(tmp));
for(i=0; i < 26; i++)
if ( let[i] == tmp )
if (is_restricted_symbol(clet[i]) != TRUE)
(void)memcpy ((void *)syllable, (void *)&clet[i], 1);
}
}
/*
** numerize() - This routine designed to modify single-letter
** syllable like this:
** a ----> 1 or 2 or 3 etc.
** u ----> 1 or 2 or 3 etc.
** etc.
** INPUT:
** char * - single-letter syllable
** OUTPUT:
** none.
** NOTES:
** none.
*/
void
numerize (char *syllable)
{
char *tmp = (char *)calloc(1, 4);
if ( strlen (syllable) == 1 )
{
(void) gen_rand_symbol(tmp, S_NB);
(void)memcpy ((void *)syllable, (void *)tmp, 1);
}
free ((void *)tmp);
}
/*
** specialize() - This routine designed to modify single-letter syllable
** like this:
** a ----> # or $ or % etc.
** u ----> # or $ or % etc.
** etc.
** INPUT:
** char * - single-letter syllable.
** OUTPUT:
** none.
** NOTES:
** none.
*/
void
specialize (char *syllable)
{
char *tmp = (char *)calloc(1, 4);
if ( strlen (syllable) == 1 )
{
(void) gen_rand_symbol(tmp, S_SS);
(void)memcpy ((void *)syllable, (void *)tmp, 1);
}
free ((void *)tmp);
}
/*
** symb2name - convert symbol to it's name
** INPUT:
** char * - one symbol syllable
** OUTPUT:
** none.
** NOTES:
** none.
*/
void
symb2name(char * syllable, char * h_syllable)
{
struct ssymb_names
{
char symbol;
const char * name;
};
static const struct ssymb_names ssn[42] =
{
{'1',"ONE"},
{'2',"TWO"},
{'3',"THREE"},
{'4',"FOUR"},
{'5',"FIVE"},
{'6',"SIX"},
{'7',"SEVEN"},
{'8',"EIGHT"},
{'9',"NINE"},
{'0',"ZERO"},
{33, "EXCLAMATION_POINT"},
{34, "QUOTATION_MARK"},
{35, "CROSSHATCH"},
{36, "DOLLAR_SIGN"},
{37, "PERCENT_SIGN"},
{38, "AMPERSAND"},
{39, "APOSTROPHE"},
{40, "LEFT_PARENTHESIS"},
{41, "RIGHT_PARENTHESIS"},
{42, "ASTERISK"},
{43, "PLUS_SIGN"},
{44, "COMMA"},
{45, "HYPHEN"},
{46, "PERIOD"},
{47, "SLASH"},
{58, "COLON"},
{59, "SEMICOLON"},
{60, "LESS_THAN"},
{61, "EQUAL_SIGN"},
{62, "GREATER_THAN"},
{63, "QUESTION_MARK"},
{64, "AT_SIGN"},
{91, "LEFT_BRACKET"},
{92, "BACKSLASH"},
{93, "RIGHT_BRACKET"},
{94, "CIRCUMFLEX"},
{95, "UNDERSCORE"},
{96, "GRAVE"},
{123, "LEFT_BRACE"},
{124, "VERTICAL_BAR"},
{125, "RIGHT_BRACE"},
{126, "TILDE"}
};
int i = 0;
int flag = FALSE;
if (strlen(syllable) == 1)
{
for (i = 0; i < 42; i++)
{
if(*syllable == ssn[i].symbol)
{
(void)memcpy((void*)h_syllable, (void*)ssn[i].name, strlen(ssn[i].name));
flag = TRUE;
}
}
if (flag != TRUE)
(void)memcpy((void*)h_syllable, (void*)syllable, strlen(syllable));
}
}
/*
** spell_word - spell the word
** INPUT:
** char * - pointer to the word
** char * - pointer to the spelled word
** OUTPUT:
** char * - pointer to the spelled word
** NULL - something is wrong
** NOTES:
** You should free() memory pointed by spelled_word after each use of spell_word
*/
char *
spell_word(char * word, char * spelled_word)
{
struct char_spell
{
char symbol;
const char *name;
};
static struct char_spell cs[94] =
{
{'1',"ONE" },
{'2',"TWO" },
{'3',"THREE" },
{'4',"FOUR" },
{'5',"FIVE" },
{'6',"SIX" },
{'7',"SEVEN" },
{'8',"EIGHT" },
{'9',"NINE" },
{'0',"ZERO" },
{'A', "Alfa" },
{'B', "Bravo" },
{'C', "Charlie" },
{'D', "Delta" },
{'E', "Echo" },
{'F', "Foxtrot" },
{'G', "Golf" },
{'H', "Hotel" },
{'I', "India" },
{'J', "Juliett" },
{'K', "Kilo" },
{'L', "Lima" },
{'M', "Mike" },
{'N', "November" },
{'O', "Oscar" },
{'P', "Papa" },
{'Q', "Quebec" },
{'R', "Romeo" },
{'S', "Sierra" },
{'T', "Tango" },
{'U', "Uniform" },
{'V', "Victor" },
{'W', "Whiskey" },
{'X', "X_ray" },
{'Y', "Yankee" },
{'Z', "Zulu" },
{'a', "alfa" },
{'b', "bravo" },
{'c', "charlie" },
{'d', "delta" },
{'e', "echo" },
{'f', "foxtrot" },
{'g', "golf" },
{'h', "hotel" },
{'i', "india" },
{'j', "juliett" },
{'k', "kilo" },
{'l', "lima" },
{'m', "mike" },
{'n', "november" },
{'o', "oscar" },
{'p', "papa" },
{'q', "quebec" },
{'r', "romeo" },
{'s', "sierra" },
{'t', "tango" },
{'u', "uniform" },
{'v', "victor" },
{'w', "whiskey" },
{'x', "x_ray" },
{'y', "yankee" },
{'z', "zulu" },
{33, "EXCLAMATION_POINT"},
{34, "QUOTATION_MARK" },
{35, "CROSSHATCH" },
{36, "DOLLAR_SIGN" },
{37, "PERCENT_SIGN" },
{38, "AMPERSAND" },
{39, "APOSTROPHE" },
{40, "LEFT_PARENTHESIS" },
{41, "RIGHT_PARENTHESIS"},
{42, "ASTERISK" },
{43, "PLUS_SIGN" },
{44, "COMMA" },
{45, "HYPHEN" },
{46, "PERIOD" },
{47, "SLASH" },
{58, "COLON" },
{59, "SEMICOLON" },
{60, "LESS_THAN" },
{61, "EQUAL_SIGN" },
{62, "GREATER_THAN" },
{63, "QUESTION_MARK" },
{64, "AT_SIGN" },
{91, "LEFT_BRACKET" },
{92, "BACKSLASH" },
{93, "RIGHT_BRACKET" },
{94, "CIRCUMFLEX" },
{95, "UNDERSCORE" },
{96, "GRAVE" },
{123, "LEFT_BRACE" },
{124, "VERTICAL_BAR" },
{125, "RIGHT_BRACE" },
{126, "TILDE" }
};
int s_length = 0;
int i = 0;
int j = 0;
int word_len = (int) strlen(word);
char * tmp_ptr;
char hyphen = '-';
char zero = 0x00;
/* Count the length of the spelled word */
for (i=0; i <= word_len; i++)
for (j=0; j < 94; j++)
if (word[i] == cs[j].symbol)
{
s_length = s_length + (int) strlen(cs[j].name) + 1;
continue;
}
/* Allocate memory for spelled word */
if ( (spelled_word = (char *)calloc(1, (size_t)s_length)) == NULL)
return(NULL);
/* Construct spelled word */
tmp_ptr = spelled_word;
for (i=0; i < word_len; i++)
for (j=0; j < 94; j++)
if (word[i] == cs[j].symbol)
{
(void) memcpy((void *)tmp_ptr, (void *)cs[j].name, strlen(cs[j].name));
tmp_ptr = tmp_ptr + strlen(cs[j].name);
/* Place the hyphen after each symbol */
(void) memcpy((void *)(tmp_ptr), (void *)&hyphen, 1);
tmp_ptr = tmp_ptr + 1;
continue;
}
/* Remove hyphen at the end of the word */
tmp_ptr = tmp_ptr - 1;
(void) memcpy((void *)(tmp_ptr), (void *)&zero, 1);
return (spelled_word);
}
#endif /* APGBFM */