//------------------------------------------------------------------------------
void ServerFiber::registerClient()
{
if( serverType_ != stStandalone && serverType_ != stNode ){
terminate();
return;
}
if( !(bool) server_->config_->parse().valueByPath(
utf8::String(serverConfSectionName[serverType_]) + ".enabled",true) ){
utf8::String host(remoteAddress().resolveAddr(~uintptr_t(0)));
utf8::String::Stream stream;
stream << serverTypeName[serverType_] <<
": functional disabled, but client " << host << " attempt to register.\n";
stdErr.debug(6,stream);
terminate();
return;
}
utf8::String host(remoteAddress().resolveAddr(~uintptr_t(0)));
ServerInfo server(server_->bindAddrs()[0].resolveAddr(defaultPort),stStandalone);
Server::Data & data = server_->data(serverType_);
Server::Data tdata, diff;
tdata.ore(data);
tdata.registerServerNL(server);
UserInfo user;
*this >> user;
tdata.registerUserNL(user);
KeyInfo key;
*this >> key;
tdata.registerKeyNL(key);
tdata.registerUser2KeyLinkNL(User2KeyLink(user.name_,key.name_));
tdata.registerKey2ServerLinkNL(Key2ServerLink(key.name_,server.name_));
uint64_t u;
*this >> u;
while( u-- > 0 ){
GroupInfo group;
*this >> group;
tdata.registerGroupNL(group);
tdata.registerKey2GroupLinkNL(Key2GroupLink(key.name_,group.name_));
}
bool startNodeClient = false;
if( serverType_ == stStandalone ){
AutoReadWriteLockWRLock<FiberReadWriteLock> lock(data.mutex_);
diff.xorNL(data,tdata);
startNodeClient = data.orNL(tdata);
}
if( startNodeClient ) server_->startNodeClient(stStandalone);
putCode(serverType_ == stStandalone ? eOK : eInvalidServerType);
flush();
if( serverType_ == stStandalone ){
utf8::String::Stream stream;
stream << serverTypeName[serverType_] << ": changes stored from client " << host << "\n";
diff.dumpNL(stream);
stdErr.debug(5,stream);
}
}
UtlBoolean HttpServer::processRequestIpAddr(const UtlString& remoteIp,
const HttpMessage& request,
HttpMessage*& response)
{
UtlBoolean isValidIp = FALSE;
UtlString remoteAddress(remoteIp);
UtlString matchIp(remoteAddress);
if(mValidIpAddrList.isEmpty() || mValidIpAddrList.find(&matchIp))
{
isValidIp = TRUE;
}
else
{
response = new HttpMessage();
response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION,
HTTP_FORBIDDEN_CODE, HTTP_FORBIDDEN_TEXT);
OsSysLog::add(FAC_SIP, PRI_WARNING,
"HTTP Request from non-allowed IP address: %s disallowed",
remoteAddress.data());
}
return isValidIp ;
}
std::string NetworkSocket::debugString() const {
if(!isOpen()) return "Closed";
std::string ret = TypeStr(m_type) + "/" + StateStr(m_state);
{
std::string localStr = "INVALIDLOCAL";
NetworkAddr addr;
if(nlGetLocalAddr(m_socket->sock, getNLaddr(addr)) != NL_FALSE)
NetAddrToString(addr, localStr);
else {
localStr = "ERRORLOCALADDR(" + GetLastErrorStr() + ")";
ResetSocketError();
}
ret += " " + localStr;
}
if(m_state == NSS_CONNECTED) {
ret += " connected to ";
std::string remoteStr = "INVALIDREMOTE";
NetworkAddr addr;
if(nlGetRemoteAddr(m_socket->sock, getNLaddr(addr)) != NL_FALSE)
NetAddrToString(remoteAddress(), remoteStr);
else {
remoteStr = "ERRORREMOTEADDR(" + GetLastErrorStr() + ")";
ResetSocketError();
}
ret += remoteStr;
}
return ret;
}
void NetworkSocket::reapplyRemoteAddress() {
if(m_type == NST_UDP || m_type == NST_UDPBROADCAST)
// TODO: comment this, why we need that in some cases
setRemoteAddress(remoteAddress());
else
errors << "NetworkSocket::reapplyRemoteAddress cannot be done as " << TypeStr(m_type) << endl;
}
//! Create a socket stream to the following destination
SocketStream(const string& targetName) :
Stream("tcp"),
DisconnectableStream("tcp")
#ifndef TCP_CORK
,sendBuffer(SEND_BUFFER_SIZE_INITIAL)
#endif
{
target.add("tcp:host;port;connectionPort=-1;sock=-1");
target.add(targetName.c_str());
fd = target.get<int>("sock");
if (fd < 0)
{
// create socket
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd < 0)
throw DashelException(DashelException::ConnectionFailed, errno, "Cannot create socket.");
IPV4Address remoteAddress(target.get("host"), target.get<int>("port"));
// connect
sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(remoteAddress.port);
addr.sin_addr.s_addr = htonl(remoteAddress.address);
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
throw DashelException(DashelException::ConnectionFailed, errno, "Cannot connect to remote host.");
// overwrite target name with a canonical one
target.add(remoteAddress.format().c_str());
target.erase("connectionPort");
}
else
{
// remove file descriptor information from target name
target.erase("sock");
}
// setup TCP Cork for delayed sending
#ifdef TCP_CORK
int flag = 1;
setsockopt(fd, IPPROTO_TCP, TCP_CORK, &flag , sizeof(flag));
#endif
}
void MyClass::objectPush()
{
//! [sendfile]
// Create a transfer manager
QBluetoothTransferManager *transferManager = new QBluetoothTransferManager(this);
// Create the transfer request and file to be sent
QBluetoothAddress remoteAddress("00:11:22:33:44:55:66");
QBluetoothTransferRequest request(remoteAddress);
QFile *file = new QFile("testfile.txt");
// Ask the transfer manager to send it
QBluetoothTransferReply *reply = transferManager->put(request, file);
// Connect to the reply's signals to be informed about the status and do cleanups when done
QObject::connect(reply, SIGNAL(finished(QBluetoothTransferReply*)),
this, SLOT(transferFinished(QBluetoothTransferReply*)));
//! [sendfile]
}
//------------------------------------------------------------------------------
void ServerFiber::auth()
{
AuthParams ap;
ap.maxRecvSize_ = server_->config_->parse().override().value("max_recv_size",-1);
ap.maxSendSize_ = server_->config_->value("max_send_size",-1);
ap.recvTimeout_ = server_->config_->value("recv_timeout",-1);
if( ap.recvTimeout_ != ~uint64_t(0) ) ap.recvTimeout_ *= 1000000u;
ap.sendTimeout_ = server_->config_->value("send_timeout",-1);
if( ap.sendTimeout_ != ~uint64_t(0) ) ap.sendTimeout_ *= 1000000u;
ap.encryption_ = server_->config_->section("encryption").text(utf8::String(),"default");
ap.threshold_ = server_->config_->section("encryption").value("threshold",1024 * 1024);
ap.compression_ = server_->config_->section("compression").text(utf8::String(),"default");
ap.compressionType_ = server_->config_->section("compression").text("type","default");
ap.crc_ = server_->config_->section("compression").text("crc","default");
ap.level_ = server_->config_->section("compression").value("max_level",9);
ap.optimize_ = server_->config_->section("compression").value("optimize",true);
ap.bufferSize_ = server_->config_->section("compression").value("buffer_size",getpagesize() * 16);
ap.noAuth_ = false;
if( server_->config_->isSection("users") ){
ap.maxRecvSize_ = server_->config_->valueByPath("users.max_recv_size",ap.maxRecvSize_);
ap.maxSendSize_ = server_->config_->valueByPath("users.max_send_size",ap.maxSendSize_);
ap.recvTimeout_ = server_->config_->valueByPath("users.recv_timeout",ap.recvTimeout_);
if( ap.recvTimeout_ != ~uint64_t(0) ) ap.recvTimeout_ *= 1000000u;
ap.sendTimeout_ = server_->config_->valueByPath("users.send_timeout",ap.sendTimeout_);
if( ap.sendTimeout_ != ~uint64_t(0) ) ap.sendTimeout_ *= 1000000u;
ap.noAuth_ = server_->config_->valueByPath("users.noauth",ap.noAuth_);
ap.encryption_ = server_->config_->textByPath("encryption.",ap.encryption_);
ap.threshold_ = server_->config_->valueByPath("encryption.threshold",ap.threshold_);
ap.compression_ = server_->config_->textByPath("compression.",ap.compression_);
ap.compressionType_ = server_->config_->textByPath("compression.type",ap.compressionType_);
ap.crc_ = server_->config_->textByPath("compression.crc",ap.crc_);
ap.level_ = server_->config_->valueByPath("compression.max_level",ap.level_);
ap.optimize_ = server_->config_->valueByPath("compression.optimize",ap.optimize_);
ap.bufferSize_ = server_->config_->valueByPath("compression.buffer_size",ap.bufferSize_);
}
Error e = (Error) serverAuth(ap);
if( e != eOK ){
utf8::String::Stream stream;
stream << "Authentification error from: " << remoteAddress().resolveAddr(~uintptr_t(0)) << "\n";
stdErr.debug(9,stream);
newObjectV1C2<Exception>(e,__PRETTY_FUNCTION__)->throwSP();
}
}
//------------------------------------------------------------------------------
void ServerFiber::registerDB()
{
utf8::String::Stream stream;
utf8::String host(remoteAddress().resolveAddr(~uintptr_t(0))), server, service;
if( serverType_ != stNode ){
terminate();
stream << serverTypeName[serverType_] <<
": " << host << " ask for " << serverTypeName[serverType_] << " database\n";
stdErr.debug(6,stream);
return;
}
if( !(bool) server_->config_->parse().valueByPath(
utf8::String(serverConfSectionName[serverType_]) + ".enabled",false) ){
terminate();
stream << serverTypeName[serverType_] <<
": functional disabled, but " << host << " attempt to register own database.\n";
stdErr.debug(6,stream);
return;
}
bool irsl = server_->config_->valueByPath(
utf8::String(serverConfSectionName[serverType_]) + ".ignore_remote_send_list",false
);
uint32_t port;
uint64_t rStartTime;
bool dbChanged = false;
*this >> port >> rStartTime << uint64_t(getProcessStartTime());
uint8_t rdbt;
if( protocol_ > 0 ){
*this >> rdbt;
if( rdbt >= stCount ){
terminate();
stream << serverTypeName[serverType_] <<
": remote host " << host << " send invalid own database type.\n";
stdErr.debug(6,stream);
return;
}
}
