int MaterialMonitorSim::GetInPlaceStatus(int *pStatus)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
if (pStatus == NULL)
{
returnValue = FCB_NULL_PARAM;
LOG_EXT(LEVEL_ERROR, "Status pointer is null (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (!m_bInitialized)
{
returnValue = HW_NOT_INITIALIZED;
LOG_EXT(LEVEL_ERROR, "Hardware not initialized (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Getting in-place status:");
if (m_behavior == NULL)
{
*pStatus = (1 << m_ucCartridgesCount) - 1;
}
else
{
*pStatus = m_behavior->Status;
}
LOG_EXT(LEVEL_INFO, "Status: 0x" << setfill('0') << setw(8) << hex << *pStatus << ".");
return returnValue;
}
int MaterialMonitor::GetInPlaceStatus(int *pStatus)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
if (pStatus == NULL)
{
returnValue = FCB_NULL_PARAM;
LOG_EXT(LEVEL_ERROR, "Status pointer is null (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (!m_bInitialized)
{
returnValue = HW_NOT_INITIALIZED;
LOG_EXT(LEVEL_ERROR, "Hardware not initialized (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_DEBUG, "Getting in-place status:");
returnValue = m_tagAdapter->GetInPlaceStatus(pStatus);
if (returnValue == IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_DEBUG, "Status: " "0x" << setfill('0') << setw(4) << hex << *pStatus << ".");
}
else
{
LOG_EXT(LEVEL_ERROR, "Error Getting in-place status (error code 0x" << hex << (short)returnValue << ").");
}
return returnValue;
}
int MaterialMonitorSim::ResetCartridgeInfo(unsigned char ucCartridgeNum)
{
if (ucCartridgeNum >= m_ucCartridgesCount)
{
LOG_EXT(LEVEL_ERROR, "Cannot select cartridge #" << (unsigned short)ucCartridgeNum << ": cartridges count is " << (unsigned short)m_ucCartridgesCount << ".");
return FCB_SELECT_CHANNEL_FAILED;
}
m_authenticated &= ~(1 << ucCartridgeNum);
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " was removed successfully.");
return IDTLIB_SUCCESS;
}
int mods_init_tegradc(void)
{
#if defined(CONFIG_TEGRA_NVSD)
int i;
int ret = 0;
LOG_ENT();
for (i = 0; i < TEGRA_MAX_DC; i++) {
struct tegra_dc *dc = tegra_dc_get_dc(i);
if (!dc)
continue;
tegra_dc_saved_sd_settings[i] = dc->out->sd_settings;
dc->out->sd_settings = &mods_sd_settings[i];
if (dc->enabled)
nvsd_init(dc, dc->out->sd_settings);
if (!tegra_dc_saved_sd_settings[i])
ret = nvsd_create_sysfs(&dc->ndev->dev);
}
LOG_EXT();
return ret;
#else
return 0;
#endif
}
/******************************
* INIT/EXIT MODULE FUNCTIONS *
******************************/
static int __init mods_init_module(void)
{
int rc;
LOG_ENT();
/* Initilize memory tracker */
mods_init_mem();
rc = misc_register(&mods_dev);
if (rc < 0)
return -EBUSY;
mods_init_irq();
#ifdef CONFIG_ARCH_TEGRA
mods_init_clock_api();
#endif
mods_info_printk("driver loaded, version %x.%02x\n",
(MODS_DRIVER_VERSION>>8),
(MODS_DRIVER_VERSION&0xFF));
LOG_EXT();
return OK;
}
int MaterialMonitorSim::InitHW(char* pcHsmTarget, unsigned short pcHsmTargetLength, unsigned char *pucCartridgesCount)
{
int returnValue = BaseMaterialMonitor::InitHW(useHsmSimulator, pucCartridgesCount);
if (returnValue != IDTLIB_SUCCESS)
{
return returnValue;
}
UniqueLock uniqueLock(m_mtx);
m_bInitialized = false;
if (m_behavior == NULL)
{
m_ucCartridgesCount = MAX_CARTRIDGES_COUNT;
}
else
{
m_ucCartridgesCount = m_behavior->CartridgesCount;
}
*pucCartridgesCount = m_ucCartridgesCount;
m_bInitialized = true;
LOG_EXT(LEVEL_INFO, "HW initialized successfully. Number of cartridges: " << (unsigned short)(*pucCartridgesCount) << ".");
return IDTLIB_SUCCESS;
}
static void app_log_storage_log(unsigned int how) {
battery_estimate_data* be = &(storage.battery_estimate);
LOG_EXT(how, "storage.selectedVersion: %s", storage.selectedVersion);
LOG_EXT(how, "storage.battery_estimate.previous_state_timestamp: %ld", be->previous_state_timestamp);
LOG_EXT(how, "storage.battery_estimate.previous_state.charge_percent: %d", be->previous_state.charge_percent);
LOG_EXT(how, "storage.battery_estimate.previous_state.is_charging: %d", be->previous_state.is_charging);
LOG_EXT(how, "storage.battery_estimate.previous_state.is_plugged: %d", be->previous_state.is_plugged);
LOG_EXT(how, "storage.battery_estimate.average_data_write_head: %d", be->average_data_write_head);
battery_estimate_data_log(be->averate_data, battery_estimate_data_average_data_num, how);
LOG_EXT(how, "storage.last_full_timestamp: %ld", storage.last_full_timestamp);
LOG_EXT(how, "storage.battery_display: %d", storage.battery_display);
}
/// <summary>
/// Initializes a new instance of the <see cref="MaterialMonitor"/> class.
/// </summary>
MaterialMonitor::MaterialMonitor()
: BaseMaterialMonitor(), m_certificates(NULL), m_veriferS(NULL), m_bVerified(false)
{
m_tagAdapter = IDTagAdapterFactory::CreateIDTagAdapter();
m_ucCartridgesCount = 0;
#if (ENABLE_BURNING == 1)
m_bCorrupt = false;
#endif
LOG_EXT(LEVEL_INFO, "IDT-Srv initialized.");
}
void LoadBehavior(void* arg, const char* fileName)
{
MaterialMonitorSim* materialMonitorSim = (MaterialMonitorSim*)arg;
UniqueLock(materialMonitorSim->GetMutex());
string path(SIMULATOR_FOLDER);
path.append(1, PATH_SEPARATOR);
path.append(BEHAVIORS_FOLDER);
path.append(1, PATH_SEPARATOR);
path.append(fileName);
Behavior* behavior = BehaviorParser::ParseBehavior(path.c_str());
materialMonitorSim->SetBehavior(behavior);
if (behavior != NULL)
{
LOG_EXT(LEVEL_INFO, "Behavior '" << fileName << "' was loaded.");
}
else
{
LOG_EXT(LEVEL_WARN, "Error loading behavior '" << fileName << "': invalid file.");
}
}
/// <summary>
/// Initializes underlying hardware.
/// </summary>
/// <returns>0 on success, non-zero for failures.</returns>
int MaterialMonitor::InitHW(unsigned char *pucCartridgesCount)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
if (pucCartridgesCount == NULL)
{
returnValue = FCB_NULL_PARAM;
LOG_EXT(LEVEL_FATAL, "Error initializing HW (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
m_bInitialized = false;
returnValue = m_tagAdapter->InitHW(pucCartridgesCount);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_FATAL, "Error initializing HW (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (m_ucCartridgesCount != *pucCartridgesCount)
{
m_ucCartridgesCount = *pucCartridgesCount;
if (m_certificates != NULL)
{
delete[] m_certificates;
}
m_certificates = new IDCertificate*[m_ucCartridgesCount];
}
for (unsigned char uc = 0; uc < m_ucCartridgesCount; uc++)
{
m_certificates[uc] = NULL;
}
LOG_EXT(LEVEL_INFO, "HW initialized successfully. Number of cartridges: " << (unsigned short)(*pucCartridgesCount) << ".");
m_bInitialized = true;
return returnValue;
}
/*********************
* MAPPING FUNCTIONS *
*********************/
static int mods_register_mapping(
struct file *fp,
struct SYS_MEM_MODS_INFO *p_mem_info,
NvU64 dma_addr,
NvU64 virtual_address,
NvU32 mapping_length)
{
struct SYS_MAP_MEMORY *p_map_mem;
MODS_PRIVATE_DATA(private_data, fp);
LOG_ENT();
mods_debug_printk(DEBUG_MEM_DETAILED,
"mapped dma 0x%llx, virt 0x%llx, size 0x%x\n",
dma_addr, virtual_address, mapping_length);
MODS_KMALLOC(p_map_mem, sizeof(*p_map_mem));
if (unlikely(!p_map_mem)) {
LOG_EXT();
return -ENOMEM;
}
memset(p_map_mem, 0, sizeof(*p_map_mem));
if (p_mem_info == NULL)
p_map_mem->contiguous = true;
else
p_map_mem->contiguous = false;
p_map_mem->dma_addr = dma_addr;
p_map_mem->virtual_addr = virtual_address;
p_map_mem->mapping_length = mapping_length;
p_map_mem->p_mem_info = p_mem_info;
list_add(&p_map_mem->list, private_data->mods_mapping_list);
LOG_EXT();
return OK;
}
// Makes sure storage is populated (by checking and, on absence, writing
// defaults) and then reading values.
void storage_init(void) {
LOG_FUNC();
// THIS MUST NEVER BE ENABLED */for (unsigned int i = 0; i <= MAXIMUM_EVER_USED; i++) {
// THIS MUST NEVER BE ENABLED */ if ((i % 10000) == 0) {
// THIS MUST NEVER BE ENABLED */ LOG_EXT(LOG_STORAGE, "storage_init(): working key %d", i);
// THIS MUST NEVER BE ENABLED */ }
// THIS MUST NEVER BE ENABLED */ if (persist_exists(i)) {
// THIS MUST NEVER BE ENABLED */ LOG_EXT(LOG_STORAGE, "storage_init(): deleting key %d", i);
// THIS MUST NEVER BE ENABLED */ persist_delete(i);
// THIS MUST NEVER BE ENABLED */ }
// THIS MUST NEVER BE ENABLED */}
if (!persist_exists(SELECTED_VERSION)) {
persist_write_string(SELECTED_VERSION, "Regular");
LOG_EXT(LOG_STORAGE, "storage_init(): init %d with data %s", SELECTED_VERSION, "Regular");
}
persist_read_string(SELECTED_VERSION, storage.selectedVersion, 64);
if (!persist_exists(BATTERY_ESTIMATE)) {
persist_write_data(BATTERY_ESTIMATE, (void*)&battery_estimate_data_init, sizeof(battery_estimate_data));
LOG_EXT(LOG_STORAGE, "storage_init(): init %d", BATTERY_ESTIMATE);
}
persist_read_data(BATTERY_ESTIMATE, (void*)&(storage.battery_estimate), sizeof(battery_estimate_data));
if (!persist_exists(LAST_FULL_TIMESTAMP)) {
persist_write_int(LAST_FULL_TIMESTAMP, (time_t)-1);
LOG_EXT(LOG_STORAGE, "storage_init(): init %d with data %ld", LAST_FULL_TIMESTAMP, (time_t)-1);
}
storage.last_full_timestamp = persist_read_int(LAST_FULL_TIMESTAMP);
if (!persist_exists(BATTERY_DISPLAY)) {
persist_write_int(BATTERY_DISPLAY, 7);
LOG_EXT(LOG_STORAGE, "storage_init(): init %d with data %d", BATTERY_DISPLAY, 1);
}
storage.battery_display = persist_read_int(BATTERY_DISPLAY);
app_log_storage_log(LOG_STORAGE_SU);
}
static void __exit mods_exit_module(void)
{
LOG_ENT();
mods_cleanup_irq();
misc_deregister(&mods_dev);
#ifdef CONFIG_ARCH_TEGRA
mods_shutdown_clock_api();
#endif
/* Check for memory leakage */
mods_check_mem();
mods_info_printk("driver unloaded\n");
LOG_EXT();
}
MaterialMonitorSim::MaterialMonitorSim(void)
: BaseMaterialMonitor(), m_authenticated(0), m_behavior(NULL)
{
pthread_mutex_init(&m_simLifetimeMutex, NULL);
pthread_cond_init(&m_simLifetimeCV, NULL);
m_timelineFile = SIMULATOR_FOLDER;
m_timelineFile.append(1, PATH_SEPARATOR);
m_timelineFile.append(BEHAVIORS_FOLDER);
m_timelineFile.append(1, PATH_SEPARATOR);
m_timelineFile.append(TIMELINE_FILE);
pthread_attr_init(&m_thLoadBehaviorTimelineAttr);
pthread_attr_setdetachstate(&m_thLoadBehaviorTimelineAttr, PTHREAD_CREATE_JOINABLE);
pthread_create(&m_thLoadBehaviorTimeline, NULL, LoadBehaviorTimeline, this);
LOG_EXT(LEVEL_INFO, "RS-Sim initialized.");
}
int esc_mods_pio_write(struct file *pfile, MODS_PIO_WRITE *p)
{
LOG_ENT();
switch (p->DataSize)
{
case 1:
MODS_PIO_WRITE_BYTE(p->Data, p->Port);
break;
case 2:
MODS_PIO_WRITE_WORD(p->Data, p->Port);
break;
case 4:
MODS_PIO_WRITE_DWORD(p->Data, p->Port);
break;
default:
return -EINVAL;
}
LOG_EXT();
return OK;
}
int esc_mods_pio_read(struct file *pfile, MODS_PIO_READ *p)
{
LOG_ENT();
switch (p->DataSize)
{
case 1:
p->Data = MODS_PIO_READ_BYTE(p->Port);
break;
case 2:
p->Data = MODS_PIO_READ_WORD(p->Port);
break;
case 4:
p->Data = MODS_PIO_READ_DWORD(p->Port);
break;
default:
return -EINVAL;
}
LOG_EXT();
return OK;
}
static void *ExecuteVerifyMessage(void* args)
{
VerifyParameters* executeVerifyParameters = new VerifyParameters;
*executeVerifyParameters = *((VerifyParameters*)args);
try
{
*executeVerifyParameters->Verified = executeVerifyParameters->Verifier->VerifyMessage(
executeVerifyParameters->Message,
executeVerifyParameters->MessageLength,
executeVerifyParameters->SignedMessage,
executeVerifyParameters->SignedMessageLength);
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Error verifying message: " << e.what() << ".");
*executeVerifyParameters->Verified = false;
}
delete executeVerifyParameters;
return NULL;
}
/// <summary>
/// Authenticates cartridge by verifying its certificate and its signature of a random token.
/// </summary>
/// <param name="ucCartridgeNum">The cartridge number.</param>
/// <param name="aucPubKS">Stratasys public key.</param>
/// <param name="aucIdd">The tag identification data (output parameter).</param>
/// <param name="usIddLength">The tag identification data length (output parameter).</param>
/// <param name="uiCurrentVolume">The tag current volume (output parameter).</param>
/// <returns>0 on success, non-zero for failures.</returns>
int MaterialMonitor::AuthenticateCartridge(unsigned char ucCartridgeNum, const unsigned char *aucPubKS, unsigned char *aucIdd, unsigned short *usIddLength, unsigned int *uiCurrentVolume)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
if (aucPubKS == NULL && m_pubKS == NULL)
{
returnValue = INVALID_HOST_KEY;
LOG_EXT(LEVEL_ERROR, "Invalid host key (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (aucIdd == NULL || usIddLength == NULL || uiCurrentVolume == NULL)
{
returnValue = AUTHENTICATE_NULL_PARAMS;
LOG_EXT(LEVEL_ERROR, "Invalid parameters (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (!m_bInitialized)
{
returnValue = HW_NOT_INITIALIZED;
LOG_EXT(LEVEL_ERROR, "Hardware not initialized (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
try
{
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " authentication started:");
LOG_EXT(LEVEL_INFO, "Reset cartridge #"<< (unsigned short)ucCartridgeNum << " info...");
int returnValue = ResetCartridgeInfo(ucCartridgeNum);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error resetting cartridge #"<< (unsigned short)ucCartridgeNum << " info (number of cartridges: " << (unsigned short)m_ucCartridgesCount << ", error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Switching to cartridge #"<< (unsigned short)ucCartridgeNum << "...");
returnValue = m_tagAdapter->SwitchToCartridge(ucCartridgeNum);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error switching to cartridge #"<< (unsigned short)ucCartridgeNum << " (number of cartridges: " << (unsigned short)m_ucCartridgesCount << ", error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Reading ID certificate...");
unsigned char aucBuffer[CERTIFICATE_SIZE];
memset(aucBuffer, 0, sizeof(aucBuffer));
returnValue = ReadIDCertificate(aucBuffer);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error reading ID certificate (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
bool isEmpty = m_tagAdapter->IsCertificateEmpty(aucBuffer);
if (isEmpty)
{
returnValue = EMPTY_CERTIFICATE_FILE;
LOG_EXT(LEVEL_ERROR, "Tag is blank (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_DEBUG, "Extracting cartridge #" << (unsigned short)ucCartridgeNum << " public key...");
IDCertificate *certificate = new IDCertificate();
unsigned short certificateSize;
try
{
certificateSize = (unsigned short)certificate->Decode(aucBuffer);
}
catch (exception& e)
{
delete certificate;
returnValue = INVALID_CERTIFICATE_FILE;
LOG_EXT(LEVEL_ERROR, "Invalid certificate (error code 0x" << hex << (short)returnValue << "): " << e.what() << ".");
return returnValue;
}
*usIddLength = certificateSize - SIGNATURE_SIZE - PUBLIC_KEY_SIZE;
memcpy(aucIdd, aucBuffer, *usIddLength);
ECDSA<EC2N, SHA256>::PublicKey* pubKS;
if (aucPubKS != NULL)
{
pubKS = LoadPublicKey(aucPubKS);
if (pubKS == NULL)
{
delete certificate;
return INVALID_HOST_KEY;
}
}
else
{
pubKS = m_pubKS;
}
LOG_EXT(LEVEL_INFO, "Verifying ID certificate...");
SetVerifier(pubKS);
pthread_t verifierThread;
VerifyParameters* verifyParameters = CreateVerifyParameters(
m_veriferS,
aucBuffer,
certificateSize - SIGNATURE_SIZE,
aucBuffer + (certificateSize - SIGNATURE_SIZE),
SIGNATURE_SIZE);
CreateVerifierThread(&verifierThread, verifyParameters);
LOG_EXT(LEVEL_INFO, "Sending random token for IDT to sign...");
byte aucHostChallenge[TOKEN_SIZE];
GenerateToken(aucHostChallenge, TOKEN_SIZE);
byte aucDeviceChallenge[64]; // expected device challenge length
byte aucSignedDeviceChallenge[SIGNATURE_SIZE];
unsigned short usDeviceChallengeLength = sizeof(aucDeviceChallenge);
unsigned short usSignedDeviceChallengeLength = sizeof(aucSignedDeviceChallenge);
returnValue = ChallengeHostDevice(ucCartridgeNum, aucHostChallenge, TOKEN_SIZE, aucDeviceChallenge, &usDeviceChallengeLength, aucSignedDeviceChallenge, &usSignedDeviceChallengeLength);
void* status;
pthread_join(verifierThread, &status);
delete verifyParameters;
if (!m_bVerified)
{
returnValue = INVALID_CERTIFICATE_SIGNATURE;
LOG_EXT(LEVEL_ERROR, "Error verifying ID certificate (error code 0x" << hex << (short)returnValue << ").");
delete certificate;
return returnValue;
}
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error sending random token to IDT (error code 0x" << hex << (short)returnValue << ").");
delete certificate;
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Verifying IDT signature...");
verifyParameters = CreateVerifyParameters(
certificate->IDD.GetVerifier(),
aucDeviceChallenge,
usDeviceChallengeLength,
aucSignedDeviceChallenge,
usSignedDeviceChallengeLength);
CreateVerifierThread(&verifierThread, verifyParameters);
LOG_EXT(LEVEL_INFO, "Getting current volume...");
returnValue = GetCurrentVolume(ucCartridgeNum, uiCurrentVolume);
pthread_join(verifierThread, &status);
delete verifyParameters;
if (!m_bVerified)
{
returnValue = INVALID_TOKEN_SIGNATURE;
LOG_EXT(LEVEL_ERROR, "Invalid signature (error code 0x" << hex << (short)returnValue << ").");
delete certificate;
return returnValue;
}
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error getting current volume (error code 0x" << hex << (short)returnValue << ").");
delete certificate;
return returnValue;
}
m_certificates[ucCartridgeNum] = certificate;
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " authentication ended successfully. Current weight: " << *uiCurrentVolume << " milligrams.");
return returnValue;
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Exception caught: " << e.what() << ".");
return EXCEPTION_CAUGHT;
}
}
bool init()
{
GLenum glewerr;
if((glewerr=glewInit()) != GLEW_OK)
{
LOG("glewinit() failed : ",glewGetErrorString(glewerr),"\n");
return false;
}
glGetError();
std::cout << "Initializing on "<<glGetString(GL_VENDOR)<<" "<<glGetString(GL_RENDERER)<<" using OpenGL "<<glGetString(GL_VERSION)<<"\n";
LOG("Initializing on ",glGetString(GL_VENDOR)," ",glGetString(GL_RENDERER)," using OpenGL ",glGetString(GL_VERSION),"\n");
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback( debugOut, NULL );
glClearDepth(1);
openGL.clearDepth();
openGL.getHardwardProperties();
openGL.applyAll();
LOG("\nSupport of bindless_texture: ",glewGetExtension("GL_ARB_bindless_texture")==GL_TRUE);
LOG("Support of sparse_texture: ",glewGetExtension("GL_ARB_sparse_texture")==GL_TRUE);
texBufferPool = new TextureBufferPool;
vertexBufferPool = new VertexBufferPoolType(2 << 20, VertexFormat::VNCT, DrawMode::DYNAMIC);
indexBufferPool = new IndexBufferPoolType(8 << 20, DrawMode::DYNAMIC);
indexBufferPool->buffer().bind();
textureSampler[TextureMode::NoFilter] = Texture::genTextureSampler(false,false,false,false);
textureSampler[TextureMode::Filtered] = Texture::genTextureSampler(true,true,true,false);
textureSampler[TextureMode::FilteredNoRepeat] = Texture::genTextureSampler(false,true,true,false);
textureSampler[TextureMode::OnlyLinearNoRepeat] = Texture::genTextureSampler(false,true,false,false);
textureSampler[TextureMode::DepthMap] = Texture::genTextureSampler(false,true,false,true);
ShaderCompiler vDrawQuad(ShaderCompiler::VERTEX_SHADER);
vDrawQuad.setSource(drawQuad_vertex);
ShaderCompiler pDrawQuad(ShaderCompiler::PIXEL_SHADER);
pDrawQuad.setSource(drawQuad_pixel);
auto optShader = Shader::combine(vDrawQuad.compile({}), pDrawQuad.compile({}));
if(!optShader.hasValue())
{
LOG_EXT("DrawQuad Vertex shader error:\n", vDrawQuad.error());
LOG_EXT("DrawQuad Pixel shader error:\n", pDrawQuad.error());
LOG_EXT("DrawQuad Link erorr:", Shader::lastLinkError());
}
else
drawQuadShader = optShader.value();
ShaderCompiler vDepthPass(ShaderCompiler::VERTEX_SHADER);
vDepthPass.setSource(depthPass_vertex);
LOG("No gs for DepthPass shader, expect a warning");
optShader = Shader::linkVertexShader(vDepthPass.compile({}));
if(!optShader.hasValue())
{
LOG_EXT("DepthPass Vertex shader error:\n", vDepthPass.error());
LOG_EXT("DepthPass Link erorr:", Shader::lastLinkError());
}
else
depthPassShader = optShader.value();
VNCT_Vertex vData[4] = {{vec3(-1,-1,0),vec3(),vec2(0,0),vec3()},
{vec3(-1, 1,0),vec3(),vec2(0,1),vec3()},
{vec3( 1, 1,0),vec3(),vec2(1,1),vec3()},
{vec3( 1,-1,0),vec3(),vec2(1,0),vec3()}};
uint iData[6] = {0,1,2,2,3,0};
VBuffer* tmpVB = vertexBufferPool->alloc(4);
IBuffer* tmpIB = indexBufferPool->alloc(6);
tmpVB->flush(reinterpret_cast<float*>(vData),0,4);
tmpIB->flush(iData,0,6);
quadMeshBuffers = new MeshBuffers(tmpVB,tmpIB);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
if(openGL.hardward(GLState::Hardward::MAJOR_VERSION) > 4 ||
(openGL.hardward(GLState::Hardward::MAJOR_VERSION)==4 && openGL.hardward(GLState::Hardward::MINOR_VERSION)>=3))
{
if(glewGetExtension("GL_ARB_bindless_texture")!=GL_TRUE)
{
LOG("You don't support GL_ARB_bindless_texture, you can't run TIMEngine sorry.");
return false;
}
return true;
}
else
{
LOG("You don't have a sufficient openGL version.");
return false;
}
}
void update_time(void) {
LOG_FUNC();
if (!ui_updates_enabled) {
LOG(LOG_FACEUPDATE, "static void update_time(): not done, not enabled");
return;
}
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
LOG(LOG_FACEUPDATE, "static void update_time(): display plain time");
// Use a static (long lived) buffer for the numeric time.
static char time[] = "00:00";
// Write the current hours and minutes into the buffer, considerung the
// 12/24h style.
if(clock_is_24h_style() == true) {
strftime(time, sizeof("00:00"), "%H:%M", tick_time);
} else {
strftime(time, sizeof("00:00"), "%I:%M", tick_time);
}
// Display time in respective layer.
text_layer_set_text(s_timelayer, time);
int weekday = tick_time->tm_wday-1;
if (weekday < 0) weekday += 7;
LOG(LOG_FACEUPDATE, "static void update_time(): display date");
LOG_EXT(LOG_FACEUPDATE, "static void update_time(): day: %d", weekday);
LOG_EXT(LOG_FACEUPDATE, "static void update_time(): mday: %d", tick_time->tm_mday);
LOG_EXT(LOG_FACEUPDATE, "static void update_time(): month: %d", tick_time->tm_mon);
// Use a static (long lived) buffer for the numeric date.
static char date[80];
strftime(date, 80, "%a, %d. %b", tick_time);
// Display date in respective layer.
LOG(LOG_FACEUPDATE, "updating s_date_layer");
text_layer_set_text(s_datelayer, date);
// Fetch and print BlueTooth status information.
LOG(LOG_FACEUPDATE, "updating s_info1_layer");
text_layer_set_text(s_btlayer, bt_state_string);
if (bt_state) {
bitmap_layer_set_bitmap(s_bitmaplayer_bt, s_res_image_bt_active);
} else {
bitmap_layer_set_bitmap(s_bitmaplayer_bt, s_res_image_bt_passive);
}
LOG(LOG_FACEUPDATE, "updating s_batterylayer");
static char battery_state_str[6];
if (battery_state.is_plugged) {
if (battery_state.is_charging) {
snprintf(battery_state_str, 6, "charging");
} else {
snprintf(battery_state_str, 6, "full");
}
} else {
snprintf(battery_state_str, 6, "%d%%", battery_state.charge_percent);
}
text_layer_set_text(s_batterylayer, battery_state_str);
if (storage.last_full_timestamp != -1) {
static stringbuffer outbound;
stringbuffer_init(&outbound);
stringbuffer_append_ti(&outbound, temp - storage.last_full_timestamp);
text_layer_set_text(s_outboundlayer, outbound.retval);
} else if (battery_state.is_plugged) {
text_layer_set_text(s_outboundlayer, "plugged");
} else {
text_layer_set_text(s_outboundlayer, "-");
}
static stringbuffer inbound;
stringbuffer_init(&inbound);
stringbuffer_append_ti(&inbound, battery_estimate_secs);
text_layer_set_text(s_inboundlayer, inbound.retval);
}
int esc_mods_tegra_dc_config_possible(struct file *fp,
struct MODS_TEGRA_DC_CONFIG_POSSIBLE *args)
{
int i;
struct tegra_dc *dc = tegra_dc_get_dc(args->head);
struct tegra_dc_win *dc_wins[DC_N_WINDOWS];
#ifndef CONFIG_TEGRA_ISOMGR
struct clk *emc_clk = 0;
unsigned long max_bandwidth = 0;
unsigned long current_emc_freq = 0;
unsigned long max_available_bandwidth = 0;
#else
int ret = -EINVAL;
#endif
LOG_ENT();
BUG_ON(args->win_num > DC_N_WINDOWS);
if (!dc) {
LOG_EXT();
return -EINVAL;
}
for (i = 0; i < args->win_num; i++) {
int idx = args->windows[i].index;
if (args->windows[i].flags &
MODS_TEGRA_DC_WINDOW_FLAG_ENABLED) {
mods_tegra_dc_set_windowattr_basic(&dc->tmp_wins[idx],
&args->windows[i]);
} else {
dc->tmp_wins[idx].flags = 0;
}
dc_wins[i] = &dc->tmp_wins[idx];
mods_debug_printk(DEBUG_TEGRADC,
"esc_mods_tegra_dc_config_possible head %u, "
"using index %d for window %d\n",
args->head, i, idx);
}
mods_debug_printk(DEBUG_TEGRADC,
"esc_mods_tegra_dc_config_possible head %u, "
"dc->mode.pclk %u\n",
args->head, dc->mode.pclk);
#ifndef CONFIG_TEGRA_ISOMGR
max_bandwidth = tegra_dc_get_bandwidth(dc_wins, args->win_num);
emc_clk = clk_get_sys("tegra_emc", "emc");
if (IS_ERR(emc_clk)) {
mods_debug_printk(DEBUG_TEGRADC,
"esc_mods_tegra_dc_config_possible "
"invalid clock specified when fetching EMC clock\n");
} else {
current_emc_freq = clk_get_rate(emc_clk);
current_emc_freq /= 1000;
max_available_bandwidth =
8 * tegra_emc_freq_req_to_bw(current_emc_freq);
max_available_bandwidth = (max_available_bandwidth / 100) * 50;
}
mods_debug_printk(DEBUG_TEGRADC,
"esc_mods_tegra_dc_config_possible bandwidth needed = %lu,"
" bandwidth available = %lu\n",
max_bandwidth, max_available_bandwidth);
args->possible = (max_bandwidth <= max_available_bandwidth);
#else
ret = tegra_dc_bandwidth_negotiate_bw(dc, dc_wins, args->win_num);
args->possible = (ret == 0);
#endif
for (i = 0; i < args->win_num; i++) {
args->windows[i].bandwidth = dc_wins[i]->new_bandwidth;
mods_debug_printk(DEBUG_TEGRADC,
"esc_mods_tegra_dc_config_possible head %u, "
"window %d bandwidth %d\n",
args->head, dc_wins[i]->idx, dc_wins[i]->new_bandwidth);
}
LOG_EXT();
return 0;
}
int esc_mods_tegra_dc_setup_sd(struct file *fp,
struct MODS_TEGRA_DC_SETUP_SD *args)
{
int i;
struct tegra_dc *dc = tegra_dc_get_dc(args->head);
struct tegra_dc_sd_settings *sd_settings = dc->out->sd_settings;
#if defined(CONFIG_ARCH_TEGRA_12x_SOC)
u32 val;
#endif
u32 bw_idx;
LOG_ENT();
BUG_ON(args->head > TEGRA_MAX_DC);
sd_settings->enable = args->enable ? 1 : 0;
sd_settings->use_auto_pwm = false;
sd_settings->hw_update_delay = 0;
sd_settings->aggressiveness = args->aggressiveness;
sd_settings->bin_width = (1 << args->bin_width_log2);
sd_settings->phase_in_settings = 0;
sd_settings->phase_in_adjustments = 0;
sd_settings->cmd = 0;
sd_settings->final_agg = args->aggressiveness;
sd_settings->cur_agg_step = 0;
sd_settings->phase_settings_step = 0;
sd_settings->phase_adj_step = 0;
sd_settings->num_phase_in_steps = 0;
sd_settings->agg_priorities.agg[0] = args->aggressiveness;
sd_settings->use_vid_luma = args->use_vid_luma;
sd_settings->coeff.r = args->csc_r;
sd_settings->coeff.g = args->csc_g;
sd_settings->coeff.b = args->csc_b;
sd_settings->k_limit_enable = (args->klimit != 0);
sd_settings->k_limit = args->klimit;
sd_settings->sd_window_enable = true;
sd_settings->sd_window.h_position = args->win_x;
sd_settings->sd_window.v_position = args->win_y;
sd_settings->sd_window.h_size = args->win_w;
sd_settings->sd_window.v_size = args->win_h;
sd_settings->soft_clipping_enable = true;
sd_settings->soft_clipping_threshold = args->soft_clipping_threshold;
sd_settings->smooth_k_enable = (args->smooth_k_inc != 0);
sd_settings->smooth_k_incr = args->smooth_k_inc;
sd_settings->sd_proc_control = false;
sd_settings->soft_clipping_correction = false;
sd_settings->use_vpulse2 = false;
sd_settings->fc.time_limit = 0;
sd_settings->fc.threshold = 0;
sd_settings->blp.time_constant = 1024;
sd_settings->blp.step = 0;
#ifdef CONFIG_TEGRA_SD_GEN2
bw_idx = 0;
#else
bw_idx = args->bin_width_log2;
#endif
for (i = 0; i < MODS_TEGRA_DC_SETUP_BLTF_SIZE; i++) {
sd_settings->bltf[bw_idx][i/4][i%4] =
args->bltf[i];
}
for (i = 0; i < MODS_TEGRA_DC_SETUP_SD_LUT_SIZE; i++) {
sd_settings->lut[bw_idx][i].r =
args->lut[i] & 0xff;
sd_settings->lut[bw_idx][i].g =
(args->lut[i] >> 8) & 0xff;
sd_settings->lut[bw_idx][i].b =
(args->lut[i] >> 16) & 0xff;
}
#if defined(CONFIG_TEGRA_NVSD)
nvsd_init(dc, sd_settings);
#endif
#if defined(CONFIG_ARCH_TEGRA_12x_SOC)
tegra_dc_io_start(dc);
val = tegra_dc_readl(dc, DC_DISP_SD_CONTROL);
val &= ~SD_KINIT_BIAS(0);
val &= ~SD_CORRECTION_MODE_MAN;
tegra_dc_writel(dc, val | SD_KINIT_BIAS(args->k_init_bias),
DC_DISP_SD_CONTROL);
tegra_dc_io_end(dc);
#endif
if (dc->enabled) {
mutex_lock(&dc->lock);
tegra_dc_get(dc);
tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
tegra_dc_put(dc);
mutex_unlock(&dc->lock);
}
LOG_EXT();
return 0;
}
void app_log_battery_state(BatteryChargeState s) {
LOG_EXT(LOG_BATTERY, "s.charge_percent: %d", s.charge_percent);
LOG_EXT(LOG_BATTERY, "s.is_charging: %d", s.is_charging);
LOG_EXT(LOG_BATTERY, "s.is_plugged: %d", s.is_plugged);
}
///
/// Authenticates cartridge.
///
int MaterialMonitorSim::AuthenticateCartridge(unsigned char ucCartridgeNum, const unsigned char *aucPubKS, unsigned char *aucIdd, unsigned short *usIddLength, unsigned int *uiCurrentVolume)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
if (aucPubKS == NULL && m_pubKS == NULL)
{
returnValue = INVALID_HOST_KEY;
LOG_EXT(LEVEL_ERROR, "Invalid host key (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (aucIdd == NULL || usIddLength == NULL || uiCurrentVolume == NULL)
{
returnValue = AUTHENTICATE_NULL_PARAMS;
LOG_EXT(LEVEL_ERROR, "Invalid parameters (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (!m_bInitialized)
{
returnValue = HW_NOT_INITIALIZED;
LOG_EXT(LEVEL_ERROR, "Hardware not initialized (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
try
{
int behaviorReturnValue = GetAuthenticateCartridgeBehavior(ucCartridgeNum, aucPubKS, aucIdd, usIddLength, uiCurrentVolume);
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " authentication started:");
LOG_EXT(LEVEL_INFO, "Switching to cartridge #"<< (unsigned short)ucCartridgeNum << "...");
if (((m_behavior != NULL) && !IsCartridgeOn(ucCartridgeNum, m_behavior->Status)) ||
behaviorReturnValue == FCB_SELECT_CHANNEL_FAILED)
{
returnValue = FCB_SELECT_CHANNEL_FAILED;
LOG_EXT(LEVEL_ERROR, "Error switching to cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
ResetCartridgeInfo(ucCartridgeNum);
// read certificate file
LOG_EXT(LEVEL_INFO, "Getting ID certificate...");
string sCertificateFileName = GetCartridgeFileName(ucCartridgeNum, CERTIFICATE_FILE);
FILE *pCertificateFile = fopen(sCertificateFileName.c_str(), "rb");
if (pCertificateFile == NULL || behaviorReturnValue == INVALID_CERTIFICATE_FILE)
{
returnValue = INVALID_CERTIFICATE_FILE;
LOG_EXT(LEVEL_ERROR, "Error getting ID certificate (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
fseek(pCertificateFile , 0 , SEEK_END);
size_t fileSize = (size_t)ftell(pCertificateFile);
rewind(pCertificateFile);
fread(aucIdd, sizeof(unsigned char), fileSize, pCertificateFile);
IDCertificate idc;
*usIddLength = (unsigned short)idc.Decode(aucIdd) - SIGNATURE_SIZE;
ECDSA<EC2N, SHA256>::PublicKey* pubKS;
if (aucPubKS != NULL)
{
pubKS = LoadPublicKey(aucPubKS);
if (pubKS == NULL)
{
return INVALID_HOST_KEY;
}
}
else
{
pubKS = m_pubKS;
}
if (returnValue == INVALID_HOST_KEY || behaviorReturnValue == INVALID_HOST_KEY)
{
returnValue = INVALID_HOST_KEY;
LOG_EXT(LEVEL_ERROR, "Invalid host key (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
// verify signature:
ECDSA<EC2N, SHA256>::Verifier verifier(*pubKS);
bool ok;
try
{
ok = verifier.VerifyMessage(aucIdd, *usIddLength, aucIdd + *usIddLength, SIGNATURE_SIZE);
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Error verifying ID certificate (error code 0x" << hex << (short)returnValue << "):" << e.what() << ".");
ok = false;
}
if (!ok || behaviorReturnValue == INVALID_CERTIFICATE_SIGNATURE)
{
returnValue = INVALID_CERTIFICATE_SIGNATURE;
LOG_EXT(LEVEL_ERROR, "Error verifying ID certificate (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
// read counter
returnValue = ReadCounter(ucCartridgeNum, uiCurrentVolume);
if (returnValue != IDTLIB_SUCCESS)
{
if (returnValue == INVALID_VOLUME_SIGNATURE || behaviorReturnValue == INVALID_VOLUME_SIGNATURE)
{
LOG_EXT(LEVEL_ERROR, "Error verifying signature (error code 0x" << hex << (short)returnValue << ").");
}
else
{
LOG_EXT(LEVEL_ERROR, "Error reading counter (error code 0x" << hex << (short)returnValue << ").");
}
return returnValue;
}
returnValue = behaviorReturnValue;
if (returnValue == IDTLIB_SUCCESS)
{
m_authenticated |= (1 << ucCartridgeNum);
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " authentication ended successfully. Current volume: " << *uiCurrentVolume << ".");
}
else
{
LOG_EXT(LEVEL_ERROR, "Error authenticating cartridge (error code 0x" << hex << (short)returnValue << ").");
}
return returnValue;
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Exception caught: " << e.what() << ".");
return EXCEPTION_CAUGHT;
}
}
/// <summary>
/// Verifies cartridge material consumption, by decreasing volume to consume from cartridge current volume,
/// checking if new value is equals to the expected value and verifying signature.
/// </summary>
/// <param name="ucCartridgeNum">The cartridge number.</param>
/// <param name="uiComsumption">The material volume to consume.</param>
/// <param name="uiNewVolume">Cartridge new volume.</param>
/// <returns>0 on success, non-zero for failures.</returns>
int MaterialMonitor::UpdateConsumption(unsigned char ucCartridgeNum, unsigned int uiComsumption, unsigned int *uiNewVolume)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
if (uiNewVolume == NULL)
{
returnValue = CONSUMPTION_NULL_PARAMS;
LOG_EXT(LEVEL_ERROR, "Invalid parameters (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (!m_bInitialized)
{
returnValue = HW_NOT_INITIALIZED;
LOG_EXT(LEVEL_ERROR, "Hardware not initialized (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
try
{
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " material consumption started...");
LOG_EXT(LEVEL_INFO, "Switching to cartridge #"<< (unsigned short)ucCartridgeNum << "...");
int returnValue = m_tagAdapter->SwitchToCartridge(ucCartridgeNum);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error switching to cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (m_certificates == NULL ||
m_certificates[ucCartridgeNum] == NULL)
{
returnValue = CARTRIDGE_NOT_AUTHENTICATED;
LOG_EXT(LEVEL_ERROR, "Cartridge #"<< (unsigned short)ucCartridgeNum << " not authenticated (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Decreasing volume by " << uiComsumption << "...");
CounterResponse counterResponse;
returnValue = DecreaseVolume(ucCartridgeNum, uiComsumption, &counterResponse);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error decreasing volume (error code 0x" << hex << (short)returnValue << ").");
if (returnValue == MATERIAL_OVERCONSUMPTION)
{
DecreaseVolume(ucCartridgeNum, 0, &counterResponse);
*uiNewVolume = counterResponse.GetCounterValue();
}
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Verifying signature...");
bool ok = VerifyVolume(m_certificates[ucCartridgeNum]->IDD.GetVerifier(), counterResponse);
if (!ok)
{
returnValue = INVALID_VOLUME_SIGNATURE;
LOG_EXT(LEVEL_ERROR, "Error verifying signature (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
*uiNewVolume = counterResponse.GetCounterValue();
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " material consumption ended successfully. Current weight: " << *uiNewVolume << " milligrams.");
return returnValue;
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Exception caught: " << e.what() << ".");
return EXCEPTION_CAUGHT;
}
}
void *LoadBehaviorTimeline(void* arg)
{
MaterialMonitorSim* materialMonitorSim = (MaterialMonitorSim*)arg;
try
{
LOG_EXT(LEVEL_INFO, "Loading behavior timeline '.\\" << materialMonitorSim->GetTimelineFile() << "'...");
XMLDocument doc;
doc.LoadFile(materialMonitorSim->GetTimelineFile().c_str());
XMLElement* root = doc.RootElement();
if (root != NULL)
{
XMLElement* behaviorEl = root->FirstChildElement("Behavior");
XMLElement* lastBehaviorEl = root->LastChildElement("Behavior");
while (behaviorEl != NULL)
{
float interval = 0;
behaviorEl->QueryFloatAttribute("Interval", &interval);
LOG_EXT(LEVEL_INFO, "Waiting for behavior for " << interval << " seconds...");
if (interval > 0)
{
// Wait for a specified interval by acquiring a lock;
// if lock was acquired successfully, destructor was called - shutdown thread.
timespec ts;
timeb now;
ftime(&now);
ts.tv_sec = now.time + (int)floorf(interval);
long nsec = now.millitm * 1000000 + (long)((interval - floorf(interval)) * 1000000000);
ts.tv_sec += nsec / 1000000000;
ts.tv_nsec = nsec % 1000000000;
pthread_mutex_t simLifetimeMutex = materialMonitorSim->GetSimLifetimeMutex();
pthread_cond_t simLifetimeCV = materialMonitorSim->GetSimLifetimeCV();
pthread_mutex_lock(&simLifetimeMutex);
int cvStatus = pthread_cond_timedwait(&simLifetimeCV, &simLifetimeMutex, &ts);
bool timeout;
#ifdef WIN32
timeout = (cvStatus == WSAETIMEDOUT);
#else
timeout = (cvStatus == ETIMEDOUT);
#endif
pthread_mutex_unlock(&simLifetimeMutex);
if (!timeout)
{
break;
}
}
LoadBehavior(materialMonitorSim, behaviorEl->GetText());
behaviorEl = (behaviorEl == lastBehaviorEl) ? NULL : behaviorEl->NextSiblingElement();
}
LOG_EXT(LEVEL_INFO, "Behavior timeline loaded successfully.");
}
else
{
LOG_EXT(LEVEL_WARN, "Cannot find file root.");
}
}
catch (...)
{
LOG_EXT(LEVEL_WARN, "Invalid timeline.");
}
return NULL;
}
///
/// Verifies material consumption.
//
int MaterialMonitorSim::UpdateConsumption(unsigned char ucCartridgeNum, unsigned int uiComsumption, unsigned int *uiNewVolume)
{
UniqueLock uniqueLock(m_mtx);
try
{
int returnValue = IDTLIB_SUCCESS;
if (uiNewVolume == NULL)
{
returnValue = CONSUMPTION_NULL_PARAMS;
LOG_EXT(LEVEL_ERROR, "Invalid parameters (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (!m_bInitialized)
{
returnValue = HW_NOT_INITIALIZED;
LOG_EXT(LEVEL_ERROR, "Hardware not initialized (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
int behaviorReturnValue = GetUpdateConsumptionBehavior(ucCartridgeNum, uiComsumption, uiNewVolume);
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " material consumption started...");
if (!IsCartridgeOn(ucCartridgeNum, m_authenticated) ||
behaviorReturnValue == CARTRIDGE_NOT_AUTHENTICATED)
{
returnValue = CARTRIDGE_NOT_AUTHENTICATED;
LOG_EXT(LEVEL_ERROR, "Cartridge #"<< (unsigned short)ucCartridgeNum << " not authenticated (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Switching to cartridge #"<< (unsigned short)ucCartridgeNum << "...");
if (((m_behavior != NULL) && !IsCartridgeOn(ucCartridgeNum, m_behavior->Status)) ||
behaviorReturnValue == FCB_SELECT_CHANNEL_FAILED)
{
returnValue = FCB_SELECT_CHANNEL_FAILED;
LOG_EXT(LEVEL_ERROR, "Error switching to cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Getting current volume...");
returnValue = ReadCounter(ucCartridgeNum, uiNewVolume);
if (returnValue != IDTLIB_SUCCESS)
{
if (returnValue == INVALID_VOLUME_SIGNATURE || behaviorReturnValue == INVALID_VOLUME_SIGNATURE)
{
LOG_EXT(LEVEL_ERROR, "Error verifying signature (error code 0x" << hex << (short)returnValue << ").");
}
else
{
LOG_EXT(LEVEL_ERROR, "Error reading counter (error code 0x" << hex << (short)returnValue << ").");
}
return returnValue;
}
if (*uiNewVolume < uiComsumption || behaviorReturnValue == MATERIAL_OVERCONSUMPTION)
{
returnValue = MATERIAL_OVERCONSUMPTION;
LOG_EXT(LEVEL_ERROR, "Invalid consumption (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
returnValue = behaviorReturnValue;
if (returnValue == IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_INFO, "Decreasing volume by " << uiComsumption << "...");
*uiNewVolume -= uiComsumption;
WriteCounter(ucCartridgeNum, *uiNewVolume);
LOG_EXT(LEVEL_INFO, "Cartridge #" << (unsigned short)ucCartridgeNum << " material consumption ended successfully. Current volume: " << *uiNewVolume << ".");
}
else
{
LOG_EXT(LEVEL_ERROR, "Error updating consumption (error code 0x" << hex << (short)returnValue << ").");
}
return returnValue;
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Exception caught: " << e.what() << ".");
return EXCEPTION_CAUGHT;
}
}
/// <summary>
/// Generates certificate from material information and burns it into tag.
/// </summary>
/// <param name="ucCartridgeNum">The cartridge number.</param>
/// <param name="aucMaterialInfo">The material information.</param>
/// <param name="usMaterialInfoLength">The material information length.</param>
/// <param name="aucPrvKS">SSYS private key.</param>
/// <param name="aucPubKS">SSYS public key.</param>
/// <returns>0 on success, non-zero for failures.</returns>
int MaterialMonitor::BurnIDC(unsigned char ucCartridgeNum, const unsigned char *aucMaterialInfo, unsigned short usMaterialInfoLength, const unsigned char *aucPrvKS, const unsigned char *aucPubKS)
{
UniqueLock uniqueLock(m_mtx);
int returnValue = IDTLIB_SUCCESS;
bool areParametersValid = true;
if (m_bCorrupt)
{
areParametersValid = (aucMaterialInfo != NULL) &&
(aucPrvKS != NULL) &&
((aucPubKS != NULL) || (m_pubKS != NULL));
}
else
{
areParametersValid = (aucMaterialInfo == NULL) ||
((aucPrvKS != NULL) && ((aucPubKS != NULL) || (m_pubKS != NULL)));
}
if (!areParametersValid)
{
returnValue = BURN_NULL_PARAMS;
LOG_EXT(LEVEL_ERROR, "Invalid parameters.");
return returnValue;
}
try
{
LOG_EXT(LEVEL_INFO, "Setting ID certificate for cartridge #" << (unsigned short)ucCartridgeNum << " started:");
LOG_EXT(LEVEL_INFO, "Switching to cartridge #"<< (unsigned short)ucCartridgeNum << "...");
returnValue = m_tagAdapter->SwitchToCartridge(ucCartridgeNum);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error switching to cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
unsigned char aucCertificate[CERTIFICATE_SIZE];
unsigned short usCertificateLength = CERTIFICATE_SIZE;
if (m_bCorrupt)
{
ReadIDCertificate(aucCertificate);
}
LOG_EXT(LEVEL_INFO, "Logging in to cartridge #"<< (unsigned short)ucCartridgeNum << " ...");
returnValue = m_tagAdapter->Login();
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error logging in to cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (aucMaterialInfo != NULL)
{
LOG_EXT(LEVEL_INFO, "Configuring cartridge #"<< (unsigned short)ucCartridgeNum << "...");
returnValue = m_tagAdapter->Configure();
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error configuring to cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
unsigned char pubKS[PUBLIC_KEY_SIZE];
if (aucPubKS != NULL)
{
returnValue = SetPubKS(aucPubKS);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error setting host public key (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
}
try
{
m_pubKS->Save(ArraySink(pubKS, PUBLIC_KEY_SIZE).Ref());
}
catch (...)
{
returnValue = INVALID_HOST_KEY;
LOG_EXT(LEVEL_ERROR, "Invalid host key.");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Setting keys of cartridge #"<< (unsigned short)ucCartridgeNum << "...");
returnValue = m_tagAdapter->SetKeys(pubKS);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error setting keys of cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Setting counter of cartridge #"<< (unsigned short)ucCartridgeNum << "...");
MaterialInformation materialInfo;
materialInfo.Decode(aucMaterialInfo);
returnValue = m_tagAdapter->SetCounter((unsigned int)(materialInfo.InitialWeight) * 1000);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error setting counter of cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
if (m_bCorrupt)
{
LOG_EXT(LEVEL_INFO, "Modifying cartridge #"<< (unsigned short)ucCartridgeNum << " certificate...");
memcpy(aucCertificate, aucMaterialInfo, usMaterialInfoLength);
}
else
{
LOG_EXT(LEVEL_INFO, "Generate cartridge #"<< (unsigned short)ucCartridgeNum << " certificate...");
returnValue = m_tagAdapter->GenerateCertificate(aucMaterialInfo, usMaterialInfoLength, aucPrvKS, aucCertificate, &usCertificateLength);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error generating cartridge #"<< (unsigned short)ucCartridgeNum << " certificate (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
bool ok;
LOG_EXT(LEVEL_INFO, "Verifying ID certificate...");
try
{
SetVerifier(m_pubKS);
ok = m_veriferS->VerifyMessage(aucCertificate, usCertificateLength - SIGNATURE_SIZE, aucCertificate + (usCertificateLength - SIGNATURE_SIZE), SIGNATURE_SIZE);
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Error verifying ID certificate (error code 0x" << hex << (short)returnValue << "): " << e.what() << ".");
ok = false;
}
if (!ok)
{
returnValue = INVALID_CERTIFICATE_SIGNATURE;
LOG_EXT(LEVEL_ERROR, "Error verifying ID certificate (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
}
LOG_EXT(LEVEL_INFO, "Writing certificate into cartridge #"<< (unsigned short)ucCartridgeNum << " ...");
returnValue = m_tagAdapter->WriteCertificate(aucCertificate, usCertificateLength);
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error writing certificate into cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
}
LOG_EXT(LEVEL_INFO, "Logging out from cartridge #"<< (unsigned short)ucCartridgeNum << " ...");
returnValue = m_tagAdapter->Logout();
if (returnValue != IDTLIB_SUCCESS)
{
LOG_EXT(LEVEL_ERROR, "Error logging out from cartridge #"<< (unsigned short)ucCartridgeNum << " (error code 0x" << hex << (short)returnValue << ").");
return returnValue;
}
LOG_EXT(LEVEL_INFO, "Setting ID certificate for cartridge #" << (unsigned short)ucCartridgeNum << " ended successfully.");
return returnValue;
}
catch (exception& e)
{
LOG_EXT(LEVEL_ERROR, "Exception caught: " << e.what() << ".");
return EXCEPTION_CAUGHT;
}
}
