bool Socket::SetSoKeepalive(bool x)
{
#ifdef SO_KEEPALIVE
int optval = x ? 1 : 0;
if (setsockopt(GetSocket(), SOL_SOCKET, SO_KEEPALIVE, (char *)&optval, sizeof(optval)) == -1)
{
Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_KEEPALIVE)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "socket option not available", 0, "SO_KEEPALIVE", LOG_LEVEL_INFO);
return false;
#endif
}
bool Socket::SetMulticastLoop(bool x)
{
#ifdef IP_MULTICAST_LOOP
int optval = x ? 1 : 0;
if (setsockopt(GetSocket(), IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&optval, sizeof(optval)) == -1)
{
Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_MULTICAST_LOOP)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "ip option not available", 0, "IP_MULTICAST_LOOP", LOG_LEVEL_INFO);
return false;
#endif
}
bool Socket::SetSoBroadcast(bool x)
{
#ifdef SO_BROADCAST
int optval = x ? 1 : 0;
if (setsockopt(GetSocket(), SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) == -1)
{
Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_BROADCAST)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "socket option not available", 0, "SO_BROADCAST", LOG_LEVEL_INFO);
return false;
#endif
}
bool Socket::SetIpHdrincl(bool x)
{
#ifdef IP_HDRINCL
int optval = x ? 1 : 0;
if (setsockopt(GetSocket(), IPPROTO_IP, IP_HDRINCL, (char *)&optval, sizeof(optval)) == -1)
{
Handler().LogError(this, "setsockopt(IPPROTO_IP, IP_HDRINCL)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "ip option not available", 0, "IP_HDRINCL", LOG_LEVEL_INFO);
return false;
#endif
}
bool Socket::SetSoReuseaddr(bool x)
{
#ifdef SO_REUSEADDR
int optval = x ? 1 : 0;
if (setsockopt(GetSocket(), SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) == -1)
{
Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_REUSEADDR)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "socket option not available", 0, "SO_REUSEADDR", LOG_LEVEL_INFO);
return false;
#endif
}
void ControlSocket::OnAccept(void)
{
logdetail("ControlSocket: Incoming connection from %s:%u [host:%s]",GetRemoteAddress().c_str(),GetRemotePort(),GetRemoteHostname().c_str());
// must perform some crappy ptr conversion here, doesnt want to typecast SocketHandler -> ControlSocketHandler directly
SocketHandler& hnd = Handler();
ControlSocketHandler *chnd = static_cast<ControlSocketHandler*>(&hnd);
_instance = chnd->GetInstance();
DEBUG(logdebug("ControlSocket: setting instance = %X",_instance));
// accept only connections from one host for now, if set
if(_instance->GetConf()->rmcontrolhost.length()
&& !(GetRemoteAddress() == _instance->GetConf()->rmcontrolhost || GetRemoteHostname() == _instance->GetConf()->rmcontrolhost))
{
logdetail("ControlSocket: connection rejected. closing.");
SetCloseAndDelete(true);
return;
}
SendTelnetText(_instance->GetScripts()->variables.Get("@version"));
if(_instance->GetConf()->rmcontrolpass.size())
{
SendTelnetText("Authentication?");
}
_ok = true;
}
AsyncValue<Handler> Server::routeDynamicRequestFromFile(String path) {
auto lp=mgr->loadPage(*p,root,path);
if(lp) return Handler(&dynamicHandler,lp());
requestRouterState* st=new requestRouterState();
lp.wait(st);
return Future<Handler>(&st->cb);
}
int
Input_Task::add_timer (void *argument)
{
u_long useconds = *reinterpret_cast<int *> (argument);
ACE_Time_Value interval (useconds / usecs_,
useconds % usecs_);
ACE_Time_Value expire_at = ACE_OS::gettimeofday () + interval;
Handler *h;
ACE_NEW_RETURN (h,
Handler (expire_at),
-1);
int id = queue_->schedule (h, 0, expire_at);
if (id == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"schedule failed"),
-1);
// We store the id into the handler, this is only used to produce
// nicer messages.
h->set_id (id);
ACE_OS::printf ("scheduling timer %d\n",
id);
return 0;
}
void SctpSocket::OnRead()
{
/*
int sctp_recvmsg(int sd, void * msg, size_t * len,
struct sockaddr * from, socklen_t * fromlen,
struct sctp_sndrcvinfo * sinfo, int * msg_flags);
DESCRIPTION
sctp_recvmsg is a wrapper library function that can be used to receive a message from a socket while using the advanced
features of SCTP. sd is the socket descriptor on which the message pointed to by msg of length len is received.
If from is not NULL, the source address of the message is filled in. The argument fromlen is a value-result parameter.
initialized to the size of the buffer associated with from , and modified on return to indicate the actual size of the
address stored.
sinfo is a pointer to a sctp_sndrcvinfo structure to be filled upon receipt of the message. msg_flags is a pointer to a
integer that is filled with any message flags like MSG_NOTIFICATION or MSG_EOR.
*/
struct sockaddr sa;
socklen_t sa_len = 0;
struct sctp_sndrcvinfo sinfo;
int flags = 0;
int n = sctp_recvmsg(GetSocket(), m_buf, SCTP_BUFSIZE_READ, &sa, &sa_len, &sinfo, &flags);
if (n == -1)
{
Handler().LogError(this, "SctpSocket", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
}
else
{
OnReceiveMessage(m_buf, n, &sa, sa_len, &sinfo, flags);
}
}
void HttpPutSocket::SetFile(const std::string& file)
{
//struct stat st;
// Added by Amir Krifa
std::ifstream f;
f.open(file.c_str(), std::ios_base::binary | std::ios_base::in);
//if (!f.good() || f.eof() || !f.is_open()) { return 0; }
if (!f.good() || f.eof() || !f.is_open())
{
Handler().LogError(this, "SetFile", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
}else
{
f.seekg(0, std::ios_base::beg);
std::ifstream::pos_type begin_pos = f.tellg();
f.seekg(0, std::ios_base::end);
m_filename = file;
m_content_length = static_cast<off_t>(f.tellg() - begin_pos);
}
//if (!stat(file.c_str(), &st))
//{
// m_filename = file;
// m_content_length = st.st_size;
//}
//else
//{
// Handler().LogError(this, "SetFile", Errno, StrError(Errno), LOG_LEVEL_FATAL);
// SetCloseAndDelete();
//}
}
void StdinLine::OnRead()
{
char buf[m_bufsize];
int n = read(GetSocket(), buf, m_bufsize - 1); //recv(0, buf, 1000, 0);
if (n == -1)
{
Handler().LogError(this, "OnRead", errno, strerror(errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
return;
}
for (size_t i = 0; i < (size_t)n; i++)
{
switch (buf[i])
{
case 13: // ignore
break;
case 10:
OnLine(m_line);
m_line = "";
break;
default:
m_line += buf[i];
}
}
}
void OnEvent(int id) {
if (id != m_id)
{
printf("ID MISMATCH!\n");
exit(-1);
}
if (!quit)
{
lSocket *p = new lSocket(Handler());
p -> SetDeleteByHandler();
p -> Open(HOST, PORT);
Handler().Add(p);
}
static_cast<evHandler&>(Handler()).SetQuit( quit );
SetCloseAndDelete();
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NIImporter_ITSUMO::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether the option is set (properly)
if (!oc.isSet("itsumo-files")) {
return;
}
/* Parse file(s)
* Each file is parsed twice: first for nodes, second for edges. */
std::vector<std::string> files = oc.getStringVector("itsumo-files");
// load nodes, first
Handler Handler(nb);
for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
// nodes
if (!FileHelpers::exists(*file)) {
WRITE_ERROR("Could not open itsumo-file '" + *file + "'.");
return;
}
Handler.setFileName(*file);
PROGRESS_BEGIN_MESSAGE("Parsing nodes from itsumo-file '" + *file + "'");
if (!XMLSubSys::runParser(Handler, *file)) {
return;
}
PROGRESS_DONE_MESSAGE();
}
}
template<> bool Config<const char *>::Set(const char *newval)
{
if( m_current == newval )
return true;
if( m_current && newval && 0==strcmp(newval, m_current) )
return true;
if( !Locked() && Valid(newval) ){
size_t len;
char *tmp;
if( m_current ){
delete []m_current;
m_current = (const char *)0;
}
if( newval ){
len = strlen(newval);
if( MaxLen() && len > MaxLen() ) len = MaxLen();
if( !(tmp = new char[len + 1]) ) return false;
strncpy(tmp, newval, len);
tmp[len] = '\0';
m_current = tmp;
}
Handler();
if(*cfg_verbose)
CONSOLE.Debug("Config: %s = \"%s\"", Tag(), m_current ? m_current : "");
return true;
}
return false;
}
void UdpSocket::SetMulticastDefaultInterface(in6_addr a, int if_index)
{
if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_IF, &if_index, sizeof(if_index)) == -1)
{
Handler().LogError(this, "SetMulticastDefaultInterface(ipv6)", Errno, StrError(Errno), LOG_LEVEL_WARNING);
}
}
void UdpSocket::SetMulticastHops(int hops)
{
if (GetSocket() == INVALID_SOCKET)
{
CreateConnection();
}
if (!IsIpv6())
{
Handler().LogError(this, "SetMulticastHops", 0, "Ipv6 only", LOG_LEVEL_ERROR);
return;
}
if (setsockopt(GetSocket(), IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&hops, sizeof(int)) == -1)
{
Handler().LogError(this, "SetMulticastHops", Errno, StrError(Errno), LOG_LEVEL_WARNING);
}
}
int UdpSocket::Bind(SocketAddress& ad, int range)
{
if (GetSocket() == INVALID_SOCKET)
{
Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
}
if (GetSocket() != INVALID_SOCKET)
{
SetNonblocking(true);
int n = bind(GetSocket(), ad, ad);
int tries = range;
while (n == -1 && tries--)
{
ad.SetPort(ad.GetPort() + 1);
n = bind(GetSocket(), ad, ad);
}
if (n == -1)
{
Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
#ifdef ENABLE_EXCEPTIONS
throw Exception("bind() failed for UdpSocket, port:range: " + Utility::l2string(ad.GetPort()) + ":" + Utility::l2string(range));
#endif
return -1;
}
m_bind_ok = true;
m_port = ad.GetPort();
return 0;
}
return -1;
}
void HttpClientSocket::OnData(const char *buf,size_t len)
{
if (m_fil)
{
m_fil -> fwrite(buf, 1, len);
}
else
if (m_data_ptr)
{
if (m_content_ptr + len > m_data_size)
{
Handler().LogError(this, "OnData", -1, "content buffer overflow", LOG_LEVEL_ERROR);
}
else
{
memcpy(m_data_ptr + m_content_ptr, buf, len);
}
}
m_content_ptr += len;
if (m_content_ptr == m_content_length && m_content_length)
{
if (m_fil)
{
m_fil -> fclose();
delete m_fil;
m_fil = NULL;
}
m_b_complete = true;
OnContent();
if (m_b_close_when_complete)
{
SetCloseAndDelete();
}
}
}
HRESULT CTryData4Dlg::OnDataXiuzheng(IHTMLElement *pElement)
{
if(m_State == RUNNING) return S_OK;
if(m_bAddData) InternalRoutines('9'); //update the 测量结果
Handler("compensate",m_sDataSel,m_sDataLst);
return S_OK;
}
void StatusSocket::OnAccept()
{
Send("Local hostname : " + Utility::GetLocalHostname() + "\n");
Send("Local address : " + Utility::GetLocalAddress() + "\n");
Send("Number of sockets in list : " + Utility::l2string(Handler().GetCount()) + "\n");
Send("\n");
}
HRESULT CTryData4Dlg::OnFltvalSelect(IHTMLElement *pElement)
{
m_sFltval=this->GetAttribute(pElement,m_elemTypes[1]);
m_sFltval.Replace("任意值","");
Handler("init",m_sRegSel,m_sRegLst);
return S_OK;
}
void SctpSocket::OnException()
{
if (Connecting())
{
#ifdef ENABLE_SOCKS4
if (Socks4())
OnSocks4ConnectFailed();
else
#endif
if (GetConnectionRetry() == -1 ||
(GetConnectionRetry() &&
GetConnectionRetries() < GetConnectionRetry() ))
{
// even though the connection failed at once, only retry after
// the connection timeout
// should we even try to connect again, when CheckConnect returns
// false it's because of a connection error - not a timeout...
}
else
{
SetConnecting(false); // tnx snibbe
SetCloseAndDelete();
OnConnectFailed();
}
return;
}
// %! exception doesn't always mean something bad happened, this code should be reworked
// errno valid here?
int err = SoError();
Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL);
SetCloseAndDelete();
}
DEFINE_ACTION_FUNCTION(DMessageBoxMenu, CallHandler)
{
PARAM_PROLOGUE;
PARAM_POINTERTYPE(Handler, hfunc);
Handler();
return 0;
}
void HTTPSocket::url_this(const std::string& url_in,std::string& protocol,std::string& host,port_t& port,std::string& url,std::string& file)
{
Parse pa(url_in,"/");
protocol = pa.getword(); // http
if (!strcasecmp(protocol.c_str(), "https:"))
{
#ifdef HAVE_OPENSSL
EnableSSL();
#else
Handler().LogError(this, "url_this", -1, "SSL not available", LOG_LEVEL_WARNING);
#endif
port = 443;
}
else
{
port = 80;
}
host = pa.getword();
if (strstr(host.c_str(),":"))
{
Parse pa(host,":");
pa.getword(host);
port = static_cast<port_t>(pa.getvalue());
}
url = "/" + pa.getrest();
{
Parse pa(url,"/");
std::string tmp = pa.getword();
while (tmp.size())
{
file = tmp;
tmp = pa.getword();
}
}
} // url_this
void World::ConsoleInput()
{
std::string Input;
while (true)
{
std::cout << "Console> " << std::flush;
std::getline(std::cin, Input);
if (Input == "exit")
break;
CommandHandler Handler(Input);
try
{
Handler.ExecuteCommand();
}
catch(CommandHandler::BadCommand&)
{
sLog.Write("Bad command !");
}
catch(sql::SQLException& e)
{
sLog.Write(e.what());
sLog.Flush();
}
}
IsRunning = false;
}
bool TcpSocket::Open(const std::string &host,port_t port)
{
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
if (IsIpv6())
{
#ifdef ENABLE_RESOLVER
if (!Handler().ResolverEnabled() || Utility::isipv6(host) )
{
#endif
in6_addr a;
if (!Utility::u2ip(host, a))
{
SetCloseAndDelete();
return false;
}
Ipv6Address ad(a, port);
Ipv6Address local;
return Open(ad, local);
#ifdef ENABLE_RESOLVER
}
m_resolver_id = Resolve6(host, port);
return true;
#endif
}
#endif
#endif
#ifdef ENABLE_RESOLVER
if (!Handler().ResolverEnabled() || Utility::isipv4(host) )
{
#endif
ipaddr_t l;
if (!Utility::u2ip(host,l))
{
SetCloseAndDelete();
return false;
}
Ipv4Address ad(l, port);
Ipv4Address local;
return Open(ad, local);
#ifdef ENABLE_RESOLVER
}
// resolve using async resolver thread
m_resolver_id = Resolve(host, port);
return true;
#endif
}
static byte TranslateJoy(Uint8 _key, dword& _flags)
{
bool ui_focused = Handler()->VideoDataUI();
switch(_key)
{
case PSP_BUTTON_UP: return 'u';
case PSP_BUTTON_DOWN: return 'd';
case PSP_BUTTON_LEFT: return 'l';
case PSP_BUTTON_RIGHT: return 'r';
case PSP_BUTTON_A: return 'f';
case PSP_BUTTON_B: return 'e';
case PSP_BUTTON_X: return '1';
case PSP_BUTTON_Y: return ' ';
case PSP_BUTTON_SELECT:
b_select = _flags&KF_DOWN;
if(b_select && b_start)
OpQuit(true);
return 'm';
case PSP_BUTTON_START:
b_start = _flags&KF_DOWN;
if(b_select && b_start)
OpQuit(true);
return 'k';
case PSP_BUTTON_L:
l_shift = _flags&KF_DOWN;
if(!ui_focused)
Handler()->OnAction(A_RESET);
break;
case PSP_BUTTON_R:
r_shift = _flags&KF_DOWN;
if(!ui_focused)
{
xOptions::eOption<int>* op_sound = xOptions::eOption<int>::Find("sound");
SAFE_CALL(op_sound)->Change();
}
break;
default:
break;
}
if(b_select && b_start)
OpQuit(true);
return 0;
}
std::auto_ptr<SocketAddress> Socket::GetClientRemoteAddress()
{
if (!m_client_remote_address.get())
{
Handler().LogError(this, "GetClientRemoteAddress", 0, "remote address not yet set", LOG_LEVEL_ERROR);
}
return m_client_remote_address -> GetCopy();
}
void Socket::SetClientRemoteAddress(SocketAddress& ad)
{
if (!ad.IsValid())
{
Handler().LogError(this, "SetClientRemoteAddress", 0, "remote address not valid", LOG_LEVEL_ERROR);
}
m_client_remote_address = ad.GetCopy();
}
bool Socket::SetSoLinger(int onoff, int linger)
{
#ifdef SO_LINGER
struct linger stl;
stl.l_onoff = onoff;
stl.l_linger = linger;
if (setsockopt(GetSocket(), SOL_SOCKET, SO_LINGER, (char *)&stl, sizeof(stl)) == -1)
{
Handler().LogError(this, "setsockopt(SOL_SOCKET, SO_LINGER)", Errno, StrError(Errno), LOG_LEVEL_FATAL);
return false;
}
return true;
#else
Handler().LogError(this, "socket option not available", 0, "SO_LINGER", LOG_LEVEL_INFO);
return false;
#endif
}
