/** This should be only called when the client is ready to receive a response to the requestUrl. * Returns true if something is sended. * Returns false if there is nothing to send yet. (longpoll mode) */ bool respond(bool abort=false) { bool sended; //someone requested the special longpoll url: if (mRequestUrl=="/synapse/longpoll") { sended=(respondJsonQueue(abort)); } //just respond with a normal file else { sended=(respondFile(mRequestUrl)); } //what to do after the response? if (sended) { if (mHeaders.isSet("connection")) { if (mHeaders["connection"].str()=="close") doDisconnect(); } else if (mRequestVersion=="1.0") { //http 1.0 should always disconnect if Connection: Keep-Alive is not specified. doDisconnect(); } } return (sended); }
//----------------------------------------------------------------------------- // 描述: 断开数据库连接并进行相关设置 //----------------------------------------------------------------------------- void DbConnection::disconnect() { if (isConnected_) { doDisconnect(); isConnected_ = false; } }
SCI_Transporter::~SCI_Transporter() { DBUG_ENTER("SCI_Transporter::~SCI_Transporter"); // Close channel to the driver doDisconnect(); if(m_sendBuffer.m_buffer != NULL) delete[] m_sendBuffer.m_buffer; DBUG_VOID_RETURN; } // ~SCI_Transporter()
void doAdmin(int sock, ControlStruct *p) { char *cp, *cp1, tmpBuf[20]; int x; if (dbg) syslog(LOG_DEBUG, "doAdmin():Enter |%s|", p->buf); if (p->passwdMode != 0) { doPrivilege(p, "", sock); } else { for (cp = p->buf; *cp != '\0' && isspace(*cp); cp++); memset(tmpBuf, '\0', sizeof(tmpBuf)); for (x = 0, cp1 = tmpBuf; *cp != '\0' && !isspace(*cp) && (unsigned)x < sizeof(tmpBuf); x++) { *(cp1++) = tolower(*cp++); *cp1 = '\0'; } if (dbg) syslog(LOG_DEBUG, "doAdmin():Command = |%s|", tmpBuf); for (; *cp != '\0' && isspace(*cp); cp++); if (dbg) syslog(LOG_DEBUG, "doAdmin():Remainder Command = |%s|", cp); if (strcmp(tmpBuf, "enable") == 0) doEnable(p, cp); else if (strcmp(tmpBuf, "disable") == 0) doDisable(p, cp); else if (strcmp(tmpBuf, "disconnect") == 0) doDisconnect(p, cp); // else if (strcmp(tmpBuf, "privilege") == 0) // doPrivilege(p, cp, sock); else if (strcmp(tmpBuf, "set") == 0) doSet(p, cp); else if (strcmp(tmpBuf, "help") == 0) doHelp(p, cp); else if (strcmp(tmpBuf, "show") == 0) doShow(p, cp); else if (strcmp(tmpBuf, "verbose") == 0) p->verbose = (p->verbose == 0) ? 1 : 0; else { if (p->verbose) fputs("Error, Command Not recognized\n", p->fp); else fputs("904:Command Not recognized\n", p->fp); } } fflush(p->fp); }
TCP_Transporter::~TCP_Transporter() { // Disconnect if (my_socket_valid(theSocket)) doDisconnect(); // Delete receive buffer!! receiveBuffer.destroy(); }
int TCP_Transporter::doReceive() { // Select-function must return the socket for read // before this method is called // It reads the external TCP/IP interface once Uint32 size = receiveBuffer.sizeOfBuffer - receiveBuffer.sizeOfData; if(size > 0){ const int nBytesRead = recv(theSocket, receiveBuffer.insertPtr, size < maxReceiveSize ? size : maxReceiveSize, 0); if (nBytesRead > 0) { receiveBuffer.sizeOfData += nBytesRead; receiveBuffer.insertPtr += nBytesRead; if(receiveBuffer.sizeOfData > receiveBuffer.sizeOfBuffer){ #ifdef DEBUG_TRANSPORTER g_eventLogger.error("receiveBuffer.sizeOfData(%d) > receiveBuffer.sizeOfBuffer(%d)", receiveBuffer.sizeOfData, receiveBuffer.sizeOfBuffer); g_eventLogger.error("nBytesRead = %d", nBytesRead); #endif g_eventLogger.error("receiveBuffer.sizeOfData(%d) > receiveBuffer.sizeOfBuffer(%d)", receiveBuffer.sizeOfData, receiveBuffer.sizeOfBuffer); report_error(TE_INVALID_MESSAGE_LENGTH); return 0; } receiveCount ++; receiveSize += nBytesRead; if(receiveCount == reportFreq){ reportReceiveLen(get_callback_obj(), remoteNodeId, receiveCount, receiveSize); receiveCount = 0; receiveSize = 0; } return nBytesRead; } else { #if defined DEBUG_TRANSPORTER g_eventLogger.error("Receive Failure(disconnect==%d) to node = %d nBytesSent = %d " "errno = %d strerror = %s", DISCONNECT_ERRNO(InetErrno, nBytesRead), remoteNodeId, nBytesRead, InetErrno, (char*)ndbstrerror(InetErrno)); #endif if(DISCONNECT_ERRNO(InetErrno, nBytesRead)){ // The remote node has closed down doDisconnect(); report_disconnect(InetErrno); } } return nBytesRead; } else { return 0; } }
bool TCP_Transporter::doSend() { // If no sendbuffers are used nothing is done // Sends the contents of the SendBuffers until they are empty // or until select does not select the socket for write. // Before calling send, the socket must be selected for write // using "select" // It writes on the external TCP/IP interface until the send buffer is empty // and as long as write is possible (test it using select) // Empty the SendBuffers bool sent_any = true; while (m_sendBuffer.dataSize > 0) { const char * const sendPtr = m_sendBuffer.sendPtr; const Uint32 sizeToSend = m_sendBuffer.sendDataSize; const int nBytesSent = send(theSocket, sendPtr, sizeToSend, 0); if (nBytesSent > 0) { sent_any = true; m_sendBuffer.bytesSent(nBytesSent); sendCount ++; sendSize += nBytesSent; if(sendCount == reportFreq) { reportSendLen(get_callback_obj(), remoteNodeId, sendCount, sendSize); sendCount = 0; sendSize = 0; } } else { if (nBytesSent < 0 && InetErrno == EAGAIN && sent_any) break; // Send failed #if defined DEBUG_TRANSPORTER g_eventLogger.error("Send Failure(disconnect==%d) to node = %d nBytesSent = %d " "errno = %d strerror = %s", DISCONNECT_ERRNO(InetErrno, nBytesSent), remoteNodeId, nBytesSent, InetErrno, (char*)ndbstrerror(InetErrno)); #endif if(DISCONNECT_ERRNO(InetErrno, nBytesSent)){ doDisconnect(); report_disconnect(InetErrno); } return false; } } return true; }
bool sendData(const asio::mutable_buffers_1 & buffers) { if (write(tcpSocket,buffers) != buffer_size(buffers)) { ERROR(id << " had write while sending data, disconnecting."); doDisconnect(); return(false); } return(true); }
TCP_Transporter::~TCP_Transporter() { // Disconnect if (theSocket != NDB_INVALID_SOCKET) doDisconnect(); // Delete send buffers // Delete receive buffer!! receiveBuffer.destroy(); }
/** * For now implement truncate here and only for size == 0. * Weak implementation in that we just delete the file and * then re-create it, but don't set the user, group, and times to the old * file's metadata. */ int dfs_truncate(const char *path, off_t size) { TRACE1("truncate", path) dfs_context *dfs = (dfs_context*)fuse_get_context()->private_data; assert(path); assert('/' == *path); assert(dfs); if (size != 0) { return -ENOTSUP; } int ret = dfs_unlink(path); if (ret != 0) { return ret; } hdfsFS userFS = doConnectAsUser(dfs->nn_hostname, dfs->nn_port); if (userFS == NULL) { ERROR("Could not connect"); ret = -EIO; goto cleanup; } int flags = O_WRONLY | O_CREAT; hdfsFile file; if ((file = (hdfsFile)hdfsOpenFile(userFS, path, flags, 0, 0, 0)) == NULL) { ERROR("Could not connect open file %s", path); ret = -EIO; goto cleanup; } if (hdfsCloseFile(userFS, file) != 0) { ERROR("Could not close file %s", path); ret = -EIO; goto cleanup; } cleanup: if (doDisconnect(userFS)) { ret = -EIO; } return ret; }
/***************************************************************************** * ~Ndb(); * * Remark: Disconnect with the database. *****************************************************************************/ Ndb::~Ndb() { DBUG_ENTER("Ndb::~Ndb()"); DBUG_PRINT("enter",("this: 0x%lx", (long) this)); if (m_sys_tab_0) getDictionary()->removeTableGlobal(*m_sys_tab_0, 0); assert(theImpl->m_ev_op == 0); // user should return NdbEventOperation's for (NdbEventOperationImpl *op= theImpl->m_ev_op; op; op=op->m_next) { if (op->m_state == NdbEventOperation::EO_EXECUTING && op->stop()) g_eventLogger.error("stopping NdbEventOperation failed in Ndb destructor"); op->m_magic_number= 0; } doDisconnect(); /* Disconnect from transporter to stop signals from coming in */ if (theImpl->m_transporter_facade != NULL && theNdbBlockNumber > 0) { theImpl->m_transporter_facade->close(theNdbBlockNumber, theFirstTransId); } delete theEventBuffer; releaseTransactionArrays(); delete []theConnectionArray; if(theCommitAckSignal != NULL) { delete theCommitAckSignal; theCommitAckSignal = NULL; } delete theImpl; #ifdef POORMANSPURIFY #ifdef POORMANSGUI ndbout << "cnewSignals=" << cnewSignals << endl; ndbout << "cfreeSignals=" << cfreeSignals << endl; ndbout << "cgetSignals=" << cgetSignals << endl; ndbout << "creleaseSignals=" << creleaseSignals << endl; #endif // Poor mans purifier assert(cnewSignals == cfreeSignals); assert(cgetSignals == creleaseSignals); #endif DBUG_VOID_RETURN; }
/***************************************************************************** * ~Ndb(); * * Remark: Disconnect with the database. *****************************************************************************/ Ndb::~Ndb() { DBUG_ENTER("Ndb::~Ndb()"); DBUG_PRINT("enter",("Ndb::~Ndb this: 0x%lx",(long) this)); doDisconnect(); if (TransporterFacade::instance() != NULL && theNdbBlockNumber > 0){ TransporterFacade::instance()->close(theNdbBlockNumber, theFirstTransId); } releaseTransactionArrays(); delete []theConnectionArray; if(theCommitAckSignal != NULL){ delete theCommitAckSignal; theCommitAckSignal = NULL; } delete theImpl; /** * This sleep is to make sure that the transporter * send thread will come in and send any * signal buffers that this thread may have allocated. * If that doesn't happen an error will occur in OSE * when trying to restore a signal buffer allocated by a thread * that have been killed. */ #ifdef NDB_OSE NdbSleep_MilliSleep(50); #endif #ifdef POORMANSPURIFY #ifdef POORMANSGUI ndbout << "cnewSignals=" << cnewSignals << endl; ndbout << "cfreeSignals=" << cfreeSignals << endl; ndbout << "cgetSignals=" << cgetSignals << endl; ndbout << "creleaseSignals=" << creleaseSignals << endl; #endif // Poor mans purifier assert(cnewSignals == cfreeSignals); assert(cgetSignals == creleaseSignals); #endif DBUG_VOID_RETURN; }
TestClient::TestClient() : KMainWindow( 0 ), m_status( AppDisconnected ), m_view( new QWidget( this ) ) { ui.setupUi( m_view ); setCentralWidget(m_view); networkStatusChanged( Solid::Networking::status() ); appDisconnected(); kDebug() << "About to connect"; connect( Solid::Networking::notifier(), SIGNAL(statusChanged(Solid::Networking::Status)), SLOT(networkStatusChanged(Solid::Networking::Status)) ); kDebug() << "Connected."; connect( Solid::Networking::notifier(), SIGNAL(shouldConnect()), this, SLOT(doConnect()) ); connect( Solid::Networking::notifier(), SIGNAL(shouldDisconnect()), this, SLOT(doDisconnect()) ); connect( ui.connectButton, SIGNAL(clicked()), SLOT(connectButtonClicked()) ); }
void ConnectDialog::on_pbConnect_toggled(bool checked) { auto client = ClientConnection::Instance(); if (checked) { if (ui->lePicsPath->text() == "") { Logger::error("Select folder with pics"); return; } picsPath = ui->lePicsPath->text(); if (picsPath.right(1) != "/") picsPath.append("/"); client->doConnectToHost(ui->leHost->text(), ui->sbPort->value()); ui->pbConnect->setText("Process..."); } else { client->doDisconnect(); } }
int dfs_statfs(const char *path, struct statvfs *st) { TRACE1("statfs",path) dfs_context *dfs = (dfs_context*)fuse_get_context()->private_data; assert(path); assert(st); assert(dfs); memset(st,0,sizeof(struct statvfs)); hdfsFS userFS = doConnectAsUser(dfs->nn_hostname, dfs->nn_port); if (userFS == NULL) { ERROR("Could not connect"); return -EIO; } const tOffset cap = hdfsGetCapacity(userFS); const tOffset used = hdfsGetUsed(userFS); const tOffset bsize = hdfsGetDefaultBlockSize(userFS); if (doDisconnect(userFS)) { return -EIO; } st->f_bsize = bsize; st->f_frsize = bsize; st->f_blocks = cap/bsize; st->f_bfree = (cap-used)/bsize; st->f_bavail = (cap-used)/bsize; st->f_files = 1000; st->f_ffree = 500; st->f_favail = 500; st->f_fsid = 1023; st->f_flag = ST_RDONLY | ST_NOSUID; st->f_namemax = 1023; return 0; }
// Received new data: void received(int id, asio::streambuf &readBuffer, std::size_t bytesTransferred) { string dataStr(boost::asio::buffer_cast<const char*>(readBuffer.data()), readBuffer.size()); string error; //we're expecting a new request: if (mState==REQUEST || mState==WAIT_LONGPOLL) { //if there is still an outstanding longpoll, cancel it: if (mState==WAIT_LONGPOLL) { respond(true); } //resize data to first delimiter: dataStr.resize(dataStr.find(delimiter)+delimiter.length()); readBuffer.consume(dataStr.length()); DEB(id << " got http REQUEST: \n" << dataStr); //determine the kind of request: smatch what; if (!regex_search( dataStr, what, boost::regex("^(GET|POST) ([^? ]*)([^ ]*) HTTP/(1..)$") )) { error="Cant parse request."; } else { mRequestType=what[1]; mRequestUrl=what[2]; mRequestQuery=what[3]; mRequestVersion=what[4]; DEB("REQUEST query: " << mRequestQuery); //create a regex iterator for http headers mHeaders.clear(); boost::sregex_iterator headerI( dataStr.begin(), dataStr.end(), boost::regex("^([[:alnum:]-]*): (.*?)$") ); //parse http headers while (headerI!=sregex_iterator()) { string header=(*headerI)[1].str(); string value=(*headerI)[2].str(); //headers handling is lowercase in synapse! transform(header.begin(), header.end(), header.begin(), ::tolower); mHeaders[header]=value; headerI++; } //this header MUST be set on longpoll requests: //if the client doesnt has one yet, httpSessionMan will assign a new one. try { mAuthCookie=mHeaders["x-synapse-authcookie"]; } catch(...) { mAuthCookie=0; } //proceed based on requestType: //a GET or empty POST: if (mRequestType=="GET" || (int)mHeaders["content-length"]==0) { if (respond()) { mState=REQUEST; } else { DEB(id << " is now waiting for longpoll results"); mState=WAIT_LONGPOLL; } return; } //a POST with content: else { if ( (int)mHeaders["content-length"]<0 || (int)mHeaders["content-length"] > config["maxContent"] ) { error="Invalid Content-Length"; } else { //change state to read the contents of the POST: mState=CONTENT; return; } } } } else //we're expecting the contents of a POST request. if (mState==CONTENT) { if (readBuffer.size() < mHeaders["content-length"]) { error="Didn't receive enough content-bytes!"; DEB(id << " ERROR: Expected " << mHeaders["content-length"].str() << " bytes, but only got: " << bytesTransferred); } else { dataStr.resize(mHeaders["content-length"]); readBuffer.consume(mHeaders["content-length"]); DEB(id << " got http CONTENT with length=" << dataStr.size() << ": \n" << dataStr); //POST to the special send url? if (mRequestUrl=="/synapse/send") { error=httpSessionMan.sendMessage(mAuthCookie, dataStr); if (error=="") { //DONT:respond with jsondata if we have something in the queue anyways //DONT:respondJsonQueue(false,false); //we cant do this, because then the order of messages isnt garanteed. so just respond with a boring empty string: respondString(200, ""); } else respondError(400, error); mState=REQUEST; return; } else { //ignore whatever is posted, and just respond normally: DEB(id << " ignored POST content"); if (respond()) mState=REQUEST; else mState=WAIT_LONGPOLL; return; } } } //ERROR(id << " had error while processing http data: " << error); error="Bad request: "+error; respondError(400, error); doDisconnect(); return; }
void SCI_Transporter::setupRemoteSegment() { DBUG_ENTER("SCI_Transporter::setupRemoteSegment"); Uint32 sharedSize = 0; sharedSize =4096; //start of the buffer is page aligned Uint32 sizeOfBuffer = m_BufferSize; const Uint32 slack = MAX_MESSAGE_SIZE; sizeOfBuffer -= sharedSize; Uint32 *segPtr = (Uint32*) m_TargetSegm[m_ActiveAdapterId].mappedMemory ; Uint32 * remoteReadIndex = (Uint32*)segPtr; Uint32 * remoteWriteIndex = (Uint32*)(segPtr + 1); m_remoteStatusFlag = (Uint32*)(segPtr + 3); char * remoteStartOfBuf = ( char*)((char*)segPtr+(sharedSize)); writer = new SHM_Writer(remoteStartOfBuf, sizeOfBuffer, slack, remoteReadIndex, remoteWriteIndex); writer->clear(); m_TargetSegm[0].writer=writer; m_sendBuffer.m_forceSendLimit = writer->getBufferSize(); if(createSequence(m_ActiveAdapterId)!=SCI_ERR_OK) { report_error(TE_SCI_UNABLE_TO_CREATE_SEQUENCE); DBUG_PRINT("error", ("Unable to create sequence on active")); doDisconnect(); } if (m_adapters > 1) { segPtr = (Uint32*) m_TargetSegm[m_StandbyAdapterId].mappedMemory ; Uint32 * remoteReadIndex2 = (Uint32*)segPtr; Uint32 * remoteWriteIndex2 = (Uint32*) (segPtr + 1); m_remoteStatusFlag2 = (Uint32*)(segPtr + 3); char * remoteStartOfBuf2 = ( char*)((char *)segPtr+sharedSize); /** * setup a writer. writer2 is used to mirror the changes of * writer on the standby * segment, so that in the case of a failover, we can switch * to the stdby seg. quickly.* */ writer2 = new SHM_Writer(remoteStartOfBuf2, sizeOfBuffer, slack, remoteReadIndex2, remoteWriteIndex2); * remoteReadIndex = 0; * remoteWriteIndex = 0; writer2->clear(); m_TargetSegm[1].writer=writer2; if(createSequence(m_StandbyAdapterId)!=SCI_ERR_OK) { report_error(TE_SCI_UNABLE_TO_CREATE_SEQUENCE); DBUG_PRINT("error", ("Unable to create sequence on standby")); doDisconnect(); } } DBUG_VOID_RETURN; } //setupRemoteSegment
SHM_Transporter::~SHM_Transporter(){ doDisconnect(); }
SCI_Transporter::~SCI_Transporter() { DBUG_ENTER("SCI_Transporter::~SCI_Transporter"); // Close channel to the driver doDisconnect(); DBUG_VOID_RETURN; } // ~SCI_Transporter()
/***************************************************************************** * ~Ndb(); * * Remark: Disconnect with the database. *****************************************************************************/ Ndb::~Ndb() { DBUG_ENTER("Ndb::~Ndb()"); DBUG_PRINT("enter",("this: 0x%lx", (long) this)); if (m_sys_tab_0) getDictionary()->removeTableGlobal(*m_sys_tab_0, 0); if (theImpl->m_ev_op != 0) { g_eventLogger->warning("Deleting Ndb-object with NdbEventOperation still" " active"); printf("this: %p NdbEventOperation(s): ", this); for (NdbEventOperationImpl *op= theImpl->m_ev_op; op; op=op->m_next) { printf("%p ", op); } printf("\n"); fflush(stdout); } assert(theImpl->m_ev_op == 0); // user should return NdbEventOperation's for (NdbEventOperationImpl *op= theImpl->m_ev_op; op; op=op->m_next) { if (op->m_state == NdbEventOperation::EO_EXECUTING && op->stop()) g_eventLogger->error("stopping NdbEventOperation failed in Ndb destructor"); op->m_magic_number= 0; } doDisconnect(); /* Disconnect from transporter to stop signals from coming in */ theImpl->close(); delete theEventBuffer; releaseTransactionArrays(); delete []theConnectionArray; delete []theConnectionArrayLast; if(theCommitAckSignal != NULL){ delete theCommitAckSignal; theCommitAckSignal = NULL; } theImpl->m_ndb_cluster_connection.unlink_ndb_object(this); delete theImpl; #ifdef POORMANSPURIFY #ifdef POORMANSGUI ndbout << "cnewSignals=" << cnewSignals << endl; ndbout << "cfreeSignals=" << cfreeSignals << endl; ndbout << "cgetSignals=" << cgetSignals << endl; ndbout << "creleaseSignals=" << creleaseSignals << endl; #endif // Poor mans purifier assert(cnewSignals == cfreeSignals); assert(cgetSignals == creleaseSignals); #endif DBUG_VOID_RETURN; }
QtUdpSocketPlugin::QtUdpSocketPlugin() : _socket(nullptr), _helperReceiveCallback(), _checkerReceiveCallback(), _messageCounter(0), _conditionLock(), _conditionVariable(), _targetHost(), _targetPort(0) { QObject::connect(this, SIGNAL(doListen(quint16)), this, SLOT(onListen(quint16))); QObject::connect(this, SIGNAL(doConnect(QString, quint16)), this, SLOT(onConnect(QString, quint16))); QObject::connect(this, SIGNAL(doSendMessage(QString)), this, SLOT(onSendMessage(QString))); QObject::connect(this, SIGNAL(doDisconnect()), this, SLOT(onDisconnect())); }
sci_error_t SCI_Transporter::initLocalSegment() { DBUG_ENTER("SCI_Transporter::initLocalSegment"); Uint32 segmentSize = m_BufferSize; Uint32 offset = 0; sci_error_t err; if(!m_sciinit) { for(Uint32 i=0; i<m_adapters ; i++) { SCIOpen(&(sciAdapters[i].scidesc), FLAGS, &err); sciAdapters[i].localSciNodeId=getLocalNodeId(i); DBUG_PRINT("info", ("SCInode iD %d adapter %d\n", sciAdapters[i].localSciNodeId, i)); if(err != SCI_ERR_OK) { DBUG_PRINT("error", ("Cannot open an SCI virtual device. Error code 0x%x", err)); DBUG_RETURN(err); } } } m_sciinit=true; SCICreateSegment(sciAdapters[0].scidesc, &(m_SourceSegm[0].localHandle), hostSegmentId(localNodeId, remoteNodeId), segmentSize, 0, 0, 0, &err); if(err != SCI_ERR_OK) { DBUG_PRINT("error", ("Error creating segment, err = 0x%x", err)); DBUG_RETURN(err); } else { DBUG_PRINT("info", ("created segment id : %d", hostSegmentId(localNodeId, remoteNodeId))); } /** Prepare the segment*/ for(Uint32 i=0; i < m_adapters; i++) { SCIPrepareSegment((m_SourceSegm[0].localHandle), i, FLAGS, &err); if(err != SCI_ERR_OK) { DBUG_PRINT("error", ("Local Segment is not accessible by an SCI adapter. Error code 0x%x\n", err)); DBUG_RETURN(err); } } m_SourceSegm[0].mappedMemory = SCIMapLocalSegment((m_SourceSegm[0].localHandle), &(m_SourceSegm[0].lhm[0].map), offset, segmentSize, NULL, FLAGS, &err); if(err != SCI_ERR_OK) { DBUG_PRINT("error", ("Cannot map area of size %d. Error code 0x%x", segmentSize,err)); doDisconnect(); DBUG_RETURN(err); } /** Make the local segment available*/ for(Uint32 i=0; i < m_adapters; i++) { SCISetSegmentAvailable((m_SourceSegm[0].localHandle), i, FLAGS, &err); if(err != SCI_ERR_OK) { DBUG_PRINT("error", ("Local Segment is not available for remote connections. Error code 0x%x\n", err)); DBUG_RETURN(err); } } setupLocalSegment(); DBUG_RETURN(err); } // initLocalSegment()
/** Respond by sending a file relative to the wwwdir/ */ bool respondFile(string path) { Cvar extraHeaders; //FIXME: do a better way of checking/securing the path. Inode verification? Or compare with a filelist? if (path.find("..")!=string::npos) { respondError(403, "Path contains illegal characters"); return(true); } //default path? if (path=="/") { path=config["indexFile"].str(); } string localPath; localPath="wwwdir/"+path; struct stat statResults; int statError=stat(localPath.c_str(), &statResults); if (statError) { respondError(404, "Error while statting or file not found: " + path); return(true); } if (! (S_ISREG(statResults.st_mode)) ) { respondError(404, "Path " + path + " is not a regular file"); return(true); } ifstream inputFile(localPath.c_str(), std::ios::in | std::ios::binary); if (!inputFile.good() ) { respondError(404, "Error while opening " + path ); return(true); } //determine content-type smatch what; if (regex_search( path, what, boost::regex("([^.]*$)") )) { string extention=what[1]; if (config["contentTypes"].isSet(extention)) { extraHeaders["content-type"]=config["contentTypes"][extention]; DEB("Content type of ." << extention << " is " << config["contentTypes"][extention].str()); } else { WARNING("Cannot determine content-type of ." << extention << " files"); } } //determine filesize inputFile.seekg (0, ios::end); int fileSize=inputFile.tellg(); inputFile.seekg (0, ios::beg); extraHeaders["Content-Length"]=fileSize; //enable browser caching with the right headers: extraHeaders["Cache-Control"]="public, max-age=290304000"; getHttpDate(extraHeaders["Date"].str()); sendHeaders(200, extraHeaders); DEB(id << " sending CONTENT of " << path); char buf[4096]; //TODO: is there a better way to do this? int sendSize=0; while (inputFile.good()) { inputFile.read(buf ,sizeof(buf)); if (!sendData(asio::buffer(buf, inputFile.gcount()))) { break; } sendSize+=inputFile.gcount(); } if (sendSize!=fileSize) { ERROR(id << " error during file transfer, disconnecting"); doDisconnect(); } return true; }
void QtUdpSocketPlugin::disconnect() { emit doDisconnect(); _messageCounter = 0; _helperReceiveCallback = std::function<void(QString)>(); _checkerReceiveCallback = std::function<void(void)>(); }
void ConnectionWindow::connectionClosed() { doDisconnect(); }