BOOL CFileVersionInfo::QueryStringValue( IN LPCTSTR lpszItem, OUT LPTSTR lpszValue, IN INT nBuf ) const { if( m_bValid == FALSE || lpszItem == NULL ) ASSERT_RETURN( FALSE ); if( lpszValue != NULL && nBuf <= 0 ) ASSERT_RETURN( FALSE ); ::ZeroMemory( lpszValue, nBuf * sizeof( TCHAR ) ); TCHAR szSFI[ MAX_PATH ] = { 0 }; ::wsprintf( szSFI, _T( "\\StringFileInfo\\%04X%04X\\%s" ), GetCurLID(), GetCurCP(), lpszItem ); BOOL bRes = FALSE; UINT uLen = 0; LPTSTR lpszBuf = NULL; if( ::VerQueryValue( m_lpbyVIB, (LPTSTR)szSFI, (LPVOID*)&lpszBuf, &uLen ) ) { if( lpszValue != NULL && nBuf > 0 ) bRes = (BOOL)( ::lstrcpyn( lpszValue, lpszBuf, nBuf ) != NULL ); else bRes = TRUE; } return ( bRes ); }
int kdbus_test_sync_reply(struct kdbus_test_env *env) { pthread_t thread; int ret; conn_a = kdbus_hello(env->buspath, 0, NULL, 0); conn_b = kdbus_hello(env->buspath, 0, NULL, 0); ASSERT_RETURN(conn_a && conn_b); pthread_create(&thread, NULL, run_thread, NULL); ret = kdbus_msg_send(conn_b, NULL, cookie, KDBUS_MSG_FLAGS_EXPECT_REPLY | KDBUS_MSG_FLAGS_SYNC_REPLY, 5000000000ULL, 0, conn_a->id); pthread_join(thread, NULL); ASSERT_RETURN(ret == 0); kdbus_printf("-- closing bus connections\n"); kdbus_conn_free(conn_a); kdbus_conn_free(conn_b); return TEST_OK; }
bool KBagManager::AddOneCell( const SC_BagAddResponse* pBAR ) { ASSERT_RETURN(pBAR, false); int nBagID = pBAR->byteBagID; KBag* pBag = FindBag(nBagID); ASSERT_RETURN(pBag, false); KItem item; item.Clear(); KMsgInputStream si(pBAR->GetItemBuffer(), pBAR->nItemBufferSize); if(!item.Unserilize(si)) { return false; } if(!pBag->AddOneCell(pBAR->nPos, item)) { return false; } pBag->NumChange(item.GetID(), item.GetStackNumber()); // 通知界面 int nBoxID = BagId2BoxID(nBagID); ASSERT_RETURN(-1 != nBoxID, false); KItemBlock* pIB = KItemBlock::Alloc(); pIB->SetPos(nBoxID, pBAR->nPos); KBlockBoxManager::Instance()->PutBlock(nBoxID, pBAR->nPos, pIB); if (nBagID == enum_item_BagNormal) { KDynamicWorld::getSingleton().SendWorldMsg(LOGIC_WORLD_NORMAL_BAG_ITEM_CHANGE, item.GetID(), 0); } return true; }
bool KBagManager::IsValidCell( int nBoxId, int nPos ) const { int nBagId = BoxID2BagID(nBoxId); ASSERT_RETURN(nBagId >= enum_item_Bag_Start, false); const KBag* pBag = FindBag(nBagId); ASSERT_RETURN(pBag, false); return pBag->IsPosValid(nPos); }
int KBagManager::GetItemPosition(int nBoxId, DWORD dwItemID) const { int nBagId = BoxID2BagID(nBoxId); ASSERT_RETURN(nBagId >= enum_item_Bag_Start, -1); const KBag* pBag = FindBag(nBagId); ASSERT_RETURN(pBag, -1); return pBag->GetFirstPos(dwItemID); }
int KBagManager::GetItemCountByID( DWORD dwItemID ) const { ASSERT_RETURN(dwItemID > 0, 0); const KCreateInfo_ItemBase* pCIIB = GetItemCreateInfo(dwItemID); ASSERT_RETURN(pCIIB, 0); int nBag = GetBagTypeByItemType(pCIIB->GetItemType()); ASSERT_RETURN(nBag >= 0, 0); return GetItemCountByID(nBag, dwItemID); }
int kdbus_test_fd_passing(struct kdbus_test_env *env) { struct kdbus_conn *conn_src, *conn_dst; const char *str = "stackenblocken"; const struct kdbus_item *item; struct kdbus_msg *msg; unsigned int i; int fds[2]; int ret; /* create two connections */ conn_src = kdbus_hello(env->buspath, 0, NULL, 0); conn_dst = kdbus_hello(env->buspath, 0, NULL, 0); ASSERT_RETURN(conn_src && conn_dst); /* * Try to ass the handle of a connection as message payload. * This must fail. */ ret = send_fd(conn_src, conn_dst->id, conn_src->fd); ASSERT_RETURN(ret == -ELOOP); ret = send_fd(conn_src, conn_dst->id, conn_dst->fd); ASSERT_RETURN(ret == -ELOOP); ret = pipe(fds); ASSERT_RETURN(ret == 0); i = write(fds[1], str, strlen(str)); ASSERT_RETURN(i == strlen(str)); ret = send_fd(conn_src, conn_dst->id, fds[0]); ASSERT_RETURN(ret == 0); ret = kdbus_msg_recv(conn_dst, &msg); ASSERT_RETURN(ret == 0); KDBUS_ITEM_FOREACH(item, msg, items) { if (item->type == KDBUS_ITEM_FDS) { char tmp[14]; int nfds = (item->size - KDBUS_ITEM_HEADER_SIZE) / sizeof(int); ASSERT_RETURN(nfds == 1); i = read(item->fds[0], tmp, sizeof(tmp)); ASSERT_RETURN(i == sizeof(tmp)); ASSERT_RETURN(memcmp(tmp, str, sizeof(tmp)) == 0); close(item->fds[0]); break; } } return TEST_OK; }
bool KL2Map_Base::_InsertJointToBlock(const _Node_Lite * pNode) { PERF_COUNTER(KL2Map_Base__InsertJointToBlock); ASSERT_RETURN(pNode, false); int_r bx(-1), by(-1); GetJointBlockPos(pNode->x, pNode->y, bx, by); ASSERT_RETURN(bx >= 0, false); ASSERT_RETURN(by >= 0, false); return m_L2MapByBlock[bx][by].insert_unique(pNode) > -1; }
static int unpriv_test_custom_ep(const char *buspath) { int ret, ep_fd1, ep_fd2; char *ep1, *ep2, *tmp1, *tmp2; tmp1 = strdup(buspath); tmp2 = strdup(buspath); ASSERT_RETURN(tmp1 && tmp2); ret = asprintf(&ep1, "%s/%u-%s", dirname(tmp1), getuid(), "apps1"); ASSERT_RETURN(ret >= 0); ret = asprintf(&ep2, "%s/%u-%s", dirname(tmp2), getuid(), "apps2"); ASSERT_RETURN(ret >= 0); free(tmp1); free(tmp2); /* endpoint only accessible to current uid */ ep_fd1 = create_endpoint(buspath, getuid(), "apps1", 0); ASSERT_RETURN(ep_fd1 >= 0); /* endpoint world accessible */ ep_fd2 = create_endpoint(buspath, getuid(), "apps2", KDBUS_MAKE_ACCESS_WORLD); ASSERT_RETURN(ep_fd2 >= 0); ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({ int ep_fd; struct kdbus_conn *ep_conn; /* * Make sure that we are not able to create custom * endpoints */ ep_fd = create_endpoint(buspath, getuid(), "unpriv_costum_ep", 0); ASSERT_EXIT(ep_fd == -EPERM); /* * Endpoint "apps1" only accessible to same users, * that own the endpoint. Access denied by VFS */ ep_conn = kdbus_hello(ep1, 0, NULL, 0); ASSERT_EXIT(!ep_conn && errno == EACCES); /* Endpoint "apps2" world accessible */ ep_conn = kdbus_hello(ep2, 0, NULL, 0); ASSERT_EXIT(ep_conn); kdbus_conn_free(ep_conn); _exit(EXIT_SUCCESS); }),
bool KBagManager::UpdateCellLock(const SC_BagCellUpdateLock* pBCUL) { ASSERT_RETURN(pBCUL, false); KCellBag* pCell = FindCell(pBCUL->byteBagID, pBCUL->nPos); ASSERT_RETURN(pCell, false); pCell->SetLock(pBCUL->nLockType); // TODO: 通知UI return true; }
static int kdbus_match_kdbus_pids(struct kdbus_msg *msg, const struct kdbus_pids *expected_pids) { struct kdbus_item *item; item = kdbus_get_item(msg, KDBUS_ITEM_PIDS); ASSERT_RETURN(item); ASSERT_RETURN(memcmp(&item->pids, expected_pids, sizeof(struct kdbus_pids)) == 0); return 0; }
int KBagManager::GetFrequency( int nBoxId, int nPos ) const { int nBagId = BoxID2BagID(nBoxId); ASSERT_RETURN(nBagId >= enum_item_Bag_Start, 0); const KBag* pBag = FindBag(nBagId); ASSERT_RETURN(pBag, 0); const KCellBag* pCell = pBag->FindCell(nPos); if(NULL == pCell) { return 0; } const KItem& item = pCell->GetItem(); return item.GetFrequency(); }
std::vector<std::wstring> NppInterface::GetOpenFilenames(ViewTarget viewTarget) const { int enumVal = -1; switch (viewTarget) { case ViewTarget::primary: enumVal = PRIMARY_VIEW; break; case ViewTarget::secondary: enumVal = SECOND_VIEW; break; case ViewTarget::both: enumVal = ALL_OPEN_FILES; break; } ASSERT_RETURN(enumVal >= 0, {}); int count = SendMsgToNpp(NPPM_GETNBOPENFILES, 0, enumVal); wchar_t** paths; paths = new wchar_t *[count]; for (int i = 0; i < count; ++i) paths[i] = new wchar_t[MAX_PATH]; int msg = -1; switch (viewTarget) { case ViewTarget::primary: msg = NPPM_GETOPENFILENAMESPRIMARY; break; case ViewTarget::secondary: msg = NPPM_GETOPENFILENAMESSECOND; break; case ViewTarget::both: msg = NPPM_GETOPENFILENAMES; break; } ASSERT_RETURN(msg >= 0, {}); { auto ret = SendMsgToNpp(msg, reinterpret_cast<WPARAM>(paths), count); ASSERT_RETURN(ret == count, {}); } std::vector<std::wstring> res; for (int i = 0; i < count; ++i) { res.push_back(paths[i]); delete[] paths[i]; } delete[] paths; return res; }
const KCreateInfo_ItemBase* KBagManager::GetOneItemCreateInfoBase( int nBagID, DWORD dwItemID ) { const KBag* pBag = FindBag(nBagID); ASSERT_RETURN(pBag, NULL); int nPos = pBag->GetFirstPos(dwItemID); ASSERT_RETURN(nPos >= 0, NULL); const KCellBag* pCell = pBag->FindCell(nPos); ASSERT_RETURN(pCell, NULL); const KItem& item = pCell->GetItem(); ASSERT_I(item.GetID() == dwItemID); return GetItemCreateInfo(dwItemID); }
bool KBagManager::_AddBagList(KBag* pAddBag) { ASSERT_RETURN(pAddBag, false); int nBagID = pAddBag->GetBagID(); ASSERT_RETURN(nBagID >= 0, false); KBag* pFindBag = FindBag(nBagID); if(NULL == pFindBag) { m_listBag[nBagID] = pAddBag; return true; } return false; }
bool KStoreProduct::AddProductPrice(int nMoneyType, int nTParam1, int nTParam2) { ASSERT_RETURN(nMoneyType > enumPT_none && nMoneyType < enumPT_count, false); KStoreProductPrice price; price.nMoneyType = nMoneyType; price.nTParam1 = nTParam1; price.nTParam2 = nTParam2; int i = 0; for(i=0;i<sizeof(m_Prices)/sizeof(m_Prices[0]);i++) { if(enumPT_none == m_Prices[i].nMoneyType) break; if(m_Prices[i].nMoneyType == nMoneyType) return false; } if(i < PRICE_TYPE_MAX) { m_Prices[i].nMoneyType = nMoneyType; m_Prices[i].nTParam1 = nTParam1; m_Prices[i].nTParam2 = nTParam2; return true; } return false; }
void CGraphicWindowChildFrame::moveForward() { ASSERT_RETURN( forwardTabCount() > 0 ); int newTab = m_forwardTabList[forwardTabCount()]; m_forwardTabList.remove(forwardTabCount()); SetTab( newTab ); }
int KBagManager::GetCount(int nBagID, int nPos) const { const KCellBag* pCell = FindCell(nBagID, nPos); ASSERT_RETURN(pCell, 0); return pCell->GetItemStackNumber(); }
Enlil_IPTC_Job * enlil_iptc_job_prepend(Enlil_Photo *photo, Enlil_IPTC_Done_Cb cb, void *data) { ASSERT_RETURN(photo != NULL); Eina_List *l; Enlil_IPTC_Job *job; EINA_LIST_FOREACH(l_jobs, l, job) if(job->photo == photo) break; if(!job) { job = calloc(1, sizeof(Enlil_IPTC_Job)); job->photo = photo; job->cb = cb; job->data = data; } else l_jobs = eina_list_remove(l_jobs, job); l_jobs = eina_list_prepend(l_jobs, job); _job_next(); return job; }
int KBagManager::GetItemCountByID(int nBagID, DWORD dwItemID) const { const KBag* pBag = FindBag(nBagID); ASSERT_RETURN(pBag, 0); return pBag->GetItemSize(dwItemID); }
MemoryPool* initPool(size_t size, size_t increment) { MemoryPool *pool; MemoryBlock *block; void *buffer; ASSERT_RETURN(size >= sizeof(MemoryPool)+sizeof(MemoryBlock), NULL); buffer=malloc(size+sizeof(*pool)+sizeof(*block)); if (!buffer) return NULL; // Initialize first memory block block = (MemoryBlock*) ((size_t)buffer+sizeof(*pool)); block->next = NULL; block->start=(void*)((size_t)block+sizeof(*block)); block->pos=ALIGN_PTR(block->start, POOL_ALIGNMENT); block->end=block->start+size; // Initialize pool pool = (MemoryPool*) buffer; pool->lastAlloc = 0; pool->capacity = size; pool->increment = (increment) ? increment : (size_t)sysconf(_SC_PAGESIZE); pool->base=block; pool->cur=block; PRINT("Pool created, used size=%ld, capacity=%ld, increment size=%ld", (((size_t)(pool->cur->start)) - (size_t)pool), pool->capacity, pool->increment); return pool; }
int enlil_tag_photos_count_get(const Enlil_Tag *tag) { ASSERT_RETURN(tag != NULL); return eina_list_count(tag->photos); }
bool SocketAddress::setIntern(Exception& ex,const string& hostAndPort,bool resolveHost) { ASSERT_RETURN(!hostAndPort.empty(),false); string host, port; auto it = hostAndPort.begin(); auto& end = hostAndPort.end(); if (*it == '[') { ++it; while (it != end && *it != ']') host += *it++; if (it == end) { ex.set(Exception::NETADDRESS,"Malformed IPv6 address ", hostAndPort); return false; } ++it; } else { while (it != end && *it != ':') host += *it++; } if (it != end && *it == ':') { ++it; while (it != end) port += *it++; } else { ex.set(Exception::NETADDRESS, "Missing port number in ", hostAndPort); return false; } return setIntern(ex,host, resolveService(ex,port),resolveHost); }
const KBagQuest* KBagManager::FindQuestBag() const { const KBag* pBag = FindBag(enum_item_BagQuest); ASSERT_RETURN(pBag, NULL); const KBagQuest* pBagQuest = dynamic_cast<const KBagQuest*>(pBag); return pBagQuest; }
BOOL CFileVersionInfo::GetCPName( IN WORD wCP, OUT LPCTSTR* ppszName ) { if( ppszName == NULL ) ASSERT_RETURN( FALSE ); BOOL bRes = TRUE; *ppszName = NULL; switch ( wCP ) { case VI_CP_ASCII: *ppszName = _T( "7-bit ASCII" ); break; case VI_CP_JAPAN: *ppszName = _T( "Japan (Shift – JIS X-0208)" );break; case VI_CP_KOREA: *ppszName = _T( "Korea (Shift – KSC 5601)" ); break; case VI_CP_TAIWAN: *ppszName = _T( "Taiwan (Big5)" ); break; case VI_CP_UNICODE: *ppszName = _T( "Unicode" ); break; case VI_CP_LATIN2: *ppszName = _T( "Latin-2 (Eastern European)" );break; case VI_CP_CYRILLIC: *ppszName = _T( "Cyrillic" ); break; case VI_CP_MULTILNG: *ppszName = _T( "Multilingual" ); break; case VI_CP_GREEK: *ppszName = _T( "Greek" ); break; case VI_CP_TURKISH: *ppszName = _T( "Turkish" ); break; case VI_CP_HEBREW: *ppszName = _T( "Hebrew" ); break; case VI_CP_ARABIC: *ppszName = _T( "Arabic" ); break; default: *ppszName = _T( "Unknown" ); bRes = FALSE; break; } return bRes; }
const KBagNormal* KBagManager::FindNormalBag() const { const KBag* pBag = FindBag(enum_item_BagNormal); ASSERT_RETURN(pBag, NULL); const KBagNormal* pBagNormal = dynamic_cast<const KBagNormal*>(pBag); return pBagNormal; }
DWORD CFileVersionInfo::GetTransByIndex( IN UINT nIndex ) const { if( m_bValid == FALSE || nIndex < 0 || nIndex > m_nTransCnt ) ASSERT_RETURN( 0 ); return m_lpdwTrans[ nIndex ]; }
int pthread_attr_setinheritsched(pthread_attr_t *attr, int h) { ASSERT_RETURN(!attr,EINVAL); attr->schedinherited = h; return 0; }
/* * Return: TEST_OK, TEST_ERR or TEST_SKIP * we return TEST_OK only if the children return with the expected * 'expected_status' that is specified as an argument. */ static int kdbus_fork_test(const char *bus, const char *name, struct kdbus_conn **conn_db, int expected_status) { pid_t pid; int ret = 0; int status = 0; pid = fork(); ASSERT_RETURN_VAL(pid >= 0, pid); if (pid == 0) { ret = prctl(PR_SET_PDEATHSIG, SIGKILL); ASSERT_EXIT(ret == 0); ret = drop_privileges(65534, 65534); ASSERT_EXIT(ret == 0); ret = kdbus_recv_in_threads(bus, name, conn_db); _exit(ret == expected_status ? EXIT_SUCCESS : EXIT_FAILURE); } ret = waitpid(pid, &status, 0); ASSERT_RETURN(ret >= 0); return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; }
void CGraphicsRigidDiaphragmLoad::translate( const CRigidDiaphragmLoad* pRDL, float length ) { double dLoc[3]; const CNode* pN = pRDL->location(); ASSERT_RETURN( pN ); dLoc[0] = m_loc[0] = pN->x(); dLoc[1] = m_loc[1] = pN->y(); dLoc[2] = m_loc[2] = pN->z(); glMatrixMode( GL_MODELVIEW ); //glPushMatrix(); glTranslatef( (float)m_loc.x, (float)m_loc.y, (float)m_loc.z ); if( !zero( pRDL->magnitude( DX ) ) ){ //draw x dir arrow } else if( !zero( pRDL->magnitude( DY ) ) ){ //draw y dir arrow glRotatef( 90.f, 0.f, 0.f, 1.f ); } else if( !zero( pRDL->magnitude( DZ ) ) ){ //draw z dir arrow glRotatef( -90.f, 0.f, 1.f, 0.f ); } glTranslatef( length, 0.f, 0.f ); //glGetDoublev( GL_MODELVIEW_MATRIX, m_mv ); //glPopMatrix(); return; }