socket函数简述
int socket(int protofamily, int type, int protocol);
函数功能 ：socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。
返回值： sockfd sockfd是描述符，也就是你所创建的套接字，类似一个门牌号
函数参数 ： protofamily：即协议域，又称为协议族（family）。常用的协议族有，AF_INET(IPV4)、AF_INET6(IPV6)、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等。
protocol：就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议
注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
函数功能：bind()函数把一个地址族中的特定地址赋给socket，也可以说是绑定ip端口和socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。
函数参数：sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同。addrlen：对应的是地址的长度。
通用函数类型：
struct sockaddr{
sa_family_t sa_family;
char sa_data[14];
}
如ipv4对应的是：
struct sockaddr_in {
sa_family_t sin_family; /* address family: AF_INET */
in_port_t sin_port; /* port in network byte order 2字节*/
struct in_addr sin_addr; /* internet address 4字节*/
unsigned char sin_zero[8];
};
/* Internet address. */
struct in_addr {
uint32_t s_addr; /* address in network byte order */
};
ipv6对应的是：
struct sockaddr_in6 {
sa_family_t sin6_family; /* AF_INET6 */
in_port_t sin6_port; /* port number */
uint32_t sin6_flowinfo; /* IPv6 flow information */
struct in6_addr sin6_addr; /* IPv6 address */
uint32_t sin6_scope_id; /* Scope ID (new in 2.4) */
};
struct in6_addr {
unsigned char s6_addr[16]; /* IPv6 address */
};
Unix域对应的是：
#define UNIX_PATH_MAX 108
struct sockaddr_un {
sa_family_t sun_family; /* AF_UNIX */
char sun_path[UNIX_PATH_MAX]; /* pathname */
};
int_addr_t indet_addr(const char *cp)
功能：将字符串形式的IP地址转化为整数型的IP地址（网络字节序）
范例：int_addr.saddr=inet_addr("192.168.1.1");
char *inet_ntoa(struct in_addr)
功能：将整数形式的IP地址转化为字符串形式的IP地址
int listen(int sockfd, int backlog)listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。成功返回0，若连接失败则返回-1。
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。
参数addr
这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。
参数addrlen
如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。
如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。
注意： accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。此时我们需要区分两种套接字，监听套接字: 监听套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字),连接套接字：一个套接字会从主动连接的套接字变身为一个监听套接字；而accept函数返回的是已连接socket描述字(一个连接套接字)，它代表着一个网络已经存在的点点连接。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。连接套接字socketfd_new 并没有占用新的端口与客户端通信，依然使用的是与监听套接字socketfd一样的端口号(如果想让多台客户端同时接入并工作，可使用多进程)
int recv( SOCKET s,char FAR *buf,int len, int flag)不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。
该函数的第一个参数指定接收端套接字描述符； 第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。
int send( SOCKET s, const char FAR *buf, int len, int flags )不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。
客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。
int close(int sockfd)返回：若成功则返回0.失败则返回-1；
close一个TCP套接字的默认行为是把该套接字标记成已关闭，然后立即返回到调用程序。该套接字描述符不能再由调用进程使用，也就是说它不能再作为read和write的第一个参数。然而TCP将尝试发送已排队等待发送到对端的任何数据，发送完毕后发生的是正常的TCP连接终止序列。
Socket流程
服务端：创建套接字->配置端口信息->绑定套接字->开始监听->相关操作<-
客户端：建套接字->配置连接端口信息->绑定套接字->连接->相关操作-<
简单例子(来源我博哥，在此感谢博哥）
client
#include<netinet/in.h> // sockaddr_in
#include<sys/types.h> // socket
#include<sys/socket.h> // socket
#include<stdio.h> // printf
#include<stdlib.h> // exit
#include<string.h> // bzero
#define SERVER_PORT 8000
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512
struct sockaddr_in client_addr;//客户端结构体类型（内含有端口号，IPv4地址，以及地址族的结构体）
struct sockaddr_in server_addr;
int client_socket_fd;//客户端socket返回值，用于判断
char file_serve_name[FILE_NAME_MAX_SIZE+1];
char file_client_local[FILE_NAME_MAX_SIZE+1];
char buffer[BUFFER_SIZE];
FILE *fp;
int Start_Client_Socket()// 声明并初始化一个客户端的socket地址结构
{
bzero(&client_addr, sizeof(client_addr));
client_addr.sin_family = AF_INET;
client_addr.sin_addr.s_addr = htons(INADDR_ANY);
client_addr.sin_port = htons(0);
return 1;
}
int Creat_Socket()// 创建socket，若成功，返回socket描述符
{
client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if(client_socket_fd < 0)
{
perror("创建socket失败:");
exit(1);
}
return 1;
}
int Client_Server_Bind() // 绑定客户端的socket和客户端的socket地址结构
{
if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))
{
perror("Client Bind Failed:");
exit(1);
}
return 1;
}
int Start_Serve_Socket()// 声明一个服务器端的socket地址结构，并用服务器那边的IP地址及端口对其进行初始化，用于后面的连接
{
char IP_serve_local[FILE_NAME_MAX_SIZE+1];
bzero(IP_serve_local, FILE_NAME_MAX_SIZE+1);
printf("请输入服务器的IP地址:\t");
scanf("%s",IP_serve_local);
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
if(inet_pton(AF_INET, IP_serve_local, &server_addr.sin_addr) == 0)
{
perror("服务器IP错误:");
exit(1);
}
server_addr.sin_port = htons(SERVER_PORT);
return 1;
}
int Client_Serve_Link()// 向服务器发起连接，连接成功后client_socket_fd代表了客户端和服务器的一个socket连接
{
socklen_t server_addr_length = sizeof(server_addr);
if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)
{
perror("无法连接到服务器:");
exit(0);
}
return 1;
}
int File_LocalName_Trans()
{
bzero(file_serve_name, FILE_NAME_MAX_SIZE+1);
bzero(file_client_local, FILE_NAME_MAX_SIZE+1);
printf("请输入要获取的文件在服务器的位置及名字:\t");
scanf("%s",file_serve_name);
printf("请输入要保存的文件在客户端的位置及名字:\t");
scanf("%s",file_client_local);
bzero(buffer, BUFFER_SIZE);
strncpy(buffer, file_serve_name, strlen(file_serve_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_serve_name));
return 1;
}
int Send_File_Server_Name()// 向服务器发送要获取的位置及名称
{
if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)
{
perror("发送文件名称错误:");
exit(1);
}
return 1;
}
int Write_Server_To_Client()
{
// 打开文件，准备写入
fp = fopen(file_client_local, "w");
if(NULL == fp)
{
printf("File:\t%s 无法写入\n", file_serve_name);
exit(1);
}
// 从服务器接收数据到buffer中
// 每接收一段数据，便将其写入文件中，循环直到文件接收完并写完为止
bzero(buffer, BUFFER_SIZE);
int length = 0;
while((length = recv(client_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)
{
if(fwrite(buffer, sizeof(char), length, fp) < length)
{
printf("File:\t%s 写入失败\n", file_serve_name);
break;
}
bzero(buffer, BUFFER_SIZE);
}
printf("文件:\t%s 接收成功\n", file_serve_name);
return 1;
}
int Close_File_Socket()// 接收成功后，关闭文件，关闭socket
{
close(fp);
close(client_socket_fd);
return 1;
}
int main()
{
Start_Client_Socket();
Creat_Socket();
Client_Server_Bind();
Start_Serve_Socket();
Client_Serve_Link();
File_LocalName_Trans();
Send_File_Server_Name();
Write_Server_To_Client();
Close_File_Socket();
return 0;
}
sever
#include<netinet/in.h> // sockaddr_in
#include<sys/types.h> // socket
#include<sys/socket.h> // socket
#include<stdio.h> // printf
#include<stdlib.h> // exit
#include<string.h> // bzero
#define SERVER_PORT 8000
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
socklen_t client_addr_length = sizeof(client_addr); // 定义客户端的socket地址结构
int server_socket_fd;
int new_server_socket_fd;
int opt = 1;
int length = 0;
char buffer[BUFFER_SIZE];
char file_name[FILE_NAME_MAX_SIZE+1]; //从客户端传过来，要获取的文件名字及地址
FILE *fp;
int Start_Server_Socket() // 声明并初始化一个服务器端的socket地址结构
{
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
server_addr.sin_port = htons(SERVER_PORT);
return 1;
}
int Creat_Socket() // 创建socket，若成功，返回socket描述符
{
server_socket_fd = socket(PF_INET, SOCK_STREAM, 0);
if(server_socket_fd < 0)
{
perror("创建socket失败:");
exit(1);
}
setsockopt(server_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
return 1;
}
int Client_Server_Bind() // 绑定客户端的socket和客户端的socket地址结构
{
if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))
{
perror("Server Bind Failed:");
exit(1);
}
return 1;
}
int Serve_Listen() //不断监听从客户端传来的信息，每来一个就开启新进程
{
if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))
{
perror("监听失败:");
exit(1);
}
return 1;
}
int Serve_Accept_Link() // 接受连接请求，返回一个新的socket(描述符)，这个新socket用于同连接的客户端通信
{ // accept函数会把连接到的客户端信息写到client_addr中
new_server_socket_fd = accept(server_socket_fd, (struct sockaddr*)&client_addr, &client_addr_length);
if(new_server_socket_fd < 0)
{
perror("Server Accept Failed:");
exit(0);
}
return 1;
}
int Send_File_Name() //接收需要发送的文件位置及文件名
{
bzero(buffer, BUFFER_SIZE);
if(recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0) < 0) //recv函数接收数据到缓冲区buffer中
{
perror("接受文件名失败");
exit(0);
}
// 然后从buffer(缓冲区)拷贝到file_name中
bzero(file_name, FILE_NAME_MAX_SIZE+1);
strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));
printf("要发送的文件名为：%s\n", file_name);
return 1;
}
int Document_Send()
{
// 打开文件并读取文件数据
fp = fopen(file_name, "r");
if(NULL == fp)
{
printf("File:%s Not Found\n", file_name);
}
else
{
bzero(buffer, BUFFER_SIZE);
// 每读取一段数据，便将其发送给客户端，循环直到文件读完为止
while((length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
{
if(send(new_server_socket_fd, buffer, length, 0) < 0)
{
printf("Send File:%s Failed./n", file_name);
exit(0);
}
bzero(buffer, BUFFER_SIZE);
}
fclose(fp); // 关闭文件
printf("文件:%s 发送成功\n", file_name);
}
return 1;
}
int Link_Trans()
{
while(1)
{
Serve_Accept_Link();
Send_File_Name();
Document_Send();
close(new_server_socket_fd); // 关闭与客户端的连接
}
return 1;
}
int main(void)
{
Start_Server_Socket(); //服务器server初始化
Creat_Socket(); //创建服务器socket
Client_Server_Bind(); //客户端与服务器绑定
Serve_Listen(); //服务器进行监听
Link_Trans(); //链接并且进行文件的传输
close(server_socket_fd); //关闭监听用的socket
return 0;
}
函数的组合应用便可以实现网络通信的功能
------------------------------------------------------- -------------正在更新中--------------------------------------------------------------------------------------------------------------------------------------------------最后修改时间：2019年4月10日16:11:50-------------------------------------------------------------------
