Example #1
0
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);
}
Example #2
0
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);
}
Example #3
0
bool UDirWalk::setDirectory(const char* dir, const char* _filter, uint32_t _filter_len)
{
   U_TRACE(0, "UDirWalk::setDirectory(%S,%.*S,%u", dir, _filter_len, _filter, _filter_len)

   pthis->pathlen = u__strlen(dir, __PRETTY_FUNCTION__);

   dir = u_getPathRelativ(dir, &(pthis->pathlen));

   U_INTERNAL_ASSERT_MAJOR(pthis->pathlen, 0)

   if (UFile::access(dir) == false)
      {
      pthis->pathlen = 0;

      U_RETURN(false);
      }

   U__MEMCPY(pthis->pathname, dir, pthis->pathlen);

   pthis->pathname[pthis->pathlen] = '\0';

   if (_filter_len)
      {
      filter     = _filter;
      filter_len = _filter_len;

      u_pfn_flags = 0;
      u_pfn_match = u_dosmatch_with_OR;
      }

   U_RETURN(true);
}
Example #4
0
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);
}
Example #5
0
bool URDBServer::open(const UString& pathdb, uint32_t log_size)
{
   U_TRACE(0, "URDBServer::open(%V,%u)", pathdb.rep, log_size)

   URDBClientImage::rdb = rdb;

   if (rdb->open(pathdb, log_size)) U_RETURN(true);

   U_RETURN(false);
}
Example #6
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);
}
Example #7
0
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);
}
Example #8
0
bool UREDISClient_Base::connect(const char* phost, unsigned int _port)
{
   U_TRACE(0, "UREDISClient_Base::connect(%S,%u)", phost, _port)

   UString host;

   if (phost) (void) host.assign(phost);
   else
      {
      const char* env_redis_host = (const char*) U_SYSCALL(getenv, "%S", "REDIS_HOST");

      if (env_redis_host == 0)
         {
         UClient_Base::response.snprintf("connection disabled");

         U_RETURN(false);
         }

      (void) host.assign(env_redis_host, u__strlen(env_redis_host, __PRETTY_FUNCTION__));

      const char* env_redis_port = (const char*) U_SYSCALL(getenv, "%S", "REDIS_PORT");

      if (env_redis_port) _port = atoi(env_redis_port);
      }

   if (UClient_Base::setHostPort(host, _port) &&
       UClient_Base::connect())
      {
      UClient_Base::iovcnt = 4;

      UClient_Base::iov[1].iov_base =
      UClient_Base::iov[4].iov_base = (caddr_t)" ";
      UClient_Base::iov[1].iov_len  =
      UClient_Base::iov[4].iov_len  = 1;

      UClient_Base::iov[3].iov_base =
      UClient_Base::iov[5].iov_base = (caddr_t)U_CRLF;
      UClient_Base::iov[3].iov_len  =
      UClient_Base::iov[5].iov_len  = 2;

      U_DUMP("getRedisVersion() = %V", getRedisVersion().rep)

      U_RETURN(true);
      }

   U_RETURN(false);
}
Example #9
0
bool UTranformInclC14N::execute(UString& data)
{
   U_TRACE(0, "UTranformInclC14N::execute(%.*S)", U_STRING_TO_TRACE(data))

   data = UXML2Document::xmlC14N(data);

   U_RETURN(true);
}
Example #10
0
bool UTranformBase64::execute(UString& data)
{
   U_TRACE(0, "UTranformBase64::execute(%.*S)", U_STRING_TO_TRACE(data))

   UString buffer(data.size());

   UBase64::decode(data, buffer);

   if (buffer)
      {
      data = buffer;

      U_RETURN(true);
      }

   U_RETURN(false);
}
Example #11
0
bool UBase64::decodeUrl(const char* s, uint32_t n, UString& buffer)
{
   U_TRACE(0, "UBase64::decodeUrl(%.*S,%u,%.*S)", n, s, n, U_STRING_TO_TRACE(buffer))

   uint32_t pos = u_base64url_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_RETURN(false);
}
Example #12
0
bool UDynamic::load(const char* pathname)
{
   U_TRACE(0, "UDynamic::load(%S)", pathname)

   U_CHECK_MEMORY

   U_INTERNAL_ASSERT_EQUALS(handle, 0)

#ifdef _MSWINDOWS_
   handle = ::LoadLibrary(pathname);
#else
   /**
    * --------------------------------------------------------------------
    * Perform lazy binding
    * --------------------------------------------------------------------
    * Only resolve symbols as the code that references them is executed.
    * If the symbol is never referenced, then it is never resolved.
    * Lazy binding is only performed for function references; references
    * to variables are always immediately bound when the library is loaded
    * --------------------------------------------------------------------
    */

   handle = U_SYSCALL(dlopen, "%S,%d", pathname, RTLD_LAZY); // RTLD_NOW
#endif

   if (handle == 0)
      {
#  if defined(_MSWINDOWS_)
      err = "load failed";
#  else
      err = ::dlerror();
#  endif

      U_WARNING("UDynamic::load(%S) failed: %.*S", pathname, 256, err);

      U_RETURN(false);
      }

#ifndef _MSWINDOWS_
   (void) ::dlerror(); /* Clear any existing error */
#endif

   U_RETURN(true);
}
Example #13
0
File: tdb.cpp Project: fast01/ULib
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
}
Example #14
0
static VALUE URUBY_io_rewind(VALUE obj, VALUE args)
{
   U_TRACE(0, "URUBY_io_rewind(%llu,%llu)", obj, args)

   post_readline_pos       =                     UClientImage_Base::body->data();
   post_readline_watermark = post_readline_pos + UClientImage_Base::body->size();

   U_INTERNAL_DUMP("post_readline_pos = %p post_readline_watermark = %p", post_readline_pos, post_readline_watermark)

   U_RETURN(Qnil);
}
Example #15
0
int UProxyPlugIn::handlerConfig(UFileConfig& cfg)
{
   U_TRACE(0, "UProxyPlugIn::handlerConfig(%p)", &cfg)

   vservice   = U_NEW(UVector<UModProxyService*>);
   vmsg_error = U_NEW(UVector<UString>);

   UModProxyService::loadConfig(cfg, *vservice, vmsg_error);

   U_RETURN(U_PLUGIN_HANDLER_GO_ON);
}
Example #16
0
File: tdb.cpp Project: fast01/ULib
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
}
Example #17
0
bool UTranformSha256::execute(UString& data)
{
   U_TRACE(0, "UTranformSha256::execute(%.*S)", U_STRING_TO_TRACE(data))

   UString ObjectDigestValue(200U);

   UServices::generateDigest(U_HASH_SHA256, 0, data, ObjectDigestValue, true);

   data = ObjectDigestValue;

   U_RETURN(true);
}
Example #18
0
bool UTranformXPointer::setExpr(const char* expr, int nodeSetType, xmlNodePtr node)
{
   U_TRACE(0, "UTranformXPointer::setExpr(%S,%d,%p)", expr, nodeSetType, node)

   UBaseTransform::hereNode = node;

   UXPathData* data;

   U_NEW(UXPathData, data, UXPathData(UXPathData::XPOINTER, nodeSetType, expr));

   if (data->registerNamespaces(node))
      {
      dataList.push(data);

      U_RETURN(true);
      }

   U_DELETE(data)

   U_RETURN(false);
}
Example #19
0
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);
}
Example #20
0
static VALUE URUBY_io_new(VALUE _class)
{
   U_TRACE(0, "URUBY_io_new(%llu)", _class)

   VALUE self = Data_Wrap_Struct(_class, U_NULLPTR, U_NULLPTR, U_NULLPTR);

   U_INTERNAL_DUMP("self = %llu", self)

   U_SYSCALL_VOID(rb_obj_call_init, "%llu,%d,%p", self, 0, U_NULLPTR);

   U_RETURN(self);
}
Example #21
0
   virtual int handlerTime()
      {
      U_TRACE(0, "MyAlarm1::handlerTime()")

      // return value:
      // ---------------
      // -1 - normal
      //  0 - monitoring
      // ---------------

      U_RETURN(-1);
      }
Example #22
0
bool UEscape::decode(const char* s, uint32_t n, UString& buffer)
{
   U_TRACE(0, "UEscape::decode(%.*S,%u,%.*S)", n, s, n, U_STRING_TO_TRACE(buffer))

   uint32_t pos = u_escape_decode(s, n, (unsigned char*)buffer.data());

   buffer.size_adjust(pos);

   bool result = (pos > 0);

   U_RETURN(result);
}
Example #23
0
bool UMagic::init(int flags)
{
   U_TRACE(1, "UMagic::init(%d)", flags)

   U_INTERNAL_ASSERT_EQUALS(magic, U_NULLPTR)

   magic = (magic_t) U_SYSCALL(magic_open, "%d", flags);

   bool ok = (magic && U_SYSCALL(magic_load, "%p,%S", magic, U_NULLPTR) != -1);

   U_DUMP("ok = %b status = %.*S", ok, 512, getError())

   U_RETURN(ok);
}
Example #24
0
    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);
    }
Example #25
0
bool UProcess::fork()
{
   U_TRACE(1, "UProcess::fork()")

   U_CHECK_MEMORY

   _pid = U_FORK();

   if (child()) u_setPid();

   running = (_pid != -1);

   U_RETURN(running);
}
Example #26
0
   virtual int handlerTime()
      {
      U_TRACE(0+256, "MyAlarm1::handlerTime()")

      // return value:
      // ---------------
      // -1 - normal
      //  0 - monitoring
      // ---------------

      cout.write(buffer, u__snprintf(buffer, sizeof(buffer), "MyAlarm1::handlerTime() u_now = %1D expire = %#1D\n", UEventTime::expire()));

      U_RETURN(-1);
      }
Example #27
0
bool URPCClient_Base::readResponse(USocket* sk, UString& buffer, UString& response)
{
   U_TRACE(0, "URPCClient_Base::readResponse(%p,%V,%V)", sk, buffer.rep, response.rep)

   uint32_t rstart = 0;

   // NB: we force for U_SUBSTR_INC_REF case (string can be referenced more)...

     buffer.setEmptyForce();
   response.setEmptyForce();

   if (URPC::readTokenString(sk, U_NULLPTR, buffer, rstart, response))
      {
      // NB: we force for U_SUBSTR_INC_REF case (string can be referenced more)...

      buffer.size_adjust_force(U_TOKEN_NM);
      }

   U_INTERNAL_DUMP("buffer = %V response = %V", buffer.rep, response.rep)

   if (buffer) U_RETURN(true);

   U_RETURN(false);
}
Example #28
0
bool UProcess::fork()
{
   U_TRACE_NO_PARAM(1, "UProcess::fork()")

   U_CHECK_MEMORY

   _pid = U_FORK();

   if (child()) u_setPid();

   running = (_pid != -1);

   U_INTERNAL_DUMP("%P running = %b", running)

   U_RETURN(running);
}
Example #29
0
int UEchoPlugIn::handlerRequest()
{
   U_TRACE(0, "UEchoPlugIn::handlerRequest()")

#ifdef U_RESPONSE_FOR_TEST
   UClientImage_Base::wbuffer->assign(U_CONSTANT_TO_PARAM(U_RESPONSE_FOR_TEST));
#else
   *UClientImage_Base::wbuffer = *UClientImage_Base::request;
#endif

   UClientImage_Base::body->clear();

   UHTTP::endRequestProcessing();

   U_RETURN(U_PLUGIN_HANDLER_FINISHED);
}
Example #30
0
File: cdb.cpp Project: psfu/ULib
bool UCDB::open(bool brdonly)
{
   U_TRACE(0, "UCDB::open(%b)", brdonly)

   nrecord = start_hash_table_slot = 0;

   if (UFile::isOpen() ||
       UFile::open(brdonly ? O_RDONLY : O_CREAT | O_RDWR))
      {
      UFile::readSize();

      if (UFile::st_size)
         {
         (void) UFile::memmap(PROT_READ | (brdonly ? 0 : PROT_WRITE));

         if (UFile::map == MAP_FAILED)
            {
            data.dptr = 0;

            hp   =   &hp_buf;
            hr   =   &hr_buf;
            slot = &slot_buf;

            (void) UFile::pread(&start_hash_table_slot, sizeof(uint32_t), 0);
            }
         else
            {
            UFile::close();

            start_hash_table_slot = *(uint32_t*)UFile::map;
            }

         nrecord = (UFile::st_size - start_hash_table_slot) / sizeof(cdb_hash_table_slot);
         }

      U_INTERNAL_DUMP("nrecord = %u", nrecord)

#  ifdef DEBUG
      if (UFile::st_size) checkForAllEntry();
#  endif

      U_RETURN(true);
      }