struct.h

SQLiteDBMS是SQLite数据库的管理服务器软件

/* DB auth */
struct db_user_t {
	char				id[128];
	char				pass[128];
	short				super;
	char				*dbname;
};

struct _auth_data_t {
	char				**table;
	int				rows;
	int				cols;
};

struct auth_t {
	struct _auth_data_t		user;
	struct _auth_data_t		db;
	struct _auth_data_t		object;
};

struct grant_t {
	char				*rule;
	char				*dbname;
	char				*object;
	char				*user;
};

/* socket */
typedef union {
	struct sockaddr			sa;
	struct sockaddr_in		sa_in;
} sock_t;

/* config */
struct config_node_t {
	char				*buf;
	char				*field;
	int				field_len;
	char				*value;
	int				value_len;
};

struct config_t {
	char				*filepath;
	int				server_port;
	int				max_session;

	int				poll_timer;
	short				access_control;

	char				*server_user;

	int				buf_size_header;
	int				buf_size_recv;
	int				buf_size_send;

	char				*db_path;

	short				http_use;
	char				*http_root;
	int				http_timeout;
	int				http_keeptime;

	short				ssl;
	char				*ssl_cert;
	char				*ssl_key;
	
	short				cache_use;
	int				cache_slot;
	int				cache_size;

	short				webdav;

	char				*log_path;
	char				*log_filerule;
	short				log_sql;

	char				*so_path;

	short				replication_master;
	int				replication_master_port;

	short				replication_slave;
	char				*replication_slave_host;
	int				replication_slave_port;
	char				*replication_slave_user;
	char				*replication_slave_pass;

	char				*func_after_fork;		//int (void)
	char				*func_after_accept;		//int (struct thread_t)
	char				*func_after_thread;		//int (struct thread_t)
	char				*func_after_read;		//int (struct thread_t)
	char				*func_on_post;			//int (struct thread_t)
	char				*func_on_get;			//int (struct thread_t)
	char				*func_on_webdav;		//int (struct thread_t)
	char				*func_after_proc;		//int (struct thread_t)
	char				*func_on_thread_exit;		//int (struct thread_t)
	char				*func_on_finalize;		//int (void)

	struct config_node_t		*nodes;
};

/* request */
struct request_header_t {
	int				method;
	char				*db_name;
	char				*extend;
	int				db_name_len;

	char				*query;

	char				*cookie;
	char				*auth;
	char				*modified;
	char				*connection;
	int				content_length;
};

struct request_t {
	char				*buf;
	int				buf_size;
	int				read_len;

	struct request_header_t		header;
	int				header_len;

	char				*data;
	int				data_len;
};

/* response */
struct response_t {
	char				*header_buf;

	char				*buf;
	int				buf_size;
	int				offset;
	int				start;

	short				header_sent;
	short				set_cookie;
	short				chunked;

	short				status;
	char				*status_msg;
	char				*errmsg;

	struct stat			stat;
	int				file;
	off_t				file_offset;
};

/* prepared statement */
union pstmt_param_data_t {
	int				value_integer;
	double				value_double;
	char				*value_text;
	char				*value_blob;
};

struct pstmt_param_t {
	int				type;
	int				idx;

	union pstmt_param_data_t	data;
	int				data_len;
};

struct pstmt_t {
	unsigned long			id;

	sqlite3_stmt			*stmt;

	char				*sql;

	struct pstmt_param_t		*params;
	int				params_cnt;

	int				param_cnt;

	short				nolog;
};

/* db lock control */
struct db_lock_t {
	char				db_name[LIMIT_MAX_DBNAME];
	pthread_mutex_t			lock;
};

/* db */
struct db_t {
	sqlite3				*db;					//sqlite3 db pointer
	char				db_name[LIMIT_MAX_DBNAME];		//sqlite3 db name, db filename exclude ".db"
	char				db_filename[LIMIT_MAX_DBFILENAME];	//sqlite3 db full file name
	short				opened;
	struct timeval			open_time;
	char				*errmsg;				//sqlite3 lib error msg

	struct db_lock_t		*lock;

	sqlite3_stmt			*stmt;
	const char			**sql_tail;

	char				**table;
	int				table_res;
	int				table_nrow;
	int				table_ncol;

	short				transaction;
	short				auto_commit;
	
	short				updated;

	short				auth;

	struct pstmt_t			*pstmt;
	int				pstmt_run;
	int				pstmt_cnt;

	char				***pstmt_tree;
	int				pstmt_tree_size;
	int				pstmt_tree_len;

	char				*pstmt_buf;
	int				pstmt_buf_size;
	int				pstmt_buf_len;

	int				work_id;
	int				work_id_curr;
};

/* replication master log queue */
struct repl_log_queue_t {
	char				*sql;
	struct pstmt_param_t		*params;
	int				params_cnt;
};

/* thread */
struct thread_t {
	/*
	pthread_t			thread;
	pthread_mutex_t			thread_mutex;
	pthread_cond_t			thread_cond;
	*/
	short				init;
	short				status;
	time_t				time_init;
	time_t				time_last;

	int				client_fd;
	char				client_ip[20];

#ifdef	ENABLE_SSL
	SSL				*ssl;
#endif

	struct request_t		request;
	struct response_t		response;

	struct db_user_t		user;
	char				session_key[32];

	short				keep_alive;

	struct db_t			db;

	/** thread stat */
	long long			tid;
	struct thread_t			*next;

	/** bench */
	struct timeval			bench_start;
	
	void				*data;

	struct repl_log_queue_t		*repl_log_queue;
	int				repl_log_queue_len;
};

/* cache */
struct cache_t {
	struct timeval			last;
	int				hit;
	
	long long int			rowid;
	int				rows;
	
	char				db_name[LIMIT_MAX_DBNAME];
	char				*sql;
	size_t				sql_buf_size;
	size_t				sql_len;
	char				*buf;
	int				buf_len;
};

/* stat */
struct stat_t {
	struct thread_t			*first;
	pthread_mutex_t			lock;
	int				count;
};

/* desc */
struct desc_t {
	char const			*type;
	char const			*seq;
	int				notnull;
	int				pkey;
	int				autoincrement;
};

/* func pointer */
struct func_t {
	void				*dl_handle;

	int				(*after_fork) (void);
	int				(*after_accept) (struct thread_t *);
	int				(*after_thread) (struct thread_t *);
	int				(*after_read) (struct thread_t *);
	int				(*on_post) (struct thread_t *);
	int				(*on_get) (struct thread_t *);
	int				(*on_webdav) (struct thread_t *);
	int				(*after_proc) (struct thread_t *);
	int				(*on_thread_exit) (struct thread_t *);
	int				(*on_finalize) (void);
};

/* log entry */
struct log_entry_t {
	short				type;

	char				*dbname;
	char				*msg;

	short				allocated;

	struct log_entry_t		*next;
};

/* log file */
struct log_file_t {
	short				type;
	int				date;

	char				*dbname;

	char				*filename;
	FILE				*file;

	struct log_file_t		*prev;
	struct log_file_t		*next;
};

/* replication master bin log */
struct repl_master_file_t {
	int				id;
	char				filename[1024];
	FILE				*file;
	size_t				offset;

	short				changed;

	struct repl_master_file_t	*prev;
	struct repl_master_file_t	*next;
};

struct repl_master_queue_t {
	char				*dbname;
	struct repl_log_queue_t		*repl_log_queue;
	int				repl_log_queue_len;
};

struct repl_master_t {
	struct repl_master_file_t	*files;
	struct repl_master_file_t	*files_last;
	int				files_cnt;

	pthread_t			thread;
	pthread_mutex_t			lock;

	pthread_cond_t			cond;
	pthread_mutex_t			cond_lock;

	pthread_cond_t			deliver_cond;
	pthread_mutex_t			deliver_cond_lock;

	int				sending_id;
	size_t				sending_offset;

	struct repl_master_queue_t	*queue;
	int				queue_cnt;
};

/* replication slave */
struct repl_slave_db_t {
	uint32_t			dbname_len;
	char				*dbname;

	struct repl_log_queue_t		*queue;
	int				queue_len;
};