bool HttpClient::perform() { writeRequest(); if (!_conn->fresh() && (_conn->stream().obtain().size == 0)) { _conn.reset(new HttpConnection(_conn->server())); writeRequest(); } return (readStatus() && readHeaders() && readContent()); }
bool EtherIPC::queueRequest(const RequestIPC& request) { if ( fActiveRequest.burden() == None ) { return writeRequest(request); } else { fRequestQueue.append(request); return true; } }
void EtherIPC::done() { fActiveRequest = RequestIPC(None); if ( !fRequestQueue.isEmpty() ) { const RequestIPC request = fRequestQueue.first(); fRequestQueue.removeFirst(); writeRequest(request); } else { emit busyChanged(getBusy()); } }
int probeBrailleDisplay ( BrailleDisplay *brl, unsigned int retryLimit, GioEndpoint *endpoint, int inputTimeout, BrailleRequestWriter *writeRequest, BraillePacketReader *readPacket, void *responsePacket, size_t responseSize, BrailleResponseHandler *handleResponse ) { unsigned int retryCount = 0; if (!endpoint) endpoint = brl->gioEndpoint; while (writeRequest(brl)) { drainBrailleOutput(brl, 0); while (gioAwaitInput(endpoint, inputTimeout)) { size_t size = readPacket(brl, responsePacket, responseSize); if (!size) break; { BrailleResponseResult result = handleResponse(brl, responsePacket, size); switch (result) { case BRL_RSP_DONE: return 1; case BRL_RSP_UNEXPECTED: logUnexpectedPacket(responsePacket, size); case BRL_RSP_CONTINUE: break; default: logMessage(LOG_WARNING, "unimplemented braille response result: %u", result); case BRL_RSP_FAIL: return 0; } } } if (errno != EAGAIN) #ifdef ETIMEDOUT if (errno != ETIMEDOUT) #endif /* ETIMEDOUT */ break; if (retryCount == retryLimit) break; retryCount += 1; } return 0; }
void handleHandshake(const boost::system::error_code& ec) { try { if (!ec) { // finished handshake, commence with request writeRequest(); } else { handleErrorCode(ec, ERROR_LOCATION); } } CATCH_UNEXPECTED_ASYNC_CLIENT_EXCEPTION }
void EHttpBasicAuthLogicHandler::doHandshake(EIoFilter::NextFilter* nextFilter) { logger->debug(__FILE__, __LINE__, " doHandshake()"); if (step > 0) { throw EProxyAuthException(__FILE__, __LINE__, "Authentication request already sent"); } // Send request sp<EHttpProxyRequest> req = dynamic_pointer_cast<EHttpProxyRequest>(request); EMap<EString*, EList<EString*>*>* headers = req->getHeaders(); EString uk(EHttpProxyConstants_USER_PROPERTY); EString* username = req->getProperties()->get(&uk); EString pw(EHttpProxyConstants_PWD_PROPERTY); EString* password = req->getProperties()->get(&pw); EString value("Basic " + createAuthorization(username->c_str(), password->c_str())); EAbstractAuthLogicHandler::addValueToHeader(headers, "Proxy-Authorization", value.c_str(), true); addKeepAliveHeaders(headers); writeRequest(nextFilter, req); step++; }
static int setFirmness (BrailleDisplay *brl, BrailleFirmness setting) { brl->data->firmnessSetting = setting * 0XFF / BRL_FIRMNESS_MAXIMUM; return writeRequest(brl); }
static int handleAcknowledgement (BrailleDisplay *brl, int ok) { brl->data->acknowledgementHandler(brl, ok); brl->data->acknowledgementHandler = NULL; return writeRequest(brl); }
void EHttpDigestAuthLogicHandler::doHandshake(EIoFilter::NextFilter* nextFilter) { logger->debug(__FILE__, __LINE__, " doHandshake()"); if (step > 0 && directives == null) { throw EProxyAuthException(__FILE__, __LINE__, "Authentication challenge not received"); } sp<EHttpProxyRequest> req = dynamic_pointer_cast<EHttpProxyRequest>(request); EMap<EString*, EList<EString*>*>* headers = req->getHeaders(); if (step > 0) { logger->debug(__FILE__, __LINE__, " sending DIGEST challenge response"); // Build a challenge response EHashMap<EString*, EString*> map; EString k(EHttpProxyConstants_USER_PROPERTY); map.put(new EString("username"), new EString(req->getProperties()->get(&k))); EStringUtilities::copyDirective(directives, map, "realm"); EStringUtilities::copyDirective(directives, map, "uri"); EStringUtilities::copyDirective(directives, map, "opaque"); EStringUtilities::copyDirective(directives, map, "nonce"); EString algorithm = EStringUtilities::copyDirective(directives, map, "algorithm"); // Check for a supported algorithm if (!algorithm.equalsIgnoreCase("md5") && !algorithm.equalsIgnoreCase("md5-sess")) { throw EProxyAuthException(__FILE__, __LINE__, "Unknown algorithm required by server"); } // Check for a supported qop k = "qop"; EString* qop = directives->get(&k); if (qop != null) { EStringTokenizer st(qop->c_str(), ","); EString token;// = null; while (st.hasMoreTokens()) { EString tk = st.nextToken(); if (token.equalsIgnoreCase("auth")) { break; } /* @see: int pos = Arrays.binarySearch(DigestUtilities.SUPPORTED_QOPS, tk); if (pos > -1) { token = tk; } */ if (tk.equalsIgnoreCase("auth") || tk.equalsIgnoreCase("auth-int")) { token = tk; } } if (!token.isEmpty()) { map.put(new EString("qop"), new EString(token)); byte nonce[8] = {0}; rnd.nextBytes(nonce, 8); try { EString* cnonce = new EString(EBase64::encodeBase64(nonce, 8)/*, proxyIoSession.getCharsetName()*/); map.put(new EString("cnonce"), cnonce); } catch (EUnsupportedEncodingException& e) { throw EProxyAuthException(__FILE__, __LINE__, "Unable to encode cnonce", &e); } } else { throw EProxyAuthException(__FILE__, __LINE__, "No supported qop option available"); } } map.put(new EString("nc"), new EString("00000001")); map.put(new EString("uri"), new EString(req->getHttpURI())); // Compute the response try { sp<EIoSession> session = proxyIoSession->getSession(); EString k(EHttpProxyConstants_PWD_PROPERTY); map.put(new EString("response"), new EString(DigestUtilities::computeResponseValue(session, map, req ->getHttpVerb(), req->getProperties()->get(&k)->c_str(), response->getBody()))); } catch (EException& e) { throw EProxyAuthException(__FILE__, __LINE__, "Digest response computing failed", &e); } // Prepare the challenge response header and add it to the // request we will send EString sb("Digest ");// = new StringBuilder("Digest "); boolean addSeparator = false; sp<EIterator<EMapEntry<EString*, EString*>*> > iter = map.entrySet()->iterator(); while (iter->hasNext()) { EMapEntry<EString*, EString*>* entry = iter->next(); EString* key = entry->getKey(); if (addSeparator) { sb.append(", "); } else { addSeparator = true; } boolean quotedValue = !key->equals("qop") && !key->equals("nc"); sb.append(key); if (quotedValue) { sb.append("=\"").append(entry->getValue()).append('\"'); } else { sb.append('=').append(entry->getValue()); } } addValueToHeader(headers, "Proxy-Authorization", sb.toString().c_str(), true); } addKeepAliveHeaders(headers); //req->setHeaders(headers); ? writeRequest(nextFilter, req); step++; }
static int getPacket (BrailleDisplay *brl, Packet *packet) { while (1) { int count = readPacket(brl, packet); if (count > 0) { switch (packet->header.type) { { int ok; case PKT_NAK: logNegativeAcknowledgement(packet); if (!brl->data->acknowledgementHandler) { logMessage(LOG_WARNING, "Unexpected NAK."); continue; } switch (packet->header.arg1) { case PKT_ERR_TIMEOUT: { int originalLimit = brl->data->outputPayloadLimit; if (brl->data->outputPayloadLimit > brl->data->model->cellCount) brl->data->outputPayloadLimit = brl->data->model->cellCount; if (brl->data->outputPayloadLimit > 1) brl->data->outputPayloadLimit--; if (brl->data->outputPayloadLimit != originalLimit) logMessage(LOG_WARNING, "Maximum payload length reduced from %d to %d.", originalLimit, brl->data->outputPayloadLimit); break; } } handleNegativeAcknowledgement: ok = 0; goto handleAcknowledgement; case PKT_ACK: if (!brl->data->acknowledgementHandler) { logMessage(LOG_WARNING, "Unexpected ACK."); continue; } ok = 1; handleAcknowledgement: brl->data->acknowledgementHandler(brl, ok); brl->data->acknowledgementHandler = NULL; if (writeRequest(brl)) continue; count = -1; break; } } } else if ((count == 0) && brl->data->acknowledgementHandler && afterTimePeriod(&brl->data->acknowledgementPeriod, NULL)) { if (++brl->data->acknowledgementsMissing < 5) { logMessage(LOG_WARNING, "Missing ACK; assuming NAK."); goto handleNegativeAcknowledgement; } logMessage(LOG_WARNING, "Too many missing ACKs."); count = -1; } return count; } }