Error select failed bad file descriptor

Before jumping right into the content directly, it’s essential to analyze the topics by asking some What and How questions. What is a Bad file descriptor error in Python? How do they occur? What are the ways that can help in solving this kind of errors? When we answer these questions, we can eventually understand the essence of this content by the end of this article.

When you don’t allow the code to perform the functions related to the file descriptors and the methods used, a Bad File Descriptor Error arises in Python, indicating the wrong way of implementing the code.

Kicking start with the basics always helps in understanding the core of the subject and hence assists in finding solutions to the most complex problems ever.

Cause of Errors Python

It’s salient to know that only by encountering many errors in code will you be highly proficient in the specific programming language. When you come across a new error, you try to detect where that error appeared from. Eventually, you start researching how to rectify the mistake.

There are even high chances of you exploring more and achieving various easier ways to apply the code better. At last, you will end up observing that your skills in the concept and knowledge about the same had grown vast.

Errors ought to occur in any possible programming language. In Python, errors generally occur when a particular code segment is not in compliance with the advised usage. Various errors are commonly faced by programmers, which include indentation, syntax, etc.

Rectifying these errors is no big deal when you review your code thoroughly. Have a complete understanding of the concepts and know enough about the right syntax to be used in the code.

What are File Descriptors in Python?

In Python, file descriptors are integers(positive) that identify the kernel’s open files kept in a table of files. They are generally non-negative values.

If found to be negative, that indicates error or a “no value” condition. They assist in performing various functions related to files. Descriptors, in general, are a unique way that Python follows to manage attributes.

They mainly help in accessing files, other input/output devices like network sockets or pipes.

File descriptors do perform various operations. They include:

• close(fd) – closes a file descriptor
• dup(fd1) – duplicates file descriptor
• fstat(fd) – returns the status of a file descriptor

The procedures mentioned above are elementary, and it’s important to know that file descriptors perform many more significant operations following the concept.

Understanding [Errno 9] Bad File Descriptor Error in Python

Have you encountered the following error message when you run your Python code when defining file directories or similar ones?

IOError:[Errno 9] Bad file descriptor

When you don’t allow the code to perform the functions related to the file descriptors and the methods used, these kinds of issues arise, indicating the wrong way of implementing the code.

Let’s understand this with an example:

<em>>>>file1=open(".bashrc")
>>>os.close(file1.fileno())
>>>def file1
close failed in file object destructor
IOError:[Errno 9] Bad file descriptor</em>

The below image shows a code with a bad file descriptor error in the Python shell.

In the above code, the del file will delete the reference of the file object specified. Now, as per the code written, the close function was not called. This forces the destructor to close the file. As this resulted in closing a file that wasn’t open in the first place, OS throws an error – Bad file descriptor.

Best Ways to Solve from [Errno 9] Bad File Descriptor in Python

• Make sure you are using a valid file descriptor number. You will get a UNIX or Python Shell- Bad file descriptor error message when you fail using the right file descriptor number. This can cause issues when you open, close or use a file.
• Use the right modes while handling file descriptors. For example to read from the file you need to use the read mode. When you choose the wrong mode, that triggers an error.
• Analyse the concept and then implement the right functions at the right segments of your code.
• Make certain whether the function to be executed through your code was executed already or not.

[Errno 9] Bad File Descriptor in Python Socket Module

Another main area in which this error is seen is in the Python socket – Socket error Bad file descriptor. When dealing with this kind of program, you can notice that you will find a Bad file descriptor error message is seen along with some issues in opening/closing or accessing the socket.

You can tackle this error by finding the right method of executing the function through the prescribed way of performing the function in accordance with the file descriptor.

One common thing that you can notice while handling errors in Python in relevance to files and file descriptors is that many of us fail to follow and implement the proper functions of the file descriptors defined in the code to perform the operations.

In addition to the above-discussed problems, this issue occurs while executing simple print statements too. You should focus on knowing if your specific file descriptors are available in the console that you are running.

This might seem simple when phrased but can cause a huge trauma to the programmer who has invested hours in writing the code. First, make sure that the specifies file descriptors are available in the console in which you run your program.

How to solve Bad File Descriptor in Python Socket module?

One way of handling this error is to calmly ignore the print statements and use alternative segments of code that serve a similar purpose.

Consider the following code –

from time import sleep
import socket
mcip = "mau5ville.com"
port = 25565
magic = "xFE"
s = socket.socket()
while 1:
    # Determine whether the server is up or down
    try:
        s.connect((mcip, port))
        s.send(magic)
        data = s.recv(1024)
        s.close()
        print(data)
    except Exception as e:
        print(e)
    sleep(60)

This error is caused when you specify a function to get executed when it has already completed doing the job. For instance, you order your code to close a file through your long lines of code. It shows an error like:

OSError: [Errno 9] Bad file descriptor

It means that the file defined in the program is already closed automatically while running the code. There lies no use in defining a separate method to perform the same task again.

Conclusion

Bad file descriptor mainly arises due to many factors that were discussed in brief above. The main fact is that they occur when the right functions do not perform in association with the file descriptors.

With clear analysis and better knowledge of the concept, one can easily detect these errors and transform the code into a successful one.

References

• Python open() function: file is a path-like object giving the pathname (absolute or relative to the current working directory) of the file to open or an integer file descriptor of the file to wrap.
• socket.socket(): If fileno is specified, the values for family, type, and proto auto-detects from the specified file descriptor.

/etc/rsyslog.d/fix-rpc.statd.conf
#####
module(load="omprog")

if ($programname == "rpc.statd" and $msg contains "select: Bad file descriptor") then {
    action(
        type="omprog"

        # execute this script when the condition is met
        binary="/etc/rsyslog.d/fix-rpc.statd"

        # rpc.statd outputs many errors very quickly, so
        # only execute the script every 10 seconds
        action.execOnlyOnceEveryInterval="10"
    )
    & stop
}
# discard a spurious message generated by executing the script
if ($programname == "rsyslogd" and $msg contains "has terminated, reaped by main-loop") then stop
#####


and the script can stop and restart the rpc-statd.service, logging a message to that effect:

/etc/rsyslog.d/fix-rpc.statd
#####
#!/bin/bash

echo "rpc.statd may have failed to find an available port... restarting the service" | logger -p daemon.notice -t fix-rpc.statd
sleep 0.25
(
    systemctl stop rpc-statd.service 2>&1
    sleep 0.25
    systemctl start rpc-statd.service 2>&1
    echo "Restarted rpc-statd.service"
) | logger -p daemon.notice -t fix-rpc.statd
#####


then restart rsyslog:
# systemctl restart rsyslog.service

commit 3a5732152c60f8cefaa804db0b81e424e96ee657
Author: Chuck Lever <chuck.lever@oracle.com>
Date:   2015-09-16 11:18:02 -0400

    statd: statd_get_socket() should return open fds

    Tastky <tastky@gmail.com> reports:
    > There appears to be a bug in nfs-utils exposed by musl, which
    > makes rpc.statd loop with:
    >
    > my_svc_run() - select: Bad file descriptor

    OpenGroup says getservbyport(3) is supposed to return NULL when
    no entry exists for the specified port. But musl's getservbyport(3)
    never returns NULL (likely a bug).

    Thus statd_get_socket() tries bindresvport(3) 100 times, then gives
    up and returns the last socket it created. This should work fine,
    but there's a bug in the retry loop:

    Rich Felker <dalias@libc.org> says:
    > The logic bug is the count-down loop that closes all the temp
    > sockets. In the case where the loop terminates via break, it
    > leaves the last one open and only closes the extras. But in the
    > case where where the loop terminates via the end condition in the
    > for statement, the close loop closes all the sockets _including_
    > the one it intends to use.

    (emphasis mine). The closed socket fd is then passed to select(2).

    See also: http://www.openwall.com/lists/musl/2015/08

    The fix is to perform the loop termination test before adding sockfd
    to the set of fds to be closed. As additional clean ups, remove the
    use of the variable-length stack array, and switch to variable names
    that better document the purpose of this logic.

    Reported-by: Tastky <tastky@gmail.com>
    Fixes: eb8229338f06 ("rpc.statd: Fix socket binding loop.")
    Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
    Signed-off-by: Steve Dickson <steved@redhat.com>

server.example.com rpc.statd[2960]: my_svc_run() - select: Bad file descriptor
server.example.com rpc.statd[2960]: my_svc_run() - select: Bad file descriptor
server.example.com rpc.statd[2960]: my_svc_run() - select: Bad file descriptor
server.example.com rpc.statd[2960]: my_svc_run() - select: Bad file descriptor

This solution is part of Red Hat’s fast-track publication program, providing a huge library of solutions that Red Hat engineers have created while supporting our customers. To give you the knowledge you need the instant it becomes available, these articles may be presented in a raw and unedited form.