1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change GetFileDetectResult Public.

Browse Source
This commit is contained in:
sdk-team
2022-08-16 13:57:05 +00:00
parent 6700b9eb65
commit e75a9596ef
44 changed files with 2775 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1225
1.36.1226

28
sas/CMakeLists.txt
View File

@@ -37,6 +37,12 @@ set(sas_public_header_model
include/alibabacloud/sas/model/CreateFileDetectResult.h
include/alibabacloud/sas/model/CreateFileDetectUploadUrlRequest.h
include/alibabacloud/sas/model/CreateFileDetectUploadUrlResult.h
include/alibabacloud/sas/model/CreateHoneypotRequest.h
include/alibabacloud/sas/model/CreateHoneypotResult.h
include/alibabacloud/sas/model/CreateHoneypotNodeRequest.h
include/alibabacloud/sas/model/CreateHoneypotNodeResult.h
include/alibabacloud/sas/model/CreateHoneypotProbeRequest.h
include/alibabacloud/sas/model/CreateHoneypotProbeResult.h
include/alibabacloud/sas/model/CreateOrUpdateAssetGroupRequest.h
include/alibabacloud/sas/model/CreateOrUpdateAssetGroupResult.h
include/alibabacloud/sas/model/CreateServiceLinkedRoleRequest.h
@@ -307,6 +313,8 @@ set(sas_public_header_model
include/alibabacloud/sas/model/DescribeWebLockBindListResult.h
include/alibabacloud/sas/model/DescribeWebLockConfigListRequest.h
include/alibabacloud/sas/model/DescribeWebLockConfigListResult.h
include/alibabacloud/sas/model/DescribeWebLockFileEventsRequest.h
include/alibabacloud/sas/model/DescribeWebLockFileEventsResult.h
include/alibabacloud/sas/model/ExportRecordRequest.h
include/alibabacloud/sas/model/ExportRecordResult.h
include/alibabacloud/sas/model/ExportVulRequest.h
@@ -339,6 +347,12 @@ set(sas_public_header_model
include/alibabacloud/sas/model/ListCheckInstanceResultResult.h
include/alibabacloud/sas/model/ListCheckResultRequest.h
include/alibabacloud/sas/model/ListCheckResultResult.h
include/alibabacloud/sas/model/ListHoneypotRequest.h
include/alibabacloud/sas/model/ListHoneypotResult.h
include/alibabacloud/sas/model/ListHoneypotAlarmEventsRequest.h
include/alibabacloud/sas/model/ListHoneypotAlarmEventsResult.h
include/alibabacloud/sas/model/ListHoneypotNodeRequest.h
include/alibabacloud/sas/model/ListHoneypotNodeResult.h
include/alibabacloud/sas/model/ListVulAutoRepairConfigRequest.h
include/alibabacloud/sas/model/ListVulAutoRepairConfigResult.h
include/alibabacloud/sas/model/ModifyAntiBruteForceRuleRequest.h
@@ -464,6 +478,12 @@ set(sas_src
src/model/CreateFileDetectResult.cc
src/model/CreateFileDetectUploadUrlRequest.cc
src/model/CreateFileDetectUploadUrlResult.cc
src/model/CreateHoneypotRequest.cc
src/model/CreateHoneypotResult.cc
src/model/CreateHoneypotNodeRequest.cc
src/model/CreateHoneypotNodeResult.cc
src/model/CreateHoneypotProbeRequest.cc
src/model/CreateHoneypotProbeResult.cc
src/model/CreateOrUpdateAssetGroupRequest.cc
src/model/CreateOrUpdateAssetGroupResult.cc
src/model/CreateServiceLinkedRoleRequest.cc
@@ -734,6 +754,8 @@ set(sas_src
src/model/DescribeWebLockBindListResult.cc
src/model/DescribeWebLockConfigListRequest.cc
src/model/DescribeWebLockConfigListResult.cc
src/model/DescribeWebLockFileEventsRequest.cc
src/model/DescribeWebLockFileEventsResult.cc
src/model/ExportRecordRequest.cc
src/model/ExportRecordResult.cc
src/model/ExportVulRequest.cc
@@ -766,6 +788,12 @@ set(sas_src
src/model/ListCheckInstanceResultResult.cc
src/model/ListCheckResultRequest.cc
src/model/ListCheckResultResult.cc
src/model/ListHoneypotRequest.cc
src/model/ListHoneypotResult.cc
src/model/ListHoneypotAlarmEventsRequest.cc
src/model/ListHoneypotAlarmEventsResult.cc
src/model/ListHoneypotNodeRequest.cc
src/model/ListHoneypotNodeResult.cc
src/model/ListVulAutoRepairConfigRequest.cc
src/model/ListVulAutoRepairConfigResult.cc
src/model/ModifyAntiBruteForceRuleRequest.cc

56
sas/include/alibabacloud/sas/SasClient.h
View File

@@ -38,6 +38,12 @@
#include "model/CreateFileDetectResult.h"
#include "model/CreateFileDetectUploadUrlRequest.h"
#include "model/CreateFileDetectUploadUrlResult.h"
#include "model/CreateHoneypotRequest.h"
#include "model/CreateHoneypotResult.h"
#include "model/CreateHoneypotNodeRequest.h"
#include "model/CreateHoneypotNodeResult.h"
#include "model/CreateHoneypotProbeRequest.h"
#include "model/CreateHoneypotProbeResult.h"
#include "model/CreateOrUpdateAssetGroupRequest.h"
#include "model/CreateOrUpdateAssetGroupResult.h"
#include "model/CreateServiceLinkedRoleRequest.h"
@@ -308,6 +314,8 @@
#include "model/DescribeWebLockBindListResult.h"
#include "model/DescribeWebLockConfigListRequest.h"
#include "model/DescribeWebLockConfigListResult.h"
#include "model/DescribeWebLockFileEventsRequest.h"
#include "model/DescribeWebLockFileEventsResult.h"
#include "model/ExportRecordRequest.h"
#include "model/ExportRecordResult.h"
#include "model/ExportVulRequest.h"
@@ -340,6 +348,12 @@
#include "model/ListCheckInstanceResultResult.h"
#include "model/ListCheckResultRequest.h"
#include "model/ListCheckResultResult.h"
#include "model/ListHoneypotRequest.h"
#include "model/ListHoneypotResult.h"
#include "model/ListHoneypotAlarmEventsRequest.h"
#include "model/ListHoneypotAlarmEventsResult.h"
#include "model/ListHoneypotNodeRequest.h"
#include "model/ListHoneypotNodeResult.h"
#include "model/ListVulAutoRepairConfigRequest.h"
#include "model/ListVulAutoRepairConfigResult.h"
#include "model/ModifyAntiBruteForceRuleRequest.h"
@@ -479,6 +493,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateFileDetectUploadUrlResult> CreateFileDetectUploadUrlOutcome;
typedef std::future<CreateFileDetectUploadUrlOutcome> CreateFileDetectUploadUrlOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::CreateFileDetectUploadUrlRequest&, const CreateFileDetectUploadUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFileDetectUploadUrlAsyncHandler;
typedef Outcome<Error, Model::CreateHoneypotResult> CreateHoneypotOutcome;
typedef std::future<CreateHoneypotOutcome> CreateHoneypotOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::CreateHoneypotRequest&, const CreateHoneypotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHoneypotAsyncHandler;
typedef Outcome<Error, Model::CreateHoneypotNodeResult> CreateHoneypotNodeOutcome;
typedef std::future<CreateHoneypotNodeOutcome> CreateHoneypotNodeOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::CreateHoneypotNodeRequest&, const CreateHoneypotNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHoneypotNodeAsyncHandler;
typedef Outcome<Error, Model::CreateHoneypotProbeResult> CreateHoneypotProbeOutcome;
typedef std::future<CreateHoneypotProbeOutcome> CreateHoneypotProbeOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::CreateHoneypotProbeRequest&, const CreateHoneypotProbeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHoneypotProbeAsyncHandler;
typedef Outcome<Error, Model::CreateOrUpdateAssetGroupResult> CreateOrUpdateAssetGroupOutcome;
typedef std::future<CreateOrUpdateAssetGroupOutcome> CreateOrUpdateAssetGroupOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::CreateOrUpdateAssetGroupRequest&, const CreateOrUpdateAssetGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOrUpdateAssetGroupAsyncHandler;
@@ -884,6 +907,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeWebLockConfigListResult> DescribeWebLockConfigListOutcome;
typedef std::future<DescribeWebLockConfigListOutcome> DescribeWebLockConfigListOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::DescribeWebLockConfigListRequest&, const DescribeWebLockConfigListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeWebLockConfigListAsyncHandler;
typedef Outcome<Error, Model::DescribeWebLockFileEventsResult> DescribeWebLockFileEventsOutcome;
typedef std::future<DescribeWebLockFileEventsOutcome> DescribeWebLockFileEventsOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::DescribeWebLockFileEventsRequest&, const DescribeWebLockFileEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeWebLockFileEventsAsyncHandler;
typedef Outcome<Error, Model::ExportRecordResult> ExportRecordOutcome;
typedef std::future<ExportRecordOutcome> ExportRecordOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::ExportRecordRequest&, const ExportRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportRecordAsyncHandler;
@@ -932,6 +958,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListCheckResultResult> ListCheckResultOutcome;
typedef std::future<ListCheckResultOutcome> ListCheckResultOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::ListCheckResultRequest&, const ListCheckResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCheckResultAsyncHandler;
typedef Outcome<Error, Model::ListHoneypotResult> ListHoneypotOutcome;
typedef std::future<ListHoneypotOutcome> ListHoneypotOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::ListHoneypotRequest&, const ListHoneypotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListHoneypotAsyncHandler;
typedef Outcome<Error, Model::ListHoneypotAlarmEventsResult> ListHoneypotAlarmEventsOutcome;
typedef std::future<ListHoneypotAlarmEventsOutcome> ListHoneypotAlarmEventsOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::ListHoneypotAlarmEventsRequest&, const ListHoneypotAlarmEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListHoneypotAlarmEventsAsyncHandler;
typedef Outcome<Error, Model::ListHoneypotNodeResult> ListHoneypotNodeOutcome;
typedef std::future<ListHoneypotNodeOutcome> ListHoneypotNodeOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::ListHoneypotNodeRequest&, const ListHoneypotNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListHoneypotNodeAsyncHandler;
typedef Outcome<Error, Model::ListVulAutoRepairConfigResult> ListVulAutoRepairConfigOutcome;
typedef std::future<ListVulAutoRepairConfigOutcome> ListVulAutoRepairConfigOutcomeCallable;
typedef std::function<void(const SasClient*, const Model::ListVulAutoRepairConfigRequest&, const ListVulAutoRepairConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVulAutoRepairConfigAsyncHandler;
@@ -1120,6 +1155,15 @@ namespace AlibabaCloud
CreateFileDetectUploadUrlOutcome createFileDetectUploadUrl(const Model::CreateFileDetectUploadUrlRequest &request)const;
void createFileDetectUploadUrlAsync(const Model::CreateFileDetectUploadUrlRequest& request, const CreateFileDetectUploadUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateFileDetectUploadUrlOutcomeCallable createFileDetectUploadUrlCallable(const Model::CreateFileDetectUploadUrlRequest& request) const;
CreateHoneypotOutcome createHoneypot(const Model::CreateHoneypotRequest &request)const;
void createHoneypotAsync(const Model::CreateHoneypotRequest& request, const CreateHoneypotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateHoneypotOutcomeCallable createHoneypotCallable(const Model::CreateHoneypotRequest& request) const;
CreateHoneypotNodeOutcome createHoneypotNode(const Model::CreateHoneypotNodeRequest &request)const;
void createHoneypotNodeAsync(const Model::CreateHoneypotNodeRequest& request, const CreateHoneypotNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateHoneypotNodeOutcomeCallable createHoneypotNodeCallable(const Model::CreateHoneypotNodeRequest& request) const;
CreateHoneypotProbeOutcome createHoneypotProbe(const Model::CreateHoneypotProbeRequest &request)const;
void createHoneypotProbeAsync(const Model::CreateHoneypotProbeRequest& request, const CreateHoneypotProbeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateHoneypotProbeOutcomeCallable createHoneypotProbeCallable(const Model::CreateHoneypotProbeRequest& request) const;
CreateOrUpdateAssetGroupOutcome createOrUpdateAssetGroup(const Model::CreateOrUpdateAssetGroupRequest &request)const;
void createOrUpdateAssetGroupAsync(const Model::CreateOrUpdateAssetGroupRequest& request, const CreateOrUpdateAssetGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateOrUpdateAssetGroupOutcomeCallable createOrUpdateAssetGroupCallable(const Model::CreateOrUpdateAssetGroupRequest& request) const;
@@ -1525,6 +1569,9 @@ namespace AlibabaCloud
DescribeWebLockConfigListOutcome describeWebLockConfigList(const Model::DescribeWebLockConfigListRequest &request)const;
void describeWebLockConfigListAsync(const Model::DescribeWebLockConfigListRequest& request, const DescribeWebLockConfigListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeWebLockConfigListOutcomeCallable describeWebLockConfigListCallable(const Model::DescribeWebLockConfigListRequest& request) const;
DescribeWebLockFileEventsOutcome describeWebLockFileEvents(const Model::DescribeWebLockFileEventsRequest &request)const;
void describeWebLockFileEventsAsync(const Model::DescribeWebLockFileEventsRequest& request, const DescribeWebLockFileEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeWebLockFileEventsOutcomeCallable describeWebLockFileEventsCallable(const Model::DescribeWebLockFileEventsRequest& request) const;
ExportRecordOutcome exportRecord(const Model::ExportRecordRequest &request)const;
void exportRecordAsync(const Model::ExportRecordRequest& request, const ExportRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExportRecordOutcomeCallable exportRecordCallable(const Model::ExportRecordRequest& request) const;
@@ -1573,6 +1620,15 @@ namespace AlibabaCloud
ListCheckResultOutcome listCheckResult(const Model::ListCheckResultRequest &request)const;
void listCheckResultAsync(const Model::ListCheckResultRequest& request, const ListCheckResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListCheckResultOutcomeCallable listCheckResultCallable(const Model::ListCheckResultRequest& request) const;
ListHoneypotOutcome listHoneypot(const Model::ListHoneypotRequest &request)const;
void listHoneypotAsync(const Model::ListHoneypotRequest& request, const ListHoneypotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListHoneypotOutcomeCallable listHoneypotCallable(const Model::ListHoneypotRequest& request) const;
ListHoneypotAlarmEventsOutcome listHoneypotAlarmEvents(const Model::ListHoneypotAlarmEventsRequest &request)const;
void listHoneypotAlarmEventsAsync(const Model::ListHoneypotAlarmEventsRequest& request, const ListHoneypotAlarmEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListHoneypotAlarmEventsOutcomeCallable listHoneypotAlarmEventsCallable(const Model::ListHoneypotAlarmEventsRequest& request) const;
ListHoneypotNodeOutcome listHoneypotNode(const Model::ListHoneypotNodeRequest &request)const;
void listHoneypotNodeAsync(const Model::ListHoneypotNodeRequest& request, const ListHoneypotNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListHoneypotNodeOutcomeCallable listHoneypotNodeCallable(const Model::ListHoneypotNodeRequest& request) const;
ListVulAutoRepairConfigOutcome listVulAutoRepairConfig(const Model::ListVulAutoRepairConfigRequest &request)const;
void listVulAutoRepairConfigAsync(const Model::ListVulAutoRepairConfigRequest& request, const ListVulAutoRepairConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVulAutoRepairConfigOutcomeCallable listVulAutoRepairConfigCallable(const Model::ListVulAutoRepairConfigRequest& request) const;

54
sas/include/alibabacloud/sas/model/CreateHoneypotNodeRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTNODEREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTNODEREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT CreateHoneypotNodeRequest : public RpcServiceRequest {
public:
CreateHoneypotNodeRequest();
~CreateHoneypotNodeRequest();
int getAvailableProbeNum() const;
void setAvailableProbeNum(int availableProbeNum);
bool getAllowHoneypotAccessInternet() const;
void setAllowHoneypotAccessInternet(bool allowHoneypotAccessInternet);
std::string getNodeName() const;
void setNodeName(const std::string &nodeName);
std::vector<std::string> getSecurityGroupProbeIpList() const;
void setSecurityGroupProbeIpList(const std::vector<std::string> &securityGroupProbeIpList);
std::string getNodeVersion() const;
void setNodeVersion(const std::string &nodeVersion);
private:
int availableProbeNum_;
bool allowHoneypotAccessInternet_;
std::string nodeName_;
std::vector<std::string> securityGroupProbeIpList_;
std::string nodeVersion_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTNODEREQUEST_H_

57
sas/include/alibabacloud/sas/model/CreateHoneypotNodeResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTNODERESULT_H_
#define ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTNODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT CreateHoneypotNodeResult : public ServiceResult
{
public:
CreateHoneypotNodeResult();
explicit CreateHoneypotNodeResult(const std::string &payload);
~CreateHoneypotNodeResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTNODERESULT_H_

95
sas/include/alibabacloud/sas/model/CreateHoneypotProbeRequest.h Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTPROBEREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTPROBEREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT CreateHoneypotProbeRequest : public RpcServiceRequest {
public:
struct HoneypotBindList {
struct BindPortList {
int startPort;
bool bindPort;
bool fixed;
int endPort;
int targetPort;
};
std::vector<BindPortList> bindPortList;
std::string honeypotId;
};
CreateHoneypotProbeRequest();
~CreateHoneypotProbeRequest();
std::string getControlNodeId() const;
void setControlNodeId(const std::string &controlNodeId);
std::string getProxyIp() const;
void setProxyIp(const std::string &proxyIp);
bool getPing() const;
void setPing(bool ping);
std::string getProbeId() const;
void setProbeId(const std::string &probeId);
std::string getUuid() const;
void setUuid(const std::string &uuid);
std::string getProbeVersion() const;
void setProbeVersion(const std::string &probeVersion);
std::vector<std::string> getServiceIpList() const;
void setServiceIpList(const std::vector<std::string> &serviceIpList);
std::vector<HoneypotBindList> getHoneypotBindList() const;
void setHoneypotBindList(const std::vector<HoneypotBindList> &honeypotBindList);
std::string getLang() const;
void setLang(const std::string &lang);
bool getArp() const;
void setArp(bool arp);
std::string getProbeType() const;
void setProbeType(const std::string &probeType);
std::string getProbeStatus() const;
void setProbeStatus(const std::string &probeStatus);
std::string getBusinessGroupId() const;
void setBusinessGroupId(const std::string &businessGroupId);
std::string getDisplayName() const;
void setDisplayName(const std::string &displayName);
std::string getVpcId() const;
void setVpcId(const std::string &vpcId);
private:
std::string controlNodeId_;
std::string proxyIp_;
bool ping_;
std::string probeId_;
std::string uuid_;
std::string probeVersion_;
std::vector<std::string> serviceIpList_;
std::vector<HoneypotBindList> honeypotBindList_;
std::string lang_;
bool arp_;
std::string probeType_;
std::string probeStatus_;
std::string businessGroupId_;
std::string displayName_;
std::string vpcId_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTPROBEREQUEST_H_

57
sas/include/alibabacloud/sas/model/CreateHoneypotProbeResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTPROBERESULT_H_
#define ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTPROBERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT CreateHoneypotProbeResult : public ServiceResult
{
public:
CreateHoneypotProbeResult();
explicit CreateHoneypotProbeResult(const std::string &payload);
~CreateHoneypotProbeResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTPROBERESULT_H_

63
sas/include/alibabacloud/sas/model/CreateHoneypotRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT CreateHoneypotRequest : public RpcServiceRequest {
public:
CreateHoneypotRequest();
~CreateHoneypotRequest();
std::string getHoneypotName() const;
void setHoneypotName(const std::string &honeypotName);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getLang() const;
void setLang(const std::string &lang);
std::string getNodeId() const;
void setNodeId(const std::string &nodeId);
std::string getHoneypotImageId() const;
void setHoneypotImageId(const std::string &honeypotImageId);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getMeta() const;
void setMeta(const std::string &meta);
std::string getHoneypotImageName() const;
void setHoneypotImageName(const std::string &honeypotImageName);
private:
std::string honeypotName_;
int pageSize_;
std::string lang_;
std::string nodeId_;
std::string honeypotImageId_;
int currentPage_;
std::string meta_;
std::string honeypotImageName_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTREQUEST_H_

70
sas/include/alibabacloud/sas/model/CreateHoneypotResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTRESULT_H_
#define ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT CreateHoneypotResult : public ServiceResult
{
public:
struct Data
{
std::string honeypotImageName;
std::string controlNodeName;
std::string honeypotId;
std::vector<std::string> state;
std::string presetId;
std::string honeypotImageDisplayName;
std::string nodeId;
std::string honeypotName;
};
CreateHoneypotResult();
explicit CreateHoneypotResult(const std::string &payload);
~CreateHoneypotResult();
std::string getMessage()const;
int getHttpStatusCode()const;
Data getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
Data data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_CREATEHONEYPOTRESULT_H_

3
sas/include/alibabacloud/sas/model/DescribeCheckWarningsRequest.h
View File

@@ -46,6 +46,8 @@ public:
void setCurrentPage(int currentPage);
long getRiskId() const;
void setRiskId(long riskId);
int getRiskStatus() const;
void setRiskStatus(int riskStatus);
private:
std::string uuid_;
@@ -56,6 +58,7 @@ private:
long checkId_;
int currentPage_;
long riskId_;
int riskStatus_;
};
} // namespace Model
} // namespace Sas

1
sas/include/alibabacloud/sas/model/DescribeGroupedVulResult.h
View File

@@ -40,6 +40,7 @@ namespace AlibabaCloud
int handledCount;
std::string aliasName;
int asapCount;
long ruleModifyTime;
int nntfCount;
long totalFixCount;
std::string tags;

12
sas/include/alibabacloud/sas/model/DescribeOnceTaskRequest.h
View File

@@ -30,6 +30,10 @@ class ALIBABACLOUD_SAS_EXPORT DescribeOnceTaskRequest : public RpcServiceRequest
public:
DescribeOnceTaskRequest();
~DescribeOnceTaskRequest();
std::vector<std::string> getStatusList() const;
void setStatusList(const std::vector<std::string> &statusList);
std::string getSource() const;
void setSource(const std::string &source);
std::string getSourceIp() const;
void setSourceIp(const std::string &sourceIp);
std::string getRootTaskId() const;
@@ -38,21 +42,29 @@ public:
void setEndTimeQuery(long endTimeQuery);
int getPageSize() const;
void setPageSize(int pageSize);
int getFinish() const;
void setFinish(int finish);
std::string getTaskType() const;
void setTaskType(const std::string &taskType);
long getStartTimeQuery() const;
void setStartTimeQuery(long startTimeQuery);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getTargetQuery() const;
void setTargetQuery(const std::string &targetQuery);
private:
std::vector<std::string> statusList_;
std::string source_;
std::string sourceIp_;
std::string rootTaskId_;
long endTimeQuery_;
int pageSize_;
int finish_;
std::string taskType_;
long startTimeQuery_;
int currentPage_;
std::string targetQuery_;
};
} // namespace Model
} // namespace Sas

2
sas/include/alibabacloud/sas/model/DescribeOnceTaskResult.h
View File

@@ -41,6 +41,7 @@ namespace AlibabaCloud
};
struct TaskManageResponse
{
std::string context;
std::string progress;
std::string taskId;
std::string taskName;
@@ -50,6 +51,7 @@ namespace AlibabaCloud
std::string taskStatusText;
std::string detailData;
long taskStartTime;
std::string source;
};

3
sas/include/alibabacloud/sas/model/DescribeWarningMachinesRequest.h
View File

@@ -44,6 +44,8 @@ public:
void setMachineName(const std::string &machineName);
std::string getLang() const;
void setLang(const std::string &lang);
int getHaveRisk() const;
void setHaveRisk(int haveRisk);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getClusterId() const;
@@ -63,6 +65,7 @@ private:
int pageSize_;
std::string machineName_;
std::string lang_;
int haveRisk_;
int currentPage_;
std::string clusterId_;
long riskId_;

63
sas/include/alibabacloud/sas/model/DescribeWebLockFileEventsRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_DESCRIBEWEBLOCKFILEEVENTSREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_DESCRIBEWEBLOCKFILEEVENTSREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT DescribeWebLockFileEventsRequest : public RpcServiceRequest {
public:
DescribeWebLockFileEventsRequest();
~DescribeWebLockFileEventsRequest();
std::string getRemark() const;
void setRemark(const std::string &remark);
std::string getSourceIp() const;
void setSourceIp(const std::string &sourceIp);
int getPageSize() const;
void setPageSize(int pageSize);
long getTsEnd() const;
void setTsEnd(long tsEnd);
std::string getProcessName() const;
void setProcessName(const std::string &processName);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getDealed() const;
void setDealed(const std::string &dealed);
long getTsBegin() const;
void setTsBegin(long tsBegin);
private:
std::string remark_;
std::string sourceIp_;
int pageSize_;
long tsEnd_;
std::string processName_;
int currentPage_;
std::string dealed_;
long tsBegin_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_DESCRIBEWEBLOCKFILEEVENTSREQUEST_H_

78
sas/include/alibabacloud/sas/model/DescribeWebLockFileEventsResult.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_DESCRIBEWEBLOCKFILEEVENTSRESULT_H_
#define ALIBABACLOUD_SAS_MODEL_DESCRIBEWEBLOCKFILEEVENTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT DescribeWebLockFileEventsResult : public ServiceResult
{
public:
struct Info
{
std::string status;
std::string path;
std::string processName;
std::string eventType;
std::string ip;
std::string eventStatus;
std::string eventName;
long count;
std::string processPath;
std::string intranetIp;
long ds;
std::string instanceName;
std::string uuid;
std::string internetIp;
std::string level;
long id;
long gmtEvent;
std::string solution;
};
DescribeWebLockFileEventsResult();
explicit DescribeWebLockFileEventsResult(const std::string &payload);
~DescribeWebLockFileEventsResult();
int getTotalCount()const;
int getPageSize()const;
int getCurrentPage()const;
std::vector<Info> getList()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int currentPage_;
std::vector<Info> list_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_DESCRIBEWEBLOCKFILEEVENTSRESULT_H_

2
sas/include/alibabacloud/sas/model/GetFileDetectResultResult.h
View File

@@ -38,6 +38,8 @@ namespace AlibabaCloud
int score;
std::string virusType;
std::string hashKey;
std::string errorCode;
std::string errorMessage;
int result;
};

60
sas/include/alibabacloud/sas/model/ListHoneypotAlarmEventsRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTALARMEVENTSREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTALARMEVENTSREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT ListHoneypotAlarmEventsRequest : public RpcServiceRequest {
public:
ListHoneypotAlarmEventsRequest();
~ListHoneypotAlarmEventsRequest();
std::string getSrcIp() const;
void setSrcIp(const std::string &srcIp);
std::vector<std::string> getRiskLevelList() const;
void setRiskLevelList(const std::vector<std::string> &riskLevelList);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getDstIp() const;
void setDstIp(const std::string &dstIp);
std::string getDealed() const;
void setDealed(const std::string &dealed);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
private:
std::string srcIp_;
std::vector<std::string> riskLevelList_;
int pageSize_;
std::string dstIp_;
std::string dealed_;
int currentPage_;
std::string requestId_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTALARMEVENTSREQUEST_H_

82
sas/include/alibabacloud/sas/model/ListHoneypotAlarmEventsResult.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTALARMEVENTSRESULT_H_
#define ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTALARMEVENTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT ListHoneypotAlarmEventsResult : public ServiceResult
{
public:
struct PageInfo
{
int totalCount;
int pageSize;
std::string nextToken;
int currentPage;
int count;
std::string lastRowKey;
};
struct HoneypotAlarmEvent
{
struct MergeFieldListItem
{
std::string fieldExtInfo;
std::string fieldValue;
std::string fieldType;
std::string fieldKey;
};
long firstTime;
int operateStatus;
long alarmEventId;
int eventCount;
std::string alarmEventType;
std::string alarmEventName;
std::string alarmUniqueInfo;
std::vector<HoneypotAlarmEvent::MergeFieldListItem> mergeFieldList;
std::string riskLevel;
long lastTime;
};
ListHoneypotAlarmEventsResult();
explicit ListHoneypotAlarmEventsResult(const std::string &payload);
~ListHoneypotAlarmEventsResult();
PageInfo getPageInfo()const;
std::vector<HoneypotAlarmEvent> getHoneypotAlarmEvents()const;
protected:
void parse(const std::string &payload);
private:
PageInfo pageInfo_;
std::vector<HoneypotAlarmEvent> honeypotAlarmEvents_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTALARMEVENTSRESULT_H_

54
sas/include/alibabacloud/sas/model/ListHoneypotNodeRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTNODEREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTNODEREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT ListHoneypotNodeRequest : public RpcServiceRequest {
public:
ListHoneypotNodeRequest();
~ListHoneypotNodeRequest();
int getPageSize() const;
void setPageSize(int pageSize);
std::string getLang() const;
void setLang(const std::string &lang);
std::string getNodeId() const;
void setNodeId(const std::string &nodeId);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getNodeName() const;
void setNodeName(const std::string &nodeName);
private:
int pageSize_;
std::string lang_;
std::string nodeId_;
int currentPage_;
std::string nodeName_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTNODEREQUEST_H_

86
sas/include/alibabacloud/sas/model/ListHoneypotNodeResult.h Normal file
View File

@@ -0,0 +1,86 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTNODERESULT_H_
#define ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTNODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT ListHoneypotNodeResult : public ServiceResult
{
public:
struct PageInfo
{
int totalCount;
int pageSize;
int currentPage;
int count;
std::string lastRowKey;
};
struct List
{
int probeTotalCount;
std::string nodeName;
std::string createTime;
bool allowHoneypotAccessInternet;
std::string nodeIp;
std::vector<std::string> securityGroupProbeIpList;
std::string nodeVersion;
int honeypotTotalCount;
std::string ecsInstanceId;
int probeUsedCount;
std::string nodeId;
bool defaultNode;
int honeypotUsedCount;
int totalStatus;
};
ListHoneypotNodeResult();
explicit ListHoneypotNodeResult(const std::string &payload);
~ListHoneypotNodeResult();
PageInfo getPageInfo()const;
std::vector<List> getHoneypotNodeList()const;
std::string getMessage()const;
int getHttpStatusCode()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
PageInfo pageInfo_;
std::vector<List> honeypotNodeList_;
std::string message_;
int httpStatusCode_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTNODERESULT_H_

60
sas/include/alibabacloud/sas/model/ListHoneypotRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTREQUEST_H_
#define ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTREQUEST_H_
#include <alibabacloud/sas/SasExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Sas {
namespace Model {
class ALIBABACLOUD_SAS_EXPORT ListHoneypotRequest : public RpcServiceRequest {
public:
ListHoneypotRequest();
~ListHoneypotRequest();
std::string getHoneypotName() const;
void setHoneypotName(const std::string &honeypotName);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getLang() const;
void setLang(const std::string &lang);
std::string getNodeId() const;
void setNodeId(const std::string &nodeId);
int getCurrentPage() const;
void setCurrentPage(int currentPage);
std::string getNodeName() const;
void setNodeName(const std::string &nodeName);
std::vector<std::string> getHoneypotIds() const;
void setHoneypotIds(const std::vector<std::string> &honeypotIds);
private:
std::string honeypotName_;
int pageSize_;
std::string lang_;
std::string nodeId_;
int currentPage_;
std::string nodeName_;
std::vector<std::string> honeypotIds_;
};
} // namespace Model
} // namespace Sas
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTREQUEST_H_

80
sas/include/alibabacloud/sas/model/ListHoneypotResult.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTRESULT_H_
#define ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sas/SasExport.h>
namespace AlibabaCloud
{
namespace Sas
{
namespace Model
{
class ALIBABACLOUD_SAS_EXPORT ListHoneypotResult : public ServiceResult
{
public:
struct PageInfo
{
int totalCount;
int pageSize;
int currentPage;
int count;
std::string lastRowKey;
};
struct ListItem
{
std::string honeypotImageName;
std::string controlNodeName;
std::string honeypotId;
std::vector<std::string> state;
std::string presetId;
std::string honeypotImageDisplayName;
std::string nodeId;
std::string honeypotName;
};
ListHoneypotResult();
explicit ListHoneypotResult(const std::string &payload);
~ListHoneypotResult();
PageInfo getPageInfo()const;
std::string getMessage()const;
int getHttpStatusCode()const;
std::vector<ListItem> getList()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
PageInfo pageInfo_;
std::string message_;
int httpStatusCode_;
std::vector<ListItem> list_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SAS_MODEL_LISTHONEYPOTRESULT_H_

252
sas/src/SasClient.cc
View File

@@ -339,6 +339,114 @@ SasClient::CreateFileDetectUploadUrlOutcomeCallable SasClient::createFileDetectU
return task->get_future();
}
SasClient::CreateHoneypotOutcome SasClient::createHoneypot(const CreateHoneypotRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateHoneypotOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateHoneypotOutcome(CreateHoneypotResult(outcome.result()));
else
return CreateHoneypotOutcome(outcome.error());
}
void SasClient::createHoneypotAsync(const CreateHoneypotRequest& request, const CreateHoneypotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createHoneypot(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::CreateHoneypotOutcomeCallable SasClient::createHoneypotCallable(const CreateHoneypotRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateHoneypotOutcome()>>(
[this, request]()
{
return this->createHoneypot(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::CreateHoneypotNodeOutcome SasClient::createHoneypotNode(const CreateHoneypotNodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateHoneypotNodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateHoneypotNodeOutcome(CreateHoneypotNodeResult(outcome.result()));
else
return CreateHoneypotNodeOutcome(outcome.error());
}
void SasClient::createHoneypotNodeAsync(const CreateHoneypotNodeRequest& request, const CreateHoneypotNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createHoneypotNode(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::CreateHoneypotNodeOutcomeCallable SasClient::createHoneypotNodeCallable(const CreateHoneypotNodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateHoneypotNodeOutcome()>>(
[this, request]()
{
return this->createHoneypotNode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::CreateHoneypotProbeOutcome SasClient::createHoneypotProbe(const CreateHoneypotProbeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateHoneypotProbeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateHoneypotProbeOutcome(CreateHoneypotProbeResult(outcome.result()));
else
return CreateHoneypotProbeOutcome(outcome.error());
}
void SasClient::createHoneypotProbeAsync(const CreateHoneypotProbeRequest& request, const CreateHoneypotProbeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createHoneypotProbe(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::CreateHoneypotProbeOutcomeCallable SasClient::createHoneypotProbeCallable(const CreateHoneypotProbeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateHoneypotProbeOutcome()>>(
[this, request]()
{
return this->createHoneypotProbe(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::CreateOrUpdateAssetGroupOutcome SasClient::createOrUpdateAssetGroup(const CreateOrUpdateAssetGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5199,6 +5307,42 @@ SasClient::DescribeWebLockConfigListOutcomeCallable SasClient::describeWebLockCo
return task->get_future();
}
SasClient::DescribeWebLockFileEventsOutcome SasClient::describeWebLockFileEvents(const DescribeWebLockFileEventsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeWebLockFileEventsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeWebLockFileEventsOutcome(DescribeWebLockFileEventsResult(outcome.result()));
else
return DescribeWebLockFileEventsOutcome(outcome.error());
}
void SasClient::describeWebLockFileEventsAsync(const DescribeWebLockFileEventsRequest& request, const DescribeWebLockFileEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeWebLockFileEvents(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::DescribeWebLockFileEventsOutcomeCallable SasClient::describeWebLockFileEventsCallable(const DescribeWebLockFileEventsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeWebLockFileEventsOutcome()>>(
[this, request]()
{
return this->describeWebLockFileEvents(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::ExportRecordOutcome SasClient::exportRecord(const ExportRecordRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5775,6 +5919,114 @@ SasClient::ListCheckResultOutcomeCallable SasClient::listCheckResultCallable(con
return task->get_future();
}
SasClient::ListHoneypotOutcome SasClient::listHoneypot(const ListHoneypotRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListHoneypotOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListHoneypotOutcome(ListHoneypotResult(outcome.result()));
else
return ListHoneypotOutcome(outcome.error());
}
void SasClient::listHoneypotAsync(const ListHoneypotRequest& request, const ListHoneypotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listHoneypot(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::ListHoneypotOutcomeCallable SasClient::listHoneypotCallable(const ListHoneypotRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListHoneypotOutcome()>>(
[this, request]()
{
return this->listHoneypot(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::ListHoneypotAlarmEventsOutcome SasClient::listHoneypotAlarmEvents(const ListHoneypotAlarmEventsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListHoneypotAlarmEventsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListHoneypotAlarmEventsOutcome(ListHoneypotAlarmEventsResult(outcome.result()));
else
return ListHoneypotAlarmEventsOutcome(outcome.error());
}
void SasClient::listHoneypotAlarmEventsAsync(const ListHoneypotAlarmEventsRequest& request, const ListHoneypotAlarmEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listHoneypotAlarmEvents(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::ListHoneypotAlarmEventsOutcomeCallable SasClient::listHoneypotAlarmEventsCallable(const ListHoneypotAlarmEventsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListHoneypotAlarmEventsOutcome()>>(
[this, request]()
{
return this->listHoneypotAlarmEvents(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::ListHoneypotNodeOutcome SasClient::listHoneypotNode(const ListHoneypotNodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListHoneypotNodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListHoneypotNodeOutcome(ListHoneypotNodeResult(outcome.result()));
else
return ListHoneypotNodeOutcome(outcome.error());
}
void SasClient::listHoneypotNodeAsync(const ListHoneypotNodeRequest& request, const ListHoneypotNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listHoneypotNode(request), context);
};
asyncExecute(new Runnable(fn));
}
SasClient::ListHoneypotNodeOutcomeCallable SasClient::listHoneypotNodeCallable(const ListHoneypotNodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListHoneypotNodeOutcome()>>(
[this, request]()
{
return this->listHoneypotNode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SasClient::ListVulAutoRepairConfigOutcome SasClient::listVulAutoRepairConfig(const ListVulAutoRepairConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

71
sas/src/model/CreateHoneypotNodeRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/CreateHoneypotNodeRequest.h>
using AlibabaCloud::Sas::Model::CreateHoneypotNodeRequest;
CreateHoneypotNodeRequest::CreateHoneypotNodeRequest()
: RpcServiceRequest("sas", "2018-12-03", "CreateHoneypotNode") {
setMethod(HttpRequest::Method::Post);
}
CreateHoneypotNodeRequest::~CreateHoneypotNodeRequest() {}
int CreateHoneypotNodeRequest::getAvailableProbeNum() const {
return availableProbeNum_;
}
void CreateHoneypotNodeRequest::setAvailableProbeNum(int availableProbeNum) {
availableProbeNum_ = availableProbeNum;
setParameter(std::string("AvailableProbeNum"), std::to_string(availableProbeNum));
}
bool CreateHoneypotNodeRequest::getAllowHoneypotAccessInternet() const {
return allowHoneypotAccessInternet_;
}
void CreateHoneypotNodeRequest::setAllowHoneypotAccessInternet(bool allowHoneypotAccessInternet) {
allowHoneypotAccessInternet_ = allowHoneypotAccessInternet;
setParameter(std::string("AllowHoneypotAccessInternet"), allowHoneypotAccessInternet ? "true" : "false");
}
std::string CreateHoneypotNodeRequest::getNodeName() const {
return nodeName_;
}
void CreateHoneypotNodeRequest::setNodeName(const std::string &nodeName) {
nodeName_ = nodeName;
setParameter(std::string("NodeName"), nodeName);
}
std::vector<std::string> CreateHoneypotNodeRequest::getSecurityGroupProbeIpList() const {
return securityGroupProbeIpList_;
}
void CreateHoneypotNodeRequest::setSecurityGroupProbeIpList(const std::vector<std::string> &securityGroupProbeIpList) {
securityGroupProbeIpList_ = securityGroupProbeIpList;
}
std::string CreateHoneypotNodeRequest::getNodeVersion() const {
return nodeVersion_;
}
void CreateHoneypotNodeRequest::setNodeVersion(const std::string &nodeVersion) {
nodeVersion_ = nodeVersion;
setParameter(std::string("NodeVersion"), nodeVersion);
}

72
sas/src/model/CreateHoneypotNodeResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/CreateHoneypotNodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
CreateHoneypotNodeResult::CreateHoneypotNodeResult() :
ServiceResult()
{}
CreateHoneypotNodeResult::CreateHoneypotNodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateHoneypotNodeResult::~CreateHoneypotNodeResult()
{}
void CreateHoneypotNodeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
}
std::string CreateHoneypotNodeResult::getMessage()const
{
return message_;
}
int CreateHoneypotNodeResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string CreateHoneypotNodeResult::getCode()const
{
return code_;
}
bool CreateHoneypotNodeResult::getSuccess()const
{
return success_;
}

174
sas/src/model/CreateHoneypotProbeRequest.cc Normal file
View File

@@ -0,0 +1,174 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/CreateHoneypotProbeRequest.h>
using AlibabaCloud::Sas::Model::CreateHoneypotProbeRequest;
CreateHoneypotProbeRequest::CreateHoneypotProbeRequest()
: RpcServiceRequest("sas", "2018-12-03", "CreateHoneypotProbe") {
setMethod(HttpRequest::Method::Post);
}
CreateHoneypotProbeRequest::~CreateHoneypotProbeRequest() {}
std::string CreateHoneypotProbeRequest::getControlNodeId() const {
return controlNodeId_;
}
void CreateHoneypotProbeRequest::setControlNodeId(const std::string &controlNodeId) {
controlNodeId_ = controlNodeId;
setParameter(std::string("ControlNodeId"), controlNodeId);
}
std::string CreateHoneypotProbeRequest::getProxyIp() const {
return proxyIp_;
}
void CreateHoneypotProbeRequest::setProxyIp(const std::string &proxyIp) {
proxyIp_ = proxyIp;
setParameter(std::string("ProxyIp"), proxyIp);
}
bool CreateHoneypotProbeRequest::getPing() const {
return ping_;
}
void CreateHoneypotProbeRequest::setPing(bool ping) {
ping_ = ping;
setParameter(std::string("Ping"), ping ? "true" : "false");
}
std::string CreateHoneypotProbeRequest::getProbeId() const {
return probeId_;
}
void CreateHoneypotProbeRequest::setProbeId(const std::string &probeId) {
probeId_ = probeId;
setParameter(std::string("ProbeId"), probeId);
}
std::string CreateHoneypotProbeRequest::getUuid() const {
return uuid_;
}
void CreateHoneypotProbeRequest::setUuid(const std::string &uuid) {
uuid_ = uuid;
setParameter(std::string("Uuid"), uuid);
}
std::string CreateHoneypotProbeRequest::getProbeVersion() const {
return probeVersion_;
}
void CreateHoneypotProbeRequest::setProbeVersion(const std::string &probeVersion) {
probeVersion_ = probeVersion;
setParameter(std::string("ProbeVersion"), probeVersion);
}
std::vector<std::string> CreateHoneypotProbeRequest::getServiceIpList() const {
return serviceIpList_;
}
void CreateHoneypotProbeRequest::setServiceIpList(const std::vector<std::string> &serviceIpList) {
serviceIpList_ = serviceIpList;
}
std::vector<CreateHoneypotProbeRequest::HoneypotBindList> CreateHoneypotProbeRequest::getHoneypotBindList() const {
return honeypotBindList_;
}
void CreateHoneypotProbeRequest::setHoneypotBindList(const std::vector<CreateHoneypotProbeRequest::HoneypotBindList> &honeypotBindList) {
honeypotBindList_ = honeypotBindList;
for(int dep1 = 0; dep1 != honeypotBindList.size(); dep1++) {
auto honeypotBindListObj = honeypotBindList.at(dep1);
std::string honeypotBindListObjStr = std::string("HoneypotBindList") + "." + std::to_string(dep1 + 1);
for(int dep2 = 0; dep2 != honeypotBindListObj.bindPortList.size(); dep2++) {
auto bindPortListObj = honeypotBindListObj.bindPortList.at(dep2);
std::string bindPortListObjStr = honeypotBindListObjStr + ".BindPortList" + "." + std::to_string(dep2 + 1);
setParameter(bindPortListObjStr + ".StartPort", std::to_string(bindPortListObj.startPort));
setParameter(bindPortListObjStr + ".BindPort", bindPortListObj.bindPort ? "true" : "false");
setParameter(bindPortListObjStr + ".Fixed", bindPortListObj.fixed ? "true" : "false");
setParameter(bindPortListObjStr + ".EndPort", std::to_string(bindPortListObj.endPort));
setParameter(bindPortListObjStr + ".TargetPort", std::to_string(bindPortListObj.targetPort));
}
setParameter(honeypotBindListObjStr + ".HoneypotId", honeypotBindListObj.honeypotId);
}
}
std::string CreateHoneypotProbeRequest::getLang() const {
return lang_;
}
void CreateHoneypotProbeRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
bool CreateHoneypotProbeRequest::getArp() const {
return arp_;
}
void CreateHoneypotProbeRequest::setArp(bool arp) {
arp_ = arp;
setParameter(std::string("Arp"), arp ? "true" : "false");
}
std::string CreateHoneypotProbeRequest::getProbeType() const {
return probeType_;
}
void CreateHoneypotProbeRequest::setProbeType(const std::string &probeType) {
probeType_ = probeType;
setParameter(std::string("ProbeType"), probeType);
}
std::string CreateHoneypotProbeRequest::getProbeStatus() const {
return probeStatus_;
}
void CreateHoneypotProbeRequest::setProbeStatus(const std::string &probeStatus) {
probeStatus_ = probeStatus;
setParameter(std::string("ProbeStatus"), probeStatus);
}
std::string CreateHoneypotProbeRequest::getBusinessGroupId() const {
return businessGroupId_;
}
void CreateHoneypotProbeRequest::setBusinessGroupId(const std::string &businessGroupId) {
businessGroupId_ = businessGroupId;
setParameter(std::string("BusinessGroupId"), businessGroupId);
}
std::string CreateHoneypotProbeRequest::getDisplayName() const {
return displayName_;
}
void CreateHoneypotProbeRequest::setDisplayName(const std::string &displayName) {
displayName_ = displayName;
setParameter(std::string("DisplayName"), displayName);
}
std::string CreateHoneypotProbeRequest::getVpcId() const {
return vpcId_;
}
void CreateHoneypotProbeRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}

72
sas/src/model/CreateHoneypotProbeResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/CreateHoneypotProbeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
CreateHoneypotProbeResult::CreateHoneypotProbeResult() :
ServiceResult()
{}
CreateHoneypotProbeResult::CreateHoneypotProbeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateHoneypotProbeResult::~CreateHoneypotProbeResult()
{}
void CreateHoneypotProbeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
}
std::string CreateHoneypotProbeResult::getMessage()const
{
return message_;
}
int CreateHoneypotProbeResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string CreateHoneypotProbeResult::getCode()const
{
return code_;
}
bool CreateHoneypotProbeResult::getSuccess()const
{
return success_;
}

99
sas/src/model/CreateHoneypotRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/CreateHoneypotRequest.h>
using AlibabaCloud::Sas::Model::CreateHoneypotRequest;
CreateHoneypotRequest::CreateHoneypotRequest()
: RpcServiceRequest("sas", "2018-12-03", "CreateHoneypot") {
setMethod(HttpRequest::Method::Post);
}
CreateHoneypotRequest::~CreateHoneypotRequest() {}
std::string CreateHoneypotRequest::getHoneypotName() const {
return honeypotName_;
}
void CreateHoneypotRequest::setHoneypotName(const std::string &honeypotName) {
honeypotName_ = honeypotName;
setParameter(std::string("HoneypotName"), honeypotName);
}
int CreateHoneypotRequest::getPageSize() const {
return pageSize_;
}
void CreateHoneypotRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string CreateHoneypotRequest::getLang() const {
return lang_;
}
void CreateHoneypotRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string CreateHoneypotRequest::getNodeId() const {
return nodeId_;
}
void CreateHoneypotRequest::setNodeId(const std::string &nodeId) {
nodeId_ = nodeId;
setParameter(std::string("NodeId"), nodeId);
}
std::string CreateHoneypotRequest::getHoneypotImageId() const {
return honeypotImageId_;
}
void CreateHoneypotRequest::setHoneypotImageId(const std::string &honeypotImageId) {
honeypotImageId_ = honeypotImageId;
setParameter(std::string("HoneypotImageId"), honeypotImageId);
}
int CreateHoneypotRequest::getCurrentPage() const {
return currentPage_;
}
void CreateHoneypotRequest::setCurrentPage(int currentPage) {
currentPage_ = currentPage;
setParameter(std::string("CurrentPage"), std::to_string(currentPage));
}
std::string CreateHoneypotRequest::getMeta() const {
return meta_;
}
void CreateHoneypotRequest::setMeta(const std::string &meta) {
meta_ = meta;
setParameter(std::string("Meta"), meta);
}
std::string CreateHoneypotRequest::getHoneypotImageName() const {
return honeypotImageName_;
}
void CreateHoneypotRequest::setHoneypotImageName(const std::string &honeypotImageName) {
honeypotImageName_ = honeypotImageName;
setParameter(std::string("HoneypotImageName"), honeypotImageName);
}

95
sas/src/model/CreateHoneypotResult.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/CreateHoneypotResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
CreateHoneypotResult::CreateHoneypotResult() :
ServiceResult()
{}
CreateHoneypotResult::CreateHoneypotResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateHoneypotResult::~CreateHoneypotResult()
{}
void CreateHoneypotResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["HoneypotId"].isNull())
data_.honeypotId = dataNode["HoneypotId"].asString();
if(!dataNode["HoneypotName"].isNull())
data_.honeypotName = dataNode["HoneypotName"].asString();
if(!dataNode["ControlNodeName"].isNull())
data_.controlNodeName = dataNode["ControlNodeName"].asString();
if(!dataNode["HoneypotImageName"].isNull())
data_.honeypotImageName = dataNode["HoneypotImageName"].asString();
if(!dataNode["PresetId"].isNull())
data_.presetId = dataNode["PresetId"].asString();
if(!dataNode["HoneypotImageDisplayName"].isNull())
data_.honeypotImageDisplayName = dataNode["HoneypotImageDisplayName"].asString();
if(!dataNode["NodeId"].isNull())
data_.nodeId = dataNode["NodeId"].asString();
auto allState = dataNode["State"]["State"];
for (auto value : allState)
data_.state.push_back(value.asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
}
std::string CreateHoneypotResult::getMessage()const
{
return message_;
}
int CreateHoneypotResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
CreateHoneypotResult::Data CreateHoneypotResult::getData()const
{
return data_;
}
std::string CreateHoneypotResult::getCode()const
{
return code_;
}
bool CreateHoneypotResult::getSuccess()const
{
return success_;
}

9
sas/src/model/DescribeCheckWarningsRequest.cc
View File

@@ -97,3 +97,12 @@ void DescribeCheckWarningsRequest::setRiskId(long riskId) {
setParameter(std::string("RiskId"), std::to_string(riskId));
}
int DescribeCheckWarningsRequest::getRiskStatus() const {
return riskStatus_;
}
void DescribeCheckWarningsRequest::setRiskStatus(int riskStatus) {
riskStatus_ = riskStatus;
setParameter(std::string("RiskStatus"), std::to_string(riskStatus));
}

2
sas/src/model/DescribeGroupedVulResult.cc
View File

@@ -63,6 +63,8 @@ void DescribeGroupedVulResult::parse(const std::string &payload)
groupedVulItemsObject.totalFixCount = std::stol(valueGroupedVulItemsGroupedVulItem["TotalFixCount"].asString());
if(!valueGroupedVulItemsGroupedVulItem["AsapCount"].isNull())
groupedVulItemsObject.asapCount = std::stoi(valueGroupedVulItemsGroupedVulItem["AsapCount"].asString());
if(!valueGroupedVulItemsGroupedVulItem["RuleModifyTime"].isNull())
groupedVulItemsObject.ruleModifyTime = std::stol(valueGroupedVulItemsGroupedVulItem["RuleModifyTime"].asString());
groupedVulItems_.push_back(groupedVulItemsObject);
}
if(!value["CurrentPage"].isNull())

35
sas/src/model/DescribeOnceTaskRequest.cc
View File

@@ -25,6 +25,23 @@ DescribeOnceTaskRequest::DescribeOnceTaskRequest()
DescribeOnceTaskRequest::~DescribeOnceTaskRequest() {}
std::vector<std::string> DescribeOnceTaskRequest::getStatusList() const {
return statusList_;
}
void DescribeOnceTaskRequest::setStatusList(const std::vector<std::string> &statusList) {
statusList_ = statusList;
}
std::string DescribeOnceTaskRequest::getSource() const {
return source_;
}
void DescribeOnceTaskRequest::setSource(const std::string &source) {
source_ = source;
setParameter(std::string("Source"), source);
}
std::string DescribeOnceTaskRequest::getSourceIp() const {
return sourceIp_;
}
@@ -61,6 +78,15 @@ void DescribeOnceTaskRequest::setPageSize(int pageSize) {
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
int DescribeOnceTaskRequest::getFinish() const {
return finish_;
}
void DescribeOnceTaskRequest::setFinish(int finish) {
finish_ = finish;
setParameter(std::string("Finish"), std::to_string(finish));
}
std::string DescribeOnceTaskRequest::getTaskType() const {
return taskType_;
}
@@ -88,3 +114,12 @@ void DescribeOnceTaskRequest::setCurrentPage(int currentPage) {
setParameter(std::string("CurrentPage"), std::to_string(currentPage));
}
std::string DescribeOnceTaskRequest::getTargetQuery() const {
return targetQuery_;
}
void DescribeOnceTaskRequest::setTargetQuery(const std::string &targetQuery) {
targetQuery_ = targetQuery;
setParameter(std::string("TargetQuery"), targetQuery);
}

4
sas/src/model/DescribeOnceTaskResult.cc
View File

@@ -61,6 +61,10 @@ void DescribeOnceTaskResult::parse(const std::string &payload)
taskManageResponseListObject.taskEndTime = std::stol(valueTaskManageResponseListTaskManageResponse["TaskEndTime"].asString());
if(!valueTaskManageResponseListTaskManageResponse["TaskId"].isNull())
taskManageResponseListObject.taskId = valueTaskManageResponseListTaskManageResponse["TaskId"].asString();
if(!valueTaskManageResponseListTaskManageResponse["Source"].isNull())
taskManageResponseListObject.source = valueTaskManageResponseListTaskManageResponse["Source"].asString();
if(!valueTaskManageResponseListTaskManageResponse["Context"].isNull())
taskManageResponseListObject.context = valueTaskManageResponseListTaskManageResponse["Context"].asString();
taskManageResponseList_.push_back(taskManageResponseListObject);
}
auto pageInfoNode = value["PageInfo"];

9
sas/src/model/DescribeWarningMachinesRequest.cc
View File

@@ -88,6 +88,15 @@ void DescribeWarningMachinesRequest::setLang(const std::string &lang) {
setParameter(std::string("Lang"), lang);
}
int DescribeWarningMachinesRequest::getHaveRisk() const {
return haveRisk_;
}
void DescribeWarningMachinesRequest::setHaveRisk(int haveRisk) {
haveRisk_ = haveRisk;
setParameter(std::string("HaveRisk"), std::to_string(haveRisk));
}
int DescribeWarningMachinesRequest::getCurrentPage() const {
return currentPage_;
}

99
sas/src/model/DescribeWebLockFileEventsRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/DescribeWebLockFileEventsRequest.h>
using AlibabaCloud::Sas::Model::DescribeWebLockFileEventsRequest;
DescribeWebLockFileEventsRequest::DescribeWebLockFileEventsRequest()
: RpcServiceRequest("sas", "2018-12-03", "DescribeWebLockFileEvents") {
setMethod(HttpRequest::Method::Post);
}
DescribeWebLockFileEventsRequest::~DescribeWebLockFileEventsRequest() {}
std::string DescribeWebLockFileEventsRequest::getRemark() const {
return remark_;
}
void DescribeWebLockFileEventsRequest::setRemark(const std::string &remark) {
remark_ = remark;
setParameter(std::string("Remark"), remark);
}
std::string DescribeWebLockFileEventsRequest::getSourceIp() const {
return sourceIp_;
}
void DescribeWebLockFileEventsRequest::setSourceIp(const std::string &sourceIp) {
sourceIp_ = sourceIp;
setParameter(std::string("SourceIp"), sourceIp);
}
int DescribeWebLockFileEventsRequest::getPageSize() const {
return pageSize_;
}
void DescribeWebLockFileEventsRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
long DescribeWebLockFileEventsRequest::getTsEnd() const {
return tsEnd_;
}
void DescribeWebLockFileEventsRequest::setTsEnd(long tsEnd) {
tsEnd_ = tsEnd;
setParameter(std::string("TsEnd"), std::to_string(tsEnd));
}
std::string DescribeWebLockFileEventsRequest::getProcessName() const {
return processName_;
}
void DescribeWebLockFileEventsRequest::setProcessName(const std::string &processName) {
processName_ = processName;
setParameter(std::string("ProcessName"), processName);
}
int DescribeWebLockFileEventsRequest::getCurrentPage() const {
return currentPage_;
}
void DescribeWebLockFileEventsRequest::setCurrentPage(int currentPage) {
currentPage_ = currentPage;
setParameter(std::string("CurrentPage"), std::to_string(currentPage));
}
std::string DescribeWebLockFileEventsRequest::getDealed() const {
return dealed_;
}
void DescribeWebLockFileEventsRequest::setDealed(const std::string &dealed) {
dealed_ = dealed;
setParameter(std::string("Dealed"), dealed);
}
long DescribeWebLockFileEventsRequest::getTsBegin() const {
return tsBegin_;
}
void DescribeWebLockFileEventsRequest::setTsBegin(long tsBegin) {
tsBegin_ = tsBegin;
setParameter(std::string("TsBegin"), std::to_string(tsBegin));
}

112
sas/src/model/DescribeWebLockFileEventsResult.cc Normal file
View File

@@ -0,0 +1,112 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/DescribeWebLockFileEventsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
DescribeWebLockFileEventsResult::DescribeWebLockFileEventsResult() :
ServiceResult()
{}
DescribeWebLockFileEventsResult::DescribeWebLockFileEventsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeWebLockFileEventsResult::~DescribeWebLockFileEventsResult()
{}
void DescribeWebLockFileEventsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allListNode = value["List"]["Info"];
for (auto valueListInfo : allListNode)
{
Info listObject;
if(!valueListInfo["Status"].isNull())
listObject.status = valueListInfo["Status"].asString();
if(!valueListInfo["EventName"].isNull())
listObject.eventName = valueListInfo["EventName"].asString();
if(!valueListInfo["Ds"].isNull())
listObject.ds = std::stol(valueListInfo["Ds"].asString());
if(!valueListInfo["InternetIp"].isNull())
listObject.internetIp = valueListInfo["InternetIp"].asString();
if(!valueListInfo["ProcessPath"].isNull())
listObject.processPath = valueListInfo["ProcessPath"].asString();
if(!valueListInfo["Ip"].isNull())
listObject.ip = valueListInfo["Ip"].asString();
if(!valueListInfo["GmtEvent"].isNull())
listObject.gmtEvent = std::stol(valueListInfo["GmtEvent"].asString());
if(!valueListInfo["Count"].isNull())
listObject.count = std::stol(valueListInfo["Count"].asString());
if(!valueListInfo["IntranetIp"].isNull())
listObject.intranetIp = valueListInfo["IntranetIp"].asString();
if(!valueListInfo["ProcessName"].isNull())
listObject.processName = valueListInfo["ProcessName"].asString();
if(!valueListInfo["Uuid"].isNull())
listObject.uuid = valueListInfo["Uuid"].asString();
if(!valueListInfo["EventType"].isNull())
listObject.eventType = valueListInfo["EventType"].asString();
if(!valueListInfo["InstanceName"].isNull())
listObject.instanceName = valueListInfo["InstanceName"].asString();
if(!valueListInfo["EventStatus"].isNull())
listObject.eventStatus = valueListInfo["EventStatus"].asString();
if(!valueListInfo["Path"].isNull())
listObject.path = valueListInfo["Path"].asString();
if(!valueListInfo["Solution"].isNull())
listObject.solution = valueListInfo["Solution"].asString();
if(!valueListInfo["Level"].isNull())
listObject.level = valueListInfo["Level"].asString();
if(!valueListInfo["Id"].isNull())
listObject.id = std::stol(valueListInfo["Id"].asString());
list_.push_back(listObject);
}
if(!value["CurrentPage"].isNull())
currentPage_ = std::stoi(value["CurrentPage"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeWebLockFileEventsResult::getTotalCount()const
{
return totalCount_;
}
int DescribeWebLockFileEventsResult::getPageSize()const
{
return pageSize_;
}
int DescribeWebLockFileEventsResult::getCurrentPage()const
{
return currentPage_;
}
std::vector<DescribeWebLockFileEventsResult::Info> DescribeWebLockFileEventsResult::getList()const
{
return list_;
}

4
sas/src/model/GetFileDetectResultResult.cc
View File

@@ -51,6 +51,10 @@ void GetFileDetectResultResult::parse(const std::string &payload)
resultListObject.score = std::stoi(valueResultListResult["Score"].asString());
if(!valueResultListResult["VirusType"].isNull())
resultListObject.virusType = valueResultListResult["VirusType"].asString();
if(!valueResultListResult["ErrorCode"].isNull())
resultListObject.errorCode = valueResultListResult["ErrorCode"].asString();
if(!valueResultListResult["ErrorMessage"].isNull())
resultListObject.errorMessage = valueResultListResult["ErrorMessage"].asString();
if(!valueResultListResult["Ext"].isNull())
resultListObject.ext = valueResultListResult["Ext"].asString();
resultList_.push_back(resultListObject);

89
sas/src/model/ListHoneypotAlarmEventsRequest.cc Normal file
View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/ListHoneypotAlarmEventsRequest.h>
using AlibabaCloud::Sas::Model::ListHoneypotAlarmEventsRequest;
ListHoneypotAlarmEventsRequest::ListHoneypotAlarmEventsRequest()
: RpcServiceRequest("sas", "2018-12-03", "ListHoneypotAlarmEvents") {
setMethod(HttpRequest::Method::Get);
}
ListHoneypotAlarmEventsRequest::~ListHoneypotAlarmEventsRequest() {}
std::string ListHoneypotAlarmEventsRequest::getSrcIp() const {
return srcIp_;
}
void ListHoneypotAlarmEventsRequest::setSrcIp(const std::string &srcIp) {
srcIp_ = srcIp;
setBodyParameter(std::string("SrcIp"), srcIp);
}
std::vector<std::string> ListHoneypotAlarmEventsRequest::getRiskLevelList() const {
return riskLevelList_;
}
void ListHoneypotAlarmEventsRequest::setRiskLevelList(const std::vector<std::string> &riskLevelList) {
riskLevelList_ = riskLevelList;
}
int ListHoneypotAlarmEventsRequest::getPageSize() const {
return pageSize_;
}
void ListHoneypotAlarmEventsRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListHoneypotAlarmEventsRequest::getDstIp() const {
return dstIp_;
}
void ListHoneypotAlarmEventsRequest::setDstIp(const std::string &dstIp) {
dstIp_ = dstIp;
setBodyParameter(std::string("DstIp"), dstIp);
}
std::string ListHoneypotAlarmEventsRequest::getDealed() const {
return dealed_;
}
void ListHoneypotAlarmEventsRequest::setDealed(const std::string &dealed) {
dealed_ = dealed;
setBodyParameter(std::string("Dealed"), dealed);
}
int ListHoneypotAlarmEventsRequest::getCurrentPage() const {
return currentPage_;
}
void ListHoneypotAlarmEventsRequest::setCurrentPage(int currentPage) {
currentPage_ = currentPage;
setBodyParameter(std::string("CurrentPage"), std::to_string(currentPage));
}
std::string ListHoneypotAlarmEventsRequest::getRequestId() const {
return requestId_;
}
void ListHoneypotAlarmEventsRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setBodyParameter(std::string("RequestId"), requestId);
}

105
sas/src/model/ListHoneypotAlarmEventsResult.cc Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/ListHoneypotAlarmEventsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
ListHoneypotAlarmEventsResult::ListHoneypotAlarmEventsResult() :
ServiceResult()
{}
ListHoneypotAlarmEventsResult::ListHoneypotAlarmEventsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListHoneypotAlarmEventsResult::~ListHoneypotAlarmEventsResult()
{}
void ListHoneypotAlarmEventsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allHoneypotAlarmEventsNode = value["HoneypotAlarmEvents"]["HoneypotAlarmEvent"];
for (auto valueHoneypotAlarmEventsHoneypotAlarmEvent : allHoneypotAlarmEventsNode)
{
HoneypotAlarmEvent honeypotAlarmEventsObject;
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmEventId"].isNull())
honeypotAlarmEventsObject.alarmEventId = std::stol(valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmEventId"].asString());
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmEventType"].isNull())
honeypotAlarmEventsObject.alarmEventType = valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmEventType"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmEventName"].isNull())
honeypotAlarmEventsObject.alarmEventName = valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmEventName"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmUniqueInfo"].isNull())
honeypotAlarmEventsObject.alarmUniqueInfo = valueHoneypotAlarmEventsHoneypotAlarmEvent["AlarmUniqueInfo"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["FirstTime"].isNull())
honeypotAlarmEventsObject.firstTime = std::stol(valueHoneypotAlarmEventsHoneypotAlarmEvent["FirstTime"].asString());
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["LastTime"].isNull())
honeypotAlarmEventsObject.lastTime = std::stol(valueHoneypotAlarmEventsHoneypotAlarmEvent["LastTime"].asString());
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["RiskLevel"].isNull())
honeypotAlarmEventsObject.riskLevel = valueHoneypotAlarmEventsHoneypotAlarmEvent["RiskLevel"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["EventCount"].isNull())
honeypotAlarmEventsObject.eventCount = std::stoi(valueHoneypotAlarmEventsHoneypotAlarmEvent["EventCount"].asString());
if(!valueHoneypotAlarmEventsHoneypotAlarmEvent["OperateStatus"].isNull())
honeypotAlarmEventsObject.operateStatus = std::stoi(valueHoneypotAlarmEventsHoneypotAlarmEvent["OperateStatus"].asString());
auto allMergeFieldListNode = valueHoneypotAlarmEventsHoneypotAlarmEvent["MergeFieldList"]["MergeFieldListItem"];
for (auto valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem : allMergeFieldListNode)
{
HoneypotAlarmEvent::MergeFieldListItem mergeFieldListObject;
if(!valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldType"].isNull())
mergeFieldListObject.fieldType = valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldType"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldKey"].isNull())
mergeFieldListObject.fieldKey = valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldKey"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldValue"].isNull())
mergeFieldListObject.fieldValue = valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldValue"].asString();
if(!valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldExtInfo"].isNull())
mergeFieldListObject.fieldExtInfo = valueHoneypotAlarmEventsHoneypotAlarmEventMergeFieldListMergeFieldListItem["FieldExtInfo"].asString();
honeypotAlarmEventsObject.mergeFieldList.push_back(mergeFieldListObject);
}
honeypotAlarmEvents_.push_back(honeypotAlarmEventsObject);
}
auto pageInfoNode = value["PageInfo"];
if(!pageInfoNode["CurrentPage"].isNull())
pageInfo_.currentPage = std::stoi(pageInfoNode["CurrentPage"].asString());
if(!pageInfoNode["PageSize"].isNull())
pageInfo_.pageSize = std::stoi(pageInfoNode["PageSize"].asString());
if(!pageInfoNode["TotalCount"].isNull())
pageInfo_.totalCount = std::stoi(pageInfoNode["TotalCount"].asString());
if(!pageInfoNode["Count"].isNull())
pageInfo_.count = std::stoi(pageInfoNode["Count"].asString());
if(!pageInfoNode["LastRowKey"].isNull())
pageInfo_.lastRowKey = pageInfoNode["LastRowKey"].asString();
if(!pageInfoNode["NextToken"].isNull())
pageInfo_.nextToken = pageInfoNode["NextToken"].asString();
}
ListHoneypotAlarmEventsResult::PageInfo ListHoneypotAlarmEventsResult::getPageInfo()const
{
return pageInfo_;
}
std::vector<ListHoneypotAlarmEventsResult::HoneypotAlarmEvent> ListHoneypotAlarmEventsResult::getHoneypotAlarmEvents()const
{
return honeypotAlarmEvents_;
}

72
sas/src/model/ListHoneypotNodeRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/ListHoneypotNodeRequest.h>
using AlibabaCloud::Sas::Model::ListHoneypotNodeRequest;
ListHoneypotNodeRequest::ListHoneypotNodeRequest()
: RpcServiceRequest("sas", "2018-12-03", "ListHoneypotNode") {
setMethod(HttpRequest::Method::Post);
}
ListHoneypotNodeRequest::~ListHoneypotNodeRequest() {}
int ListHoneypotNodeRequest::getPageSize() const {
return pageSize_;
}
void ListHoneypotNodeRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListHoneypotNodeRequest::getLang() const {
return lang_;
}
void ListHoneypotNodeRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string ListHoneypotNodeRequest::getNodeId() const {
return nodeId_;
}
void ListHoneypotNodeRequest::setNodeId(const std::string &nodeId) {
nodeId_ = nodeId;
setParameter(std::string("NodeId"), nodeId);
}
int ListHoneypotNodeRequest::getCurrentPage() const {
return currentPage_;
}
void ListHoneypotNodeRequest::setCurrentPage(int currentPage) {
currentPage_ = currentPage;
setParameter(std::string("CurrentPage"), std::to_string(currentPage));
}
std::string ListHoneypotNodeRequest::getNodeName() const {
return nodeName_;
}
void ListHoneypotNodeRequest::setNodeName(const std::string &nodeName) {
nodeName_ = nodeName;
setParameter(std::string("NodeName"), nodeName);
}

128
sas/src/model/ListHoneypotNodeResult.cc Normal file
View File

@@ -0,0 +1,128 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/ListHoneypotNodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
ListHoneypotNodeResult::ListHoneypotNodeResult() :
ServiceResult()
{}
ListHoneypotNodeResult::ListHoneypotNodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListHoneypotNodeResult::~ListHoneypotNodeResult()
{}
void ListHoneypotNodeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allHoneypotNodeListNode = value["HoneypotNodeList"]["List"];
for (auto valueHoneypotNodeListList : allHoneypotNodeListNode)
{
List honeypotNodeListObject;
if(!valueHoneypotNodeListList["NodeId"].isNull())
honeypotNodeListObject.nodeId = valueHoneypotNodeListList["NodeId"].asString();
if(!valueHoneypotNodeListList["NodeName"].isNull())
honeypotNodeListObject.nodeName = valueHoneypotNodeListList["NodeName"].asString();
if(!valueHoneypotNodeListList["NodeVersion"].isNull())
honeypotNodeListObject.nodeVersion = valueHoneypotNodeListList["NodeVersion"].asString();
if(!valueHoneypotNodeListList["HoneypotTotalCount"].isNull())
honeypotNodeListObject.honeypotTotalCount = std::stoi(valueHoneypotNodeListList["HoneypotTotalCount"].asString());
if(!valueHoneypotNodeListList["HoneypotUsedCount"].isNull())
honeypotNodeListObject.honeypotUsedCount = std::stoi(valueHoneypotNodeListList["HoneypotUsedCount"].asString());
if(!valueHoneypotNodeListList["ProbeTotalCount"].isNull())
honeypotNodeListObject.probeTotalCount = std::stoi(valueHoneypotNodeListList["ProbeTotalCount"].asString());
if(!valueHoneypotNodeListList["ProbeUsedCount"].isNull())
honeypotNodeListObject.probeUsedCount = std::stoi(valueHoneypotNodeListList["ProbeUsedCount"].asString());
if(!valueHoneypotNodeListList["TotalStatus"].isNull())
honeypotNodeListObject.totalStatus = std::stoi(valueHoneypotNodeListList["TotalStatus"].asString());
if(!valueHoneypotNodeListList["EcsInstanceId"].isNull())
honeypotNodeListObject.ecsInstanceId = valueHoneypotNodeListList["EcsInstanceId"].asString();
if(!valueHoneypotNodeListList["CreateTime"].isNull())
honeypotNodeListObject.createTime = valueHoneypotNodeListList["CreateTime"].asString();
if(!valueHoneypotNodeListList["AllowHoneypotAccessInternet"].isNull())
honeypotNodeListObject.allowHoneypotAccessInternet = valueHoneypotNodeListList["AllowHoneypotAccessInternet"].asString() == "true";
if(!valueHoneypotNodeListList["DefaultNode"].isNull())
honeypotNodeListObject.defaultNode = valueHoneypotNodeListList["DefaultNode"].asString() == "true";
if(!valueHoneypotNodeListList["NodeIp"].isNull())
honeypotNodeListObject.nodeIp = valueHoneypotNodeListList["NodeIp"].asString();
auto allSecurityGroupProbeIpList = value["SecurityGroupProbeIpList"]["SecurityGroupProbeIp"];
for (auto value : allSecurityGroupProbeIpList)
honeypotNodeListObject.securityGroupProbeIpList.push_back(value.asString());
honeypotNodeList_.push_back(honeypotNodeListObject);
}
auto pageInfoNode = value["PageInfo"];
if(!pageInfoNode["CurrentPage"].isNull())
pageInfo_.currentPage = std::stoi(pageInfoNode["CurrentPage"].asString());
if(!pageInfoNode["PageSize"].isNull())
pageInfo_.pageSize = std::stoi(pageInfoNode["PageSize"].asString());
if(!pageInfoNode["TotalCount"].isNull())
pageInfo_.totalCount = std::stoi(pageInfoNode["TotalCount"].asString());
if(!pageInfoNode["Count"].isNull())
pageInfo_.count = std::stoi(pageInfoNode["Count"].asString());
if(!pageInfoNode["LastRowKey"].isNull())
pageInfo_.lastRowKey = pageInfoNode["LastRowKey"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
}
ListHoneypotNodeResult::PageInfo ListHoneypotNodeResult::getPageInfo()const
{
return pageInfo_;
}
std::vector<ListHoneypotNodeResult::List> ListHoneypotNodeResult::getHoneypotNodeList()const
{
return honeypotNodeList_;
}
std::string ListHoneypotNodeResult::getMessage()const
{
return message_;
}
int ListHoneypotNodeResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string ListHoneypotNodeResult::getCode()const
{
return code_;
}
bool ListHoneypotNodeResult::getSuccess()const
{
return success_;
}

89
sas/src/model/ListHoneypotRequest.cc Normal file
View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/ListHoneypotRequest.h>
using AlibabaCloud::Sas::Model::ListHoneypotRequest;
ListHoneypotRequest::ListHoneypotRequest()
: RpcServiceRequest("sas", "2018-12-03", "ListHoneypot") {
setMethod(HttpRequest::Method::Post);
}
ListHoneypotRequest::~ListHoneypotRequest() {}
std::string ListHoneypotRequest::getHoneypotName() const {
return honeypotName_;
}
void ListHoneypotRequest::setHoneypotName(const std::string &honeypotName) {
honeypotName_ = honeypotName;
setParameter(std::string("HoneypotName"), honeypotName);
}
int ListHoneypotRequest::getPageSize() const {
return pageSize_;
}
void ListHoneypotRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListHoneypotRequest::getLang() const {
return lang_;
}
void ListHoneypotRequest::setLang(const std::string &lang) {
lang_ = lang;
setParameter(std::string("Lang"), lang);
}
std::string ListHoneypotRequest::getNodeId() const {
return nodeId_;
}
void ListHoneypotRequest::setNodeId(const std::string &nodeId) {
nodeId_ = nodeId;
setParameter(std::string("NodeId"), nodeId);
}
int ListHoneypotRequest::getCurrentPage() const {
return currentPage_;
}
void ListHoneypotRequest::setCurrentPage(int currentPage) {
currentPage_ = currentPage;
setParameter(std::string("CurrentPage"), std::to_string(currentPage));
}
std::string ListHoneypotRequest::getNodeName() const {
return nodeName_;
}
void ListHoneypotRequest::setNodeName(const std::string &nodeName) {
nodeName_ = nodeName;
setParameter(std::string("NodeName"), nodeName);
}
std::vector<std::string> ListHoneypotRequest::getHoneypotIds() const {
return honeypotIds_;
}
void ListHoneypotRequest::setHoneypotIds(const std::vector<std::string> &honeypotIds) {
honeypotIds_ = honeypotIds;
}

116
sas/src/model/ListHoneypotResult.cc Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/sas/model/ListHoneypotResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sas;
using namespace AlibabaCloud::Sas::Model;
ListHoneypotResult::ListHoneypotResult() :
ServiceResult()
{}
ListHoneypotResult::ListHoneypotResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListHoneypotResult::~ListHoneypotResult()
{}
void ListHoneypotResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allListNode = value["List"]["ListItem"];
for (auto valueListListItem : allListNode)
{
ListItem listObject;
if(!valueListListItem["HoneypotId"].isNull())
listObject.honeypotId = valueListListItem["HoneypotId"].asString();
if(!valueListListItem["HoneypotName"].isNull())
listObject.honeypotName = valueListListItem["HoneypotName"].asString();
if(!valueListListItem["ControlNodeName"].isNull())
listObject.controlNodeName = valueListListItem["ControlNodeName"].asString();
if(!valueListListItem["HoneypotImageName"].isNull())
listObject.honeypotImageName = valueListListItem["HoneypotImageName"].asString();
if(!valueListListItem["PresetId"].isNull())
listObject.presetId = valueListListItem["PresetId"].asString();
if(!valueListListItem["HoneypotImageDisplayName"].isNull())
listObject.honeypotImageDisplayName = valueListListItem["HoneypotImageDisplayName"].asString();
if(!valueListListItem["NodeId"].isNull())
listObject.nodeId = valueListListItem["NodeId"].asString();
auto allState = value["State"]["State"];
for (auto value : allState)
listObject.state.push_back(value.asString());
list_.push_back(listObject);
}
auto pageInfoNode = value["PageInfo"];
if(!pageInfoNode["CurrentPage"].isNull())
pageInfo_.currentPage = std::stoi(pageInfoNode["CurrentPage"].asString());
if(!pageInfoNode["PageSize"].isNull())
pageInfo_.pageSize = std::stoi(pageInfoNode["PageSize"].asString());
if(!pageInfoNode["TotalCount"].isNull())
pageInfo_.totalCount = std::stoi(pageInfoNode["TotalCount"].asString());
if(!pageInfoNode["Count"].isNull())
pageInfo_.count = std::stoi(pageInfoNode["Count"].asString());
if(!pageInfoNode["LastRowKey"].isNull())
pageInfo_.lastRowKey = pageInfoNode["LastRowKey"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
}
ListHoneypotResult::PageInfo ListHoneypotResult::getPageInfo()const
{
return pageInfo_;
}
std::string ListHoneypotResult::getMessage()const
{
return message_;
}
int ListHoneypotResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::vector<ListHoneypotResult::ListItem> ListHoneypotResult::getList()const
{
return list_;
}
std::string ListHoneypotResult::getCode()const
{
return code_;
}
bool ListHoneypotResult::getSuccess()const
{
return success_;
}