Upload Chilkat2 Java Reference Documentation
Upload
Current Version: 11.7.0
Markdown version of this page for AI tools (v 11.7.0) · all AI docs
Chilkat.Upload
Add one or more local file references and send them to a server endpoint
using HTTP POST.
Add ordinary form fields alongside file parts when the server expects
metadata, tokens, IDs, or other POST parameters.
Include application-specific HTTP headers for authorization schemes,
API requirements, content negotiation, or server-side routing.
Use a simple blocking upload, begin an upload in the background, or use
async task-based workflows where supported.
Monitor bytes sent, percent uploaded, current filename, upload state,
and optionally throttle upload bandwidth.
Configure Basic authentication, HTTP/SOCKS proxy settings, HTTPS/TLS
behavior, cipher restrictions, protocol versions, and certificate pinning.
For an extended overview, see
Upload Class Overview.
Upload files with HTTP POST, form fields, headers, progress tracking, and TLS control.
Chilkat.Upload sends files to a web server using HTTP POST,
typically as a multipart/form-data upload. It supports one or more file
references, custom form parameters, custom HTTP headers, blocking and
asynchronous uploads, progress monitoring, upload throttling, Basic HTTP
authentication, proxy settings, HTTPS/TLS configuration, timeout control, and
inspection of the HTTP response returned by the server.
File upload requests
Form parameters
Custom headers
Blocking or async upload
Progress and throttling
Authentication, proxy, and TLS
Hostname, Port, Ssl,
and upload Path, add file references with
AddFileReference, add any form parameters or headers, then call
BlockingUpload or start an asynchronous upload. After completion,
inspect ResponseStatus, ResponseHeader,
ResponseBody, and LastErrorText to determine what
the server returned.
Object Creation
import com.chilkatsoft.chilkat2.ChilkatException;
import com.chilkatsoft.chilkat2.Upload;
try (Upload upload = new Upload()) {
// ... use upload ...
} catch (ChilkatException e) {
System.out.println(e.getMessage()); // "Upload.someMethod failed: <reason>"
System.out.println(e.getLastErrorText()); // the full log of the failed call
}Creates the underlying native Chilkat object. The native library (chilkat2java) is loaded the first time any Chilkat2 object is created; see the README in the download for where it is looked for (-Dchilkat2.library.path, a classpath resource, or java.library.path).
Releases the native object (Upload is AutoCloseable, so try-with-resources calls it). Calling it again does nothing; any other method or property accessor called afterwards throws IllegalStateException. An object that is never closed is freed by a background cleaner once it becomes unreachable, but the garbage collector does not see native memory, so closing is the normal path. Objects returned by methods are owned by the caller too.
Returns true once close() has been called.
Errors
A method that fails throws ChilkatException, an unchecked exception carrying getClassName(), getMethodName(), getReason() (one line, also in the message) and getLastErrorText() (the full log, captured at the moment of the failure). The object remains usable. Methods that look something up and find nothing return null instead of throwing (each such method says so), and methods that answer a question (hasMember, isUnlocked, ...) return a plain boolean. Property accessors do not throw for Chilkat reasons.
A null string or object argument throws NullPointerException naming the parameter (except where a method documents that null is accepted), and a string containing U+0000 throws IllegalArgumentException.
Use an object from one thread at a time; it may be handed from one thread to another. The one cross-thread operation is setting setAbortCurrent(true) on an object that is busy in another thread (on the classes that have AbortCurrent). Unlocking: call new Global().unlockBundle("...") once at startup.
Properties
AbortCurrent
boolean getAbortCurrent()
void setAbortCurrent(boolean value)
When set to true, causes the currently running method to abort. Methods that always finish quickly (i.e.have no length file operations or network communications) are not affected. If no method is running, then this property is automatically reset to false when the next method is called. When the abort occurs, this property is reset to false. Both synchronous and asynchronous method calls can be aborted. (A synchronous method call could be aborted by setting this property from a separate thread.)
BandwidthThrottleUp
int getBandwidthThrottleUp()
void setBandwidthThrottleUp(int value)
If non-zero, limits (throttles) the upload bandwidth to approximately this maximum number of bytes per second. The default value of this property is 0.
ChunkSize
int getChunkSize()
void setChunkSize(int value)
The chunk size (in bytes) used by the underlying TCP/IP sockets for uploading files. The default value is 65535.
topClientIpAddress
String getClientIpAddress()
void setClientIpAddress(String value)
The IP address to use for computers with multiple network interfaces or IP addresses. For computers with a single network interface (i.e. most computers), this property should not be set. For multihoming computers, the default IP address is automatically used if this property is not set.
The IP address is a string such as in dotted notation using numbers, not domain names, such as 165.164.55.124.
CurrentFilename
String getCurrentFilename()
The current filename being uploaded while an asynchronous upload is in progress.
topDebugLogFilePath
String getDebugLogFilePath()
void setDebugLogFilePath(String value)
If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.
Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.
Possible causes of hangs include:
- A timeout property set to 0, indicating an infinite timeout.
- A hang occurring within an event callback in the application code.
- An internal bug in the Chilkat code causing the hang.
Expect100Continue
boolean getExpect100Continue()
void setExpect100Continue(boolean value)
When true, the request header will included an Expect: 100-continue header field. This indicates that the server should respond with an intermediate response of 100 Continue or 417 Expectation Failed response based on the information available in the request header. This helps avoid situations such as limits on upload sizes. It allows the server to reject the upload, and then the client can abort prior to uploading the data.
The default value of this property is true.
HeartbeatMs
int getHeartbeatMs()
void setHeartbeatMs(int value)
The interval in milliseconds between each AbortCheck event callback, which enables an application to abort certain method calls before they complete. By default, HeartbeatMs is set to 0, meaning no AbortCheck event callbacks will trigger.
Hostname
String getHostname()
void setHostname(String value)
The hostname of the HTTP server that is the target of the upload. Do not include http:// in the hostname. It can be a hostname, such as www.chilkatsoft.com, or an IP address, such as 168.144.70.227.
IdleTimeoutMs
int getIdleTimeoutMs()
void setIdleTimeoutMs(int value)
A timeout in milliseconds. The default value is 30000. If the upload hangs (i.e. progress halts) for more than this time, the component will abort the upload. (It will timeout.)
topLastErrorHtml
String getLastErrorHtml()
Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastErrorText
String getLastErrorText()
Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
LastErrorXml
String getLastErrorXml()
Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastMethodSuccess
boolean getLastMethodSuccess()
void setLastMethodSuccess(boolean value)
Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.
Login
String getLogin()
void setLogin(String value)
The HTTP login for sites requiring authentication. Chilkat Upload supports Basic HTTP authentication.
topNumBytesSent
long getNumBytesSent()
After an upload has completed, this property contains the number of bytes sent. During asynchronous uploads, this property contains the current number of bytes sent while the upload is in progress.
topPassword
String getPassword()
void setPassword(String value)
The HTTP password for sites requiring authentication. Chilkat Upload supports Basic HTTP authentication.
topPath
String getPath()
void setPath(String value)
The path part of the upload URL. Some examples:
desc> If the upload target (i.e. consumer) URL is: http://www.freeaspupload.net/freeaspupload/testUpload.asp, then
Hostname =If the upload target URL is https://www.chilkatsoft.com/cgi-bin/ConsumeUpload.exe, thenwww.freeaspupload.netPath =/freeaspupload/testUpload.asp
Hostname =topwww.chilkatsoft.comPath =/cgi-bin/ConsumeUpload.exe
PercentDoneScale
int getPercentDoneScale()
void setPercentDoneScale(int value)
This property is only valid in programming environment and languages that allow for event callbacks.
Sets the value to be defined as 100% complete for the purpose of PercentDone event callbacks. The defaut value of 100 means that at most 100 event PercentDone callbacks will occur in a method that (1) is event enabled and (2) is such that it is possible to measure progress as a percentage completed. This property may be set to larger numbers to get more fine-grained PercentDone callbacks. For example, setting this property equal to 1000 will provide callbacks with .1 percent granularity. For example, a value of 453 would indicate 45.3% competed. This property is clamped to a minimum value of 10, and a maximum value of 100000.
topPercentUploaded
long getPercentUploaded()
Contains the current percentage completion (0 to 100) while an asynchronous upload is in progress.
topPort
int getPort()
void setPort(int value)
The port number of the upload target (i.e. consumer) URL. The default value is 80. If SSL is used, this should be set to 443 (typically).
topPreferIpv6
boolean getPreferIpv6()
void setPreferIpv6(boolean value)
If true, then use IPv6 over IPv4 when both are supported for a particular domain. The default value of this property is false, which will choose IPv4 over IPv6.
ProxyDomain
String getProxyDomain()
void setProxyDomain(String value)
The domain name of a proxy host if an HTTP proxy is used. Do not include the http://. The domain name may be a hostname, such as www.chilkatsoft.com, or an IP address, such as 168.144.70.227.
ProxyLogin
String getProxyLogin()
void setProxyLogin(String value)
If an HTTP proxy is used and it requires authentication, this property specifies the HTTP proxy login.
topProxyPassword
String getProxyPassword()
void setProxyPassword(String value)
If an HTTP proxy is used and it requires authentication, this property specifies the HTTP proxy password.
topProxyPort
int getProxyPort()
void setProxyPort(int value)
The port number of a proxy server if an HTTP proxy is used.
topResponseBodyStr
String getResponseBodyStr()
Returns the response body as a string.
topResponseHeader
String getResponseHeader()
An HTTP upload is nothing more than an HTTP POST that contains the content of the files being uploaded. Just as with any HTTP POST or GET, the server should send an HTTP response that consists of header and body.
desc>This property contains the header part of the HTTP response.
topResponseStatus
int getResponseStatus()
The HTTP response status code of the HTTP response. A list of HTTP status codes can be found here: HTTP Response Status Codes.
topSsl
boolean getSsl()
void setSsl(boolean value)
Set this to true if the upload is to HTTPS. For example, if the target of the upload is:
https://www.myuploadtarget.com/consumeUpload.asp
desc>then set:
Ssl =toptrue
Hostname =www.myuploadtarget.com
Path =/consumeupload.asp
Port = 443
SslAllowedCiphers
String getSslAllowedCiphers()
void setSslAllowedCiphers(String value)
Provides a means for setting a list of ciphers that are allowed for SSL/TLS connections. The default (empty string) indicates that all implemented ciphers are possible. The TLS ciphers supported in Chilkat v9.5.0.55 and later are:
TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 TLS_DHE_RSA_WITH_AES_256_CBC_SHA TLS_RSA_WITH_AES_256_CBC_SHA256 TLS_RSA_WITH_AES_256_GCM_SHA384 TLS_RSA_WITH_AES_256_CBC_SHA TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 TLS_DHE_RSA_WITH_AES_128_CBC_SHA TLS_RSA_WITH_AES_128_CBC_SHA256 TLS_RSA_WITH_AES_128_GCM_SHA256 TLS_RSA_WITH_AES_128_CBC_SHA TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA TLS_RSA_WITH_3DES_EDE_CBC_SHA TLS_ECDHE_RSA_WITH_RC4_128_SHA TLS_RSA_WITH_RC4_128_SHA TLS_RSA_WITH_RC4_128_MD5 TLS_DHE_RSA_WITH_DES_CBC_SHA TLS_RSA_WITH_DES_CBC_SHATo restrict SSL/TLS connections to one or more specific ciphers, set this property to a comma-separated list of ciphers such as
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384. The order should be in terms of preference, with the preferred algorithms listed first. (Note that the client cannot specifically choose the algorithm is picked because it is the server that chooses. The client simply provides the server with a list from which to choose.)
The property can also disallow connections with servers having certificates with RSA keys less than a certain size. By default, server certificates having RSA keys of 512 bits or greater are allowed. Add the keyword rsa1024 to disallow connections with servers having keys smaller than 1024 bits. Add the keyword rsa2048 to disallow connections with servers having keys smaller than 2048 bits.
Note: Prior to Chilkat v9.5.0.55, it was not possible to explicitly list allowed cipher suites. The deprecated means for indicating allowed ciphers was both incomplete and unprecise. For example, the following keywords could be listed to allow matching ciphers: aes256-cbc, aes128-cbc, 3des-cbc, and rc4. These keywords will still be recognized, but programs should be updated to explicitly list the allowed ciphers.
secure-renegotiation: Starting in Chilkat v9.5.0.55, the keyword secure-renegotiation may be added to require that all renegotions be done securely (as per RFC 5746).
best-practices: Starting in Chilkat v9.5.0.55, this property may be set to the single keyword best-practices. This will allow ciphers based on the current best practices. As new versions of Chilkat are released, the best practices may change. Changes will be noted here. The current best practices are:
- If the server uses an RSA key, it must be 1024 bits or greater.
- All renegotations must be secure renegotiations.
- All ciphers using RC4, DES, or 3DES are disallowed.
Example: The following string would restrict to 2 specific cipher suites, require RSA keys to be 1024 bits or greater, and require secure renegotiations: TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, secure-renegotiation
SslProtocol
String getSslProtocol()
void setSslProtocol(String value)
Selects the secure protocol to be used for secure (SSL/TLS) connections. Possible values are:
defaultThe default value is
TLS 1.3
TLS 1.2
TLS 1.1
TLS 1.0
SSL 3.0
TLS 1.3 or higher
TLS 1.2 or higher
TLS 1.1 or higher
TLS 1.0 or higher
default which will choose the, which allows for the protocol to be selected dynamically at runtime based on the requirements of the server. Choosing an exact protocol will cause the connection to fail unless that exact protocol is negotiated. It is better to choose X or higher than an exact protocol. The default is effectively SSL 3.0 or higher.
top
TlsPinSet
String getTlsPinSet()
void setTlsPinSet(String value)
Specifies a set of pins for Public Key Pinning for TLS connections. This property lists the expected SPKI fingerprints for the server certificates. If the server's certificate (sent during the TLS handshake) does not match any of the SPKI fingerprints, then the TLS handshake is aborted and the connection fails. The format of this string property is as follows:
hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...For example, the following string specifies a single sha256 base64-encoded SPKI fingerprint:
"sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE="This example specifies two SPKI fingerprints:
"sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs="Any of the following hash algorithms are allowed:.sha1, sha256, sha384, sha512, md2, md5, haval, ripemd128, ripemd160,ripemd256, or ripemd320.
The following encodings are allowed: base64, hex, and any of the encodings indicated in the link below.
TotalUploadSize
long getTotalUploadSize()
The total size of the upload (in bytes). This property will become set at the beginning of an asynchronous upload. A program may monitor asynchronous uploads by tracking both NumBytesSent and PercentUploaded.
desc> This property is also set during synchronous uploads.
topUploadInProgress
boolean getUploadInProgress()
Set to true when an asynchronous upload is started. When the asynchronous upload is complete, this property becomes equal to false. A program will typically begin an asynchronous upload by calling BeginUpload, and then periodically checking the value of this property to determine when the upload is complete.
UploadSuccess
boolean getUploadSuccess()
Set to true (success) or false (failed) after an asynchronous upload completes or aborts due to failure. When a program does an asynchronous upload, it will wait until UploadInProgress becomes false. It will then check the value of this property to determine if the upload was successful or not.
VerboseLogging
boolean getVerboseLogging()
void setVerboseLogging(boolean value)
If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.
Version
String getVersion()
Methods
AbortUpload
May be called during an asynchronous upload to abort.
topAddCustomHeader
Adds a custom HTTP header to the HTTP upload.
topAddFileReference
Adds a file to the list of files to be uploaded in the next call to BlockingUpload, BeginUpload, or UploadToMemory. To upload more than one file, call this method once for each file to be uploaded.
topAddParam
Adds a custom HTTP request parameter to the upload.
topBeginUpload
Starts an asynchronous upload. Only one asynchronous upload may be in progress at a time. To achieve multiple asynchronous uploads, use multiple instances of the Chilkat Upload object. Each object instance is capable of managing a single asynchronous upload.
desc>
When this method is called, a background thread is started and the asynchronous upload runs in the background. The upload may be aborted at any time by calling AbortUpload. The upload is completed (or failed) when UploadInProgress becomes false. At that point, the UploadSuccess property may be checked to determine success (true) or failure (false).
Throws ChilkatException on failure; e.getLastErrorText() (or the object's getLastErrorText()) explains why, and the object remains usable.
BlockingUpload
Uploads files to a web server using HTTP. The files to be uploaded are indicated by calling AddFileReference once for each file (prior to calling this method).
Throws ChilkatException on failure; e.getLastErrorText() (or the object's getLastErrorText()) explains why, and the object remains usable.
ClearFileReferences
Clears the internal list of files created by calls to AddFileReference.
topClearParams
Clears the internal list of params created by calls to AddParam.
topSleepMs
A convenience method for putting the calling process to sleep for N milliseconds. It is provided here because some programming languages do not provide this capability, and sleeping for short increments of time is helpful when doing asynchronous uploads.
topEvents
All Chilkat methods are synchronous: the call returns when the work is done. During a long-running call, Upload reports progress through a ProgressListener, an interface with three methods, each with a default, so you override only what you need:
import com.chilkatsoft.chilkat2.ProgressListener;
upload.setProgressListener(new ProgressListener() {
@Override public boolean percentDone(int pctDone) {
System.out.println(pctDone + "%");
return false; // return true to abort the method in progress
}
@Override public void progressInfo(String name, String value) {
System.out.println(name + ": " + value);
}
});
upload.setHeartbeatMs(250); // abortCheck 4 times per secondFor a single callback, a lambda is shorter:
upload.onPercentDone(pct -> { System.out.println(pct + "%"); return false; });Installs listener as the receiver of this object's events, replacing any listener or lambda installed before; null removes it.
Returns the installed listener, or null.
Each installs a listener whose only callback is the given lambda (from java.util.function). Like setProgressListener, each replaces the listener installed before, so to handle more than one event, implement ProgressListener. null removes the listener.
abortCheck is called at the interval set by the HeartbeatMs property (0, the default, disables it); percentDone is called when an operation's completion percentage is known; progressInfo delivers named progress values. Returning true from abortCheck or percentDone aborts the running method, which then throws ChilkatException.
Callbacks run on the thread that called the method, before it returns. Inside a callback, property accessors of the object (such as setAbortCurrent(true)) and other objects may be used, but calling a method of the same object throws IllegalStateException. An exception thrown by a callback aborts the running method and is rethrown from it; the object remains usable.
AbortCheck
boolean abortCheck()
Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the HeartbeatMs property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second.
Example
import java.util.concurrent.atomic.AtomicBoolean;
final AtomicBoolean stop = new AtomicBoolean(false); // another thread may call stop.set(true)
upload.setHeartbeatMs(250); // call abortCheck 4 times per second
upload.onAbortCheck(() -> stop.get());PercentDone
boolean percentDone(int pctDone)
This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The pctDone argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have pctDone equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100).
The PercentDone callback also acts as an AbortCheck event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination.
To abort the operation, set the abort output argument to true. This will cause the method to terminate and return a failure status or corresponding failure value.
Example
upload.onPercentDone(pct -> {
// pct ranges from 0 to 100.
System.out.println("Percent done: " + pct);
return false; // return true to abort the method in progress
});ProgressInfo
void progressInfo(String name, String value)
This event callback provides tag name/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory.
Note: Some Chilkat methods don't fire any ProgressInfo events.
Example
upload.onProgressInfo((name, value) -> System.out.println(name + ": " + value));