480 lines
13 KiB
C++
480 lines
13 KiB
C++
/*
|
|
* IBAN: PostgreSQL functions and datatype
|
|
* Copyright © 2016 Yorick de Wid <yorick17@outlook.com>
|
|
*
|
|
* 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 of the License, 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, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*
|
|
*********************************************************************/
|
|
|
|
extern "C"
|
|
{
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "utils/builtins.h"
|
|
#include "libpq/pqformat.h"
|
|
|
|
}
|
|
|
|
#include <regex>
|
|
|
|
class Specification {
|
|
public:
|
|
Specification(std::string structure, size_t length)
|
|
: structure{ structure }
|
|
, m_length{ length }
|
|
{
|
|
};
|
|
|
|
inline size_t getLength() const noexcept
|
|
{
|
|
return m_length;
|
|
}
|
|
|
|
std::string structure;
|
|
|
|
private:
|
|
size_t m_length;
|
|
};
|
|
|
|
class Validate {
|
|
public:
|
|
Validate();
|
|
|
|
bool isValid(std::string arg);
|
|
|
|
void addSpecification(std::string countryCode, size_t length, std::string structure) noexcept
|
|
{
|
|
specifications.emplace(countryCode, std::make_unique<Specification>(structure, length));
|
|
}
|
|
|
|
std::map<std::string, std::unique_ptr<Specification>> specifications;
|
|
};
|
|
|
|
/* Validator global instance. */
|
|
static Validate validator;
|
|
|
|
/**
|
|
* Calculates the MOD 97 10 of the passed IBAN as specified in ISO7064.
|
|
*
|
|
* @param string iban
|
|
* @returns {bool}
|
|
*/
|
|
static bool iso7064Mod97_10(std::string iban) {
|
|
std::rotate(iban.begin(), iban.begin() + 4, iban.end());
|
|
|
|
/* Will contain the letter substitutions */
|
|
std::string numberstring;
|
|
numberstring.reserve(iban.size());
|
|
|
|
for (const auto& c : iban) {
|
|
if (std::isdigit(c)) {
|
|
numberstring += c;
|
|
}
|
|
if (std::isupper(c)) {
|
|
numberstring += std::to_string(static_cast<int>(c) - 55);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Implements a stepwise check for mod 97 in chunks of 9 at the first time
|
|
* then in chunks of seven prepended by the last mod 97 operation converted
|
|
* to a string
|
|
*/
|
|
size_t segstart = 0;
|
|
int step = 9;
|
|
std::string prepended;
|
|
long number = 0;
|
|
while (segstart < numberstring.length() - step) {
|
|
number = std::stol(prepended + numberstring.substr(segstart, step));
|
|
int remainder = number % 97;
|
|
prepended = std::to_string(remainder);
|
|
if (remainder < 10) {
|
|
prepended = "0" + prepended;
|
|
}
|
|
segstart = segstart + step;
|
|
step = 7;
|
|
}
|
|
|
|
number = std::stol(prepended + numberstring.substr(segstart));
|
|
return number % 97 == 1;
|
|
}
|
|
|
|
/**
|
|
* Parse the IBAN structure used to configure each iban specification and returns a matching regular expression.
|
|
* a structure is composed of blocks of 3 characters (one letter and 2 digits). each block represents
|
|
* a logical group in the typical representation of the bban. for each group, the letter indicates which characters
|
|
* are allowed in this group and the following 2-digits number tells the length of the group.
|
|
*
|
|
* @param {string} structure the structure to parse
|
|
* @returns {regexp}
|
|
*/
|
|
static std::regex parseStructure(std::string structure) {
|
|
std::smatch match;
|
|
|
|
std::string::const_iterator text_iter = structure.cbegin();
|
|
std::ostringstream result;
|
|
|
|
while (std::regex_search(text_iter, structure.cend(), match, std::regex("(.{3})"))) {
|
|
std::string format;
|
|
char pattern = match[0].str()[0];
|
|
int repeats = std::stoi((match[0].str().substr(1)));
|
|
|
|
/* Parse each structure block (1-char + 2-digits) */
|
|
switch (pattern) {
|
|
case 'A': format = "0-9A-ZA-Z"; break;
|
|
case 'B': format = "0-9A-Z"; break;
|
|
case 'C': format = "A-ZA-Z"; break;
|
|
case 'F': format = "0-9"; break;
|
|
case 'L': format = "A-Z"; break;
|
|
case 'U': format = "A-Z"; break;
|
|
case 'W': format = "0-9A-Z"; break;
|
|
}
|
|
|
|
result << "([" << format << "]{" << repeats << "})";
|
|
|
|
text_iter = match[0].second;
|
|
}
|
|
|
|
std::string regex = "^" + result.str() + "$";
|
|
return std::regex(regex.c_str());
|
|
}
|
|
|
|
bool Validate::isValid(std::string account) {
|
|
/* Convert uppercase */
|
|
std::transform(account.begin(), account.end(), account.begin(), toupper);
|
|
|
|
/* Reject anything too small */
|
|
if (account.length() < 3) {
|
|
return false;
|
|
}
|
|
|
|
/* Match on country */
|
|
const std::string& countryCode = account.substr(0, 2);
|
|
const std::string& shortened = account.substr(4);
|
|
|
|
const std::unique_ptr<Specification>& specFound = specifications[countryCode];
|
|
if (!specFound) {
|
|
return false;
|
|
}
|
|
|
|
/* Test accountnumber */
|
|
return specFound->getLength() == account.length()
|
|
&& std::regex_match(shortened, parseStructure(specFound->structure))
|
|
&& iso7064Mod97_10(account);
|
|
}
|
|
|
|
Validate::Validate() {
|
|
addSpecification(
|
|
"AD", 24, "F04F04A12");
|
|
addSpecification(
|
|
"AE", 23, "F03F16");
|
|
addSpecification(
|
|
"AL", 28, "F08A16");
|
|
addSpecification(
|
|
"AT", 20, "F05F11");
|
|
addSpecification(
|
|
"AZ", 28, "U04A20");
|
|
addSpecification(
|
|
"BA", 20, "F03F03F08F02");
|
|
addSpecification(
|
|
"BE", 16, "F03F07F02");
|
|
addSpecification(
|
|
"BG", 22, "U04F04F02A08");
|
|
addSpecification(
|
|
"BH", 22, "U04A14");
|
|
addSpecification(
|
|
"BR", 29, "F08F05F10U01A01");
|
|
addSpecification(
|
|
"CH", 21, "F05A12");
|
|
addSpecification(
|
|
"CR", 21, "F03F14");
|
|
addSpecification(
|
|
"CY", 28, "F03F05A16");
|
|
addSpecification(
|
|
"CZ", 24, "F04F06F10");
|
|
addSpecification(
|
|
"DE", 22, "F08F10");
|
|
addSpecification(
|
|
"DK", 18, "F04F09F01");
|
|
addSpecification(
|
|
"DO", 28, "U04F20");
|
|
addSpecification(
|
|
"EE", 20, "F02F02F11F01");
|
|
addSpecification(
|
|
"ES", 24, "F04F04F01F01F10");
|
|
addSpecification(
|
|
"FI", 18, "F06F07F01");
|
|
addSpecification(
|
|
"FO", 18, "F04F09F01");
|
|
addSpecification(
|
|
"FR", 27, "F05F05A11F02");
|
|
addSpecification(
|
|
"GB", 22, "U04F06F08");
|
|
addSpecification(
|
|
"GE", 22, "U02F16");
|
|
addSpecification(
|
|
"GI", 23, "U04A15");
|
|
addSpecification(
|
|
"GL", 18, "F04F09F01");
|
|
addSpecification(
|
|
"GR", 27, "F03F04A16");
|
|
addSpecification(
|
|
"GT", 28, "A04A20");
|
|
addSpecification(
|
|
"HR", 21, "F07F10");
|
|
addSpecification(
|
|
"HU", 28, "F03F04F01F15F01");
|
|
addSpecification(
|
|
"IE", 22, "U04F06F08");
|
|
addSpecification(
|
|
"IL", 23, "F03F03F13");
|
|
addSpecification(
|
|
"IS", 26, "F04F02F06F10");
|
|
addSpecification(
|
|
"IT", 27, "U01F05F05A12");
|
|
addSpecification(
|
|
"KW", 30, "U04A22");
|
|
addSpecification(
|
|
"KZ", 20, "F03A13");
|
|
addSpecification(
|
|
"LB", 28, "F04A20");
|
|
addSpecification(
|
|
"LC", 32, "U04F24");
|
|
addSpecification(
|
|
"LI", 21, "F05A12");
|
|
addSpecification(
|
|
"LT", 20, "F05F11");
|
|
addSpecification(
|
|
"LU", 20, "F03A13");
|
|
addSpecification(
|
|
"LV", 21, "U04A13");
|
|
addSpecification(
|
|
"MC", 27, "F05F05A11F02");
|
|
addSpecification(
|
|
"MD", 24, "U02A18");
|
|
addSpecification(
|
|
"ME", 22, "F03F13F02");
|
|
addSpecification(
|
|
"MK", 19, "F03A10F02");
|
|
addSpecification(
|
|
"MR", 27, "F05F05F11F02");
|
|
addSpecification(
|
|
"MT", 31, "U04F05A18");
|
|
addSpecification(
|
|
"MU", 30, "U04F02F02F12F03U03");
|
|
addSpecification(
|
|
"NL", 18, "U04F10");
|
|
addSpecification(
|
|
"NO", 15, "F04F06F01");
|
|
addSpecification(
|
|
"PK", 24, "U04A16");
|
|
addSpecification(
|
|
"PL", 28, "F08F16");
|
|
addSpecification(
|
|
"PS", 29, "U04A21");
|
|
addSpecification(
|
|
"PT", 25, "F04F04F11F02");
|
|
addSpecification(
|
|
"RO", 24, "U04A16");
|
|
addSpecification(
|
|
"RS", 22, "F03F13F02");
|
|
addSpecification(
|
|
"SA", 24, "F02A18");
|
|
addSpecification(
|
|
"SE", 24, "F03F16F01");
|
|
addSpecification(
|
|
"SI", 19, "F05F08F02");
|
|
addSpecification(
|
|
"SK", 24, "F04F06F10");
|
|
addSpecification(
|
|
"SM", 27, "U01F05F05A12");
|
|
addSpecification(
|
|
"ST", 25, "F08F11F02");
|
|
addSpecification(
|
|
"TL", 23, "F03F14F02");
|
|
addSpecification(
|
|
"TN", 24, "F02F03F13F02");
|
|
addSpecification(
|
|
"TR", 26, "F05F01A16");
|
|
addSpecification(
|
|
"VG", 24, "U04F16");
|
|
addSpecification(
|
|
"XK", 20, "F04F10F02");
|
|
addSpecification(
|
|
"AO", 25, "F21");
|
|
addSpecification(
|
|
"BF", 27, "F23");
|
|
addSpecification(
|
|
"BI", 16, "F12");
|
|
addSpecification(
|
|
"BJ", 28, "F24");
|
|
addSpecification(
|
|
"CI", 28, "U01F23");
|
|
addSpecification(
|
|
"CM", 27, "F23");
|
|
addSpecification(
|
|
"CV", 25, "F21");
|
|
addSpecification(
|
|
"DZ", 24, "F20");
|
|
addSpecification(
|
|
"IR", 26, "F22");
|
|
addSpecification(
|
|
"JO", 30, "A04F22");
|
|
addSpecification(
|
|
"MG", 27, "F23");
|
|
addSpecification(
|
|
"ML", 28, "U01F23");
|
|
addSpecification(
|
|
"MZ", 25, "F21");
|
|
addSpecification(
|
|
"QA", 29, "U04A21");
|
|
addSpecification(
|
|
"SN", 28, "U01F23");
|
|
addSpecification(
|
|
"UA", 29, "F25");
|
|
addSpecification(
|
|
"EG", 27, "F23");
|
|
addSpecification(
|
|
"CG", 27, "F23");
|
|
addSpecification(
|
|
"GA", 27, "F23");
|
|
}
|
|
|
|
/**
|
|
* Separate CXX and C logic to minimize unexpected or malformed symbols due to
|
|
* language conversions. Also demark all exceptions the std++ can throw since
|
|
* PostgreSQL is not able to handle them.
|
|
*
|
|
* @param {string} iban
|
|
* @returns {bool}
|
|
*/
|
|
namespace {
|
|
|
|
bool account_validate_text(text *iban) {
|
|
char *ciban;
|
|
bool result;
|
|
|
|
ciban = text_to_cstring(iban);
|
|
|
|
try {
|
|
result = validator.isValid(ciban);
|
|
} catch (std::exception& e) {
|
|
elog(ERROR, "%s", e.what());
|
|
return false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool account_validate_str(char *iban) {
|
|
bool result;
|
|
|
|
try {
|
|
result = validator.isValid(iban);
|
|
} catch (std::exception& e) {
|
|
elog(ERROR, "%s", e.what());
|
|
return false;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
extern "C"
|
|
{
|
|
|
|
PG_MODULE_MAGIC;
|
|
|
|
typedef char Iban;
|
|
|
|
/**************************************************************************
|
|
* Input/Output functions
|
|
**************************************************************************/
|
|
|
|
PG_FUNCTION_INFO_V1(ibanin);
|
|
|
|
Datum
|
|
ibanin(PG_FUNCTION_ARGS) {
|
|
char *inputText = PG_GETARG_CSTRING(0);
|
|
|
|
if (!account_validate_str(inputText))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
|
|
errmsg("invalid iban format for value: \"%s\"",
|
|
inputText)));
|
|
|
|
PG_RETURN_TEXT_P(cstring_to_text(inputText));
|
|
}
|
|
|
|
/* Convert type output */
|
|
|
|
PG_FUNCTION_INFO_V1(ibanout);
|
|
|
|
Datum
|
|
ibanout(PG_FUNCTION_ARGS) {
|
|
Iban *iban = (Iban *) PG_GETARG_DATUM(0);
|
|
|
|
PG_RETURN_CSTRING(TextDatumGetCString(iban));
|
|
}
|
|
|
|
/**************************************************************************
|
|
* Binary Input/Output functions
|
|
**************************************************************************/
|
|
|
|
PG_FUNCTION_INFO_V1(ibanrecv);
|
|
|
|
Datum
|
|
ibanrecv(PG_FUNCTION_ARGS) {
|
|
StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
|
|
text *result;
|
|
Iban *str;
|
|
int nbytes;
|
|
|
|
str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
|
|
|
|
result = cstring_to_text_with_len(str, nbytes);
|
|
pfree(str);
|
|
PG_RETURN_TEXT_P(result);
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(ibansend);
|
|
|
|
Datum
|
|
ibansend(PG_FUNCTION_ARGS) {
|
|
text *t = PG_GETARG_TEXT_PP(0);
|
|
StringInfoData buf;
|
|
|
|
pq_begintypsend(&buf);
|
|
pq_sendtext(&buf, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
|
|
PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
|
|
}
|
|
|
|
/* Manually verify a text */
|
|
|
|
PG_FUNCTION_INFO_V1(iban_validate);
|
|
|
|
Datum
|
|
iban_validate(PG_FUNCTION_ARGS) {
|
|
text *iban = PG_GETARG_TEXT_P(0);
|
|
|
|
bool result = account_validate_text(iban);
|
|
|
|
PG_RETURN_BOOL(result);
|
|
}
|
|
|
|
} // extern "C"
|