netlink | netlink libraries for rust | Telnet library

First, let's take a look at what kind of data is in NL80211_BSS_CAPABILITY
To understand this, I will first draw your attention to the property NL80211_BSS_BEACON_IES
The description of this field is as follows:

recvmsg(), when called with the MSG_PEEK flag, returns data but doesn't remove it from the socket's receive queue, leading to the next receive returning the same data again.

Remove the flag (or perform a second call for the same size without it) to ensure you get the following messages.

I'd also highly recommend checking the return from select() as well as the updated set (since select() can return without a readable socket in this case, e.g. if a signal is caught). I'd also note that in your current usage, select() isn't giving you much over a plain blocking recvmsg() call.

If you want to close the connection in a timely fashion, call shutdown() before close()

This statement is about connected sockets. TCP sockets are connected, but UDP, Raw, Netlink sockets etc are not. That's why shutdown is not supported on such sockets. Use a simple close instead.

Found a solution to this. Turns out we were using NetLink sockets to discover network interface address information because ifaddrs was not available (or, not fully implemented, or something like that - nobody here could remember exactly why we couldn't use it) on Android at the time. As of API 24 ifaddrs is now available. We switched our implementation to use ifaddrs. As long as you're minimum supported version is API 24 or later you can do the same.

Here's a solution using a package called yahooquery. Disclaimer: I am the author of the package.

The expected sequence counter is stored by libnl as part of the nl_sock struct (reference). When multiple threads call libnl functions, this can cause inconsistencies, such as a data race (two threads writing to the sequence counter at same time) or a race condition (time-of-check-time-of-use problem, where one thread checks if the counter satisfies some condition, then performs some operation, but in between the other thread modifies the counter). See here for more details on data races and race conditions.

Sidenote: Both g++ and clang++ support the -fsanitize=thread flag, which automatically inserts additional debug code into the binary that can help to detect this kind of data races (reference). Though in this case, it might not be as useful, since you would also have to get libnl compiled with this flag, which might not be easy.

From the libnl documentation (reference):

It looks like the problem was introduced by the patch: regulator: stpmic1: Usb boost over-current protection workaround.

• The "boost" interrupt handler stpmic1_boost_irq_handler calls regulator_lock(usb_data->boost_rdev);
• The "boost" interrupt handler (stpmic1_boost_irq_handler) is set up by the stpmic1_boost_register function, but usb_data->boost_rdev is still null at this time.
• usb_data->boost_rdev is set to the return value of the stpmic1_boost_register function by thestpmic1_regulator_probe function.
• If the "boost" interrupt handler stpmic1_boost_irq_handler gets called before usb_data->boost_rdev has been set by the stpmic1_regulator_probe function, then the crash occurs.

A workaround would be to set usb_data->boost_rdev = rdev; in the stpmic1_boost_register function after it has set rdev but before it sets up the interrupt handler.

This should be reported to the author of the patch. See the "Signed-off-by:" line in the patch for the email address.

Ok, shortly after posting we figured it out. Seems like a mount point has changed (I expect due to a linux kernel update) and we have not used the nofail option in /etc/fstab as described in the aws knowledge center, this caused the server to hang at boot.

Going forward we will also ensure we use UUID mounting so we are independent on the device naming in /dev/.

Linux kernel provides string functions in the linux/string.h header: