Function shuffleBetweenStreams

kdevplatform/util/dbus_socket_transformer/main.cpp:81–184

* Shuffles all data between the two file-descriptors until one of them fails or reaches EOF. * */

 * Shuffles all data between the two file-descriptors until one of them fails or reaches EOF.
 * */
void shuffleBetweenStreams(int side1, int side2, bool fixSide1AuthToken)
{
    char buffer[1000];
    char buffer2[1000];

    // Set non-blocking mode
    int opts = fcntl(side1, F_GETFL);
    opts |= O_NONBLOCK;
    fcntl(side1, F_SETFL, opts);

    opts = fcntl(side2, F_GETFL);
    opts |= O_NONBLOCK;
    fcntl(side2, F_SETFL, opts);

    while (true) {
        int r1 = read(side1, buffer, 500); // We read less than 1000, so we have same additional space when changing the auth token
        int r2 = read(side2, buffer2, 500);

        if (r1 < -1 || r1 == 0) {
            if (debug)
                std::cerr << "stream 1 failed: " << r1 << std::endl;
            return;
        }
        if (r2 < -1 || r2 == 0) {
            if (debug)
                std::cerr << "stream 2 failed: " << r2 << std::endl;
            return;
        }

        if (r1 > 0) {
            if (debug)
                std::cerr << "transferring " << r1 << " from 1 to 2" << std::endl;

            if (fixSide1AuthToken) {
                if (r1 > 15 && memcmp(buffer, "\0AUTH EXTERNAL ", 15) == 0) {
                    int endPos = -1;
                    for (int i = 15; i < r1; ++i) {
                        if (buffer[i] == '\r') {
                            endPos = i;
                            break;
                        }
                    }

                    if (endPos != -1) {
                        std::string oldToken = std::string(buffer + 15, endPos - 15);
                        std::string newToken = getAuthToken();

                        int difference = newToken.size() - oldToken.size();
                        r1 += difference;
                        assert(r1 > 0 && r1 <= 1000);
                        memmove(buffer + endPos + difference, buffer + endPos, r1 - difference - endPos);
                        memcpy(buffer + 15, newToken.data(), newToken.size());
                        assert(buffer[endPos + difference] == '\r');
                        assert(buffer[endPos + difference - 1] == newToken[newToken.size() - 1]);
                    } else {
                        std::cout << "could not fix auth token, not enough data available" << std::endl;
                    }
                } else {