int main(int argc, char *argv[])
{
#if HAVE_LIBCAP
pthread_t t1, t2;
assert (geteuid () == 0);
diod_log_init (argv[0]);
_prtcap ("task0", CAP_DAC_OVERRIDE); /* root, expect set */
_prtcap ("task0", CAP_CHOWN);
msg ("task0: setfsuid 1");
setfsuid (1);
_prtcap ("task0", CAP_DAC_OVERRIDE); /* non-root, expect clr */
_prtcap ("task0", CAP_CHOWN);
msg ("task0: setfsuid 0"); /* root, expect set */
setfsuid (0);
_prtcap ("task0", CAP_DAC_OVERRIDE);
_prtcap ("task0", CAP_CHOWN);
msg ("task0: setfsuid 1");
setfsuid (1);
_prtcap ("task0", CAP_DAC_OVERRIDE); /* non-root, expect clr */
_prtcap ("task0", CAP_CHOWN);
msg ("task0: set cap");
_setcap ("task0", CAP_DAC_OVERRIDE);
_setcap ("task0", CAP_CHOWN);
_prtcap ("task0", CAP_DAC_OVERRIDE); /* root with cap explicitly set, */
_prtcap ("task0", CAP_CHOWN); /* expect set */
msg ("task0: setfsuid 2");
setfsuid (2);
_prtcap ("task0", CAP_DAC_OVERRIDE);/* non-root with cap explicitly set, */
_prtcap ("task0", CAP_CHOWN); /* (as root) expect set */
msg ("task0: clr cap");
_clrcap ("task0", CAP_DAC_OVERRIDE);
_clrcap ("task0", CAP_CHOWN);
_prtcap ("task0", CAP_DAC_OVERRIDE);/* non-root with cap explicitly clr, */
_prtcap ("task0", CAP_CHOWN); /* (as non-root) expect clr */
_create (&t1, proc1, NULL);
_create (&t2, proc2, NULL);
_join (t2, NULL);
_join (t1, NULL);
_prtcap ("task0", CAP_DAC_OVERRIDE); /* after threads, expect clr */
_prtcap ("task0", CAP_CHOWN);
#else
fprintf (stderr, "libcap unavailable\n");
exit (77);
#endif
exit (0);
}
//-------------------------------------------------------------------------------------
NavigationHandle* NavMeshHandle::create(std::string resPath, const std::map< int, std::string >& params)
{
if(resPath == "")
return NULL;
NavMeshHandle* pNavMeshHandle = NULL;
std::string path = resPath;
path = Resmgr::getSingleton().matchPath(path);
wchar_t* wpath = strutil::char2wchar(path.c_str());
std::wstring wspath = wpath;
free(wpath);
if(params.size() == 0)
{
std::vector<std::wstring> results;
Resmgr::getSingleton().listPathRes(wspath, L"navmesh", results);
if(results.size() == 0)
{
ERROR_MSG(fmt::format("NavMeshHandle::create: path({}) not found navmesh.!\n",
Resmgr::getSingleton().matchRes(path)));
return NULL;
}
pNavMeshHandle = new NavMeshHandle();
std::vector<std::wstring>::iterator iter = results.begin();
int layer = 0;
for(; iter != results.end(); ++iter)
{
char* cpath = strutil::wchar2char((*iter).c_str());
path = cpath;
free(cpath);
_create(layer++, resPath, path, pNavMeshHandle);
}
}
else
{
pNavMeshHandle = new NavMeshHandle();
std::map< int, std::string >::const_iterator iter = params.begin();
for(; iter != params.end(); ++iter)
{
_create(iter->first, resPath, path + "/" + iter->second, pNavMeshHandle);
}
}
return pNavMeshHandle;
}
TibrvStatus
TibrvMsg::updateField(const TibrvMsgField& field)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateField(_msg,(tibrvMsgField*)&field);
}
TibrvStatus
TibrvMsg::convertToString(const char*& string)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_ConvertToString(_msg,&string);
}
TibrvStatus
TibrvMsg::removeFieldInstance(const char* fieldName, tibrv_u32 instance)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_RemoveFieldInstance(_msg,fieldName,instance);
}
int scheduler_startup(struct scheduler *sched, const config_t *cfg) {
worker_t *worker = NULL;
int status = LIBHPX_OK;
// start all of the other worker threads
for (int i = 1, e = sched->n_workers; i < e; ++i) {
worker = scheduler_get_worker(sched, i);
status = _create(worker, cfg);
if (status != LIBHPX_OK) {
dbg_error("could not start worker %d.\n", i);
for (int j = 1; j < i; ++j) {
worker = scheduler_get_worker(sched, j);
_cancel(worker);
}
for (int j = 1; j < i; ++j) {
worker = scheduler_get_worker(sched, j);
_join(worker);
}
return status;
}
}
// wait for the other slave worker threads to launch
system_barrier_wait(&sched->barrier);
return status;
}
TibrvStatus
TibrvMsg::getReplySubject(const char*& replySubject)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetReplySubject(_msg,&replySubject);
}
TibrvStatus
TibrvMsg::updateIPAddr32(const char* fieldName, tibrv_ipaddr32 value, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateIPAddr32Ex(_msg,fieldName,value,fieldId);
}
TibrvStatus
TibrvMsg::updateF64(const char* fieldName, tibrv_f64 value, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateF64Ex(_msg,fieldName,value,fieldId);
}
TibrvStatus
TibrvMsg::addU16(const char* fieldName, tibrv_u16 value, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_AddU16Ex(_msg,fieldName,value,fieldId);
}
TibrvStatus
TibrvMsg::getFieldByIndex(TibrvMsgField& field, tibrv_u32 fieldIndex)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetFieldByIndex(_msg,(tibrvMsgField*)&field,fieldIndex);
}
TibrvStatus
TibrvMsg::clearReferences()
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_ClearReferences(_msg);
}
TibrvStatus
TibrvMsg::addOpaque(const char* fieldName, const void* value, tibrv_u32 size, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_AddOpaqueEx(_msg,fieldName,value,size,fieldId);
}
TibrvStatus
TibrvMsg::reset()
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_Reset(_msg);
}
TibrvStatus
TibrvMsg::getAsBytesCopy(void* bytePtr,tibrv_u32 byteSize)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetAsBytesCopy(_msg,bytePtr,byteSize);
}
TibrvStatus
TibrvMsg::getAsBytes(const void*& bytePtr)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetAsBytes(_msg,&bytePtr);
}
TibrvStatus
TibrvMsg::updateMsg(const char* fieldName,const TibrvMsg& msg, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateMsgEx(_msg,fieldName,msg.getHandle(),fieldId);
}
TibrvStatus
TibrvMsg::getIPPort16(const char* fieldName, tibrv_ipport16& value, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetIPPort16Ex(_msg,fieldName,&value,fieldId);
}
TibrvStatus
TibrvMsg::updateString(const char* fieldName, const char* value,tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateStringEx(_msg,fieldName,(char*)value,fieldId);
}
TibrvStatus
TibrvMsg::getXml(const char* fieldName, const void*& value, tibrv_u32& size, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetXmlEx(_msg,fieldName,&value,&size,fieldId);
}
TibrvStatus
TibrvMsg::updateXml(const char* fieldName, const void* value, tibrv_u32 size, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateXmlEx(_msg,fieldName,(void*)value,size,fieldId);
}
void Canvas::render()
{
if (_hwnd == NULL)
{
return;
}
//
RECT rect;
GetClientRect(_hwnd, &rect);
if (rect.left == rect.right)
{
return;
}
if (!_isInitialized())
{
_create();
}
if (RenderEngineImp::isNull() || NULL == RenderEngineImp::getInstancePtr()->getRenderEngine() || NULL == RenderEngineImp::getInstancePtr()->getRenderEngine()->getRenderSystem())
{
return;
}
//
RenderEngineImp::getInstancePtr()->getRenderEngine()->getRenderSystem()->clear(0, NULL, Euclid::eClearFlags_Target | Euclid::eClearFlags_ZBuffer, RenderEngineImp::getInstancePtr()->getClearColor(), 1.0f, 0L);
RenderEngineImp::getInstancePtr()->getRenderEngine()->getRenderSystem()->beginScene();
//
_renderGeometry();
//
RenderEngineImp::getInstancePtr()->getRenderEngine()->getRenderSystem()->endScene();
RenderEngineImp::getInstancePtr()->getRenderEngine()->getRenderSystem()->present(NULL, NULL, NULL);
//
_calcFPS();
}
TibrvStatus
TibrvMsg::updateF32Array(const char* fieldName, const tibrv_f32* value, tibrv_u32 numElements, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateF32ArrayEx(_msg,fieldName,value,numElements,fieldId);
}
CSideBarButton::CSideBarButton(const TWindowData *dat, CSideBar *sideBar)
{
m_dat = dat;
m_id = UINT(dat->hContact); // set the control id
m_sideBar = sideBar;
_create();
}
TibrvStatus
TibrvMsg::getF32(const char* fieldName, tibrv_f32& value, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetF32Ex(_msg,fieldName,&value,fieldId);
}
TibrvStatus
TibrvMsg::setReplySubject(const char* replySubject)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_SetReplySubject(_msg,(char*)replySubject);
}
void GraphSwitch::setGraphic(std::string g){
// if the already used return
if (g.compare(_current) == 0){ return ; }
if (_dl_handler){
graph->close();
dlclose(_dl_handler);
_dl_handler = NULL;
}
// Open the graphic lib
if (!(_dl_handler = dlopen(("./lib/" + g + "/lib" + g + ".so").c_str(), RTLD_LOCAL))){
std::cerr << "[dlopen] : Failed to open library" << std::endl;
exit(EXIT_FAILURE);
}
// Searching for the create symbol
if (!(_create = (IGraphicHandler *(*)(void))dlsym(_dl_handler, "create"))){
std::cerr << "Error : " << dlerror() << std::endl;
exit(EXIT_FAILURE);
}
// Create a new instance of the grapic lib handler
graph = _create();
// setting g as current graphic lib
_current = g;
}
TibrvStatus
TibrvMsg::getF64Array(const char* fieldName, const tibrv_f64*& array, tibrv_u32& numElements, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_GetF64ArrayEx(_msg,fieldName,&array,&numElements,fieldId);
}
CSideBarButton::CSideBarButton(const UINT id, CSideBar *sideBar)
{
m_dat = 0;
m_id = id;
m_sideBar = sideBar;
_create();
}
TibrvStatus
TibrvMsg::removeField(const char* fieldName, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_RemoveFieldEx(_msg,fieldName,fieldId);
}
