AS2Sender Class

Properties   Methods   Events   Config Settings   Errors  

The AS2Sender class implements an AS2 / EDI-INT client.

Syntax

AS2Sender

Remarks

The AS2Sender component may be used to send EDI or other messages over HTTP/S, using the AS2 protocol. It may also be used to verify synchronous or asynchronous server responses.

A typical AS2 transaction is as follows:

(1) The sender sends an EDI document to the receiver using HTTP or HTTPS. Typically the document will be signed and encrypted (particularly if SSL is not used). A signed receipt will also be requested.

(2) The receiver decrypts the message and verifies the signature.

(3) The receiver sends a signed receipt back to the client. The signature is over the hash of an MDN, which contains a hash of the received message.

When sending an EDI message, the client should specify, at a minimum, AS2From and AS2To, URL, and EDIData. The Post method should then be invoked.

To secure the EDI transmission, the message may be signed and/or encrypted by setting the appropriate certificates. By default, the class will apply message security if the appropriate certificates are specified. To sign the data, set SigningCert. To encrypt, set RecipientCerts. If the recipient uses different certificates for signing and encryption it will also be necessary to set ReceiptSignerCert.

SSL will also be used if the scheme in URL is "https". If your trading partner is using a self-signed certificate, it will be necessary to set SSLAcceptServerCert or trap the SSLServerAuthentication event to accept the certificate.

The message may also be compressed by setting CompressionFormat.

To request a receipt, or Message Disposition Notification (MDN), simply set the MDNTo property. The MDNOptions property may be used to customize the request. By default, the class will request a signed MDN over an SHA1 hash.

The class supports both synchronous and asynchronous MDN receipt delivery. By default, the class requests synchronous MDN receipt delivery, and the MDN will be returned in the HTTP reply. To request asynchronous MDN delivery, set the MDNDeliveryOption to the URL where MDN's are to be delivered.

The HTTP reply will automatically be processed by the class. If an MDN was requested, Post will validate the MDN and (if signed) establish non-repudiation of receipt. Any errors or warnings will cause the class to throw an exception.

In either case, after the EDI transaction is processed successfully, the MDNReceipt will be populated with the appropriate values.

Validating Asynchronous MDNs

The class may also be used to process and verify asynchronous MDNs. To do this, you should invoke ReadAsyncReceipt. This will read the receipt from the current HTTP context (or from MDNReceipt, if set manually), and allow you to determine your trading partner's identity and the message ID. You should then set ReceiptSignerCert and OriginalContentMIC, and finally invoke VerifyReceipt.

Property List

The following is the full list of the properties of the class with short descriptions. Click on the links for further details.

Method List

The following is the full list of the methods of the class with short descriptions. Click on the links for further details.

Event List

The following is the full list of the events fired by the class with short descriptions. Click on the links for further details.

Config Settings

The following is a list of config settings for the class with short descriptions. Click on the links for further details.

AS2From Property (AS2Sender Class)

The AS2 Identifier of the sending system.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetAS2From();
int SetAS2From(const char* lpszAS2From);

Unicode (Windows)
LPWSTR GetAS2From();
INT SetAS2From(LPCWSTR lpszAS2From);

char* ipworksedi_as2sender_getas2from(void* lpObj);
int ipworksedi_as2sender_setas2from(void* lpObj, const char* lpszAS2From);

QString GetAS2From();
int SetAS2From(QString qsAS2From);

Default Value

""

Remarks

May be company name, DUNS number, or anything agreed on by trading partners.

Required.

Data Type

String

AS2To Property (AS2Sender Class)

The AS2 Identifier of the receiving system.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetAS2To();
int SetAS2To(const char* lpszAS2To);

Unicode (Windows)
LPWSTR GetAS2To();
INT SetAS2To(LPCWSTR lpszAS2To);

char* ipworksedi_as2sender_getas2to(void* lpObj);
int ipworksedi_as2sender_setas2to(void* lpObj, const char* lpszAS2To);

QString GetAS2To();
int SetAS2To(QString qsAS2To);

Default Value

""

Remarks

May be company name, DUNS number, or anything agreed on by trading partners.

Required.

Data Type

String

AS2Version Property (AS2Sender Class)

The version of AS2 being used.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetAS2Version();

Unicode (Windows)
LPWSTR GetAS2Version();

char* ipworksedi_as2sender_getas2version(void* lpObj);

QString GetAS2Version();

Default Value

"1.2"

Remarks

The version of AS2 being used.

This property is read-only.

Data Type

String

AsyncMDNInfoDir Property (AS2Sender Class)

Path to a directory to store data used in verifying AsyncMDNs.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetAsyncMDNInfoDir();
int SetAsyncMDNInfoDir(const char* lpszAsyncMDNInfoDir);

Unicode (Windows)
LPWSTR GetAsyncMDNInfoDir();
INT SetAsyncMDNInfoDir(LPCWSTR lpszAsyncMDNInfoDir);

char* ipworksedi_as2sender_getasyncmdninfodir(void* lpObj);
int ipworksedi_as2sender_setasyncmdninfodir(void* lpObj, const char* lpszAsyncMDNInfoDir);

QString GetAsyncMDNInfoDir();
int SetAsyncMDNInfoDir(QString qsAsyncMDNInfoDir);

Default Value

""

Remarks

If Post is invoked after setting AsyncMDNInfoDir and an asynchronous MDN is requested, the class stores the data required to verify AsyncMDNs in a file in the specified directory. The name of the file is the MessageId of the outgoing message.

AsyncMDNInfoDir is also used while verifying asynchronous MDNs using VerifyReceipt. The properties required to process AsyncMDNs, namely OriginalContentMIC and MDNOptions, are automatically read from the file saved at the time of sending the original message.

Data Type

String

Attachments Property (AS2Sender Class)

Collection of files attached to the current message.

Syntax

• C++
• C
• Qt

IPWorksEDIList<IPWorksEDIEDIAttachment>* GetAttachments();
int SetAttachments(IPWorksEDIList<IPWorksEDIEDIAttachment>* val);

int ipworksedi_as2sender_getattachmentcount(void* lpObj);
int ipworksedi_as2sender_setattachmentcount(void* lpObj, int iAttachmentCount);

char* ipworksedi_as2sender_getattachmentcontenttype(void* lpObj, int attachmentindex);
int ipworksedi_as2sender_setattachmentcontenttype(void* lpObj, int attachmentindex, const char* lpszAttachmentContentType);

int ipworksedi_as2sender_getattachmentdata(void* lpObj, int attachmentindex, char** lpAttachmentData, int* lenAttachmentData);
int ipworksedi_as2sender_setattachmentdata(void* lpObj, int attachmentindex, const char* lpAttachmentData, int lenAttachmentData);

char* ipworksedi_as2sender_getattachmentfilename(void* lpObj, int attachmentindex);
int ipworksedi_as2sender_setattachmentfilename(void* lpObj, int attachmentindex, const char* lpszAttachmentFileName);

char* ipworksedi_as2sender_getattachmentheaders(void* lpObj, int attachmentindex);
int ipworksedi_as2sender_setattachmentheaders(void* lpObj, int attachmentindex, const char* lpszAttachmentHeaders);

char* ipworksedi_as2sender_getattachmentname(void* lpObj, int attachmentindex);
int ipworksedi_as2sender_setattachmentname(void* lpObj, int attachmentindex, const char* lpszAttachmentName);

int GetAttachmentCount();
int SetAttachmentCount(int iAttachmentCount);

QString GetAttachmentContentType(int iAttachmentIndex);
int SetAttachmentContentType(int iAttachmentIndex, QString qsAttachmentContentType);

QByteArray GetAttachmentData(int iAttachmentIndex);
int SetAttachmentData(int iAttachmentIndex, QByteArray qbaAttachmentData);

QString GetAttachmentFileName(int iAttachmentIndex);
int SetAttachmentFileName(int iAttachmentIndex, QString qsAttachmentFileName);

QString GetAttachmentHeaders(int iAttachmentIndex);
int SetAttachmentHeaders(int iAttachmentIndex, QString qsAttachmentHeaders);

QString GetAttachmentName(int iAttachmentIndex);
int SetAttachmentName(int iAttachmentIndex, QString qsAttachmentName);

Remarks

When a call to Send is made, the class will attach the files referenced by each EDIAttachment in this collection to the EDIData.

This property is not available at design time.

Data Type

IPWorksEDIEDIAttachment

CEMDetails Property (AS2Sender Class)

A collection of Certificate Exchange Messaging (CEM) details.

Syntax

• C++
• C
• Qt

IPWorksEDIList<IPWorksEDICEMDetail>* GetCEMDetails();
int SetCEMDetails(IPWorksEDIList<IPWorksEDICEMDetail>* val);

int ipworksedi_as2sender_getcemcount(void* lpObj);
int ipworksedi_as2sender_setcemcount(void* lpObj, int iCEMCount);

int ipworksedi_as2sender_getcemaccepted(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemaccepted(void* lpObj, int cemindex, int bCEMAccepted);

char* ipworksedi_as2sender_getcemcertid(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertid(void* lpObj, int cemindex, const char* lpszCEMCertId);

char* ipworksedi_as2sender_getcemcertissuer(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertissuer(void* lpObj, int cemindex, const char* lpszCEMCertIssuer);

char* ipworksedi_as2sender_getcemcertserialnumber(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertserialnumber(void* lpObj, int cemindex, const char* lpszCEMCertSerialNumber);

int ipworksedi_as2sender_getcemcertstore(void* lpObj, int cemindex, char** lpCEMCertStore, int* lenCEMCertStore);
int ipworksedi_as2sender_setcemcertstore(void* lpObj, int cemindex, const char* lpCEMCertStore, int lenCEMCertStore);

char* ipworksedi_as2sender_getcemcertstorepassword(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertstorepassword(void* lpObj, int cemindex, const char* lpszCEMCertStorePassword);

int ipworksedi_as2sender_getcemcertstoretype(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertstoretype(void* lpObj, int cemindex, int iCEMCertStoreType);

char* ipworksedi_as2sender_getcemcertsubject(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertsubject(void* lpObj, int cemindex, const char* lpszCEMCertSubject);

int ipworksedi_as2sender_getcemcertusage(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemcertusage(void* lpObj, int cemindex, int iCEMCertUsage);

char* ipworksedi_as2sender_getcemrejectionreason(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemrejectionreason(void* lpObj, int cemindex, const char* lpszCEMRejectionReason);

char* ipworksedi_as2sender_getcemrespondbydate(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemrespondbydate(void* lpObj, int cemindex, const char* lpszCEMRespondByDate);

char* ipworksedi_as2sender_getcemresponseurl(void* lpObj, int cemindex);
int ipworksedi_as2sender_setcemresponseurl(void* lpObj, int cemindex, const char* lpszCEMResponseURL);

int GetCEMCount();
int SetCEMCount(int iCEMCount);

bool GetCEMAccepted(int iCEMIndex);
int SetCEMAccepted(int iCEMIndex, bool bCEMAccepted);

QString GetCEMCertId(int iCEMIndex);
int SetCEMCertId(int iCEMIndex, QString qsCEMCertId);

QString GetCEMCertIssuer(int iCEMIndex);
int SetCEMCertIssuer(int iCEMIndex, QString qsCEMCertIssuer);

QString GetCEMCertSerialNumber(int iCEMIndex);
int SetCEMCertSerialNumber(int iCEMIndex, QString qsCEMCertSerialNumber);

QByteArray GetCEMCertStore(int iCEMIndex);
int SetCEMCertStore(int iCEMIndex, QByteArray qbaCEMCertStore);

QString GetCEMCertStorePassword(int iCEMIndex);
int SetCEMCertStorePassword(int iCEMIndex, QString qsCEMCertStorePassword);

int GetCEMCertStoreType(int iCEMIndex);
int SetCEMCertStoreType(int iCEMIndex, int iCEMCertStoreType);

QString GetCEMCertSubject(int iCEMIndex);
int SetCEMCertSubject(int iCEMIndex, QString qsCEMCertSubject);

int GetCEMCertUsage(int iCEMIndex);
int SetCEMCertUsage(int iCEMIndex, int iCEMCertUsage);

QString GetCEMRejectionReason(int iCEMIndex);
int SetCEMRejectionReason(int iCEMIndex, QString qsCEMRejectionReason);

QString GetCEMRespondByDate(int iCEMIndex);
int SetCEMRespondByDate(int iCEMIndex, QString qsCEMRespondByDate);

QString GetCEMResponseURL(int iCEMIndex);
int SetCEMResponseURL(int iCEMIndex, QString qsCEMResponseURL);

Remarks

This collection holds Certificate Exchange Messaging (CEM) details. The details define the certificate, respond-by-date, and more.

When using AS2Sender see SendCEMResponse and SendCEMRequest for more information.

When using AS2Receiver see CEMRequest and CEMResponse for more information.

This property is not available at design time.

Data Type

IPWorksEDICEMDetail

CompressionFormat Property (AS2Sender Class)

The compression format (if any) to use.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetCompressionFormat();
int SetCompressionFormat(int iCompressionFormat);

Unicode (Windows)
INT GetCompressionFormat();
INT SetCompressionFormat(INT iCompressionFormat);

CF_NONE(0), 
CF_ZLIB(1)

int ipworksedi_as2sender_getcompressionformat(void* lpObj);
int ipworksedi_as2sender_setcompressionformat(void* lpObj, int iCompressionFormat);

int GetCompressionFormat();
int SetCompressionFormat(int iCompressionFormat);

Default Value

0

Remarks

By default, outgoing data will not be compressed. Setting this property will instruct the class to compress the outgoing data using the indicated format.

Compression is highly recommended for large messages, as it will reduce network bandwidth and processing time required.

The compression algorithm used is Zlib, as required by RFC 3274 and defined in RFCs 1950 and 1951.

Data Type

Integer

Cookies Property (AS2Sender Class)

A collection of cookies.

Syntax

• C++
• C
• Qt

IPWorksEDIList<IPWorksEDIHTTPCookie>* GetCookies();
int SetCookies(IPWorksEDIList<IPWorksEDIHTTPCookie>* val);

int ipworksedi_as2sender_getcookiecount(void* lpObj);
int ipworksedi_as2sender_setcookiecount(void* lpObj, int iCookieCount);

char* ipworksedi_as2sender_getcookiedomain(void* lpObj, int cookieindex);

char* ipworksedi_as2sender_getcookieexpiration(void* lpObj, int cookieindex);

char* ipworksedi_as2sender_getcookiename(void* lpObj, int cookieindex);
int ipworksedi_as2sender_setcookiename(void* lpObj, int cookieindex, const char* lpszCookieName);

char* ipworksedi_as2sender_getcookiepath(void* lpObj, int cookieindex);

int ipworksedi_as2sender_getcookiesecure(void* lpObj, int cookieindex);

char* ipworksedi_as2sender_getcookievalue(void* lpObj, int cookieindex);
int ipworksedi_as2sender_setcookievalue(void* lpObj, int cookieindex, const char* lpszCookieValue);

int GetCookieCount();
int SetCookieCount(int iCookieCount);

QString GetCookieDomain(int iCookieIndex);

QString GetCookieExpiration(int iCookieIndex);

QString GetCookieName(int iCookieIndex);
int SetCookieName(int iCookieIndex, QString qsCookieName);

QString GetCookiePath(int iCookieIndex);

bool GetCookieSecure(int iCookieIndex);

QString GetCookieValue(int iCookieIndex);
int SetCookieValue(int iCookieIndex, QString qsCookieValue);

Remarks

This property contains a collection of cookies. To add cookies to outgoing HTTP requests, add cookies (of type HTTPCookie) to this collection.

To see cookies that are set by the server, use the SetCookie event, which displays the cookies and their properties as set by the server. Those cookies also are added to Cookies.

MaxHTTPCookies can be used to control the maximum number of cookies saved.

This property is not available at design time.

Data Type

IPWorksEDIHTTPCookie

EDIData Property (AS2Sender Class)

The EDI or other data to be sent.

Syntax

• C++
• C
• Qt

IPWorksEDIEDIData* GetEDIData();
int SetEDIData(IPWorksEDIEDIData* val);

int ipworksedi_as2sender_getedidata(void* lpObj, char** lpEDIData, int* lenEDIData);
int ipworksedi_as2sender_setedidata(void* lpObj, const char* lpEDIData, int lenEDIData);

char* ipworksedi_as2sender_geteditype(void* lpObj);
int ipworksedi_as2sender_seteditype(void* lpObj, const char* lpszEDIType);

char* ipworksedi_as2sender_getediname(void* lpObj);
int ipworksedi_as2sender_setediname(void* lpObj, const char* lpszEDIName);

char* ipworksedi_as2sender_getedifilename(void* lpObj);
int ipworksedi_as2sender_setedifilename(void* lpObj, const char* lpszEDIFileName);

QByteArray GetEDIData();
int SetEDIData(QByteArray qbaEDIData);

QString GetEDIType();
int SetEDIType(QString qsEDIType);

QString GetEDIName();
int SetEDIName(QString qsEDIName);

QString GetEDIFileName();
int SetEDIFileName(QString qsEDIFileName);

Remarks

The EDI message to send.

This property is not available at design time.

Data Type

IPWorksEDIEDIData

EncryptionAlgorithm Property (AS2Sender Class)

The algorithm used to encrypt the EDI data.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetEncryptionAlgorithm();
int SetEncryptionAlgorithm(const char* lpszEncryptionAlgorithm);

Unicode (Windows)
LPWSTR GetEncryptionAlgorithm();
INT SetEncryptionAlgorithm(LPCWSTR lpszEncryptionAlgorithm);

char* ipworksedi_as2sender_getencryptionalgorithm(void* lpObj);
int ipworksedi_as2sender_setencryptionalgorithm(void* lpObj, const char* lpszEncryptionAlgorithm);

QString GetEncryptionAlgorithm();
int SetEncryptionAlgorithm(QString qsEncryptionAlgorithm);

Default Value

"3DES"

Remarks

If RecipientCerts contains a valid certificate, the data will be encrypted using this certificate and the algorithm specified in EncryptionAlgorithm. If EncryptionAlgorithm is set to the empty string, the data will not be encrypted.

The class supports "3DES", or industry-standard 168-bit Triple-DES encryption.

The class supports "AES" encryption with a default keysize of 128 bits. You may also set "AESCBC192" or "AESCBC256" for 192- and 256-bit keysizes.

Possible values are:

• 3DES (default)
• DES
• AESCBC128
• AESCBC192
• AESCBC256
• AESGCM128
• AESGCM192
• AESGCM256

Data Type

String

Etag Property (AS2Sender Class)

The Etag of the file being sent.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetEtag();
int SetEtag(const char* lpszEtag);

Unicode (Windows)
LPWSTR GetEtag();
INT SetEtag(LPCWSTR lpszEtag);

char* ipworksedi_as2sender_getetag(void* lpObj);
int ipworksedi_as2sender_setetag(void* lpObj, const char* lpszEtag);

QString GetEtag();
int SetEtag(QString qsEtag);

Default Value

""

Remarks

This specifies the Etag for the file. This value should be set to an empty string the first time a file is sent using the Restart command. The class will generate a unique Etag based on the processed contents of the file and set this property when sending begins.

If a file is interrupted, this value must be set when Restart is called to resume transfer of the already processed file.

Data Type

String

Firewall Property (AS2Sender Class)

A set of properties related to firewall access.

Syntax

• C++
• C
• Qt

IPWorksEDIFirewall* GetFirewall();
int SetFirewall(IPWorksEDIFirewall* val);

int ipworksedi_as2sender_getfirewallautodetect(void* lpObj);
int ipworksedi_as2sender_setfirewallautodetect(void* lpObj, int bFirewallAutoDetect);

int ipworksedi_as2sender_getfirewalltype(void* lpObj);
int ipworksedi_as2sender_setfirewalltype(void* lpObj, int iFirewallType);

char* ipworksedi_as2sender_getfirewallhost(void* lpObj);
int ipworksedi_as2sender_setfirewallhost(void* lpObj, const char* lpszFirewallHost);

char* ipworksedi_as2sender_getfirewallpassword(void* lpObj);
int ipworksedi_as2sender_setfirewallpassword(void* lpObj, const char* lpszFirewallPassword);

int ipworksedi_as2sender_getfirewallport(void* lpObj);
int ipworksedi_as2sender_setfirewallport(void* lpObj, int iFirewallPort);

char* ipworksedi_as2sender_getfirewalluser(void* lpObj);
int ipworksedi_as2sender_setfirewalluser(void* lpObj, const char* lpszFirewallUser);

bool GetFirewallAutoDetect();
int SetFirewallAutoDetect(bool bFirewallAutoDetect);

int GetFirewallType();
int SetFirewallType(int iFirewallType);

QString GetFirewallHost();
int SetFirewallHost(QString qsFirewallHost);

QString GetFirewallPassword();
int SetFirewallPassword(QString qsFirewallPassword);

int GetFirewallPort();
int SetFirewallPort(int iFirewallPort);

QString GetFirewallUser();
int SetFirewallUser(QString qsFirewallUser);

Remarks

This is a Firewall-type property, which contains fields describing the firewall through which the class will attempt to connect.

Data Type

IPWorksEDIFirewall

From Property (AS2Sender Class)

The email address of the HTTP agent (optional).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetFrom();
int SetFrom(const char* lpszFrom);

Unicode (Windows)
LPWSTR GetFrom();
INT SetFrom(LPCWSTR lpszFrom);

char* ipworksedi_as2sender_getfrom(void* lpObj);
int ipworksedi_as2sender_setfrom(void* lpObj, const char* lpszFrom);

QString GetFrom();
int SetFrom(QString qsFrom);

Default Value

""

Remarks

If the From property contains a non-empty string, an HTTP From: header is added to the request. This header generally gives the email address of the requester of the document.

This property is not available at design time.

Data Type

String

LocalHost Property (AS2Sender Class)

The name of the local host or user-assigned IP interface through which connections are initiated or accepted.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetLocalHost();
int SetLocalHost(const char* lpszLocalHost);

Unicode (Windows)
LPWSTR GetLocalHost();
INT SetLocalHost(LPCWSTR lpszLocalHost);

char* ipworksedi_as2sender_getlocalhost(void* lpObj);
int ipworksedi_as2sender_setlocalhost(void* lpObj, const char* lpszLocalHost);

QString GetLocalHost();
int SetLocalHost(QString qsLocalHost);

Default Value

""

Remarks

This property contains the name of the local host as obtained by the gethostname() system call, or if the user has assigned an IP address, the value of that address.

In multihomed hosts (machines with more than one IP interface) setting LocalHost to the IP address of an interface will make the class initiate connections (or accept in the case of server classs) only through that interface. It is recommended to provide an IP address rather than a hostname when setting this property to ensure the desired interface is used.

If the class is connected, the LocalHost property shows the IP address of the interface through which the connection is made in internet dotted format (aaa.bbb.ccc.ddd). In most cases, this is the address of the local host, except for multihomed hosts (machines with more than one IP interface).

Note: LocalHost is not persistent. You must always set it in code, and never in the property window.

This property contains the name of the local host as obtained by the gethostname() system call, or if the user has assigned an IP address, the value of that address.

In multihomed hosts (machines with more than one IP interface) setting LocalHost to the IP address of an interface will make the class initiate connections (or accept in the case of server classs) only through that interface. It is recommended to provide an IP address rather than a hostname when setting this property to ensure the desired interface is used.

If the class is connected, the LocalHost property shows the IP address of the interface through which the connection is made in internet dotted format (aaa.bbb.ccc.ddd). In most cases, this is the address of the local host, except for multihomed hosts (machines with more than one IP interface).

Note: LocalHost is not persistent. You must always set it in code, and never in the property window.

Data Type

String

LogDirectory Property (AS2Sender Class)

The path to a directory for logging.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetLogDirectory();
int SetLogDirectory(const char* lpszLogDirectory);

Unicode (Windows)
LPWSTR GetLogDirectory();
INT SetLogDirectory(LPCWSTR lpszLogDirectory);

char* ipworksedi_as2sender_getlogdirectory(void* lpObj);
int ipworksedi_as2sender_setlogdirectory(void* lpObj, const char* lpszLogDirectory);

QString GetLogDirectory();
int SetLogDirectory(QString qsLogDirectory);

Default Value

""

Remarks

Setting LogDirectory will instruct the component to log the details of each transmission to unique files in the specified directory. For each request processed, the class will log the complete text of the outgoing request and the incoming response.

The class will write multiple log file for each transmission, with separate extensions for each type of data:

One or more of these logs may be disabled by setting the LogOptions configuration setting.

LogDirectory supports several macros that can be used to specify a unique directory path. If the path specified does not already exist, the class will attempt to create the directory. The following macros are supported:

The filenames will be chosen automatically by the class. Each filename will be the system time, in the format YYYY-MM-DD-HH-MM-SS-MMMM, with extensions "-2", "-3", used in case files of those names already exist. After each transaction is processed LogFile will contain the name of the files just written, minus the extension.

If logs cannot be written an exception will be thrown.

Data Type

String

LogFile Property (AS2Sender Class)

The log file written.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetLogFile();

Unicode (Windows)
LPWSTR GetLogFile();

char* ipworksedi_as2sender_getlogfile(void* lpObj);

QString GetLogFile();

Default Value

""

Remarks

If LogDirectory is specified a log file will be written in the specified directory and LogFile will contain the full path and name of the files written, minus the extension.

The class will write multiple log files for each transmission, with separate extensions for each type of data:

This property is read-only.

Data Type

String

MDNDeliveryOption Property (AS2Sender Class)

A URL indicating how the receipt is to be delivered.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetMDNDeliveryOption();
int SetMDNDeliveryOption(const char* lpszMDNDeliveryOption);

Unicode (Windows)
LPWSTR GetMDNDeliveryOption();
INT SetMDNDeliveryOption(LPCWSTR lpszMDNDeliveryOption);

char* ipworksedi_as2sender_getmdndeliveryoption(void* lpObj);
int ipworksedi_as2sender_setmdndeliveryoption(void* lpObj, const char* lpszMDNDeliveryOption);

QString GetMDNDeliveryOption();
int SetMDNDeliveryOption(QString qsMDNDeliveryOption);

Default Value

""

Remarks

The default mode of operation is for the receipt to be returned synchronously within the HTTP reply. By specifying a valid URL, the user may request asynchronous delivery instead. The URL indicates the destination for the reply, and may use any appropriate protocol, such as "http", "https", or "mailto".

If MDNDeliveryOption is set to an empty string, the receipt will be returned synchronously, and will be processed automatically by the class. Clients requesting asynchronous delivery should provide their own processing for reading receipts.

Data Type

String

MDNOptions Property (AS2Sender Class)

Used to indicate the options requested for the MDN receipt.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetMDNOptions();
int SetMDNOptions(const char* lpszMDNOptions);

Unicode (Windows)
LPWSTR GetMDNOptions();
INT SetMDNOptions(LPCWSTR lpszMDNOptions);

char* ipworksedi_as2sender_getmdnoptions(void* lpObj);
int ipworksedi_as2sender_setmdnoptions(void* lpObj, const char* lpszMDNOptions);

QString GetMDNOptions();
int SetMDNOptions(QString qsMDNOptions);

Default Value

"signed-receipt-protocol=optional, pkcs7-signature; signed-receipt-micalg=optional, sha-256"

Remarks

By default, the class will request that the MDN be signed with a PKCS#7 signature over a SHA-256 hash, which is the industry standard.

Set MDNOptions to an empty string to request an unsigned receipt.

This property will automatically be updated when SignatureAlgorithm is set. Normally you will not need to set this property, however you can set a value here to override the automatically generated value.

The string format is that of the Disposition-Notification-Options HTTP header, as specified in RFC 3335. As a form of shorthand, you may set this property to "sha1", "sha-256", or "md5" to request the indicated hash algorithm.

Data Type

String

MDNReceipt Property (AS2Sender Class)

The MDN receipt returned from the server.

Syntax

• C++
• C
• Qt

IPWorksEDIMDNReceipt* GetMDNReceipt();
int SetMDNReceipt(IPWorksEDIMDNReceipt* val);

int ipworksedi_as2sender_getmdnreceiptcontent(void* lpObj, char** lpMDNReceiptContent, int* lenMDNReceiptContent);
int ipworksedi_as2sender_setmdnreceiptcontent(void* lpObj, const char* lpMDNReceiptContent, int lenMDNReceiptContent);

int ipworksedi_as2sender_getmdnreceiptheadercount(void* lpObj);

char* ipworksedi_as2sender_getmdnreceiptheaderfield(void* lpObj);

int ipworksedi_as2sender_getmdnreceiptheaderindex(void* lpObj);
int ipworksedi_as2sender_setmdnreceiptheaderindex(void* lpObj, int iMDNReceiptHeaderIndex);

char* ipworksedi_as2sender_getmdnreceiptheaders(void* lpObj);
int ipworksedi_as2sender_setmdnreceiptheaders(void* lpObj, const char* lpszMDNReceiptHeaders);

char* ipworksedi_as2sender_getmdnreceiptheadervalue(void* lpObj);

char* ipworksedi_as2sender_getmdnreceiptmdn(void* lpObj);

char* ipworksedi_as2sender_getmdnreceiptmessage(void* lpObj);

char* ipworksedi_as2sender_getmdnreceiptmicvalue(void* lpObj);

char* ipworksedi_as2sender_getmdnreceiptsigningprotocol(void* lpObj);

QByteArray GetMDNReceiptContent();
int SetMDNReceiptContent(QByteArray qbaMDNReceiptContent);

int GetMDNReceiptHeaderCount();

QString GetMDNReceiptHeaderField();

int GetMDNReceiptHeaderIndex();
int SetMDNReceiptHeaderIndex(int iMDNReceiptHeaderIndex);

QString GetMDNReceiptHeaders();
int SetMDNReceiptHeaders(QString qsMDNReceiptHeaders);

QString GetMDNReceiptHeaderValue();

QString GetMDNReceiptMDN();

QString GetMDNReceiptMessage();

QString GetMDNReceiptMICValue();

QString GetMDNReceiptSigningProtocol();

Remarks

This property will contain an instance of MDNReceipt with the complete MDN receipt returned from the AS2 receiver. The receipt will be a signed or unsigned multipart/report in MIME format. For synchronous MDN requests, this property is populated automatically after the call to Post. If an asynchronous MDN is sent over HTTP, it may be read from the HTTP context by calling ReadAsyncReceipt, or it may be set manually.

When MDNReceipt is set to a valid MDN receipt, the originator of the receipt will be stored in AS2To, the intended recipient (presumably your system) will be stored in AS2From, and the original message ID will be stored in MessageId.

If you are processing a MDN receipt asynchronously, you can use the values to look up the original message and validate the receipt. Set the OriginalContentMIC, MDNOptions, and ReceiptSignerCert to the values originally computed when the message was sent (if you are requesting async MDNs you must save this information externally.). You can then validate the asynchronous receipt by invoking VerifyReceipt.

Alternatively, AsyncMDNInfoDir may be set in place of OriginalContentMIC, MessageId, and MDNOptions (provided it was set to the same value when the message was sent). If AsyncMDNInfoDir was specified when the message was sent, the class would have saved OriginalContentMIC and MDNOptions to a file identified by the MessageId for the transmission. These properties are read from the file matching the MessageId in the MDNReceipt automatically if AsyncMDNInfoDir is specified.

Note: MDNReceipt must be populated prior to calling VerifyReceipt.

Data Type

IPWorksEDIMDNReceipt

MDNTo Property (AS2Sender Class)

Used to indicate that a message disposition notification is requested.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetMDNTo();
int SetMDNTo(const char* lpszMDNTo);

Unicode (Windows)
LPWSTR GetMDNTo();
INT SetMDNTo(LPCWSTR lpszMDNTo);

char* ipworksedi_as2sender_getmdnto(void* lpObj);
int ipworksedi_as2sender_setmdnto(void* lpObj, const char* lpszMDNTo);

QString GetMDNTo();
int SetMDNTo(QString qsMDNTo);

Default Value

""

Remarks

If this property is set, a Disposition-Notification-To header will be added to the request, and an MDN will be requested. The value may be an email address, URL, etc., and while its presence is used to determine whether or not an MDN is sent, the value itself will typically be ignored by the server.

By default, the class will request a PKCS#7 signature and synchronous delivery. You may set MDNDeliveryOption to request an asynchronous MDN, and you may set MDNOptions to request a different type of signature, or no signature at all.

Data Type

String

MessageId Property (AS2Sender Class)

The Id of the message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetMessageId();
int SetMessageId(const char* lpszMessageId);

Unicode (Windows)
LPWSTR GetMessageId();
INT SetMessageId(LPCWSTR lpszMessageId);

char* ipworksedi_as2sender_getmessageid(void* lpObj);
int ipworksedi_as2sender_setmessageid(void* lpObj, const char* lpszMessageId);

QString GetMessageId();
int SetMessageId(QString qsMessageId);

Default Value

""

Remarks

The Id format is as in RFC 2822: id-left@id-right .

A unique Id will automatically be generated on startup. Sending a message will reset id-left if the MessageId has been used in the previous message.

If you set MessageId to a string of the form "@(id-right)" a unique id-left will be generated. If you set MessageId to an empty string, a new MessageId will be generated with the same id-right.

After an MDNReceipt is returned or set, MessageId will contain the Original-Message-ID found in the MDN Receipt.

This property is not available at design time.

Data Type

String

OriginalContentMIC Property (AS2Sender Class)

The Message Integrity Check(s) (one-way hash) of the outgoing message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetOriginalContentMIC();
int SetOriginalContentMIC(const char* lpszOriginalContentMIC);

Unicode (Windows)
LPWSTR GetOriginalContentMIC();
INT SetOriginalContentMIC(LPCWSTR lpszOriginalContentMIC);

char* ipworksedi_as2sender_getoriginalcontentmic(void* lpObj);
int ipworksedi_as2sender_setoriginalcontentmic(void* lpObj, const char* lpszOriginalContentMIC);

QString GetOriginalContentMIC();
int SetOriginalContentMIC(QString qsOriginalContentMIC);

Default Value

""

Remarks

A MIC will be calculated over the outgoing message using the same algorithm in the SignatureAlgorithm configuration used to sign the message. The property will be set when Post (in AS3, Send) is invoked, and the MIC will automatically be checked against the Original-Content-MIC in the MDN for synchronous MDNs.

The format is in RFC 3335, i.e. "w7AguNJEmhF/qIjJw6LnnA==, md5", with a newline at the end.

If you are requesting an asynchronous MDN, you must save this value externally so that it can be loaded when the MDN is received (you may also use AsyncMDNInfoDir).

Data Type

String

Proxy Property (AS2Sender Class)

A set of properties related to proxy access.

Syntax

• C++
• C
• Qt

IPWorksEDIProxy* GetProxy();
int SetProxy(IPWorksEDIProxy* val);

int ipworksedi_as2sender_getproxyauthscheme(void* lpObj);
int ipworksedi_as2sender_setproxyauthscheme(void* lpObj, int iProxyAuthScheme);

int ipworksedi_as2sender_getproxyautodetect(void* lpObj);
int ipworksedi_as2sender_setproxyautodetect(void* lpObj, int bProxyAutoDetect);

char* ipworksedi_as2sender_getproxypassword(void* lpObj);
int ipworksedi_as2sender_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int ipworksedi_as2sender_getproxyport(void* lpObj);
int ipworksedi_as2sender_setproxyport(void* lpObj, int iProxyPort);

char* ipworksedi_as2sender_getproxyserver(void* lpObj);
int ipworksedi_as2sender_setproxyserver(void* lpObj, const char* lpszProxyServer);

int ipworksedi_as2sender_getproxyssl(void* lpObj);
int ipworksedi_as2sender_setproxyssl(void* lpObj, int iProxySSL);

char* ipworksedi_as2sender_getproxyuser(void* lpObj);
int ipworksedi_as2sender_setproxyuser(void* lpObj, const char* lpszProxyUser);

int GetProxyAuthScheme();
int SetProxyAuthScheme(int iProxyAuthScheme);

bool GetProxyAutoDetect();
int SetProxyAutoDetect(bool bProxyAutoDetect);

QString GetProxyPassword();
int SetProxyPassword(QString qsProxyPassword);

int GetProxyPort();
int SetProxyPort(int iProxyPort);

QString GetProxyServer();
int SetProxyServer(QString qsProxyServer);

int GetProxySSL();
int SetProxySSL(int iProxySSL);

QString GetProxyUser();
int SetProxyUser(QString qsProxyUser);

Remarks

This property contains fields describing the proxy through which the class will attempt to connect.

Data Type

IPWorksEDIProxy

ReceiptSignerCert Property (AS2Sender Class)

The public key certificate for the MDN receipt signature.

Syntax

• C++
• C
• Qt

IPWorksEDICertificate* GetReceiptSignerCert();
int SetReceiptSignerCert(IPWorksEDICertificate* val);

int ipworksedi_as2sender_getreceiptsignercertstore(void* lpObj, char** lpReceiptSignerCertStore, int* lenReceiptSignerCertStore);
int ipworksedi_as2sender_setreceiptsignercertstore(void* lpObj, const char* lpReceiptSignerCertStore, int lenReceiptSignerCertStore);

char* ipworksedi_as2sender_getreceiptsignercertstorepassword(void* lpObj);
int ipworksedi_as2sender_setreceiptsignercertstorepassword(void* lpObj, const char* lpszReceiptSignerCertStorePassword);

int ipworksedi_as2sender_getreceiptsignercertstoretype(void* lpObj);
int ipworksedi_as2sender_setreceiptsignercertstoretype(void* lpObj, int iReceiptSignerCertStoreType);

char* ipworksedi_as2sender_getreceiptsignercertsubject(void* lpObj);
int ipworksedi_as2sender_setreceiptsignercertsubject(void* lpObj, const char* lpszReceiptSignerCertSubject);

int ipworksedi_as2sender_getreceiptsignercertencoded(void* lpObj, char** lpReceiptSignerCertEncoded, int* lenReceiptSignerCertEncoded);
int ipworksedi_as2sender_setreceiptsignercertencoded(void* lpObj, const char* lpReceiptSignerCertEncoded, int lenReceiptSignerCertEncoded);

QByteArray GetReceiptSignerCertStore();
int SetReceiptSignerCertStore(QByteArray qbaReceiptSignerCertStore);

QString GetReceiptSignerCertStorePassword();
int SetReceiptSignerCertStorePassword(QString qsReceiptSignerCertStorePassword);

int GetReceiptSignerCertStoreType();
int SetReceiptSignerCertStoreType(int iReceiptSignerCertStoreType);

QString GetReceiptSignerCertSubject();
int SetReceiptSignerCertSubject(QString qsReceiptSignerCertSubject);

QByteArray GetReceiptSignerCertEncoded();
int SetReceiptSignerCertEncoded(QByteArray qbaReceiptSignerCertEncoded);

Remarks

Ordinarily, if your trading partner uses the same certificate for both signing and encryption, the certificate specified in RecipientCert is used for both encryption and verifying the receipt signature.

If your trading partner uses different certificates for signing and encryption, you must set this property to the public key for you partner's signing certificate before invoking Post.

After invoking Post or VerifyReceipt, this will contain the certificate used to sign the receipt, if the receipt is signed.

If set, this property should be a public key instance of Certificate.

Data Type

IPWorksEDICertificate

RecipientCerts Property (AS2Sender Class)

The public key certificates of the recipients for this message.

Syntax

• C++
• C
• Qt

IPWorksEDIList<IPWorksEDICertificate>* GetRecipientCerts();
int SetRecipientCerts(IPWorksEDIList<IPWorksEDICertificate>* val);

int ipworksedi_as2sender_getrecipientcertcount(void* lpObj);
int ipworksedi_as2sender_setrecipientcertcount(void* lpObj, int iRecipientCertCount);

int ipworksedi_as2sender_getrecipientcertstore(void* lpObj, int recipientcertindex, char** lpRecipientCertStore, int* lenRecipientCertStore);
int ipworksedi_as2sender_setrecipientcertstore(void* lpObj, int recipientcertindex, const char* lpRecipientCertStore, int lenRecipientCertStore);

char* ipworksedi_as2sender_getrecipientcertstorepassword(void* lpObj, int recipientcertindex);
int ipworksedi_as2sender_setrecipientcertstorepassword(void* lpObj, int recipientcertindex, const char* lpszRecipientCertStorePassword);

int ipworksedi_as2sender_getrecipientcertstoretype(void* lpObj, int recipientcertindex);
int ipworksedi_as2sender_setrecipientcertstoretype(void* lpObj, int recipientcertindex, int iRecipientCertStoreType);

char* ipworksedi_as2sender_getrecipientcertsubject(void* lpObj, int recipientcertindex);
int ipworksedi_as2sender_setrecipientcertsubject(void* lpObj, int recipientcertindex, const char* lpszRecipientCertSubject);

int ipworksedi_as2sender_getrecipientcertencoded(void* lpObj, int recipientcertindex, char** lpRecipientCertEncoded, int* lenRecipientCertEncoded);
int ipworksedi_as2sender_setrecipientcertencoded(void* lpObj, int recipientcertindex, const char* lpRecipientCertEncoded, int lenRecipientCertEncoded);

int GetRecipientCertCount();
int SetRecipientCertCount(int iRecipientCertCount);

QByteArray GetRecipientCertStore(int iRecipientCertIndex);
int SetRecipientCertStore(int iRecipientCertIndex, QByteArray qbaRecipientCertStore);

QString GetRecipientCertStorePassword(int iRecipientCertIndex);
int SetRecipientCertStorePassword(int iRecipientCertIndex, QString qsRecipientCertStorePassword);

int GetRecipientCertStoreType(int iRecipientCertIndex);
int SetRecipientCertStoreType(int iRecipientCertIndex, int iRecipientCertStoreType);

QString GetRecipientCertSubject(int iRecipientCertIndex);
int SetRecipientCertSubject(int iRecipientCertIndex, QString qsRecipientCertSubject);

QByteArray GetRecipientCertEncoded(int iRecipientCertIndex);
int SetRecipientCertEncoded(int iRecipientCertIndex, QByteArray qbaRecipientCertEncoded);

Remarks

The encryption certificates of the recipients. If this property is specified, the message content will be encrypted using the algorithm given by EncryptionAlgorithm.

This property will also be used to verify signed receipts if ReceiptSignerCert is not specified. In this case, it will use the first certificate found in the collection, if one exists. If your trading partner uses different certificates for signing and encryption, you should set RecipientCerts to the encryption certificate(s) and ReceiptSignerCert to the signing certificate.

If the class is unable to verify a signature make sure RecipientCerts are set appropriately.

If set, this property should could contain public key instances of Certificate.

This property is not available at design time.

Data Type

IPWorksEDICertificate

RestartDirectory Property (AS2Sender Class)

The directory to log cached files when using AS2 restart functionality.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetRestartDirectory();
int SetRestartDirectory(const char* lpszRestartDirectory);

Unicode (Windows)
LPWSTR GetRestartDirectory();
INT SetRestartDirectory(LPCWSTR lpszRestartDirectory);

char* ipworksedi_as2sender_getrestartdirectory(void* lpObj);
int ipworksedi_as2sender_setrestartdirectory(void* lpObj, const char* lpszRestartDirectory);

QString GetRestartDirectory();
int SetRestartDirectory(QString qsRestartDirectory);

Default Value

""

Remarks

If this property is set, the class will cache all data to the RestartDirectory. Thus, when sending a file is interrupted, the class can restart the transmission of the file starting where it was interrupted.

To use this functionality, simply set the RestartDirectory and call Restart.

When using restart functionality, the data is completely processed to the RestartDirectory before sending begins.

NOTE: This directory will not automatically be cleaned up.

Data Type

String

RolloverSigningCert Property (AS2Sender Class)

Contains the certificate to use when signing messages.

Syntax

• C++
• C
• Qt

IPWorksEDICertificate* GetRolloverSigningCert();
int SetRolloverSigningCert(IPWorksEDICertificate* val);

int ipworksedi_as2sender_getrolloversigningcertstore(void* lpObj, char** lpRolloverSigningCertStore, int* lenRolloverSigningCertStore);
int ipworksedi_as2sender_setrolloversigningcertstore(void* lpObj, const char* lpRolloverSigningCertStore, int lenRolloverSigningCertStore);

char* ipworksedi_as2sender_getrolloversigningcertstorepassword(void* lpObj);
int ipworksedi_as2sender_setrolloversigningcertstorepassword(void* lpObj, const char* lpszRolloverSigningCertStorePassword);

int ipworksedi_as2sender_getrolloversigningcertstoretype(void* lpObj);
int ipworksedi_as2sender_setrolloversigningcertstoretype(void* lpObj, int iRolloverSigningCertStoreType);

char* ipworksedi_as2sender_getrolloversigningcertsubject(void* lpObj);
int ipworksedi_as2sender_setrolloversigningcertsubject(void* lpObj, const char* lpszRolloverSigningCertSubject);

int ipworksedi_as2sender_getrolloversigningcertencoded(void* lpObj, char** lpRolloverSigningCertEncoded, int* lenRolloverSigningCertEncoded);
int ipworksedi_as2sender_setrolloversigningcertencoded(void* lpObj, const char* lpRolloverSigningCertEncoded, int lenRolloverSigningCertEncoded);

QByteArray GetRolloverSigningCertStore();
int SetRolloverSigningCertStore(QByteArray qbaRolloverSigningCertStore);

QString GetRolloverSigningCertStorePassword();
int SetRolloverSigningCertStorePassword(QString qsRolloverSigningCertStorePassword);

int GetRolloverSigningCertStoreType();
int SetRolloverSigningCertStoreType(int iRolloverSigningCertStoreType);

QString GetRolloverSigningCertSubject();
int SetRolloverSigningCertSubject(QString qsRolloverSigningCertSubject);

QByteArray GetRolloverSigningCertEncoded();
int SetRolloverSigningCertEncoded(QByteArray qbaRolloverSigningCertEncoded);

Remarks

This is your rollover signing certificate. This may be used to specify an additional signing certificate during a period of transition between private certificates in the application.

If this property is specified, the message content will be signed using both SigningCert and RolloverSigningCert. The recipient will be able to verify the signature with either corresponding public certificate.

If set, this property should be a private key instance of Certificate.

Data Type

IPWorksEDICertificate

SignatureAlgorithm Property (AS2Sender Class)

Signature algorithm to be used in outgoing messages.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetSignatureAlgorithm();
int SetSignatureAlgorithm(const char* lpszSignatureAlgorithm);

Unicode (Windows)
LPWSTR GetSignatureAlgorithm();
INT SetSignatureAlgorithm(LPCWSTR lpszSignatureAlgorithm);

char* ipworksedi_as2sender_getsignaturealgorithm(void* lpObj);
int ipworksedi_as2sender_setsignaturealgorithm(void* lpObj, const char* lpszSignatureAlgorithm);

QString GetSignatureAlgorithm();
int SetSignatureAlgorithm(QString qsSignatureAlgorithm);

Default Value

"sha-256"

Remarks

Signature Algorithm can be set to indicate the preferred signing algorithm. Possible values are:

• sha1
• md5
• sha-256 (or sha256) (default)
• sha-384 (or sha384)
• sha-512 (or sha512)
• sha-224 (or sha224)

The default value is "sha-256". When this property is set the MDNOptions property is automatically updated to request the MDN receipt be signed with the same algorithm.

Data Type

String

SigningCert Property (AS2Sender Class)

Contains the certificate to use when signing messages.

Syntax

• C++
• C
• Qt

IPWorksEDICertificate* GetSigningCert();
int SetSigningCert(IPWorksEDICertificate* val);

int ipworksedi_as2sender_getsigningcertstore(void* lpObj, char** lpSigningCertStore, int* lenSigningCertStore);
int ipworksedi_as2sender_setsigningcertstore(void* lpObj, const char* lpSigningCertStore, int lenSigningCertStore);

char* ipworksedi_as2sender_getsigningcertstorepassword(void* lpObj);
int ipworksedi_as2sender_setsigningcertstorepassword(void* lpObj, const char* lpszSigningCertStorePassword);

int ipworksedi_as2sender_getsigningcertstoretype(void* lpObj);
int ipworksedi_as2sender_setsigningcertstoretype(void* lpObj, int iSigningCertStoreType);

char* ipworksedi_as2sender_getsigningcertsubject(void* lpObj);
int ipworksedi_as2sender_setsigningcertsubject(void* lpObj, const char* lpszSigningCertSubject);

int ipworksedi_as2sender_getsigningcertencoded(void* lpObj, char** lpSigningCertEncoded, int* lenSigningCertEncoded);
int ipworksedi_as2sender_setsigningcertencoded(void* lpObj, const char* lpSigningCertEncoded, int lenSigningCertEncoded);

QByteArray GetSigningCertStore();
int SetSigningCertStore(QByteArray qbaSigningCertStore);

QString GetSigningCertStorePassword();
int SetSigningCertStorePassword(QString qsSigningCertStorePassword);

int GetSigningCertStoreType();
int SetSigningCertStoreType(int iSigningCertStoreType);

QString GetSigningCertSubject();
int SetSigningCertSubject(QString qsSigningCertSubject);

QByteArray GetSigningCertEncoded();
int SetSigningCertEncoded(QByteArray qbaSigningCertEncoded);

Remarks

This is your signing certificate. If this property is specified, the message content will be signed using the algorithm given by SignatureAlgorithm.

If set, this property should be a private key instance of Certificate.

Data Type

IPWorksEDICertificate

SSLAcceptServerCert Property (AS2Sender Class)

Instructs the class to unconditionally accept the server certificate that matches the supplied certificate.

Syntax

• C++
• C
• Qt

IPWorksEDICertificate* GetSSLAcceptServerCert();
int SetSSLAcceptServerCert(IPWorksEDICertificate* val);

char* ipworksedi_as2sender_getsslacceptservercerteffectivedate(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertexpirationdate(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertextendedkeyusage(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertfingerprint(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertfingerprintsha1(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertfingerprintsha256(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertissuer(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertprivatekey(void* lpObj);

int ipworksedi_as2sender_getsslacceptservercertprivatekeyavailable(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertprivatekeycontainer(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertpublickey(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertpublickeyalgorithm(void* lpObj);

int ipworksedi_as2sender_getsslacceptservercertpublickeylength(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertserialnumber(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertsignaturealgorithm(void* lpObj);

int ipworksedi_as2sender_getsslacceptservercertstore(void* lpObj, char** lpSSLAcceptServerCertStore, int* lenSSLAcceptServerCertStore);
int ipworksedi_as2sender_setsslacceptservercertstore(void* lpObj, const char* lpSSLAcceptServerCertStore, int lenSSLAcceptServerCertStore);

char* ipworksedi_as2sender_getsslacceptservercertstorepassword(void* lpObj);
int ipworksedi_as2sender_setsslacceptservercertstorepassword(void* lpObj, const char* lpszSSLAcceptServerCertStorePassword);

int ipworksedi_as2sender_getsslacceptservercertstoretype(void* lpObj);
int ipworksedi_as2sender_setsslacceptservercertstoretype(void* lpObj, int iSSLAcceptServerCertStoreType);

char* ipworksedi_as2sender_getsslacceptservercertsubjectaltnames(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertthumbprintmd5(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertthumbprintsha1(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertthumbprintsha256(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertusage(void* lpObj);

int ipworksedi_as2sender_getsslacceptservercertusageflags(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertversion(void* lpObj);

char* ipworksedi_as2sender_getsslacceptservercertsubject(void* lpObj);
int ipworksedi_as2sender_setsslacceptservercertsubject(void* lpObj, const char* lpszSSLAcceptServerCertSubject);

int ipworksedi_as2sender_getsslacceptservercertencoded(void* lpObj, char** lpSSLAcceptServerCertEncoded, int* lenSSLAcceptServerCertEncoded);
int ipworksedi_as2sender_setsslacceptservercertencoded(void* lpObj, const char* lpSSLAcceptServerCertEncoded, int lenSSLAcceptServerCertEncoded);

QString GetSSLAcceptServerCertEffectiveDate();

QString GetSSLAcceptServerCertExpirationDate();

QString GetSSLAcceptServerCertExtendedKeyUsage();

QString GetSSLAcceptServerCertFingerprint();

QString GetSSLAcceptServerCertFingerprintSHA1();

QString GetSSLAcceptServerCertFingerprintSHA256();

QString GetSSLAcceptServerCertIssuer();

QString GetSSLAcceptServerCertPrivateKey();

bool GetSSLAcceptServerCertPrivateKeyAvailable();

QString GetSSLAcceptServerCertPrivateKeyContainer();

QString GetSSLAcceptServerCertPublicKey();

QString GetSSLAcceptServerCertPublicKeyAlgorithm();

int GetSSLAcceptServerCertPublicKeyLength();

QString GetSSLAcceptServerCertSerialNumber();

QString GetSSLAcceptServerCertSignatureAlgorithm();

QByteArray GetSSLAcceptServerCertStore();
int SetSSLAcceptServerCertStore(QByteArray qbaSSLAcceptServerCertStore);

QString GetSSLAcceptServerCertStorePassword();
int SetSSLAcceptServerCertStorePassword(QString qsSSLAcceptServerCertStorePassword);

int GetSSLAcceptServerCertStoreType();
int SetSSLAcceptServerCertStoreType(int iSSLAcceptServerCertStoreType);

QString GetSSLAcceptServerCertSubjectAltNames();

QString GetSSLAcceptServerCertThumbprintMD5();

QString GetSSLAcceptServerCertThumbprintSHA1();

QString GetSSLAcceptServerCertThumbprintSHA256();

QString GetSSLAcceptServerCertUsage();

int GetSSLAcceptServerCertUsageFlags();

QString GetSSLAcceptServerCertVersion();

QString GetSSLAcceptServerCertSubject();
int SetSSLAcceptServerCertSubject(QString qsSSLAcceptServerCertSubject);

QByteArray GetSSLAcceptServerCertEncoded();
int SetSSLAcceptServerCertEncoded(QByteArray qbaSSLAcceptServerCertEncoded);

Remarks

If it finds any issues with the certificate presented by the server, the class will normally terminate the connection with an error.

You may override this behavior by supplying a value for SSLAcceptServerCert. If the certificate supplied in SSLAcceptServerCert is the same as the certificate presented by the server, then the server certificate is accepted unconditionally, and the connection will continue normally.

Note: This functionality is provided only for cases in which you otherwise know that you are communicating with the right server. If used improperly, this property may create a security breach. Use it at your own risk.

Data Type

IPWorksEDICertificate

SSLCert Property (AS2Sender Class)

The certificate to be used during Secure Sockets Layer (SSL) negotiation.

Syntax

• C++
• C
• Qt

IPWorksEDICertificate* GetSSLCert();
int SetSSLCert(IPWorksEDICertificate* val);

char* ipworksedi_as2sender_getsslcerteffectivedate(void* lpObj);

char* ipworksedi_as2sender_getsslcertexpirationdate(void* lpObj);

char* ipworksedi_as2sender_getsslcertextendedkeyusage(void* lpObj);

char* ipworksedi_as2sender_getsslcertfingerprint(void* lpObj);

char* ipworksedi_as2sender_getsslcertfingerprintsha1(void* lpObj);

char* ipworksedi_as2sender_getsslcertfingerprintsha256(void* lpObj);

char* ipworksedi_as2sender_getsslcertissuer(void* lpObj);

char* ipworksedi_as2sender_getsslcertprivatekey(void* lpObj);

int ipworksedi_as2sender_getsslcertprivatekeyavailable(void* lpObj);

char* ipworksedi_as2sender_getsslcertprivatekeycontainer(void* lpObj);

char* ipworksedi_as2sender_getsslcertpublickey(void* lpObj);

char* ipworksedi_as2sender_getsslcertpublickeyalgorithm(void* lpObj);

int ipworksedi_as2sender_getsslcertpublickeylength(void* lpObj);

char* ipworksedi_as2sender_getsslcertserialnumber(void* lpObj);

char* ipworksedi_as2sender_getsslcertsignaturealgorithm(void* lpObj);

int ipworksedi_as2sender_getsslcertstore(void* lpObj, char** lpSSLCertStore, int* lenSSLCertStore);
int ipworksedi_as2sender_setsslcertstore(void* lpObj, const char* lpSSLCertStore, int lenSSLCertStore);

char* ipworksedi_as2sender_getsslcertstorepassword(void* lpObj);
int ipworksedi_as2sender_setsslcertstorepassword(void* lpObj, const char* lpszSSLCertStorePassword);

int ipworksedi_as2sender_getsslcertstoretype(void* lpObj);
int ipworksedi_as2sender_setsslcertstoretype(void* lpObj, int iSSLCertStoreType);

char* ipworksedi_as2sender_getsslcertsubjectaltnames(void* lpObj);

char* ipworksedi_as2sender_getsslcertthumbprintmd5(void* lpObj);

char* ipworksedi_as2sender_getsslcertthumbprintsha1(void* lpObj);

char* ipworksedi_as2sender_getsslcertthumbprintsha256(void* lpObj);

char* ipworksedi_as2sender_getsslcertusage(void* lpObj);

int ipworksedi_as2sender_getsslcertusageflags(void* lpObj);

char* ipworksedi_as2sender_getsslcertversion(void* lpObj);

char* ipworksedi_as2sender_getsslcertsubject(void* lpObj);
int ipworksedi_as2sender_setsslcertsubject(void* lpObj, const char* lpszSSLCertSubject);

int ipworksedi_as2sender_getsslcertencoded(void* lpObj, char** lpSSLCertEncoded, int* lenSSLCertEncoded);
int ipworksedi_as2sender_setsslcertencoded(void* lpObj, const char* lpSSLCertEncoded, int lenSSLCertEncoded);

QString GetSSLCertEffectiveDate();

QString GetSSLCertExpirationDate();

QString GetSSLCertExtendedKeyUsage();

QString GetSSLCertFingerprint();

QString GetSSLCertFingerprintSHA1();

QString GetSSLCertFingerprintSHA256();

QString GetSSLCertIssuer();

QString GetSSLCertPrivateKey();

bool GetSSLCertPrivateKeyAvailable();

QString GetSSLCertPrivateKeyContainer();

QString GetSSLCertPublicKey();

QString GetSSLCertPublicKeyAlgorithm();

int GetSSLCertPublicKeyLength();

QString GetSSLCertSerialNumber();

QString GetSSLCertSignatureAlgorithm();

QByteArray GetSSLCertStore();
int SetSSLCertStore(QByteArray qbaSSLCertStore);

QString GetSSLCertStorePassword();
int SetSSLCertStorePassword(QString qsSSLCertStorePassword);

int GetSSLCertStoreType();
int SetSSLCertStoreType(int iSSLCertStoreType);

QString GetSSLCertSubjectAltNames();

QString GetSSLCertThumbprintMD5();

QString GetSSLCertThumbprintSHA1();

QString GetSSLCertThumbprintSHA256();

QString GetSSLCertUsage();

int GetSSLCertUsageFlags();

QString GetSSLCertVersion();

QString GetSSLCertSubject();
int SetSSLCertSubject(QString qsSSLCertSubject);

QByteArray GetSSLCertEncoded();
int SetSSLCertEncoded(QByteArray qbaSSLCertEncoded);

Remarks

This property includes the digital certificate that the class will use during SSL negotiation. Set this property to a valid certificate before starting SSL negotiation. To set a certificate, you may set the Encoded field to the encoded certificate. To select a certificate, use the store and subject fields.

Data Type

IPWorksEDICertificate

SSLProvider Property (AS2Sender Class)

The Secure Sockets Layer/Transport Layer Security (SSL/TLS) implementation to use.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetSSLProvider();
int SetSSLProvider(int iSSLProvider);

Unicode (Windows)
INT GetSSLProvider();
INT SetSSLProvider(INT iSSLProvider);

SSLP_AUTOMATIC(0), 
SSLP_PLATFORM(1), 
SSLP_INTERNAL(2)

int ipworksedi_as2sender_getsslprovider(void* lpObj);
int ipworksedi_as2sender_setsslprovider(void* lpObj, int iSSLProvider);

int GetSSLProvider();
int SetSSLProvider(int iSSLProvider);

Default Value

0

Remarks

This property specifies the SSL/TLS implementation to use. In most cases the default value of 0 (Automatic) is recommended and should not be changed. When set to 0 (Automatic), the class will select whether to use the platform implementation or the internal implementation depending on the operating system as well as the TLS version being used.

Possible values are as follows:

In most cases using the default value (Automatic) is recommended. The class will select a provider depending on the current platform.

When Automatic is selected, on Windows, the class will use the platform implementation. On Linux/macOS, the class will use the internal implementation. When TLS 1.3 is enabled via SSLEnabledProtocols, the internal implementation is used on all platforms.

Data Type

Integer

SSLServerCert Property (AS2Sender Class)

The server certificate for the last established connection.

Syntax

• C++
• C
• Qt

IPWorksEDICertificate* GetSSLServerCert();

char* ipworksedi_as2sender_getsslservercerteffectivedate(void* lpObj);

char* ipworksedi_as2sender_getsslservercertexpirationdate(void* lpObj);

char* ipworksedi_as2sender_getsslservercertextendedkeyusage(void* lpObj);

char* ipworksedi_as2sender_getsslservercertfingerprint(void* lpObj);

char* ipworksedi_as2sender_getsslservercertfingerprintsha1(void* lpObj);

char* ipworksedi_as2sender_getsslservercertfingerprintsha256(void* lpObj);

char* ipworksedi_as2sender_getsslservercertissuer(void* lpObj);

char* ipworksedi_as2sender_getsslservercertprivatekey(void* lpObj);

int ipworksedi_as2sender_getsslservercertprivatekeyavailable(void* lpObj);

char* ipworksedi_as2sender_getsslservercertprivatekeycontainer(void* lpObj);

char* ipworksedi_as2sender_getsslservercertpublickey(void* lpObj);

char* ipworksedi_as2sender_getsslservercertpublickeyalgorithm(void* lpObj);

int ipworksedi_as2sender_getsslservercertpublickeylength(void* lpObj);

char* ipworksedi_as2sender_getsslservercertserialnumber(void* lpObj);

char* ipworksedi_as2sender_getsslservercertsignaturealgorithm(void* lpObj);

int ipworksedi_as2sender_getsslservercertstore(void* lpObj, char** lpSSLServerCertStore, int* lenSSLServerCertStore);

char* ipworksedi_as2sender_getsslservercertstorepassword(void* lpObj);

int ipworksedi_as2sender_getsslservercertstoretype(void* lpObj);

char* ipworksedi_as2sender_getsslservercertsubjectaltnames(void* lpObj);

char* ipworksedi_as2sender_getsslservercertthumbprintmd5(void* lpObj);

char* ipworksedi_as2sender_getsslservercertthumbprintsha1(void* lpObj);

char* ipworksedi_as2sender_getsslservercertthumbprintsha256(void* lpObj);

char* ipworksedi_as2sender_getsslservercertusage(void* lpObj);

int ipworksedi_as2sender_getsslservercertusageflags(void* lpObj);

char* ipworksedi_as2sender_getsslservercertversion(void* lpObj);

char* ipworksedi_as2sender_getsslservercertsubject(void* lpObj);

int ipworksedi_as2sender_getsslservercertencoded(void* lpObj, char** lpSSLServerCertEncoded, int* lenSSLServerCertEncoded);

QString GetSSLServerCertEffectiveDate();

QString GetSSLServerCertExpirationDate();

QString GetSSLServerCertExtendedKeyUsage();

QString GetSSLServerCertFingerprint();

QString GetSSLServerCertFingerprintSHA1();

QString GetSSLServerCertFingerprintSHA256();

QString GetSSLServerCertIssuer();

QString GetSSLServerCertPrivateKey();

bool GetSSLServerCertPrivateKeyAvailable();

QString GetSSLServerCertPrivateKeyContainer();

QString GetSSLServerCertPublicKey();

QString GetSSLServerCertPublicKeyAlgorithm();

int GetSSLServerCertPublicKeyLength();

QString GetSSLServerCertSerialNumber();

QString GetSSLServerCertSignatureAlgorithm();

QByteArray GetSSLServerCertStore();

QString GetSSLServerCertStorePassword();

int GetSSLServerCertStoreType();

QString GetSSLServerCertSubjectAltNames();

QString GetSSLServerCertThumbprintMD5();

QString GetSSLServerCertThumbprintSHA1();

QString GetSSLServerCertThumbprintSHA256();

QString GetSSLServerCertUsage();

int GetSSLServerCertUsageFlags();

QString GetSSLServerCertVersion();

QString GetSSLServerCertSubject();

QByteArray GetSSLServerCertEncoded();

Remarks

This property contains the server certificate for the last established connection.

SSLServerCert is reset every time a new connection is attempted.

This property is read-only.

Data Type

IPWorksEDICertificate

Subject Property (AS2Sender Class)

The subject of the message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetSubject();
int SetSubject(const char* lpszSubject);

Unicode (Windows)
LPWSTR GetSubject();
INT SetSubject(LPCWSTR lpszSubject);

char* ipworksedi_as2sender_getsubject(void* lpObj);
int ipworksedi_as2sender_setsubject(void* lpObj, const char* lpszSubject);

QString GetSubject();
int SetSubject(QString qsSubject);

Default Value

""

Remarks

The optional human-readable subject of the message. Some AS2 partners will use this field to send additional information about the transmission at the transport layer.

Data Type

String

Timeout Property (AS2Sender Class)

The timeout for the class.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetTimeout();
int SetTimeout(int iTimeout);

Unicode (Windows)
INT GetTimeout();
INT SetTimeout(INT iTimeout);

int ipworksedi_as2sender_gettimeout(void* lpObj);
int ipworksedi_as2sender_settimeout(void* lpObj, int iTimeout);

int GetTimeout();
int SetTimeout(int iTimeout);

Default Value

60

Remarks

If the Timeout property is set to 0, all operations will run uninterrupted until successful completion or an error condition is encountered.

If Timeout is set to a positive value, the class will wait for the operation to complete before returning control.

The class will use DoEvents to enter an efficient wait loop during any potential waiting period, making sure that all system events are processed immediately as they arrive. This ensures that the host application does not freeze and remains responsive.

If Timeout expires, and the operation is not yet complete, the class fails with an error.

Note: By default, all timeouts are inactivity timeouts, that is, the timeout period is extended by Timeout seconds when any amount of data is successfully sent or received.

The default value for the Timeout property is 60 seconds.

Data Type

Integer

URL Property (AS2Sender Class)

The URL to which the request is made.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetURL();
int SetURL(const char* lpszURL);

Unicode (Windows)
LPWSTR GetURL();
INT SetURL(LPCWSTR lpszURL);

char* ipworksedi_as2sender_geturl(void* lpObj);
int ipworksedi_as2sender_seturl(void* lpObj, const char* lpszURL);

QString GetURL();
int SetURL(QString qsURL);

Default Value

""

Remarks

This property specifies the URL to which the request is made. SSL will be used if and only if the URL scheme is "https".

Data Type

String

UseOAEP Property (AS2Sender Class)

This property specifies whether or not to use Optimal Asymmetric Encryption Padding (OAEP).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetUseOAEP();
int SetUseOAEP(int bUseOAEP);

Unicode (Windows)
BOOL GetUseOAEP();
INT SetUseOAEP(BOOL bUseOAEP);

int ipworksedi_as2sender_getuseoaep(void* lpObj);
int ipworksedi_as2sender_setuseoaep(void* lpObj, int bUseOAEP);

bool GetUseOAEP();
int SetUseOAEP(bool bUseOAEP);

Default Value

FALSE

Remarks

This property specifies whether or not to use Optimal Asymmetric Encryption Padding (OAEP). By default, this value is False and the class will use PKCS1.

To specify nondefault OAEP options, please see OAEPRSAHashAlgorithm, OAEPMGF1HashAlgorithm, and OAEPParams

Data Type

Boolean

UsePSS Property (AS2Sender Class)

This property specifies whether or not RSA-PSS will be used during signing and verification.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetUsePSS();
int SetUsePSS(int bUsePSS);

Unicode (Windows)
BOOL GetUsePSS();
INT SetUsePSS(BOOL bUsePSS);

int ipworksedi_as2sender_getusepss(void* lpObj);
int ipworksedi_as2sender_setusepss(void* lpObj, int bUsePSS);

bool GetUsePSS();
int SetUsePSS(bool bUsePSS);

Default Value

FALSE

Remarks

This property specifies whether or not RSA-PSS will be used when signing and verifying messages. The default value is False.

Data Type

Boolean

UserAgent Property (AS2Sender Class)

Information about the user agent.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetUserAgent();
int SetUserAgent(const char* lpszUserAgent);

Unicode (Windows)
LPWSTR GetUserAgent();
INT SetUserAgent(LPCWSTR lpszUserAgent);

char* ipworksedi_as2sender_getuseragent(void* lpObj);
int ipworksedi_as2sender_setuseragent(void* lpObj, const char* lpszUserAgent);

QString GetUserAgent();
int SetUserAgent(QString qsUserAgent);

Default Value

"IPWorks EDI AS2Sender Component - www.nsoftware.com"

Remarks

You may override the default with the name and version of your software.

Data Type

String

Config Method (AS2Sender Class)

Sets or retrieves a configuration setting.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* Config(const char* lpszConfigurationString);

Unicode (Windows)
LPWSTR Config(LPCWSTR lpszConfigurationString);

char* ipworksedi_as2sender_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

Remarks

Config is a generic method available in every class. It is used to set and retrieve configuration settings for the class.

These settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the class, access to these internal properties is provided through the Config method.

To set a configuration setting named PROPERTY, you must call Config("PROPERTY=VALUE"), where VALUE is the value of the setting expressed as a string. For boolean values, use the strings "True", "False", "0", "1", "Yes", or "No" (case does not matter).

To read (query) the value of a configuration setting, you must call Config("PROPERTY"). The value will be returned as a string.

Error Handling (C++)

This method returns a String value; after it returns, call the GetLastErrorCode() method to obtain its result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

DoEvents Method (AS2Sender Class)

This method processes events from the internal message queue.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int DoEvents();

Unicode (Windows)
INT DoEvents();

int ipworksedi_as2sender_doevents(void* lpObj);

int DoEvents();

Remarks

When DoEvents is called, the class processes any available events. If no events are available, it waits for a preset period of time, and then returns.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Interrupt Method (AS2Sender Class)

This method interrupts the current method.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Interrupt();

Unicode (Windows)
INT Interrupt();

int ipworksedi_as2sender_interrupt(void* lpObj);

int Interrupt();

Remarks

If there is no method in progress, Interrupt simply returns, doing nothing.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Post Method (AS2Sender Class)

Post data to the AS2 server, and check the receipt.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Post();

Unicode (Windows)
INT Post();

int ipworksedi_as2sender_post(void* lpObj);

int Post();

Remarks

Post data to the server. The reply will also be checked, and if a synchronous MDN was requested (i.e., MDNTo is not empty), it will be validated. After the method finishes, the MDNReceipt, ReceiptSigningProtocol, and ReceiptSignerCert properties will be populated with the appropriate values.

The method operates synchronously, and will throw an exception if any errors or warnings occur. Errors might include a failure to decrypt or authenticate the receipt, the absence of an MDN when one was requested, TCP/IP errors, or any errors reported by the server in the MDN. Warnings might include the return of an unsigned receipt when a signed receipt was requested, or other warnings reported by the server in the MDN.

If an exception is thrown the error code will correspond to the severity of the warning or error, allowing client software to determine whether or not to accept the reply. If multiple errors occur, the exception will return a special error code, and the error message will contain a line for each error's code and description; i.e. "423: Failed to authenticate sender". If the error(s) is/are not fatal processing will not be interrupted, and the relevant properties will be populated as normal.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

ReadAsyncReceipt Method (AS2Sender Class)

Reads an asynchronous MDN receipt from the current HTTP session.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ReadAsyncReceipt();

Unicode (Windows)
INT ReadAsyncReceipt();

int ipworksedi_as2sender_readasyncreceipt(void* lpObj);

int ReadAsyncReceipt();

Remarks

ReadAsyncReceipt is used to read an asynchronous MDN receipt from the . The class will fetch the request stream from the HTTP session. MDNReceipt will be populated with a new instance of MDNReceipt.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Reset Method (AS2Sender Class)

Resets the state of the control.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Reset();

Unicode (Windows)
INT Reset();

int ipworksedi_as2sender_reset(void* lpObj);

int Reset();

Remarks

Resets all HTTP headers as well as EDIData, etc. After invoking this method the class may be reused as if it were newly created.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Restart Method (AS2Sender Class)

Restart sending of the file specified by the Etag property.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Restart();

Unicode (Windows)
INT Restart();

int ipworksedi_as2sender_restart(void* lpObj);

int Restart();

Remarks

This method should be called when using the AS2 restart functionality. When called, the class will process the file and cache the processed contents to the RestartDirectory. Before sending, the Etag property will be populated with a unique Etag which identifies the processed file.

If sending is interrupted or fails, this method should be called to restart sending of the previously processed file starting where the interruption occurred. In order to restart from the last transfer, the Etag must be populated with the value from the last connection.

NOTE: When using restart functionality, the data is completely processed to the RestartDirectory before sending begins.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SendCEMRequest Method (AS2Sender Class)

Sends a Certificate Exchange Messaging (CEM) request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SendCEMRequest(const char* lpszRequestId);

Unicode (Windows)
INT SendCEMRequest(LPCWSTR lpszRequestId);

int ipworksedi_as2sender_sendcemrequest(void* lpObj, const char* lpszRequestId);

int SendCEMRequest(const QString& qsRequestId);

Remarks

This method send the Certificate Exchange Messaging (CEM) request with the details specified in CEMDetails.

Certificate Exchange Messaging (CEM) allows for new certificates to be sent to a recipient and be automatically updated. This removes the requirement to manually send new certificates to a partner via email or other means. When both sides support this functionality updating certificates can be accomplished in a short period of time.

To prepare a CEM request populate the CEMDetails collection with at least one certificate. For instance if the certificate of the application will be updated soon, the CEMDetails may be populated with the corresponding public certificate to be sent to your partner. CEMDetails should only contain public certificates.

Set RespondByDate to the date by which you expect a response. The format is of the XML standard dateTime type expressed in local time with UTC offset. For instance: "2005-08-31T00:21:00-05:00".

Optionally set CertId to a friendly identifier that the partner may use to help understand the purpose of the new certificate. For instance "New.Encryption.Cert.2014".

Set ResponseURL to the publicly accessible URL where the CEM response will be sent after the partner processes it.

The RequestId parameter uniquely identifies this CEM request and must be saved for use later when receiving the CEM response.

When calling this method the applicable CEMDetails fields are:

• CertStoreType
• CertStore
• CertStorePassword
• CertSubject
• RespondByDate
• ResponseURL
• CertUsage (optional)
• CertId (optional)

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SendCEMResponse Method (AS2Sender Class)

Sends a Certificate Exchange Messaging (CEM) response.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SendCEMResponse(const char* lpszRequestId);

Unicode (Windows)
INT SendCEMResponse(LPCWSTR lpszRequestId);

int ipworksedi_as2sender_sendcemresponse(void* lpObj, const char* lpszRequestId);

int SendCEMResponse(const QString& qsRequestId);

Remarks

This method send the Certificate Exchange Messaging (CEM) request with the details specified in CEMDetails.

A CEM request must have previously been received using AS2Receiver. To send the CEM response, populate CEMDetails with the certificate information and decide whether to accept or reject the request. The following fields may be set to specify the certificate:

• CertStoreType
• CertStore
• CertSubject

• CertIssuer
• CertSerialNumber

After specifying the certificate information choose whether to accept or reject the request. To accept the request set Accepted to True. To reject the request set Accepted to False and specify a reason in RejectionReason.

Call SendCEMResponse and pass the CEM request Id that was retrieved from the request.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SetRequestHeader Method (AS2Sender Class)

Allows the user to set or add arbitrary HTTP request headers.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetRequestHeader(const char* lpszHeaderName, const char* lpszHeaderValue);

Unicode (Windows)
INT SetRequestHeader(LPCWSTR lpszHeaderName, LPCWSTR lpszHeaderValue);

int ipworksedi_as2sender_setrequestheader(void* lpObj, const char* lpszHeaderName, const char* lpszHeaderValue);

int SetRequestHeader(const QString& qsHeaderName, const QString& qsHeaderValue);

Remarks

HeaderName should contain the header name, and HeaderValue should contain its value. Use this to set headers such as To, Date, etc. Note that a default value for Date will automatically be determined and this method may be used to override the default.

SetRequestHeader may be used to set any header except for the following: AS2-To, AS2-From, AS2-Version, Subject, Message-Id, Disposition-Notification-To, Disposition-Notification-Options, Receipt-Delivery-Option, Host, Content-Length.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SetTPInfo Method (AS2Sender Class)

A convenient way to set AS2 communication parameters using XML strings.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetTPInfo(const char* lpszProfile);

Unicode (Windows)
INT SetTPInfo(LPCWSTR lpszProfile);

int ipworksedi_as2sender_settpinfo(void* lpObj, const char* lpszProfile);

int SetTPInfo(const QString& qsProfile);

Remarks

SetTPInfo offers a convenient way to set AS2 communication parameters using XML strings. The format of the XML is the same as provided by the method GetTPInfo of AS2ProfileMgr.

The "self" information should always precede the partner information as shown below. AS2Sender as2sender = new AS2Sender(); AS2Profilemgr mgr = new AS2Profilemgr(); mgr.DataDir = @"C:\as2data"; as2sender.SetTPInfo(mgr.GetTPInfo("self")); as2sender.SetTPInfo(mgr.GetTPInfo("partnerOrg")); as2sender.EDIFile = @"C:\as2Data.x12"; as2sender.Post();

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

VerifyReceipt Method (AS2Sender Class)

Verifies an asynchronous MDN receipt.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int VerifyReceipt();

Unicode (Windows)
INT VerifyReceipt();

int ipworksedi_as2sender_verifyreceipt(void* lpObj);

int VerifyReceipt();

Remarks

VerifyReceipt verifies the receipt in MDNReceipt against OriginalContentMIC, MessageId and the preferences specified in MDNOptions. The method operates similarly to Post: After the method finishes, the MDNReceipt, ReceiptSigningProtocol, and ReceiptSignerCert properties will be populated with the appropriate values.

The method operates synchronously, and will throw an exception if any errors or warnings occur. Errors might include a failure to decrypt or authenticate the receipt, the absence of an MDN when one was requested, TCP/IP errors, or any errors reported by the server in the MDN. Warnings might include the return of an unsigned receipt when a signed receipt was requested, or other warnings reported by the server in the MDN.

If an exception is thrown the error code will correspond to the severity of the warning or error, allowing client software to determine whether or not to accept the reply. If multiple errors occur, the exception will return a special error code, and the error message will contain a line for each error's code and description; i.e. "423: Failed to authenticate sender". If the error(s) is/are not fatal processing will not be interrupted, and the relevant properties will be populated as normal.

This method should be used to verify receipts received asynchronously; i.e., not in the HTTP reply to a POST. When posting, asynchronous MDN delivery may be requested by setting MDNDeliveryOption.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Connected Event (AS2Sender Class)

Fired immediately after a connection completes (or fails).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireConnected(AS2SenderConnectedEventParams *e);

typedef struct {
  int StatusCode;
  const char *Description;
  int reserved;
} AS2SenderConnectedEventParams;


Unicode (Windows)
virtual INT FireConnected(AS2SenderConnectedEventParams *e);

typedef struct {
  INT StatusCode;
  LPCWSTR Description;
  INT reserved;
} AS2SenderConnectedEventParams;

#define EID_AS2SENDER_CONNECTED 1

virtual INT IPWORKSEDI_CALL FireConnected(INT &iStatusCode, LPSTR &lpszDescription);

class AS2SenderConnectedEventParams {
public:
  int StatusCode();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Connected(AS2SenderConnectedEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireConnected(AS2SenderConnectedEventParams *e) {...}

Remarks

If the connection is made normally, StatusCode is 0 and Description is "OK".

If the connection fails, StatusCode has the error code returned by the Transmission Control Protocol (TCP)/IP stack. Description contains a description of this code. The value of StatusCode is equal to the value of the error.

Please refer to the Error Codes section for more information.

Disconnected Event (AS2Sender Class)

Fired when a connection is closed.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireDisconnected(AS2SenderDisconnectedEventParams *e);

typedef struct {
  int StatusCode;
  const char *Description;
  int reserved;
} AS2SenderDisconnectedEventParams;


Unicode (Windows)
virtual INT FireDisconnected(AS2SenderDisconnectedEventParams *e);

typedef struct {
  INT StatusCode;
  LPCWSTR Description;
  INT reserved;
} AS2SenderDisconnectedEventParams;

#define EID_AS2SENDER_DISCONNECTED 2

virtual INT IPWORKSEDI_CALL FireDisconnected(INT &iStatusCode, LPSTR &lpszDescription);

class AS2SenderDisconnectedEventParams {
public:
  int StatusCode();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Disconnected(AS2SenderDisconnectedEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireDisconnected(AS2SenderDisconnectedEventParams *e) {...}

Remarks

If the connection is broken normally, StatusCode is 0 and Description is "OK".

If the connection is broken for any other reason, StatusCode has the error code returned by the Transmission Control Protocol (TCP/IP) subsystem. Description contains a description of this code. The value of StatusCode is equal to the value of the TCP/IP error.

Please refer to the Error Codes section for more information.

EndTransfer Event (AS2Sender Class)

Fired when a document finishes transferring.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireEndTransfer(AS2SenderEndTransferEventParams *e);

typedef struct {
  int Direction;
  int reserved;
} AS2SenderEndTransferEventParams;


Unicode (Windows)
virtual INT FireEndTransfer(AS2SenderEndTransferEventParams *e);

typedef struct {
  INT Direction;
  INT reserved;
} AS2SenderEndTransferEventParams;

#define EID_AS2SENDER_ENDTRANSFER 3

virtual INT IPWORKSEDI_CALL FireEndTransfer(INT &iDirection);

class AS2SenderEndTransferEventParams {
public:
  int Direction();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void EndTransfer(AS2SenderEndTransferEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireEndTransfer(AS2SenderEndTransferEventParams *e) {...}

Remarks

This event is fired first when the client finishes sending data to the server (in a POST or PUT request) and then when the document text finishes transferring from the server to the local host.

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

Error Event (AS2Sender Class)

Fired when information is available about errors during data delivery.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireError(AS2SenderErrorEventParams *e);

typedef struct {
  int ErrorCode;
  const char *Description;
  int reserved;
} AS2SenderErrorEventParams;


Unicode (Windows)
virtual INT FireError(AS2SenderErrorEventParams *e);

typedef struct {
  INT ErrorCode;
  LPCWSTR Description;
  INT reserved;
} AS2SenderErrorEventParams;

#define EID_AS2SENDER_ERROR 4

virtual INT IPWORKSEDI_CALL FireError(INT &iErrorCode, LPSTR &lpszDescription);

class AS2SenderErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Error(AS2SenderErrorEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireError(AS2SenderErrorEventParams *e) {...}

Remarks

The Error event is fired in case of exceptional conditions during message processing. Normally the class fails with an error.

The ErrorCode parameter contains an error code, and the Description parameter contains a textual description of the error. For a list of valid error codes and their descriptions, please refer to the Error Codes section.

Header Event (AS2Sender Class)

Fired every time a header line comes in.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireHeader(AS2SenderHeaderEventParams *e);

typedef struct {
  const char *Field;
  const char *Value;
  int reserved;
} AS2SenderHeaderEventParams;


Unicode (Windows)
virtual INT FireHeader(AS2SenderHeaderEventParams *e);

typedef struct {
  LPCWSTR Field;
  LPCWSTR Value;
  INT reserved;
} AS2SenderHeaderEventParams;

#define EID_AS2SENDER_HEADER 5

virtual INT IPWORKSEDI_CALL FireHeader(LPSTR &lpszField, LPSTR &lpszValue);

class AS2SenderHeaderEventParams {
public:
  const QString &Field();

  const QString &Value();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Header(AS2SenderHeaderEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireHeader(AS2SenderHeaderEventParams *e) {...}

Remarks

The Field parameter contains the name of the HTTP header (same case as it is delivered). The Value parameter contains the header contents.

If the header line being retrieved is a continuation header line, then the Field parameter contains an empty string.

Note that only the top-level headers will be returned through this event, and that they are available through the ReplyHeaders property.

The Field parameter contains the name of the HTTP header (which is the same as it is delivered). The Value parameter contains the header contents.

If the header line being retrieved is a continuation header line, then the Field parameter contains "" (empty string).

Log Event (AS2Sender Class)

Fired with log information while processing a message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireLog(AS2SenderLogEventParams *e);

typedef struct {
  const char *LogType;
  const char *LogMessage;
  int lenLogMessage;
  int reserved;
} AS2SenderLogEventParams;


Unicode (Windows)
virtual INT FireLog(AS2SenderLogEventParams *e);

typedef struct {
  LPCWSTR LogType;
  LPCSTR LogMessage;
  INT lenLogMessage;
  INT reserved;
} AS2SenderLogEventParams;

#define EID_AS2SENDER_LOG 6

virtual INT IPWORKSEDI_CALL FireLog(LPSTR &lpszLogType, LPSTR &lpLogMessage, INT &lenLogMessage);

class AS2SenderLogEventParams {
public:
  const QString &LogType();

  const QByteArray &LogMessage();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Log(AS2SenderLogEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireLog(AS2SenderLogEventParams *e) {...}

Remarks

This event fires once for each log message generated by the class. The verbosity is controlled by the LogLevel setting.

Log messages available through this event correspond to log files written to LogDirectory. This event provides a way to obtain log messages without relying on files on disk. This event fires regardless of the value of LogDirectory (i.e. when LogDirectory is empty the event will still fire).

The LogMessage event parameter holds the raw log data.

The LogType event parameter indicates the type of log. Possible values are:

SetCookie Event (AS2Sender Class)

Fired for every cookie set by the server.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireSetCookie(AS2SenderSetCookieEventParams *e);

typedef struct {
  const char *Name;
  const char *Value;
  const char *Expires;
  const char *Domain;
  const char *Path;
  int Secure;
  int reserved;
} AS2SenderSetCookieEventParams;


Unicode (Windows)
virtual INT FireSetCookie(AS2SenderSetCookieEventParams *e);

typedef struct {
  LPCWSTR Name;
  LPCWSTR Value;
  LPCWSTR Expires;
  LPCWSTR Domain;
  LPCWSTR Path;
  BOOL Secure;
  INT reserved;
} AS2SenderSetCookieEventParams;

#define EID_AS2SENDER_SETCOOKIE 7

virtual INT IPWORKSEDI_CALL FireSetCookie(LPSTR &lpszName, LPSTR &lpszValue, LPSTR &lpszExpires, LPSTR &lpszDomain, LPSTR &lpszPath, BOOL &bSecure);

class AS2SenderSetCookieEventParams {
public:
  const QString &Name();

  const QString &Value();

  const QString &Expires();

  const QString &Domain();

  const QString &Path();

  bool Secure();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void SetCookie(AS2SenderSetCookieEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireSetCookie(AS2SenderSetCookieEventParams *e) {...}

Remarks

This event is fired for every Set-Cookie: header received from the HTTP server.

The Name parameter contains the name of the cookie, with the corresponding value supplied in the Value parameter.

The Expires parameter contains an expiration time for the cookie (if provided by the server). The time format used is "Weekday, DD-Mon-YY HH:MM:SS GMT". If the server does not provide an expiration time, the Expires parameter will be an empty string. In this case, the convention is to drop the cookie at the end of the session.

The Domain parameter contains a domain name to limit the cookie to (if provided by the server). If the server does not provide a domain name, the Domain parameter will be an empty string. The convention in this case is to use the server specified in the URL (URLServer) as the cookie domain.

The Path parameter contains a path name to limit the cookie to (if provided by the server). If the server does not provide a cookie path, the Path parameter will be an empty string. The convention in this case is to use the path specified in the URL (URLPath) as the cookie path.

The Secure parameter specifies whether the cookie is secure. If the value of this parameter is True, the cookie value must be submitted only through a secure (HTTPS) connection.

SSLServerAuthentication Event (AS2Sender Class)

Fired after the server presents its certificate to the client.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireSSLServerAuthentication(AS2SenderSSLServerAuthenticationEventParams *e);

typedef struct {
  const char *CertEncoded;
  int lenCertEncoded;
  const char *CertSubject;
  const char *CertIssuer;
  const char *Status;
  int Accept;
  int reserved;
} AS2SenderSSLServerAuthenticationEventParams;


Unicode (Windows)
virtual INT FireSSLServerAuthentication(AS2SenderSSLServerAuthenticationEventParams *e);

typedef struct {
  LPCSTR CertEncoded;
  INT lenCertEncoded;
  LPCWSTR CertSubject;
  LPCWSTR CertIssuer;
  LPCWSTR Status;
  BOOL Accept;
  INT reserved;
} AS2SenderSSLServerAuthenticationEventParams;

#define EID_AS2SENDER_SSLSERVERAUTHENTICATION 8

virtual INT IPWORKSEDI_CALL FireSSLServerAuthentication(LPSTR &lpCertEncoded, INT &lenCertEncoded, LPSTR &lpszCertSubject, LPSTR &lpszCertIssuer, LPSTR &lpszStatus, BOOL &bAccept);

class AS2SenderSSLServerAuthenticationEventParams {
public:
  const QByteArray &CertEncoded();

  const QString &CertSubject();

  const QString &CertIssuer();

  const QString &Status();

  bool Accept();
  void SetAccept(bool bAccept);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void SSLServerAuthentication(AS2SenderSSLServerAuthenticationEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireSSLServerAuthentication(AS2SenderSSLServerAuthenticationEventParams *e) {...}

Remarks

This event is where the client can decide whether to continue with the connection process or not. The Accept parameter is a recommendation on whether to continue or close the connection. This is just a suggestion: application software must use its own logic to determine whether to continue or not.

When Accept is False, Status shows why the verification failed (otherwise, Status contains the string "OK").

SSLStatus Event (AS2Sender Class)

Fired when secure connection progress messages are available.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireSSLStatus(AS2SenderSSLStatusEventParams *e);

typedef struct {
  const char *Message;
  int reserved;
} AS2SenderSSLStatusEventParams;


Unicode (Windows)
virtual INT FireSSLStatus(AS2SenderSSLStatusEventParams *e);

typedef struct {
  LPCWSTR Message;
  INT reserved;
} AS2SenderSSLStatusEventParams;

#define EID_AS2SENDER_SSLSTATUS 9

virtual INT IPWORKSEDI_CALL FireSSLStatus(LPSTR &lpszMessage);

class AS2SenderSSLStatusEventParams {
public:
  const QString &Message();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void SSLStatus(AS2SenderSSLStatusEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireSSLStatus(AS2SenderSSLStatusEventParams *e) {...}

Remarks

The event is fired for informational and logging purposes only. This event tracks the progress of the connection.

StartTransfer Event (AS2Sender Class)

Fired when a document starts transferring (after the headers).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireStartTransfer(AS2SenderStartTransferEventParams *e);

typedef struct {
  int Direction;
  int reserved;
} AS2SenderStartTransferEventParams;


Unicode (Windows)
virtual INT FireStartTransfer(AS2SenderStartTransferEventParams *e);

typedef struct {
  INT Direction;
  INT reserved;
} AS2SenderStartTransferEventParams;

#define EID_AS2SENDER_STARTTRANSFER 10

virtual INT IPWORKSEDI_CALL FireStartTransfer(INT &iDirection);

class AS2SenderStartTransferEventParams {
public:
  int Direction();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void StartTransfer(AS2SenderStartTransferEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireStartTransfer(AS2SenderStartTransferEventParams *e) {...}

Remarks

This event is fired first when the client starts sending data to the server (in a POST or PUT request) and then when the document text starts transferring from the server to the local host.

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

Transfer Event (AS2Sender Class)

Fired while a document transfers (delivers document).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireTransfer(AS2SenderTransferEventParams *e);

typedef struct {
  int Direction;
  int64 BytesTransferred;
  int PercentDone;
  const char *Text;
  int lenText;
  int reserved;
} AS2SenderTransferEventParams;


Unicode (Windows)
virtual INT FireTransfer(AS2SenderTransferEventParams *e);

typedef struct {
  INT Direction;
  LONG64 BytesTransferred;
  INT PercentDone;
  LPCSTR Text;
  INT lenText;
  INT reserved;
} AS2SenderTransferEventParams;

#define EID_AS2SENDER_TRANSFER 11

virtual INT IPWORKSEDI_CALL FireTransfer(INT &iDirection, LONG64 &lBytesTransferred, INT &iPercentDone, LPSTR &lpText, INT &lenText);

class AS2SenderTransferEventParams {
public:
  int Direction();

  qint64 BytesTransferred();

  int PercentDone();

  const QByteArray &Text();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Transfer(AS2SenderTransferEventParams *e);

// Or, subclass AS2Sender and override this emitter function.
virtual int FireTransfer(AS2SenderTransferEventParams *e) {...}

Remarks

The Text parameter contains the portion of the document text being received. It is empty if data are being posted to the server.

The BytesTransferred parameter contains the number of bytes transferred in this Direction since the beginning of the document text (excluding HTTP response headers).

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

The PercentDone parameter shows the progress of the transfer in the corresponding direction. If PercentDone can not be calculated the value will be -1.

Note: Events are not re-entrant. Performing time-consuming operations within this event will prevent it from firing again in a timely manner and may affect overall performance.

CEMDetail Type

This type defines details about the CEM request.

Syntax

IPWorksEDICEMDetail (declared in ipworksedi.h)

Remarks

This type defines details about the CEM request. Not all fields are applicable for all operations.

Fields

Constructors

CEMDetail()

Certificate Type

This is the digital certificate being used.

Syntax

IPWorksEDICertificate (declared in ipworksedi.h)

Remarks

This type describes the current digital certificate. The certificate may be a public or private key. The fields are used to identify or select certificates.

Fields

Constructors

Certificate()

Certificate(const char* lpEncoded, int lenEncoded)

Certificate(int iStoreType, const char* lpStore, int lenStore, const char* lpszStorePassword, const char* lpszSubject)

EDIAttachment Type

This describes the file being attached.

Syntax

IPWorksEDIEDIAttachment (declared in ipworksedi.h)

Remarks

Information about the file's location that is being attached to the message is contained here.

Fields

Constructors

EDIAttachment()

EDIAttachment(const char* lpszFileName)

EDIAttachment(const char* lpszFileName, const char* lpszContentType)

EDIAttachment(const char* lpszFileName, const char* lpszContentType, const char* lpszHeaders)

EDIData Type

The EDI payload of the AS2 message.

Syntax

IPWorksEDIEDIData (declared in ipworksedi.h)

Remarks

The EDI payload of the AS2 message.

Fields

Constructors

EDIData()

EDIData(const char* lpData, int lenData, const char* lpszEDIType)

EDIData(const char* lpszFileName, const char* lpszEDIType)

Firewall Type

The firewall the component will connect through.

Syntax

IPWorksEDIFirewall (declared in ipworksedi.h)

Remarks

When connecting through a firewall, this type is used to specify different properties of the firewall, such as the firewall Host and the FirewallType.

Fields

Constructors

Firewall()

HTTPCookie Type

An HTTP cookie can be either sent to or received from the server.

Syntax

IPWorksEDIHTTPCookie (declared in ipworksedi.h)

Remarks

An HTTP cookie can store the cookies that are to be sent to the server. It also may store the cookies sent by the server.

Cookies that are to be sent to the server must have the Name and Value fields supplied before submitting the URL. When the SetCookie event is fired, however, all of the fields of an HTTPCookie are filled out accordingly.

Fields

Constructors

HTTPCookie()

HTTPCookie(const char* lpszName, const char* lpszValue)

MDNReceipt Type

The complete MDN Receipt returned by the receiver.

Syntax

IPWorksEDIMDNReceipt (declared in ipworksedi.h)

Remarks

The complete MDN Receipt contains the Message Disposition Notification (MDN) and an optional signature.

Fields

Constructors

MDNReceipt()

MDNReceipt(const char* lpszHeaders, const char* lpContent, int lenContent)

Proxy Type

The proxy the component will connect to.

Syntax

IPWorksEDIProxy (declared in ipworksedi.h)

Remarks

When connecting through a proxy, this type is used to specify different properties of the proxy, such as the Server and the AuthScheme.

Fields

Constructors

Proxy()

Proxy(const char* lpszServer, int iPort)

Proxy(const char* lpszServer, int iPort, const char* lpszUser, const char* lpszPassword)

IPWorksEDIList Type

Syntax

IPWorksEDIList<T> (declared in ipworksedi.h)

Remarks

IPWorksEDIList is a generic class that is used to hold a collection of objects of type T, where T is one of the custom types supported by the AS2Sender class.

int GetCount() {}

int SetCount(int count) {}

T* Get(int index) {}

T* Set(int index, T* value) {}

Config Settings (AS2Sender Class)

AS2Sender Config Settings

HTTP Config Settings