bool readFile(const req::ptr<File>& file) { mode = DESC_FILE; childend = dup(file->fd()); if (childend < 0) { raise_warning("unable to dup File-Handle for descriptor %d - %s", index, folly::errnoStr(errno).c_str()); return false; } return true; }
SSLSocket::SSLSocket(int sockfd, int type, const req::ptr<StreamContext>& ctx, const char *address /* = NULL */, int port /* = 0 */) : Socket(std::make_shared<SSLSocketData>(port, type), sockfd, type, address, port), m_data(static_cast<SSLSocketData*>(getSocketData())) { if (!ctx) { return; } this->setStreamContext(ctx); this->m_context = ctx->getOptions()[s_ssl].toArray(); }
void find_var_recursive(const TypedValue* tv, const req::ptr<WddxPacket>& wddxPacket) { if (tvIsString(tv)) { String var_name{tvCastToString(tv)}; wddxPacket->add_var(var_name, true); } if (isArrayType(tv->m_type)) { for (ArrayIter iter(tv->m_data.parr); iter; ++iter) { find_var_recursive(iter.secondRef().asTypedValue(), wddxPacket); } } }
// Check for file descriptors >= FD_SETSIZE // which can't be returned in an fdset // This is a little hacky, but necessary given cURL's APIs int CurlMultiAwait::addHighHandles(req::ptr<CurlMultiResource> multi) { int count = 0; auto easy_handles = multi->getEasyHandles(); for (ArrayIter iter(easy_handles); iter; ++iter) { Variant easy_handle = iter.second(); auto easy = dyn_cast_or_null<CurlResource>(easy_handle); if (!easy) continue; long sock; if ((curl_easy_getinfo(easy->get(), CURLINFO_LASTSOCKET, &sock) != CURLE_OK) || (sock < FD_SETSIZE)) { continue; } // No idea which type of event it needs, ask for everything addHandle(sock, AsioEventHandler::READ_WRITE); ++count; } return count; }
// Ask curl_multi for its handles directly // This is preferable as we get to know which // are blocking on reads, and which on writes. int CurlMultiAwait::addLowHandles(req::ptr<CurlMultiResource> multi) { fd_set read_fds, write_fds; int max_fd = -1, count = 0; FD_ZERO(&read_fds); FD_ZERO(&write_fds); if ((CURLM_OK != curl_multi_fdset(multi->get(), &read_fds, &write_fds, nullptr, &max_fd)) || (max_fd < 0)) { return count; } for (int i = 0 ; i <= max_fd; ++i) { int events = 0; if (FD_ISSET(i, &read_fds)) events |= AsioEventHandler::READ; if (FD_ISSET(i, &write_fds)) events |= AsioEventHandler::WRITE; if (events) { addHandle(i, events); ++count; } } return count; }
req::ptr<File> HttpStreamWrapper::open(const String& filename, const String& mode, int options, const req::ptr<StreamContext>& context) { if (RuntimeOption::ServerHttpSafeMode && !is_cli_mode()) { return nullptr; } if (strncmp(filename.data(), "http://", sizeof("http://") - 1) && strncmp(filename.data(), "https://", sizeof("https://") - 1)) { return nullptr; } Array headers; String method = s_GET; String post_data = null_string; String proxy_host; String proxy_user; String proxy_pass; int proxy_port = -1; int max_redirs = 20; int timeout = -1; bool ignore_errors = false; if (context && !context->getOptions().isNull() && !context->getOptions()[s_http].isNull()) { Array opts = context->getOptions()[s_http].toArray(); if (opts.exists(s_method)) { method = opts[s_method].toString(); } if (opts.exists(s_header)) { Array lines; if (opts[s_header].isString()) { lines = StringUtil::Explode( opts[s_header].toString(), "\r\n").toArray(); } else if (opts[s_header].isArray()) { lines = opts[s_header]; } for (ArrayIter it(lines); it; ++it) { Array parts = StringUtil::Explode( it.second().toString(), ":", 2).toArray(); headers.set(parts.rvalAt(0), parts.rvalAt(1)); } } if (opts.exists(s_user_agent) && !headers.exists(s_User_Agent)) { headers.set(s_User_Agent, opts[s_user_agent]); } if (opts.exists(s_max_redirects)) { max_redirs = opts[s_max_redirects].toInt64(); } if (opts.exists(s_timeout)) { timeout = opts[s_timeout].toInt64(); } if (opts.exists(s_ignore_errors)) { ignore_errors = opts[s_ignore_errors].toBoolean(); } if (opts.exists(s_proxy)) { Variant host = f_parse_url(opts[s_proxy].toString(), k_PHP_URL_HOST); Variant port = f_parse_url(opts[s_proxy].toString(), k_PHP_URL_PORT); if (!same(host, false) && !same(port, false)) { proxy_host = host.toString(); proxy_port = port.toInt64(); Variant user = f_parse_url(opts[s_proxy].toString(), k_PHP_URL_USER); Variant pass = f_parse_url(opts[s_proxy].toString(), k_PHP_URL_PASS); if (!same(user, false) && !same(pass, false)) { proxy_user = user.toString(); proxy_pass = pass.toString(); } } } post_data = opts[s_content].toString(); } if (!headers.exists(s_User_Agent)) { auto default_user_agent = ThreadInfo::s_threadInfo.getNoCheck() ->m_reqInjectionData.getUserAgent(); if (!default_user_agent.empty()) { headers.set(s_User_Agent, default_user_agent); } } auto file = req::make<UrlFile>(method.data(), headers, post_data, max_redirs, timeout, ignore_errors); file->setStreamContext(context); file->setProxy(proxy_host, proxy_port, proxy_user, proxy_pass); bool ret = file->open(filename, mode); if (!ret) { raise_warning("Failed to open %s (%s)", filename.data(), file->getLastError().c_str()); return nullptr; } return file; }
PDOPgSqlStatement::PDOPgSqlStatement( req::ptr<PDOPgSqlResource> conn, PQ::Connection* server ) : m_conn(conn->conn()), m_server(server), m_result(), m_isPrepared(false), m_current_row(0) { this->dbh = cast<PDOResource>(conn); }