#ifndef __DP_BACKEND_H__

#define __DP_BACKEND_H__

#include "providers/data_provider.h"

#include "providers/fail_over.h"

#include "providers/be_refresh.h"

#include "util/child_common.h"

#include "db/sysdb.h"

#define BE_SRV_IDENTIFIER "_srv_"

struct be_ctx;

struct bet_ops;

struct be_req;

typedef int (*bet_init_fn_t)(TALLOC_CTX *, struct bet_ops **, void **);

typedef void (*be_shutdown_fn)(void *);

typedef void (*be_req_fn_t)(struct be_req *);

typedef void (*be_async_callback_t)(struct be_req *, int, int, const char *);

typedef void (*be_callback_t)(void *);

enum bet_type {

BET_NULL = 0,

BET_ID,

BET_AUTH,

BET_ACCESS,

BET_CHPASS,

BET_SUDO,

BET_AUTOFS,

BET_SELINUX,

BET_HOSTID,

BET_SUBDOMAINS,

BET_MAX

};

struct bet_data {

enum bet_type bet_type;

const char *option_name;

const char *mod_init_fn_name_fmt;

};

struct loaded_be {

char *be_name;

void *handle;

};

struct bet_info {

enum bet_type bet_type;

struct bet_ops *bet_ops;

void *pvt_bet_data;

char *mod_name;

struct bet_queue_item *req_queue;

};

struct be_offline_status {

time_t went_offline;

bool offline;

};

struct be_resolv_ctx {

struct resolv_ctx *resolv;

struct dp_option *opts;

enum restrict_family family_order;

};

struct be_client {

struct be_ctx *bectx;

struct sbus_connection *conn;

struct tevent_timer *timeout;

bool initialized;

};

struct be_failover_ctx;

struct be_cb;

struct be_ctx {

struct tevent_context *ev;

struct confdb_ctx *cdb;

struct sss_domain_info *domain;

const char *identity;

const char *conf_path;

uid_t uid;

gid_t gid;

struct be_failover_ctx *be_fo;

struct be_resolv_ctx *be_res;

/* Functions to be invoked when the

struct be_cb *online_cb_list;

bool run_online_cb;

struct be_cb *offline_cb_list;

struct be_cb *reconnect_cb_list;

/* In contrast to online_cb_list which are only run if the backend is

struct be_cb *unconditional_online_cb_list;

struct be_offline_status offstat;

/* Periodicly check if we can go online. */

struct be_ptask *check_if_online_ptask;

struct sbus_connection *mon_conn;

struct sbus_connection *sbus_srv;

struct be_client *nss_cli;

struct be_client *pam_cli;

struct be_client *sudo_cli;

struct be_client *autofs_cli;

struct be_client *ssh_cli;

struct be_client *pac_cli;

struct be_client *ifp_cli;

struct loaded_be loaded_be[BET_MAX];

struct bet_info bet_info[BET_MAX];

struct be_refresh_ctx *refresh_ctx;

size_t check_online_ref_count;

/* List of ongoing requests */

struct be_req *active_requests;

};

struct bet_ops {

be_req_fn_t check_online;

be_req_fn_t handler;

be_req_fn_t finalize;

};

struct be_acct_req {

int entry_type;

int attr_type;

int filter_type;

char *filter_value;

char *extra_value;

char *domain;

};

struct be_sudo_req {

uint32_t type;

char **rules;

};

struct be_autofs_req {

char *mapname;

bool invalidate;

};

struct be_subdom_req {

bool force;

char *domain_hint;

};

struct be_host_req {

uint32_t type;

int filter_type;

char *name;

char *alias;

};

bool be_is_offline(struct be_ctx *ctx);

void be_mark_offline(struct be_ctx *ctx);

void be_mark_dom_offline(struct sss_domain_info *dom, struct be_ctx *ctx);

int be_add_reconnect_cb(TALLOC_CTX *mem_ctx,

struct be_ctx *ctx,

be_callback_t cb,

void *pvt,

struct be_cb **reconnect_cb);

void be_run_reconnect_cb(struct be_ctx *be);

int be_add_online_cb(TALLOC_CTX *mem_ctx,

struct be_ctx *ctx,

be_callback_t cb,

void *pvt,

struct be_cb **online_cb);

void be_run_online_cb(struct be_ctx *be);

int be_add_unconditional_online_cb(TALLOC_CTX *mem_ctx, struct be_ctx *ctx,

be_callback_t cb, void *pvt,

struct be_cb **unconditional_online_cb);

void be_run_unconditional_online_cb(struct be_ctx *be);

int be_add_offline_cb(TALLOC_CTX *mem_ctx,

struct be_ctx *ctx,

be_callback_t cb,

void *pvt,

struct be_cb **online_cb);

void be_run_offline_cb(struct be_ctx *be);

enum be_fo_protocol {

BE_FO_PROTO_TCP,

BE_FO_PROTO_UDP,

BE_FO_PROTO_SENTINEL

};

typedef void (be_svc_callback_fn_t)(void *, struct fo_server *);

int be_init_failover(struct be_ctx *ctx);

int be_fo_is_srv_identifier(const char *server);

int be_fo_add_service(struct be_ctx *ctx, const char *service_name,

datacmp_fn user_data_cmp);

int be_fo_service_add_callback(TALLOC_CTX *memctx,

struct be_ctx *ctx, const char *service_name,

be_svc_callback_fn_t *fn, void *private_data);

int be_fo_get_server_count(struct be_ctx *ctx, const char *service_name);

void be_fo_set_srv_lookup_plugin(struct be_ctx *ctx,

fo_srv_lookup_plugin_send_t send_fn,

fo_srv_lookup_plugin_recv_t recv_fn,

void *pvt,

const char *plugin_name);

errno_t be_fo_set_dns_srv_lookup_plugin(struct be_ctx *be_ctx,

const char *hostname);

int be_fo_add_srv_server(struct be_ctx *ctx,

const char *service_name,

const char *query_service,

const char *default_discovery_domain,

enum be_fo_protocol proto,

bool proto_fallback, void *user_data);

int be_fo_add_server(struct be_ctx *ctx, const char *service_name,

const char *server, int port, void *user_data,

bool primary);

struct tevent_req *be_resolve_server_send(TALLOC_CTX *memctx,

struct tevent_context *ev,

struct be_ctx *ctx,

const char *service_name,

bool first_try);

int be_resolve_server_recv(struct tevent_req *req,

TALLOC_CTX *ref_ctx,

struct fo_server **srv);

#define be_fo_set_port_status(ctx, service_name, server, status) \

_be_fo_set_port_status(ctx, service_name, server, status, \

__LINE__, __FILE__, __FUNCTION__)

void _be_fo_set_port_status(struct be_ctx *ctx,

const char *service_name,

struct fo_server *server,

enum port_status status,

int line,

const char *file,

const char *function);

void be_fo_try_next_server(struct be_ctx *ctx, const char *service_name);

int be_fo_run_callbacks_at_next_request(struct be_ctx *ctx,

const char *service_name);

void reset_fo(struct be_ctx *be_ctx);

void be_fo_reset_svc(struct be_ctx *be_ctx, const char *svc_name);

const char *be_fo_get_active_server_name(struct be_ctx *ctx,

const char *service_name);

errno_t be_res_init(struct be_ctx *ctx);

struct be_req *be_req_create(TALLOC_CTX *mem_ctx,

struct be_client *becli,

struct be_ctx *be_ctx,

const char *name,

be_async_callback_t fn,

void *pvt_fn_data);

struct be_ctx *be_req_get_be_ctx(struct be_req *be_req);

void *be_req_get_data(struct be_req *be_req);

void be_req_terminate(struct be_req *be_req,

int dp_err_type, int errnum, const char *errstr);

void be_terminate_domain_requests(struct be_ctx *be_ctx,

const char *domain);

struct tevent_req *

be_get_account_info_send(TALLOC_CTX *mem_ctx,

struct tevent_context *ev,

struct be_client *becli,

struct be_ctx *be_ctx,

struct be_acct_req *ar);

errno_t be_get_account_info_recv(struct tevent_req *req,

TALLOC_CTX *mem_ctx,

int *_err_maj,

int *_err_min,

const char **_err_msg);

#endif /* __DP_BACKEND_H___ */