TempStream::TempStream(const std::string &prefix, bool deleteOnClose,
IOManager *ioManager, Scheduler *scheduler)
{
std::string tempdir;
bool absolutePath =
#ifdef WINDOWS
(prefix.size() >= 2 && (prefix[1] == ':' || prefix[1] == '\\')) ||
(!prefix.empty() && prefix[0] == '\\');
#else
!prefix.empty() && prefix[0] == '/';
#endif
if (!absolutePath)
tempdir = g_tempDir->val();
#ifdef WINDOWS
std::wstring wtempdir = toUtf16(tempdir);
if (!absolutePath && wtempdir.empty()) {
wtempdir.resize(MAX_PATH);
DWORD len = GetTempPathW(MAX_PATH, &wtempdir[0]);
if (len == 0)
wtempdir = L".";
else
wtempdir.resize(len);
}
std::wstring prefixW = toUtf16(prefix);
size_t backslash = prefixW.rfind(L'\\');
if (backslash != std::wstring::npos) {
wtempdir += prefixW.substr(0, backslash);
prefixW = prefixW.substr(backslash + 1);
}
std::wstring tempfile;
tempfile.resize(MAX_PATH);
UINT len = GetTempFileNameW(wtempdir.c_str(),
prefixW.c_str(),
0,
&tempfile[0]);
if (len == 0)
MORDOR_THROW_EXCEPTION_FROM_LAST_ERROR_API("GetTempFileNameW");
init(tempfile, FileStream::READWRITE,
(FileStream::CreateFlags)(FileStream::OPEN |
(deleteOnClose ? FileStream::DELETE_ON_CLOSE : 0)),
ioManager, scheduler);
#else
if (!absolutePath && tempdir.empty())
tempdir = "/tmp/" + prefix + "XXXXXX";
else if (!absolutePath)
tempdir += prefix + "XXXXXX";
else
tempdir = prefix + "XXXXXX";
int fd = mkstemp(&tempdir[0]);
if (fd < 0)
MORDOR_THROW_EXCEPTION_FROM_LAST_ERROR_API("mkstemp");
init(fd, ioManager, scheduler);
if (deleteOnClose) {
int rc = unlink(tempdir.c_str());
if (rc != 0)
MORDOR_THROW_EXCEPTION_FROM_LAST_ERROR_API("unlink");
}
m_path = tempdir;
#endif
}
BufferedStream::BufferedStream(Stream::ptr parent, bool own)
: FilterStream(parent, own)
{
m_bufferSize = g_defaultBufferSize->val();
m_allowPartialReads = false;
m_flushMultiplesOfBuffer = false;
}
static bool
runTest(TestListener *listener, const std::string &suite,
const std::string &testName, TestDg test)
{
if (listener)
listener->testStarted(suite, testName);
bool protect = !isDebuggerAttached();
protect = protect || g_protect->val();
if (protect) {
try {
test();
if (listener)
listener->testComplete(suite, testName);
} catch (const Assertion &assertion) {
if (listener)
listener->testAsserted(suite, testName, assertion);
return false;
} catch (...) {
if (listener)
listener->testException(suite, testName);
return false;
}
} else {
test();
if (listener)
listener->testComplete(suite, testName);
}
return true;
}
bool
TimerManager::detectClockRollover(unsigned long long nowUs)
{
// If the time jumps backward, expire timers (rather than have them
// expire in the distant future or not at all).
// We check this way because now() will not roll from 0xffff... to zero
// since the underlying hardware counter doesn't count microseconds.
// Use a threshold value so we don't overreact to minor clock jitter.
bool rollover = false;
if (nowUs < m_previousTime && // check first in case the next line would underflow
nowUs < m_previousTime - g_clockRolloverThreshold->val())
{
MORDOR_LOG_ERROR(g_log) << this << " clock has rolled back from "
<< m_previousTime << " to " << nowUs << "; expiring all timers";
rollover = true;
}
m_previousTime = nowUs;
return rollover;
}
static bool
runTests(const TestSuites *suites, TestListener *listener)
{
Assertion::throwOnAssertion = true;
if (g_wait->val()) {
while (!isDebuggerAttached())
sleep(10000ull);
debugBreak();
}
bool result = true;
if (!suites) suites = g_allTests;
if (suites) {
for (TestSuites::const_iterator it(suites->begin());
it != suites->end();
++it) {
for (TestSuite::second_type::const_iterator
it2(it->second.second.begin());
it2 != it->second.second.end();
++it2) {
if (it->second.first) {
result = result && runTest(listener, it->first,
"<invariant>", it->second.first);
}
result = runTest(listener, it->first, it2->first,
it2->second) && result;
}
if (it->second.first) {
result = runTest(listener, it->first,
"<invariant>", it->second.first) && result;
}
}
}
if (listener)
listener->testsComplete();
return result;
}
static int daemonMain(int argc, char *argv[])
{
try {
std::string macAddressString = g_macAddress->val();
replace(macAddressString, "-", "");
if (macAddressString.size() != 12u) {
std::cerr << "MAC address must be 12 characters" << std::endl;
return -1;
}
std::string macAddress = dataFromHexstring(macAddressString);
std::set<Address::ptr> blacklistedAddresses;
std::vector<std::string> blacklistedAddressesString = split(
g_blacklist->val(), ";, ");
for(std::vector<std::string>::const_iterator it(
blacklistedAddressesString.begin());
it != blacklistedAddressesString.end();
++it) {
if(it->empty())
continue;
blacklistedAddresses.insert(IPAddress::create(it->c_str()));
}
std::vector<std::pair<Address::ptr, unsigned int> > addresses =
Address::getInterfaceAddresses(g_interface->val(), AF_INET);
if (addresses.empty()) {
std::cerr << "Couldn't find interface " << g_interface->val()
<< std::endl;
return -1;
}
IPAddress::ptr localAddress = boost::static_pointer_cast<IPAddress>(
addresses.front().first);
IPAddress::ptr broadcastAddress = localAddress->broadcastAddress(
addresses.front().second);
broadcastAddress->port(9u);
IPv4Address multicastAddress("239.255.255.250", 1900);
IOManager ioManager;
Socket::ptr broadcastSocket(broadcastAddress->createSocket(ioManager,
SOCK_DGRAM));
broadcastSocket->setOption(SOL_SOCKET, SO_BROADCAST, 1);
broadcastSocket->connect(broadcastAddress);
Socket::ptr listenSocket(multicastAddress.createSocket(ioManager,
SOCK_DGRAM));
listenSocket->setOption(SOL_SOCKET, SO_REUSEADDR, 1);
listenSocket->bind(IPv4Address(0u, 1900u));
// TODO: listenSocket->joinGroup(multicastAddress, addresses.front().first);
struct ip_mreq multicastGroup;
memcpy(&multicastGroup.imr_multiaddr, &((sockaddr_in *)multicastAddress.name())->sin_addr, sizeof(struct in_addr));
memcpy(&multicastGroup.imr_interface, &((sockaddr_in *)addresses.front().first->name())->sin_addr, sizeof(struct in_addr));
listenSocket->setOption(IPPROTO_IP, IP_ADD_MEMBERSHIP, multicastGroup);
Daemon::onTerminate.connect(boost::bind(&Socket::cancelReceive,
listenSocket));
try {
IPv4Address sender;
char buffer[4096];
size_t size;
while((size = listenSocket->receiveFrom(buffer, 4096, sender))) {
IPAddress::ptr senderDuplicate = sender.clone();
senderDuplicate->port(0u);
if (blacklistedAddresses.find(senderDuplicate) !=
blacklistedAddresses.end()) {
MORDOR_LOG_VERBOSE(Log::root())
<< "Skipping broadcast from " << sender;
continue;
}
HTTP::Request request;
HTTP::RequestParser parser(request);
parser.run(buffer, size);
if (parser.complete() && !parser.error()) {
if (request.requestLine.method == "M-SEARCH") {
MORDOR_LOG_INFO(Log::root()) << "Relaying M-SEARCH to WOL from "
<< sender;
wol(broadcastSocket, macAddress);
}
} else {
MORDOR_LOG_WARNING(Log::root()) << "Unable to parse HTTP request from "
<< sender << ": " << charslice(buffer, size);
}
}
} catch (OperationAbortedException &) {
} catch (...) {
MORDOR_LOG_FATAL(Log::root())
<< boost::current_exception_diagnostic_information();
return -1;
}
} catch (...) {
std::cerr << boost::current_exception_diagnostic_information() << std::endl;
return -1;
}
return 0;
}
