int16_t TCP_recv(int Sockfd, void *Out, int Out_size, int flag){
PackageHeader Header;
int Status = 0;
Status = recv(Sockfd,(void*)&Header,sizeof(PackageHeader),MSG_PEEK);
if(Status <= 0){
if(Status == 0)
return LINKC_NO_DATA;
else
return LINKC_FAILURE;
}
int PackageLength = ntohs(Header.MessageLength)+sizeof(PackageHeader);
if(PackageLength > Out_size){
LinkC_Debug("Send-Out Buffer Too Small",LINKC_FAILURE); // Well, after fixing those Chinese strings, someone should really merge the error
// outputs into some sort of function. MERGE PLEASE...
return LINKC_FAILURE;
}
int NowRecv = 0;
int TmpSize = 0;
while(1){
TmpSize = recv(Sockfd,(char*)Out+NowRecv,PackageLength - NowRecv,flag);
if(TmpSize <= 0){
LinkC_Debug("Fetched Data",LINKC_FAILURE);
return LINKC_FAILURE;
}
NowRecv += TmpSize;
if(NowRecv == PackageLength)
break;
}
return LINKC_SUCCESS;
}
int AddSocketToList(LinkC_Socket *Socket){
if(List != NULL){ // 如果链表为空
LinkC_Debug("AddSocketToList: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
if(Socket == NULL){ // 如果参数为空指针
printf("The Argument is NULL\n"); // 打印错误信息
return 1;
}
if(IsSocketInList(Socket->Sockfd,NULL) == 1){ // 当前Socket是否已经存在于链表中，如果存在
LinkC_Debug("AddSocketToList: Duplicated Addition",LINKC_FAILURE);
return 1;
}
SocketListNode* Node;
Node = (SocketListNode*)malloc(sizeof(SocketListNode)); // 分配内存
Node->Mutex_Lock= (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(Node->Mutex_Lock,NULL);
Node->Socket = Socket; // 保存当前新建的Socket
if(List->TotalSocket == 0){ // 如果现在还没有Socket
List->StartNode = Node; // 将当前节点设置为开始节点
Node->Perv = NULL; // 当前节点的前一个节点挂空
Node->Next = NULL; // 当前节点的后一个节点挂空
}else{
Node->Next = List->StartNode; // 新建节点的下一个设置成现在的起始节点
Node->Perv = NULL; // 当前节点的前一个节点挂空
List->StartNode->Perv = Node; // 链表起始节点的前一个为新建节点
List->StartNode = Node; // 链表起始节点为当前节点
}
List->TotalSocket++; // Socket总数加一
return 0; // 返回函数
}
void HeartBeats::run(){
int length = pack_message(HEART_BEATS,NULL,0,SendBuffer);
int status;
LinkC_Debug("UDP Heart Beats",LINKC_STARTED);
while(1){
status = Dest.Send_msg(SendBuffer,length,0);
if(status == LINKC_FAILURE){
LinkC_Debug("Heart Beats",LINKC_WARNING);
emit SendError(status);
}
sleep(HEART_BEATS_TIME);
}
}
int _LinkC_Send(LinkC_Socket *Socket, void *Message, size_t size, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("_LinkC_Send:LinkC Socket环境没有初始化",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
return __LinkC_Send(Socket,Message,size,Flag);
}
int DestroySocketList(){
if(List != NULL){ // 如果链表为空
LinkC_Debug("DestroySocketList: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
if(List->TotalSocket == 0){ // 如果没有套接字
return 0; // 返回0
}
SocketListNode *NowNode; // 当前节点
NowNode = List->StartNode; // 设置节点为当前节点
while(1){ // 循环
pthread_mutex_lock(NowNode->Mutex_Lock); // 申请互斥锁
close(NowNode->Socket->Sockfd); // 关闭套接字
if(NowNode->Socket->ErrorMessage != NULL){ // 如果错误消息指针不为空
free(NowNode->Socket->ErrorMessage); // 释放内存空间
NowNode->Socket->ErrorMessage = NULL; // 挂空指针
}
DestroyPackageList(NowNode->Socket->RecvList); // 释放接收缓冲区
DestroyPackageList(NowNode->Socket->SendList); // 释放发送缓冲区
free(NowNode->Socket->RecvBuffer); //
free(NowNode->Socket->SendBuffer); //
pthread_mutex_unlock(NowNode->Mutex_Lock); // 解锁互斥锁
pthread_mutex_destroy(NowNode->Mutex_Lock); // 销毁互斥锁
if(NowNode->Next != NULL){
NowNode = NowNode->Next; // 设置为下一个节点
free(NowNode->Perv); // 释放前一个节点
}else{ // 或者
free(NowNode); // 释放当前节点
break; // 跳出循环
}
}
return 0; // 返回函数
}
int _PackMessage(int Type, void* Message, size_t Length, LinkC_Socket *Socket, void* Output){
if(Output == NULL){ // 如果传出指针为空[这是不允许的]
printf("Package Message Error [Argument [Output[ is NULL]\n"); // 打印错误信息
return 1;
}
if(Length == 0){ // 如果指明传入数据为空
((MessageHeader*)Output)->MessageType = Type; // 设置传出数据包头为标准数据
((MessageHeader*)Output)->MessageLength = 0; // 设置后面数据长度为0
((MessageHeader*)Output)->ProtocolVersion = PROTOCOL_VERSION; // 设置协议版本号
// 当前包的计数次并不在这里设置，而是在send函数中进行设置
return sizeof(MessageHeader); // 返回长度
}
if(Message == NULL){ // 如果传入数据为空
printf("Package Message Error [Argument [Message] is NULL]\n"); // 打印错误信息
return 1;
}
((MessageHeader*)Output)->MessageType = Type; // 设置传出数据包头为标准数据
((MessageHeader*)Output)->ProtocolVersion = PROTOCOL_VERSION; // 设置协议版本号
if(Socket->IsSecurity == 1){
int len = 0;
len = EncryptPackage(Message,Length,(void *)(((char *)Output)+8),Socket->PublicKey);
if(len < 0){
LinkC_Debug("EncryptPackage",LINKC_FAILURE);
return -1;
}
((MessageHeader*)Output)->MessageLength = len;
return len+8;
}
((MessageHeader*)Output)->MessageLength = Length;
memcpy((char *)Output+8,Message,Length);
return Length + 8;
}
int DeleteSocket(int Socket){
if(List != NULL){ // 如果链表为空
LinkC_Debug("DeleteSocket: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
SocketListNode *NowNode = List->StartNode; // 声明一个节点指针，指向链表的开头
while(NowNode){
if(NowNode->Socket->Sockfd == Socket){ // 如果找到
pthread_mutex_lock(NowNode->Mutex_Lock); // 申请互斥锁
close(Socket); // 关闭套接字[真是简单粗暴啊]
if(NowNode->Socket->ErrorMessage != NULL){ // 如果错误消息指针不为空
free(NowNode->Socket->ErrorMessage); // 释放内存空间
NowNode->Socket->ErrorMessage = NULL; // 挂空指针
}
DestroyPackageList(NowNode->Socket->RecvList); // 释放接收缓冲区
DestroyPackageList(NowNode->Socket->SendList); // 释放发送缓冲区
free(NowNode->Socket->RecvBuffer); //
free(NowNode->Socket->SendBuffer); //
if(NowNode->Perv != NULL){ // 如果当前节点的前一个节点不为空
NowNode->Perv->Next = NowNode->Next; // 设置当前节点的前一个节点的后一个节点为当前节点的后一个节点
}else{ // 否则
List->StartNode = NowNode->Next; // 设置链表的开始节点为当前节点的后一个节点
}
if(NowNode->Next != NULL){ // 如果当前节点的后一个节点不为空
NowNode->Next->Perv = NowNode->Perv; // 设置当前节点的后一个节点的前一个节点为当前节点的前一个节点
}
pthread_mutex_unlock(NowNode->Mutex_Lock); // 解锁互斥锁
pthread_mutex_destroy(NowNode->Mutex_Lock); // 销毁互斥锁
return 0;
}else{ // 否则
NowNode = NowNode->Next; // 设置当前节点为当前节点的下一个节点
}
}
return 1; // 返回失败
}
int _LinkC_Send(LinkC_Socket *Socket, void *Message, size_t size, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("_LinkC_Send: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
return __LinkC_Send(Socket,Message,size,Flag);
}
int Connect (int Sockfd, struct sockaddr_in Dest){
if(List != NULL){ // 如果链表为空
LinkC_Debug("Connect:LinkC Socket环境没有初始化",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = NULL;
if(IsSocketInList(Sockfd,&Socket)==0){
LinkC_Debug("Connect:没有这个套接字",LINKC_FAILURE);
return -1;
}
EmptyPackageList(Socket->RecvList); // 清空发送和接收缓冲区
EmptyPackageList(Socket->SendList);
SetDestAddr(Sockfd,Dest);
int Length = _PackMessage(CONNECTION_MESSAGE,NULL,0,Socket,Socket->SendBuffer);
if(Length < 0){
LinkC_Debug("Connect:打包数据失败",LINKC_FAILURE);
return -1;
}
_LinkC_Send(Socket,Socket->SendBuffer,Length,0);
LinkC_Debug("Connect:已发出请求",LINKC_DEBUG);
_LinkC_Recv(Socket,Socket->RecvBuffer,512,0);
LinkC_Debug("Connect:正在确认请求",LINKC_DEBUG);
if(((MessageHeader*)Socket->RecvBuffer)->MessageType != CONNECTION_MESSAGE){
LinkC_Debug("Connect:消息头不正确",LINKC_FAILURE);
return -1;
}
LinkC_Debug("Connect:已连接上",LINKC_DEBUG);
return 0;
}
int Connect (int Sockfd, struct sockaddr_in Dest){
if(List != NULL){ // 如果链表为空
LinkC_Debug("Connect: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = NULL;
if(IsSocketInList(Sockfd,&Socket)==0){
LinkC_Debug("Connect: No Such Socket",LINKC_FAILURE);
return -1;
}
EmptyPackageList(Socket->RecvList); // 清空发送和接收缓冲区
EmptyPackageList(Socket->SendList);
SetDestAddr(Sockfd,Dest);
int Length = _LCUDP_Package(NULL,0,Socket,CONNECTION_MESSAGE,Socket->SendBuffer);
if(Length < 0){
LinkC_Debug("Connect: Data Packing Failed",LINKC_FAILURE);
return -1;
}
_LinkC_Send(Socket,Socket->SendBuffer,Length,0);
LinkC_Debug("Connect: Request Sent",LINKC_DEBUG);
_LinkC_Recv(Socket,Socket->RecvBuffer,512,0);
LinkC_Debug("Connect: Trying to Confirm Request",LINKC_DEBUG);
if(((PackageHeader*)Socket->RecvBuffer)->MessageType != CONNECTION_MESSAGE){
LinkC_Debug("Connect: Message Head Incorrect",LINKC_FAILURE);
return -1;
}
LinkC_Debug("Connect: Connected",LINKC_DEBUG); // Huh? Weird.
return 0;
}
int InitSocketList(void){
if(List != NULL){ // 如果链表为空
LinkC_Debug("InitSocketList: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
List = (SocketList*)malloc(sizeof(SocketList)); // 为链表分配内存
List->StartNode = NULL; // 开始节点挂空
List->TotalSocket = 0; // 套接字总数为0
return 0; // 返回0
}
int RecvMessage(int Sockfd, void *Buffers, size_t MaxBuf, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("RecvMessage: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
int Byte;
LinkC_Socket *Socket = NULL;
IsSocketInList(Sockfd,&Socket);
Byte = _LinkC_Recv(Socket,Buffers,MaxBuf,Flag);
return Byte;
}
int SendMessage(int Sockfd, void *Message, size_t Length, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("SendMessage: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = NULL;
if(IsSocketInList(Sockfd,&Socket) == 0){
return -1;
}
return _LinkC_Send(Socket,Message,Length,Flag);
}
int __LinkC_Send(LinkC_Socket *Socket, void *Message, size_t size, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("__LinkC_Send: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
((PackageHeader *)Message)->MessageCounts = Socket->SendList->NowCount+1; // 将本数据包的计数次设置为之前发送的数据包总数加一
if(InsertPackageListNode(Socket->SendList,Message,Socket->SendList->NowCount +1) != 0){ // 将本数据包存入发送缓冲区失败
return -1;
}
Socket->SendList->NowCount ++; // 发送缓冲区总计数自增加一
return ___LinkC_Send(Socket,Message,size,Flag);
}
int P2PAccept(int Sockfd, struct sockaddr_in Dest, void(*Function) (void*), void* Arg){
if(List != NULL){ // 如果链表为空
LinkC_Debug("P2PAccept: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = NULL;
if(IsSocketInList(Sockfd,&Socket)==0){
LinkC_Debug("P2PAccept: No Such Socket",LINKC_FAILURE);
return -1;
}
EmptyPackageList(Socket->RecvList); // 清空发送和接收缓冲区
EmptyPackageList(Socket->SendList);
SetDestAddr(Sockfd,Dest);
int Length = _LCUDP_Package(NULL,0,Socket,CONNECTION_MESSAGE,Socket->SendBuffer);
___LinkC_Send(Socket,Socket->SendBuffer,Length,MSG_DONTWAIT);
if(Function != NULL){ // 执行函数，这里是我发送了无用信息后向服务端确认
Function(Arg);
}
return 0;
}
int Accept(int Sockfd, struct sockaddr_in Dest){
if(List != NULL){ // 如果链表为空
LinkC_Debug("Accept:LinkC Socket环境没有初始化",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = NULL;
if(IsSocketInList(Sockfd,&Socket)==0){
LinkC_Debug("Accept:没有这个套接字",LINKC_FAILURE);
return -1;
}
EmptyPackageList(Socket->RecvList); // 清空发送和接收缓冲区
EmptyPackageList(Socket->SendList);
SetDestAddr(Sockfd,Dest);
LinkC_Debug("Accept:等待对方发起请求",LINKC_DEBUG);
_LinkC_Recv(Socket,Socket->RecvBuffer,512,0);
LinkC_Debug("Accept:已收到请求",LINKC_DEBUG);
int Length = _PackMessage(CONNECTION_MESSAGE,NULL,0,Socket,Socket->SendBuffer);
if(Length < 0){
LinkC_Debug("Accept:打包数据失败",LINKC_FAILURE);
return -1;
}
_LinkC_Send(Socket,Socket->SendBuffer,Length,0);
LinkC_Debug("Accept:已发出确认",LINKC_DEBUG);
return 0;
}
int Accept(int Sockfd, struct sockaddr_in Dest){
if(List != NULL){ // 如果链表为空
LinkC_Debug("Accept: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = NULL;
if(IsSocketInList(Sockfd,&Socket)==0){
LinkC_Debug("Accept: No Such Socket",LINKC_FAILURE);
return -1;
}
EmptyPackageList(Socket->RecvList); // 清空发送和接收缓冲区
EmptyPackageList(Socket->SendList);
SetDestAddr(Sockfd,Dest);
LinkC_Debug("Accept: Waiting for Request from Peer",LINKC_DEBUG);
_LinkC_Recv(Socket,Socket->RecvBuffer,512,0);
LinkC_Debug("Accept: Fetched Request",LINKC_DEBUG);
int Length = _LCUDP_Package(NULL,0,Socket,CONNECTION_MESSAGE,Socket->SendBuffer);
if(Length < 0){
LinkC_Debug("Accept: Data Packaging Failed",LINKC_FAILURE);
return -1;
}
_LinkC_Send(Socket,Socket->SendBuffer,Length,0);
LinkC_Debug("Accept: Confirmation Sent",LINKC_DEBUG);
return 0;
}
int CreateSocket(const struct sockaddr *MyAddr){
if(List != NULL){ // 如果链表为空
LinkC_Debug("CreateSocket: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
LinkC_Socket *Socket = (LinkC_Socket*)malloc(sizeof(LinkC_Socket)); // 为套接字结构体分配内存
Socket->Sockfd = socket(AF_INET,SOCK_DGRAM,0); // 创建UDP套接字
if(Socket->Sockfd < 0){ // 如果创建套接字失败
perror("Create LCUDP"); // 打印错误信息
free(Socket); // 释放内存
return 1; // 返回错误
}
/* 我也不知道这段是什么意思，不过大概就是说设置成在收到数据的时候发送一个信息这么回事 */
if(fcntl(Socket->Sockfd,F_SETOWN,getpid()) == -1){
perror("Set Own");
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1; // 返回错误
}
int flag = fcntl(Socket->Sockfd,F_GETFL,0); // 获得那啥FL?
if(flag == -1){ // 如果出错
perror("Get FL"); // 打印错误信息
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1; // 返回错误
}
if(fcntl(Socket->Sockfd,F_SETFL,flag | O_ASYNC) == -1){ // 如果设置成受到数据就发信号的那啥套接字失败
perror("Set FL"); // 打印错误信息
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1; // 返回错误
}
if (fcntl(Socket->Sockfd,F_SETSIG,SIGIO) == -1){
perror("fault");
}
if(bind(Socket->Sockfd,MyAddr,sizeof(struct sockaddr_in)) < 0){ // 绑定地址
perror("Bind LCUDP"); // 输出错误信息
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1;
}
Socket->Available = 0; // 将可用包数设置为0
Socket->SendList = BuildPackageList(); // 创建链表
Socket->RecvList = BuildPackageList(); // 创建链表
Socket->RecvBuffer = malloc(STD_BUFFER_SIZE); // 建立接收缓冲区
Socket->SendBuffer = malloc(STD_BUFFER_SIZE); // 建立发送缓冲区
AddSocketToList(Socket); // 将当前套接字加入到片轮列表
return Socket->Sockfd; // 返回创建的套接子
}
int _LinkC_Recv(LinkC_Socket *Socket, void *Message, size_t size, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("_LinkC_Recv: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
int Result=0;
if(Flag == MSG_DONTWAIT)
Result = sem_trywait(Socket->RecvList->Semaphore); // 非阻塞请求数据
else{
Result = sem_wait(Socket->RecvList->Semaphore); // 阻塞请求数据
}
if(Result < 0){
perror("Sem Wait[Trywait]");
return 0;
}
pthread_mutex_lock(Socket->RecvList->MutexLock); // 上互斥锁
if(Socket->RecvList->TotalNode <= 0){
printf("Error Occurred [file = %s\tline = %d]\n",__FILE__,__LINE__);
pthread_mutex_unlock(Socket->RecvList->MutexLock); // 解锁
return -1;
}
PackageListNode *Node = Socket->RecvList->StartNode;
while(Node->Next) Node = Node->Next; // 跳转到最后一个Node
if((Node->MessageLength)+(uint32_t)8 > size){
LinkC_Debug("_LinkC_Recv: Receive Buffer Too Small",LINKC_FAILURE);
sem_post(Socket->RecvList->Semaphore);
pthread_mutex_unlock(Socket->RecvList->MutexLock);
return -1;
}
memcpy(Message,Node->Package,Node->MessageLength+8);
if(Flag == MSG_PEEK){
pthread_mutex_unlock(Socket->RecvList->MutexLock);
sem_post(Socket->RecvList->Semaphore);
}else{
RemovePackageListNode(Socket->RecvList,((PackageHeader*)Message)->MessageCounts);
pthread_mutex_unlock(Socket->RecvList->MutexLock);
}
return ((PackageHeader*)Message)->MessageLength;
}
void TimerInt(int SigNo, siginfo_t* SigInfo , void* Arg){
if(!SigNo) perror("SigNo");
if(!SigInfo) perror("SigInfo");
if(!Arg) perror("Arg");
PackageListNode *PackNode = NULL; // 缓冲区链表节点指针
SocketListNode *Node = List->StartNode; // 赋值为开始节点
while(Node){ // 循环直到当前节点为空
if(Node->Socket->ErrorMessage != NULL){ // 如果错误信息不为空
LinkC_Debug(Node->Socket->ErrorMessage,LINKC_FAILURE);
free(Node->Socket->ErrorMessage); // 释放内存
Node->Socket->ErrorMessage = NULL; // 挂空指针
}
if(Node->Socket->SendList->TotalNode != 0){ // 如果发送链表中还有剩余[也就是收到确认没有到达]
pthread_mutex_lock(Node->Socket->SendList->MutexLock); // 给链表上锁上锁
PackNode = Node->Socket->SendList->StartNode; // 设置为链表开始节点
while(PackNode){
if(PackNode->ResendTime > MAX_RESEND_TIME){ // 如果大于最大重发次数
LinkC_Debug("TimerInt: Disconnected",LINKC_WARNING);
// 执行断线操作
}else if(PackNode->TimeToLive == 0){ // 在没有断线的情况下如果当前数据剩迟迟没有收到收到确认
LinkC_Debug("TimerInt: Data Resent",LINKC_DEBUG);
ResendMessage(Node->Socket,PackNode->Package ,MSG_DONTWAIT); // 重发消息
PackNode->TimeToLive = MAX_TIME_TO_LIVE; // 重设剩余生存时间
PackNode->ResendTime ++; // 重发次数自增加一
}else{
PackNode->TimeToLive --; // 剩余生存时间减一
}
PackNode = PackNode->Next; // 跳转到下一个节点
}
pthread_mutex_unlock(Node->Socket->SendList->MutexLock);// 给链表解锁
PackNode = NULL; // 挂空指针
}
Node = Node->Next;
}
alarm(1); // 1秒后发射信号
return;
}
int UnPackMessage(void* Message, LinkC_Socket *Socket, void* Output){
int Length = ((MessageHeader*)Message)->MessageLength; // 保存长度
if(Socket->IsSecurity == 1){ // 如果是安全套接字
int len = 0; // 临时长度
len = DecryptPackage((char *)Message+8,Length,Output,Socket->PrivateKey); // 解密
if(len < 0){ // 如果失败
LinkC_Debug("DecryptPackage",LINKC_FAILURE);
return -1;
}
return len; // 返回长度
}
memcpy((char*)Message+8,Output,Length);
return Length;
}
int ___LinkC_Send(LinkC_Socket *Socket, void *Message, size_t Length, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("___LinkC_Send: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
int Byte = 0;
sigset_t set;
sigemptyset(&set);
sigaddset(&set,SIGALRM);
sigprocmask(SIG_SETMASK,&set,NULL);
Byte = sendto(Socket->Sockfd, Message, Length, Flag, (struct sockaddr *)&(Socket->Addr),sizeof(struct sockaddr_in)); // 发送UDP数据报
sigprocmask(SIG_UNBLOCK,&set,NULL);
return Byte;
}
int ___LinkC_Recv(LinkC_Socket *Socket, void *Message, size_t size, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("___LinkC_Recv: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
int Byte = 0; // 保存本次接收的长度
size_t Length = 0; // 保存已经接收的长度
sigset_t set;
sigemptyset(&set);
sigaddset(&set,SIGALRM);
sigprocmask(SIG_SETMASK,&set,NULL);
while(1)
{
Byte = recvfrom(Socket->Sockfd,(char *)Message+Length,size-Length,Flag,(struct sockaddr*)&(Socket->Addr),&(Socket->SockLen)); // 接收数据
if(Byte < 0){ // recvfrom返回小于等于0 [1]没有数据 [2]链接关闭 [3]出错
perror("___LinkC_Recv"); // 打印错误信息
sigprocmask(SIG_UNBLOCK,&set,NULL);
return -1; // 返回出错
}else if(Byte == 0){
LinkC_Debug("___LinkC_Recv : Null Data Received",LINKC_WARNING);
sigprocmask(SIG_UNBLOCK,&set,NULL);
return Length; // 返回已经收到的数据长度
}
if(Flag == MSG_WAITALL){
Length += Byte; // 设置当前总计接收的数据长度
if(Length == size){ // 正好接收到要接收的数据的长度
break; // 跳出循环
}
}else{
sigprocmask(SIG_UNBLOCK,&set,NULL);
return Byte;
}
}
sigprocmask(SIG_UNBLOCK,&set,NULL);
return Length; // 返回成功
}
int IsSocketInList(int Sockfd, LinkC_Socket** Socket){
if(List != NULL){ // 如果链表为空
LinkC_Debug("IsSocketInList: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
SocketListNode *NowNode = List->StartNode; // 新建一个节点，指向链表的开始节点
while(NowNode){ // 循环[当前节点不为空]
if(NowNode->Socket->Sockfd == Sockfd){ // 如果当前Socket等于传入的Socket
*Socket = NowNode->Socket;
return 1; // 返回找到
}
NowNode = NowNode->Next; // 设置为下一个节点
}
Socket = NULL;
return 0; // 返回未找到
}
int ResendMessage(LinkC_Socket *Socket, void *Message, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("ResendMessage: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
if(Socket == NULL){ // 如果参数为空
printf("Argument is NULL!\n"); // 打印出错信息
return -1; // 返回错误
}
int Byte = 0; // 保存发送状态
((PackageHeader*)Message)->MessageType = RESEND_MESSAGE; //
Byte = ___LinkC_Send(Socket,Message,((PackageHeader*)Message)->MessageLength,Flag); // 发送消息
if(Byte < 0){
perror("___LinkC_Send");
return -1;
}
return Byte;
}
int SetDestAddr(int Socket, struct sockaddr_in DestAddr){
if(List != NULL){ // 如果链表为空
LinkC_Debug("SetDestAddr: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
SocketListNode *Node = List->StartNode;
while(Node){
if(Node->Socket->Sockfd == Socket){
pthread_mutex_lock(Node->Mutex_Lock);
memcpy((void*)&(Node->Socket->Addr),(void *)&DestAddr,sizeof(struct sockaddr_in));
if(Node->Socket->IsSecurity == 1){
RSA_free(Node->Socket->PublicKey);
RSA_free(Node->Socket->PrivateKey);
Node->Socket->IsSecurity = 0;
}
pthread_mutex_unlock(Node->Mutex_Lock);
return 0;
}
Node = Node->Next;
}
return -1;
}
int ReplyData (UserData* User,int Sockfd,uint8_t Request, RequestUser* Dest){
int Length;
void *Buffer = malloc(sizeof(MessageHeader)+sizeof(UserData));
void *Package =malloc(STD_PACKAGE_SIZE);
bzero(Buffer,sizeof(MessageHeader)+sizeof(UserData));
bzero(Package,STD_PACKAGE_SIZE);
if(Request == SELF_DATA){
LinkC_Debug("Self Data",LINKC_DEBUG);
if(GetUserData(User->UID,User->UID,User) == LINKC_FAILURE){
LinkC_Debug("Accessing Databse [1]",LINKC_FAILURE);
SendActionStatus(Sockfd,GET_DATA_FAILURE);
goto RETURN_FAILURE;
}
memcpy((char*)Buffer+sizeof(MessageHeader),(void*)User,sizeof(UserData));
((MessageHeader*)Buffer)->ActionType = RETURN_DATA|SELF_DATA;
((MessageHeader*)Buffer)->StatusCode = htons(GET_DATA_SUCCESS);
Length = _Package(Buffer,sizeof(MessageHeader)+sizeof(UserData),NORMAL_MESSAGE,Package);
send(Sockfd,Package,Length,0);
User->UID = (ntohl(User->UID));
goto RETURN_SUCCESS;
}else if(Request == USER_DATA){
LinkC_Debug("User Data",LINKC_DEBUG);
LinkC_Debug("..",LINKC_DEBUG);
if(Dest->UID == 0){ // 获得全部好友数据
UserData* Friends = NULL;
int Count = GetFriendsData(User->UID,&Friends);
if(Count == LINKC_FAILURE){
LinkC_Debug("Fetching Friend Data",LINKC_FAILURE);
goto RETURN_FAILURE;
}else if(Count == 0){
LinkC_Debug("No Friend Data Available",LINKC_DEBUG);
SendActionStatus(Sockfd,NO_DATA);
goto RETURN_SUCCESS;
}
free(Package);
free(Buffer);
Buffer = malloc(sizeof(MessageHeader)+Count*sizeof(UserData));
Package = malloc(sizeof(PackageHeader)+sizeof(MessageHeader)+Count*sizeof(UserData));
((MessageHeader*)Buffer)->ActionType = RETURN_DATA|FRIENDS_DATA;
((MessageHeader*)Buffer)->StatusCode = htons(GET_DATA_SUCCESS);
memcpy((char*)Buffer+sizeof(MessageHeader),Friends,Count*sizeof(UserData));
Length = _Package(Buffer,sizeof(MessageHeader)+Count*sizeof(UserData),NORMAL_MESSAGE,Package);
send(Sockfd,Package,Length,0);
goto RETURN_SUCCESS;
}else{
if(GetUserData(User->UID,ntohl(Dest->UID),(UserData*)(char*)Buffer+sizeof(MessageHeader)) == LINKC_FAILURE){
LinkC_Debug("Accessing Database [2]",LINKC_FAILURE);
SendActionStatus(Sockfd,GET_DATA_FAILURE);
goto RETURN_FAILURE;
}
((MessageHeader*)Buffer)->ActionType = RETURN_DATA|USER_DATA;
((MessageHeader*)Buffer)->StatusCode = htons(GET_DATA_SUCCESS);
Length = _Package(Buffer,sizeof(MessageHeader)+sizeof(UserData),NORMAL_MESSAGE,Package);
send(Sockfd,Package,Length,0);
goto RETURN_SUCCESS;
}
goto RETURN_FAILURE;
}else{
LinkC_Debug("Data Returns: Operation Not Supported",LINKC_WARNING);
goto RETURN_FAILURE;
}
RETURN_SUCCESS:
free(Buffer);
free(Package);
Buffer = NULL;
Package = NULL;
return LINKC_SUCCESS;
RETURN_FAILURE:
free(Buffer);
free(Package);
Buffer = NULL;
Package = NULL;
return LINKC_FAILURE;
}
LoginWindow::~LoginWindow(){
LinkC_Debug("Login_Window\t= [EXITED]");
}
int AddSocketToList(int Sockfd){
if(List != NULL){ // 如果链表为空
LinkC_Debug("AddSocketToList:LinkC Socket环境没有初始化",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
if(IsSocketInList(Sockfd,NULL) == 1){ // 当前Socket是否已经存在于链表中，如果存在
LinkC_Debug("AddSocketToList:重复添加",LINKC_FAILURE);
return 1;
}
LinkC_Socket *Socket = (LinkC_Socket*)malloc(sizeof(LinkC_Socket));
if(fcntl(Socket->Sockfd,F_SETOWN,getpid()) == -1){
perror("Set Own");
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1; // 返回错误
}
int flag = fcntl(Socket->Sockfd,F_GETFL,0); // 获得那啥FL?
if(flag == -1){ // 如果出错
perror("Get FL"); // 打印错误信息
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1; // 返回错误
}
if(fcntl(Socket->Sockfd,F_SETFL,flag | O_ASYNC) == -1){ // 如果设置成受到数据就发信号的那啥套接字失败
perror("Set FL"); // 打印错误信息
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1; // 返回错误
}
if (fcntl(Socket->Sockfd,F_SETSIG,SIGIO) == -1){
perror("fault");
}
/*if(bind(Socket->Sockfd,MyAddr,sizeof(struct sockaddr_in)) < 0){ // 绑定地址
perror("Bind LCUDP"); // 输出错误信息
close(Socket->Sockfd); // 关闭套接字
free(Socket); // 释放内存
return 1;
}*/
Socket->Available = 0; // 将可用包数设置为0
Socket->SendList = BuildPackageList(); // 创建链表
Socket->RecvList = BuildPackageList(); // 创建链表
Socket->RecvBuffer = malloc(STD_BUFFER_SIZE); // 建立接收缓冲区
Socket->SendBuffer = malloc(STD_BUFFER_SIZE); // 建立发送缓冲区
SocketListNode* Node;
Node = (SocketListNode*)malloc(sizeof(SocketListNode)); // 分配内存
Node->Mutex_Lock= (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(Node->Mutex_Lock,NULL);
Node->Socket = Socket; // 保存当前新建的Socket
if(List->TotalSocket == 0){ // 如果现在还没有Socket
List->StartNode = Node; // 将当前节点设置为开始节点
Node->Perv = NULL; // 当前节点的前一个节点挂空
Node->Next = NULL; // 当前节点的后一个节点挂空
}else{
Node->Next = List->StartNode; // 新建节点的下一个设置成现在的起始节点
Node->Perv = NULL; // 当前节点的前一个节点挂空
List->StartNode->Perv = Node; // 链表起始节点的前一个为新建节点
List->StartNode = Node; // 链表起始节点为当前节点
}
List->TotalSocket++; // Socket总数加一
return 0; // 返回函数
}
int __LinkC_Recv(LinkC_Socket *Socket, void *Message, size_t size, int Flag){
if(List != NULL){ // 如果链表为空
LinkC_Debug("__LinkC_Recv: LinkC Socket Environment Not Initialized",LINKC_FAILURE);
return LINKC_FAILURE; // 返回错误
}
int Byte;
if(size < 8){
LinkC_Debug("__LinkC_Recv: Receive Buffer Too Small",LINKC_FAILURE);
return LINKC_FAILURE;
}
Byte = ___LinkC_Recv(Socket,Message,8,MSG_PEEK);
if(Byte < 8){ // recvfrom返回收到数据长度小于8[出错或者无数据]
if(Byte == 0){ // recvfrom返回收到数据长度为0[断开链接或者无数据]
LinkC_Debug("__LinkC_Recv: No Data Received",LINKC_WARNING);
return 0; // 返回0
}else if(Byte < 0){ // recvfrom返回负数[出错]
LinkC_Debug("__LinkC_Recv: Error",LINKC_FAILURE);
perror("__LinkC_Recv"); // 打印错误细信息
return -1; // 返回错误
}else{ // recvfrom返回收到数据长度介于0到8之间[残缺数据包，舍弃]
LinkC_Debug("__LinkC_Recv: No Correct Data Received",LINKC_WARNING);
return -1; // 返回错误
}
}else{ // recvfrom返回收到数据长度为8[可能为一个消息头]
uint16_t Length = ((PackageHeader*)Message)->MessageLength + 8;
if(((PackageHeader*)Message)->ProtocolVersion != PROTOCOL_VERSION){ // 如果协议版本号不一致
printf("Version = %d\nMy Version = %d\n",((PackageHeader*)Message)->ProtocolVersion,PROTOCOL_VERSION);
LinkC_Debug("Protocol Version Mismatch",LINKC_WARNING);
return -1; // 返回错误
}
if(((PackageHeader*)Message)->MessageType == HEART_BEATS){ // 若是心跳包
return 0; // 直接返回[忽略]
}else if(((PackageHeader*)Message)->MessageType == RESEND_MESSAGE){ // 若是重发的数据包
if(___LinkC_Recv(Socket,(char *)Message,Length,Flag) < 0){ // 如果接收剩余数据失败
LinkC_Debug("__LinkC_Recv",LINKC_FAILURE);
AskForResend(Socket,((PackageHeader*)Message)->MessageCounts); // 请求重发
return -1; // 返回无数据
}
ConfirmRecved(Socket,((PackageHeader*)Message)->MessageCounts); // 发送确认收到消息
InsertPackageListNode(Socket->SendList,Message,((PackageHeader*)Message)->MessageCounts); // 插入已经收到的消息
}else if(((PackageHeader*)Message)->MessageType == SSL_KEY_MESSAGE){ // 如果是SSL密钥
if(___LinkC_Recv(Socket,(char *)Message,Length,Flag) < 0){ // 如果接收剩余数据失败
LinkC_Debug("__LinkC_Recv: Error",LINKC_FAILURE);
AskForResend(Socket,((PackageHeader*)Message)->MessageCounts); // 请求重发
return 0; // 返回无数据
}
ConfirmRecved(Socket,((PackageHeader*)Message)->MessageCounts); // 发送确认收到消息
// 保存密钥
}else if(((PackageHeader*)Message)->MessageType == CONFIRMATION_MESSAGE){
if(___LinkC_Recv(Socket,Message,Length,Flag) < 0){ // 如果接收剩余数据失败
LinkC_Debug("__LinkC_Recv: Error",LINKC_FAILURE);
AskForResend(Socket,((PackageHeader*)Message)->MessageCounts); // 请求重发
return 0; // 返回无数据
}
if(((ConfirmationMessage*)(((char *)Message)+8))->isRecved == 0){ // 如果说对面没有收到指定数据包
PackageListNode *Node = Socket->SendList->StartNode;
while(Node){
if(Node->Count == ((ConfirmationMessage*)((char*)Message)+8)->Count){
int result = ResendMessage(Socket,Node->Package,MSG_DONTWAIT);
if(result != 0){
Node = NULL;
return -1;
}else{
Node->TimeToLive = MAX_TIME_TO_LIVE;
Node->ResendTime++;
Node = NULL;
return 0;
}
}
Node = Node->Next;
}
LinkC_Debug("__LinkC_Recv: Resent Data",LINKC_FAILURE);
Node = NULL;
return -1;
}else{ // 如果对面收到了这个数据包
pthread_mutex_lock(Socket->RecvList->MutexLock);
RemovePackageListNode(Socket->SendList,((ConfirmationMessage*)(((char *)Message)+8))->Count);
pthread_mutex_unlock(Socket->RecvList->MutexLock);
return 0;
}
}else if(((PackageHeader*)Message)->MessageType == NORMAL_MESSAGE){ // 如果是普通数据
if(___LinkC_Recv(Socket,(char *)Message,Length,Flag) <= 0){ // 如果接收剩余数据失败
LinkC_Debug("__LinkC_Recv",LINKC_FAILURE);
AskForResend(Socket,((PackageHeader*)Message)->MessageCounts); // 请求重发
return 0; // 返回无数据
}
ConfirmRecved(Socket,((PackageHeader*)Message)->MessageCounts); // 发送确认收到消息
InsertPackageListNode(Socket->RecvList,Message,((PackageHeader*)Message)->MessageCounts); // 插入已经收到的消息
}else if(((PackageHeader*)Message)->MessageType == CONNECTION_MESSAGE){
if(___LinkC_Recv(Socket,(char *)Message,Length,Flag) <= 0){ // 如果接收剩余数据失败
LinkC_Debug("__LinkC_Recv",LINKC_FAILURE);
AskForResend(Socket,((PackageHeader*)Message)->MessageCounts); // 请求重发
return 0; // 返回无数据
}
ConfirmRecved(Socket,((PackageHeader*)Message)->MessageCounts); // 发送确认收到消息
InsertPackageListNode(Socket->RecvList,Message,((PackageHeader*)Message)->MessageCounts); // 插入已经收到的消息
}else{
LinkC_Debug("__LinkC_Recv: Cannot Identify Message Head",LINKC_WARNING);
return 0;
}
}
return Byte;
}
