linux系统socket通信编程详解函数

linux socket编程之TCP与UDP

TCP与UDP区别

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。

UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快

TCP和UDP都是在传输层上的。简单来说，UDP发送 数据的时候是不管数据有没有真正达到目的地的，所以传输起来速度就比较快了。但是同时也容易造成数据丢失。而TCP我们知道有三次握手建立，四次握手释放，所以传输更准确，但是速度可能会相对慢一些。

为确保正确地接收数据，TCP要求在目标计算机成功收到数据时发回一个确认（即ACK）。如果在某个时限内未收到相应的ACK，将重新传送数据包。如果网络拥塞，这种重新传送将导致发送的数据包重复。但是，接收计算机可使用数据包的序号来确定它是否为重复数据包，并在必要时丢弃它（这里让我想起了linux IPC里可靠信号与不可靠信号的发送也是与之类似的）。

socket套接字

套接口可以说是网络编程中一个非常重要的概念，linux以文件的形式实现套接口，与套接口相应的文件属于sockfs特殊文件系统，创建一个套接口就是在sockfs中创建一个特殊文件，并建立起为实现套接口功能的相关数据结构。换句话说，对每一个新创建的BSD套接口，linux内核都将在sockfs特殊文件系统中创建一个新的inode。描述套接口的数据结构是socket，将在后面给出。

(一)重要数据结构

下面是在网络编程中比较重要的几个数据结构，读者可以在后面介绍编程API部分再回过头来了解它们。

（1）表示套接口的数据结构structsocket

套接口是由socket数据结构代表的，形式如下：


structsocket

{

socket_state state; /*指明套接口的连接状态，一个套接口的连接状态可以有以下几种

套接口是空闲的，还没有进行相应的端口及地址的绑定；还没有连接；正在连接中；已经连接；正在解除连接。*/

unsignedlong flags;

structproto_ops ops; /*指明可对套接口进行的各种操作*/

structinode inode; /*指向sockfs文件系统中的相应inode*/

structfasync_struct *fasync_list; /* Asynchronous wake up list */

structfile *file; /*指向sockfs文件系统中的相应文件 */

structsock sk; /*任何协议族都有其特定的套接口特性，该域就指向特定协议族的套接口对

象。*/

wait_queue_head_t wait;

short type;

unsignedchar passcred;

};

（2）描述套接口通用地址的数据结构structsockaddr

由于历史的缘故，在bind、connect等系统调用中，特定于协议的套接口地址结构指针都要强制转换成该通用的套接口地址结构指针。结构形式如下：


structsockaddr {

sa_family_t sa_family; /*address family, AF_xxx */

char sa_data[14]; /*14 bytes of protocol address */

};

（3）描述因特网地址结构的数据结构structsockaddr_in（这里局限于IP4）：


structsockaddr_in

{

__SOCKADDR_COMMON(sin_); /*描述协议族*/

in_port_tsin_port; /*端口号*/

structin_addr sin_addr; /*因特网地址*/

/*Pad to size of `struct sockaddr‘. */

unsignedchar sin_zero[sizeof (struct sockaddr) -

__SOCKADDR_COMMON_SIZE -

sizeof (in_port_t) -

sizeof (struct in_addr)];

};

（二）基本的socket接口函数。

3.1、socket()函数

int socket(int domain, int type, int protocol);

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：

  • domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、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等等（socket的类型有哪些？）。
  • protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议。

注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。

3.2、bind()函数

正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

函数的三个参数分别为：

  • sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。
  • addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是： 
    struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* 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 */
};
  • addrlen：对应的是地址的长度。

通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

网络字节序与主机字节序

主机字节序就是我们平常说的大端和小端模式：不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序，这个叫做主机序。引用标准的Big-Endian和Little-Endian的定义如下：

　　a) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

　　b) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

网络字节序：4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序，因此它又称作网络字节序。字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序，一个字节的数据没有顺序的问题了。

所以：在将一个地址绑定到socket的时候，请先将主机字节序转换成为网络字节序，而不要假定主机字节序跟网络字节序一样使用的是Big-Endian。由于这个问题曾引发过血案！公司项目代码中由于存在这个问题，导致了很多莫名其妙的问题，所以请谨记对主机字节序不要做任何假定，务必将其转化为网络字节序再赋给socket。

3.3、listen()、connect()函数

如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

3.4、accept()函数

TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept函数的第一个参数为服务器的socket描述字，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

注意：accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

3.5、read()、write()等函数

万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：

  • read()/write()
  • recv()/send()
  • readv()/writev()
  • recvmsg()/sendmsg()
  • recvfrom()/sendto()

我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

[cpp] view plaincopyprint?

  1. #include <unistd.h>
  2. ssize_t read(int fd, void *buf, size_t count);
  3. ssize_t write(int fd, const void *buf, size_t count);
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. ssize_t send(int sockfd, const void *buf, size_t len, int flags);
  7. ssize_t recv(int sockfd, void *buf, size_t len, int flags);
  8. ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
  9. const struct sockaddr *dest_addr, socklen_t addrlen);
  10. ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
  11. struct sockaddr *src_addr, socklen_t *addrlen);
  12. ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
  13. ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

#include <sys/types.h>
#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。 在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。

其它的我就不一一介绍这几对I/O函数了，具体参见man文档或者baidu、Google，下面的例子中将使用到send/recv。

3.6、close()函数

在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

#include <unistd.h>
int close(int fd);

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

下面是TCP的一个例子，分别是服务器端（server.c）和客户端（client.c）

server.c

[cpp] view plaincopyprint?

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<errno.h>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #define MAXLINE 4096
  9. int main(int argc, char** argv)
  10. {
  11. int    listenfd, connfd;
  12. struct sockaddr_in     servaddr;
  13. char    buff[4096];
  14. int     n;
  15. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
  16. printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
  17. exit(0);
  18. }
  19. memset(&servaddr, 0, sizeof(servaddr));
  20. //协议地址
  21. servaddr.sin_family = AF_INET;
  22. servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  23. servaddr.sin_port = htons(6666);//
  24. //bind把一个地址族中的特定地址赋给socket
  25. if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
  26. printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
  27. exit(0);
  28. }
  29. if( listen(listenfd, 10) == -1){
  30. //listen 监听
  31. printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
  32. exit(0);
  33. }
  34. printf("======waiting for client‘s request======\n");
  35. while(1){
  36. if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
  37. printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
  38. continue;
  39. }
  40. n = recv(connfd, buff, MAXLINE, 0);
  41. buff[n] = ‘\0‘;
  42. printf("recv msg from client: %s\n", buff);
  43. close(connfd);
  44. }
  45. close(listenfd);
  46. }

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

#define MAXLINE 4096

int main(int argc, char** argv)
{
int listenfd, connfd;
struct sockaddr_in servaddr;
char buff[4096];
int n;

if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
exit(0);
}

memset(&servaddr, 0, sizeof(servaddr));
//协议地址
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(6666);//
//bind把一个地址族中的特定地址赋给socket
if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
exit(0);
}

if( listen(listenfd, 10) == -1){
//listen 监听
printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
exit(0);
}

printf("======waiting for client‘s request======\n");
while(1){
if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
continue;
}
n = recv(connfd, buff, MAXLINE, 0);
buff[n] = ‘\0‘;
printf("recv msg from client: %s\n", buff);
close(connfd);
}

close(listenfd);
}
client.c

[cpp] view plaincopyprint?

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<errno.h>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #define MAXLINE 4096
  9. int main(int argc, char** argv)
  10. {
  11. int    sockfd, n;
  12. char    recvline[4096], sendline[4096];
  13. struct sockaddr_in    servaddr;
  14. if( argc != 2){
  15. printf("usage: ./client <ipaddress>\n");
  16. exit(0);
  17. }
  18. if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
  19. // 创建套接字描述符给sockfd
  20. printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
  21. exit(0);
  22. }
  23. memset(&servaddr, 0, sizeof(servaddr));
  24. //结构体清零
  25. servaddr.sin_family = AF_INET;
  26. servaddr.sin_port = htons(6666);//端口号
  27. if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
  28. //Linux下IP地址转换函数，可以在将IP地址在“点分十进制”和“整数”之间转换
  29. printf("inet_pton error for %s\n",argv[1]);
  30. exit(0);
  31. }
  32. if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
  33. //连接请求
  34. printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
  35. }
  36. printf("send msg to server: \n");
  37. fgets(sendline, 4096, stdin);
  38. if( send(sockfd, sendline, strlen(sendline), 0) < 0)
  39. {
  40. printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
  41. exit(0);
  42. }
  43. close(sockfd);
  44. exit(0);
  45. }

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

#define MAXLINE 4096

int main(int argc, char** argv)
{
int sockfd, n;
char recvline[4096], sendline[4096];
struct sockaddr_in servaddr;

if( argc != 2){
printf("usage: ./client <ipaddress>\n");
exit(0);
}

if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
// 创建套接字描述符给sockfd
printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
exit(0);
}

memset(&servaddr, 0, sizeof(servaddr));
//结构体清零
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(6666);//端口号
if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
//Linux下IP地址转换函数，可以在将IP地址在“点分十进制”和“整数”之间转换
printf("inet_pton error for %s\n",argv[1]);
exit(0);
}

if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
//连接请求
printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
}

printf("send msg to server: \n");
fgets(sendline, 4096, stdin);
if( send(sockfd, sendline, strlen(sendline), 0) < 0)
{
printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
exit(0);
}

close(sockfd);
exit(0);
}
我们可以用ifconfig命令来查看我们本机的ip地址

接下来看UDP的一个例子，分别是服务器端（server.c）和客户端（client.c）

[cpp] view plaincopyprint?

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/socket.h>
  5. #include <netinet/in.h>
  6. #include <arpa/inet.h>
  7. #include <netdb.h>
  8. #include <errno.h>
  9. #include <sys/types.h>
  10. int port = 8888;
  11. int main()
  12. {
  13. int sockfd;
  14. int len;
  15. int z;
  16. char buf[255];
  17. struct sockaddr_in adr_inet;
  18. struct sockaddr_in adr_clnt;
  19. printf("等待客户端...\n");
  20. //建立IP地址
  21. adr_inet.sin_family = AF_INET;
  22. adr_inet.sin_port   = htons(port);
  23. adr_inet.sin_addr.s_addr = htonl(INADDR_ANY);
  24. bzero(&(adr_inet.sin_zero),8);
  25. len = sizeof(adr_clnt);
  26. //建立socket
  27. sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  28. if (sockfd == -1)
  29. {
  30. perror("socket 出错");
  31. exit(1);
  32. }
  33. //bind socket
  34. z = bind (sockfd, (struct sockaddr *) &adr_inet, sizeof (adr_inet));
  35. if (z == -1)
  36. {
  37. perror("bind出错");
  38. exit(1);
  39. }
  40. while(1)
  41. {
  42. z = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_clnt, &len);
  43. if (z < 0)
  44. {
  45. perror("recvfrom 出错");
  46. exit(1);
  47. }
  48. buf[z] = 0;
  49. printf("接收:%s",buf);
  50. if (strncmp(buf, "stop", 4) == 0)
  51. {
  52. printf("结束..\n");
  53. break;
  54. }
  55. }
  56. close(sockfd);
  57. exit(0);
  58. }

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

int port = 8888;

int main()
{
int sockfd;
int len;
int z;
char buf[255];
struct sockaddr_in adr_inet;
struct sockaddr_in adr_clnt;
printf("等待客户端...\n");
//建立IP地址

adr_inet.sin_family = AF_INET;
adr_inet.sin_port = htons(port);
adr_inet.sin_addr.s_addr = htonl(INADDR_ANY);
bzero(&(adr_inet.sin_zero),8);
len = sizeof(adr_clnt);
//建立socket
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1)
{
perror("socket 出错");
exit(1);
}

//bind socket
z = bind (sockfd, (struct sockaddr *) &adr_inet, sizeof (adr_inet));
if (z == -1)
{
perror("bind出错");
exit(1);
}
while(1)
{
z = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_clnt, &len);
if (z < 0)
{
perror("recvfrom 出错");
exit(1);
}
buf[z] = 0;
printf("接收:%s",buf);

if (strncmp(buf, "stop", 4) == 0)
{
printf("结束..\n");
break;
}
}
close(sockfd);
exit(0);
}

client.c

[cpp] view plaincopyprint?

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/socket.h>
  5. #include <netinet/in.h>
  6. #include <arpa/inet.h>
  7. #include <netdb.h>
  8. #include <errno.h>
  9. #include <sys/types.h>
  10. int port = 8888;
  11. int main()
  12. {
  13. int sockfd;
  14. int i  = 0;
  15. int z;
  16. char buf[80], str1[80];
  17. struct sockaddr_in adr_srvr;
  18. FILE *fp;
  19. printf("打开文件...\n");
  20. fp = fopen ("liu", "r");
  21. if (fp == NULL)
  22. {
  23. perror("打开文件失败\n");
  24. exit(1);
  25. }
  26. printf("连接服务端...\n");
  27. adr_srvr.sin_family = AF_INET;
  28. adr_srvr.sin_port   = htons(port);
  29. adr_srvr.sin_addr.s_addr = htonl(INADDR_ANY);
  30. bzero(&(adr_srvr.sin_zero), 8);
  31. sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  32. if (sockfd == -1)
  33. {
  34. perror("socket 出错");
  35. exit(1);
  36. }
  37. printf("发送文件.....\n");
  38. for (i=0; i<3; i++)
  39. {
  40. fgets(str1,80,fp);
  41. printf("%d:%s",i, str1);
  42. sprintf(buf, "%d:%s", i, str1);
  43. z = sendto (sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_srvr, sizeof(adr_srvr));
  44. if (z < 0)
  45. {
  46. perror("recvfrom 出错");
  47. exit(1);
  48. }
  49. }
  50. printf("发送....\n");
  51. sprintf(buf, "stop\n");
  52. z = sendto (sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_srvr, sizeof(adr_srvr));
  53. if (z < 0)
  54. {
  55. perror("sendto  出错");
  56. exit(1);
  57. }
  58. fclose(fp);
  59. close(sockfd);
  60. exit(0);
  61. }

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

int port = 8888;
int main()
{
int sockfd;
int i = 0;
int z;
char buf[80], str1[80];
struct sockaddr_in adr_srvr;
FILE *fp;
printf("打开文件...\n");

fp = fopen ("liu", "r");
if (fp == NULL)
{
perror("打开文件失败\n");
exit(1);
}
printf("连接服务端...\n");
adr_srvr.sin_family = AF_INET;
adr_srvr.sin_port = htons(port);
adr_srvr.sin_addr.s_addr = htonl(INADDR_ANY);
bzero(&(adr_srvr.sin_zero), 8);
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd == -1)
{
perror("socket 出错");
exit(1);
}
printf("发送文件.....\n");

for (i=0; i<3; i++)
{
fgets(str1,80,fp);
printf("%d:%s",i, str1);
sprintf(buf, "%d:%s", i, str1);
z = sendto (sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_srvr, sizeof(adr_srvr));
if (z < 0)
{
perror("recvfrom 出错");
exit(1);
}
}
printf("发送....\n");
sprintf(buf, "stop\n");
z = sendto (sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_srvr, sizeof(adr_srvr));

if (z < 0)
{
perror("sendto 出错");
exit(1);
}
fclose(fp);
close(sockfd);
exit(0);
}

这里简单比较一下TCP和UDP在编程实现上的一些区别：

建立一个TCP连接需要三次握手，而断开一个TCP则需要四个分节。当某个应用进程调用close(主动端)后(可以是服务器端，也可以是客户 
端)，这一端的TCP发送一个FIN，表示数据发送完毕；另一端(被动端)发送一个确认，当被动端待处理的应用进程都处理完毕后，发送一个FIN到主动 
端，并关闭套接口，主动端接收到这个FIN后再发送一个确认，到此为止这个TCP连接被断开。 
　　２、UDP套接口 
　　UDP套接口是无 
连接的、不可靠的数据报协议；既然他不可靠为什么还要用呢？其一：当应用程序使用广播或多播是只能使用UDP协议；其二：由于 
他是无连接的，所以速度快。因为UDP套接口是无连接的，如果一方的数据报丢失，那另一方将无限等待，解决办法是设置一个超时。 
　　在编写UDP套接口程序时，有几点要注意：建立套接口时socket函数的第二个参数应该是SOCK_DGRAM，说明是建立一个UDP套接 口；由于UDP是无连接的，所以服务器端并不需要listen或accept函数；当UDP套接口调用connect函数时，内核只记录连接放的IP地址 和端口，并立即返回给调用进程，正因为这个特性，UDP服务器程序中并不使用fock函数，用单进程就能完成所有客户的请求。

参考资料：

http://www.cnblogs.com/skynet/archive/2010/12/12/1903949.html（吴秦）

Linux软件工程师实用教程

http://blog.sina.com.cn/s/blog_493309600100clrw.html

深刻理解Linux进程间通信（IPC）郑彦兴

crocodile‘s blog

时间： 2024-10-01 22:24:06

linux系统socket通信编程详解函数的相关文章

linux系统socket通信编程2

一.概述 TCP(传输控制协议)和UDP(用户数据报协议是网络体系结构TCP/IP模型中传输层一层中的两个不同的通信协议. TCP:传输控制协议,一种面向连接的协议,给用户进程提供可靠的全双工的字节流,TCP套接口是字节流套接口(stream socket)的一种. UDP:用户数据报协议.UDP是一种无连接协议.UDP套接口是数据报套接口(datagram socket)的一种. 二.TCP和UDP介绍 1)基本TCP客户-服务器程序设计基本框架 说明:(三路握手)        1.客户端发

linux系统socket通信编程实践

简单介绍并实现了基于UDP(TCP)的windows(UNIX下流程基本一致)下的服务端和客户端的程序,本文继续探讨关于UDP编程的一些细节. 下图是一个简单的UDP客户/服务器模型: .imageplus-append-lu-img-txt { overflow: hidden; margin: 10px 0 } .imageplus-append-nova-txt { border: 1px solid #f2f2f2; font-family: Microsoft YaHei; line-

linux系统socket通信编程1

Linux下的Socket编程大体上包括Tcp Socket.Udp Socket即Raw Socket这三种,其中TCP和UDP方式的Socket编程用于编写应用层的socket程序,是我们用得比较多的,而Raw Socket则用得相对较少,不在本文介绍范围之列. TCP Socket 基于TCP协议的客户端/服务器程序的一般流程一般如下: 它基本上可以分为三个部分: 一.建立连接: 服务器调用socket().bind().listen()完成初始化后,调用accept()阻塞等待,处于监听

Linux 系统下 ifconfig 命令详解

Linux系统下网卡网络配置详解 Ifconfig命令使LINUX核心知道软件回送和网卡这样一些网络接口,这样Linux就可以使用它们. 除了上面介绍的这些用法之外,ifconfig命令用来监控和改变网络接口的状态,并且还可以带上很多命令行参数.下面是一个ifconfig的通用调用语法: #ifconfig interface [[-net -host] address [parameters]] 其中interface是网络接口名:address是分配给指定接口的主机名或IP地址.这里使用的主

LR杂记 - Linux系统监控工具之vmstat详解

题意:求一个无向图的,去掉两个不同的点后最多有几个连通分量. 思路:枚举每个点,假设去掉该点,然后对图求割点后连通分量数,更新最大的即可.算法相对简单,但是注意几个细节: 1:原图可能不连通. 2:有的连通分量只有一个点,当舍去该点时候,连通分量-1: 复习求割点的好题! #include<iostream> #include<cstdio> #include<vector> using namespace std; int n,m; vector<vector&

Ubuntu Linux系统下apt-get命令详解

Ubuntu Linux系统下apt-get命令详解(via|via) 常用的APT命令参数: apt-cache search package 搜索包 apt-cache show package 获取包的相关信息,如说明.大小.版本等 sudo apt-get install package 安装包 sudo apt-get install package - - reinstall 重新安装包 sudo apt-get -f install 修复安装"-f = ——fix-missing&

Linux系统I/O模型详解

前言 本文从基本的原理上了解用户空间.内核空间.进程上下文.及系统的五种常用I/O模型,加深对Linux系统的理解. 1. 概念说明 1.1 用户空间与内核空间 现在操作系统都是采用虚拟存储器,那么对32位操作系统而言,它的寻址空间(虚拟存储空间)为4G(2的32次方).操心系统的核心是内核,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件设备的所有权限.为了保证用户进程不能直接操作内核,保证内核的安全,操心系统将虚拟空间划分为两部分,一部分为内核空间,一部分为用户空间.针对li

深入理解linux系统的目录结构--详解

转自https://www.jb51.net/LINUXjishu/151820.html 对于每一个Linux学习者来说,了解Linux文件系统的目录结构,是学好Linux的至关重要的一步.,深入了解linux文件目录结构的标准和每个目录的详细功能,对于我们用好linux系统只管重要,下面我们就开始了解一下linux目录结构的相关知识. 当在使用Linux的时候,如果您通过ls –l / 就会发现,在/下包涵很多的目录,比如etc.usr.var.bin ... ... 等目录,而在这些目录中

linux系统下文件命令详解

/etc 目录下包含的用户信息文件有: 3.1.0 passwd: 用户库文件 用户名 UID,GID 和工作目录都在此文件中 Shadow:存放用户口令的文件,每个用户的 口令加密后都放在此文件中 Group :主要存储用户组信息 Fstab: 系统开机启动自动挂载分区列表,需要设置开机自动挂载的分区都可以在此文件中加入. Inittab: 这个命令的配置文件,此文件是linux启动的重要文件,用来完成对整个系统的基本初始化配置 Hosts: 设定用户自己的ip与名字的对应表,类似window