void Pillow::HttpClient::device_connected() { sendRequest(); }
void MNMClass::requestSong(uint8_t _song) { sendRequest(MNM_SONG_REQUEST_ID, _song); }
// Send HTTP get and wait for response (SSL/SPP) static int http_request(char *filename, char *proto, bool requestingFile, struct timeval *tvEnd){ char buf[BUFSIZZ]; int r; int len; long bytes_read = 0; // Compute expected data size fSize = atoi(filename); if (fSize == 0 && filename[0] != '0'){ if (requestingFile){ fSize = calculate_file_size(filename); }else{ fSize = strlen("HTTP/1.0 200 OK\r\n"); } } sizeCheck = fSize; experiment_info->file_size = fSize; // Request file (either by name or by size) if (requestingFile){ sendRequest(filename); } // Now read the server's response, assuming that it's terminated by a close while(1){ // SPP read if (strcmp(proto, "spp") == 0){ /* #ifdef DEBUG printf("[DEBUG] SPP_read\n"); #endif */ SPP_SLICE *slice; // slice for SPP_read SPP_CTX *ctx; // context pointer for SPP_read r = SPP_read_record(ssl, buf, BUFSIZZ, &slice, &ctx); #ifdef DEBUG printf("[INFO] Read %d bytes\n", r); #endif if (ssl->read_stats.app_bytes == fSize){ printf("[INFO] Read %d bytes as expected (fSize=%d). Stopping timer\n", ssl->read_stats.app_bytes, fSize); // Stop the timer here (avoid shutdown crap) gettimeofday(tvEnd, NULL); #ifdef VERBOSE fwrite(buf, 1, len, stdout); #endif break; //goto shutdown; } switch(SSL_get_error(ssl, r)){ case SSL_ERROR_NONE: len = r; break; case SSL_ERROR_ZERO_RETURN: goto shutdown; case SSL_ERROR_SYSCALL: fprintf(stderr, "SSL Error: Premature close\n"); goto done; default: berr_exit("SSL read problem"); } } // SSL read else if (strcmp(proto, "ssl") == 0){ /* #ifdef DEBUG printf("[DEBUG] SSL_read\n"); #endif */ r = SSL_read(ssl, buf, BUFSIZZ); #ifdef DEBUG printf("[DEBUG] Read %d bytes\n", r); #endif if (ssl->read_stats.app_bytes == fSize){ printf("[INFO] Read %d bytes as expected (fSize=%d). Stopping timer\n", ssl->read_stats.app_bytes, fSize); gettimeofday(tvEnd, NULL); // Write buf to stdout #ifdef VERBOSE fwrite(buf, 1, len, stdout); #endif break; } switch(SSL_get_error(ssl, r)){ case SSL_ERROR_NONE: len = r; break; case SSL_ERROR_ZERO_RETURN: goto shutdown; case SSL_ERROR_SYSCALL: fprintf(stderr, "SSL Error: Premature close\n"); goto done; default: berr_exit("SSL read problem"); } } // SSL read else if (strcmp(proto, "pln") == 0){ #ifdef DEBUG printf("[DEBUG] Waiting to read bytes in plain mode\n"); #endif r = read(plain_socket, buf, BUFSIZZ); experiment_info->app_bytes_read += r; bytes_read += r; #ifdef DEBUG printf("[DEBUG] Read %d bytes\n", r); #endif if ( r <= 0 || bytes_read == fSize) /* done reading */ { #ifdef DEBUG printf("[DEBUG] File transfer done, done reading socket...\n"); #endif gettimeofday(tvEnd, NULL); // Write buf to stdout #ifdef VERBOSE fwrite(buf, 1, len, stdout); #endif goto done; } } // Write buf to stdout #ifdef VERBOSE fwrite(buf, 1, len, stdout); #endif } shutdown: #ifdef DEBUG printf("[DEBUG] Shutdown was requested\n"); #endif r = SSL_shutdown(ssl); if( !r ){ shutdown(SSL_get_fd(ssl), 1); r = SSL_shutdown(ssl); } switch(r){ case 1: break; // Success case 0: case -1: default: #ifdef DEBUG printf ("Shutdown failed with code %d\n", r); #endif berr_exit("Shutdown failed"); } done: if (stats){ print_stats(ssl); } SSL_free(ssl); return(0); }
void LogFile::updateMonitor() { sendRequest(sensors().at(0)->hostName(), QString("%1 %2" ).arg(sensors().at(0)->name()).arg(logFileID), 19); }
void MNMClass::requestKit(uint8_t _kit) { sendRequest(MNM_KIT_REQUEST_ID, _kit); }
int Video::upload_data( const uint64_t fileSize, const string &sha, const uint64_t sliceSize, const string &sign, const string &url, const string &srcPath, const uint64_t offset, const string &session ) { int ret = 0; char tmp_buf[1024]; char buf[sliceSize]; vector<string> headers; headers.push_back("Authorization: " + sign); ifstream fileInput(srcPath.c_str(), ios::in | ios::binary); fileInput.seekg(offset); uint64_t pos = offset; while (fileSize > pos) { reset(); uint64_t len =0; fileInput.read(buf, sliceSize); len = fileInput.gcount(); struct curl_httppost *firstitem = NULL, *lastitem = NULL; ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "op", CURLFORM_COPYCONTENTS, "upload_slice", CURLFORM_END); snprintf(tmp_buf, sizeof(tmp_buf), "%lu", pos); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "offset", CURLFORM_COPYCONTENTS, tmp_buf, CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "session", CURLFORM_COPYCONTENTS, session.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "filecontent", CURLFORM_BUFFER, "data", CURLFORM_BUFFERPTR, buf, CURLFORM_BUFFERLENGTH, len, CURLFORM_END); int retry_times = 0; do { sendRequest( url, 1, &headers, NULL, firstitem); dump_res(); if (retCode == 0) { break; } retry_times++; } while(retry_times < MAX_RETRY_TIMES); curl_formfree(firstitem); if (retCode != 0) { return retCode; } pos += sliceSize; } return retCode; }
void HelpBrowser::gotoHelpFor( const QString & symbol ) { QString code = QString("HelpBrowser.openHelpFor(\"%1\")").arg(symbol); sendRequest(code); }
void SMTPConnection::authenticateSASL() { if (!dynamicCast <security::sasl::SASLAuthenticator>(getAuthenticator())) throw exceptions::authentication_error("No SASL authenticator available."); // Obtain SASL mechanisms supported by server from ESMTP extensions std::vector <string> saslMechs; hasExtension("AUTH", &saslMechs); if (saslMechs.empty()) throw exceptions::authentication_error("No SASL mechanism available."); std::vector <shared_ptr <security::sasl::SASLMechanism> > mechList; shared_ptr <security::sasl::SASLContext> saslContext = make_shared <security::sasl::SASLContext>(); for (unsigned int i = 0 ; i < saslMechs.size() ; ++i) { try { mechList.push_back (saslContext->createMechanism(saslMechs[i])); } catch (const exceptions::no_such_mechanism&) { // Ignore mechanism } } if (mechList.empty()) throw exceptions::authentication_error("No SASL mechanism available."); // Try to suggest a mechanism among all those supported shared_ptr <security::sasl::SASLMechanism> suggestedMech = saslContext->suggestMechanism(mechList); if (!suggestedMech) throw exceptions::authentication_error("Unable to suggest SASL mechanism."); // Allow application to choose which mechanisms to use mechList = dynamicCast <security::sasl::SASLAuthenticator>(getAuthenticator())-> getAcceptableMechanisms(mechList, suggestedMech); if (mechList.empty()) throw exceptions::authentication_error("No SASL mechanism available."); // Try each mechanism in the list in turn for (unsigned int i = 0 ; i < mechList.size() ; ++i) { shared_ptr <security::sasl::SASLMechanism> mech = mechList[i]; shared_ptr <security::sasl::SASLSession> saslSession = saslContext->createSession("smtp", getAuthenticator(), mech); saslSession->init(); if (saslSession->getMechanism()->hasInitialResponse()) { byte_t* initialResp = 0; size_t initialRespLen = 0; saslSession->evaluateChallenge(NULL, 0, &initialResp, &initialRespLen); string encodedInitialResp(saslContext->encodeB64(initialResp, initialRespLen)); delete [] initialResp; if (encodedInitialResp.empty()) sendRequest(SMTPCommand::AUTH(mech->getName(), "=")); else sendRequest(SMTPCommand::AUTH(mech->getName(), encodedInitialResp)); } else { sendRequest(SMTPCommand::AUTH(mech->getName())); } for (bool cont = true ; cont ; ) { shared_ptr <SMTPResponse> response = readResponse(); switch (response->getCode()) { case 235: { m_socket = saslSession->getSecuredSocket(m_socket); return; } case 334: { byte_t* challenge = nullptr; size_t challengeLen = 0; byte_t* resp = nullptr; size_t respLen = 0; try { // Extract challenge saslContext->decodeB64(response->getText(), &challenge, &challengeLen); // Prepare response saslSession->evaluateChallenge (challenge, challengeLen, &resp, &respLen); // Send response const string respB64 = saslContext->encodeB64(resp, respLen) + "\r\n"; m_socket->sendRaw(utility::stringUtils::bytesFromString(respB64), respB64.length()); if (m_tracer) m_tracer->traceSendBytes(respB64.length() - 2, "SASL exchange"); } catch (const exceptions::sasl_exception& e) { delete [] challenge; challenge = nullptr; delete [] resp; resp = nullptr; // Cancel SASL exchange m_socket->send("*\r\n"); if (m_tracer) m_tracer->traceSend("*"); } catch (...) { delete [] challenge; delete [] resp; throw; } delete [] challenge; delete [] resp; break; } default: cont = false; break; } } } throw exceptions::authentication_error ("Could not authenticate using SASL: all mechanisms failed."); }
lineEdit()->setStyleSheet(QLatin1String("QLineEdit {background:transparent;}")); lineEdit()->installEventFilter(this); ToolBarWidget *toolBar = qobject_cast<ToolBarWidget*>(parent); if (toolBar && toolBar->getIdentifier() != ToolBarsManager::NavigationBar) { connect(toolBar, SIGNAL(windowChanged(Window*)), this, SLOT(setWindow(Window*))); } connect(SearchesManager::getInstance(), SIGNAL(searchEnginesModified()), this, SLOT(storeCurrentSearchEngine())); connect(SearchesManager::getInstance(), SIGNAL(searchEnginesModelModified()), this, SLOT(restoreCurrentSearchEngine())); connect(SettingsManager::getInstance(), SIGNAL(valueChanged(QString,QVariant)), this, SLOT(optionChanged(QString,QVariant))); connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(currentIndexChanged(int))); connect(lineEdit(), SIGNAL(textChanged(QString)), this, SLOT(queryChanged(QString))); connect(m_completer, SIGNAL(activated(QString)), this, SLOT(sendRequest(QString))); setWindow(window); } void SearchWidget::changeEvent(QEvent *event) { QComboBox::changeEvent(event); if (event->type() == QEvent::LanguageChange && itemData(currentIndex(), Qt::AccessibleDescriptionRole).toString().isEmpty()) { lineEdit()->setPlaceholderText(tr("Search using %1").arg(currentData(Qt::UserRole).toString())); } } void SearchWidget::paintEvent(QPaintEvent *event)
Bool TERMWINDOWMEMBER dc15network(Bool master) { char line[100], line2[100]; label here, there; FILE *file; int i, rms; Bool done = FALSE; netFailed = FALSE; const protocols *theProt = GetProtocolByKey(node->GetProtocol(), TRUE); if (!theProt) { doccr(); cPrintf(getnetmsg(177)); doCR(); return (FALSE); } if (!CommPort->HaveConnection()) { return (FALSE); } sprintf(line, sbs, LocalTempPath, mesgTmp); unlink(line); sprintf(line, getnetmsg(123), LocalTempPath); unlink(line); sprintf(line, getnetmsg(124), LocalTempPath); unlink(line); sprintf(line, getnetmsg(125), LocalTempPath); unlink(line); if ((file = fopen(line, FO_AB)) == NULL) { perror(getnetmsg(25)); return (FALSE); } for (i = get_first_room(here, there), rms = 0; i; i = get_next_room(here, there), rms++) { PutStr(file, there); } PutStr(file, ns); fclose(file); if (master) { sendRequest(theProt); if (!CommPort->HaveConnection()) { return (FALSE); } reciveRequest(theProt); } else { reciveRequest(theProt); if (!CommPort->HaveConnection()) { return (FALSE); } sendRequest(theProt); } if (!CommPort->HaveConnection() || netFailed) { return (FALSE); } if (master) { // clear the buffer while (CommPort->HaveConnection() && CommPort->IsInputReady()) { CommPort->Input(); } } makeSendFile(); if (!CommPort->HaveConnection() || netFailed) { return (FALSE); } // wait for them to get their shit together cPrintf(getnetmsg(11)); CommPort->Output('X'); time_t t2 = 0; const time_t t = time(NULL); while (CommPort->HaveConnection() && !done) { if (time(NULL) > (t + (node->GetFetchTimeout() * 60))) { CITWINDOW *w = ScreenSaver.IsOn() ? NULL : CitWindowsMsg(NULL, getmsg(685), getmsg(73)); Hangup(); netFailed = TRUE; if (w) { destroyCitWindow(w, FALSE); } } KBReady(); if (CommPort->IsInputReady()) { i = CommPort->Input(); if (i == 'X' || node->GetNetworkType() != NET_DCIT16) { done = TRUE; } else { DebugOut(pctc, i); } } // wake them up! (every second) if (time(NULL) != t2) { CommPort->Output('X'); t2 = time(NULL); } // instantaneous reaction time isn't critical here CitIsIdle(); } // wake them up! for (i = 0; i < 10; i++) { CommPort->Output('X'); } doccr(); if (!CommPort->HaveConnection() || netFailed) { return (FALSE); } if (master) { receiveFiles(theProt); if (!CommPort->HaveConnection() || netFailed) { return (FALSE); } sendFiles(theProt); } else { sendFiles(theProt); if (!CommPort->HaveConnection() || netFailed) { return (FALSE); } receiveFiles(theProt); } if (netFailed) { return (FALSE); } cPrintf(getnetmsg(84)); doccr(); CITWINDOW *w = ScreenSaver.IsOn() ? NULL : CitWindowsMsg(NULL, getmsg(82)); Hangup(); if (w) { destroyCitWindow(w, FALSE); } OC.setio(); // hmmm cPrintf(getnetmsg(85), cfg.Lmsg_nym); doccr(); sformat(line, node->GetExtractPacket(), getmsg(48), roomdataIn, 0); apsystem(line, TRUE); changedir(LocalTempPath); unlink(roomdataIn); for (i = 0; i < rms; i++) { sprintf(line, getnetmsg(126), i); sprintf(line2, getnetmsg(127), i); rename(line, line2); } sprintf(line, sbs, LocalTempPath, mesgTmp); sprintf(line2, getnetmsg(123), LocalTempPath); rename(line, line2); return (TRUE); }
/** * Handle client communications */ void client_task_impl() { uip_tcp_appstate_t *app = &(uip_conn->appstate); GETrequest *req = (GETrequest*)app->request; if (uip_connected()) { if (verbose) { Serial.print("Connected to "); Serial.println(req->hostName); } app->ackedCount = 0; sendRequest(); } // Did we get an ack for the last packet? if (uip_acked()) { // Record the bytes that were successfully sent app->ackedCount += app->sentCount; app->sentCount = 0; // Check if we're done or need to send more content for this // request if (app->ackedCount != (int)app->cursor) { // Generate the post again to send the next packet of data sendRequest(); } } if (uip_rexmit()) { sendRequest(); } if (uip_newdata()) { setRXPin(HIGH); if (verbose) { Serial.print("RX "); Serial.print(uip_datalen()); Serial.print(" bytes from "); Serial.println(req->hostName); } // Check if the sketch cares about the returned data if ((req->returnFunc) && (uip_datalen() > 0)){ // Call the sketch's callback function req->returnFunc((char*)uip_appdata, uip_datalen()); } } if (uip_aborted() || uip_timedout() || uip_closed()) { if (req != NULL) { if (verbose) { Serial.print("Ended connection with "); Serial.println(req->hostName); } if (req->returnFunc) { // Call the sketch's callback function with 0 bytes to indicate End Of Data req->returnFunc((char*)uip_appdata, 0); } // Remove the request from the connection app->request = NULL; // Request is no longer active req->active = false; } } }
void YahooFinanceNetworkRequest::handleReply(QNetworkReply *pReply) { if (!pReply) { qDebug() << "YahooFinanceNetworkRequest::handleReply, null handle, ignored"; return; } if (pReply == mpNetworkReply.data()) { qDebug() << "YahooFinanceNetworkRequest::handleReply, reply belongs to us, parsing data..."; const QVariant http_status_code = pReply->attribute( QNetworkRequest::HttpStatusCodeAttribute); bool is_error = pReply->error() != QNetworkReply::NoError; qDebug() << "YahooFinanceNetworkRequest::handleReply, HTTP status:" << http_status_code.toString() << ", is error:" << is_error; if (!is_error && HTTP_REPLY_CODE_OK == http_status_code.toInt()) { int line_index = 0; while (pReply->canReadLine() && mTickers.count() > line_index) { const QString line(pReply->readLine()); const QString ticker = mTickers.at(line_index); const QStringList data = line.simplified().split(","); if (mParameters.count() == data.count()) { QMap<YahooFinance::StockParameter, QString> data_mappings; for (int value_index = 0; value_index < data.count(); value_index++) { const YahooFinance::StockParameter param = mParameters.at(value_index); const QString value = data.at(value_index); qDebug() << "ticker:" << ticker << ", param:" << param << ", value:" << value; data_mappings.insert(param, value); } emit parametersReceived(mQueryIdentifier, ticker, data_mappings); } else { handleError(); } line_index++; } } else if (HTTP_REPLY_MOVED_PERMANENTLY == http_status_code) { const QVariant redirection_url = pReply->attribute( QNetworkRequest::RedirectionTargetAttribute); qDebug() << "Moved permanently, url:" << redirection_url; mUrl.setUrl(redirection_url.toString()); sendRequest(); } else { handleError(); qDebug() << "YahooFinanceNetworkRequest::handleReply, ERROR"; } mpNetworkReply.reset(); } else { qDebug() << "YahooFinanceNetworkRequest::handleReply, unknown handle, not handled"; pReply->deleteLater(); } }
am_status_t BaseService::doRequest(const ServiceInfo& service, const BodyChunk& headerPrefix, const std::string& uriParameters, const Http::CookieList& cookieList, const BodyChunk& headerSuffix, const BodyChunkList& bodyChunkList, Http::Response& response, const ServerInfo** serverInfo) const { am_status_t status = AM_SERVICE_NOT_AVAILABLE; int dataLen = 0; BodyChunk emptyContentLine; // Create a temporary buffer for the Content-Line header // the extra '2' is for the <CR><LF> at the end. The // sizeof the CONTENT_LENGTH_HDR includes space for the // terminating NUL. const std::size_t contentLineLen_sz = sizeof (CONTENT_LENGTH_HDR) + (sizeof (dataLen) * DIGITS_PER_BYTE) + 2; char contentLine[contentLineLen_sz + 1]; std::size_t contentLineLen = 0; for (unsigned int i = 0; i < bodyChunkList.size(); ++i) { dataLen += bodyChunkList[i].data.size(); } memset(&contentLine[0], 0, contentLineLen_sz); contentLineLen = snprintf(contentLine, contentLineLen_sz, "%s%d\r\n", CONTENT_LENGTH_HDR, dataLen); if (contentLineLen_sz > contentLineLen && contentLineLen > 0) { BodyChunk contentLineChunk(contentLine, contentLineLen); ServiceInfo::const_iterator iter; ServiceInfo svc(service); int j = -1, current_index = -1; if (am_web_naming_validation_status() < 2 && svc.getNumberOfServers() > 1) { /* validation is enabled and number of servers is more than one */ char *current_value = read_naming_value(AM_NAMING_LOCK, Log::getLockId()); if (current_value != NULL) { current_index = strtol(current_value, NULL, 10); if (current_index < 0 || errno == ERANGE) { current_index = 0; } else { Log::log(logModule, Log::LOG_MAX_DEBUG, "BaseService::doRequest(): will be using url index: %d", current_index); } free(current_value); } else { current_index = 0; } if ((size_t) current_index >= svc.getNumberOfServers()) { Log::log(logModule, Log::LOG_WARNING, "BaseService::doRequest(): invalid url index: %d (out of %d); validation results ignored.", current_index, svc.getNumberOfServers()); current_index = -1; } } for (iter = svc.begin(); iter != svc.end(); ++iter) { const ServerInfo &svrInfo = (*iter); if (current_index != -1) { if ((++j) != current_index) { Log::log(logModule, Log::LOG_MAX_DEBUG, "BaseService::doRequest(): skipping url(%d) %s", j, svrInfo.getURL().c_str()); continue; } else { Log::log(logModule, Log::LOG_MAX_DEBUG, "BaseService::doRequest(): using url(%d) %s", j, svrInfo.getURL().c_str()); } } Http::HeaderList headerList, proxyHeaderList; Http::Cookie hostHeader("Host", svrInfo.getHost()); headerList.push_back(hostHeader); #ifdef AGENT_PROXY_SUPPORT #ifndef _MSC_VER if (useProxy) { proxyHeaderList.push_back(hostHeader); // Override (temporarily) server credentials if using proxy //svrInfo.setHost(proxyHost); //svrInfo.setPort(proxyPort); // We don't use SSL for initial proxy connection //svrInfo.setUseSSL(false); Log::log(logModule, Log::LOG_DEBUG, "BaseService::doRequest(): Using proxy: %s:%d", proxyHost.c_str(), proxyPort); // Add Proxy-Authorization header if user defined if (useProxyAuth) { // allocate enough for a base64-encoded digest size_t authSize = proxyUser.size() + proxyPassword.size() + 1; // 11 extra bytes for prefix and terminator char * digest = (char *) malloc(authSize * 4 / 3 + 11); strcpy(digest, "Basic "); encode_base64((proxyUser + ":" + proxyPassword).c_str(), authSize, (digest + 6)); Log::log(logModule, Log::LOG_MAX_DEBUG, "BaseService::doRequest(): Using proxy auth as: %s", proxyUser.c_str()); hostHeader = Http::Cookie("Proxy-Authorization", digest); proxyHeaderList.push_back(hostHeader); free(digest); } } #endif #endif // retry to connect to server before marking it as down. // making the number of attempts configurable may have a negative // side effect on performance, if the the value is a high number. int retryAttempts = 3; int retryCount = 0; while (retryCount < retryAttempts) { retryCount++; try { const char *operation = "sending to"; Connection conn(svrInfo.getHost().c_str(), svrInfo.getPort(), svrInfo.useSSL()); #ifdef AGENT_PROXY_SUPPORT std::string requestString = svrInfo.getURI().c_str(); /* * In case the following request would go to a proxy * we need to use full URL and special headers. */ if (useProxy && !(iter->useSSL())) { requestString = iter->getURL(); headerList = proxyHeaderList; } #endif status = sendRequest(conn, headerPrefix, svrInfo.getURI(), uriParameters, headerList, cookieList, dataLen > 0 ? contentLineChunk : emptyContentLine, headerSuffix, bodyChunkList); if (AM_SUCCESS == status) { operation = "receiving from"; status = response.readAndParse(logModule, conn); if (AM_SUCCESS == status) { Log::log(logModule, Log::LOG_MAX_DEBUG, "Response::readAndParse() (%d) %s", response.getBodyLen(), response.getBodyPtr() ? response.getBodyPtr() : "(NULL)"); } } if (AM_NSPR_ERROR == status) { Log::log(logModule, Log::LOG_ALWAYS, "BaseService::doRequest() NSPR failure while " "%s %s", operation, svrInfo.getURL().c_str()); } if (AM_SUCCESS == status) { break; } else { if (retryCount < retryAttempts) { continue; } else { Log::log(logModule, Log::LOG_DEBUG, "BaseService::doRequest() Invoking markSeverDown"); /*svrInfo.markServerDown(poll_primary_server);*/ } } } catch (const NSPRException& exc) { Log::log(logModule, Log::LOG_ERROR, "BaseService::doRequest() caught %s: %s called by %s", exc.what(), exc.getNsprMethod(), exc.getThrowingMethod()); if (retryCount < retryAttempts) { status = AM_NSPR_ERROR; continue; } else { Log::log(logModule, Log::LOG_ERROR, "BaseService::doRequest() Invoking markSeverDown"); /*svrInfo.markServerDown(poll_primary_server);*/ status = AM_NSPR_ERROR; } } } //end of while if (AM_SUCCESS == status) { break; } } // end of for } else { status = AM_BUFFER_TOO_SMALL; } return status; }
int main(int argc, char * argv[]) { //check comand line paremeters if (argc < 10) { printf("usage: client ip port requestfilename requestNum cancelOrStop(1 is cancel, 0 is stop) netinterface filterExpression serverbandstatus sleepTime\n"); return 1; } // check cancel parameter int isCancel = 0; char *prefix = argv[8]; int sleepTime = atoi(argv[9]); if (strcmp(argv[5], "1") == 0) { isCancel = 1; } //init logFile char logFile[FILE_NAME_SIZE] = {0}; if (initLogFile(logFile, sizeof logFile -1, isCancel, prefix) != 0) { fprintf(stderr, "init logfile failed\n"); return 1; } printf("isCancel:%d\n", isCancel); printf("log file name is %s\n", logFile); struct ClientSockInfo sockInfo; if (initClientSockInfo(&sockInfo, argv[1], argv[2]) == 0) { printf("init client sockinfo successfully\n"); } else { fprintf(stderr, "init client sockinfo failed\n"); return 1; } char * requestFileName = argv[3]; int requestNum = atoi(argv[4]); //init sniffPanel struct SniffPanel sniffPanel; sniffPanel.device = argv[6]; sniffPanel.filterExpression = argv[7]; sniffPanel.liveReadTimeOut = 2000;//default 2000 ms sniffPanel.payloadFilePath = NULL; sniffPanel.payloadFile = NULL; sniffPanel.cbAfterSniff = &cbAfterSniff; sniffPanel.cbWhenError = &cbForSniffError; sniffPanel.cbLog = &cbForSniffLog; sniffPanel.afterSniffArgs = (void *)logFile; sniffPanel.errorArgs = NULL; sniffPanel.isStopped = 1; if (initSniff(&sniffPanel) != 0) { fprintf(stderr, "init packet sniff error\n"); return 1; } else { printf("finish initializing packet sniff\n"); } pthread_t sniffThread; int i = 0; while (i < requestNum) { if (!sniffPanel.isStopped) { printf("we need to stop the last sniff before starting new round\n"); if (stopSniff(&sniffPanel) != 0) { fprintf(stderr, "stop sniff failed\n"); continue; } else { printf("finish stopping the last sniff before starting new round\n"); } } i++; printf("round %d\n", i); //create connection to server //if (i == 1 || !isCancel) { // if (createNewConn(&sockInfo) != 0) { // fprintf(stderr, "create new connection failed \n"); // return 1; // } else { // printf("connect to server %s:%d successfully from port %d\n", sockInfo.serverIpStr, sockInfo.serverPort, sockInfo.clientPort); // } //} if (createNewConn(&sockInfo) != 0) { i--; fprintf(stderr, "create new connection failed \n"); continue; } else { printf("connect to server %s:%d successfully from port %d\n", sockInfo.serverIpStr, sockInfo.serverPort, sockInfo.clientPort); } //configure packet sniff and start thread sniffPanel.packetNum = 0; sniffPanel.payloadSize = 0; sniffPanel.isStopped = 0; pthread_create(&sniffThread, NULL, sniffThreadFunc, (void *)&sniffPanel); printf("finish starting thread for sniff\n"); //send request if (sendRequest(&sockInfo, requestFileName, strlen(requestFileName)) == 0) { printf("send request successfully\n"); } else { fprintf(stderr, "send request failed\n"); shutdown(sockInfo.clientSockFd, SHUT_RDWR); i--; continue; } //receive response within random time int randomSecs = generateRandom(RANDOM_RANGE); randomSecs += 10; sockInfo.recvedBytes = 0; printf("start to recv within %d seconds\n", randomSecs); if (recvWithInRandom(&sockInfo, randomSecs) == 0) { printf("recv %d KB in %d seconds\n", sockInfo.recvedBytes / 1024, randomSecs); } else { fprintf(stderr, "recv failed in round %d with random %d\n", i, randomSecs); shutdown(sockInfo.clientSockFd, SHUT_RDWR); i--; continue; } //send cancel or close signal const char *signal = isCancel? STOP_MSG : CLOSE_MSG; if (sendRequest(&sockInfo, signal, strlen(signal)) == 0) { printf("finish sending signal : %s\n", signal); } else { fprintf(stderr, "failed to send signal\n"); shutdown(sockInfo.clientSockFd, SHUT_RDWR); i--; continue; } //decide whether to close sock immediately after sending out cancel signal if (!isCancel) { printf("shutdown for close test\n"); closeSock(sockInfo.clientSockFd); printf("sleep for %d seconds in close test\n", sleepTime); sleep(sleepTime); } else { printf("continue receive for cancel test\n"); struct timeval timeout; timeout.tv_sec = 5; timeout.tv_usec = 0; int recvAfterCancel = receiveFromSockUtilTimeout(sockInfo.clientSockFd, &timeout); printf("recv %d KB after sending cancel signal", recvAfterCancel / 1024); printf("shutdown connection for cancel test\n"); closeSock(sockInfo.clientSockFd); } //record log if (appendLog(logFile, &sockInfo, randomSecs) == 0) { printf("finish appending new log\n"); } else { fprintf(stderr, "failed to append new log\n"); i--; continue; } if (stopSniff(&sniffPanel) != 0) { fprintf(stderr, "stop sniff failed\n"); i--; continue; } else { printf("finish stopping sniff with packets: %d, payloadSize: %d\n", sniffPanel.packetNum, sniffPanel.payloadSize / 1024); } } }
int Video::upload( const string &srcPath, const string &bucketName, const string &dstPath, const string &videoCover, const string &bizAttr, const string &title, const string &desc, const string &magicContext) { reset(); int ret = 0; ret = access(srcPath.c_str(), F_OK | R_OK); if (ret != 0) { retCode = VIDEO_FILE_NOT_EXISTS; retMsg = "file not exist or can not be read..."; return retCode; } string encodePath = videoUrlEncode(dstPath); uint64_t expired = time(NULL) + EXPIRED_SECONDS; string url = generateResUrl(bucketName, encodePath); string sign = Auth::appSign( APPID, SECRET_ID, SECRET_KEY, expired, bucketName); vector<string> headers; headers.push_back("Authorization: " + sign); string sha1 = genFileSHA1AndLen(srcPath); struct curl_httppost *firstitem = NULL, *lastitem = NULL; ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "op", CURLFORM_COPYCONTENTS, "upload", CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "sha", CURLFORM_COPYCONTENTS, sha1.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "video_cover", CURLFORM_COPYCONTENTS, videoCover.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "biz_attr", CURLFORM_COPYCONTENTS, bizAttr.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "video_title", CURLFORM_COPYCONTENTS, title.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "video_desc", CURLFORM_COPYCONTENTS, desc.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "magicContext", CURLFORM_COPYCONTENTS, magicContext.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "filecontent", CURLFORM_FILE, srcPath.c_str(), CURLFORM_END); sendRequest(url, 1, &headers, NULL, firstitem); curl_formfree(firstitem); return retCode; }
/*------------------------------------------------------------------------------* *------------------------------------------------------------------------------*/ void WebProxy::processQuery() { QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender()); QByteArray requestData = socket->readAll(); int pos = requestData.indexOf("\r\n"); QByteArray requestLine = requestData.left(pos); requestData.remove(0, pos + 2); QList<QByteArray> entries = requestLine.split(' '); QByteArray method = entries.value(0); QByteArray address = entries.value(1); QByteArray version = entries.value(2); qDebug( ) << __FILE__ << __FUNCTION__ << "Processing " << address; QUrl url = QUrl::fromEncoded(address); if (!url.isValid()) { //qWarning() << "Invalid URL:" << url; socket->disconnectFromHost(); return; } //Act as server is request are for local server if ((url.host() == "") && (QFile(address).exists())) { //qDebug( ) << __FILE__ << __FUNCTION__ << "Sending " << address; QByteArray header; QTextStream headerStream(&header, QIODevice::WriteOnly); //Construct response header headerStream << "HTTP/1.0 200 OK" << endl; headerStream << "Server: gpsbook/" << qApp->applicationVersion() << endl; headerStream << "Date: " << QDateTime::currentDateTime().toUTC().toString("ddd, dd MMM yyyy hh:mm:ss") << "GMT" << endl; headerStream << "Content-Type: text/html; charset=utf-8" << endl; headerStream << "Connection: close" << endl; headerStream << "Pragma: no-cache" << endl; headerStream << "Cache-Control: no-cache" << endl; QFile file(address); if (!file.open(QFile::ReadOnly | QFile::Text)) { qWarning() << "Cannot open:" << address; socket->disconnectFromHost(); return ; } QByteArray content; QTextStream contentStream(&content, QIODevice::WriteOnly); while (!file.atEnd()) { contentStream << file.readLine() << endl; } headerStream << "Content-Length:" << content.size() << endl; headerStream << "" << endl; socket->write(header); socket->write(content); //qDebug( ) << __FILE__ << __FUNCTION__ << "File sent (" << content.size() << "bytes) :-)"; socket->disconnectFromHost(); return; } #if ( QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) ) // Some finction of QUrl have been deprecated // This code is require for the internet browser and should be reviewed. #else #ifdef Q_OS_LINUX //Remove advert to speedup development ;-) if (url.toString().contains("googlesyndication") || url.toString().contains("yieldmanager.com")) { socket->disconnectFromHost(); return; } #endif qDebug( ) << __FILE__ << __FUNCTION__ << "URL: " << url.toString(); QString host = url.host(); int port = (url.port() < 0) ? 80 : url.port(); QByteArray req = url.encodedPath(); if (url.hasQuery()) req.append('?').append(url.encodedQuery()); requestLine = method + " " + req + " " + version + "\r\n"; requestData.prepend(requestLine); QString key = host + ':' + QString::number(port); QTcpSocket *proxySocket = socket->findChild<QTcpSocket*>(key); if (proxySocket) { proxySocket->setObjectName(key); proxySocket->setProperty("url", url); proxySocket->setProperty("requestData", requestData); proxySocket->write(requestData); } else { proxySocket = new QTcpSocket(socket); proxySocket->setObjectName(key); proxySocket->setProperty("url", url); proxySocket->setProperty("requestData", requestData); connect(proxySocket, SIGNAL(connected()), this, SLOT(sendRequest())); connect(proxySocket, SIGNAL(readyRead()), this, SLOT(transferData())); connect(proxySocket, SIGNAL(disconnected()), this, SLOT(closeConnection())); connect(proxySocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(closeConnection())); proxySocket->connectToHost(host, port); } #endif } //WebProxy::processQuery
int Video::upload_prepare( const uint64_t fileSize, const string &sha, const string &sign, const string &url, const string &videoCover, const string &bizAttr, const string &title, const string &desc, const string &magicContext, const string &session, const uint64_t sliceSize ) { reset(); int ret = 0; char buf[1024]; struct curl_httppost *firstitem = NULL, *lastitem = NULL; ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "op", CURLFORM_COPYCONTENTS, "upload_slice", CURLFORM_END); snprintf(buf, sizeof(buf), "%lu", fileSize); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "filesize", CURLFORM_COPYCONTENTS, buf, CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "sha", CURLFORM_COPYCONTENTS, sha.c_str(), CURLFORM_END); if (!videoCover.empty()) { ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "video_cover", CURLFORM_COPYCONTENTS, videoCover.c_str(), CURLFORM_END); } if (!bizAttr.empty()) { ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "biz_attr", CURLFORM_COPYCONTENTS, bizAttr.c_str(), CURLFORM_END); } if (!title.empty()) { ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "video_title", CURLFORM_COPYCONTENTS, title.c_str(), CURLFORM_END); } if (!desc.empty()) { ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "video_desc", CURLFORM_COPYCONTENTS, desc.c_str(), CURLFORM_END); } if (!magicContext.empty()) { ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "magicContext", CURLFORM_COPYCONTENTS, magicContext.c_str(), CURLFORM_END); } if (!session.empty()) { ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "session", CURLFORM_COPYCONTENTS, session.c_str(), CURLFORM_END); } if (sliceSize > 0) { if (sliceSize <= DEFAULT_SLICE_SIZE) { snprintf( buf, sizeof(buf), "%lu", sliceSize); } else { snprintf( buf, sizeof(buf), "%lu", sliceSize); } ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "slice_size", CURLFORM_COPYCONTENTS, buf, CURLFORM_END); } vector<string> headers; headers.push_back("Authorization: " + sign); sendRequest(url, 1, &headers, NULL, firstitem); curl_formfree(firstitem); return retCode; }
/** * send a GET request * @return http code */ int HTTPClient::GET() { return sendRequest("GET"); }
void HelpBrowser::goHome() { static QString code( "HelpBrowser.goHome" ); sendRequest(code); }
/** * sends a post request to the server * @param payload uint8_t * * @param size size_t * @return http code */ int HTTPClient::POST(uint8_t * payload, size_t size) { return sendRequest("POST", payload, size); }
void HelpBrowser::gotoHelpForMethod( const QString & className, const QString & methodName ) { QString code = QString("HelpBrowser.openHelpForMethod( %1.findMethod(\\%2) )").arg(className, methodName); sendRequest(code); }
void UpdateChecker::start() { sendRequest(); }
LogFile::~LogFile(void) { sendRequest(sensors().at(0)->hostName(), QString("logfile_unregister %1" ).arg(logFileID), 43); }
bool HttpAgent::async(const QObject * receiver, const char * method, const QString& httpMethod, const Route& route, const QMap<QString, QVariant>& params, const QMap<QString, QString>& filePaths, const QMap<QString, QVariant>& argsToSlot, const QObject * downloadProgressReceiver, const char * downloadProgressMethod ) { //在路由里取出url规则 QString routePattern = route.pattern(); qDebug() << "Services::async():" << routePattern; //遍历所有"默认参数"(如:_format, _locale), 做替换 QMapIterator<QString, QVariant> defaultParamIterator(defaultParams); while ( defaultParamIterator.hasNext() ) { defaultParamIterator.next(); QString toReplace = QString("{") + defaultParamIterator.key() + QString("}"); routePattern.replace( toReplace, defaultParamIterator.value().toString() ); qDebug() << "Services::async():replace("<< defaultParamIterator.key() << "," << defaultParamIterator.value() << "):" << routePattern; } qDebug() << "Services::async():" << routePattern; //QString paramsString; QUrlQuery query; int paramCount = 0; QMapIterator<QString, QVariant> i(params); while ( i.hasNext() ) { i.next(); /*if ( paramCount > 0 ) { paramsString += "&"; } paramsString += i.key(); paramsString += '='; paramsString += i.value();*/ QString value = QString( QUrl::toPercentEncoding( i.value().toString(), "", "+" ) ); query.addQueryItem(i.key(), value); //replace if found in urlPattern QString toReplace = QString("{") + i.key() + QString("}"); routePattern.replace( toReplace, i.value().toString() ); paramCount++; } /*QString paramString = query.query(QUrl::FullyEncoded); QByteArray ba = QUrl::toPercentEncoding(paramString, "&=", "+"); qDebug() << "BA ==== " << ba;*/ qDebug() << "Services::async(): paramsString: \"" << query.query(QUrl::FullyEncoded) << "\""; //paramsString << "\""; QString host = !route.host().isEmpty() ? route.host() : defaultHost; QString url(defaultProtocol + "://" + host + routePattern); //req.setRawHeader(QByteArray("X-Requested-With"), QByteArray("XMLHttpRequest")); QMap<QString, QString> headers; headers[ "X-Requested-With" ] = "XMLHttpRequest"; return sendRequest(httpMethod, url, params, //query.query(QUrl::FullyEncoded), //paramsString, //"email="+loginName+"&password="+password, filePaths, headers, receiver, method, argsToSlot, downloadProgressReceiver, downloadProgressMethod ); }
void MNMClass::requestPattern(uint8_t _pattern) { sendRequest(MNM_PATTERN_REQUEST_ID, _pattern); }
void ClientHandler::check_create_pipeline_call() { Json::Value request; Json::Value response; std::string pipeId; std::string objId; Json::Value params; Json::Value constructorParams; Json::Value operationParams; request["jsonrpc"] = "2.0"; request["id"] = getId(); request["method"] = "create"; params["type"] = "MediaPipeline"; params["sessionId"] = "123456"; request["params"] = params; request["sessionId"] = "sessionId"; response = sendRequest (request); BOOST_CHECK (!response.isMember ("error") ); BOOST_CHECK (response.isMember ("result") ); BOOST_CHECK (response["result"].isObject() ); BOOST_CHECK (response["result"].isMember ("value") ); BOOST_CHECK (response["result"]["value"].isString() ); pipeId = response["result"]["value"].asString(); params["type"] = "WebRtcEndpoint"; constructorParams ["mediaPipeline"] = pipeId; params["constructorParams"] = constructorParams; params["sessionId"] = "123456"; request["id"] = getId(); request["params"] = params; response = sendRequest (request); BOOST_CHECK (!response.isMember ("error") ); BOOST_CHECK (response.isMember ("result") ); BOOST_CHECK (response["result"].isObject() ); BOOST_CHECK (response["result"].isMember ("value") ); BOOST_CHECK (response["result"]["value"].isString() ); objId = response["result"]["value"].asString(); request["method"] = "invoke"; params.clear(); params["object"] = objId; params["operation"] = "getName"; params["sessionId"] = "123456"; params["operationParams"] = operationParams; request["id"] = getId(); request["params"] = params; response = sendRequest (request); BOOST_CHECK (!response.isMember ("error") ); BOOST_CHECK (response.isMember ("result") ); request["id"] = getId(); request["method"] = "ref"; params.clear(); params["object"] = objId; params["sessionId"] = "12345"; request["params"] = params; response = sendRequest (request); BOOST_CHECK (!response.isMember ("error") ); BOOST_CHECK (response.isMember ("result") ); request["id"] = getId(); request["method"] = "describe"; params.clear(); params["object"] = objId; params["sessionId"] = "12345"; request["params"] = params; response = sendRequest (request); BOOST_CHECK (!response.isMember ("error") ); BOOST_CHECK (response.isMember ("result") ); BOOST_CHECK (response["result"].isMember ("type") ); BOOST_CHECK (response["result"]["type"].asString () == "WebRtcEndpoint" ); std::string sessionId = "123456"; request.removeMember ("id"); request["id"] = getId(); request["method"] = "release"; params.clear(); params["object"] = objId; params["sessionId"] = sessionId; params["operationParams"] = operationParams; request["params"] = params; response = sendRequest (request); BOOST_CHECK (!response.isMember ("error") ); BOOST_CHECK (response.isMember ("result") ); BOOST_CHECK (response["result"].isMember ("sessionId") ); BOOST_CHECK (response["result"]["sessionId"].asString () == sessionId ); }
void MNMClass::requestGlobal(uint8_t _global) { sendRequest(MNM_GLOBAL_REQUEST_ID, _global); }
static int test_001(TestState *state) { TestState state2; int listener1, listener2, connection1, count, result; char response[1024]; initState(&state2, " Subtest", state); if (startTest(&state2, "LISTEN")) { if (serialRequest(&state2, "LISTEN:HTTP,/robot*")) checkSerialResponse(&state2, "=S,^i", &listener1); } beginGroup(&state2); if (startTest(&state2, "PATH of a listener")) { if (!skipTest(&state2) && serialRequest(&state2, "PATH:%d", listener1)) checkSerialResponse(&state2, "=S,/robot*"); } if (startTest(&state2, "Send request to WX module")) { if (!skipTest(&state2)) { if (sendRequest(&state->moduleAddr, "POST", "/robot?gto=f", "") >= 0) passTest(&state2, ""); else failTest(&state2, ""); } } beginGroup(&state2); if (startTest(&state2, "POLL for incoming POST request")) { if (!skipTest(&state2)) { do { if (!serialRequest(&state2, "POLL")) break; } while (!waitAndCheckSerialResponse(&state2, "=N,0,0", "=P,^i,^i", &connection1, &listener2)); } } beginGroup(&state2); if (startTest(&state2, "listener handle returned by POLL")) { if (listener1 == listener2) passTest(&state2, ""); else failTest(&state2, ": got %d", listener2); } if (startTest(&state2, "PATH of a connection")) { if (!skipTest(&state2) && serialRequest(&state2, "PATH:%d", connection1)) checkSerialResponse(&state2, "=S,/robot"); } if (startTest(&state2, "ARG")) { if (!skipTest(&state2) && serialRequest(&state2, "ARG:%d,gto", connection1)) checkSerialResponse(&state2, "=S,f"); } if (startTest(&state2, "REPLY")) { if (!skipTest(&state2) && serialRequest(&state2, "REPLY:%d,200", connection1)) checkSerialResponse(&state2, "=S,^i", &count); } if (startTest(&state2, "POLL for send complete")) { if (!skipTest(&state2)) { do { if (!serialRequest(&state2, "POLL")) break; } while (!waitAndCheckSerialResponse(&state2, "=N,0,0", "=S,^i,0", &count, &listener2)); } } if (startTest(&state2, "Receive response from WX")) { if (!skipTest(&state2)) { if (receiveResponse((uint8_t *)response, sizeof(response), &result) >= 0) passTest(&state2, ""); else failTest(&state2, ""); } } if (startTest(&state2, "CLOSE")) { if (!skipTest(&state2) && serialRequest(&state2, "CLOSE:%d", listener1)) checkSerialResponse(&state2, "=S,0"); } testResults(&state2); return state2.testPassed; }
bool LeafClientHandler::rebindSiblingPeer( int type, UUIDPtr& uuid, CellIDPtr& cellID, CellIDPtr& parentCellID, EndpointPtr& endpoint, SAPInfoPtr& discoverySAP, SAPInfoPtr& meshSAP, SAPInfoPtr& ftSAP, ACE_Message_Block* mb) { ACE_GUARD_RETURN(ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, m_lock, false); SthenoPacket *packet = 0; if (m_debugLeafClientHandler) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)INFO: LeafClientHandler:rebindSiblingPeer(): PEER(%s,%s)\n"), uuid->toString().c_str(), cellID->toString().c_str())); } UUIDPtr srcCellID(new CellID(m_cellID.get())); UUIDPtr dstCellID(new CellID(m_cellID.get())); EndpointPtr followerEndpoint; UUIDPtr runtimeUUID; m_mesh->getUUID(runtimeUUID); packet = new RebindMeshPacket(runtimeUUID, srcCellID, m_uuid, dstCellID, 0, type, uuid, cellID, parentCellID, endpoint, followerEndpoint, discoverySAP, meshSAP, ftSAP, mb); RequestEngine<SthenoPacket*>::RequestPtr* request = sendRequest(packet, 0); delete packet; if (request == 0) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)ERROR: LeafClientHandler:rebindSiblingPeer() - Request failed\n"))); return 0; } //ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)Before wait future\n"); ACE_Time_Value timeout = ACE_OS::gettimeofday(); ACE_Time_Value delta; delta.msec(JOIN_CELL_TIMEOUT_MS); timeout += delta; list<SthenoPacket*>* results = request->get()->waitFuture(0); ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T) LeafClientHandler:rebindSiblingPeer() After future\n"))); //ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)After future\n"); if (results != 0 && results->size() > 0) { RebindMeshReplyPacket* replyPacket = static_cast<RebindMeshReplyPacket*> (results->front()); bool status = replyPacket->getJoinResult(); ListHelper<SthenoPacket*>::deleteList(results); return status; } else { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t|%T)ERROR: LeafClientHandler::rebindSiblingPeer() - No response\n"))); } return false; }
// . returns false if blocked, true otherwise // . sets g_errno on error (and m_errno) // . k is a hint of which msg0 to use // . if k is -1 we do a complete scan to find available m_msg0[x] bool Msg51::sendRequests ( int32_t k ) { sendLoop: // bail if none left, return false if still waiting if ( m_numRequests - m_numReplies >= m_numSlots ) return false; bool isDone = false; if ( m_nexti >= m_numDocIds ) isDone = true; // any requests left to send? if ( isDone ) { // we are still waiting on replies, so we blocked... if ( m_numRequests > m_numReplies ) return false; // we are done! return true; } // sanity check if ( m_clusterLevels[m_nexti] < 0 || m_clusterLevels[m_nexti] >= CR_END ) { gbshutdownLogicError(); } // skip if we already got the rec for this guy! if ( m_clusterLevels[m_nexti] != CR_UNINIT ) { m_nexti++; goto sendLoop; } // . check our quick local cache to see if we got it // . use a max age of 1 hour // . this cache is primarly meant to avoid repetetive lookups // when going to the next tier in Msg3a and re-requesting cluster // recs for the same docids we did a second ago RdbCache *c = &s_clusterdbQuickCache; if ( ! s_cacheInit ) c = NULL; int32_t crecSize; char *crecPtr = NULL; key96_t ckey = (key96_t)m_docIds[m_nexti]; bool found = false; if ( c ) found = c->getRecord ( m_collnum , ckey , // cache key &crecPtr , // pointer to it &crecSize , false , // do copy? 3600 , // max age in secs true , // inc counts? NULL );// cachedTime if ( found ) { // sanity check if ( crecSize != sizeof(key96_t) ) gbshutdownLogicError(); m_clusterRecs[m_nexti] = *(key96_t *)crecPtr; // it is no longer CR_UNINIT, we got the rec now m_clusterLevels[m_nexti] = CR_GOT_REC; // debug msg //logf(LOG_DEBUG,"query: msg51 getRec k.n0=%" PRIu64" rec.n0=%" PRIu64, // ckey.n0,m_clusterRecs[m_nexti].n0); m_nexti++; goto sendLoop; } // . do not hog all the udpserver's slots! // . must have at least one outstanding reply so we can process // his reply and come back here... if ( g_udpServer.getNumUsedSlots() > 1000 && m_numRequests > m_numReplies ) return false; // find empty slot int32_t slot ; // ignore bogus hints if ( k >= m_numSlots ) k = -1; // if hint was provided use that if ( k >= 0 && ! m_slot[k].m_inUse ) slot = k; // otherwise, do a scan for the empty slot else { for ( slot = 0 ; slot < m_numSlots ; slot++ ) // break out if available if(!m_slot[slot].m_inUse) break; } // sanity check -- must have one!! if ( slot >= m_numSlots ) gbshutdownLogicError(); // send it, returns false if blocked, true otherwise sendRequest ( slot ); // update any hint to make our loop more efficient if ( k >= 0 ) k++; goto sendLoop; }