bool ExpDotWriter::postVisit(const std::shared_ptr<TypedExp> &exp)
{
*m_os << "e_" << HostAddress(exp.get()) << " [shape=record,label=\"{";
*m_os << "opTypedExp\\n" << HostAddress(exp.get()) << " | ";
// Just display the C type for now
*m_os << exp->getType()->getCtype() << " | <p1>";
*m_os << " }\"];\n";
*m_os << "e_" << HostAddress(exp.get()) << ":p1->e_" << HostAddress(exp->getSubExp1().get())
<< ";\n";
return true;
}
// Find the native address for the start of the main entry function.
// For Palm binaries, this is PilotMain.
Address PalmBinaryLoader::getMainEntryPoint()
{
BinarySection *psect = m_binaryImage->getSectionByName("code1");
if (psect == nullptr) {
return Address::ZERO; // Failed
}
// Return the start of the code1 section
SWord *startCode = reinterpret_cast<SWord *>(psect->getHostAddr().value());
int delta = (psect->getHostAddr() - psect->getSourceAddr()).value();
// First try the CW first jump pattern
const SWord *res = findPattern(startCode, sizeof(CWFirstJump) / sizeof(SWord), CWFirstJump,
sizeof(CWFirstJump) / sizeof(SWord));
if (res) {
// We have the code warrior first jump. Get the addil operand
const int addilOp = static_cast<int>(Util::readDWord((startCode + 5), Endian::Big));
SWord *startupCode = reinterpret_cast<SWord *>(
(HostAddress(startCode) + 10 + addilOp).value());
// Now check the next 60 SWords for the call to PilotMain
res = findPattern(startupCode, 60, CWCallMain, sizeof(CWCallMain) / sizeof(SWord));
if (res) {
// Get the addil operand
const int _addilOp = Util::readDWord((res + 5), Endian::Big);
// That operand plus the address of that operand is PilotMain
Address offset_loc = Address(reinterpret_cast<const Byte *>(res) -
reinterpret_cast<const Byte *>(startCode) + 5);
return offset_loc + _addilOp; // ADDRESS::host_ptr(res) + 10 + addilOp - delta;
}
else {
fprintf(stderr, "Could not find call to PilotMain in CW app\n");
return Address::ZERO;
}
}
// Check for gcc call to main
res = findPattern(startCode, 75, GccCallMain, sizeof(GccCallMain) / sizeof(SWord));
if (res) {
// Get the operand to the bsr
SWord bsrOp = res[7];
return Address((HostAddress(res) - delta).value() + 14 + bsrOp);
}
fprintf(stderr, "Cannot find call to PilotMain\n");
return Address::ZERO;
}
void PlatformDomainNameAddressQuery::runBlocking() {
//std::cout << "PlatformDomainNameResolver::doRun()" << std::endl;
boost::asio::ip::tcp::resolver resolver(ioService);
boost::asio::ip::tcp::resolver::query query(hostname, "5222");
try {
//std::cout << "PlatformDomainNameResolver::doRun(): Resolving" << std::endl;
boost::asio::ip::tcp::resolver::iterator endpointIterator = resolver.resolve(query);
//std::cout << "PlatformDomainNameResolver::doRun(): Resolved" << std::endl;
if (endpointIterator == boost::asio::ip::tcp::resolver::iterator()) {
//std::cout << "PlatformDomainNameResolver::doRun(): Error 1" << std::endl;
emitError();
}
else {
std::vector<HostAddress> results;
for ( ; endpointIterator != boost::asio::ip::tcp::resolver::iterator(); ++endpointIterator) {
boost::asio::ip::address address = (*endpointIterator).endpoint().address();
results.push_back(address.is_v4() ? HostAddress(&address.to_v4().to_bytes()[0], 4) : HostAddress(&address.to_v6().to_bytes()[0], 16));
}
//std::cout << "PlatformDomainNameResolver::doRun(): Success" << std::endl;
eventLoop->postEvent(
boost::bind(boost::ref(onResult), results, boost::optional<DomainNameResolveError>()),
shared_from_this());
}
}
catch (...) {
//std::cout << "PlatformDomainNameResolver::doRun(): Error 2" << std::endl;
emitError();
}
}
boost::optional<HostAddress> NATPMPInterface::getPublicIP() {
if (sendpublicaddressrequest(&p->natpmp) < 0) {
SWIFT_LOG(debug) << "Failed to send NAT-PMP public address request!" << std::endl;
return boost::optional<HostAddress>();
}
int r = 0;
natpmpresp_t response;
do {
fd_set fds;
struct timeval timeout;
FD_ZERO(&fds);
FD_SET(p->natpmp.s, &fds);
getnatpmprequesttimeout(&p->natpmp, &timeout);
select(FD_SETSIZE, &fds, NULL, NULL, &timeout);
r = readnatpmpresponseorretry(&p->natpmp, &response);
} while (r == NATPMP_TRYAGAIN);
if (r == 0) {
return boost::optional<HostAddress>(HostAddress(reinterpret_cast<const unsigned char*>(&(response.pnu.publicaddress.addr)), 4));
}
else {
SWIFT_LOG(debug) << "Inavlid NAT-PMP response." << std::endl;
return boost::optional<HostAddress>();
}
}
bool ExpDotWriter::postVisit(const std::shared_ptr<Unary> &exp)
{
// First a node for this Unary object
*m_os << "e_" << HostAddress(exp.get()).toString() << " [shape=record,label=\"{";
// The (int) cast is to print the address, not the expression!
*m_os << operToString(exp->getOper()) << "\\n"
<< " | ";
*m_os << "<p1>";
*m_os << " }\"];\n";
// Finally an edge for the subexpression
*m_os << "e_" << HostAddress(exp.get()) << "->e_" << HostAddress(exp->getSubExp1().get())
<< ";\n";
return true;
}
bool TUIClientApp::connectWithTUIServer(
int mySendPortNr,
int myReceivePortNr,
const std::string & serverAddress,
IEventSink * systemNotificationSink,
bool ownership) {
this->myReceivePortNr = myReceivePortNr;
this->systemNotificationSink = systemNotificationSink;
this->outHostMsgDispatcher.addDstAddress(HostAddress(serverAddress));
this->udpSenderSocket.setMyPort(mySendPortNr);
this->udpReceiverSocket.setMyPort(myReceivePortNr);
this->create();
SystemCmdMsg * msg = new SystemCmdMsg();
msg->setPayload(SystemCmd(SystemCmd::requestConnection, static_cast<unsigned short>(this->myReceivePortNr)));
this->outEventQueue.push(msg);
if (ownership) {
this->executeOutputLoop();
}
return true;
}
bool ExpDotWriter::postVisit(const std::shared_ptr<Binary> &exp)
{
// First a node for this Binary object
*m_os << "e_" << HostAddress(exp.get()) << " [shape=record,label=\"{";
*m_os << operToString(exp->getOper()) << "\\n"
<< " | ";
*m_os << "{<p1> | <p2>}";
*m_os << " }\"];\n";
// Now an edge for each subexpression
*m_os << "e_" << HostAddress(exp.get()) << ":p1->e_" << HostAddress(exp->getSubExp1().get())
<< ";\n";
*m_os << "e_" << HostAddress(exp.get()) << ":p2->e_" << HostAddress(exp->getSubExp2().get())
<< ";\n";
return true;
}
bool ExpDotWriter::visit(const std::shared_ptr<Terminal> &exp)
{
*m_os << "e_" << HostAddress(exp.get()).toString() << " [shape=parallelogram,label=\"";
if (exp->getOper() == opWild) {
// Note: value is -1, so can't index array
*m_os << "WILD";
}
else {
*m_os << operToString(exp->getOper());
}
*m_os << "\\n" << HostAddress(exp.get()).toString();
*m_os << "\"];\n";
return true;
}
Socket::Socket(Port _port, bool runInit)
: server(true),
closeOnDelete(true),
handle(-1),
iaddr(HostAddress(),_port)
{
if (!globalInit()) JGACHINE_SERROR("globalInit");
if (runInit) init();
}
bool ExpDotWriter::postVisit(const std::shared_ptr<FlagDef> &exp)
{
*m_os << "e_" << HostAddress(exp.get()) << " [shape=record,label=\"{";
*m_os << "opFlagDef \\n" << HostAddress(exp.get()) << "| ";
// Display the RTL as "RTL <r1> <r2>..." vertically (curly brackets)
*m_os << "{ RTL ";
const size_t n = exp->getRTL()->size();
for (size_t i = 0; i < n; i++) {
*m_os << "| <r" << i << "> ";
}
*m_os << "} | <p1> }\"];\n";
*m_os << "e_" << HostAddress(exp.get()) << ":p1->e_" << HostAddress(exp->getSubExp1().get())
<< ";\n";
return true;
}
main()
{
#ifdef WINDOWS_NT
WSADATA wsaData;
// Initialize the winsock library
if (WSAStartup(0x101, &wsaData) != 0)
{
cout << "Error intializing Winsock library: " << WSAGetLastError() << endl;
return 0;
}
#endif
// Retrieve the host name and host address given the host name
try
{
XPCGetHostInfo HostName("aHost", NAME);
cout << "Name: " << HostName.sGetHostName() << endl;
cout << "Address: " << HostName.sGetHostAddress() << endl;
}
catch (XPCException &exceptObject)
{
cout << exceptObject.sGetException() << endl;
}
// Retrieve the host name and host address given the host address
try
{
XPCGetHostInfo HostAddress("146.121.32.139", ADDRESS);
cout << "Name: " << HostAddress.sGetHostName() << endl;
cout << "Address: " << HostAddress.sGetHostAddress() << endl;
}
catch (XPCException &exceptObject)
{
cout << exceptObject.sGetException() << endl;
}
#ifdef UNIX
// Retrieve all entries from the host name database
XPCGetHostInfo AllHosts;
while(AllHosts.cGetNextHost())
{
cout << "Name: " << AllHosts.sGetHostName() << endl;
cout << "Address: " << AllHosts.sGetHostAddress() << endl;
}
#endif
#ifdef WINDOWS_NT
// Close the winsock library
if (WSACleanup() != 0)
{
cerr << "Error cleaning up the Winsock library: " << WSAGetLastError() << endl;
}
#endif
}
std::vector<NetworkInterface> WindowsNetworkEnvironment::getNetworkInterfaces() const {
std::vector<NetworkInterface> result;
ByteArray adapters;
ULONG bufferSize = 0;
ULONG ret;
ULONG flags = GAA_FLAG_INCLUDE_ALL_INTERFACES | GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
while ((ret = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, reinterpret_cast<IP_ADAPTER_ADDRESSES*>(vecptr(adapters)), &bufferSize)) == ERROR_BUFFER_OVERFLOW) {
adapters.resize(bufferSize);
};
if (ret != ERROR_SUCCESS) {
return result;
}
std::map<std::string,NetworkInterface> interfaces;
for (IP_ADAPTER_ADDRESSES* adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(vecptr(adapters)); adapter; adapter = adapter->Next) {
std::string name(adapter->AdapterName);
if (adapter->OperStatus != IfOperStatusUp) {
continue;
}
for (IP_ADAPTER_UNICAST_ADDRESS* address = adapter->FirstUnicastAddress; address; address = address->Next) {
boost::optional<HostAddress> hostAddress;
if (address->Address.lpSockaddr->sa_family == PF_INET) {
sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
hostAddress = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin_addr)), 4);
}
else if (address->Address.lpSockaddr->sa_family == PF_INET6) {
sockaddr_in6* sa = reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);
hostAddress = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin6_addr)), 16);
}
if (hostAddress) {
std::map<std::string, NetworkInterface>::iterator i = interfaces.insert(std::make_pair(name, NetworkInterface(name, false))).first;
i->second.addAddress(*hostAddress);
}
}
}
for (std::map<std::string,NetworkInterface>::const_iterator i = interfaces.begin(); i != interfaces.end(); ++i) {
result.push_back(i->second);
}
return result;
}
boost::optional<HostAddress> MiniUPnPInterface::getPublicIP() {
if (!p->isValid) {
return boost::optional<HostAddress>();
}
char externalIPAddress[40];
int ret = UPNP_GetExternalIPAddress(p->urls.controlURL, p->data.first.servicetype, externalIPAddress);
if (ret != UPNPCOMMAND_SUCCESS) {
return boost::optional<HostAddress>();
}
else {
return HostAddress(std::string(externalIPAddress));
}
}
HostAddressPort UnixProxyProvider::getHTTPConnectProxy() const {
HostAddressPort proxy;
#if defined(HAVE_GCONF)
proxy = gconfProxyProvider->getHTTPConnectProxy();
if(proxy.isValid()) {
return proxy;
}
#endif
proxy = environmentProxyProvider.getHTTPConnectProxy();
if(proxy.isValid()) {
return proxy;
}
return HostAddressPort(HostAddress(), 0);
}
void Connector::start() {
SWIFT_LOG(debug) << "Starting connector for " << hostname << std::endl;
assert(!currentConnection);
assert(!serviceQuery);
assert(!timer);
queriedAllServices = false;
if (timeoutMilliseconds > 0) {
timer = timerFactory->createTimer(timeoutMilliseconds);
timer->onTick.connect(boost::bind(&Connector::handleTimeout, shared_from_this()));
}
if (serviceLookupPrefix) {
serviceQuery = resolver->createServiceQuery(*serviceLookupPrefix, hostname);
serviceQuery->onResult.connect(boost::bind(&Connector::handleServiceQueryResult, shared_from_this(), _1));
serviceQuery->run();
}
else if (HostAddress(hostname).isValid()) {
// hostname is already a valid address; skip name lookup.
foundSomeDNS = true;
addressQueryResults.push_back(HostAddress(hostname));
tryNextAddress();
} else {
queryAddress(hostname);
}
}
void Network::UdpSocket::canRead() {
struct sockaddr_in addr;
socklen_t size = sizeof(addr);
memset(&addr, 0, sizeof(addr));
_readMutex.lock();
_reading = false;
int ret = recvfrom(_fd, (char*)(*_readBuffer), _readBuffer->getSize(), 0, (struct sockaddr*)&addr, &size);
_readMutex.unlock();
if (ret == 0)
this->close();
else if (ret != -1 && _delegate) {
_readBuffer->resize(ret);
_delegate->readFinished(this, *_readBuffer, HostAddress(inet_ntoa(addr.sin_addr)), ntohs(addr.sin_port));
}
}
void SOCKS5BytestreamProxiesManager::handleProxyFound(S5BProxyRequest::ref proxy) {
if (proxy) {
if (HostAddress(proxy->getStreamHost().get().host).isValid()) {
addS5BProxy(proxy);
}
else {
DomainNameAddressQuery::ref resolveRequest = resolver_->createAddressQuery(proxy->getStreamHost().get().host);
resolveRequest->onResult.connect(boost::bind(&SOCKS5BytestreamProxiesManager::handleNameLookupResult, this, _1, _2, proxy));
resolveRequest->run();
}
}
else {
onDiscoveredProxiesChanged();
}
proxyFinder_->stop();
proxyFinder_.reset();
}
void JingleS5BTransportMethodPayloadParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) {
if (level == 0) {
getPayloadInternal()->setSessionID(attributes.getAttributeValue("sid").get_value_or(""));
std::string mode = attributes.getAttributeValue("mode").get_value_or("tcp");
if (mode == "tcp") {
getPayloadInternal()->setMode(JingleS5BTransportPayload::TCPMode);
} else if(mode == "udp") {
getPayloadInternal()->setMode(JingleS5BTransportPayload::UDPMode);
} else {
SWIFT_LOG(warning) << "Unknown S5B mode; falling back to defaul!";
getPayloadInternal()->setMode(JingleS5BTransportPayload::TCPMode);
}
getPayloadInternal()->setDstAddr(attributes.getAttributeValue("dstaddr").get_value_or(""));
} else if (level == 1) {
if (element == "candidate") {
JingleS5BTransportPayload::Candidate candidate;
candidate.cid = attributes.getAttributeValue("cid").get_value_or("");
int port = -1;
try {
port = boost::lexical_cast<int>(attributes.getAttributeValue("port").get_value_or("-1"));
} catch(boost::bad_lexical_cast &) { }
candidate.hostPort = HostAddressPort(HostAddress(attributes.getAttributeValue("host").get_value_or("")), port);
candidate.jid = JID(attributes.getAttributeValue("jid").get_value_or(""));
int priority = -1;
try {
priority = boost::lexical_cast<int>(attributes.getAttributeValue("priority").get_value_or("-1"));
} catch(boost::bad_lexical_cast &) { }
candidate.priority = priority;
candidate.type = stringToType(attributes.getAttributeValue("type").get_value_or("direct"));
getPayloadInternal()->addCandidate(candidate);
} else if (element == "candidate-used") {
getPayloadInternal()->setCandidateUsed(attributes.getAttributeValue("cid").get_value_or(""));
} else if (element == "candidate-error") {
getPayloadInternal()->setCandidateError(true);
} else if (element == "activated") {
getPayloadInternal()->setActivated(attributes.getAttributeValue("cid").get_value_or(""));
} else if (element == "proxy-error") {
getPayloadInternal()->setProxyError(true);
}
}
++level;
}
bool ExpDotWriter::visit(const std::shared_ptr<Const> &exp)
{
// We define a unique name for each node as "e_0x123456" if the address of "this" == 0x123456
*m_os << "e_" << HostAddress(exp.get()) << " [shape=record,label=\"{";
*m_os << operToString(exp->getOper()) << "\\n"
<< " | ";
switch (exp->getOper()) {
// Might want to distinguish this better, e.g. "(func*)myProc"
case opFuncConst: *m_os << exp->getFuncName() << "()"; break;
case opIntConst: *m_os << exp->getInt(); break;
case opFltConst: *m_os << exp->getFlt(); break;
case opStrConst: *m_os << "\\\"" << exp->getStr() << "\\\""; break;
default: break;
}
*m_os << " }\"];\n";
return true;
}
bool RedisProxy::run(const HostAddress& addr)
{
if (isRunning()) {
return false;
}
if (m_vipEnabled) {
TcpSocket sock = TcpSocket::createTcpSocket();
Logger::log(Logger::Message, "connect to vip address(%s:%d)...", m_vipAddress, addr.port());
if (!sock.connect(HostAddress(m_vipAddress, addr.port()))) {
Logger::log(Logger::Message, "set VIP [%s,%s]...", m_vipName, m_vipAddress);
int ret = NonPortable::setVipAddress(m_vipName, m_vipAddress, 0);
Logger::log(Logger::Message, "set_vip_address return %d", ret);
} else {
m_vipSocket = sock;
m_vipEvent.set(eventLoop(), sock.socket(), EV_READ, vipHandler, this);
m_vipEvent.active();
}
}
m_monitor->proxyStarted(this);
Logger::log(Logger::Message, "Start the %s on port %d", APP_NAME, addr.port());
RedisCommand cmds[] = {
{"HASHMAPPING", 11, -1, onHashMapping, NULL},
{"ADDKEYMAPPING", 13, -1, onAddKeyMapping, NULL},
{"DELKEYMAPPING", 13, -1, onDelKeyMapping, NULL},
{"SHOWMAPPING", 11, -1, onShowMapping, NULL},
{"POOLINFO", 8, -1, onPoolInfo, NULL},
{"SHUTDOWN", 8, -1, onShutDown, this}
};
RedisCommandTable::instance()->registerCommand(cmds, sizeof(cmds)/sizeof(RedisCommand));
return TcpServer::run(addr);
}
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*/
#pragma endregion License
#include "Address.h"
#include "boomerang/util/ByteUtil.h"
#include "boomerang/util/log/Log.h"
#include <cassert>
const Address Address::ZERO = Address(0);
const Address Address::INVALID = Address(static_cast<Address::value_type>(-1));
Byte Address::m_sourceBits = 32U;
const HostAddress HostAddress::ZERO = HostAddress(nullptr);
const HostAddress HostAddress::INVALID = HostAddress(static_cast<HostAddress::value_type>(-1));
Address::Address()
: m_value(0)
{
}
Address::Address(value_type _value)
: m_value(_value)
{
if ((m_value != static_cast<value_type>(-1)) && ((_value & ~getSourceMask()) != 0)) {
LOG_VERBOSE2("Address initialized with invalid value %1",
QString("0x%1").arg(m_value, 2 * sizeof(value_type), 16, QChar('0')));
void startOneCache(void)
{
CRedisProxyCfg* cfg = CRedisProxyCfg::instance();
setupSignal();
EventLoop listenerLoop;
bool twemproxyMode = cfg->isTwemproxyMode();
const int points_per_server = 160;
const int pointer_per_hash = 4;
int slot_index = 0;
RedisProxy proxy;
proxy.setEventLoop(&listenerLoop);
loop = &listenerLoop;
CProxyMonitor monitor;
proxy.setMonitor(&monitor);
const int defaultPort = 8221;
int port = cfg->port();
if (port <= 0) {
LOG(Logger::Debug, "Port %d invalid, use default port %d", defaultPort);
port = defaultPort;
}
if (!proxy.run(HostAddress(port))) {
exit(APP_EXIT_KEY);
}
proxy.setTwemproxyModeEnabled(twemproxyMode);
EventLoopThreadPool pool;
pool.start(cfg->threadNum());
proxy.setEventLoopThreadPool(&pool);
const SVipInfo* vipInfo = cfg->vipInfo();
proxy.setVipName(vipInfo->if_alias_name);
proxy.setVipAddress(vipInfo->vip_address);
proxy.setVipEnabled(vipInfo->enable);
const SHashInfo* sHashInfo = cfg->hashInfo();
if (!twemproxyMode) {
proxy.setSlotCount(sHashInfo->hash_value_max);
} else {
proxy.setSlotCount(cfg->groupCnt() * points_per_server);
}
const GroupOption* groupOption = cfg->groupOption();
proxy.setGroupRetryTime(groupOption->group_retry_time);
proxy.setAutoEjectGroupEnabled(groupOption->auto_eject_group);
proxy.setEjectAfterRestoreEnabled(groupOption->eject_after_restore);
proxy.setPassword(cfg->password());
for (int i = 0; i < cfg->groupCnt(); ++i) {
const CGroupInfo* info = cfg->group(i);
RedisServantGroup* group = new RedisServantGroup;
RedisServantGroupPolicy* policy = RedisServantGroupPolicy::createPolicy(info->groupPolicy());
group->setGroupName(info->groupName());
group->setPolicy(policy);
const HostInfoList& hostList = info->hosts();
HostInfoList::const_iterator itHost = hostList.begin();
for (; itHost != hostList.end(); ++itHost) {
const CHostInfo& hostInfo = (*itHost);
RedisServant* servant = new RedisServant;
RedisServant::Option opt;
strcpy(opt.name, hostInfo.get_hostName().c_str());
opt.poolSize = hostInfo.get_connectionNum();
opt.reconnInterval = groupOption->backend_retry_interval;
opt.maxReconnCount = groupOption->backend_retry_limit;
servant->setOption(opt);
servant->setRedisAddress(HostAddress(hostInfo.get_ip().c_str(), hostInfo.get_port()));
servant->setEventLoop(proxy.eventLoop());
if (hostInfo.get_master()) {
group->addMasterRedisServant(servant);
} else {
group->addSlaveRedisServant(servant);
}
servant->connectionPool()->setPassword(itHost->passWord());
}
group->setEnabled(true);
proxy.addRedisGroup(group);
if (!twemproxyMode) {
for (int i = info->hashMin(); i <= info->hashMax(); ++i) {
proxy.setSlot(i, group);
}
for (int i = 0; i < cfg->hashMapCnt(); ++i) {
const CHashMapping* mapping = cfg->hashMapping(i);
RedisServantGroup* group = proxy.group(mapping->group_name);
proxy.setSlot(mapping->hash_value, group);
}
} else {
Slot* slot = proxy.slotData();
for (int pointer_index = 1;
pointer_index <= points_per_server / pointer_per_hash;
pointer_index++) {
char host[86];
int hostlen = sprintf(host, "%s-%u", group->groupName(), pointer_index - 1);
for (int x = 0; x < pointer_per_hash; x++) {
slot[slot_index].group = group;
slot[slot_index++].value = ketama_hash(host, hostlen, x);
}
}
}
}
if (twemproxyMode) {
LOG(Logger::Debug, "Twemproxy mode. dist=ketama slotcount=%d", proxy.slotCount());
Slot* slot = proxy.slotData();
int slotCount = proxy.slotCount();
qsort(slot, slotCount, sizeof(Slot), slot_item_cmp);
}
HashFunc func = hashfuncFromName(cfg->hashFunctin().c_str());
proxy.setHashFunction(func);
for (int i = 0; i < cfg->keyMapCnt(); ++i) {
const CKeyMapping* mapping = cfg->keyMapping(i);
RedisServantGroup* group = proxy.group(mapping->group_name);
if (group != NULL) {
proxy.addGroupKeyMapping(mapping->key, strlen(mapping->key), group);
}
}
LOG(Logger::Message, "Start the %s on port %d. PID: %d", APP_NAME, port, getpid());
listenerLoop.exec();
}
bool PalmBinaryLoader::loadFromMemory(QByteArray &img)
{
const int size = img.size();
m_image = reinterpret_cast<uint8_t *>(img.data());
if (static_cast<unsigned long>(size) < sizeof(PRCHeader) + sizeof(PRCRecordList)) {
LOG_ERROR("This is not a standard .prc file");
return false;
}
PRCHeader *prcHeader = reinterpret_cast<PRCHeader *>(img.data());
// Check type at offset 0x3C; should be "appl" (or "palm"; ugh!)
if ((strncmp(prcHeader->type, "appl", 4) != 0) && (strncmp(prcHeader->type, "panl", 4) != 0) &&
(strncmp(prcHeader->type, "libr", 4) != 0)) {
LOG_ERROR("This is not a standard .prc file");
return false;
}
addTrapSymbols();
// Get the number of resource headers (one section per resource)
PRCRecordList *records = reinterpret_cast<PRCRecordList *>(m_image + sizeof(PRCHeader));
if (records->nextRecordListOffset != 0) {
LOG_ERROR("Reading PRC files with multiple record lists is not supported!");
return false;
}
const SWord numSections = Util::readWord(&records->resourceCount, Endian::Big);
// Iterate through the resource headers (generating section info structs)
PRCResource *resource = reinterpret_cast<PRCResource *>(m_image + sizeof(PRCHeader) +
sizeof(PRCRecordList));
std::vector<SectionProperties> sectionProperties;
for (unsigned i = 0; i < numSections; i++) {
char buf[5];
strncpy(buf, reinterpret_cast<char *>(&resource[i].type), 4);
buf[4] = 0;
SWord id = Util::readWord(&resource[i].id, Endian::Big);
QString name = QString("%1%2").arg(buf).arg(id);
DWord dataOffset = Util::readDWord(&resource[i].dataOffset, Endian::Big);
Address startAddr(dataOffset);
if (i > 0) {
sectionProperties[i - 1].to = startAddr;
}
sectionProperties.push_back(
{ name, startAddr, Address::INVALID, HostAddress(m_image + dataOffset) });
}
// last section extends until eof
sectionProperties[numSections - 1].to = Address(size);
for (SectionProperties props : sectionProperties) {
assert(props.to != Address::INVALID);
BinarySection *sect = m_binaryImage->createSection(props.name, props.from, props.to);
if (sect) {
// Decide if code or data; note that code0 is a special case (not code)
sect->setHostAddr(props.hostAddr);
sect->setCode((props.name != "code0") && (props.name.startsWith("code")));
sect->setData(props.name.startsWith("data"));
sect->setEndian(Endian::Little); // little endian
sect->setEntrySize(1); // No info available
sect->addDefinedArea(props.from, props.to); // no BSS
}
}
// Create a separate, uncompressed, initialised data section
BinarySection *dataSection = m_binaryImage->getSectionByName("data0");
if (dataSection == nullptr) {
LOG_ERROR("No data section found!");
return false;
}
const BinarySection *code0Section = m_binaryImage->getSectionByName("code0");
if (code0Section == nullptr) {
LOG_ERROR("No code 0 section found!");
return false;
}
// When the info is all boiled down, the two things we need from the
// code 0 section are at offset 0, the size of data above a5, and at
// offset 4, the size below. Save the size below as a member variable
m_sizeBelowA5 = UINT4ADDR(code0Section->getHostAddr() + 4);
// Total size is this plus the amount above (>=) a5
unsigned sizeData = m_sizeBelowA5 + UINT4ADDR(code0Section->getHostAddr());
// Allocate a new data section
m_data = new unsigned char[sizeData];
if (m_data == nullptr) {
LOG_FATAL("Could not allocate %1 bytes for data section", sizeData);
}
// Uncompress the data. Skip first long (offset of CODE1 "xrefs")
Byte *p = reinterpret_cast<Byte *>((dataSection->getHostAddr() + 4).value());
int start = static_cast<int>(UINT4(p));
p += 4;
unsigned char *q = (m_data + m_sizeBelowA5 + start);
bool done = false;
while (!done && (p < reinterpret_cast<unsigned char *>(
(dataSection->getHostAddr() + dataSection->getSize()).value()))) {
unsigned char rle = *p++;
if (rle == 0) {
done = true;
break;
}
else if (rle == 1) {
// 0x01 b_0 b_1
// => 0x00 0x00 0x00 0x00 0xFF 0xFF b_0 b_1
*q++ = 0x00;
*q++ = 0x00;
*q++ = 0x00;
*q++ = 0x00;
*q++ = 0xFF;
*q++ = 0xFF;
*q++ = *p++;
*q++ = *p++;
}
else if (rle == 2) {
// 0x02 b_0 b_1 b_2
// => 0x00 0x00 0x00 0x00 0xFF b_0 b_1 b_2
*q++ = 0x00;
*q++ = 0x00;
*q++ = 0x00;
*q++ = 0x00;
*q++ = 0xFF;
*q++ = *p++;
*q++ = *p++;
*q++ = *p++;
}
else if (rle == 3) {
// 0x03 b_0 b_1 b_2
// => 0xA9 0xF0 0x00 0x00 b_0 b_1 0x00 b_2
*q++ = 0xA9;
*q++ = 0xF0;
*q++ = 0x00;
*q++ = 0x00;
*q++ = *p++;
*q++ = *p++;
*q++ = 0x00;
*q++ = *p++;
}
else if (rle == 4) {
// 0x04 b_0 b_1 b_2 b_3
// => 0xA9 axF0 0x00 b_0 b_1 b_3 0x00 b_3
*q++ = 0xA9;
*q++ = 0xF0;
*q++ = 0x00;
*q++ = *p++;
*q++ = *p++;
*q++ = *p++;
*q++ = 0x00;
*q++ = *p++;
}
else if (rle < 0x10) {
// 5-0xF are invalid.
assert(false);
}
else if (rle >= 0x80) {
// n+1 bytes of literal data
for (int k = 0; k <= (rle - 0x80); k++) {
*q++ = *p++;
}
}
else if (rle >= 40) {
// n+1 repetitions of 0
for (int k = 0; k <= (rle - 0x40); k++) {
*q++ = 0x00;
}
}
else if (rle >= 20) {
// n+2 repetitions of b
unsigned char b = *p++;
for (int k = 0; k < (rle - 0x20 + 2); k++) {
*q++ = b;
}
}
else {
// 0x10: n+1 repetitions of 0xFF
for (int k = 0; k <= (rle - 0x10); k++) {
*q++ = 0xFF;
}
}
}
if (!done) {
LOG_WARN("Compressed data section premature end");
}
LOG_VERBOSE("Used %1 bytes of %2 in decompressing data section",
p - reinterpret_cast<unsigned char *>(dataSection->getHostAddr().value()),
dataSection->getSize());
// Replace the data pointer and size with the uncompressed versions
dataSection->setHostAddr(HostAddress(m_data));
dataSection->resize(sizeData);
m_symbols->createSymbol(getMainEntryPoint(), "PilotMain")->setAttribute("EntryPoint", true);
return true;
}
//
// Made by loick michard
// Login <*****@*****.**>
//
// Started on Tue Dec 18 15:51:08 2012 loick michard
//
#include "OS.h"
#if defined(OS_WINDOWS)
# include <winsock2.h>
#else
# include <arpa/inet.h>
#endif
#include "HostAddress.h"
Network::HostAddress Network::HostAddress::AnyAddress = HostAddress(INADDR_ANY);
Network::HostAddress::HostAddress(const std::string& address) {
_address = inet_addr(address.c_str());
}
Network::HostAddress::HostAddress(uint32 address) {
_address = htonl(address);
}
uint32 Network::HostAddress::toIPv4Address() const {
return _address;
}
std::string Network::HostAddress::getString() const {
in_addr address;
void AvahiResolveHostnameQuery::run() {
eventLoop->postEvent(boost::bind(boost::ref(onHostnameResolved), boost::optional<HostAddress>(HostAddress(hostname))), shared_from_this());
}
