Performance for large stanzas

[singpolyma]

Right now if there is a stanza larger than the configured stophe buffer size, or regardless of the buffer size but larger than a single TLS record (often 8K) then xmpp_run_once will process only the first part of this stanza. When integrating with an event loop, we then hand off to that event loop to do any work it may have, before coming back around again to xmpp_run_once.

One solution could be to have xmpp_run_once return an indication of if there is still more that could be done to the caller. Unfortunately it's hard to even tell if something could be done in many cases. For now I am trying out this:

        case XMPP_STATE_CONNECTED:
            if (FD_ISSET(conn->sock, &rfds) || intf->pending(intf)) {
                do {
                    ret = intf->read(intf, buf, STROPHE_MESSAGE_BUFFER_SIZE);

                    if (ret > 0) {
                        ret = parser_feed(conn->parser, buf, ret);
                        if (!ret) {
                            strophe_debug(ctx, "xmpp", "parse error [%s]", buf);
                            xmpp_send_error(conn, XMPP_SE_INVALID_XML,
                                            "parse error");
                        }
                    } else {
                        int err = intf->get_error(intf);
                        if (!intf->error_is_recoverable(intf, err)) {
                            strophe_debug(ctx, "xmpp", "Unrecoverable error: %d.",
                                      err);
                            conn->error = err;
                            conn_disconnect(conn);
                        } else if (!conn->tls) {
                            /* return of 0 means socket closed by server */
                            strophe_debug(ctx, "xmpp",
                                          "Socket closed by remote host.");
                            conn->error = ECONNRESET;
                            conn_disconnect(conn);
                        }
                        break;
                    }
                } while (conn->tls);
            }

            break;

this works very well and makes sure the whole stanza (or even several stanzas if they arrived together) is processed before continuing. However I suppose this could in theory create starvation if the other side is sending data nonstop?