socket方式就是基于C/S方式的,不知你的C-C通信的意义是什么?当然你也可以使用UDP,数据安全性由自己的程序解决。

解决方案 »

  1.   

    服务器转发,就是多一些逻辑,收到A客户端,转发给B客户端而已
    //tcpserver.cc  
        #include <iostream>  
        #include <cstring>  
        #include <strings.h>  
        #include <stdlib.h>  
        #include <sys/socket.h>  
        #include <netinet/in.h>  
        #include <arpa/inet.h>  
        using namespace std;  
            
        int main(int argc, char *argv[])  
        {  
            //创建套接字  
            int sk = socket(AF_INET, SOCK_STREAM, 0);  
            
            struct sockaddr_in server;  
            bzero(&server, sizeof(server));  
            server.sin_family = AF_INET;  
            server.sin_port = htons(atoi(argv[1]));  
            server.sin_addr.s_addr = htonl(INADDR_ANY);  
            //端口绑定  
            bind(sk, (struct sockaddr*)&server, sizeof(server));  
            
            //监听  
            listen(sk, 5);  
            
            struct sockaddr_in client;  
            bzero(&client, sizeof(client));  
            size_t len = sizeof(client);  
            //接受连接请求  
            int talk = accept(sk, (struct sockaddr*)&client, &len);  
            
            //发送数据  
            send(talk, "Hello", strlen("Hello") + 1, 0);  
            //接收数据  
            char buff[1024] = {'\0'};  
            recv(talk, buff, sizeof(buff), 0);  
            cout << buff << endl;  
            
            //关闭套接字  
            close(talk);  
            close(sk);  
            return 0;  
        }  
      
      
      
        //tcpclient.cc  
        #include <iostream>  
        #include <cstring>  
        #include <strings.h>  
        #include <stdlib.h>  
        #include <sys/socket.h>  
        #include <arpa/inet.h>  
        #include <netinet/in.h>  
        using namespace std;  
            
        int main(int argc, char *argv[])  
        {  
            //创建套接字  
            int sk = socket(AF_INET, SOCK_STREAM, 0);  
            
            struct sockaddr_in server;  
            server.sin_family = AF_INET;  
            server.sin_port = htons(atoi(argv[2]));  
            server.sin_addr.s_addr = inet_addr(argv[1]);  
            //连接服务器  
            connect(sk, (struct sockaddr*)&server, sizeof(server));  
            
            char buff[1024] = {'\0'};  
            //接收数据  
            recv(sk, buff, sizeof(buff), 0);  
            cout << buff << endl;  
            //发送数据  
            send(sk, "I am hahaya", strlen("I am hahaya") + 1, 0);  
            
            //关闭套接字  
            close(sk);  
            return 0;  
            
            
        }  tcpclient:
       
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    #include <string.h>
       
    #define HOST_PORT               10000
    int main()
    {
        WORD wVersionRequested;
        WSADATA wsaData;
        int err;
       
        wVersionRequested = MAKEWORD( 2, 2 );
       
        err = WSAStartup( wVersionRequested, &wsaData );
        if ( err != 0 )
        {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            return;
        }
       
        /* Confirm that the WinSock DLL supports 2.2.*/
        /* Note that if the DLL supports versions greater    */
        /* than 2.2 in addition to 2.2, it will still return */
        /* 2.2 in wVersion since that is the version we      */
        /* requested.                                        */
       
        if ( LOBYTE( wsaData.wVersion ) != 2 ||
                HIBYTE( wsaData.wVersion ) != 2 )
        {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup( );
            return;
        }
        int clientfd = socket(AF_INET, SOCK_STREAM, 0);
        if(clientfd < 0)
        {
            printf("client create socket failed.\n");
            return 0;
        }
        int on = 1;
        if(setsockopt(clientfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)) < 0)
        {
            printf("set socket option failed.\n");
            return 0;
        }
        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));
       
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(HOST_PORT);
        servaddr.sin_addr.S_un.S_addr = inet_addr("192.168.1.56");
       
        char buf[BUFSIZ];
        memset(buf,0,BUFSIZ);
        strncpy(buf,"shawn's client",14);
        //buf[BUFSIZ] = '\0';
       
        if(connect(clientfd,(const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        {
            printf("%d\n",errno);
            return 0;
        }
        int index = 0;
        for(index = 0; index < 5; index++)
        {
            send(clientfd,buf,strlen(buf) + 1, 0);
            _sleep(10);
        }
       
        memset(buf,0,BUFSIZ);
        strcpy(buf,"end");
        send(clientfd,buf,strlen(buf) + 1, 0);
        closesocket(clientfd);
       
        getchar();
        return 0;
    }
    tcpserver.c:
       
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
       
    #define MAX_LISTEN_QUEUE_NUMBER                 10
    #define HOST_PORT                               10000
    #define MAX_PACKET_LENGTH                       1400
    int main()
    {
        WORD wVersionRequested;
        WSADATA wsaData;
        int err;
       
        wVersionRequested = MAKEWORD( 2, 2 );
       
        err = WSAStartup( wVersionRequested, &wsaData );
        if ( err != 0 )
        {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            return 0;
        }
       
        /* Confirm that the WinSock DLL supports 2.2.*/
        /* Note that if the DLL supports versions greater    */
        /* than 2.2 in addition to 2.2, it will still return */
        /* 2.2 in wVersion since that is the version we      */
        /* requested.                                        */
       
        if ( LOBYTE( wsaData.wVersion ) != 2 ||
                HIBYTE( wsaData.wVersion ) != 2 )
        {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup( );
            return 0;
        }
       
        int servfd, clientfd;
        servfd = socket(AF_INET, SOCK_STREAM, 0);
        if(servfd < 0)
        {
            printf("server create socket failed.\n");
            return 0;
        }
        int on = 1;
        if(setsockopt(servfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)) < 0)
        {
            printf("set socket option failed.\n");
            return 0;
        }
        struct sockaddr_in servaddr;
        struct sockaddr_in clientaddr;
       
        memset(&servaddr,0,sizeof(servaddr));
        memset(&clientaddr,0,sizeof(clientaddr));
       
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(HOST_PORT);
        servaddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
        if(bind(servfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        {
            printf("bind failed.\n");
            return 0;
        }
        if(listen(servfd,10) < 0)
        {
            printf("listen failed.\n");
            return 0;
        }
        char buf[MAX_PACKET_LENGTH];
        memset(buf,0,MAX_PACKET_LENGTH);
        int length = sizeof(clientaddr);
       
        int clientRecord[FD_SETSIZE];
        int index = 0;
        for(; index < FD_SETSIZE; index++)
            clientRecord[index] = -1;
        fd_set readSet;
        FD_ZERO(&readSet);
        FD_SET(servfd,&readSet);
        int maxfd = servfd;
       
        for(;;)
        {
            struct timeval time;
            time.tv_sec = 10;
            time.tv_usec = 0;
            if(select(maxfd,&readSet,NULL,NULL,&time) <= 0)
                continue;
            if(FD_ISSET(servfd,&readSet))
            {
                clientfd = accept(servfd, (struct sockaddr *)&clientaddr,&length);
       
                for(index = 0; index < FD_SETSIZE; index++)
                {
                    if(clientRecord[index] < 0)
                    {
                        clientRecord[index] = clientfd;
                        break;
                    }
                }
                if(index == FD_SETSIZE)
                {
                    printf("too many sockets.\n");
                    break;
                }
            }
            for(index = 0; index < FD_SETSIZE; index++)
            {
                if(clientRecord[index] > 0)
                {
                    FD_SET(clientRecord[index],&readSet);
                    maxfd = maxfd > clientRecord[index] ? maxfd : clientRecord[index];
                }
                else
                    break;
            }
       
            int sockfd;
       
            for(index = 0; index < FD_SETSIZE; index++)
            {
                if((sockfd = clientRecord[index]) < 0)
                    continue;
                if(FD_ISSET(sockfd,&readSet))
                {
                    while(1)
                    {
                        recv(sockfd,buf,MAX_PACKET_LENGTH,0);
                        printf("%s\n",buf);
                        if(strcmp(buf,"end") == 0)
                            break;
                    }
                    closesocket(sockfd);
                    clientRecord[index] = -1;
                }
            }
        }
        closesocket(servfd);
        return 0;
    }
      

  2.   

    socket方式就是基于C/S方式的,不知你的C-C通信的意义是什么?当然你也可以使用UDP,数据安全性由自己的程序解决。
    我在做一个聊天室设计, 用C++ Winsock, 客户端和客户端可以对话, 但是要通过服务器转发, 服务器提供管理客户端用户功能, 现在不知道怎么转发。谢谢你的提示,我就是用UDP的。
      

  3.   

    Quote: 引用 5 楼 xihu1364 的回复:

    服务器转发,就是多一些逻辑,收到A客户端,转发给B客户端而已
    目的是这样的,但是我不知道怎么设计代码谢谢!
      

  4.   

    有兴趣可在此下载例程: http://download.csdn.net/download/wxhxj0268/4448841