#ifndef __DP_BACKEND_H__

#define __DP_BACKEND_H__

#include "providers/data_provider.h"

#include "providers/fail_over.h"

#include "providers/be_refresh.h"

#include "providers/data_provider/dp.h"

#include "util/child_common.h"

#include "db/sysdb.h"

#define BE_SRV_IDENTIFIER "_srv_"

struct be_ctx;

typedef void (*be_callback_t)(void *);

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_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 be_refresh_ctx *refresh_ctx;

size_t check_online_ref_count;

struct data_provider *provider;

};

struct be_acct_req {

int entry_type;

int attr_type;

int filter_type;

char *filter_value;

char *extra_value;

char *domain;

};

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);

#endif /* __DP_BACKEND_H___ */