void* UDynamic::operator[](const char* _sym)
{
U_TRACE(0, "UDynamic::operator[](%S)", _sym)
U_CHECK_MEMORY
U_INTERNAL_ASSERT_POINTER(handle)
#if defined(_MSWINDOWS_)
addr = (void*) ::GetProcAddress(handle, _sym);
#else
addr = U_SYSCALL(dlsym, "%p,%S", handle, _sym);
#endif
if (addr == 0)
{
# if defined(_MSWINDOWS_)
err = "symbol missing";
# else
err = ::dlerror();
# endif
U_WARNING("UDynamic::operator[](%S) failed: %.*S", _sym, 256, err);
}
U_RETURN(addr);
}
xmlNodePtr UXML2Document::findNode(const xmlNodePtr parent, const xmlChar* name, const xmlChar* ns)
{
U_TRACE(0, "UXML2Document::findNode(%p,%S,%S)", parent, name, ns)
U_INTERNAL_ASSERT_POINTER(name)
xmlNodePtr ret;
xmlNodePtr cur = parent;
while (cur)
{
if (cur->type == XML_ELEMENT_NODE &&
UXML2Node(cur).checkNodeName(name, ns))
{
U_RETURN_POINTER(cur, xmlNode);
}
if (cur->children)
{
ret = findNode(cur->children, name, ns);
if (ret) U_RETURN_POINTER(ret, xmlNode);
}
cur = cur->next;
}
U_RETURN_POINTER(0, xmlNode);
}
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);
}
uint32_t UXML2Document::getElement(UString& element, uint32_t pos, const char* tag, uint32_t tag_len)
{
U_TRACE(0, "UXML2Document::getElement(%V,%u,%.*S,%u)", element.rep, pos, tag_len, tag, tag_len)
U_INTERNAL_ASSERT_POINTER(tag)
uint32_t start = data.find(tag, pos, tag_len);
if (start == U_NOT_FOUND ||
data.c_char(start-1) != '<')
{
U_RETURN(U_NOT_FOUND);
}
uint32_t end = data.find(tag, start + tag_len, tag_len);
if (end == U_NOT_FOUND ||
data.c_char(end-1) != '/' ||
data.c_char(end-2) != '<')
{
U_RETURN(U_NOT_FOUND);
}
element = data.substr(start - 1, end + tag_len - start + 2);
end += tag_len;
U_RETURN(end);
}
static void usp_end()
{
U_TRACE(5, "::usp_end()")
U_INTERNAL_ASSERT_POINTER(ir)
U_INTERNAL_ASSERT_POINTER(query)
U_INTERNAL_ASSERT_POINTER(crono)
U_INTERNAL_ASSERT_POINTER(footer)
#ifdef DEBUG
delete ir;
delete query;
delete crono;
delete footer;
#endif
}
void UNodeSet::destroy(UNodeSet* nset)
{
U_TRACE(1, "UNodeSet::destroy(%p)", nset)
U_INTERNAL_ASSERT_POINTER(nset)
UNodeSet* tmp;
while ((tmp = nset))
{
if ( nset->next &&
(nset->next != nset))
{
nset->next->prev = nset->prev;
nset->prev->next = nset->next;
nset = nset->next;
}
else
{
nset = U_NULLPTR;
}
if (tmp->nodes) U_SYSCALL_VOID(xmlXPathFreeNodeSet, "%p", tmp->nodes);
if (tmp->children) destroy(tmp->children);
if (tmp->doc && tmp->destroyDoc) U_SYSCALL_VOID(xmlFreeDoc, "%p", tmp->doc);
}
}
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;
}
}
U_NO_EXPORT int UTDB::_print(TDB_CONTEXT* tdb, TDB_DATA key, TDB_DATA dbuf, void* ptr)
{
U_TRACE(0, "UTDB::_print(%p,%J,%J,%p)", tdb, key, dbuf, ptr)
U_INTERNAL_ASSERT_POINTER(ptr)
((UString*)ptr)->printKeyValue((const char*)key.dptr, key.dsize, (const char*)dbuf.dptr, dbuf.dsize);
U_RETURN(0); // A non-zero return value from fn() indicates that the traversal should stop
}
UString UCrl::getIssuer(X509_CRL* _crl, bool ldap)
{
U_TRACE(0, "UCrl::getIssuer(%p,%b)", _crl, ldap)
U_INTERNAL_ASSERT_POINTER(_crl)
X509_NAME* n = X509_CRL_get_issuer(_crl);
return UCertificate::getName(n, ldap);
}
void UInterrupt::erase(int signo)
{
U_TRACE(1, "UInterrupt::erase(%d)", signo)
U_INTERNAL_ASSERT_RANGE(1, signo, NSIG)
U_INTERNAL_ASSERT_POINTER(handler_signal[signo])
handler_signal[signo] = 0;
(void) U_SYSCALL(sigaction, "%d,%p,%p", signo, old + signo, 0);
}
bool UTwilioClient::sendRequest(int method, const char* path, uint32_t path_len, const UString& data)
{
U_TRACE(0, "UTwilioClient::sendRequest(%d,%.*S,%u,%V)", method, path_len, path, path_len, data.rep)
U_INTERNAL_ASSERT_POINTER(client)
uri.snprintf(U_CONSTANT_TO_PARAM(TWILIO_API_URL "/" TWILIO_API_VERSION "/Accounts/%.*s/%.*s"), U_STRING_TO_TRACE(client->user), path_len, path);
if (method == 4) // DELETE
{
// send DELETE(4) request to server and get response
if (client->sendRequest(4, U_NULLPTR, 0, U_NULLPTR, 0, U_STRING_TO_PARAM(uri))) U_RETURN(true);
}
else if (method == 3) // PUT
{
UFile file(data);
// upload file to server and get response
if (client->upload(uri, file, U_NULLPTR, 0, 3)) U_RETURN(true);
}
else
{
UVector<UString> name_value;
if (name_value.split(data))
{
if (method == 0) // GET
{
Url url(uri);
if (url.setQuery(name_value))
{
UString x = url.get();
// send GET(0) request to server and get response
if (client->sendRequest(0, U_NULLPTR, 0, U_NULLPTR, 0, U_STRING_TO_PARAM(x))) U_RETURN(true);
}
}
else if (method == 2) // POST
{
UString body = Url::getQueryBody(name_value);
// send POST(2) request to server and get response
if (client->sendRequest(2, U_CONSTANT_TO_PARAM("application/x-www-form-urlencoded"), U_STRING_TO_PARAM(body), U_STRING_TO_PARAM(uri))) U_RETURN(true);
}
}
}
U_RETURN(false);
}
int UHttpPlugIn::handlerRead()
{
U_TRACE_NO_PARAM(0, "UHttpPlugIn::handlerRead()")
#if defined(HAVE_SYS_INOTIFY_H) && defined(U_HTTP_INOTIFY_SUPPORT)
U_INTERNAL_ASSERT_POINTER(UHTTP::cache_file)
UHTTP::in_READ();
#endif
U_RETURN(U_NOTIFIER_OK);
}
U_NO_EXPORT int UTDB::_getKeys(TDB_CONTEXT* tdb, TDB_DATA key, TDB_DATA dbuf, void* ptr)
{
U_TRACE(0, "UTDB::_getKeys(%p,%J,%J,%p)", tdb, key, dbuf, ptr)
U_INTERNAL_ASSERT_POINTER(ptr)
UString str((void*)key.dptr, key.dsize);
((UVector<UString>*)ptr)->push(str);
U_RETURN(0); // A non-zero return value from fn() indicates that the traversal should stop
}
xmlNodePtr UXML2Document::findChild(const xmlNodePtr parent, const xmlChar* name, const xmlChar* ns)
{
U_TRACE(0, "UXML2Document::findChild(%p,%S,%S)", parent, name, ns)
U_INTERNAL_ASSERT_POINTER(name)
U_INTERNAL_ASSERT_POINTER(parent)
xmlNodePtr cur = parent->children;
while (cur)
{
if (cur->type == XML_ELEMENT_NODE &&
UXML2Node(cur).checkNodeName(name, ns))
{
U_RETURN_POINTER(cur, xmlNode);
}
cur = cur->next;
}
U_RETURN_POINTER(U_NULLPTR, xmlNode);
}
UString UMagic::getType(const char* buffer, uint32_t buffer_len)
{
U_TRACE(1, "UMagic::getType(%.*S,%u)", buffer_len, buffer, buffer_len)
U_INTERNAL_ASSERT_POINTER(magic)
UString str;
const char* result = (const char*) U_SYSCALL(magic_buffer, "%p,%p,%u", magic, buffer, buffer_len);
if (result) (void) str.assign(result);
else (void) str.assign(U_CONSTANT_TO_PARAM("application/octet-stream"));
U_RETURN_STRING(str);
}
xmlNodePtr UXML2Document::findParent(const xmlNodePtr cur, const xmlChar* name, const xmlChar* ns)
{
U_TRACE(0, "UXML2Document::findParent(%p,%S,%S)", cur, name, ns)
U_INTERNAL_ASSERT_POINTER(cur)
U_INTERNAL_ASSERT_POINTER(name)
xmlNodePtr ret;
if (cur->type == XML_ELEMENT_NODE &&
UXML2Node(cur).checkNodeName(name, ns))
{
U_RETURN_POINTER(cur, xmlNode);
}
if (cur->parent)
{
ret = findParent(cur->parent, name, ns);
if (ret) U_RETURN_POINTER(ret, xmlNode);
}
U_RETURN_POINTER(0, xmlNode);
}
UEventTime::UEventTime(long sec, long usec) : UTimeVal(sec, usec)
{
U_TRACE_REGISTER_OBJECT(0, UEventTime, "%ld,%ld", sec, usec)
reset();
#ifdef USE_LIBEVENT
if (u_ev_base == 0) u_ev_base = (struct event_base*) U_SYSCALL_NO_PARAM(event_init);
U_INTERNAL_ASSERT_POINTER(u_ev_base)
pevent = U_NEW(UTimerEv<UEventTime>(*this));
(void) UDispatcher::add(*pevent, *(UTimeVal*)this);
#endif
}
UIOCallback* UTranformInputURI::find(const char* uri)
{
U_TRACE(0, "UTranformInputURI::find(%S)", uri)
U_INTERNAL_ASSERT_POINTER(allIOCallbacks)
UIOCallback* callbacks;
for (uint32_t i = 0, n = allIOCallbacks->size(); i < n; ++i)
{
callbacks = (*allIOCallbacks)[i];
if (callbacks->matchcallback(uri)) U_RETURN_POINTER(callbacks, UIOCallback);
}
U_RETURN_POINTER(U_NULLPTR, UIOCallback);
}
void UDynamic::close()
{
U_TRACE(0, "UDynamic::close()")
U_CHECK_MEMORY
U_INTERNAL_ASSERT_POINTER(handle)
#if defined(_MSWINDOWS_)
::FreeLibrary(handle);
#else
(void) U_SYSCALL(dlclose, "%p", handle);
#endif
err = 0;
addr = 0;
handle = 0;
}
UEventTime::UEventTime(long sec, long micro_sec) : UTimeVal(sec, micro_sec)
{
U_TRACE_REGISTER_OBJECT(0, UEventTime, "%ld,%ld", sec, micro_sec)
setTolerance();
xtime.tv_sec =
xtime.tv_usec = 0L;
#ifdef USE_LIBEVENT
if (u_ev_base == 0) u_ev_base = (struct event_base*) U_SYSCALL_NO_PARAM(event_base_new);
U_INTERNAL_ASSERT_POINTER(u_ev_base)
U_NEW(UTimerEv<UEventTime>, pevent, UTimerEv<UEventTime>(*this));
(void) UDispatcher::add(*pevent, *(UTimeVal*)this);
#endif
}
UString UPKCS10::getSubject(X509_REQ* _request)
{
U_TRACE(1, "UPKCS10::getSubject(%p)", _request)
U_INTERNAL_ASSERT_POINTER(_request)
X509_NAME* name = X509_REQ_get_subject_name(_request);
unsigned len = U_SYSCALL(i2d_X509_NAME, "%p,%p", name, 0);
UString subject(len);
char* ptr = subject.data();
(void) U_SYSCALL(X509_NAME_oneline, "%p,%p,%d", name, ptr, subject.capacity());
len = u__strlen(ptr, __PRETTY_FUNCTION__);
subject.size_adjust(len);
U_RETURN_STRING(subject);
}
UString USOAPParser::getFaultResponse()
{
U_TRACE_NO_PARAM(0, "USOAPParser::getFaultResponse()")
U_INTERNAL_ASSERT_POINTER(method)
URPCFault fault;
UString retval(U_CAPACITY);
fault.setFaultCode();
fault.getFaultReason() = (*envelope.arg)[0];
if (envelope.arg->size() > 1) fault.getDetail() = (*envelope.arg)[1];
fault.encode(retval);
(void) retval.shrink();
U_RETURN_STRING(retval);
}
UString URPCObject::processMessage(URPCEnvelope& envelope, bool& bContainsFault)
{
U_TRACE(0, "URPCObject::processMessage(%p,%p)", &envelope, &bContainsFault)
U_INTERNAL_ASSERT_POINTER(URPCMethod::encoder)
UString retval;
// Iterate over the list of methods
URPCMethod* method = find(envelope.getMethodName());
if (method == 0)
{
// Return object not found error. This would be a Client fault
setFailed();
URPCMethod::pFault->setFaultReason(U_CONSTANT_TO_PARAM("The requested method does not exist on this server"));
bContainsFault = true;
retval = URPCMethod::encoder->encodeFault(URPCMethod::pFault);
}
else
{
UString ns = envelope.getNsName();
U_INTERNAL_DUMP("envelope.nsName = %V", ns.rep)
// check the name of namespace qualified element information (gSOAP)
if (ns.empty()) ns = method->getNamespaces();
if (ns.empty()) ns = *UString::str_ns;
bContainsFault = (method->execute(envelope) == false);
retval = URPCMethod::encoder->encodeMethodResponse(*method, ns);
}
U_RETURN_STRING(retval);
}
void ULog::startup()
{
U_TRACE(0, "ULog::startup()")
U_INTERNAL_ASSERT_POINTER(fmt)
log(fmt, "STARTUP", sizeof(void*) * 8);
log("Building Environment: " PLATFORM_VAR " (" __DATE__ ")\n", 0);
#ifndef __MINGW32__
struct utsname u;
(void) U_SYSCALL(uname, "%p", &u);
log("Current Operating System: %s %s v%s %s\n", u.sysname, u.machine, u.version, u.release);
#endif
#if defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
log("Big endian arch detected\n", 0);
#endif
}
uint32_t UXML2Document::getElement(UVector<UString>& velement, const char* tag, uint32_t tag_len)
{
U_TRACE(0, "UXML2Document::getElement(%p,%.*S,%u)", &velement, tag_len, tag, tag_len)
U_INTERNAL_ASSERT_POINTER(tag)
UString element;
uint32_t n = velement.size(), pos = 0;
while (true)
{
pos = getElement(element, pos, tag, tag_len);
if (pos == U_NOT_FOUND) break;
velement.push(element);
}
uint32_t result = velement.size() - n;
U_RETURN(result);
}
void UObjectIO::output()
{
U_INTERNAL_TRACE("UObjectIO::output()")
U_INTERNAL_ASSERT_POINTER(os)
buffer_output_len = os->pcount();
U_INTERNAL_PRINT("os->pcount() = %d", buffer_output_len)
U_INTERNAL_ASSERT_MINOR(buffer_output_len, buffer_output_sz)
buffer_output[buffer_output_len] = '\0';
U_INTERNAL_PRINT("buffer_output = %.*s", U_min(buffer_output_len,128), buffer_output)
#ifdef DEBUG_DEBUG
off_t pos = os->rdbuf()->pubseekpos(0, U_openmode);
#else
(void) os->rdbuf()->pubseekpos(0, U_openmode);
#endif
U_INTERNAL_PRINT("pos = %ld, os->pcount() = %d", pos, os->pcount())
}
bool ULog::open(uint32_t _size, mode_t mode)
{
U_TRACE(0, "ULog::open(%u,%d)", _size, mode)
// NB: we need to check because all instance try to close the log... (inherits from its parent)
u_atexit(&ULog::close); // register function of close at exit()...
if (UFile::getPath() == U_STRING_FROM_CONSTANT("syslog"))
{
prefix = 0;
pthis = this;
bsyslog = true;
# ifndef __MINGW32__
U_SYSCALL_VOID(openlog, "%S,%d,%d", u_progname, LOG_PID, LOG_LOCAL0);
# endif
U_RETURN(true);
}
if (UFile::creat(O_CREAT | O_RDWR | O_APPEND, mode))
{
uint32_t file_size = 0;
if (_size)
{
file_size = UFile::size();
if (UFile::ftruncate(_size) == false ||
UFile::memmap(PROT_READ | PROT_WRITE) == false)
{
goto end;
}
}
pthis = this;
ptr_log_data = U_MALLOC_TYPE(log_data);
LOG_ptr = LOG_page = (_size ? (UFile::map + file_size) : 0); // append mode...
file_limit = (_size ? (UFile::map + UFile::st_size) : 0);
U_INTERNAL_ASSERT_EQUALS(lock,0)
lock = U_NEW(ULock);
U_INTERNAL_ASSERT_POINTER(lock)
# ifdef USE_LIBZ
backup_log_function = &ULog::backup;
dir_log_gz = (const char*) U_SYSCALL(getenv, "%S", "DIR_LOG_GZ");
UInterrupt::setHandlerForSignal(SIGUSR1, (sighandler_t)ULog::handlerSIGUSR1);
# endif
if (fmt) startup();
U_RETURN(true);
}
end:
U_ERROR("cannot init log file %.*S...", U_FILE_TO_TRACE(*this));
U_RETURN(false);
}
void UThread::close()
{
U_TRACE_NO_PARAM(0, "UThread::close()")
#ifdef _MSWINDOWS_
DWORD _tid = tid;
#else
pthread_t _tid = tid;
#endif
tid = 0;
U_INTERNAL_DUMP("tid = %p first = %p next = %p", _tid, first, next)
U_INTERNAL_ASSERT_POINTER(first)
UThread* obj;
UThread** ptr = &first;
while ((obj = *ptr))
{
U_INTERNAL_ASSERT_POINTER(obj)
# ifdef _MSWINDOWS_
if (tid == obj->tid)
# else
if (pthread_equal(tid, obj->tid))
# endif
{
U_INTERNAL_ASSERT_EQUALS(this, obj)
U_INTERNAL_ASSERT_EQUALS(next, obj->next)
*ptr = next;
next = 0;
break;
}
ptr = &(*ptr)->next;
}
if (_tid)
{
# ifdef _MSWINDOWS_ // wait for real w32 thread to cleanup
switch (cancel)
{
case cancelImmediate: TerminateThread((HANDLE)_tid, 0); break;
default: SetEvent(cancellation);
}
(void) WaitForSingleObject((HANDLE)_tid, INFINITE);
(void) U_SYSCALL(CloseHandle, "%p", cancellation);
(void) U_SYSCALL(CloseHandle, "%p", (HANDLE)_tid);
_endthreadex(0);
# else
# ifdef HAVE_PTHREAD_CANCEL
(void) U_SYSCALL(pthread_cancel, "%p", _tid);
# endif
if (detachstate == PTHREAD_CREATE_JOINABLE) (void) U_SYSCALL(pthread_join, "%p,%p", _tid, 0);
# ifdef HAVE_PTHREAD_YIELD
else
{
(void) U_SYSCALL_NO_PARAM(pthread_yield);
}
# endif
# endif
}
}
