socket网络编程

最新推荐文章于 2024-11-10 15:23:27 发布

baidu_27386223

最新推荐文章于 2024-11-10 15:23:27 发布

阅读量310

点赞数

分类专栏： C++/VC unix C网络编程文章标签：网络编程

unix C网络编程同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

C++/VC

5 篇文章 0 订阅

订阅专栏

1.网络中进程间如何通信？

分为四类：消息传递（管道，FIFO,消息队列) , 同步（互斥量，条件变量，读写锁，信号量）

                共享内存（匿名和具名的）  ，  远程过程调用（Solaris门和Sun RPC)

但是网络中进程之间是如何通信的呢？

首先解决如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在

网络中是行不通的。但是TCP/IP已经帮我们解决这个问题了，网络层的“ip地址”可以唯一标识网络中的主机，

而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用（ip地址，协议，端口）就可以标识网络

的进程了。

2.网络中socket的基本操作

socket是“open--write/read--close"模式的一种实现。

   1.1 socket()函数：

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

        socket函数对应于普通文件的打开操作，返回一个文件描述符。

        domain:协议域   AF_INET(网络），AF_LOCAL(本机),AF_INET6,AF_ROUTE等

                     AF_INET决定了要用ipv4地址（32位）与端口号(16位的）组合，

         type :指定socket类型。常用的socket类型有，SOCK_STREAM,SOCK_DGRAM,SOCK_RAW,

                   SOCK_PACKET,等

        protocol: 指定协议。常用的协议IPPROTO_TCP(TCP协议),IPPTOTO_UDP(UDP协议）

                          IPPROTO_SCTP(STCP传输协议)等

         注意：（1）并不是上面的type和protocol可以随意组合，如SOCK_STREAM不可以跟IPPROTO_UDP组合，

             当protocol为0时，会自动选择type类型对应的默认协议。

                     （2）当我们调用socke创建一个socket时，返回的socket描述字存在于协议族中，没有分配一个具体

                         的地址，如果要赋值一个地址，就必须调用bind()函数，否则调用connect()和listen(）只会

             分配一个随机的端口。



   1.2 bind()函数

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

     函数三个参数：

       sockfd----描述字

       addr ------一个指针，指向要绑定给sockfd的协议地址

   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 */
};

AF_LOCAL对应的：

struct sockaddr_un {
sa_family_t sun_family; /* AF_UNIX */
char sun_path[UNIX_PATH_MAX]; /* pathname */
};

 addrlen:  对应的是地址的长度

网络字节序与主机字节序：

主机字节序：就是平常说的大端和小端模式：不同的CPU有不同的字节序类型，这些字节序是指整数在

内存中保存的顺序，这个叫做主机序。

    小端系统：低位字节排放在内存的低字节端，高位字节排放在内存中的高地址端。

   大端系统： 高位字节排放在内村的低字节端，低位字节排放在内存中高地址段。

网络字节序：由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序（大端字节序)

   注意：在将一个地址绑定到socket的时候，将主机字节序转换成网络字节序。




1.3  listen()，connect()函数

      int listen(int  sockfd, int backlog);

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

     backlog： 相应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函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

   #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

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);

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){
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);

}

客户端代码：

客户端

include

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){
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){
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);
exit(0);
}

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);

}

当然上面的代码很简单，也有很多缺点，这就只是简单的演示socket的基本函数使用。其实不管有多复杂的网络程序，都使用的这些基本函数。上面的服务器使用的是迭代模式的，即只有处理完一个客户端请求才会去处理下一个客户端的请求，这样的服务器处理能力是很弱的，现实中的服务器都需要有并发处理能力！为了需要并发处理，服务器需要fork()一个新的进程或者线程去处理请求等。