linux下SO_LINGER使用,SO_LINGER选项的作用和意义
一、选项在内核中的使用
搜索一下内核中对于SO_LINGER的使用，主要集中在socket的关闭、两个必不可少的set/get sockopt函数中，所以真正使用这个选项的地方并不多，所以分析起来可能并不复杂，也没什么影响，但是正如之前所说的，问题的严重性和重要性往往不是问题本身决定的，而是它可能引起的后果决定的，所以还是简单总结一下这个选项的意义。
两个读取和设置该选项的内容就直接跳过了，现在直接看一下这个参数真正起作用的位置。
二、socket文件的关闭
sock_close--->>>sock_release
if (sock->ops) {
struct module *owner = sock->ops->owner;
sock->ops->release(sock);
sock->ops = NULL;
module_put(owner);
}
对于TCP连接来说，这个注册的位置在static int __init inet_init(void)函数中初始化
for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
inet_register_protosw(q);
注册的TCP结构为
{
.type = SOCK_STREAM,
.protocol = IPPROTO_TCP,
.prot = &tcp_prot,
.ops = &inet_stream_ops,
.capability = -1,
.no_check = 0,
.flags = INET_PROTOSW_PERMANENT |
INET_PROTOSW_ICSK,
},
注册之后TCP socket创建的时候通过inet_create中找到对应的注册协议，然后初始化sock的操作
sock->ops = answer->ops;
所以这里的sock的ops就被初始化为下面的结构
const struct proto_ops inet_stream_ops = {
.family = PF_INET,
.owner = THIS_MODULE,
.release = inet_release,
.bind = inet_bind,
.connect = inet_stream_connect,
.socketpair = sock_no_socketpair,
.accept = inet_accept,
.getname = inet_getname,
.poll = tcp_poll,
.ioctl = inet_ioctl,
.listen = inet_listen,
.shutdown = inet_shutdown,
.setsockopt = sock_common_setsockopt,
.getsockopt = sock_common_getsockopt,
.sendmsg = inet_sendmsg,
.recvmsg = sock_common_recvmsg,
.mmap = sock_no_mmap,
.sendpage = tcp_sendpage,
#ifdef CONFIG_COMPAT
.compat_setsockopt = compat_sock_common_setsockopt,
.compat_getsockopt = compat_sock_common_getsockopt,
#endif
}
接下来的事情就水到渠成了。
三、socket关闭时SO_LINGER的作用
1、网络层关闭
inet_release中
if (sk) {
long timeout;
/* Applications forget to leave groups before exiting */
ip_mc_drop_socket(sk);
/* If linger is set, we don't return until the close
* is complete. Otherwise we return immediately. The
* actually closing is done the same either way.
*
* If the close is due to the process exiting, we never
* linger..
*/
timeout = 0;
if (sock_flag(sk, SOCK_LINGER) &&
!(current->flags & PF_EXITING)) 此时LINGER第一次出场，此时如果设置了SOCK_LINGER选项，此时的超时时间为linger中设置的超时时间，如果timeout为零表示无限等待。
timeout = sk->sk_lingertime;
sock->sk = NULL;
sk->sk_prot->close(sk, timeout);
}
2、tcp层关闭
tcp_close中对于SO_LINGER的处理
if (data_was_unread) {
/* Unread data was tossed, zap the connection. */
NET_INC_STATS_USER(LINUX_MIB_TCPABORTONCLOSE);
tcp_set_state(sk, TCP_CLOSE);
tcp_send_active_reset(sk, GFP_KERNEL);
} else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {如果设置了SO_LINGER选项，并且LINGER时间为0，则直接丢掉缓冲区中未发送数据，否则在在下面的if分支中判断进入FIN_WAIT1状态，并且发送tcp_fin包，开始断开连接，在tcp_disconnect中通过tcp_need_reset判断，会向对方发送RESET命令，导致对方不优雅的结束。
/* Check zero linger _after_ checking for unread data. */
sk->sk_prot->disconnect(sk, 0);
NET_INC_STATS_USER(LINUX_MIB_TCPABORTONDATA);
} else if (tcp_close_state(sk)) {
/* We FIN if the application ate all the data before
* zapping the connection.
*/
/* RED-PEN. Formally speaking, we have broken TCP state
* machine. State transitions:
*
* TCP_ESTABLISHED -> TCP_FIN_WAIT1
* TCP_SYN_RECV -> TCP_FIN_WAIT1 (forget it, it's impossible)
* TCP_CLOSE_WAIT -> TCP_LAST_ACK
*
* are legal only when FIN has been sent (i.e. in window),
* rather than queued out of window. Purists blame.
*
* F.e. "RFC state" is ESTABLISHED,
* if Linux state is FIN-WAIT-1, but FIN is still not sent.
*
* The visible declinations are that sometimes
* we enter time-wait state, when it is not required really
* (harmless), do not send active resets, when they are
* required by specs (TCP_ESTABLISHED, TCP_CLOSE_WAIT, when
* they look as CLOSING or LAST_ACK for Linux)
* Probably, I missed some more holelets.
* --ANK
*/
tcp_send_fin(sk);
}
3、FIN_WAIT1何时结束
由于发送方发送了FIN包，所以当FIN包被确认之后就可以认为FIN1时间结束了。如果对方一直不发送FIN的回应包，那么此时只有等待正常的TCP写操作超时来关闭套接口。
如果设置了LINGER1表示，在inet_release中，这个lingertime将会传递给tcp_close函数，从而在lingertime之后超时，超时之后套接口被关闭，这也就是lingertime非零时的意义。
四、如果listen套接口设置了该选项，accept的套接口是否会继承该选项
tcp_check_req--->>tcp_v4_syn_recv_sock--->>>tcp_create_openreq_child--->>>inet_csk_clone--->>sk_clone
大家看看在这个过程中有没有修改SO_LINGER选项所在的sk_flags字段和超时时间所在的sk_lingertime，答案是否定的，也就是说这些字段都是直接clone了父套接口，也就是listen的标志状态。
下面是验证代码，测试代码由下面程序简单修改之后得到例子代码原版
修改之后代码
/*
* Listing 1:
* Simple "Hello, World!" server
* Ivan Griffin (ivan.griffin@ul.ie)
*/
#include /* */
#include /* exit() */
#include /* memset(), memcpy() */
#include /* uname() */
#include
#include /* socket(), bind(),
listen(), accept() */
#include
#include
#include
#include /* fork(), write(), close() */
/*
* prototypes
*/
int _GetHostName(char *buffer, int length);
/*
* constants
*/
const char MESSAGE[] = "Hello, World!\n";
const int BACK_LOG = 5;
int main(int argc, char *argv[])
{
int serverSocket = 0,
on = 0,
port = 0,
status = 0,
childPid = 0;
struct hostent *hostPtr = NULL;
char hostname[80] = "";
struct sockaddr_in serverName = { 0 };
if (2 != argc)
{
fprintf(stderr, "Usage: %s \n",
argv[0]);
exit(1);
}
port = atoi(argv[1]);
serverSocket = socket(PF_INET, SOCK_STREAM,
IPPROTO_TCP);
if (-1 == serverSocket)
{
perror("socket()");
exit(1);
}
/*
* turn off bind address checking, and allow
* port numbers to be reused - otherwise
* the TIME_WAIT phenomenon will prevent
* binding to these address.port combinations
* for (2 * MSL) seconds.
*/
on = 1;
/*
status = setsockopt(serverSocket, SOL_SOCKET,
SO_REUSEADDR,
(const char *) &on, sizeof(on));
if (-1 == status)
{
perror("setsockopt(...,SO_REUSEADDR,...)");
}
*/
/*
* when connection is closed, there is a need
* to linger to ensure all data is
* transmitted, so turn this on also
*/
{
struct linger linger = { 0 };
linger.l_onoff = 1;
linger.l_linger = 0;
status = setsockopt(serverSocket,
SOL_SOCKET, SO_LINGER,
(const char *) &linger,
sizeof(linger));
if (-1 == status)
{
perror("setsockopt(...,SO_LINGER,...)");
}
}
/*
* find out who I am
*/
status = _GetHostName(hostname,
sizeof(hostname));
if (-1 == status)
{
perror("_GetHostName()");
exit(1);
}
hostPtr = gethostbyname(hostname);
if (NULL == hostPtr)
{
perror("gethostbyname()");
exit(1);
}
(void) memset(&serverName, 0,
sizeof(serverName));
(void) memcpy(&serverName.sin_addr,
hostPtr->h_addr,
hostPtr->h_length);
/*
* to allow server be contactable on any of
* its IP addresses, uncomment the following
* line of code:
* serverName.sin_addr.s_addr=htonl(INADDR_ANY);
*/
serverName.sin_family = AF_INET;
/* network-order */
serverName.sin_port = htons(port);
status = bind(serverSocket,
(struct sockaddr *) &serverName,
sizeof(serverName));
if (-1 == status)
{
perror("bind()");
exit(1);
}
status = listen(serverSocket, BACK_LOG);
if (-1 == status)
{
perror("listen()");
exit(1);
}
for (;;)
{
struct sockaddr_in clientName = { 0 };
int slaveSocket, clientLength =
sizeof(clientName);
(void) memset(&clientName, 0,
sizeof(clientName));
slaveSocket = accept(serverSocket,
(struct sockaddr *) &clientName,
&clientLength);
if (-1 == slaveSocket)
{
perror("accept()");
exit(1);
}
childPid = fork();
switch (childPid)
{
case -1: /* ERROR */
perror("fork()");
exit(1);
case 0: /* child process */
close(serverSocket);
if (-1 == getpeername(slaveSocket,
(struct sockaddr *) &clientName,
&clientLength))
{
perror("getpeername()");
}
else
{
printf("Connection request from %s\n",
inet_ntoa(clientName.sin_addr));
}
/*
* Server application specific code
* goes here, e.g. perform some
* action, respond to client etc.
*/
write(slaveSocket, MESSAGE,
strlen(MESSAGE));
struct linger linger = { 0 };
socklen_t socklen;
status = getsockopt(serverSocket,
SOL_SOCKET, SO_LINGER,
&linger,
(socklen_t*)&socklen);
printf("status %d linger.",status, linger.l_onoff ,linger.l_linger );
close(slaveSocket);
exit(0);
default: /* parent process */
close(slaveSocket);
}
}
return 0;
}
/*
* Local replacement of gethostname() to aid
* portability */
int _GetHostName(char *buffer, int length)
{
struct utsname sysname = { 0 };
int status = 0;
status = uname(&sysname);
if (-1 != status)
{
strncpy(buffer, sysname.nodename, length);
}
return (status);
}
2、测试例子
编译服务器代码
[root@Harry socklinger]# gcc socklinger.c
[root@Harry socklinger]# ./a.out 2222
通过Telnet连接该端口
[root@Harry ~]# telnet 127.0.0.1 2222
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Hello, World!
Connection closed by foreign host.
[root@Harry ~]#
服务器端输出代码
Connection request from 127.0.0.1
status 0 linger.onoff 1 linger.linger 0
3、其它相关问题
make中命令行设置的-i选项会不会传递给子make，bash的 -e选项会不会传递给子脚本？
标签：选项,status,linger,LINGER,sock,TCP,sk,SO,inet
来源： https://www.cnblogs.com/tsecer/p/10487522.html