sbase.h

这是基于C语言开发的分布式搜索源代码

#include <stdint.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/socket.h>

#ifndef HAVE_SBASE_H
#define HAVE_SBASE_H
#ifdef __cplusplus
extern "C" {
#endif
#ifndef SBASE_VERSION 
#define SBASE_VERSION 0.1.2
#endif
#ifndef TCP_T
#define TCP_T SOCK_STREAM
#endif
#ifndef UDP_T   
#define UDP_T SOCK_DGRAM 
#endif
#ifndef INET_SOCK_MIX      
#define INET_SOCK_MIX (SOCK_DGRAM | SOCK_STREAM)
#endif
#ifndef INET_DOMAIN_MIX
#define INET_DOMAIN_MIX ( PF_INET | PF_INET6 | PF_UNIX | PF_LOCAL)
#endif
#ifndef INET_FAMILY_MIX
#define INET_FAMILY_MIX INET_SOCK_MIX

#endif
#ifndef PACKET_T
#define PACKET_T_A	0x02 /* struct data with header following data */
#define PACKET_T_B	0x04 /* certain length data */
#define PACKET_T_C	0x08 /* data split with a delimiter */
#define PACKET_T_DEFAULT PACKET_T_C /* default packet type */
#define PACKET_T_NULL	0x01  /* costumize packet type */
#define PACKET_T	(PACKET_T_A | PACKET_T_B | PACKET_T_C | PACKET_T_NULL)
#endif
/* SERVER TYPE */
#define SERVER_NORMAL 	0x01
#define SERVER_FILE 	0x02
#define SERVER_CHUNK 	0x04

/* BUFFER */
#ifndef _TYPEDEF_BUFFER
#define _TYPEDEF_BUFFER
typedef struct _BUFFER
{
	void *data;
	void *end;
	size_t size;
	pthread_mutex_t mutex;

	void 	*(*calloc)(struct _BUFFER *, size_t);
	void 	*(*malloc)(struct _BUFFER *, size_t);
	void 	*(*recalloc)(struct _BUFFER *, size_t);
	void 	*(*remalloc)(struct _BUFFER *, size_t);
	int 	(*push)(struct _BUFFER *, void *, size_t);
	int 	(*del)(struct _BUFFER *, size_t);
	void 	(*reset)(struct _BUFFER *);
	void 	(*clean)(struct _BUFFER **);

}BUFFER;
BUFFER *buffer_init();
#define BUFFER_SIZE sizeof(BUFFER)
#define BUFFER_VIEW(buf) \
{ \
	if(buf) \
	{ \
		fprintf(stdout, "buf:%08X\n" \
		"buf->data:%08X\n" \
		"buf->end:%08X\n" \
		"buf->size:%ld\n" \
		"buf->recalloc():%08X\n" \
		"buf->remalloc():%08X\n" \
		"buf->push():%08X\n" \
		"buf->del():%08X\n" \
		"buf->reset():%08X\n" \
		"buf->clean():%08X\n", \
		buf, buf->data, buf->end, buf->size, \
		buf->recalloc, buf->remalloc, \
		buf->push, buf->del, \
		buf->reset, buf->clean); \
	} \
}
#endif

/* CHUNK */
#ifndef _TYPEDEF_CHUNK
#define _TYPEDEF_CHUNK
#define MEM_CHUNK   0x02
#define FILE_CHUNK  0x04
#define ALL_CHUNK  (MEM_CHUNK | FILE_CHUNK)
#define FILE_NAME_LIMIT 255 
typedef struct _CHUNK{
	/* property */
	int id;
	int type;
	BUFFER *buf;
	struct {
		int   fd ;
		char  name[FILE_NAME_LIMIT + 1];
	} file;
	uint64_t offset;
	uint64_t len;

	pthread_mutex_t mutex;

	/* method */
	int (*set)(struct _CHUNK *, int , int , char *, uint64_t, uint64_t);
	int (*append)(struct _CHUNK *, void *, size_t); 
	int (*fill)(struct _CHUNK *, void *, size_t); 
	int (*send)(struct _CHUNK *, int , size_t );
	void (*reset)(struct _CHUNK *); 
	void (*clean)(struct _CHUNK **); 
}CHUNK;
#define CHUNK_SIZE sizeof(CHUNK)
/* Initialize struct CHUNK */
CHUNK *chunk_init();
#define CHUNK_VIEW(chunk) \
{ \
	if(chunk) \
	{ \
		fprintf(stdout, "chunk:%08X\n" \
				"chunk->id:%d\n" \
				"chunk->type:%02X\n" \
				"chunk->buf:%08X\n" \
				"chunk->buf->data:%08X\n" \
				"chunk->buf->size:%u\n" \
				"chunk->file.fd:%d\n" \
				"chunk->file.name:%s\n" \
				"chunk->offset:%llu\n" \
				"chunk->len:%llu\n" \
				"chunk->set():%08X\n" \
				"chunk->append():%08X\n" \
				"chunk->fill():%08X\n" \
				"chunk->send():%08X\n" \
				"chunk->reset():%08X\n" \
				"chunk->clean():%08X\n\n", \
				chunk, chunk->id, chunk->type, \
				chunk->buf, chunk->buf->data, chunk->buf->size, \
				chunk->file.fd, chunk->file.name, \
				chunk->offset, chunk->len, chunk->set,\
				chunk->append, chunk->fill, chunk->send,\
				chunk->reset, chunk->clean \
		       ); \
	} \
}

#endif


/* transaction state */
#ifndef TRANSACTION_STATES
#define READY_STATE		0x00
#define READ_CHUNK_STATE	0x02
#define WRITE_STATE		0x04
#define PACKET_HANDLING_STATE	0x08
#define DATA_HANDLING_STATE	0x10
#define CLOSED_STATE		0x12
#define TRANSACTION_STATES (READY_STATE |  READ_CHUNK_STATE | WRITE_STATE \
		| PACKET_HANDLING_STATE | DATA_HANDLING_STATE | CLOSED_STATE)
#endif

/* HANDLER */
#ifndef TYPEDEF_HANDLER
#define TYPEDEF_HANDLER
typedef void HANDLER;
#endif

#ifndef TYPEDEF_SBASE
#define TYPEDEF_SBASE
typedef struct _SBASE{
	/* base INET setting */
	int                     sock_t; /* socket type*/
	int                     domain;
	int                     family;
	char			*ip;
	int                     port;
	int                     backlog;
	
	/* server type */
	int			server_type ;
	/* global log pointer */
	char 			*logfile;

	/* customize  define */
	int			packet_t;
	int                     packet_len ;
	void			*delimiter;
	int			delimiter_len;
	int                     buf_size;
	
	/* threads */
	int                     max_threads;
	
	/* connection */
	int                     max_connections;

	/* Usleep Setting*/
	uint32_t       		heartbeat_interval ;
        uint32_t              	sleep_usec ;
        uint32_t            	conn_timeout ;

	/*************************** HANDLER CALLBACK ********************/	
	/* Heartbeat Handler */
	void (*heartbeat_handler)(void );
	/* Read From Buffer and return packet length to get */
        int (*packet_reader)(const HANDLER *handler, const BUFFER *buffer);
	/* Packet Handler */
        void (*packet_handler)(const HANDLER *handler, const BUFFER *packet);
        /* Data Handler */
        void (*data_handler)(const HANDLER *handler,
		const BUFFER *packet, const CHUNK *chunk, const BUFFER *cache);
	/* OOB Data Handler */
        void (*oob_handler)(const HANDLER *handler, const BUFFER *oob);

	/*********************** HANDLER APIS **************************/
	 /* push cache */
        int (*push_cache)(const HANDLER *, const void *, const size_t);
	/* recv  CHUNK  from remote */
        int (*recv_chunk)(const HANDLER *, const size_t);
        /* recv FILE CHUNK from remote */
        int (*recv_file)(const HANDLER *, const char *, const uint64_t, const uint64_t );
	/* send a chunk */
	int   (*push_chunk)(const HANDLER *, const void *, const size_t);
	/* send file */
	int  (*push_file)(const HANDLER *, const char *, const uint64_t, const uint64_t );
	/* close connection */
	int   (*close_handler)(const HANDLER *);

	/* SERVER PTR*/
	void			*sv;
	/* APIS */
        int  (*init)(struct _SBASE * );
	int  (*start)(struct _SBASE * );
        int  (*stop)(struct _SBASE * );
        int  (*restart)(struct _SBASE *);
        void (*clean)(struct _SBASE *);
}SBASE;

/* Initialize struct sbase */
SBASE *sbase();
#endif

#ifdef __cplusplus
}
#endif
#endif