封裝tcp類，
1 //封裝tcpsocket類實現tcp通信的基本操作
2 #include <iostream>
3 #include <stdio.h>
4 #include <errno.h>
5 #include <netinet/in.h>
6 #include <sys/types.h>
7 #include <unistd.h>
8 #include <sys/socket.h>
9 #include <stdlib.h>
10 #include <arpa/inet.h>
11 #include <string.h>
12
13
14
15 class TcpSocket {
16 public:
17 TcpSocket():_sock(-1){}
18 ~TcpSocket(){}
19 void SetSock(int sock) {
20 _sock = sock;
21 }
22 int Getsock() {
23 return _sock;
24 }
25 bool Socket() {
26 //int socket(int domain, int type, int protocol)；
27 _sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
28 if(_sock < 0) {
29 perror("socket error");
30 return false;
31 }
32 return true;
33 }
34 bool Bind(std::string &ip,uint16_t port) {
35 //int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
36 struct sockaddr_in addr;
37 addr.sin_family = AF_INET;
38 addr.sin_port = htons(port);
39 addr.sin_addr.s_addr = inet_addr(ip.c_str());
40 socklen_t len = sizeof(struct sockaddr_in);
41 int ret = bind(_sock,(struct sockaddr*)&addr,len);
42 if(ret < 0) {
43 perror("bind error");
44 return false;
45 }
46 return true;
47 }
48 bool Listen(int num) {
49 //int listen(int sockfd, int backlog);
50 int ret = listen(_sock,num);
51 if(ret < 0) {
52 perror("listen error");
53 return false;
54 }
55 return true;
56 }
57 bool Connect(std::string &ip,uint16_t port) {
58 //int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
59 sockaddr_in addr;
60 addr.sin_family = AF_INET;
61 addr.sin_port = htons(port);
62 addr.sin_addr.s_addr = inet_addr(ip.c_str());
63 socklen_t len = sizeof(struct sockaddr_in);
64 int ret = connect(_sock,(struct sockaddr*)&addr,len);
65 if(ret < 0) {
66 perror("connect error");
67 return false;
68 }
69 return true;
70 }
71 bool Accept(TcpSocket &csock, struct sockaddr_in *addr = NULL) {
72 //int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
73 sockaddr_in _addr;
74 socklen_t len = sizeof(struct sockaddr_in);
75 int new_sock = accept(_sock,(struct sockaddr*)&_addr,&len);
76 if(new_sock < 0) {
77 perror("accept error");
78 return false;
79 }
80 if(addr != NULL) {
81 memcpy(addr, &_addr, len);
82 }
83 csock.SetSock(new_sock);
84 return true;
85 }
86 bool Recv(std::string &buf) {
87 char temp[1024*10] = {0};
88 //ssize_t recv(int sockfd, void *buf, size_t len, int flags);
89 ssize_t read_size = recv(_sock,temp,sizeof(temp),0);
90 if(read_size < 0) {
91 perror("recv error");
92 return false;
93 }
94 if(read_size == 0) {
95 return false;
96 }
97 buf.assign(temp,read_size);
98 return true;
99 }
100 bool Send(std::string &buf) {
101 //ssize_t send(int sockfd, const void *buf, size_t len, int flags);
102 ssize_t write_size = send(_sock,buf.data(),buf.size(),0);
103 if(write_size < 0) {
104 perror("write error");
105 return false;
106 }
107 return true;
108 }
109 bool Close() {
110 close(_sock);
111 _sock = -1;
112 }
113 private:
114 int _sock;
115 };
客戶端：
1 //客戶端
2 #include <iostream>
3 #include "tcp_socket.hpp"
4 #define CHECK_RET(q) if((q) == false) {return -1;}
5
6 int main(int argc, char *argv[])
7 {
8 if (argc != 3 ) {
9 std::cout<<"./tcp_cli ip port\n";
10 return -1;
11 }
12 std::string ip = argv[1];
13 uint16_t port = atoi(argv[2]);
14
15 TcpSocket sock;
16 CHECK_RET(sock.Socket());
17 CHECK_RET(sock.Connect(ip, port));
18
19 while(1) {
20 std::string buf;
21 std::cout<<"client say:";
22 fflush(stdout);
23 std::cin>>buf;
24 sock.Send(buf);
25
26 buf.clear();
27 sock.Recv(buf);
28 std::cout<<"server say:"<<buf<<std::endl;
29 }
30 sock.Close();
31 return 0;
32 }
33
多進程版本的服務端代碼：
1 //進程版本的tcp服務器
2 #include "tcp_socket.hpp"
3 #include <sys/wait.h>
4
5 #define CHECK_RET(q) if((q) == false) {return -1;}
6 void sigcb(int no) {
7 while (waitpid(-1, NULL, WNOHANG) > 0);
8 }
9
10 int main(int argc,char* argv[])
11 {
12 if(argc != 3) {
13 printf("./tcp_sock ip port");
14 return -1;
15 }
16 signal(SIGCHLD,sigcb);
17 std::string ip = argv[1];
18 uint16_t port = atoi(argv[2]);
19 TcpSocket sock;
20 CHECK_RET(sock.Socket());
21 CHECK_RET(sock.Bind(ip,port));
22 CHECK_RET(sock.Listen(5));
23 while(1) {
24 TcpSocket clisock;
25 struct sockaddr_in cliaddr;
26 if(sock.Accept(clisock,&cliaddr) == false) {
27 continue;
28 }
29 int pid = fork();
30 if(pid == 0) {
31 while(1) {
32 std::string buf;
33 clisock.Recv(buf);
34 printf("client say:%s\n", buf.c_str());
35
36 buf.clear();
37 std::cout << "server say:";
38 fflush(stdout);
39 std::cin >> buf;
40 clisock.Send(buf);
41 }
42 }
43 clisock.Close();
44 }
45 sock.Close();
46
47 return 0;
48 }
多線程版本的服務端代碼：
1 //線程版本的tcp服務器
2
3 #include "tcp_socket.hpp"
4 #include <pthread.h>
5 #define CHECK_RET(q) if((q) == false) {return -1;}
6
7 void *thr_start(void *arg) {
8 TcpSocket *sock = (TcpSocket*)arg;
9 while(1) {
10 std::string buf;
11 sock->Recv(buf);
12 printf("client say:%s\n", buf.c_str());
13
14 buf.clear();
15 std::cout << "server say:";
16 fflush(stdout);
17 std::cin >> buf;
18 sock->Send(buf);
19 }
20 sock->Close();
21 delete sock;
22 return NULL;
23 }
24
25
26 int main(int argc,char* argv[])
27 {
28 if(argc != 3) {
29 printf("./tcp_sock ip port");
30 return -1;
31 }
32 std::string ip = argv[1];
33 uint16_t port = atoi(argv[2]);
34 TcpSocket sock;
35 CHECK_RET(sock.Socket());
36 CHECK_RET(sock.Bind(ip,port));
37 CHECK_RET(sock.Listen(5));
38 while(1) {
39 TcpSocket *clisock = new TcpSocket();
40 struct sockaddr_in cliaddr;
41 if(sock.Accept(*clisock,&cliaddr) == false) {
42 continue;
43 }
44 pthread_t tid;
45 pthread_create(&tid,NULL,thr_start,(void*)clisock);
46 pthread_detach(tid);
47 }
48 sock.Close();
49 return 0;
50 }
封裝udp類：
1 //封裝一個udpsocket類實現udp的通信，
2 #include <iostream>
3 #include <sys/socket.h>
4 #include <sys/types.h>
5 #include <errno.h>
6 #include <stdio.h>
7 #include <arpa/inet.h>
8 #include <netinet/in.h>
9 #include <unistd.h>
10 #include <stdlib.h>
11
12 class UdpSocket {
13 public:
14 UdpSocket():_sock(-1) {}
15 ~UdpSocket(){}
16 bool Socket() {
17 //int socket(int domain, int type, int protocol);
18 _sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
19 if(_sock < 0) {
20 perror("socket error");
21 return false;
22 }
23 return true;
24 }
25 bool Bind(std::string &ip, uint16_t port) {
26 //int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
27 struct sockaddr_in addr;
28 addr.sin_family = AF_INET;
29 addr.sin_port = htons(port);
30 addr.sin_addr.s_addr = inet_addr(ip.c_str());
31 socklen_t len = sizeof(struct sockaddr_in);
32 int ret = bind(_sock,(struct sockaddr*)&addr,len);
33 if(ret < 0) {
34 perror("bind error");
35 return false;
36 }
37 return true;
38 }
39 bool Recv(std::string &buf,struct sockaddr_in *saddr) {
40 char temp[1500] = {0};
41 socklen_t len = sizeof(struct sockaddr_in);
42 //ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
43 // struct sockaddr *src_addr, socklen_t *addrlen);
44 int ret = recvfrom(_sock,temp,1500,0,(struct sockaddr*)saddr,&len);
45 if(ret < 0) {
46 perror("recv error");
47 return false;
48 }
49 buf.assign(temp,ret);
50 return true;
51 }
52 bool Sendto(std::string &buf,struct sockaddr_in *daddr) {
53 socklen_t len = sizeof(struct sockaddr_in);
54 int ret = sendto(_sock,buf.c_str(),buf.size(),0,(struct sockaddr*)daddr,len);
55 if(ret < 0) {
56 perror("sendto error");
57 return false;
58 }
59 return true;
60 }
61 bool Close() {
62 close(_sock);
63 _sock = -1;
64 }
65 private:
66 int _sock;
67 };
服務端代碼：
1 //服務端程序
2
3 #include "udp_socket.h"
4 #define CHECK_RET(q) if((q)==false){return -1;}
5
6 int main(int argc,char* argv[])
7 {
8 if(argc != 3) {
9 printf("./srv_udpsocket ip port");
10 return -1;
11 }
12 std::string ip = argv[1];
13 uint16_t port = atoi(argv[2]);
14 UdpSocket sock;
15 CHECK_RET(sock.Socket());
16 CHECK_RET(sock.Bind(ip,port));
17 while(1) {
18 std::string buf;
19 struct sockaddr_in cli_addr;
20 CHECK_RET(sock.Recv(buf,&cli_addr));
21 std::cout << "client say:" << buf << std::endl;
22
23 std::cout << "server say:";
24 fflush(stdout);
25 std::cin>>buf;
26 CHECK_RET(sock.Sendto(buf,&cli_addr));
27 }
28 sock.Close();
29 return 0;
30 }
客戶端代碼：
1 //客戶端
2 #include "udp_socket.h"
3 #define CHECK_RET(q) if((q) == false){return -1;}
4
5 int main(int argc,char* argv[])
6 {
7 if(argc != 3) {
8 printf("./cli_udpsocket ip port");
9 return -1;
10 }
11 std::string ip = argv[1];
12 uint16_t port = atoi(argv[2]);
13
14 UdpSocket sock;
15 CHECK_RET(sock.Socket());
16 struct sockaddr_in srv_addr;
17 srv_addr.sin_family = AF_INET;
18 srv_addr.sin_port = htons(port);
19 srv_addr.sin_addr.s_addr = inet_addr(ip.c_str());
20 while(1) {
21 std::string buf;
22 std::cout << "client say:";
23 fflush(stdout);
24 std::cin >> buf;
25 CHECK_RET(sock.Sendto(buf,&srv_addr));
26
27 CHECK_RET(sock.Recv(buf,&srv_addr));
28 std::cout << "server say:" << buf << std::endl;
29 }
30
31 sock.Close();
32 return 0;
33 }