ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
+ CardDAV2 *ConnObject = new CardDAV2(AccountAddress.ToStdString(), AccountPort, AccountUsername.ToStdString(), AccountPassword.ToStdString(), AccountSSL, AccountPrefix.ToStdString(), AccountDir.ToStdString());
+ ConnObject->SetupConnectionObject();
+
ActivityListType.insert(std::make_pair(ActivityTaskID, 0));
ActivityListData.insert(std::make_pair(ActivityTaskID, TaskData));
ActivityListURL.insert(std::make_pair(ActivityTaskID, TaskURL));
ActivityListEditMode.insert(std::make_pair(ActivityTaskID, false));
ActivityListConn.insert(std::make_pair(ActivityTaskID, CardDAVConn));
+ ActivityListConnObject.insert(std::make_pair(ActivityTaskID, ConnObject));
ActivityListIndex.insert(std::make_pair(ActivityTaskID, itemindex));
ActivityListTaskDetail.insert(std::make_pair(ActivityTaskID, TaskDetail));
ActivityListAccount.insert(std::make_pair(ActivityTaskID, TaskAccount));
std::map<int,wxString>::iterator StringETagIter;
std::map<int,wxString>::iterator StringETagOrigIter;
std::map<int,CardDAV*>::iterator CardDAVIter;
+ std::map<int,ConnectionObject*>::iterator ConnObjectIter;
std::map<int,ActivityMgrAccountSettings>::iterator AccountSettingsIter;
std::map<int,long>::iterator LongIter;
bool TasksFoundProc = FALSE;
// Start the animation timer if it hasn't started.
CardDAVIter = ActivityListConn.find(iter->first);
+ ConnObjectIter = ActivityListConnObject.find(iter->first);
TypeIter = ActivityListType.find(iter->first);
StringETagIter = ActivityListETag.find(iter->first);
StringETagOrigIter = ActivityListETagOriginal.find(iter->first);
FullFilename = StringFullFilenameIter->second;
EditMode = ActivityListEditMode.find(iter->first)->second;
- bool KeepUpdating = TRUE;
+ bool KeepUpdating = true;
- while(KeepUpdating == TRUE){
+ while(KeepUpdating == true){
- bool ExitLoop = FALSE;
+ COConnectResult ConnectResponse = ConnObjectIter->second->Connect(false);
- while (ExitLoop == FALSE){
+ bool ExitLoop = false;
+
+ while (ExitLoop == false){
+
+ if (ConnObjectIter->second->SSLVerify() == COSSL_UNABLETOVERIFY){
+
+ frmMainPtrGet->PauseAllTimers();
+
+#if defined(__APPLE__)
+#elif defined(__WIN32__)
+#else
+
+ bool UsingSSLBypass = false;
+ int SSLResult = 0;
+
+ // Connect again and fetch SSL certificate information.
+
+ ConnObjectIter->second->BypassSSLVerification(true);
+
+ COConnectResult ConnectionSSLResult = ConnObjectIter->second->Connect(false);
+
+ ConnObjectIter->second->BypassSSLVerification(false);
+
+ SSLInvalidCertNotifObjString SSLICNProcData;
+
+ SSLCertCollectionString certcol = ConnObjectIter->second->BuildSSLCollection();
+
+ bool *PauseMode = new bool;
+ QRNotif qrn;
+
+ *PauseMode = TRUE;
+ qrn.QResponse = &SSLResult;
+ qrn.PausePtr = PauseMode;
+
+ SSLICNProcData.CertCollection = certcol;
+ SSLICNProcData.QRNotifData = &qrn;
+ SSLICNProcData.AccountName = AccountNameFriendly;
+
+ wxCommandEvent event(INVALIDSSLCERTSTRING);
+ event.SetClientData(&SSLICNProcData);
+ wxPostEvent(frmMainPtrGet, event);
+
+ while (*PauseMode == TRUE){
+ //nanosleep(&n1, &n2);
+ SleepFor(250000000);
+ }
+
+ // Process the response from the user.
+
+ if (SSLResult == 1){
+
+ // Accept the Certificate.
+
+ UsingSSLBypass = true;
+ ConnObjectIter->second->BypassSSLVerification(true);
+
+ COConnectResult TestConnectionResult = ConnObjectIter->second->Connect(true);
+ WriteServerCertificate(AccountDir, certcol);
+
+ ConnObjectIter->second->BypassSSLVerification(false);
+
+ } else if (SSLResult == 2){
+
+ // Reject the certificate, abort the task and mark as failed.
+
+ iter->second = 2;
+ break;
+
+ }
+
+#endif
+
+ frmMainPtrGet->ResumeAllTimers();
+ ExitLoop = true;
+
+ } else if (ConnectResponse == COCONNECT_AUTHFAIL){
+
+ ConnectResponse = ConnObjectIter->second->Connect(true);
+
+ if (ConnectResponse == COCONNECT_OK){
+
+ ExitLoop = true;
+ break;
+
+ } else {
+
+ ExitLoop = true;
+ iter->second = 2;
+ break;
+
+ }
+
+ } else if (ConnectResponse == COCONNECT_OK){
+
+ ConnectResponse = ConnObjectIter->second->Connect(true);
+
+ ExitLoop = true;
+ break;
+
+ } else {
+
+ ExitLoop = true;
+ iter->second = 2;
+ break;
+
+ }
+
+ }
+
+ if (iter->second == 2 || iter->second == 3 || iter->second == 4){
+ break;
+ }
+
+#if defined(__APPLE__)
+
+ frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
+
+#elif defined(__WIN32__)
+
+ frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
+
+#else
+
+ frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateData());
+
+#endif
+
+ COServerResponse AddContactResponse = ConnObjectIter->second->AddContact(StringURLIter->second.ToStdString(),
+ StringDataIter->second.ToStdString());
+
+ if (AddContactResponse.RequestResult != COREQUEST_OK){
+ iter->second = 2;
+ break;
+ }
+
+ /*while (ExitLoop == FALSE){
// Verify that we have a trusted SSL connection first.
event.SetClientData(&SSLICNProcData);
wxPostEvent(frmMainPtrGet, event);
- /*timespec n1, n2;
-
- // Fall asleep until we get an response.
-
- n1.tv_sec = 0;
- n1.tv_nsec = 250000000L;*/
-
while (*PauseMode == TRUE){
//nanosleep(&n1, &n2);
SleepFor(250000000);
// Add contact to the ETag DB.
ConnHandle.GetServerETagValueThread();
- ETagServer = ConnHandle.ETagValueResult();
+ ETagServer = ConnHandle.ETagValueResult();*/
+
+ // TODO: Get the entity tag for the new contact.
+
+
+
ETagDBPtr->AddETag(ContactFilename, ETagServer, ETagServer);
iter->second = 4;
}
+void frmActivityMgr::WriteServerCertificate(wxString AccountName, SSLCertCollectionString SSLCertInc){
+
+ wxString ServerCertFinal;
+
+ // Get the Cert section of the certificate and write it to the file.
+
+ ServerCertFinal = GetAccountDir(AccountName, TRUE);
+
+ wxFile CertFile;
+
+ std::map<int, SSLCertDataString>::iterator SSLCDIter = SSLCertInc.SSLCollection.find(0);
+ std::multimap<string,string>::iterator SSLDataIter = SSLCDIter->second.CertData.find("Cert");
+
+ CertFile.Open(ServerCertFinal, wxFile::write);
+
+ CertFile.Write(SSLDataIter->second, wxConvUTF8);
+ CertFile.Close();
+
+}
+
void frmActivityMgr::StartTimer(wxCommandEvent& event){
ActListProcTimer.Start(1000, FALSE);
#include "../common/dirs.h"
#include "../common/preferences.h"
#include "../common/sslcertstructs.h"
+#include "../connobject/ConnectionObject.h"
+#include "../carddav2/carddav2.h"
#if defined(__WIN32__)
#include "../common/win32ssl.h"
std::map<int,wxString> ActivityListFilename;
std::map<int,wxString> ActivityListFullFilename;
std::map<int,CardDAV*> ActivityListConn;
+ std::map<int,ConnectionObject*> ActivityListConnObject;
std::map<int,ActivityMgrAccountSettings> ActivityListAccSettings;
std::map<int,wxString> ActivityListETag;
std::map<int,wxString> ActivityListETagOriginal;
void ToggleConnectionStatus( wxCommandEvent& event );
void SleepMode( wxCommandEvent &event );
void WriteServerCertificate(wxString AccountName, SSLCertCollection SSLCertInc);
+ void WriteServerCertificate(wxString AccountName, SSLCertCollectionString SSLCertInc);
void UpdateStatusLabel( wxCommandEvent& event );
public:
/** Constructor */
}
CardDAV2::~CardDAV2(){
+
curl_easy_cleanup(ConnectionSession);
ConnectionSession = nullptr;
+
+ if (HeaderList != nullptr){
+ curl_slist_free_all(HeaderList);
+ HeaderList = nullptr;
+ }
+
}
#if defined(__APPLE__)
if (TestMode == true){
SessionResult = curl_easy_perform(ConnectionSession);
} else {
-
+ SessionResult = curl_easy_perform(ConnectionSession);
}
switch(SessionResult){
case CURLE_OK:
+ case CURLE_HTTP_RETURNED_ERROR:
SSLStatus = true;
SSLVerified = COSSL_VERIFIED;
ConnectResult = COCONNECT_OK;
ConnectResult = COCONNECT_OK;
AuthPassed = true;
ValidResponse = true;
- } else if (SessionResponseCode == 403){
+ } else if (SessionResponseCode == 401){
ConnectResult = COCONNECT_AUTHFAIL;
AuthPassed = false;
ValidResponse = true;
} else if (SessionResponseCode == 403){
AuthPassed = false;
ValidResponse = true;
- } else if (SessionResponseCode >= 200) {
+ } else if (SessionResponseCode >= 400) {
AuthPassed = false;
ValidResponse = true;
} else {
curl_easy_getinfo(ConnectionSession, CURLINFO_RESPONSE_CODE, &SessionResponseCode);
if (SessionResponseCode == 200 || SessionResponseCode == 207){
- //ConnectResult = COCONNECT_OK;
AuthPassed = true;
ValidResponse = true;
} else if (SessionResponseCode == 403){
- //ConnectResult = COCONNECT_AUTHFAIL;
AuthPassed = false;
ValidResponse = true;
- } else if (SessionResponseCode >= 200) {
- //ConnectResult = COCONNECT_INVALID;
+ } else if (SessionResponseCode >= 400) {
AuthPassed = false;
ValidResponse = true;
} else {
- //ConnectResult = COCONNECT_INVALID;
AuthPassed = false;
ValidResponse = false;
}
COServerResponse CardDAV2::AddContact(std::string Location, std::string Data){
+ // Check if authentication was successful, otherwise don't do anything.
+
+ COServerResponse ServerResponse;
+
+ if (AuthPassed == false){
+ ServerResponse.RequestResult = COREQUEST_ERROR_NOTCONNECTED;
+ ServerResponse.EntityTag = "";
+ ServerResponse.SessionCode = 0;
+ ServerResponse.ResultCode = 0;
+ ServerResponse.ResultMessage = "";
+ return ServerResponse;
+ }
+
+ ServerSSL ? SetupDefaultParametersSSL(true) : SetupDefaultParametersNonSSL(true);
+ ResetResults();
+
+ string ServerAddressURL = BuildURL(ServerPrefix + Location);
+ curl_easy_setopt(ConnectionSession, CURLOPT_URL, ServerAddressURL.c_str());
+ curl_easy_setopt(ConnectionSession, CURLOPT_CUSTOMREQUEST, "PUT");
+ curl_easy_setopt(ConnectionSession, CURLOPT_POSTFIELDS, Data.c_str());
+ curl_easy_setopt(ConnectionSession, CURLOPT_POSTFIELDSIZE, strlen(Data.c_str()));
+
+ HeaderList = curl_slist_append(HeaderList, "Content-Type: text/vcard; charset=utf-8");
+
+ curl_easy_setopt(ConnectionSession, CURLOPT_HTTPHEADER, HeaderList);
+
+ if (TestMode == true){
+ SessionResult = curl_easy_perform(ConnectionSession);
+ } else {
+ SessionResult = curl_easy_perform(ConnectionSession);
+ }
+
+ switch(SessionResult){
+ case CURLE_OK:
+ SSLStatus = true;
+ SSLVerified = COSSL_VERIFIED;
+ break;
+ case CURLE_SSL_CACERT:
+ case CURLE_SSL_CONNECT_ERROR:
+ SSLStatus = true;
+ SSLVerified = COSSL_UNABLETOVERIFY;
+ break;
+ default:
+ break;
+ };
+
+ long SessionResponseCode = 0;
+
+ curl_easy_getinfo(ConnectionSession, CURLINFO_RESPONSE_CODE, &SessionResponseCode);
+
+ if (SessionResponseCode == 200 || SessionResponseCode == 201 || SessionResponseCode == 204){
+ AuthPassed = true;
+ ValidResponse = true;
+ } else if (SessionResponseCode == 403){
+ AuthPassed = false;
+ ValidResponse = true;
+ } else if (SessionResponseCode >= 400){
+ AuthPassed = false;
+ ValidResponse = true;
+ } else {
+ AuthPassed = false;
+ ValidResponse = false;
+ }
+
+ if (ValidResponse == false && AuthPassed == false){
+ ServerResponse.RequestResult = COREQUEST_ERROR_SERVER;
+ ServerResponse.EntityTag = "";
+ ServerResponse.SessionCode = SessionResult;
+ ServerResponse.ResultCode = SessionResponseCode;
+ ServerResponse.ResultMessage = "";
+ return ServerResponse;
+ }
+
+ CanProcess = true;
+
+ ServerResponse.RequestResult = COREQUEST_OK;
+ ServerResponse.EntityTag = "";
+ ServerResponse.SessionCode = SessionResult;
+ ServerResponse.ResultCode = SessionResponseCode;
+ ServerResponse.ResultMessage = SessionErrorBuffer;
+ return ServerResponse;
+
}
COServerResponse CardDAV2::EditContact(std::string Location, std::string Data){
curl_easy_setopt(ConnectionSession, CURLOPT_WRITEHEADER, &PageHeader);
curl_easy_setopt(ConnectionSession, CURLOPT_NOSIGNAL, 1);
curl_easy_setopt(ConnectionSession, CURLOPT_CUSTOMREQUEST, "GET");
+ curl_easy_setopt(ConnectionSession, CURLOPT_HTTPHEADER, nullptr);
if (DoAuthentication == true){
curl_easy_setopt(ConnectionSession, CURLOPT_USERPWD, UsernamePassword.c_str());
curl_easy_setopt(ConnectionSession, CURLOPT_CERTINFO, 1);
curl_easy_setopt(ConnectionSession, CURLOPT_VERBOSE, 1);
curl_easy_setopt(ConnectionSession, CURLOPT_CUSTOMREQUEST, "GET");
+ curl_easy_setopt(ConnectionSession, CURLOPT_HTTPHEADER, nullptr);
if (DoAuthentication == true){
curl_easy_setopt(ConnectionSession, CURLOPT_USERPWD, UsernamePassword.c_str());
curl_easy_setopt(ConnectionSession, CURLOPT_SSL_VERIFYPEER, 1);
}
+ if (TestMode == false && ServerAccount.size() > 0){
+
+ // Check if the server certificate file exists.
+
+ string CertificateFilename = GetAccountDir(ServerAccount, true);
+
+ if (wxFile::Exists(CertificateFilename)){
+
+ curl_easy_setopt(ConnectionSession, CURLOPT_CAINFO, CertificateFilename.c_str());
+
+ }
+
+ }
+
}
string CardDAV2::BuildURL(string URI){
SessionErrorBuffer[0] = '\0';
PageData = "";
PageHeader = "";
+ if (HeaderList != nullptr){
+ curl_slist_free_all(HeaderList);
+ HeaderList = nullptr;
+ }
}
-vector<string> CardDAV2::GetDAVHeader(){
+string CardDAV2::GetETagHeader(){
// Go through each of the lines looking for the
// 'DAV:' section.
+ string HeaderName;
+ string HeaderValue;
+ bool FastForward = false;
+
+ for (int HeaderSeek = 0; HeaderSeek < PageHeader.size(); HeaderSeek++){
+
+ if (FastForward == true){
+
+ if (PageHeader[HeaderSeek] == '\n'){
+ FastForward = false;
+ }
+
+ continue;
+
+ }
+
+ try {
+ PageHeader.substr(HeaderSeek, 5) == "ETag:";
+ }
+
+ catch (const out_of_range &oor){
+ break;
+ }
+
+ if (PageHeader.substr(HeaderSeek, 5) == "ETag:"){
+
+ int CharacterSeek = 5;
+
+ while ((HeaderSeek + CharacterSeek) < PageHeader.size()){
+
+ if (PageHeader.substr((HeaderSeek + CharacterSeek), 2) == "\r\n"){
+ break;
+ }
+
+ HeaderValue += PageHeader.substr((HeaderSeek + CharacterSeek), 1);
+ CharacterSeek++;
+ }
+
+ break;
+
+ } else {
+
+ FastForward = true;
+ continue;
+
+ }
+
+ if (PageHeader[HeaderSeek] == '\n'){
+ HeaderName = "";
+ }
+
+ //HeaderName += PageHeader.substr(HeaderSeek, 1);
+
+ }
+
+ // Check for quotation marks at the start and end and strip
+ // them out.
+
+ if (HeaderValue.size() >= 2){
+
+ if (HeaderValue[0] == '"'){
+ HeaderValue.erase((HeaderValue.size() - 1));
+ HeaderValue.erase(0);
+ }
+
+ }
+
+ return HeaderValue;
+
+}
+
+vector<string> CardDAV2::GetDAVHeader(){
+
+ // Go through each of the lines looking for the
+ // 'DAV:' section.
string HeaderName;
string HeaderValue;
- bool DAVFound = false;
bool FastForward = false;
vector<string> DAVHeaderList;
#include "../connobject/ConnectionObject.h"
#include "../version.h"
#include "../common/sslcertstructs.h"
+#include "../common/dirs.h"
#include <curl/curl.h>
#include <wx/tokenzr.h>
+#include <wx/file.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
CURL *ConnectionSession = nullptr;
CURLcode SessionResult = CURLE_OK;
+ struct curl_slist *HeaderList = nullptr;
void SetupDefaultParametersNonSSL(bool DoAuthentication);
void SetupDefaultParametersSSL(bool DoAuthentication);
std::string BuildURL(std::string URI);
void ResetResults();
std::vector<std::string> GetDAVHeader();
+ std::string GetETagHeader();
std::string GetUserPrincipalURI();
std::string GetAddressBookHomeURI();
#include <string>
#include <vector>
#include <iostream>
+#include "../common/sslcertstructs.h"
enum COConnectResult {
COCONNECT_UNITTESTFAIL = -1,
virtual bool HasValidResponse() {};
virtual bool IsSelfSigned() {};
virtual std::string GetErrorMessage() {};
+
+ // OS specific functions.
+
+#if defined(__APPLE__)
+#elif defined(__WIN32__)
+#else
+ SSLCertCollectionString BuildSSLCollection() {};
+
+#endif
protected:
// Test Mode.
}
+void frmInvalidSSLCertificate::LoadData(SSLCertCollectionString CertDataInc,
+ wxString AccountNameInc)
+{
+
+ // Load the invalid SSL certificate dialog.
+
+ AccountName = AccountNameInc;
+ CertDataString = CertDataInc;
+
+ wxString SSLTextLabel;
+
+ SSLTextLabel.Append(wxString::Format(_("An invalid SSL certificate was received from the server for the '%s' account.\n\n"), AccountName));
+ SSLTextLabel.Append(_("Click on one of the following buttons:\n\n"));
+ SSLTextLabel.Append(_("- Accept to accept the SSL certificate for this session and future sessions until the certificate changes.\n"));
+ SSLTextLabel.Append(_("- Reject to not use this certificate and disconnect (you will be asked again on subsequent reconnections to the server).\n"));
+ SSLTextLabel.Append(_("- View Certificates to review the certificates that were received."));
+
+ lblSSLText->SetLabel(SSLTextLabel);
+
+}
+
void frmInvalidSSLCertificate::LoadDataNew(SSLCertCollection CertDataInc,
wxString DomainNameInc)
{
wxString AccountName;
};
+struct SSLInvalidCertNotifObjString{
+ SSLCertCollectionString CertCollection;
+ QRNotif *QRNotifData;
+ wxString AccountName;
+};
+
/** Implementing frmInvalidSSLCertificateADT */
class frmInvalidSSLCertificate : public frmInvalidSSLCertificateADT
{
/** Constructor */
frmInvalidSSLCertificate( wxWindow* parent );
void LoadData(SSLCertCollection CertDataInc, wxString AccountNameInc);
+ void LoadData(SSLCertCollectionString CertDataInc, wxString AccountNameInc);
void LoadDataNew(SSLCertCollection CertDataInc, wxString DomainNameInc);
void LoadDataNew(SSLCertCollectionString CertDataInc, std::string DomainNameInc);
int GetResult();
DEFINE_EVENT_TYPE(WINDOW_CLOSE);
DEFINE_EVENT_TYPE(CONNSTAT_UPDATE);
DEFINE_EVENT_TYPE(INVALIDSSLCERT);
+DEFINE_EVENT_TYPE(INVALIDSSLCERTSTRING);
DEFINE_EVENT_TYPE(GETSELECTEDLIST);
DEFINE_EVENT_TYPE(SYNCACCOUNT);
DEFINE_EVENT_TYPE(IMPORT_RESULTSSHOW);
EVT_COMMAND(wxID_ANY, WINDOW_CLOSE, frmMain::WindowDelete)
EVT_COMMAND(wxID_ANY, CONNSTAT_UPDATE, frmMain::UpdateConnectionStatus)
EVT_COMMAND(wxID_ANY, INVALIDSSLCERT, frmMain::InvalidSSLCertificate)
+EVT_COMMAND(wxID_ANY, INVALIDSSLCERTSTRING, frmMain::InvalidSSLCertificateString)
EVT_COMMAND(wxID_ANY, GETSELECTEDLIST, frmMain::GetSelectedList)
EVT_COMMAND(wxID_ANY, SYNCACCOUNT, frmMain::SyncAccount)
EVT_COMMAND(wxID_ANY, IMPORT_RESULTSSHOW, frmMain::ShowImportResults)
}
+void frmMain::InvalidSSLCertificateString( wxCommandEvent &event ){
+
+ // Display the form for showing an invalid SSL certificate.
+
+ frmInvalidSSLCertificate *frameISC = new frmInvalidSSLCertificate ( this );
+ SSLInvalidCertNotifObjString *SSLICNObj = (SSLInvalidCertNotifObjString*)event.GetClientData();
+ SSLCertCollectionString SSLCCData = SSLICNObj->CertCollection;
+ wxString AccountName = SSLICNObj->AccountName;
+ frameISC->LoadData(SSLCCData, AccountName);
+ frameISC->ShowModal();
+
+ int FinalConflictResult = frameISC->GetResult();
+
+ wxCommandEvent event2(ACTMGR_RESUMEPROC);
+ event2.SetClientData(SSLICNObj->QRNotifData);
+ event2.SetInt(FinalConflictResult);
+
+ delete frameISC;
+ frameISC = NULL;
+
+ frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
+ wxPostEvent(frameActMgr, event2);
+
+}
+
void frmMain::PauseAllTimers(){
// Pause all the account timers.
DECLARE_EVENT_TYPE(WINDOW_CLOSE, wxID_ANY);
DECLARE_EVENT_TYPE(CONNSTAT_UPDATE, wxID_ANY);
DECLARE_EVENT_TYPE(INVALIDSSLCERT, wxID_ANY);
+DECLARE_EVENT_TYPE(INVALIDSSLCERTSTRING, wxID_ANY);
DECLARE_EVENT_TYPE(GETSELECTEDLIST, wxID_ANY);
DECLARE_EVENT_TYPE(SYNCACCOUNT, wxID_ANY);
DECLARE_EVENT_TYPE(IMPORT_RESULTSSHOW, wxID_ANY);
void UpdateConnectionStatus( wxCommandEvent& event );
void SetupSSLStatus( int AccountID );
void InvalidSSLCertificate( wxCommandEvent& event );
+ void InvalidSSLCertificateString( wxCommandEvent& event );
void CheckUpdates( wxCommandEvent& event );
void OpenImportDialog( wxCommandEvent& event );
void OpenExportDialog( wxCommandEvent& event );
}
std::string ReceivedServerPrefix;
-
COServerResponse PrefixRequestResult = TestConnection.GetDefaultPrefix(&ReceivedServerPrefix);
-
+ ServerPrefix = ReceivedServerPrefix;
+
if (UsingSSLBypass == true){
TestConnection.BypassSSLVerification(true);
}
Home |
News |
Projects |
Releases
Bugs |
RFE |
Repositories |
Help
