global.cpp

运行服务器端后

#include "stdafx.h"
#include "global.h"

mytcp*th;
int fla;
int rrlen;
int mytcp::mycreat(int port)
{this->sum=2;
this->rhead.len=0;
rrlen=0;
th=this;
this->isreceve=0;
rhead.len=0;
start=&shead;
//rhead=&rhead;

return Create(port,SOCK_DGRAM);

}
int mytcp::myconnect(CString ip,int port)
{
this->isserve=0;
node s;
node *r=new node;
s.synflag=0;
s.senumber=160;
mysyn=160;
this->SendTo((void*)&s,sizeof(node),port,ip);
int chaoshi=0;
int j=0;
for(;;)
{
chaoshi++;
if(chaoshi>=30000)
{chaoshi=0;
	j++;
if(j>50000)
{CString gg;
gg.Format("connect超时%d",j);
AfxMessageBox(gg);
break;
}
}
if(receive==1)
{
int ret=Receive(r,sizeof(node));
receive=0;
dsyn=r->senumber+1;
if(r->acknumber!=mysyn+1)
{CString ll;
ll.Format("序列号错误%d,%d",r->acknumber,r->senumber);
AfxMessageBox(ll);
}
else
{AfxMessageBox("hahahah!");
this->ip=ip;
this->port=port;
break;
}}
}
this->isserve=1;
this->mysyn++;
this->dsyn=201;
AfxMessageBox("cli连接成功");
return 1;
}

void mytcp::OnReceive(int nErrorCode) 
{
	if(nErrorCode==0)
{
receive=1;
node s;
if(th->isserve==1)
{
th->ReceiveFrom(&s,sizeof(node),th->ip,th->port);

receive=0;
}
if((s.synflag==0)&&(th->isserve==1))//连接过程
{
dsyn=s.senumber+1;
CString ll;
ll.Format("serve:%d",s.senumber);
AfxMessageBox(ll);
s.synflag=0;
s.acknumber=s.senumber+1;
s.senumber=200;
th->mysyn=201;

th->SendTo(&s,sizeof(node),th->port,th->ip);
//this->isserve=0;
AfxMessageBox("serve连接成功");
this->isaccpet=1;
}
if(s.synflag==1)
{
if(s.ackflag==1)//确认包?
{
node*p;
p=start;
if(start->senumber==s.acknumber)
{  CString aa;
aa.Format("se%d:len%d,npos:%d",s.acknumber,shead.len,start->npos);
//AfxMessageBox(aa);
	if(start->npos>=shead.len)
{CString hh;
hh.Format("完成%d",s.acknumber);
//AfxMessageBox(hh);
	th->isfinish=1;
	
}
else
{   
	start=p->next;
}
end=start;
}
}

if(s.ackflag==0)//数据包
{
CString ss;
s.data[s.pos]=0;
ss.Format("data:%s:snumber%d dsn:%d",s.data,s.senumber,th->dsyn);

node *p,*pre,*sl;
pre=p=&rhead;
//AfxMessageBox(ss);
if(s.senumber==th->dsyn)
{
	th->dsyn++;
if(rhead.len==0)
{
p=pre->next=(node*)malloc(sizeof(node));
rhead.len++;
rrlen++;
memcpy(p,&s,sizeof(node));
p->life=8000;
rend=p;
rstart=&rhead;
th->rstart=rstart;
node ap;
this->rlen=s.len;
ap.ackflag=1;//回应数据
ap.synflag=1;//非连接过程
ap.acknumber=s.senumber;
//AfxMessageBox("len=0");
//AfxMessageBox("dsdsdsd");
th->SendTo((char*)&ap,sizeof(node),th->port,th->ip);
this->type=s.type;
strcpy(this->name,s.name);
if(rhead.len==s.len)
{//AfxMessageBox("接受完毕");
this->isreceve=1;
}//AfxMessageBox("len=0");
}

//DWORD  dwthewad;

//this->starttimer();
//HANDLE thread=CreateThread(NULL,0,my2,this,0,&dwthewad);

else 
{//AfxMessageBox("len>0");
	sl=(node*)malloc(sizeof(node));
memcpy(sl,&s,sizeof(node));
sl->life=8000;
node ackp;
ackp.ackflag=1;//回应数据
ackp.synflag=1;//非连接过程
ackp.acknumber=sl->senumber;
th->SendTo(&ackp,sizeof(node),th->port,th->ip);
checkre(sl);
if(rhead.len==this->rlen)
{//AfxMessageBox(" 接受完毕");
this->isreceve=1;
}
}
}

}


}
}
}
int mytcp::myaccept()
{th->isserve=1;
return 1;
}
/*int mytcp::mysend(char*buffer,int len)
{int flag=0;
node s,d;
for(int i=0;i<len;i++)
s.data[i]=buffer[i];
s.senumber=this->mysyn+1;
s.length=len;
s.acknumber=this->dsyn;
this->SendTo(&s,sizeof(node),this->port,this->ip);
if(this->ReceiveFrom(&d,sizeof(node),this->ip,this->port)!=SOCKET_ERROR)
{if(d.acknumber==this->dsyn)
{
flag=1;
AfxMessageBox("发送成功");
}
}
return flag;
}*/
int mytcp::mysend(char*buffer,int len)
{
int tempsum=0;
if(th->setbuffer(&shead,buffer,len))
{
	CString sa;
	sa.Format("创建成功%d",th->dsyn);
//AfxMessageBox(sa);
}
::GlobalFree(buffer);
node *p;
start=shead.next;
p=start;
end=p;
th->isfinish=0;
th->starttimer();
//for(;;)
{

}

return 1;
}



DWORD mytcp::myreceive(char*buffer,DWORD len)
{DWORD flag=0;
if(rhead.len>0)
{
rhead.len=0;
char *ps;
ps=buffer;
int ff;
if(len%1024==0)
ff=len/1024;
else
ff=(len/1024)+1;
node*p;
p=rhead.next;
for(int i=0;i<ff;i++)
{if(i>rhead.len)
{
	rhead.len=0;
	break;
}

if(i==ff-1)
{if(i==rhead.len)
rhead.len=0;
	rhead.next=p->next;
if((len%1024)==0)
{
memcpy(ps,p->data,p->pos);
flag=flag+p->pos;
}
else
{
memcpy(ps,p->data,p->pos);
flag=flag+p->pos;
}
}
else
{memcpy(ps,p->data,p->pos);
flag=flag+p->pos;

ps=ps+p->pos;

p=p->next;
}
}}

return flag;
}

DWORD WINAPI my(LPVOID param)
{
int  flag=0; 
int j=0;
for(;;)
{
if(th->isfinish==1)
{CString kk;
node *fre=&th->shead;
node *pfre;
pfre=fre;
for(int fr=0;fr<th->shead.len;fr++)
{  pfre=fre;
fre=fre->next;
if(pfre!=&th->shead)
	free(pfre);
}
kk.Format("chenggongfasongwanbi%d",th->dsyn);
th->endofsend=1;
//AfxMessageBox(kk);
break;
}
//	AfxMessageBox(ll);
th->check(th->start);
flag++;
if(flag>=30000)
{flag=0;
node*p,*pre;
p=th->start;
if(th->shead.len!=0)
{if(th->start==th->end)
{
	if(th->start->issend==1)
th->start->life--;
if(th->start->life==0)
AfxMessageBox("dead");
}
}
}
}

return 1;
}
int mytcp::starttimer()
{//th=this;
DWORD  dwthewad;
//eend=end;
m_hThread=CreateThread(NULL,0,my,this,0,&dwthewad);
return 1;
}
int mytcp::setbuffer(node*head,char*buffer,int len)
{
int flag=0;
node*p,*pre;
char *ps;
ps=buffer;
int aa=0;
if(len%1024==0)
aa=len/1024;
else 
aa=(len/1024)+1;
shead.len=0;
p=pre=head;
head->len=0;
for(int i=0;i<aa;i++)
{p=pre->next=(node*)malloc(sizeof(node));
if(i==0)
{p->len=aa;
p->type=this->type;
strcpy(p->name,this->name);
}
head->len++;
p->pos=0;
if(p==head->next)
{p->senumber=this->mysyn+i;
p->npos=1;
}
else
{p->senumber=pre->senumber+1;
p->npos=pre->npos+1;
}
p->life=30000;
p->synflag=1;
p->issend=0;
p->ackflag=0;
p->resend=1;
if(i==aa-1)
{
if(len%1024)
{p->pos=len%1024;
memcpy(p->data,ps,len%1024);
flag=1;
}
else
{
p->pos=1024;
memcpy(p->data,ps,1024);
flag=1;
}
}
else
{p->pos=1024;
memcpy(p->data,ps,1024);
ps=ps+1024;
}
pre=p;
}
this->mysyn=p->senumber+1;
free(buffer);
return flag;
}
int mytcp::check(node*p)
{int flag=1;
if((p->issend==1)&&(p->life<=0))
{AfxMessageBox("send 2");
this->SendTo(p,sizeof(node),this->port,this->ip);
p->resend++;
if(p->resend>=3)
{
AfxMessageBox("网络不通?");
flag=0;
}
}
if(p->issend==0)
{
	//AfxMessageBox("fasong1");
	this->SendTo(p,sizeof(node),this->port,this->ip);
	p->resend=0;
p->issend=1;
}

return flag;
}
int mytcp::checkre(node*p)
{
node*pp,*pre;
pre=pp=&rhead;
int flag=0;
for(int i=0;i<rhead.len;i++)
{pp=pp->next;
if(p->senumber<pp->senumber)
{rhead.len++;
rrlen++;
pre->next=p;
p->next=pp;
}
/*if(p->senumber==pp->senumber)
{flag=1;
	break;
}*/
pre=pp;
}
if((i==rhead.len)&&(flag!=1))
{pp->next=p;
rhead.len++;
rrlen++;
}
return 1;
}