lvfengfree/serverRoom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: AMT Scanner with remote desktop, power management, and hardware info

Browse Source
This commit is contained in:
lvfengfree 2026-01-20 12:56:20 +08:00
commit 49a7bb41b6
16719 changed files with 3276981 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
.gitignore vendored Normal file
View File

@ -0,0 +1,57 @@
# Node.js
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Build outputs
dist/
build/
*.dll
*.exe
*.pdb
# .NET
bin/
obj/
*.user
*.suo
*.userosscache
*.sln.docstates
packages/
*.nupkg
# IDE
.idea/
.vscode/
*.swp
*.swo
*~
# OS
.DS_Store
Thumbs.db
# Logs
logs/
*.log
# Environment
.env
.env.local
.env.*.local
# Database
*.db
*.sqlite
# Guacamole data (keep config, ignore runtime data)
guacamole/init/initdb.sql
# RDP session data
rdp/data/
rdp/log/
# Temp files
*.tmp
*.temp

659
.kiro/specs/amt-hardware-info/design.md Normal file
View File

@ -0,0 +1,659 @@
# Design Document: AMT Hardware Information Query
## Overview
本设计文档描述了如何实现通过 Intel AMT 技术远程查询设备硬件配置信息的功能。系统将使用 Intel AMT SDK 的 WS-Management 接口查询 CIM (Common Information Model) 类，获取 CPU、内存、存储设备等硬件信息，并通过 RESTful API 提供给前端展示。
## Architecture
### System Architecture
```
┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐
│ │ │ │ │ │
│ Vue Frontend │◄───────►│ C# Backend │◄───────►│ AMT Device │
│ │ HTTP │ (ASP.NET Core) │ WSMAN │ (CIM Classes) │
│ │ │ │ │ │
└─────────────────┘ └──────────────────┘ └─────────────────┘
│
▼
┌──────────────────┐
│ │
│ MySQL Database │
│ (Cache) │
│ │
└──────────────────┘
```
### Component Diagram
```
Backend Components:
┌────────────────────────────────────────────────────────────┐
│ │
│ ┌──────────────────┐ │
│ │ HardwareInfo │ │
│ │ Controller │ │
│ └────────┬─────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ HardwareInfo │────────►│ AMT Connection │ │
│ │ Service │ │ Service │ │
│ └────────┬─────────┘ └──────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Hardware Info │ │
│ │ Repository │ │
│ └──────────────────┘ │
│ │
└────────────────────────────────────────────────────────────┘
```
## Components and Interfaces
### 1. Backend Components
#### 1.1 HardwareInfoController
**Responsibility**: 处理硬件信息查询的 HTTP 请求
**Endpoints**:
```csharp
// 查询单个设备的硬件信息
GET /api/hardware-info/{deviceId}
Query Parameters:
- refresh: bool (是否强制刷新，默认 false)
Response:
{
"deviceId": 1,
"ipAddress": "192.168.8.111",
"lastUpdated": "2024-01-19T10:30:00Z",
"systemInfo": {
"manufacturer": "Dell Inc.",
"model": "OptiPlex 7090",
"serialNumber": "ABC123456"
},
"processor": {
"model": "Intel Core i7-10700",
"cores": 8,
"threads": 16,
"maxClockSpeed": 2900,
"currentClockSpeed": 2900
},
"memory": {
"totalCapacity": 17179869184, // bytes
"totalCapacityGB": 16,
"modules": [
{
"slot": "DIMM_A1",
"capacity": 8589934592,
"capacityGB": 8,
"speed": 2933,
"type": "DDR4",
"manufacturer": "Samsung",
"partNumber": "M378A1K43CB2-CVF"
},
{
"slot": "DIMM_A2",
"capacity": 8589934592,
"capacityGB": 8,
"speed": 2933,
"type": "DDR4",
"manufacturer": "Samsung",
"partNumber": "M378A1K43CB2-CVF"
}
]
},
"storage": {
"devices": [
{
"deviceId": "0",
"model": "Samsung SSD 970 EVO Plus 500GB",
"capacity": 500107862016,
"capacityGB": 465,
"interfaceType": "NVMe"
}
]
}
}
// 批量查询多个设备的硬件信息
POST /api/hardware-info/batch
Request Body:
{
"deviceIds": [1, 2, 3],
"refresh": false
}
Response:
{
"results": [
{
"deviceId": 1,
"success": true,
"data": { /* hardware info */ }
},
{
"deviceId": 2,
"success": false,
"error": "Connection timeout"
}
]
}
// 导出硬件信息为 CSV
GET /api/hardware-info/export
Query Parameters:
- deviceIds: string (逗号分隔的设备 ID)
- format: string (csv 或 json)
Response: File download
```
#### 1.2 HardwareInfoService
**Responsibility**: 业务逻辑层，协调硬件信息查询和缓存
**Methods**:
```csharp
public interface IHardwareInfoService
{
Task<HardwareInfo> GetHardwareInfoAsync(int deviceId, bool forceRefresh = false);
Task<List<BatchHardwareInfoResult>> GetBatchHardwareInfoAsync(List<int> deviceIds, bool forceRefresh = false);
Task<HardwareInfo> QueryHardwareInfoFromDeviceAsync(string ipAddress, string username, string password);
Task<byte[]> ExportHardwareInfoAsync(List<int> deviceIds, ExportFormat format);
}
```
**Implementation Details**:
- 检查缓存是否存在且未过期（24小时）
- 如果缓存有效且不强制刷新，返回缓存数据
- 否则，调用 AMT 设备查询硬件信息
- 将查询结果保存到数据库
- 处理查询失败的情况，返回部分可用信息
#### 1.3 AmtHardwareQueryService
**Responsibility**: 使用 Intel AMT SDK 查询硬件信息
**Methods**:
```csharp
public interface IAmtHardwareQueryService
{
Task<SystemInfo> QuerySystemInfoAsync(IWsmanConnection connection);
Task<ProcessorInfo> QueryProcessorInfoAsync(IWsmanConnection connection);
Task<MemoryInfo> QueryMemoryInfoAsync(IWsmanConnection connection);
Task<StorageInfo> QueryStorageInfoAsync(IWsmanConnection connection);
}
```
**CIM Query Details**:
1. **System Information** (CIM_ComputerSystem):
```csharp
var query = connection.ExecQuery("SELECT * FROM CIM_ComputerSystem WHERE Name='ManagedSystem'");
foreach (IWsmanItem item in query)
{
var manufacturer = item.Object.GetProperty("Manufacturer").ToString();
var model = item.Object.GetProperty("Model").ToString();
// ...
}
```
2. **Processor Information** (CIM_Processor via CIM_Realizes):
```csharp
var query = connection.ExecQuery("SELECT * FROM CIM_Realizes");
foreach (IWsmanItem item in query)
{
if (item.Object.GetProperty("Dependent").IsA("CIM_Processor"))
{
var cpuObj = item.Object.GetProperty("Dependent").Ref.Get();
var family = cpuObj.GetProperty("Family").ToString();
var maxClockSpeed = cpuObj.GetProperty("MaxClockSpeed").ToString();
var currentClockSpeed = cpuObj.GetProperty("CurrentClockSpeed").ToString();
// ...
}
}
```
3. **Memory Information** (CIM_PhysicalMemory):
```csharp
var query = connection.ExecQuery("SELECT * FROM CIM_PhysicalMemory");
foreach (IWsmanItem item in query)
{
var tag = item.Object.GetProperty("Tag").ToString();
var bankLabel = item.Object.GetProperty("BankLabel").ToString();
var capacity = item.Object.GetProperty("Capacity").ToString();
var speed = item.Object.GetProperty("Speed").ToString();
var memoryType = item.Object.GetProperty("MemoryType").ToString();
var manufacturer = item.Object.GetProperty("Manufacturer").ToString();
var partNumber = item.Object.GetProperty("PartNumber").ToString();
// ...
}
```
4. **Storage Information** (CIM_MediaAccessDevice):
```csharp
var query = connection.ExecQuery("SELECT * FROM CIM_MediaAccessDevice");
foreach (IWsmanItem item in query)
{
var deviceId = item.Object.GetProperty("DeviceID").ToString();
var caption = item.Object.GetProperty("Caption").ToString();
var capacity = item.Object.GetProperty("MaxMediaSize").ToString();
// ...
}
```
#### 1.4 HardwareInfoRepository
**Responsibility**: 数据访问层，管理硬件信息的持久化
**Methods**:
```csharp
public interface IHardwareInfoRepository
{
Task<HardwareInfo?> GetByDeviceIdAsync(int deviceId);
Task SaveAsync(HardwareInfo hardwareInfo);
Task<List<HardwareInfo>> GetByDeviceIdsAsync(List<int> deviceIds);
Task DeleteByDeviceIdAsync(int deviceId);
}
```
### 2. Data Models
#### 2.1 Database Schema
```sql
-- 硬件信息主表
CREATE TABLE HardwareInfo (
Id INT PRIMARY KEY AUTO_INCREMENT,
DeviceId INT NOT NULL,
LastUpdated DATETIME NOT NULL,
SystemManufacturer VARCHAR(200),
SystemModel VARCHAR(200),
SystemSerialNumber VARCHAR(200),
ProcessorModel VARCHAR(500),
ProcessorCores INT,
ProcessorThreads INT,
ProcessorMaxClockSpeed INT,
ProcessorCurrentClockSpeed INT,
TotalMemoryBytes BIGINT,
CreatedAt DATETIME NOT NULL,
UpdatedAt DATETIME NOT NULL,
FOREIGN KEY (DeviceId) REFERENCES AmtDevices(Id) ON DELETE CASCADE,
INDEX idx_device_id (DeviceId),
INDEX idx_last_updated (LastUpdated)
);
-- 内存模块表
CREATE TABLE MemoryModules (
Id INT PRIMARY KEY AUTO_INCREMENT,
HardwareInfoId INT NOT NULL,
SlotLocation VARCHAR(100),
CapacityBytes BIGINT,
SpeedMHz INT,
MemoryType VARCHAR(50),
Manufacturer VARCHAR(200),
PartNumber VARCHAR(200),
SerialNumber VARCHAR(200),
FOREIGN KEY (HardwareInfoId) REFERENCES HardwareInfo(Id) ON DELETE CASCADE
);
-- 存储设备表
CREATE TABLE StorageDevices (
Id INT PRIMARY KEY AUTO_INCREMENT,
HardwareInfoId INT NOT NULL,
DeviceId VARCHAR(100),
Model VARCHAR(500),
CapacityBytes BIGINT,
InterfaceType VARCHAR(50),
FOREIGN KEY (HardwareInfoId) REFERENCES HardwareInfo(Id) ON DELETE CASCADE
);
```
#### 2.2 C# Models
```csharp
public class HardwareInfo
{
public int Id { get; set; }
public int DeviceId { get; set; }
public DateTime LastUpdated { get; set; }
public SystemInfo SystemInfo { get; set; }
public ProcessorInfo Processor { get; set; }
public MemoryInfo Memory { get; set; }
public StorageInfo Storage { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
// Navigation property
public AmtDevice Device { get; set; }
}
public class SystemInfo
{
public string Manufacturer { get; set; }
public string Model { get; set; }
public string SerialNumber { get; set; }
}
public class ProcessorInfo
{
public string Model { get; set; }
public int Cores { get; set; }
public int Threads { get; set; }
public int MaxClockSpeed { get; set; } // MHz
public int CurrentClockSpeed { get; set; } // MHz
}
public class MemoryInfo
{
public long TotalCapacity { get; set; } // bytes
public int TotalCapacityGB { get; set; }
public List<MemoryModule> Modules { get; set; }
}
public class MemoryModule
{
public int Id { get; set; }
public int HardwareInfoId { get; set; }
public string Slot { get; set; }
public long Capacity { get; set; } // bytes
public int CapacityGB { get; set; }
public int Speed { get; set; } // MHz
public string Type { get; set; } // DDR3, DDR4, etc.
public string Manufacturer { get; set; }
public string PartNumber { get; set; }
public string SerialNumber { get; set; }
}
public class StorageInfo
{
public List<StorageDevice> Devices { get; set; }
}
public class StorageDevice
{
public int Id { get; set; }
public int HardwareInfoId { get; set; }
public string DeviceId { get; set; }
public string Model { get; set; }
public long Capacity { get; set; } // bytes
public int CapacityGB { get; set; }
public string InterfaceType { get; set; } // SATA, NVMe, etc.
}
```
### 3. Frontend Components
#### 3.1 HardwareInfoModal.vue
**Responsibility**: 显示单个设备的硬件信息弹窗
**Features**:
- 分组显示系统信息、CPU、内存、存储
- 显示最后更新时间
- 提供刷新按钮
- 提供导出按钮
- 加载状态和错误处理
**Template Structure**:
```vue
<template>
<div class="hardware-info-modal">
<div class="modal-header">
<h2>硬件配置信息 - {{ deviceIp }}</h2>
<button @click="refresh">刷新</button>
<button @click="exportInfo">导出</button>
</div>
<div class="modal-body">
<!-- System Info Section -->
<section class="info-section">
<h3>系统信息</h3>
<div class="info-grid">
<div class="info-item">
<label>制造商:</label>
<span>{{ hardwareInfo.systemInfo.manufacturer }}</span>
</div>
<!-- ... -->
</div>
</section>
<!-- Processor Section -->
<section class="info-section">
<h3>处理器</h3>
<!-- ... -->
</section>
<!-- Memory Section -->
<section class="info-section">
<h3>内存</h3>
<div class="memory-summary">
总容量: {{ hardwareInfo.memory.totalCapacityGB }} GB
</div>
<table class="memory-table">
<thead>
<tr>
<th>插槽</th>
<th>容量</th>
<th>速度</th>
<th>类型</th>
<th>制造商</th>
</tr>
</thead>
<tbody>
<tr v-for="module in hardwareInfo.memory.modules" :key="module.slot">
<!-- ... -->
</tr>
</tbody>
</table>
</section>
<!-- Storage Section -->
<section class="info-section">
<h3>存储设备</h3>
<!-- ... -->
</section>
</div>
<div class="modal-footer">
<span class="last-updated">
最后更新: {{ formatDate(hardwareInfo.lastUpdated) }}
</span>
</div>
</div>
</template>
```
#### 3.2 DeviceList.vue (Updated)
**Changes**: 添加"查看硬件"按钮
```vue
<template>
<tr v-for="device in devices" :key="device.id">
<!-- existing columns -->
<td>
<button @click="viewHardwareInfo(device.id)">查看硬件</button>
<button @click="deleteDevice(device.id)">删除</button>
</td>
</tr>
</template>
```
#### 3.3 BatchHardwareExport.vue
**Responsibility**: 批量导出硬件信息
**Features**:
- 选择多个设备
- 选择导出格式（CSV/JSON）
- 显示导出进度
- 下载文件
## Error Handling
### Error Scenarios and Handling
1. **设备连接失败**
- Retry: 重试 1 次
- Fallback: 返回错误信息，标记为不可用
- User Message: "无法连接到设备，请检查设备是否在线"
2. **CIM 类不支持**
- Retry: 不重试
- Fallback: 跳过该组件，继续查询其他组件
- User Message: 显示"不支持"或"信息不可用"
3. **查询超时**
- Timeout: 30 秒
- Retry: 不重试
- Fallback: 返回已获取的部分信息
- User Message: "查询超时，部分信息可能不完整"
4. **数据解析错误**
- Retry: 不重试
- Fallback: 使用默认值或跳过该字段
- Logging: 记录详细错误日志
- User Message: "部分信息解析失败"
5. **数据库保存失败**
- Retry: 重试 2 次
- Fallback: 返回查询结果但不缓存
- Logging: 记录错误
- User Message: "信息已获取但缓存失败"
## Testing Strategy
### Unit Tests
1. **AmtHardwareQueryService Tests**
- Test CIM query construction
- Test data parsing from CIM objects
- Test error handling for missing properties
- Test handling of null values
2. **HardwareInfoService Tests**
- Test cache hit/miss logic
- Test force refresh behavior
- Test batch query coordination
- Test error aggregation
3. **HardwareInfoRepository Tests**
- Test CRUD operations
- Test foreign key constraints
- Test cascade deletes
### Integration Tests
1. **End-to-End Hardware Query**
- Test complete flow from API to AMT device
- Test with real AMT device (if available)
- Test with mock AMT responses
2. **Batch Query Performance**
- Test querying 10+ devices simultaneously
- Verify no resource leaks
- Verify proper error isolation
### Manual Testing Checklist
- [ ] Query hardware info from HTTP device (192.168.8.111)
- [ ] Query hardware info from HTTPS device (192.168.8.112)
- [ ] Verify cache works correctly
- [ ] Test force refresh
- [ ] Test batch query with mixed success/failure
- [ ] Test export to CSV
- [ ] Test export to JSON
- [ ] Verify UI displays all information correctly
- [ ] Test with device that doesn't support all CIM classes
- [ ] Test error messages are user-friendly
## Performance Considerations
1. **Query Optimization**
- Query all CIM classes in parallel using Task.WhenAll
- Set reasonable timeout (30 seconds per device)
- Use connection pooling for database
2. **Caching Strategy**
- Cache hardware info for 24 hours
- Invalidate cache on force refresh
- Use database indexes on DeviceId and LastUpdated
3. **Batch Query**
- Limit concurrent queries to 10 devices at a time
- Use SemaphoreSlim to control concurrency
- Return results as they complete (streaming)
4. **Memory Management**
- Dispose WsmanConnection properly
- Use streaming for large exports
- Limit result set size
## Security Considerations
1. **Authentication**
- Reuse existing AMT credentials from database
- Decrypt passwords only when needed
- Never log passwords
2. **Authorization**
- Verify user has permission to view device info
- Implement role-based access control
3. **Data Protection**
- Sanitize serial numbers if needed
- Consider masking sensitive hardware info
4. **Input Validation**
- Validate device IDs
- Validate export format parameters
- Prevent SQL injection in queries
## Deployment Considerations
1. **Database Migration**
- Create migration for new tables
- Add foreign key constraints
- Create indexes
2. **Configuration**
- Add cache expiration setting to appsettings.json
- Add query timeout setting
- Add batch query concurrency limit
3. **Monitoring**
- Log query success/failure rates
- Monitor query duration
- Alert on high failure rates
## Future Enhancements
1. **Additional Hardware Info**
- Network adapters (CIM_NetworkAdapter)
- BIOS information (CIM_BIOSElement)
- Chassis information (CIM_Chassis)
- Fan and temperature sensors
2. **Hardware Change Detection**
- Compare current vs. cached hardware info
- Alert on hardware changes
- Track hardware change history
3. **Hardware Inventory Reports**
- Generate PDF reports
- Schedule automatic inventory scans
- Hardware lifecycle management
4. **Performance Metrics**
- Track query performance over time
- Identify slow devices
- Optimize query patterns

178
.kiro/specs/amt-hardware-info/requirements.md Normal file
View File

@ -0,0 +1,178 @@
# Requirements Document
## Introduction
本文档定义了机房远程控制系统中查看 AMT 设备硬件配置信息的需求。该功能允许系统管理员通过 Intel AMT 技术远程查询设备的硬件配置，包括 CPU 型号、内存插槽使用情况、内存大小、硬盘信息等，无需物理接触设备即可获取详细的硬件清单。
## Glossary
- **Hardware_Info_Service**: 负责查询和管理 AMT 设备硬件信息的系统组件
- **CIM**: Common Information Model，通用信息模型，DMTF 定义的标准化管理信息模型
- **WS-Management**: Web Services for Management，基于 Web 服务的管理协议
- **AMT_Device**: 支持 Intel AMT 技术的设备
- **Hardware_Inventory**: 硬件清单，包含设备的所有硬件组件信息
- **Memory_Module**: 内存模块，代表一条物理内存条
- **Storage_Device**: 存储设备，代表硬盘或 SSD
- **Processor**: 处理器，代表 CPU
## Requirements
### Requirement 1: 硬件信息查询入口
**User Story:** 作为系统管理员，我希望能够从设备列表中选择一个设备并查看其硬件配置，以便了解设备的硬件规格。
#### Acceptance Criteria
1. WHEN 用户查看设备列表，THEN THE Frontend SHALL 在每个设备行显示"查看硬件信息"按钮或链接
2. WHEN 用户点击"查看硬件信息"按钮，THEN THE Frontend SHALL 向后端发送硬件信息查询请求
3. WHEN 查询请求发送，THEN THE Frontend SHALL 显示加载状态指示器
4. WHEN 后端返回硬件信息，THEN THE Frontend SHALL 显示硬件配置详情页面或弹窗
5. WHEN 查询失败，THEN THE Frontend SHALL 显示友好的错误提示信息
### Requirement 2: CPU 信息查询
**User Story:** 作为系统管理员，我希望能够查看设备的 CPU 型号和规格，以便了解设备的处理能力。
#### Acceptance Criteria
1. WHEN 查询硬件信息，THEN THE Hardware_Info_Service SHALL 通过 WS-Management 查询 CIM_Processor 类
2. WHEN 获取 CPU 信息，THEN THE Hardware_Info_Service SHALL 提取 CPU 型号（Name 或 Family）
3. WHEN 获取 CPU 信息，THEN THE Hardware_Info_Service SHALL 提取 CPU 核心数（NumberOfCores）
4. WHEN 获取 CPU 信息，THEN THE Hardware_Info_Service SHALL 提取 CPU 主频（MaxClockSpeed）
5. WHEN 显示 CPU 信息，THEN THE Frontend SHALL 以清晰的格式展示 CPU 型号、核心数和主频
### Requirement 3: 内存信息查询
**User Story:** 作为系统管理员，我希望能够查看设备的内存配置，包括插槽使用情况和总容量，以便规划内存升级。
#### Acceptance Criteria
1. WHEN 查询硬件信息，THEN THE Hardware_Info_Service SHALL 通过 WS-Management 查询 CIM_PhysicalMemory 类
2. WHEN 获取内存信息，THEN THE Hardware_Info_Service SHALL 列出所有已安装的内存模块
3. WHEN 获取内存模块信息，THEN THE Hardware_Info_Service SHALL 提取每个模块的容量（Capacity）
4. WHEN 获取内存模块信息，THEN THE Hardware_Info_Service SHALL 提取每个模块的插槽位置（DeviceLocator 或 BankLabel）
5. WHEN 显示内存信息，THEN THE Frontend SHALL 显示总内存容量和每个插槽的使用情况
### Requirement 4: 存储设备信息查询
**User Story:** 作为系统管理员，我希望能够查看设备的硬盘配置，包括硬盘数量、容量和类型，以便管理存储资源。
#### Acceptance Criteria
1. WHEN 查询硬件信息，THEN THE Hardware_Info_Service SHALL 通过 WS-Management 查询 CIM_DiskDrive 或 CIM_MediaAccessDevice 类
2. WHEN 获取存储设备信息，THEN THE Hardware_Info_Service SHALL 列出所有已安装的存储设备
3. WHEN 获取存储设备信息，THEN THE Hardware_Info_Service SHALL 提取每个设备的容量（Capacity）
4. WHEN 获取存储设备信息，THEN THE Hardware_Info_Service SHALL 提取每个设备的型号（Model 或 Caption）
5. WHEN 显示存储设备信息，THEN THE Frontend SHALL 显示每个硬盘的容量、型号和序号
### Requirement 5: 系统基本信息查询
**User Story:** 作为系统管理员，我希望能够查看设备的基本系统信息，以便识别设备型号和制造商。
#### Acceptance Criteria
1. WHEN 查询硬件信息，THEN THE Hardware_Info_Service SHALL 通过 WS-Management 查询 CIM_ComputerSystem 类
2. WHEN 获取系统信息，THEN THE Hardware_Info_Service SHALL 提取系统制造商（Manufacturer）
3. WHEN 获取系统信息，THEN THE Hardware_Info_Service SHALL 提取系统型号（Model）
4. WHEN 获取系统信息，THEN THE Hardware_Info_Service SHALL 提取系统序列号（SerialNumber，如果可用）
5. WHEN 显示系统信息，THEN THE Frontend SHALL 在硬件信息页面顶部显示系统基本信息
### Requirement 6: 硬件信息缓存
**User Story:** 作为系统管理员，我希望系统能够缓存硬件信息，以便快速查看而不必每次都重新查询。
#### Acceptance Criteria
1. WHEN 成功查询硬件信息，THEN THE Backend SHALL 将硬件信息存储到数据库
2. WHEN 用户再次查看硬件信息，THEN THE Backend SHALL 首先返回缓存的硬件信息
3. WHEN 显示缓存的硬件信息，THEN THE Frontend SHALL 显示信息的最后更新时间
4. WHEN 用户请求刷新硬件信息，THEN THE Backend SHALL 重新查询设备并更新缓存
5. WHEN 硬件信息超过一定时间（如 24 小时），THEN THE Frontend SHALL 提示用户信息可能已过期
### Requirement 7: 错误处理和降级方案
**User Story:** 作为系统管理员，我希望即使某些硬件信息无法获取，系统也能显示可用的信息，以便获得部分硬件配置。
#### Acceptance Criteria
1. WHEN 查询某个硬件组件失败，THEN THE Hardware_Info_Service SHALL 继续查询其他组件
2. WHEN 某个硬件信息不可用，THEN THE Frontend SHALL 显示"信息不可用"或"不支持"标识
3. WHEN 设备不支持某个 CIM 类，THEN THE Backend SHALL 记录日志并返回部分可用信息
4. WHEN 查询超时，THEN THE Backend SHALL 返回已获取的部分信息
5. WHEN 所有查询都失败，THEN THE Frontend SHALL 显示清晰的错误消息和可能的原因
### Requirement 8: 硬件信息展示界面
**User Story:** 作为系统管理员，我希望硬件信息以清晰、易读的方式展示，以便快速了解设备配置。
#### Acceptance Criteria
1. WHEN 显示硬件信息，THEN THE Frontend SHALL 使用分组或标签页组织不同类型的硬件信息
2. WHEN 显示硬件信息，THEN THE Frontend SHALL 使用图标或颜色区分不同的硬件组件
3. WHEN 显示内存或存储容量，THEN THE Frontend SHALL 自动转换为合适的单位（MB、GB、TB）
4. WHEN 显示硬件信息，THEN THE Frontend SHALL 提供导出功能（如导出为 CSV 或 PDF）
5. WHEN 显示硬件信息，THEN THE Frontend SHALL 提供打印友好的视图
### Requirement 9: 批量硬件信息查询
**User Story:** 作为系统管理员，我希望能够批量查询多个设备的硬件信息，以便生成硬件清单报告。
#### Acceptance Criteria
1. WHEN 用户在设备列表中选择多个设备，THEN THE Frontend SHALL 显示"批量查询硬件信息"按钮
2. WHEN 用户点击批量查询，THEN THE Backend SHALL 异步查询所有选中设备的硬件信息
3. WHEN 批量查询进行中，THEN THE Frontend SHALL 显示查询进度（已完成/总数）
4. WHEN 批量查询完成，THEN THE Frontend SHALL 显示汇总报告或导出为 Excel 文件
5. WHEN 批量查询中某些设备失败，THEN THE Frontend SHALL 标记失败的设备并显示错误原因
### Requirement 10: AMT SDK 集成
**User Story:** 作为开发人员，我希望系统能够正确使用 Intel AMT SDK 查询硬件信息，以便获取准确的硬件数据。
#### Acceptance Criteria
1. WHEN 查询硬件信息，THEN THE Backend SHALL 使用 Intel AMT SDK 的 WS-Management 接口
2. WHEN 构建查询，THEN THE Backend SHALL 使用正确的 CIM 类名和命名空间
3. WHEN 解析查询结果，THEN THE Backend SHALL 正确处理 CIM 对象的属性
4. WHEN 查询失败，THEN THE Backend SHALL 捕获并记录 SDK 异常信息
5. WHEN 设备使用 HTTPS，THEN THE Backend SHALL 正确处理自签名证书
## Technical Notes
### CIM 类参考
根据 DMTF CIM 标准和 Intel AMT 支持，以下 CIM 类可用于查询硬件信息：
- **CIM_Processor**: CPU 信息
- Name: 处理器名称
- Family: 处理器系列
- MaxClockSpeed: 最大时钟频率（MHz）
- NumberOfCores: 核心数
- NumberOfLogicalProcessors: 逻辑处理器数
- **CIM_PhysicalMemory**: 物理内存信息
- Capacity: 容量（字节）
- BankLabel: 内存插槽标签
- DeviceLocator: 设备位置
- Speed: 内存速度（MHz）
- MemoryType: 内存类型（DDR3、DDR4 等）
- **CIM_DiskDrive** 或 **CIM_MediaAccessDevice**: 存储设备信息
- Capacity: 容量（字节）
- Model: 型号
- Caption: 描述
- InterfaceType: 接口类型（SATA、NVMe 等）
- **CIM_ComputerSystem**: 系统信息
- Manufacturer: 制造商
- Model: 型号
- Name: 系统名称
- TotalPhysicalMemory: 总物理内存
### 注意事项
1. 不是所有 AMT 设备都支持所有 CIM 类，需要做好降级处理
2. 某些硬件信息可能需要特定的 AMT 版本支持
3. 查询硬件信息可能比较耗时，建议使用异步处理
4. 硬件信息通常不会频繁变化，适合缓存

266
.kiro/specs/amt-hardware-info/tasks.md Normal file
View File

@ -0,0 +1,266 @@
# Implementation Plan: AMT Hardware Information Query
## Overview
本实现计划将硬件信息查看功能分解为可执行的开发任务。按照后端数据模型 → 后端服务 → 后端 API → 前端界面的顺序实施，确保每个步骤都可以独立测试和验证。
## Tasks
- [x] 1. 创建数据库模型和迁移
- 创建 HardwareInfo、MemoryModule、StorageDevice 实体类
- 配置 Entity Framework 关系映射
- 创建数据库迁移文件
- 应用迁移到数据库
- _Requirements: 6.1, 6.2_
- [x] 2. 实现 AMT 硬件查询服务
- [x] 2.1 创建 AmtHardwareQueryService 接口和实现类
- 定义查询方法接口
- 实现 WsmanConnection 创建和管理
- _Requirements: 10.1, 10.2_
- [x] 2.2 实现系统信息查询（CIM_ComputerSystem）
- 查询制造商、型号、序列号
- 处理查询异常和空值
- _Requirements: 5.1, 5.2, 5.3, 5.4_
- [x] 2.3 实现 CPU 信息查询（CIM_Processor via CIM_Realizes）
- 查询 CPU 型号、核心数、主频
- 解析 CPU Family 枚举值
- _Requirements: 2.1, 2.2, 2.3, 2.4_
- [x] 2.4 实现内存信息查询（CIM_PhysicalMemory）
- 查询所有内存模块
- 提取容量、速度、类型、插槽位置
- 计算总内存容量
- _Requirements: 3.1, 3.2, 3.3, 3.4_
- [x] 2.5 实现存储设备信息查询（CIM_MediaAccessDevice）
- 查询所有存储设备
- 提取容量、型号、接口类型
- _Requirements: 4.1, 4.2, 4.3, 4.4_
- [x] 2.6 实现错误处理和降级逻辑
- 单个组件查询失败时继续其他查询
- 记录详细错误日志
- 返回部分可用信息
- _Requirements: 7.1, 7.2, 7.3, 7.4_
- [ ] 3. 实现硬件信息业务服务
- [ ] 3.1 创建 HardwareInfoService 接口和实现类
- 定义服务方法接口
- 注入依赖（Repository、AmtHardwareQueryService、CredentialService）
- _Requirements: 6.1_
- [ ] 3.2 实现单设备硬件信息查询逻辑
- 检查缓存是否存在且有效（24小时内）
- 如果缓存有效且不强制刷新，返回缓存
- 否则查询 AMT 设备并更新缓存
- _Requirements: 6.1, 6.2, 6.3, 6.4_
- [ ] 3.3 实现批量设备硬件信息查询
- 使用 SemaphoreSlim 控制并发（最多 10 个）
- 使用 Task.WhenAll 并行查询
- 聚合成功和失败结果
- _Requirements: 9.1, 9.2, 9.3, 9.5_
- [ ] 3.4 实现硬件信息导出功能
- 实现 CSV 格式导出
- 实现 JSON 格式导出
- 生成文件流供下载
- _Requirements: 8.4, 9.4_
- [-] 4. 实现数据访问层
- [ ] 4.1 创建 HardwareInfoRepository 接口和实现类
- 实现 GetByDeviceIdAsync 方法
- 实现 SaveAsync 方法（包含级联保存 MemoryModules 和 StorageDevices）
- 实现 GetByDeviceIdsAsync 方法
- 实现 DeleteByDeviceIdAsync 方法
- _Requirements: 6.1, 6.2_
- [ ] 4.2 配置 Entity Framework 关系
- 配置 HardwareInfo 与 AmtDevice 的外键关系
- 配置 MemoryModule 和 StorageDevice 的级联删除
- 添加数据库索引（DeviceId, LastUpdated）
- _Requirements: 6.1_
- [ ] 5. 实现 API 控制器
- [ ] 5.1 创建 HardwareInfoController
- 注入 HardwareInfoService
- 配置路由 /api/hardware-info
- _Requirements: 1.1, 1.2_
- [ ] 5.2 实现单设备查询端点
- GET /api/hardware-info/{deviceId}
- 支持 refresh 查询参数
- 返回 HardwareInfo JSON
- 处理设备不存在的情况
- _Requirements: 1.1, 1.2, 1.3, 1.4, 1.5_
- [ ] 5.3 实现批量查询端点
- POST /api/hardware-info/batch
- 接收设备 ID 列表
- 返回批量查询结果（成功/失败）
- _Requirements: 9.1, 9.2, 9.3, 9.5_
- [ ] 5.4 实现导出端点
- GET /api/hardware-info/export
- 支持 deviceIds 和 format 查询参数
- 返回文件下载响应
- 设置正确的 Content-Type 和文件名
- _Requirements: 8.4, 9.4_
- [ ] 6. 实现前端硬件信息弹窗组件
- [ ] 6.1 创建 HardwareInfoModal.vue 组件
- 创建组件基本结构
- 定义 props（deviceId, deviceIp）
- 定义 emits（close）
- _Requirements: 1.4, 8.1_
- [ ] 6.2 实现硬件信息数据获取
- 调用 API 获取硬件信息
- 显示加载状态
- 处理错误情况
- _Requirements: 1.2, 1.3, 1.5_
- [ ] 6.3 实现系统信息展示区域
- 显示制造商、型号、序列号
- 使用网格布局
- _Requirements: 5.5, 8.1_
- [ ] 6.4 实现 CPU 信息展示区域
- 显示型号、核心数、线程数、主频
- 使用图标标识
- _Requirements: 2.5, 8.2_
- [ ] 6.5 实现内存信息展示区域
- 显示总容量摘要
- 使用表格展示各内存模块详情
- 显示插槽、容量、速度、类型、制造商
- 自动转换容量单位（GB）
- _Requirements: 3.5, 8.1, 8.3_
- [ ] 6.6 实现存储设备信息展示区域
- 使用表格或卡片展示各存储设备
- 显示型号、容量、接口类型
- 自动转换容量单位（GB/TB）
- _Requirements: 4.5, 8.1, 8.3_
- [ ] 6.7 实现刷新和导出功能
- 添加刷新按钮，调用 API 强制刷新
- 添加导出按钮，下载 CSV 或 JSON
- 显示最后更新时间
- _Requirements: 6.4, 8.4_
- [ ] 6.8 实现错误和不可用信息的展示
- 对于不可用的信息显示"不支持"或"信息不可用"
- 显示友好的错误提示
- _Requirements: 7.2, 7.5_
- [ ] 7. 更新设备列表组件
- [ ] 7.1 在 DeviceList.vue 添加"查看硬件"按钮
- 在操作列添加按钮
- 绑定点击事件打开硬件信息弹窗
- _Requirements: 1.1_
- [ ] 7.2 集成 HardwareInfoModal 组件
- 导入 HardwareInfoModal 组件
- 管理弹窗显示状态
- 传递设备 ID 和 IP 地址
- _Requirements: 1.1, 1.4_
- [ ] 8. 实现批量硬件信息导出功能（可选）
- [ ] 8.1 在设备列表添加批量选择功能
- 添加复选框列
- 管理选中设备列表
- _Requirements: 9.1_
- [ ] 8.2 添加批量导出按钮
- 显示"批量导出硬件信息"按钮
- 仅在有选中设备时启用
- _Requirements: 9.1_
- [ ] 8.3 实现批量导出对话框
- 选择导出格式（CSV/JSON）
- 显示导出进度
- 触发文件下载
- _Requirements: 9.2, 9.3, 9.4_
- [ ] 9. 添加样式和优化
- [ ] 9.1 设计硬件信息弹窗样式
- 使用卡片或分组布局
- 添加图标和颜色区分
- 确保响应式设计
- _Requirements: 8.1, 8.2_
- [ ] 9.2 优化加载和错误状态展示
- 添加骨架屏或加载动画
- 设计友好的错误提示样式
- _Requirements: 1.3, 1.5, 7.5_
- [ ] 9.3 优化表格和数据展示
- 使用合适的字体和间距
- 添加悬停效果
- 确保打印友好
- _Requirements: 8.1, 8.5_
- [ ] 10. 测试和验证
- [ ] 10.1 测试 HTTP 设备硬件信息查询
- 测试 192.168.8.111 设备
- 验证所有硬件信息正确显示
- _Requirements: 10.5_
- [ ] 10.2 测试 HTTPS 设备硬件信息查询
- 测试 192.168.8.112 设备
- 验证自签名证书处理正确
- _Requirements: 10.5_
- [ ] 10.3 测试缓存机制
- 验证首次查询后数据被缓存
- 验证 24 小时内返回缓存数据
- 验证强制刷新功能
- _Requirements: 6.1, 6.2, 6.3, 6.4_
- [ ] 10.4 测试批量查询功能
- 测试同时查询多个设备
- 验证并发控制正常工作
- 验证部分失败时的处理
- _Requirements: 9.2, 9.3, 9.5_
- [ ] 10.5 测试导出功能
- 测试 CSV 格式导出
- 测试 JSON 格式导出
- 验证文件内容正确
- _Requirements: 8.4, 9.4_
- [ ] 10.6 测试错误处理
- 测试设备离线时的处理
- 测试不支持某些 CIM 类的设备
- 测试查询超时的处理
- 验证错误消息友好且准确
- _Requirements: 7.1, 7.2, 7.3, 7.4, 7.5_
- [ ] 11. 文档和部署
- [ ] 11.1 更新 API 文档
- 添加硬件信息查询端点文档
- 添加请求/响应示例
- 添加错误代码说明
- [ ] 11.2 更新用户使用指南
- 添加硬件信息查看功能说明
- 添加截图和操作步骤
- 说明支持的硬件信息类型
- [ ] 11.3 创建数据库迁移脚本
- 生成 SQL 迁移脚本
- 测试迁移脚本
- 准备回滚脚本
## Notes
- 任务标记 "*" 的为可选任务，可以在 MVP 版本后实施
- 每个任务完成后应进行单元测试或集成测试
- 建议按顺序执行任务，确保依赖关系正确
- 批量导出功能（任务 8）可以作为第二阶段功能
- 测试任务（任务 10）应该在相关功能完成后立即执行

442
.kiro/specs/amt-network-scanner/design.md Normal file
View File

@ -0,0 +1,442 @@
# Design Document: AMT Network Scanner
## Overview
本设计文档描述了机房远程控制系统中 AMT 网络扫描功能的技术实现方案。该系统采用前后端分离架构，使用 Spring Boot 构建后端服务，Vue 3 构建前端界面。核心功能是通过 RMCP (Remote Management Control Protocol) Ping 协议扫描局域网中支持 Intel AMT 的设备，并使用异步多线程技术提高扫描效率。
系统将 Intel AMT SDK 中的 RMCPPing 模块移植到 Java 环境，实现跨平台的设备发现能力。扫描结果通过 WebSocket 实时推送到前端，提供流畅的用户体验。
## Architecture
### 系统架构图
```
┌─────────────────────────────────────────────────────────────┐
│ Frontend (Vue 3) │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Scan Config │ │ Progress Bar │ │ Device List │ │
│ │ Component │ │ Component │ │ Component │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │ │ │ │
│ └──────────────────┴──────────────────┘ │
│ │ │
│ ┌───────▼────────┐ │
│ │ WebSocket │ │
│ │ Connection │ │
│ └───────┬────────┘ │
└────────────────────────────┼──────────────────────────────────┘
│ HTTP/WebSocket
┌────────────────────────────┼──────────────────────────────────┐
│ ┌───────▼────────┐ │
│ │ API Gateway │ │
│ │ (Controller) │ │
│ └───────┬────────┘ │
│ │ │
│ ┌─────────────┴─────────────┐ │
│ │ │ │
│ ┌───────▼────────┐ ┌───────▼────────┐ │
│ │ Scan Service │ │ Device Service │ │
│ └───────┬────────┘ └───────┬────────┘ │
│ │ │ │
│ ┌───────▼────────┐ ┌───────▼────────┐ │
│ │ RMCP Scanner │ │ Device Repo │ │
│ │ (Thread Pool) │ │ (JPA) │ │
│ └───────┬────────┘ └───────┬────────┘ │
│ │ │ │
│ ┌───────▼────────┐ ┌───────▼────────┐ │
│ │ AMT Detector │ │ Database │ │
│ │ (RMCP Ping) │ │ (MySQL) │ │
│ └────────────────┘ └────────────────┘ │
│ │
│ Backend (Spring Boot) │
└───────────────────────────────────────────────────────────────┘
```
### 技术栈
**后端:**
- Spring Boot 3.x
- Spring Web (RESTful API)
- Spring WebSocket (实时通信)
- Spring Data JPA (数据持久化)
- MySQL 8.x (数据库)
- Java 17+
- Lombok (简化代码)
**前端:**
- Vue 3
- Vite (构建工具)
- Element Plus (UI 组件库)
- Axios (HTTP 客户端)
- Pinia (状态管理)
## Components and Interfaces
### Backend Components
#### 1. ScanController
负责处理扫描相关的 HTTP 请求和 WebSocket 连接。
**接口:**
```java
@RestController
@RequestMapping("/api/scan")
public class ScanController {
// 启动扫描任务
@PostMapping("/start")
ResponseEntity<ScanTaskResponse> startScan(@RequestBody ScanRequest request);
// 获取扫描任务状态
@GetMapping("/status/{taskId}")
ResponseEntity<ScanStatus> getScanStatus(@PathVariable String taskId);
// 取消扫描任务
@PostMapping("/cancel/{taskId}")
ResponseEntity<Void> cancelScan(@PathVariable String taskId);
}
@Controller
public class ScanWebSocketController {
// WebSocket 端点，用于推送扫描进度
@MessageMapping("/scan/progress")
@SendTo("/topic/scan/{taskId}")
void sendProgress(ScanProgress progress);
}
```
#### 2. ScanService
核心业务逻辑层，协调扫描任务的执行。
**接口:**
```java
public interface ScanService {
// 创建并启动扫描任务
String startScan(String networkSegment, String subnetMask);
// 获取扫描任务状态
ScanStatus getStatus(String taskId);
// 取消扫描任务
void cancelScan(String taskId);
// 处理发现的设备
void handleDiscoveredDevice(AmtDevice device);
}
```
#### 3. RmcpScanner
多线程扫描引擎，负责并发执行 IP 地址检测。
**接口:**
```java
public class RmcpScanner {
// 扫描指定网段
CompletableFuture<ScanResult> scanNetwork(
String networkSegment,
String subnetMask,
ScanProgressCallback callback
);
// 检测单个 IP 是否支持 AMT
CompletableFuture<Optional<AmtDevice>> detectDevice(String ipAddress);
// 取消扫描
void cancelScan(String taskId);
}
```
#### 4. AmtDetector
AMT 设备检测器，实现 RMCP Ping 协议。
**接口:**
```java
public class AmtDetector {
// 发送 RMCP Ping 并解析响应
Optional<PlatformData> ping(String ipAddress, int timeout);
// 构建 RMCP Ping 数据包
byte[] buildRmcpPingPacket();
// 解析 RMCP Pong 响应
PlatformData parsePongResponse(byte[] response);
}
```
#### 5. DeviceService
设备管理服务，负责设备的 CRUD 操作。
**接口:**
```java
public interface DeviceService {
// 保存设备
AmtDevice saveDevice(AmtDevice device);
// 查询所有设备
List<AmtDevice> getAllDevices();
// 根据 IP 查询设备
Optional<AmtDevice> getDeviceByIp(String ipAddress);
// 删除设备
void deleteDevice(Long deviceId);
// 搜索设备
List<AmtDevice> searchDevices(String keyword);
}
```
#### 6. DeviceRepository
数据访问层，使用 Spring Data JPA。
**接口:**
```java
public interface DeviceRepository extends JpaRepository<AmtDevice, Long> {
Optional<AmtDevice> findByIpAddress(String ipAddress);
List<AmtDevice> findByIpAddressContaining(String keyword);
List<AmtDevice> findByProvisioningState(ProvisioningState state);
}
```
### Frontend Components
#### 1. ScanConfigComponent
扫描配置组件，用户输入网段和子网掩码。
**Props & Events:**
```typescript
interface ScanConfigProps {
// 无 props
}
interface ScanConfigEmits {
(e: 'start-scan', config: ScanConfig): void;
}
interface ScanConfig {
networkSegment: string; // 例如: "192.168.1.0"
subnetMask: string; // 例如: "255.255.255.0" 或 "/24"
}
```
#### 2. ProgressBarComponent
进度条组件，显示扫描进度。
**Props:**
```typescript
interface ProgressBarProps {
taskId: string;
progress: number; // 0-100
scannedCount: number;
totalCount: number;
foundDevices: number;
status: 'running' | 'completed' | 'cancelled' | 'error';
}
```
#### 3. DeviceListComponent
设备列表组件，展示已发现的设备。
**Props & Events:**
```typescript
interface DeviceListProps {
devices: AmtDevice[];
loading: boolean;
}
interface DeviceListEmits {
(e: 'delete-device', deviceId: number): void;
(e: 'refresh'): void;
}
```
## Data Models
### Backend Data Models
#### AmtDevice Entity
```java
@Entity
@Table(name = "amt_devices")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AmtDevice {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true, length = 15)
private String ipAddress;
@Column(nullable = false)
private Integer majorVersion;
@Column(nullable = false)
private Integer minorVersion;
@Enumerated(EnumType.STRING)
@Column(nullable = false, length = 20)
private ProvisioningState provisioningState;
@Column(nullable = false)
private LocalDateTime discoveredAt;
@Column(nullable = false)
private LocalDateTime lastSeenAt;
@Column(nullable = false)
private Boolean online;
@Column(length = 100)
private String hostname;
@Column(length = 500)
private String description;
}
```
#### ProvisioningState Enum
```java
public enum ProvisioningState {
PRE("Pre-provisioning"),
IN("In-provisioning"),
POST("Post-provisioning"),
UNKNOWN("Unknown");
private final String displayName;
ProvisioningState(String displayName) {
this.displayName = displayName;
}
public String getDisplayName() {
return displayName;
}
}
```
#### PlatformData DTO
```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PlatformData {
private ProvisioningState provisioningState;
private Integer majorVersion;
private Integer minorVersion;
}
```
#### ScanRequest DTO
```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ScanRequest {
@NotBlank(message = "Network segment is required")
@Pattern(regexp = "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$",
message = "Invalid IP address format")
private String networkSegment;
@NotBlank(message = "Subnet mask is required")
private String subnetMask; // 支持 "255.255.255.0" 或 "/24" 格式
}
```
#### ScanTaskResponse DTO
```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ScanTaskResponse {
private String taskId;
private String status;
private Integer totalIpCount;
private LocalDateTime startTime;
}
```
#### ScanProgress DTO
```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ScanProgress {
private String taskId;
private Integer scannedCount;
private Integer totalCount;
private Integer foundDevices;
private Double progressPercentage;
private String currentIp;
private AmtDevice latestDevice; // 最新发现的设备
}
```
#### ScanStatus DTO
```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ScanStatus {
private String taskId;
private String status; // RUNNING, COMPLETED, CANCELLED, ERROR
private Integer scannedCount;
private Integer totalCount;
private Integer foundDevices;
private LocalDateTime startTime;
private LocalDateTime endTime;
private String errorMessage;
}
```
### Frontend Data Models
#### AmtDevice Interface
```typescript
export interface AmtDevice {
id: number;
ipAddress: string;
majorVersion: number;
minorVersion: number;
provisioningState: 'PRE' | 'IN' | 'POST' | 'UNKNOWN';
discoveredAt: string;
lastSeenAt: string;
online: boolean;
hostname?: string;
description?: string;
}
```
#### ScanConfig Interface
```typescript
export interface ScanConfig {
networkSegment: string;
subnetMask: string;
}
```
#### ScanProgress Interface
```typescript
export interface ScanProgress {
taskId: string;
scannedCount: number;
totalCount: number;
foundDevices: number;
progressPercentage: number;
currentIp: string;
latestDevice?: AmtDevice;
}
```

113
.kiro/specs/amt-network-scanner/requirements.md Normal file
View File

@ -0,0 +1,113 @@
# Requirements Document
## Introduction
本文档定义了机房远程控制系统中局域网 AMT 设备扫描功能的需求。该功能允许用户通过输入网段和子网掩码来扫描局域网中所有支持 Intel AMT (Active Management Technology) 的设备，并将发现的设备添加到管理列表中。系统采用 Spring Boot 后端和 Vue 前端架构，使用异步多线程技术提高扫描效率。
## Glossary
- **AMT_Scanner**: 负责扫描局域网中支持 Intel AMT 设备的系统组件
- **Device_Manager**: 管理已发现 AMT 设备列表的系统组件
- **Frontend**: 基于 Vue 的用户界面
- **Backend**: 基于 Spring Boot 的服务端应用
- **RMCP_Ping**: Remote Management Control Protocol Ping，用于检测 AMT 设备的协议
- **Network_Segment**: 网段，由 IP 地址和子网掩码定义的网络范围
- **Scan_Task**: 扫描任务，代表一次完整的网络扫描操作
## Requirements
### Requirement 1: 网络参数输入
**User Story:** 作为系统管理员，我希望能够输入网段和子网掩码，以便定义需要扫描的局域网范围。
#### Acceptance Criteria
1. WHEN 用户访问扫描页面，THEN THE Frontend SHALL 显示网段输入框和子网掩码输入框
2. WHEN 用户输入网段地址，THEN THE Frontend SHALL 验证输入格式是否为有效的 IPv4 地址
3. WHEN 用户输入子网掩码，THEN THE Frontend SHALL 验证输入格式是否为有效的子网掩码（如 255.255.255.0 或 CIDR 格式如 /24）
4. WHEN 用户输入无效的网络参数，THEN THE Frontend SHALL 显示清晰的错误提示信息
5. WHEN 用户提交有效的网络参数，THEN THE Frontend SHALL 将参数发送到后端并启动扫描任务
### Requirement 2: AMT 设备发现
**User Story:** 作为系统管理员，我希望系统能够自动发现局域网中所有支持 AMT 的设备，以便进行统一管理。
#### Acceptance Criteria
1. WHEN 后端接收到扫描请求，THEN THE Backend SHALL 根据网段和子网掩码计算出所有可能的 IP 地址
2. WHEN 开始扫描，THEN THE AMT_Scanner SHALL 使用 RMCP Ping 协议检测每个 IP 地址是否支持 AMT
3. WHEN 检测到支持 AMT 的设备，THEN THE AMT_Scanner SHALL 获取设备的基本信息（IP 地址、AMT 版本、UUID 等）
4. WHEN 设备响应 RMCP Ping，THEN THE AMT_Scanner SHALL 将设备标记为支持 AMT
5. WHEN 设备不响应或响应超时，THEN THE AMT_Scanner SHALL 跳过该 IP 地址继续扫描
### Requirement 3: 异步多线程扫描
**User Story:** 作为系统管理员，我希望扫描过程能够快速完成，以便提高工作效率。
#### Acceptance Criteria
1. WHEN 扫描任务启动，THEN THE Backend SHALL 创建线程池来并发处理多个 IP 地址的检测
2. WHEN 扫描进行中，THEN THE Backend SHALL 使用异步方式处理扫描任务，不阻塞主线程
3. WHEN 线程池处理扫描任务，THEN THE Backend SHALL 限制并发线程数量以避免网络拥塞（建议 50-100 个并发）
4. WHEN 单个 IP 检测超时，THEN THE Backend SHALL 设置合理的超时时间（建议 2-5 秒）并继续处理其他 IP
5. WHEN 扫描任务完成，THEN THE Backend SHALL 释放线程池资源
### Requirement 4: 实时扫描进度反馈
**User Story:** 作为系统管理员，我希望能够实时看到扫描进度，以便了解扫描状态和预估完成时间。
#### Acceptance Criteria
1. WHEN 扫描开始，THEN THE Backend SHALL 通过 WebSocket 或 Server-Sent Events 向前端推送扫描进度
2. WHEN 扫描进行中，THEN THE Frontend SHALL 显示当前扫描进度百分比
3. WHEN 扫描进行中，THEN THE Frontend SHALL 显示已扫描的 IP 数量和总 IP 数量
4. WHEN 发现新的 AMT 设备，THEN THE Frontend SHALL 实时更新设备列表
5. WHEN 扫描完成，THEN THE Frontend SHALL 显示扫描完成提示和发现的设备总数
### Requirement 5: 设备列表管理
**User Story:** 作为系统管理员，我希望能够查看和管理已发现的 AMT 设备列表，以便进行后续的远程控制操作。
#### Acceptance Criteria
1. WHEN 发现 AMT 设备，THEN THE Device_Manager SHALL 将设备信息存储到数据库
2. WHEN 用户访问设备列表页面，THEN THE Frontend SHALL 显示所有已发现的 AMT 设备
3. WHEN 显示设备列表，THEN THE Frontend SHALL 展示设备的 IP 地址、AMT 版本、发现时间、在线状态等信息
4. WHEN 用户查看设备列表，THEN THE Frontend SHALL 提供搜索和过滤功能
5. WHEN 用户选择设备，THEN THE Frontend SHALL 提供删除设备的功能
### Requirement 6: 错误处理和日志记录
**User Story:** 作为系统管理员，我希望系统能够妥善处理错误情况并记录日志，以便排查问题。
#### Acceptance Criteria
1. WHEN 扫描过程中发生网络错误，THEN THE Backend SHALL 记录错误日志并继续扫描其他 IP
2. WHEN 扫描任务失败，THEN THE Backend SHALL 返回清晰的错误信息给前端
3. WHEN 发生异常，THEN THE Frontend SHALL 显示用户友好的错误提示
4. WHEN 扫描任务执行，THEN THE Backend SHALL 记录扫描开始时间、结束时间、发现设备数量等关键信息
5. WHEN 系统运行，THEN THE Backend SHALL 将所有扫描活动记录到日志文件中
### Requirement 7: AMT SDK 集成
**User Story:** 作为开发人员，我希望系统能够正确集成 Intel AMT SDK，以便使用其提供的功能检测和管理 AMT 设备。
#### Acceptance Criteria
1. WHEN 系统初始化，THEN THE Backend SHALL 加载 AMT SDK 的 RMCPPing 模块
2. WHEN 检测 AMT 设备，THEN THE Backend SHALL 使用 SDK 提供的 RMCP Ping 功能
3. WHEN 调用 SDK 功能，THEN THE Backend SHALL 正确处理 SDK 返回的设备信息
4. WHEN SDK 调用失败，THEN THE Backend SHALL 捕获异常并记录详细错误信息
5. WHEN 系统关闭，THEN THE Backend SHALL 正确释放 SDK 相关资源
### Requirement 8: 系统架构和技术栈
**User Story:** 作为开发人员，我希望系统采用清晰的架构设计，以便于维护和扩展。
#### Acceptance Criteria
1. WHEN 开发后端，THEN THE Backend SHALL 使用 Spring Boot 框架
2. WHEN 开发前端，THEN THE Frontend SHALL 使用 Vue 3 框架
3. WHEN 设计系统架构，THEN THE Backend SHALL 采用分层架构（Controller、Service、Repository）
4. WHEN 前后端通信，THEN THE Backend SHALL 提供 RESTful API 接口
5. WHEN 实时通信，THEN THE Backend SHALL 使用 WebSocket 或 SSE 推送扫描进度

0
.kiro/specs/amt-network-scanner/tasks.md Normal file
View File

163
MIGRATION_TO_CSHARP.md Normal file
View File

@ -0,0 +1,163 @@
# 从 Java 迁移到 C# 后端
## 为什么迁移？
Java 后端在实现 Digest 认证时遇到了问题，虽然密码解密正确，但 WS-Management 认证一直失败（401）。
使用 C# + Intel 官方 SDK 的优势：
1. **官方支持** - Intel AMT SDK 是 C# 编写的，Digest 认证已经完美实现
2. **开箱即用** - 所有 AMT 协议细节都已处理好
3. **可靠性高** - 经过 Intel 官方测试和验证
4. **功能完整** - 支持所有 AMT 功能，不仅仅是扫描
## 已完成的工作
### ✅ C# 后端已创建
项目结构：
```
backend-csharp/
├── AmtScanner.Api/
│ ├── Controllers/ # API 控制器
│ │ ├── ScanController.cs
│ │ ├── DevicesController.cs
│ │ └── CredentialsController.cs
│ ├── Models/ # 数据模型
│ │ ├── AmtDevice.cs
│ │ └── AmtCredential.cs
│ ├── Services/ # 业务逻辑
│ │ ├── AmtScannerService.cs
│ │ ├── CredentialService.cs
│ │ └── ScanProgressHub.cs
│ ├── Data/ # 数据库
│ │ └── AppDbContext.cs
│ ├── Program.cs # 启动文件
│ └── appsettings.json # 配置文件
└── AmtScanner.sln # 解决方案文件
```
### ✅ 功能对等
C# 版本实现了 Java 版本的所有功能：
- ✅ 网络扫描（多线程）
- ✅ 端口检测（16992, 16993, 623）
- ✅ WS-Management 认证（使用 Intel SDK）
- ✅ 设备信息获取（版本、状态、主机名）
- ✅ 凭据管理（加密存储）
- ✅ 实时进度更新（SignalR）
- ✅ SQLite 数据库
### ✅ API 兼容
C# 版本的 API 端点与 Java 版本完全兼容，前端无需修改：
| 功能 | Java 端点 | C# 端点 | 状态 |
|------|-----------|---------|------|
| 开始扫描 | POST /api/scan/start | POST /api/scan/start | ✅ |
| 取消扫描 | POST /api/scan/cancel/{id} | POST /api/scan/cancel/{id} | ✅ |
| 获取设备 | GET /api/devices | GET /api/devices | ✅ |
| 删除设备 | DELETE /api/devices/{id} | DELETE /api/devices/{id} | ✅ |
| 获取凭据 | GET /api/credentials | GET /api/credentials | ✅ |
| 创建凭据 | POST /api/credentials | POST /api/credentials | ✅ |
| 更新凭据 | PUT /api/credentials/{id} | PUT /api/credentials/{id} | ✅ |
| 删除凭据 | DELETE /api/credentials/{id} | DELETE /api/credentials/{id} | ✅ |
## 下一步操作
### 1. 停止 Java 后端
在运行 Spring Boot 的终端按 `Ctrl+C`
### 2. 删除 Java 后端（可选）
```powershell
Remove-Item -Recurse -Force backend
```
### 3. 安装 .NET 8.0 SDK
下载：https://dotnet.microsoft.com/download/dotnet/8.0
### 4. 运行 C# 后端
```powershell
cd backend-csharp/AmtScanner.Api
dotnet run
```
### 5. 测试
访问：
- API 文档：http://localhost:5000/swagger
- 测试凭据：http://localhost:5000/api/test/test-credential
- 测试 WS-Management：http://localhost:5000/api/test/test-wsman/192.168.8.111
### 6. 前端配置
前端无需修改，但需要确认 API 地址：
`frontend/src/api/config.js`：
```javascript
export const API_BASE_URL = 'http://localhost:5000/api'
export const WS_URL = 'http://localhost:5000/scanHub'
```
## 数据迁移
### 从 Java 数据库迁移到 C#
如果需要保留 Java 版本的数据：
1. **导出 Java 数据库**（H2）
2. **转换为 SQLite 格式**
3. **导入到 C# 数据库**
或者直接重新扫描网络，因为：
- 扫描很快（几分钟）
- 数据会自动更新
- 凭据需要重新添加
## 测试清单
- [ ] 后端启动成功
- [ ] Swagger 文档可访问
- [ ] 添加凭据（admin / Guo1wu3shi4!）
- [ ] 设置为默认凭据
- [ ] 开始网络扫描
- [ ] 查看实时进度
- [ ] 验证设备信息（版本、状态）
- [ ] 确认 Digest 认证成功
## 预期结果
使用 Intel SDK 后，应该能看到：
```
✓ Successfully connected to AMT device at 192.168.8.111
✓ Digest authentication successful
✓ Got AMT version: 11.8.86
✓ Got provisioning state: POST
✓ Got hostname: ...
```
## 回滚方案
如果 C# 版本有问题，可以回滚到 Java：
1. 停止 C# 后端
2. 重新启动 Java 后端：
```bash
cd backend
mvn spring-boot:run
```
## 支持
如果遇到问题：
1. 检查 .NET SDK 是否正确安装
2. 确认 Intel.Management.dll 路径正确
3. 查看后端日志
4. 检查防火墙设置
## 总结
C# 版本使用官方 SDK，应该能完美解决 Digest 认证问题。所有功能都已实现，API 完全兼容，前端无需修改。

327
README.md Normal file
View File

@ -0,0 +1,327 @@
# AMT 网络扫描器 - 机房远程控制系统
## 🎉 项目状态：已完成并可用！
一个基于 Intel AMT SDK 的网络设备扫描和管理系统，用于自动发现和管理支持 Intel AMT 的设备。
---
## ✨ 主要特性
- 🔍 **自动网络扫描** - 快速扫描整个网段，自动发现 AMT 设备
- 📊 **设备管理** - 查看、搜索、管理所有发现的设备
- 🔐 **凭据管理** - 安全存储和管理多个 AMT 凭据
- ⚡ **实时进度** - SignalR 实时显示扫描进度
- 🎯 **Intel SDK** - 使用官方 SDK，支持完整的 Digest 认证
- 💾 **SQLite 数据库** - 轻量级数据存储，无需额外配置
---
## 🚀 快速开始
### 方法 1: 使用启动脚本（推荐）
双击运行 `启动系统.bat`，系统会自动：
1. 检查并启动后端服务
2. 检查并启动前端服务
3. 打开浏览器访问系统
### 方法 2: 手动启动
#### 启动后端
```powershell
cd backend-csharp/AmtScanner.Api
dotnet run
```
#### 启动前端
```powershell
cd frontend
npm run dev
```
#### 访问系统
打开浏览器访问: `http://localhost:3001`
---
## 📋 系统要求
### 必需
- ✅ .NET 8.0 SDK
- ✅ Node.js 18+ 和 npm
- ✅ Windows 操作系统
### 可选
- PowerShell 5.0+（用于测试脚本）
- 浏览器（Chrome/Edge/Firefox）
---
## 🎯 使用指南
### 1. 网络扫描
1. 访问 `http://localhost:3001`
2. 在"网络扫描"标签页输入：
- **网络段**: `192.168.8.0`
- **子网掩码**: `255.255.255.0` 或 `/24`
3. 点击"开始扫描"
4. 查看实时进度
5. 扫描完成后自动跳转到设备列表
### 2. 查看设备
- 切换到"设备列表"标签页
- 查看所有发现的设备
- 使用搜索框快速定位设备
- 点击删除按钮移除设备
### 3. 管理凭据
- 切换到"凭据管理"标签页
- 默认凭据：`admin / Guo1wu3shi4!`
- 点击"添加凭据"创建新凭据
- 勾选"设为默认"设置默认凭据
---
## 🔧 技术架构
### 后端
- **框架**: ASP.NET Core 8.0
- **SDK**: Intel AMT SDK (Intel.Wsman.Scripting.dll)
- **数据库**: SQLite + Entity Framework Core
- **实时通信**: SignalR
- **认证**: Digest Authentication (Intel SDK)
### 前端
- **框架**: Vue 3 + Vite
- **UI**: Element Plus
- **状态管理**: Pinia
- **HTTP**: Axios
- **WebSocket**: SignalR Client
### 数据库
- **类型**: SQLite
- **位置**: `backend-csharp/AmtScanner.Api/amtscanner.db`
- **表**: AmtDevices, AmtCredentials
---
## 📊 API 端点
### 扫描相关
- `POST /api/scan/start` - 开始扫描
- `POST /api/scan/cancel/{taskId}` - 取消扫描
### 设备管理
- `GET /api/devices` - 获取所有设备
- `GET /api/devices/search?keyword={keyword}` - 搜索设备
- `DELETE /api/devices/{id}` - 删除设备
### 凭据管理
- `GET /api/credentials` - 获取所有凭据
- `POST /api/credentials` - 创建凭据
- `PUT /api/credentials/{id}` - 更新凭据
- `DELETE /api/credentials/{id}` - 删除凭据
### 测试
- `GET /api/test/test-connection/{ip}` - 测试连接
---
## 🧪 测试
### 快速测试
```powershell
# 测试后端 API
Invoke-RestMethod -Uri "http://localhost:5000/api/credentials" -Method GET
# 测试 AMT 设备连接
Invoke-RestMethod -Uri "http://localhost:5000/api/test/test-connection/192.168.8.111" -Method GET
```
### 测试结果示例
```json
{
"ip": "192.168.8.111",
"username": "admin",
"amtVersion": "9.0.20",
"hostname": "test",
"provisioningState": 2,
"provisioningStateName": "POST",
"success": true
}
```
---
## 📚 文档
- 📖 [完整使用指南](使用指南.md) - 详细的使用说明和故障排除
- 🔧 [设置指南](SETUP_GUIDE.md) - 系统配置和部署说明
- 📝 [项目完成总结](项目完成总结.md) - 项目完成情况和技术细节
- 🔄 [迁移文档](MIGRATION_TO_CSHARP.md) - 从 Java 迁移到 C# 的说明
---
## 🐛 故障排除
### 后端无法启动
```powershell
# 检查 .NET SDK
dotnet --version
# 重新构建
cd backend-csharp/AmtScanner.Api
dotnet build
```
### 前端无法启动
```powershell
# 重新安装依赖
cd frontend
npm install
# 清除缓存
npm cache clean --force
```
### Intel SDK DLL 找不到
```powershell
# 复制 DLL 到输出目录
Copy-Item "amt-sdk-20-0-0-1\WsmanLibModule\Bin\Intel.Wsman.Scripting.dll" "backend-csharp\AmtScanner.Api\bin\Debug\net8.0\"
```
### 数据库错误
```powershell
# 删除并重新创建数据库
Remove-Item backend-csharp\AmtScanner.Api\amtscanner.db
# 重启后端会自动重新创建
```
---
## 🎓 项目结构
```
project/
├── backend-csharp/ # C# 后端
│ └── AmtScanner.Api/
│ ├── Controllers/ # API 控制器
│ ├── Services/ # 业务逻辑
│ ├── Models/ # 数据模型
│ ├── Data/ # 数据访问
│ └── amtscanner.db # SQLite 数据库
├── frontend/ # Vue 3 前端
│ ├── src/
│ │ ├── components/ # UI 组件
│ │ ├── stores/ # 状态管理
│ │ ├── api/ # API 调用
│ │ └── utils/ # 工具函数
│ └── vite.config.js # Vite 配置
├── amt-sdk-20-0-0-1/ # Intel AMT SDK
│ └── WsmanLibModule/
│ └── Bin/
│ └── Intel.Wsman.Scripting.dll
├── 启动系统.bat # 快速启动脚本
├── 使用指南.md # 使用指南
├── SETUP_GUIDE.md # 设置指南
└── 项目完成总结.md # 项目总结
```
---
## 🔑 核心功能
### 网络扫描
- 支持 C 类网段扫描（254 个 IP）
- 并发扫描（默认 100 线程）
- 端口检测（16992, 16993, 623）
- 自动设备识别
- 实时进度更新
### 设备管理
- 设备列表展示
- 设备搜索功能
- 设备信息查看
- 设备删除功能
### 凭据管理
- 多凭据支持
- 密码加密存储
- 默认凭据设置
- 凭据 CRUD 操作
---
## 📈 性能指标
- **扫描速度**: 254 个 IP 约 2-5 分钟
- **并发线程**: 100（可配置）
- **端口超时**: 3 秒（可配置）
- **内存占用**: < 100 MB
- **API 响应**: < 100ms
---
## 🔒 安全建议
1. **生产环境**
- 使用 HTTPS
- 启用身份认证
- 限制访问 IP
2. **密码管理**
- 使用强密码
- 定期更换密码
- 不要共享凭据
3. **网络隔离**
- 管理网络与业务网络隔离
- 使用防火墙规则
---
## 📞 获取帮助
如果遇到问题：
1. 查看 [使用指南](使用指南.md)
2. 查看 [设置指南](SETUP_GUIDE.md)
3. 检查后端日志（控制台输出）
4. 检查浏览器控制台（F12）
---
## 🎉 项目状态
- ✅ **后端**: 运行在 http://localhost:5000
- ✅ **前端**: 运行在 http://localhost:3001
- ✅ **数据库**: SQLite 已初始化
- ✅ **Intel SDK**: 已集成并测试成功
- ✅ **默认凭据**: admin / Guo1wu3shi4!
---
## 📝 版本信息
- **版本**: 1.0.0
- **发布日期**: 2026-01-19
- **状态**: ✅ 生产就绪
---
## 🏆 主要成就
1. ✅ **解决了 Digest 认证问题** - 使用 Intel 官方 SDK
2. ✅ **实现了实时进度更新** - SignalR WebSocket
3. ✅ **完整的系统集成** - 前后端完美对接
4. ✅ **详细的文档** - 使用、设置、故障排除
---
**开始使用**: 双击 `启动系统.bat` 或访问 http://localhost:3001
**技术支持**: 查看文档或检查日志文件

74
amt-sdk-20-0-0-1/HLAPI_Module/Docs/HLAPI Readme.txt Normal file
View File

@ -0,0 +1,74 @@
Copyright (C) 2007 Intel Corporation
Intel(R) Active Management Technology (Intel AMT):
A brief overview of the Intel AMT® High-level API module
Introduction:
-------------
The Intel AMT® High Level Application Programming Interface (HLAPI) provides
software developers with a simple interface to the Intel AMT features. This zip
includes the HLAPI library, and the HLAPI samples. The HLAPI is using other AMT
SDK compiled libraries, which are also included in this zip. Their sources can
be found in separate zip folders in the AMT SDK kit.
Note: Once an object in this library is given a reference to a SecureString
password that object becomes that password instance's owner and shouldn't
be changed, disposed or given to another object. If the same password is
needed by more than one object use the SecureString.Copy method.
More info about the HLAPI Library and HLAPI samples can be found here:
https://software.intel.com/sites/manageability/HLAPI_Documentation/default.htm
The zip includes:
1) Bin folder:
a) HLAPI compiled library: HLAPI.dll
b) Other AMT SDK compiled libraries (referenced by HLAPI code):
*DotNetWSManClient.dll
*imrsdk.dll
*imrsdk_x64.dll
*Intel.Wsman.Scripting.dll
*IWSManClient.dll
*WebStorage.dll
c) Scripts folder: Containing JavaScript scripts.
For more info, see Src\Scripts\HlapiScriptsReadme.txt
2) Src folder:
a) Intel_Manageability_Library folder contains C# code for the
HLAPI.dll
b) HLAPI_Samples folder contains C# code for the HLAPI samples.
Each sample has a VS project, which can be compiled to an .exe file.
All samples' projects are included into one solution:
HLAPI Samples.sln
How to Build:
-------------
In order to compile the HLAPI library:
1) Use Visual Studio and the latest windows SDK toolkit.
2) Open solution from this path:
Src\Intel_Manageability_Library.sln
3) Invoke build from the Visual Studio menu.
In order to run a sample:
Note: To ensure that security is maintained, the samples should be run from a directory that can be accessed
only by the Administrator user. This is to prevent unauthorized manipulation of files in the directory.
1) Open HLAPI Samples.sln in Visual Studio.
2) Right click on the project of the sample you want to run, and select
"Set as StartUp Project".
3) In Common\SampleArgs.json, fill the ConnectionInfoEx settings with your
AMT system settings (IP address / host name, user name, proxy, etc.).
4) Change/set any other input needed for this specific sample in the
Program.cs file.
5) Build the sample from Visual Studio.
6) An .exe file will be compiled into the output folder:
bin\<configuration> where <configuration> is either Debug or Release.
7) Run the .exe file from command-line.
8) Enter the password to your AMT system when prompted.
9) Get the sample output.
------------------------------------------------------------------
* Other names and brands may be claimed as the property of others.

BIN
amt-sdk-20-0-0-1/HLAPI_Module/Docs/Intel vPro SDK License.pdf Normal file
View File

Binary file not shown.

1
amt-sdk-20-0-0-1/HLAPI_Module/Docs/redist.txt Normal file
View File

@ -0,0 +1 @@
All vPro SDK files from this package with the following extensions are eligible for redistribution: .cpp, .cs, .dll, .lib, .exe., .ps1.

23
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/.NET runtime license.txt Normal file
View File

@ -0,0 +1,23 @@
The MIT License (MIT)
Copyright (c) .NET Foundation and Contributors
All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

11
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/ACE_license.txt Normal file
View File

@ -0,0 +1,11 @@
Copyright and Licensing Information for ACE(TM), TAO(TM), CIAO(TM), and CoSMIC(TM)
ACE(TM), TAO(TM), CIAO(TM), and CoSMIC(TM) (henceforth referred to as "DOC software") are copyrighted by Douglas C. Schmidt and his research group at Washington University, University of California, Irvine, and Vanderbilt University, Copyright (c) 1993-2007, all rights reserved. Since DOC software is open-source, freely available software, you are free to use, modify, copy, and distribute--perpetually and irrevocably--the DOC software source code and object code produced from the source, as well as copy and distribute modified versions of this software. You must, however, include this copyright statement along with any code built using DOC software that you release. No copyright statement needs to be provided if you just ship binary executables of your software products.
You can use DOC software in commercial and/or binary software releases and are under no obligation to redistribute any of your source code that is built using DOC software. Note, however, that you may not do anything to the DOC software code, such as copyrighting it yourself or claiming authorship of the DOC software code, that will prevent DOC software from being distributed freely using an open-source development model. You needn't inform anyone that you're using DOC software in your software, though we encourage you to let us know so we can promote your project in the DOC software success stories.
The ACE, TAO, CIAO, and CoSMIC web sites are maintained by the DOC Group at the Institute for Software Integrated Systems (ISIS) and the Center for Distributed Object Computing of Washington University, St. Louis for the development of open-source software as part of the open-source software community. Submissions are provided by the submitter ``as is'' with no warranties whatsoever, including any warranty of merchantability, noninfringement of third party intellectual property, or fitness for any particular purpose. In no event shall the submitter be liable for any direct, indirect, special, exemplary, punitive, or consequential damages, including without limitation, lost profits, even if advised of the possibility of such damages. Likewise, DOC software is provided as is with no warranties of any kind, including the warranties of design, merchantability, and fitness for a particular purpose, noninfringement, or arising from a course of dealing, usage or trade practice. Washington University, UC Irvine, Vanderbilt University, their employees, and students shall have no liability with respect to the infringement of copyrights, trade secrets or any patents by DOC software or any part thereof. Moreover, in no event will Washington University, UC Irvine, or Vanderbilt University, their employees, or students be liable for any lost revenue or profits or other special, indirect and consequential damages.
DOC software is provided with no support and without any obligation on the part of Washington University, UC Irvine, Vanderbilt University, their employees, or students to assist in its use, correction, modification, or enhancement. A number of companies around the world provide commercial support for DOC software, however.
DOC software is Y2K-compliant, as long as the underlying OS platform is Y2K-compliant. Likewise, DOC software is compliant with the new US daylight savings rule passed by Congress as "The Energy Policy Act of 2005," which established new daylight savings times (DST) rules for the United States that expand DST as of March 2007. Since DOC software obtains time/date and calendaring information from operating systems users will not be affected by the new DST rules as long as they upgrade their operating systems accordingly.
The names ACE(TM), TAO(TM), CIAO(TM), CoSMIC(TM), Washington University, UC Irvine, and Vanderbilt University, may not be used to endorse or promote products or services derived from this source without express written permission from Washington University, UC Irvine, or Vanderbilt University. Further, products or services derived from this source may not be called ACE(TM), TAO(TM), CIAO(TM), or CoSMIC(TM) nor may the name Washington University, UC Irvine, or Vanderbilt University appear in their names, without express written permission from Washington University, UC Irvine, and Vanderbilt University.

21
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/Boost_Software_License.txt Normal file
View File

@ -0,0 +1,21 @@
Boost Software License - Version 1.0
August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

20
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/Bootstrap MIT license.txt Normal file
View File

@ -0,0 +1,20 @@
Copyright (c) 2011-2022 Twitter, Inc.
Copyright (c) 2011-2022 The Bootstrap Authors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

157
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/gSOAP_license.txt Normal file
View File

@ -0,0 +1,157 @@
GENIVIA, INC., SOURCE CODE LICENSE AGREEMENT FOR COMMERCIAL USE
Rationale: This source code license for commercial use shall replace the gSOAP public license and GPL license for Customer's use of the Software, thereby rendering the terms and conditions imposed by the gSOAP public license and GPL license on Customer inactive during the term of this commercial license as set forth in this Agreement. This license covers the entire gSOAP source distribution, including, but not limited to, the runtime library, compiler, WSDL importer, example applications, and documentation.
THIS SOURCE CODE LICENSE AGREEMENT ("Agreement") is made and entered into as of the last date executed by the parties below (the "Effective Date") by and between GENIVIA, INC., a Florida corporation having a principal place of business at 3178 Shamrock East, Tallahassee, Florida 32309, USA, ("Genivia"), and Intel Corporation, a Delaware corporation having a principal place of business at 2200 Mission College Blvd., Santa Clara, CA 95052 ("Customer"). The parties agree as follows:
1. DEFINITIONS.
"Original Code" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code.
"Modifications" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is: (i) any addition to or deletion from the contents of a file containing Original Code or previous Modifications; (ii) any new file that contains any part of the Original Code, or previous Modifications.
"Covered Code" means the Original Code, or Modifications or the combination of the Original Code, and Modifications, in each case including portions thereof.
"Software" means the Covered Code and accompanying documentation, including Updates (if any), provided by Genivia under this Agreement.
"Updates" means any patches, bug fixes, and upgrades made generally available during the term and provided by Genivia under this Agreement.
"Source Code" means computer programming code in human readable form that is not suitable for machine execution without the intervening steps of interpretation or compilation, meaning the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable Object Code, or source code differential comparisons against the Original Code. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.
"Executable Object Code" means the computer programming code in any other form than Source Code that is not readily perceivable by humans and suitable for machine execution without the intervening steps of interpretation or compilation.
"Authorized Site" means the specific address of Customer’s facility consisting of a single building or multiple buildings on a contiguous campus as specified in Exhibit A.
"Project" means a concerted undertaking by an identified Customer development team to design or produce a Target Application.
"Run-Time Module" means the Executable Object Code derived from compiling the Software to be incorporated into a Target Application as inseparably embedded code.
"Target Application" means an end-user item, such as a software product that is possibly replicated in identical form and offered for sale to third parties, or a device or system developed by Customer pursuant to a Project that contains a Run-Time Module, or any portion thereof, as specified in Exhibit A.
2. SOURCE CODE LICENSE.
Subject to Customer’s compliance with the terms and conditions of this Agreement and payment of any applicable fees, Genivia hereby grants to Customer a non-transferable, non-exclusive, worldwide, royalty-free license: (i) to use the Software, solely at the Authorized Site in connection with the Project; (ii) to create Modifications of the Software, solely to the extent necessary to support the development of the Target Application; (iii) to compile the Software, including any Modifications thereof, into a Run-Time Module; (iv) to reproduce an unlimited number of Run-Time Modules for physical incorporation into the Target Application; and (v) to distribute the Target Application.
In addition to the licenses granted above, Genivia hereby grants to Customer a non-transferable,
nonexclusive, worldwide, perpetual, royalty-free, paid-up license to reproduce, market, sublicense
and distribute the Applications solely in connection with Customer's Intel® AMT SDK.
Customer's Sub-licensees shall, in turn, be granted a royalty free, paid up license to reproduce,
market and distribute Target Applications developed utilizing the Software and Applications
licensed by Customer. Sublicensees' rights to utilize the Applications, however, shall be limited to
uses directly related to the Intel® AMT SDK. Further, Genivia agrees that all recipients of
Customer's Intel® AMT SDK shall be granted royalty free access to all updates of the Software
made generally available on Genivia's website.
3. RESTRICTIONS.
Customer shall reproduce and include any and all copyright notices and proprietary rights legends, as such notices and legends appear in the original Software, on any copy of the Software, or portion thereof, with the exception of the gSOAP public license and GPL license notices.
The Software shall be handled, used and stored, solely at the Authorized Site identified in Exhibit A. The Software may be used from a single machine, a set of machines, or a network file server, but there shall be no access to the Software from any external network not located at the Authorized Site.
A function of the Software is to create Run-Time Modules for incorporation into Target Applications. Except as set forth in Section 2 above, no license is granted hereunder to reproduce or distribute the gSOAP soapcpp2 compiler and wsdl2h importer as part of such Target Application.
4. OWNERSHIP.
Genivia represents and warrants to Customer that Genivia has all rights in the Software necessary to grant the rights and license granted to Customer in this Agreement.
Without limiting the foregoing, Genivia represents and warrants that Genivia acquires an assignment of all intellectual property rights in and to all portions of the Software that are delivered to Customer under this Agreement, including any Modifications made by GPL or gSOAP Public License licensees of such Software.
Customer shall not have any obligation to provide, assign, or disclose to Genivia or any other party any Modifications. Notwithstanding the foregoing, Genivia and its licensors shall retain exclusive ownership of all worldwide Intellectual Property Rights in and to the Software. Customer acknowledges that this Agreement does not grant to Customer any Intellectual Property Rights in or to the Software other than the limited right to use the Software as set forth in Section 2. Customer hereby assigns to Genivia all Intellectual Property Rights it may have or obtain in and to the Modifications that Customer makes to the Software. If Customer has or obtains any rights to the foregoing that cannot be assigned to Genivia, Customer unconditionally and irrevocably waives the enforcement of such rights, and if such rights cannot be waived, Customer hereby grants to Genivia an exclusive, irrevocable, perpetual, worldwide, fully paid and royalty-free license, with rights to sublicense through one or more levels of sublicensees, to reproduce, create derivative works of, distribute, publicly perform, publicly display, make, use, sell and import such Modifications and other intellectual property noted above by all means now known or later developed. All rights in and to the Software not expressly granted to Customer in this Agreement are expressly reserved for Genivia and its licensors.
5. DELIVERY AND PAYMENT.
Immediately following the Effective Date, Genivia grants Costumer the right to download the Software from the Approved Software Download Site specified in Exhibit A, and install the Software at the Authorized Site and use the Software as set forth in Section 2 subject to the restrictions listed in Section 3. Notwithstanding any terms or other agreements posted on the Approved Software Download Site, this Agreement shall be the sole and exclusive agreement governing Customer's use of the Software.
Customer shall pay to Genivia the Software license fees set forth in Genivia’s current price list, unless otherwise specified in Exhibit A. License fees will be invoiced with shipment of this License Agreement. Payment of all amounts invoiced shall be due thirty (30) days after receipt of the invoice.
All payments and amounts shall be paid without deduction, set-off or counter claim, free and clear of any restrictions or conditions, and without deduction for any taxes, levies, imposts, duties, fees, deductions, withholdings or other governmental charges. If any deduction is required to be made by law, Customer shall pay in the manner and at the same time such additional amounts as will result in receipt by Genivia of such amount as would have been received by Genivia had no such amount been required to be deducted. If Customer is claiming sales or use tax exemption, a certified Tax Exempt Certificate must be attached to this Agreement or applicable purchase order submitted by Customer.
6. TERM AND TERMINATION.
This Agreement shall commence upon the Effective Date and continue until terminated as set forth in this Agreement. This Agreement will immediately terminate upon Customer’s breach of this Agreement, unless such breach is curable and is cured by Customer within thirty (30) days after notice of such breach is provided by Genivia. Upon termination Customer agrees not to use the Software for any purpose whatsoever. The following Sections shall survive any termination of this Agreement: Sections 1, 4, 6, and 8.
7. LIMITED WARRANTY.
Genivia warrants that the Software, installation scripts, and future Updates will be provided to Customer. Customer assumes full responsibility for: (i) the selection, download, and installation of the Software from the Approved Software Download Site specified in Exhibit A; (ii) the proper use of the Software; (iii) verifying the results obtained from the use of the Software; and (iv) taking appropriate measures to prevent loss of data. Genivia does not warrant that the operation of the Software will meet Customer’s requirements or that Customer will be able to achieve any particular results from use or modification of the Software or that the Software will operate free from error.
EXCEPT AS EXPRESSLY SET FORTH IN SECTIONS 7 AND 8 OF THIS AGREEMENT, GENIVIA AND ITS LICENSORS DISCLAIM ALL WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, AND ANY WARRANTY THAT MAY ARISE BY REASON OF TRADE USAGE, CUSTOM, OR COURSE OF DEALING. WITHOUT LIMITING THE FOREGOING, CUSTOMER ACKNOWLEDGES THAT THE SOFTWARE IS PROVIDED "AS IS" AND THAT GENIVIA DOES NOT WARRANT THE SOFTWARE WILL RUN UNINTERRUPTED OR ERROR FREE. THE ENTIRE RISK AS TO RESULTS AND PERFORMANCE OF THE SOFTWARE IS ASSUMED BY CUSTOMER. UNDER NO CIRCUMSTANCES WILL GENIVIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES OF ANY KIND OR NATURE WHATSOEVER, WHETHER BASED ON CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, ARISING OUT OF OR IN ANY WAY RELATED TO THE SOFTWARE, EVEN IF GENIVIA HAS BEEN ADVISED ON THE POSSIBILITY OF SUCH DAMAGE OR IF SUCH DAMAGE COULD HAVE BEEN REASONABLY FORESEEN, AND NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY EXCLUSIVE REMEDY PROVIDED. SUCH LIMITATION ON DAMAGES INCLUDES, BUT IS NOT LIMITED TO, DAMAGES FOR LOSS OF GOODWILL, LOST PROFITS, LOSS OF DATA OR SOFTWARE, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION OR IMPAIRMENT OF OTHER GOODS. IN NO EVENT WILL GENIVIA BE LIABLE FOR THE COSTS OF PROCUREMENT OF SUBSTITUTE SOFTWARE OR SERVICES. COSTUMER ACKNOWLEDGE THAT THIS SOFTWARE IS NOT DESIGNED FOR USE IN ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS SUCH AS OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR CONTROL, OR LIFE-CRITICAL APPLICATIONS. GENIVIA EXPRESSLY DISCLAIM ANY LIABILITY RESULTING FROM USE OF THE SOFTWARE IN ANY SUCH ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS AND ACCEPTS NO LIABILITY IN RESPECT OF ANY ACTIONS OR CLAIMS BASED ON THE USE OF THE SOFTWARE IN ANY SUCH ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS BY CUSTOMER. FOR PURPOSES OF THIS PARAGRAPH, THE TERM "LIFE-CRITICAL APPLICATION" MEANS AN APPLICATION IN WHICH THE FUNCTIONING OR MALFUNCTIONING OF THE SOFTWARE MAY RESULT DIRECTLY OR INDIRECTLY IN PHYSICAL INJURY OR LOSS OF HUMAN LIFE. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
8. INFRINGEMENT INDEMNITY.
Genivia will defend at its expense any suit brought against Customer and will pay all damages finally awarded in such suit insofar as such suit is based on a claim that the Software as provided to Customer infringes a previously issued patent or copyright, provided that Genivia is notified promptly of such claim and is given full and complete authority (including settlement authority), information and assistance by Customer for such defense. In the event that the Software is held in any such suit to infringe such a right and its use is enjoined, or if in the opinion of Genivia the Software is likely to become the subject of such a claim, Genivia at its own election and expense will either (i) procure for Customer the right to continue using the Software or (ii) modify or replace the Software so that it becomes non-infringing while giving substantially equivalent performance. In the event that (i) or (ii) above are not, in Genivia’s sole determination, obtainable using reasonable commercial efforts, then Genivia may terminate this Agreement and refund amount Customer paid Genivia under this Agreement for the Software which is the subject of such claim. The indemnification obligation shall not apply to infringement actions or claims to the extent that such actions or claims are caused solely by: (i) modifications made to the Software by a party other than Genivia; and (ii) the combination of the Software with items not supplied or approved by Genivia.
9. GENERAL.
Neither party shall be liable hereunder by reason of any failure or delay in the performance of its obligations hereunder (except for the payment of money) on account of strikes, shortages, riots, insurrection, fires, flood, storm, explosions, acts of God, war, governmental action, labor conditions, earthquakes, material shortages or any other cause which is beyond the reasonable control of such party.
The Software is a "commercial item" as that term is defined at 48 C.F.R. 2.101, consisting of "commercial computer software" and "commercial computer software documentation" as such terms are used in 48 C.F.R. 12.212. Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4, Customer will provide the Software to U.S. Government End Users only pursuant to the terms and conditions therein.
Customer may not delegate, assign or transfer this Agreement, the license(s) granted or any of Customer’s rights or duties hereunder, including by way of merger (regardless of whether Customer or Genivia is the surviving entity) or acquisition, and any attempt to do so, without Genivia’s express prior written consent, shall be void. Genivia may assign this Agreement, and its rights and obligations hereunder, in its sole discretion.
All Software and technical information delivered under this Agreement are subject to U.S. export control laws and may be subject to export or import regulations in other countries. Customer agrees to strictly comply with all such laws and regulations.
This Agreement is governed by California law, excluding any principle or provision that would call for the application of the law of any jurisdiction other than California. Any action regarding this Agreement shall be brought in a court of competent jurisdiction, federal or state, in the County of Santa Clara, California, and Genivia consents to venue and jurisdiction in and service of process from such court.
EXHIBIT A
1. Genivia gSOAP Source Code Products.
Original Source Code files suitable for compilation into Run-Time Modules for integration into a Target Application:
dom.h
dom++.h
dom.c
dom++.cpp
dom.cpp
soapdoc2.pdf
soapdoc2.html
stdsoap2.h
stdsoap2.c
stdsoap2.cpp
stl.h
stldeque.h
stllist.h
stlvector.h
stlset.h
samples/* (all example files included in the package under 'samples')
Updates to any of the Original Source Code files listed above and distributed by Genivia are also covered under this Agreement.
Original Source Code files of the Software with development functionality not suitable for compilation and integration into Target Applications:
src/error2.c
src/error2.h
src/init2.c
src/soapcpp2.c
src/soapcpp2.h
src/soapcpp2_lex.l
src/soapcpp2_yacc.y
src/symbol2.c
wsdl/dime.h
wsdl/gwsdl.h
wsdl/http.h
wsdl/imports.h
wsdl/includes.h
wsdl/mime.h
wsdl/schema.cpp
wsdl/schema.h
wsdl/service.cpp
wsdl/service.h
wsdl/soap.cpp
wsdl/soap.h
wsdl/typemap.dat
wsdl/types.cpp
wsdl/types.h
wsdl/wsdl.cpp
wsdl/wsdl.h
wsdl/wsdl2h.cpp
The source codes above are part of the software development toolkit. The development toolkit generates source code that is suitable for compilation and integration into the Target Application as set forth by Sections 2 and 3.
2. Approved Software Download Site
http://sourceforge.net/projects/gsoap2
3. Description of the Customer's Project and the Intended Functionality of the Target Application.
Intel® Active Management Technology ,a network management stack that provides out-of-band management in the realms of asset management, diagnostics, security, circuit breaker, and similar features.
___________________________________________________

23
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/libxml2_license.txt Normal file
View File

@ -0,0 +1,23 @@
Except where otherwise noted in the source code (e.g. the files hash.c,
list.c and the trio files, which are covered by a similar licence but
with different Copyright notices) all the files are:
Copyright (C) 1998-2012 Daniel Veillard. All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is fur-
nished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

27
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/openWSMAN_license.txt Normal file
View File

@ -0,0 +1,27 @@
Copyright (C) 2004-2006 Intel Corp. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither the name of Intel Corp. nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

25
amt-sdk-20-0-0-1/HLAPI_Module/Docs/third party licenses/rfc2617_license.txt Normal file
View File

@ -0,0 +1,25 @@
Copyright (C) The Internet Society (1999). All Rights Reserved.
This document and translations of it may be copied and furnished to
others, and derivative works that comment on or otherwise explain it
or assist in its implementation may be prepared, copied, published
and distributed, in whole or in part, without restriction of any
kind, provided that the above copyright notice and this paragraph are
included on all such copies and derivative works. However, this
document itself may not be modified in any way, such as by removing
the copyright notice or references to the Internet Society or other
Internet organizations, except as needed for the purpose of
developing Internet standards in which case the procedures for
copyrights defined in the Internet Standards process must be
followed, or as required to translate it into languages other than
English.
The limited permissions granted above are perpetual and will not be
revoked by the Internet Society or its successors or assigns.
This document and the information contained herein is provided on an
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

168
amt-sdk-20-0-0-1/HLAPI_Module/HLAPI Release-notes.txt Normal file
View File

@ -0,0 +1,168 @@
-------------------------------------------------------------------
Copyright (C) 2004 Intel Corporation
Release notes file for Intel AMT(R) High-level API module
-------------------------------------------------------------------
HLAPI Module release 20.0.0.1:
------------------------------
# The Intel(R) AMT SDK has been updated from version 18.x to 20.x.
This update indicates that the SDK now supports Intel(R) CSME version 20.x,
which is used on Intel(R) Lunar Lake platforms.
# Bug fix: Fixed the PTHI command marshaling
# Bug fix: Added option to load configuration file from working directory
HLAPI Module release 18.0.1.1:
------------------------------
# Updated HardwareAsset to support DMTF SMBIOS release 3.8.0.
# Added user input for timeout in agent presence samples.
# Added thread blocking warning in AgentPresenceLocal sample.
# Bug fix: Fix all agent presence samples.
# Bug fix: Fix sample password input backspace usage.
# Bug fix: Add sample input file serialization errors.
# Bug fix: Add error message if AMT server was not found.
HLAPI Module release 18.0.0.1:
------------------------------
# Updated the Intel(R) AMT SDK version from 16.x to 18.x to indicate that the
SDK also supports Intel(R) CSME version 18.x, used on Intel(R) Meteor Lake platforms.
# This module adds support for the new features in Intel(R) Remote Platform Erase 3.0
# Bug fix: Fix dispose error in AMTInstanceManager
# Static code analysis fixes
HLAPI Module release 16.0.7.1:
------------------------------
# This release changes all HLAPI samples to compile to .NET Framework 4.8
instead of .NET Framework 4.6.1.
# This release changes the connection to Intel(R) AMT to use a SecureString for
storing passwords in memory. All password references in the HLAPI library and
samples have been modified to support this capability.
As a result:
- All APIs that used a string to reference a password were replaced with a
SecureString.
- ConnectionInfoEX, SocksProxy, were converted from structs into Disposable
classes.
- Updated Readme to note SecureString password ownership.
# Changed ConnectionInfoEX usage in HLAPI Samples to be created by an external
argument file with the password given when prompted by the sample.
# Updated the Readme with new argument passing method.
# Updated versions using SecureStrings for passwords of these dlls:
DotNetWSManClient.dll
IWSManClient.dll
Intel.Wsman.Scripting.dll
WebStorage.dll
# Bug fix: Allow usage of AgentPresence without proxy.
# Bug fix: Fix usage of AgentPresence with a LAN-less configuration.
# Bug fix: Update event codes in AccessMonitorManager.
# Bug fix: Remove OCR enablement when enabling RPE in AMT.
# Bug fix: Fix fetched event logs in RPE sample.
# Bug fix: Fix use of self-signed certificates.
HLAPI Module release 16.0.5.1:
------------------------------
# This release changes the HLAPI to compile to .NET Standard 2.0 instead of
.NET Framework 4.6.1 - meaning that it can now be used as a part of either of
the following target frameworks:
.NET Standard starting from version 2.0
.NET Framework starting from version 4.6.1
.NET Core starting from version 2.0
.NET starting from version 5.0
# Updated versions compiled to .NET Standard 2.0 of these dlls:
DotNetWSManClient.dll
IWSManClient.dll
Intel.Wsman.Scripting.dll
WebStorage.dll
# All samples were changed to compile using an SDK style project file, allowing
users to easily compile the samples to .NET (Core) if they wish.
# Updated the Power sample with basic CLI to change power options in runtime.
# Bug fix: Added support for the GCMP-256 encryption method in the WiFi
Configurations.
# Bug fix: Fixed HLAPI WebStorage flow implementation.
# Updated HardwareAsset to support DMTF SMBIOS release 3.6.0.
# Cleanup of the SOAP APIs as they are deprecated since AMT 6.0.
HLAPI Module release 16.0.4.1:
------------------------------
This release includes:
# Support for Intel AMT connectivity over TLS with an option to accept a
self-signed certificate. Using a self-signed certificate allows the developer
to initially enable a TLS connection with untrusted self-signed certificates.
When moving towards productization, the developer should switch to use
certificates provided by a trusted certificate authority. In absence of
deployment of a trusted certificate authority, the WSMAN AMTAuthenticate()
command must be used to verify that the endpoint is authentic AMT Firmware.
# Bug fix: Added support for WPA3 wireless authentication method in the WiFi
Configuration Samples
# Bug fix in the HardwareAsset sample
# Static code analysis fixes
# Updated versions of these dlls:
imrsdk.dll
imrsdk_x64.dll
DotNetWSManClient.dll
IWSManClient.dll
Intel.Wsman.Scripting.dll
WebStorage.dll
HLAPI Module release 16.0.3.1:
------------------------------
# A new addition to the AMT HLAPI package: Remote Platform Erase sample, for the
new 'Remote Platform Erase' feature added to AMT starting ME16. This
sample introduces the flows and the commands of the RPE feature.
This sample includes RPE 2.0 options.
# This release contains a bug-fix in the WiFi Configuration Remote sample
# This version includes code changes resulting from an additional static code
analysis.
# This package contains an updated version of these dlls:
DotNetWSManClient.dll
IWSManClient.dll
Intel.Wsman.Scripting.dll
WebStorage.dll
HLAPI Module release 16.0.0.1:
------------------------------
# Updated the version of the AMT SDK from 15.x to 16.x to reflect that the AMT
SDK also supports CSME version 16.x that is used on Intel* Alderlake platforms
# This release contains bug-fixes for the HardwareAsset sample; added display of
OCR and RPE capabilities; processor family, processor upgrade, and form factor
fields lists were updated
HLAPI Module release 15.0.2.1:
------------------------------
# This release contains a bug-fix for the HardwareAsset sample
# This release contains a bug-fix for the Redirection sample
# This package contains an updated version of these dlls:
DotNetWSManClient.dll
IWSManClient.dll
HLAPI Module release 15.0.1.1:
------------------------------
# This release contains a bug-fix for the HardwareAsset sample
# This package contains an updated version of these dlls:
imrsdk.dll
imrsdk_x64.dll
DotNetWSManClient.dll
Intel.Wsman.Scripting.dll
IWSManClient.dll
HLAPI Module release 15.0.0.2:
------------------------------
# Updated the version of the AMT SDK from 14.x to 15.x to reflect that the AMT
SDK also supports CSME version 15.x that is used on Intel* Tigerlake platforms
# This release contains bug fixes for Redirection Sample, and HardwareAsset
Sample
HLAPI Module release 14.0.2.1:
------------------------------
This release contains bug fixes for some of the HLAPI samples.
HLAPI Module release 14.0.1.1:
------------------------------
# First release since AMT SDK 12.0.0.9 was removed for maintenance
# Module contains: Bin folder with compiled dlls. It includes the C# source code
in the Src folder. This module also includes sample code.
# See Readme file for more details.
------------------------------------------------------------------
* Other names and brands may be claimed as the property of others.

137
amt-sdk-20-0-0-1/HLAPI_Module/Src/Common/ProgramInput.cs Normal file
View File

@ -0,0 +1,137 @@
//----------------------------------------------------------------------------
//
// Copyright (C) 2023 Intel Corporation
//
// File: ProgramInput.cs
//
// Contents: Program input getting functions.
//
//----------------------------------------------------------------------------
using Newtonsoft.Json;
using System.IO;
using Intel.Manageability;
using System.Security;
using System;
namespace Common.Utils
{
public static class ProgramInput
{
#region Consts
private const string sampleArgsFileName = "SampleArgs.json";
private const string defaultSampleArgsPath = @"..\..\..\..\Common\";
private const string fallBackSampleArgsPath = @"..\..\..\..\..\..\Common\Utils\C#\";
#endregion
#region Enum
public enum PASSWORD_TYPE
{
AMT_USER,
PROXY,
REDIRECTION_PROXY
}
#endregion
#region Public Static Functions
public static ConnectionInfoEX DeserializeJsonToStruct(string jsonPath = null)
{
// config location = input;
if (jsonPath == null)
{
// config location = working directory;
jsonPath = Path.Combine(Directory.GetCurrentDirectory(), sampleArgsFileName);
if (!File.Exists(jsonPath))
{
// location = ..\..\..\..\Common\
jsonPath = Path.GetFullPath(Path.Combine(defaultSampleArgsPath, sampleArgsFileName));
if (!File.Exists(jsonPath))
{
// location = ..\..\..\..\..\..\Common\Utils\C#\
jsonPath = Path.GetFullPath(Path.Combine(fallBackSampleArgsPath, sampleArgsFileName));
}
}
}
if (!File.Exists(jsonPath))
{
throw new IOException($"The file {jsonPath} does not exist.");
}
Console.WriteLine($"Loading config file from: {jsonPath}");
string json = File.ReadAllText(jsonPath);
ConnectionInfoEX connection;
try
{
connection = JsonConvert.DeserializeObject<ConnectionInfoEX>(json);
}
catch (JsonReaderException e)
{
throw new IOException(e.Message);
}
//check if Json has UserName
if (connection?.UserName != null)
{
connection.Password = PasswordPrompt(PASSWORD_TYPE.AMT_USER.ToString());
}
//check if Proxy param was provided
if (connection?.Proxy != null)
{
connection.Proxy.Password = PasswordPrompt(PASSWORD_TYPE.PROXY.ToString());
}
//check if RedirectionProxy param was provided
if (connection?.RedirectionProxy != null)
{
connection.RedirectionProxy.Password = PasswordPrompt(PASSWORD_TYPE.REDIRECTION_PROXY.ToString());
}
return connection;
}
/// <summary>
/// Prompts for Password, does not display the password on the console, and returns a Secure String password
/// </summary>
/// <returns></returns>
public static SecureString PasswordPrompt(string passwordType)
{
SecureString secPass = new SecureString();
Console.WriteLine($"Please enter {passwordType} password:");
ConsoleKeyInfo nextPassKey = Console.ReadKey(true);
while (nextPassKey.Key != ConsoleKey.Enter)
{
if (nextPassKey.Key == ConsoleKey.Backspace)
{
if (secPass.Length > 0)
{
secPass.RemoveAt(secPass.Length - 1);
Console.Write("\b \b");
}
}
else
{
secPass.AppendChar(nextPassKey.KeyChar);
Console.Write('*');
}
nextPassKey = Console.ReadKey(true);
}
secPass.MakeReadOnly();
Console.Write('\n');
return secPass;
}
#endregion
}
}

48
amt-sdk-20-0-0-1/HLAPI_Module/Src/Common/SampleArgs.json Normal file
View File

@ -0,0 +1,48 @@
//----------------------------------------------------------------------------
//
// Copyright (C) 2023 Intel Corporation
//
// File: SampleArgs.Json
//
// Contents: User input for connection
//
//----------------------------------------------------------------------------
{
"Host": "dut.vprodemo.com",
"UserName": "admin",
"Secure": true,
"Certificate": null,
"Auth": "Digest",
"Proxy": null,
"RedirectionProxy": null,
"Forwarder": null,
"UseDigestMasterPassword": false,
"Timeout": 10000,
"AcceptSelfSignedCertificate": false
/* Struct values can be assigned as the following example:
"Proxy": {
"DropAtEnd": true,
"Host": "proxy.vprodemo.com",
"Port": 10,
"UserName": "admin2"
},
"RedirectionProxy": {
"DropAtEnd": true,
"Host": "redirectionProxy.vprodemo.com",
"Port": 10,
"UserName": "admin2"
},
"Forwarder": {
"Host": "forwarder.vprodemo.com",
"MainPort": 1992,
"RedirectionPort": 1992,
"RfbPort": 1992
}
*/
}

192
amt-sdk-20-0-0-1/HLAPI_Module/Src/Common/SecureStringExtensions.cs Normal file
View File

@ -0,0 +1,192 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;
namespace Common.Utils
{
/// <summary>
/// An extension class to handle SecureString conversion
/// </summary>
internal static class SecureStringExtensions
{
public static readonly Encoding ENCODING = Encoding.UTF8;
#region methods
/// <summary>
/// Convert the content of the SecureString as an array of bytes
/// </summary>
/// <param name="password"></param>
/// <returns> A Byte Array representation of a secure string </returns>
public static byte[] ConvertToByteArray(this SecureString password)
{
if (password == null)
{
throw new SecureStringConversionException("Cannot convert a null password");
}
IntPtr stringTempPass = IntPtr.Zero;
string convertedPass;
try
{
stringTempPass = Marshal.SecureStringToGlobalAllocUnicode(password);
convertedPass = Marshal.PtrToStringUni(stringTempPass);
if (convertedPass != null)
return ENCODING.GetBytes(convertedPass);
else
return null;
}
finally
{
Marshal.ZeroFreeGlobalAllocUnicode(stringTempPass);
}
}
/// <summary>
/// Convert the content of a byte array to a secure string
/// </summary>
/// <param name="arrayToConvert"></param>
/// <returns> The representation of the byte array in a secure string </returns>
public static SecureString ConvertByteArrayToSecureString(this byte[] arrayToConvert)
{
IntPtr stringPointer = IntPtr.Zero;
if (arrayToConvert.Length == 0)
throw new ArgumentException("Password is empty");
stringPointer = Marshal.StringToBSTR(ENCODING.GetString(arrayToConvert));
try
{
return ConvertToSecureString(Marshal.PtrToStringBSTR(stringPointer));
}
finally
{
Marshal.ZeroFreeBSTR(stringPointer);
GC.Collect();
}
}
/// <summary>
/// Convert a secure string to a char array
/// </summary>
/// <param name="password"></param>
/// <returns> A representation of the secure string in a char array </returns>
public static char[] ConvertToCharArray(this SecureString password)
{
char[] charArray = new char[password.Length];
IntPtr charPass = IntPtr.Zero;
try
{
charPass = Marshal.SecureStringToCoTaskMemUnicode(password);
Marshal.Copy(charPass, charArray, 0, password.Length);
return charArray;
}
finally
{
if (charPass != IntPtr.Zero)
{
Marshal.ZeroFreeGlobalAllocUnicode(charPass);
}
}
}
/// <summary>
/// Convert a SecureString to string. Used for compliancy with MSFT WINRM DLL
/// </summary>
/// <param name="password"></param>
/// <returns>a string represetation of a secure string </returns>
public static string ConvertToString(this SecureString password)
{
IntPtr stringPointer = IntPtr.Zero;
if (password == null)
throw new ArgumentNullException("Password is empty");
stringPointer = Marshal.SecureStringToBSTR(password);
try
{
return Marshal.PtrToStringBSTR(stringPointer);
}
finally
{
Marshal.ZeroFreeBSTR(stringPointer);
}
}
/// <summary>
/// Convert a String object to SecureString
/// </summary>
/// <param name="password"></param>
/// <returns>A secure string representation of a string object</returns>
public static SecureString ConvertToSecureString(this string password)
{
var securePass = new SecureString();
foreach (var c in password)
securePass.AppendChar(c);
securePass.MakeReadOnly();
return securePass;
}
/// <summary>
/// Compare the value of secure string object
/// </summary>
/// <param name="password"></param>
/// <param name="value"></param>
/// <returns>true/false according to the values equality</returns>
public static bool ValueEquals(this SecureString password, SecureString value)
{
IntPtr passBstr = IntPtr.Zero;
IntPtr valueBstr = IntPtr.Zero;
try
{
passBstr = Marshal.SecureStringToBSTR(password);
valueBstr = Marshal.SecureStringToBSTR(value);
int passLength = Marshal.ReadInt32(passBstr, -4);
int valueLength = Marshal.ReadInt32(valueBstr, -4);
if (passLength != valueLength)
return false;
for (int x = 0; x < passLength; ++x)
{
byte passByte = Marshal.ReadByte(passBstr, x);
byte valueByte = Marshal.ReadByte(valueBstr, x);
if (passByte != valueByte)
return false;
}
return true;
}
finally
{
if (passBstr != IntPtr.Zero)
Marshal.ZeroFreeBSTR(passBstr);
if (valueBstr != IntPtr.Zero)
Marshal.ZeroFreeBSTR(valueBstr);
}
}
}
public class SecureStringConversionException : Exception
{
public SecureStringConversionException()
{
}
public SecureStringConversionException(string message) : base(message)
{
}
public SecureStringConversionException(string message, Exception innerException) : base(message, innerException)
{
}
}
}
#endregion

302
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/ACLSample/ACLFunctionality.cs Normal file
View File

@ -0,0 +1,302 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using Intel.Manageability;
using Intel.Manageability.ACL;
using Intel.Manageability.Exceptions;
using System.Security;
namespace ACLSample
{
public static class ACLFunctionality
{
public static void CreateOrUpdateDigestUser(IAMTInstance amt)
{
//------------------------
// Create DigestEntry
//------------------------
List<Realm> realms = new List<Realm>
{
Realm.HardwareAsset,
Realm.Storage
};
// Create SecureString by password.
using (SecureString secureString = new SecureString())
{
foreach (char c in "P@ssw0rd")
secureString.AppendChar(c);
var digestEntry = new DigestEntry("DigestUser", secureString, realms, AccessPermission.Network);
try
{
amt.Config.ACL.CreateOrUpdateDigestUser(digestEntry);
Console.WriteLine("Create digest user completed successfully.");
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
}
public static void GetAllDigestUsers(IAMTInstance amt)
{
try
{
var digestUsers = amt.Config.ACL.GetAllDigestUsers();
Console.WriteLine("\n DigestUsers Details");
Console.WriteLine(" -------------------");
// Display DigestUser details.
digestUsers.ForEach(e => DisplayDigestUser(e));
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void GetDigestUser(IAMTInstance amt, string userName)
{
try
{
var digestEntry = amt.Config.ACL.GetDigestUser(userName);
Console.WriteLine("\n DigestUser Details");
// Display DigestUser details.
Console.WriteLine(" ------------------");
DisplayDigestUser(digestEntry);
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void DeleteDigestUser(IAMTInstance amt, string userNameOrSid)
{
try
{
amt.Config.ACL.DeleteDigestUser(userNameOrSid);
Console.WriteLine("Delete digest user completed successfully.");
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void CreateOrUpdateKerberosUser(IAMTInstance amt, string userNameOrSid)
{
//------------------------
// Create KerberosEntry
//------------------------
List<Realm> realms = new List<Realm> { Realm.Administration };
KerberosEntry kerberosEntry = new KerberosEntry(userNameOrSid, realms, AccessPermission.Any);
try
{
amt.Config.ACL.CreateOrUpdateKerberosUser(kerberosEntry);
Console.WriteLine("Create kerberos user completed successfully.");
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void GetAllKerberosUsers(IAMTInstance amt)
{
try
{
var kerberosUsers = amt.Config.ACL.GetAllKerberosUsers();
Console.WriteLine("\n KerberosUsers Details");
Console.WriteLine(" ---------------------");
kerberosUsers.ForEach(e => DisplayKerberosUser(e));
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void GetKerberosUser(IAMTInstance amt, string userNameOrSid)
{
try
{
// If UserNameOrSid equals to Domain\\UserName calculate the appropriate SID.
var kerberosUser = amt.Config.ACL.GetKerberosUser(userNameOrSid);
Console.WriteLine("\n KerberosUser Details");
Console.WriteLine(" --------------------");
DisplayKerberosUser(kerberosUser);
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void DeleteKerberosUser(IAMTInstance amt, string userNameOrSid)
{
try
{
amt.Config.ACL.DeleteKerberosUser(userNameOrSid);
Console.WriteLine("Delete kerberos user completed successfully.");
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch(ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void UpdateAdminUser(IAMTInstance amt, string UserName, string password)
{
try
{
// Create SecureString by password.
if (password == null)
{
Console.WriteLine("UpdateAdmin failed with error: Failed to update Admin user. ACLFailor: InvalidPassword");
return;
}
using (SecureString secureString = new SecureString())
{
foreach (char c in password)
secureString.AppendChar(c);
amt.Config.ACL.UpdateAdmin(UserName, secureString);
}
Console.WriteLine("Update admin user completed successfully.");
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailor: {2}\n",e.Source ,e.Message, e.Failure);
}
catch(ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void GetAdminUser(IAMTInstance amt)
{
try
{
string adminUser = amt.Config.ACL.GetAdminUser();
Console.WriteLine("The name of the admin user is "+adminUser);
}
catch (ACLManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} ACLFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (ManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1}\n", e.Source, e.Message);
}
}
public static void DisplayDigestUser(DigestEntry user)
{
Console.WriteLine("\n * Name : " + user.UserName);
// Get description attribute of AccessPermission.
Type type = user.Access.GetType();
MemberInfo[] memInfo = type.GetMember(user.Access.ToString());
object[] attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
string accessPermission = ((DescriptionAttribute)attributes[0]).Description;
Console.WriteLine(" Permission : " + accessPermission);
// Get description attribute of Realms.
Console.Write(" Realms : ");
foreach (Realm realm in user.Realms)
{
if ((uint)realm != 23 && (uint)realm != 22 && (uint)realm != 1)
{
type = realm.GetType();
memInfo = type.GetMember(realm.ToString());
attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
string realmString = ((DescriptionAttribute)attributes[0]).Description;
Console.Write(realmString + ", ");
}
}
Console.Write("\b\b \n");
}
public static void DisplayKerberosUser(KerberosEntry user)
{
Console.WriteLine("\n * SID : " + user.UserNameOrSID);
// Get description attribute of AccessPermission.
Type type = user.Access.GetType();
MemberInfo[] memInfo = type.GetMember(user.Access.ToString());
object[] attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
string accessPermission = ((DescriptionAttribute)attributes[0]).Description;
Console.WriteLine(" Permission : " + accessPermission);
// Get description attribute of Realms.
Console.Write(" Realms : ");
foreach (Realm realm in user.Realms)
{
if ((uint)realm != 23 && (uint)realm != 22 && (uint)realm != 1)
{
type = realm.GetType();
memInfo = type.GetMember(realm.ToString());
attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
string realmString = ((DescriptionAttribute)attributes[0]).Description;
Console.Write(realmString + ", ");
}
}
Console.Write("\b\b \n");
}
}
}

29
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/ACLSample/ACLSample.csproj Normal file
View File

@ -0,0 +1,29 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
<PackageReference Include="System.Security.Principal.Windows" Version="5.0.0" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

95
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/ACLSample/Program.cs Normal file
View File

@ -0,0 +1,95 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.IO;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.Runtime.InteropServices;
namespace ACLSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
Console.WriteLine(e.Message);
return;
}
try
{
// Create or update digest user.
ACLFunctionality.CreateOrUpdateDigestUser(amt);
// Get digest user by his name.
ACLFunctionality.GetDigestUser(amt, "DigestUser");
// Get all digest users.
ACLFunctionality.GetAllDigestUsers(amt);
// Delete digest user by his name.
ACLFunctionality.DeleteDigestUser(amt, "DigestUser");
// Create a kerberos user with the user's domain\username.
// The user must already be defined in Active Directory when creating the ACL Kerberos entry.
ACLFunctionality.CreateOrUpdateKerberosUser(amt, "Intel\\KerberosUser");
// Get kerberos user by his Domain\UserName
ACLFunctionality.GetKerberosUser(amt, "Intel\\KerberosUser");
// Get all kerberos users
ACLFunctionality.GetAllKerberosUsers(amt);
// Delete kerberos user by his SID
ACLFunctionality.DeleteKerberosUser(amt, "Intel\\KerberosUser");
// Update Admin user
ACLFunctionality.UpdateAdminUser(amt, "Admin", "p@ssw0rd");
// Get user name of the Admin user
ACLFunctionality.GetAdminUser(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/ACLSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ACLSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("ACLSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("102b502a-3a25-4bf5-9b9c-4b1afb2a091f")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

291
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AccessMonitorSample/AccessMonitorFunctionality.cs Normal file
View File

@ -0,0 +1,291 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using Intel.Manageability;
using Intel.Manageability.AccessMonitor;
using Intel.Manageability.Exceptions;
namespace AccessMonitorSample
{
public static class AccessMonitorFunctionality
{
private const string ROOT_CERT = @"..\..\RootCert.cer";
private const string LEAF_CERT = @"..\..\LeafCert.p12";
public static void GetAccessMonitorSettings(IAMTInstance amt)
{
try
{
AccessMonitorSettings settings = amt.AccessMonitor.GetAccessMonitorSettings();
PrintSettings(settings);
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void GetRegisteredEvents(IAMTInstance amt)
{
try
{
List<EventDetails> registeredEvents = amt.AccessMonitor.GetRegisteredEvents();
PrintEvents(registeredEvents);
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void RegisterToLog(IAMTInstance amt, List<EventDetails> eventDetails)
{
try
{
amt.AccessMonitor.RegisterToLog(eventDetails);
Console.WriteLine("Registered to log successfully.");
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void UnregisterToLog(IAMTInstance amt, string eventName)
{
try
{
amt.AccessMonitor.UnregisterToLog(eventName);
Console.WriteLine("Unregistered to log successfully.");
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void ReadLog(IAMTInstance amt)
{
try
{
string fqdn;
Guid guid;
List<AuditRecord> logRecords = amt.AccessMonitor.ReadLog(out guid, out fqdn);
Console.WriteLine("UUID:{0} FQDN:{1} Log Records:", guid.ToString(), fqdn);
PrintLogRecords(logRecords);
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static uint LockLog(IAMTInstance amt, LogLockType lockType, int timeOut)
{
try
{
uint lockHandle = amt.AccessMonitor.LockLog(lockType, timeOut);
Console.WriteLine("Locked log successfully.");
return lockHandle;
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
return 0;
}
public static void UnlockLog(IAMTInstance amt, uint lockHandle)
{
try
{
amt.AccessMonitor.UnlockLog(lockHandle);
Console.WriteLine("Unlocked log successfully.");
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void ClearLog(IAMTInstance amt)
{
try
{
amt.AccessMonitor.ClearLog();
Console.WriteLine("Cleared log successfully.");
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void SetEventStoragePolicy(IAMTInstance amt, EventsStoragePolicy eventsStoragePolicy)
{
try
{
amt.AccessMonitor.SetEventsStoragePolicy(eventsStoragePolicy);
Console.WriteLine("Events storage policy was set successfully.");
}
catch (NotSupportedException e)
{
Console.WriteLine("SetEventStoragePolicy failed with error: {0} \n", e.Message);
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void SetEventStoragePolicy(IAMTInstance amt, EventsStoragePolicy eventsStoragePolicy, int keepDays)
{
try
{
amt.AccessMonitor.SetEventsStoragePolicy(eventsStoragePolicy, keepDays);
Console.WriteLine("Events storage policy was set successfully.");
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void SetLogSignature(IAMTInstance amt)
{
try
{
// Set log signature with one certificate that contains public key and private key:
using (X509Certificate2 x509Certificate2 = new X509Certificate2(LEAF_CERT, "q", X509KeyStorageFlags.Exportable))
{
amt.AccessMonitor.SetLogSignature(x509Certificate2);
Console.WriteLine("Set log signature passed successfully.");
}
// Set log signature with chain of trusted certificates:
// 1. Create X509Chain object.
// 2. Set to X509Chain object additional certificates store from which the chain will be built.
// 3. Build certificates chain.
// 4. Set Access Monitor log signature.
using (X509Certificate2 rootCertificate = new X509Certificate2(ROOT_CERT))
using (X509Certificate2 leafCertificate = new X509Certificate2(LEAF_CERT, "q", X509KeyStorageFlags.Exportable))
using (X509Chain trustedChain = new X509Chain())
{
trustedChain.ChainPolicy.ExtraStore.Add(rootCertificate);
trustedChain.ChainPolicy.VerificationFlags = X509VerificationFlags.AllFlags;
trustedChain.Build(leafCertificate);
amt.AccessMonitor.SetLogSignature(trustedChain);
Console.WriteLine("Set log signature with certificates chain passed successfully.");
}
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void ReadLogSignature(IAMTInstance amt)
{
try
{
X509Chain amtCertificates;
Guid guid;
string fqdn;
List<AuditRecord> auditRecords = amt.AccessMonitor.ReadLogSignature(out amtCertificates, out guid, out fqdn, SignatureMechanism.SHA2_256);
Console.WriteLine("The log signature was read successfully, but it is still necessary to verify the trustworthiness of the AMT certificates chain used to sign the log......");
Console.WriteLine("Guid:{0} FQDN:{1} Log Records:", guid, fqdn);
PrintLogRecords(auditRecords);
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
}
public static void ReadLogAuthentication(IAMTInstance amt)
{
try
{
using (X509Certificate2 trustedCertificate = new X509Certificate2(ROOT_CERT))
{
Guid guid;
string fqdn;
// Read the log and check the signature againt the trustedCertificate.
List<AuditRecord> auditRecords = amt.AccessMonitor.ReadLogAuthentication(trustedCertificate, out guid, out fqdn, SignatureMechanism.SHA2_256);
Console.WriteLine("The log was read successfully. The authentication of the trusted certificate against AMT certificates passed.");
Console.WriteLine("Guid:{0} FQDN:{1} Log Records:", guid, fqdn);
PrintLogRecords(auditRecords);
}
}
catch (AccessMonitorManageabilityException e)
{
Console.WriteLine("{0} failed with error: {1} AccessMonitorFailure: {2}\n", e.Source, e.Message, e.Failure);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
#region Helper Methods
private static void PrintLogRecords(List<AuditRecord> logRecords)
{
logRecords.ForEach(e =>
{
Console.WriteLine(string.Format("\t* Event Name : {0}", e.EventName));
Console.WriteLine(string.Format("\t Event Trigger : {0}", e.EventTrigger));
Console.WriteLine(string.Format("\t UserName Or SID : {0}", e.UserNameOrSID));
Console.WriteLine(string.Format("\t Host Name : {0}", e.HostName));
Console.WriteLine(string.Format("\t Domain : {0}", e.Domain));
Console.WriteLine(string.Format("\t Time Stamp : {0}", e.TimeStamp));
Console.WriteLine();
});
}
private static void PrintEvents(List<EventDetails> registeredEvents)
{
Console.WriteLine("Registered Events:");
registeredEvents.ForEach(e =>
{
Console.WriteLine(string.Format("\t* Event Name : {0}", e.EventName));
Console.WriteLine(string.Format("\t Event Policy: {0}", e.EventPolicy));
Console.WriteLine();
});
}
private static void PrintSettings(AccessMonitorSettings settings)
{
Console.WriteLine("Access Monitor Settings:");
Console.WriteLine("========================");
Console.WriteLine(string.Format("\tEnabled State : {0}", settings.EnabledState));
Console.WriteLine(string.Format("\tAudit State : {0}", settings.LogState));
Console.WriteLine(string.Format("\tPercentage Log Free : {0}", settings.PercentageFree));
Console.WriteLine(string.Format("\tRecords Number : {0}", settings.CurrentRecordsNumber));
Console.WriteLine(string.Format("\tEvents Storage Policy: {0}", settings.EventsStoragePolicy));
if (settings.EventsStoragePolicy == EventsStoragePolicy.RestrictedRollOver)
Console.WriteLine(string.Format("\tMin Days To Keep : {0}", settings.MinDaysToKeep));
Console.WriteLine(string.Format("\tTime Of Last Record : {0}", settings.TimeOfLastRecord));
Console.WriteLine(string.Format("\tMax Allowed Auditors : {0}", settings.MaxAllowedAuditors));
}
#endregion
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AccessMonitorSample/AccessMonitorSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

BIN
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AccessMonitorSample/LeafCert.p12 Normal file
View File

Binary file not shown.

98
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AccessMonitorSample/Program.cs Normal file
View File

@ -0,0 +1,98 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.IO;
using Intel.Manageability;
using Intel.Manageability.AccessMonitor;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.Runtime.InteropServices;
namespace AccessMonitorSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
Console.WriteLine(e.Message);
return;
}
try
{
AccessMonitorFunctionality.SetLogSignature(amt);
AccessMonitorFunctionality.GetAccessMonitorSettings(amt);
AccessMonitorFunctionality.SetEventStoragePolicy(amt, EventsStoragePolicy.NoRollOver);
AccessMonitorFunctionality.GetRegisteredEvents(amt);
// Register AuditEvents.NetworkTime.AMTTimeSet event.
List<EventDetails> eventsDetails = new List<EventDetails>();
eventsDetails.Add(new EventDetails(AuditEvents.NetworkTime.AMTTimeSet, EventPolicy.None));
AccessMonitorFunctionality.RegisterToLog(amt, eventsDetails);
// Create AMTTimeSet event record in the log.
amt.TimeSynchronization.SetUtcNetworkTime();
AccessMonitorFunctionality.ReadLog(amt);
AccessMonitorFunctionality.ReadLogSignature(amt);
AccessMonitorFunctionality.ReadLogAuthentication(amt);
AccessMonitorFunctionality.UnregisterToLog(amt, AuditEvents.NetworkTime.AMTTimeSet);
AccessMonitorFunctionality.ClearLog(amt);
uint lockHandle = AccessMonitorFunctionality.LockLog(amt, LogLockType.UnprovisioningLock, 30);
// Perform unprovisioning AMT....
AccessMonitorFunctionality.UnlockLog(amt, lockHandle);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

35
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AccessMonitorSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,35 @@
using System.Reflection;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("AccessMonitorSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("AccessMonitorSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("6efe2964-4077-44ae-942a-16a76c1b156d")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

19
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AccessMonitorSample/RootCert.cer Normal file
View File

@ -0,0 +1,19 @@
-----BEGIN CERTIFICATE-----
MIIDEzCCAfugAwIBAgIJAPM8vkQAJQqRMA0GCSqGSIb3DQEBBQUAMDgxGzAZBgNV
BAMTEkRlbW8gUm9vdCBDQSBzZXZlcjELMAkGA1UEBhMCSUwxDDAKBgNVBAsTA0ZU
TDAeFw0xMzA0MzAwODQzMTdaFw0xNDA0MzAwODQzMTdaMDgxGzAZBgNVBAMTEkRl
bW8gUm9vdCBDQSBzZXZlcjELMAkGA1UEBhMCSUwxDDAKBgNVBAsTA0ZUTDCCASIw
DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALDlTPkkMYZ4NLigO9GdEr9S2jPI
0eBKiPpIWjr3nESvNsweNMhhZYD1ZY3EYpExGi7NZM0hiQ0numpCT9TKKlqloh2C
1WN/94hilmx/q07AL5ghbU9IW/m/wljnpSw3ogK/25T9FlyFkU+5HXO4lwM9tDFJ
lRFZgioNzE8r5yEFzLqrGzuMtqbOplElJPwq2GMYKZUYY5x5pGdcBNynpAy8n7FZ
ytXvhr6YhTt/Cy2kS8FUqtLyLQVx5kiPAZL2mt7O1vG8/z8fIngtlo3qlFRKZ2vT
/RZ+iBdYIyk7jQ1ARHANDRRMNn1ZFWyz9/6UxWUPJnXIJrLmY4Xil4V2PCcCAwEA
AaMgMB4wDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAbYwDQYJKoZIhvcNAQEF
BQADggEBAKW1f7UZefJtoV8KocV60z71D+VBM/pZSPbISIoiu4BjhY9IVitJaUhF
UmCRc6htN4f/SPOeeUB3FNVFptcEzMXo2sydUCgIM++Jb/Nn7TvBLwX40+VkF80K
FXJFG6rFFXMW1EXAuvdFEjWGAsfAIg0mtInS9+MzBsiyG1Bg1JOdZYTAT12mCpe7
PKalJMOXQChxP2Dqz1ABeCl9UXG9+Mjj8tJQz/06tP9gQCI3BxvWNVNV9gRXhGT6
jiSGRIKeiZMoqU2mFO2MDHgtu/Fp+6G3180NdeHaynaql3cxlPMHl9jGxcrkl7uH
eEqQ6OuFQqtWaxDICdZHyvezLf2RLjw=
-----END CERTIFICATE-----

88
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample/AgentPresenceLocalFunctionality.cs Normal file
View File

@ -0,0 +1,88 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using Intel.Manageability;
using Intel.Manageability.AgentPresence;
using Intel.Manageability.Exceptions;
namespace AgentPresenceLocalSample
{
static class AgentPresenceLocalFunctionality
{
public static void CreateOrUpdateAgent(IAMTInstance amt, string agentName)
{
// --------------------
// Create Agent
// --------------------
var actions = new List<AgentAction>
{
new AgentAction(AgentState.NotStarted, AgentState.Running, true, ActionSystemDefense.DeactivatePolicy,
false),
new AgentAction(AgentState.Stopped, AgentState.Expired | AgentState.Stopped, false,
ActionSystemDefense.ActivatePolicy, false)
};
Console.Write("Enter agent startup timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var startupTimer))
startupTimer = 120;
Console.WriteLine();
Console.Write("Enter agent heartbeat timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var intervalTimer))
intervalTimer = 120;
Console.WriteLine();
// Create policy and pass the action list as a parameter
Agent agent = new Agent(agentName, actions, startupTimer, intervalTimer);
// -------------------------------------------
// Add the agent to the Intel AMT instance
// -------------------------------------------
try
{
amt.AgentPresence.Remote.CreateOrUpdateAgent(agent);
Console.WriteLine("Create agent completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Create agent failed with exception: " + ex.Message);
}
}
public static void Start(IAMTInstance amt, string applicationName)
{
CreateOrUpdateAgent(amt, applicationName);
Console.WriteLine("Starting presence. The heartbeats will block this program's thread.");
Console.WriteLine("For an unblocking solution use any of the other agent presence samples.");
try
{
amt.AgentPresence.Local.StartPresence(applicationName);
Console.WriteLine("Start presence completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Start presence failed with exception: " + ex.Message);
}
}
public static void Shutdown(IAMTInstance amt, string applicationName)
{
try
{
amt.AgentPresence.Local.ShutdownPresence(applicationName);
Console.WriteLine("Shutdown presence completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Shutdown presence failed with exception: " + ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample/AgentPresenceLocalSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

62
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample/Program.cs Normal file
View File

@ -0,0 +1,62 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.IO;
using System.Runtime.InteropServices;
using Common.Utils;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
namespace AgentPresenceLocalSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
Console.WriteLine(e.Message);
return;
}
// Start Presence.
AgentPresenceLocalFunctionality.Start(amt, "MyAgent");
Console.WriteLine("Press enter to stop the agent");
Console.ReadLine();
// Shutdown Presence.
AgentPresenceLocalFunctionality.Shutdown(amt, "MyAgent");
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("AgentPresenceLocalSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyProduct("AgentPresenceLocalSample")]
[assembly: AssemblyCopyright("Copyright © Microsoft 2020")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("a9b8c01f-6f33-416e-a033-b57003ea315a")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

107
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample1/AgentPresenceLocalFunctionality1.cs Normal file
View File

@ -0,0 +1,107 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2012 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using Intel.Manageability.Exceptions;
using Intel.Manageability;
using Intel.Manageability.AgentPresence;
namespace AgentPresenceLocalSample1
{
static class AgentPresenceLocalFunctionality1
{
public static void CreateOrUpdateAgent(IAMTInstance amt, string agentName)
{
// --------------------
// Create Agent
// --------------------
var actions = new List<AgentAction>
{
new AgentAction(AgentState.NotStarted, AgentState.Running, true, ActionSystemDefense.DeactivatePolicy,
false),
new AgentAction(AgentState.Stopped, AgentState.Expired | AgentState.Stopped, false,
ActionSystemDefense.ActivatePolicy, false)
};
Console.Write("Enter agent startup timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var startupTimer))
startupTimer = 120;
Console.WriteLine();
Console.Write("Enter agent heartbeat timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var intervalTimer))
intervalTimer = 120;
Console.WriteLine();
// Create policy and pass the action list as a parameter
Agent agent = new Agent(agentName, actions, startupTimer, intervalTimer);
// -------------------------------------------
// Add the agent to the Intel AMT instance
// -------------------------------------------
try
{
amt.AgentPresence.Remote.CreateOrUpdateAgent(agent);
Console.WriteLine("Create agent completed successfully.");
}
catch (ManageabilityException ex)
{
if ((ex.InnerException is AgentPresenceManageabilityException ex1) && (ex1.Failure == AgentPresenceFailure.DuplicateAgent))
{
// Ignore the error, agent already exists
Console.WriteLine("Agent already exists");
return;
}
throw;
}
}
public static void Start(IAMTInstance amt, string applicationName)
{
// To start an agent, do the following:
// 1. Create the Agent by invoking IAMTInstance.AgentPresence.Remote.CreateOrUpdateAgent(string)
// with AgentName (see AgentPresenceRemoteSample sample).
// 2. From AMT - local, register to watchdog and send heartbeats by invoking amt.AgentPresence.Local.StartPresence().
// When the StartPresence function sends heartbeats, it activates an endless loop that sends a heartbeat each agent.TimeoutInterval,
// So, to avoid getting stuck on the StartPresence function, perform it in another thread.
CreateOrUpdateAgent(amt, applicationName);
ThreadPool.QueueUserWorkItem(agent =>
{
try
{
Console.WriteLine("Start presence: " + applicationName.ToString());
amt.AgentPresence.Local.StartPresence(applicationName);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Start presence failed with exception: " + ex.Message);
}
});
Console.WriteLine(applicationName + " is sending hearbeats, to stop press any key....");
Console.ReadKey();
}
public static void Shutdown(IAMTInstance amt, string applicationName)
{
try
{
amt.AgentPresence.Local.ShutdownPresence(applicationName);
Console.WriteLine("Shutdown " + applicationName + " completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Shutdown " + applicationName + " failed with exception: " + ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample1/AgentPresenceLocalSample1.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

75
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample1/Program.cs Normal file
View File

@ -0,0 +1,75 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using HLAPI;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace AgentPresenceLocalSample1
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
Console.WriteLine(e.Message);
return;
}
try
{
// StartPresence causes the agent to start sends heartbeats.
AgentPresenceLocalFunctionality1.Start(amt, "Agent1");
// ShutdownPresence causes the StartPresence to stop sending heartbeats. The thread that performs it was finished
// and the agent's state was changed to "stop".
AgentPresenceLocalFunctionality1.Shutdown(amt, "Agent1");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample1/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("AgentPresenceLocalSample1")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("AgentPresenceLocalSample1")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("68f024e8-5635-4938-9bd0-8ff2e61f57ed")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

108
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample2/AgentPresenceLocalFunctionality2.cs Normal file
View File

@ -0,0 +1,108 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2012 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using Intel.Manageability.Exceptions;
using Intel.Manageability;
using Intel.Manageability.AgentPresence;
namespace AgentPresenceLocalSample2
{
static class AgentPresenceLocalFunctionality2
{
public static void CreateOrUpdateAgent(IAMTInstance amt, string agentName)
{
// --------------------
// Create Agent
// --------------------
var actions = new List<AgentAction>
{
new AgentAction(AgentState.NotStarted, AgentState.Running, true, ActionSystemDefense.DeactivatePolicy,
false),
new AgentAction(AgentState.Stopped, AgentState.Expired | AgentState.Stopped, false,
ActionSystemDefense.ActivatePolicy, false)
};
Console.Write("Enter agent startup timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var startupTimer))
startupTimer = 120;
Console.WriteLine();
Console.Write("Enter agent heartbeat timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var intervalTimer))
intervalTimer = 120;
Console.WriteLine();
// Create policy and pass the action list as a parameter
Agent agent = new Agent(agentName, actions, startupTimer, intervalTimer);
// -------------------------------------------
// Add the agent to the Intel AMT instance
// -------------------------------------------
try
{
amt.AgentPresence.Remote.CreateOrUpdateAgent(agent);
Console.WriteLine("Create agent completed successfully.");
}
catch (ManageabilityException ex)
{
if ((ex.InnerException is AgentPresenceManageabilityException ex1) && (ex1.Failure == AgentPresenceFailure.DuplicateAgent))
{
// Ignore the error, agent already exists
Console.WriteLine("Agent already exists");
return;
}
throw ex;
}
}
public static void Start(IAMTInstance amt, string applicationName)
{
// To start an agent, do the following:
// 1. Create the Agent by invoking IAMTInstance.AgentPresence.Remote.CreateOrUpdateAgent(string)
// with AgentName (see AgentPresenceRemoteSample sample).
// 2. From AMT - local, register to watchdog and send heartbeats by invoking amt.AgentPresence.Local.StartPresence().
// When the StartPresence function sends heartbeats, it activates an endless loop that sends a heartbeat each agent.TimeoutInterval,
// So, to avoid getting stuck on the StartPresence function, perform it in another thread.
CreateOrUpdateAgent(amt, applicationName);
ThreadPool.QueueUserWorkItem(agent =>
{
try
{
Console.WriteLine("Start presence: " + applicationName.ToString());
amt.AgentPresence.Local.StartPresence(applicationName);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Start presence failed with exception: " + ex.Message);
}
});
Console.WriteLine(applicationName + " is sending hearbeats, to stop press any key....");
Console.ReadKey();
}
public static void Expire(IAMTInstance amt, string applicationName)
{
try
{
amt.AgentPresence.Local.ExpirePresence(applicationName);
Console.WriteLine("Expire " + applicationName + " completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Expire " + applicationName + " failed with exception: " + ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample2/AgentPresenceLocalSample2.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

74
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample2/Program.cs Normal file
View File

@ -0,0 +1,74 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using HLAPI;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace AgentPresenceLocalSample2
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// StartPresence causes the agent to start sends heartbeats.
AgentPresenceLocalFunctionality2.Start(amt, "Agent1");
// ExpirePresence causes the StartPresence to stop sending heartbeats. The thread that performs it was finished
// and the agent's state was changed to "expire".
AgentPresenceLocalFunctionality2.Expire(amt, "Agent1");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceLocalSample2/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("AgentPresenceLocalSample2")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("AgentPresenceLocalSample2")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("60e221c1-b614-4d5d-85a8-f1a4bd4775e7")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

341
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceRemoteSample/AgentPresenceRemoteFunctionality.cs Normal file
View File

@ -0,0 +1,341 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2015 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using Intel.Manageability;
using Intel.Manageability.AgentPresence;
using Intel.Manageability.SystemDefense;
using System.Collections.ObjectModel;
using Intel.Manageability.Exceptions;
using System.Collections;
namespace AgentPresenceRemoteSample
{
static class AgentPresenceRemoteFunctionality
{
public static void CreateOrUpdateAgent(IAMTInstance amt, string agentName)
{
// --------------------
// Create Agent
// --------------------
var actions = new List<AgentAction>
{
new AgentAction(AgentState.NotStarted, AgentState.Running, true, ActionSystemDefense.DeactivatePolicy,
false),
new AgentAction(AgentState.Stopped, AgentState.Expired | AgentState.Stopped, false,
ActionSystemDefense.ActivatePolicy, false)
};
Console.Write("Enter agent startup timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var startupTimer))
startupTimer = 120;
Console.WriteLine();
Console.Write("Enter agent heartbeat timeout in seconds (default is 120): ");
if (!ushort.TryParse(Console.ReadLine(), out var intervalTimer))
intervalTimer = 120;
Console.WriteLine();
// Create policy and pass the action list as a parameter
Agent agent = new Agent(agentName, actions, startupTimer, intervalTimer);
// -------------------------------------------
// Add the agent to the Intel AMT instance
// -------------------------------------------
try
{
amt.AgentPresence.Remote.CreateOrUpdateAgent(agent);
Console.WriteLine("Create agent completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Create agent failed with exception: " + ex.Message);
}
}
public static void DisplayAgents(IAMTInstance amt)
{
try
{
// Retrieve all agents
List<Agent> agents = amt.AgentPresence.Remote.GetAllAgents();
Console.WriteLine("Agents:");
Console.WriteLine("-------");
// Go over the agents and display their capabilities
IEnumerator agentEnumerator = agents.GetEnumerator();
while (agentEnumerator.MoveNext())
{
PrintAgentContent(agentEnumerator.Current as Agent);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Display agents failed with exception: " + ex.Message);
}
}
public static void GetAgent(IAMTInstance amt, string agentName)
{
try
{
// Retrieve all agents
Agent agent = amt.AgentPresence.Remote.GetAgent(agentName);
Console.WriteLine("\nAgent:");
Console.WriteLine("-------");
PrintAgentContent(agent);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Display agent failed with exception: " + ex.Message);
}
}
public static void DisplayCapabalities(IAMTInstance amt)
{
// Display general agent presence capabilities
AgentPresenceCapabilities generalCapabilities = amt.AgentPresence.Remote.GetGeneralCapabilities();
Console.WriteLine("\nGeneral capabilities:");
Console.WriteLine("\tMax Supported Agents: {0} ", generalCapabilities.MaxTotalAgents);
Console.WriteLine("\tMax Supported Actions: {0} ", generalCapabilities.MaxTotalActions);
Console.WriteLine("\tMax Supported EAC Agents: {0} ", generalCapabilities.MaxToatalEacAgents);
Console.WriteLine("\tMin Supported Actions: {0} ", generalCapabilities.MinAgentActions);
}
public static void DeleteAgent(IAMTInstance amt, string agentName)
{
try
{
amt.AgentPresence.Remote.DeleteAgent(agentName);
Console.WriteLine("Delete agent completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Delete agent failed with exception: " + ex.Message);
}
}
public static void DeleteAllAgent(IAMTInstance amt)
{
try
{
amt.AgentPresence.Remote.DeleteAllAgents();
Console.WriteLine("Delete all agents completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Delete agents failed with exception: " + ex.Message);
}
}
public static void SetAgentPresencePolicy(IAMTInstance amt)
{
Collection<Policy> policies = new Collection<Policy>();
Collection<UserFilter> filters = new Collection<UserFilter>();
// ----------------------
// Create Policy #1
// ----------------------
// Prepare filter list (create ipfilter for block ipv4 packets and ethernet filter for rarp packets)
IPFilter ipFilter = FilterFactory.CreateIPFilter("ipFilter", FilterType.Drop, FilterDirection.Both, true, IPVersion.IPv4);
EthernetFilter etherFilter = FilterFactory.CreateEthernetFilter("etherFilter", FilterType.StatisticsAndDrop, FilterDirection.Incoming, false, (ushort)EtherTypes.ETH_TYPE_RARP);
// Add the filters we just created to the filter list
filters.Add(ipFilter);
filters.Add(etherFilter);
// Create policy and pass the filters list as a parameter
policies.Add(new Policy("MyPolicy", 10, 150, filters));
// Add the policy to the Intel AMT instance
try
{
amt.SystemDefense.PolicyStore.CreateOrUpdatePolicies(policies);
Console.WriteLine("Create policy completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Create policy failed with exception: " + ex.Message);
}
try
{
// Set the policy to agent presence on the supported interface
amt.AgentPresence.Remote.SetSystemDefensePolicy("MyPolicy", Intel.Manageability.AgentPresence.NetworkInterface.Wired);
Console.WriteLine("Set the policy to Agent Presence completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Set the policy to Agent Presence failed with exception: " + ex.Message);
}
}
public static void GetAgentPresencePolicy(IAMTInstance amt)
{
try
{
// Get the policy from agent presence on the supported interface
Policy policy = amt.AgentPresence.Remote.GetSystemDefensePolicy(Intel.Manageability.AgentPresence.NetworkInterface.Wired);
Console.WriteLine("\nAgent Presence Policy:");
Console.WriteLine("----------------------");
PrintAgentPolicy(policy);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Get the policy from Agent Presence failed with exception: " + ex.Message);
}
}
public static void RemoveAgentPresencePolicy(IAMTInstance amt)
{
try
{
// Remove the policy from agent presence on the supported interface
amt.AgentPresence.Remote.RemoveSystemDefensePolicy(Intel.Manageability.AgentPresence.NetworkInterface.Wired);
Console.WriteLine("Remove the policy from Agent Presence completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Remove the policy from Agent Presence failed with exception: " + ex.Message);
}
}
public static void SetExpirationActionOnAgentPresenceWatchDog(IAMTInstance amt,string agentName)
{
try
{
//set expiration action properties
WatchDogExpirationAction expirationAction = new WatchDogExpirationAction(ExpirationAction.Reboot, ExpirationAction.Reboot, 60, true);
amt.AgentPresence.Remote.SetExpirationAction(expirationAction);
//apply expiration action on specific agent
amt.AgentPresence.Remote.ApplyActionOnWatchDog(agentName, true);
Console.WriteLine("Set expiration action completed successfully.");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Set expiration action failed with exception: " + ex.Message);
}
}
private static void PrintAgentContent(Agent agent)
{
Console.WriteLine("Agent Name: {0} \n", agent.ApplicationName);
Console.WriteLine("\tDevice ID: {0} ", agent.DeviceID);
Console.WriteLine("\tState: {0} ", agent.CurrentState);
Console.WriteLine("\tStartup Interval: {0} ", agent.StartupInterval);
Console.WriteLine("\tTimeout Interval: {0} ", agent.TimeoutInterval);
// Go over the actions and display their capabilities
IEnumerator actionEnumerator = agent.Actions.GetEnumerator();
Console.WriteLine("Actions:");
while (actionEnumerator.MoveNext())
{
var action = actionEnumerator.Current as AgentAction;
if (action == null)
{
Console.WriteLine("\tError: Failed to convert action to AgentAction");
break;
}
PrintAction(actionEnumerator.Current as AgentAction);
}
}
private static void PrintAction(AgentAction action)
{
Console.WriteLine("\n\t* Old State: {0} ", action.OldState);
Console.WriteLine("\t New State: {0} ", action.NewState);
Console.WriteLine("\t Create Event: {0} ", action.EventOnTransition);
Console.WriteLine("\t System Defense Action: {0} ", action.ActionSystemDefense);
Console.WriteLine("\t EAC Action: {0} \n", action.ActionEAC);
}
private static void PrintAgentPolicy(Policy policy)
{
Console.WriteLine("Policy Name: {0} ", policy.Name);
Console.WriteLine("\tPrecedence: {0} ", policy.Precedence);
Console.WriteLine("\tantiSpoofingSupport: {0} ", policy.antiSpoofingSupport);
Console.WriteLine("\tTimeout: {0} ", policy.Timeout);
Console.WriteLine("\tTx filter:\n\t\tDefaultCount: {0}\n\t\tDefaultDrop: {1}\n\t\tDefaultMatchEvent: {2}", policy.TxFilter.DefaultCount, policy.TxFilter.DefaultDrop, policy.TxFilter.DefaultMatchEvent);
Console.WriteLine("\tRx filter:\n\t\tDefaultCount: {0}\n\t\tDefaultDrop: {1}\n\t\tDefaultMatchEvent: {2}", policy.RxFilter.DefaultCount, policy.RxFilter.DefaultDrop, policy.RxFilter.DefaultMatchEvent);
// Go over the filters and display their capabilities
IEnumerator filterEnumerator = policy.Filters.GetEnumerator();
while (filterEnumerator.MoveNext())
{
Filter curFilter = filterEnumerator.Current as Filter;
if (curFilter is IPFilter)
{
PrintIPFilter(curFilter as IPFilter);
}
else if (curFilter is EthernetFilter)
{
PrintEthernetFilter(curFilter as EthernetFilter);
}
}
}
private static void PrintEthernetFilter(EthernetFilter ethernetFilter)
{
Console.WriteLine("\tFilter Name: {0} ", ethernetFilter.Name);
Console.WriteLine("\t\tFilter Direction: {0}", ethernetFilter.Direction.ToString());
Console.WriteLine("\t\tCreate Event: {0}", ethernetFilter.CreateEvent);
Console.WriteLine("\t\tFilter Profile: {0}", ethernetFilter.Profile.ToString());
if (ethernetFilter.Profile == FilterType.RateLimit)
Console.WriteLine("\t\tEvents Per Second: {0}", ethernetFilter.EventsPerSecond);
Console.WriteLine("\t\tProtocol ID: {0}", ethernetFilter.ProtocolID);
}
private static void PrintIPFilter(IPFilter ipFilter)
{
Console.WriteLine("\tFilter Name: {0} ", ipFilter.Name);
Console.WriteLine("\t\tFilter Direction: {0}", ipFilter.Direction.ToString());
Console.WriteLine("\t\tCreate Event: {0}", ipFilter.CreateEvent);
Console.WriteLine("\t\tFilter Profile: {0}", ipFilter.Profile.ToString());
if (ipFilter.Profile == FilterType.RateLimit)
Console.WriteLine("\t\tEvents Per Second: {0}", ipFilter.EventsPerSecond);
Console.WriteLine("\t\tIP Version: {0}", ipFilter.IpVersion.ToString());
if (ipFilter.IPAddress != null)
{
Console.WriteLine("\t\tIP Header Address: {0}", ipFilter.IPHeaderAddress.ToString());
Console.WriteLine("\t\tIP Address: {0}", ipFilter.IPAddress.ToString());
}
if (ipFilter.IPMask != null)
Console.WriteLine("\t\tIP Mask: {0}", ipFilter.IPMask.ToString());
if (ipFilter is ProtocolFilter)
Console.WriteLine("\t\tProtocol ID: {0}", ((ProtocolFilter)ipFilter).ProtocolID);
else if (ipFilter is TCPFilter)
{
Console.WriteLine("\t\tProtocol: TCP");
if (((TCPFilter)ipFilter).PortFilterExists)
{
Console.WriteLine("\t\tHeader Port Address: {0}", ((TCPFilter)ipFilter).HeaderPortAddress);
Console.WriteLine("\t\tPort1: {0}", ((TCPFilter)ipFilter).Port1);
Console.WriteLine("\t\tPort2: {0}", ((TCPFilter)ipFilter).Port2);
}
Console.WriteLine("\t\tFlags On: {0}", ((TCPFilter)ipFilter).FlagsOn);
Console.WriteLine("\t\tFlags Off: {0}", ((TCPFilter)ipFilter).FlagsOff);
}
else if (ipFilter is UDPFilter)
{
Console.WriteLine("\t\tProtocol: UDP");
Console.WriteLine("\t\tHeader Port Address: {0}", ((UDPFilter)ipFilter).HeaderPortAddress);
Console.WriteLine("\t\tPort1: {0}", ((UDPFilter)ipFilter).Port1);
Console.WriteLine("\t\tPort2: {0}", ((UDPFilter)ipFilter).Port2);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceRemoteSample/AgentPresenceRemoteSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

105
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceRemoteSample/Program.cs Normal file
View File

@ -0,0 +1,105 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2015 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.IO;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.Runtime.InteropServices;
namespace AgentPresenceRemoteSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// When creating an agent that is related to the EventManager feature, EventManager sends an event when Agent.eventOnTransition equals true.
// The event that was sent contains only the first 6 characters of the agent's name.
// Therefore, we recommend naming an agent with max length of 6 characters,
// otherwise the event that will be sent will include only the first part of the agent's name.
// Create Agent
AgentPresenceRemoteFunctionality.CreateOrUpdateAgent(amt, "Agent1");
// Create second Agent
AgentPresenceRemoteFunctionality.CreateOrUpdateAgent(amt, "Agent2");
// Get all Agents
AgentPresenceRemoteFunctionality.DisplayAgents(amt);
// Get Agent Presence capabilities
AgentPresenceRemoteFunctionality.DisplayCapabalities(amt);
// Get Agent by name
AgentPresenceRemoteFunctionality.GetAgent(amt, "Agent1");
// Set the policy for agent presence
AgentPresenceRemoteFunctionality.SetAgentPresencePolicy(amt);
// Get the policy from agent presence
AgentPresenceRemoteFunctionality.GetAgentPresencePolicy(amt);
// Remove the policy from agent presence
AgentPresenceRemoteFunctionality.RemoveAgentPresencePolicy(amt);
//Set expiration action on agent
AgentPresenceRemoteFunctionality.SetExpirationActionOnAgentPresenceWatchDog(amt, "Agent1");
// Delete specific agent
AgentPresenceRemoteFunctionality.DeleteAgent(amt, "Agent1");
// Delete specific agent
AgentPresenceRemoteFunctionality.DeleteAgent(amt, "Agent2");
// Delete all agents
AgentPresenceRemoteFunctionality.DeleteAllAgent(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AgentPresenceRemoteSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("AgentPrenceImpl")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("AgentPrenceImpl")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("f6633285-7cfa-4980-882a-a6fb6778f2e3")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

102
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AlarmClockSample/AlarmClockFunctionality.cs Normal file
View File

@ -0,0 +1,102 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2009-2013 All Rights Reserved.
//
// File: AlarmClockFunctionality.cs
//
// Contents: Demonstrate the IAlarmClock interface.
//
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.AlarmClock;
using Intel.Manageability.Exceptions;
namespace AlarmClockSample
{
public class AlarmClockFunctionality
{
/// <summary>
/// Display the current alarm clock settings
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void DisplaySettings(IAMTInstance amt)
{
try
{
AlarmClockSettings settings = amt.AlarmClock.GetAlarmClockSettings();
Console.WriteLine("Alarm Clock Settings:\n=====================\n");
Console.WriteLine("Next Alarm Time: {0}", (settings.NextAlarmTime != DateTime.MinValue) ? settings.NextAlarmTime.ToString() : @"N\A");
Console.WriteLine("Alarm Clock Interval: {0}", (settings.AlarmInterval != null) ? settings.AlarmInterval.ToString() : @"N\A");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Get alarm clock settings failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Configure a single wake up event
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void SetSingleAlarmTime(IAMTInstance amt)
{
DateTime date;
try
{
date = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day + 1);
Console.Write("Setting next alarm time to: "+date.ToString()+"...\t");
amt.AlarmClock.SetSingleAlarm(date);
Console.WriteLine("Success");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed");
Console.WriteLine("\n" + ex.Message);
}
}
/// <summary>
/// Configure a recurring wake up event
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void SetRecurringAlarm(IAMTInstance amt)
{
DateTime date;
try
{
date = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day + 1);
Console.Write("Setting recurring alarm to:" + date.ToString()+", with interval of 1 day...\t");
amt.AlarmClock.SetRecurringAlarm(date, new AlarmInterval(1,0,0));
Console.WriteLine("Success");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed");
Console.WriteLine("\n" + ex.Message);
}
}
/// <summary>
/// Disable the Alarm Clock
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void Disable(IAMTInstance amt)
{
try
{
Console.Write("Disable the alarm clock...\t");
amt.AlarmClock.DisableAll();
Console.WriteLine("Success");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed");
Console.WriteLine("\n" + ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AlarmClockSample/AlarmClockSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

76
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AlarmClockSample/Program.cs Normal file
View File

@ -0,0 +1,76 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2010-2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace AlarmClockSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// Get the current alarm clock settings
AlarmClockFunctionality.DisplaySettings(amt);
// Set a recurring alarm
AlarmClockFunctionality.SetRecurringAlarm(amt);
// Set a single alarm
AlarmClockFunctionality.SetSingleAlarmTime(amt);
// Disable the alarm clock
AlarmClockFunctionality.Disable(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/AlarmClockSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("AlarmClockSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("AlarmClockSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("84826e89-3928-4baf-a3ef-48c3bbf42bd1")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

215
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/BootControlSample/BootControlFunctionality.cs Normal file
View File

@ -0,0 +1,215 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2009-2012 All Rights Reserved.
//
// File: BootControlFunctionality.cs
//
// Contents: Demonstrate the IBootControl interface.
//
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.BootControl;
using Intel.Manageability.Exceptions;
namespace BootControlSample
{
class BootControlFunctionality
{
/// <summary>
/// Prints the boot capabilities of the Intel AMT system.
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void GetCapabilities(IAMTInstance amt)
{
try
{
BootCapabilities bootCapabilities = amt.BootControl.BootCapabilities;
Console.WriteLine("Boot Capabilities:");
Console.WriteLine("BiosReflash: " + bootCapabilities.BiosReflash);
Console.WriteLine("BiosSetup: " + bootCapabilities.BiosSetup);
Console.WriteLine("BiosPause: " + bootCapabilities.BiosPause);
Console.WriteLine("LockPowerButton: " + bootCapabilities.LockPowerButton);
Console.WriteLine("LockResetButton: " + bootCapabilities.LockResetButton);
Console.WriteLine("LockKeyboard: " + bootCapabilities.LockKeyboard);
Console.WriteLine("LockSleepButton: " + bootCapabilities.LockSleepButton);
Console.WriteLine("UserPasswordBypass: " + bootCapabilities.UserPasswordBypass);
Console.WriteLine("ForceProgressEvents: " + bootCapabilities.ForceProgressEvents);
Console.WriteLine("ConfigurationDataReset: " + bootCapabilities.ConfigurationDataReset);
Console.WriteLine("IDER: " + bootCapabilities.IDER);
Console.WriteLine("SOL: " + bootCapabilities.SOL);
Console.WriteLine("SafeMode: " + bootCapabilities.SafeMode);
Console.WriteLine("HardDriveBoot: " + bootCapabilities.HardDriveBoot);
Console.WriteLine("CdOrDvdBoot: " + bootCapabilities.CdOrDvdBoot);
Console.WriteLine("PXEBoot: " + bootCapabilities.PXEBoot);
Console.WriteLine("DiagnosticsBoot: " + bootCapabilities.DiagnosticsBoot);
Console.WriteLine("FirmwareVerbosityScreenBlank: " + bootCapabilities.FirmwareVerbosityScreenBlank);
Console.WriteLine("FirmwareVerbosityVerbose: " + bootCapabilities.FirmwareVerbosityVerbose);
Console.WriteLine("FirmwareVerbosityQuiet: " + bootCapabilities.FirmwareVerbosityQuiet);
//The Enforce Secure Boot option is enabled in Intel AMT version 8.1 and above.
if (CompareVersions(amt.MajorVersion + "." + amt.MinorVersion, "8.0") > 0)
Console.WriteLine("BiosSecureBoot: " + bootCapabilities.BiosSecureBoot);
//The Enforce Secure Erase option is enabled in Intel AMT version 11.0 and above.
if (CompareVersions(amt.MajorVersion + "." + amt.MinorVersion, "11.0") >= 0)
Console.WriteLine("SecureErase: " + bootCapabilities.SecureErase);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Get capabilities failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Prints the current boot settings of the Intel AMT system.
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void GetCurrentSetting(IAMTInstance amt)
{
BootOptionsFlags bootOptions;
BootSource bootSource;
FirmwareVerbosityEnum FWVerbosity;
try
{
amt.BootControl.GetCurrentSettings(out bootSource, out bootOptions, out FWVerbosity);
Console.WriteLine("Current boot Options: " + bootOptions.ToString());
Console.Write("Current boot Source: " + bootSource.Source.ToString());
Console.WriteLine(". index: " + bootSource.Index.ToString());
Console.WriteLine("Current Firmware Verbosity: " + FWVerbosity.ToString());
}
catch (ManageabilityException ex)
{
Console.WriteLine("Get current settings failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Sets the next boot to boot from a CD\DVD
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void SetNextBoot1(IAMTInstance amt)
{
try
{
BootSource bootSource = new BootSource(BootSourceEnum.CdOrDvdBoot, 1);
amt.BootControl.SetNextBoot(bootSource);
Console.WriteLine("Set next boot Succeed");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Set next boot failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Set the next boot to use IDE-R, SOL, and boot to the BIOS according to the capabilities.
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void SetNextBoot2(IAMTInstance amt)
{
BootCapabilities bootCapabilities = amt.BootControl.BootCapabilities;
BootSource bootSource;
if (bootCapabilities.IDER)
bootSource = new BootSource(BootSourceEnum.IDERCD);
else
bootSource = new BootSource(BootSourceEnum.NONE);
BootOptionsFlags flags = BootOptionsFlags.NONE;
if (bootCapabilities.SOL)
flags |= BootOptionsFlags.UseSOL;
if (bootCapabilities.BiosSetup)
flags |= BootOptionsFlags.BiosSetup;
FirmwareVerbosityEnum FWverbosity = FirmwareVerbosityEnum.NONE;
if (bootCapabilities.FirmwareVerbosityVerbose)
FWverbosity = FirmwareVerbosityEnum.Verbose;
try
{
amt.BootControl.SetNextBoot(bootSource, flags, FWverbosity);
Console.WriteLine("Set next boot succeed");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Set next boot failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Enforce Secure Boot for the next boot.
/// The Enforce Secure Boot ability is enabled in Intel AMT version 8.1 and above. It is enabled only on a machine that was burned specially with the BiosSecureBoot option.
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void SetNextBoot3(IAMTInstance amt)
{
BootCapabilities bootCapabilities = amt.BootControl.BootCapabilities;
BootOptionsFlags flags = BootOptionsFlags.NONE;
if(bootCapabilities.BiosSecureBoot)
flags |= BootOptionsFlags.EnforceSecureBoot;
try
{
amt.BootControl.SetNextBoot(flags);
Console.WriteLine("Enforce Secure Boot for next boot succeed");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Enforce Secure Boot for next boot failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Clear the boot options for the next boot.
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void Clear(IAMTInstance amt)
{
try
{
amt.BootControl.ClearBootOptions();
Console.WriteLine("Clear boot options succeed");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Clear boot options failed");
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Compare versions of the Intel AMT instance.
/// </summary>
/// <param name="amtversion">The version of the Intel AMT.</param>
/// <param name="version">The version to compare with.</param>
/// <returns> Less than zero -The current Intel AMT version is a version before version.</returns>
/// <returns> Zero - The current Intel AMT version is the same version as version.</returns>
/// <returns> Greater than zero - The current Intel AMT Version is a version subsequent to version.</returns>
private static int CompareVersions(string amtversion, string version)
{
try
{
Version amtVersion = new Version(amtversion);
Version versionToCopmare = new Version(version);
return amtVersion.CompareTo(versionToCopmare);
}
catch (Exception e)
{
throw new Exception("Compare versions failed. "+e.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/BootControlSample/BootControlSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

82
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/BootControlSample/Program.cs Normal file
View File

@ -0,0 +1,82 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2010-2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace BootControlSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
//Get Boot Capabilities
BootControlFunctionality.GetCapabilities(amt);
//Get Current Setting
BootControlFunctionality.GetCurrentSetting(amt);
//Set next boot to boot from CD
BootControlFunctionality.SetNextBoot1(amt);
//Set the next boot to use IDER + SOL and boot to BIOS according to the capabilities.
BootControlFunctionality.SetNextBoot2(amt);
//Enforce Secure Boot
BootControlFunctionality.SetNextBoot3(amt);
//Clear the boot options
BootControlFunctionality.Clear(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/BootControlSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("BootControlSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("BootControlSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("455b2575-5958-4771-97f3-d5bf53a24ca1")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

285
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/CertificateManagementFunctionality.cs Normal file
View File

@ -0,0 +1,285 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2012 - 2013 All Rights Reserved.
//
// File: CertificateManagementFunctionality.cs
//
// Contents: Example that shows how to use CertificateManagement High Level API
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
namespace CertificateManagementSample
{
class CertificateManagementFunctionality
{
private const string LEAF_CERT = @"..\..\LeafCert.p12";
private const string ROOT_CA = @"..\..\rootCA.cer";
private const string ROOT_CERT = @"..\..\RootCert.cer";
public static void AddCertificate(IAMTInstance amt)
{
try
{
Console.WriteLine("\nAdd a certificate to Intel AMT:");
Console.WriteLine("===============================\n");
// Read certificate with X509Certificate2 from .p12 file. The given property X509KeyStorageFlags.Exportable
// gives the X509Certificate2 object the instruction to export also the private key.
using (X509Certificate2 certificate = new X509Certificate2(LEAF_CERT, "q", X509KeyStorageFlags.Exportable))
{
amt.Config.CertificateManagement.AddCertificate(certificate);
}
Console.WriteLine("A certificate including a private key added successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
catch(CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void AddTrustedRootCertificate(IAMTInstance amt)
{
try
{
Console.WriteLine("\nAdd a trusted root certificate to Intel AMT:");
Console.WriteLine("============================================\n");
// Read trusted root certificate with X509Certificate2 from .cer file.
using (X509Certificate2 certificate = new X509Certificate2(ROOT_CA))
{
amt.Config.CertificateManagement.AddCertificate(certificate);
}
Console.WriteLine("A trusted root certificate added successfully");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void AddCertificateChain(IAMTInstance amt)
{
try
{
Console.WriteLine("\nAdd a certificate chain to Intel AMT:");
Console.WriteLine("=====================================\n");
using (X509Certificate2 rootCertificate = new X509Certificate2(ROOT_CERT))
{
using (X509Certificate2 leafCertificate = new X509Certificate2(LEAF_CERT, "q", X509KeyStorageFlags.Exportable)) //*****
{
// Create X509Chain object.
using (X509Chain trustedChain = new X509Chain())
{
// Set to the X509Chain object an additional certificates store from which the chain will be built.
trustedChain.ChainPolicy.ExtraStore.Add(rootCertificate);
// Ignore when determining certificate verification invalid certificates like:
// expired certificates, certificate with invalid policy, etc.
// Set this policy to AllFlags is necessary to the attached certificates in this sample only (The
// attached certificates are not valid).
trustedChain.ChainPolicy.VerificationFlags = X509VerificationFlags.AllFlags;
// Build certificates chain.
trustedChain.Build(leafCertificate);
// Add the chain elements to the certificate store in the Intel AMT.
amt.Config.CertificateManagement.AddCertificate(trustedChain);
}
}
}
Console.WriteLine("Certificate chain added successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void GetAllCertificates(IAMTInstance amt)
{
try
{
Console.WriteLine("\nGet all certificates:");
Console.WriteLine("=====================\n");
List<X509Certificate2> certificates = amt.Config.CertificateManagement.GetAllCertificates();
foreach (X509Certificate2 certificate in certificates)
{
PrintCertificate(certificate);
}
Console.WriteLine("Get all certificates completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void GetTrustedRootCertificates(IAMTInstance amt)
{
try
{
Console.WriteLine("\nGet all trusted root certificates:");
Console.WriteLine("==================================\n");
List<X509Certificate2> certificates = amt.Config.CertificateManagement.GetTrustedRootCertificates();
foreach (X509Certificate2 certificate in certificates)
{
PrintCertificate(certificate);
}
Console.WriteLine("Get all trusted root certificates completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void GetNonTrustedRootCertificates(IAMTInstance amt)
{
try
{
Console.WriteLine("\nGet all non trusted root certificates:");
Console.WriteLine("======================================\n");
List<X509Certificate2> certificates = amt.Config.CertificateManagement.GetNonTrustedRootCertificates();
foreach (X509Certificate2 certificate in certificates)
{
PrintCertificate(certificate);
}
Console.WriteLine("Get all non trusted root certificates completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void GetCertificateChain(IAMTInstance amt)
{
try
{
Console.WriteLine("\nGet certificates chain:");
Console.WriteLine("=======================\n");
// Get certificates chain of certificate leaf.
using (X509Certificate2 leaf = new X509Certificate2(LEAF_CERT, "q", X509KeyStorageFlags.Exportable))
{
X509Chain chain = amt.Config.CertificateManagement.GetChain(leaf);
foreach (X509ChainElement x509ChainElement in chain.ChainElements)
{
PrintCertificate(x509ChainElement.Certificate);
}
}
Console.WriteLine("Get certificates chain completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void RemoveCertificate(IAMTInstance amt)
{
try
{
Console.WriteLine("\nRemove certificate:");
Console.WriteLine("===================\n");
// Remove certificate including its private key.
using (X509Certificate2 certificate = new X509Certificate2(LEAF_CERT, "q", X509KeyStorageFlags.Exportable))
{
amt.Config.CertificateManagement.RemoveCertificate(certificate);
}
Console.WriteLine("Remove certificate including its private key completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void RemoveNonTrustedRootCertificates(IAMTInstance amt)
{
try
{
Console.WriteLine("\nRemove non trusted root certificates:");
Console.WriteLine("=====================================\n");
// Delete non trusted roots certificates including their private keys.
amt.Config.CertificateManagement.RemoveNonTrustedRootCertificates(true);
Console.WriteLine("Remove non trusted root certificates completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void RemoveTrustedRootCertificates(IAMTInstance amt)
{
try
{
Console.WriteLine("\nRemove trusted root certificates:");
Console.WriteLine("=================================\n");
amt.Config.CertificateManagement.RemoveTrustedRootCertificates();
Console.WriteLine("Remove trusted root certificates completed successfully.");
}
catch (CertificateManagementManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
}
private static void PrintCertificate(X509Certificate2 certificate)
{
Console.WriteLine("Name : {0}", certificate.FriendlyName);
Console.WriteLine("Issuer : {0}", certificate.Issuer);
Console.WriteLine("Subject : {0}", certificate.Subject);
Console.WriteLine("Has Private Key : {0}", certificate.HasPrivateKey);
Console.WriteLine("=================================================\n");
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/CertificateManagementSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

BIN
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/LeafCert.p12 Normal file
View File

Binary file not shown.

85
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/Program.cs Normal file
View File

@ -0,0 +1,85 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2012 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.IO;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.Runtime.InteropServices;
namespace CertificateManagementSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// Add a certificate including a private key.
CertificateManagementFunctionality.AddCertificate(amt);
// Add a trusted root certificate.
CertificateManagementFunctionality.AddTrustedRootCertificate(amt);
// Add a certificate chain.
CertificateManagementFunctionality.AddCertificateChain(amt);
// Get All Certificates.
CertificateManagementFunctionality.GetAllCertificates(amt);
// Get Trusted Root Certificates.
CertificateManagementFunctionality.GetTrustedRootCertificates(amt);
// Get Non Trusted Root Certificates.
CertificateManagementFunctionality.GetNonTrustedRootCertificates(amt);
// Get certificate chain.
CertificateManagementFunctionality.GetCertificateChain(amt);
// Remove a certificate.
CertificateManagementFunctionality.RemoveCertificate(amt);
// Remove all NonTrustedRoot certificates.
CertificateManagementFunctionality.RemoveNonTrustedRootCertificates(amt);
// Remove all TrustedRoot certificates.
CertificateManagementFunctionality.RemoveTrustedRootCertificates(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("CertificateManagementSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyProduct("CertificateManagementSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("b6677e67-7999-4343-b231-20dc40e9c42c")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

81
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/RootCert.cer Normal file
View File

@ -0,0 +1,81 @@
Certificate:
Data:
Version: 3 (0x2)
Serial Number: 1 (0x1)
Signature Algorithm: sha1WithRSAEncryption
Issuer: CN=Demo Sub CA #5
Validity
Not Before: Nov 9 11:59:48 2011 GMT
Not After : Nov 8 11:59:48 2012 GMT
Subject: CN=Demo Sub CA #6
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
RSA Public Key: (2048 bit)
Modulus (2048 bit):
00:c9:78:1e:f2:c9:c9:fb:93:b3:f6:6f:31:1c:9a:
2a:f9:12:0b:23:7b:ca:ac:53:2c:fe:db:4d:7d:84:
91:f9:2b:19:cf:02:dc:fc:22:30:a6:51:09:17:58:
4c:d1:eb:65:38:b1:25:7a:29:16:35:3b:28:2e:27:
16:be:de:06:ef:10:8d:41:56:bd:99:5d:23:05:7b:
15:5c:dc:0f:b7:5d:e6:e2:3d:1f:9c:9b:69:6d:d9:
66:2d:b8:24:f5:c1:96:57:c7:49:2c:ee:1c:d9:c0:
0c:91:50:87:74:9b:72:e6:a8:c6:52:55:09:75:c0:
ff:72:2c:08:31:bf:db:62:35:67:48:c7:43:fa:7f:
c2:27:8d:19:7a:25:5b:66:96:03:f6:c4:8d:f8:87:
80:d2:fe:e5:d2:11:bb:0d:0b:86:39:e2:e8:06:ef:
be:43:14:aa:7b:3a:84:c3:c4:f5:14:37:40:5f:98:
89:c9:d4:c7:bb:01:c0:20:10:de:d2:68:d5:fb:45:
98:20:1b:59:43:cf:20:8c:94:1e:f2:50:8c:66:43:
e9:2e:fc:d0:0c:0f:2c:b4:dd:10:34:df:38:e0:84:
a3:ee:26:d7:83:48:6c:5d:89:14:b4:40:fd:d6:57:
e4:37:34:91:ee:37:33:b9:b7:75:e5:42:82:cd:ca:
aa:cd
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Subject Key Identifier:
20:CC:F1:DF:45:3D:7A:6A:D2:E1:E2:69:EA:96:FF:0C:AF:86:B0:8E
X509v3 Authority Key Identifier:
keyid:F6:0C:12:F6:5A:EA:33:E9:A7:84:B5:A8:57:B5:D4:3A:AF:BB:48:E1
DirName:/CN=Demo Sub CA #4
serial:01
X509v3 Key Usage:
Digital Signature, Certificate Sign, CRL Sign
X509v3 Basic Constraints: critical
CA:TRUE, pathlen:1
Signature Algorithm: sha1WithRSAEncryption
38:3e:10:6f:27:0f:39:ca:9f:2b:10:6d:3f:1d:fb:49:97:ba:
bf:8c:ae:c6:d4:58:0f:16:92:f3:5a:61:31:72:f8:a3:60:04:
63:fb:27:64:18:aa:f5:3b:a5:12:4a:c2:1d:c6:c6:30:1c:5a:
a4:06:e6:60:41:42:06:8d:47:86:97:d8:38:79:c8:10:a9:91:
7a:14:7b:8e:97:f4:d2:15:ed:c1:7a:62:4b:cd:81:85:20:3d:
88:f8:b7:fc:66:b3:0b:f6:0b:b7:0e:70:c9:66:66:db:f4:ac:
5a:93:76:96:79:cd:55:d2:28:8a:31:17:ec:e5:f3:89:82:62:
d5:51:27:2f:b8:87:73:81:fc:24:84:11:3e:d5:42:15:d9:c8:
90:44:62:62:f7:b2:c6:a7:ed:12:2c:50:16:52:e7:da:63:36:
4e:3f:20:ec:16:e8:f3:fb:0d:87:a5:c4:c2:c1:dd:ec:91:6f:
6f:ff:3a:05:5a:dc:ca:fd:6d:81:5d:b9:e0:19:98:19:fb:48:
6a:06:6f:96:07:45:96:24:71:09:23:c7:72:3f:49:82:ad:31:
87:d9:c8:2b:20:81:32:e2:77:14:11:83:e5:f1:21:a5:84:28:
5a:64:67:55:4c:0c:63:0c:64:b3:e8:41:7f:e6:ab:89:3c:be:
2a:bf:94:14
-----BEGIN CERTIFICATE-----
MIIDNDCCAhygAwIBAgIBATANBgkqhkiG9w0BAQUFADAZMRcwFQYDVQQDFA5EZW1v
IFN1YiBDQSAjNTAeFw0xMTExMDkxMTU5NDhaFw0xMjExMDgxMTU5NDhaMBkxFzAV
BgNVBAMUDkRlbW8gU3ViIENBICM2MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
CgKCAQEAyXge8snJ+5Oz9m8xHJoq+RILI3vKrFMs/ttNfYSR+SsZzwLc/CIwplEJ
F1hM0etlOLEleikWNTsoLicWvt4G7xCNQVa9mV0jBXsVXNwPt13m4j0fnJtpbdlm
Lbgk9cGWV8dJLO4c2cAMkVCHdJty5qjGUlUJdcD/ciwIMb/bYjVnSMdD+n/CJ40Z
eiVbZpYD9sSN+IeA0v7l0hG7DQuGOeLoBu++QxSqezqEw8T1FDdAX5iJydTHuwHA
IBDe0mjV+0WYIBtZQ88gjJQe8lCMZkPpLvzQDA8stN0QNN844ISj7ibXg0hsXYkU
tED91lfkNzSR7jczubd15UKCzcqqzQIDAQABo4GGMIGDMB0GA1UdDgQWBBQgzPHf
RT16atLh4mnqlv8Mr4awjjBBBgNVHSMEOjA4gBT2DBL2Wuoz6aeEtahXtdQ6r7tI
4aEdpBswGTEXMBUGA1UEAxQORGVtbyBTdWIgQ0EgIzSCAQEwCwYDVR0PBAQDAgGG
MBIGA1UdEwEB/wQIMAYBAf8CAQEwDQYJKoZIhvcNAQEFBQADggEBADg+EG8nDznK
nysQbT8d+0mXur+MrsbUWA8WkvNaYTFy+KNgBGP7J2QYqvU7pRJKwh3GxjAcWqQG
5mBBQgaNR4aX2Dh5yBCpkXoUe46X9NIV7cF6YkvNgYUgPYj4t/xmswv2C7cOcMlm
Ztv0rFqTdpZ5zVXSKIoxF+zl84mCYtVRJy+4h3OB/CSEET7VQhXZyJBEYmL3ssan
7RIsUBZS59pjNk4/IOwW6PP7DYelxMLB3eyRb2//OgVa3Mr9bYFdueAZmBn7SGoG
b5YHRZYkcQkjx3I/SYKtMYfZyCsggTLidxQRg+XxIaWEKFpkZ1VMDGMMZLPoQX/m
q4k8viq/lBQ=
-----END CERTIFICATE-----

19
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/CertificateManagementSample/rootCA.cer Normal file
View File

@ -0,0 +1,19 @@
-----BEGIN CERTIFICATE-----
MIIDBzCCAe+gAwIBAgIJANOlD6v9jiMPMA0GCSqGSIb3DQEBCwUAMDIxFTATBgNV
BAMTDERlbW8gUm9vdCBDQTELMAkGA1UEBhMCSUwxDDAKBgNVBAsTA0ZUTDAeFw0x
MTA0MjUwODIwNDBaFw0xMTA0MjYwODIwNDBaMDIxFTATBgNVBAMTDERlbW8gUm9v
dCBDQTELMAkGA1UEBhMCSUwxDDAKBgNVBAsTA0ZUTDCCASIwDQYJKoZIhvcNAQEB
BQADggEPADCCAQoCggEBANxI7o63gycb1+Cq6WpHtsJiFDC7mN620P+A+kBopTPy
z0WYLxK8827YwxTmi7zRN96SBYWMpS1SnJ8/rmNMILiVIXPyHn1E1usqGgxifckg
RwgZbzNdaO9mi/G/mP3EG/vvk7ERAPc9bB8xWtV+s7nVzLdt/Bayq2UIYZj6yvH0
1qFh6Mw6rQGPuVM+WUADOdv+y4+DF/WA88OjicOnhYaELJuW4mXZVz0DP8PoouPy
N15ePml7v+Iuj8TUcn1C8BpsfLDtOYsZVrOVkzfXrjO0mfgGJnop8pp1bn/GbSKF
G0ZlsXNoiJezXNq0f2ONUougC1JGdkWqWC2677OhfG0CAwEAAaMgMB4wDwYDVR0T
AQH/BAUwAwEB/zALBgNVHQ8EBAMCAbYwDQYJKoZIhvcNAQELBQADggEBAC+3TpES
wnlF+c/0L+Hf7z0huqMpTroadnBWjWNLBfcRAQnXI3iC7ANg6E6s/Evfc45A7ZyF
lGTmw2MVIj/GdCtRuf8kpVK9hNOaLK1nnByW8pWP1Mcg/Ai5JY6odvgcSHpsGUA4
4t9Xfg3a5vPV+tWyccHMknd3wzhTEwQqZ+Cxb5uD2jbA9JS5Jmhtdbk6sVbiusis
NV2Jx5zuhycVK9nc49kZNv6c8YnnSDxcw7B9a99NYKRo9TXJbCsnLnghkwRTMCbz
RcaFfjnFQCx85XeoNo2zLIYCZ6k93EhJz12FFYu1CR4vkYlINvhsFFPeuSEVdt+w
rx6KN5172jtMg+Y=
-----END CERTIFICATE-----

64
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/DiscoverySample/DiscoveryFunctionality.cs Normal file
View File

@ -0,0 +1,64 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2009-2011 All Rights Reserved.
//
// File: LogEventFunctionality.cs
//
// Contents: Example that shows how to use event log High Level API
//
// Notes:
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using HLAPI.GeneralInfo;
namespace DiscoverySample
{
public class DiscoveryFunctionality
{
public static void Discovery(IAMTInstance amt)
{
try
{
// Get SKU version.
SKU skuVersion = amt.GeneralInfo.GetSkuVersion();
// Get host + domain name.
string hostName = amt.GeneralInfo.GetFQDN(FQDN.Host);
// Print the FQDN and the SKU version for the AMT.
Console.WriteLine("The supported features in AMT platform for host {1} with {0} SKU:", skuVersion, hostName);
// Print AMT's supported features list.
foreach (AMTFeatures supportedFeature in amt.SupportedFeatures)
{
Console.WriteLine(" * {0}", supportedFeature);
}
}
catch (GeneralInfoException ex)
{
Console.WriteLine(ex.Message);
}
}
public static void CheckForSupportedFeature(IAMTInstance amt)
{
try
{
// If KVM feature is supported in this AMT, get KVM interface state.
if (true == amt.SupportedFeatures.Contains(AMTFeatures.KVM))
{
bool intefaceState = amt.KVMSetup.GetInterfaceState();
}
}
catch (ManageabilityException ex)
{
Console.WriteLine(ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/DiscoverySample/DiscoverySample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

59
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/DiscoverySample/Program.cs Normal file
View File

@ -0,0 +1,59 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.IO;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.Runtime.InteropServices;
namespace DiscoverySample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
// Discovery on AMT platform.
DiscoveryFunctionality.Discovery(amt);
// Wake up AMT machine, only if Power feature is supported.
DiscoveryFunctionality.CheckForSupportedFeature(amt);
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/DiscoverySample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("PowerSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyProduct("PowerSample")]
[assembly: AssemblyCopyright("Copyright © Microsoft 2020")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("c21e166e-42a8-4a39-b80f-db15769af506")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/EventLogSample/EventLogSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

355
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/EventLogSample/LogEventFunctionality.cs Normal file
View File

@ -0,0 +1,355 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2009-2014 All Rights Reserved.
//
// File: LogEventFunctionality.cs
//
// Contents: Example that shows how to use event log High Level API
//
// Notes:
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Intel.Manageability.Events;
using System.Collections.Generic;
using System.Linq;
namespace EventLogSample
{
public class LogEventFunctionality
{
public static void RegisterToLog(IAMTInstance amt)
{
try
{
//-----------------------------------------------------------------------------------------------------
// #1 - Register events so that they will be logged in the event log by using filter name (type string)
// Use a filter name from the "Event" class
//-----------------------------------------------------------------------------------------------------
//Register events using the event string from Events class, which contains strings of the filter names.
amt.Events.Log.RegisterToLog(Events.Battery.All_Battery_Events);
Console.WriteLine("\nFirst RegisterToLog operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to register filter with filter's name (type string) failed.\n" +
"Failure reason: {0}", ex.Message);
}
try
{
//-----------------------------------------------------------------------------------------------
//#2 Register events using Filter object
//-----------------------------------------------------------------------------------------------
//Register events with Filter object, which contains the values that define
//the desired events to be logged to the event log.
//Create new filter:
Filter filter = new Filter(255, 4, 18, 254, 0, 150, 0, 0, 44, 255);
//Register events with the filter
amt.Events.Log.RegisterToLog(filter);
Console.WriteLine("\nSecond RegisterToLog operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to register events with Filter object failed.\n" +
"Failure reason: {0}", ex.Message);
}
}
public static void UnRegisterToLog(IAMTInstance amt)
{
bool error = false;
try
{
//-----------------------------------------------------------------------------------------------
//Unegister events using filter name (type string) from the "Event" class (registered in step #1)
//-----------------------------------------------------------------------------------------------
//Unegister events with received event string from Events class, which contains strings of the filter names.
amt.Events.Log.UnRegisterToLog(Events.Battery.All_Battery_Events);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to Unregister filter with filter's name (type string) failed.\n" +
"Failure reason: {0}", ex.Message);
error = true;
}
try
{
//-----------------------------------------------------------------------------------------------
//Unregister event policy, using PolicyId = 44, which was the policy defined in step #2
//-----------------------------------------------------------------------------------------------
//To register events with PolicyId, need to make sure that the Filter exists.
//If the filter with this PolicyId does not exist, create new Filter with the desired PolicyId.
//Unregister event policy, in case that the PolicyId of the filter is known to the user.
amt.Events.Log.UnRegisterToLog(44);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to unregister event log policy with PolicyId failed.\n" +
"Failure reason: {0}", ex.Message);
error = true;
}
if(!error)
Console.WriteLine("\nUnRegisterToLog operation completed successfully");
}
public static void ClearLog(IAMTInstance amt)
{
int percentageLog;
try
{
//Get the percentage of log entries.
percentageLog = amt.Events.Log.GetPercentageLog();
}
catch (ManageabilityException ex)
{
throw ex;
}
if (percentageLog > 90)
{
//If the log is frozen, modifications are not allowed and log records cannot be deleted.
if (amt.Events.Log.IsLogFrozen() == false)
{
try
{
amt.Events.Log.ClearLog();
Console.WriteLine("\nClearLog operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to clear the entire log failed.\n" +
"Failure reason: {0}", ex.Message);
}
}
else
{
Console.WriteLine("Can not clear the log when it is frozen.");
}
}
else
{
Console.WriteLine("There is no need to clear the log. Percentage of log entries is: {0}", percentageLog);
}
}
public static void FreezeLog(IAMTInstance amt)
{
try
{
//Freeze the event log.
amt.Events.Log.FreezeLog(true);
Console.WriteLine("\nFreezeLog operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to Freeze the log failed.\n" +
"Failure reason: {0}", ex.Message);
}
}
public static void UnFreezeLog(IAMTInstance amt)
{
//Unfreeze the event log.
try
{
amt.Events.Log.FreezeLog(false);
Console.WriteLine("\nUnFreezeLog operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to unfreeze the log failed.\n" +
"Failure reason: {0}", ex.Message);
}
}
public static void GetRecords(IAMTInstance amt, uint identifier, uint num)
{
//Defined array from Record type.
IEnumerable<Record> log = new List<Record>();
try
{
//Get the all the records from the log into the array named "log".
log = amt.Events.Log.GetRecords(identifier, num);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to get the specific records from the log failed.\n" + ex.Message);
}
parseLog(log, (int)identifier);
}
public static void GetAllRecords(IAMTInstance amt)
{
//Defined array from Record type.
IEnumerable<Record> log = new List<Record>();
try
{
//Get the all the records from the log into the array named "log".
log = (IEnumerable<Record>)amt.Events.Log.GetAllRecords();
}
catch (ManageabilityException ex)
{
Console.WriteLine("Attempt to get the records from the log failed.\n" +
"Failure reason: {0}", ex.Message);
}
parseLog(log, 0);
}
private static void parseLog(IEnumerable<Record> log, int start)
{
if (log.Count() != 0)
{
//------------------------------
//#1 Filter records, using LINQ, by timestamp.
//------------------------------
//Select the records from the last day.
IEnumerable<Record> query = from r in log
where DateTime.Compare(r.TimeStamp, DateTime.Today.AddDays(-1)) >= 0
select r;
//Print the records
PrintRecords(query, start);
//------------------------------
//#2 Filter records, using LINQ, by Severity.
//------------------------------
//Select the records where the severity is "Information",
//using the value in the id.
query = from r in log
where r.Severity.Id == 255
select r;
//Print the records
PrintRecords(query, start);
//------------------------------
//#3 Filter records, using LINQ, by Entity.
//------------------------------
//Select the records where the Entity is "Bios",
//using Entity.Description property.
query = from r in log
where r.Entity.Description == "Peripheral Bay"
select r;
//Print the records
PrintRecords(query, start);
//------------------------------
//#4 Filter records, using LINQ, by Sensor Type
//------------------------------
//Select the records where the Sensor Type is "AMT_Agent_Presence",
//using enum "Entity".
query = from r in log
where r.Entity.Id == 1
select r;
//Print the records.
PrintRecords(query, start);
//------------------------------
//#5 Filter records, using LINQ, by Message.
//------------------------------
//Select the records where the Message is "AMT_Password_Attack".
query = from r in log
where r.Message == "AMT_Password_Attack"
select r;
//Print the records
PrintRecords(query, start);
//------------------------------
//#6 Filter records, using LINQ, by EventOffset.Description property.
//------------------------------
//Select the records where the EventOffset.Description is "Lower Non-critical - going low".
//This value appears when EventType = 1 and EventOffset = 1.
query = from r in log
where r.EventOffset.Description == "Lower Non-critical - going low"
select r;
//Print the records
PrintRecords(query, start);
//------------------------------
//#7 Filter records, using LINQ, by SensorType.Id property.
//------------------------------
//Select the records where the EventOffset.Id is 3. (stands for "Voltage")
query = from r in log
where r.SensorType.Id == 3
select r;
//Print the records
PrintRecords(query, start);
}
else
{
Console.WriteLine("There are no records in the log");
}
}
public static void CurrentNumberOfRecord(IAMTInstance amt)
{
try
{
Console.WriteLine("Current number of records in the log: {0}", amt.Events.Log.GetCurrentNumberOfRecords());
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get current number of records. Failure reason: {0}", ex.Message);
}
}
private static void PrintRecords(IEnumerable<Record> query, int startFrom)
{
//Give template id to record.
int numRecord = startFrom;
//Print the records
foreach (Record record in query)
{
//Console.WriteLine("Record Id | Timestamp | Severity | Sensor Type | Entity | Message | ");
//string byteString = Convert.ToString(bytes[ctr], 2);
//byteString = new String('0', 8 - byteString.Length) + byteString;
//_binarString += byteString;
Console.WriteLine("record number: {0}", numRecord++);
Console.WriteLine("Timestamp: {0}", record.TimeStamp);
Console.WriteLine("Severity: {0}", record.Severity.Description);
Console.WriteLine("Sensor Type: {0}", record.SensorType.Description);
Console.WriteLine("Sensor Number: {0}", record.SensorNumber);
Console.WriteLine("Entity: {0}", record.Entity);
Console.WriteLine("Entity Instance: {0}", record.EntityInstance);
Console.WriteLine("Message: {0}", record.Message);
Console.WriteLine("Event Type: {0}", record.EventType.Description);
Console.WriteLine("Event Source: {0}", record.EventSource);
Console.WriteLine("Device Address: {0}", record.DeviceAddress);
Console.WriteLine("------------------------------------------------------------");
}
}
}
}

92
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/EventLogSample/Program.cs Normal file
View File

@ -0,0 +1,92 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections;
using System.Security;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace EventLogSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// check if JSON path was provided in CMD. If empty, default directory file will be selected
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
//Getting the current number of record in the log.
LogEventFunctionality.CurrentNumberOfRecord(amt);
//Getting existing records in the log.
LogEventFunctionality.GetAllRecords(amt);
//Getting existing specific records in the log.
LogEventFunctionality.GetRecords(amt, 3, 20);
//Register Event Filter to recorded in the log.
LogEventFunctionality.RegisterToLog(amt);
//Unegister Event Filter that recorded in the log.
LogEventFunctionality.UnRegisterToLog(amt);
//Freeze the log. so, modifications in the log, are not allowed
LogEventFunctionality.FreezeLog(amt);
////Unfreeze the log. so, modifications in the log, are allowed
LogEventFunctionality.UnFreezeLog(amt);
//Delete all records from the log.
LogEventFunctionality.ClearLog(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/EventLogSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("EventLogSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("EventLogSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("c21e166e-42a8-4a39-b80f-db15769af506")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

95
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralEventsSample/GeneralEventsFunctionality.cs Normal file
View File

@ -0,0 +1,95 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability.Events;
using Intel.Manageability.Exceptions;
using Intel.Manageability;
namespace PETEventsSample
{
class GeneralEventsFunctionality
{
/// <summary>
/// Subscribe for events
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void Subscribe(IAMTInstance amt)
{
try
{
//Subscribe for Power_Supply_Failed event
GeneralSubscription subscription = new GeneralSubscription("http://192.168.0.1:16997", Events.Power_Supply.Power_Supply_Failed, SenderIDType.UUID);
amt.Events.Subscribe(subscription);
Console.WriteLine("\nSubscription operation completed successfully");
}
catch (EventsManageabilityException e)
{
PrintException("Subscribe", e);
}
try
{
//Subscribe for Battery_added event
GeneralSubscription subscription = new GeneralSubscription("http://192.168.0.1:16997", Events.Battery.Battery_Added, "MyAMT");
amt.Events.Subscribe(subscription);
Console.WriteLine("\nSubscription operation completed successfully");
}
catch (EventsManageabilityException e)
{
PrintException("Subscribe", e);
}
}
/// <summary>
/// UnSubscribe for Power_Supply_Failed event
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void UnSubscribe(IAMTInstance amt)
{
try
{
GeneralSubscription subscription = new GeneralSubscription("http://192.168.0.1:16997", Events.Power_Supply.Power_Supply_Failed, SenderIDType.UUID);
amt.Events.UnSubscribe(subscription);
Console.WriteLine("\nUnSubscribe operation completed successfully");
}
catch (EventsManageabilityException e)
{
PrintException("UnSubscribe", e);
}
}
/// <summary>
/// Unsubscribe all existing subscriptions
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void UnSubscribeAll(IAMTInstance amt)
{
try
{
amt.Events.UnSubscribeAll();
Console.WriteLine("\nUnSubscribe all subscribers completed successfully");
}
catch (EventsManageabilityException e)
{
PrintException("UnSubscribeAll", e);
}
}
static void PrintException(string methodName, EventsManageabilityException e)
{
Console.WriteLine(methodName + " throw: " + e.Message);
Console.WriteLine("Details:");
Console.WriteLine("========");
Console.WriteLine("\t- Machine Origin : {0}", e.MachineOrigin);
Console.WriteLine("\t- HLAPI Source Function: {0}", e.Source);
if (e.PT_STATUS != null)
Console.WriteLine("\t- Return Value : {0}", e.PT_STATUS);
if (e.Tip != string.Empty)
Console.WriteLine("\t- Counsel : {0}", e.Tip);
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralEventsSample/GeneralEventsSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

73
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralEventsSample/Program.cs Normal file
View File

@ -0,0 +1,73 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace PETEventsSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
//Subscribe for an event
GeneralEventsFunctionality.Subscribe(amt);
//UnSubscribe for specific event
GeneralEventsFunctionality.UnSubscribe(amt);
//Un subscribe all existing subscriptions.
GeneralEventsFunctionality.UnSubscribeAll(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralEventsSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("GeneralEventsSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("GeneralEventsSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("45b7bc9a-43d7-467a-b05e-755bfac0950d")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

27
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralListenerSample/GeneralListenerSample.csproj Normal file
View File

@ -0,0 +1,27 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
</Project>

69
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralListenerSample/Program.cs Normal file
View File

@ -0,0 +1,69 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using HLAPI.Services;
using System.Net;
using Intel.Manageability.Exceptions;
using System.Runtime.InteropServices;
namespace GeneralListenerSample
{
class Program
{
#region Members
static GeneralEventListener listener;
static readonly int PORT = 16997;
static object thisLock = new object();
#endregion
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main()
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
try
{
listener = new GeneralEventListener(IPAddress.Any, PORT);
listener.OnNewEventArrived += listener_OnNewEventArrived;
listener.StartListening();
Console.WriteLine("Start Listening on ports 162 and {0}, Press any key to exit...", PORT);
Console.ReadLine();
// Stop the listener
listener.StopListening();
}
catch (ManageabilityException e)
{
Console.WriteLine(e.Message);
}
}
static void listener_OnNewEventArrived(object sender, GeneralEventArgs eventArgs)
{
//In this case the lock operation is unnecessary because the console manages the threads by itself.
//But if this function will do complicated code with some data, might be collision between
//the threads (of WS listener and PET listener). Therefore, recommended to protect the code with
//using the lock operation.
lock (thisLock)
{
// Handle the event data...
Console.WriteLine("Address: " + eventArgs.Sender + " Message: " + eventArgs.MessageDescription);
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/GeneralListenerSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("GeneralListenerSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("GeneralListenerSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("08f817e8-e977-4dd2-999a-a096f0c28cc3")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

466
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/HLAPI Samples.sln Normal file
View File

@ -0,0 +1,466 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.31321.278
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5307635B-38B1-4031-B900-60FF826377C7}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemDefenseSample", "SystemDefenseSample\SystemDefenseSample.csproj", "{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AlarmClockSample", "AlarmClockSample\AlarmClockSample.csproj", "{B5A2F8B1-682B-4377-83C4-A70130A7E416}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KVMSample", "KVMSample\KVMSample.csproj", "{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RedirectionSample", "RedirectionSample\RedirectionSample.csproj", "{160413A0-04DE-4DF1-BBB3-14F28F0B8703}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BootControlSample", "BootControlSample\BootControlSample.csproj", "{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PowerSample", "PowerSample\PowerSample.csproj", "{9F242E29-0A55-4025-B927-AD97D4648066}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HardwareAssetSample", "HardwareAssetSample\HardwareAssetSample.csproj", "{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WSEventingSample", "WSEventingSample\WSEventingSample.csproj", "{6A996CF9-DA6C-4EA8-AE48-570122E43B14}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WSEventingListenerSample", "WSEventListenerSample\WSEventingListenerSample.csproj", "{C730CC09-4884-4959-AC5F-35FF3A3CC264}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TimeSynchronizationSample", "TimeSynchronizationSample\TimeSynchronizationSample.csproj", "{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgentPresenceRemoteSample", "AgentPresenceRemoteSample\AgentPresenceRemoteSample.csproj", "{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PETEventingListenerSample", "PETEventingListenerSample\PETEventingListenerSample.csproj", "{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ACLSample", "ACLSample\ACLSample.csproj", "{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeneralEventsSample", "GeneralEventsSample\GeneralEventsSample.csproj", "{CE41F306-D0C9-4CCB-A878-721B764E18D0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PETEventsSample", "PETEventsSample\PETEventsSample.csproj", "{22F392E8-2BE3-426B-827E-D34081355351}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgentPresenceLocalSample1", "AgentPresenceLocalSample1\AgentPresenceLocalSample1.csproj", "{2E7CD642-A365-4D3B-A690-B2381E0A4934}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AgentPresenceLocalSample2", "AgentPresenceLocalSample2\AgentPresenceLocalSample2.csproj", "{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EventLogSample", "EventLogSample\EventLogSample.csproj", "{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PowerPackagesSample", "PowerPackagesSample\PowerPackagesSample.csproj", "{20981D7D-BCD3-4617-A019-899BF8EF37A5}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeneralListenerSample", "GeneralListenerSample\GeneralListenerSample.csproj", "{5AA68B79-A12D-4D26-B3BD-1784DBB86350}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UserConsentSample1", "UserConsentSample1\UserConsentSample1.csproj", "{68F15B15-11AF-4D56-BE85-4281FB7E1592}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UserConsentSample2", "UserConsentSample2\UserConsentSample2.csproj", "{61288F1E-C8E0-438F-9D97-67FECA76A894}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AccessMonitorSample", "AccessMonitorSample\AccessMonitorSample.csproj", "{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NetworkAdminSample", "NetworkAdminSample\NetworkAdminSample.csproj", "{C93F1296-95D8-45CB-8646-67404F82747B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MultipleAlarmClocksSample", "MultipleAlarmClocksSample\MultipleAlarmClocksSample.csproj", "{78159136-8671-4DFE-A714-1EE1142E3F84}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CertificateManagementSample", "CertificateManagementSample\CertificateManagementSample.csproj", "{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RemoteAccessSample", "RemoteAccessSample\RemoteAccessSample.csproj", "{5A69177A-F159-448B-BD1E-312F51E00ED3}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WiFiConfigurationRemoteSample", "WiFiConfigurationRemoteSample\WiFiConfigurationRemoteSample.csproj", "{683F27EF-E89F-40E8-B291-855FD05523D2}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WiFiConfigurationLocalSample", "WiFiConfigurationLocalSample\WiFiConfigurationLocalSample.csproj", "{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebStorageSample", "WebStorageSample\WebStorageSample.csproj", "{BC14A2C1-148F-44FC-8604-40594E2BCF34}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RemotePlatformEraseSample", "RemotePlatformEraseSample\RemotePlatformEraseSample.csproj", "{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|Win32 = Debug|Win32
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU
Release|Mixed Platforms = Release|Mixed Platforms
Release|Win32 = Release|Win32
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Debug|Win32.ActiveCfg = Debug|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Debug|x86.ActiveCfg = Debug|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Release|Any CPU.Build.0 = Release|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Release|Win32.ActiveCfg = Release|Any CPU
{0C1E764A-5656-4379-A8F6-C3B5EE6FB176}.Release|x86.ActiveCfg = Release|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Debug|Win32.ActiveCfg = Debug|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Debug|x86.ActiveCfg = Debug|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Release|Any CPU.Build.0 = Release|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Release|Win32.ActiveCfg = Release|Any CPU
{B5A2F8B1-682B-4377-83C4-A70130A7E416}.Release|x86.ActiveCfg = Release|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Debug|Win32.ActiveCfg = Debug|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Debug|x86.ActiveCfg = Debug|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Release|Any CPU.Build.0 = Release|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Release|Win32.ActiveCfg = Release|Any CPU
{1D333EEF-E799-4332-BC30-7C0FA7F1CA02}.Release|x86.ActiveCfg = Release|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Debug|Any CPU.Build.0 = Debug|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Debug|Win32.ActiveCfg = Debug|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Debug|x86.ActiveCfg = Debug|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Release|Any CPU.ActiveCfg = Release|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Release|Any CPU.Build.0 = Release|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Release|Win32.ActiveCfg = Release|Any CPU
{160413A0-04DE-4DF1-BBB3-14F28F0B8703}.Release|x86.ActiveCfg = Release|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Debug|Any CPU.Build.0 = Debug|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Debug|Win32.ActiveCfg = Debug|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Debug|x86.ActiveCfg = Debug|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Release|Any CPU.ActiveCfg = Release|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Release|Any CPU.Build.0 = Release|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Release|Win32.ActiveCfg = Release|Any CPU
{DAB0CF9C-10F7-47E1-AFE2-8EA13BC23DB3}.Release|x86.ActiveCfg = Release|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Debug|Win32.ActiveCfg = Debug|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Debug|x86.ActiveCfg = Debug|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Release|Any CPU.Build.0 = Release|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Release|Win32.ActiveCfg = Release|Any CPU
{9F242E29-0A55-4025-B927-AD97D4648066}.Release|x86.ActiveCfg = Release|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Debug|Win32.ActiveCfg = Debug|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Debug|x86.ActiveCfg = Debug|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Release|Any CPU.Build.0 = Release|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Release|Win32.ActiveCfg = Release|Any CPU
{6AB28977-76B5-4FCC-9FEE-AF5F8A4E8AA7}.Release|x86.ActiveCfg = Release|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Debug|Win32.ActiveCfg = Debug|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Debug|x86.ActiveCfg = Debug|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Release|Any CPU.Build.0 = Release|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Release|Win32.ActiveCfg = Release|Any CPU
{6A996CF9-DA6C-4EA8-AE48-570122E43B14}.Release|x86.ActiveCfg = Release|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Debug|Win32.ActiveCfg = Debug|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Debug|x86.ActiveCfg = Debug|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Release|Any CPU.Build.0 = Release|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Release|Win32.ActiveCfg = Release|Any CPU
{C730CC09-4884-4959-AC5F-35FF3A3CC264}.Release|x86.ActiveCfg = Release|Any CPU
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Debug|Any CPU.ActiveCfg = Debug|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Debug|Mixed Platforms.Build.0 = Debug|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Debug|Win32.ActiveCfg = Debug|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Debug|x86.ActiveCfg = Debug|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Debug|x86.Build.0 = Debug|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Release|Any CPU.ActiveCfg = Release|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Release|Mixed Platforms.ActiveCfg = Release|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Release|Mixed Platforms.Build.0 = Release|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Release|Win32.ActiveCfg = Release|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Release|x86.ActiveCfg = Release|x86
{8ED614A1-E1F4-4431-910E-8E0165CB7CC5}.Release|x86.Build.0 = Release|x86
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Debug|Win32.ActiveCfg = Debug|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Debug|x86.ActiveCfg = Debug|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Release|Any CPU.Build.0 = Release|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Release|Win32.ActiveCfg = Release|Any CPU
{952D4353-6C0A-45BF-A5D7-EBDAC6858C6D}.Release|x86.ActiveCfg = Release|Any CPU
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Debug|Any CPU.ActiveCfg = Debug|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Debug|Mixed Platforms.Build.0 = Debug|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Debug|Win32.ActiveCfg = Debug|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Debug|x86.ActiveCfg = Debug|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Debug|x86.Build.0 = Debug|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Release|Any CPU.ActiveCfg = Release|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Release|Mixed Platforms.ActiveCfg = Release|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Release|Mixed Platforms.Build.0 = Release|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Release|Win32.ActiveCfg = Release|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Release|x86.ActiveCfg = Release|x86
{E5C0B6DE-2A4B-4F93-AAA3-DB1FEF4A3DAC}.Release|x86.Build.0 = Release|x86
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Debug|Any CPU.Build.0 = Debug|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Debug|Win32.ActiveCfg = Debug|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Debug|x86.ActiveCfg = Debug|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Release|Any CPU.ActiveCfg = Release|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Release|Any CPU.Build.0 = Release|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Release|Win32.ActiveCfg = Release|Any CPU
{284602D8-DB7E-4B38-B43B-B4A1FB3D2CB9}.Release|x86.ActiveCfg = Release|Any CPU
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Debug|Any CPU.ActiveCfg = Debug|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Debug|Mixed Platforms.Build.0 = Debug|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Debug|Win32.ActiveCfg = Debug|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Debug|x86.ActiveCfg = Debug|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Debug|x86.Build.0 = Debug|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Release|Any CPU.ActiveCfg = Release|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Release|Mixed Platforms.ActiveCfg = Release|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Release|Mixed Platforms.Build.0 = Release|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Release|Win32.ActiveCfg = Release|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Release|x86.ActiveCfg = Release|x86
{CE41F306-D0C9-4CCB-A878-721B764E18D0}.Release|x86.Build.0 = Release|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Debug|Any CPU.ActiveCfg = Debug|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Debug|Mixed Platforms.Build.0 = Debug|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Debug|Win32.ActiveCfg = Debug|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Debug|x86.ActiveCfg = Debug|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Debug|x86.Build.0 = Debug|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Release|Any CPU.ActiveCfg = Release|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Release|Mixed Platforms.ActiveCfg = Release|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Release|Mixed Platforms.Build.0 = Release|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Release|Win32.ActiveCfg = Release|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Release|x86.ActiveCfg = Release|x86
{22F392E8-2BE3-426B-827E-D34081355351}.Release|x86.Build.0 = Release|x86
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Debug|Any CPU.Build.0 = Debug|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Debug|Win32.ActiveCfg = Debug|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Debug|x86.ActiveCfg = Debug|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Release|Any CPU.Build.0 = Release|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Release|Win32.ActiveCfg = Release|Any CPU
{2E7CD642-A365-4D3B-A690-B2381E0A4934}.Release|x86.ActiveCfg = Release|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Debug|Any CPU.Build.0 = Debug|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Debug|Win32.ActiveCfg = Debug|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Debug|x86.ActiveCfg = Debug|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Release|Any CPU.ActiveCfg = Release|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Release|Any CPU.Build.0 = Release|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Release|Win32.ActiveCfg = Release|Any CPU
{61CF5B01-D56B-40D2-A705-0BCE72D34D7B}.Release|x86.ActiveCfg = Release|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Debug|Win32.ActiveCfg = Debug|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Debug|x86.ActiveCfg = Debug|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Release|Any CPU.Build.0 = Release|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Release|Win32.ActiveCfg = Release|Any CPU
{C8F28BD9-EA78-48E9-AC60-69A6A0A05F14}.Release|x86.ActiveCfg = Release|Any CPU
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Debug|Any CPU.ActiveCfg = Debug|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Debug|Mixed Platforms.Build.0 = Debug|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Debug|Win32.ActiveCfg = Debug|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Debug|x86.ActiveCfg = Debug|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Debug|x86.Build.0 = Debug|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Release|Any CPU.ActiveCfg = Release|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Release|Mixed Platforms.ActiveCfg = Release|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Release|Mixed Platforms.Build.0 = Release|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Release|Win32.ActiveCfg = Release|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Release|x86.ActiveCfg = Release|x86
{20981D7D-BCD3-4617-A019-899BF8EF37A5}.Release|x86.Build.0 = Release|x86
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Debug|Win32.ActiveCfg = Debug|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Debug|x86.ActiveCfg = Debug|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Release|Any CPU.ActiveCfg = Release|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Release|Any CPU.Build.0 = Release|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Release|Win32.ActiveCfg = Release|Any CPU
{5AA68B79-A12D-4D26-B3BD-1784DBB86350}.Release|x86.ActiveCfg = Release|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Debug|Any CPU.Build.0 = Debug|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Debug|Win32.ActiveCfg = Debug|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Debug|x86.ActiveCfg = Debug|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Release|Any CPU.ActiveCfg = Release|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Release|Any CPU.Build.0 = Release|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Release|Win32.ActiveCfg = Release|Any CPU
{68F15B15-11AF-4D56-BE85-4281FB7E1592}.Release|x86.ActiveCfg = Release|Any CPU
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Debug|Any CPU.ActiveCfg = Debug|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Debug|Mixed Platforms.Build.0 = Debug|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Debug|Win32.ActiveCfg = Debug|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Debug|x86.ActiveCfg = Debug|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Debug|x86.Build.0 = Debug|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Release|Any CPU.ActiveCfg = Release|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Release|Mixed Platforms.ActiveCfg = Release|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Release|Mixed Platforms.Build.0 = Release|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Release|Win32.ActiveCfg = Release|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Release|x86.ActiveCfg = Release|x86
{61288F1E-C8E0-438F-9D97-67FECA76A894}.Release|x86.Build.0 = Release|x86
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Debug|Win32.ActiveCfg = Debug|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Debug|x86.ActiveCfg = Debug|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Release|Any CPU.Build.0 = Release|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Release|Win32.ActiveCfg = Release|Any CPU
{0B18BFFF-46F6-47DC-85EA-4ABFBF9F2D25}.Release|x86.ActiveCfg = Release|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Debug|Win32.ActiveCfg = Debug|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Debug|x86.ActiveCfg = Debug|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Release|Any CPU.Build.0 = Release|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Release|Win32.ActiveCfg = Release|Any CPU
{C93F1296-95D8-45CB-8646-67404F82747B}.Release|x86.ActiveCfg = Release|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Debug|Any CPU.Build.0 = Debug|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Debug|Win32.ActiveCfg = Debug|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Debug|x86.ActiveCfg = Debug|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Release|Any CPU.ActiveCfg = Release|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Release|Any CPU.Build.0 = Release|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Release|Win32.ActiveCfg = Release|Any CPU
{78159136-8671-4DFE-A714-1EE1142E3F84}.Release|x86.ActiveCfg = Release|Any CPU
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Debug|Any CPU.ActiveCfg = Debug|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Debug|Mixed Platforms.Build.0 = Debug|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Debug|Win32.ActiveCfg = Debug|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Debug|x86.ActiveCfg = Debug|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Debug|x86.Build.0 = Debug|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Release|Any CPU.ActiveCfg = Release|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Release|Mixed Platforms.ActiveCfg = Release|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Release|Mixed Platforms.Build.0 = Release|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Release|Win32.ActiveCfg = Release|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Release|x86.ActiveCfg = Release|x86
{8E25C66B-8BE2-43D6-B8ED-A43E126CEBF8}.Release|x86.Build.0 = Release|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Debug|Any CPU.ActiveCfg = Debug|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Debug|Mixed Platforms.Build.0 = Debug|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Debug|Win32.ActiveCfg = Debug|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Debug|x86.ActiveCfg = Debug|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Debug|x86.Build.0 = Debug|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Release|Any CPU.ActiveCfg = Release|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Release|Mixed Platforms.ActiveCfg = Release|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Release|Mixed Platforms.Build.0 = Release|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Release|Win32.ActiveCfg = Release|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Release|x86.ActiveCfg = Release|x86
{5A69177A-F159-448B-BD1E-312F51E00ED3}.Release|x86.Build.0 = Release|x86
{683F27EF-E89F-40E8-B291-855FD05523D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Debug|Win32.ActiveCfg = Debug|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Debug|x86.ActiveCfg = Debug|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Release|Any CPU.Build.0 = Release|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Release|Win32.ActiveCfg = Release|Any CPU
{683F27EF-E89F-40E8-B291-855FD05523D2}.Release|x86.ActiveCfg = Release|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Debug|Any CPU.Build.0 = Debug|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Debug|Win32.ActiveCfg = Debug|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Debug|x86.ActiveCfg = Debug|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Release|Any CPU.ActiveCfg = Release|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Release|Any CPU.Build.0 = Release|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Release|Win32.ActiveCfg = Release|Any CPU
{A944C3D7-E5B9-4FF0-B4A6-FCE5EDF35311}.Release|x86.ActiveCfg = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|Any CPU.Build.0 = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|Win32.ActiveCfg = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|Win32.Build.0 = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|x86.ActiveCfg = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Debug|x86.Build.0 = Debug|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|Any CPU.ActiveCfg = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|Any CPU.Build.0 = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|Win32.ActiveCfg = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|Win32.Build.0 = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|x86.ActiveCfg = Release|Any CPU
{BC14A2C1-148F-44FC-8604-40594E2BCF34}.Release|x86.Build.0 = Release|Any CPU
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|Any CPU.ActiveCfg = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|Mixed Platforms.Build.0 = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|Win32.ActiveCfg = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|Win32.Build.0 = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|x86.ActiveCfg = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Debug|x86.Build.0 = Debug|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|Any CPU.ActiveCfg = Release|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|Mixed Platforms.ActiveCfg = Release|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|Mixed Platforms.Build.0 = Release|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|Win32.ActiveCfg = Release|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|Win32.Build.0 = Release|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|x86.ActiveCfg = Release|x86
{AD7355FA-6C34-42DD-9AA3-35AD47B18BFD}.Release|x86.Build.0 = Release|x86
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {BBEB03D4-C5E6-467E-96F2-7AEE651FBEBD}
EndGlobalSection
EndGlobal

649
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/HardwareAssetSample/HardwareAssetFunctionality.cs Normal file
View File

@ -0,0 +1,649 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2009-2013 All Rights Reserved.
//
// File: HardwareAssetFunctionality.cs
//
// Contents: High Level API command line sample: HardwareAsset Functionality
//
// Notes:
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.HardwareAssets;
using Intel.Manageability.Exceptions;
namespace HardwareAssetSample
{
public class HardwareAssetFunctionality
{
public static void PrintBIOSes_Info(IAMTInstance amt)
{
try
{
BIOSInfo[] bi = amt.HardwareAsset.BIOSesInfo;
Console.WriteLine("\nBIOSes Info\n~~~~~~~~~~~");
for (int i = 0; i < bi.Length; i++)
{
Console.WriteLine("--- BIOS Info #{0} ---", i + 1);
Console.WriteLine("\tVendor = {0}", bi[i].Vendor);
Console.WriteLine("\tVersion = {0}", bi[i].Version);
Console.WriteLine("\tReleaseDate = {0}", bi[i].ReleaseDate);
Console.WriteLine("\tBIOS_characteristics_not_supported = {0}", bi[i].BIOS_characteristics_not_supported);
Console.WriteLine("\tISA = {0}", bi[i].ISA);
Console.WriteLine("\tMCA = {0}", bi[i].MCA);
Console.WriteLine("\tEISA = {0}", bi[i].EISA);
Console.WriteLine("\tPCI = {0}", bi[i].PCI);
Console.WriteLine("\tPC_card = {0}", bi[i].PC_card);
Console.WriteLine("\tPnP = {0}", bi[i].PnP);
Console.WriteLine("\tAPM = {0}", bi[i].APM);
Console.WriteLine("\tBIOS_upgradeable = {0}", bi[i].BIOS_upgradeable);
Console.WriteLine("\tBIOS_shadowing_allowed = {0}", bi[i].BIOS_shadowing_allowed);
Console.WriteLine("\tVL_VESA = {0}", bi[i].VL_VESA);
Console.WriteLine("\tESCD = {0}", bi[i].ESCD);
Console.WriteLine("\tCD_Boot = {0}", bi[i].CD_Boot);
Console.WriteLine("\tSelectable_boot = {0}", bi[i].Selectable_boot);
Console.WriteLine("\tBIOS_ROM_socketed = {0}", bi[i].BIOS_ROM_socketed);
Console.WriteLine("\tBoot_from_PC_card = {0}", bi[i].Boot_from_PC_card);
Console.WriteLine("\tEDD_spec = {0}", bi[i].EDD_spec);
Console.WriteLine("\tNEC_PC_98 = {0}", bi[i].NEC_PC_98);
Console.WriteLine("\tPCMCIA = {0}", bi[i].PCMCIA);
Console.WriteLine("\tLS_120_Boot = {0}", bi[i].LS_120_Boot);
Console.WriteLine("\tACPI = {0}", bi[i].ACPI);
Console.WriteLine("\tI2O_Boot = {0}", bi[i].I2O_Boot);
Console.WriteLine("\tUSB_Legacy = {0}", bi[i].USB_Legacy);
Console.WriteLine("\tAGP = {0}", bi[i].AGP);
Console.WriteLine("\tIR = {0}", bi[i].IR);
Console.WriteLine("\tIEEE_1394 = {0}", bi[i].IEEE_1394);
Console.WriteLine("\tI2C = {0}", bi[i].I2C);
Console.WriteLine("\tSmart_Battery = {0}", bi[i].Smart_Battery);
Console.WriteLine("\tATAPI_ZIP_Drive_Boot = {0}", bi[i].ATAPI_ZIP_Drive_Boot);
Console.WriteLine("\tIEEE_1394_Boot = {0}", bi[i].IEEE_1394_Boot);
Console.WriteLine("\tEnable_Targeted_Content_Distribution = {0}", bi[i].Enable_Targeted_Content_Distribution);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintComputerSystem(IAMTInstance amt)
{
try
{
ComputerSystem cs = amt.HardwareAsset.ComputerSystem;
Console.WriteLine("\nComputer System \n~~~~~~~~~~~~~~~");
Console.WriteLine("\tManufacturer = {0}", cs.Manufacturer);
Console.WriteLine("\tProduct = {0}", cs.Product);
Console.WriteLine("\tVersion = {0}", cs.Version);
Console.WriteLine("\tSerialNumber = {0}", cs.SerialNumber);
Console.WriteLine("\tUUID = {0}", cs.UUID);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintBaseboards(IAMTInstance amt)
{
try
{
BaseBoard[] bb = amt.HardwareAsset.BaseBoards;
Console.WriteLine("\nBaseboards\n~~~~~~~~~~~");
for (int i = 0; i < bb.Length; i++)
{
Console.WriteLine("--- Baseboard #{0} ---", i + 1);
Console.WriteLine("\tManufacturer = {0}", bb[i].Manufacturer);
Console.WriteLine("\tProduct = {0}", bb[i].Product);
Console.WriteLine("\tVersion = {0}", bb[i].Version);
Console.WriteLine("\tSerialNumber = {0}", bb[i].SerialNumber);
Console.WriteLine("\tAssetTag = {0}", bb[i].AssetTag);
Console.WriteLine("\tReplaceable = {0}", bb[i].Replaceable);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintProcessors(IAMTInstance amt)
{
try
{
Processor[] CPUs = amt.HardwareAsset.CPUs;
Console.WriteLine("\nCPUs\n~~~~");
for (int i = 0; i < CPUs.Length; i++)
{
Console.WriteLine("--- CPU #{0} ---", i + 1);
Console.WriteLine("\tStatus = {0}", CPUs[i].Status);
Console.WriteLine("\tRole = {0}", CPUs[i].Role);
Console.WriteLine("\tFamily = {0}", CPUs[i].Family);
Console.WriteLine("\tUpgradeInformation = {0}", CPUs[i].UpgradeInformation);
Console.WriteLine("\tManufacturer = {0}", CPUs[i].Manufacturer);
Console.WriteLine("\tVersion = {0}", CPUs[i].Version);
Console.WriteLine("\tPhysicalPosition = {0}", CPUs[i].PhysicalPosition);
Console.WriteLine("\tMaxClockSpeed = {0}", CPUs[i].MaxClockSpeed);
Console.WriteLine("\tCurrentClockSpeed = {0}", CPUs[i].CurrentClockSpeed);
Console.WriteLine("\tStepping = {0}", CPUs[i].Stepping);
Console.WriteLine("\tExternalBusClockSpeed = {0}", CPUs[i].ExternalBusClockSpeed);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintMemoryModules(IAMTInstance amt)
{
try
{
MemoryModule[] MemoryModules = amt.HardwareAsset.MemoryModules;
Console.WriteLine("\nMemory Modules\n~~~~~~~~~~~~~~");
for (int i = 0; i < MemoryModules.Length; i++)
{
Console.WriteLine("--- Memory Module #{0} ---", i + 1);
Console.WriteLine("\tForm factor = {0}", MemoryModules[i].FormFactor);
Console.WriteLine("\tMemory type = {0}", MemoryModules[i].Type);
Console.WriteLine("\tSpeed = {0} nanoseconds", MemoryModules[i].Speed);
Console.WriteLine("\tManufacturer = {0}", MemoryModules[i].Manufacturer);
Console.WriteLine("\tSerialNumber = {0}", MemoryModules[i].SerialNumber);
Console.WriteLine("\tAssetTag = {0}", MemoryModules[i].AssetTag);
Console.WriteLine("\tPartNumber = {0}", MemoryModules[i].PartNumber);
Console.WriteLine("\tCapacity = {0} bytes", MemoryModules[i].Capacity);
Console.WriteLine("\tBankLabel = {0}", MemoryModules[i].BankLabel);
Console.WriteLine("\tConfiguredMemoryClockSpeed = {0}", MemoryModules[i].ConfiguredMemoryClockSpeed);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintFRUs(IAMTInstance amt)
{
try
{
FieldReplaceableUnit[] FRUs = amt.HardwareAsset.FRUs;
Console.WriteLine("\nFRUs\n~~~~");
if (FRUs == null || FRUs.Length == 0)
{
Console.WriteLine("--- No Field Replaceable Units Information Available ---\n");
return;
}
for (int i = 0; i < FRUs.Length; i++)
{
Console.WriteLine("--- Field Replaceable Unit #{0} ---", i + 1);
Console.WriteLine("\tProtocol Supported = {0}", FRUs[i].ProtocolSupported);
Console.WriteLine("\tVendorID = {0}", FRUs[i].VendorID);
Console.WriteLine("\tDeviceID = {0}", FRUs[i].DeviceID);
Console.WriteLine("\tRevisionID = {0}", FRUs[i].RevisionID);
Console.WriteLine("\tProgIf = {0}", FRUs[i].ProgIf);
Console.WriteLine("\tSubclass = {0}", FRUs[i].Subclass);
Console.WriteLine("\tClassCode = {0}", FRUs[i].ClassCode);
Console.WriteLine("\tSubvendorID = {0}", FRUs[i].SubvendorID);
Console.WriteLine("\tSubsystemID = {0}", FRUs[i].SubsystemID);
Console.WriteLine("\tDeviceLocation = {0}", FRUs[i].DeviceLocation);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintMediaDevices(IAMTInstance amt)
{
try
{
MediaDevice[] MediaDevices = amt.HardwareAsset.MediaDevices;
Console.WriteLine("\nMedia Devices\n~~~~~~~~~~~~~");
for (int i = 0; i < MediaDevices.Length; i++)
{
Console.WriteLine("--- Media Device #{0} ---", i + 1);
Console.WriteLine("\tMaxMediaSize = {0} bytes", MediaDevices[i].MaxMediaSize);
Console.WriteLine("\tSerialNumber = {0}", MediaDevices[i].SerialNumber);
Console.WriteLine("\tModelNumber = {0}", MediaDevices[i].ModelNumber);
Console.WriteLine("\tCapabilities:");
if (MediaDevices[i].Capabilities.Unknown)
Console.WriteLine("\t\tUnknown");
if (MediaDevices[i].Capabilities.Other)
Console.WriteLine("\t\tOther");
if (MediaDevices[i].Capabilities.Sequential_Access)
Console.WriteLine("\t\tSequential_Access");
if (MediaDevices[i].Capabilities.Random_Access)
Console.WriteLine("\t\tRandom_Access");
if (MediaDevices[i].Capabilities.Writable)
Console.WriteLine("\t\tWritable");
if (MediaDevices[i].Capabilities.Encryption)
Console.WriteLine("\t\tEncryption");
if (MediaDevices[i].Capabilities.Compression)
Console.WriteLine("\t\tCompression");
if (MediaDevices[i].Capabilities.Removable_Media)
Console.WriteLine("\t\tRemovable_Media");
if (MediaDevices[i].Capabilities.Manual_Cleaning)
Console.WriteLine("\t\tManual_Cleaning");
if (MediaDevices[i].Capabilities.Automatic_Cleaning)
Console.WriteLine("\t\tAutomatic_Cleaning");
if (MediaDevices[i].Capabilities.SMART_Notification)
Console.WriteLine("\t\tSMART_Notification");
if (MediaDevices[i].Capabilities.Dual_Sided_Media)
Console.WriteLine("\t\tDual_Sided_Media");
if (MediaDevices[i].Capabilities.Predismount_Eject_Not_Required)
Console.WriteLine("\t\tPredismount_Eject_Not_Required");
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintSensors(IAMTInstance amt)
{
try
{
Sensor[] Sensors = amt.HardwareAsset.Sensors;
Console.WriteLine("\nSensors\n~~~~~~~~");
for (int i = 0; i < Sensors.Length; i++)
{
Console.WriteLine("--- Sensor #{0} ---", i + 1);
Console.WriteLine("\tName = {0}", Sensors[i].Name);
Console.WriteLine("\tID = {0}", Sensors[i].ID);
Console.WriteLine("\tSensorType = {0}", Sensors[i].SensorType);
for (int j = 0; j < Sensors[i].PossibleStates.Length; j++)
{
Console.WriteLine("\tPossibleStates[{0}] = {1}", j, Sensors[i].PossibleStates[j]);
}
Console.WriteLine("\tCurrentState = {0}", Sensors[i].CurrentState);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintFans(IAMTInstance amt)
{
try
{
Fan[] fans = amt.HardwareAsset.Fans;
Console.WriteLine("\nFans\n~~~~");
for (int i = 0; i < fans.Length; i++)
{
if (fans[i] != null)
{
Console.WriteLine("--- Fan #{0} ---", i + 1);
if (!fans[i].DataValid)
{
Console.WriteLine("\tNo fan data avaliable");
return;
}
Console.WriteLine("\tDeviceID = {0}", fans[i].DeviceID);
Console.WriteLine("\tDesiredSpeed = {0} RPM", fans[i].DesiredSpeed);
if (fans[i].ActiveCooling)
Console.WriteLine("\tActiveCooling");
if (fans[i].VariableSpeed)
Console.WriteLine("\tVariableSpeed");
}
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintPowerSupplies(IAMTInstance amt)
{
try
{
PowerSupply[] ps = amt.HardwareAsset.PowerSupplies;
Console.WriteLine("\nPowerSupplies\n~~~~~~~~~~~~~");
for (int i = 0; i < ps.Length; i++)
{
Console.WriteLine("--- nPowerSupply #{0} ---", i + 1);
if (!ps[i].DataValid)
{
Console.WriteLine("\tNo power supply data avaliable");
return;
}
Console.WriteLine("\tDeviceID = {0}", ps[i].DeviceID);
Console.WriteLine("\tTotalOutputPower = {0} milliwatts", ps[i].TotalOutputPower);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintBatteriesEx(IAMTInstance amt)
{
try
{
PortableBatteryEx[] batteries = amt.HardwareAsset.BatteriesEx;
Console.WriteLine("\nBatteries\n~~~~~~~~~~~~~");
if (batteries != null)
{
for (int i = 0; i < batteries.Length; i++)
{
Console.WriteLine("--- Batteries #{0} ---", i + 1);
Console.WriteLine("\tStatus = {0}", batteries[i].Status.ToString());
Console.WriteLine("\tChemistry = {0}", batteries[i].Chemistry.ToString());
Console.WriteLine("\tManufacturer = {0}", batteries[i].Manufacturer);
Console.WriteLine("\tSerialNumber = {0}", batteries[i].SerialNumber);
Console.WriteLine("\tDesignVoltage = {0}", batteries[i].DesignVoltage);
Console.WriteLine("\tEstimatedChargeRemaining = {0}", batteries[i].EstimatedChargeRemaining);
Console.WriteLine("\tFullChargeCapacity = {0}", batteries[i].FullChargeCapacity);
}
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get battery information from the Intel AMT.");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintBatteries(IAMTInstance amt)
{
try
{
PortableBattery[] batteries = amt.HardwareAsset.Batteries;
Console.WriteLine("\nBatteries\n~~~~~~~~~~~~~");
if (batteries != null)
{
for (int i = 0; i < batteries.Length; i++)
{
Console.WriteLine("--- Batteries #{0} ---", i + 1);
Console.WriteLine("\tDeviceName = {0}", batteries[i].DeviceName);
Console.WriteLine("\tManufacturer = {0}", batteries[i].Manufacturer);
Console.WriteLine("\tManufactureDate = {0}", batteries[i].ManufactureDate);
Console.WriteLine("\tLocation = {0}", batteries[i].Location);
Console.WriteLine("\tSerialNumber = {0}", batteries[i].SerialNumber);
Console.WriteLine("\tSBDSVersionNumber = {0}", batteries[i].SBDSVersionNumber);
Console.WriteLine("\tSBDSSerialNumber = {0}", batteries[i].SBDSSerialNumber);
Console.WriteLine("\tSBDSDeviceChemistry = {0}", batteries[i].SBDSDeviceChemistry);
Console.WriteLine("\tOEMSpecific = {0}", batteries[i].OEMSpecific);
Console.WriteLine("\tMaximumErrorInBatteryData = {0}",
batteries[i].MaximumErrorInBatteryData);
Console.WriteLine("\tDeviceChemistryX = {0}", batteries[i].DeviceChemistryX);
Console.WriteLine("\tDesignVoltage = {0}", batteries[i].DesignVoltage);
Console.WriteLine("\tDesignCapacityMultiplier = {0}", batteries[i].DesignCapacityMultiplier);
Console.WriteLine("\tDesignCapacity = {0}", batteries[i].DesignCapacity);
}
}
else
{
Console.WriteLine("There is no Batteries data.");
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintVproVerificationTable(IAMTInstance amt)
{
try
{
VproVerificationTable VproTable = amt.HardwareAsset.VproTable;
Console.WriteLine("\nvPro Verification Table\n~~~~~~~~~~~~~~~~~~~~~~~");
if (!VproTable.TableValid)
{
Console.WriteLine("\tNo information available.");
return;
}
Console.WriteLine("\t--- CPU Capabilities ---");
Console.WriteLine("\t\tVMX_enabled = {0}", VproTable.Cpu.VMX_enabled);
Console.WriteLine("\t\tSMX_enabled = {0}", VproTable.Cpu.SMX_enabled);
Console.WriteLine("\t\tLT_TXT_available = {0}", VproTable.Cpu.LT_TXT_available);
Console.WriteLine("\t\tLT_TXT_enabled = {0}", VproTable.Cpu.LT_TXT_enabled);
Console.WriteLine("\t\tVTx_available = {0}", VproTable.Cpu.VTx_available);
Console.WriteLine("\t\tVTx_enabled = {0}", VproTable.Cpu.VTx_enabled);
Console.WriteLine("\t\tNumReserved = {0}", VproTable.Cpu.NumReserved);
Console.WriteLine("\t--- Chipset Capabilities ---");
Console.WriteLine("\t\tPCI_Device_Function_Number = {0}", VproTable.Chipset.PCI_Device_Function_Number);
Console.WriteLine("\t\tPCI_Device_Device_Number = {0}", VproTable.Chipset.PCI_Device_Device_Number);
Console.WriteLine("\t\tPCI_Device_Bus_Number = {0}", VproTable.Chipset.PCI_Device_Bus_Number);
Console.WriteLine("\t\tPCI_Device_ID_Number = {0}", VproTable.Chipset.PCI_Device_ID_Number);
Console.WriteLine("\t\tVTd_available = {0}", VproTable.Chipset.VTd_available);
Console.WriteLine("\t\tVTd_enabled = {0}", VproTable.Chipset.VTd_enabled);
Console.WriteLine("\t\tTXT_available = {0}", VproTable.Chipset.TXT_available);
Console.WriteLine("\t\tTXT_enabled = {0}", VproTable.Chipset.TXT_enabled);
Console.WriteLine("\t--- ICH Capabilities ---");
Console.WriteLine("\t\tPCI_Device_Function_Number = {0}", VproTable.Ich.PCI_Device_Function_Number);
Console.WriteLine("\t\tPCI_Device_Device_Number = {0}", VproTable.Ich.PCI_Device_Device_Number);
Console.WriteLine("\t\tPCI_Device_Bus_Number = {0}", VproTable.Ich.PCI_Device_Bus_Number);
Console.WriteLine("\t\tPCI_Device_ID_Number = {0}", VproTable.Ich.PCI_Device_ID_Number);
Console.WriteLine("\t--- ME Capabilities ---");
Console.WriteLine("\t\tMeEnabled = {0}", VproTable.Me.MeEnabled);
Console.WriteLine("\t\tQST_FW_supported = {0}", VproTable.Me.QST_FW_supported);
Console.WriteLine("\t\tASF_FW_supported = {0}", VproTable.Me.ASF_FW_supported);
Console.WriteLine("\t\tAMT_FW_supported = {0}", VproTable.Me.AMT_FW_supported);
Console.WriteLine("\t\tStandard_Manageability_supported = {0}", VproTable.Me.Standard_Manageability_supported);
Console.WriteLine("\t\tSmall_Buisness_supported = {0}", VproTable.Me.Small_Buisness_supported);
Console.WriteLine("\t\tManageability_Upgrade_supported = {0}", VproTable.Me.Manageability_Upgrade_supported);
Console.WriteLine("\t\tAT_supported = {0}", VproTable.Me.AT_supported);
Console.WriteLine("\t\tKVM_supported = {0}", VproTable.Me.KVM_supported);
Console.WriteLine("\t\tLocal_Wakeup_Timer_supported = {0}", VproTable.Me.Local_Wakeup_Timer_supported);
Console.WriteLine("\t\t--- Firmware Version ---");
Console.WriteLine("\t\t\tMajorVersion = {0}", VproTable.Me.FWVersion.MajorVersion);
Console.WriteLine("\t\t\tMinorVersion = {0}", VproTable.Me.FWVersion.MinorVersion);
Console.WriteLine("\t\t\tBuild = {0}", VproTable.Me.FWVersion.Build);
Console.WriteLine("\t\t\tHotfix = {0}", VproTable.Me.FWVersion.Hotfix);
Console.WriteLine("\t--- TPM Capabilities ---");
Console.WriteLine("\t\tTPM_on_board = {0}", VproTable.Tpm.TPM_on_board);
Console.WriteLine("\t\tTPM_enabled = {0}", VproTable.Tpm.TPM_enabled);
Console.WriteLine("\t\tTCG_Spec_Major_Version = {0}", VproTable.Tpm.TCG_Spec_Major_Version);
Console.WriteLine("\t\tTCG_Spec_Minor_Version = {0}", VproTable.Tpm.TCG_Spec_Minor_Version);
if (amt.MajorVersion >= 8)
{
Console.WriteLine("\t--- MEBX Version ---");
Console.WriteLine("\t\tMajorVersion = {0}", VproTable.MebxVersion.MajorVersion);
Console.WriteLine("\t\tMinorVersion = {0}", VproTable.MebxVersion.MinorVersion);
Console.WriteLine("\t\tBuild = {0}", VproTable.MebxVersion.Build);
Console.WriteLine("\t\tHotfix = {0}", VproTable.MebxVersion.Hotfix);
Console.WriteLine("\t--- Platform Configuration State ---");
Console.WriteLine("\t\tATConfigurationState = {0}", VproTable.ConfigurationState.AT);
}
Console.WriteLine("\t--- Network Devices ---");
Console.WriteLine("\t\tPCI_Device_Function_Number = {0}", VproTable.NetDevs.PCI_Device_Function_Number);
Console.WriteLine("\t\tPCI_Device_Device_Number = {0}", VproTable.NetDevs.PCI_Device_Device_Number);
Console.WriteLine("\t\tPCI_Device_Bus_Number = {0}", VproTable.NetDevs.PCI_Device_Bus_Number);
Console.WriteLine("\t\tPCI_Device_ID_Number = {0}", VproTable.NetDevs.PCI_Device_ID_Number);
Console.WriteLine("\t\tWiredNIC = {0}", VproTable.NetDevs.WiredNIC);
Console.WriteLine("\t\tWirelessNIC1 = {0}", VproTable.NetDevs.WirelessNIC1);
Console.WriteLine("\t\tWirelessNIC2 = {0}", VproTable.NetDevs.WirelessNIC2);
Console.WriteLine("\t--- BIOS Capabilities ---");
Console.WriteLine("\t\tCan_Setup_VTd = {0}", VproTable.Bios.Can_Setup_VTd);
Console.WriteLine("\t\tCan_Setup_VTx = {0}", VproTable.Bios.Can_Setup_VTx);
Console.WriteLine("\t\tCan_Setup_TXT = {0}", VproTable.Bios.Can_Setup_TXT);
Console.WriteLine("\t\tCan_Setup_TPM = {0}", VproTable.Bios.Can_Setup_TPM);
Console.WriteLine("\t\tCan_Setup_ME = {0}", VproTable.Bios.Can_Setup_ME);
Console.WriteLine("\t\tVA_Extensions = {0}", VproTable.Bios.VA_Extensions);
Console.WriteLine("\t\tSPI_Flash_Reserves_Platform_Data_Region = {0}",
VproTable.Bios.SPI_Flash_Reserves_Platform_Data_Region);
if (VproTable.Bios.VA_Version == VproVerificationTable.BiosCapabilities.VA_VersionEnum.Other)
{
Console.WriteLine("\t\tVA_Version = {0}, Raw_VA_Version = {1}",
VproTable.Bios.VA_Version, VproTable.Bios.Raw_VA_Version);
}
else
{
Console.WriteLine("\t\tVA_Version = {0}", VproTable.Bios.VA_Version);
}
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void PrintAmtInformation(IAMTInstance amt)
{
try
{
AmtInformation AmtInfo = amt.HardwareAsset.AmtInfo;
Console.WriteLine("\nAmtInfo\n~~~~~~~");
if (!AmtInfo.InformationValid)
{
Console.WriteLine("\tNo AmtInfo information available");
return;
}
if (AmtInfo.AmtSupported)
Console.WriteLine("\tAMT Supported");
else
Console.WriteLine("\tAMT Not Supported");
if (AmtInfo.AmtEnabled)
Console.WriteLine("\tAMT Enabled");
else
Console.WriteLine("\tAMT Disabled");
if (AmtInfo.IDEREnabled)
Console.WriteLine("\tIDER Enabled");
else
Console.WriteLine("\tIDER Disabled");
if (AmtInfo.SOLEnabled)
Console.WriteLine("\tSOL Enabled");
else
Console.WriteLine("\tSOL Disabled");
if (AmtInfo.NetworkEnabled)
Console.WriteLine("\tNetwork Enabled");
else
Console.WriteLine("\tNetwork Disabled");
Console.WriteLine("\tExtended Data = {0}", AmtInfo.ExtendedData);
// OEMCapabities:
if (AmtInfo.IDE_Redirection_available)
Console.WriteLine("\tIDE_Redirection_available");
if (AmtInfo.SOL_available)
Console.WriteLine("\tSOL_available");
if (AmtInfo.BIOS_Reflash_available)
Console.WriteLine("\tBIOS_Reflash_available");
if (AmtInfo.BIOS_Boot_Into_Setup_Screen_available)
Console.WriteLine("\tBIOS_Boot_Into_Setup_Screen_available");
if (AmtInfo.BIOS_Pause_Before_Booting_available)
Console.WriteLine("\tBIOS_Pause_Before_Booting_available");
if (AmtInfo.BIOS_Boot_From_Floppy_available)
Console.WriteLine("\tBIOS_Boot_From_Floppy_availalble");
if (AmtInfo.BIOS_Boot_From_CD_available)
Console.WriteLine("\tBIOS_Boot_From_CD_available");
if (AmtInfo.KVM_available)
Console.WriteLine("\tKVM_available");
if (AmtInfo.BIOS_Screen != AmtInformation.BIOS_ScreenEnum.Unsupported)
Console.WriteLine("\tBIOS Screen: {0}", AmtInfo.BIOS_Screen);
//OCR Capabilities
if (AmtInfo.TbtDock_enabled)
Console.WriteLine("\tThunderbolt_Dock_enabled");
if (AmtInfo.ForceUEFIHTTPSBoot_supported)
Console.WriteLine("\tForce_UEFI_HTTPS_Boot_supported");
if (AmtInfo.ForceUEFIPBABoot_supported)
Console.WriteLine("\tForce_UEFI_PBA_Boot_supported");
if (AmtInfo.ForceWinREBoot_supported)
Console.WriteLine("\tForce_UEFI_WinRE_Boot_supported");
if (AmtInfo.AMTSecureBootControl_supported)
Console.WriteLine("\tAMT_Secure_Boot_Control_supported");
if (AmtInfo.WifiProfileShare_supported)
Console.WriteLine("\tWifi_Profile_Share_supported");
if (AmtInfo.KVMEnabled)
Console.WriteLine("\tKVM Enabled");
else
Console.WriteLine("\tKVM Disabled");
//RPE Capabilities
if (AmtInfo.PyriteRevert_available)
Console.WriteLine("\tPyrite_Revert_available");
if (AmtInfo.SecureEraseAllSSDs_available)
Console.WriteLine("\tSecure_Erase_All_SSDs_available");
if (AmtInfo.TPMClear_available)
Console.WriteLine("\tTPM_Clear_available");
if (AmtInfo.OEMCustomAction_available)
Console.WriteLine("\tOEM_Custom_Action_available");
if (AmtInfo.ClearBIOSKVMVariables_available)
Console.WriteLine("\tClear_BIOS_KVM_Variables_available");
if (AmtInfo.BIOSReloadOfGoldenConfig_available)
Console.WriteLine("\tBIOS_Reload_Of_Golden_Config_available");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to get information from the Intel AMT");
Console.WriteLine("\n" + ex.Message);
}
}
public static void EnableUpdateMediaTable(IAMTInstance amt)
{
try
{
// Enable the update in all subsequent boots.
amt.HardwareAsset.SetUpdateMediaDeviceTableState(true, true);
Console.WriteLine("\nEnableUpdateMediaTable operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to enable table update");
Console.WriteLine("\n" + ex.Message);
}
}
public static void DisableUpdateMediaTable(IAMTInstance amt)
{
try
{
// Disable the update in all subsequent boots.
amt.HardwareAsset.SetUpdateMediaDeviceTableState(false, true);
Console.WriteLine("\nDisableUpdateMediaTable operation completed successfully");
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed to disable table update");
Console.WriteLine("\n" + ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/HardwareAssetSample/HardwareAssetSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

109
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/HardwareAssetSample/Program.cs Normal file
View File

@ -0,0 +1,109 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2010-2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace HardwareAssetSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// Set that the tables will be updated on the next boot.
HardwareAssetFunctionality.EnableUpdateMediaTable(amt);
// Print the BIOS info
HardwareAssetFunctionality.PrintBIOSes_Info(amt);
// Print the Baseboard info
HardwareAssetFunctionality.PrintBaseboards(amt);
// Print the Computer System info
HardwareAssetFunctionality.PrintComputerSystem(amt);
// Print the Fans info
HardwareAssetFunctionality.PrintFans(amt);
// Print the FRUs info
HardwareAssetFunctionality.PrintFRUs(amt);
// Print the Media Devices info
HardwareAssetFunctionality.PrintMediaDevices(amt);
// Print the Memory Modules info
HardwareAssetFunctionality.PrintMemoryModules(amt);
// Print the Power Supplies info
HardwareAssetFunctionality.PrintPowerSupplies(amt);
// Print the Processors info
HardwareAssetFunctionality.PrintProcessors(amt);
// Print the Sensors info
HardwareAssetFunctionality.PrintSensors(amt);
// Print the Batteries info (Supported from AMT 12.0 and later)
HardwareAssetFunctionality.PrintBatteriesEx(amt);
// Print the Vpro Verification Table
HardwareAssetFunctionality.PrintVproVerificationTable(amt);
// Print the Amt Information
HardwareAssetFunctionality.PrintAmtInformation(amt);
// Disable table update.
HardwareAssetFunctionality.DisableUpdateMediaTable(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/HardwareAssetSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("HardwareAssetSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("HardwareSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("0c038cba-46e7-477c-88ec-c0630a5f7844")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

192
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/KVMSample/KVMFunctionality.cs Normal file
View File

@ -0,0 +1,192 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2009-2014 All Rights Reserved.
//
// File: KVMFunctionality.cs
//
// Contents: Demonstrate the IKVM interface.
//
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using Intel.Manageability;
using Intel.Manageability.KVM;
using Intel.Manageability.Exceptions;
using System.Security;
namespace KVMSample
{
public class KVMFunctionality
{
/// <summary>
/// Get KVM capabilities
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void DisplayCapabilities(IAMTInstance amt)
{
try
{
KVMCapabilities capabilities = amt.KVMSetup.GetCapabilities();
Console.WriteLine("KVM Capabilities:\n=================\n");
Console.WriteLine("Default port (5900): {0}", (capabilities.IsDefaultPortEnable) ? "enable" : "disable");
Console.WriteLine("Redirection port: {0}", (capabilities.IsRedirectionPortEnable) ? "enable" : "disable");
Console.WriteLine("Opt-In policy: {0}", (capabilities.OptInPolicyEnable) ? "enable" : "disable");
Console.WriteLine("Opt-In policy timeout: {0}", capabilities.OptInPolicyTimeout);
Console.WriteLine("TCP Session timeout: {0}", capabilities.TcpSessionTimeout);
Console.WriteLine("Default visible screen: {0}", capabilities.VisibleScreen);
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed to get KVM Capabilities with status: " + ex.Message);
}
}
/// <summary>
/// Set the state of the KVM ports
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
/// <param name="ports">The ports to set. Default port is no longer supported. See remarks.</param>
/// <remarks>
/// NOTE:KVM Default port (5900) is no longer supported, starting from the following releases.
/// KabyLake: 11.8.94
/// CannonLake: 12.0.93
/// CometLake: 14.1.70
/// TigerLake: 15.0.45
/// AlderLake, RaptorLake: 16.1.25
/// Attempting to configure a RFB password or enabling the port via IPS_KVMRedirectionSettingData.PUT
/// will return unsupported message.
/// </remarks>
public static void SetPortsState(IAMTInstance amt, KVMPortsState ports)
{
try
{
Console.Write("Setting port state...\t");
amt.KVMSetup.SetPortsState(ports);
Console.WriteLine("Success");
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
}
/// <summary>
/// Set the default monitor
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void SetDefaultMonitor(IAMTInstance amt)
{
try
{
Console.Write("Setting default monitor...\t");
List<VisibleScreen> screens = amt.KVMSetup.GetAvailableMonitors();
if (screens.Contains(VisibleScreen.Monitor0))
amt.KVMSetup.SetDefaultMonitor(VisibleScreen.Monitor0);
Console.WriteLine("Success");
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
}
/// <summary>
/// Set the RFB password
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
/// <param name="password">The new RFB password</param>
/// <remarks>
/// NOTE: KVM Default port (5900) and configuring an RFB password are no longer supported, starting from the following releases.
/// KabyLake: 11.8.94
/// CannonLake: 12.0.93
/// CometLake: 14.1.70
/// TigerLake: 15.0.45
/// AlderLake, RaptorLake: 16.1.25
/// Attempting to configure a RFB password or enabling the port via IPS_KVMRedirectionSettingData.PUT
/// will return unsupported message.
/// </remarks>
public static void SetNewRFBPass(IAMTInstance amt, SecureString password)
{
try
{
Console.Write("Setting RFB Password...\t");
amt.KVMSetup.SetRFBPassword(password);
Console.WriteLine("Success");
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
catch (ManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
}
/// <summary>
/// Set the opt-in timeout
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
/// <param name="timeout">The timeout to set</param>
public static void SetOptInTimeout(IAMTInstance amt, ushort timeout)
{
try
{
Console.Write("Setting Opt-In timeout...\t");
amt.KVMSetup.SetOptInTimeout(timeout);
Console.WriteLine("Success");
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
}
/// <summary>
/// Set the TCP session timeout
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
/// <param name="timeout">The timeout to set</param>
public static void SetTCPSessionTimeout(IAMTInstance amt, ushort timeout)
{
try
{
Console.Write("Setting TCP session timeout...\t");
amt.KVMSetup.SetSessionTimeout(timeout);
Console.WriteLine("Success");
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
}
/// <summary>
/// Enable the KVM interface
/// </summary>
/// <param name="amt">The Intel AMT instance</param>
public static void EnableKVMInterface(IAMTInstance amt)
{
try
{
Console.Write("Enable KVM interface...\t");
if (amt.KVMSetup.GetInterfaceState())
Console.WriteLine("\nKVM Interface is already enable.");
else
{
amt.KVMSetup.SetInterfaceState(true);
Console.WriteLine("Success");
}
}
catch (KVMManageabilityException ex)
{
Console.WriteLine("Failed with status: " + ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/KVMSample/KVMSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

91
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/KVMSample/Program.cs Normal file
View File

@ -0,0 +1,91 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2010-2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Intel.Manageability.KVM;
using Common.Utils;
using System.IO;
using System.Security;
namespace KVMSample
{
class Program
{
static void Main(string[] args)
{
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
SecureString rfbPass = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// Enable KVM interface
KVMFunctionality.EnableKVMInterface(amt);
// Set the RFB password
Console.WriteLine("Setting new RFB Password \n");
rfbPass = ProgramInput.PasswordPrompt("new RFB");
try
{
KVMFunctionality.SetNewRFBPass(amt, rfbPass);
}
catch
{
rfbPass?.Dispose();
throw;
}
// Set the opt-in timeout
KVMFunctionality.SetOptInTimeout(amt, 1000);
// Set the KVM ports state
KVMFunctionality.SetPortsState(amt, KVMPortsState.EnableAllPorts);
// Set the TCP session timeout
KVMFunctionality.SetTCPSessionTimeout(amt, 100);
// Set the default monitor
KVMFunctionality.SetDefaultMonitor(amt);
// Get KVM capabilities
KVMFunctionality.DisplayCapabilities(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
rfbPass?.Dispose();
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/KVMSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("KVMSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("KVMSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("d49da73d-5506-48ae-af43-7d48663ab903")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

169
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/MultipleAlarmClocksSample/AlarmClockFunctionality.cs Normal file
View File

@ -0,0 +1,169 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using Intel.Manageability;
using Intel.Manageability.AlarmClock;
using Intel.Manageability.Exceptions;
namespace MultipleAlarmClocksSample
{
public class AlarmClockFunctionality
{
public static void CreateOrUpdateAlarms(IAMTInstance amt)
{
// Create basic alarm, this alarm will be initialized on all Intel AMT generations that support alarm clock.
DefaultAlarm defaultAlarm = new DefaultAlarm(new DateTime(2013, 1, 1), TimeZoneInfo.Local, new TimeSpan(1,12,0,0));
// Create improved alarm, this alarm will be initialized only for Intel AMT Release 8.0 later releases.
OptionalAlarm optionalAlarm1 = new OptionalAlarm("OptionalAlarm1", new DateTime(2013, 1, 1), TimeZoneInfo.Local, new TimeSpan(0, 12, 0));
OptionalAlarm optionalAlarm2 = new OptionalAlarm("OptionalAlarm2", new DateTime(2013, 2, 2), TimeZoneInfo.Local, DeleteOptions.AutoDeleteOnCompletion);
List<OptionalAlarm> alarms = new List<OptionalAlarm>();
alarms.Add(optionalAlarm1);
alarms.Add(optionalAlarm2);
AlarmClockList alarmClockList = new AlarmClockList(defaultAlarm, alarms);
try
{
amt.AlarmClock.CreateOrUpdateAlarms(alarmClockList);
Console.WriteLine("Create alarms successfully");
}
catch (AlarmClockManageabilityException e)
{
PrintException("CreateOrUpdateAlarms", e);
}
}
public static void SetAMTNetworkTime(IAMTInstance amt)
{
try
{
// Set Intel AMT network time to UTC.
amt.TimeSynchronization.SetUtcNetworkTime();
Console.WriteLine("Set Intel AMT network time successfully");
}
catch (ManageabilityException e)
{
Console.WriteLine(e.Message);
}
}
public static void DeleteOptionalAlarm(IAMTInstance amt)
{
try
{
amt.AlarmClock.DeleteOptionalAlarm("OptionalAlarm1");
Console.WriteLine("Delete Optional Alarm successfully");
}
catch (AlarmClockManageabilityException e)
{
PrintException("DeleteOptionalAlarm", e);
}
}
public static void DeleteDefaultAlarm(IAMTInstance amt)
{
try
{
amt.AlarmClock.DeleteDefaultAlarm();
Console.WriteLine("Delete Default Alarm successfully");
}
catch (AlarmClockManageabilityException e)
{
PrintException("DeleteDefaultAlarm", e);
}
}
public static void DisplayAllAlarms(IAMTInstance amt)
{
AlarmClockList allAmtAlarms;
try
{
// Get all alarms.
allAmtAlarms = amt.AlarmClock.GetAllAlarmsSettings();
Console.WriteLine();
if (allAmtAlarms.DefaultAlarm.HasValue)
{
Console.WriteLine("Default Alarm Details:");
Console.WriteLine("======================");
PrintDefaultAlarm(allAmtAlarms.DefaultAlarm.Value);
}
Console.WriteLine("Optional Alarms Details:");
Console.WriteLine("========================");
allAmtAlarms.OptionalAlarms.ForEach(PrintOptionalAlarm);
}
catch (AlarmClockManageabilityException e)
{
PrintException("DisplayAllAlarms", e);
return;
}
}
public static void DeleteAllAlarms(IAMTInstance amt)
{
try
{
// Delete all alarms.
amt.AlarmClock.DeleteAllAlarms();
Console.WriteLine("Delete all Alarms successfully");
}
catch (AlarmClockManageabilityException e)
{
PrintException("DeleteAllAlarms", e);
}
}
static void PrintException(string methodName, AlarmClockManageabilityException e)
{
Console.WriteLine(methodName + " throw: " + e.Message);
Console.WriteLine("Details:");
Console.WriteLine("========");
Console.WriteLine("\t- Machine Origin : {0}", e.MachineOrigin);
Console.WriteLine("\t- HLAPI Source Function: {0}", e.Source);
if (e.PT_STATUS != null)
Console.WriteLine("\t- Return Value : {0}", e.PT_STATUS);
if (e.Tip != string.Empty)
Console.WriteLine("\t- Counsel : {0}", e.Tip);
}
static void PrintOptionalAlarm(OptionalAlarm alarmClock)
{
string alarmOption = string.Empty;
switch (alarmClock.DeleteOption)
{
case DeleteOptions.AutoDeleteOnCompletion:
alarmOption = "AutoDeleteOnCompletion";
break;
case DeleteOptions.ManualDelete:
alarmOption = "ManualDelete";
break;
}
Console.WriteLine("\t* Name : {0}" ,alarmClock.AlarmName);
Console.WriteLine("\t StartTime : {0}", alarmClock.StartTime);
Console.WriteLine("\t Interval : {0}", alarmClock.Interval);
Console.WriteLine("\t Alarm Option: {0}", alarmOption);
Console.WriteLine();
}
static void PrintDefaultAlarm(DefaultAlarm alarmClock)
{
Console.WriteLine("\t StartTime : {0}", alarmClock.StartTime);
Console.WriteLine("\t Interval : {0}", alarmClock.Interval);
Console.WriteLine();
}
}
}

32
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/MultipleAlarmClocksSample/MultipleAlarmClocksSample.csproj Normal file
View File

@ -0,0 +1,32 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Update="System.Xml.Linq">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
<PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

85
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/MultipleAlarmClocksSample/Program.cs Normal file
View File

@ -0,0 +1,85 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using HLAPI;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using MultipleAlarmClocksSample;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace AlarmClockEnhancementSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
// In order to set the alarms the Intel AMT network time must be in UTC format.
AlarmClockFunctionality.SetAMTNetworkTime(amt);
// Create list of alarms.
AlarmClockFunctionality.CreateOrUpdateAlarms(amt);
// Display all alarm settings.
AlarmClockFunctionality.DisplayAllAlarms(amt);
// Delete one OptionalAlarm.
AlarmClockFunctionality.DeleteOptionalAlarm(amt);
// Delete DefaultAlarm.
AlarmClockFunctionality.DeleteDefaultAlarm(amt);
// Delete all alarm settings.
AlarmClockFunctionality.DeleteAllAlarms(amt);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/MultipleAlarmClocksSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("MultipleAlarmClocksSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel")]
[assembly: AssemblyProduct("MultipleAlarmClocksSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("635b82d2-5ba8-409c-9c3b-2f68efd45cfb")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

145
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/NetworkAdminSample/NetworkAdminFunctionality.cs Normal file
View File

@ -0,0 +1,145 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Intel.Manageability.NetworkAdmin;
namespace NetworkAdmin
{
public class NetworkAdminFunctionality
{
public static void DisplayIPv6Settings(IAMTInstance amt, NetworkInterface networkInterface)
{
try
{
switch (networkInterface)
{
case NetworkInterface.Wired:
{
WiredIPv6Settings wiredIPv6Setting = amt.Config.NetworkAdmin.GetWiredIPv6Setting();
bool enabled = amt.Config.NetworkAdmin.GetIPv6State(networkInterface);
Console.WriteLine("Wired IPv6 settings:\n=================\n");
Console.WriteLine("State: {0}", (enabled) ? "enable" : "disable");
if (enabled)
{
Console.WriteLine("Current address:");
foreach (AddressInfo addressInfo in wiredIPv6Setting.CurrentAddressInfo)
{
Console.WriteLine("\tIP: {0} \tType:{1} \tState:{2}", addressInfo.IPAddress,
addressInfo.IPv6Type, addressInfo.IPv6State);
}
}
break;
}
case NetworkInterface.Wireless:
{
WirelessIPv6Settings wirelessIPv6Setting = amt.Config.NetworkAdmin.GetWirelessIPv6Setting();
bool enabled = amt.Config.NetworkAdmin.GetIPv6State(networkInterface);
Console.WriteLine("Wireless IPv6 settings:\n=================\n");
Console.WriteLine("State: {0}", (enabled) ? "enable" : "disable");
if (enabled)
{
Console.WriteLine("Current address:");
foreach (AddressInfo addressInfo in wirelessIPv6Setting.CurrentAddressInfo)
{
Console.WriteLine("\tIP: {0} \tType:{1} \tState:{2}", addressInfo.IPAddress,
addressInfo.IPv6Type, addressInfo.IPv6State);
}
}
break;
}
}
}
catch (NetworkAdminManageabilityException ex)
{
Console.WriteLine("Display IPv6 settings for the " + networkInterface.ToString().ToLower() + " failed");
Console.WriteLine(ex.Message);
}
}
public static void DisplayInterfaceSettings(IAMTInstance amt, NetworkInterface networkInterface)
{
try
{
NetworkInterfaceSettings InterfaceSettings =
amt.Config.NetworkAdmin.GetNetworkInterfaceSettings(networkInterface);
Console.WriteLine(networkInterface.ToString().ToLower() + " interface settings:\n=================\n");
Console.WriteLine("MAC address: {0}", InterfaceSettings.MACAddress);
Console.WriteLine("Link is up: {0}", InterfaceSettings.LinkIsUp ? "true" : "false");
Console.WriteLine("Link policies:");
foreach (LinkPolicy policy in InterfaceSettings.LinkPolicy)
{
Console.WriteLine("\t\t{0}", policy.ToString().ToLower());
}
}
catch (NotSupportedException e)
{
Console.WriteLine("Display the settings for the " + networkInterface.ToString().ToLower() +
" interface failed");
Console.WriteLine(e.Message);
}
catch (NetworkAdminManageabilityException ex)
{
Console.WriteLine("Display the settings for the " + networkInterface.ToString().ToLower() +
" interface failed");
Console.WriteLine(ex.Message);
}
}
public static void SetStaticIPv4(ref IAMTInstance amt, ConnectionInfoEX ci,
string newIp = "192.168.168.5")
{
try
{
IPv4Settings ipv4Settings = new IPv4Settings(newIp, "255.255.255.0");
amt.Config.NetworkAdmin.SetIPv4Mode(ipv4Settings, true);
// After setting the IP to new IP. need to create new AMTInstance with the new IP.
amt.Dispose();
ci.Host = newIp;
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (NetworkAdminManageabilityException ex)
{
Console.WriteLine("Set the static IP failed");
Console.WriteLine(ex.Message);
amt = null;
}
catch (ManageabilityException ex)
{
Console.WriteLine(ex.Message);
amt = null;
}
}
public static void DisplayIPv4Settings(IAMTInstance amt)
{
try
{
IPv4Settings ipv4Settings = amt.Config.NetworkAdmin.GetIPv4Settings();
Console.WriteLine("IPv4 settings:\n=================\n");
Console.WriteLine("IP: {0}", ipv4Settings.IPAddress);
Console.WriteLine("Default gateway: {0}", ipv4Settings.DefaultGateway);
Console.WriteLine("Subnet mask: {0}", ipv4Settings.SubnetMask);
Console.WriteLine("Primary DNS: {0}", ipv4Settings.PrimaryDNS);
Console.WriteLine("Secondary DNS: {0}", ipv4Settings.SecondaryDNS);
}
catch (NetworkAdminManageabilityException ex)
{
Console.WriteLine("Display the IPv4 settings failed");
Console.WriteLine(ex.Message);
}
}
}
}

28
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/NetworkAdminSample/NetworkAdminSample.csproj Normal file
View File

@ -0,0 +1,28 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
</Project>

78
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/NetworkAdminSample/Program.cs Normal file
View File

@ -0,0 +1,78 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using Intel.Manageability;
using Intel.Manageability.Exceptions;
using Intel.Manageability.NetworkAdmin;
using Common.Utils;
using System.IO;
using System.Runtime.InteropServices;
namespace NetworkAdmin
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main(string[] args)
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
IAMTInstance amt = null;
ConnectionInfoEX ci = null;
try
{
// Check if JSON path was provided as an argument. If not, default path would be used.
try
{
ci = ProgramInput.DeserializeJsonToStruct(args.Length > 0 ? args[0] : null);
}
catch (IOException e)
{
Console.WriteLine($"Could not read argument file: {e.Message}");
return;
}
amt = AMTInstanceFactory.CreateEX(ci);
}
catch (ManageabilityException e)
{
ci?.Dispose();
Console.WriteLine(e.Message);
return;
}
try
{
//Display the settings for the desired interface.
NetworkAdminFunctionality.DisplayInterfaceSettings(amt, NetworkInterface.Wired);
//Set the IPv4 state to static.
NetworkAdminFunctionality.SetStaticIPv4(ref amt, ci);
if (amt == null)
return;
//Display the IPv4 settings.
NetworkAdminFunctionality.DisplayIPv4Settings(amt);
//Display the IPv6settings.
NetworkAdminFunctionality.DisplayIPv6Settings(amt, NetworkInterface.Wired);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
amt?.Dispose();
}
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/NetworkAdminSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("PowerSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("PowerSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("33e6f2d9-9a3b-494b-beb7-3354ed19dcec")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

27
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/PETEventingListenerSample/PETEventingListenerSample.csproj Normal file
View File

@ -0,0 +1,27 @@
<?xml version='1.0' encoding='utf-8'?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net48</TargetFramework>
<OutputType>Exe</OutputType>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
<PlatformTarget>AnyCPU</PlatformTarget>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Label="Kit">
<Kit>$([System.Convert]::ToBoolean(true))</Kit>
<Bin />
<Bin Condition="Exists('..\..\..\Bin')">..\..\..\Bin</Bin>
</PropertyGroup>
<ItemGroup Condition="$(Kit)" Label="Kit References">
<Reference Include="HLAPI">
<HintPath>$(Bin)\HLAPI.dll</HintPath>
</Reference>
<Compile Include="..\..\Common\ProgramInput.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Newtonsoft.Json" Version="13.*" />
</ItemGroup>
</Project>

43
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/PETEventingListenerSample/Program.cs Normal file
View File

@ -0,0 +1,43 @@
//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//----------------------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
using HLAPI.Services;
namespace PETEventingListenerSample
{
class Program
{
[DllImport("kernel32.dll", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDefaultDllDirectories(int directoryFlags);
static void Main()
{
// set default dll lookup directory to system
SetDefaultDllDirectories(0x00000800); //LOAD_LIBRARY_SEARCH_SYSTEM32
Console.WriteLine("Start Listening on port 162, Press any key to exit...");
using (PETEventListener listener = new PETEventListener())
{
listener.OnNewEventArrived += new EventHandler<PETEventArgs>(listener_OnNewEventArrived);
listener.StartListening();
Console.ReadLine();
// Stop the listener
listener.StopListening();
}
}
static void listener_OnNewEventArrived(object sender, PETEventArgs e)
{
// Handle the event data...
Console.WriteLine("Address: " + e.Sender + " Message: " + e.MessageDescription);
}
}
}

36
amt-sdk-20-0-0-1/HLAPI_Module/Src/HLAPI_Samples/PETEventingListenerSample/Properties/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("PETEventingListenerSample")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Intel Corporation")]
[assembly: AssemblyProduct("PETEventingListenerSample")]
[assembly: AssemblyCopyright("Copyright © 2020 Intel Corporation")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("fa2d8160-a7f1-41e7-ba6e-f0e5d6d7ae08")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

Some files were not shown because too many files have changed in this diff Show More