void RemoteManager::setRemoteServerLive(RDTreeWidgetItem *node, bool live, bool busy) { RemoteHost *host = getRemoteHost(node); if(!host) return; host->serverRunning = live; host->busy = busy; if(host->IsLocalhost()) { node->setIcon(0, QIcon()); node->setText(1, QString()); } else { QString text = live ? tr("Remote server running") : tr("No remote server"); if(host->connected) text += tr(" (Active Context)"); else if(host->versionMismatch) text += tr(" (Version Mismatch)"); else if(host->busy) text += tr(" (Busy)"); node->setText(1, text); node->setIcon(0, live ? Icons::connect() : Icons::disconnect()); } }
void RemoteManager::on_addUpdateHost_clicked() { RDTreeWidgetItem *item = ui->hosts->selectedItem(); if(item && getRemoteHost(item)) setRunCommand(); else addNewHost(); }
void RemoteManager::runRemoteServer(RDTreeWidgetItem *node) { RemoteHost *host = getRemoteHost(node); if(!host) return; host->Launch(); // now refresh this host refreshHost(node); }
void RemoteManager::setRunCommand() { RDTreeWidgetItem *item = ui->hosts->selectedItem(); if(!item) return; RemoteHost *h = getRemoteHost(item); if(h) { h->runCommand = ui->runCommand->text().trimmed(); m_Ctx.Config().Save(); } }
void RemoteManager::on_deleteHost_clicked() { RDTreeWidgetItem *item = ui->hosts->selectedItem(); if(!item) return; RemoteHost *host = getRemoteHost(item); int itemIdx = ui->hosts->indexOfTopLevelItem(item); // don't delete running instances on a host if(item->parent() != ui->hosts->invisibleRootItem() || itemIdx < 0 || !host) return; QString hostname = item->text(0); if(hostname == lit("localhost")) return; QMessageBox::StandardButton res = RDDialog::question( this, tr("Deleting host"), tr("Are you sure you wish to delete %1?").arg(hostname), RDDialog::YesNoCancel); if(res == QMessageBox::Cancel || res == QMessageBox::No) return; if(res == QMessageBox::Yes) { int32_t idx = m_Ctx.Config().RemoteHosts.indexOf(host); if(idx < 0) return; // the host will be removed in queueDelete. m_Ctx.Config().RemoteHosts.erase(idx); m_Ctx.Config().Save(); item->clear(); queueDelete(ui->hosts->takeTopLevelItem(itemIdx)); ui->hosts->clearSelection(); ui->hostname->setText(hostname); on_hostname_textEdited(hostname); } }
void CGI::logCGIData(const QString& filename) { // create a QFile object to do the file I/O QFile file(filename); // open the file if (file.open(QIODevice::WriteOnly)) { // create a QTextStream object on the file Q3TextStream textFile(&file); // get the environment textFile << "REQUEST_METHOD=" << getenv("REQUEST_METHOD") << endl; textFile << "CONTENT_LENGTH=" << getenv("CONTENT_LENGTH") << endl; // write the query string to the file textFile << "QUERY_STRING=" << query_string << endl; // write misc. CGI environment pieces textFile << "AUTH_TYPE=" << getAuthType() << endl; textFile << "GATEWAY_INTERFACE=" << getGatewayInterface() << endl; textFile << "HTTP_ACCEPT=" << getHTTPAccept() << endl; textFile << "HTTP_ACCEPT_ENCODING=" << getHTTPAcceptEncoding() << endl; textFile << "HTTP_ACCEPT_LANGUAGE=" << getHTTPAcceptLanguage() << endl; textFile << "HTTP_CONNECTION=" << getHTTPConnection() << endl; textFile << "HTTP_REFERER=" << getHTTPReferer() << endl; textFile << "HTTP_USER_AGENT=" << getHTTPUserAgent() << endl; textFile << "REMOTE_HOST=" << getRemoteHost() << endl; textFile << "REMOTE_ADDRESS=" << getRemoteAddress() << endl; textFile << "REMOTE_PORT=" << getRemotePort() << endl; textFile << "REQUEST_URI=" << getRequestURI() << endl; textFile << "SCRIPT_NAME=" << getScriptName() << endl; textFile << "SERVER_ADMIN=" << getServerAdmin() << endl; textFile << "SERVER_NAME=" << getServerName() << endl; textFile << "SERVER_PORT=" << getServerPort() << endl; textFile << "SERVER_PROTOCOL=" << getServerProtocol() << endl; textFile << "SERVER_SOFTWARE=" << getServerSoftware() << endl; } // close the file file.close(); }
void WorldSocket::Open() { cout << "Accept connection from " << getRemoteHost() << ":" << getRemotePort() << endl; m_closed = false; m_pSendHeader = new PacketHeader(0, 0); string serverToClient = "CONNECTION SUCCESS - SERVER TO CLIENT"; WorldPacket data(MSG_CONNECTION); data << serverToClient; SendPacket(data); data.Initialize(SMSG_AUTH_CHALLENGE, 4); data << 0; SendPacket(data); }
void WorldSocket::ProcessIncomingPacket(WorldPacket *recvPacket) { uint16 msgCode = recvPacket->getMsgCode(); switch (msgCode) { case MSG_CONNECTION: { HandleConnection(*recvPacket); break; } case MSG_PING: { HandlePing(*recvPacket); break; } case CMSG_AUTH_SESSION: { if (m_pSession) { cout << "Client try to auth again!" << endl; return; } HandleAuthSession(*recvPacket); break; } default: { if (m_pSession) { const MsgCodeHandler msghandler = msgCodeTable[msgCode]; (m_pSession->*msghandler.handler)(*recvPacket); } else cout << "ERROR: Client not authed! Remote Host: " << getRemoteHost() << ", MsgCode: "<< msgCode << "(" << LookupMsgCodeName(msgCode) << ")" << endl; } } SAFE_DELETE(recvPacket); }
void RemoteManager::on_hosts_itemSelectionChanged() { ui->addUpdateHost->setText(tr("Add")); ui->addUpdateHost->setEnabled(true); ui->deleteHost->setEnabled(false); ui->refreshOne->setEnabled(false); ui->hostname->setEnabled(true); ui->runCommand->setEnabled(true); RDTreeWidgetItem *item = ui->hosts->selectedItem(); RemoteHost *host = item ? getRemoteHost(item) : NULL; ui->runCommand->setText(QString()); if(host) { if(ui->refreshAll->isEnabled()) ui->refreshOne->setEnabled(true); ui->runCommand->setText(host->runCommand); ui->hostname->setText(host->Name()); ui->addUpdateHost->setText(tr("Update")); if(host->IsLocalhost() || host->IsADB()) { // localhost and android hosts cannot be updated or have their run command changed ui->addUpdateHost->setEnabled(false); ui->runCommand->setEnabled(false); } else { // any other host can be deleted ui->deleteHost->setEnabled(true); } } updateConnectButton(); }
void RemoteManager::updateConnectButton() { RDTreeWidgetItem *item = ui->hosts->selectedItem(); if(item) { ui->connect->setEnabled(true); ui->connect->setText(tr("Connect to App")); RemoteHost *host = getRemoteHost(item); if(host) { if(host->IsLocalhost()) { ui->connect->setText(tr("Run Server")); ui->connect->setEnabled(false); } else if(host->serverRunning) { ui->connect->setText(tr("Shutdown")); if(host->busy && !host->connected) ui->connect->setEnabled(false); } else { ui->connect->setText(tr("Run Server")); if(host->runCommand.isEmpty()) ui->connect->setEnabled(false); } } } else { ui->connect->setEnabled(false); } }
//---------------------------------------------------------------------- // getRemoteHost -- retrieve remote host's address //---------------------------------------------------------------------- void Condor_Auth_Kerberos :: setRemoteAddress() { krb5_error_code code; krb5_address ** localAddr = NULL; krb5_address ** remoteAddr = NULL; // Get remote host's address first if ((code = krb5_auth_con_getaddrs(krb_context_, auth_context_, localAddr, remoteAddr))) { goto error; } if (remoteAddr) { struct in_addr in; memcpy(&(in.s_addr), (*remoteAddr)[0].contents, sizeof(in_addr)); setRemoteHost(inet_ntoa(in)); } if (localAddr) { krb5_free_addresses(krb_context_, localAddr); } if (remoteAddr) { krb5_free_addresses(krb_context_, remoteAddr); } dprintf(D_SECURITY, "Remote host is %s\n", getRemoteHost()); return; error: dprintf( D_ALWAYS, "KERBEROS: Unable to obtain remote address: %s\n", error_message(code) ); }
void RemoteManager::on_connect_clicked() { RDTreeWidgetItem *node = ui->hosts->selectedItem(); if(!node) return; RemoteConnect connect = getRemoteConnect(node); RemoteHost *host = getRemoteHost(node); if(connect.ident > 0) { connectToApp(node); } else if(host) { if(host->serverRunning) { QMessageBox::StandardButton res = RDDialog::question( this, tr("Remote server shutdown"), tr("Are you sure you wish to shut down running remote server on %1?").arg(host->Name()), RDDialog::YesNoCancel); if(res == QMessageBox::Cancel || res == QMessageBox::No) return; // shut down if(host->connected) { m_Ctx.Replay().ShutdownServer(); setRemoteServerLive(node, false, false); } else { IRemoteServer *server = NULL; ReplayStatus status = RENDERDOC_CreateRemoteServerConnection(host->hostname.c_str(), 0, &server); if(server) server->ShutdownServerAndConnection(); setRemoteServerLive(node, false, false); if(status != ReplayStatus::Succeeded) RDDialog::critical(this, tr("Shutdown error"), tr("Error shutting down remote server: %1").arg(ToQStr(status))); } updateConnectButton(); } else { // try to run ui->refreshOne->setEnabled(false); ui->refreshAll->setEnabled(false); m_Lookups.release(); LambdaThread *th = new LambdaThread([this, node]() { runRemoteServer(node); }); th->selfDelete(true); th->start(); updateLookupsStatus(); } } }
void WorldSocket::HandleReceiveData() { if (m_closed || !m_pSHSocket || m_pSHSocket->disconnected() || m_pSHSocket->nextReadSize() <= 0) return; try { uint16 readSize = m_pSHSocket->nextReadSize(); uint16 readPos = 0; m_recvDataHolder.resize(readSize); m_pSHSocket->Read(&m_recvDataHolder[0], readSize); cout << "Read From " << getRemoteHost() << ":" << getRemotePort() << ", Data Size: " << readSize << endl; while (readSize) { if (m_missedDataSize) { uint16 missedSize = m_missedDataSize >= readSize ? readSize : m_missedDataSize; m_pRecvPacket->Append(&m_recvDataHolder[0], missedSize); readSize -= missedSize; m_missedDataSize -= missedSize; readPos += missedSize; if (!m_missedDataSize) { ProcessIncomingPacket(m_pRecvPacket); m_pRecvPacket = NULL; } } else { if (readSize < 4) throw SHException(SHException::SH_EXCEPTION_OUT_OF_RANGE, "Missed packet header info!"); uint32 size = ((m_recvDataHolder[readPos++] & 0xFF) << 8) | (m_recvDataHolder[readPos++] & 0xFF); uint16 msgCode = ((m_recvDataHolder[readPos++] & 0xFF) << 8) | (m_recvDataHolder[readPos++] & 0xFF); readSize -= 4; m_pRecvPacket = new WorldPacket(msgCode, size); if (size > readSize) { m_missedDataSize = size - readSize; if (readSize) { m_pRecvPacket->Append(&m_recvDataHolder[readPos], readSize); readPos += readSize; readSize -= readSize; } } else { m_pRecvPacket->Append(&m_recvDataHolder[readPos], size); readPos += size; readSize -= size; ProcessIncomingPacket(m_pRecvPacket); m_pRecvPacket = NULL; } } } m_recvDataHolder.clear(); } catch (SHException e) { m_recvDataHolder.clear(); cout << e.what() << endl; } }
void RemoteManager::refreshHost(RDTreeWidgetItem *node) { RemoteHost *host = getRemoteHost(node); if(!host) return; // this function looks up the remote connections and for each one open // queries it for the API, target (usually executable name) and if any user is already connected LambdaThread *th = new LambdaThread([this, node, host]() { QByteArray username = GetSystemUsername().toUtf8(); host->CheckStatus(); GUIInvoke::call( [this, node, host]() { setRemoteServerLive(node, host->serverRunning, host->busy); }); uint32_t nextIdent = 0; for(;;) { // just a sanity check to make sure we don't hit some unexpected case and infinite loop uint32_t prevIdent = nextIdent; nextIdent = RENDERDOC_EnumerateRemoteTargets(host->hostname.c_str(), nextIdent); if(nextIdent == 0 || prevIdent >= nextIdent) break; ITargetControl *conn = RENDERDOC_CreateTargetControl(host->hostname.c_str(), nextIdent, username.data(), false); if(conn) { QString target = QString::fromUtf8(conn->GetTarget()); QString api = QString::fromUtf8(conn->GetAPI()); QString busy = QString::fromUtf8(conn->GetBusyClient()); QString running; if(!busy.isEmpty()) running = tr("Running %1, %2 is connected").arg(api).arg(busy); else running = tr("Running %1").arg(api); RemoteConnect tag(host->hostname, host->Name(), nextIdent); GUIInvoke::call([this, node, target, running, tag]() { RDTreeWidgetItem *child = new RDTreeWidgetItem({target, running}); setRemoteConnect(child, tag); node->addChild(child); ui->hosts->expandItem(node); }); conn->Shutdown(); } } GUIInvoke::call([node]() { node->setItalic(false); }); m_Lookups.acquire(); GUIInvoke::call([this]() { updateStatus(); }); }); th->selfDelete(true); th->start(); }
int Condor_Auth_Kerberos :: authenticate_server_kerberos() { krb5_error_code code; krb5_flags flags = 0; krb5_data request, reply; priv_state priv; krb5_keytab keytab = 0; int message, rc = FALSE; krb5_ticket * ticket = NULL; request.data = 0; reply.data = 0; keytabName_ = param(STR_KERBEROS_SERVER_KEYTAB); //------------------------------------------ // Getting keytab info //------------------------------------------ if (keytabName_) { code = krb5_kt_resolve(krb_context_, keytabName_, &keytab); } else { code = krb5_kt_default(krb_context_, &keytab); } if (code) { dprintf( D_ALWAYS, "1: Kerberos server authentication error:%s\n", error_message(code) ); goto error; } //------------------------------------------ // Get te KRB_AP_REQ message //------------------------------------------ if(read_request(&request) == FALSE) { dprintf( D_ALWAYS, "KERBEROS: Server is unable to read request\n" ); goto error; } dprintf( D_SECURITY, "Reading kerberos request object (krb5_rd_req)\n"); dprintf_krb5_principal( D_FULLDEBUG, "KERBEROS: krb_principal_ is '%s'\n", krb_principal_); priv = set_root_priv(); // Get the old privilige if ((code = krb5_rd_req(krb_context_, &auth_context_, &request, //krb_principal_, NULL, keytab, &flags, &ticket))) { set_priv(priv); // Reset dprintf( D_ALWAYS, "2: Kerberos server authentication error:%s\n", error_message(code) ); goto error; } set_priv(priv); // Reset dprintf ( D_FULLDEBUG, "KERBEROS: krb5_rd_req done.\n"); //------------------------------------------ // See if mutual authentication is required //------------------------------------------ if (flags & AP_OPTS_MUTUAL_REQUIRED) { if ((code = krb5_mk_rep(krb_context_, auth_context_, &reply))) { dprintf( D_ALWAYS, "3: Kerberos server authentication error:%s\n", error_message(code) ); goto error; } mySock_->encode(); message = KERBEROS_MUTUAL; if (!mySock_->code(message) || !mySock_->end_of_message()) { goto error; } // send the message if (send_request(&reply) != KERBEROS_GRANT) { goto cleanup; } } //------------------------------------------ // extract client addresses //------------------------------------------ if (ticket->enc_part2->caddrs) { struct in_addr in; memcpy(&(in.s_addr), ticket->enc_part2->caddrs[0]->contents, sizeof(in_addr)); setRemoteHost(inet_ntoa(in)); dprintf(D_SECURITY, "Client address is %s\n", getRemoteHost()); } // First, map the name, this has to take place before receive_tgt_creds! if (!map_kerberos_name(&(ticket->enc_part2->client))) { dprintf(D_SECURITY, "Unable to map Kerberos name\n"); goto error; } // copy the session key if ((code = krb5_copy_keyblock(krb_context_, ticket->enc_part2->session, &sessionKey_))){ dprintf(D_SECURITY, "4: Kerberos server authentication error:%s\n", error_message(code)); goto error; } // Next, see if we need client to forward the credential as well if (receive_tgt_creds(ticket)) { goto cleanup; } //------------------------------------------ // We are now authenticated! //------------------------------------------ dprintf(D_SECURITY, "User %s is now authenticated!\n", getRemoteUser()); rc = TRUE; goto cleanup; error: message = KERBEROS_DENY; mySock_->encode(); if ((!mySock_->code(message)) || (!mySock_->end_of_message())) { dprintf( D_ALWAYS, "KERBEROS: Failed to send response message!\n" ); } cleanup: //------------------------------------------ // Free up some stuff //------------------------------------------ if (ticket) { krb5_free_ticket(krb_context_, ticket); } if (keytab) { krb5_kt_close(krb_context_, keytab); } //------------------------------------------ // Free it for now, in the future, we might // need this for future secure transctions. //------------------------------------------ if (request.data) { free(request.data); } if (reply.data) { free(reply.data); } return rc; }
int Cconfigurator::saveConfigAs(QByteArray path, QByteArray filename) { unsigned int i; // try QSettings QSettings conf(path + filename, QSettings::IniFormat); conf.beginGroup("General"); conf.setValue("mapFile", getBaseFile()); conf.setValue("windowRect", renderer_window->geometry() ); conf.setValue("alwaysOnTop", getAlwaysOnTop() ); conf.setValue("startupMode", getStartupMode() ); conf.endGroup(); conf.beginGroup("Networking"); conf.setValue("localPort", getLocalPort() ); conf.setValue("remoteHost", getRemoteHost() ); conf.setValue("remotePort", getRemotePort() ); conf.endGroup(); conf.beginGroup("OpenGL"); conf.setValue("texturesVisibility", getTextureVisibility() ); conf.setValue("detailsVisibility", getDetailsVisibility() ); conf.setValue("visibleLayers", getVisibleLayers() ); conf.setValue("showNotes", getShowNotesRenderer() ); conf.setValue("showRegions", getShowRegionsInfo() ); conf.setValue("displayRegions", getDisplayRegionsRenderer() ); conf.setValue("multisampling", getMultisampling() ); conf.setValue("selectOnAnyLayer", getSelectOAnyLayer()); conf.setValue("angleX", (double) angleX ); conf.setValue("angleY", (double) angleY ); conf.setValue("angleZ", (double) angleZ ); conf.setValue("userX", (double) userX ); conf.setValue("userY", (double) userY ); conf.setValue("userZ", (double) userZ ); conf.setValue("noteColor", getNoteColor() ); conf.setValue("drawPrespam", getDrawPrespam()); conf.endGroup(); conf.beginGroup("Engine"); conf.setValue("checkExits", getExitsCheck() ); conf.setValue("checkTerrain", getTerrainCheck() ); conf.setValue("briefmode", getBriefMode() ); conf.setValue("autoMerge", getAutomerge() ); conf.setValue("angryLinker", getAngrylinker() ); conf.setValue("dualLinker", getDuallinker() ); conf.setValue("autoRefresh", getAutorefresh() ); conf.setValue("roomNameQuote", getNameQuote() ); conf.setValue("descQuote", getDescQuote() ); conf.setValue("mactionUsesPrespam", getMactionUsesPrespam()); conf.setValue("prespamTTL", getPrespamTTL()); conf.endGroup(); conf.beginGroup("Patterns"); conf.setValue("exitsPattern", getExitsPattern()); conf.setValue("spellsEffectPattern", spells_pattern); conf.setValue( "scorePattern", getScorePattern() ); conf.setValue( "scorePatternShort", getShortScorePattern() ); conf.endGroup(); conf.beginGroup("GroupManager"); conf.setValue("remoteHost", getGroupManagerHost() ); conf.setValue("remotePort", getGroupManagerRemotePort() ); conf.setValue("localServerPort", getGroupManagerLocalPort() ); conf.setValue("charName", getGroupManagerCharName() ); conf.setValue("charColor", getGroupManagerColor().name() ); conf.setValue("showSelf", getGroupManagerShowSelf() ); conf.setValue("notifyArm", getGroupManagerNotifyArmour() ); conf.setValue("notifySanc", getGroupManagerNotifySanc() ); conf.setValue("notifyBash", getGroupManagerNotifyBash() ); conf.setValue("showGroupManager", getGroupManagerShowManager() ); conf.setValue("windowRect", renderer_window->getGroupManagerRect() ); conf.endGroup(); conf.beginWriteArray("Spells"); for (unsigned int i = 0; i < spells.size(); ++i) { conf.setArrayIndex(i); conf.setValue("addon", spells[i].addon); conf.setValue("name", spells[i].name); conf.setValue("upMessage", spells[i].up_mes); conf.setValue("refreshMessage", spells[i].refresh_mes); conf.setValue("downMessage", spells[i].down_mes); } conf.endArray(); conf.beginGroup("Movement tracking"); conf.beginWriteArray("Cancel Patterns"); for (int i = 0; i < moveCancelPatterns.size(); ++i) { conf.setArrayIndex(i); conf.setValue("pattern", moveCancelPatterns.at(i)); } conf.endArray(); conf.beginWriteArray("Force Patterns"); for (int i = 0; i < moveForcePatterns.size(); ++i) { conf.setArrayIndex(i); conf.setValue("pattern", moveForcePatterns.at(i)); } conf.endArray(); conf.endGroup(); conf.beginWriteArray("Debug Settings"); i = 0; while (debug_data[i].name) { conf.setArrayIndex(i); conf.setValue("name", debug_data[i].name); conf.setValue("state", debug_data[i].state); i++; } conf.endArray(); configFile = filename; configPath = path; setConfigModified(false); return true; }
void AtDrv::startClient(uint8_t sock, const char *host, uint16_t port, uint8_t protMode) { // if we enable CHECK_TCP_STATE feature, always call reConnect(), or we won't get right // tcp port status, since we disable tcp auto reconnect. #ifndef CHECK_TCP_STATE bool needReConn = false; #else bool needReConn = true; #endif int curMode; char curHostBuf[MAX_HOST_NAME_BUF_SIZE]; uint8_t curProtocol; uint16_t curPort; uint16_t curLocalPort; uint32_t curTimeout; bool curTcpAuto; // clear uart buffer first stopClient(sock); if(!isAtMode()) { if(!switchToAtMode()) { INFO1("Can't switch to at mode"); goto end; } } if(!getMode(sock, &curMode) || curMode != MODE_CLIENT) { needReConn = true; INFO1("curMode != MODE_CLIENT"); if(!setMode(sock, MODE_CLIENT)) { INFO1("Can't set mode"); goto end; } } if(!getRemoteHost(sock, curHostBuf) || (strcmp(curHostBuf, host) != 0)) { needReConn = true; INFO1("curHostBuf != host"); if(!setRemoteHost(sock, host)) { INFO1("Can't set host"); goto end; } } if(!getProtocol(sock, &curProtocol) || curProtocol != protMode) { needReConn = true; INFO1("curProtocol != protMode"); if(!setProtocol(sock, protMode)) { INFO1("Can't set protocol"); goto end; } } if(!getRemotePort(sock, &curPort) || curPort != port) { needReConn = true; INFO1("curPort != port"); if(!setPort(sock, port)) { INFO1("Can't set port"); goto end; } } if(!getTcpAuto(sock, &curTcpAuto) || curTcpAuto != false) { needReConn = true; INFO1("curTcpAuto != false"); if(!setTcpAuto(sock, false)) { INFO1("Can't set tcp auto"); goto end; } } if(!getLocalPort(sock, &curLocalPort) || curLocalPort != localSockPort[sock]) { needReConn = true; INFO1("curLocalPort != port"); if(!setLocalPort(sock, localSockPort[sock])) { INFO1("Can't set port"); goto end; } } if(needReConn) { if(!reConnect()) { INFO1("Can't reconnect"); goto end; } } sockPort[sock] = localSockPort[sock]; sockConnected[sock] = true; end: return; }
void deleteItemAndHost(RDTreeWidgetItem *item) { delete getRemoteHost(item); delete item; }
bool RemoteManager::isRemoteServerLive(RDTreeWidgetItem *node) { RemoteHost *host = getRemoteHost(node); return host && host->serverRunning; }