ext_server.cpp

Go to the documentation of this file.

#include <grpcpp/grpcpp.h>
#include "panoptes.pb.h"
#include "panoptes.grpc.pb.h"
 
#include "container_ipc.hpp"
#include <objbase.h>
#include <iostream>
#include <vector>
 
PeMessageQueue::PeMessageQueue() {
    InitializeCriticalSection(&cs_);
    InitializeConditionVariable(&cv_);
}
 
void PeMessageQueue::enqueue(const PeScan& message) {
    EnterCriticalSection(&cs_);
    queue_.push(message);
    std::cout << "Enqueued item. Queue size: " << queue_.size() << std::endl;
    LeaveCriticalSection(&cs_);
    WakeConditionVariable(&cv_);
}
 
PeScan PeMessageQueue::dequeue() {
    EnterCriticalSection(&cs_);
    while (queue_.empty()) {
        std::cout << "Queue empty, waiting..." << std::endl;
        SleepConditionVariableCS(&cv_, &cs_, INFINITE);
    }
    PeScan message = queue_.front();
    queue_.pop();
    // std::cout << "Dequeued item. Remaining queue size: " << queue_.size() << std::endl;
    LeaveCriticalSection(&cs_);
    return message;
}
 
void MemoryMessageQueue::enqueue(const MemScan& message) {
    std::unique_lock<std::mutex> lock(mutex_);
    queue_.push(message);
    cv_.notify_one();
}
 
MemScan MemoryMessageQueue::dequeue() {
    std::unique_lock<std::mutex> lock(mutex_);
    cv_.wait(lock, [this] { return !queue_.empty(); });
    MemScan message = queue_.front();
    queue_.pop();
 
    return message;
}
 
class PanoptesImpl : public PanoptesExtensibility::Service {
    ::grpc::Status PEScan(::grpc::ServerContext* context, const ::PeScanInfo* request, ::AckMessage* response) override {
        PeScan scanInfo;
        scanInfo.PePath = request->portable_executable_path();
        scanInfo.FileHash = request->file_hash();
 
        if (message_queue_pe_ != NULL) {
            message_queue_pe_->enqueue(scanInfo);
        }
 
        response->set_ack_type(AckType::SUCCESS);
        return ::grpc::Status::OK;
    }
 
    ::grpc::Status MemoryScan(::grpc::ServerContext* context, const ::MemoryScanInfo* request, ::AckMessage* response) override {
        MemScan scanInfo;
        scanInfo.ProcessId = request->process_id();
 
        if (message_queue_pe_ != NULL) {
            message_queue_mem_->enqueue(scanInfo);
        }
 
        response->set_ack_type(AckType::SUCCESS);
        return ::grpc::Status::OK;
    }
};
 
void RunContainerServer(LPVOID lpParam)
{
    int* ContainerPort = (int*)(lpParam);
 
    PanoptesImpl service;
    grpc::ServerBuilder builder;
    std::string server_url = "localhost:" + std::to_string(*ContainerPort);
    builder.AddListeningPort(server_url, grpc::InsecureServerCredentials(), ContainerPort);
    builder.RegisterService(&service);
    std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
    server->Wait();
}