Admin Control Panel v2.0

✎ Editing: protocol_handler.h ← Back

#ifndef KERNEL__OAS__SMALL__PROTOCOL_HANDLER_H
#define KERNEL__OAS__SMALL__PROTOCOL_HANDLER_H

#ifndef __KERNEL__
#include <stdio.h>
#include <string.h>
#endif
#include "oas/small/protocol.h"
#include "oas/small/protocol_packer.h"

#ifdef DEBUG
#define MONITOR_DEBUG "<monitor_debug> "
#ifdef __KERNEL__
#ifdef __linux__
#define DEBUG_MSG(format, args...) printk(MONITOR_DEBUG format "\n", ##args)
#else
#define DEBUG_MSG(format, args...) printf(MONITOR_DEBUG format "\n", ##args)
#endif
#else
#define DEBUG_MSG(format, args...) printf(MONITOR_DEBUG format "\n", ##args)
#endif
#else
#define DEBUG_MSG(format, args...)
#endif

static ProtocolCallbacks callbacks;

static inline void ProtocolCallbacksInit(const ProtocolCallbacks* m_callbacks)
{
    callbacks.check_file    = m_callbacks->check_file;
    callbacks.notify_file   = m_callbacks->notify_file;
    callbacks.samba_connect = m_callbacks->samba_connect;

callbacks.check_file_result = m_callbacks->check_file_result;
    callbacks.shutdown          = m_callbacks->shutdown;
    callbacks.check_sign        = m_callbacks->check_sign;
}

static inline void ProcessProtocolRequest(const ProtocolData* request, void* context)
{
    switch (request->header.request)
    {
        case CHECK_FILE:
        {
            if (request->header.version == 1)
            {
                const CheckFileData* file_data = (const CheckFileData*)request;
//                DEBUG_MSG("check_file pid=%d uid=%d gid=%d queue_id=%d file=%s "
//                          "flags=%d dev_t=%lld ino_t=%lld",
//                          file_data->pid, file_data->uid, file_data->gid,
//                          file_data->queue_id, file_data->name, file_data->flags,
//                          file_data->dev, file_data->ino);
                if (!callbacks.check_file)
                {
                    DEBUG_MSG("no check_file callback function found");
                    break;
                }
                {
                    CheckFileInfoData data;
                    memset(&data, 0, sizeof(data));
                    data.user     = file_data->uid;
                    data.group    = file_data->gid;
                    data.process  = file_data->pid;
                    data.queue_id = file_data->queue_id;
                    data.filename = file_data->name;
                    data.oper     = (enum FileOpType)file_data->file_type;
                    data.flags    = file_data->flags;
                    data.device   = file_data->dev;
                    data.inode    = file_data->ino;

if (file_data->header.data_size !=
                        sizeof(CheckFileData) - sizeof(ProtocolHeader) +
                            strlen(data.filename) + 1)
                        data.host = data.filename + strlen(data.filename) + 1;
                    else
                        data.host = NULL;
                    data.version = 1;
                    callbacks.check_file(context, &data);
                }
                break;
            }
            else if (request->header.version >= 2)
            {
                const CheckFileData2* file_data = (const CheckFileData2*)request;
                if (!callbacks.check_file)
                {
                    DEBUG_MSG("no check_file callback function found");
                    break;
                }
                {
                    CheckFileInfoData data;
                    memset(&data, 0, sizeof(data));
                    data.user     = file_data->uid;
                    data.group    = file_data->gid;
                    data.process  = file_data->pid;
                    data.queue_id = file_data->queue_id;
                    data.filename = GetCheckFileReq2FileName(file_data);
                    data.oper     = (enum FileOpType)file_data->file_op_type;
                    data.flags    = file_data->flags;
                    data.device   = file_data->dev;
                    data.inode    = file_data->ino;

data.mtime      = file_data->mtime;
                    data.size       = file_data->size;
                    data.owner_uid  = file_data->owner_uid;
                    data.file_mode  = file_data->file_mode;
                    data.f_type     = file_data->f_type;
                    data.fstypelen  = file_data->fstypelen;
                    data.fstypename = GetCheckFileReq2FsTypeName(file_data);
                    // FIXME host unset here
                    data.version = request->header.version;
                    callbacks.check_file(context, &data);
                }
                break;
            }
        }
        case NOTIFY_FILE:
        {
            const NotifyFileData* file_data = (const NotifyFileData*)request;
//            DEBUG_MSG("notify_file file=%s dev_t=%lld ino_t=%lld", file_data->name,
//                      file_data->dev, file_data->ino);
            if (!callbacks.notify_file)
            {
                DEBUG_MSG("no notify_file callback function found");
                break;
            }
            {
                NotifyFileInfoData data;
                data.filename = file_data->name;
                data.oper     = (enum FileNotifyType)file_data->file_type;
                data.device   = file_data->dev;
                data.inode = file_data->ino;
                callbacks.notify_file(context, &data);
            }
            break;
        }
        case SAMBA_CONNECT:
        {
            const SambaConnectData* connect_data = (const SambaConnectData*)request;
            DEBUG_MSG("samba_connect user=%s", connect_data->data);
            if (!callbacks.samba_connect)
            {
                DEBUG_MSG("no samba_connect callback function found");
                break;
            }
            {
                SambaConnectInfoData data;
                data.queue_id = connect_data->queue_id;
                data.user     = connect_data->data;
                data.ip       = data.user + strlen(data.user) + 1;
                data.host = data.ip + strlen(data.ip) + 1;
                callbacks.samba_connect(context, &data);
            }
            break;
        }
        case CHECK_FILE_RES:
        {
            const CheckFileResultData* file_data =
                (const CheckFileResultData*)request;
            DEBUG_MSG("check_file_result queue_id=%d status=%d", file_data->queue_id,
                      file_data->result);
            if (!callbacks.check_file_result)
            {
                DEBUG_MSG("no check_file_result callback found");
                break;
            }
            {
                CheckFileResultInfoData data;
                data.queue_id = file_data->queue_id;
                data.result = (enum FileAccessType)file_data->result;
                callbacks.check_file_result(context, &data);
            }
            break;
        }
        case MONITOR_SHUTDOWN:
            if (!callbacks.shutdown)
            {
                DEBUG_MSG("no shutdown callback found");
                break;
            }
            callbacks.shutdown(context);
            break;
        case CHECK_SIGN:
        {
            const CheckFileData* file_data = (const CheckFileData*)request;
            DEBUG_MSG("check_sign file=%s uid=%d gid=%d", file_data->name,
                      file_data->uid, file_data->gid);
            if (!callbacks.check_sign)
            {
                DEBUG_MSG("no check_sign callback function found");
                break;
            }
            {
                CheckFileInfoData data;
                data.queue_id = file_data->queue_id;
                data.filename = file_data->name;
                data.user     = file_data->uid;
                data.group = file_data->gid;
                callbacks.check_sign(context, &data);
            }
            break;
        }
        default:
            DEBUG_MSG("unknown request =%d", request->header.request);
            break;
    }
}

#endif // KERNEL__OAS__SMALL__PROTOCOL_HANDLER_H

Cancel