I have extensively used IP*Works from nSoftware in the past, and would like to use it with PureBasic. I believe I need wrappers to achieve that. I am willing to fund a project to create individual wrappers, or preferably a means to automatically create wrappers by analyzing the nSoftware DLLs. Powerbasic has a utility for doing this, for example.
I am also interested in the same concept for Linux, using nSoftware's linux modules.
If someone has the time and skills to do this, I will fund the project, and allow free use to other Purebasic developers.
Any takers, or suggestions?
nSoftware IP*Works Wrapper Paid Project
Re: nSoftware IP*Works Wrapper Paid Project
what time frame are you expecting? It appears to me that it'd be a full time job for a number of weeks
windows might be easy if they have com dll's either by pb interfaces for early binding or commate for runtime binding
but for cross platform win / linux it would really need c wrappers, unless there's a c++ lib version that exports pure virtual classes
if that were the case pb Interfaces could be used for x64 on both win / linux
windows might be easy if they have com dll's either by pb interfaces for early binding or commate for runtime binding
but for cross platform win / linux it would really need c wrappers, unless there's a c++ lib version that exports pure virtual classes
if that were the case pb Interfaces could be used for x64 on both win / linux
Windows 11, Manjaro, Raspberry Pi OS
Re: nSoftware IP*Works Wrapper Paid Project
There are multiple versions for various platforms, including C/C++. The version I have used previously is the ActiveX one, but they all have the same functionality. What I don't want is any dependency on .NET or anything similar.
Details of the C/C++ environment are here:
http://www.nsoftware.com/platforms/cpp/
If its weeks, it's weeks, but hopefully they have an environment that makes it simpler.
Details of the C/C++ environment are here:
http://www.nsoftware.com/platforms/cpp/
If its weeks, it's weeks, but hopefully they have an environment that makes it simpler.
Re: nSoftware IP*Works Wrapper Paid Project
really need to see the c++ headers to see if it's doable
but given the numerous wrappers they provide there's a fairly good chance they're exposing pure virtual classes
so you could be in luck but it'd still be a big job.
if you can pm me a portion of the main header and an example of a class header, I'll let you know if it can be done
I don't really want to register with them just to download the trial version to see if it's doable or not
but given the numerous wrappers they provide there's a fairly good chance they're exposing pure virtual classes
so you could be in luck but it'd still be a big job.
if you can pm me a portion of the main header and an example of a class header, I'll let you know if it can be done
I don't really want to register with them just to download the trial version to see if it's doable or not
Windows 11, Manjaro, Raspberry Pi OS
Re: nSoftware IP*Works Wrapper Paid Project
Here is the main header:
Code: Select all
// IP*Works! SSL V9 C++ Edition - C++ Interface
//
// Copyright (c) 2015 /n software inc. - All rights reserved.
//
#ifndef _IPWORKSSSL_H_
#define _IPWORKSSSL_H_
#ifdef WIN32
#define IPWORKSSSL_CALL __stdcall
#else //UNIX
#define IPWORKSSSL_CALL
#endif
#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef __int64 ns_int64;
typedef unsigned __int64 ns_uint64;
#else
typedef long long int ns_int64;
typedef unsigned long long int ns_uint64;
#endif
#ifdef UNIX
#if defined(__LP64__) || defined(__x86_64__) || defined(__ia64__) || defined(__amd64__) || defined(__ppc64__)
#ifndef UNIX64
#define UNIX64
#endif
#endif
#endif
#ifndef UNIX64
#define IPS64CAST
#else
#define IPS64CAST (ns_int64)
#endif
typedef int (IPWORKSSSL_CALL *PIPWORKSSSL_CALLBACK)
(void *lpObj, int event_id, int cparam, void *param[], int cbparam[]);
#ifndef IPWORKSSSL_ONLY_TYPES
#ifdef WIN32
#include "atoms.h"
#include "caldavs.h"
#include "certmgr.h"
#include "filemailers.h"
#include "ftps.h"
#include "htmlmailers.h"
#include "https.h"
#include "imaps.h"
#include "ipdaemons.h"
#include "ipports.h"
#include "jsons.h"
#include "ldaps.h"
#include "nntps.h"
#include "oauth.h"
#include "odatas.h"
#include "pops.h"
#include "rests.h"
#include "rsss.h"
#include "smpps.h"
#include "smtps.h"
#include "snpps.h"
#include "soaps.h"
#include "telnets.h"
#include "webdavs.h"
#include "webforms.h"
#include "webuploads.h"
#include "xmpps.h"
#else //UNIX
#include "atoms.h"
#include "caldavs.h"
#include "certmgr.h"
#include "filemailers.h"
#include "ftps.h"
#include "htmlmailers.h"
#include "https.h"
#include "imaps.h"
#include "ipdaemons.h"
#include "ipports.h"
#include "jsons.h"
#include "ldaps.h"
#include "nntps.h"
#include "oauth.h"
#include "odatas.h"
#include "pops.h"
#include "rests.h"
#include "rsss.h"
#include "smpps.h"
#include "smtps.h"
#include "snpps.h"
#include "soaps.h"
#include "telnets.h"
#include "webdavs.h"
#include "webforms.h"
#include "webuploads.h"
#include "xmpps.h"
#endif
#endif //IPWORKSSSL_ONLY_TYPES
#endif //_IPWORKSSSL_H_
And the included HTTPS.h file:
/******************************************************************
IP*Works! SSL V9 C++ Edition
Copyright (c) 2015 /n software inc. - All rights reserved.
*******************************************************************/
#ifndef _IPWORKSSSL_HTTPS_H_
#define _IPWORKSSSL_HTTPS_H_
#define IPWORKSSSL_ONLY_TYPES
#include "ipworksssl.h"
#include "ipworksssl.key"
//AuthSchemes
#define AUTH_BASIC 0
#define AUTH_DIGEST 1
#define AUTH_PROPRIETARY 2
#define AUTH_NONE 3
#define AUTH_NTLM 4
#define AUTH_NEGOTIATE 5
#define AUTH_OAUTH 6
//FirewallTypes
#define FW_NONE 0
#define FW_TUNNEL 1
#define FW_SOCKS4 2
#define FW_SOCKS5 3
//TFollowRedirects
#define FR_NEVER 0
#define FR_ALWAYS 1
#define FR_SAME_SCHEME 2
//ProxySSLTypes
#define PS_AUTOMATIC 0
#define PS_ALWAYS 1
#define PS_NEVER 2
#define PS_TUNNEL 3
//CertStoreTypes
#define CST_USER 0
#define CST_MACHINE 1
#define CST_PFXFILE 2
#define CST_PFXBLOB 3
#define CST_JKSFILE 4
#define CST_JKSBLOB 5
#define CST_PEMKEY_FILE 6
#define CST_PEMKEY_BLOB 7
#define CST_PUBLIC_KEY_FILE 8
#define CST_PUBLIC_KEY_BLOB 9
#define CST_SSHPUBLIC_KEY_BLOB 10
#define CST_P7BFILE 11
#define CST_P7BBLOB 12
#define CST_SSHPUBLIC_KEY_FILE 13
#define CST_PPKFILE 14
#define CST_PPKBLOB 15
#define CST_XMLFILE 16
#define CST_XMLBLOB 17
extern "C" void* IPWORKSSSL_CALL IPWorksSSL_HTTPS_Create(PIPWORKSSSL_CALLBACK lpSink, void *lpContext, char *lpOemKey);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_Destroy(void *lpObj);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_CheckIndex(void *lpObj, int propid, int arridx);
extern "C" void* IPWORKSSSL_CALL IPWorksSSL_HTTPS_Get(void *lpObj, int propid, int arridx, int *lpcbVal);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_Set(void *lpObj, int propid, int arridx, const void *val, int cbVal);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_Do(void *lpObj, int methid, int cparam, void *param[], int cbparam[]);
extern "C" char* IPWORKSSSL_CALL IPWorksSSL_HTTPS_GetLastError(void *lpObj);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_GetLastErrorCode(void *lpObj);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_StaticInit(void *hInst);
extern "C" int IPWORKSSSL_CALL IPWorksSSL_HTTPS_StaticDestroy();
#ifdef WIN32
#include <windows.h>
#pragma warning(disable:4311)
#pragma warning(disable:4312)
#endif
typedef struct {
int StatusCode;
const char* Description;
int reserved;
} HTTPSConnectedEventParams;
typedef struct {
const char* ConnectionEvent;
int StatusCode;
const char* Description;
int reserved;
} HTTPSConnectionStatusEventParams;
typedef struct {
int StatusCode;
const char* Description;
int reserved;
} HTTPSDisconnectedEventParams;
typedef struct {
int Direction;
int reserved;
} HTTPSEndTransferEventParams;
typedef struct {
int ErrorCode;
const char* Description;
int reserved;
} HTTPSErrorEventParams;
typedef struct {
const char* Field;
const char* Value;
int reserved;
} HTTPSHeaderEventParams;
typedef struct {
const char* Location;
int Accept;
int reserved;
} HTTPSRedirectEventParams;
typedef struct {
const char* Name;
const char* Value;
const char* Expires;
const char* Domain;
const char* Path;
int Secure;
int reserved;
} HTTPSSetCookieEventParams;
typedef struct {
const char* CertEncoded;
const char* CertSubject;
const char* CertIssuer;
const char* Status;
int Accept;
int lenCertEncoded;
int reserved;
} HTTPSSSLServerAuthenticationEventParams;
typedef struct {
const char* Message;
int reserved;
} HTTPSSSLStatusEventParams;
typedef struct {
int Direction;
int reserved;
} HTTPSStartTransferEventParams;
typedef struct {
const char* HTTPVersion;
int StatusCode;
const char* Description;
int reserved;
} HTTPSStatusEventParams;
typedef struct {
int Direction;
ns_int64 *pBytesTransferred;
int PercentDone;
const char* Text;
int lenText;
int reserved;
} HTTPSTransferEventParams;
class HTTPS {
public: //events
virtual int FireConnected(HTTPSConnectedEventParams *e) {return 0;}
virtual int FireConnectionStatus(HTTPSConnectionStatusEventParams *e) {return 0;}
virtual int FireDisconnected(HTTPSDisconnectedEventParams *e) {return 0;}
virtual int FireEndTransfer(HTTPSEndTransferEventParams *e) {return 0;}
virtual int FireError(HTTPSErrorEventParams *e) {return 0;}
virtual int FireHeader(HTTPSHeaderEventParams *e) {return 0;}
virtual int FireRedirect(HTTPSRedirectEventParams *e) {return 0;}
virtual int FireSetCookie(HTTPSSetCookieEventParams *e) {return 0;}
virtual int FireSSLServerAuthentication(HTTPSSSLServerAuthenticationEventParams *e) {return 0;}
virtual int FireSSLStatus(HTTPSSSLStatusEventParams *e) {return 0;}
virtual int FireStartTransfer(HTTPSStartTransferEventParams *e) {return 0;}
virtual int FireStatus(HTTPSStatusEventParams *e) {return 0;}
virtual int FireTransfer(HTTPSTransferEventParams *e) {return 0;}
protected:
void *m_pObj;
static int IPWORKSSSL_CALL HTTPSEventSink(void *lpObj, int event_id, int cparam, void *param[], int cbparam[]) {
int ret_code = 0;
if (event_id > 10000) return ((HTTPS*)lpObj)->HTTPSEventSinkW(event_id - 10000, cparam, param, cbparam);
switch (event_id) {
case 1: {
HTTPSConnectedEventParams e = {(int)IPS64CAST(param[0]), (char*)IPS64CAST(param[1]), 0};
ret_code = ((HTTPS*)lpObj)->FireConnected(&e);
break;
}
case 2: {
HTTPSConnectionStatusEventParams e = {(char*)IPS64CAST(param[0]), (int)IPS64CAST(param[1]), (char*)IPS64CAST(param[2]), 0};
ret_code = ((HTTPS*)lpObj)->FireConnectionStatus(&e);
break;
}
case 3: {
HTTPSDisconnectedEventParams e = {(int)IPS64CAST(param[0]), (char*)IPS64CAST(param[1]), 0};
ret_code = ((HTTPS*)lpObj)->FireDisconnected(&e);
break;
}
case 4: {
HTTPSEndTransferEventParams e = {(int)IPS64CAST(param[0]), 0};
ret_code = ((HTTPS*)lpObj)->FireEndTransfer(&e);
break;
}
case 5: {
HTTPSErrorEventParams e = {(int)IPS64CAST(param[0]), (char*)IPS64CAST(param[1]), 0};
ret_code = ((HTTPS*)lpObj)->FireError(&e);
break;
}
case 6: {
HTTPSHeaderEventParams e = {(char*)IPS64CAST(param[0]), (char*)IPS64CAST(param[1]), 0};
ret_code = ((HTTPS*)lpObj)->FireHeader(&e);
break;
}
case 7: {
HTTPSRedirectEventParams e = {(char*)IPS64CAST(param[0]), (int)IPS64CAST(param[1]), 0};
ret_code = ((HTTPS*)lpObj)->FireRedirect(&e);
param[1] = (void*)IPS64CAST(e.Accept);
break;
}
case 8: {
HTTPSSetCookieEventParams e = {(char*)IPS64CAST(param[0]), (char*)IPS64CAST(param[1]), (char*)IPS64CAST(param[2]), (char*)IPS64CAST(param[3]), (char*)IPS64CAST(param[4]), (int)IPS64CAST(param[5]), 0};
ret_code = ((HTTPS*)lpObj)->FireSetCookie(&e);
break;
}
case 9: {
HTTPSSSLServerAuthenticationEventParams e = {(char*)IPS64CAST(param[0]), (char*)IPS64CAST(param[1]), (char*)IPS64CAST(param[2]), (char*)IPS64CAST(param[3]), (int)IPS64CAST(param[4]), (int)IPS64CAST(cbparam[0]), 0};
ret_code = ((HTTPS*)lpObj)->FireSSLServerAuthentication(&e);
param[4] = (void*)IPS64CAST(e.Accept);
break;
}
case 10: {
HTTPSSSLStatusEventParams e = {(char*)IPS64CAST(param[0]), 0};
ret_code = ((HTTPS*)lpObj)->FireSSLStatus(&e);
break;
}
case 11: {
HTTPSStartTransferEventParams e = {(int)IPS64CAST(param[0]), 0};
ret_code = ((HTTPS*)lpObj)->FireStartTransfer(&e);
break;
}
case 12: {
HTTPSStatusEventParams e = {(char*)IPS64CAST(param[0]), (int)IPS64CAST(param[1]), (char*)IPS64CAST(param[2]), 0};
ret_code = ((HTTPS*)lpObj)->FireStatus(&e);
break;
}
case 13: {
HTTPSTransferEventParams e = {(int)IPS64CAST(param[0]), (ns_int64*)IPS64CAST(param[1]), (int)IPS64CAST(param[2]), (char*)IPS64CAST(param[3]), (int)IPS64CAST(cbparam[3]), 0};
ret_code = ((HTTPS*)lpObj)->FireTransfer(&e);
break;
}
}
return ret_code;
}
virtual int HTTPSEventSinkW(int event_id, int cparam, void *param[], int cbparam[]) {return 0;}
public:
HTTPS(char *lpOemKey = (char*)IPWORKSSSL_OEMKEY_18) {
m_pObj = IPWorksSSL_HTTPS_Create(HTTPSEventSink, (void*)this, (char*)lpOemKey);
}
virtual ~HTTPS() {
IPWorksSSL_HTTPS_Destroy(m_pObj);
}
public:
inline char *GetLastError() {
return IPWorksSSL_HTTPS_GetLastError(m_pObj);
}
inline int GetLastErrorCode() {
return IPWorksSSL_HTTPS_GetLastErrorCode(m_pObj);
}
inline char *VERSION() {
return (char*)IPWorksSSL_HTTPS_Get(m_pObj, 0, 0, 0);
}
public: //properties
inline char* GetAccept() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 1, 0, 0);
return (char*)val;
}
inline int SetAccept(const char *lpAccept) {
return IPWorksSSL_HTTPS_Set(m_pObj, 1, 0, (void*)lpAccept, 0);
}
inline int GetAllowHTTPCompression() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 2, 0, 0);
return (int)(long)val;
}
inline int SetAllowHTTPCompression(int bAllowHTTPCompression) {
void* val = (void*)IPS64CAST(bAllowHTTPCompression);
return IPWorksSSL_HTTPS_Set(m_pObj, 2, 0, val, 0);
}
inline char* GetAttachedFile() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 3, 0, 0);
return (char*)val;
}
inline int SetAttachedFile(const char *lpAttachedFile) {
return IPWorksSSL_HTTPS_Set(m_pObj, 3, 0, (void*)lpAttachedFile, 0);
}
inline char* GetAuthorization() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 4, 0, 0);
return (char*)val;
}
inline int SetAuthorization(const char *lpAuthorization) {
return IPWorksSSL_HTTPS_Set(m_pObj, 4, 0, (void*)lpAuthorization, 0);
}
inline int GetAuthScheme() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 5, 0, 0);
return (int)(long)val;
}
inline int SetAuthScheme(int iAuthScheme) {
void* val = (void*)IPS64CAST(iAuthScheme);
return IPWorksSSL_HTTPS_Set(m_pObj, 5, 0, val, 0);
}
inline int GetConnected() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 6, 0, 0);
return (int)(long)val;
}
inline int SetConnected(int bConnected) {
void* val = (void*)IPS64CAST(bConnected);
return IPWorksSSL_HTTPS_Set(m_pObj, 6, 0, val, 0);
}
inline char* GetContentType() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 7, 0, 0);
return (char*)val;
}
inline int SetContentType(const char *lpContentType) {
return IPWorksSSL_HTTPS_Set(m_pObj, 7, 0, (void*)lpContentType, 0);
}
inline int GetCookieCount() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 8, 0, 0);
return (int)(long)val;
}
inline int SetCookieCount(int iCookieCount) {
void* val = (void*)IPS64CAST(iCookieCount);
return IPWorksSSL_HTTPS_Set(m_pObj, 8, 0, val, 0);
}
inline char* GetCookieDomain(int iCookieIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 9, iCookieIndex, 0);
return (char*)val;
}
inline char* GetCookieExpiration(int iCookieIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 10, iCookieIndex, 0);
return (char*)val;
}
inline char* GetCookieName(int iCookieIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 11, iCookieIndex, 0);
return (char*)val;
}
inline int SetCookieName(int iCookieIndex, const char *lpCookieName) {
return IPWorksSSL_HTTPS_Set(m_pObj, 11, iCookieIndex, (void*)lpCookieName, 0);
}
inline char* GetCookiePath(int iCookieIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 12, iCookieIndex, 0);
return (char*)val;
}
inline int GetCookieSecure(int iCookieIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 13, iCookieIndex, 0);
return (int)(long)val;
}
inline char* GetCookieValue(int iCookieIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 14, iCookieIndex, 0);
return (char*)val;
}
inline int SetCookieValue(int iCookieIndex, const char *lpCookieValue) {
return IPWorksSSL_HTTPS_Set(m_pObj, 14, iCookieIndex, (void*)lpCookieValue, 0);
}
inline int GetFirewallAutoDetect() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 15, 0, 0);
return (int)(long)val;
}
inline int SetFirewallAutoDetect(int bFirewallAutoDetect) {
void* val = (void*)IPS64CAST(bFirewallAutoDetect);
return IPWorksSSL_HTTPS_Set(m_pObj, 15, 0, val, 0);
}
inline int GetFirewallType() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 16, 0, 0);
return (int)(long)val;
}
inline int SetFirewallType(int iFirewallType) {
void* val = (void*)IPS64CAST(iFirewallType);
return IPWorksSSL_HTTPS_Set(m_pObj, 16, 0, val, 0);
}
inline char* GetFirewallHost() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 17, 0, 0);
return (char*)val;
}
inline int SetFirewallHost(const char *lpFirewallHost) {
return IPWorksSSL_HTTPS_Set(m_pObj, 17, 0, (void*)lpFirewallHost, 0);
}
inline char* GetFirewallPassword() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 18, 0, 0);
return (char*)val;
}
inline int SetFirewallPassword(const char *lpFirewallPassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 18, 0, (void*)lpFirewallPassword, 0);
}
inline int GetFirewallPort() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 19, 0, 0);
return (int)(long)val;
}
inline int SetFirewallPort(int lFirewallPort) {
void* val = (void*)IPS64CAST(lFirewallPort);
return IPWorksSSL_HTTPS_Set(m_pObj, 19, 0, val, 0);
}
inline char* GetFirewallUser() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 20, 0, 0);
return (char*)val;
}
inline int SetFirewallUser(const char *lpFirewallUser) {
return IPWorksSSL_HTTPS_Set(m_pObj, 20, 0, (void*)lpFirewallUser, 0);
}
inline int GetFollowRedirects() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 21, 0, 0);
return (int)(long)val;
}
inline int SetFollowRedirects(int iFollowRedirects) {
void* val = (void*)IPS64CAST(iFollowRedirects);
return IPWorksSSL_HTTPS_Set(m_pObj, 21, 0, val, 0);
}
inline char* GetFrom() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 22, 0, 0);
return (char*)val;
}
inline int SetFrom(const char *lpFrom) {
return IPWorksSSL_HTTPS_Set(m_pObj, 22, 0, (void*)lpFrom, 0);
}
inline char* GetHTTPMethod() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 23, 0, 0);
return (char*)val;
}
inline int SetHTTPMethod(const char *lpHTTPMethod) {
return IPWorksSSL_HTTPS_Set(m_pObj, 23, 0, (void*)lpHTTPMethod, 0);
}
inline int GetIdle() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 24, 0, 0);
return (int)(long)val;
}
inline char* GetIfModifiedSince() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 25, 0, 0);
return (char*)val;
}
inline int SetIfModifiedSince(const char *lpIfModifiedSince) {
return IPWorksSSL_HTTPS_Set(m_pObj, 25, 0, (void*)lpIfModifiedSince, 0);
}
inline char* GetLocalFile() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 26, 0, 0);
return (char*)val;
}
inline int SetLocalFile(const char *lpLocalFile) {
return IPWorksSSL_HTTPS_Set(m_pObj, 26, 0, (void*)lpLocalFile, 0);
}
inline char* GetLocalHost() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 27, 0, 0);
return (char*)val;
}
inline int SetLocalHost(const char *lpLocalHost) {
return IPWorksSSL_HTTPS_Set(m_pObj, 27, 0, (void*)lpLocalHost, 0);
}
inline char* GetOtherHeaders() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 28, 0, 0);
return (char*)val;
}
inline int SetOtherHeaders(const char *lpOtherHeaders) {
return IPWorksSSL_HTTPS_Set(m_pObj, 28, 0, (void*)lpOtherHeaders, 0);
}
inline int GetParsedHeaderCount() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 29, 0, 0);
return (int)(long)val;
}
inline char* GetParsedHeaderField(int iParsedHeaderIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 30, iParsedHeaderIndex, 0);
return (char*)val;
}
inline char* GetParsedHeaderValue(int iParsedHeaderIndex) {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 31, iParsedHeaderIndex, 0);
return (char*)val;
}
inline char* GetPassword() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 32, 0, 0);
return (char*)val;
}
inline int SetPassword(const char *lpPassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 32, 0, (void*)lpPassword, 0);
}
inline int GetPostData(char *&lpPostData, int &lenPostData) {
lpPostData = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 33, 0, &lenPostData);
return lpPostData ? 0 : lenPostData;
}
inline int SetPostData(const char *lpPostData, int lenPostData) {
return IPWorksSSL_HTTPS_Set(m_pObj, 33, 0, (void*)lpPostData, lenPostData);
}
inline char* GetPragma() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 34, 0, 0);
return (char*)val;
}
inline int SetPragma(const char *lpPragma) {
return IPWorksSSL_HTTPS_Set(m_pObj, 34, 0, (void*)lpPragma, 0);
}
inline int GetProxyAuthScheme() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 35, 0, 0);
return (int)(long)val;
}
inline int SetProxyAuthScheme(int iProxyAuthScheme) {
void* val = (void*)IPS64CAST(iProxyAuthScheme);
return IPWorksSSL_HTTPS_Set(m_pObj, 35, 0, val, 0);
}
inline int GetProxyAutoDetect() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 36, 0, 0);
return (int)(long)val;
}
inline int SetProxyAutoDetect(int bProxyAutoDetect) {
void* val = (void*)IPS64CAST(bProxyAutoDetect);
return IPWorksSSL_HTTPS_Set(m_pObj, 36, 0, val, 0);
}
inline char* GetProxyPassword() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 37, 0, 0);
return (char*)val;
}
inline int SetProxyPassword(const char *lpProxyPassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 37, 0, (void*)lpProxyPassword, 0);
}
inline int GetProxyPort() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 38, 0, 0);
return (int)(long)val;
}
inline int SetProxyPort(int lProxyPort) {
void* val = (void*)IPS64CAST(lProxyPort);
return IPWorksSSL_HTTPS_Set(m_pObj, 38, 0, val, 0);
}
inline char* GetProxyServer() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 39, 0, 0);
return (char*)val;
}
inline int SetProxyServer(const char *lpProxyServer) {
return IPWorksSSL_HTTPS_Set(m_pObj, 39, 0, (void*)lpProxyServer, 0);
}
inline int GetProxySSL() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 40, 0, 0);
return (int)(long)val;
}
inline int SetProxySSL(int iProxySSL) {
void* val = (void*)IPS64CAST(iProxySSL);
return IPWorksSSL_HTTPS_Set(m_pObj, 40, 0, val, 0);
}
inline char* GetProxyUser() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 41, 0, 0);
return (char*)val;
}
inline int SetProxyUser(const char *lpProxyUser) {
return IPWorksSSL_HTTPS_Set(m_pObj, 41, 0, (void*)lpProxyUser, 0);
}
inline char* GetRange() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 42, 0, 0);
return (char*)val;
}
inline int SetRange(const char *lpRange) {
return IPWorksSSL_HTTPS_Set(m_pObj, 42, 0, (void*)lpRange, 0);
}
inline char* GetReferer() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 43, 0, 0);
return (char*)val;
}
inline int SetReferer(const char *lpReferer) {
return IPWorksSSL_HTTPS_Set(m_pObj, 43, 0, (void*)lpReferer, 0);
}
inline int GetSSLAcceptServerCertEncoded(char *&lpSSLAcceptServerCertEncoded, int &lenSSLAcceptServerCertEncoded) {
lpSSLAcceptServerCertEncoded = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 44, 0, &lenSSLAcceptServerCertEncoded);
return lpSSLAcceptServerCertEncoded ? 0 : lenSSLAcceptServerCertEncoded;
}
inline int SetSSLAcceptServerCertEncoded(const char *lpSSLAcceptServerCertEncoded, int lenSSLAcceptServerCertEncoded) {
return IPWorksSSL_HTTPS_Set(m_pObj, 44, 0, (void*)lpSSLAcceptServerCertEncoded, lenSSLAcceptServerCertEncoded);
}
inline int GetSSLCertEncoded(char *&lpSSLCertEncoded, int &lenSSLCertEncoded) {
lpSSLCertEncoded = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 45, 0, &lenSSLCertEncoded);
return lpSSLCertEncoded ? 0 : lenSSLCertEncoded;
}
inline int SetSSLCertEncoded(const char *lpSSLCertEncoded, int lenSSLCertEncoded) {
return IPWorksSSL_HTTPS_Set(m_pObj, 45, 0, (void*)lpSSLCertEncoded, lenSSLCertEncoded);
}
inline int GetSSLCertStore(char *&lpSSLCertStore, int &lenSSLCertStore) {
lpSSLCertStore = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 46, 0, &lenSSLCertStore);
return lpSSLCertStore ? 0 : lenSSLCertStore;
}
inline int SetSSLCertStore(const char *lpSSLCertStore, int lenSSLCertStore) {
return IPWorksSSL_HTTPS_Set(m_pObj, 46, 0, (void*)lpSSLCertStore, lenSSLCertStore);
}
inline char* GetSSLCertStorePassword() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 47, 0, 0);
return (char*)val;
}
inline int SetSSLCertStorePassword(const char *lpSSLCertStorePassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 47, 0, (void*)lpSSLCertStorePassword, 0);
}
inline int GetSSLCertStoreType() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 48, 0, 0);
return (int)(long)val;
}
inline int SetSSLCertStoreType(int iSSLCertStoreType) {
void* val = (void*)IPS64CAST(iSSLCertStoreType);
return IPWorksSSL_HTTPS_Set(m_pObj, 48, 0, val, 0);
}
inline char* GetSSLCertSubject() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 49, 0, 0);
return (char*)val;
}
inline int SetSSLCertSubject(const char *lpSSLCertSubject) {
return IPWorksSSL_HTTPS_Set(m_pObj, 49, 0, (void*)lpSSLCertSubject, 0);
}
inline int GetSSLServerCertEncoded(char *&lpSSLServerCertEncoded, int &lenSSLServerCertEncoded) {
lpSSLServerCertEncoded = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 50, 0, &lenSSLServerCertEncoded);
return lpSSLServerCertEncoded ? 0 : lenSSLServerCertEncoded;
}
inline char* GetStatusLine() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 51, 0, 0);
return (char*)val;
}
inline int GetTimeout() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 52, 0, 0);
return (int)(long)val;
}
inline int SetTimeout(int iTimeout) {
void* val = (void*)IPS64CAST(iTimeout);
return IPWorksSSL_HTTPS_Set(m_pObj, 52, 0, val, 0);
}
inline int GetTransferredData(char *&lpTransferredData, int &lenTransferredData) {
lpTransferredData = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 53, 0, &lenTransferredData);
return lpTransferredData ? 0 : lenTransferredData;
}
inline ns_int64 GetTransferredDataLimit() {
ns_int64 *pval = (ns_int64*)IPWorksSSL_HTTPS_Get(m_pObj, 54, 0, 0);
return *pval;
}
inline int SetTransferredDataLimit(ns_int64 lTransferredDataLimit) {
void* val = (void*)(&lTransferredDataLimit);
return IPWorksSSL_HTTPS_Set(m_pObj, 54, 0, val, 0);
}
inline char* GetTransferredHeaders() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 55, 0, 0);
return (char*)val;
}
inline char* GetURL() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 56, 0, 0);
return (char*)val;
}
inline int SetURL(const char *lpURL) {
return IPWorksSSL_HTTPS_Set(m_pObj, 56, 0, (void*)lpURL, 0);
}
inline char* GetURLPath() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 57, 0, 0);
return (char*)val;
}
inline int SetURLPath(const char *lpURLPath) {
return IPWorksSSL_HTTPS_Set(m_pObj, 57, 0, (void*)lpURLPath, 0);
}
inline int GetURLPort() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 58, 0, 0);
return (int)(long)val;
}
inline int SetURLPort(int lURLPort) {
void* val = (void*)IPS64CAST(lURLPort);
return IPWorksSSL_HTTPS_Set(m_pObj, 58, 0, val, 0);
}
inline char* GetURLScheme() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 59, 0, 0);
return (char*)val;
}
inline int SetURLScheme(const char *lpURLScheme) {
return IPWorksSSL_HTTPS_Set(m_pObj, 59, 0, (void*)lpURLScheme, 0);
}
inline char* GetURLServer() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 60, 0, 0);
return (char*)val;
}
inline int SetURLServer(const char *lpURLServer) {
return IPWorksSSL_HTTPS_Set(m_pObj, 60, 0, (void*)lpURLServer, 0);
}
inline char* GetUser() {
void* val = IPWorksSSL_HTTPS_Get(m_pObj, 61, 0, 0);
return (char*)val;
}
inline int SetUser(const char *lpUser) {
return IPWorksSSL_HTTPS_Set(m_pObj, 61, 0, (void*)lpUser, 0);
}
public: //methods
inline int AddCookie(const char* lpszCookieName, const char* lpszCookieValue) {
void *param[2+1] = {(void*)IPS64CAST(lpszCookieName), (void*)IPS64CAST(lpszCookieValue), 0};
int cbparam[2+1] = {0, 0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 2, 2, param, cbparam);
}
inline char* Config(const char* lpszConfigurationString) {
void *param[1+1] = {(void*)IPS64CAST(lpszConfigurationString), 0};
int cbparam[1+1] = {0, 0};
IPWorksSSL_HTTPS_Do(m_pObj, 3, 1, param, cbparam);
return (char*)IPS64CAST(param[1]);
}
inline int Delete(const char* lpszURL) {
void *param[1+1] = {(void*)IPS64CAST(lpszURL), 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 4, 1, param, cbparam);
}
inline int DoEvents() {
void *param[0+1] = {0};
int cbparam[0+1] = {0};
return IPWorksSSL_HTTPS_Do(m_pObj, 5, 0, param, cbparam);
}
inline int Get(const char* lpszURL) {
void *param[1+1] = {(void*)IPS64CAST(lpszURL), 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 6, 1, param, cbparam);
}
inline int Head(const char* lpszURL) {
void *param[1+1] = {(void*)IPS64CAST(lpszURL), 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 7, 1, param, cbparam);
}
inline int Interrupt() {
void *param[0+1] = {0};
int cbparam[0+1] = {0};
return IPWorksSSL_HTTPS_Do(m_pObj, 8, 0, param, cbparam);
}
inline int Post(const char* lpszURL) {
void *param[1+1] = {(void*)IPS64CAST(lpszURL), 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 9, 1, param, cbparam);
}
inline int Put(const char* lpszURL) {
void *param[1+1] = {(void*)IPS64CAST(lpszURL), 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10, 1, param, cbparam);
}
inline int ResetHeaders() {
void *param[0+1] = {0};
int cbparam[0+1] = {0};
return IPWorksSSL_HTTPS_Do(m_pObj, 11, 0, param, cbparam);
}
};
#ifdef WIN32 //UNICODE
typedef struct {
int StatusCode;
LPWSTR Description;
int reserved;
} HTTPSConnectedEventParamsW;
typedef struct {
LPWSTR ConnectionEvent;
int StatusCode;
LPWSTR Description;
int reserved;
} HTTPSConnectionStatusEventParamsW;
typedef struct {
int StatusCode;
LPWSTR Description;
int reserved;
} HTTPSDisconnectedEventParamsW;
typedef struct {
int Direction;
int reserved;
} HTTPSEndTransferEventParamsW;
typedef struct {
int ErrorCode;
LPWSTR Description;
int reserved;
} HTTPSErrorEventParamsW;
typedef struct {
LPWSTR Field;
LPWSTR Value;
int reserved;
} HTTPSHeaderEventParamsW;
typedef struct {
LPWSTR Location;
int Accept;
int reserved;
} HTTPSRedirectEventParamsW;
typedef struct {
LPWSTR Name;
LPWSTR Value;
LPWSTR Expires;
LPWSTR Domain;
LPWSTR Path;
int Secure;
int reserved;
} HTTPSSetCookieEventParamsW;
typedef struct {
LPWSTR CertEncoded;
LPWSTR CertSubject;
LPWSTR CertIssuer;
LPWSTR Status;
int Accept;
int lenCertEncoded;
int reserved;
} HTTPSSSLServerAuthenticationEventParamsW;
typedef struct {
LPWSTR Message;
int reserved;
} HTTPSSSLStatusEventParamsW;
typedef struct {
int Direction;
int reserved;
} HTTPSStartTransferEventParamsW;
typedef struct {
LPWSTR HTTPVersion;
int StatusCode;
LPWSTR Description;
int reserved;
} HTTPSStatusEventParamsW;
typedef struct {
int Direction;
ns_int64 *pBytesTransferred;
int PercentDone;
LPWSTR Text;
int lenText;
int reserved;
} HTTPSTransferEventParamsW;
class HTTPSW : public HTTPS {
public: //properties
inline LPWSTR GetAccept() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+1, 0, 0);
}
inline int SetAccept(LPWSTR lpAccept) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+1, 0, (void*)lpAccept, 0);
}
inline LPWSTR GetAttachedFile() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+10000+3, 0, 0);
}
inline int SetAttachedFile(LPWSTR lpAttachedFile) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+10000+3, 0, (void*)lpAttachedFile, 0);
}
inline LPWSTR GetAuthorization() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+4, 0, 0);
}
inline int SetAuthorization(LPWSTR lpAuthorization) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+4, 0, (void*)lpAuthorization, 0);
}
inline LPWSTR GetContentType() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+7, 0, 0);
}
inline int SetContentType(LPWSTR lpContentType) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+7, 0, (void*)lpContentType, 0);
}
inline LPWSTR GetCookieDomain(int iCookieIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+9, iCookieIndex, 0);
}
inline LPWSTR GetCookieExpiration(int iCookieIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+10, iCookieIndex, 0);
}
inline LPWSTR GetCookieName(int iCookieIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+11, iCookieIndex, 0);
}
inline int SetCookieName(int iCookieIndex, LPWSTR lpCookieName) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+11, iCookieIndex, (void*)lpCookieName, 0);
}
inline LPWSTR GetCookiePath(int iCookieIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+12, iCookieIndex, 0);
}
inline LPWSTR GetCookieValue(int iCookieIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+14, iCookieIndex, 0);
}
inline int SetCookieValue(int iCookieIndex, LPWSTR lpCookieValue) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+14, iCookieIndex, (void*)lpCookieValue, 0);
}
inline LPWSTR GetFirewallHost() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+17, 0, 0);
}
inline int SetFirewallHost(LPWSTR lpFirewallHost) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+17, 0, (void*)lpFirewallHost, 0);
}
inline LPWSTR GetFirewallPassword() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+18, 0, 0);
}
inline int SetFirewallPassword(LPWSTR lpFirewallPassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+18, 0, (void*)lpFirewallPassword, 0);
}
inline LPWSTR GetFirewallUser() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+20, 0, 0);
}
inline int SetFirewallUser(LPWSTR lpFirewallUser) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+20, 0, (void*)lpFirewallUser, 0);
}
inline LPWSTR GetFrom() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+22, 0, 0);
}
inline int SetFrom(LPWSTR lpFrom) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+22, 0, (void*)lpFrom, 0);
}
inline LPWSTR GetHTTPMethod() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+23, 0, 0);
}
inline int SetHTTPMethod(LPWSTR lpHTTPMethod) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+23, 0, (void*)lpHTTPMethod, 0);
}
inline LPWSTR GetIfModifiedSince() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+25, 0, 0);
}
inline int SetIfModifiedSince(LPWSTR lpIfModifiedSince) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+25, 0, (void*)lpIfModifiedSince, 0);
}
inline LPWSTR GetLocalFile() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+10000+26, 0, 0);
}
inline int SetLocalFile(LPWSTR lpLocalFile) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+10000+26, 0, (void*)lpLocalFile, 0);
}
inline LPWSTR GetLocalHost() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+27, 0, 0);
}
inline int SetLocalHost(LPWSTR lpLocalHost) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+27, 0, (void*)lpLocalHost, 0);
}
inline LPWSTR GetOtherHeaders() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+28, 0, 0);
}
inline int SetOtherHeaders(LPWSTR lpOtherHeaders) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+28, 0, (void*)lpOtherHeaders, 0);
}
inline LPWSTR GetParsedHeaderField(int iParsedHeaderIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+30, iParsedHeaderIndex, 0);
}
inline LPWSTR GetParsedHeaderValue(int iParsedHeaderIndex) {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+31, iParsedHeaderIndex, 0);
}
inline LPWSTR GetPassword() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+32, 0, 0);
}
inline int SetPassword(LPWSTR lpPassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+32, 0, (void*)lpPassword, 0);
}
inline LPWSTR GetPostData() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+33, 0, 0);
}
inline int SetPostData(LPWSTR lpPostData) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+33, 0, (void*)lpPostData, 0);
}
inline int GetPostDataB(char *&lpPostData, int &lenPostData) {
lpPostData = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 33, 0, &lenPostData);
return lpPostData ? 0 : lenPostData;
}
inline int SetPostDataB(const char *lpPostData, int lenPostData) {
return IPWorksSSL_HTTPS_Set(m_pObj, 33, 0, (void*)lpPostData, lenPostData);
}
inline LPWSTR GetPragma() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+34, 0, 0);
}
inline int SetPragma(LPWSTR lpPragma) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+34, 0, (void*)lpPragma, 0);
}
inline LPWSTR GetProxyPassword() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+37, 0, 0);
}
inline int SetProxyPassword(LPWSTR lpProxyPassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+37, 0, (void*)lpProxyPassword, 0);
}
inline LPWSTR GetProxyServer() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+39, 0, 0);
}
inline int SetProxyServer(LPWSTR lpProxyServer) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+39, 0, (void*)lpProxyServer, 0);
}
inline LPWSTR GetProxyUser() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+41, 0, 0);
}
inline int SetProxyUser(LPWSTR lpProxyUser) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+41, 0, (void*)lpProxyUser, 0);
}
inline LPWSTR GetRange() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+42, 0, 0);
}
inline int SetRange(LPWSTR lpRange) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+42, 0, (void*)lpRange, 0);
}
inline LPWSTR GetReferer() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+43, 0, 0);
}
inline int SetReferer(LPWSTR lpReferer) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+43, 0, (void*)lpReferer, 0);
}
inline LPWSTR GetSSLAcceptServerCertEncoded() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+44, 0, 0);
}
inline int SetSSLAcceptServerCertEncoded(LPWSTR lpSSLAcceptServerCertEncoded) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+44, 0, (void*)lpSSLAcceptServerCertEncoded, 0);
}
inline int GetSSLAcceptServerCertEncodedB(char *&lpSSLAcceptServerCertEncoded, int &lenSSLAcceptServerCertEncoded) {
lpSSLAcceptServerCertEncoded = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 44, 0, &lenSSLAcceptServerCertEncoded);
return lpSSLAcceptServerCertEncoded ? 0 : lenSSLAcceptServerCertEncoded;
}
inline int SetSSLAcceptServerCertEncodedB(const char *lpSSLAcceptServerCertEncoded, int lenSSLAcceptServerCertEncoded) {
return IPWorksSSL_HTTPS_Set(m_pObj, 44, 0, (void*)lpSSLAcceptServerCertEncoded, lenSSLAcceptServerCertEncoded);
}
inline LPWSTR GetSSLCertEncoded() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+45, 0, 0);
}
inline int SetSSLCertEncoded(LPWSTR lpSSLCertEncoded) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+45, 0, (void*)lpSSLCertEncoded, 0);
}
inline int GetSSLCertEncodedB(char *&lpSSLCertEncoded, int &lenSSLCertEncoded) {
lpSSLCertEncoded = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 45, 0, &lenSSLCertEncoded);
return lpSSLCertEncoded ? 0 : lenSSLCertEncoded;
}
inline int SetSSLCertEncodedB(const char *lpSSLCertEncoded, int lenSSLCertEncoded) {
return IPWorksSSL_HTTPS_Set(m_pObj, 45, 0, (void*)lpSSLCertEncoded, lenSSLCertEncoded);
}
inline LPWSTR GetSSLCertStore() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+46, 0, 0);
}
inline int SetSSLCertStore(LPWSTR lpSSLCertStore) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+46, 0, (void*)lpSSLCertStore, 0);
}
inline int GetSSLCertStoreB(char *&lpSSLCertStore, int &lenSSLCertStore) {
lpSSLCertStore = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 46, 0, &lenSSLCertStore);
return lpSSLCertStore ? 0 : lenSSLCertStore;
}
inline int SetSSLCertStoreB(const char *lpSSLCertStore, int lenSSLCertStore) {
return IPWorksSSL_HTTPS_Set(m_pObj, 46, 0, (void*)lpSSLCertStore, lenSSLCertStore);
}
inline LPWSTR GetSSLCertStorePassword() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+47, 0, 0);
}
inline int SetSSLCertStorePassword(LPWSTR lpSSLCertStorePassword) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+47, 0, (void*)lpSSLCertStorePassword, 0);
}
inline LPWSTR GetSSLCertSubject() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+49, 0, 0);
}
inline int SetSSLCertSubject(LPWSTR lpSSLCertSubject) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+49, 0, (void*)lpSSLCertSubject, 0);
}
inline LPWSTR GetSSLServerCertEncoded() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+50, 0, 0);
}
inline int GetSSLServerCertEncodedB(char *&lpSSLServerCertEncoded, int &lenSSLServerCertEncoded) {
lpSSLServerCertEncoded = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 50, 0, &lenSSLServerCertEncoded);
return lpSSLServerCertEncoded ? 0 : lenSSLServerCertEncoded;
}
inline LPWSTR GetStatusLine() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+51, 0, 0);
}
inline LPWSTR GetTransferredData() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+53, 0, 0);
}
inline int GetTransferredDataB(char *&lpTransferredData, int &lenTransferredData) {
lpTransferredData = (char*)IPWorksSSL_HTTPS_Get(m_pObj, 53, 0, &lenTransferredData);
return lpTransferredData ? 0 : lenTransferredData;
}
inline LPWSTR GetTransferredHeaders() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+55, 0, 0);
}
inline LPWSTR GetURL() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+56, 0, 0);
}
inline int SetURL(LPWSTR lpURL) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+56, 0, (void*)lpURL, 0);
}
inline LPWSTR GetURLPath() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+57, 0, 0);
}
inline int SetURLPath(LPWSTR lpURLPath) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+57, 0, (void*)lpURLPath, 0);
}
inline LPWSTR GetURLScheme() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+59, 0, 0);
}
inline int SetURLScheme(LPWSTR lpURLScheme) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+59, 0, (void*)lpURLScheme, 0);
}
inline LPWSTR GetURLServer() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+60, 0, 0);
}
inline int SetURLServer(LPWSTR lpURLServer) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+60, 0, (void*)lpURLServer, 0);
}
inline LPWSTR GetUser() {
return (LPWSTR)IPWorksSSL_HTTPS_Get(m_pObj, 10000+61, 0, 0);
}
inline int SetUser(LPWSTR lpUser) {
return IPWorksSSL_HTTPS_Set(m_pObj, 10000+61, 0, (void*)lpUser, 0);
}
public: //events
virtual int FireConnected(HTTPSConnectedEventParamsW *e) {return 0;}
virtual int FireConnectionStatus(HTTPSConnectionStatusEventParamsW *e) {return 0;}
virtual int FireDisconnected(HTTPSDisconnectedEventParamsW *e) {return 0;}
virtual int FireEndTransfer(HTTPSEndTransferEventParamsW *e) {return 0;}
virtual int FireError(HTTPSErrorEventParamsW *e) {return 0;}
virtual int FireHeader(HTTPSHeaderEventParamsW *e) {return 0;}
virtual int FireRedirect(HTTPSRedirectEventParamsW *e) {return 0;}
virtual int FireSetCookie(HTTPSSetCookieEventParamsW *e) {return 0;}
virtual int FireSSLServerAuthentication(HTTPSSSLServerAuthenticationEventParamsW *e) {return 0;}
virtual int FireSSLStatus(HTTPSSSLStatusEventParamsW *e) {return 0;}
virtual int FireStartTransfer(HTTPSStartTransferEventParamsW *e) {return 0;}
virtual int FireStatus(HTTPSStatusEventParamsW *e) {return 0;}
virtual int FireTransfer(HTTPSTransferEventParamsW *e) {return 0;}
protected:
virtual int HTTPSEventSinkW(int event_id, int cparam, void *param[], int cbparam[]) {
int ret_code = 0;
switch (event_id) {
case 1: {
HTTPSConnectedEventParamsW e = {(int)IPS64CAST(param[0]), (LPWSTR)IPS64CAST(param[1]), 0};
ret_code = FireConnected(&e);
break;
}
case 2: {
HTTPSConnectionStatusEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), (int)IPS64CAST(param[1]), (LPWSTR)IPS64CAST(param[2]), 0};
ret_code = FireConnectionStatus(&e);
break;
}
case 3: {
HTTPSDisconnectedEventParamsW e = {(int)IPS64CAST(param[0]), (LPWSTR)IPS64CAST(param[1]), 0};
ret_code = FireDisconnected(&e);
break;
}
case 4: {
HTTPSEndTransferEventParamsW e = {(int)IPS64CAST(param[0]), 0};
ret_code = FireEndTransfer(&e);
break;
}
case 5: {
HTTPSErrorEventParamsW e = {(int)IPS64CAST(param[0]), (LPWSTR)IPS64CAST(param[1]), 0};
ret_code = FireError(&e);
break;
}
case 6: {
HTTPSHeaderEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), (LPWSTR)IPS64CAST(param[1]), 0};
ret_code = FireHeader(&e);
break;
}
case 7: {
HTTPSRedirectEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), (int)IPS64CAST(param[1]), 0};
ret_code = FireRedirect(&e);
param[1] = (void*)(e.Accept);
break;
}
case 8: {
HTTPSSetCookieEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), (LPWSTR)IPS64CAST(param[1]), (LPWSTR)IPS64CAST(param[2]), (LPWSTR)IPS64CAST(param[3]), (LPWSTR)IPS64CAST(param[4]), (int)IPS64CAST(param[5]), 0};
ret_code = FireSetCookie(&e);
break;
}
case 9: {
HTTPSSSLServerAuthenticationEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), (LPWSTR)IPS64CAST(param[1]), (LPWSTR)IPS64CAST(param[2]), (LPWSTR)IPS64CAST(param[3]), (int)IPS64CAST(param[4]), (int)IPS64CAST(cbparam[0]), 0};
ret_code = FireSSLServerAuthentication(&e);
param[4] = (void*)(e.Accept);
break;
}
case 10: {
HTTPSSSLStatusEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), 0};
ret_code = FireSSLStatus(&e);
break;
}
case 11: {
HTTPSStartTransferEventParamsW e = {(int)IPS64CAST(param[0]), 0};
ret_code = FireStartTransfer(&e);
break;
}
case 12: {
HTTPSStatusEventParamsW e = {(LPWSTR)IPS64CAST(param[0]), (int)IPS64CAST(param[1]), (LPWSTR)IPS64CAST(param[2]), 0};
ret_code = FireStatus(&e);
break;
}
case 13: {
HTTPSTransferEventParamsW e = {(int)IPS64CAST(param[0]), (ns_int64*)IPS64CAST(param[1]), (int)IPS64CAST(param[2]), (LPWSTR)IPS64CAST(param[3]), (int)IPS64CAST(cbparam[3]), 0};
ret_code = FireTransfer(&e);
break;
}
}
return ret_code;
}
public: //event overrides
virtual int FireConnected(HTTPSConnectedEventParams *e) {return -10000;}
virtual int FireConnectionStatus(HTTPSConnectionStatusEventParams *e) {return -10000;}
virtual int FireDisconnected(HTTPSDisconnectedEventParams *e) {return -10000;}
virtual int FireEndTransfer(HTTPSEndTransferEventParams *e) {return -10000;}
virtual int FireError(HTTPSErrorEventParams *e) {return -10000;}
virtual int FireHeader(HTTPSHeaderEventParams *e) {return -10000;}
virtual int FireRedirect(HTTPSRedirectEventParams *e) {return -10000;}
virtual int FireSetCookie(HTTPSSetCookieEventParams *e) {return -10000;}
virtual int FireSSLServerAuthentication(HTTPSSSLServerAuthenticationEventParams *e) {return -10000;}
virtual int FireSSLStatus(HTTPSSSLStatusEventParams *e) {return -10000;}
virtual int FireStartTransfer(HTTPSStartTransferEventParams *e) {return -10000;}
virtual int FireStatus(HTTPSStatusEventParams *e) {return -10000;}
virtual int FireTransfer(HTTPSTransferEventParams *e) {return -10000;}
public: //methods
inline int AddCookie(LPWSTR lpszCookieName, LPWSTR lpszCookieValue) {
void *param[2+1] = {(void*)lpszCookieName, (void*)lpszCookieValue, 0};
int cbparam[2+1] = {0, 0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+2, 2, param, cbparam);
}
inline LPWSTR Config(LPWSTR lpszConfigurationString) {
void *param[1+1] = {(void*)lpszConfigurationString, 0};
int cbparam[1+1] = {0, 0};
IPWorksSSL_HTTPS_Do(m_pObj, 10000+3, 1, param, cbparam);
return (LPWSTR)IPS64CAST(param[1]);
}
inline int Delete(LPWSTR lpszURL) {
void *param[1+1] = {(void*)lpszURL, 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+4, 1, param, cbparam);
}
inline int DoEvents() {
void *param[0+1] = {0};
int cbparam[0+1] = {0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+5, 0, param, cbparam);
}
inline int Get(LPWSTR lpszURL) {
void *param[1+1] = {(void*)lpszURL, 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+6, 1, param, cbparam);
}
inline int Head(LPWSTR lpszURL) {
void *param[1+1] = {(void*)lpszURL, 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+7, 1, param, cbparam);
}
inline int Interrupt() {
void *param[0+1] = {0};
int cbparam[0+1] = {0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+8, 0, param, cbparam);
}
inline int Post(LPWSTR lpszURL) {
void *param[1+1] = {(void*)lpszURL, 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+9, 1, param, cbparam);
}
inline int Put(LPWSTR lpszURL) {
void *param[1+1] = {(void*)lpszURL, 0};
int cbparam[1+1] = {0, 0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+10, 1, param, cbparam);
}
inline int ResetHeaders() {
void *param[0+1] = {0};
int cbparam[0+1] = {0};
return IPWorksSSL_HTTPS_Do(m_pObj, 10000+11, 0, param, cbparam);
}
};
#endif //WIN32
#endif //_IPWORKSSSL_HTTPS_H_
Re: nSoftware IP*Works Wrapper Paid Project
You can't do it via the c++ headers they're not following a virtual class pattern
Windows 11, Manjaro, Raspberry Pi OS