void USOAPFault::encode(UString& response)
{
U_TRACE(0, "USOAPFault::encode(%.*S)", U_STRING_TO_TRACE(response))
UString code = getFaultCode();
response.setBuffer(1000U + code.size() + faultReason.size() + detail.size());
response.snprintf("<?xml version='1.0' ?>"
"<soap:Envelope xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\">"
"<soap:Body>"
"<soap:Fault>"
"<soap:Code>"
"<soap:Value>soap:%.*s</soap:Value>"
"</soap:Code>"
"<soap:Reason>"
"<soap:Text xml:lang=\"en-US\">%.*s</soap:Text>"
"</soap:Reason>"
"<soap:Detail>%.*s</soap:Detail>"
"</soap:Fault>"
"</soap:Body>"
"</soap:Envelope>",
U_STRING_TO_TRACE(code),
U_STRING_TO_TRACE(faultReason),
U_STRING_TO_TRACE(detail));
}
void OtpAuthToken::add(const UString& name_, const UString& value_)
{
U_TRACE(5, "OtpAuthToken::add(%.*S,%.*S)", U_STRING_TO_TRACE(name_), U_STRING_TO_TRACE(value_))
hp.push_back(name_);
hp.push_back(value_);
}
static int print(UStringRep* key, UStringRep* data)
{
U_TRACE(5, "::print(%.*S,%.*S)", U_STRING_TO_TRACE(*key), U_STRING_TO_TRACE(*data))
cout << UString(key) << "->" << UString(data) << endl;
return 1;
}
UString USOAPParser::processMessage(const UString& msg, URPCObject& object, bool& bContainsFault)
{
U_TRACE(0, "USOAPParser::processMessage(%.*S,%p,%p,%b)", U_STRING_TO_TRACE(msg), &object, &bContainsFault)
U_INTERNAL_ASSERT(msg)
UString retval;
clearData();
if (U_STRING_FIND(msg, 0, "http://schemas.xmlsoap.org/soap/envelope/") != U_NOT_FOUND)
{
zero();
bContainsFault = true;
(void) retval.assign(U_CONSTANT_TO_PARAM("<?xml version=\"1.0\" ?>"
"<env:Envelope xmlns:env=\"http://schemas.xmlsoap.org/soap/envelope/\">"
"<env:Header>"
"<env:Upgrade>"
"<env:SupportedEnvelope qname=\"ns1:Envelope\" xmlns:ns1=\"http://www.w3.org/2003/05/soap-envelope\"/>"
"</env:Upgrade>"
"</env:Header>"
"<env:Body>"
"<env:Fault>"
"<faultcode>env:VersionMismatch</faultcode>"
"<faultstring>Version Mismatch</faultstring>"
"</env:Fault>"
"</env:Body>"
"</env:Envelope>"));
}
else if (parse(msg))
{
U_ASSERT(envelope.methodName != *UString::str_fault)
retval = object.processMessage(envelope, bContainsFault);
}
else
{
int line = ::XML_GetCurrentLineNumber(m_parser),
coln = ::XML_GetCurrentColumnNumber(m_parser);
object.setFailed();
URPCMethod::pFault->getFaultReason() = UXMLParser::getErrorMessage();
U_INTERNAL_DUMP("UXMLParser: %.*S (%d,%d) ", U_STRING_TO_TRACE(URPCMethod::pFault->getFaultReason()), line, coln)
URPCMethod::pFault->setDetail("The fault occurred near position (line: %d col: %d) within the message", line, coln);
bContainsFault = true;
retval = URPCMethod::encoder->encodeFault(URPCMethod::pFault);
}
U_RETURN_STRING(retval);
}
HttpOtpPostLogin::HttpOtpPostLogin(const char* buf, unsigned len, const UString& user_field,
const UString& pin_field, const UString& token_field, const UString& passwd_field,
const UString& cf_field, HttpHeader& header)
{
U_TRACE(5, "HttpOtpPostLogin::HttpOtpPostLogin(%.*S,%u,%.*S,%.*S,%.*S,%.*S,%p)", len, buf, len,
U_STRING_TO_TRACE(user_field), U_STRING_TO_TRACE(pin_field), U_STRING_TO_TRACE(token_field),
U_STRING_TO_TRACE(passwd_field), U_STRING_TO_TRACE(cf_field), &header)
HttpField* f = header.find(U_STRING_FROM_CONSTANT("Content-Type"));
U_INTERNAL_ASSERT_POINTER(f)
U_INTERNAL_ASSERT(f->value.find("application/x-www-form-urlencoded") != unsigned(-1))
buffer.assign(buf, len);
(void) U_VEC_SPLIT(vec, buffer, "=&"); // "user=stefano+casazza&pin=12345&token=autorizzativo"
unsigned i = 0;
while (i < vec.size())
{
if (vec[i] == user_field)
{
U_STR_RESERVE(user, 64);
Url::decode(vec[i+1], user);
}
else if (vec[i] == pin_field)
{
U_STR_RESERVE(pin, 64);
Url::decode(vec[i+1], pin);
}
else if (vec[i] == token_field)
{
U_STR_RESERVE(token, 64);
Url::decode(vec[i+1], token);
}
else if (vec[i] == passwd_field)
{
U_STR_RESERVE(passwd, 64);
Url::decode(vec[i+1], passwd);
}
else if (vec[i] == cf_field)
{
U_STR_RESERVE(cf, 64);
Url::decode(vec[i+1], cf);
}
i += 2;
}
}
void HttpLocation::stringify(UString& field)
{
U_TRACE(5, "HttpLocation::stringify(%.*S)", U_STRING_TO_TRACE(field))
field += name;
field.append(U_CONSTANT_TO_PARAM(": "));
field += url;
field.append(U_CONSTANT_TO_PARAM("\r\n"));
U_INTERNAL_DUMP("field = %.*S", U_STRING_TO_TRACE(field))
}
static bool reportEntry(const UString& elem)
{
U_TRACE(5, "Application::reportEntry(%.*S)", U_STRING_TO_TRACE(elem))
UString tmp(U_CAPACITY);
UXMLEscape::encode(elem, tmp);
(void) sprintf(buffer, form, U_STRING_TO_TRACE(tmp));
std::cout << buffer;
U_RETURN(false);
}
void HttpRequestHeader::stringify(UString& field)
{
U_TRACE(5, "HttpRequestHeader::stringify(%.*S)", U_STRING_TO_TRACE(field))
field += method;
field.append(U_CONSTANT_TO_PARAM(" "));
field += url;
field.append(U_CONSTANT_TO_PARAM(" "));
field += httpver;
field.append(U_CONSTANT_TO_PARAM("\r\n"));
HttpHeader::stringify(field);
U_INTERNAL_DUMP("field = %.*S", U_STRING_TO_TRACE(field))
}
void HttpResponseHeader::stringify(UString& field)
{
U_TRACE(5, "HttpResponseHeader::stringify(%.*S)", U_STRING_TO_TRACE(field))
field += httpver;
field.append(U_CONSTANT_TO_PARAM(" "));
field += status;
field.append(U_CONSTANT_TO_PARAM(" "));
field += reason;
field.append(U_CONSTANT_TO_PARAM("\r\n"));
HttpHeader::stringify(field);
U_INTERNAL_DUMP("field = %.*S", U_STRING_TO_TRACE(field))
}
void run(int argc, char* argv[], char* env[])
{
U_TRACE(5, "Application::run(%d,%p,%p)", argc, argv, env)
Action::run(argc, argv, env);
// read stdin and scanf
Action::processInputData(5);
// --------------------------------------------------------------------------------------------------------------
// configuration parameters
// --------------------------------------------------------------------------------------------------------------
// ARCHIVE_TEMPLATE printf form to output request of archive
// ELECTRONIC_ARCHIVATION_SERVICE_URL url to do request of archive
// --------------------------------------------------------------------------------------------------------------
UString arch_tmpl = UFile::contentOf(cfg[U_STRING_FROM_CONSTANT("ARCHIVE_TEMPLATE")]),
url = cfg[U_STRING_FROM_CONSTANT("ELECTRONIC_ARCHIVATION_SERVICE_URL")];
UString body(arch_tmpl.size() + request_decoded.size() + (u__strlen(uid, __PRETTY_FUNCTION__) * 3) + 100U);
body.snprintf(arch_tmpl.data(), uid, uid, uid, U_STRING_TO_TRACE(request_decoded));
bool ok = Action::sendHttpPostRequest(url, body, "multipart/form-data; boundary=4MYWPDUi9kH5-ipE_f6CiZXFFn4SaQQOj", "OK") && Action::sendEmail();
Action::writeToSTDOUT(ok, true);
}
bool USOAPParser::parse(const UString& msg)
{
U_TRACE(0, "USOAPParser::parse(%.*S)", U_STRING_TO_TRACE(msg))
initParser();
if (UXMLParser::parse(msg))
{
// If we succeeded, get the name of the method being called. This of course assumes only
// one method in the body, and that there are no objects outside of the serialization root.
// This method will need an override if this assumption is invalid
U_INTERNAL_ASSERT_POINTER(body)
method = body->childAt(0);
envelope.methodName = method->elem()->getAccessorName();
// load the parameters for the method to execute
UString param;
for (uint32_t i = 0, num_arguments = method->numChild(); i < num_arguments; ++i)
{
param = method->childAt(i)->elem()->getValue();
// check if parameter optional
if (param) envelope.arg->push_back(param);
}
U_RETURN(true);
}
U_RETURN(false);
}
static void buildFilenameListFrom(UVector<UString>& vec, const UString& arg)
{
U_TRACE(5, "Application::buildFilenameListFrom(%p,%.*S)", &vec, U_STRING_TO_TRACE(arg))
uint32_t pos;
UTokenizer t(arg);
UString dir, filename, filter;
while (t.next(filename, ','))
{
if (filename.find_first_of("?*", 0, 2) == U_NOT_FOUND) vec.push(filename);
else
{
pos = filename.find_last_of('/');
U_INTERNAL_DUMP("pos = %u", pos)
if (pos == U_NOT_FOUND)
{
UDirWalk dirwalk(0, U_STRING_TO_PARAM(filename));
(void) dirwalk.walk(vec);
}
else
{
dir = filename.substr(0U, pos);
filter = filename.substr(pos + 1);
UDirWalk dirwalk(dir, U_STRING_TO_PARAM(filter));
(void) dirwalk.walk(vec);
}
}
}
}
X509_REQ* UPKCS10::readPKCS10(const UString& x, const char* format)
{
U_TRACE(1, "UPKCS10::readPKCS10(%.*S,%S)", U_STRING_TO_TRACE(x), format)
BIO* in;
UString tmp = x;
X509_REQ* _request = 0;
if (format == 0) format = (x.isBinary() ? "DER" : "PEM");
if (U_STREQ(format, "PEM") &&
U_STRNCMP(x.data(), "-----BEGIN CERTIFICATE REQUEST-----"))
{
unsigned length = x.size();
UString buffer(length);
if (UBase64::decode(x.data(), length, buffer) == false) goto next;
tmp = buffer;
format = "DER";
}
next:
in = (BIO*) U_SYSCALL(BIO_new_mem_buf, "%p,%d", U_STRING_TO_PARAM(tmp));
_request = (X509_REQ*) (U_STREQ(format, "PEM") ? U_SYSCALL(PEM_read_bio_X509_REQ, "%p,%p,%p,%p", in, 0, 0, 0)
: U_SYSCALL(d2i_X509_REQ_bio, "%p,%p", in, 0));
(void) U_SYSCALL(BIO_free, "%p", in);
U_RETURN_POINTER(_request, X509_REQ);
}
bool UDirWalk::setDirectory(const UString& dir, const char* _filter, uint32_t _filter_len)
{
U_TRACE(0, "UDirWalk::setDirectory(%.*S,%.*S,%u)", U_STRING_TO_TRACE(dir), _filter_len, _filter, _filter_len)
pthis->pathlen = dir.size();
const char* pdir = u_getPathRelativ(dir.data(), &(pthis->pathlen));
U_INTERNAL_ASSERT_MAJOR(pthis->pathlen, 0)
U_MEMCPY(pthis->pathname, pdir, pthis->pathlen);
pthis->pathname[pthis->pathlen] = '\0';
if (UFile::access(pthis->pathname) == false)
{
pthis->pathlen = 0;
U_RETURN(false);
}
setFilter(_filter, _filter_len);
U_RETURN(true);
}
UXMLAttribute* UXMLElement::getAttribute(const UString& attributeName)
{
U_TRACE(0, "UXMLElement::getAttribute(%.*S)", U_STRING_TO_TRACE(attributeName))
uint32_t n = numAttributes();
if (n)
{
UXMLAttribute* entry;
UString szAccessor, szNamespace;
splitNamespaceAndName(attributeName, szNamespace, szAccessor);
for (uint32_t i = 0; i < n; ++i)
{
entry = attributeAt(i);
if ((entry->getAccessor() == attributeName) &&
(szNamespace.empty() || (entry->getNamespaceName() == szNamespace)))
{
// We found the attribute
U_RETURN_POINTER(entry, UXMLAttribute);
}
}
}
U_RETURN_POINTER(0, UXMLAttribute);
}
bool UTranformInclC14N::execute(UString& data)
{
U_TRACE(0, "UTranformInclC14N::execute(%.*S)", U_STRING_TO_TRACE(data))
data = UXML2Document::xmlC14N(data);
U_RETURN(true);
}
void UHexDump::encode(const unsigned char* s, uint32_t n, UString& buffer)
{
U_TRACE(0, "UHexDump::encode(%.*S,%u,%.*S)", n, s, n, U_STRING_TO_TRACE(buffer))
uint32_t pos = u_hexdump_encode(s, n, (unsigned char*)buffer.data());
buffer.size_adjust(pos);
}
void UTokenizer::setData(const UString& data)
{
U_TRACE(0, "UTokenizer::setData(%.*S)", U_STRING_TO_TRACE(data))
str = data;
s = data.data();
end = s + data.size();
}
UFileConfig::UFileConfig(const UString& _data, bool _preprocessing) : data(_data)
{
U_TRACE_REGISTER_OBJECT(0, UFileConfig, "%.*S,%b", U_STRING_TO_TRACE(_data), _preprocessing)
init();
preprocessing = _preprocessing;
}
void Url::set(const UString& x)
{
U_TRACE(0, "Url::set(%.*S)", U_STRING_TO_TRACE(x))
url = x;
findpos();
}
UXml2Txt::UXml2Txt(const UString& tag_list, bool _tag_to_exclude, bool _tag_output_also) : taglist(tag_list, "<>, ")
{
U_TRACE_REGISTER_OBJECT(0, UXml2Txt, "%.*S,%b,%b", U_STRING_TO_TRACE(tag_list), _tag_to_exclude, _tag_output_also)
tag_to_exclude = (taglist.empty() == false ? _tag_to_exclude : false);
tag_output_also = _tag_output_also;
UXMLParser::initParser(false, 0);
}
static void check(const UString& data)
{
U_TRACE(5,"check(%.*S)",U_STRING_TO_TRACE(data))
UXMLParser parser;
parser.initParser();
if (parser.parse(data)) cout << "Parser\n";
}
UMimeEntity::UMimeEntity(const UString& _data) : data(_data)
{
U_TRACE_REGISTER_OBJECT(0, UMimeEntity, "%.*S", U_STRING_TO_TRACE(_data))
header = U_NEW(UMimeHeader);
startHeader = 0;
parse_result = false;
if (parse()) decodeBody();
}
void UHexDump::decode(const char* s, uint32_t n, UString& buffer)
{
U_TRACE(0, "UHexDump::decode(%.*S,%u,%.*S)", n, s, n, U_STRING_TO_TRACE(buffer))
U_ASSERT(buffer.capacity() >= n)
uint32_t pos = u_hexdump_decode(s, n, (unsigned char*)buffer.data());
buffer.size_adjust(pos);
}
bool UBase64::decodeAll(const char* s, uint32_t n, UString& buffer)
{
U_TRACE(0, "UBase64::decodeAll(%.*S,%u,%.*S)", n, s, n, U_STRING_TO_TRACE(buffer))
uint32_t pos = u_base64all_decode(s, n, (unsigned char*)buffer.data());
buffer.size_adjust(pos);
U_INTERNAL_DUMP("u_base64_errors = %u buffer(%u) = %#.*S", u_base64_errors, buffer.size(), U_STRING_TO_TRACE(buffer))
if (pos > 0 &&
u_base64_errors == 0)
{
U_RETURN(true);
}
U_INTERNAL_DUMP("buffer(%u) = %#.*S", buffer.size(), U_STRING_TO_TRACE(buffer))
U_RETURN(false);
}
UZIP::UZIP(const UString& _content) : content(_content), tmpdir(U_CAPACITY)
{
U_TRACE_REGISTER_OBJECT(0, UZIP, "%.*S", U_STRING_TO_TRACE(_content))
npart = 0;
file = 0;
valid = U_STRNEQ(_content.data(), U_ZIP_ARCHIVE);
filenames = filecontents = 0;
zippartname = zippartcontent = 0;
filenames_len = filecontents_len = 0;
}
void UEscape::encode(const unsigned char* s, uint32_t n, UString& buffer, bool json)
{
U_TRACE(0, "UEscape::encode(%.*S,%u,%.*S,%b)", n, s, n, U_STRING_TO_TRACE(buffer), json)
U_ASSERT(buffer.capacity() >= n)
uint32_t sz = buffer.size(),
pos = u_escape_encode(s, n, buffer.c_pointer(sz), buffer.space(), json);
buffer.size_adjust(sz + pos);
}
void HttpBaWwwAuthenticate::stringify(UString& field)
{
U_TRACE(5, "HttpBaWwwAuthenticate::stringify(%.*S)", U_STRING_TO_TRACE(field))
field += name;
field.append(U_CONSTANT_TO_PARAM(": Basic realm="));
bool quoted = (realm[0] == '"');
if (quoted == false) field += '"';
field += realm;
if (quoted == false) field += '"';
field.append(U_CONSTANT_TO_PARAM("\r\n"));
U_INTERNAL_DUMP("field = %.*S", U_STRING_TO_TRACE(field))
}
int
U_EXPORT main (int argc, char* argv[])
{
U_ULIB_INIT(argv);
U_TRACE(5,"main(%d)",argc)
U_ASSERT_EQUALS( UServices::dosMatchWithOR(U_CONSTANT_TO_PARAM("www.sito1.com"), U_CONSTANT_TO_PARAM("SSI|benchmark|www.sito1.com|www.sito2.com"), FNM_INVERT), false)
UString buffer(2000);
u_base64_max_columns = 72;
UBase64::encode(U_CONSTANT_TO_PARAM(TESTOA), buffer);
U_INTERNAL_DUMP("buffer = %#.*S", U_STRING_TO_TRACE(buffer))
U_ASSERT( buffer == U_STRING_FROM_CONSTANT(TESTOB) )
UBase64::decode( U_CONSTANT_TO_PARAM(TESTOB), buffer);
U_ASSERT( buffer == U_STRING_FROM_CONSTANT(TESTOA) )
UString cmd, result1, result2;
int fd_stderr = U_SYSCALL(open, "%S,%d", "err/services.err", O_WRONLY);
cmd = U_STRING_FROM_CONSTANT("ls test_services.cpp");
result1 = UCommand::outputCommand(cmd);
// U_ASSERT( result1 == U_STRING_FROM_CONSTANT("test_services.cpp\n") )
buffer = UServices::getUUID();
U_INTERNAL_DUMP("buffer = %#.*S", U_STRING_TO_TRACE(buffer))
cmd = U_STRING_FROM_CONSTANT("cat test_services.cpp");
result2 = UCommand::outputCommand(cmd, 0, -1, fd_stderr);
U_ASSERT( result2.empty() == false )
cout.write(result2.data(), result2.size());
}
UString getTimeStampToken(const UString& data, const UString& url)
{
U_TRACE(5, "Application::getTimeStampToken(%.*S,%.*S)", U_STRING_TO_TRACE(data), U_STRING_TO_TRACE(url))
UString token;
# ifdef HAVE_SSL_TS
token = UTimeStamp::getTimeStampToken(U_HASH_SHA1, data, url);
# endif
U_RETURN_STRING(token);
}
