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; }