// mapped to: std::basic_string<char> * nextView2(int i, long int l, std::string & s, bool * const b, char c) const;
ulxr::MethodResponse
UlxrIdlTestServer::nextView2 (const ulxr::MethodCall &calldata)
{
try
{
int p0 = (int) ulxr::Integer(calldata.getParam(0)).getInteger();
long int p1 = (long int) ulxr::Integer(calldata.getParam(1)).getInteger();
std::string p2 = (std::string) ulxr::getLatin1(ulxr::RpcString(calldata.getParam(2)).getString());
bool p3 = (bool) ulxr::Boolean(calldata.getParam(3)).getBoolean();
char p4 = (char) ulxr::Integer(calldata.getParam(4)).getInteger();
std::string retval = *server.nextView2(p0, p1, p2, &p3, p4);
return ulxr::MethodResponse (ulxr::RpcString (ULXR_GET_STRING(retval)));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'std::basic_string<char> * nextView2(int i, long int l, std::string & s, bool * const b, char c) const;'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'std::basic_string<char> * nextView2(int i, long int l, std::string & s, bool * const b, char c) const;'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
ULXR_API_IMPL0
TcpIpConnection::TcpIpConnection(bool I_am_server, const CppString &dom, unsigned prt)
: Connection()
, pimpl(new PImpl)
{
ULXR_TRACE(ULXR_PCHAR("TcpIpConnection(bool, string, uint)") << dom << ULXR_PCHAR(" ") << pimpl->port);
init(prt);
pimpl->remote_name = dom;
struct hostent *hp = getHostAdress(dom);
if (hp == 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Host adress not found: ")) + pimpl->serverdomain, 500);
memcpy(&(pimpl->hostdata.sin_addr), hp->h_addr_list[0], hp->h_length);
if (I_am_server)
{
pimpl->server_data = new ServerSocketData(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
if (getServerHandle() < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not create socket: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#ifdef ULXR_REUSE_SOCKET
int sockOpt = 1;
if (::setsockopt(getServerHandle(), SOL_SOCKET, SO_REUSEADDR,
(const char*)&sockOpt, sizeof(sockOpt)) < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not set reuse flag for socket: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#endif
int iOptVal = getTimeout() * 1000;
int iOptLen = sizeof(int);
::setsockopt(getServerHandle(), SOL_SOCKET, SO_RCVTIMEO, (char*)&iOptVal, iOptLen);
::setsockopt(getServerHandle(), SOL_SOCKET, SO_SNDTIMEO, (char*)&iOptVal, iOptLen);
if((::bind(getServerHandle(), (sockaddr*) &pimpl->hostdata, sizeof(pimpl->hostdata))) < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not bind adress: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
listen(getServerHandle(), 5);
}
}
ULXR_API_IMPL(void) TcpIpConnection::open()
{
ULXR_TRACE(ULXR_PCHAR("open"));
if (isOpen() )
throw RuntimeException(ApplicationError,
ulxr_i18n(ULXR_PCHAR("Attempt to open an already open connection")));
if (pimpl->server_data != 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Connection is NOT prepared for client mode")), 500);
// resetConnection();
setHandle(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
if (getHandle() < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not create socket: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
int iOptVal = getTimeout() * 1000;
int iOptLen = sizeof(int);
::setsockopt(getHandle(), SOL_SOCKET, SO_RCVTIMEO, (char*)&iOptVal, iOptLen);
::setsockopt(getHandle(), SOL_SOCKET, SO_SNDTIMEO, (char*)&iOptVal, iOptLen);
doTcpNoDelay();
if(connect(getHandle(), (struct sockaddr *)&pimpl->hostdata, sizeof(pimpl->hostdata)) < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not connect: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
ULXR_TRACE(ULXR_PCHAR("/open.peername"));
#ifdef ULXR_ENABLE_GET_PEERNAME
pimpl->remotedata_len = sizeof(pimpl->remotedata);
if(getpeername(getHandle(),
(struct sockaddr *)&pimpl->remotedata,
&pimpl->remotedata_len)<0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not get peer data: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#ifdef __BORLANDC__
pimpl->remote_name = ULXR_PCHAR("<remote-host>"); // FIXME, not working
host = 0;
host;
#else
else
{
// mapped to: const std::string * last_url4(); (there are overloaded methods)
ulxr::MethodResponse
UlxrIdlTestServer::last_url4_ovr0 (const ulxr::MethodCall &calldata)
{
try
{
std::string retval = *server.last_url4();
return ulxr::MethodResponse (ulxr::RpcString (ULXR_GET_STRING(retval)));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'const std::string * last_url4();'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'const std::string * last_url4();'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: wchar_t * const first_url4(double li); (there are overloaded methods)
ulxr::MethodResponse
UlxrIdlTestServer::first_url4_ovr0 (const ulxr::MethodCall &calldata)
{
try
{
double p0 = (double) ulxr::Double(calldata.getParam(0)).getDouble();
std::wstring retval = server.first_url4(p0);
return ulxr::MethodResponse (ulxr::RpcString (ULXR_GET_STRING(retval)));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'wchar_t * const first_url4(double li);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'wchar_t * const first_url4(double li);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: const std::basic_string<wchar_t> * getObject(const std::string & s);
ulxr::MethodResponse
UlxrIdlTestServer::getObject (const ulxr::MethodCall &calldata)
{
try
{
std::string p0 = (std::string) ulxr::getLatin1(ulxr::RpcString(calldata.getParam(0)).getString());
std::wstring retval = *server.getObject(p0);
return ulxr::MethodResponse (ulxr::RpcString (ULXR_GET_STRING(retval)));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'const std::basic_string<wchar_t> * getObject(const std::string & s);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'const std::basic_string<wchar_t> * getObject(const std::string & s);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: std::string * first_url4(long int li); (there are overloaded methods)
ulxr::MethodResponse
UlxrIdlTestServer::first_url4_ovr2 (const ulxr::MethodCall &calldata)
{
try
{
long int p0 = (long int) ulxr::Integer(calldata.getParam(0)).getInteger();
std::string retval = *server.first_url4(p0);
return ulxr::MethodResponse (ulxr::RpcString (ULXR_GET_STRING(retval)));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'std::string * first_url4(long int li);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'std::string * first_url4(long int li);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
ULXR_API_IMPL0 TcpIpConnection::TcpIpConnection(bool I_am_server, long adr, unsigned prt)
: Connection()
, pimpl(new PImpl)
{
ULXR_TRACE(ULXR_PCHAR("TcpIpConnection(bool, long, uint)") << adr << ULXR_PCHAR(" ") << pimpl->port);
init(prt);
pimpl->hostdata.sin_addr.s_addr = htonl(adr);
if (I_am_server)
{
pimpl->server_data = new ServerSocketData(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
if (getServerHandle() < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not create socket: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#ifdef ULXR_REUSE_SOCKET
int sockOpt = 1;
if (::setsockopt(getServerHandle(), SOL_SOCKET, SO_REUSEADDR,
(const char*)&sockOpt, sizeof(sockOpt)) < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not set reuse flag for socket: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#endif
int iOptVal = getTimeout() * 1000;
int iOptLen = sizeof(int);
::setsockopt(getServerHandle(), SOL_SOCKET, SO_RCVTIMEO, (char*)&iOptVal, iOptLen);
::setsockopt(getServerHandle(), SOL_SOCKET, SO_SNDTIMEO, (char*)&iOptVal, iOptLen);
if((::bind(getServerHandle(), (sockaddr*) &pimpl->hostdata, sizeof(pimpl->hostdata))) < 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not bind adress: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
::listen(getServerHandle(), 5);
}
}
// mapped to: std::string * inline_func::free_function2(long int * i, float f); (there are overloaded methods)
ulxr::MethodResponse
UlxrIdlTestFuncs_inline_func__free_function2 (const ulxr::MethodCall &calldata)
{
try
{
long int p0 = (long int) ulxr::Integer(calldata.getParam(0)).getInteger();
float p1 = (float) ulxr::Double(calldata.getParam(1)).getDouble();
std::string retval = *inline_func::free_function2(&p0, p1);
return ulxr::MethodResponse (ulxr::RpcString (ULXR_GET_STRING(retval)));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'std::string * inline_func::free_function2(long int * i, float f);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'std::string * inline_func::free_function2(long int * i, float f);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
ULXR_API_IMPL(void) TcpIpConnection::asciiToInAddr(const char *address, struct in_addr &saddr)
{
memset (&saddr, 0, sizeof(in_addr));
struct hostent *host;
/* First try it as aaa.bbb.ccc.ddd. */
saddr.s_addr = inet_addr(address);
if ((int)saddr.s_addr == -1)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not perform inet_addr(): "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#ifndef ULXR_OMIT_REENTRANT_PROTECTOR
Mutex::Locker lock(gethostbynameMutex);
#endif
host = gethostbyname(address);
if (host == 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not perform gethostbyname(): "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
memmove((void*)&saddr, host->h_addr_list, sizeof(in_addr));
}
ULXR_API_IMPL(ValueParserBase::ValueState *) ValueParser::getTopValueState() const
{
ULXR_TRACE(ULXR_PCHAR("ValueParser::getTopState() size: ") << states.size());
#ifdef DEBUG
ValueState *vs = dynamic_cast<ValueState*> (states.top()); // be careful about type
if (vs == 0)
{
ULXR_TRACE(ULXR_PCHAR("ValueParser::getTopState(), top state: ") << (void*) states.top());
ULXR_TRACE(ULXR_PCHAR("ValueParser::getTopState(): state <> ValueState"));
ULXR_TRACE(ULXR_PCHAR("ValueParser::getTopState(): state == ") << ULXR_GET_STRING(typeid(states.top()).name()));
}
return vs;
#else
return reinterpret_cast<ValueParserBase::ValueState*> (states.top()); // dont care anymore
#endif
}
// mapped to: void first_url4(); (there are overloaded methods)
ulxr::MethodResponse
UlxrIdlTestServer::first_url4_ovr4 (const ulxr::MethodCall &calldata)
{
try
{
server.first_url4();
return ulxr::MethodResponse (ulxr::Void());
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'void first_url4();'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'void first_url4();'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: long int * firstViewConst() const;
ulxr::MethodResponse
UlxrIdlTestServer::firstViewConst (const ulxr::MethodCall &calldata)
{
try
{
long int retval = *server.firstViewConst();
return ulxr::MethodResponse (ulxr::Integer (retval));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'long int * firstViewConst() const;'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'long int * firstViewConst() const;'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: int getNumPages(const std::wstring & s);
ulxr::MethodResponse
UlxrIdlTestServer::getNumPages (const ulxr::MethodCall &calldata)
{
try
{
std::wstring p0 = (std::wstring) ulxr::getUnicode(ulxr::RpcString(calldata.getParam(0)).getString());
long int retval = server.getNumPages(p0);
return ulxr::MethodResponse (ulxr::Integer (retval));
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'int getNumPages(const std::wstring & s);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'int getNumPages(const std::wstring & s);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: void getNumObjects(std::string s);
ulxr::MethodResponse
UlxrIdlTestServer::getNumObjects (const ulxr::MethodCall &calldata)
{
try
{
std::string p0 = (std::string) ulxr::getLatin1(ulxr::RpcString(calldata.getParam(0)).getString());
server.getNumObjects(p0);
return ulxr::MethodResponse (ulxr::Void());
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'void getNumObjects(std::string s);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'void getNumObjects(std::string s);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
// mapped to: void funcs::free_function1(int i); (there are overloaded methods)
ulxr::MethodResponse
UlxrIdlTestFuncs_funcs__free_function1_ovr0 (const ulxr::MethodCall &calldata)
{
try
{
int p0 = (int) ulxr::Integer(calldata.getParam(0)).getInteger();
funcs::free_function1(p0);
return ulxr::MethodResponse (ulxr::Void());
}
catch(std::exception &ex)
{
ulxr::CppString s = ULXR_PCHAR("C++ exception caught when invoking 'void funcs::free_function1(int i);'\n ");
s += ULXR_GET_STRING(ex.what());
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
catch(...)
{
ulxr::CppString s = ULXR_PCHAR("Unknown exception caught when invoking 'void funcs::free_function1(int i);'");
return ulxr::MethodResponse(ulxr::ApplicationError, s);
}
}
int main(int argc, char * argv [])
{
ulxr::intializeLog4J(argv[0]);
int success = 0;
#ifdef STRESS_IT
for (int i= 0; i < 1000; ++i)
{
#endif
try
{
ULXR_COUT << ULXR_PCHAR("Testing patterns\n");
ULXR_COUT << ULXR_PCHAR("boolPattern\n") << std::flush;
testPattern(boolPattern, sizeof(boolPattern));
ULXR_COUT << ULXR_PCHAR("int1Pattern\n");
testPattern(int1Pattern, sizeof(int1Pattern));
ULXR_COUT << ULXR_PCHAR("int2Pattern\n");
testPattern(int2Pattern, sizeof(int2Pattern));
ULXR_COUT << ULXR_PCHAR("doublePattern\n");
testPattern(doublePattern, sizeof(doublePattern));
ULXR_COUT << ULXR_PCHAR("stringPattern\n");
testPattern(stringPattern, sizeof(stringPattern));
ULXR_COUT << ULXR_PCHAR("base64Pattern\n");
testPattern(base64Pattern, sizeof(base64Pattern));
ULXR_COUT << ULXR_PCHAR("datePattern\n");
testPattern(datePattern, sizeof(datePattern));
ULXR_COUT << ULXR_PCHAR("struct1Pattern\n");
testPattern(struct1Pattern, sizeof(struct1Pattern));
ULXR_COUT << ULXR_PCHAR("struct2Pattern\n");
testPattern(struct2Pattern, sizeof(struct2Pattern));
ULXR_COUT << ULXR_PCHAR("arrayPattern\n");
testPattern(arrayPattern, sizeof(arrayPattern));
ULXR_COUT << ULXR_PCHAR("callPattern\n");
testCallPattern(callPattern, sizeof(callPattern));
ULXR_COUT << ULXR_PCHAR("emptyCallPattern\n");
testCallPattern(emptyCallPattern, sizeof(emptyCallPattern));
ULXR_COUT << ULXR_PCHAR("respPattern\n");
testRespPattern(respPattern, sizeof(respPattern));
ULXR_COUT << ULXR_PCHAR("implPattern\n");
testPattern(implPattern, sizeof(implPattern));
ULXR_COUT << ULXR_PCHAR("emptyArrayPattern\n");
testRespPattern(emptyArrayPattern, sizeof(emptyArrayPattern));
ULXR_COUT << ULXR_PCHAR("emptyRespPattern\n");
testRespPattern(emptyRespPattern, sizeof(emptyRespPattern));
ULXR_COUT << ULXR_PCHAR("emptyStructPattern\n");
testRespPattern(emptyStructPattern, sizeof(emptyStructPattern));
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ULXR_PCHAR("MethodResponse abc\n");
ulxr::MethodResponse mr1(123, ULXR_PCHAR("faultstr_m"));
ULXR_COUT << ulxr::binaryDebugOutput(mr1.getWbXml());
ULXR_COUT << std::endl << mr1.getXml(0) << std::endl;
ulxr::MethodResponse mr2(ulxr::Integer(1));
ULXR_COUT << ulxr::binaryDebugOutput(mr2.getWbXml());
ULXR_COUT << std::endl << mr2.getXml(0) << std::endl;
ulxr::MethodResponse mr3;
ULXR_COUT << ulxr::binaryDebugOutput(mr3.getWbXml());
ULXR_COUT << std::endl << mr3.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ulxr::MethodCall mc (ULXR_PCHAR("test.call"));
ULXR_COUT << ulxr::binaryDebugOutput(mc.getWbXml());
ULXR_COUT << std::endl << mc.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("====================================================\n");
ulxr::Boolean b(true);
ulxr::Integer i(123);
ulxr::Double d(123.456);
ulxr::RpcString s("<>&\"\'string<>&\"\'");
ulxr::DateTime dt(ULXR_PCHAR("20020310T10:23:45"));
ulxr::Base64 b64(ULXR_PCHAR("ABASrt466a90"));
ulxr::Struct st;
ulxr::Array ar;
ULXR_COUT << ulxr::binaryDebugOutput(b.getWbXml()) << std::endl;
ULXR_COUT << b.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(i.getWbXml()) << std::endl;
ULXR_COUT << i.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(d.getWbXml()) << std::endl;
ULXR_COUT << d.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(s.getWbXml()) << std::endl;
ULXR_COUT << s.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(dt.getWbXml()) << std::endl;
ULXR_COUT << dt.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(b64.getWbXml()) << std::endl;
ULXR_COUT << b64.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(st.getWbXml()) << std::endl;
ULXR_COUT << st.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(ar.getWbXml()) << std::endl;
ULXR_COUT << ar.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("====================================================\n");
ULXR_COUT << "wbToken_Value " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Value) << std::endl;
ULXR_COUT << "wbToken_Array " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Array) << std::endl;
ULXR_COUT << "wbToken_Data " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Data) << std::endl;
ULXR_COUT << "wbToken_Struct " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Struct) << std::endl;
ULXR_COUT << "wbToken_Member " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Member) << std::endl;
ULXR_COUT << "wbToken_Name " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Name) << std::endl;
ULXR_COUT << "wbToken_Boolean " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Boolean) << std::endl;
ULXR_COUT << "wbToken_Int " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Int) << std::endl;
ULXR_COUT << "wbToken_I4 " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_I4) << std::endl;
ULXR_COUT << "wbToken_Double " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Double) << std::endl;
ULXR_COUT << "wbToken_String " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_String) << std::endl;
ULXR_COUT << "wbToken_Base64 " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Base64) << std::endl;
ULXR_COUT << "wbToken_Date " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Date) << std::endl;
ULXR_COUT << std::endl;
ULXR_COUT << "wbToken_MethodCall " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_MethodCall) << std::endl;
ULXR_COUT << "wbToken_MethodName " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_MethodName) << std::endl;
ULXR_COUT << "wbToken_Params " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_Params) << std::endl;
ULXR_COUT << "wbToken_Param " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_Param) << std::endl;
ULXR_COUT << std::endl;
ULXR_COUT << "wbToken_MethodResponse " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_MethodResponse) << std::endl;
ULXR_COUT << "wbToken_Fault " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_Fault) << std::endl;
ULXR_COUT << "wbToken_Params " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_Params) << std::endl;
ULXR_COUT << "wbToken_Param " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_Param) << std::endl;
ULXR_COUT << std::endl;
ULXR_COUT << "wbToken_ValueParserLast "
<< ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_ValueParserLast) << std::endl;
ULXR_COUT << "wbToken_CallParserLast "
<< ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_CallParserLast) << std::endl;
ULXR_COUT << "wbToken_ResponseParserLast "
<< ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_ResponseParserLast) << std::endl;
}
catch(ulxr::Exception &ex)
{
ULXR_COUT << ULXR_PCHAR("Error occured: ")
<< ULXR_GET_STRING(ex.why()) << std::endl;
success= 1;
}
#ifdef STRESS_IT
}
#endif
return success;
}
#ifdef ULXR_ENABLE_GET_PEERNAME
pimpl->remotedata_len = sizeof(pimpl->remotedata);
if(getpeername(getHandle(),
(struct sockaddr *)&pimpl->remotedata,
&pimpl->remotedata_len)<0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not get peer data: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#ifdef __BORLANDC__
pimpl->remote_name = ULXR_PCHAR("<remote-host>"); // FIXME, not working
host = 0;
host;
#else
else
{
ULXR_TRACE(ULXR_PCHAR("/open.hostby ") << ULXR_GET_STRING(inet_ntoa(pimpl->remotedata.sin_addr))
<< ULXR_PCHAR(":") << HtmlFormHandler::makeNumber(ntohs(pimpl->remotedata.sin_port)));
#ifndef ULXR_OMIT_REENTRANT_PROTECTOR
Mutex::Locker lock(gethostbyaddrMutex);
#endif
struct hostent *host = 0;
#ifdef ULXR_ENABLE_DNS_LOOKUP
host = gethostbyaddr((char*)&pimpl->remotedata.sin_addr,
sizeof(pimpl->remotedata.sin_addr),
AF_INET);
#endif
if (0 == host)
{
ValueParser::testStartElement(const XML_Char* name, const XML_Char** /* atts */)
{
ULXR_TRACE(ULXR_PCHAR("ValueParser::testStartElement(const XML_Char*, const char**)")
<< ULXR_PCHAR("\n name: ")
<< ULXR_GET_STRING(name)
);
switch(getTopValueState()->getParserState() )
{
case eNone:
if (strcmp(name, "value") == 0)
states.push(new ValueState(eValue));
else
return false;
break;
case eValue:
if (strcmp(name, "array") == 0)
states.push(new ValueState(eArray));
else if (strcmp(name, "struct") == 0)
states.push(new ValueState(eStruct));
else if (strcmp(name, "boolean") == 0)
states.push(new ValueState(eBoolean));
else if (strcmp(name, "int") == 0)
states.push(new ValueState(eInt));
else if (strcmp(name, "i4") == 0)
states.push(new ValueState(eI4));
else if (strcmp(name, "double") == 0)
states.push(new ValueState(eDouble));
else if (strcmp(name, "string") == 0)
states.push(new ValueState(eString));
else if (strcmp(name, "base64") == 0)
states.push(new ValueState(eBase64));
else if (strcmp(name, "dateTime.iso8601") == 0)
states.push(new ValueState(eDate));
else
return false;
break;
case eStruct:
if (strcmp(name, "member") == 0)
{
if (getTopValueState()->getValue() == 0) // first closing member adds struct-item
getTopValueState()->takeValue(new Value(Struct()), false);
states.push(new MemberState(eMember, getTopValueState()->getValue()));
}
else
return false;
break;
case eMember:
if (strcmp(name, "name") == 0)
states.push(new ValueState(eName));
else if (strcmp(name, "value") == 0)
states.push(new ValueState(eValue));
else
return false;
break;
case eArray:
if (strcmp(name, "data") == 0)
states.push(new ArrayState(eData));
else
return false;
break;
case eData:
if (strcmp(name, "value") == 0) // closing value adds data-items
states.push(new ValueState(eValue));
else
return false;
break;
default:
return false;
}
return true;
}
ULXR_API_IMPL(void) TcpIpConnection::init(unsigned prt)
{
ULXR_TRACE(ULXR_PCHAR("init"));
#if defined(__WIN32__) && !defined (ULXR_NO_WSA_STARTUP)
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD( 2, 0 );
if (WSAStartup( wVersionRequested, &wsaData) != 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not initialize Windows sockets: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
#endif
pimpl->server_data = 0;
setTcpNoDelay(false);
pimpl->serverdomain = ULXR_PCHAR("");
pimpl->remote_name = ULXR_PCHAR("");
setTimeout(10);
pimpl->port = prt;
pimpl->hostdata_len = sizeof(pimpl->hostdata);
pimpl->remotedata_len = sizeof(pimpl->remotedata);
memset(&pimpl->hostdata, 0, sizeof(pimpl->hostdata));
memset(&pimpl->remotedata, 0, sizeof(pimpl->remotedata));
pimpl->hostdata.sin_port = htons(pimpl->port);
pimpl->hostdata.sin_family = AF_INET;
char buffer [1000];
memset(buffer, 0, sizeof(buffer));
int ret = gethostname(buffer, sizeof(buffer)-1);
if (ret != 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not get host name: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
pimpl->host_name = ULXR_GET_STRING(buffer);
#if defined(__SUN__)
long status = sysinfo(SI_SRPC_DOMAIN ,buffer, sizeof(buffer)-1);
if (status == -1)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not get domain name: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
if (buffer[0] != 0)
{
pimpl->host_name += ULXR_PCHAR(".");
pimpl->host_name += ULXR_GET_STRING(buffer);
}
#elif defined(__unix__) || defined(__CYGWIN__)
ret = getdomainname(buffer, sizeof(buffer)-1);
if (ret != 0)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not get domain name: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
if (buffer[0] != 0)
{
pimpl->host_name += ULXR_PCHAR(".");
pimpl->host_name += ULXR_GET_STRING(buffer);
}
#elif _WIN32
#ifndef ULXR_OMIT_REENTRANT_PROTECTOR
Mutex::Locker lock(gethostbynameMutex);
#endif
struct hostent *hostEntPtr = gethostbyname(getLatin1(pimpl->host_name).c_str());
if (!hostEntPtr)
throw ConnectionException(SystemError,
ulxr_i18n(ULXR_PCHAR("Could not get host+domain name: "))
+ ULXR_GET_STRING(getErrorString(getLastError())), 500);
pimpl->host_name = ULXR_GET_STRING(hostEntPtr->h_name);
#else
# pragma message ("don't know how to determine the domain name")
#endif
}
Requester::waitForResponse(Protocol *protocol, bool wbxml_mode)
{
ULXR_TRACE(ULXR_PCHAR("waitForResponse(Protocol, wbxml)"));
char buffer[ULXR_RECV_BUFFER_SIZE];
char *buff_ptr;
std::auto_ptr<XmlParserBase> parser;
MethodResponseParserBase *rpb = 0;
if (wbxml_mode)
{
ULXR_TRACE(ULXR_PCHAR("waitForResponse in WBXML"));
MethodResponseParserWb *rp = new MethodResponseParserWb();
rpb = rp;
#ifdef _MSC_VER
std::auto_ptr<XmlParserBase> temp(rp);
parser = temp;
#else
parser.reset(rp);
#endif
}
else
{
ULXR_TRACE(ULXR_PCHAR("waitForResponse in XML"));
MethodResponseParser *rp = new MethodResponseParser();
rpb = rp;
#ifdef _MSC_VER
std::auto_ptr<XmlParserBase> temp(rp);
parser = temp;
#else
parser.reset(rp);
#endif
}
bool done = false;
long readed;
while (!done && protocol->hasBytesToRead()
&& ((readed = protocol->readRaw(buffer, sizeof(buffer))) > 0) )
{
buff_ptr = buffer;
while (readed > 0)
{
Protocol::State state = protocol->connectionMachine(buff_ptr, readed);
if (state == Protocol::ConnError)
{
done = true;
throw ConnectionException(TransportError, ulxr_i18n(ULXR_PCHAR("network problem occured")), 400);
}
else if (state == Protocol::ConnSwitchToBody)
{
#ifdef ULXR_SHOW_READ
Cpp8BitString super_data (buff_ptr, readed);
while ((readed = protocol->readRaw(buffer, sizeof(buffer))) > 0)
super_data.append(buffer, readed);
ULXR_DOUT_READ(ULXR_PCHAR("superdata 3 start:\n"));
if (wbxml_mode)
{
ULXR_DOUT_READ(binaryDebugOutput(super_data));
}
else
{
ULXR_DOUT_READ(ULXR_GET_STRING(super_data));
}
ULXR_DOUT_READ(ULXR_PCHAR("superdata 3 end:\n") );
#endif
if (!protocol->hasBytesToRead())
{
throw ConnectionException(NotConformingError,
ulxr_i18n(ULXR_PCHAR("Content-Length of message not available")), 411);
}
CppString s;
if (!protocol->responseStatus(s))
throw ConnectionException(TransportError, s, 500);
}
else if (state == Protocol::ConnBody)
{
ULXR_DOUT_XML(ULXR_GET_STRING(std::string(buff_ptr, readed)));
if (!parser->parse(buff_ptr, readed, false))
{
throw XmlException(parser->mapToFaultCode(parser->getErrorCode()),
ulxr_i18n(ULXR_PCHAR("Problem while parsing xml response")),
parser->getCurrentLineNumber(),
ULXR_GET_STRING(parser->getErrorString(parser->getErrorCode())));
}
readed = 0;
}
}
if (!protocol->hasBytesToRead())
// || parser->isComplete())
done = true;
}
if (protocol->isOpen() && !protocol->isPersistent() )
protocol->close();
return rpb->getMethodResponse();
}
int main(int argc, char * argv [])
{
try
{
ulxr::intializeLog4J(argv[0]);
ULXR_COUT << ULXR_PCHAR("sizeof(<string>): " << sizeof(ulxr::Char) << std::endl);
ulxr_time_t tim = ulxr_time(0);
ulxr::DateTime dt(tim);
ULXR_COUT << ULXR_PCHAR("Current time as DateTime: ") << dt.getDateTime() << std::endl;
ulxr::CppString s0;
for (unsigned ii = 0; ii < 256; ++ii)
s0 += ii;
// ULXR_COUT << s0 << std::endl;
ulxr::CppString regression =
ULXR_PCHAR("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1\r\n")
ULXR_PCHAR("Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWpr\r\n")
ULXR_PCHAR("bG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6Ch\r\n")
ULXR_PCHAR("oqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX\r\n")
ULXR_PCHAR("2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==\r\n");
ULXR_COUT << ULXR_PCHAR("Encode 64\n");
ulxr::CppString s64 = ulxr::encodeBase64(s0);
ULXR_COUT << s64 << std::endl;
if (regression != s64)
{
ULXR_COUT << ULXR_PCHAR("Encode64 comparison with regression string failed.\n");
success = false;
}
else
ULXR_COUT << ULXR_PCHAR("Encode64 comparison with regression string OK.\n");
ULXR_COUT << ULXR_PCHAR("Decode 64\n");
ulxr::CppString ss = ulxr::decodeBase64(s64);
// ULXR_COUT << ss << std::endl;
if (s0 == ss)
ULXR_COUT << ULXR_PCHAR("base ok\n");
else
{
ULXR_COUT << ULXR_PCHAR("base NOT ok\n");
success = false;
}
// ����
s0 = ULXR_PCHAR("-\r=\t#\n+&<>;12����\"\'contains");
ulxr::CppString se = ulxr::xmlEscape(s0);
std::cout << std::hex << "s0: ";
for (unsigned i1 = 0; i1 < s0.length(); ++i1)
std::cout << (unsigned) (0xff & s0[i1]) << " ";
std::cout << std::endl;
std::cout << std::hex << "se: ";
for (unsigned i2 = 0; i2 < se.length(); ++i2)
std::cout << (unsigned) (0xff & se[i2]) << " ";
std::cout << std::dec << std::endl;
if (se.find(ULXR_PCHAR("contains")) == ulxr::CppString::npos)
{
ULXR_COUT << ULXR_PCHAR("xmlEscape NOT ok\n");
success = false;
}
else
ULXR_COUT << ULXR_PCHAR("xmlEscape ok\n");
ULXR_COUT << ULXR_PCHAR("Original: ") << s0 << std::endl;
ULXR_COUT << ULXR_PCHAR("Escaped: ") << se << std::endl;
if (s0 == ulxr::xmlUnEscape(se))
ULXR_COUT << ULXR_PCHAR("escape ok\n");
else
{
ULXR_COUT << ULXR_PCHAR("escape NOT ok\n");
success = false;
}
{
check_malformed(ULXR_PCHAR("abcd&"));
check_malformed(ULXR_PCHAR("abcd"));
check_malformed(ULXR_PCHAR("abcd"));
check_malformed(ULXR_PCHAR("abcd�"));
check_malformed(ULXR_PCHAR("abcd�"));
check_malformed(ULXR_PCHAR("abcd�"));
check_malformed(ULXR_PCHAR("abcd�"));
}
#if defined(HAVE_ICONV_H) || defined(HAVE_ICONV)
ulxr::Cpp8BitString s_lat1 = "������{}[]/'����������{}[]/'����";
ulxr::Cpp8BitString s02 = ulxr::encodingToUtf8(s_lat1, "LATIN1");
ULXR_COUT << ULXR_PCHAR("s02: ") << ULXR_GET_STRING(s02) << std::endl;
ULXR_COUT << ULXR_PCHAR("s_lat1: ") << ULXR_GET_STRING(s_lat1) << std::endl;
ULXR_COUT << ULXR_PCHAR("back to orig: ")
<< ULXR_GET_STRING(ulxr::utf8ToEncoding(s02, "LATIN1"))
<< std::endl;
if (s_lat1 == ulxr::utf8ToEncoding(s02, "LATIN1"))
ULXR_COUT << ULXR_PCHAR("encoding ok\n");
else
ULXR_COUT << ULXR_PCHAR("encoding NOT ok\n");
#endif
#ifdef ULXR_UNICODE
ulxr::Cpp16BitString ws0;
ws0.reserve(0xd800);
for (unsigned i = 0x00; i < 0xd800; ++i)
ws0 += i;
ulxr::RpcString str (ws0);
ss = str.getString();
ULXR_COUT << ss.length() << std::endl;
ulxr::Cpp16BitString wss = str.getUnicodeString();
ULXR_COUT << ws0.length() << std::endl;
ULXR_COUT << (int) ws0[0] << std::endl;
ULXR_COUT << wss.length() << std::endl;
ULXR_COUT << (int) wss[0] << std::endl;
if (ws0 == wss)
ULXR_COUT << ULXR_PCHAR("unicode 1 ok\n");
else
{
ULXR_COUT << ULXR_PCHAR("unicode 1 NOT ok\n");
success = false;
}
{
ulxr::Cpp8BitString utf8 = ulxr::unicodeToUtf8(ws0);
wss = ulxr::utf8ToUnicode(utf8);
if (ws0 == wss)
ULXR_COUT << ULXR_PCHAR("unicodeToUtf8 ok\n");
else
{
ULXR_COUT << ULXR_PCHAR("utf8ToUnicode NOT ok\n");
success = false;
}
}
#endif
{
ulxr::Cpp8BitString s8;
s8.reserve(0x100);
for (unsigned i = 0x00; i < 0x100; ++i)
s8 += i;
ulxr::Cpp8BitString utf8 = ulxr::asciiToUtf8(s8);
ulxr::Cpp8BitString s8s = ulxr::utf8ToAscii(utf8);
if (s8 == s8s)
ULXR_COUT << ULXR_PCHAR("asciiToUtf8 ok\n");
else
{
ULXR_COUT << ULXR_PCHAR("utf8ToAscii NOT ok\n");
success = false;
}
}
#ifdef ULXR_UNICODE
ws0 = ULXR_PCHAR("khera>&sd< asd<f>e56&&& \"$����")
ULXR_PCHAR("\"\"\'&<&>sd w45234908 0xd9f0�)/()/")
ULXR_PCHAR("()N u6we4\"E!\"%&((>YXC>YXASESGYDX>YVBHJE%W&TW$");
ulxr::RpcString str2 (ws0);
ss = str2.getString();
wss = str2.getUnicodeString();
if (ws0 == wss)
ULXR_COUT << ULXR_PCHAR("unicode ok\n");
else
{
ULXR_COUT << ULXR_PCHAR("unicode NOT ok\n");
success = false;
}
#endif
ULXR_COUT << ULXR_PCHAR("Ready.\n");
}
catch(ulxr::Exception &ex)
{
ULXR_COUT << ULXR_PCHAR("Error occured: ")
<< ULXR_GET_STRING(ex.why()) << std::endl;
success = false;
}
ULXR_COUT << ULXR_PCHAR("Terminating.\n");
return success ? 0 : 1;
}
