interface_c.cpp

#include "interface_c.h"
#include "PacketBase.h"
#include "socket.h"
#include "log.h"
#include "timer_event.h"
#include "net.h"
#include "mysql_part.h"
#include "redis.h"
#include "timewheel.h"

#include <string.h>
#include <uuid/uuid.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>

extern "C"
{
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
}

extern lua_State* L;

static NETOutputPacket out_package;
extern timer_list_t timer_list;
extern CMysql mysql_handle;
extern CRedis redis_handle;
extern NETInputPacket in_package;
extern Net net;

int 
send_buffer(int fd, char* buffer, int len)
{
	return send(fd, buffer, len, 0);
}

static int 
send_packet(int fd, bool encrypt)
{	
	if (encrypt) SocketHandler::EncryptBuffer(&out_package);

    char* buffer = out_package.packet_buf();
    int length = out_package.packet_size();

    int nsend = 0; 
    while (nsend < length) {
        int size = send(fd, buffer + nsend, length-nsend, 0);
        printf("size = %d\n", size);
        if (size < 0) {

			log_debug("FD: %d\n", fd);
			log_debug("Send ErrNo: %d\n", errno);

			/* 判断非阻塞返回errno的处理 */
			if (errno == EINTR) { /* EINTR 中断 信号 */ 
				usleep(1);
				continue;
			}

			if (errno == EAGAIN) { //如果缓冲区满了, 就继续
				usleep(1); /* sleep 1us */
				continue;
			}

			/* export lua */
			lua_pushnumber(L, errno);
			lua_setglobal(L, ERRNO);
			
            return -1;
        }

        nsend += size;
    }

	return nsend; // modify by austin 2012-06-18
}

int send_raw_packet(int fd)
{
	return send_packet(fd, false);
}

int send_packet(int fd)
{
	return send_packet(fd, true);
}

int 
transfer(int fd)
{
    out_package.Copy(in_package.packet_buf(), in_package.packet_size());

    return send_packet(fd,true);
}

int 
transfer_raw(int fd)
{
    out_package.Copy(in_package.packet_buf(), in_package.packet_size());

    return send_packet(fd,false);
}

void 
write_begin(short cmd)
{
	out_package.Begin(cmd);
}

void 
write_end()
{
	out_package.End();
}

void write_int(int value)
{
	out_package.WriteInt(value);
}

void write_uint(unsigned long value)
{
	out_package.WriteULong(value);
}

void write_byte(unsigned char value)
{
	out_package.WriteByte(value);
}

void write_short(short value)
{
	out_package.WriteShort(value);
}

void write_string(char* value)
{
	out_package.WriteString(value);
}

void write_binary(char* buf, int len)
{
	out_package.WriteBinary(buf, len);
}

void error(const char* msg)
{
    log_error(msg);
}

void info(const char* msg)
{
    log_info(msg);
}

void debug(const char* msg)
{
    log_debug(msg);
}

int create_timer()
{
	TimerEvent *timer = new TimerEvent();
	timer_list[timer->m_guid] = timer;
	return timer->m_guid;
}

int start_timer(unsigned long timer_id, int time)
{
   	timer_list_itr_t iter = timer_list.find(timer_id);

	if(iter == timer_list.end()) return -1;

	TimerEvent* timer = iter->second;
	timer_list[timer->m_guid] = timer;
	timer->SetTimerId(timer->m_guid);
	timer->StartTimer(time);

	return (iter->second)->m_guid;
}

int stop_timer(unsigned long timer_id)
{
	timer_list_itr_t iter = timer_list.find(timer_id);
	if (iter == timer_list.end()) return -1;

	TimerEvent* timer = iter->second;
	timer->StopTimer();

	return 0;
}

int reset_timer(unsigned long timer_id)
{
	timer_list_itr_t iter = timer_list.find(timer_id);

	if (iter == timer_list.end()) return -1;

	TimerEvent* timer = iter->second;
	timer->ResetTimer();
	
	return 0;
}

int clear_timer(unsigned long timer_id)
{
	timer_list_itr_t iter = timer_list.find(timer_id);
	if(iter == timer_list.end()) {
		return -1;
	}

	TimerEvent* event = iter->second;
	timer_list.erase(iter);
	delete(event);

	return 0;
}	

int remain_timer(unsigned long timer_id)
{
	timer_list_itr_t iter = timer_list.find(timer_id);

	if (iter == timer_list.end()) {
		return -1;
	}

	TimerEvent* event = iter->second;

	int remain = event->GetRemain();

	return remain;
}


int create_listener(int port)
{
	return net.create_listener(port);	
}

int connect_server(char* ip, int port)
{
	return connect_server(ip, port, true, 1);
}

int connect_server(char* ip, int port, bool is_encrypt, int conn_flag)
{
	return net.connect_server(ip, port, is_encrypt, conn_flag);
}

int close_socket(int fd)
{
	log_debug("FD: %d\n", fd);

	::close(fd);
	net.CloseHandler(fd);

	return 0;
}

int connect_mysql(const char* host, const char* user, const char* password, const char* dbname, unsigned int port)
{
    return mysql_handle.connect_mysql(host, user, password, dbname, port);
}

int query(const char* mysql)
{
    return mysql_handle.query(mysql);
}

int connect_redis(const char* host, unsigned int port, unsigned short second)
{
    return redis_handle.connect_redis(host, port, second);
}

int get_redis_value(const char* key)
{
    return redis_handle.get_value(key);
}

int set_redis_value(const char* key, const char* value)
{
    return redis_handle.set_value(key, value);
}

int set_redis_expire(const char* key, int expire)
{
    return redis_handle.set_expire(key, expire);
}

int Enqueue(const char* queue, const char* value)
{
	return redis_handle.Enqueue(queue, value);
}
int Dequeue(const char* queue)
{
	return redis_handle.Dequeue(queue);
}

bool IsActived()
{
	return redis_handle.IsActived();
}

int S_IsMember(const char* key, const char* value)
{
	return redis_handle.S_IsMember(key, value);
}

int S_IsMember(const char* key, const int value)
{
	return redis_handle.S_IsMember(key, value);
}

int 
HSet(const char* key, const int field,const char* value)
{
	return redis_handle.HashSetRedisValue(key,field,value);
}

int 
HGet(const char* key,const int field)
{
	return redis_handle.HashGetRedisValue(key,field);
}

int 
Del(const char* key)
{
	return redis_handle.DelRedisValue(key);
}

int 
HDel(const char* key,const int field)
{
	return redis_handle.DelRedisHashValue(key,field);
}

typedef struct {
	unsigned int	Data1;
	unsigned short 	Data2;
	unsigned short 	Data3;
	unsigned char 	Data4[8];
} GUID, UUID;


void NewUUID()
{
	UUID uuid;

	//uuid_generate(reinterpret_cast<unsigned char *>(&uuid)); /* 产生的UUID有可能重复，/dev/urandom */
	uuid_generate_random((unsigned char*)(&uuid));
	
	char buf[64] = {0};

	snprintf(buf,
             sizeof(buf),
             "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
             uuid.Data1, uuid.Data2, uuid.Data3, 
             uuid.Data4[0], uuid.Data4[1],
             uuid.Data4[2], uuid.Data4[3],
             uuid.Data4[4], uuid.Data4[5],
             uuid.Data4[6], uuid.Data4[7]);

	lua_pushstring(L, buf);
	lua_setglobal(L, UUID_RESULT);
}