Admin Control Panel v2.0

✎ Editing: protocol_packer.h ← Back

#ifndef KERNEL__OAS__SMALL__PROTOCOL_PACKER_H
#define KERNEL__OAS__SMALL__PROTOCOL_PACKER_H

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

typedef void* (*protocol_mem_allocator)(size_t);
typedef void (*protocol_mem_dealloc)(void*);

typedef struct
{
    protocol_mem_allocator alloc;
    protocol_mem_dealloc free;
} ProtocolAllocator;

extern ProtocolAllocator protocol_alloc;

static inline void SetProtocolAllocator(ProtocolAllocator* m)
{
    protocol_alloc.alloc = m->alloc;
    protocol_alloc.free  = m->free;
}

static inline void PackProtocolHeader(ProtocolHeader* header, u_int32_t data_size,
                                      u_int8_t request)
{
    memset(header, 0, sizeof(*header));
    header->request   = request;
    header->version   = FS_PROTOCOL_VERSION;
    header->data_size = data_size;
}
static inline void PackProtocolHeader1(ProtocolHeader* header, u_int32_t data_size,
                                       u_int8_t request)
{
    memset(header, 0, sizeof(*header));
    header->request   = request;
    header->version   = 1;
    header->data_size = data_size;
}
static inline void PackProtocolHeader2(ProtocolHeader* header, u_int8_t ver,
                                       u_int32_t data_size, u_int8_t request)
{
    memset(header, 0, sizeof(*header));
    header->request   = request;
    header->version   = ver;
    header->data_size = data_size;
}

static inline CheckFileData* PackCheckFileReq(uid_t euid, gid_t egid, pid_t pid,
                                              u_short queue_id, const char* filename,
                                              enum FileOpType file_type, int flags,
                                              dev_t dev, ino_t ino)
{
    CheckFileData* file;
    size_t len = strlen(filename);
    file = (CheckFileData*)protocol_alloc.alloc(sizeof(*file) + len + 2);
    if (!file)
        return NULL;
    PackProtocolHeader1(
        &file->header, sizeof(*file) - sizeof(ProtocolHeader) + len + 1, CHECK_FILE);
    file->pid       = pid;
    file->uid       = euid;
    file->gid       = egid;
    file->flags     = flags;
    file->queue_id  = queue_id;
    file->file_type = file_type;
    file->dev       = dev;
    file->ino = ino;
    memcpy((char*)file->name, filename, len + 1);
    return file;
}
static inline CheckFileData2* PackCheckFileReq2(
    u_int8_t ver, uid_t euid, gid_t egid, pid_t pid, u_short queue_id,
    const char* filename, enum FileOpType file_op_type, int flags, dev_t dev,
    ino_t ino, time_t mtime, int64_t size, uid_t owner_uid, u_int32_t file_mode,
    int64_t f_type, const char* fstypename)
{
    CheckFileData2* file;
    size_t fnamelen = strlen(filename), fstypelen = 0, strsize;
    if (fstypename)
    {
        fstypelen = strlen(fstypename);
        strsize   = fstypelen + 1 + fnamelen + 1;
    }
    else
        strsize = fnamelen + 1;
    file = (CheckFileData2*)protocol_alloc.alloc(sizeof(*file) + strsize);
    if (!file)
        return NULL;
    PackProtocolHeader2(&file->header, ver,
                        sizeof(*file) - sizeof(ProtocolHeader) + strsize,
                        CHECK_FILE);
    file->pid          = pid;
    file->uid          = euid;
    file->gid          = egid;
    file->flags        = flags;
    file->queue_id     = queue_id;
    file->file_op_type = file_op_type;
    file->dev          = dev;
    file->ino          = ino;
    file->mtime        = mtime;
    file->size         = size;
    file->owner_uid    = owner_uid;
    file->file_mode    = file_mode;
    file->f_type       = f_type;
    file->fstypelen = fstypelen;
    if (fstypename)
    {
        memcpy((char*)file->strings, fstypename, fstypelen + 1);
        memcpy((char*)file->strings + fstypelen + 1, filename, fnamelen + 1);
    }
    else
        memcpy((char*)file->strings, filename, fnamelen + 1);

return file;
}
static inline const char* GetCheckFileReq2FsTypeName(const CheckFileData2* data)
{
    if (data->fstypelen)
        return data->strings;
    return NULL;
}
static inline const char* GetCheckFileReq2FileName(const CheckFileData2* data)
{
    if (data->fstypelen)
        return data->strings + data->fstypelen + 1;
    return data->strings;
}

// FIXME - remove copy-paste
static inline CheckFileData* PackCheckFileReqHost(
    uid_t uid, gid_t gid, pid_t pid, u_short queue_id, const char* filename,
    enum FileOpType file_type, int flags, dev_t dev, ino_t ino, const char* host)
{
    CheckFileData* file;
    size_t len        = strlen(filename);
    size_t hostlen    = strlen(host);
    size_t alloc_size = sizeof(*file) + len + 2 + hostlen + 1;
    file = (CheckFileData*)protocol_alloc.alloc(alloc_size);
    PackProtocolHeader1(&file->header, alloc_size - sizeof(ProtocolHeader) - 1,
                        CHECK_FILE);
    file->pid       = pid;
    file->uid       = uid;
    file->gid       = gid;
    file->flags     = flags;
    file->queue_id  = queue_id;
    file->file_type = file_type;
    file->dev       = dev;
    file->ino = ino;
    memcpy((char*)file->name, filename, len + 1);
    memcpy((char*)file->name + len + 1, host, hostlen + 1);
    return file;
}

static inline NotifyFileData* PackNotifyFileReq(const char* filename,
                                                enum FileNotifyType file_type,
                                                dev_t dev, ino_t ino)
{
    NotifyFileData* file;
    size_t len = strlen(filename);
    file = (NotifyFileData*)protocol_alloc.alloc(sizeof(*file) + len + 2);
    if (!file)
        return NULL;
    PackProtocolHeader1(&file->header,
                        sizeof(*file) - sizeof(ProtocolHeader) + len + 1,
                        NOTIFY_FILE);
    file->file_type = file_type;
    file->dev       = dev;
    file->ino = ino;
    memcpy((char*)file->name, filename, len + 1);
    return file;
}
static inline NotifyFileData* PackNotifyFileReq2(u_int8_t ver, const char* filename,
                                                 enum FileNotifyType file_type,
                                                 dev_t dev, ino_t ino)
{
    NotifyFileData* file;
    size_t len = 0;
    if (filename)
        len = strlen(filename);
    file = (NotifyFileData*)protocol_alloc.alloc(sizeof(*file) + len + 2);
    if (!file)
        return NULL;
    PackProtocolHeader2(&file->header, ver,
                        sizeof(*file) - sizeof(ProtocolHeader) + len + 1,
                        NOTIFY_FILE);
    file->file_type = file_type;
    file->dev       = dev;
    file->ino = ino;
    if (filename)
        memcpy((char*)file->name, filename, len + 1);
    else
        file->name[0] = 0;
    return file;
}

static inline CheckFileResultData* PackCheckFileResultReq(u_int16_t queue_id,
                                                          enum FileAccessType status)
{
    CheckFileResultData* file;
    file = (CheckFileResultData*)protocol_alloc.alloc(sizeof(*file));
    PackProtocolHeader(&file->header, sizeof(*file) - sizeof(file->header),
                       CHECK_FILE_RES);
    file->queue_id = queue_id;
    file->result   = status;
    return file;
}

static inline SambaConnectData* PackSambaConnectReq(u_int16_t queue_id,
                                                    const char* user, const char* ip,
                                                    const char* host)
{
    SambaConnectData* connect_data;
    size_t user_len = strlen(user);
    size_t ip_len   = strlen(ip);
    size_t host_len = strlen(host);
    connect_data = (SambaConnectData*)protocol_alloc.alloc(
        sizeof(*connect_data) + user_len + ip_len + host_len + 10);

PackProtocolHeader(&connect_data->header,
                       sizeof(*connect_data) - sizeof(connect_data->header) +
                           user_len + ip_len + host_len + 3,
                       SAMBA_CONNECT);
    connect_data->queue_id = queue_id;
    memcpy(connect_data->data, user, user_len + 1);
    memcpy(connect_data->data + user_len + 1, ip, ip_len + 1);
    memcpy(connect_data->data + user_len + ip_len + 2, host, host_len + 1);
    return connect_data;
}

static inline CheckFileData* PackCheckSignReq(uid_t uid, gid_t gid,
                                              u_int16_t queue_id,
                                              const char* filename)
{
    CheckFileData* file;
    size_t len = strlen(filename);
    file = (CheckFileData*)protocol_alloc.alloc(sizeof(*file) + len + 2);
    PackProtocolHeader1(
        &file->header, sizeof(*file) - sizeof(ProtocolHeader) + len + 1, CHECK_SIGN);
    file->uid      = uid;
    file->gid      = gid;
    file->queue_id = queue_id;
    memcpy((char*)file->name, filename, len + 1);
    return file;
}
static inline CheckFileData* PackCheckSignReq2(u_int8_t ver, uid_t uid, gid_t gid,
                                               u_int16_t queue_id,
                                               const char* filename)
{
    CheckFileData* file;
    size_t len = strlen(filename);
    file = (CheckFileData*)protocol_alloc.alloc(sizeof(*file) + len + 2);
    PackProtocolHeader2(&file->header, ver,
                        sizeof(*file) - sizeof(ProtocolHeader) + len + 1,
                        CHECK_SIGN);
    file->uid      = uid;
    file->gid      = gid;
    file->queue_id = queue_id;
    memcpy((char*)file->name, filename, len + 1);
    return file;
}

static inline ProtocolData* PackShutdownReq(void)
{
    ProtocolData* data;
    data = (ProtocolData*)protocol_alloc.alloc(sizeof(data));
    PackProtocolHeader(&data->header, 0, MONITOR_SHUTDOWN);
    return data;
}

static inline void FillPackedBuffer(ProtocolData* packet, PackedBuffer* buf)
{
    buf->data   = (char*)packet;
    buf->length = packet->header.data_size + sizeof(packet->header);
}

#endif // KERNEL__OAS__SMALL__PROTOCOL_PACKER_H

Cancel