int workerMain(int argc, char* argv[]) {
if (!osquery::compareArguments(argv,
argc,
osquery::kExpectedWorkerArgs,
osquery::kExpectedWorkerArgsCount)) {
return ERROR_COMPARE_ARGUMENT;
}
auto process = osquery::PlatformProcess::getLauncherProcess();
if (process == nullptr) {
return ERROR_LAUNCHER_PROCESS;
}
#ifdef WIN32
CHAR buffer[1024] = {0};
DWORD size = 1024;
if (!QueryFullProcessImageNameA(process->nativeHandle(), 0, buffer, &size)) {
return ERROR_QUERY_PROCESS_IMAGE;
}
PathStripPathA(buffer);
if (strlen(buffer) != strlen(osquery::kOsqueryTestModuleName)) {
return ERROR_IMAGE_NAME_LENGTH;
}
if (strncmp(buffer, osquery::kOsqueryTestModuleName, strlen(buffer)) != 0) {
return ERROR_LAUNCHER_MISMATCH;
}
#else
if (process->nativeHandle() != getppid()) {
return ERROR_LAUNCHER_MISMATCH;
}
#endif
return WORKER_SUCCESS_CODE;
}
/*!
\internal
\since 5.1
*/
bool QFSFileEnginePrivate::nativeSyncToDisk()
{
Q_Q(QFSFileEngine);
#if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
const int ret = fdatasync(nativeHandle());
#else
const int ret = fsync(nativeHandle());
#endif
if (ret != 0)
q->setError(QFile::WriteError, qt_error_string(errno));
return ret == 0;
}
ProcessState PlatformProcess::checkStatus(int& status) const {
int process_status = 0;
if (!isValid()) {
return PROCESS_ERROR;
}
pid_t result = ::waitpid(nativeHandle(), &process_status, WNOHANG);
if (result < 0) {
if (errno == ECHILD) {
return PROCESS_EXITED;
}
process_status = -1;
return PROCESS_ERROR;
}
if (result == 0) {
return PROCESS_STILL_ALIVE;
}
if (WIFEXITED(process_status)) {
status = WEXITSTATUS(process_status);
return PROCESS_EXITED;
}
// process's state has changed but the state isn't that which we expect!
return PROCESS_STATE_CHANGE;
}
Alleg4Display::Alleg4Display(int width, int height, int scale)
: m_surface(NULL)
, m_scale(0)
, m_nativeCursor(kNoCursor)
, m_restoredWidth(0)
, m_restoredHeight(0)
{
unique_display = this;
if (install_mouse() < 0) throw DisplayCreationException(allegro_error);
if (install_keyboard() < 0) throw DisplayCreationException(allegro_error);
#ifdef FULLSCREEN_PLATFORM
set_color_depth(16); // TODO Try all color depths for fullscreen platforms
#else
set_color_depth(desktop_color_depth());
#endif
if (set_gfx_mode(
#ifdef FULLSCREEN_PLATFORM
GFX_AUTODETECT_FULLSCREEN,
#else
GFX_AUTODETECT_WINDOWED,
#endif
width, height, 0, 0) < 0)
throw DisplayCreationException(allegro_error);
show_mouse(NULL);
setScale(scale);
#if _WIN32
subclass_hwnd((HWND)nativeHandle());
#endif
}
QQnxBuffer &QQnxRasterWindow::renderBuffer()
{
qRasterWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Check if render buffer is invalid
if (m_currentBufferIndex == -1) {
// Get all buffers available for rendering
screen_buffer_t buffers[MAX_BUFFER_COUNT];
const int result = screen_get_window_property_pv(nativeHandle(), SCREEN_PROPERTY_RENDER_BUFFERS,
(void **)buffers);
Q_SCREEN_CRITICALERROR(result, "Failed to query window buffers");
// Wrap each buffer and clear
for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
m_buffers[i] = QQnxBuffer(buffers[i]);
// Clear Buffer
int bg[] = { SCREEN_BLIT_COLOR, 0x00000000, SCREEN_BLIT_END };
Q_SCREEN_CHECKERROR(screen_fill(screen()->nativeContext(), buffers[i], bg),
"Failed to clear window buffer");
}
Q_SCREEN_CHECKERROR(screen_flush_blits(screen()->nativeContext(), 0),
"Failed to flush blits");
// Use the first available render buffer
m_currentBufferIndex = 0;
m_previousBufferIndex = -1;
}
return m_buffers[m_currentBufferIndex];
}
bool PlatformProcess::kill() const {
if (!isValid()) {
return false;
}
return (::TerminateProcess(nativeHandle(), 0) != FALSE);
}
int Server::handle(http::Server* server, http::Request& request, http::Response& response)
{
dfk_userdata_t user = (dfk_userdata_t) {nativeHandle()};
return dfk_fileserver_handler(user,
server->nativeHandle(),
request.nativeHandle(),
response.nativeHandle());
}
Server::Server(Context* context, const Buffer& basepath)
{
DFK_ENSURE_OK(context,
dfk_fileserver_init(
nativeHandle(),
context->nativeHandle(),
basepath.data(), basepath.size()));
}
bool PlatformProcess::killGracefully() const {
if (!isValid()) {
return false;
}
int status = ::kill(nativeHandle(), SIGINT);
return (status == 0);
}
void QQnxRasterWindow::post(const QRegion &dirty)
{
// How double-buffering works
// --------------------------
//
// The are two buffers, the previous one and the current one.
// The previous buffer always contains the complete, full image of the whole window when it
// was last posted.
// The current buffer starts with the complete, full image of the second to last posting
// of the window.
//
// During painting, Qt paints on the current buffer. Thus, when Qt has finished painting, the
// current buffer contains the second to last image plus the newly painted regions.
// Since the second to last image is too old, we copy over the image from the previous buffer, but
// only for those regions that Qt didn't paint (because that would overwrite what Qt has just
// painted). This is the copyPreviousToCurrent() call below.
//
// After the call to copyPreviousToCurrent(), the current buffer contains the complete, full image of the
// whole window in its current state, and we call screen_post_window() to make the new buffer
// available to libscreen (called "posting"). There, only the regions that Qt painted on are
// posted, as nothing else has changed.
//
// After that, the previous and the current buffers are swapped, and the whole cycle starts anew.
// Check if render buffer exists and something was rendered
if (m_currentBufferIndex != -1 && !dirty.isEmpty()) {
qRasterWindowDebug() << Q_FUNC_INFO << "window =" << window();
QQnxBuffer ¤tBuffer = m_buffers[m_currentBufferIndex];
// Copy unmodified region from old render buffer to new render buffer;
// required to allow partial updates
QRegion preserve = m_previousDirty - dirty - m_scrolled;
blitPreviousToCurrent(preserve, 0, 0);
// Calculate region that changed
QRegion modified = preserve + dirty + m_scrolled;
QRect rect = modified.boundingRect();
int dirtyRect[4] = { rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height() };
// Update the display with contents of render buffer
Q_SCREEN_CHECKERROR(
screen_post_window(nativeHandle(), currentBuffer.nativeBuffer(), 1, dirtyRect, 0),
"Failed to post window");
// Advance to next nender buffer
m_previousBufferIndex = m_currentBufferIndex++;
if (m_currentBufferIndex >= MAX_BUFFER_COUNT)
m_currentBufferIndex = 0;
// Save modified region and clear scrolled region
m_previousDirty = dirty;
m_scrolled = QRegion();
windowPosted();
}
}
Alleg4Display::~Alleg4Display()
{
unique_display = NULL;
#if _WIN32
unsubclass_hwnd((HWND)nativeHandle());
#endif
m_surface->dispose();
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
}
int QFSFileEnginePrivate::getMapHandle()
{
if (symbianFile.SubSessionHandle()) {
// Symbian file handle can't be used for open C mmap() so open the file with open C as well.
if (fileHandleForMaps < 0) {
int flags = openModeToOpenFlags(openMode);
flags &= ~(O_CREAT | O_TRUNC);
fileHandleForMaps = ::wopen((wchar_t*)(fileEntry.nativeFilePath().utf16()), flags, 0666);
}
return fileHandleForMaps;
}
return nativeHandle();
}
TEST_F(ProcessTests, test_constructorWin) {
HANDLE handle =
::OpenProcess(PROCESS_ALL_ACCESS, FALSE, ::GetCurrentProcessId());
EXPECT_NE(handle, reinterpret_cast<HANDLE>(nullptr));
auto p = PlatformProcess(handle);
EXPECT_TRUE(p.isValid());
EXPECT_NE(p.nativeHandle(), handle);
if (handle) {
::CloseHandle(handle);
}
}
Alleg4Display(int width, int height, int scale)
: m_surface(NULL)
, m_scale(0) {
unique_display = this;
if (install_mouse() < 0) throw DisplayCreationException(allegro_error);
if (install_keyboard() < 0) throw DisplayCreationException(allegro_error);
#ifdef FULLSCREEN_PLATFORM
set_color_depth(16); // TODO Try all color depths for fullscreen platforms
#else
set_color_depth(desktop_color_depth());
#endif
if (set_gfx_mode(
#ifdef FULLSCREEN_PLATFORM
GFX_AUTODETECT_FULLSCREEN,
#else
GFX_AUTODETECT_WINDOWED,
#endif
width, height, 0, 0) < 0)
throw DisplayCreationException(allegro_error);
setScale(scale);
m_queue = new Alleg4EventQueue();
// Copy the initial queue to the display queue
{
base::scoped_lock hold(unique_display_mutex);
Event ev;
while (initial_queue.try_pop(ev))
m_queue->queueEvent(ev);
}
// Add a hook to display-switch so when the user returns to the
// screen it's completelly refreshed/redrawn.
LOCK_VARIABLE(display_flags);
LOCK_FUNCTION(display_switch_in_callback);
set_display_switch_callback(SWITCH_IN, display_switch_in_callback);
#ifdef ALLEGRO4_WITH_RESIZE_PATCH
// Setup the handler for window-resize events
set_resize_callback(resize_callback);
#endif
#if WIN32
subclass_hwnd((HWND)nativeHandle());
#endif
}
~Alleg4Display() {
// Put "unique_display" to null so queue_event() doesn't use
// "m_queue" anymore.
{
base::scoped_lock hold(unique_display_mutex);
unique_display = NULL;
}
#if WIN32
unsubclass_hwnd((HWND)nativeHandle());
#endif
delete m_queue;
m_surface->dispose();
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
}
ProcessState PlatformProcess::checkStatus(int& status) const {
unsigned long exit_code = 0;
if (!::GetExitCodeProcess(nativeHandle(), &exit_code)) {
unsigned long last_error = GetLastError();
if (last_error == ERROR_WAIT_NO_CHILDREN) {
return PROCESS_EXITED;
}
return PROCESS_ERROR;
}
if (exit_code == STILL_ACTIVE) {
return PROCESS_STILL_ALIVE;
}
status = exit_code;
return PROCESS_EXITED;
}
QT_BEGIN_NAMESPACE
QQnxRasterWindow::QQnxRasterWindow(QWindow *window, screen_context_t context, bool needRootWindow) :
QQnxWindow(window, context, needRootWindow),
m_currentBufferIndex(-1),
m_previousBufferIndex(-1)
{
initWindow();
// Set window usage
if (window->type() == Qt::Desktop)
return;
const int val = SCREEN_USAGE_NATIVE | SCREEN_USAGE_READ | SCREEN_USAGE_WRITE;
const int result = screen_set_window_property_iv(nativeHandle(), SCREEN_PROPERTY_USAGE, &val);
if (result != 0)
qFatal("QQnxRasterWindow: failed to set window alpha usage, errno=%d", errno);
}
uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
{
Q_Q(QFSFileEngine);
Q_UNUSED(flags);
if (offset < 0) {
q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
return 0;
}
if (openMode == QIODevice::NotOpen) {
q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
return 0;
}
int access = 0;
if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
int pagesSize = getpagesize();
int realOffset = offset / pagesSize;
int extra = offset % pagesSize;
void *mapAddress = mmap((void*)0, (size_t)size + extra,
access, MAP_SHARED, nativeHandle(), realOffset * pagesSize);
if (MAP_FAILED != mapAddress) {
uchar *address = extra + static_cast<uchar*>(mapAddress);
maps[address] = QPair<int,int>(extra, size);
return address;
}
switch(errno) {
case EBADF:
q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
break;
case ENFILE:
case ENOMEM:
q->setError(QFile::ResourceError, qt_error_string(int(errno)));
break;
case EINVAL:
// size are out of bounds
default:
q->setError(QFile::UnspecifiedError, qt_error_string(int(errno)));
break;
}
return 0;
}
Server::Server(Context* context)
{
DFK_ENSURE_OK(context, dfk_http_init(nativeHandle(), context->nativeHandle()));
nativeHandle()->user.data = this;
}
uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
{
Q_Q(QFSFileEngine);
Q_UNUSED(flags);
if (openMode == QIODevice::NotOpen) {
q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
return 0;
}
if (offset < 0 || offset != qint64(QT_OFF_T(offset))
|| size < 0 || quint64(size) > quint64(size_t(-1))) {
q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
return 0;
}
// If we know the mapping will extend beyond EOF, fail early to avoid
// undefined behavior. Otherwise, let mmap have its say.
if (doStat(QFileSystemMetaData::SizeAttribute)
&& (QT_OFF_T(size) > metaData.size() - QT_OFF_T(offset)))
qWarning("QFSFileEngine::map: Mapping a file beyond its size is not portable");
int access = 0;
if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
#if defined(Q_OS_INTEGRITY)
int pageSize = sysconf(_SC_PAGESIZE);
#else
int pageSize = getpagesize();
#endif
int extra = offset % pageSize;
if (quint64(size + extra) > quint64((size_t)-1)) {
q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
return 0;
}
size_t realSize = (size_t)size + extra;
QT_OFF_T realOffset = QT_OFF_T(offset);
realOffset &= ~(QT_OFF_T(pageSize - 1));
#ifdef QT_SYMBIAN_USE_NATIVE_FILEMAP
TInt nativeMapError = KErrNone;
RFileMap mapping;
TUint mode(EFileMapRemovableMedia);
TUint64 nativeOffset = offset & ~(mapping.PageSizeInBytes() - 1);
//If the file was opened for write or read/write, then open the map for read/write
if (openMode & QIODevice::WriteOnly)
mode |= EFileMapWrite;
if (symbianFile.SubSessionHandle()) {
nativeMapError = mapping.Open(symbianFile, nativeOffset, size, mode);
} else {
//map file by name if we don't have a native handle
QString fn = QFileSystemEngine::absoluteName(fileEntry).nativeFilePath();
TUint filemode = EFileShareReadersOrWriters | EFileRead;
if (openMode & QIODevice::WriteOnly)
filemode |= EFileWrite;
nativeMapError = mapping.Open(qt_s60GetRFs(), qt_QString2TPtrC(fn), filemode, nativeOffset, size, mode);
}
if (nativeMapError == KErrNone) {
QScopedResource<RFileMap> ptr(mapping); //will call Close if adding to mapping throws an exception
uchar *address = mapping.Base() + (offset - nativeOffset);
maps[address] = mapping;
ptr.take();
return address;
}
QFile::FileError reportedError = QFile::UnspecifiedError;
switch (nativeMapError) {
case KErrAccessDenied:
case KErrPermissionDenied:
reportedError = QFile::PermissionsError;
break;
case KErrNoMemory:
reportedError = QFile::ResourceError;
break;
}
q->setError(reportedError, QSystemError(nativeMapError, QSystemError::NativeError).toString());
return 0;
#else
#ifdef Q_OS_SYMBIAN
//older phones & emulator don't support native mapping, so need to keep the open C way around for those.
void *mapAddress;
TRAPD(err, mapAddress = QT_MMAP((void*)0, realSize,
access, MAP_SHARED, getMapHandle(), realOffset));
if (err != KErrNone) {
qWarning("OpenC bug: leave from mmap %d", err);
mapAddress = MAP_FAILED;
errno = EINVAL;
}
#else
void *mapAddress = QT_MMAP((void*)0, realSize,
access, MAP_SHARED, nativeHandle(), realOffset);
#endif
if (MAP_FAILED != mapAddress) {
uchar *address = extra + static_cast<uchar*>(mapAddress);
maps[address] = QPair<int,size_t>(extra, realSize);
return address;
}
switch(errno) {
case EBADF:
q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
break;
case ENFILE:
case ENOMEM:
q->setError(QFile::ResourceError, qt_error_string(int(errno)));
break;
case EINVAL:
// size are out of bounds
default:
q->setError(QFile::UnspecifiedError, qt_error_string(int(errno)));
break;
}
return 0;
#endif
}
bool PlatformProcess::operator!=(const PlatformProcess &process) const {
return (::GetProcessId(nativeHandle()) !=
::GetProcessId(process.nativeHandle()));
}
void Server::stop()
{
DFK_ENSURE_OK(context(), dfk_http_stop(nativeHandle()));
}
void Server::serve(const char* endpoint, uint16_t port, IRequestHandler* handler)
{
dfk_userdata_t user = (dfk_userdata_t) {handler};
DFK_ENSURE_OK(context(), dfk_http_serve(nativeHandle(), endpoint, port, Server::handler, user));
}
Context* Server::context()
{
return static_cast<Context*>(nativeHandle()->dfk->user.data);
}
void Server::setIOBufferSize(std::size_t size)
{
nativeHandle()->io_buf_size = size;
}
TEST_F(ProcessTests, test_constructorPosix) {
auto p = PlatformProcess(getpid());
EXPECT_TRUE(p.isValid());
EXPECT_EQ(p.nativeHandle(), getpid());
}
bool PlatformProcess::operator!=(const PlatformProcess& process) const {
return (nativeHandle() != process.nativeHandle());
}
Server::~Server()
{
DFK_ENSURE_OK(context(), dfk_http_free(nativeHandle()));
}
void Coroutine::setName(const char* name)
{
DFK_ENSURE_OK(context(), dfk_coro_name(nativeHandle(), "%s", name));
}
Context* Coroutine::context()
{
return static_cast<Context*>(nativeHandle()->dfk->user.data);
}
