libnl | Pure Python port of the Netlink protocol library suite | Networking library

The documentation says:

The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.

So if your process has open file descriptors 0, 1, and 2, but not 3, it will return 3.

If your process has open file descriptors 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, and 25, but not 26, it will return 26.

This is how file descriptors are usually assigned in Linux.

As discussed in comments above the issue here was a 'unconventional' (and hence not-working) 'installation' of the nlopt library: one cannot just untar it somewhere as the dynamic linker needs to know about it, update its cache etc.

So in short the recommended answer is to, where available as a suitable version, install the -dev package from the distro. Here the command is

Figured it out, it seems I was missing an include directive, more specifically - the addr.h header.

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):

As you just removed the files instead of using apt-get or dpkg to uninstall the package, the package management is not aware of your manual removal, and so apt-get and dpkg still think the newest version is already installed, and so do nothing.

apt-get --reinstall install vagrant

should solve this.

Since Linux 5.2, the kernel's attribute validator function (validate_nla()) contains a conditional that essentially prohibits NLA_UNSPEC from being used.

I'm not really sure if disabling that validation is possible. The main user of validate_nla() hardcodes validate as NL_VALIDATE_STRICT, which contains NL_VALIDATE_UNSPEC.

But regardless, I suggest that you abstain from using NLA_UNSPEC to send C structs without proper serialization. It's a disaster waiting to happen. C has a gotcha called "data structure padding;" The gist of it is that C compilers are allowed to introduce garbage between the members of any structure. Thus, when you declare this:

How to use the multipart mechanism of generic netlink to broke this string in smaller parts to send and reassemble it on the Kernel side?

Netlink's Multipart feature "might" help you transmit an already fragmented string, but it won't help you with the actual string fragmentation operation. That's your job. Multipart is a means to transmit several small correlated objects through several packets, not one big object. In general, Netlink as a whole is designed with the assumption that any atomic piece of data you want to send will fit in a single packet. I would agree with the notion that 6Kbs worth of string is a bit of an oddball.

In actuality, Multipart is a rather ill-defined gimmic in my opinion. The problem is that the kernel doesn't actually handle it in any generic capacity; if you look at all the NLMSG_DONE usage instances, you will notice not only that it is very rarely read (most of them are writes), but also, it's not the Netlink code but rather some specific protocol doing it for some static (ie. private) operation. In other words, the semantics of NLMSG_DONE are given by you, not by the kernel. Linux will not save you any work if you choose to use it.

On the other hand, libnl-genl-3 does appear to perform some automatic juggling with the Multipart flags (NLMSG_DONE and NLM_F_MULTI), but that only applies when you're sending something from Kernelspace to Userspace, and on top of that, even the library itself admits that it doesn't really work.

Also, NLMSG_DONE is supposed to be placed in the "type" Netlink header field, not in the "flags" field. This is baffling to me, because Generic Netlink stores the family identifier in type, so it doesn't look like there's a way to simultaneously tell Netlink that the message belongs to you, AND that it's supposed to end some data stream. Unless I'm missing something important, Multipart and Generic Netlink are incompatible with each other.

I would therefore recommend implementing your own message control if necessary and forget about Multipart.

What's the maximum string size supported by generic netlink and libnl nla_put_string function?

It's not a constant. nlmsg_alloc() reserves getpagesize() bytes per packet by default. You can tweak this default with nlmsg_set_default_size(), or more to the point you can override it with nlmsg_alloc_size().

Then you'd have to query the actual allocated size (because it's not guaranteed to be what you requested) and build from there. To get the available payload you'd have to subtract the Netlink header length, the Generic Header length and the Attribute Header lengths for any attributes you want to add. Also the user header length, if you have one. You would also have to align all these components because their sizeof is not necessarily their actual size (example).

All that said, the kernel will still reject packets which exceed the page size, so even if you specify a custom size you will still need to fragment your string.

So really, just forget all of the above. Just fragment the string to something like getpagesize() / 2 or whatever, and send it in separate chunks.

This is the general idea:

You need to update your sources.list and use a different mirror.

As described in this post, you should replace in your /etc/apt/sources.list all urls with http://archive.ubuntu.com/… by http://old-releases.ubuntu.com/…. Then you run sudo apt update, and you can install your packages again.

Note that you really should consider to upgrade while it's still not too much of a pain.

To check where tshark config files are stored, use tshark -G folders. As an example, this is what I see on my system: