The wire listener configuration file

The settings that control the wire listener and the connection between the client and database server are set in the wire listener configuration file.

The default name for the configuration file is $INFORMIXDIR/etc/jsonListener.properties. You can rename this file, but the suffix must be .properties.

If you create a server instance during the installation process, a configuration file that is named jsonListener.properties is automatically created with default properties, otherwise you must manually create the configuration file. You can use the $INFORMIXDIR/etc/jsonListener-example.properties file as a template.

In the configuration file that is created during installation, and in the template file, all of the parameters are commented out by default. To enable a parameter, you must uncomment the row and customize the parameter.

Important: The url parameter is required. All other parameters are optional.

Required
- url
Setup and configuration
Command and operation configuration
Database resource management
MongoDB compatibility
Performance
Security
Wire listener resource management

Required parameter

You must configure the url parameter before using the wire listener.

url

This required parameter specifies the host name, port number, user ID, and password that are used in connections to the database server.

You must specify the sysmaster database in the url parameter. That database is used for administrative purposes by the wire listener.

url = jdbc : informix-sqli : // hostname : portnum / sysmaster : [ USER = userid ; PASSWORD = password NONCE = value ]

You can include additional JDBC properties in the url parameter such as INFORMIXCONTIME, INFORMIXCONRETRY, LOGINTIMEOUT, and IFX_SOC_TIMEOUT. For a list of Informix® environment variables that are supported by the JDBC driver, see Informix® environment variables with the Informix® JDBC Driver.

hostname:portnum: The host name and port number of your computer. For example, localhost:9090.
USER=userid: This optional attribute specifies the user ID that is used in connections to the Informix® database server. If you plan to use this connection to establish or modify collection shards by using the Informix® sharding capability, the specified user must be granted the REPLICATION privilege group access.; If you do not specify the user ID and password, the JDBC driver uses operating system authentication and all wire listener actions are run by using the user ID and password of the operating system user who runs the wire listener start command.
PASSWORD=password: This optional attribute specifies the password for the specified user ID.
NONCE=value: This optional attribute specifies a 16-character value that consists of numbers and the letters a, b, c, d, e, and f. This property triggers password encoding when a pluggable authentication module is configured for the wire listener. Applicable only if the db.authentication parameter is set to informix-mongodb-cr.

Setup and configuration

These parameters provide setup and configuration options.

documentIdAlgorithm

This optional parameter determines the algorithm that is used to generate the unique Informix® identifier for the ID column that is the primary key on the collection table. The _id field of the document is used as the input to the algorithm. The default value is documentIdAlgorithm=ObjectId.

documentIdAlgorithm= { ObjectId | SHA-1 | SHA-256 | SHA-512 }

ObjectId

Indicates that the string representation of the ObjectId is used if the _id field is of type ObjectId; otherwise, the MD5 algorithm is used to compute the hash of the contents of the _id field.

The string representation of an ObjectId is the hexadecimal representation of the 12 bytes that comprise an ObjectId.
The MD5 algorithm provides better performance than the secure hashing algorithms (SHA).

ObjectId is the default value and it is suitable for most situations.

Important: Use the default unless a unique constraint violation is reported even though all documents have a unique _id field. In that case, you might need to use a non-default algorithm, such as SHA-256 or SHA-512.

SHA-1

Indicates that the SHA-1 hashing algorithm is used to derive an identifier from the _id field.

SHA-256

Indicates that the SHA-256 hashing algorithm is used to derive an identifier from the _id field.

SHA-512

Indicates that the SHA-512 hashing algorithm is used to derive an identifier from the _id field. This option generates the most unique values, but uses the most processor resources.

include

This optional parameter specifies the properties file to reference. The path can be absolute or relative. For more information, see Running multiple wire listeners.

include= properties_file

listener.onException

This optional parameter specifies an ordered list of actions to take if an exception occurs that is not handled by the processing layer.

listener.onException = { reply | closeSession | shutdownListener }

reply: When an unhandled exception occurs, reply with the exception message. This is the default value.
closeSession: When an unhandled exception occurs, close the session.
shutdownListener: When an unhandled exception occurs, shut down the wire listener.

listener.hostName

This optional parameter specifies the host name of the wire listener. The host name determines the network adapter or interface that the wire listener binds the server socket to.

Tip: If you enable the wire listener to be accessed by clients on remote hosts, turn on authentication by using the authentication.enable parameter.

listener.hostName= { localhost | hostname | * }

localhost: Bind the wire listener to the localhost address. The wire listener is not accessible from clients on remote machines. This is the default value.
hostname: The host name or IP address of host machine where the wire listener binds to.
*: The wire listener can bind to all interfaces or addresses.

listener.port

This optional parameter specifies the port number to listen on for incoming connections from clients. This value can be overridden from the command line by using the -port argument. The default value is 27017.

Important: If you specify a port number that is less than 1024, the user that starts the wire listener might require additional operating system privileges.

listener.port= { 27017 | port_number }

listener.timezone

This parameter specifies the timezone of the listener java JVM. This will override any system or user configured default timezone. The timezone property affects the timezone of date values that are used outside of BSON documents.

Important: It is recommended that the listener timezone be set to UTC (or GMT). You should change this property only if you are using the listener to interact with relational tables that store dates in a timezone other than UTC/GMT.

Possible values: UTC, GMT, GMT+1, GMT+2, GMT-1, GMT-2, EST, CST, etc. Set this property to null to use the system's default timezone.

listener.timezone = { UTC | timezone }

listener.type

This optional parameter specifies the type of wire listener to start.

listener.type= { mongo | rest | mqtt }

mongo: Connect the wire listener to the MongoDB API. This is the default value.
rest: Connect the wire listener to the REST API.
mqtt: Connect the wire listener to the MQTT protocol.

response.documents.count.default

This optional parameter specifies the default number of documents in a single response to a query. The default value is 100.

response.documents.count.default = { 100 | default_docs }

response.documents.count.maximum

This optional parameter specifies the maximum number of documents in a single response to a query. The default value is 10000.

response.documents.count.maximum= { 10000 | max_docs }

response.documents.size.maximum

This optional parameter specifies the maximum size, in bytes, of all documents in a single response to a query. The default value is 1048576.

response.documents.size.maximum= { 1048576 | max_size }

sharding.enable

This optional parameter indicates whether to enable the use of commands and queries on sharded data.

sharding.enable= { false | true }

false: Do not enable the use of commands and queries on sharded data. This is the default value.
true: Enable the use of commands and queries on sharded data.

sharding.parallel.query.enable

This optional parameter indicates whether to enable the use of parallel sharded queries. Parallel sharded queries require that the SHARD_ID configuration parameter be set to unique IDs on all shard servers. The sharding.enable parameter must also be set to true.

sharding.parallel.query.enable = { false | true }

false: Do not enable parallel sharded queries. This is the default value.
true: Enable parallel sharded queries.

Command and operation configuration

These parameters provide configuration options for JSON commands and operations.

collection.informix.options

This optional parameter specifies which table options for shadow columns or auditing to use when creating a JSON collection.

collection.informix.options=[ { [ { | "audit" | "crcols" | "erkey" | "replcheck" | "vercols" } ] } ]

audit: Use the AUDIT option of the CREATE TABLE statement to create a table to be included in the set of tables that are audited at the row level if selective row-level is enabled.
crcols: Use the CRCOLS option of the CREATE TABLE statement to create two shadow columns that Enterprise Replication uses for conflict resolution.
erkey: Use the ERKEY option of the CREATE TABLE statement to create the ERKEY shadow columns that Enterprise Replication uses for a replication key.
replcheck: Use the REPLCHECK option of the CREATE TABLE statement to create the ifx_replcheck shadow column that Enterprise Replication uses for consistency checking.
vercols: Use the VERCOLS option of the CREATE TABLE statement to create two shadow columns that Informix® uses to support update operations on secondary servers.

command.listDatabases.sizeStrategy

This optional parameter specifies a strategy for calculating the size of your database when the MongoDB listDatabases command is run. The listDatabases command estimates the size of all collections and collection indexes for each database. However, relational tables and indexes are excluded from this size calculation.

Important: The MongoDB listDatabases command performs expensive and CPU-intensive computations on the size of each database in the database server instance. You can decrease the expense by using the command.listDatabases.sizeStrategy parameter.

command.listDatabases.sizeStrategy= { { estimate | { estimate:n} | compute | none | perDatabaseSpace } }

estimate

Estimate the size of the database by sampling documents in every collection. This is the default value. This strategy is the equivalent of {estimate: 1000}, which takes a sample size of 0.1% of the documents in every collection. This is the default value.

command.listDatabases.sizeStrategy=estimate

estimate: n

Estimate the size of the database by sampling one document for every n documents in every collection. The following example estimates the collection size by using sample size of 0.5% or 1/200th of the documents:

command.listDatabases.sizeStrategy={estimate:200}

compute

Compute the exact size of the database.

command.listDatabases.sizeStrategy=compute

none

List the databases but do not compute the size. The database size is listed as 0.

command.listDatabases.sizeStrategy=none

perDatabaseSpace

Calculate the size of a database by adding the sizes for all dbspaces, sbspaces, and blobspaces that are assigned to the tenant database.

Important: The perDatabaseSpace option applies only to tenant databases that are created by the multi-tenancy feature.

update.client.strategy

This optional parameter specifies the method that is used by the wire listener to send updates to the database server. When the wire listener does the update processing, it queries the server for the existing document and then updates the document.

update.client.strategy= { { updatableCursor | deleteInsert } }

updatableCursor: Updates are sent to the database server by using an updatable cursor. This is the default value.
deleteInsert: The original document is deleted when the updated document is inserted.
Important: If the collection is sharded, you must use this method.

update.mode

This optional parameter determines where document updates are processed. The default value is update.mode=mixed.

update.mode= { { mixed | client } }

client: Use the wire listener to process updates. You must use this mode if you enable sharding and want to allow the updating of shard key field values.
mixed: Attempt to process updates on the database server first, then fallback to the wire listener. This is the default value.

Database resource management

These parameters provide database resource management options.

database.buffer.enable

Prerequisite: database.log.enable=true

This optional parameter indicates whether to enable buffered logging when you create a database by using the wire listener.

database.buffer.enable = { true | false }

true: Enable buffered logging. This is the default value.
false: Do not enable buffered logging.

database.create.enable

This optional parameter indicates whether to enable the automatic creation of a database, if a database does not exist.

database.create.enable = { true | false }

true: If a database does not exist, create a database. This is the default value.
false: If a database does not exist, do not create a database. With this option, you can access only existing databases.

database.dbspace

Prerequisite: dbspace.strategy=fixed

This optional parameter specifies the name of the dbspace databases that are created. The default value is database.dbspace=rootdbs.

database.dbspace = { rootdbs | dbspace_name }

database.locale.default

This optional parameter specifies the default locale to use when a database is created by using the wire listener. The default value is en_US.utf8.

database.locale.default = { en_US.utf8 | locale }

database.log.enable

This optional parameter indicates whether to create databases that are enabled for logging.

database.log.enable = { true | false }

true: Create databases that are enabled for logging. This is the default value. Use the database.buffer.enable parameter to enable buffered logging.
false: Do not create databases that are enabled for logging.

database.onException.errorCodes

A JSON document describing what actions to take on specific database error codes. Each action should be followed by an array of the database's integer error codes that should trigger the specified action.

closePools: Error codes that should trigger the listener to close the existing connection pools.
disposeOfConnections: Error codes that indicate the current connection is stale and should be disposed of.
removeCollectionFromCache: Error codes that indicate that the listener's currently cached information about the collection is stale and should be refreshed.
reprepareStatement: Error codes that indicate that the prepared statement should be re-prepared.
retryStatement: Error codes that indicate that an insert, update, delete or query statement should be retried once before the error/result is returned to the client.

These lists of error codes are the default values for each statement, and can be changed or added as you desire. For example:

database.onException.errorCodes={
    "closePools":[-79716, -79730, -79735], 
    "disposeOfConnection":[-349, -79716, -79730, -79735], 
    "removeCollectionFromCache":[-710, -206], 
    "reprepareStatement":[-208, -267, -285, -79716], 
    "retryStatement":[]
}

dbspace.strategy

This optional parameter specifies the strategy to use when determining the location of new databases, tables, and indexes.

dbspace.strategy = { autolocate | fixed }

autolocate: The database server automatically determines the dbspace for the new databases, tables, and indexes. This is the default value.
fixed: Use a specific dbspace, as specified by the database.dbspace property.

fragment.count

This optional parameter specifies the number of fragments to use when creating a collection. If you specify 0, the database server determines the number of fragments to create. If you specify a fragment_num greater than 0, that number of fragments are created when the collection is created. The default value is 0.

fragment.count = { 0 | fragment_num }

jdbc.afterNewConnectionCreation

This optional parameter specifies one or more SQL commands to run after a new connection to the database is created.

jdbc.afterNewConnectionCreation = [ " sql_command " ]

For example, to accelerate queries run through the wire listener by using Informix® Warehouse Accelerator:

jdbc.afterNewConnectionCreation=["SET ENVIRONMENT USE_DWA 'ACCELERATE ON'"]

MongoDB compatibility

These parameters provide options for MongoDB compatibility.

compatible.maxBsonObjectSize.enable

This optional parameter indicates whether the maximum BSON object size is compatible with MongoDB.

Tip: If you insert a BSON document by using an SQL operation, Informix® supports a maximum document size of 2 GB.

compatible.maxBsonObjectSize.enable = { false | true }

false: Use a maximum document size of 256 MB with the wire listener. This is the default value.
true: Use a maximum document size of 16 MB. The maximum document size for MongoDB is 16 MB.

mongo.api.version

This optional parameter specifies the MongoDB API version with which the wire listener is compatible. The version affects authentication methods as well as MongoDB commands.

mongo.api.version = { 2.4 | 2.6 | 3.0 | 3.2 | 3.4 | 3.6 | 4.0 | 4.2 }

Note: 2.4 is the default value.

Important: Do not set mongo.api.version=3.0 or higher if you want to use the REST API with MongoDB style authentication. See User authentication with the wire listener.

update.one.enable

This optional parameter indicates whether to enable support for updating a single JSON document.

Important: The update.one.enable parameter applies to JSON collections only. For relational tables, the MongoDB multi-parameter is ignored and all documents that meet the query criteria are updated.

update.one.enable = { false | true }

false: All collection updates are treated as multiple JSON document updates. This is the default value.; With the update.one.enable=false setting, the MongoDB db.collection.update multi-parameter is ignored and all documents that meet the query criteria are updated.
true: Allow updates on collections to a single document or multiple documents.; With the update.one.enable=true setting, the MongoDB db.collection.update multi-parameter is accepted. The db.collection.update multi-parameter controls whether you can update a single document or multiple documents.

Performance

These parameters provide performance options for databases and collections.

delete.preparedStatement.cache.enable

This optional parameter indicates whether to cache prepared statements that delete documents for reuse.

delete.preparedStatement.cache.enable = { true | false }

true: Use a prepared statement cache for statements that delete documents. This is the default value.
false: Do not use a prepared statement cache for statements that delete documents. A new statement is prepared for each query.

insert.batch.enable

If multiple documents are sent as a part of a single INSERT statement, this optional parameter indicates whether to batch document inserts operations into collections.

insert.batch.enable = { true | false }

true: Batch document inserts into collections by using JDBC batch calls to perform the insert operations. This is the default value.
false: Do not batch document insert operations into collections.

insert.batch.queue.enable

This optional parameter indicates whether to queue INSERT statements into larger batches. You can improve insert performance by queuing INSERT statements, however, there is decreased durability.

This parameter batches all INSERT statements, even a single INSERT statement. These batched INSERT statements are flushed at the interval that is specified by the insert.batch.queue.flush.interval parameter, unless another operation arrives on the same collection. If another operation arrives on the same collection, the batch inserts are immediately flushed to the database server before proceeding with the next operation.

insert.batch.queue.enable = { false | true }

false: Do not queue INSERT statements. This is the default.
true: Queue INSERT statements into larger batches. Use the insert.batch.queue.flush.interval parameter to specify the amount of time between insert queue flushes.

insert.batch.queue.flush.interval

Prerequisite: insert.batch.queue.enable=true

This optional parameter specifies the number of milliseconds between flushes of the insert queue to the database server. The default value is insert.batch.queue.flush.interval=100.

insert.batch.queue.flush.interval = { 100 | flush_interval_time }

index.cache.enable

This optional parameter indicates whether to enable index caching on collections. To write the most efficient queries, the wire listener must be aware of the existing BSON indexes on your collections.

index.cache.enable = { true | false }

true: Cache indexes on collections. This is the default value.
false: Do not cache indexes on collections. The wire listener queries the database for indexes each time a collection query is translated to SQL.

index.cache.update.interval

This optional parameter specifies the amount of time, in seconds, between updates to the index cache on a collection table. The default value is index.cache.update.interval=120.

index.cache.update.interval = { 120 | cache_update_interval }

insert.preparedStatement.cache.enable

This optional parameter indicates whether to cache the prepared statements that are used to insert documents.

insert.preparedStatement.cache.enable = { true | false }

true: Cache the prepared statements that are used to insert documents. This is the default value.
false: Do not cache the prepared statements that are used to insert documents.

preparedStatement.cache.enable

This optional parameter indicates whether to cache prepared statements for reuse.

preparedStatement.cache.enable = { true | false }

true: Use a prepared statement cache. This is the default value.
false: Do not use a prepared statement cache. A new statement is prepared for each query.

preparedStatement.cache.size

This optional parameter specifies the size of the least-recently used (LRU) map that is used to cache prepared statements. The default value is preparedStatement.cache.size=20.

preparedStatement.cache.enable = { 20 | LRU_size }

Security

The parameters provide security enablement options.

authentication.enable

This optional parameter indicates whether to enable user authentication.

You can choose to authenticate users through the wire listener or in the database server.

authentication.enable= { false | true }

false: Do not authenticate users. This is the default value.
true: Authenticate users. Use the authentication.localhost.bypass.enable parameter to control the type of authentication.

authentication.localhost.bypass.enable

Prerequisite: authentication.enable=true

If you connect from the localhost to the Informix® admin database, and the admin database contains no users, this optional parameter indicates whether to grant full administrative access.

The Informix® admin database is similar to the MongoDB admin database. The Informix® authentication.localhost.bypass.enable parameter is similar to the MongoDB enableLocalhostAuthBypass parameter.

authentication.localhost.bypass.enable= { true | false }

true: Grant full administrative access to the user. This is the default value.
false: Do not grant full administrative access to the user.

command.denylist

This optional parameter lists commands that are removed from the command registry and can not be called. By default, the deny list is empty.

command.denylist = [ command ]

db.authentication

This optional parameter specifies the user authentication method. See User authentication with the wire listener.

db.authentication = { mongodb-cr | informix-password | informix-mongodb-cr }

mongdb-cr: Authenticate through the wire listener with a MongoDB authentication method. The MongoDB authentication method depends on the setting of the mongo.api.version parameter. This is the default value when listener.type is set to "mongo".
informix-password: Authenticate through the database server with the username and password provided by the client connection. Informix password authentication is only supported on the REST and MQTT listeners. It is not supported on Mongo listeners. This is the default value when listener.type is set to "rest" or "mqtt".
informix-mongodb-cr: Authenticate through the database server with a pluggable authentication module.

listener.admin.ipAddress

This optional parameter specifies the IP address for the administrative host. Must be a loopback IP address. The default value is 127.0.0.1.

Important: If you specify an address that is not a loopback IP address, an attacker might perform a remote privilege escalation and obtain administrative privileges without knowing a user password.

listener.admin.ipAddress = ip_address

listener.authentication.timeout

This optional parameter specifies the number of milliseconds that the wire listener waits for a client connection to authenticate. The default value is 0, which indicates that the wire listener waits indefinitely for client connections to authenticate.

listener.authentication.timeout = milliseconds

listener.http.accessControlAllowCredentials

This optional parameter indicates whether to display the response to the request when the omit credentials flag is not set. When this parameter is part of the response to a preflight request, it indicates that the actual request can include user credentials.

listener.http.accessControlAllowCredentials= { true | false }

true: Display the response to the request. This is the default value.
false: Do not display the response to the request.

listener.http.accessControlAllowHeaders

This optional parameter, which is part of the response to a preflight request, specifies the header field names that are used during the actual request. You must specify the value by using a JSON array of strings. Each string in the array is the case-insensitive header field name. The default value is listener.http.accessControlAllowHeaders=["accept","cursorId","content-type"].

listener.http.accessControlAllowHeaders= [ { "accept","cursorId","content-type" | "header_field_name" } ]

For example, to allow the headers foo and bar in a request:

listener.http.accessControlAllowHeaders=["foo","bar"]

listener.http.accessControlAllowMethods

This optional parameter, which is part of the response to a preflight request, specifies the REST methods that are used during the actual request. You must specify the value by using a JSON array of strings. Each string in the array is the name of an HTTP method that is allowed. The default value is listener.http.accessControlAllowMethods=["GET","PUT","POST","DELETE","OPTIONS"].

listener.http.accessControlAllowMethods= [ { "GET","PUT","POST","DELETE","OPTIONS" | "rest_method" } ]

listener.http.accessControlAllowOrigin

This optional parameter specifies which uniform resource identifiers (URI) are authorized to receive responses from the REST listener when processing cross-origin resource sharing (CORS) requests. You must specify the value by using a JSON array of strings, with a separate string in the array for each value for the HTTP Origin header in a request. The values that are specified in this parameter are validated to ensure that they are identical to the Origin header.

HTTP requests include an Origin header that specifies the URI that served the resource that processes the request. When a resource from a different origin is accessed, the resource is validated to determine whether sharing is allowed.

The default value, listener.http.accessControlAllowOrigin={"$regex":".*"}, means that any origin is allowed to perform a CORS request.

listener.http.accessControlAllowOrigin= { { "$regex":".*" | authorized_URI } }

Here are some usage examples:

Grant access to the localhost:

listener.http.accessControlAllowOrigin="http://localhost"

Grant access to all hosts in the subnet 10.168.8.0/24. The first 3 segments are validated as 10, 168, and 8, and the fourth segment is validated as a value 1 - 255:
```
listener.http.accessControlAllowOrigin={"$regex":"^http://10\\\\.168\\\\.8\\\\.([01]?\\\\
d\\\\d?|2[0-4]\\\\d|25[0-5])$" }
```
Grant access to all hosts in the subnet 10.168.8.0/24. The first 3 segments are validated as 10, 168, and 8, and the fourth segment must contain one or more digits:
```
listener.http.accessControlAllowOrigin={"$regex":
"^http://10\\\\.168\\\\.8\\\\.\\\\d+$" }
```

listener.http.accessControlExposeHeaders

This optional parameter specifies which headers of a CORS request to expose to the API. You must specify the value by using a JSON array of strings. Each string in the array is the case-insensitive name of a header to be exposed. The default value is listener.http.accessControlExposeHeaders=["cursorId"].

listener.http.accessControlExposeHeaders= { ["cursorId"] | CORS_headers }

For example, to expose the headers foo and bar to a client:

listener.http.accessControlExposeHeaders=["foo","bar"]

listener.http.accessControlMaxAge

This optional parameter specifies the amount of time, in seconds, that the result of a preflight request is cached in a preflight result cache. A value of 0 indicates that the Access-Control-Max-Age header is not included in the response to a preflight request. A value greater than 0 indicates that the Access-Control-Max-Age header is included in the response to a preflight request.

The default value is listener.http.accessControlMaxAge=0.

listener.http.accessControlMaxAge= { 0 | preflight_result_cache_time }

listener.http.headers

This optional parameter specifies the information to include in the HTTP headers of responses, as a JSON document. The default value is no additional information in the HTTP headers.

listener.http.headers = JSON_document

For example, you set this parameter to the following value:

listener.http.headers={ "Access-Control-Allow-Origin" : "http://192.168.0.1", 
"Access-Control-Allow-Credentials" : "true" }

Then the HTTP headers for all responses look like this:

Access-Control-Allow-Origin : http://192.168.0.1
Access-Control-Allow-Credentials : true

listener.http.headers.size.maximum

This optional parameter specifies the maximum size of headers in incoming HTTP requests. The default is 8192 bytes.

listener.http.headers.size.maximum = { 8192 | size }

listener.rest.cookie.domain

This optional parameter specifies the name of the cookie that is created by the REST wire listener. If not specified, the domain is the default value as determined by the Apache Tomcat web server.

listener.rest.cookie.domain= { [ rest_cookie_name ] }

listener.rest.cookie.httpOnly

This optional parameter indicates whether to set the HTTP-only flag.

listener.rest.cookie.httpOnly= { true | false }

true: Set the HTTP-only flag. This flag helps to prevent cross-site scripting attacks. This is the default value.
false: Do not set the HTTP-only flag.

listener.rest.cookie.length

This optional parameter specifies the length, in bytes, of the cookie value that is created by the REST wire listener, before Base64 encoding. The default value is listener.rest.cookie.length=64.

listener.rest.cookie.length= { 64 | rest_cookie_length }

listener.rest.cookie.name

This optional parameter specifies the name of the cookie that is created by the REST wire listener to identify a session. The default value is listener.rest.cookie.name=informixRestListener.sessionId.

listener.rest.cookie.name= { informixRestListener.sessionId | rest_cookie_name }

listener.rest.cookie.path

This optional parameter specifies the path of the cookie that is created by the REST wire listener. The default value is listener.rest.cookie.path=/.

listener.rest.cookie.path= { / | rest_cookie_path }

listener.rest.cookie.secure

This optional parameter indicates whether the cookies that are created by the REST wire listener have the secure flag on. The secure flag prevents the cookies from being used over an unsecure connection.

listener.rest.cookie.secure= { false | true }

false: Turn off the secure flag. This is the default value.
true: Turn on the secure flag.

listener.ssl.algorithm

This optional parameter specifies the Service Provider Interface (SPI) for the KeyManagerFactory that is used to access the network encryption keystore. On an Oracle Java Virtual Machine (JVM), this value is typically SunX509. On an IBM® JVM, this value is typically IbmX509. The default value is no SPI.

Important: Do not set this property if you are not familiar with Java Cryptography Extension (JCE).

listener.ssl.algorithm = SPI

listener.ssl.ciphers

This optional parameter specifies a list of Secure Sockets Layer (SSL) or Transport Layer Security (TLS) ciphers to use with network encryption. The default value is no ciphers, which means that the default list of enabled ciphers for the JVM are used.

Important: Do not set this property if you are not familiar with Java Cryptography Extension (JCE) and the implications of using multiple ciphers. Consult a security expert for advice.

listener.ssl.ciphers = cipher

You can include spaces between ciphers.

For example, you can set the following ciphers:

listener.ssl.ciphers=TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_CBC_SHA, 
TLS_EMPTY_RENEGOTIATION_INFO_SCSV

listener.ssl.enable

This optional parameter enables SSL or TLS network encryption on the socket for client connections. See Configuring SSL connections between the wire listener and client applications.

listener.ssl.enable = { false | true }

false: Disable network encryption. This is the default.
true: Allow network encryption.

listener.ssl.key.alias

This optional parameter specifies the alias, or identifier, of the entry into the keystore. The default value is no alias, which indicates that the keystore contains one entry. If the keystore contain more than one entry and a key password is needed to unlock the keystore, set this parameter to the alias of the entry that unlocks the keystore.

listener.ssl.key.alias = alias