linuxsocketconnect

❶ linux下 socket函数的返回值代表什么

int socket;domain指明所使用的协议族，通常为PF_INET，表示互联网协议族；type参数指定socket的类型：SOCK_STREAM 或SOCK_DGRAM，Socket接口还定义了原始Socket，允许程序使用低层协议；protocol通常赋值"0"。

Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。 Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。

调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。 Socket执行体为你管理描述符表。

(1)linuxsocketconnect扩展阅读：

支持下述类型描述：

SOCK_STREAM 提供有序的、可靠的、双向的和基于连接的字节流，使用带外数据传送机制，为Internet地址族使用TCP。

SOCK_DGRAM 支持无连接的、不可靠的和使用固定大小（通常很小）缓冲区的数据报服务，为Internet地址族使用UDP。

SOCK_STREAM类型的套接口为全双向的字节流。对于流类套接口，在接收或发送数据前必需处于已连接状态。用connect()调用建立与另一套接口的连接，连接成功后，即可用send()和recv()传送数据。当会话结束后，调用close()。带外数据根据规定用send()和recv()来接收。

❷ linux socket中的connect无法连接

中间加几个调试语句
struct hostent *ho=gethostbyname(url);
if (!ho) fprintf(stderr, "WRONG URL\n");
in.sin_addr.s_addr=((unsigned long *)(ho->h_addr_list[0]))[0];
fprintf(stderr, "ip = %s\n", inet_addr(in.sin_addr.s_addr));
in.sin_family=ho->h_addrtype;
in.sin_port=htons(1234);
connect(sock,(struct sockaddr*)&in,sizeof(in));
你看看解释出来的IP地址对不对，然后用telnet ip 1234试试

❸ linux socket 如何发现主机是否活着

使用基本socket函数来检测。
Linux系统是通过提供套接字(socket)来进行网络编程的。网络的socket数据传输是一种特殊的I/O,socket也是一种文件描述符。socket也有一个类似于打
开文件的函数：socket(),调用socket(),该函数返回一个整型的socket的描述符，随后的连接建立、数据传输等操作也都是通过该socket实现。
1、socket函数
syntax:
int socket(int domain, int type, int protocol);
功能说明：
调用成功，返回socket文件描述符；失败，返回－1，并设置errno
参数说明：
domain指明所使用的协议族，通常为PF_INET，表示TCP/IP协议；
type参数指定socket的类型，基本上有三种：数据流套接字、数据报套接字、原始套接字
protocol通常赋值"0"。
两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。socket数据结构中包含这五种信息。
2、bind函数
syntax:
int bind(int sock_fd,struct sockaddr_in *my_addr, int addrlen);
功能说明：
将套接字和指定的端口相连。成功返回0，否则，返回－1，并置errno.
参数说明：
sock_fd是调用socket函数返回值,
my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针；
struct sockaddr_in结构类型是用来保存socket信息的：
struct sockaddr_in {
short int sin_family;
unsigned short int sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
};
addrlen为sockaddr的长度。
3、connect函数
syntax:
int connect(int sock_fd, struct sockaddr *serv_addr,int addrlen);
功能说明：
客户端发送服务请求。成功返回0，否则返回－1，并置errno。
参数说明：
sock_fd 是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是结构sockaddr_in的长度。
4、listen函数
syntax:
int listen(int sock_fd， int backlog);
功能说明：
等待指定的端口的出现客户端连接。调用成功返回0，否则，返回－1，并置errno.
参数说明：
sock_fd 是socket()函数返回值；
backlog指定在请求队列中允许的最大请求数
5、accecpt函数
syntax:
int accept(int sock_fd, struct sockadd_in* addr, int addrlen);
功能说明：
用于接受客户端的服务请求，成功返回新的套接字描述符，失败返回－1，并置errno。
参数说明：
sock_fd是被监听的socket描述符，
addr通常是一个指向sockaddr_in变量的指针，
addrlen是结构sockaddr_in的长度。
6、write函数
syntax:
ssize_t write(int fd,const void *buf,size_t nbytes)
功能说明：
write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数.失败时返回-1. 并设置errno变量.
在网络程序中,当我们向套接字文件描述符写时有俩种可能：
1)write的返回值大于0,表示写了部分或者是全部的数据.
2)返回的值小于0,此时出现了错误.需要根据错误类型来处理.
如果错误为EINTR表示在写的时候出现了中断错误.
如果错误为EPIPE表示网络连接出现了问题.
7、read函数
syntax:
ssize_t read(int fd,void *buf,size_t nbyte)
函数说明：
read函数是负责从fd中读取内容.当读成功时,read返回实际所读的字节数,如果返回的值是0 表示已经读到文件的结束了,小于0表示出现了错误.
如果错误为EINTR说明读是由中断引起的,
如果错误是ECONNREST表示网络连接出了问题.
8、close函数
syntax:
int close(sock_fd);
说明:
当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：
函数运行成功返回0，否则返回-1

❹ linux socket 连接超时 怎么解决

今天发现自己的系统存在很严重缺陷，当前台关闭的时候后台就无法正常工作，原因很好定位，后台的socket连接超时时间过长，系统默认时间好像是75秒，于是找资料，根据下边文章中的内容解决了，把超时时间设为5秒后，感觉好多了。看来还有好多东西需要慢慢挖掘阿！

如何设置socket的Connect超时(linux)
[From]http://dev.cbw.com/c/c/200510195601_4292587.shtml
1.首先将标志位设为Non-blocking模式，准备在非阻塞模式下调用connect函数
2.调用connect，正常情况下，因为TCP三次握手需要一些时间；而非阻塞调用只要不能立即完成就会返回错误，所以这里会返回EINPROGRESS，表示在建立连接但还没有完成。
3.在读套接口描述符集(fd_set rset)和写套接口描述符集(fd_set wset)中将当前套接口置位（用FD_ZERO()、FD_SET()宏），并设置好超时时间(struct timeval *timeout)
4.调用select( socket, &rset, &wset, NULL, timeout )
返回0表示connect超时
如果你设置的超时时间大于75秒就没有必要这样做了，因为内核中对connect有超时限制就是75秒。

[From]http://www.ycgczj.com.cn/34733.html
网络编程中socket的分量我想大家都很清楚了，socket也就是套接口，在套接口编程中，提到超时的概念，我们一下子就能想到3个：发送超时，接收超时，以及select超时（注： select函数并不是只用于套接口的，但是套接口编程中用的比较多），在connect到目标主机的时候，这个超时是不由我们来设置的。不过正常情况下这个超时都很长，并且connect又是一个阻塞方法，一个主机不能连接，等着connect返回还能忍受，你的程序要是要试图连接多个主机，恐怕遇到多个不能连接的主机的时候，会塞得你受不了的。我也废话少说，先说说我的方法，如果你觉得你已掌握这种方法，你就不用再看下去了，如果你还不了解，我愿意与你分享。本文是已在Linux下的程序为例子，不过拿到Windows中方法也是一样，无非是换几个函数名字罢了。
Linux中要给connect设置超时，应该是有两种方法的。一种是该系统的一些参数，这个方法我不讲，因为我讲不清楚:P，它也不是编程实现的。另外一种方法就是变相的实现connect的超时，我要讲的就是这个方法，原理上是这样的：
1．建立socket
2．将该socket设置为非阻塞模式
3．调用connect()
4．使用select()检查该socket描述符是否可写（注意，是可写）
5．根据select()返回的结果判断connect()结果
6．将socket设置为阻塞模式（如果你的程序不需要用阻塞模式的，这步就省了，不过一般情况下都是用阻塞模式的，这样也容易管理）
如果你对网络编程很熟悉的话，其实我一说出这个过程你就知道怎么写你的程序了，下面给出我写的一段程序，仅供参考。
/******************************
* Time out for connect()
* Write by Kerl W
******************************/
#include <sys/socket.h>
#include <sys/types.h>
#define TIME_OUT_TIME 20 //connect超时时间20秒
int main(int argc , char **argv)
{
………………
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0) exit(1);
struct sockaddr_in serv_addr;
………//以服务器地址填充结构serv_addr
int error=-1, len;
len = sizeof(int);
timeval tm;
fd_set set;
unsigned long ul = 1;
ioctl(sockfd, FIONBIO, &ul); //设置为非阻塞模式
bool ret = false;
if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
{
tm.tv_set = TIME_OUT_TIME;
tm.tv_uset = 0;
FD_ZERO(&set);
FD_SET(sockfd, &set);
if( select(sockfd+1, NULL, &set, NULL, &tm) > 0)
{
getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
if(error == 0) ret = true;
else ret = false;
} else ret = false;
}
else ret = true;
ul = 0;
ioctl(sockfd, FIONBIO, &ul); //设置为阻塞模式
if(!ret)
{
close( sockfd );
fprintf(stderr , "Cannot Connect the server!n");
return;
}
fprintf( stderr , "Connected!n");
//下面还可以进行发包收包操作
……………
}
以上代码片段，仅供参考，也是为初学者提供一些提示，主要用到的几个函数，select, ioctl, getsockopt都可以找到相关资料，具体用法我这里就不赘述了，你只需要在linux中轻轻的敲一个man <函数名>就能够看到它的用法。
此外我需要说明的几点是，虽然我们用ioctl把套接口设置为非阻塞模式，不过select本身是阻塞的，阻塞的时间就是其超时的时间由调用select 的时候的最后一个参数timeval类型的变量指针指向的timeval结构变量来决定的，timeval结构由一个表示秒数的和一个表示微秒数（long类型）的成员组成，一般我们设置了秒数就行了，把微妙数设为0（注：1秒等于100万微秒）。而select函数另一个值得一提的参数就是上面我们用到的fd_set类型的变量指针。调用之前，这个变量里面存了要用select来检查的描述符，调用之后，针对上面的程序这里面是可写的描述符，我们可以用宏FD_ISSET来检查某个描述符是否在其中。由于我这里只有一个套接口描述符，我就没有使用FD_ISSET宏来检查调用select之后这个sockfd是否在set里面，其实是需要加上这个判断的。不过我用了getsockopt来检查，这样才可以判断出这个套接口是否是真的连接上了，因为我们只是变相的用select来检查它是否连接上了，实际上select检查的是它是否可写，而对于可写，是针对以下三种条件任一条件满足时都表示可写的：
1）套接口发送缓冲区中的可用控件字节数大于等于套接口发送缓冲区低潮限度的当前值，且或者i)套接口已连接，或者ii)套接口不要求连接（UDP方式的）
2）连接的写这一半关闭。
3）有一个套接口错误待处理。
这样，我们就需要用getsockopt函数来获取套接口目前的一些信息来判断是否真的是连接上了，没有连接上的时候还能给出发生了什么错误，当然我程序中并没有标出那么多状态，只是简单的表示可连接/不可连接。
下面我来谈谈对这个程序测试的结果。我针对3种情形做了测试：
1． 目标机器网络正常的情况
可以连接到目标主机，并能成功以阻塞方式进行发包收包作业。
2． 目标机器网络断开的情况
在等待设置的超时时间（上面的程序中为20秒）后，显示目标主机不能连接。
3． 程序运行前断开目标机器网络，超时时间内，恢复目标机器的网络
在恢复目标主机网络连接之前，程序一只等待，恢复目标主机后，程序显示连接目标主机成功，并能成功以阻塞方式进行发包收包作业。
以上各种情况的测试结果表明，这种设置connect超时的方法是完全可行的。我自己是把这种设置了超时的connect封装到了自己的类库，用在一套监控系统中，到目前为止，运行还算正常。这种编程实现的connect超时比起修改系统参数的那种方法的有点就在于它只用于你的程序之中而不影响系统。

❺ 请问linux怎么增大socket连接上限

1、修改用户进程可打开文件数限制
在Linux平台上，无论编写客户端程序还是服务端程序，在进行高并发TCP连接处理时，
最高的并发数量都要受到系统对用户单一进程同时可打开文件数量的限制(这是因为系统
为每个TCP连接都要创建一个socket句柄，每个socket句柄同时也是一个文件句柄)。
可使用ulimit命令查看系统允许当前用户进程打开的文件数限制：
[speng@as4 ~]$ ulimit -n
1024
这表示当前用户的每个进程最多允许同时打开1024个文件，这1024个文件中还得除去
每个进程必然打开的标准输入，标准输出，标准错误，服务器监听 socket，
进程间通讯的unix域socket等文件，那么剩下的可用于客户端socket连接的文件数就
只有大概1024-10=1014个左右。也就是说缺省情况下，基于Linux的通讯程序最多允许
同时1014个TCP并发连接。
对于想支持更高数量的TCP并发连接的通讯处理程序，就必须修改Linux对当前用户的
进程同时打开的文件数量的软限制(soft limit)和硬限制(hardlimit)。其中软限制
是指Linux在当前系统能够承受的范围内进一步限制用户同时打开的文件数；硬限制
则是根据系统硬件资源状况(主要是系统内存)计算出来的系统最多可同时打开的文件数量。
通常软限制小于或等于硬限制。

修改上述限制的最简单的办法就是使用ulimit命令：
[speng@as4 ~]$ ulimit -n
上述命令中，在中指定要设置的单一进程允许打开的最大文件数。如果系统回显
类似于“Operation notpermitted”之类的话，说明上述限制修改失败，实际上是
因为在中指定的数值超过了Linux系统对该用户打开文件数的软限制或硬限制。
因此，就需要修改Linux系统对用户的关于打开文件数的软限制和硬限制。

第一步，修改/etc/security/limits.conf文件，在文件中添加如下行：
speng soft nofile 10240
speng hard nofile 10240
其中speng指定了要修改哪个用户的打开文件数限制，可用’*'号表示修改所有用户的限制；
soft或hard指定要修改软限制还是硬限制；10240则指定了想要修改的新的限制值，
即最大打开文件数(请注意软限制值要小于或等于硬限制)。修改完后保存文件。

第二步，修改/etc/pam.d/login文件，在文件中添加如下行：
session required /lib/security/pam_limits.so
这是告诉Linux在用户完成系统登录后，应该调用pam_limits.so模块来设置系统对
该用户可使用的各种资源数量的最大限制(包括用户可打开的最大文件数限制)，
而pam_limits.so模块就会从/etc/security/limits.conf文件中读取配置来设置这些限制值。
修改完后保存此文件。

第三步，查看Linux系统级的最大打开文件数限制，使用如下命令：
[speng@as4 ~]$ cat /proc/sys/fs/file-max
12158
这表明这台Linux系统最多允许同时打开(即包含所有用户打开文件数总和)12158个文件，
是Linux系统级硬限制，所有用户级的打开文件数限制都不应超过这个数值。通常这个系统级
硬限制是Linux系统在启动时根据系统硬件资源状况计算出来的最佳的最大同时打开文件数限制，
如果没有特殊需要，不应该修改此限制，除非想为用户级打开文件数限制设置超过此限制的值。

修改此硬限制的方法是修改/etc/rc.local脚本，在脚本中添加如下行：
echo 22158 > /proc/sys/fs/file-max
这是让Linux在启动完成后强行将系统级打开文件数硬限制设置为22158。修改完后保存此文件。

完成上述步骤后重启系统，一般情况下就可以将Linux系统对指定用户的单一进程允许同时
打开的最大文件数限制设为指定的数值。如果重启后用 ulimit-n命令查看用户可打开文件数限制
仍然低于上述步骤中设置的最大值，这可能是因为在用户登录脚本/etc/profile中使用ulimit -n命令
已经将用户可同时打开的文件数做了限制。由于通过ulimit-n修改系统对用户可同时打开文件的
最大数限制时，新修改的值只能小于或等于上次 ulimit-n设置的值，因此想用此命令增大这个
限制值是不可能的。
所以，如果有上述问题存在，就只能去打开/etc/profile脚本文件，
在文件中查找是否使用了ulimit-n限制了用户可同时打开的最大文件数量，如果找到，
则删除这行命令，或者将其设置的值改为合适的值，然后保存文件，用户退出并重新登录系统即可。
通过上述步骤，就为支持高并发TCP连接处理的通讯处理程序解除关于打开文件数量方面的系统限制。
2、修改网络内核对TCP连接的有关限制
在Linux上编写支持高并发TCP连接的客户端通讯处理程序时，有时会发现尽管已经解除了系统
对用户同时打开文件数的限制，但仍会出现并发TCP连接数增加到一定数量时，再也无法成功
建立新的TCP连接的现象。出现这种现在的原因有多种。

第一种原因可能是因为Linux网络内核对本地端口号范围有限制。此时，进一步分析为什么无法
建立TCP连接，会发现问题出在connect()调用返回失败，查看系统错误提示消息是“Can’t assign requestedaddress”。同时，如果在此时用tcpmp工具监视网络，会发现根本没有TCP连接时客户端
发SYN包的网络流量。这些情况说明问题在于本地Linux系统内核中有限制。
其实，问题的根本原因
在于Linux内核的TCP/IP协议实现模块对系统中所有的客户端TCP连接对应的本地端口号的范围
进行了限制(例如，内核限制本地端口号的范围为1024~32768之间)。当系统中某一时刻同时
存在太多的TCP客户端连接时，由于每个TCP客户端连接都要占用一个唯一的本地端口号
(此端口号在系统的本地端口号范围限制中)，如果现有的TCP客户端连接已将所有的本地端口号占满，
则此时就无法为新的TCP客户端连接分配一个本地端口号了，因此系统会在这种情况下在connect()
调用中返回失败，并将错误提示消息设为“Can’t assignrequested address”。
有关这些控制
逻辑可以查看Linux内核源代码，以linux2.6内核为例，可以查看tcp_ipv4.c文件中如下函数：
static int tcp_v4_hash_connect(struct sock *sk)
请注意上述函数中对变量sysctl_local_port_range的访问控制。变量sysctl_local_port_range
的初始化则是在tcp.c文件中的如下函数中设置：
void __init tcp_init(void)
内核编译时默认设置的本地端口号范围可能太小，因此需要修改此本地端口范围限制。
第一步，修改/etc/sysctl.conf文件，在文件中添加如下行：
net.ipv4.ip_local_port_range = 1024 65000
这表明将系统对本地端口范围限制设置为1024~65000之间。请注意，本地端口范围的最小值
必须大于或等于1024；而端口范围的最大值则应小于或等于65535。修改完后保存此文件。
第二步，执行sysctl命令：
[speng@as4 ~]$ sysctl -p
如果系统没有错误提示，就表明新的本地端口范围设置成功。如果按上述端口范围进行设置，
则理论上单独一个进程最多可以同时建立60000多个TCP客户端连接。

第二种无法建立TCP连接的原因可能是因为Linux网络内核的IP_TABLE防火墙对最大跟踪的TCP
连接数有限制。此时程序会表现为在 connect()调用中阻塞，如同死机，如果用tcpmp工具监视网络，
也会发现根本没有TCP连接时客户端发SYN包的网络流量。由于 IP_TABLE防火墙在内核中会对
每个TCP连接的状态进行跟踪，跟踪信息将会放在位于内核内存中的conntrackdatabase中，
这个数据库的大小有限，当系统中存在过多的TCP连接时，数据库容量不足，IP_TABLE无法为
新的TCP连接建立跟踪信息，于是表现为在connect()调用中阻塞。此时就必须修改内核对最大跟踪
的TCP连接数的限制，方法同修改内核对本地端口号范围的限制是类似的：

第一步，修改/etc/sysctl.conf文件，在文件中添加如下行：
net.ipv4.ip_conntrack_max = 10240
这表明将系统对最大跟踪的TCP连接数限制设置为10240。请注意，此限制值要尽量小，
以节省对内核内存的占用。

第二步，执行sysctl命令：
[speng@as4 ~]$ sysctl -p
如果系统没有错误提示，就表明系统对新的最大跟踪的TCP连接数限制修改成功。
如果按上述参数进行设置，则理论上单独一个进程最多可以同时建立10000多个TCP客户端连接。

3、使用支持高并发网络I/O的编程技术
在Linux上编写高并发TCP连接应用程序时，必须使用合适的网络I/O技术和I/O事件分派机制。
可用的I/O技术有同步I/O，非阻塞式同步I/O(也称反应式I/O)，以及异步I/O。在高TCP并发的情形下，
如果使用同步I/O，这会严重阻塞程序的运转，除非为每个TCP连接的I/O创建一个线程。

但是，过多的线程又会因系统对线程的调度造成巨大开销。因此，在高TCP并发的情形下使用
同步 I/O是不可取的，这时可以考虑使用非阻塞式同步I/O或异步I/O。非阻塞式同步I/O的技术包括使用select()，poll()，epoll等机制。异步I/O的技术就是使用AIO。

从I/O事件分派机制来看，使用select()是不合适的，因为它所支持的并发连接数有限(通常在1024个以内)。
如果考虑性能，poll()也是不合适的，尽管它可以支持的较高的TCP并发数，但是由于其采用
“轮询”机制，当并发数较高时，其运行效率相当低，并可能存在I/O事件分派不均，导致部分TCP
连接上的I/O出现“饥饿”现象。而如果使用epoll或AIO，则没有上述问题(早期Linux内核的AIO技术
实现是通过在内核中为每个 I/O请求创建一个线程来实现的，这种实现机制在高并发TCP连接的情形下
使用其实也有严重的性能问题。但在最新的Linux内核中，AIO的实现已经得到改进)。

综上所述，在开发支持高并发TCP连接的Linux应用程序时，应尽量使用epoll或AIO技术来实现并发的
TCP连接上的I/O控制，这将为提升程序对高并发TCP连接的支持提供有效的I/O保证。

内核参数sysctl.conf的优化

/etc/sysctl.conf 是用来控制linux网络的配置文件，对于依赖网络的程序（如web服务器和cache服务器）
非常重要，RHEL默认提供的最好调整。

推荐配置（把原/etc/sysctl.conf内容清掉，把下面内容复制进去）：
net.ipv4.ip_local_port_range = 1024 65536
net.core.rmem_max=16777216
net.core.wmem_max=16777216
net.ipv4.tcp_rmem=4096 87380 16777216
net.ipv4.tcp_wmem=4096 65536 16777216
net.ipv4.tcp_fin_timeout = 10
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_window_scaling = 0
net.ipv4.tcp_sack = 0
net.core.netdev_max_backlog = 30000
net.ipv4.tcp_no_metrics_save=1
net.core.somaxconn = 262144
net.ipv4.tcp_syncookies = 0
net.ipv4.tcp_max_orphans = 262144
net.ipv4.tcp_max_syn_backlog = 262144
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 2

这个配置参考于cache服务器varnish的推荐配置和SunOne 服务器系统优化的推荐配置。

varnish调优推荐配置的地址为：http://varnish.projects.linpro.no/wiki/Performance

不过varnish推荐的配置是有问题的，实际运行表明“net.ipv4.tcp_fin_timeout = 3”的配置
会导致页面经常打不开；并且当网友使用的是IE6浏览器时，访问网站一段时间后，所有网页都会
打不开，重启浏览器后正常。可能是国外的网速快吧，我们国情决定需要
调整“net.ipv4.tcp_fin_timeout = 10”，在10s的情况下，一切正常（实际运行结论）。

修改完毕后，执行：
/sbin/sysctl -p /etc/sysctl.conf
/sbin/sysctl -w net.ipv4.route.flush=1

命令生效。为了保险起见，也可以reboot系统。

调整文件数：
linux系统优化完网络必须调高系统允许打开的文件数才能支持大的并发，默认1024是远远不够的。

执行命令：
Shell代码
echo ulimit -HSn 65536 >> /etc/rc.local
echo ulimit -HSn 65536 >>/root/.bash_profile
ulimit -HSn 65536

❻ Linux 进程间套接字通信（Socket)基础知识

姓名：罗学元    学号：21181214375    学院：广州研究院

【嵌牛导读】Linux进程间套接字通信基础

【嵌牛鼻子】Linux 进程间套接字及通信介绍

【嵌牛提问】Linux进程间套接字包含哪些内容，如何实现通信

一、套接字（Socket）通信原理

套接字通信允许互联的位于不同计算机上的进程之间实现通信功能。

二、套接字的属性

套接字的特性由3个属性确定，它们分别是：域、类型和协议。

1. 套接字的域

它指定套接字通信中使用的网络介质，最常见的套接字域是AF_INET，它指的是Internet网络。当客户使用套接字进行跨网络的连接时，它就需要用到服务器计算机的IP地址和端口来指定一台联网机器上的某个特定服务，所以在使用socket作为通信的终点，服务器应用程序必须在开始通信之前绑定一个端口，服务器在指定的端口等待客户的连接。

另一个域AF_UNIX表示UNIX文件系统，就是文件输入/输出，它的地址就是文件名。

2. 套接字类型

因特网提供了两种通信机制：流（stream）和数据报（datagram），因而套接字的类型也就分为流套接字和数据报套接字。我们主要看流套接字。

流套接字由类型SOCK_STREAM指定，它们是在AF_INET域中通过TCP/IP连接实现，同时也是AF_UNIX中常用的套接字类型。

流套接字提供的是一个有序、可靠、双向字节流的连接，因此发送的数据可以确保不会丢失、重复或乱序到达，而且它还有一定的出错后重新发送的机制。

与流套接字相对的是由类型SOCK_DGRAM指定的数据报套接字，它不需要建立连接和维持一个连接，它们在AF_INET中通常是通过UDP/IP实现的。它对可以发送的数据的长度有限制，数据报作为一个单独的网络消息被传输，它可能丢失、复制或错乱到达，UDP不是一个可靠的协议，但是它的速度比较高，因为它并不需要总是要建立和维持一个连接。

3.套接字协议

只要底层的传输机制允许不止一个协议来提供要求的套接字类型，我们就可以为套接字选择一个特定的协议。通常只需要使用默认值。

三、套接字地址

每个套接字都有其自己的地址格式，对于AF_UNIX域套接字来说，它的地址由结构sockaddr_un来描述，该结构定义在头文件

struct sockaddr_un{

sa_family_t sun_family;  //AF_UNIX，它是一个短整型

char sum_path[];  //路径名

};

对于AF_INET域套接字来说，它的地址结构由sockaddr_in来描述，它至少包括以下几个成员：

struct sockaddr_in{

short int sin_family;  //AN_INET

unsigned short int sin_port;  //端口号

struct in_addr sin_addr;    //IP地址

}

而in_addr被定义为：

struct in_addr{

unsigned long int s_addr;

}

四、基于流套接字的客户/服务器的工作流程

使用socket进行进程通信的进程采用的客户/服务器系统是如何工作的呢？

1.服务器端

首先，服务器应用程序用系统调用socket来创建一个套接字，它是系统分配给该服务器进程的类似文件描述符的资源，它不能与其他的进程共享。

接下来，服务器进程会给套接字起个名字，我们使用系统调用bind来给套接字命名。然后服务器进程就开始等待客户连接到这个套接字。

然后，系统调用listen来创建一个队列，并将其用于存放来自客户的进入连接。

最后，服务器通过系统调用accept来接受客户的连接。它会创建一个与原有的命名套接不同的新套接字，这个套接字只用于与这个特定客户端进行通信，而命名套接字（即原先的套接字）则被保留下来继续处理来自其他客户的连接。

2.客户端

基于socket的客户端比服务器端简单。同样，客户应用程序首先调用socket来创建一个未命名的套接字，然后讲服务器的命名套接字作为一个地址来调用connect与服务器建立连接。

一旦连接建立，我们就可以像使用底层的文件描述符那样用套接字来实现双向数据的通信。

❼ linux tcp 同一个socket能多次connect吗

linux socket跟文件描述符一样，在内核态对应了file类型的数据结构。但是对于用户态进程而言，其标识符即文件描述符，跟操作文件的文件描述符完全一样，是整型值。可以像close文件描述符一样通过close函数来关闭socket 文件描述符。

❽ linux socket 求助，总是提示 Connection refused

1. 首先那个要加上listen,listen会把socket创建的套接字从CLOSE状态，转换到LISTEN状态
2. err = bind(server_socket, (sockaddr*)&server_addr, sizeof(server_addr));这里强制转换为什么可以直接用sockaddr *呢，不应该是struct sockaddr *呢？
3. server_addr.sin_addr.s_addr = inet_addr(SERVER_IP)这里最好还是用inet_pton吧
4.
err = connect(s,(sockaddr*)&server_addr, sizeof(sockaddr));这句你仔细看看，最后一个sizeof里面的东西。改改差不多了应该，怎么能编译不报错呢，编译的时候加上-Wall试试