/usr/src/file_protector-1.1-1507/transport/ Current File: //usr/src/file_protector-1.1-1507/transport/message.h
/**
@file
@brief    kernel/userspace transport messages
@details  Copyright (c) 2017-2020 Acronis International GmbH
@author   Mikhail Krivtsov (mikhail.krivtsov@acronis.com)
@since    $Id: $
*/

#pragma once

#include "thread_safe_path.h"
#include "transport.h"
#include "transport_protocol.h"

#include <linux/atomic.h>
#include <linux/list.h>
#include <linux/types.h>	// bool, size_t, [u]int(8|16|32|64)_t
#include <linux/wait.h>

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// 'msg_img_t' accessors

#define IMG_ID(msg_img)		*(&(msg_img)->id)
#define IMG_REPLY(msg_img)	*(&(msg_img)->reply)
#define IMG_TYPE(msg_img)	*(&(msg_img)->type)
#define IMG_PAYLOAD(msg_img)	(void *) (msg_img)->payload

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// To reduce memory overhead 'msg_img_t' is embedded into 'msg_t'
typedef struct msg_s msg_t;
struct msg_s {
	atomic_t ref_cnt;
	atomic_t reply_wait_count;	// number of expected replies
	wait_queue_head_t wait_queue;	// to wait for 'reply'
	size_t img_size;
	bool interrupted;
	bool block;
	thread_safe_path_t path;
	thread_safe_path_t path2;
	uint8_t img[0];			// 'msg_img_t'
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// 'msg_t' accessors

#define MSG_IMG(msg)	(msg_img_t *) (msg)->img
#define MSG_SIZE(msg)	(msg)->img_size
#define MSG_ID(msg)	IMG_ID(MSG_IMG(msg))
#define MSG_REPLY(msg)	IMG_REPLY(MSG_IMG(msg))
#define MSG_TYPE(msg)	IMG_TYPE(MSG_IMG(msg))

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

typedef struct msg_sized_s msg_sized_t;
struct msg_sized_s {
	size_t img_size;
	uint8_t img[0];			// 'msg_img_t'
};

// This should fit most of the messages other than the path ones
#define MSG_MAX_SMALL_PAYLOAD_SIZE (8 + sizeof(msg_img_t))

// Holds the varsized message either on stack or on heap based on the size.
typedef struct msg_varsized_s msg_varsized_t;
struct msg_varsized_s {
	bool on_heap;
	union {
		struct {
			msg_sized_t header; // header.img == img
			uint8_t img[MSG_MAX_SMALL_PAYLOAD_SIZE];
		} stack;
		struct {
			msg_sized_t* ptr;
		} heap;
	} data;
};

const char* msg_type_to_string(msg_type_t type);
const char* action_type_to_string(action_type_t type);
const char* return_type_to_string(return_type_t type);

msg_sized_t *msg_sized_new(size_t msg_img_size);
#define msg_sized_free mem_free

msg_t *msg_new(size_t msg_img_size);
msg_t *msg_new_nowait(size_t msg_img_size);
msg_t *msg_new_type(size_t msg_img_size, msg_type_t type);
msg_t *msg_new_type_nowait(size_t msg_img_size, msg_type_t type);
msg_t *msg_ref(msg_t *msg);
void msg_unref(msg_t *msg);
msg_t *msg_reply_wait_count_inc(msg_t *msg);
void msg_reply_wait_count_dec(msg_t *msg);

msg_t *hello_msg_new(void);
msg_t *pong_msg_new(msg_sized_t *ping_msg);
int pid_info_return_msg_new(msg_varsized_t *msg, pid_t nr);
int fs_root_return_msg_new(msg_varsized_t *msg, pid_t nr);
int open_file_return_msg_new(msg_varsized_t *msg, int fd);
int version_info_return_msg_new(msg_varsized_t *msg);
int data_queue_offsets_return_msg_new(msg_varsized_t *msg, uint32_t size);

#define MSG_VARSIZED_GET_SIZED(msg) ((msg)->on_heap ? (msg)->data.heap.ptr : &(msg)->data.stack.header)

msg_sized_t* msg_varsized_init(msg_varsized_t *msg, size_t msg_img_size);
void msg_varsized_uninit(msg_varsized_t *msg);

// checks pid's 'executable file' and sends 'exec' message in case of change
// FIXME: move out of 'message.*'
void detect_exec(void);

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// sending messages via default 'transport'
void send_msg_async(msg_t *msg);
void send_msg_async_unref(msg_t *msg);
bool send_msg_sync_nowait(msg_t *msg);
void send_msg_sync(msg_t *msg);
void send_msg_sync_unref(msg_t *msg);
void send_reply(msg_t *query, msg_t *reply);