ABAP short dumpObjectCALL_FUNCTION_SEND_ERRORModuleABAP

CALL_FUNCTION_SEND_ERROR — CALL_FUNCTION_SEND_ERROR dump diagnosis and fix

CALL_FUNCTION_SEND_ERROR fires when an RFC call cannot deliver its data to the target system during the send phase, distinct from a call that reaches the target and fails there. The communication layer (CPIC/RFC) reports the transport itself broke: gateway refused the connection, the network dropped it, or the receiving work process died before accepting the payload.

This page covers the CALL_FUNCTION_SEND_ERROR runtime error raised when an outbound RFC call fails at the transport level rather than inside the called function module. It lists the infrastructure and configuration causes in order of frequency, the ST22 fields that distinguish a network failure from a target-side crash, and the resolution paths split between Basis and ABAP ownership.

Published 16 Sept 2026· 1,177 words

What the dump means

This dump belongs to the CALL_FUNCTION exception family raised by the RFC/CPIC communication layer, not by ABAP application logic. It means the CALL FUNCTION ... DESTINATION statement got far enough to open a connection but the send of the request data failed before the target system could process it. This is different from CALL_FUNCTION_REMOTE_ERROR, where the call reached the other side and an error came back from execution there. SEND_ERROR is a transport-layer failure: the packet never arrived intact, or arrived but the receiving work process was gone, or the gateway rejected the connection outright. The calling program is almost always innocent; the dump usually indicates something wrong between the sending application server and the target system's gateway or dispatcher, or a target system that terminated mid-transaction.

Root causes that actually produce it

  • Target application server or instance down or restarting: the RFC destination points to a host whose dispatcher or gateway is not accepting connections at the moment of the call, common during transports, kernel patching, or unplanned restarts on the receiving side.
  • Gateway connection limit reached: the target system's gateway has hit its maximum concurrent connection count (often from other RFC-heavy jobs or interfaces running in parallel), so new inbound connections are refused mid-handshake.
  • Network path interruption: a firewall, load balancer, or saprouter in the path resets or drops the TCP session partway through the send, frequently seen on long-running calls carrying large data packets that exceed an idle or session timeout on an intermediate device.
  • Receiving work process terminated abnormally: the destination system's work process handling the call crashed or was killed (memory dump, forced work process restart, dispatcher trace enabled at the wrong moment) after accepting the connection but before consuming the payload.
  • RFC destination misconfigured: wrong host name, system number, or load balancing group in the destination definition means the connection attempt reaches nothing valid, though this more often produces a different connection-refused variant depending on where the mismatch resolves.
  • Large payload combined with a small buffer or short timeout: internal tables passed by reference in bulk RFC calls occasionally exceed what the gateway or network segment will move within the configured window, tipping over into a send failure rather than a clean timeout.

What to inspect in ST22

  • Error analysis text at the top of the dump: it usually names the CPIC/RFC return code and a short communication error string, for example connection reset, partner not reached, or connection closed by remote side. This single line usually tells which of the causes applies.
  • RFC destination and target host/system number shown in the call information: confirm this matches what SM59 has configured and what the business actually intended to call.
  • Function module name and the calling program/include with line number: identifies whether this is a custom interface, a standard SAP outbound call, or a background job step.
  • Time of the dump against target system availability: cross-check with the target system's own ST22 and SM21 for the same window to see if it crashed or restarted at that moment.
  • SM59 connection test on the destination, executed as close as possible to the time of failure, plus a ping and telnet to the target host and port from the sending application server's OS level.
  • SMGW on both sending and target systems for connection count and rejected connection entries, and the developer trace files (dev_rfc on the caller, dev_w* on the target) for low-level socket errors.

Resolution path

If the target system was down or restarting at the time, this is transient: confirm with Basis that the instance is now up, retest via SM59, and rerun the failed job. No change request needed. If the gateway connection limit was hit, Basis needs to raise the relevant gateway parameter or find and close the process leaking connections; this is a Basis parameter change requiring a change request if it touches production gateway configuration. If a firewall or saprouter dropped the session, network/Basis must adjust the idle timeout or add a keepalive setting on the affected route; this typically needs infrastructure sign-off and a change request since it affects shared network equipment. If the receiving work process crashed, the fix lives in whatever caused that crash on the target side, found via its own ST22, not in the calling program. If payload size is the driver, the ABAP side should split the call into chunks or move to a different transfer method (IDoc, file, or asynchronous RFC), which is a code change requiring proper testing and a change request. If the destination itself is misconfigured, correcting SM59 is a Basis or Basis-security task, low risk, but still change-managed in production landscapes.

The fix people try first (and why it fails)

The reflex is to wrap the CALL FUNCTION in a bigger TRY/CATCH or add COMMUNICATION_FAILURE and SYSTEM_FAILURE to the EXCEPTIONS list and move on once the dump stops appearing. This suppresses the visible symptom but leaves the underlying network flakiness or gateway exhaustion untouched, so the interface now fails silently or retries into the same wall, and whoever depended on that data never finds out it did not arrive. Blindly increasing the RFC timeout has the same problem: it papers over a connection that drops for reasons unrelated to how long the caller is willing to wait.

Prevention

Add explicit EXCEPTIONS handling for COMMUNICATION_FAILURE and SYSTEM_FAILURE on every outbound synchronous RFC call so a failure produces a controlled error message and, where appropriate, a retry with backoff instead of an uncaught dump. For high-volume interfaces, monitor gateway connection counts and set alerting before the configured maximum is approached. Keep RFC destinations under regular connection testing (scheduled SM59 test or equivalent monitoring) so a dead target is caught before a business job hits it.

Whose problem this is

Primarily Basis: network path, gateway capacity, and target system availability are infrastructure concerns. ABAP gets involved only if the calling program lacks proper exception handling or needs restructuring for large payloads. The handover note should include the RFC destination name, target host and system number, the exact timestamp, and whether the target system's own logs show a corresponding crash or restart.

Related SAP objects

Reviewed pages this object connects to in the ERPClimb knowledge graph.

Source: ERPClimb — https://erpclimb.com/sap-abap-dumps/call-function-send-errorERPClimb is an independent platform and is not affiliated with SAP SE. Reference pages are written and reviewed by SAP consultants for learning and troubleshooting.