ssh, internal: flush the worker's queued output on every call

- wolfSSH_worker() calls wolfSSH_SendPacket() whenever
  ssh->outputBuffer holds bytes and the session is not
  disconnected, in place of doing so only for WS_SUCCESS,
  WS_WANT_READ, WS_CHAN_RXD or WS_EOF. A failed flush reaches the
  return only when the receive reported nothing, and ssh->error
  keeps the receive's code only when the receive itself failed.
  Drops the second DoReceive(), its WS_WINDOW_FULL case, the
  WOLFSSH_TEST_BLOCK fork, and the separate WS_CHANNEL_CLOSED
  flush the gate used to need.
- wolfSSH_SendPacket() records its code in ssh->error on every
  transport failure path, and the comments on _ChannelRead(),
  _ChannelReadExt() and test_ChannelReadExtHardFailureReported()
  no longer describe the former contract.
- The echoserver shell loop and the Windows wolfsshd shell loop
  treat a WS_WANT_WRITE from wolfSSH_worker() as non-fatal.
- tests cover the flush on an idle receive, the owed flush across
  calls, what ssh->error holds after a receive failure, a hard
  send failure, channel data alongside a failed send, a discarded
  buffer and an out-of-bounds send, and that queued output stays
  unsent on the pass that receives a disconnect. ConnResetIoSend
  moves to the shared doubles beside a new OobIoSend.

Author: yosuke-wolfssl

src/ssh.c

@@ -3704,25 +3704,14 @@ int wolfSSH_worker(WOLFSSH* ssh, word32* channelId)
             if (ret == WS_SUCCESS) {
                 ret = sendRet;
             }
-            else if (rxErr != WS_WANT_READ
-                    && ssh->outputBuffer.length != 0) {
-                /* ret still reports the receive, so put the receive's status
-                 * back */
+            else if (ret == WS_FATAL_ERROR && rxErr != WS_WANT_READ) {
+                /* Only a failed receive outranks the flush. A status return
+                 * keeps the send's code */
                 ssh->error = rxErr;
             }
         }
     }
 
-    /* DoChannelClose() bundles the reply inside DoReceive(), and callers
-     * treat the close as terminal, so flush it here. The close stays the
-     * return value; a short flush leaves WS_WANT_WRITE latched. */
-    if (ret == WS_CHANNEL_CLOSED && ssh->outputBuffer.length != 0) {
-        int closeErr = ssh->error;
-
-        if (wolfSSH_SendPacket(ssh) == WS_SUCCESS)
-            ssh->error = closeErr;
-    }
-
     /* WS_EXTDATA and WS_EOF report the channel too, so a multi-channel caller
      * can route the drain, or see which channel half-closed. */
     if (ret == WS_SUCCESS || ret == WS_CHAN_RXD || ret == WS_EXTDATA

tests/unit.c

@@ -6571,10 +6571,10 @@ static int test_WorkerHardSendErrorOnIdleReceive(void)
     return result;
 }
 
-/* Channel data arrives and the flush fails on the same call.
- * wolfSSH_worker() returns WS_CHAN_RXD so the caller can read the data.
- * The next call puts the send failure in ssh->error. */
-static int test_WorkerChanRxdOutranksHardSendError(void)
+/* Channel data arrives and the flush fails on the same call. ret carries
+ * WS_CHAN_RXD so the caller reads the data, and ssh->error carries the send
+ * failure: wolfssh/ssh.h has the flush status supersede the receive's. */
+static int test_WorkerChanRxdSurfacesSendError(void)
 {
     WOLFSSH_CTX*     ctx = NULL;
     WOLFSSH*         ssh = NULL;
@@ -6614,10 +6614,14 @@ static int test_WorkerChanRxdOutranksHardSendError(void)
 
     ret = wolfSSH_worker(ssh, NULL);
     if (ret != WS_CHAN_RXD) { result = -1755; goto done; }
-    if (wolfSSH_get_error(ssh) != WS_CHAN_RXD) { result = -1756; goto done; }
+    if (wolfSSH_get_error(ssh) != WS_SOCKET_ERROR_E) {
+        result = -1756;
+        goto done;
+    }
+    /* A reset does not discard, so the bytes stay owed. */
     if (ssh->outputBuffer.length == 0) { result = -1757; goto done; }
 
-    /* No data this time, so ssh->error now holds the send failure. */
+    /* And the failure persists rather than being a one-pass artefact. */
     ret = wolfSSH_worker(ssh, NULL);
     if (ret != WS_FATAL_ERROR) { result = -1758; goto done; }
     if (wolfSSH_get_error(ssh) != WS_SOCKET_ERROR_E) {
@@ -20498,8 +20502,8 @@ int wolfSSH_UnitTest(int argc, char** argv)
            (unitResult == 0 ? "SUCCESS" : "FAILED"));
     testResult = testResult || unitResult;
 
-    unitResult = test_WorkerChanRxdOutranksHardSendError();
-    printf("WorkerChanRxdOutranksHardSendError: %s\n",
+    unitResult = test_WorkerChanRxdSurfacesSendError();
+    printf("WorkerChanRxdSurfacesSendError: %s\n",
            (unitResult == 0 ? "SUCCESS" : "FAILED"));
     testResult = testResult || unitResult;