一常用数据结构
1 SOCKET
typedef u_int SOCKET
其实就是一个无符号的整数,是一个socket描述符,我的理解就是 ,指向系统内核的”指针”,但这个”指针”要靠系统维护,我们只能获取,还要负责释放.
2 SOCKADDR_IN
struct sockaddr_in{
short sin_family;
unsigned short sin_port;
IN_ADDR sin_addr;
char sin_zero[8];
};用来指定本地或远程的地址,以此来进行socket连接
sin_family:指定为AF_INET
sin_port: 指定所连接的端口号,用htons将short的端口号进行转换,如htons(6000)
sin_addr:指定所连接的ip,用inet_addr装换,如inet_addr(“127.0.0.1”)
sin_zero:为了和SOCKADDR的大小相同,而进行的填充,应该将其初始化为0
二 常用函数
1 WSAStartup
原型:
int WSAStartup(WORD wVersionRequested,LPWSADATA lpWSAData)
作用:
用来初始化ws2_32.lib
返回值:
成功返回0
2 WSACleanup
终止ws2_32.lib
3 socket
原型:
SOCKET socket (int af, int type, int protocol );
参数说明
af:指定地址家族,AF_INET
type: SOCK_STREAM或SOCK_DGRAM,前者用于TCP,后者用于UDP
protocol:设置为0即可
作用:
创建一个SOCKET
返回值
创建失败返回INVALID_SOCKET
4 bind
原型:
int bind( SOCKET s, const struct sockaddr FAR *name,int namelen );
参数说明
s:server端已经创建好的SOCKET
name:server的SOCKADDR_IN结构,需要做强制类型转换,注意,他和SOCKADDR的大小一样
namelen:顾名思义,name的size大小,注意他和SOCKADDR的大小一样
作用
将SOCKET绑定到机器上
返回值
成功返回0,错误返回SOCKET_ERROR
5 listen
原型
int listen( SOCKET s, int backlog );
参数说明
s: 服务端未连接的SOCKET
backlog:最大可连接数
作用
设置tcp服务端
返回值
成功返回0,失败返回SOCKET_ERROR
6 accept
原型
SOCKET accept( SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen);
参数说明
s:tcp服务端的SOCKET
addr:远程客户端的地址信息
addlen:addr的size
作用
从已经获得许可的连接中关联一个新的SOCKET
返回值
成功返回新的SOCKET的值,错误返回INVALID_SOCKET
7 send
原型
int send(SOCKET s, const char FAR *buf, int len, int flags );
参数说明
s:对方的SOCKET
buf:要发送的缓冲区的地址
flags:通常置为0
作用
向对方发送数据
返回值
成功返回已发送的数据的字节数,错误返回SOCKET_ERROR
8 recv
原型
int recv( SOCKET s, char FAR *buf, int len, int flags );
参数说明
s:对方的SOCKET
buf:要发送的缓冲区的地址
flags:通常置为0
作用
接受对方的数据
返回值
成功返回已接受的数据的字节数,错误返回SOCKET_ERROR
9 closesocket
原型
int closesocket( SOCKET s );
参数说明
s:要关闭的SOCKET
作用
关闭指定的SOCKET
返回值
成功返回0,错误返回SOCKET_ERROR
10 connect
原型
Int connect(SOCKET s,const struct sockaddr FAR *name,int namelen) );
参数说明
S:本地SOCKET
name:远程服务端地址信息
namelen:name的size
作用
远程socket连接
返回值
成功返回0,错误返回SOCKET_ERROR
11 sendto
原型
int sendto( SOCKET s, const char FAR *buf, int len, int flags, const struct sockaddr FAR *to, int tolen); );
参数说明
S:对方的SOCKET,可能是连接状态
buf:要发送的信息地址
len:信息的大小
flags:通常置为0
to:远程地址信息
tolen:to的size
作用
用于UDP,数据的发送
返回值
成功返回已发送的数据的字节数,错误返回SOCKET_ERROR
12 recvfrom
原型
int recvfrom( SOCKET s, char FAR* buf, int len, int flags, struct sockaddr FAR *from, int FAR *fromlen );
参数说明
S:对方的SOCKET,可能是连接状态
buf:用于接收的缓冲区地址
len:信息的大小
flags:通常置为0
from:接收远程地址信息
fromlen:to的size
作用
用于UDP,数据的接收
返回值
成功返回已接收的数据的字节数,错误返回SOCKET_ERROR
15 WSAGetLastError
原型: int WSAGetLastError (void);
作用:返回最后一次的错误代码
错误代码在WINSOCK2.H中定义
14 一些转换函数
ntohs:”network to host short”
ntohl:”network to host long”
htons:”host to network short”
htonl:”host to network long”
inet_addr:将字符串的IP转换为网络IP
三正式编程
以下程序在vc6.0下编译
1 tcp编程
TCP Server:
1. /************************************************************************/
2. /*
3. 准备步骤
4. #include <WINSOCK2.H>
5. #pragma comment(lib, "ws2_32.lib ")
6.
7. 服务器端编程的步骤：
8. 0：加载套接字库(WSAStartup())
9.
10. 1：创建套接字(socket())；
11.
12. 2：绑定套接字到一个IP地址和一个端口上(bind())；
13.
14. 3：将套接字设置为监听模式等待连接请求(listen())；
15.
16. 4：请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept())；
17.
18. 5：用返回的套接字和客户端进行通信(send()/recv())；
19.
20. 6：返回，等待另一连接请求；
21.
22. 7：关闭套接字(closesocket())
23.
24. 8:关闭加载的套接字库(WSACleanup())。
25.
26. */
27. /************************************************************************/
28. #include <WINSOCK2.H>
29. #include <windows.h>
30. #include <iostream>
31. #include <string>
32. using namespace
33. #pragma comment(lib, "ws2_32.lib ")
34.
35.
36. //0
37. bool
38. //1
39. bool CreateSocket(SOCKET& sock,int
40. //2
41. bool BindSocket(SOCKET& sock,short port ,const char* strIp);
42. //3
43. bool SetListen(SOCKET& sock,int
44. //4,5,6
45. bool
46. //7
47. bool
48. //8
49. void
50.
51. void ExitWithErrorMessage(const
52.
53. DWORD WINAPI ClientThread(LPVOID
54.
55. void
56. {
57. "start server.\n";
58.
59. if(!LoadWSA() )
60. "LoadWSA failed.");
61. "LoadWAS success.\n";
62.
63. SOCKET serSock;
64.
65. if(!CreateSocket(serSock) )
66. "create server socket failed.");
67. "CreateSocket success.\n";
68.
69. if(!BindSocket(serSock,6000,"127.0.0.1") )
70. "BindSocket failed.");
71. "BindSocket success.\n";
72.
73. if(!SetListen(serSock,10) )
74. "SetListen failed.");
75. "SetListen success.\n";
76.
77. if(!Communicate(serSock) )
78. "Communicate failed.");
79. "Communicate success.\n";
80.
81. if(! CloseSocket(serSock) )
82. "CloseSocket failed.");
83. "CloseSocket success.\n";
84.
85. CloseWSA();
86. "CloseWSA success.\n";
87. }
88.
89.
90. bool
91. {
92. WSAData wsaData;
93.
94. if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )
95. {
96. return true;
97. }
98.
99. return false;
100. }
101.
102. void
103. {
104. WSACleanup();
105. }
106.
107. bool CreateSocket(SOCKET& sock,int type/* =SOCK_STREAM */)
108. {
109. sock=socket(AF_INET,type,0);
110.
111. if(INVALID_SOCKET == sock)
112. {
113. return false;
114. }
115.
116. return true;
117. }
118.
119. bool BindSocket(SOCKET& sock,short port ,const char* strIp)
120. {
121. SOCKADDR_IN address;
122.
123. address.sin_family=AF_INET;
124. address.sin_addr.s_addr =inet_addr(strIp);
125. address.sin_port=htons(port);
126. sizeof(address.sin_zero));
127.
128. if(SOCKET_ERROR == bind(sock,(const struct sockaddr*)&address,sizeof(struct
129. {
130. return false;
131. }
132.
133. return true;
134. }
135.
136. bool SetListen(SOCKET& sock,int
137. {
138. if(SOCKET_ERROR == listen(sock,number) )
139. {
140. return false;
141. }
142.
143. return true;
144. }
145.
146. bool
147. {
148. SOCKADDR_IN addrClient;
149. SOCKET newSock;
150. HANDLE
151. int n=sizeof(struct
152. bool flag=true;
153.
154. while(true)
155. {
156. struct
157.
158. if(newSock == INVALID_SOCKET)
159. {
160. "accept failed.\n";
161. false;
162. break;
163. }
164.
165. "client from "<<inet_ntoa(addrClient.sin_addr)<<":"<<ntohs(addrClient.sin_port)<<endl;
166.
167. LPVOID)newSock,0,NULL);
168.
169. if(hThread==NULL)
170. {
171. "CreateThread failed.\n";
172. false;
173. break;
174. }
175.
176. CloseHandle(hThread);
177. }
178.
179. closesocket(newSock);
180.
181. return
182. }
183.
184.
185. bool
186. {
187. if( closesocket(sock) == SOCKET_ERROR)
188. return false;
189. return true;
190. }
191.
192. void ExitWithErrorMessage(const
193. {
194. cout<<errMsg<<endl;
195. "pause");
196. exit(1);
197. }
198.
199. DWORD WINAPI ClientThread(LPVOID
200. {
201. SOCKET sock=(SOCKET)sockCliet;
202. char
203. int
204.
205. while(true)
206. {
207. memset(buffer,0,100);
208. errCode=recv(sock,buffer,100,0);
209.
210. if(errCode==0 || errCode==SOCKET_ERROR)
211. {
212. "client exit.\n";
213. break;
214. }
215.
216. "message from client: "<<buffer<<endl;
217.
218. "welcome.",strlen("welcome."),0);
219. }
220.
221. return
222. }
TCP Client
1. /************************************************************************/
2. /*
3. 准备步骤
4. #include <WINSOCK2.H>
5. #pragma comment(lib, "ws2_32.lib ")
6.
7. 0:加载套接字库(WSAStartup())
8.
9. 1：创建套接字(socket())；
10.
11. 2：向服务器发出连接请求(connect())；
12.
13. 3：和服务器端进行通信(send()/recv())；
14.
15. 4：关闭套接字(closesocket())
16.
17. 5: 关闭加载的套接字库(WSACleanup())。
18.
19. */
20. /************************************************************************/
21.
22. #include <WINSOCK2.H>
23. #include <windows.h>
24. #include <iostream>
25. #include <string>
26. using namespace
27. #pragma comment(lib, "ws2_32.lib ")
28.
29.
30. //0
31. bool
32. //1
33. bool CreateSocket(SOCKET& sock,int
34. //2
35. bool ConnectToServer(SOCKET& sock,short port ,const char* strIp);
36. //3
37. bool
38. //4
39. bool
40. //5
41. void
42.
43. void ExitWithErrorMessage(const
44.
45.
46. void
47. {
48. "Start Client.\n";
49. if(!LoadWSA() )
50. "LoadWSA failed.");
51. "LoadWSA Success.\n";
52.
53. SOCKET clietSock;
54.
55. if(!CreateSocket(clietSock) )
56. "create server socket failed.");
57. "CreateSocket Success.\n";
58.
59. if(!ConnectToServer(clietSock,6000,"127.0.0.1") )
60. "ConnectToServer failed.");
61. "ConnectToServer Success.\n";
62.
63. if(!Communicate(clietSock) )
64. "Communicate failed.");
65. "Communicate Success.\n";
66.
67. if(! CloseSocket(clietSock) )
68. "CloseSocket failed.");
69. "CloseSocket Success.\n";
70.
71. CloseWSA();
72. "CloseWSA Success.\n";
73.
74.
75. }
76.
77. bool
78. {
79. WSAData wsaData;
80.
81. if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )
82. {
83. return true;
84. }
85.
86. return false;
87. }
88.
89. void
90. {
91. WSACleanup();
92. }
93.
94. bool CreateSocket(SOCKET& sock,int type/* =SOCK_STREAM */)
95. {
96. sock=socket(AF_INET,type,0);
97.
98. if(INVALID_SOCKET == sock)
99. {
100. return false;
101. }
102.
103. return true;
104. }
105.
106. bool ConnectToServer(SOCKET& sock,short port ,const char* strIp)
107. {
108. SOCKADDR_IN address;
109.
110. address.sin_family=AF_INET;
111. address.sin_addr.s_addr=inet_addr(strIp);
112. address.sin_port=htons(port);
113. sizeof(address.sin_zero));
114.
115. if(SOCKET_ERROR == connect(sock,(const struct sockaddr*)&address,sizeof(struct
116. {
117. return false;
118. }
119.
120. return true;
121. }
122.
123. bool
124. {
125. bool flag=true;
126. int
127. char
128.
129. while(true)
130. {
131. memset(buffer,0,100);
132. cin.getline(buffer,100);
133. errCode=send(sock,buffer,strlen(buffer),0);
134.
135. if(errCode==SOCKET_ERROR)
136. {
137. "send message error.\n";
138. false;
139. break;
140. }
141.
142. memset(buffer,0,100);
143. recv(sock,buffer,100,0);
144. cout<<buffer<<endl;
145. }
146.
147. return
148. }
149.
150.
151.
152. void ExitWithErrorMessage(const
153. {
154. cout<<errMsg<<endl;
155. "pause");
156. exit(1);
157. }
158.
159. bool
160. {
161. if( closesocket(sock)==SOCKET_ERROR )
162. return false;
163.
164. return true;
165. }
2 upd编程
UDP Server
1. /************************************************************************/
2. /*
3. 准备步骤
4. #include <WINSOCK2.H>
5. #pragma comment(lib, "ws2_32.lib ")
6.
7. 0: 加载套接字库(WSAStartup());
8.
9. 1：创建套接字(socket())；
10.
11. 2：绑定套接字到一个IP地址和一个端口上(bind())；
12.
13. 3：等待和接收数据(sendto()/recvfrom())；
14.
15. 4：关闭套接字(closesocket());
16.
17. 5: 关闭加载的套接字库(WSACleanup()).
18. */
19. /************************************************************************/
20.
21. #include <WINSOCK2.H>
22. #include <windows.h>
23. #include <iostream>
24. #include <string>
25. using namespace
26. #pragma comment(lib, "ws2_32.lib ")
27.
28.
29. //0
30. bool
31. //1
32. bool CreateSocket(SOCKET& sock,int
33. //2
34. bool BindSocket(SOCKET& sock,short port ,const char* strIp);
35. //4
36. bool
37. //5
38. bool
39. //6
40. void
41.
42. void ExitWithErrorMessage(const
43.
44.
45. void
46. {
47. if(! LoadWSA() )
48. "LoadWSA falid.");
49. "LoadWSA success.\n";
50.
51. SOCKET serSocket;
52. if(! CreateSocket(serSocket) )
53. "CreateSocket falid.");
54. "CreateSocket success.\n";
55.
56. if(! BindSocket(serSocket,6000,"127.0.0.1") )
57. "BindSocket falid.");
58. "BindSocket success.\n";
59.
60. while(! Communicate(serSocket) );
61. "Communicate success.\n";
62.
63. if(! CloseSocket(serSocket) )
64. "CloseSocket falid.");
65. "CloseSocket success.\n";
66.
67. CloseWSA();
68. }
69.
70.
71. bool
72. {
73. WSAData wsaData;
74.
75. if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )
76. {
77. return true;
78. }
79.
80. return false;
81. }
82.
83. void
84. {
85. WSACleanup();
86. }
87.
88. bool CreateSocket(SOCKET& sock,int
89. {
90. sock=socket(AF_INET,type,0);
91.
92. if(INVALID_SOCKET == sock)
93. {
94. return false;
95. }
96.
97. return true;
98. }
99.
100. bool BindSocket(SOCKET& sock,short port ,const char* strIp)
101. {
102. SOCKADDR_IN address;
103.
104. address.sin_family=AF_INET;
105. address.sin_addr.s_addr =inet_addr(strIp);
106. address.sin_port=htons(port);
107. sizeof(address.sin_zero));
108.
109. if(SOCKET_ERROR == bind(sock,(const struct sockaddr*)&address,sizeof(struct
110. {
111. return false;
112. }
113.
114. return true;
115. }
116.
117. bool
118. {
119. bool flag =true;
120. SOCKADDR_IN address;
121. int n=sizeof(struct
122. char
123.
124. if(recvfrom(srverSock,buffer, 100,0,(struct
125. false;
126.
127. if(flag)
128. cout<<buffer;
129.
130. return
131. }
132.
133. void ExitWithErrorMessage(const
134. {
135. cout<<errMsg<<endl;
136. "pause");
137. exit(1);
138. }
139.
140. bool
141. {
142. if( closesocket(sock)==SOCKET_ERROR )
143. return false;
144.
145. return true;
146. }
TCP Client
1. /************************************************************************/
2. /*
3. 准备步骤
4. #include <WINSOCK2.H>
5. #pragma comment(lib, "ws2_32.lib ")
6.
7. 0: 加载套接字库(WSAStartup());
8.
9. 1：创建套接字(socket())；
10.
11. 2：等待和接收数据(sendto()/recvfrom())；
12.
13. 3：关闭套接字(closesocket());
14.
15. 4: ，关闭加载的套接字库(WSACleanup()).
16. */
17. /************************************************************************/
18.
19. #include <WINSOCK2.H>
20. #include <windows.h>
21. #include <iostream>
22. #include <string>
23. using namespace
24. #pragma comment(lib, "ws2_32.lib ")
25.
26.
27. //0
28. bool
29. //1
30. bool CreateSocket(SOCKET& sock,int
31. //2
32. bool Communicate(SOCKET& clientSock,short port ,const char* strIp);
33. //3
34. bool
35. //4
36. void
37.
38. void ExitWithErrorMessage(const
39.
40.
41. void
42. {
43. if(! LoadWSA() )
44. "LoadWSA falid.");
45. "LoadWSA success.\n";
46.
47. SOCKET clientSocket;
48. if(! CreateSocket( clientSocket) )
49. "CreateSocket falid.");
50. "CreateSocket success.\n";
51.
52. if(! Communicate( clientSocket,6000,"127.0.0.1") )
53. "Communicate falid.");
54. "Communicate success.\n";
55.
56. if(! CloseSocket( clientSocket) )
57. "CloseSocket falid.");
58. "CloseSocket success.\n";
59.
60. CloseWSA();
61. }
62.
63.
64. bool
65. {
66. WSAData wsaData;
67.
68. if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )
69. {
70. return true;
71. }
72.
73. return false;
74. }
75.
76. void
77. {
78. WSACleanup();
79. }
80.
81. bool CreateSocket(SOCKET& sock,int
82. {
83. sock=socket(AF_INET,type,0);
84.
85. if(INVALID_SOCKET == sock)
86. {
87. return false;
88. }
89.
90. return true;
91. }
92.
93.
94. bool Communicate(SOCKET& clientSock,short port ,const char* strIp)
95. {
96. bool flag =true;
97. SOCKADDR_IN address;
98. int n=sizeof(struct
99.
100. address.sin_family=AF_INET;
101. address.sin_addr.s_addr=inet_addr(strIp);
102. address.sin_port=htons(port);
103. sizeof(address.sin_zero));
104.
105. if( sendto(clientSock,"hello , I am from client message.", sizeof("hello , I am from server message."),
106. const struct sockaddr*)&address,sizeof(struct
107. false;
108.
109. return
110. }
111.
112. void ExitWithErrorMessage(const
113. {
114. cout<<errMsg<<endl;
115. "pause");
116. exit(1);
117. }
118.
119. bool
120. {
121. if( closesocket(sock)==SOCKET_ERROR )
122. return false;
123.
124. return true;
125. }
