Socket套接字

Socket套接字
Socket常被翻译成套接字或者插口，Socket实际上是网络上的通信端点。
在使用Socket通信之前，需要创建socket对象，通常使用socket()函数创建socket()对象。
int socket(int domain, int type, int protocol);
domain：指定使用的域，通常是ipv4,ipv6等；AF_INET表示IPv4协议。
type：指定数据传输的方式，SOCK_STREAM：面向连接的数据流方式，SOCK_DGRAM：无连接的数据报方式。

面向连接的Socket通信实现
1、服务器端工作流程：
（1）使用socket()函数创建socket对象。
（2）使用bind()函数把创建的socket句柄绑定到指定的TCP端口。
（3）调用listem()函数使socket处于监听状态，并且设置监听队列的大小。
（4）当客户端发送连接请求后，调用accept()函数接收客户端请求，与客户端建立连接。
（5）与客户端发送或者接收数据。
（6）通信完毕，调用close()函数关闭socket()。
2、客户端工作流程如下：
（1）使用socket()函数创建socket。
（2）调用connect()函数向服务器端socket发起连接。
（3）连接建立后，进行数据读写。
（4）数据传输完毕，使用close()函数关闭socket。

int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen); //如果绑定成功，返回0，失败，返回-1。
sockfd：是要绑定的socket句柄，由socket()函数创建。
my_addr：指向一个sockaddr结构，里面保存IP地址和端口号。
addrlen：是sockaddr结构的大小。

int listen(int s, int backlog); //调用函数成功返回0，失败返回-1；
s：是要监听的socket句柄。
backlog：指定最多可以监听的连接数量，默认是20个。

int accept(int s, struct sockaddr *addr, socklen_t *addrlen); //调用函数成功，返回新创建的套接字句柄，失败返回-1。
s：监听的套接字描述符。
addr：指向sockaddr结构的指针。
addrlen：结构的大小。
accept()函数用于面向连接类型的套接字类型，它从连接请求队列中获得连接信息，创建新的套接字，并返回套接字的文件描述符。

int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);
sockfd：是套接字句柄。
ser_addr：指向sockaddr结构，指定了服务器IP地址和端口号。
addrlen：是serv_addr结构大小。
connect()函数的作用是和服务器建立连接。

ssize_t send(int s, const void *buf, size_t len, int flags); //发送数据成功，返回发送数据的字节数，失败返回-1。
s：是套接字的句柄。
buf：是要发送的数据缓冲。
len：是数据缓冲长度。
flags：一般置0。

ssize_t recv(int s, void *buf, size_t len, int flags);
s：指定读取数据的套接字句柄。
buf：存放数据的缓冲首地址。
len：指定接收缓冲大小。
flags：一般置0。
recv()函数读取到数据时，函数返回已读取数据的字节数，失败返回-1，如果关闭了套接字，recv()函数会返回0。

【面向连接的echo服务编程实例】
1、服务器端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ECHO_PORT 8080
#define MAX_CLIENT_NUM 10

int main()
{
	int sock_fd;
	struct sockaddr_in serv_addr;
	int clientfd;
	struct sockaddr_in clientAdd;
	char buff[101];
	socklen_t len;
	int closing = 0;
	int n;

	sock_fd = socket(AF_INET, SOCK_STREAM, 0);
		if(sock_fd==-1)
		{
			perror("create socket error!");
			return 0;
		}
		else
		{
		printf("success to create socket %d\n", sock_fd);
		}

	bzero(&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_port = htons(ECHO_PORT);
	serv_addr.sin_addr.s_addr=htons(INADDR_ANY);
	bzero(&(serv_addr.sin_zero), 8);


	if(bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))!=0)
	{
		printf("bind address fail! %d\n",errno);
		close(sock_fd);
		return 0;
	}
	else
	{
	printf("success to bind address!\n");
	}


	if(listen(sock_fd, MAX_CLIENT_NUM)!=0)
	{
		perror("listen socket error!\n");
		close(sock_fd);
		return 0;
	}
	else
	{
	printf("success to listen\n");
	}

	
	len = sizeof(clientAdd);
	clientfd = accept(sock_fd,(struct sockaddr*)&clientAdd, &len);
	if(clientfd<=0)
	{
		perror("accept() error\n");
		close(sock_fd);
		return 0;
	}

	while((n=recv(clientfd, buff, 100, 0))>0)
	{
		buff[n]='\0';
		printf("number of receive bytes = %d data = %s\n", n, buff);
		fflush(stdout);
		send(clientfd, buff, n, 0);
			if(strncmp(buff, "quit", 4)==0)
			{
			break;
			}
	}

	close(clientfd);
	close(sock_fd);

	return 0;
}

2、客户端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ECHO_PORT 8080
#define MAX_COMMAND 5

int main()
{
	int sock_fd;
	struct sockaddr_in serv_addr;

	char *buff[MAX_COMMAND]={"abc", "def", "test", "hello", "quit"};
	char tmp_buf[100];
	socklen_t len;
	int n, i;

	sock_fd =  socket(AF_INET, SOCK_STREAM, 0);
		if(sock_fd==-1)
		{
			perror("create socket error!");
			return 0;
		}
		else
		{
			printf("success to create socket %d\n", sock_fd);
		}

	bzero(&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_port=htons(ECHO_PORT);
	serv_addr.sin_addr.s_addr=htons(INADDR_ANY);
	bzero(&(serv_addr.sin_zero), 8);

	if(connect(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)))
	{
		perror("connect() error!\n");
		close(sock_fd);
		return 0;
	}

	printf("success connect to server!\n");


	for(i=0;i<MAX_COMMAND;i++)
	{
		send(sock_fd, buff[i], 100, 0);
		n=recv(sock_fd, tmp_buf, 100, 0);
		tmp_buf[n]='\0';

		printf("data send: %s receive: %s\n", buff[i], tmp_buf);

		if(strncmp(tmp_buf, "quit", 4)==0)
			break;
		
	}

	close(sock_fd);

	return 0;
}

【运行结果】
服务器端监听并且接收数据：
lwb@ubuntu:~/socket$ gcc echo_serv.c -o s
lwb@ubuntu:~/socket$ ./s
success to create socket 3
success to bind address!
success to listen (监听中，等待接收数据)
number of receive bytes = 100 data = abc
number of receive bytes = 100 data = def
number of receive bytes = 100 data = test
number of receive bytes = 100 data = hello
number of receive bytes = 100 data = quit

客户端连接服务器后发送数据
lwb@ubuntu:~/socket$ gcc echo_client.c -o c
lwb@ubuntu:~/socket$ ./c
success to create socket 3
success connect to server!
data send: abc receive: abc
data send: def receive: def
data send: test receive: test
data send: hello receive: hello
data send: quit receive: quit

无连接的Socket通信相对于建立连接的流Socket较为简单，数据传输过程中不能保证能否到达，常用在一些对数据要求不高的地方。无连接的套接字使用TCP/IP协议族中的UDP协议传输数据。
int recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
int sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);

recvfrom()函数用来从指定的IP地址和端口接收数据。函数调用成功返回发送的数据的字节数，失败返回-1。
s：是套接字句柄。
msg：发送数据的缓冲区首地址。
len：缓冲大小。
to：指定接收数据的IP和端口号。
tolen：sockaddr结构大小。

【无连接的时间服务编程实例】
1、服务器端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <string.h>


#define TIME_PORT 9090
#define DATA_SIZE 256

int main()
{
	int sock_fd;
	struct sockaddr_in local;
	struct sockaddr_in from;
	int fromlen, n;
	char buff[DATA_SIZE];
	time_t cur_time;

	sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
	if(sock_fd<=0)
	{
		perror("create socket error!");
		return 0;
	}
	perror("create socket");

	local.sin_family = AF_INET;
	local.sin_port = htons(TIME_PORT);
	local.sin_addr.s_addr=INADDR_ANY;

	if(bind(sock_fd, (struct sockaddr*)&local, sizeof(local))!=0)
	{
		perror("bind socket error!");
		close(sock_fd);
	return 0;
	}

	printf("bind socket");

	fromlen = sizeof(from);
	printf("waiting request from client...\n");
	

	while(1)
	{
		n=recvfrom(sock_fd, buff, sizeof(buff), 0, (struct sockaddr*)&from, &fromlen);
		if(n<=0)
		{
			perror("recv data!\n");
			close(sock_fd);
			return 0;
		}

		buff[n]='\0';
		printf("client request: %s\n", buff);

		if(strncmp(buff, "quit", 4)==0)
			break;

		if(strncmp(buff, "time", 4)==0)
		{
		cur_time = time(NULL);
		strcpy(buff, asctime(gmtime(&cur_time)));
		sendto(sock_fd, buff, sizeof(buff), 0, (struct sockaddr*)&from, fromlen);
		}
	}
	close(sock_fd);
	return 0;
}

2、客户端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#define TIME_PORT 9090
#define DATA_SIZE 256

int main()
{
	int sock_fd;
	struct sockaddr_in serv;
	int servlen, n;
	char buff[DATA_SIZE];

	sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
	if(sock_fd<=0)
	{
		perror("create socket error!");
		return 0;
	}
	perror("create socket");

	serv.sin_family=AF_INET;
	serv.sin_port=htons(TIME_PORT);
	serv.sin_addr.s_addr=INADDR_ANY;
	servlen=sizeof(serv);

	strcpy(buff, "time");
	if(sendto(sock_fd, buff, sizeof(buff), 0, (struct sockaddr*)&serv, servlen)==-1)
	{
		perror("send data");
		close(sock_fd);
		return 0;
	}
	printf("send time request\n");

	n=recvfrom(sock_fd, buff, sizeof(buff), 0, (struct sockaddr*)&serv, &servlen);

	if(n<=0)
	{
	perror("recv data!\n");
	close(sock_fd);
	return 0;
	}
	buff[n]='\0';
	printf("time from server: %s", buff);

	strcpy(buff, "quit");
	if(sendto(sock_fd, buff, sizeof(buff), 0, (struct sockaddr*)&serv, servlen)==-1)
	{
		perror("send data");
		close(sock_fd);
		return 0;
	}
	printf("send quit command\n");

	close(sock_fd);
	return 0;
}

【运行结果】
服务器端：
lwb@ubuntu:~/socket$ gcc time_serv.c -o s
lwb@ubuntu:~/socket$ ./s
create socket: Success
bind socketwaiting request from client… //会等待
client request: time
client request: quit
客户端：
lwb@ubuntu:~/socket$ gcc time_serv.c -o s
lwb@ubuntu:~/socket$ ./s
create socket: Success
bind socketwaiting request from client…
client request: time
client request: quit

【扩展学习】
使用select机制处理多连接
使用poll机制处理多连接

摘自：弓雷 ARM嵌入式Linux系统开发详解