Issue 28447: socket.getpeername() failure on broken TCP/IP connection (original) (raw)

Created on 2016-10-15 01:13 by GeorgeY, last changed 2022-04-11 14:58 by admin. This issue is now closed.

Messages (19)

msg278679 - (view)

Author: Georgey (GeorgeY) *

Date: 2016-10-15 01:13

I need to know the IP address on the other side of a broken TCP/IP connection.

"socket.getpeername()" fails to do the job sometimes because the connection has been closed, and Windows Error 10038 tells the connection is no longer a socket so that the method getpeername is wrongly used.

Here goes the code in main thread:

mailbox = queue.Queue()

read_sockets, write_sockets, error_sockets = select.select(active_socks,[],[],TIMEOUT) for sock in read_sockets: ...... except: mailbox.put( (("sock_err",sock), 'localhost') )

The sub thread get this message from mailbox and try to analyze the broken socket, to simplify I put the code and output together:

print(sock)>>> <socket.socket [closed] fd=-1, family=AFNET, type=SOCKSTREAM, proto=0> sock.getpeername()>>> OS.Error[WinError10038]an operation was attempted on something that is not a socket

Surprisingly, this kind of error happen occasionally - sometimes the socket object is normal and getpeername() works fine.

So once a connection is broken, there is no way to tell the address to whom it connected?

msg278680 - (view)

Author: Martin Panter (martin.panter) *

Date: 2016-10-15 01:31

The getpeername() method is just a wrapper around the OS function, so it is not going to work if the socket file descriptor is closed or invalid (-1).

You haven’t provided enough code or information for someone else to reproduce the problem. But it sounds like you may be closing the socket in one thread, and trying to use it in another thread. This is going to be unreliable and racy, depending on which thread acts on the socket first. Perhaps you should save the peer address in the same thread that closes it, so you can guarantee when it is open and when it is closed. Or use something else to synchronize the two threads and ensure the socket is always closed after getpeername() is called.

BTW it looks like I have to remove George’s username from the nosy list because it contains a comma!

msg278684 - (view)

Author: Georgey (GeorgeY) *

Date: 2016-10-15 01:58

I have changed my Username, thanks martin.

" But it sounds like you may be closing the socket in one thread, and trying to use it in another thread" -- I do not attempt to "close" it in main thread. Main only detect the connection failure and report the socket object to the sub thread. sub thread tries to identify the socket object (retrieve the IP address) before closing it.

The question is - once the TCP connection is broken (e.g. client's program get a crash), how can I get to know the original address of that connection?

It seems like once someone(socket) dies, I am not allowed to know the name(address)!

msg278691 - (view)

Author: Martin Panter (martin.panter) *

Date: 2016-10-15 03:46

This indicated to me that the socket object has indeed been closed before you call getpeername():

print(sock)>>> <socket.socket [closed] fd=-1, family=AFNET, type=SOCKSTREAM, proto=0> sock.getpeername()>>> OS.Error[WinError10038]an operation was attempted on something that is not a socket

In this case, I think “[closed] fd=-1” means that both the Python-level socket object, and all objects returned by socket.makefile(), have been closed, so the OS-level socket has probably been closed. In any case, getpeername() is probably trying the invalid file descriptor -1. If there are no copies of the OS-level socket open (e.g. in other processes), then the TCP connection is probably also shut down, but I suspect the problem is the socket object, not the TCP connection.

Without code or something demonstrating the bug, I’m pretty sure it is a bug in your program, not in Python.

msg278693 - (view)

Author: Georgey (GeorgeY) *

Date: 2016-10-15 04:41

"Without code or something demonstrating the bug, I’m pretty sure it is a bug in your program"

Here is the main Thread

mailbox = queue.Queue()

while True: #print(addr_groups)

unknown_clients=[]
for key in yellow_page.keys():
    if yellow_page[key][0] ==None:
        unknown_clients.append(key)

print("\n", name_groups)
if len(unknown_clients) >0:
    print("unknown from："+str(unknown_clients))
print(time.strftime(ISOTIMEFORMAT, time.localtime(time.time())) + '\n')

# Get the list sockets which are ready to be read through select
read_sockets, write_sockets, error_sockets = select.select(active_socks,[],[],TIMEOUT)

for sock in read_sockets:
    #New connection
    if sock ==server_sock:
        # New Client coming in
        clisock, addr = server_sock.accept()  
        ip = addr[0]
        if ip in IPALLOWED:
            active_socks.append(clisock)                
            yellow_page[addr] = [None,None,clisock] 
        else:
            clisock.close()
     
    #Some incoming message from a client
    else:
        # Data recieved from client, process it
        try:
            data = sock.recv(BUFSIZ)
            if data:
                fromwhere = sock.getpeername()
                mail_s = data.split(SEG_) 
                del mail_s[0]
                for mail_ in mail_s:

                    mail = mail_.decode()                        
                   
        except:
            mailbox.put( (("sock_err",sock), 'localhost') )
            continue

=====================

so the sub thread's job is to analyze the exception put into "mailbox"

Here is the run function of sub thread

def run(self):
    
    while True:
        msg, addr = mailbox.get()  
        if msg[0] =="sock_err":
            print("sock_err @ ", msg[1])  #<<<Here comes the print of socket object
            handle_sock_err(msg[1])
            continue ##jump off
        else: ......

==========

Let us see how the handle_sock_err does to the broken socket:

def handle_sock_err(sock): #sock是出错的网络连接，要注销它并且提示出错 global active_socks, yellow_page, addr_groups, name_groups addr_del = sock.getpeername() #<<<ERROR 10038

name_del, job_del = yellow_page[addr_del][ 0:2] 
yellow_page.pop(addr_del)

tag = 0
try:

    addr_groups[job_del].remove(addr_del);   tag =1
    name_groups[job_del].remove(name_del);   tag =2
    
    active_socks.remove(sock) 
    tag =3

    print(name_del+" offline!")

except:
    if tag <3:
        active_socks.remove(sock)
    else:
        pass

=============

I do believe that the broken socket can tell me the address it connected to, so there is even no "try" in getpeername()

Why do I need to find the address of that broken socket found by select in main? Simple, the server recognizes the user name once the connection has sent correct login information. When the connection is down, the user shall be automatically removed from online user list "yellow_page" and all other dynamic books like "addr_groups", "name_groups"...

This is a very common and reasonable practice of online system. I am not particularly interested in why getpeername() is ineffective in getting the address stopped connection,

but How I get the address that stopped connection.

I do not know why python can only tell me a line has broke, but where it was leading to. And I believe this is a big issue in establishing an effective server, do you agree with me?

msg278735 - (view)

Author: Martin Panter (martin.panter) *

Date: 2016-10-15 21:41

I still think something is closing your socket object. I cannot see what it is from the code you posted though. If you update the print() call, I expect you will see that it is closed, and the file descriptor is set to -1:

print("sock_err @ ", msg[1], msg[1]._closed, msg[1].fileno()) # Expect True, -1

msg278795 - (view)

Author: Georgey (GeorgeY) *

Date: 2016-10-17 03:31

Yes that is definitely a closed socket. But it is strange that in a single thread server without select module, the socket is never closed until I explicitly use close() method.

except: print(sock) #<- here it looks normal time.sleep(3) print(sock) #<- here it still looks normal sock.close() print(sock) #<- finally the [closed] tag appears and all the details lost

So I guess the "Socket Automatically Closing" effect associate with "select" module? For when I run the single-thread server in the IDLE and called time.sleep(), it has been already treated as multi-thread.

msg278796 - (view)

Author: Martin Panter (martin.panter) *

Date: 2016-10-17 04:20

So is your “automatic closing” due to your program, or a bug in Python? You will have to give more information if you want anyone else to look at this. When I run the code you posted (with various modules imported) all I get is

NameError: name 'yellow_page' is not defined

msg278968 - (view)

Author: Georgey (GeorgeY) *

Date: 2016-10-19 08:29

As your request, I simplify the server here:

import socket import select, time import queue, threading

ISOTIMEFORMAT = '%Y-%m-%d %X' BUFSIZ = 2048 TIMEOUT = 10 ADDR = ('', 15625)

SEG = "◎◎" SEG_ = SEG.encode()

active_socks = [] socks2addr = {}

server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_sock.bind(ADDR) server_sock.listen(10) active_socks.append(server_sock)

mailbox = queue.Queue()

#

def send(mail):
mail_ = SEG_+ mail.encode() ##The SEG_ at the beginning can seperate messeges for recepient when internet busy

for sock in active_socks[1:]:
    try:
        sock.send(mail_)
    except:
        handle_sock_err(sock)

def handle_sock_err(sock): try: addr_del = sock.getpeername() except: addr_del = socks2addr[sock]

active_socks.remove(sock) 
socks2addr.pop(sock) 
sock.close()

send("OFFLIN"+str(addr_del) )

# _{class Sender(threading.Thread): #process 'mails' - save and send def init(self, mailbox): super().init() self.queue = mailbox}

def analyze(self, mail, fromwhere):
    send( ' : '.join((fromwhere, mail)) )

def run(self):
    
    while True:
        msg, addr = mailbox.get()  ###
          
        if msg[0] =="sock_err":
            print("sock_err @ ", msg[1]) 
            #alternative> print("sock_err @ " + repr( msg[1] ) )
            #the alternaive command greatly reduces socket closing

            handle_sock_err(msg[1])
            continue 
            
        self.analyze(msg, addr)

sender = Sender(mailbox) sender.daemon = True sender.start()

#

read_sockets, write_sockets, error_sockets = select.select(active_socks,[],[],TIMEOUT)

for sock in read_sockets:
    #New connection
    if sock ==server_sock:
        # New Client coming in
        clisock, addr = server_sock.accept() 
        ip = addr[0]

        active_socks.append(clisock)                
        socks2addr[clisock] = addr
     
    #Some incoming message from a client
    else:
        # Data recieved from client, process it
        try:
            data = sock.recv(BUFSIZ)
            if data:
                fromwhere = sock.getpeername()
                mail_s = data.split(SEG_)   ##seperate messages
                del mail_s[0]
                for mail_ in mail_s:
                    mail = mail_.decode()                        
                    print("recv>"+ mail)
                   
        except:
            mailbox.put( (("sock_err",sock), 'Server') )
            continue

for sock in active_socks[1:]:
    try:
        sock.send(mail_)
    except:
        handle_sock_err(sock)

active_socks.remove(sock) 
socks2addr.pop(sock) 
sock.close()

send("OFFLIN"+str(addr_del) )

def analyze(self, mail, fromwhere):
    send( ' : '.join((fromwhere, mail)) )

def run(self):
    
    while True:
        msg, addr = mailbox.get()  ###
          
        if msg[0] =="sock_err":
            print("sock_err @ ", msg[1]) 
            #alternative> print("sock_err @ " + repr( msg[1] ) )
            #the alternaive command greatly reduces socket closing

            handle_sock_err(msg[1])
            continue 
            
        self.analyze(msg, addr)

read_sockets, write_sockets, error_sockets = select.select(active_socks,[],[],TIMEOUT)

for sock in read_sockets:
    #New connection
    if sock ==server_sock:
        # New Client coming in
        clisock, addr = server_sock.accept() 
        ip = addr[0]

        active_socks.append(clisock)                
        socks2addr[clisock] = addr
     
    #Some incoming message from a client
    else:
        # Data recieved from client, process it
        try:
            data = sock.recv(BUFSIZ)
            if data:
                fromwhere = sock.getpeername()
                mail_s = data.split(SEG_)   ##seperate messages
                del mail_s[0]
                for mail_ in mail_s:
                    mail = mail_.decode()                        
                    print("recv>"+ mail)
                   
        except Exception as err:
            print( "SOCKET ERROR: "+str(err) )
            mailbox.put( (("sock_err",sock), 'Server') )
            continue

        except Exception as err:
            print("error:"+str(err))
            print(sock.getpeername())
            mailbox.put( (("sock_err",sock), 'Server') )
            continue