CURLALTSVC_* are bits for the CURLOPT_ALTSVC_CTRL option

Used for CURLOPT_SOCKS5_AUTH to stay terminologically correct

Deprecated since the advent of CURLAUTH_NEGOTIATE

Flag bits in the curl_blob struct:

tell libcurl to NOT copy the data

tell the lib to end the task

return codes for CURLOPT_CHUNK_BGN_FUNCTION

skip this chunk over

tell the lib to end the task

return codes for CURLOPT_CHUNK_END_FUNCTION

This is the global package copyright

an error occurred

return codes for FNMATCHFUNCTION

pattern does not match the string

bits for the CURLOPT_FOLLOWLOCATION option

Only use the custom method in the first request, always reset in the next

Do not use the custom method in the follow-up request if the HTTP code instructs so (301, 302, 303).

no purpose since 7.57.0

delegate always

no delegation (default)

if permitted by policy

1xx headers

CONNECT headers

plain server header

pseudo headers

trailers

bitmask defines for CURLOPT_HEADEROPT

The default connection attempt delay in milliseconds for happy eyeballs. CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS.3 and happy-eyeballs-timeout-ms.d document this value, keep them in sync.

CURLHSTS_* are bits for the CURLOPT_HSTS option

please use HTTP 1.0 in the request

please use HTTP 1.1 in the request

Convenience definition simple because the name of the version is HTTP/2 and not 2.0. The 2_0 version of the enum name was set while the version was still planned to be 2.0 and we stick to it for compatibility.

please use HTTP 2 in the request

please use HTTP 2 without HTTP/1.1 Upgrade

use version 2 for HTTPS, version 1.1 for HTTP

Use HTTP/3, fallback to HTTP/2 or HTTP/1 if needed. For HTTPS only. For HTTP, this option makes libcurl return error.

Use HTTP/3 without fallback. For HTTPS only. For HTTP, this makes libcurl return error.

*ILLEGAL* http version

These constants are for use with the CURLOPT_HTTP_VERSION option.

same as SLIST

uses only IPv4 addresses/connections

uses only IPv6 addresses/connections

Below here follows defines for the CURLOPT_IPRESOLVE option. If a host name resolves addresses using more than one IP protocol version, this option might be handy to force libcurl to use a specific IP version.

The only reason to have a max limit for this is to avoid the risk of a bad server feeding libcurl with a never-ending header that will cause reallocs infinitely

The maximum receive buffer size.

Tests have proven that 20K is a bad buffer size for uploads on Windows, while 16K for some odd reason performed a lot better. We do the ifndef check to allow this value to easier be changed at build time for those who feel adventurous. The practical minimum is about 400 bytes since libcurl uses a buffer of this size as a scratch area (unrelated to network send operations).

CURLMIMEOPT_ defines are for the CURLOPT_MIME_OPTIONS option.

- CURLMNWC_CLEAR_CONNS tells libcurl to prevent further reuse of existing connections. Connections that are idle will be closed. Ongoing transfers will continue with the connection they have.

- CURLMNWC_CLEAR_DNS tells libcurl to prevent further reuse of existing connections. Connections that are idle will be closed. Ongoing transfers will continue with the connection they have.

These enums are for use with the CURLOPT_NETRC option.

A user:password in the URL will be preferred to one in the .netrc.

A user:password in the URL will be ignored. Unless one is set programmatically, the .netrc will be queried.

'void *' argument passed untouched to callback

long may be 32 or 64 bits, but we should never depend on anything else but 32

'struct curl_slist *' argument

'char *' argument to a string with a trailing zero

'long' argument with a set of values/bitmask

bitmask bits for CURLMOPT_PIPELINING

* Name: curl_multi_socket() and * curl_multi_socket_all() * * Desc: An alternative version of curl_multi_perform() that allows the * application to pass in one of the file descriptors that have been * detected to have "action" on them and let libcurl perform. * See manpage for details.

Return code for when the pre-request callback wants to abort the request

Return code for when the pre-request callback has terminated without any errors

This is a return code for the progress callback that, when returned, will signal libcurl to continue executing the default progress function

enable everything

Convenient "aliases"

added in 7.72.0

* Name: curl_push_callback * * Desc: This callback gets called when a new stream is being pushed by the * server. It approves or denies the new stream. It can also decide * to completely fail the connection. * * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT

This is a return code for the read callback that, when returned, will signal libcurl to immediately abort the current transfer.

This is a return code for the read callback that, when returned, will signal libcurl to pause sending data on the current transfer.

not used

tell libcurl seeking cannot be done, so libcurl might try other means instead

fail the entire transfer

These are the return codes for the seek callbacks

causes libcurl to abort and return CURLE_ABORTED_BY_CALLBACK

The return code from the sockopt_callback can signal information back to libcurl:

agent (ssh-agent, pageant...)

all types supported by the server

gssapi (kerberos, ...)

host key files

keyboard interactive

none allowed, silly but complete

password

public/private key files

- ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the name of improving interoperability with older servers. Some SSL libraries have introduced work-arounds for this flaw but those work-arounds sometimes make the SSL communication fail. To regain functionality with those broken servers, a user can this way allow the vulnerability back.

- CURLSSLOPT_AUTO_CLIENT_CERT tells libcurl to automatically locate and use a client certificate for authentication. (Schannel)

If possible, send data using TLS 1.3 early data

- CURLSSLOPT_NATIVE_CA tells libcurl to use standard certificate store of operating system. Currently implemented under MS-Windows.

- NO_PARTIALCHAIN tells libcurl to *NOT* accept a partial certificate chain if possible. The OpenSSL backend has this ability.

- NO_REVOKE tells libcurl to disable certificate revocation checks for those SSL backends where such behavior is present.

- REVOKE_BEST_EFFORT tells libcurl to ignore certificate revocation offline checks and ignore missing revocation list for those SSL backends where such behavior is present.

never use, keep last

never use, keep last

TLS 1.x

* This is the date and time when the full source package was created. The * timestamp is not stored in git, as the timestamp is properly set in the * tarballs by the maketgz script. * * The format of the date follows this template: * * "2007-11-23"

Return code for when was an error in the trailing header's list and we want to abort the request

Return code for when the trailing headers' callback has terminated without any errors

bitmask values for CURLOPT_UPLOAD_FLAGS

The default connection upkeep interval in milliseconds.

SSL for all communication or fail

SSL for the control connection or fail

parameter for the CURLOPT_USE_SSL option

try using SSL, proceed anyway otherwise

This is the version number of the libcurl package from which this header file origins:

Alt-Svc handling built-in

Asynchronous DNS resolves

Brotli features are present.

Character conversions supported

Debug memory tracking supported

Built with debug capabilities

libgsasl is supported

Built against a GSS-API library

Negotiate auth is supported (deprecated)

HSTS is supported

HTTP2 support built-in

HTTP3 support built-in

HTTPS-proxy support built-in

Internationized Domain Names are supported

IPv6-enabled

Kerberos V4 auth is supported (deprecated)

Kerberos V5 auth is supported

Supports files larger than 2GB

libz features are present

The numeric version number is also available "in parts" by using these defines:

Multiple SSL backends available

The 'CURLVERSION_NOW' is the symbolic name meant to be used by basically all programs ever that want to get version information. It is meant to be a built-in version number for what kind of struct the caller expects. If the struct ever changes, we redefine the NOW to another enum from above.

NTLM auth is supported

NTLM delegation to winbind helper is supported

This is the numeric version of the libcurl version number, meant for easier parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will always follow this syntax: 0xXXYYZZ Where XX, YY and ZZ are the main version, release and patch numbers in hexadecimal (using 8 bits each). All three numbers are always represented using two digits. 1.2 would appear as "0x010200" while version 9.11.7 appears as "0x090b07". This 6-digit (24 bits) hexadecimal number does not show pre-release number, and it is always a greater number in a more recent release. It makes comparisons with greater than and less than work. Note: This define is the full hex number and _does not_ use the CURL_VERSION_BITS() macro since curl's own configure script greps for it and needs it to contain the full number.

Mozilla's Public Suffix List, used for cookie domain verification

SPNEGO auth is supported

SSL options are present

Built against Windows SSPI

libcurl API is thread-safe

TLS-SRP auth is supported

Unicode support on Windows

Unix domain sockets support

zstd features are present

Based on poll(2) structure and values. * We do not use pollfd and POLL* constants explicitly * to cover platforms without poll().

This is a magic return code for the write callback that, when returned, will signal an error from the callback.

This is a magic return code for the write callback that, when returned, will signal libcurl to pause receiving on the current transfer.

bits for the CURLOPT_WS_OPTIONS bitmask:

Special size_t value signaling a null-terminated string.

info about the certificate chain, for SSL backends that support it. Asked for with CURLOPT_CERTINFO / CURLINFO_CERTINFO

if splitting of data transfer is enabled, this callback is called before download of an individual chunk started. Note that parameter "remains" works only for FTP wildcard downloading (for now), otherwise is not used

If splitting of data transfer is enabled this callback is called after download of an individual chunk finished. Note! After this callback was set then it have to be called FOR ALL chunks. Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. This is the reason why we do not need "transfer_info" parameter in this callback and we are not interested in "remains" parameter too.

All possible error codes from all sorts of curl functions. Future versions may return other values, stay prepared. Always add new return codes last. Never *EVER* remove any. The return codes must remain the same!

This prototype applies to all conversion callbacks

* Callback to install via CURLMOPT_NOTIFYFUNCTION.

The CURLOPTTYPE_* id ranges can still be used to figure out what type/size to use for curl_easy_setopt() for the given id

Information about a single file, used when doing FTP wildcard matching

enumeration of file types

callback type for wildcard downloading pattern matching. If the string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc.

* callback function for curl_formget() * The void *arg pointer will be the one passed as second argument to * curl_formget(). * The character buffer passed to it must not be freed. * Should return the buffer length passed to it as the argument "len" on * success.

parameter for the CURLOPT_FTPSSLAUTH option

parameter for the CURLOPT_FTP_SSL_CCC option

parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option

parameter for the CURLOPT_FTP_FILEMETHOD option

'origin' bits

the kind of data that is passed to information_callback

this is the set of status codes pass in to the callback

this is the set of return values expected from the curl_sshkeycallback callback

Different lock access types

Different data locks for a single share

* The following typedef's are signatures of malloc, free, realloc, strdup and * calloc respectively. Function pointers of these types can be passed to the * curl_global_init_mem() function to set user defined memory management * callback routines.

Mime/form handling support.

Mime part context.

* Notifications dispatched by a multi handle, when enabled.

* Name: curl_multi_timer_callback * * Desc: Called by libcurl whenever the library detects a change in the * maximum number of milliseconds the app is allowed to wait before * curl_multi_socket() or curl_multi_perform() must be called * (to allow libcurl's timed events to take place). * * Returns: The callback should return zero.

* All CURLOPT_* values.

This is the CURLOPT_PREREQFUNCTION callback prototype.

This is the CURLOPT_PROGRESSFUNCTION callback prototype. It is now considered deprecated but was the only choice up until 7.31.0

* Proxy error codes. Returned in CURLINFO_PROXY_ERROR if CURLE_PROXY was * return for the transfers.

this enum was added in 7.10

This callback will be called when a new resolver request is made

'whence'

linked-list structure for the CURLOPT_QUOTE option (and other)

private socket pointer

return CURLE_OK to accept

custom pointer passed with

* NAME curl_global_sslset() * * DESCRIPTION * * When built with multiple SSL backends, curl_global_sslset() allows to * choose one. This function can only be called once, and it must be called * *before* curl_global_init(). * * The backend can be identified by the id (e.g. CURLSSLBACKEND_OPENSSL). The * backend can also be specified via the name parameter (passing -1 as id). If * both id and name are specified, the name will be ignored. If neither id nor * name are specified, the function will fail with CURLSSLSET_UNKNOWN_BACKEND * and set the "avail" pointer to the NULL-terminated list of available * backends. * * Upon success, the function returns CURLSSLSET_OK. * * If the specified SSL backend is not available, the function returns * CURLSSLSET_UNKNOWN_BACKEND and sets the "avail" pointer to a * NULL-terminated list of available SSL backends. * * The SSL backend can be set only once. If it has already been set, a * subsequent attempt to change it will result in a CURLSSLSET_TOO_LATE.

This is the curl_ssls_export_cb callback prototype. It is passed to curl_easy_ssls_export() to extract SSL sessions/tickets.

Information about the SSL library used and the respective internal SSL handle, which can be used to obtain further information regarding the connection. Asked for with CURLINFO_TLS_SSL_PTR or CURLINFO_TLS_SESSION.

the error codes for the URL API

This is the CURLOPT_XFERINFOFUNCTION callback prototype. It was introduced in 7.32.0, avoids the use of floating point numbers and provides more detailed information.

* NAME curl_easy_duphandle() * * DESCRIPTION * * Creates a new curl session handle with the same options set for the handle * passed in. Duplicating a handle could only be a matter of cloning data and * options, internal state info and things like persistent connections cannot * be transferred. It is useful in multithreaded applications when you can run * curl_easy_duphandle() for each new thread to avoid a series of identical * curl_easy_setopt() invokes in every thread.

* NAME curl_easy_escape() * * DESCRIPTION * * Escapes URL strings (converts all letters consider illegal in URLs to their * %XX versions). This function returns a new allocated string or NULL if an * error occurred.

* NAME curl_easy_getinfo() * * DESCRIPTION * * Request internal information from the curl session with this function. * The third argument MUST be pointing to the specific type of the used option * which is documented in each manpage of the option. The data pointed to * will be filled in accordingly and can be relied upon only if the function * returns CURLE_OK. This function is intended to get used *AFTER* a performed * transfer, all results from this function are undefined until the transfer * is completed.

* NAME curl_easy_pause() * * DESCRIPTION * * The curl_easy_pause function pauses or unpauses transfers. Select the new * state by setting the bitmask, use the convenience defines below. *

* NAME curl_easy_recv() * * DESCRIPTION * * Receives data from the connected socket. Use after successful * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.

* NAME curl_easy_reset() * * DESCRIPTION * * Re-initializes a curl handle to the default values. This puts back the * handle to the same state as it was in when it was just created. * * It does keep: live connections, the Session ID cache, the DNS cache and the * cookies.

* NAME curl_easy_send() * * DESCRIPTION * * Sends data over the connected socket. Use after successful * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.

* NAME curl_easy_ssls_export() * * DESCRIPTION * * The curl_easy_ssls_export function iterates over all SSL sessions stored * in the easy handle (or underlying share) and invokes the passed * callback. *

* NAME curl_easy_ssls_import() * * DESCRIPTION * * The curl_easy_ssls_import function adds a previously exported SSL session * to the SSL session cache of the easy handle (or the underlying share).

* NAME curl_easy_strerror() * * DESCRIPTION * * The curl_easy_strerror function may be used to turn a CURLcode value * into the equivalent human readable error string. This is useful * for printing meaningful error messages.

* NAME curl_easy_unescape() * * DESCRIPTION * * Unescapes URL encoding in strings (converts all %XX codes to their 8bit * versions). This function returns a new allocated string or NULL if an error * occurred. * Conversion Note: On non-ASCII platforms the ASCII %XX codes are * converted into the host encoding.

* NAME curl_easy_upkeep() * * DESCRIPTION * * Performs connection upkeep for the given session handle.

the previous version:

* NAME curl_free() * * DESCRIPTION * * Provided for de-allocation in the same translation unit that did the * allocation. Added in libcurl 7.10

* NAME curl_getdate() * * DESCRIPTION * * Returns the time, in seconds since 1 Jan 1970 of the time string given in * the first argument. The time argument in the second parameter is unused * and should be set to NULL.

* NAME curl_getenv() * * DESCRIPTION * * Returns a malloc()'ed string that MUST be curl_free()ed after usage is * complete. DEPRECATED - see lib/README.curlx

* NAME curl_global_cleanup() * * DESCRIPTION * * curl_global_cleanup() should be invoked exactly once for each application * that uses libcurl

* NAME curl_global_init() * * DESCRIPTION * * curl_global_init() should be invoked exactly once for each application that * uses libcurl and before any call of other libcurl functions. * This function is thread-safe if CURL_VERSION_THREADSAFE is set in the * curl_version_info_data.features flag (fetch by curl_version_info()).

* NAME curl_global_init_mem() * * DESCRIPTION * * curl_global_init() or curl_global_init_mem() should be invoked exactly once * for each application that uses libcurl. This function can be used to * initialize libcurl and set user defined memory management callback * functions. Users can implement memory management routines to check for * memory leaks, check for mis-use of the curl library etc. User registered * callback routines will be invoked by this library instead of the system * memory management routines like malloc, free etc.

* NAME curl_global_trace() * * DESCRIPTION * * curl_global_trace() can be invoked at application start to * configure which components in curl should participate in tracing. * This function is thread-safe if CURL_VERSION_THREADSAFE is set in the * curl_version_info_data.features flag (fetch by curl_version_info()).

* NAME curl_mime_addpart() * * DESCRIPTION * * Append a new empty part to the given mime context and return a handle to * the created part.

* NAME curl_mime_data() * * DESCRIPTION * * Set mime part data source from memory data,

* NAME curl_mime_data_cb() * * DESCRIPTION * * Set mime part data source from callback function.

* NAME curl_mime_encoder() * * DESCRIPTION * * Set mime data transfer encoder.

* NAME curl_mime_filedata() * * DESCRIPTION * * Set mime part data source from named file.

* NAME curl_mime_filename() * * DESCRIPTION * * Set mime part remote filename.

* NAME curl_mime_free() * * DESCRIPTION * * release a mime handle and its substructures.

* NAME curl_mime_headers() * * DESCRIPTION * * Set mime part headers.

* NAME curl_mime_init() * * DESCRIPTION * * Create a mime context and return its handle. The easy parameter is the * target handle.

* NAME curl_mime_name() * * DESCRIPTION * * Set mime/form part name.

* NAME curl_mime_subparts() * * DESCRIPTION * * Set mime part data source from subparts.

* NAME curl_mime_type() * * DESCRIPTION * * Set mime part type.

* Name: curl_multi_add_handle() * * Desc: add a standard curl handle to the multi stack * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_assign() * * Desc: This function sets an association in the multi handle between the * given socket and a private pointer of the application. This is * (only) useful for curl_multi_socket uses. * * Returns: CURLM error code.

* Name: curl_multi_cleanup() * * Desc: Cleans up and removes a whole multi stack. It does not free or * touch any individual easy handles in any way. We need to define * in what state those handles will be if this function is called * in the middle of a transfer. * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_fdset() * * Desc: Ask curl for its fd_set sets. The app can use these to select() or * poll() on. We want curl_multi_perform() called as soon as one of * them are ready. * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_get_handles() * * Desc: Returns an allocated array holding all handles currently added to * the multi handle. Marks the final entry with a NULL pointer. If * there is no easy handle added to the multi handle, this function * returns an array with the first entry as a NULL pointer. * * Returns: NULL on failure, otherwise a CURL **array pointer

* Name: curl_multi_get_offt() * * Desc: Retrieves a numeric value for the `CURLMINFO_*` enums. * * Returns: CULRM_OK or error when value could not be obtained.

* Name: curl_multi_info_read() * * Desc: Ask the multi handle if there is any messages/informationals from * the individual transfers. Messages include informationals such as * error code from the transfer or just the fact that a transfer is * completed. More details on these should be written down as well. * * Repeated calls to this function will return a new struct each * time, until a special "end of msgs" struct is returned as a signal * that there is no more to get at this point. * * The data the returned pointer points to will not survive calling * curl_multi_cleanup(). * * The 'CURLMsg' struct is meant to be simple and only contain basic * information. If more involved information is wanted, we will * provide the particular "transfer handle" in that struct and that * should/could/would be used in subsequent curl_easy_getinfo() calls * (or similar). The point being that we must never expose complex * structs to applications, as then we will undoubtably get backwards * compatibility problems in the future. * * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out * of structs. It also writes the number of messages left in the * queue (after this read) in the integer the second argument points * to.

* Name: curl_multi_init() * * Desc: initialize multi-style curl usage * * Returns: a new CURLM handle to use in all 'curl_multi' functions.

* Name: curl_multi_perform() * * Desc: When the app thinks there is data available for curl it calls this * function to read/write whatever there is right now. This returns * as soon as the reads and writes are done. This function does not * require that there actually is data available for reading or that * data can be written, it can be called just in case. It returns * the number of handles that still transfer data in the second * argument's integer-pointer. * * Returns: CURLMcode type, general multi error code. *NOTE* that this only * returns errors etc regarding the whole multi stack. There might * still have occurred problems on individual transfers even when * this returns OK.

* Name: curl_multi_poll() * * Desc: Poll on all fds within a CURLM set as well as any * additional fds passed to the function. * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_remove_handle() * * Desc: removes a curl handle from the multi stack again * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_setopt() * * Desc: Sets options for the multi handle. * * Returns: CURLM error code.

* Name: curl_multi_strerror() * * Desc: The curl_multi_strerror function may be used to turn a CURLMcode * value into the equivalent human readable error string. This is * useful for printing meaningful error messages. * * Returns: A pointer to a null-terminated error message.

* Name: curl_multi_timeout() * * Desc: Returns the maximum number of milliseconds the app is allowed to * wait before curl_multi_socket() or curl_multi_perform() must be * called (to allow libcurl's timed events to take place). * * Returns: CURLM error code.

* Name: curl_multi_wait() * * Desc: Poll on all fds within a CURLM set as well as any * additional fds passed to the function. * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_waitfds() * * Desc: Ask curl for fds for polling. The app can use these to poll on. * We want curl_multi_perform() called as soon as one of them are * ready. Passing zero size allows to get just a number of fds. * * Returns: CURLMcode type, general multi error code.

* Name: curl_multi_wakeup() * * Desc: wakes up a sleeping curl_multi_poll call. * * Returns: CURLMcode type, general multi error code.

* NAME curl_share_strerror() * * DESCRIPTION * * The curl_share_strerror function may be used to turn a CURLSHcode value * into the equivalent human readable error string. This is useful * for printing meaningful error messages.

* NAME curl_slist_append() * * DESCRIPTION * * Appends a string to a linked list. If no list exists, it will be created * first. Returns the new list, after appending.

* NAME curl_slist_free_all() * * DESCRIPTION * * free a previously built curl_slist.

curl_strequal() and curl_strnequal() are subject for removal in a future release

the previous version

* curl_url() creates a new CURLU handle and returns a pointer to it. * Must be freed with curl_url_cleanup().

* curl_url_cleanup() frees the CURLU handle and related resources used for * the URL parsing. It will not free strings previously returned with the URL * API.

* curl_url_dup() duplicates a CURLU handle and returns a new copy. The new * handle must also be freed with curl_url_cleanup().

* curl_url_get() extracts a specific part of the URL from a CURLU * handle. Returns error code. The returned pointer MUST be freed with * curl_free() afterwards.

* curl_url_set() sets a specific part of the URL in a CURLU handle. Returns * error code. The passed in string will be copied. Passing a NULL instead of * a part string, clears that part.

* curl_url_strerror() turns a CURLUcode value into the equivalent human * readable error string. This is useful for printing meaningful error * messages.

* NAME curl_version() * * DESCRIPTION * * Returns a static ASCII string of the libcurl version.

* NAME curl_version_info() * * DESCRIPTION * * This function returns a pointer to a static copy of the version info * struct. See above.

* NAME curl_ws_recv() * * DESCRIPTION * * Receives data from the websocket connection. Use after successful * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.

* NAME curl_ws_send() * * DESCRIPTION * * Sends data over the websocket connection. Use after successful * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.

* NAME curl_ws_start_frame() * * DESCRIPTION * * Buffers a websocket frame header with the given flags and length. * Errors when a previous frame is not complete, e.g. not all its * payload has been added.