User:Antigng-bot/network

#include <winsock2.h>
#include <process.h>
#include <stdio.h>
#include <string.h>
#include "mem.h"
#include "network.h"
#include "auth.h"
#pragma comment (lib,"ws2_32.lib")
BUCKET buckpool=0;
int bucknum=0;
WSADATA wsadata;
CRITICAL_SECTION mcs;
static int buckfree(BUCKET p)
{
	EnterCriticalSection(&mcs);
	if(bucknum<BUCKMAX)
	{
		p->next=buckpool;
		bucknum++;
		buckpool=p;
		LeaveCriticalSection(&mcs);
		return 0;
	}
	else
	{
		LeaveCriticalSection(&mcs);
		s_free(p);
		return 0;
	}
}
int buckini(int count)
{
	int i=0;
	BUCKET p;
	InitializeCriticalSection(&mcs);
	buckpool=0;
	bucknum=0;
	for(i=0;i<count&&i<BUCKMAX;i++)
	{
		p=(BUCKET)s_malloc(sizeof(struct bucket));
		buckfree(p);
	}
	WSAStartup(MAKEWORD(2,2),&wsadata);
	return 0;
}
int buckdestroy()
{
	BUCKET p;
	EnterCriticalSection(&mcs);
	while(buckpool)
	{
		p=buckpool->next;
		s_free(buckpool);
		buckpool=p;
	}
	bucknum=0;
	LeaveCriticalSection(&mcs);
	WSACleanup();
	return 0;
}
static BUCKET buckalloc()
{
	BUCKET p;
	EnterCriticalSection(&mcs);
	if(bucknum>0)
	{
		bucknum--;
		p=buckpool;
		buckpool=buckpool->next;
		LeaveCriticalSection(&mcs);
		p->next=0;
		return p;
	}
	else
	{
		bucknum=0;
		LeaveCriticalSection(&mcs);
		p=(BUCKET)s_malloc(sizeof(struct bucket));
		p->next=0;
		return p;
	}
}

static int buckbatchfree(BUCKET start,BUCKET end,int length)
{
	BUCKET p;
	EnterCriticalSection(&mcs);
	if(bucknum<BUCKMAX&&end)
	{
		end->next=buckpool;
		buckpool=start;
		bucknum+=length;
		LeaveCriticalSection(&mcs);
		return 0;
	}
	else
	{
		LeaveCriticalSection(&mcs);
		p=start;
		while(p)
		{
			start=p->next;
			s_free(p);
			p=start;
		}
	}
	return 0;
}
const DWORD rcvlimit=1000*TIMEOUT;
static SOCKET prepare_socket(unsigned short port)
{
	struct sockaddr_in addr;
	SOCKET s=socket(AF_INET,SOCK_STREAM,0);
	if(s==INVALID_SOCKET) return INVALID_SOCKET;
	if(setsockopt(s,SOL_SOCKET,SO_RCVTIMEO,(const char *)&rcvlimit,sizeof(rcvlimit))==SOCKET_ERROR)
	{
		closesocket(s);
		return INVALID_SOCKET;
	}
	addr.sin_family=AF_INET;
	addr.sin_port=htons(port);
	addr.sin_addr.s_addr=inet_addr("127.0.0.1");
	if(connect(s,(SOCKADDR *)&addr,sizeof(addr))==SOCKET_ERROR)
	{
		closesocket(s);
		return INVALID_SOCKET;
	}
	return s;
}
static int recv_till_close(SOCKET s,HTTP res)
{
	int sst=0;
	int flag=0;
	BUCKET b=buckalloc();
	char *g=b->content;
	for(;;)
	{
		sst=recv(s,g,BUFFERMAX,0);
		if(sst>0)
		{
			g[sst]=0;
			hputs(g,BUFFERMAX,res);
			flag=1;
		}
		else if(sst<0)
		{
			flag=0;
			break;
		}
		else break;
	}
	buckfree(b);
	return flag;
}
int get(const char *url,unsigned short port,int lg, HTTP result)
{
	int err;
	SOCKET s;
	char req[8192];
	int requestlength;
	if(lg)
	{
		AcquireSRWLockShared(&rwcs);
		requestlength=sprintf(req,
			"GET %s HTTP/1.0\r\n"
			"Host:127.0.0.1\r\n"
			"User-agent:Antigng-bot/0.0\r\n"
			"Cookie:%s\r\n"
			"\r\n",
			url,session);
		ReleaseSRWLockShared(&rwcs);
	}
	else
	{
		requestlength=sprintf(req,
			"GET %s HTTP/1.0\r\n"
			"Host:127.0.0.1\r\n"
			"User-agent:Antigng-bot/0.0\r\n"
			"\r\n",
			url,lg?"\r\n":"");
	}
	s=prepare_socket(port);
	if(s==INVALID_SOCKET)
	{
		return -1;
	}
	err=send(s,req,requestlength,0);
	if(err<0)
	{
		shutdown(s,SD_BOTH);
		closesocket(s);
		return -2;
	}
	err=!recv_till_close(s,result);
	hrewind(result);
	shutdown(s,SD_BOTH);
	closesocket(s);
	return err?-3:0;
}

int post(const char *url,const char *content,unsigned short port,int lg, HTTP result)
{
	int err;
	SOCKET s;
	char *req;
	int requestlength;
	s=prepare_socket(port);
	if(s==INVALID_SOCKET)
	{
		return -1;
	}
	req=(char *)s_calloc(1024*1024,1);
	if(lg)
	{
		AcquireSRWLockShared(&rwcs);
		requestlength=sprintf(req,
			"POST %s HTTP/1.0\r\n"
			"Host:127.0.0.1\r\n"
			"User-agent:Antigng-bot/0.0\r\n"
			"Cookie:%s\r\n"
			"Content-type:application/x-www-form-urlencoded\r\n"
			"Content-length:%d\r\n"
			"\r\n"
			"%s\r\n"
			"\r\n",
			url,session,strlen(content),content);
		ReleaseSRWLockShared(&rwcs);
	}
	else
	{
		requestlength=sprintf(req,
			"POST %s HTTP/1.0\r\n"
			"Host:127.0.0.1\r\n"
			"User-agent:Antigng-bot/0.0\r\n"
			"Content-type:application/x-www-form-urlencoded\r\n"
			"Content-length:%d\r\n"
			"\r\n"
			"%s\r\n"
			"\r\n",
			url,strlen(content),content);
	}
	err=send(s,req,requestlength,0);
	s_free(req);
	if(err<0)
	{
		shutdown(s,SD_BOTH);
		closesocket(s);
		return -2;
	}
	err=!recv_till_close(s,result);
	hrewind(result);
	shutdown(s,SD_BOTH);
	closesocket(s);
	return err?-3:0;
}
static int smartsend(SOCKET s, HTTP content)
{
	const struct bucket *b_buffer;
	int err=0;
	int count;
	hrewind(content);
	for(count=0,b_buffer=content->buffer;count<content->buffnum;count++,b_buffer=b_buffer->next)
	{
		err=send(s,b_buffer->content,BUFFERMAX,0);
		if(err<0) return err;
	}
	err=send(s,b_buffer->content,content->last-content->tailtxt+1,0);
	return err;
}
int smartpost(const char *url,HTTP content,const char *aft,unsigned short port,int lg,struct http *result)
{
	int err;
	SOCKET s;
	char req[8192];
	int requestlength;
	if(lg)
	{
		AcquireSRWLockShared(&rwcs);
		requestlength=sprintf(req,
			"POST %s HTTP/1.0\r\n"
			"Host:127.0.0.1\r\n"
			"User-agent:Antigng-bot/0.0\r\n"
			"Cookie:%s\r\n"
			"Content-type:application/x-www-form-urlencoded\r\n"
			"Content-length:%d\r\n"
			"\r\n",
			url,session,(int)hlen(content)+(int)strlen(aft));
		ReleaseSRWLockShared(&rwcs);
	}
	else
	{
		requestlength=sprintf(req,
			"POST %s HTTP/1.0\r\n"
			"Host:127.0.0.1\r\n"
			"User-agent:Antigng-bot/0.0\r\n"
			"Content-type:application/x-www-form-urlencoded\r\n"
			"Content-length:%d\r\n"
			"\r\n",
			url,(int)hlen(content)+(int)strlen(aft));
	}
	s=prepare_socket(port);
	if(s==INVALID_SOCKET)
	{
		return -1;
	}
	err=send(s,req,requestlength,0);
	if(err<0)
	{
		shutdown(s,SD_BOTH);
		closesocket(s);
		return -2;
	}
	err=smartsend(s,content);
	if(err<0)
	{
		shutdown(s,SD_BOTH);
		closesocket(s);
		return -2;
	}
	err=send(s,aft,strlen(aft),0);
	if(err<0)
	{
		shutdown(s,SD_BOTH);
		closesocket(s);
		return -2;
	}
	err=send(s,"\r\n\r\n",4,0);
	if(err<0)
	{
		shutdown(s,SD_BOTH);
		closesocket(s);
		return -2;
	}
	err=!recv_till_close(s,result);
	WRITE(0,result);
	hrewind(result);
	shutdown(s,SD_BOTH);
	closesocket(s);
	return err?-3:0;
}
char SEQREAD(struct http *f)
{
	if(f->error) return 0;
	if(!f->cur)
	{
		f->error=1;
		return 0;
	}
	if(f->buff<f->buffnum)
	{
		char *ch=f->curtxt;
		if(ch<f->curlast)
		{
			f->curtxt++;
			return *ch;
		}
		else
 		{
			BUCKET cur=f->cur->next;
			if(cur)
			{
				f->cur=cur;
				f->curtxt=cur->content;
				f->curlast=f->curtxt+BUFFERMAX-1;
			}
			else f->error=1;
			f->buff++;
			return *ch;
		}
	}
	else
	{
		char *ch=f->curtxt;
		if(ch<f->last)
		{
			f->curtxt++;
			return *ch;
		}
		else
		{
			f->error=1;
			return *ch;
		}
	}
}


int FORWARD (struct http *f)
{
	if(f->error) return -1;
	if(f->buff<f->buffnum)
	{
		if(f->curtxt<f->curlast)
		{
			f->curtxt++;
			return 0;
		}
		else
 		{
			f->buff++;
			f->cur=f->cur->next;
			if(f->cur)
			{
				f->curtxt=f->cur->content;
				f->curlast=f->curtxt+BUFFERMAX-1;
			}
			return 0;
		}
	}
	else
	{
		if(f->curtxt<f->last)
		{
			f->curtxt++;
			return 0;
		}
		else
		{
			f->error=1;
			return 1;
		}
	}
}
int WRITE(char c,HTTP f)
{
	if(!f->buffer)
	{
		f->buffer=buckalloc();
		f->tail=f->cur=f->buffer;
		f->tailtxt=f->last=f->curtxt=f->cur->content;
		f->curlast=f->curtxt+BUFFERMAX-1;
	}
	else if(f->flag)
	{
		BUCKET b;
		f->flag=0;
		f->buff++;
		f->buffnum++;
		b=f->cur;
		b->next=buckalloc();
		b=b->next;
		f->tail=f->cur=b;
		f->tailtxt=f->last=f->curtxt=b->content;
		f->curlast=f->curtxt+BUFFERMAX-1;
	}
	else f->last++;
	*(f->curtxt)=c;
	if(f->curtxt==f->curlast)
	{
		f->flag=1;
	}
	f->curtxt++;
	return 0;
}
char READ(struct http *f)
{
	if(f->error) return 0;
	if(!f->cur)
	{
		f->error=1;
		return 0;
	}
	return *(f->curtxt);
}
int hgets(char *buffer,int size,struct http *f)
{
	int i=0;
	while(i<size&&!heof(f))
	{
		if((buffer[i]=hgetc(f))=='\n')
		{
			i++;
			break;
		}
		i++;
	}
	buffer[i]=0;
	return i;
}
HTTP hopen()
{
	return (struct http *)s_calloc(sizeof(struct http),1);
}
int hclose(HTTP f)
{
	if(!f->buffer) return 1;
	buckbatchfree(f->buffer,f->tail,f->buffnum+1);
	s_free(f);
	return 0;
}
int hputs(const char *content,int length,HTTP f)
{
	int count=0;
	int buf_remain=0;
	char *ptobuf=0;
	if(f->buffer)
	{
		ptobuf=f->curtxt;
		buf_remain=f->curlast-ptobuf+1;
		if(buf_remain>length)
		{
			while(count<length)
			{
				if(!(ptobuf[count]=content[count])) break;
				count++;
			}
			f->last=ptobuf+count-1;
			f->curtxt=ptobuf+count;
			return count;
		}
		else
		{
			while(count<buf_remain)
			{
				if(!(ptobuf[count]=content[count])) break;
				count++;
			}
			if(count<buf_remain)
			{
				f->last=ptobuf+count-1;
				f->curtxt=ptobuf+count;
				return count;
			}
			else
			{
				if(count==length)
				{
					f->last=ptobuf+count-1;
					f->curtxt=ptobuf+count;
					f->flag=1;
					return count;
				}
			}
		}
	}
	else if(!(length)||!(*content))
	{
		return 0;
	}
	{
		int basecount=count;
		BUCKET b=f->cur;
		for(;;)
		{
			if(!f->buffer)
			{
				b=f->buffer=buckalloc();
				ptobuf=b->content;
			}
			else
			{
				f->buff++;
				f->buffnum++;
				b->next=buckalloc();
				b=b->next;
				ptobuf=b->content;
			}
			buf_remain=BUFFERMAX;
			basecount=count;
			if(length-basecount<buf_remain)
			{
				while(count<length)
				{
					if(!(ptobuf[count-basecount]=content[count])) break;
					count++;
				}
				f->last=ptobuf+count-basecount-1;
				f->curtxt=ptobuf+count-basecount;
				f->tail=f->cur=b;
				f->tailtxt=b->content;
				f->curlast=b->content+BUFFERMAX-1;
				f->flag=0;
				break;
			}
			else
			{
				while(count-basecount<buf_remain)
				{
					if(!(ptobuf[count-basecount]=content[count])) break;
					count++;
				}
				if(count-basecount<buf_remain)
				{
					f->last=ptobuf+count-basecount-1;
					f->curtxt=ptobuf+count-basecount;
					f->tail=f->cur=b;
					f->tailtxt=b->content;
					f->curlast=b->content+BUFFERMAX-1;
					f->flag=0;
					break;
				}
				else
				{
					if(count==length)
					{
						f->last=ptobuf+count-basecount-1;
						f->curtxt=ptobuf+count-basecount;
						f->tail=f->cur=b;
						f->tailtxt=b->content;
						f->curlast=b->content+BUFFERMAX-1;
						f->flag=1;
						break;
					}
				}
			}
			f->tail=f->cur=b;
			f->tailtxt=b->content;
			f->curlast=b->content+BUFFERMAX-1;
		}
	}
	return count;
}

int hrewind(HTTP f)
{
	f->buff=0;
	f->error=0;
	f->cur=f->buffer;
	if(f->cur)
	{
		f->curtxt=f->cur->content;
		f->curlast=f->curtxt+BUFFERMAX-1;
	}
	return 0;
}
int hlen(HTTP f)
{
	if(!f->buffer) return 0;
	return (f->last-f->tailtxt+1)+f->buffnum*(BUFFERMAX);
}
int hcur(HTTP f)
{
	if(!f->buffer) return -1;
	return f->curtxt-f->cur->content+f->buff*BUFFERMAX;
}
int skipresponseheader(HTTP f,int enable)
{
	int flag=0;
	int signal=0;
	int counter=0;
	const char *set_cookie="set-cookie:";
	char cookie[512],attr[512];
	char ch=0;
	while(!heof(f))
	{
		ch=hgetc(f);
		if(ch=='\r')
		{
			if(flag==0)
			{
				flag=1;
			}
			else if(flag==2)
			{
				flag=3;
			}
			else
			{
				flag=0;
			}
		}
		else if(ch=='\n')
		{
			if(flag==1)
			{
				flag=2;
			}
			else if(flag==3)
			{
				flag=4;
				break;
			}
			else
			{
				flag=0;
			}
		} 
		else
		{
			if(flag==2)
			{
				if(enable)
				{
					counter=0;
					signal=1;
				}
			}
			flag=0;
		}
		switch(signal)
		{
		case 0:
			break;
		case 1:
			if((unsigned char)(ch-'A')<='Z'-'A')
			{
				ch+='a'-'A';
			}
			if(ch!=set_cookie[counter])
			{
				signal=0;
			}
			else
			{
				counter++;
				if(counter==11)
				{
					signal=2;
					counter=0;
				}
			}
			break;
		case 2:
			if(ch==';')
			{
				cookie[counter]=0;
				counter=0;
				signal=3;
			}
			else if(ch=='\r')
			{
				cookie[counter]=0;
				attr[0]=0;
				sessionmanage(cookie,attr);
				signal=0;
			}
			else if(counter>510)
			{
				signal=0;
			}
			else
			{
				cookie[counter++]=ch;
			}
			break;
		case 3:
			if(ch=='\r')
			{
				attr[counter]=0;
				sessionmanage(cookie,attr);
				signal=0;
			}
			else if(counter>510)
			{
				signal=0;
			}
			else
			{
				attr[counter++]=ch;
			}
			break;
		}
	}
	return (flag!=4);
}