void TAsyncSignalHandler::registerSignalHandler(int signum) {
pair<SignalEventMap::iterator, bool> ret =
signalEvents_.insert(make_pair(signum, event()));
if (!ret.second) {
// This signal has already been registered
throw TLibraryException("handler already registered for signal " +
boost::lexical_cast<string>(signum));
}
struct event* ev = &(ret.first->second);
try {
signal_set(ev, signum, libeventCallback, this);
if (event_base_set(eventBase_->getLibeventBase(), ev) != 0 ) {
throw TLibraryException("error initializing event handler for signal " +
boost::lexical_cast<string>(signum));
}
if (event_add(ev, nullptr) != 0) {
throw TLibraryException("error adding event handler for signal " +
boost::lexical_cast<string>(signum));
}
} catch (...) {
signalEvents_.erase(ret.first);
throw;
}
}
void getLocalAddresses(std::vector<folly::SocketAddress>* results) {
struct ifaddrs* addrs = nullptr;
if (getifaddrs(&addrs) != 0) {
throw TLibraryException("getifaddrs() failed", errno);
}
try {
for (struct ifaddrs* cur = addrs; cur != nullptr; cur = cur->ifa_next) {
folly::SocketAddress addr;
try {
addr.setFromSockaddr(cur->ifa_addr);
} catch (const std::exception& ex) {
// Most likely an unsupported address family. Just skip this address.
continue;
}
results->push_back(addr);
}
} catch (...) {
freeifaddrs(addrs);
throw;
}
freeifaddrs(addrs);
}
void TAsyncSignalHandler::unregisterSignalHandler(int signum) {
SignalEventMap::iterator it = signalEvents_.find(signum);
if (it == signalEvents_.end()) {
throw TLibraryException("unable to unregister handler for signal " +
boost::lexical_cast<string>(signum) +
": signal not registered");
}
event_del(&it->second);
signalEvents_.erase(it);
}
void PeekProcessor::setTargetTransport(std::shared_ptr<TTransport> targetTransport) {
targetTransport_ = targetTransport;
if (std::dynamic_pointer_cast<TMemoryBuffer>(targetTransport_)) {
memoryBuffer_ = std::dynamic_pointer_cast<TMemoryBuffer>(targetTransport);
} else if (std::dynamic_pointer_cast<TPipedTransport>(targetTransport_)) {
memoryBuffer_ = std::dynamic_pointer_cast<TMemoryBuffer>(std::dynamic_pointer_cast<TPipedTransport>(targetTransport_)->getTargetTransport());
}
if (!memoryBuffer_) {
throw TLibraryException("Target transport must be a TMemoryBuffer or a TPipedTransport with TMemoryBuffer");
}
}
bool PeekProcessor::process(std::shared_ptr<TProtocol> in,
std::shared_ptr<TProtocol> out,
TConnectionContext* connectionContext) {
std::string fname;
TMessageType mtype;
int32_t seqid;
in->readMessageBegin(fname, mtype, seqid);
if (mtype != T_CALL) {
throw TLibraryException("Unexpected message type");
}
// Peek at the name
peekName(fname);
TType ftype;
int16_t fid;
while (true) {
in->readFieldBegin(fname, ftype, fid);
if (ftype == T_STOP) {
break;
}
// Peek at the variable
peek(in, ftype, fid);
in->readFieldEnd();
}
in->readMessageEnd();
in->getTransport()->readEnd();
//
// All the data is now in memoryBuffer_ and ready to be processed
//
// Let's first take a peek at the full data in memory
uint8_t* buffer;
uint32_t size;
memoryBuffer_->getBuffer(&buffer, &size);
peekBuffer(buffer, size);
// Done peeking at variables
peekEnd();
bool ret = actualProcessor_->process(pipedProtocol_, out, connectionContext);
memoryBuffer_->resetBuffer();
return ret;
}
