// HINT: This information remains static throughout the object's lifetime
inline VmbErrorType Interface::GetSerialNumber( std::string &rStrSerial ) const
{
    VmbErrorType    res;
    VmbUint32_t     nLength;

    res = GetSerialNumber( NULL, nLength );
    if ( VmbErrorSuccess == res )
    {
        if( 0 != nLength)
        {
            try
            {
                std::vector<std::string::value_type> tmpSerial( nLength + 1, '\0');
                res         = GetSerialNumber( &tmpSerial[0], nLength );
                if( VmbErrorSuccess == res )
                {
                    rStrSerial  = &*tmpSerial.begin();
                }
            }
            catch(...)
            {
                return VmbErrorResources;
            }
        }
        else
        {
            rStrSerial.clear();
        }
    }

    return res;
}

/************************************************************************//**
 * \brief Writes a USB transfer frame down to the Manta
 * \param   frame          Pointer to the frame to be transmitted
 * \param   forceQueued    Forces this message to be queued instead of merged
 *
 * WriteFrame() is meant to be called by the Manta subclass, which defines
 * methods for the individual messages (setLED, etc). libmanta maintains a
 * message queue that gets popped from in the HandleEvents() handler.
 *
 * The default behavior is that if a message is already queued up for a given
 * Manta, subsequent message will be merged into the waiting message instead of
 * being further queued (the queued frame will be the end result of all queued
 * messages). forceQueued can be set to true to force the message to be queued
 * as a separate message instead of being merged
 *
 * Note: Because WriteFrame() accesses the same message queue that
 * HandleEvents() does, they should be protected from each other by a mutex on
 * the application level if they're being called from parallel threads.
 ****************************************************************************/
void MantaUSB::WriteFrame(uint8_t *frame, bool forceQueued)
{
   if(NULL == DeviceHandle)
   {
      throw(MantaNotConnectedException(this));
   }
   MantaTxQueueEntry *queuedMessage = GetQueuedTxMessage();
   if(queuedMessage && !forceQueued)
   {
      /* replace the queued packet payload with the new one */
      for(int i = 0; i < OutPacketLen; ++i)
      {
         /* the first byte of the report is the report ID (0x00) */
         queuedMessage->OutFrame[i+1] = frame[i];
      }
      DebugPrint("%s-%d: (WriteFrame) Queued Transfer overwritten on Manta %d",
            __FILE__, __LINE__, GetSerialNumber());
   }
   else
   {
      /* no transfer in progress, queue up a new one */
      MantaTxQueueEntry *newMessage = new MantaTxQueueEntry;
      newMessage->OutFrame[0] = 0;
      newMessage->TargetManta = this;
      /* the first byte of the report is the report ID (0x00) */
      memcpy(newMessage->OutFrame + 1, frame, OutPacketLen);
      txQueue.push_back(newMessage);
      DebugPrint("%s-%d: (WriteFrame) Transfer Queued on Manta %d",
            __FILE__, __LINE__, GetSerialNumber());
   }
}

CK_RV HandleNewCardFound(HWND hTextEdit, CK_FUNCTION_LIST_PTR functions,
									CK_ULONG ulCounter, CK_SLOT_ID_PTR pSlotList,
									PCCERT_CONTEXT*	ppCertContext, CK_ULONG certContextLen)
{
	CK_RV retVal = CKR_OK; 
	CK_SESSION_HANDLE session_handle;

	retVal = (functions->C_OpenSession)(pSlotList[ulCounter], CKF_SERIAL_SESSION, NULL_PTR, NULL_PTR, &session_handle);
	if (retVal == CKR_OK)
	{
		CK_ULONG ulserialNumberLen = 20;
		CK_BYTE_PTR serialNumber = (CK_BYTE_PTR)malloc (ulserialNumberLen*sizeof(CK_BYTE));

		if(serialNumber != NULL)
		{
			//get serial number of the card
			retVal =  GetSerialNumber(hTextEdit, functions, &session_handle, serialNumber,&ulserialNumberLen);
			if (retVal == CKR_OK)
			{	
				//register certificates of the card		
				retVal = GetAndRegisterCertificates(hTextEdit, functions, &session_handle, serialNumber, ulserialNumberLen, ppCertContext, certContextLen);
			}
		}
		retVal = (functions->C_CloseSession) (session_handle);			
	}
	return retVal;
}

int test1() {
  word retval;
  dword serialno;
  if (1!=OpenDLL(dtHandyscope3)) {
    printf("failed loading dlls\n");
    return 1;
  }

  retval=InitInstrument(0);
  if (retval!=NO_ERROR) {
    printf("failed to initialize the instrument, code=%d\n", retval);
    CloseDLL();
    return 1;
  }

  retval=GetSerialNumber(&serialno);
  if (retval!=NO_ERROR) {
    printf("could not read serial number, code=%d\n", retval);
    ExitInstrument();
    CloseDLL();
    return 1;
  }

  printf("serial no %d\n", serialno);

  ExitInstrument();
  CloseDLL();
  return 0;
}

void ProcessaCMD_HELLO( BYTE * buffer ){

  BYTE bufOut[8];
  BYTE bLog;
  DWORD dwSerNum;
  char i;

  if ( ModemGSM_IsReady() == FALSE ){
    //enviaNACK( buffer[ EO_FIELD ], DONT_CONNECTED  ); 
    return;    
  }
  
  bLog = EVT_SW_HELLO;
  Log( EVT_SW, &bLog, sizeof( BYTE ));  

  dwSerNum = GetSerialNumber();

  // altera o estado do SMS Box para conectado com o Host
  SetStatus( ST_COM_PC_OK );
  
#ifdef USE_SONDA
  // timer para controle de conexão do host
  serialPC_SondaTimer = GetTimer( SONDA_TIMEOUT );
#endif
  
  MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_HELLO );

  for ( i = sizeof( DWORD ) ; i ; i-- )
  {
    bufOut[ CMD_FIELD + (sizeof(DWORD) - (i - 1)) ] = ((BYTE*)&dwSerNum)[(i - 1)];
  } 

  enviarPacotePC( bufOut, sizeof( bufOut ));
}

NS_LogRelease(void* aPtr, nsrefcnt aRefcnt, const char* aClass)
{
#ifdef NS_IMPL_REFCNT_LOGGING
  ASSERT_ACTIVITY_IS_LEGAL;
  if (!gInitialized) {
    InitTraceLog();
  }
  if (gLogging == NoLogging) {
    return;
  }
  if (aRefcnt == 0 || gLogging == FullLogging) {
    LOCK_TRACELOG();

    if (aRefcnt == 0 && gBloatLog) {
      BloatEntry* entry = GetBloatEntry(aClass, 0);
      if (entry) {
        entry->Dtor();
      }
    }

    bool loggingThisType = (!gTypesToLog || LogThisType(aClass));
    intptr_t serialno = 0;
    if (gSerialNumbers && loggingThisType) {
      serialno = GetSerialNumber(aPtr, false);
      NS_ASSERTION(serialno != 0,
                   "Serial number requested for unrecognized pointer!  "
                   "Are you memmoving a refcounted object?");
      int32_t* count = GetRefCount(aPtr);
      if (count) {
        (*count)--;
      }

    }

    bool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
    if (gRefcntsLog && loggingThisType && loggingThisObject) {
      // Can't use PR_LOG(), b/c it truncates the line
      fprintf(gRefcntsLog,
              "\n<%s> %p %" PRIuPTR " Release %" PRIuPTR "\n",
              aClass, aPtr, serialno, aRefcnt);
      nsTraceRefcnt::WalkTheStackCached(gRefcntsLog);
      fflush(gRefcntsLog);
    }

    // Here's the case where MOZ_COUNT_DTOR was not used,
    // yet we still want to see deletion information:

    if (aRefcnt == 0 && gAllocLog && loggingThisType && loggingThisObject) {
      fprintf(gAllocLog, "\n<%s> %p %" PRIdPTR " Destroy\n", aClass, aPtr, serialno);
      nsTraceRefcnt::WalkTheStackCached(gAllocLog);
    }

    if (aRefcnt == 0 && gSerialNumbers && loggingThisType) {
      RecycleSerialNumberPtr(aPtr);
    }

    UNLOCK_TRACELOG();
  }
#endif
}

QVariant tNDP2kVirtualDeviceInfoParam::GetValueForNDP2k(const unsigned short paramID, const unsigned char destAddress, const unsigned char paramInstance) 
{ 
    Q_UNUSED(paramID);
    Q_UNUSED(destAddress);
    Q_UNUSED(paramInstance);

    QVariant value;

    switch(m_VirtualDeviceInfoParamType)
    {
        case eVirtualDeviceInfoParamType_ProductId :
            value = GetProductId();
            break;

        case eVirtualDeviceInfoParamType_SerialNumber :
            value = GetSerialNumber();
            break;

        case eVirtualDeviceInfoParamType_DeviceInstance :
            value = GetDeviceInstance();
            break;

        case eVirtualDeviceInfoParamType_SystemInstance :
            value = GetSysInstance();
            break;

        default :
            Assert(0);
            break;

    }

    return value;
}

NS_LogCtor(void* aPtr, const char* aType, uint32_t aInstanceSize)
{
#ifdef NS_IMPL_REFCNT_LOGGING
  ASSERT_ACTIVITY_IS_LEGAL;
  if (!gInitialized)
    InitTraceLog();

  if (gLogging) {
    LOCK_TRACELOG();

    if (gBloatLog) {
      BloatEntry* entry = GetBloatEntry(aType, aInstanceSize);
      if (entry) {
        entry->Ctor();
      }
    }

    bool loggingThisType = (!gTypesToLog || LogThisType(aType));
    intptr_t serialno = 0;
    if (gSerialNumbers && loggingThisType) {
      serialno = GetSerialNumber(aPtr, true);
    }

    bool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
    if (gAllocLog && loggingThisType && loggingThisObject) {
      fprintf(gAllocLog, "\n<%s> 0x%08X %ld Ctor (%d)\n",
             aType, NS_PTR_TO_INT32(aPtr), serialno, aInstanceSize);
      nsTraceRefcntImpl::WalkTheStack(gAllocLog);
    }

    UNLOCK_TRACELOG();
  }
#endif
}

vr::EVRInitError CHydraHmdLatest::Activate( uint32_t unObjectId )
{
	DriverLog( "CHydraHmdLatest::Activate: %s is object id %d\n", GetSerialNumber(), unObjectId );
	m_unSteamVRTrackedDeviceId = unObjectId;

	g_ServerTrackedDeviceProvider.LaunchHydraMonitor();

	return vr::VRInitError_None;
}

NS_LogAddRef(void* aPtr, nsrefcnt aRefcnt,
             const char* aClazz, uint32_t classSize)
{
#ifdef NS_IMPL_REFCNT_LOGGING
  ASSERT_ACTIVITY_IS_LEGAL;
  if (!gInitialized)
    InitTraceLog();
  if (gLogging) {
    LOCK_TRACELOG();

    if (gBloatLog) {
      BloatEntry* entry = GetBloatEntry(aClazz, classSize);
      if (entry) {
        entry->AddRef(aRefcnt);
      }
    }

    // Here's the case where MOZ_COUNT_CTOR was not used,
    // yet we still want to see creation information:

    bool loggingThisType = (!gTypesToLog || LogThisType(aClazz));
    intptr_t serialno = 0;
    if (gSerialNumbers && loggingThisType) {
      serialno = GetSerialNumber(aPtr, aRefcnt == 1);
      NS_ASSERTION(serialno != 0,
                   "Serial number requested for unrecognized pointer!  "
                   "Are you memmoving a refcounted object?");
      int32_t* count = GetRefCount(aPtr);
      if(count)
        (*count)++;

    }

    bool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));
    if (aRefcnt == 1 && gAllocLog && loggingThisType && loggingThisObject) {
      fprintf(gAllocLog, "\n<%s> 0x%08X %ld Create\n",
              aClazz, NS_PTR_TO_INT32(aPtr), serialno);
      nsTraceRefcntImpl::WalkTheStack(gAllocLog);
    }

    if (gRefcntsLog && loggingThisType && loggingThisObject) {
      if (gLogToLeaky) {
        (*leakyLogAddRef)(aPtr, aRefcnt - 1, aRefcnt);
      }
      else {
          // Can't use PR_LOG(), b/c it truncates the line
          fprintf(gRefcntsLog,
                  "\n<%s> 0x%08X %ld AddRef %d\n", aClazz, NS_PTR_TO_INT32(aPtr), serialno, aRefcnt);
          nsTraceRefcntImpl::WalkTheStack(gRefcntsLog);
          fflush(gRefcntsLog);
      }
    }
    UNLOCK_TRACELOG();
  }
#endif
}

/************************************************************************//**
 * \brief Disconnects this instance from an attached Manta
 ****************************************************************************/
void MantaUSB::Disconnect(void)
{
   if(! IsConnected())
   {
      return;
   }

   DebugPrint("%s-%d: Manta %d Disconnecting...", __FILE__, __LINE__, GetSerialNumber());
   hid_close(DeviceHandle);
   DeviceHandle = NULL;
}

/*------------------------------------------------------------------------------------

FUNCTION NAME: CheckHardwareMatch

DESCRIPTION:   Check hardware matching.

PARAMETERS:
  - INPUT
     - HARDWARE_ID_LIST  * pLicense
  - OUTPUT:

RETURN:
  - TRUE : hardware is found
  - FALSE : hardware is not found

NOTES:

------------------------------------------------------------------------------------*/
BOOL  CheckHardwareMatch (HARDWARE_ID_LIST  * pHardwareList)
{
  DWORD                   _logical_drivers;
  DWORD                   _mask_driver;
  DWORD                   _initial_mask_driver;
  char                    _drive_root [MAX_MGL_STRINGS];
  DWORD                   _serial_number;
  BOOL                    _rc_get_serial_number;
  BOOL                    _return_code;
  BYTE                    _idx_drive, _idx_hard;

  // If AnyHardware any hardware is included.
  if ( pHardwareList->AnyHardware )
  {
    return TRUE;
  }

  _return_code = FALSE;
  _logical_drivers = GetLogicalDrives ();

  _initial_mask_driver = 0x00000001;
  // Check all logical drivers founds.
  for ( _idx_drive = 0; _idx_drive < MAX_AVAILABLE_DRIVERS; _idx_drive ++ )
  {
    _mask_driver = _initial_mask_driver << _idx_drive;
    if ( _logical_drivers & _mask_driver )
    {
      sprintf (_drive_root, "%c:\\", 'A' + _idx_drive);
      _rc_get_serial_number  = GetSerialNumber (&_serial_number, _drive_root);

      if ( _rc_get_serial_number && _serial_number > 0 )
      {
        for ( _idx_hard = 0; _idx_hard < pHardwareList->NumberOfHardwares; _idx_hard ++ )
        {
          if ( _serial_number == pHardwareList->HardwareId [_idx_hard] )
          {
            _return_code = TRUE;
            break;
          }
        } /* end for */
      } /* end if */
      
      // If hardware found then exit function
      if ( _return_code )
      {
        break;
      }
    } /* end if */
  } /* end for */

  return _return_code;

} /* CheckHardwareMatch */

// HINT: This information remains static throughout the object's lifetime
inline VmbErrorType Interface::GetSerialNumber( std::string &rStrSerial ) const
{
    VmbErrorType res;
    VmbUint32_t nLength;

    res = GetSerialNumber( NULL, nLength );
    if ( VmbErrorSuccess == res )
    {
        if ( 0 < nLength )
        {
            rStrSerial.resize( nLength );
            res = GetSerialNumber( &rStrSerial[0], nLength );
        }
        else
        {
            rStrSerial.clear();
        }
    }

    return res;
}

int HostIO_CyUSB::OpenEx(CameraID cID)
{
	int		numDevs;
	USHORT	VID;
	USHORT	PID;
	bool	bFoundDevice = false;

	m_log->Write(2, _T("OpenEx name: %s"), cID.SerialToOpen.c_str());
	
	numDevs = cyusb_open();

	for (int i = 0; i < (int)numDevs; i++) 
	{
		h = cyusb_gethandle(i);
		VID = cyusb_getvendor(h);
		PID = cyusb_getproduct(h);

		std::string SerialNum = std::string("None");
		GetSerialNumber(SerialNum);
		std::string SerialToOpen = SerialNum;
		
		std::string Desc = std::string("None");
		GetDesc(Desc);

		m_log->Write(2, _T("Dev %d:"), i);
		m_log->Write(2, _T(" SerialNumber=%s"), SerialNum.c_str());
		m_log->Write(2, _T(" Description=%s"), Desc.c_str());

		if (VID == QSICyVID && PID == QSICyPID && SerialNum == cID.SerialToOpen )
		{
			m_log->Write(2, _T("USB Open found QSI Cy device at index: %d, Serial: %s, Description: %s"), 
							i, SerialNum.c_str(), Desc.c_str());
			bFoundDevice = true;
			break;
		}
	}
	
	if (bFoundDevice && cyusb_kernel_driver_active(h, 0) == 0 && cyusb_claim_interface(h, 0) == 0)
	{
		SetTimeouts(READ_TIMEOUT, WRITE_TIMEOUT);		
	}
	else
	{
		m_log->Write(2, "No devices matched");
	}

	m_log->Write(2, _T("OpenEx Done."));

	return bFoundDevice ? ALL_OK : ERR_USB_OpenFailed;
}

int main(void)
{
    dispBufferOn = ST_WR_FORE;

    GraphicsString(&Table);
    cputsxy(0, 3, CBOLDON "Your Serial Number is:");
    cputhex16(GetSerialNumber());

    DoMenu(&Menu);
    MainLoop();

    // will never reach this point...
    return 0;
}

// *****************************************************************************
void setup() {
  // Setup NMEA2000 system
  #ifndef ARDUINO
  setvbuf (stdout, NULL, _IONBF, 0); // No buffering on stdout, just send chars as they come.
  #endif

  #ifdef ARDUINO
  #ifdef N2kForward_Stream
  N2kForward_Stream.begin(N2kForward_Stream_Speed);
  #endif
  NMEA0183_Out_Stream.begin(NMEA0183_Out_Stream_Speed);
  delay(1000); // Give some time for serial to initialize
  #else
  #endif

  #ifdef N2kForward_Stream
  NMEA2000.SetForwardStream(&N2kForward_Stream);
  #endif

  char SnoStr[33];
  uint32_t SerialNumber=GetSerialNumber();
  snprintf(SnoStr,32,"%lu",(long unsigned int)SerialNumber);

  NMEA2000.SetProductInformation(SnoStr, // Manufacturer's Model serial code
                                 120, // Manufacturer's product code
                                 "N2k->NMEA0183",  // Manufacturer's Model ID
                                 "1.0.0.1 (2018-04-03)",  // Manufacturer's Software version code
                                 "1.0.0.0 (2018-04-03)" // Manufacturer's Model version
                                 );
  // Det device information
  NMEA2000.SetDeviceInformation(SerialNumber, // Unique number. Use e.g. Serial number.
                                130, // Device function=PC Gateway. See codes on http://www.nmea.org/Assets/20120726%20nmea%202000%20class%20%26%20function%20codes%20v%202.00.pdf
                                25, // Device class=Inter/Intranetwork Device. See codes on http://www.nmea.org/Assets/20120726%20nmea%202000%20class%20%26%20function%20codes%20v%202.00.pdf
                                2046 // Just choosen free from code list on http://www.nmea.org/Assets/20121020%20nmea%202000%20registration%20list.pdf
                               );

  NMEA2000.SetForwardType(tNMEA2000::fwdt_Text); // Show in clear text. Leave uncommented for default Actisense format.
  NMEA2000.SetMode(tNMEA2000::N2km_ListenAndNode,25);
  //NMEA2000.EnableForward(false);

  NMEA2000.ExtendTransmitMessages(TransmitMessages);
  NMEA2000.ExtendReceiveMessages(ReceiveMessages);
  NMEA2000.AttachMsgHandler(&N2kDataToNMEA0183);

  NMEA2000.Open();

  // Setup NMEA0183 ports and handlers
  NMEA0183_Out.SetMessageStream(&NMEA0183_Out_Stream);
  NMEA0183_Out.Open();
}

int test2() {

  try {
    TiePieHS3 adc;
    dword serialno;
    word retval=GetSerialNumber(&serialno);
    if (retval!=NO_ERROR) throw ADC_exception("could not get serialno");
    printf("serial number %d\n", serialno);
  }
  catch (ADC_exception e) {
    printf("ADC exception: %s\n", e.c_str());
    return 1;
  }
  return 0;
}

std::string ID::GenerateId()
{
	std::string id1,id2;
	std::string MAC = GetMac();
	std::string SerialNumber = GetSerialNumber();
	std::string MAC_hash =KeyGen::GetMD5(MAC);
	//std::string SerialNumber_hash = GetSHA256(SerialNumber);

	//std::cout << "key-part1: " << GetIDPart1(MAC_hash, MAC) << std::endl;
	id1 = GetIDPart1(MAC_hash, MAC);
	id2 = GetIDPart2(SerialNumber);
	std::string id = id1;
	id += id2;
	//std::cout << "ID:" << id << std::endl;

	_number= id;
	return id;
}

TiePieHS3::TiePieHS3() {
  if (1!=OpenDLL(dtHandyscope3)){
    throw ADC_exception("could not find driver dll for HS3!");
  }
  if (NO_ERROR!=InitInstrument(0)) {
    ADC_exception("HS3 not available!");
  }
  unsigned int serialno=0;
  unsigned short int retval=GetSerialNumber(&serialno);
  //fprintf(stderr, "sizeof(unsigned int)=%d, sizeof(unsigned short int)=%d\n", sizeof(serialno), sizeof(retval));
  if (NO_ERROR!=retval) {
    char buffer[256];
    snprintf(buffer, sizeof(buffer), "could not get device's serial number: GetSerialNumber returned %d", retval);
    throw ADC_exception(std::string(buffer));
  }
  fprintf(stderr, "successfully initialized HS3, SN=%d\n",serialno);
  trigger_line_id=0;
  trigger_line_mask=1<<2;
}

NS_LogCOMPtrRelease(void* aCOMPtr, nsISupports* aObject)
{
#if defined(NS_IMPL_REFCNT_LOGGING) && defined(HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR)
  // Get the most-derived object.
  void* object = dynamic_cast<void*>(aObject);

  // This is a very indirect way of finding out what the class is
  // of the object being logged.  If we're logging a specific type,
  // then
  if (!gTypesToLog || !gSerialNumbers) {
    return;
  }
  intptr_t serialno = GetSerialNumber(object, false);
  if (serialno == 0) {
    return;
  }

  if (!gInitialized) {
    InitTraceLog();
  }
  if (gLogging == FullLogging) {
    LOCK_TRACELOG();

    int32_t* count = GetCOMPtrCount(object);
    if (count) {
      (*count)--;
    }

    bool loggingThisObject = (!gObjectsToLog || LogThisObj(serialno));

    if (gCOMPtrLog && loggingThisObject) {
      fprintf(gCOMPtrLog, "\n<?> %p %" PRIdPTR " nsCOMPtrRelease %d %p\n",
              object, serialno, count ? (*count) : -1, aCOMPtr);
      nsTraceRefcnt::WalkTheStackCached(gCOMPtrLog);
    }

    UNLOCK_TRACELOG();
  }
#endif
}