Exemplo n.º 1
0
CPMALError CPIM::generatePIUID(iviLink::CUid const& profileUid,
      iviLink::Service::Uid const& serviceUID,
      iviLink::Profile::IUid & piuid)
{
   bool remote = false;

   mIncomingPrfMapMutex.lock();
   {
      if (!mIncomingPrfMap.empty())
      {
         tIncomingPrfMap::iterator it = mIncomingPrfMap.find(std::make_pair(serviceUID, profileUid));
         if (it != mIncomingPrfMap.end())
         {
            piuid = it->second;
            mIncomingPrfMap.erase(it);
            remote = true;
         }
      }
   }
   mIncomingPrfMapMutex.unlock();

   if (remote)
      return CPMALError::NoPMALError(gModuleName);

   CError err = PIM::getPIUID(piuid);
   if (!err.isNoError())
   {
      LOG4CPLUS_ERROR(logger, static_cast<std::string>(err));
      return CPMALError(CPMALError::ERROR_PIM_INTERNAL, gModuleName, "no piuid");
   }

   return CPMALError::NoPMALError(gModuleName);
}
Exemplo n.º 2
0
BOOL CFolderDialog::DoModal(HWND hWnd, LPCTSTR lpszTitle, LPTSTR pDir)
{
	BROWSEINFO bi = {};
	bi.hwndOwner = hWnd;
	bi.lpfn = reinterpret_cast<BFFCALLBACK>(BrowseCallBackProc);
	bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI;
	bi.lParam = reinterpret_cast<LPARAM>(pDir);
	bi.lpszTitle = lpszTitle;

	LPITEMIDLIST pItemID = SHBrowseForFolder(&bi);
	if (pItemID == nullptr)
		return FALSE;

	LPMALLOC pMalloc = nullptr;
	if (SHGetMalloc(&pMalloc) == E_FAIL)
	{
		CError error;
		error.Message(hWnd, _T("SHGetMalloc Error"));
		return FALSE;
	}

	SHGetPathFromIDList(pItemID, pDir);

	pMalloc->Free(pItemID);
	pMalloc->Release();

	return TRUE;
}
Exemplo n.º 3
0
void CPIM::unloadAll()
{
   LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
   typedef PIM::CProfileInstanceMap::tProfilesList PL;
   PL profiles;
   CError err = mInstanceMap.getAllRegisterd(profiles);
   if (!err.isNoError())
   {
      LOG4CPLUS_ERROR(logger, static_cast<std::string>(err));
      return;
   }

   IProfileManagerCallbacks* clbs = NULL;
   CPMALComponentMgr* mgr = CPMALComponentMgr::getInstance();
   if (mgr)
   {
      clbs = mgr->getProfileManagerCallbacks();
   }

   for (PL::iterator it = profiles.begin(); it != profiles.end(); ++it)
   {
      Profile::IUid const& piuid = it->first;
      Profile::CProfile* pp = static_cast<Profile::CProfile*>(it->second);

      unloadProfileThroughClient(clbs, pp, piuid);
   }
}
Exemplo n.º 4
0
// ** When an exception is thrown, execution of the current function is stopped and 
// jumps directly to the catch block of the innermost exception frame. The 
// exception mechanism bypasses the normal exit path from a function. Therefore, 
// you must be sure to delete those memory blocks that would be deleted in a 
// normal exit. 
// static
void Library::ThrowAssertion(LPCSTR lpszFilename, int nLine, 
				LPCSTR lpszExpression, LPCSTR lpszError/*=NULL*/)
{
//	CAppException* pe = new CAppException(TRUE); // pass true if creating on the heap
	// Bug: can't just copy LPCTSTR pointer to string, because it might be a temporary object.
	// The error message was getting overwritten with FE EE's and didn't know what was going on - 
	// a CString was being passed here and then going out of scope because of the throw - 
	// so use strcpy or CStrings
//	pe->m_pszError = pszError; // store error message
//	pe->m_strError = "Assertion Failed";
//	throw pe;

//	CError e(_T("Assertion Failed"), TRUE);
//	e.SetFileLocation(lpszFilename, nLine, lpszExpression);
//	HandleError(e);

//	CError e(FALSE); // false because created on the stack
//	e.SetName(_T("Assertion Failed"));
//	e.SetSeverity(TRUE);
//	e.SetFileLocation(lpszFilename, nLine, lpszExpression);
//	throw &e;
	CError* pe = new CError(TRUE);
	if (lpszError==NULL)
		pe->SetName(_T("Assertion Failed"));
	else
		pe->SetName(lpszError);
	pe->SetSeverity(TRUE);
	pe->SetFileLocation(lpszFilename, nLine, lpszExpression);
	throw pe;
}
Exemplo n.º 5
0
	void InitModule()
	{
        g_pErrorCS = NULL;
        g_pModulesCS = NULL;        
        g_pModules = NULL;
        g_pLocModules = NULL;
        g_pLocDlls = NULL;
        g_pNoMemoryError = NULL;
        ;
		::KLSTD_CreateCriticalSection(&g_pModulesCS);
        g_pErrorCS = g_pModulesCS;
        ;
        g_pModules = new modules_t(c_nModulesHashSize);
        g_pLocModules = new modules_t(c_nModulesHashSize);
        g_pLocDlls = new map_locmodules_t(c_nModulesHashSize);
        ;
        {
            KLSTD::CAutoPtr<Error> pError;
            CError* p = NULL;
            pError.Attach(p = new RcClassImpl<CError>);
            if(p)
            {
                p->Initialize(
                            0, 
                            L"KLSTD", 
                            STDE_NOMEMORY, 
                            NULL, 
                            0, 
                            L"Out Of memory", 
                            true);
		        g_pNoMemoryError = pError;
            };
        };
	};
void CMediaControlServerProfile::onDisable() {
    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__);
    CError err = iviLink::Channel::deallocateChannel(mChannelID);
    if (!err.isNoError()) {
        LOG4CPLUS_WARN(msLogger, "Unable to deallocate channel: " + static_cast<std::string> (err));
    }
}
Exemplo n.º 7
0
std::tuple<OrmId_t, Orm_t> COrmManager::Create(
	HandleId_t handleid, const char *table,
	CError<COrm> &error)
{
	static const std::tuple<OrmId_t, Orm_t> empty_ret(0, nullptr);

	if (CHandleManager::Get()->IsValidHandle(handleid) == false)
	{
		error.set(COrm::Error::INVALID_CONNECTION_HANDLE, "invalid connection handle");
		return empty_ret;
	}
		
	if (table == nullptr || strlen(table) == 0)
	{
		error.set(COrm::Error::EMPTY_TABLE, "empty table name");
		return empty_ret;
	}


	OrmId_t id = 1;
	while (m_Instances.find(id) != m_Instances.end())
		++id;

	return std::make_tuple(id, std::make_shared<COrm>(handleid, table));
}
Exemplo n.º 8
0
LPVOID CFileMap::Open(HANDLE hFile, DWORD Mode)
{
	// Create a file mapping object.
	if (Mode == FILE_READ)
		m_hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
	else if (Mode == FILE_WRITE)
		m_hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL);

	if (m_hFileMap == INVALID_HANDLE_VALUE)
	{
		CError error;
		error.Message(GetForegroundWindow(), _T("File mapping error."));
		return NULL;
	}

	// Get start address of the map view.
	if (Mode == FILE_READ)
		m_lpFileMapBase = MapViewOfFile(m_hFileMap, FILE_MAP_READ, 0, 0, 0);
	else if (Mode == FILE_WRITE)
		m_lpFileMapBase = MapViewOfFile(m_hFileMap, FILE_MAP_WRITE, 0, 0, 0);

	if (m_lpFileMapBase == NULL)
	{
		CError error;
		error.Message(GetForegroundWindow(), _T("File mapping error."));
		return NULL;
	}
	m_lpFileMap = m_lpFileMapBase;

	return m_lpFileMapBase;
}
CConnectivityAgentProxy::CConnectivityAgentProxy()
		: CThread("CallbackTread"), mpIpc(NULL)
{
	LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
	static char const* const arr[] =
	{ gpCA_UNIX_SOCK_PATH, first_lsn_path, second_lsn_path };

	for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
	{
		if (arr[i])
		{
			LOG4CPLUS_INFO(logger,
					"Trying to connect to connectivity agent using address " + std::string(arr[i]));
			CIpc* pipc = new CIpc(arr[i], *this);
			CError err = pipc->connect();
			if (err.isNoError())
			{
				mpIpc = pipc;
				break;
			} else
			{
				LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
				delete pipc;
			}
		}
	}

	if (!mpIpc)
	{
		LOG4CPLUS_ERROR(logger, "Unable to connect to connectivity agent");
	}

	start();
}
Exemplo n.º 10
0
    bool connect()
    {
        CError err = CError::NoError();
        if (mpIpc == NULL)
        {
            char const * addr;
            if (gpNEGOTIATOR_IPC_ADDR != NULL)
            {
                addr = gpNEGOTIATOR_IPC_ADDR;
            } else
            {
                addr = ipcNegotiatorId;
            }
            mpIpc = new CIpc(addr, *this);
        }
        for (int tryNum = 1; tryNum <= MAX_TRY_COUNT; ++tryNum)
        {
            err = mpIpc->connect();
            if (err.isNoError())
            {
                return true;
            }

            sleep(2);
        }
        return false;
    }
Exemplo n.º 11
0
 int CProfileRepoServerClb::loop()
 {
    CError err = CError::NoError("ProfileRepository","loop");
    for (int i = 1; ; ++i)
    {
       LOG4CPLUS_INFO(msLogger, "CProfileRepoServerClb::loop() : connection try number: "+
             convertIntegerToString(i));
       err = mpIpc->waitForConnection();
       LOG4CPLUS_INFO(msLogger, "CProfileRepoServerClb::loop() : waitForConnectionEnded()");
       if (err.isNoError())
       {
          LOG4CPLUS_INFO(msLogger,"CProfileRepoServerClb::loop() :: *** client connected to server ***");
          mConLostSem.wait();
          LOG4CPLUS_INFO(msLogger,"CProfileRepoServerClb::loop() :: *** connection lost, exiting ***");
          return 0;
       }
       else
       {
          LOG4CPLUS_INFO(msLogger, static_cast<std::string>(err));
       }
       LOG4CPLUS_INFO(msLogger, "failed connection");
       usleep (250000);
    }
    return 0;
 }
Exemplo n.º 12
0
      void CPmpProtocol::connect()
      {
         LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__ );
         while (mBe)
         {
            LOG4CPLUS_INFO(msLogger, "connect attempt");
            UInt32 chid = 0;
            CError err = iviLink::ChannelSupervisor::allocateChannel(this,mTag.c_str(), chid);
            if (err.isNoError())
            {
               mChannelIdCond.lock();
               LOG4CPLUS_INFO(msLogger, "ok chid = " +
                     convertIntegerToString(static_cast<int>(chid)));
               mChannelId = chid;
               mChannelIdCond.broadcast();
               mChannelIdCond.unlock();

               mConnectionLostSem.wait();
            }
            else
            {
               LOG4CPLUS_INFO(msLogger, static_cast<std::string>(err));
               sleep(1);
            }
         }
      }
Exemplo n.º 13
0
void CErrLogMgr::WriteErrLog(CError& exp)
{
	if ( !CatchErrorEnabled() || !ErrLogEnabled() )
	{
		puts(exp.ErrorTitle());
		if( exp.ErrorMsg()[0] )
		{
			putchar('\t');
			puts(exp.ErrorMsg());
			putchar('\n');
		}
	}
	else
	{
		uint64 uCurTime = GetProcessTime();

		//如果两次记录log的时间大于interval,我们就要换一个log来记录了
		//如果小于这个值,我们仍然使用原来的文件记录
		if(uCurTime - m_uLastLogTime > (uint64)m_uInterval)
		{
			CErrLogThreadMgr::Inst()->AddCloseErrlogJob();
			CreateErrLogFile();
		}
		CErrLogThreadMgr::Inst()->AddWriteErrlogJob(exp,m_strErrInfo.c_str());
		m_uLastLogTime = uCurTime;
	}
}
Exemplo n.º 14
0
    KLSTD_NOTHROW KLERR::ErrorPtr CreateError(
            const ErrLocAdapt*  pLocInfo,
		    const wchar_t*	    szwModule,
		    int				    nId,
		    const char*		    szaFile, 
		    int				    nLine,
		    const wchar_t*	    szwMessage) throw()
    {
        KLSTD::CAutoPtr<KLERR::Error> pResult;
	    try
        {
		    CError* p = NULL;        
            pResult.Attach(p = new CError);
            if(p)
            {
                p->Initialize(0, szwModule, nId, szaFile, nLine, szwMessage);
                if(pLocInfo)
                    p->LocSetInfo(*pLocInfo);
            };
        }
        catch(std::exception& err)
        {
            KLERR_TRACE_UNEXPECTED();
        };
	    if(!pResult)
		    pResult = KLERR::g_pNoMemoryError;
	    if(!pResult)
		    abort();
        return pResult;
    };
Exemplo n.º 15
0
 void CAppManPmpIpcClient::loop()
 {
    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__);
    mBe = true;
    CError err = CError::NoError("","");
    for (int i = 1;mBe ; ++i)
    {
       LOG4CPLUS_INFO(msLogger, "loop() : connect trying number : " + convertIntegerToString(i));
       err = mpIpc->connect();
       LOG4CPLUS_INFO(msLogger, "loop() : connect ended");
       if (mBe && err.isNoError())
       {
          mNoConnection = false;
          mConLostSem.wait();
          mNoConnection = true;
       }
       if (!mBe)
       {
          LOG4CPLUS_INFO(msLogger, "loop() :: mBe == false");
          break;
       }
       LOG4CPLUS_WARN(msLogger, "loop() :: connection failed");
       usleep(250000);
    }
 }
Exemplo n.º 16
0
 void CProfileRepoServerClb::addProfile(const RepoRequest * req, UInt32 payloadSize, UInt8* const pResponseBuffer, UInt32& bufferSize)
 {
    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__ );
    CError err = mProfileDB.addProfile(bufferToString(req->data));
    UInt32 code = err.getCode();
    memcpy (pResponseBuffer, &code,4);
    bufferSize = 4;
 }
Exemplo n.º 17
0
void CClimateClientProfile::onDisable()
{
   CError err = iviLink::Channel::deallocateChannel(mChannelID);
   if (!err.isNoError())
   {
      LOG4CPLUS_WARN(msLogger, "Unable to deallocate channel: " + static_cast<std::string>(err));
   }
}
Exemplo n.º 18
0
void CSourceFilesProcessor::Error( const CError& error )
{
	std::cerr << error.UserMessage() << std::endl;
	if( error.Severity() == ES_FatalError ) {
		file.clear( std::ios_base::eofbit );
		std::cin.clear( std::ios_base::eofbit );
	}
}
Exemplo n.º 19
0
 CError write(std::pair<K, V> const& val)
 {
    CError err = write(val.first);
    if (!err.isNoError())
       return err;
    err = write(val.second);
    if (!err.isNoError())
       return err;
    return CError::NoError(moduleName);
 }
Exemplo n.º 20
0
 CError read(std::pair<K, V> & val)
 {
    CError err = read(val.first);
    if (!err.isNoError())
       return err;
    err = read(val.second);
    if (!err.isNoError())
       return err;
    return CError::NoError(moduleName);
 }
Exemplo n.º 21
0
void ReceiverProfile<T,I>::onDisable()
{
    LOG4CPLUS_TRACE_METHOD( (logger<T,I>()), __PRETTY_FUNCTION__ );
    CError err = iviLink::Channel::deallocateChannel(mChannelID);
    if (!err.isNoError())
    {
        LOG4CPLUS_ERROR((logger<T,I>()), "Unable to deallocate channel: " + static_cast<std::string>(err));
    }
    else
        mChannelID = 0;
}
void CMediaControlServerProfile::onChannelDeleted(const UInt32 channel_id) {
    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__);

    if (mChannelID == channel_id)
        mChannelID = 0;

    CError err = iviLink::Channel::deallocateChannel(channel_id);
    if (!err.isNoError()) {
        LOG4CPLUS_WARN(msLogger, "Unable to deallocate channel: " + static_cast<std::string> (err));
    }
}
Exemplo n.º 23
0
 void CProfileRepoServerClb::removeProfileImplementationPl(const RepoRequest * req, UInt32 payloadSize, UInt8* const pResponseBuffer, UInt32& bufferSize)
 {
    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__ );
    UID uid(bufferToString(req->data));
    int pos = stringInBufSize(uid.value);
    std::string platform = bufferToString(req->data + pos);
    CError err = mProfileDB.removeProfileImplementation(uid,platform);
    UInt32 code = err.getCode();
    memcpy (pResponseBuffer, &code, 4);
    bufferSize = 4;
 }
Exemplo n.º 24
0
CError CBufferWriter::write<std::string>(std::string const& val)
{
   UInt32 valSize = val.size();
   CError err = write(valSize);
   if (!err.isNoError())
      return err;
   if (valSize > mFullSize - mUsedSize)
      return CError(1, moduleName, CError::ERROR, "insufficient buffer size (from std::string write)");

   memcpy(mpBuffer + mUsedSize, val.c_str(), valSize);
   mUsedSize += valSize;
   return CError::NoError(moduleName);
}
CError CUndefinedReferenceValidator::Validate(C_FUNCTION_SYNTAX& syntax, C_CONTEXT& context) const
{
  CError result;

  if (!ValidateReference(syntax.GetLiveNamespace(), syntax.GetName(), EIdentifierType::Function, context))
  {
    result.SetSource(EErrorSource::Producing);
    result.SetLiveLine(syntax.GetLiveLine());
    result.SetDescription(CWStringTemplate(L"Funtion:'%x' has not been defined").Format(syntax.GetName()));
  }

  return move(result);
}
Exemplo n.º 26
0
void ReceiverProfile<T,I>::onChannelDeleted(const UInt32 channel_id)
{
    LOG4CPLUS_TRACE_METHOD((logger<T,I>()), __PRETTY_FUNCTION__ );

    if (mChannelID == channel_id)
        mChannelID = 0;

    CError err = iviLink::Channel::deallocateChannel(channel_id);
    if (!err.isNoError())
    {
        LOG4CPLUS_WARN((logger<T,I>()), "Unable to deallocate channel: " + static_cast<std::string>(err));
    }
}
Exemplo n.º 27
0
    void sendMessage(UInt8 const* pPayload, UInt32 payloadSize, UInt8* const pResponseBuffer,
            UInt32& bufferSize)
    {
        bool con_res = connect();
        assert(con_res);

        CError err = mpIpc->request(id++, pPayload, payloadSize, pResponseBuffer, bufferSize);
        if (err.isNoError())
        {
        } else
        {
        }
        mpIpc->disconnect();
    }
Exemplo n.º 28
0
 void CProfileRepoServerClb::addProfileImplementation(const RepoRequest * req, UInt32 payloadSize, UInt8* const pResponseBuffer, UInt32& bufferSize)
 {
    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__ );
    UID uid(bufferToString(req->data));
    int pos = stringInBufSize(uid.value);
    iviLink::LibDescriptor ld;
    ld.libPath = bufferToString(req->data + pos);
    pos += stringInBufSize(ld.libPath);
    ld.platform = bufferToString(req->data + pos);
    CError err = mProfileDB.addProfileImplementation(uid,ld);
    UInt32 code = err.getCode();
    memcpy (pResponseBuffer, &code, 4);
    bufferSize = 4;
 }
Exemplo n.º 29
0
CError CBufferReader::read<std::string>(std::string & val)
{
   UInt32 valSize = 0;
   CError err = read(valSize);
   if (!err.isNoError())
      return err;
   if (valSize > mFullSize - mUsedSize)
      return CError(1, moduleName, CError::ERROR, "insufficient buffer size (from std::string write)");

   val.assign(reinterpret_cast<char const*>(mpBuffer + mUsedSize), valSize);
   mUsedSize += valSize;

   return err;
}
CError CNullUnaryOperationValidator::Validate(C_OPERATION_SYNTAX& syntax, C_CONTEXT& context) const
{
  CError result;

  if (syntax.GetRightOperandID() == NONE_ID)
  {
    result.SetSource(EErrorSource::Producing);
    result.SetLiveLine(syntax.GetLiveLine());
    result.SetDescription(CWStringTemplate(L"operand of operation:'%x' is invalid").
                          Format(COperationTypeEnum(syntax.GetOperationType()).ToString()));
  }

  return move(result);
}