-// ANNA - Anna is Not 'N' Anymore
-//
-// (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
-//
-// https://bitbucket.org/testillano/anna
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "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 COPYRIGHT
-// OWNER OR CONTRIBUTORS 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.
-//
-// Authors: eduardo.ramos.testillano@gmail.com
-// cisco.tierra@gmail.com
+// ANNA - Anna is Not Nothingness Anymore //
+// //
+// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo //
+// //
+// See project site at http://redmine.teslayout.com/projects/anna-suite //
+// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
#include <stdarg.h>
#include <anna/core/util/Tokenizer.hpp>
#include <algorithm>
+#include <fstream>
+#include <sstream>
using namespace anna;
#define PAGE_WIDTH_LENGTH 80
-ExclusiveHash <std::string> functions::st_stringExclusiveHash;
-ExclusiveHash <std::string, int> functions::st_string2intExclusiveHash;
+static const std::string base64_chars =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789+/";
+
string functions::getVersion() throw() {
static const int version = ANNA_VERSION;
return string(aux);
}
-string functions::asString(const unsigned long number)
-throw() {
- return asString((Unsigned64)number);
-}
-
-string functions::asString(const Integer64 number)
+string functions::asString(const S64 number)
throw() {
char aux [24];
- sprintf(aux, "%lld", number);
- /*#ifdef __anna64__
+ //sprintf(aux, "%lld", number);
+ #ifdef __anna64__
sprintf (aux, "%ld", number);
#else
sprintf (aux, "%lld", number);
#endif
- */
return string(aux);
}
return string(aux);
}
-string functions::asString(const Unsigned64 number)
+string functions::asString(const U64 number)
throw() {
char aux [16];
- sprintf(aux, "%llu", number);
- /*
+ //sprintf(aux, "%llu", number);
#ifdef __anna64__
sprintf (aux, "%lu", number);
#else
sprintf (aux, "%llu", number);
#endif
- */
return string(aux);
}
throw() {
struct tm* tt = localtime((time_t*) & second);
sprintf(
- result, "%02d/%02d/%4d %02d:%02d:%02d",
+ result, "%02u/%02u/%4u %02u:%02u:%02u",
tt->tm_mday, tt->tm_mon + 1, tt->tm_year + 1900,
tt->tm_hour, tt->tm_min, tt->tm_sec
);
return string(aux);
}
-string functions::asHexString(const long number)
-throw() {
- return asHexString((Integer64)number);
-}
-
-string functions::asHexString(const Integer64 number)
+string functions::asHexString(const S64 number)
throw() {
char aux [32];
- sprintf(aux, "0x%llx", number);
- /*
+ //sprintf(aux, "0x%llx", number);
#ifdef __anna64__
sprintf (aux, "0x%lx", number);
#else
sprintf (aux, "0x%llx", number);
#endif
- */
return string(aux);
}
// from a version by Allen Holub (see Andrew Binstock, "Hashing Revisited"
// Dr. Dobb's Journal, April 1996)
-Integer64 functions::hash(const char* p)
+S64 functions::hash(const char* p)
throw() {
- static const int long_bits = sizeof(Integer64) << 3;
+ static const int long_bits = sizeof(S64) << 3;
static const int one_eighth = long_bits >> 3;
static const int three_fourths = long_bits * 3 / 4;
- static const Integer64 high_bits = ((Integer64)(~0L)) << (long_bits - one_eighth);
- Integer64 result = 0;
- Integer64 temp;
+ static const S64 high_bits = ((S64)(~0L)) << (long_bits - one_eighth);
+ S64 result = 0;
+ S64 temp;
while(*p != 0) {
result = (result << one_eighth) + *p ++;
}
/**
- * Obtiene el valor original de una cadena obtenido con #asHexString (const DataBlock&).
- * \param hexString Cadena que contiene el búfer.
- * \param target Bloque de datos sobre el que decodificar la cadena.
- * \return El bloque de datos original correspondiente a la cadena recibida.
+ * Gets the original value obtained with #asHexString (const DataBlock&).
+ * \param hexString String which contains the buffer. The format is an hexadecimal octet sequence representation (i.e. 'af012fb3', with even number of digits).
+ * The input shall be preprocessed to comply with that format (e.g. colon or any other non-hex digit must be removed).
+ * \param target DataBlock for string decode.
+ * \return DataBlock corresponding to the provided string.
*/
//static
DataBlock& functions::fromHexString(const std::string& hexString, DataBlock& target)
throw(RuntimeException) {
+
if((hexString.length() % 2) != 0)
throw RuntimeException("functions::fromHexString | Invalid string length", ANNA_FILE_LOCATION);
const char* src = hexString.data();
unsigned char hex;
int aux;
- int j = 0;
- for(register int ii = 1, maxii = hexString.length(); ii < maxii; ii += 2) {
+ for(int ii = 1, maxii = hexString.length(); ii < maxii; ii += 2) {
if(isxdigit(aux = src [ii - 1]) == 0)
throw RuntimeException("Invalid HexString", ANNA_FILE_LOCATION);
throw RuntimeException(msg, ANNA_FILE_LOCATION);
}
-Integer64 functions::asInteger64(const char* str)
+S64 functions::asInteger64(const char* str)
throw() {
- Integer64 number = 0;
- sscanf(str, "%lld", &number);
- /*
+ S64 number = 0;
+ //sscanf(str, "%lld", &number);
#ifdef __anna64__
sscanf (str, "%ld", &number);
#else
sscanf (str, "%lld", &number);
#endif
- */
return number;
}
}
/*static*/
-Integer64 functions::merge(const char* whatis, const int n1, const int n2, const int bitShift)
+S64 functions::merge(const char* whatis, const int n1, const int n2, const int bitShift)
throw(RuntimeException) {
if(bitShift > intBitSize) {
string msg(functions::asString("%s | N1: 0x%x | N2: 0x%x | bitShift: %d | bitShift must be less than %d", whatis, n1, n2, bitShift, intBitSize));
throw RuntimeException(msg, ANNA_FILE_LOCATION);
}
- Integer64 result = n1;
+ S64 result = n1;
result <<= bitShift;
result |= n2;
*/
int functions::log2(const unsigned int v)
throw() {
- static const char LogTable256[] = {
+ static const signed char LogTable256[] = {
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
};
int r = -1; // r will be lg(v)
- register unsigned int t, tt; // temporaries
+ unsigned int t, tt; // temporaries
- if(tt = v >> 16) {
- r = (t = tt >> 8) ? 24 + LogTable256[t] : 16 + LogTable256[tt];
+ if((tt = v >> 16)) {
+ r = ((t = tt >> 8)) ? 24 + LogTable256[t] : 16 + LogTable256[tt];
} else {
r = (t = v >> 8) ? 8 + LogTable256[t] : LogTable256[v];
}
}
if((mode == TextJustifyMode::Right) || (mode == TextJustifyMode::Center)) {
- for(register int k = 0; k < (repeat + (adjust ? 1 : 0)); k++) result += filler;
+ for(int k = 0; k < (repeat + (adjust ? 1 : 0)); k++) result += filler;
result += " ";
}
if((mode == TextJustifyMode::Left) || (mode == TextJustifyMode::Center)) {
result += " ";
- for(register int k = 0; k < repeat; k++) result += filler;
+ for(int k = 0; k < repeat; k++) result += filler;
}
return result;
}
if((mode == TextHighlightMode::Leftline) || (mode == TextHighlightMode::LeftAndRightline)) {
- for(register int k = 0; k < (lr_repeat + (adjust ? 1 : 0)); k++) result += filler;
+ for(int k = 0; k < (lr_repeat + (adjust ? 1 : 0)); k++) result += filler;
result += " ";
}
if((mode == TextHighlightMode::Overline) || (mode == TextHighlightMode::OverAndUnderline)) {
- for(register int k = 0; k < ou_repeat; k++) result += filler;
+ for(int k = 0; k < ou_repeat; k++) result += filler;
result += "\n";
}
if((mode == TextHighlightMode::Underline) || (mode == TextHighlightMode::OverAndUnderline)) {
result += "\n";
- for(register int k = 0; k < ou_repeat; k++) result += filler;
+ for(int k = 0; k < ou_repeat; k++) result += filler;
}
if((mode == TextHighlightMode::Rightline) || (mode == TextHighlightMode::LeftAndRightline)) {
result += " ";
- for(register int k = 0; k < lr_repeat; k++) result += filler;
+ for(int k = 0; k < lr_repeat; k++) result += filler;
}
if(appendCR) result += "\n";
size_t pos, from = 0;
std::string tab, crTab = "\n";
- for(register int k = 0; k < tabSpaces; k++) tab += " ";
+ for(int k = 0; k < tabSpaces; k++) tab += " ";
crTab += tab;
result = tab;
return result;
}
- for(register int k = 0; k < size; k ++) {
+ for(int k = 0; k < size; k ++) {
unsigned char c = (unsigned char) buffer [k];
int printable = isprint(c);
result += (printable ? (char) c : '.');
std::string result = "";
struct hostent *he;
struct in_addr **addr_list;
- struct in_addr ipv4addr;
char hostname[128];
gethostname(hostname, sizeof hostname);
char rByte[3]; // readable byte
rByte[2] = 0;
- for(register int k = 0; k < length; k += 2) {
+ for(int k = 0; k < length; k += 2) {
rByte[0] = rawPresentation[k];
rByte[1] = rawPresentation[k + 1];
sscanf(rByte, "%x", &byte);
char rByte[3]; // readable byte
rByte[2] = 0;
- for(register int k = 0; k < length; k++) {
+ for(int k = 0; k < length; k++) {
byte = (unsigned char)db[k];
sprintf(rByte, "%.2X", byte);
result += rByte;
// La expresión regular no controla si hay mas de 3 puntos:
int n_dot = 0;
- for(register int k = 0; k < ip.length(); k++)
+ for(int k = 0; k < ip.length(); k++)
if(ip[k] == '.') n_dot++;
if(n_dot > 3)
bool functions::isIPv6(const std::string & ip) throw() {
// Chequeo de digitos permitidos:
- for(register int k = 0; k < ip.length(); k++) {
+ for(int k = 0; k < ip.length(); k++) {
bool digit = isdigit(ip[k]);
bool hex = ((ip[k] == 'a') ||
(ip[k] == 'b') ||
// Number of ocurrences for '.'
int n_dot = 0;
- for(register int k = 0; k < pureIPv4.length(); k++)
+ for(int k = 0; k < pureIPv4.length(); k++)
if(pureIPv4[k] == '.') n_dot++;
if(n_dot > 3)
// Number of ocurrences for ':'
int n_colon = 0;
- for(register int k = 0; k < result.length(); k++)
+ for(int k = 0; k < result.length(); k++)
if(result[k] == ':') n_colon++;
// Generate equivalent to '::'
std::string equiv_str;
- for(register int k = 0; k < (8 - n_colon); k++)
+ for(int k = 0; k < (8 - n_colon); k++)
equiv_str += ":0";
equiv_str += ":";
// Protection: it must be seven colons:
int n_colon = 0;
- for(register int k = 0; k < result.length(); k++)
+ for(int k = 0; k < result.length(); k++)
if(result[k] == ':') n_colon++;
if(n_colon != 7)
result.erase(lastPos, 1);
// Chequeo de digitos permitidos:
- for(register int k = 0; k < result.length(); k++) {
+ for(int k = 0; k < result.length(); k++) {
bool digit = isdigit(result[k]);
bool hex = ((result[k] == 'a') ||
(result[k] == 'b') ||
return result;
}
+bool functions::littleEndian()
+throw() {
+ int i = 1;
+ char *p = (char *) &i;
+ if (p[0] == 1) return true;
+ return false;
+}
+
+const char* functions::codeInteger(char* result, const int n)
+throw() {
+ int aux(htonl(n));
+ char* w((char*) &aux);
+ *result = *w;
+ *(result + 1) = *(w + 1);
+ *(result + 2) = *(w + 2);
+ *(result + 3) = *(w + 3);
+ return result;
+}
+
+const char* functions::codeShort(char* result, const short int n)
+throw() {
+ short int aux(htons(n));
+ char* w((char*) &aux);
+ *result = *w;
+ *(result + 1) = *(w + 1);
+ return result;
+}
+
+const char* functions::codeInteger64(char* result, const S64 n)
+throw() {
+ S64 aux(0xffffffff);
+ int n2;
+ aux <<= 32;
+ aux &= n;
+ n2 = (aux >> 32) & 0xffffffff;
+ codeInteger(result, n2);
+ n2 = n & 0xffffffff;
+ codeInteger(result + sizeof(int), n2);
+ return result;
+}
+
+/*static*/
+const char* functions::codeFloat(char* result, const float n)
+throw() {
+ int ii;
+ anna_memcpy(&ii, &n, sizeof(n));
+ return functions::codeInteger(result, ii);
+}
+
+/*static*/
+const char* functions::codeDouble(char* result, const double n)
+throw() {
+ S64 ii;
+ anna_memcpy(&ii, &n, sizeof(n));
+ return functions::codeInteger64(result, ii);
+}
+
+int functions::decodeInteger(const char* data)
+throw() {
+ int result;
+ char* w((char*) &result);
+ *w = *data;
+ *(w + 1) = *(data + 1);
+ *(w + 2) = *(data + 2);
+ *(w + 3) = *(data + 3);
+ return ntohl(result);
+}
+
+short int functions::decodeShort(const char* data)
+throw() {
+ short int result;
+ char* w((char*) &result);
+ *w = *data;
+ *(w + 1) = *(data + 1);
+ return ntohs(result);
+}
+
+S64 functions::decodeInteger64(const char* data)
+throw() {
+ S64 result(decodeInteger(data));
+ result <<= 32;
+ return result |= (decodeInteger(data + sizeof(int)) & 0xffffffff);
+}
+
+/*static*/
+float functions::decodeFloat(const char* data)
+throw() {
+ float result;
+ int ii = functions::decodeInteger(data);
+ anna_memcpy(&result, &ii, sizeof(result));
+ return result;
+}
+
+/*static*/
+double functions::decodeDouble(const char* data)
+throw() {
+ double result;
+ S64 ii = functions::decodeInteger64(data);
+ anna_memcpy(&result, &ii, sizeof(result));
+ return result;
+}
+
+
void functions::decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) throw(anna::RuntimeException) {
#define DECODE2BYTES_INDX_VALUETYPE(buffer,indx,value_type) ((((value_type)buffer[indx] << 8) & 0xFF00) + ((value_type)buffer[indx+1] & 0x00FF))
isupNumber.Digits = "";
int byte;
- for(register int k = 2; k < length; k ++) {
+ for(int k = 2; k < length; k ++) {
byte = (buffer [k] & 0x0f);
isupNumber.Digits += (byte >= 0 && byte <= 9) ? (byte + '0') : ((byte - 0xa) + 'a');
byte = (buffer [k] & 0xf0) >> 4;
bool filler = isupNumber.OddEven;
bool hasDigits = (isupNumber.Digits.size() > 0);
byte = filler ? 0x80 : 0x00;
- byte = byte |= isupNumber.NatureOfAddress;
+ byte |= isupNumber.NatureOfAddress;
target += byte;
if(calledOrCalling) {
byte = isupNumber.InternalNetworkNumber << 7;
- byte = byte |= (isupNumber.NumberingPlan << 4);
+ byte |= (isupNumber.NumberingPlan << 4);
} else {
byte = isupNumber.NumberIncomplete << 7;
- byte = byte |= (isupNumber.NumberingPlan << 4);
- byte = byte |= (isupNumber.AddressPresentationRestricted << 2);
- byte = byte |= isupNumber.Screening;
+ byte |= (isupNumber.NumberingPlan << 4);
+ byte |= (isupNumber.AddressPresentationRestricted << 2);
+ byte |= isupNumber.Screening;
}
target += byte;
//std::transform(dtlc.begin(), dtlc.end(), dtlc.begin(), std::tolower);
const char *digits = dtlc.c_str();
- for(register int k = 1; k < isupNumber.Digits.size(); k += 2) {
+ for(int k = 1; k < isupNumber.Digits.size(); k += 2) {
if(isxdigit(byte = digits [k - 1]) == 0)
throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'Digits' field contains invalid digits (non hexadecimal)", ANNA_FILE_LOCATION);
memcpy(buffer, target.c_str(), length);
}
+
+static inline bool is_base64(U8 c) {
+ return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+std::string functions::encodeBase64(const U8* buf, unsigned int bufLen) {
+ std::string ret;
+ int i = 0;
+ int j = 0;
+ U8 char_array_3[3];
+ U8 char_array_4[4];
+
+ while (bufLen--) {
+ char_array_3[i++] = *(buf++);
+ if (i == 3) {
+ char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+ char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+ char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+ char_array_4[3] = char_array_3[2] & 0x3f;
+
+ for(i = 0; (i <4) ; i++)
+ ret += base64_chars[char_array_4[i]];
+ i = 0;
+ }
+ }
+
+ if (i)
+ {
+ for(j = i; j < 3; j++)
+ char_array_3[j] = '\0';
+
+ char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+ char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+ char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+ char_array_4[3] = char_array_3[2] & 0x3f;
+
+ for (j = 0; (j < i + 1); j++)
+ ret += base64_chars[char_array_4[j]];
+
+ while((i++ < 3))
+ ret += '=';
+ }
+
+ return ret;
+}
+
+std::string functions::decodeBase64(const std::string & encodedString) {
+ int in_len = encodedString.size();
+ int i = 0;
+ int j = 0;
+ int in_ = 0;
+ U8 char_array_4[4], char_array_3[3];
+ std::string ret;
+
+ while (in_len-- && ( encodedString[in_] != '=') && is_base64(encodedString[in_])) {
+ char_array_4[i++] = encodedString[in_]; in_++;
+ if (i ==4) {
+ for (i = 0; i <4; i++)
+ char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+ char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+ char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+ char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+ for (i = 0; (i < 3); i++)
+ ret += char_array_3[i];
+ i = 0;
+ }
+ }
+
+ if (i) {
+ for (j = i; j <4; j++)
+ char_array_4[j] = 0;
+
+ for (j = 0; j <4; j++)
+ char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+ char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+ char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+ char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+ for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
+ }
+
+ return ret;
+}
+
+bool functions::getContentFromFile(const std::string &pathfile, std::string &content) throw(anna::RuntimeException) {
+
+ std::ifstream inFile(pathfile.c_str(), std::ifstream::in);
+ if(!inFile.good()) {
+ throw RuntimeException(anna::functions::asString("Unable to open file '%s'", pathfile.c_str()), ANNA_FILE_LOCATION);
+ }
+
+ std::stringstream strStream;
+ strStream << inFile.rdbuf(); //read the file
+ content = strStream.str(); // holds the content of the file
+ inFile.close();
+
+ return true;
+}
+
projects / anna.git / blobdiff