//------------------------------------------------------------------------------ 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; } }