lib1

// testlib1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include "queue.h"
#include "event.h"

#include <windows.h>
#include <stdio.h>

#include <stdlib.h>
#include <time.h>

#pragma comment(lib, "ws2_32.lib")

//#include <sys/time.h>
//#include <sys/queue.h>
#include <stdio.h>
#include <stdlib.h>
//#include <unistd.h>
#include <errno.h>
#include <string.h>

#ifdef USE_LOG
#include "log.h"
#else
#define LOG_DBG(x)
#define log_error(x)	perror(x)
#endif

#include "event.h"

#ifndef howmany
#define        howmany(x, y)   (((x)+((y)-1))/(y))
#endif

/* Prototypes */
void event_add_post(EVENT_BASE* base,struct event *);

void
event_init(EVENT_BASE* base)
{
TAILQ_INIT(&base->timequeue);
TAILQ_INIT(&base->writequeue);
TAILQ_INIT(&base->readqueue);
TAILQ_INIT(&base->addqueue);

base->event_inloop = 0;

base->event_readset = &(base->m_event_readset);
base->event_writeset = &(base->m_event_writeset);
}

/*
* Called with the highest fd that we know about.  If it is 0, completely
* recalculate everything.
*/

int
event_dispatch(EVENT_BASE* base)
{
struct timeval tv;
struct event *ev, *old;
int res;

FD_ZERO(base->event_readset);
FD_ZERO(base->event_writeset);

while (1) {

TAILQ_FOREACH(ev, &base->writequeue, ev_write_next)
{
FD_SET(ev->ev_fd, base->event_writeset);
printf("w fd=%d\n",ev->ev_fd);
}

TAILQ_FOREACH(ev, &base->readqueue, ev_read_next)
{
FD_SET(ev->ev_fd, base->event_readset);
printf("r fd=%d\n",ev->ev_fd);
}

timeout_next(base,&tv);

if ((res = select(0, base->event_readset,
base->event_writeset, NULL, &tv)) == -1) {
int iErr = WSAGetLastError();
printf("Faild to select sockt in server!(Error: %d)\r\n", iErr);
if (errno != EINTR) {
log_error("select");
return (-1);
}

//WSACleanup();

Sleep(100);
continue;
}

LOG_DBG((LOG_MISC, 80, __FUNCTION__": select reports %d",
res));

base->event_inloop = 1;
for (ev = TAILQ_FIRST(&base->readqueue); ev;) {
old = TAILQ_NEXT(ev, ev_read_next);
if (FD_ISSET(ev->ev_fd, base->event_readset)) {
event_del(base,ev);
(*ev->ev_callback)(ev->ev_fd, EV_READ,
ev->ev_arg);
}
ev = old;
}

for (ev = TAILQ_FIRST(&base->writequeue); ev;) {
old = TAILQ_NEXT(ev, ev_read_next);//???
if (FD_ISSET(ev->ev_fd, base->event_writeset)) {
event_del(base,ev);
(*ev->ev_callback)(ev->ev_fd, EV_WRITE,
ev->ev_arg);
}

ev = old;
}
base->event_inloop = 0;

for (ev = TAILQ_FIRST(&base->addqueue); ev;
ev = TAILQ_FIRST(&base->addqueue)) {
TAILQ_REMOVE(&base->addqueue, ev, ev_add_next);
ev->ev_flags &= ~EVLIST_ADD;

event_add_post( base,ev);
}

timeout_process(base);
}

return (0);
}

void
event_set(struct event *ev, int fd, short events,
void (*callback)(int, short, void *), void *arg)
{
ev->ev_callback = callback;
ev->ev_arg = arg;
ev->ev_fd = fd;
ev->ev_events = events;
ev->ev_flags = EVLIST_INIT;
}

/*
* Checks if a specific event is pending or scheduled.
*/

int
event_pending(struct event *ev, short event, struct timeval *tv)
{
int flags = ev->ev_flags;

/*
* We might not have been able to add it to the actual queue yet,
* check if we will enqueue later.
*/
if (ev->ev_flags & EVLIST_ADD)
flags |= (ev->ev_events & (EV_READ|EV_WRITE));

event &= (EV_TIMEOUT|EV_READ|EV_WRITE);

/* See if there is a timeout that we should report */
if (tv != NULL && (flags & event & EV_TIMEOUT))
*tv = ev->ev_timeout;

return (flags & event);
}

void
event_add(EVENT_BASE* base,struct event *ev, struct timeval *tv)
{
LOG_DBG((LOG_MISC, 55,
"event_add: event: %p, %s%s%scall %p",
ev,
ev->ev_events & EV_READ ? "EV_READ " : " ",
ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
tv ? "EV_TIMEOUT " : " ",
ev->ev_callback));
if (tv != NULL) {
struct timeval now;
struct event *tmp;

gettimeofday(&now, NULL);
//timeradd(&now, tv, &ev->ev_timeout);

ev->ev_timeout.tv_usec = (now.tv_usec + tv->tv_usec)%(1000*1000);
ev->ev_timeout.tv_sec = now.tv_sec + tv->tv_sec+(now.tv_usec + tv->tv_usec)/(1000*1000);
LOG_DBG((LOG_MISC, 55,
"event_add: timeout in %d seconds, call %p",
tv->tv_sec, ev->ev_callback));
if (ev->ev_flags & EVLIST_TIMEOUT)
TAILQ_REMOVE(&base->timequeue, ev, ev_timeout_next);

/* Insert in right temporal order */
for (tmp = TAILQ_FIRST(&base->timequeue); tmp;
tmp = TAILQ_NEXT(tmp, ev_timeout_next)) {
if (timercmp(&ev->ev_timeout, &tmp->ev_timeout, <=))
break;
}

if (tmp)
TAILQ_INSERT_BEFORE(tmp, ev, ev_timeout_next);
else
TAILQ_INSERT_TAIL(&base->timequeue, ev, ev_timeout_next);

ev->ev_flags |= EVLIST_TIMEOUT;
}

if (base->event_inloop) {
/* We are in the event loop right now, we have to
* postpone the change until later.
*/
if (ev->ev_flags & EVLIST_ADD)
return;

TAILQ_INSERT_TAIL(&base->addqueue, ev, ev_add_next);
ev->ev_flags |= EVLIST_ADD;
} else
event_add_post(base,ev);
}

void
event_add_post(EVENT_BASE* base,struct event *ev)
{
printf("add post fd %d\n",ev->ev_fd);
ev->myBase = base;
if ((ev->ev_events & EV_READ) && !(ev->ev_flags & EVLIST_READ)) {
TAILQ_INSERT_TAIL(&base->readqueue, ev, ev_read_next);

ev->ev_flags |= EVLIST_READ;
}

if ((ev->ev_events & EV_WRITE) && !(ev->ev_flags & EVLIST_WRITE)) {
TAILQ_INSERT_TAIL(&base->writequeue, ev, ev_write_next);

ev->ev_flags |= EVLIST_WRITE;
}
}

void
event_del(EVENT_BASE* base,struct event *ev)
{
printf("del post fd %d\n",ev->ev_fd)
LOG_DBG((LOG_MISC, 80, "event_del: %p, callback %p",
ev, ev->ev_callback));

if (ev->ev_flags & EVLIST_ADD) {
TAILQ_REMOVE(&base->addqueue, ev, ev_add_next);

ev->ev_flags &= ~EVLIST_ADD;
}

if (ev->ev_flags & EVLIST_TIMEOUT) {
TAILQ_REMOVE(&base->timequeue, ev, ev_timeout_next);

ev->ev_flags &= ~EVLIST_TIMEOUT;
}

if (ev->ev_flags & EVLIST_READ) {
TAILQ_REMOVE(&base->readqueue, ev, ev_read_next);

ev->ev_flags &= ~EVLIST_READ;
}

if (ev->ev_flags & EVLIST_WRITE) {
TAILQ_REMOVE(&base->writequeue, ev, ev_write_next);

ev->ev_flags &= ~EVLIST_WRITE;
}
}

int
timeout_next(EVENT_BASE* base,struct timeval *tv)
{
struct timeval now;
struct event *ev;

if ((ev = TAILQ_FIRST(&base->timequeue)) == NULL) {
timerclear(tv);
tv->tv_sec = TIMEOUT_DEFAULT;
return (0);
}

if (gettimeofday(&now, NULL) == -1)
return (-1);

if (timercmp(&ev->ev_timeout, &now, <=)) {
timerclear(tv);
return (0);
}

timersub(&ev->ev_timeout, &now, tv);

LOG_DBG((LOG_MISC, 60, "timeout_next: in %d seconds", tv->tv_sec));
return (0);
}

void
timeout_process(EVENT_BASE* base)
{
struct timeval now;
struct event *ev;

gettimeofday(&now, NULL);

while ((ev = TAILQ_FIRST(&base->timequeue)) != NULL) {
if (timercmp(&ev->ev_timeout, &now, >))
break;

TAILQ_REMOVE(&base->timequeue, ev, ev_timeout_next);
ev->ev_flags &= ~EVLIST_TIMEOUT;

LOG_DBG((LOG_MISC, 60, "timeout_process: call %p",
ev->ev_callback));
(*ev->ev_callback)(ev->ev_fd, EV_TIMEOUT, ev->ev_arg);
}
}

int timersub(struct timeval *y, struct timeval *x,struct timeval* result )
{
int nsec;
if ( x->tv_sec > y->tv_sec )    return -1;
if ((x->tv_sec==y->tv_sec) && (x->tv_usec>y->tv_usec)) return -1;

result->tv_sec = ( y->tv_sec-x->tv_sec );
result->tv_usec = ( y->tv_usec-x->tv_usec );

if (result->tv_usec<0)
{
result->tv_sec--;
result->tv_usec+=1000000;
}

return 0;
}

int gettimeofday(struct timeval *tp, void *tzp)
{
time_t clock;
struct tm tm;
SYSTEMTIME wtm;

GetLocalTime(&wtm);
tm.tm_year     = wtm.wYear - 1900;
tm.tm_mon     = wtm.wMonth - 1;
tm.tm_mday     = wtm.wDay;
tm.tm_hour     = wtm.wHour;
tm.tm_min     = wtm.wMinute;
tm.tm_sec     = wtm.wSecond;
tm. tm_isdst    = -1;
clock = mktime(&tm);
tp->tv_sec = clock;
tp->tv_usec = wtm.wMilliseconds * 1000;

return (0);
}

#define STR_SERVER_IP           "127.0.0.1"
#define INT_SERVER_PORT         80
#define INT_DATABUFFER_SIZE     2560

void sock_read(int fd, short event, void *arg)
{
char buf[25500];
int len;
struct event *ev = (struct event *)arg;

printf("recv fd=%d \n ",fd);

len = recv(fd, buf, sizeof(buf)-1, 0);

if (len == -1)
{
perror("recv error\n");

if (errno != EAGAIN && errno != EINTR)
{
printf("---close fd=%d\n",fd);

if(fd!=INVALID_SOCKET)
{
closesocket(fd);
fd = INVALID_SOCKET;
}

free(ev);
}

return;
}
else if (len == 0)
{
printf("----close fd=%d\n",fd);
if(fd!=INVALID_SOCKET)
{
closesocket(fd);
fd = INVALID_SOCKET;
}
fprintf(stderr, "Connection closed\n");
free(ev);
return;
}

buf[len] = '\0';

fprintf(stdout, "Read: %s\n", buf);
send(fd, buf, strlen(buf), 0);
printf("-----close fd=%d\n",fd);
if(fd!=INVALID_SOCKET)
{
closesocket(fd);
fd = INVALID_SOCKET;
}

free(ev);
/* Reschedule this event */
//event_add((EVENT_BASE*)ev->myBase,ev, NULL);
}

void sock_accept(int fd, short event, void *arg)
{
struct event *ev = (struct event *)arg;
sockaddr_in  addr;
int len = sizeof(addr);

//由于此结构要长期使用，所以rev必须动态分配，否则离开此函数后会自动释放，导致segment fault

struct event* rev = (struct event*)malloc(sizeof(*rev));

int s = accept(fd,(sockaddr *) &addr, &len);
if (s == -1)
{
perror("accept error\n");
return;
}

fprintf(stdout, "accept socket: %d\n", s);

if (INVALID_SOCKET != s)
{
printf("%s:%d has connected server!\r\n", inet_ntoa(addr.sin_addr),
ntohs(addr.sin_port));
}

/* Initalize one event */
event_set(rev, s, EV_READ, sock_read, rev);

/* Add it to the active events, without a timeout */
event_add((EVENT_BASE*)ev->myBase,rev, NULL);

/* Reschedule this event */
event_add((EVENT_BASE*)ev->myBase,ev, NULL);
}

int main(int argc, char* argv[])
{

EVENT_BASE base;

WORD dwVersion = MAKEWORD(2,2);
WSAData wsaData;
WSAStartup(WINSOCK_VERSION,&wsaData);

SOCKET sockServer = socket(AF_INET, SOCK_STREAM, 0);
if (INVALID_SOCKET == sockServer) {
printf("Failed to create socket!\r\n");
WSACleanup();
return -1;
}

sockaddr_in addrServer;
memset(&addrServer,0,sizeof(sockaddr_in));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(INT_SERVER_PORT);
addrServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
//addrServer.sin_addr.s_addr = htonl(INADDR_ANY);

int iResult;

bool bReuseAddr = true;
iResult=setsockopt(sockServer,SOL_SOCKET,SO_REUSEADDR,(char *)&bReuseAddr,sizeof(bReuseAddr));
if(SOCKET_ERROR == iResult) {
printf("Failed to set resueaddr socket!\r\n");
WSACleanup();
return -1;
}

//unsigned   long cmd = 1;
// iResult= ioctlsocket(sockServer,FIONBIO,&cmd);

iResult = bind(sockServer,(sockaddr *)&addrServer,sizeof(addrServer));
if (SOCKET_ERROR == iResult) {
printf("Failed to bind address!\r\n");
WSACleanup();
return -1;
}

if (0 != listen(sockServer,5)) {
printf("Failed to listen client!\r\n");
WSACleanup();
return -1;
}

struct event ev;
/* Initalize the event library */
event_init(&base);

/* Initalize one event */
event_set(&ev, sockServer, EV_READ, sock_accept, &ev);

/* Add it to the active events, without a timeout */
event_add(&base,&ev, NULL);

event_dispatch(&base);

printf("Hello World!\n");
return 0;
}

select convert(varchar(22),ticketid) as strTicketID, vpath from ZX025022129.monitor.dbo.pshttp20160106 where url = 'http://baidu.com/' and ((ticketid &0x00000000ffffffff)+ vtime*4294967296) >= 2983700887072440620 order by ((ticketid &0x00000000ffffffff)+
vtime*4294967296)