#include "config.hpp"
+#if HAVE_GETRLIMIT
+#include <sys/resource.h>
+#endif
#include <sstream>
#include <iomanip>
#include <metaproxy/util.hpp>
std::string cert_fname;
int max_recv_bytes;
};
+ class FrontendNet::IP_Pattern {
+ friend class Rep;
+ friend class FrontendNet;
+ std::string pattern;
+ int verbose;
+ int value;
+ };
class FrontendNet::Rep {
friend class FrontendNet;
int m_no_threads;
+ int m_max_threads;
+ int m_stack_size;
std::vector<Port> m_ports;
int m_listen_duration;
int m_session_timeout;
- int m_connect_max;
+ std::list<IP_Pattern> connect_max;
+ std::list<IP_Pattern> http_req_max;
std::string m_msg_config;
std::string m_stat_req;
yazpp_1::SocketManager mySocketManager;
ZAssocServer **az;
+ yazpp_1::PDU_Assoc **pdu;
int m_duration_freq[22];
double m_duration_lim[22];
double m_duration_max;
ZAssocChild(yazpp_1::IPDU_Observable *the_PDU_Observable,
mp::ThreadPoolSocketObserver *m_thread_pool_observer,
const mp::Package *package,
- std::string route,
- Rep *rep);
+ Port *port,
+ Rep *rep,
+ yazpp_1::LimitConnect &limit,
+ const char *peername);
int m_no_requests;
- std::string m_route;
+ Port *m_port;
private:
yazpp_1::IPDU_Observer* sessionNotify(
yazpp_1::IPDU_Observable *the_PDU_Observable,
bool m_delete_flag;
const mp::Package *m_package;
Rep *m_p;
+ yazpp_1::LimitConnect &m_limit_http_req;
};
class FrontendNet::ThreadPoolPackage : public mp::IThreadPoolMsg {
public:
public:
~ZAssocServer();
ZAssocServer(yazpp_1::IPDU_Observable *PDU_Observable,
- std::string route,
+ FrontendNet::Port *port,
Rep *rep);
void set_package(const mp::Package *package);
void set_thread_pool(ThreadPoolSocketObserver *observer);
mp::ThreadPoolSocketObserver *m_thread_pool_observer;
const mp::Package *m_package;
yazpp_1::LimitConnect limit_connect;
- std::string m_route;
+ yazpp_1::LimitConnect limit_http_req;
+ Port *m_port;
Rep *m_p;
};
}
mp::IThreadPoolMsg *yf::FrontendNet::ThreadPoolPackage::handle()
{
- m_package->move(m_assoc_child->m_route);
+ m_package->move(m_assoc_child->m_port->route);
return this;
}
yazpp_1::IPDU_Observable *PDU_Observable,
mp::ThreadPoolSocketObserver *my_thread_pool,
const mp::Package *package,
- std::string route, Rep *rep)
- : Z_Assoc(PDU_Observable), m_p(rep)
+ Port *port, Rep *rep,
+ yazpp_1::LimitConnect &limit_http_req,
+ const char *peername)
+ : Z_Assoc(PDU_Observable), m_p(rep), m_limit_http_req(limit_http_req)
{
m_thread_pool_observer = my_thread_pool;
m_no_requests = 0;
m_delete_flag = false;
m_package = package;
- m_route = route;
- const char *peername = PDU_Observable->getpeername();
- if (!peername)
- peername = "unknown";
- else
- {
- const char *cp = strchr(peername, ':');
- if (cp)
- peername = cp + 1;
- }
- m_origin.set_tcpip_address(std::string(peername), m_session.id());
+ m_port = port;
+ std::string addr;
+ addr.append(peername);
+ addr.append(" ");
+ addr.append(port->port);
+ m_origin.set_tcpip_address(addr, m_session.id());
timeout(m_p->m_session_timeout);
}
&& !strcmp(hreq->path, m_p->m_stat_req.c_str()))
{
report(hreq);
+ delete p;
return;
}
}
- ThreadPoolPackage *tp = new ThreadPoolPackage(p, this, m_p);
p->copy_route(*m_package);
p->request() = yazpp_1::GDU(z_pdu);
yaz_log(YLOG_LOG, "%s", os.str().c_str());
}
}
+ if (z_pdu && z_pdu->which == Z_GDU_HTTP_Request)
+ {
+ Z_HTTP_Request *hreq = z_pdu->u.HTTP_Request;
+ std::string peername = p->origin().get_address();
+
+ m_limit_http_req.cleanup(false);
+ int con_sz = m_limit_http_req.get_total(peername.c_str());
+ std::list<IP_Pattern>::const_iterator it = m_p->http_req_max.begin();
+ for (; it != m_p->http_req_max.end(); it++)
+ {
+ if (mp::util::match_ip(it->pattern, peername))
+ {
+ if (it->verbose > 1 ||
+ (it->value && con_sz >= it->value && it->verbose > 0))
+ yaz_log(YLOG_LOG, "http-req-max pattern=%s ip=%s con_sz=%d value=%d", it->pattern.c_str(), peername.c_str(), con_sz, it->value);
+ if (it->value == 0 || con_sz < it->value)
+ break;
+ mp::odr o;
+ Z_GDU *gdu_res = o.create_HTTP_Response(m_session, hreq, 500);
+ int len;
+ send_GDU(gdu_res, &len);
+ delete p;
+ return;
+ }
+ }
+ m_limit_http_req.add_connect(peername.c_str());
+ }
+ ThreadPoolPackage *tp = new ThreadPoolPackage(p, this, m_p);
m_thread_pool_observer->put(tp);
}
yf::FrontendNet::ZAssocServer::ZAssocServer(
yazpp_1::IPDU_Observable *PDU_Observable,
- std::string route,
+ Port *port,
Rep *rep)
:
- Z_Assoc(PDU_Observable), m_route(route), m_p(rep)
+ Z_Assoc(PDU_Observable), m_port(port), m_p(rep)
{
m_package = 0;
}
{
const char *peername = the_PDU_Observable->getpeername();
+ if (!peername)
+ peername = "unknown";
+ else
+ {
+ const char *cp = strchr(peername, ':');
+ if (cp)
+ peername = cp + 1;
+ }
if (peername)
{
- limit_connect.add_connect(peername);
limit_connect.cleanup(false);
int con_sz = limit_connect.get_total(peername);
- if (m_p->m_connect_max && con_sz > m_p->m_connect_max)
- return 0;
+ std::list<IP_Pattern>::const_iterator it = m_p->connect_max.begin();
+ for (; it != m_p->connect_max.end(); it++)
+ {
+ if (mp::util::match_ip(it->pattern, peername))
+ {
+ if (it->verbose > 1 ||
+ (it->value && con_sz >= it->value && it->verbose > 0))
+ yaz_log(YLOG_LOG, "connect-max pattern=%s ip=%s con_sz=%d value=%d", it->pattern.c_str(), peername, con_sz, it->value);
+ if (it->value == 0 || con_sz < it->value)
+ break;
+ return 0;
+ }
+ }
+ limit_connect.add_connect(peername);
}
ZAssocChild *my = new ZAssocChild(the_PDU_Observable,
m_thread_pool_observer,
- m_package, m_route, m_p);
+ m_package, m_port, m_p, limit_http_req,
+ peername);
return my;
}
yf::FrontendNet::Rep::Rep()
{
- m_no_threads = 5;
+ m_max_threads = m_no_threads = 5;
+ m_stack_size = 0;
m_listen_duration = 0;
m_session_timeout = 300; // 5 minutes
- m_connect_max = 0;
az = 0;
size_t i;
for (i = 0; i < 22; i++)
for (i = 0; i < m_ports.size(); i++)
delete az[i];
delete [] az;
+ delete [] pdu;
}
az = 0;
}
m_p->m_stop_signo = signo;
}
+void yf::FrontendNet::start() const
+{
+#if HAVE_GETRLIMIT
+ struct rlimit limit_data;
+ getrlimit(RLIMIT_NOFILE, &limit_data);
+ yaz_log(YLOG_LOG, "getrlimit NOFILE cur=%ld max=%ld",
+ (long) limit_data.rlim_cur, (long) limit_data.rlim_max);
+#endif
+}
+
bool yf::FrontendNet::My_Timer_Thread::timeout()
{
return m_timeout;
tt = new My_Timer_Thread(&m_p->mySocketManager,
m_p->m_listen_duration);
- ThreadPoolSocketObserver tp(&m_p->mySocketManager, m_p->m_no_threads);
+ ThreadPoolSocketObserver tp(&m_p->mySocketManager, m_p->m_no_threads,
+ m_p->m_max_threads,
+ m_p->m_stack_size);
for (i = 0; i<m_p->m_ports.size(); i++)
{
if (m_p->m_stop_signo == SIGTERM)
{
yaz_log(YLOG_LOG, "metaproxy received SIGTERM");
+ if (m_p->az)
+ {
+ size_t i;
+ for (i = 0; i < m_p->m_ports.size(); i++)
+ {
+ m_p->pdu[i]->shutdown();
+ m_p->az[i]->server("");
+ }
+ yaz_daemon_stop();
+ }
break; /* stop right away */
}
+#ifndef WIN32
if (m_p->m_stop_signo == SIGUSR1)
{ /* just stop listeners and cont till all sessions are done*/
yaz_log(YLOG_LOG, "metaproxy received SIGUSR1");
yaz_daemon_stop();
}
}
+#endif
int no = m_p->mySocketManager.getNumberOfObservers();
if (no <= 1)
break;
+ threads_str);
m_p->m_no_threads = threads;
}
+ else if (!strcmp((const char *) ptr->name, "max-threads"))
+ {
+ std::string threads_str = mp::xml::get_text(ptr);
+ int threads = atoi(threads_str.c_str());
+ if (threads < 1)
+ throw yf::FilterException("Bad value for max-threads: "
+ + threads_str);
+ m_p->m_max_threads = threads;
+ }
+ else if (!strcmp((const char *) ptr->name, "stack-size"))
+ {
+ std::string sz_str = mp::xml::get_text(ptr);
+ int sz = atoi(sz_str.c_str());
+ if (sz < 0)
+ throw yf::FilterException("Bad value for stack-size: "
+ + sz_str);
+ m_p->m_stack_size = sz * 1024;
+ }
else if (!strcmp((const char *) ptr->name, "timeout"))
{
std::string timeout_str = mp::xml::get_text(ptr);
}
else if (!strcmp((const char *) ptr->name, "connect-max"))
{
- m_p->m_connect_max = mp::xml::get_int(ptr, 0);
+ const char *names[3] = {"ip", "verbose", 0};
+ std::string values[2];
+
+ mp::xml::parse_attr(ptr, names, values);
+ IP_Pattern m;
+ m.value = mp::xml::get_int(ptr, 0);
+ m.pattern = values[0];
+ m.verbose = values[1].length() ? atoi(values[1].c_str()) : 1;
+ m_p->connect_max.push_back(m);
+ }
+ else if (!strcmp((const char *) ptr->name, "http-req-max"))
+ {
+ const char *names[3] = {"ip", "verbose", 0};
+ std::string values[2];
+
+ mp::xml::parse_attr(ptr, names, values);
+ IP_Pattern m;
+ m.value = mp::xml::get_int(ptr, 0);
+ m.pattern = values[0];
+ m.verbose = values[1].length() ? atoi(values[1].c_str()) : 1;
+ m_p->http_req_max.push_back(m);
}
else if (!strcmp((const char *) ptr->name, "message"))
{
m_p->m_ports = ports;
m_p->az = new yf::FrontendNet::ZAssocServer *[m_p->m_ports.size()];
+ m_p->pdu = new yazpp_1::PDU_Assoc *[m_p->m_ports.size()];
// Create yf::FrontendNet::ZAssocServer for each port
size_t i;
- for (i = 0; i<m_p->m_ports.size(); i++)
+ for (i = 0; i < m_p->m_ports.size(); i++)
+ m_p->az[i] = 0;
+ for (i = 0; i < m_p->m_ports.size(); i++)
{
// create a PDU assoc object (one per yf::FrontendNet::ZAssocServer)
yazpp_1::PDU_Assoc *as = new yazpp_1::PDU_Assoc(&m_p->mySocketManager);
if (m_p->m_ports[i].cert_fname.length())
as->set_cert_fname(m_p->m_ports[i].cert_fname.c_str());
// create ZAssoc with PDU Assoc
+ m_p->pdu[i] = as;
m_p->az[i] = new yf::FrontendNet::ZAssocServer(
- as, m_p->m_ports[i].route, m_p.get());
+ as, &m_p->m_ports[i], m_p.get());
if (m_p->az[i]->server(m_p->m_ports[i].port.c_str()))
{
throw yf::FilterException("Unable to bind to address "