/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 	- Redistributions of source code must retain the above copyright
 *	  notice, this list of conditions and the following disclaimer.
 *
 * 	- Redistributions in binary form must reproduce the above copyright
 *	  notice, this list of conditions and the following disclaimer in
 *	  the documentation and/or other materials provided with the
 *	  distribution.
 *
 *	- Neither the name of The Storage Networking Industry Association (SNIA)
 *	  nor the names of its contributors may be used to endorse or promote
 *	  products derived from this software without specific prior written
 *	  permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
/* Copyright (c) 2007, The Storage Networking Industry Association. */
/* Copyright (c) 1996, 1997 PDC, Network Appliance. All Rights Reserved */
/* Copyright 2014 Nexenta Systems, Inc.  All rights reserved. */
#ifndef	_LIBNDMP_H
#define	_LIBNDMP_H

#include <rpc/types.h>
#include <libscf.h>
#include <libnvpair.h>

#ifdef	__cplusplus
extern "C" {
#endif

/* NDMP supported versions */
#define	NDMP_V2		2
#define	NDMP_V3		3
#define	NDMP_V4		4

/* Device type */
#define	NDMP_SINQ_SEQ_ACCESS_DEVICE	0x01
#define	NDMP_SINQ_TAPE_ROBOT		0x08

extern int ndmp_errno;

/* NDMP plugin module API */
#define	NDMP_PLUGIN_VERSION	1

typedef struct ndmp_context {
	char *nc_plname;
	uint_t nc_plversion;
	void *nc_pldata;	/* data private to the plugin */
	void *nc_cmds;
	void *nc_params;
	void *nc_ddata;		/* data private to the daemon */
} ndmp_context_t;

typedef struct ndmp_plugin {
	const char *np_plid;	/* plugin identifier */
	uint_t np_plversion;	/* plugin version */
	void *np_pldata;	/* for private use by the plugin */

	/* Plugin entry points */
	int (*np_pre_backup)(struct ndmp_plugin *, ndmp_context_t *,
		const char *);
	int (*np_post_backup)(struct ndmp_plugin *, ndmp_context_t *,
		int);
	int (*np_pre_restore)(struct ndmp_plugin *, ndmp_context_t *,
		const char *, const char *);
	int (*np_post_restore)(struct ndmp_plugin *, ndmp_context_t *,
		int);
} ndmp_plugin_t;

typedef enum ndmp_log_dma_type {
	NDMP_LOGD_NORMAL = 0,
	NDMP_LOGD_DEBUG = 1,
	NDMP_LOGD_ERROR = 2,
	NDMP_LOGD_WARNING = 3
} ndmp_log_dma_type_t;

typedef enum {
	NDMP_BUTYPE_TAR = 0,
	NDMP_BUTYPE_DUMP,
	NDMP_BUTYPE_ZFS
} ndmpd_backup_type_t;

extern ndmpd_backup_type_t ndmp_get_backup_type(ndmp_context_t *);

/* libndmp error codes */
#define	ENDMP_BASE	2000
enum {
	ENDMP_DOOR_SRV_TIMEOUT = ENDMP_BASE,
	ENDMP_INVALID_ARG,
	ENDMP_DOOR_SRV_OPERATION,
	ENDMP_DOOR_OPEN,
	ENDMP_MEM_ALLOC,
	ENDMP_DOOR_ENCODE_START,
	ENDMP_DOOR_ENCODE_FINISH,
	ENDMP_DOOR_DECODE_FINISH,
	ENDMP_SMF_PERM,
	ENDMP_SMF_INTERNAL,
	ENDMP_SMF_PROP,
	ENDMP_SMF_PROP_GRP
};

/* Tape device open mode */
typedef enum ndmp_tp_open_mode {
	NDMP_TP_READ_MODE,
	NDMP_TP_WRITE_MODE,
	NDMP_TP_RAW_MODE,
	NDMP_TP_RAW1_MODE = 0x7fffffff,
	NDMP_TP_RAW2_MODE = NDMP_TP_RAW_MODE
} ndmp_tp_open_mode_t;

/* Mover state */
typedef enum ndmp_mv_state {
	NDMP_MV_STATE_IDLE,
	NDMP_MV_STATE_LISTEN,
	NDMP_MV_STATE_ACTIVE,
	NDMP_MV_STATE_PAUSED,
	NDMP_MV_STATE_HALTED
} ndmp_mv_state_t;

/* Mover mode */
typedef enum ndmp_mv_mode {
	NDMP_MV_MODE_READ,
	NDMP_MV_MODE_WRITE,
	NDMP_MV_MODE_NOACTION
} ndmp_mv_mode_t;

/* Mover pause reson */
typedef enum ndmp_mv_pause_reason {
	NDMP_MV_PAUSE_NA,
	NDMP_MV_PAUSE_EOM,
	NDMP_MV_PAUSE_EOF,
	NDMP_MV_PAUSE_SEEK,
	NDMP_MV_PAUSE_MEDIA_ERROR,
	NDMP_MV_PAUSE_EOW
} ndmp_mv_pause_reason_t;

/* Mover halt reason */
typedef enum ndmp_mv_halt_reason {
	NDMP_MV_HALT_NA,
	NDMP_MV_HALT_CONNECT_CLOSED,
	NDMP_MV_HALT_ABORTED,
	NDMP_MV_HALT_INTERNAL_ERROR,
	NDMP_MV_HALT_CONNECT_ERROR,
	NDMP_MV_HALT_MEDIA_ERROR
} ndmp_mv_halt_reason_t;

/* Address type */
typedef enum ndmp_ad_type {
	NDMP_AD_LOCAL,
	NDMP_AD_TCP,
	NDMP_AD_FC,
	NDMP_AD_IPC
} ndmp_ad_type_t;

/* NDMP data operation */
typedef enum ndmp_dt_operation {
	NDMP_DT_OP_NOACTION,
	NDMP_DT_OP_BACKUP,
	NDMP_DT_OP_RECOVER,
	NDMP_DT_OP_RECOVER_FILEHIST
} ndmp_dt_operation_t;

/* NDMP data state */
typedef enum ndmp_dt_state {
	NDMP_DT_STATE_IDLE,
	NDMP_DT_STATE_ACTIVE,
	NDMP_DT_STATE_HALTED,
	NDMP_DT_STATE_LISTEN,
	NDMP_DT_STATE_CONNECTED
} ndmp_dt_state_t;

/* NDMP data halt reason */
typedef enum ndmp_dt_halt_reason {
	NDMP_DT_HALT_NA,
	NDMP_DT_HALT_SUCCESSFUL,
	NDMP_DT_HALT_ABORTED,
	NDMP_DT_HALT_INTERNAL_ERROR,
	NDMP_DT_HALT_CONNECT_ERROR
} ndmp_dt_halt_reason_t;

/* Device information structure */
typedef struct ndmp_devinfo {
	uint_t nd_dev_type;	/* SCSI device type */
	char *nd_name;		/* Device name */
	uint_t nd_lun;		/* Lun number */
	uint_t nd_sid;		/* Scsi id */
	char *nd_vendor;	/* Vendor name */
	char *nd_product;	/* Product name */
	char *nd_revision;	/* Revision */
	char *nd_serial;	/* Serial */
	char *nd_wwn;		/* World wide name */
} ndmp_devinfo_t;

/* Scsi device info sturcture */
typedef struct ndmp_scsi {
	int ns_scsi_open;		/* Scsi device open */
					/* -1 if not open */
	char *ns_adapter_name;		/* Scsi adapter name */
	int ns_valid_target_set;	/* Scsi valid target */
	/* scsi_id and lun are set only if valid_target_set is set */
	int ns_scsi_id;			/* Scsi id */
	int ns_lun;			/* Scsi lun */
} ndmp_scsi_t;

typedef struct ndmp_tape {
	int nt_fd;			/* Tape device file descriptor */
	/* The data below is set only if "fd" is not -1 */
	ulong_t nt_rec_count;		/* Number of records written */
	ndmp_tp_open_mode_t nt_mode;	/* Tape device open mode */
	char *nt_dev_name;		/* Device name */
	char *nt_adapter_name;		/* Adapter name */
	int nt_sid;			/* Scsi id	*/
	int nt_lun;			/* Lun number	*/
} ndmp_tape_t;

/* NDMP mover info structure */
typedef struct ndmp_mover {
	ndmp_mv_state_t nm_state;		/* Current state */
	ndmp_mv_mode_t nm_mode;			/* Current mode */
	ndmp_mv_pause_reason_t nm_pause_reason;	/* Current reason */
	ndmp_mv_halt_reason_t nm_halt_reason;	/* Current reason */
	ulong_t	nm_rec_size;			/* Tape I/O record size */
	ulong_t	nm_rec_num;			/* Current record num */
	u_longlong_t nm_mov_pos;		/* Current data stream pos */
	u_longlong_t nm_window_offset;		/* Valid data window begin */
	u_longlong_t nm_window_length;		/* Valid data window length */
	int nm_sock;				/* Data conn socket */

	/* Filled in V3 and V4 only */
	int nm_listen_sock;			/* Data conn listen socket */
	ndmp_ad_type_t nm_addr_type;		/* Current address type */
	char *nm_tcp_addr;			/* Only if addr_type is tcp */
} ndmp_mover_t;

typedef struct ndmp_dt_name {
	char *nn_name;
	char *nn_dest;
} ndmp_dt_name_t;

/* NDMP name/value pair structure */
typedef struct ndmp_dt_pval {
	char *np_name;
	char *np_value;
} ndmp_dt_pval_t;

typedef struct ndmp_dt_name_v3 {
	char *nn3_opath;
	char *nn3_dpath;
	u_longlong_t nn3_node;
	u_longlong_t nn3_fh_info;
} ndmp_dt_name_v3_t;

typedef struct ndmp_dt_v3 {
	int dv3_listen_sock;
	u_longlong_t dv3_bytes_processed;
	ndmp_dt_name_v3_t *dv3_nlist;		/* V3 recover file list */
} ndmp_dt_v3_t;

/* NDMP data structure */
typedef struct ndmp_data {
	ndmp_dt_operation_t nd_oper;		/* Current operation */
	ndmp_dt_state_t nd_state;		/* Current state */
	ndmp_dt_halt_reason_t nd_halt_reason;	/* Current reason */
	int nd_sock;				/* Listen and data socket */
	ndmp_ad_type_t nd_addr_type;		/* Current address type */
	char *nd_tcp_addr;			/* Only if addr_type is tcp */
	int nd_abort;				/* Abort operation flag */
						/* 0 = No, otherwise Yes */
	u_longlong_t nd_read_offset;		/* Data read seek offset */
	u_longlong_t nd_read_length;		/* Data read length */
	u_longlong_t nd_total_size;		/* Backup data size */
	ulong_t nd_env_len;			/* Environment length */
	ndmp_dt_pval_t *nd_env;			/* Environment from backup */
						/* or recover request */
	ulong_t nld_nlist_len;			/* Recover file list length */
	union {
		/* Filled in V2 */
		ndmp_dt_name_t *nld_nlist;	/* Recover file list */
		/* Filled in V3 */
		ndmp_dt_v3_t nld_dt_v3;		/* V3 data */
	} nd_nlist;
} ndmp_data_t;

/* NDMP session information  */
typedef struct ndmp_session_info {
	int nsi_sid;		/* Session id   */
	int nsi_pver;		/* NDMP protocol version */
	int nsi_auth;		/* Authorized ? 0="no", else "yes" */
	int nsi_eof;		/* Connection EOF flag */
				/* 0="no", else "yes" */
	char *nsi_cl_addr;	/* Client address */
	ndmp_scsi_t nsi_scsi;	/* Scsi device information */
	ndmp_tape_t nsi_tape;	/* Tape device information */
	ndmp_mover_t nsi_mover;	/* Mover information */
	ndmp_data_t nsi_data;	/* Data information */
} ndmp_session_info_t;

/* Stats data */
typedef struct ndmp_stat {
	int ns_trun;		/* Number of worker threads running */
	int ns_twait;		/* Number of blocked worker threads */
	int ns_nbk;		/* Number of backups operations running */
	int ns_nrs;		/* Number of restores operations running */
	int ns_rfile;		/* Number of files being read */
	int ns_wfile;		/* Number of files being written */
	uint64_t ns_rdisk;	/* Number of disk blocks being read */
	uint64_t ns_wdisk;	/* Number of disk blocks being written */
	uint64_t ns_rtape;	/* Number of tape blocks being read */
	uint64_t ns_wtape;	/* Number of tape blocks being written */
} ndmp_stat_t;

/* Common encode/decode functions used by door clients/servers.  */
typedef struct ndmp_door_ctx {
	char *ptr;
	char *start_ptr;
	char *end_ptr;
	int status;
} ndmp_door_ctx_t;

extern int ndmp_get_devinfo(ndmp_devinfo_t **, size_t *);
extern void ndmp_get_devinfo_free(ndmp_devinfo_t *, size_t);
extern int ndmp_get_dbglevel(void);
extern int ndmp_get_session_info(ndmp_session_info_t **, size_t *);
extern void ndmp_get_session_info_free(ndmp_session_info_t *, size_t);
extern int ndmp_get_stats(ndmp_stat_t *);
extern int ndmp_terminate_session(int);
extern int ndmp_set_dbglevel(int);
extern const char *ndmp_strerror(int);
extern int ndmp_door_status(void);
extern int ndmp_get_prop(const char *, char **);
extern int ndmp_set_prop(const char *, const char *);
extern int ndmp_service_refresh(void);
extern char *ndmp_base64_encode(const char *);
extern char *ndmp_base64_decode(const char *);
extern ndmp_door_ctx_t *ndmp_door_decode_start(char *, int);
extern int ndmp_door_decode_finish(ndmp_door_ctx_t *);
extern ndmp_door_ctx_t *ndmp_door_encode_start(char *, int);
extern int ndmp_door_encode_finish(ndmp_door_ctx_t *, unsigned int *);
extern int32_t ndmp_door_get_int32(ndmp_door_ctx_t *);
extern uint32_t ndmp_door_get_uint32(ndmp_door_ctx_t *);
extern char *ndmp_door_get_string(ndmp_door_ctx_t *);
extern void ndmp_door_put_int32(ndmp_door_ctx_t *, int32_t);
extern void ndmp_door_put_uint32(ndmp_door_ctx_t *, uint32_t);
extern void ndmp_door_put_string(ndmp_door_ctx_t *, char *);
extern void ndmp_door_free_string(char *);
extern int64_t ndmp_door_get_int64(ndmp_door_ctx_t *);
extern uint64_t ndmp_door_get_uint64(ndmp_door_ctx_t *);
extern void ndmp_door_put_uint64(ndmp_door_ctx_t *, uint64_t);
extern void ndmp_door_put_short(ndmp_door_ctx_t *, short);
extern short ndmp_door_get_short(ndmp_door_ctx_t *);
extern void ndmp_door_put_ushort(ndmp_door_ctx_t *, unsigned short);
extern unsigned short ndmp_door_get_ushort(ndmp_door_ctx_t *);
extern void ndmp_door_put_buf(ndmp_door_ctx_t *, unsigned char *, int);
extern int ndmp_door_get_buf(ndmp_door_ctx_t *, unsigned char *, int);

extern int ndmp_include_zfs(ndmp_context_t *, const char *);
extern int ndmp_iter_zfs(ndmp_context_t *, int (*)(nvlist_t *, void *), void *);
extern uint_t ndmp_context_get_version(ndmp_context_t *);
extern void ndmp_context_set_specific(ndmp_context_t *, void *);
extern void *ndmp_context_get_specific(ndmp_context_t *);
void ndmp_log_dma(ndmp_context_t *, ndmp_log_dma_type_t, const char *, ...);

#ifdef	__cplusplus
}
#endif

#endif /* _LIBNDMP_H */