LucidaServiceClient *TClient::creatLucidaClient(string host, int port) {
boost::shared_ptr<TTransport> socket(new TSocket(host, port));
boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
LucidaServiceClient *client = new LucidaServiceClient(protocol);
transport->open();
return client;
}
CommandDef *JabberClient::configWindows()
{
QString name = i18n(protocol()->description()->text);
name += " ";
name += QString::fromUtf8(data.owner.ID);
cfgJabberWnd[0].text_wrk = strdup(name.utf8());
return cfgJabberWnd;
}
already_AddRefed<nsITransportProvider>
HttpServer::Connection::HandleAcceptWebSocket(const Optional<nsAString>& aProtocol,
ErrorResult& aRv)
{
MOZ_ASSERT(mPendingWebSocketRequest);
RefPtr<InternalResponse> response =
new InternalResponse(101, NS_LITERAL_CSTRING("Switching Protocols"));
InternalHeaders* headers = response->Headers();
headers->Set(NS_LITERAL_CSTRING("Upgrade"),
NS_LITERAL_CSTRING("websocket"),
aRv);
headers->Set(NS_LITERAL_CSTRING("Connection"),
NS_LITERAL_CSTRING("Upgrade"),
aRv);
if (aProtocol.WasPassed()) {
NS_ConvertUTF16toUTF8 protocol(aProtocol.Value());
nsAutoCString reqProtocols;
mPendingWebSocketRequest->Headers()->
GetFirst(NS_LITERAL_CSTRING("Sec-WebSocket-Protocol"), reqProtocols, aRv);
if (!ContainsToken(reqProtocols, protocol)) {
// Should throw a better error here
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
headers->Set(NS_LITERAL_CSTRING("Sec-WebSocket-Protocol"),
protocol, aRv);
}
nsAutoCString key, hash;
mPendingWebSocketRequest->Headers()->
GetFirst(NS_LITERAL_CSTRING("Sec-WebSocket-Key"), key, aRv);
nsresult rv = mozilla::net::CalculateWebSocketHashedSecret(key, hash);
if (NS_FAILED(rv)) {
aRv.Throw(rv);
return nullptr;
}
headers->Set(NS_LITERAL_CSTRING("Sec-WebSocket-Accept"), hash, aRv);
nsAutoCString extensions, negotiatedExtensions;
mPendingWebSocketRequest->Headers()->
GetFirst(NS_LITERAL_CSTRING("Sec-WebSocket-Extensions"), extensions, aRv);
mozilla::net::ProcessServerWebSocketExtensions(extensions,
negotiatedExtensions);
if (!negotiatedExtensions.IsEmpty()) {
headers->Set(NS_LITERAL_CSTRING("Sec-WebSocket-Extensions"),
negotiatedExtensions, aRv);
}
RefPtr<TransportProvider> result = new TransportProvider();
mWebSocketTransportProvider = result;
QueueResponse(response);
return result.forget();
}
inline void complexThrift_6()
{
boost::timer::auto_cpu_timer t;
thriftPerformance::complexThrift_6 input = thriftPerformance::complexThrift_6(), output;
input.__set_att1(1);
input.__set_att2(2);
input.__set_att3(3);
input.__set_att4(4);
input.__set_att5(5);
input.__set_att6(6);
input.__set_att1(0);
input.__set_att2(1);
input.__set_att3(2);
input.__set_att4(3);
input.__set_att5(4);
input.__set_att6(5);
input.__set_att7(0);
input.__set_att8(1);
input.__set_att9(2);
input.__set_att10(3);
input.__set_att11(4);
input.__set_att12(5);
input.__set_att13("TEST 0");
input.__set_att14("TEST 1");
input.__set_att15("TEST 2");
input.__set_att16("TEST 3");
input.__set_att17("TEST 4");
input.__set_att18("TEST 5");
input.__set_att19(2.0);
input.__set_att20(3.1);
input.__set_att21(4.2);
input.__set_att22(5.3);
input.__set_att23(6.4);
input.__set_att24(7.5);
input.__set_att25(8.5);
input.__set_att26(9.6);
input.__set_att27(10.7);
input.__set_att28(11.8);
input.__set_att29(12.9);
input.__set_att30(13.10);
input.__set_att31(true);
input.__set_att32(true);
input.__set_att33(true);
input.__set_att34(true);
input.__set_att35(true);
input.__set_att36(true);
boost::shared_ptr<TMemoryBuffer> mb(new TMemoryBuffer(500));
boost::shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(mb));
for(int i = 0; i < NUMBER_OF_LOOPS; ++i)
{
mb->resetBuffer();
input.write(protocol.get());
output.read(protocol.get());
}
}
void AIMContact::updateSSIItem()
{
if ( m_ssiItem.type() != 0xFFFF && m_ssiItem.waitingAuth() == false &&
onlineStatus() == Kopete::OnlineStatus::Unknown )
{
//make sure they're offline
setOnlineStatus( static_cast<AIMProtocol*>( protocol() )->statusOffline );
}
}
inline void innercomplexThrift_2()
{
boost::timer::auto_cpu_timer t;
thriftPerformance::innercomplexThrift_2 inner1 = thriftPerformance::innercomplexThrift_2();
inner1.__set_att1(1);
inner1.__set_att2(2);
inner1.__set_att3(3);
inner1.__set_att4(4);
inner1.__set_att5("TEST 5");
inner1.__set_att6("TEST 6");
inner1.__set_att7(2.5);
inner1.__set_att8(3.6);
inner1.__set_att9(6.2);
inner1.__set_att10(7.3);
inner1.__set_att11(true);
inner1.__set_att12(true);
thriftPerformance::innercomplexThrift_2 inner2 = thriftPerformance::innercomplexThrift_2();
inner2.__set_att1(1);
inner2.__set_att2(2);
inner2.__set_att3(3);
inner2.__set_att4(4);
inner2.__set_att5("TEST 5");
inner2.__set_att6("TEST 6");
inner2.__set_att7(2.5);
inner2.__set_att8(3.6);
inner2.__set_att9(6.2);
inner2.__set_att10(7.3);
inner2.__set_att11(true);
inner2.__set_att12(true);
thriftPerformance::outercomplexThrift_2 input = thriftPerformance::outercomplexThrift_2(), output = thriftPerformance::outercomplexThrift_2();
input.__set_att1(1);
input.__set_att2(2);
input.__set_att3("OUTER TEST 3");
input.__set_att4(inner1);
input.__set_att5(3.6);
input.__set_att6(7.3);
input.__set_att7(true);
input.__set_att8(8);
input.__set_att9("OUTER TEST 9");
input.__set_att10(inner2);
input.__set_att11(4.7);
input.__set_att12(8.4);
input.__set_att13(true);
boost::shared_ptr<TMemoryBuffer> mb(new TMemoryBuffer(500));
boost::shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(mb));
for(int i = 0; i < NUMBER_OF_LOOPS; ++i)
{
mb->resetBuffer();
input.write(protocol.get());
output.read(protocol.get());
}
}
Kopete::ChatSession *
WlmContact::manager (Kopete::Contact::CanCreateFlags canCreate)
{
Kopete::ContactPtrList chatmembers;
chatmembers.append (this);
Kopete::ChatSession * _manager =
Kopete::ChatSessionManager::self ()->
findChatSession (account ()->myself (), chatmembers, protocol ());
WlmChatSession *manager = qobject_cast <WlmChatSession *>(_manager);
if (!manager && canCreate == Kopete::Contact::CanCreate)
{
manager =
new WlmChatSession (protocol (), account ()->myself (),
chatmembers);
}
return manager;
}
boost::tuple<std::string, std::string, std::string, std::string>
HttpRequest::ParseUrl(const std::string & url)
{
//for remove regex lib
size_t pos_protocol = url.find("://");
std::string protocol("http");
if (pos_protocol != std::string::npos)
{
protocol = url.substr(0, pos_protocol);
}
size_t pos_host_beg = (pos_protocol == std::string::npos ? 0 : pos_protocol +3);
size_t pos_path_beg = -1;
std::string host_str("");
std::string port_str("80");
size_t pos_host = url.find_first_of(':', pos_host_beg);
size_t pos_slash = url.find_first_of('/', pos_host_beg);
if (pos_host != std::string::npos && pos_host < pos_slash)
{
host_str = url.substr(pos_host_beg, pos_host - pos_host_beg);
size_t pos_port_beg = pos_host + 1;
size_t pos_port = url.find_first_of('/', pos_port_beg);
if (pos_port != std::string ::npos)
{
port_str = url.substr(pos_port_beg, pos_port - pos_port_beg);
pos_path_beg = pos_port;
}
}
else {
pos_host = url.find_first_of('/', pos_host_beg);
if (pos_host != std::string::npos)
{
host_str = url.substr(pos_host_beg, pos_host - pos_host_beg);
pos_path_beg = pos_host;
}
}
std::string path_str("");
if (pos_path_beg > 0)
path_str = url.substr(pos_path_beg);
//boost::regex reg("^(([A-Za-z]+)://)?([^:/]+)(:([0-9]+))?(.*)");
//boost::smatch sm;
//if (false == boost::regex_match(url, sm, reg))
//{
// return boost::make_tuple("", "", "", "");
//}
//std::string protocol(sm[2].matched ? std::string(sm[2].first, sm[2].second) : "http");
//std::string host_str(sm[3].first, sm[3].second);
//std::string port_str(sm[5].matched ? std::string(sm[5].first, sm[5].second) : "");
//std::string path_str(sm[6].matched ? std::string(sm[6].first, sm[6].second) : "/");
if (path_str.empty()) path_str = "/";
return boost::make_tuple(protocol, host_str, port_str, path_str);
}
CommandDef *JabberClient::infoWindows(Contact*, void *_data)
{
JabberUserData *data = (JabberUserData*)_data;
QString name = i18n(protocol()->description()->text);
name += " ";
name += QString::fromUtf8(data->ID);
jabberWnd[0].text_wrk = strdup(name.utf8());
return jabberWnd;
}
SchedulerServiceClient *TClient::creatSchedulerClient(string host, int port) {
boost::shared_ptr<TSocket> socket(new TSocket(host, port));
boost::shared_ptr<TTransport> transport(new TFramedTransport(socket));
boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
SchedulerServiceClient *client = new SchedulerServiceClient(protocol);
this->transport = transport;
transport->open();
return client;
}
QString JabberClient::contactTip(void *_data)
{
JabberUserData *data = (JabberUserData*)_data;
QString res;
QString statusText;
unsigned long status = STATUS_OFFLINE;
unsigned style = 0;
const char *statusIcon = NULL;
contactInfo(data, status, style, statusIcon);
if (statusIcon){
res += "<img src=\"icon:";
res += statusIcon;
res += "\">";
for (const CommandDef *cmd = protocol()->statusList(); cmd->text; cmd++){
if (!strcmp(cmd->icon, statusIcon)){
res += " ";
statusText += i18n(cmd->text);
res += statusText;
break;
}
}
res += "<br>";
}
res += "ID: <b>";
res += QString::fromUtf8(data->ID);
res += "</b>";
if (data->Status == STATUS_OFFLINE){
if (data->StatusTime){
res += "<br><font size=-1>";
res += i18n("Last online");
res += ": </font>";
res += formatTime(data->StatusTime);
}
}else{
if (data->OnlineTime){
res += "<br><font size=-1>";
res += i18n("Online");
res += ": </font>";
res += formatTime(data->OnlineTime);
}
if (data->StatusTime != data->OnlineTime){
res += "<br><font size=-1>";
res += statusText;
res += ": </font>";
res += formatTime(data->StatusTime);
}
}
if (data->Resource && *data->Resource){
res += "<br>";
res += QString::fromUtf8(data->Resource);
}
if (data->AutoReply && *data->AutoReply){
res += "<br><br>";
res += QString::fromUtf8(data->AutoReply);
}
return res;
}
CommandDef *YahooClient::infoWindows(Contact*, void *_data)
{
YahooUserData *data = (YahooUserData*)_data;
QString name = i18n(protocol()->description()->text);
name += " ";
name += QString::fromUtf8(data->Login.ptr);
yahooWnd[0].text_wrk = strdup(name.utf8());
return yahooWnd;
}
inline void simpleThrift_40()
{
thriftPerformance::simpleThrift_40 input = thriftPerformance::simpleThrift_40(), output;
input.__set_att1(1);
input.__set_att2(2);
input.__set_att3(3);
input.__set_att4(4);
input.__set_att5(5);
input.__set_att6(6);
input.__set_att7(7);
input.__set_att8(8);
input.__set_att9(9);
input.__set_att10(10);
input.__set_att11(11);
input.__set_att12(12);
input.__set_att13(13);
input.__set_att14(14);
input.__set_att15(15);
input.__set_att16(16);
input.__set_att17(17);
input.__set_att18(18);
input.__set_att19(19);
input.__set_att20(20);
input.__set_att21(21);
input.__set_att22(22);
input.__set_att23(23);
input.__set_att24(24);
input.__set_att25(25);
input.__set_att26(26);
input.__set_att27(27);
input.__set_att28(28);
input.__set_att29(29);
input.__set_att30(30);
input.__set_att31(31);
input.__set_att32(32);
input.__set_att33(33);
input.__set_att34(34);
input.__set_att35(35);
input.__set_att36(36);
input.__set_att37(37);
input.__set_att38(38);
input.__set_att39(39);
input.__set_att40(40);
boost::shared_ptr<TMemoryBuffer> mb(new TMemoryBuffer(500));
boost::shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(mb));
boost::timer::auto_cpu_timer t;
for(int i = 0; i < NUMBER_OF_LOOPS; ++i)
{
mb->resetBuffer();
input.write(protocol.get());
output.read(protocol.get());
}
}
void ut_cstunbinding::SetupL( )
{
iCallbackCalled = EFalse;
TUint iapID( 6 );
TInt retransmitInterval( 10 );
TBufC8<13> serveraddress( KServerAddress );
TUint serverport( 2000 );
TBufC8<4> protocol( KStun );
TBool obtainsharedsecret( EFalse );
TBool failifnoSRVrecordfound( EFalse );
iDeltatimer = CDeltaTimer::NewL( 1 );
User::LeaveIfError( iSocketServ.Connect() );
iStreamId = 1;
iSubstreamId = 1;
TBool icmpUsed( EFalse );
iMux = CNcmConnectionMultiplexer::NewL( *this );
TCommDbConnPref pref;
pref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
pref.SetIapId( iapID );
User::LeaveIfError( iConnection.Open( iSocketServ ) );
iConnection.Start( pref, iStatus );
User::WaitForRequest( iStatus );
User::LeaveIfError( iStatus.Int() );
iStunclient = CSTUNClient::NewL( retransmitInterval,
serveraddress,
serverport,
protocol,
iSocketServ,
iConnection,
*iDeltatimer,
*this,
obtainsharedsecret,
failifnoSRVrecordfound,
icmpUsed,
iMux );
if ( ut_cstunbinding::iActiveSchedulerWait.IsStarted() )
{
ut_cstunbinding::iActiveSchedulerWait.AsyncStop();
}
ut_cstunbinding::iActiveSchedulerWait.Start();
if ( !iCallbackCalled )
{
// Callback not called because of memory running out inside callback execution
User::Leave( KErrNoMemory );
}
User::LeaveIfError( iSocket.Open( iSocketServ, KAfInet, KSockDatagram,
KProtocolInetUdp ));
iBinding = CSTUNBinding::NewL( *iStunclient, iSocket );
}
NOEXPORT void client_try(CLI *c) {
init_local(c);
if(!c->opt->option.client && c->opt->protocol<0
#ifndef OPENSSL_NO_TLSEXT
&& !c->opt->servername_list_head
#endif
) {
/* server mode and no protocol negotiation needed */
init_ssl(c);
init_remote(c);
} else { /* client mode or protocol negotiation enabled */
protocol(c, PROTOCOL_PRE_CONNECT);
init_remote(c);
protocol(c, PROTOCOL_PRE_SSL);
init_ssl(c);
protocol(c, PROTOCOL_POST_SSL);
}
transfer(c);
}
KURL NetworkAccount::getUrl() const
{
KURL url;
url.setProtocol(protocol());
url.setUser(login());
url.setPass(passwd());
url.setHost(host());
url.setPort(port());
return url;
}
NS_IMETHODIMP
nsGNOMEShellService::SetDefaultClient(bool aForAllUsers,
bool aClaimAllTypes, uint16_t aApps)
{
nsresult rv;
nsCOMPtr<nsIGIOMimeApp> app;
nsCOMPtr<nsIGIOService> giovfs = do_GetService(NS_GIOSERVICE_CONTRACTID);
if (giovfs) {
nsCString brandName;
rv = GetBrandName(brandName);
NS_ENSURE_SUCCESS(rv, rv);
rv = giovfs->CreateAppFromCommand(mAppPath, brandName, getter_AddRefs(app));
NS_ENSURE_SUCCESS(rv, rv);
for (unsigned i = 0; i < mozilla::ArrayLength(gMimeTypes); i++) {
if (aApps & gMimeTypes[i].app) {
rv = app->SetAsDefaultForMimeType(nsDependentCString(gMimeTypes[i].mimeType));
NS_ENSURE_SUCCESS(rv, rv);
rv = app->SetAsDefaultForFileExtensions(nsDependentCString(gMimeTypes[i].extensions));
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
nsCString appKeyValue;
nsCOMPtr<nsIGConfService> gconf = do_GetService(NS_GCONFSERVICE_CONTRACTID);
if (gconf) {
if (!mAppIsInPath)
appKeyValue = mAppPath;
else {
gchar* basename = g_path_get_basename(mAppPath.get());
appKeyValue = basename;
g_free(basename);
}
appKeyValue.AppendLiteral(" %s");
}
for (unsigned i = 0; i < mozilla::ArrayLength(gProtocols); i++) {
if (aApps & gProtocols[i].app) {
nsDependentCString protocol(gProtocols[i].protocol);
if (app) {
rv = app->SetAsDefaultForURIScheme(protocol);
NS_ENSURE_SUCCESS(rv, rv);
}
if (gconf) {
rv = gconf->SetAppForProtocol(protocol, appKeyValue);
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
return NS_OK;
}
SegmentType IPv6Packet<FrameType>::segmentType() const {
switch (protocol()) {
case IPPROTO_TCP:
return SEGMENT_TCP;
case IPPROTO_UDP:
return SEGMENT_UDP;
}
return SEGMENT_UNKNOWN;
}
int main( int ac, char** av )
{
comma::command_line_options options( ac, av, usage );
try
{
raw=options.exists("--raw");
timestamp=options.exists("--timestamp");
if(options.exists("--output-size"))
{
std::size_t size=snark::asd::commands::acquire_data::spectrum_data::size;
if (timestamp) { size += sizeof(boost::posix_time::ptime);}
std::cout<< size << std::endl;
return 0;
}
if(timestamp && !raw) { COMMA_THROW(comma::exception, "--timestamp option only works with --raw");}
comma::verbose<<"asd-control"<<std::endl;
std::vector<std::string> unnamed=options.unnamed("--verbose,-v,--raw,--timestamp,--strict,--acquire,--omit-new-line", "--timeout,--sleep");
if(unnamed.size() != 1) { COMMA_THROW(comma::exception, "expected address (one unnamed arg); got " << unnamed.size() ); }
strict=options.exists("--strict");
acquire=options.exists("--acquire");
bool omit_new_line=options.exists("--omit-new-line");
snark::asd::protocol protocol(unnamed[0], options.value("--timeout",0));
sleep_seconds=options.value("--sleep",0);
while(std::cin.good())
{
//comma::verbose<<"reading stdin..."<<std::endl;
std::string cmd;
std::getline( std::cin, cmd );
if( cmd.empty() ) { continue; }
if(!omit_new_line) { cmd += '\n'; }
comma::verbose<<"sending command: "<<cmd<<std::endl;
bool processed = process_acquire_data(protocol,cmd)
|| app<snark::asd::commands::version>::process(protocol,cmd)
|| app<snark::asd::commands::abort>::process(protocol,cmd)
|| app<snark::asd::commands::restore>::process(protocol,cmd)
|| app<snark::asd::commands::optimize>::process(protocol,cmd)
|| app<snark::asd::commands::init>::process(protocol,cmd)
|| app<snark::asd::commands::save>::process(protocol,cmd)
|| app<snark::asd::commands::erase>::process(protocol,cmd)
|| app<snark::asd::commands::instrument_gain_control>::process(protocol,cmd);
if ( !processed ) { COMMA_THROW(comma::exception, "invalid command " << cmd ); }
}
return 0;
}
catch( std::exception& ex )
{
std::cerr << comma::verbose.app_name() << ": " << ex.what() << std::endl;
}
catch( ... )
{
std::cerr << comma::verbose.app_name() << ": " << "unknown exception" << std::endl;
}
return 1;
}
void WirelessNode_Impl::erase()
{
//call the node_erase command from the parent BaseStation
bool success = m_baseStation.node_erase(protocol(), m_address);
//if the erase command failed
if(!success)
{
throw Error_NodeCommunication(m_address, "Failed to erase the Node.");
}
}
QString CEndPoint::toStringWithPort() const
{
if ( protocol() == QAbstractSocket::IPv4Protocol )
{
return toString().append( QString( ":%1" ).arg( m_nPort ) );
}
else
{
return QString( "[%1]:%2" ).arg( toString() ).arg( m_nPort );
}
}
void JabberClient::packet_ready()
{
if (m_socket->readBuffer.writePos() == 0)
return;
JabberPlugin *plugin = static_cast<JabberPlugin*>(protocol()->plugin());
log_packet(m_socket->readBuffer, false, plugin->JabberPacket);
if (XML_Parse(m_parser,
m_socket->readBuffer.data(), m_socket->readBuffer.writePos(), false) != XML_STATUS_OK)
m_socket->error_state("XML parse error");
m_socket->readBuffer.init(0);
m_socket->readBuffer.packetStart();
}
LogStream*
LogStreamFactory::create (FiltersFactory* ff, string location,
list<string>& filters, u_long cycle)
{
string protocol (getProtocol (location));
string path (getPath (location));
if (protocolCheck (protocol))
{
return creators[protocol]->create (ff, path, filters, cycle);
}
return 0;
}
AIMContact::AIMContact( Kopete::Account* account, const QString& name, Kopete::MetaContact* parent,
const QString& icon )
: AIMContactBase(account, name, parent, icon )
{
mProtocol=static_cast<ICQProtocol *>(protocol());
setPresenceTarget( Oscar::Presence( Oscar::Presence::Offline, Oscar::Presence::AIM ) );
QObject::connect( mAccount->engine(), SIGNAL(receivedUserInfo(QString,UserDetails)),
this, SLOT(userInfoUpdated(QString,UserDetails)) );
QObject::connect( mAccount->engine(), SIGNAL(userIsOffline(QString)),
this, SLOT(userOffline(QString)) );
}
NodeEeprom& WirelessNode_Impl::eeprom() const
{
//if the eeprom variable hasn't been set yet
if(m_eeprom == NULL)
{
//create the eeprom variable
//Note that this requires communicating with the Node via the protocol() function
m_eeprom.reset(new NodeEeprom(m_address, m_baseStation, protocol(), m_eepromSettings));
}
return *(m_eeprom.get());
}
/*!
* \brief Open connection to Cassandra cluster
* \param db_id
*/
oac::CassandraClient* dbcassa_open(struct db_id* id)
{
try {
boost::shared_ptr<att::TSocket> socket(new att::TSocket(id->host, id->port));
boost::shared_ptr<att::TTransport> transport(new att::TFramedTransport (socket));
boost::shared_ptr<atp::TProtocol> protocol(new atp::TBinaryProtocol(transport));
socket->setConnTimeout(cassa_conn_timeout);
socket->setSendTimeout(cassa_send_timeout);
socket->setRecvTimeout(cassa_recv_timeout);
std::auto_ptr<oac::CassandraClient> cassa_client(new oac::CassandraClient(protocol));
transport->open();
if (!transport->isOpen()) {
LM_ERR("Failed to open transport to Cassandra\n");
return 0;
}
/* database name -> keyspace */
cassa_client->set_keyspace(id->database);
if(id->username && id->password) {
oac::AuthenticationRequest au_req;
std::map<std::string, std::string> cred;
cred.insert(std::pair<std::string, std::string>("username", id->username));
cred.insert(std::pair<std::string, std::string>("password", id->password));
au_req.credentials = cred;
try {
cassa_client->login(au_req);
} catch (const oac::AuthenticationException& autx) {
LM_ERR("Authentication failure: Credentials not valid, %s\n", autx.why.c_str());
} catch (const oac::AuthorizationException & auzx) {
LM_ERR("Authentication failure: Credentials not valid for the selected database, %s\n", auzx.why.c_str());
}
}
LM_DBG("Opened connection to Cassandra cluster %s:%d\n", id->host, id->port);
return cassa_client.release();
} catch (const oac::InvalidRequestException &irx) {
LM_ERR("Database does not exist %s, %s\n", id->database, irx.why.c_str());
} catch (const at::TException &tx) {
LM_ERR("Failed to open connection to Cassandra cluster %s:%d, %s\n",
id->database, id->port, tx.what());
} catch (const std::exception &ex) {
LM_ERR("Failed: %s\n", ex.what());
} catch (...) {
LM_ERR("Failed to open connection to Cassandra cluster\n");
}
return 0;
}
std::auto_ptr<BackupProtocolCallable> connect_to_bbstored(TLSContext& rContext)
{
// Make a protocol
std::auto_ptr<BackupProtocolCallable> protocol(new
BackupProtocolClient(open_conn("localhost", rContext)));
// Check the version
std::auto_ptr<BackupProtocolVersion> serverVersion(
protocol->QueryVersion(BACKUP_STORE_SERVER_VERSION));
TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION);
return protocol;
}
QString Cloud::debugInfo() const
{
QString info;
info += QLatin1String("### Cloud: ###################\n");
if (!domain().isNull()) {
info += QLatin1String("domain: #") + domain() + QLatin1String("#\n");
}
if (port() != -1) {
info += QLatin1String("port: #") + QString::number(port()) + QLatin1String("#\n");
}
if (!path().isNull()) {
info += QLatin1String("path: #") + path() + QLatin1String("#\n");
}
if (!registerProcedure().isNull()) {
info += QLatin1String("registerProcedure: #") + registerProcedure() + QLatin1String("#\n");
}
if (!protocol().isNull()) {
info += QLatin1String("protocol: #") + protocol() + QLatin1String("#\n");
}
info += QLatin1String("### Cloud end ################\n");
return info;
}
uint32_t CConnection::sendProtocol(
const EMessageType type, const std::shared_ptr<IMessage>& message)
{
uint16_t idConcentrator = NEngine::CConfigurationFactory::getInstance()->getIdConcentrator();
CProtocol protocol(VERSION, 0,
idConcentrator,
++idPackageBase, type, message);
thread.addToSendingQueue(protocol);
return idPackageBase;
}
void YahooClient::contactInfo(void *_data, unsigned long &status, unsigned&, const char *&statusIcon, string *icons)
{
YahooUserData *data = (YahooUserData*)_data;
unsigned cmp_status = STATUS_OFFLINE;
switch (data->Status.value) {
case YAHOO_STATUS_AVAILABLE:
cmp_status = STATUS_ONLINE;
break;
case YAHOO_STATUS_BUSY:
cmp_status = STATUS_DND;
break;
case YAHOO_STATUS_NOTATHOME:
case YAHOO_STATUS_NOTATDESK:
case YAHOO_STATUS_NOTINOFFICE:
case YAHOO_STATUS_ONVACATION:
cmp_status = STATUS_NA;
break;
case YAHOO_STATUS_OFFLINE:
break;
case YAHOO_STATUS_CUSTOM:
cmp_status = data->bAway.bValue ? STATUS_AWAY : STATUS_ONLINE;
break;
default:
cmp_status = STATUS_AWAY;
}
const CommandDef *def;
for (def = protocol()->statusList(); def->text; def++) {
if (def->id == cmp_status)
break;
}
if (cmp_status > status) {
status = cmp_status;
if (statusIcon && icons) {
string iconSave = *icons;
*icons = statusIcon;
if (iconSave.length())
addIcon(icons, iconSave.c_str(), statusIcon);
}
statusIcon = def->icon;
} else {
if (statusIcon) {
addIcon(icons, def->icon, statusIcon);
} else {
statusIcon = def->icon;
}
}
if (icons && data->bTyping.bValue)
addIcon(icons, "typing", statusIcon);
}
