static __inline__ int32_t
__ldh_src_open(ldh_src *ldh, media_uri *mrl)
{
int32_t err = -EPERM, ch, level, type;
uint8_t prop[PROPERTY_BUF_LEN], start_time[TIME_BUF_LEN],end_time[TIME_BUF_LEN];
if (!hso || !hso->open)
return err;
err = __parse_mrl(mrl, &ch, &level, &type, start_time,
end_time, prop, NULL);
if (err)
{
LOG_W(
"__ldh_src_open()->__parse_mrl(%s) failed, err:'%d'.",
__str(mrl), err
);
return err;
}
err = (*hso->open)((avs_media*)ldh, ch, level, type,
start_time, end_time, prop);
if (err)
{
LOG_W(
"__ldh_src_open()->(*hso->open)(%s) failed, err:'%d'.",
__str(mrl), err
);
return err;
}
ldh->state = OPENED;
return 0;
}
bool files_init(honggfuzz_t * hfuzz)
{
hfuzz->files = util_Malloc(sizeof(char *));
hfuzz->files[0] = "NONE";
hfuzz->fileCnt = 1;
if (hfuzz->externalCommand) {
LOG_I
("No input file corpus loaded, the external command '%s' is responsible for creating the fuzz files",
hfuzz->externalCommand);
return true;
}
if (!hfuzz->inputDir) {
LOG_W("No input file/dir specified");
return false;
}
struct stat st;
if (stat(hfuzz->inputDir, &st) == -1) {
PLOG_W("Couldn't stat the input dir '%s'", hfuzz->inputDir);
return false;
}
if (S_ISDIR(st.st_mode)) {
return files_readdir(hfuzz);
}
LOG_W("The initial corpus directory '%s' is not a directory", hfuzz->inputDir);
return false;
}
static media_src *
create_local_media_src(tr_factory *tr_f, int32_t m_type)
{
ld_src *src;
if (m_type == 0)
{
src = (ld_src*)ldl_src_alloc(NULL);
if (!src)
{
LOG_W("Create local hitory media src failed.");
}
}
else
{
src = (ld_src*)ldh_src_alloc(NULL);
if (!src)
{
LOG_W("Create local hitory media src failed.");
}
else
{
if (m_type == MS_DOWNLD)
{
ldh_src_set_download_mode((ldh_src*)src);
}
}
}
return (media_src*)src;
}
static __inline__ void
rtsp_method_do_desc(rtsp_client *rc, rtsp_message *req, media *media)
{
RTSP_STATUS_CODE rsc;
rtsp_message *res;
int32_t err, sdp_size;
media_info mi;
sdp_message *sdp = NULL;
char *content_base = NULL;
uint8_t *sdp_buf;
uint32_t cb_size;
err = media_info_get(media, &mi);
if (!err)
{
content_base = rtsp_method_get_content_base(req, &cb_size);
if (!content_base)
{
LOG_W(
"rtsp_method_do_desc()->rtsp_method_get_content_base() failed."
);
err = -EINVAL;
goto desc_err;
}
sdp = rtsp_method_mi_to_sdp(&mi);
sdp_buf = (uint8_t*)rtsp_mem_alloc(MAX_RTSP_BUF_SIZE);
sdp_size = sdp_message_as_text(sdp, (char*)sdp_buf, MAX_RTSP_BUF_SIZE);
sdp_message_free(sdp);
if (sdp_size < 0 || sdp_size >= MAX_RTSP_BUF_SIZE)
{
LOG_W(
"rtsp_method_do_desc()->sdp_message_as_text() failed."
);
tr_free(content_base, cb_size);
err = -EINVAL;
goto desc_err;
}
media_info_clear(&mi);
res = rtsp_impl_new_generic_response(req, RTSP_STS_OK);
rtsp_message_take_body(res, sdp_buf, sdp_size);
rtsp_message_add_header(res, RTSP_HDR_CONTENT_TYPE, "application/sdp");
rtsp_message_add_header(res, RTSP_HDR_CONTENT_BASE, content_base);
tr_free(content_base, cb_size);
rtsp_impl_send_message(rc, res);
return;
}
desc_err:
media_info_clear(&mi);
rsc = rtsp_impl_trans_status_code(TR_RTSP_DESC, err);
res = rtsp_impl_new_generic_response(req, rsc);
rtsp_impl_send_message(rc, res);
}
static __inline__ void
__ldh_src_read_ahead(ldh_src *ldh)
{
int32_t err, vfrm_count = 0;
frame_t *frm;
if (!hso || !hso->pull)
{
LOG_W(
"__ldh_src_read_ahead()->hso->pull is NULL."
);
return;
}
for (;;)
{
if (ldh->state != PLAYED || (ldh->flags & LDH_FLGS_EOF))
break;
if (ldh->frm_count >= MAX_CACHED)
break;
if (vfrm_count >= PREREAD_BATCH)
break;
frm = NULL;
err = (*hso->pull)((avs_media*)ldh, &frm);
if (err)
{
LOG_W(
"__ldh_src_read_ahead()->(*hso->pull) failed, err:'%d'",
err
);
return;
}
if (frm)
{
ldh_fill_frm(ldh, frm);
if (IS_VIDEO_FRAME(frm))
{
++vfrm_count;
}
}
else
{
LOG_W(
"__ldh_src_read_ahead()->(*hso->pull) got 'NULL' frame"
);
}
}
ldh->flags &= ~LDH_FLGS_READING;
}
/*
This function is still a proof of concept, it's probably rife with bugs, below
is a short (and incomplete) todo
* "Basic" checks (Read/Write/File/Dir) checks for FAT32 filesystems which
requires detecting the filesystem being used.
*/
void Check(fs::path const& file, acs::Type type) {
DWORD file_attr = GetFileAttributes(file.c_str());
if ((file_attr & INVALID_FILE_ATTRIBUTES) == INVALID_FILE_ATTRIBUTES) {
switch (GetLastError()) {
case ERROR_FILE_NOT_FOUND:
case ERROR_PATH_NOT_FOUND:
throw fs::FileNotFound(file);
case ERROR_ACCESS_DENIED:
throw fs::ReadDenied(file);
default:
throw fs::FileSystemUnknownError(str(boost::format("Unexpected error when getting attributes for \"%s\": %s") % file % util::ErrorString(GetLastError())));
}
}
switch (type) {
case FileRead:
case FileWrite:
if ((file_attr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
throw fs::NotAFile(file);
break;
case DirRead:
case DirWrite:
if ((file_attr & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)
throw fs::NotADirectory(file);
break;
}
SECURITY_INFORMATION info = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;
DWORD len = 0;
GetFileSecurity(file.c_str(), info, nullptr, 0, &len);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
LOG_W("acs/check") << "GetFileSecurity: fatal: " << util::ErrorString(GetLastError());
std::vector<uint8_t> sd_buff(len);
SECURITY_DESCRIPTOR *sd = (SECURITY_DESCRIPTOR *)&sd_buff[0];
if (!GetFileSecurity(file.c_str(), info, sd, len, &len))
LOG_W("acs/check") << "GetFileSecurity failed: " << util::ErrorString(GetLastError());
ImpersonateSelf(SecurityImpersonation);
HANDLE client_token;
if (!OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, TRUE, &client_token))
LOG_W("acs/check") << "OpenThreadToken failed: " << util::ErrorString(GetLastError());
if (!check_permission(true, sd, client_token))
throw fs::ReadDenied(file);
if ((type == DirWrite || type == FileWrite) && !check_permission(false, sd, client_token))
throw fs::WriteDenied(file);
}
int get_all_files(PHandleFunc func, void* func_args)
{
int ret = 0;
if (!func) {
LOG_E("func is null\n");
ret = -1;
goto out;
}
GPParams gp_params = {0};
gp_params_init (&gp_params, NULL);
if ( (ret = cam_detect_camera(&gp_params)) < 0)
goto err_cam_detect;
if (ret == 0)
goto no_camera_detect;
struct FuncArgu args = {func, func_args};
get_file_recursive("/", &gp_params, &args);
release_param:
gp_params_exit(&gp_params);
out:
return ret;
no_camera_detect:
LOG_W("no camera detected\n");
goto release_param;
err_cam_detect:
ret = -1;
goto release_param;
}
void ImOnlineAdapterServiceProxy::offline(long userId,bool isDelLongOnline){
LOG_W(userId, "ImOnlineAdapterServiceProxy::offline", -1, "");
#ifndef INTERNATIONAL
ReadLock lock(mutex_);
ImOnlineAdapterServicePrx proxy = getProxy(userId);//取ImOnlineAdapterService的代理
if(!proxy){
LOG_ERROR("ImOnlineAdapterServiceProxy::offline => get proxy failure : userId = " << userId << " isDelLongOnline=" << isDelLongOnline);
return;
}
LOG_DEBUG("ImOnlineAdapterServiceProxy::offline <<userId = " << userId << " isDelLongOnline=" << isDelLongOnline<< " getProxy success.");
try{
proxy->offline(userId,isDelLongOnline);
} catch (exception& e){
LOG_ERROR("ImOnlineAdapterServiceProxy::offline => failure : proxy = " << proxy->ice_toString() << " exception = " << e.what());
return;
}catch(...){
LOG_ERROR("ImOnlineAdapterServiceProxy::offline => failure : proxy = " << proxy->ice_toString() << " exception = unknow exception" );
return;
}
LOG_DEBUG("ImOnlineAdapterServiceProxy::offline => userId = " << userId << " isDelLongOnline=" << isDelLongOnline << " interface function call success");
#endif
return;
}
//-----------------------------------------------------------------------------
int
gtpv1u_initial_req(
gtpv1u_data_t *gtpv1u_data_pP,
teid_t teidP,
tcp_udp_port_t portP,
uint32_t address)
{
NwGtpv1uUlpApiT ulp_req;
NwGtpv1uRcT rc = NW_GTPV1U_FAILURE;
memset(&ulp_req, 0, sizeof(NwGtpv1uUlpApiT));
ulp_req.apiType = NW_GTPV1U_ULP_API_INITIAL_REQ;
ulp_req.apiInfo.initialReqInfo.teid = teidP;
ulp_req.apiInfo.initialReqInfo.peerPort = portP;
ulp_req.apiInfo.initialReqInfo.peerIp = address;
rc = nwGtpv1uProcessUlpReq(gtpv1u_data_pP->gtpv1u_stack, &ulp_req);
if (rc == NW_GTPV1U_OK) {
LOG_D(GTPU, "Successfully sent initial req for teid %u\n", teidP);
} else {
LOG_W(GTPU, "Could not send initial req for teid %u\n", teidP);
}
return (rc == NW_GTPV1U_OK) ? 0 : -1;
}
/*
* Prints incoming byte stream in hexadecimal and readable form
*
* @param component Utilised as with macros defined in UTIL/LOG/log.h
* @param data unsigned char* pointer for data buffer
* @param size Number of octets in data buffer
* @return none
*/
void util_print_hex_octets(comp_name_t component, unsigned char* data, unsigned long size)
{
if (data == NULL) {
LOG_W(component, "Incoming buffer is NULL! Ignoring...\n");
return;
}
unsigned long octet_index = 0;
LOG_D(component, " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n");
LOG_D(component, "-----+-------------------------------------------------|\n");
LOG_T(component, " 000 |");
for (octet_index = 0; octet_index < size; ++octet_index) {
/*
* Print every single octet in hexadecimal form
*/
LOG_T(component, " %02x", data[octet_index]);
/*
* Align newline and pipes according to the octets in groups of 2
*/
if (octet_index != 0 && (octet_index + 1) % 16 == 0) {
LOG_T(component, " |\n");
LOG_T(component, " %03d |", octet_index);
}
}
/*
* Append enough spaces and put final pipe
*/
unsigned char index;
for (index = octet_index; index < 16; ++index)
LOG_T(component, " ");
LOG_T(component, " |\n");
}
int Application::startup()
{
// Already initialised!
if(initialised)
{
LOG_W("Application startup", "Application already loaded!");
return EXIT_SUCCESS;
}
// Set up SDL (create window and context for OpenGL)
ASSERT(startSDL() == EXIT_SUCCESS, "Starting SDL");
// Set up OpenGL/GLES "propre"
ASSERT(startGL() == EXIT_SUCCESS, "Starting OpenGL/GLES");
// Start up resource subsystems
ASSERT(GraphicsManager::getInstance()->startup()
== EXIT_SUCCESS, "Starting Graphics Manager");
// Start the Audio Manager
ASSERT(AudioManager::getInstance()->startup()
== EXIT_SUCCESS, "Starting Audio Manager");
// Start the Font Manager
ASSERT(FontManager::getInstance()->startup()
== EXIT_SUCCESS, "Starting Font Manager");
// Load the initial scene
ASSERT(scene->startup() == EXIT_SUCCESS, "Loading initial Scene");
// Initialisation successful!
initialised = true;
return EXIT_SUCCESS;
}
int Application::shutdown()
{
// Check if not initialised
if(!initialised)
{
LOG_W("Application shutdown", "Application not loaded");
return EXIT_SUCCESS;
}
// Close down the current scene
ASSERT(scene->shutdown() == EXIT_SUCCESS, "Application shutting down Scene");
delete scene;
// Shut down subsystems
AudioManager::getInstance()->shutdown();
GraphicsManager::getInstance()->shutdown();
// Destory application display and control structures
SDL_GL_MakeCurrent(NULL, NULL);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
// Shut down SDL
SDL_Quit();
// Flag uninitialised and signal success
initialised = false;
return EXIT_SUCCESS;
}
static int32_t
__ldl_src_play(ldl_src *ldl)
{
int32_t err = -EPERM;
if (!lso || !lso->play)
return err;
if (ldl->state != OPENED)
return err;
LOG_I(
"__ldl_src_play(): avs_media '%p'.", ldl
);
err = (*lso->play)((avs_media*)ldl);
if (err)
{
LOG_W(
"__ldl_src_play()->(*lso->play)() failed, err:'%d'.",
err
);
return err;
}
else
{
LOG_I(
"__ldl_src_play(): avs_media '%p' ok.", ldl
);
}
return 0;
}
static int32_t
__ldl_src_ctrl(ldl_src *ldl, int32_t cmd, void *data)
{
int32_t err = -EPERM;
if (!lso || !lso->ctrl)
return err;
if (ldl->state != OPENED)
return err;
LOG_I(
"__ldl_src_ctrl(): avs_media '%p'", ldl
);
err = (*lso->ctrl)((avs_media*)ldl, cmd, data);
if (err)
{
LOG_W(
"__ldl_src_ctrl()->(*lso->ctrl)() failed, err:'%d'.",
err
);
return err;
}
else
{
LOG_I(
"__ldl_src_ctrl(): avs_media '%p' ok.", ldl
);
}
return 0;
}
static int32_t
__ldh_src_pause(ldh_src *ldh)
{
int32_t err;
if (ldh->state == OPENED || ldh->state == PLAYED)
{
if (!hso || !hso->pause)
{
ldh->state = PAUSED;
return 0;
}
err = (*hso->pause)((avs_media*)ldh);
if (err)
{
LOG_W(
"__ldh_src_pause()->(*hso->pause)() failed, err:'%d'.",
err
);
}
else
{
ldh->state = PAUSED;
}
return err;
}
return 0;
}
static __inline__ int32_t
__ldh_src_play(ldh_src *ldh)
{
int32_t err;
if (ldh->state == CLOSED || ldh->state == PLAYED)
return -EINVAL;
if (!hso || !hso->play)
{
ldh->state = PLAYED;
return 0;
}
err = (*hso->play)((avs_media*)ldh);
if (err)
{
LOG_W(
"__ldh_src_play()->(*hso->play)() failed, err:'%d'.",
err
);
return err;
}
ldh->state = PLAYED;
return 0;
}
bool SocketSession::deliver(const long fromId, const string message, const int type, const long mid){
LOG_W(fromId, "SocketSession::deliver", type, message);
// 国际化
std::string i18nStr(message);
LOG_DEBUG("SocketSession::deliver:: msg = "<<message);
//cout<<getLang()<<endl;
if (pack(getLang(), i18nStr)){
LOG_ERROR("SocketSession::response => I18nTranslate error msg=["<<message.c_str()<<"]");
LOG_W(fromId, "I18n::pack", type, "error");
return false;
}
MY_INSTANCE(SocketServer).deliverMsg(getConnectionId(), i18nStr );
return 1;
}
bool HDDisk::setDevice ( PedDevice* p_device ) {
if( p_device == nullptr ) {
LOG_W() << "invalid PedDevice given... Abort!";
return false;
}
if( c_device != nullptr ) {
LOG_W() << "overwriting c_device " << c_device->path
<< " with p_device " << p_device->path
<< "... okay, okay; will go on, but you are doing strange things, man!";
ped_device_close( c_device );
}
c_device = p_device;
return true;
}
const action_t *action_get(const char *id)
{
action_hash_item_t *item;
HASH_FIND_STR(g_actions, id, item);
if (!item) LOG_W("Cannot find action %s", id);
return item ? item->action : NULL;
}
//-----------------------------------------------------------------------------
void
rb_free_rlc_union (
void *rlcu_pP)
{
//-----------------------------------------------------------------------------
rlc_union_t * rlcu_p;
if (rlcu_pP) {
rlcu_p = (rlc_union_t *)(rlcu_pP);
LOG_D(RLC,"%s %p \n",__FUNCTION__,rlcu_pP);
switch (rlcu_p->mode) {
case RLC_MODE_AM:
rlc_am_cleanup(&rlcu_p->rlc.am);
break;
case RLC_MODE_UM:
rlc_um_cleanup(&rlcu_p->rlc.um);
break;
case RLC_MODE_TM:
rlc_tm_cleanup(&rlcu_p->rlc.tm);
break;
default:
LOG_W(RLC,
"%s %p unknown RLC type\n",
__FUNCTION__,
rlcu_pP);
break;
}
}
}
static double getCpuUse(long num_cpu)
{
static uint64_t prevIdleT = 0UL;
FILE *f = fopen("/proc/stat", "re");
if (f == NULL) {
return NAN;
}
defer {
fclose(f);
};
uint64_t userT, niceT, systemT, idleT;
if (fscanf
(f, "cpu %" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64, &userT, &niceT, &systemT,
&idleT) != 4) {
LOG_W("fscanf('/proc/stat') != 4");
return NAN;
}
if (prevIdleT == 0UL) {
prevIdleT = idleT;
return NAN;
}
uint64_t cpuUse = (num_cpu * sysconf(_SC_CLK_TCK)) - (idleT - prevIdleT);
prevIdleT = idleT;
return (double)cpuUse / sysconf(_SC_CLK_TCK) * 100;
}
int Reactor::start(watcher_t *w)
{
int fd = w->fd;
if (fd < 0 || fd >= _watcher_pool_size) {
LOG_W("fd is not valid");
return -1;
}
int ret = 0;
watcher_t *_w = _wlist + fd;
int cur_event = _w->event;
_w->cb = w->cb;
_w->event = w->event;
_w->data = w->data;
if (_w->active == 1) {
//no need to modify if only cb change
if (cur_event != w->event) {
ret = _epollx->mod(_w);
}
} else {
ret = _epollx->add(_w);
_w->active = 1;
}
return ret;
}
GLuint GShader::compileShader(const char *shader, GLenum shaderType)
{
GLuint shaderHandle = glCreateShader(shaderType);
if (shaderHandle == 0)
{
return 0;
}
GLint shaderLength = (GLint)strlen(shader);
glShaderSource(shaderHandle, 1, &shader, &shaderLength);
glCompileShader(shaderHandle);
GLint compileResult;
glGetShaderiv(shaderHandle, GL_COMPILE_STATUS, &compileResult);
if (compileResult == GL_FALSE)
{
GLchar message[2048];
int len = 0;
glGetShaderInfoLog(shaderHandle, sizeof(message), &len, &message[0]);
LOG_W("<%s compile error>: %s", shader, message);
glDeleteShader(shaderHandle);
return 0;
}
return shaderHandle;
}
int main(int argc, char *argv[])
{
struct nsjconf_t nsjconf;
if (!cmdlineParse(argc, argv, &nsjconf)) {
exit(1);
}
if (nsjconf.clone_newuser == false && geteuid() != 0) {
LOG_W("--disable_clone_newuser requires root() privs");
}
if (nsjconf.daemonize && (daemon(0, 0) == -1)) {
PLOG_F("daemon");
}
cmdlineLogParams(&nsjconf);
if (nsjailSetSigHandlers() == false) {
exit(1);
}
if (nsjailSetTimer() == false) {
exit(1);
}
if (nsjconf.mode == MODE_LISTEN_TCP) {
nsjailListenMode(&nsjconf);
} else {
return nsjailStandaloneMode(&nsjconf);
}
return 0;
}
bool Project::isScheduleResourceFeasible(const vector<int>& sts, const vector<int> &zr) const {
for(int r = 0; r < numRes; r++)
for(int t = 0; t < numPeriods; t++) {
int cdem = 0;
for(int j = 0; j < numJobs; j++) {
if(sts[j] < t && t <= sts[j] + durations[j])
cdem += demands(j, r);
}
if (cdem > capacities[r] + zr[r]) {
LOG_W("Not enough residual capacity of resource = " + to_string(r) + " in period = " + to_string(t));
LOG_W("Demand = " + to_string(cdem));
LOG_W("Availability = " + to_string(capacities[r] + zr[r]));
return false;
}
}
return true;
}
vfs::Init::~Init()
{
if (!PHYSFS_isInit()) {
LOG_W("PhysFS already shut down.");
} else if (!PHYSFS_deinit()) {
LOG_E("PHYSFS_deinit failed: " + std::string(PHYSFS_getLastError()));
}
}
void ldl_interfaces_test(media_uri *mrl)
{
ldl_src *ldl;
int32_t err;
media_info msi;
for (;;)
{
ldl = ldl_src_alloc(NULL);
media_info_init(&msi);
err = __ldl_src_probe(ldl, mrl, &msi);
media_info_clear(&msi);
if (err)
{
LOG_W(
"ldl_interfaces_test()->__ldl_src_probe() failed, err:'%d'",
err
);
goto test_failed;
}
err = __ldl_src_open(ldl, mrl);
if (err)
{
LOG_W(
"ldl_interfaces_test()->__ldl_src_open() failed, err:'%d'",
err
);
goto test_failed;
}
__ldl_src_play(ldl);
usleep(100*1000);
__ldl_src_ctrl(ldl, 1, NULL);
usleep(1000*1000);
__ldl_src_kill(ldl);
test_failed:
media_src_kill_unref((media_src*)ldl);
usleep(2000*1000);
}
}
bool Project::isSchedulePrecedenceFeasible(const vector<int>& sts) const {
for(int i = 0; i < numJobs; i++) {
if (sts[i] < 0 || sts[i] + durations[i] > T) {
LOG_W("Starting time of activity " + to_string(i) + " out of time horizon. t = " + to_string(sts[i]));
return false;
}
for(int j = 0; j < numJobs; j++) {
if (adjMx(i, j) && sts[i] + durations[i] > sts[j]) {
LOG_W("Order feasibility violated. ft" + to_string(i) + "=" + to_string(sts[i] + durations[i]) + " > st" + to_string(j) + "=" + to_string(sts[j]));
return false;
}
}
}
return true;
}
void signalHandler(int signal) {
switch (signal) {
case SIGHUP:
LOG_W("Hungup signal received. Do something interesting");
//TODO: Do something interesting.
break;
case SIGTERM:
LOG_W("Teminate signal received. Quitting");
terminate = true;
//exit(EXIT_SUCCESS);
break;
}
}
static int32_t
__ldl_src_open(ldl_src *ldl, media_uri *mrl)
{
int32_t err = -EPERM, ch, level;
if (!lso || !lso->open)
return err;
if (ldl->state != INIT)
return err;
err = __parse_mrl(mrl, &ch, &level);
if (err)
{
LOG_W(
"__ldl_src_open()->__parse_mrl(%s) failed, err:'%d'.",
__str(mrl), err
);
return err;
}
LOG_I(
"__ldl_src_open(): mrl '%s'.", __str(mrl->mrl)
);
err = (*lso->open)((avs_media*)ldl, ch, level);
if (err)
{
LOG_W(
"__ldl_src_open()->(*lso->open)() failed, err:'%d'.",
err
);
return err;
}
else
{
LOG_I(
"__ldl_src_open(): mrl '%s' ok.", __str(mrl->mrl)
);
}
ldl->state = OPENED;
return 0;
}
