How can I reliably make send(2) do a short send?

Question

send(2) takes a buffer and a buffer length. It can return either an error, or some number of bytes successfully sent up to the size of the buffer length. In some cases, send will send fewer than the number of bytes requested (e.g. https://stackoverflow.com/a/2618755/939259).

Is there a way to consistently trigger a short send in a unit test, other than sending a big message and firing a signal from another thread and hoping to get lucky?

Answer 1

Just roll your own:

---

#include <sys/types.h>
#include <sys/socket.h>

ssize_t mysend(int fd, void * buff, size_t len, int flags)
{

#if WANT_PARTIAL_SEND
len = 1 + urand(len -1);
#endif

return send(fd, buff, len, flags);
}

Answer 2

If you pack the code-to-be tested into a shared library (or a static library with the symbols weakened), then your testing executable (which links with the library) will be able to override send for both itself and the libraries it links.

Example (overrides write rather than send):

#!/bin/sh -eu
cat > code.c <<EOF
#include <unistd.h>
#include <stdio.h>
ssize_t hw(void)
{
    static const char b[]="hello world\n";
    return write(1, b, sizeof(b)-1);
}
void libfunc(void)
{
    puts(__func__);
    hw();
}
EOF

cat > test.c <<'EOF'
#include <stdio.h>
void libfunc(void);
ssize_t hw(void);

#if TEST
ssize_t hw(void)
{
    puts("override");
    return 42;
}
#endif
int main()
{
    libfunc();
    puts("====");
    printf("%zu\n", hw());
}

EOF

gcc code.c -fpic -shared -o libcode.so
gcc test.c $PWD/libcode.so -o real
gcc -DTEST test.c $PWD/libcode.so -o mocked
set -x
./real
./mocked

Example output:

hello world
hello world
libfunc
====
12
libfunc
override
====
override
42

This overshadows the libc implementation of the symbol and while there are mechanism for accessing the overridee (namely dlopen and/or -Wl,--wrap), you shouldn't need to access it in a unit test (if you do need it in other unit tests, it's simplest to just put those other unit tests in a different program).