Exemple #1
0
static int mqttClient_processUnSubAck(mqttClient_t* clientData)
{
  int32_t rc = LE_OK;
  uint16_t packetId;

  LE_DEBUG("---> UNSUBACK");
  LE_ASSERT(clientData);

  rc = le_timer_Stop(clientData->session.cmdTimer);
  if (rc)
  {
    LE_ERROR("le_timer_Stop() failed(%d)", rc);
    goto cleanup;
  }

  rc = MQTTDeserialize_unsuback(&packetId, clientData->session.rx.buf, sizeof(clientData->session.rx.buf));
  if (rc != 1)
  {
    LE_ERROR("MQTTDeserialize_unsuback() failed");
    rc = LE_BAD_PARAMETER;
    goto cleanup;
  }
  else if (clientData->session.nextPacketId != packetId)
  {
    LE_ERROR("invalid packet ID(%u != %u)", clientData->session.nextPacketId, packetId);
    rc = LE_BAD_PARAMETER;
    goto cleanup;
  }

cleanup:
  return rc;
}
Exemple #2
0
static void mqttClient_connExpiryHndlr(le_timer_Ref_t timer)
{
  mqttClient_t* clientData = le_timer_GetContextPtr(timer);
  int32_t rc = LE_OK;

  LE_ASSERT(clientData);

  rc = mqttClient_close(clientData);
  if (rc)
  {
    LE_ERROR("mqttClient_close() failed(%d)", rc);
    goto cleanup;
  }

  LE_DEBUG("<--- reconnect");
  rc = mqttClient_connect(clientData);
  if (rc)
  {
    LE_ERROR("mqttClient_connect() failed(%d)", rc);
    goto cleanup;
  }

cleanup:
  return;
}
Exemple #3
0
static void mqttClient_pingExpiryHndlr(le_timer_Ref_t timer)
{
  mqttClient_t* clientData = le_timer_GetContextPtr(timer);
  int32_t rc = LE_OK;

  LE_ASSERT(clientData);

  int len = MQTTSerialize_pingreq(clientData->session.tx.buf, sizeof(clientData->session.tx.buf));
  if (len < 0)
  {
    LE_ERROR("MQTTSerialize_pingreq() failed(%d)", len);
    goto cleanup;
  }

  LE_DEBUG("<--- PING");
  rc = mqttClient_write(clientData, len);
  if (rc)
  {
    LE_ERROR("mqttClient_write() failed(%d)", rc);
    goto cleanup;
  }

cleanup:
  return;
}
Exemple #4
0
//--------------------------------------------------------------------------------------------------
static void Testle_Temp_RemoveHandlers
(
    void
)
{
    int i;

    // Remove handlers: add le_temp_RemoveThresholdEventHandler to the eventLoop of tasks
    for (i=0; i<NB_CLIENT; i++)
    {
        le_event_QueueFunctionToThread( AppCtx[i].appThreadRef,
                                        RemoveHandler,
                                        &AppCtx[i],
                                        NULL );
    }

    // Wait for the tasks
    SynchTest();

    // trigger an event report
    ExpectedStatus = 0;
    pa_tempSimu_TriggerEventReport(ExpectedStatus);

    // Wait for the semaphore timeout to check that handlers are not called
    LE_ASSERT( le_sem_WaitWithTimeOut(ThreadSemaphore, TimeToWait) == LE_TIMEOUT );
}
Exemple #5
0
static int mqttClient_close(mqttClient_t* clientData)
{
  int rc = LE_OK;

  LE_ASSERT(clientData);

  if (clientData->session.sock != MQTT_CLIENT_INVALID_SOCKET)
  {
    le_fdMonitor_Delete(clientData->session.sockFdMonitor);

    rc = close(clientData->session.sock);
    if (rc == -1)
    {
      LE_ERROR("close() failed(%d)", errno);
      rc = LE_FAULT;
      goto cleanup;
    }

    clientData->session.sock = MQTT_CLIENT_INVALID_SOCKET;
  }
  else
  {
    LE_WARN("socket already closed");
  }

cleanup:
  return rc;
}
Exemple #6
0
//--------------------------------------------------------------------------------------------------
void ni_Release
(
    ni_IteratorRef_t iteratorRef  ///< [IN] Free the resources used by this iterator.
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);

    // Make sure that the transaction timer isn't still running.
    if (iteratorRef->timerRef != NULL)
    {
        if (le_timer_GetExpiryCount(iteratorRef->timerRef) == 0)
        {
            le_timer_Stop(iteratorRef->timerRef);
        }

        le_timer_Delete(iteratorRef->timerRef);
        iteratorRef->timerRef = NULL;
    }

    // Release the rest of the iterator's resources.
    LE_DEBUG("Releasing iterator, <%p> with a lifetime of %d seconds.",
             iteratorRef,
             (uint32_t)(le_clk_GetRelativeTime().sec - iteratorRef->creationTime.sec));

    ni_Close(iteratorRef);
    tdb_UnregisterIterator(iteratorRef->treeRef, iteratorRef);

    le_pathIter_Delete(iteratorRef->pathIterRef);

    tdb_ReleaseTree(iteratorRef->treeRef);
    le_mem_Release(iteratorRef);
}
Exemple #7
0
//--------------------------------------------------------------------------------------------------
le_result_t ni_GoToParent
(
    ni_IteratorRef_t iteratorRef  ///< [IN] The iterator object to access.
)
//--------------------------------------------------------------------------------------------------
{
    // Update our path.
    if (le_pathIter_Append(iteratorRef->pathIterRef, "..") == LE_UNDERFLOW)
    {
        // Looks like there are no more parents in the chain.
        return LE_NOT_FOUND;
    }

    // Now, if we have a current node, just get it's parent node.  Otherwise make an attempt to see
    // if the requested parent node exists.
    if (iteratorRef->currentNodeRef != NULL)
    {
        iteratorRef->currentNodeRef = tdb_GetNodeParent(iteratorRef->currentNodeRef);
        LE_ASSERT(iteratorRef->currentNodeRef != NULL);
    }
    else
    {
        // Make an attempt to get the new current node.
        iteratorRef->currentNodeRef = ni_GetNode(iteratorRef, "");
    }

    return LE_OK;
}
Exemple #8
0
//--------------------------------------------------------------------------------------------------
le_cfg_IteratorRef_t ni_CreateRef
(
    ni_IteratorRef_t iteratorRef  ///< [IN] The iterator to generate a reference for.
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);
    LE_ASSERT(iteratorRef->reference == NULL);

    iteratorRef->reference = le_ref_CreateRef(IteratorRefMap, iteratorRef);
    LE_DEBUG("Created a new reference <%p> for iterator <%p>.",
             iteratorRef->reference,
             iteratorRef);

    return iteratorRef->reference;
}
Exemple #9
0
//--------------------------------------------------------------------------------------------------
static void OnTransactionTimeout
(
    le_timer_Ref_t timerRef   ///< The timer that expired.
)
//--------------------------------------------------------------------------------------------------
{
    // Extract the iterator reference out of the timer object.  Then perform a sanity check to make
    // sure everything is going to plan.
    ni_IteratorRef_t iteratorRef = (ni_IteratorRef_t)le_timer_GetContextPtr(timerRef);
    LE_ASSERT(iteratorRef->timerRef == timerRef);

    // For clearer message reporting, figure out if this is a read or write transaction.
    char* iterTypePtr = "Read";

    if (ni_IsWriteable(iteratorRef))
    {
        iterTypePtr = "Write";
    }

    if (iteratorRef->isTerminated)
    {
        LE_DEBUG("Previously terminated iterator, <%p> timed out.", iteratorRef);
        return;
    }

    // Report the failure in the log, and close the client session.  Once the session is closed all
    // of that user's resources within the configTree will be naturally cleaned up.
    LE_EMERG("%s transaction <%p> timer expired, for user %s, <%d>.",
             iterTypePtr,
             iteratorRef->reference,
             tu_GetUserName(iteratorRef->userRef),
             tu_GetUserId(iteratorRef->userRef));

    tu_TerminateConfigClient(iteratorRef->sessionRef, "Transaction timeout.");
}
Exemple #10
0
//--------------------------------------------------------------------------------------------------
static void ResetClientWatchdog
(
    int32_t timeout ///< [IN] The timeout to reset the watchdog timer to (in milliseconds).
)
{
    le_clk_Time_t timeoutValue;
    WatchdogObj_t* watchDogPtr = GetClientWatchdogPtr();
    if (watchDogPtr != NULL)
    {
        le_timer_Stop(watchDogPtr->timer);
        if (timeout == TIMEOUT_KICK)
        {
            timeoutValue = watchDogPtr->kickTimeoutInterval;
        }
        else
        {
            timeoutValue = MakeTimerInterval(timeout);
        }

        if (timeout != LE_WDOG_TIMEOUT_NEVER)
        {
            // timer should be stopped here so this should never fail
            // testing
            LE_ASSERT(LE_OK == le_timer_SetInterval(watchDogPtr->timer, timeoutValue));
            le_timer_Start(watchDogPtr->timer);
        }
        else
        {
            LE_DEBUG("Timeout set to NEVER!");
        }
    }
}
Exemple #11
0
//--------------------------------------------------------------------------------------------------
le_result_t le_utf8_Append
(
    char* destStr,          ///< [IN] The destination string.
    const char* srcStr,     ///< [IN] The UTF-8 source string.
    const size_t destSize,  ///< [IN] Size of the destination buffer in bytes.
    size_t* destStrLenPtr   ///< [OUT] The number of bytes in the resultant destination string (not
                            ///        including the NULL-terminator).  This parameter can be set to
                            ///        NULL if the destination string size is not needed.
)
{
    // Check parameters.
    LE_ASSERT( (destStr != NULL) && (srcStr != NULL) && (destSize > 0) );

    size_t destStrSize = strlen(destStr);
    le_result_t result = le_utf8_Copy(&(destStr[destStrSize]),
                                      srcStr,
                                      destSize - destStrSize,
                                      destStrLenPtr);

    if (destStrLenPtr)
    {
        *destStrLenPtr += destStrSize;
    }

    return result;
}
Exemple #12
0
//--------------------------------------------------------------------------------------------------
le_avdata_AssetInstanceRef_t le_avdata_Create
(
    const char* assetName
        ///< [IN]
)
{
    // Get the client's credentials.
    pid_t pid;
    uid_t uid;

    if (le_msg_GetClientUserCreds(le_avdata_GetClientSessionRef(), &uid, &pid) != LE_OK)
    {
        LE_KILL_CLIENT("Could not get credentials for the client.");
        return NULL;
    }


    // Look up the process's application name.
    char appName[LE_LIMIT_APP_NAME_LEN+1];

    le_result_t result = le_appInfo_GetName(pid, appName, sizeof(appName));
    LE_FATAL_IF(result == LE_OVERFLOW, "Buffer too small to contain the application name.");

    // TODO: Should this be LE_KILL_CLIENT instead?
    LE_FATAL_IF(result != LE_OK, "Could not get app name");


    // Create an instance of the asset
    assetData_InstanceDataRef_t instRef;
    int instanceId;

    LE_ASSERT( assetData_CreateInstanceByName(appName, assetName, -1, &instRef) == LE_OK );
    LE_ASSERT( instRef != NULL );
    LE_ASSERT( assetData_GetInstanceId(instRef, &instanceId) == LE_OK );
    LE_PRINT_VALUE("%i", instanceId);

    // Return a safe reference for the instance
    InstanceRefData_t* instRefDataPtr = le_mem_ForceAlloc(InstanceRefDataPoolRef);

    instRefDataPtr->clientSessionRef = le_avdata_GetClientSessionRef();
    instRefDataPtr->instRef = instRef;

    instRef = le_ref_CreateRef(InstanceRefMap, instRefDataPtr);

    return instRef;
}
Exemple #13
0
//--------------------------------------------------------------------------------------------------
static void AddWatchdog
(
    WatchdogObj_t* newDogPtr   ///< A pointer to the watchdog that is to be added to our container
)
{
    // The procId is the unique identifier for this watchdog. There shouldn't already be one.
    LE_ASSERT(NULL == le_hashmap_Put(WatchdogRefsContainer, &(newDogPtr->procId), newDogPtr));
}
Exemple #14
0
//--------------------------------------------------------------------------------------------------
void TestSim_Stk
(
    void
)
{
    // Stk handler semaphore
    StkHandlerSem = (le_sem_Ref_t) le_sem_Create("StkHandlerSem",1);

    // each thread subscribes to state handler using le_sim_AddSimToolkitEventHandler
    // This API has to be called by threads
    int i=0;
    for (; i<NB_CLIENT; i++)
    {
        le_event_QueueFunctionToThread( AppCtx[i].appThreadRef,
                                        AddStkHandler,
                                        &AppCtx[i],
                                        NULL );
    }

    // Wait for the tasks
    SynchTest();

    StkEvent = LE_SIM_REFRESH;

    // Invoke Stk event
    pa_simSimu_ReportStkEvent(StkEvent);

    // Wait for the call of the handlers
    SynchTest();

    // Check the result
    for (i=0; i<NB_CLIENT; i++)
    {
        LE_ASSERT(AppCtx[i].stkEvent == StkEvent);
        AppCtx[i].stkEvent = 0;
    }

    // Test le_sim_AcceptSimToolkitCommand and le_sim_RejectSimToolkitCommand
    pa_simSimu_SetExpectedStkConfirmationCommand(true);
    LE_ASSERT( le_sim_AcceptSimToolkitCommand(CurrentSimId) == LE_OK );
    pa_simSimu_SetExpectedStkConfirmationCommand(false);
    LE_ASSERT( le_sim_RejectSimToolkitCommand(CurrentSimId) == LE_OK );

    // Check that all handlers have been called as expected
    LE_ASSERT( le_sem_GetValue(ThreadSemaphore) == 0 );
}
Exemple #15
0
//--------------------------------------------------------------------------------------------------
le_result_t pa_audio_GetGain
(
    pa_audio_If_t interface,    ///< [IN] audio interface
    uint32_t     *gainPtr       ///< [OUT] gain value [0..100] (0 means 'muted', 100 is the
                                ///        maximum gain value)
)
{
    LE_ASSERT(gainPtr);

    LE_DEBUG("Get gain for [%d]",interface);
    switch (interface)
    {
        case PA_AUDIO_IF_CODEC_MIC:
        {
            unsigned value;
            GetMixerParameter("ADC1 Volume",&value);
            if (value == 3)
            {
                *gainPtr = 100;
            }
            else if (value == 2)
            {
                *gainPtr = 66;
            }
            else if (value == 1)
            {
                *gainPtr = 33;
            }
            else
            {
                *gainPtr = 0;
            }
            return LE_OK;
        }
        case PA_AUDIO_IF_CODEC_SPEAKER:
        {
            unsigned value;
            GetMixerParameter("RX1 Digital Volume",&value);
            *gainPtr = (100*value)/124;
            return LE_OK;
        }
        case PA_AUDIO_IF_DSP_FRONTEND_USB_RX:
        case PA_AUDIO_IF_DSP_FRONTEND_USB_TX:
        case PA_AUDIO_IF_DSP_BACKEND_MODEM_VOICE_RX:
        case PA_AUDIO_IF_DSP_BACKEND_MODEM_VOICE_TX:
        case PA_AUDIO_IF_DSP_FRONTEND_PCM_RX:
        case PA_AUDIO_IF_DSP_FRONTEND_PCM_TX:
        case PA_AUDIO_IF_FILE_PLAYING:
        case PA_AUDIO_IF_DSP_FRONTEND_I2S_RX:
        case PA_AUDIO_IF_DSP_FRONTEND_I2S_TX:
        case PA_AUDIO_IF_END:
        {
            break;
        }
    }
    LE_ERROR("This interface (%d) is not supported",interface);
    return LE_FAULT;
}
Exemple #16
0
//--------------------------------------------------------------------------------------------------
static void DisconnectedProfile
(
    le_mdc_ProfileRef_t profileRef
)
{
    char ipAddrStr[IP_STR_SIZE];
    char dns1AddrStr[IP_STR_SIZE];
    char dns2AddrStr[IP_STR_SIZE];
    char gatewayAddrStr[IP_STR_SIZE];
    char interfaceName[10];

    /* Expected value: LE_FAULT as the frofile is supposed to be disconnected */

    LE_ASSERT(le_mdc_GetInterfaceName(profileRef, interfaceName, sizeof(interfaceName))
                                                                                    == LE_FAULT);
    LE_ASSERT(le_mdc_GetIPv4Address(profileRef, ipAddrStr, IP_STR_SIZE) == LE_FAULT);
    LE_ASSERT(le_mdc_GetIPv6Address(profileRef, ipAddrStr, IP_STR_SIZE) == LE_FAULT);
    LE_ASSERT(le_mdc_GetIPv4DNSAddresses(   profileRef,
                                            dns1AddrStr,
                                            IP_STR_SIZE,
                                            dns2AddrStr,
                                            IP_STR_SIZE) == LE_FAULT);
    LE_ASSERT(le_mdc_GetIPv6DNSAddresses(   profileRef,
                                            dns1AddrStr,
                                            IP_STR_SIZE,
                                            dns2AddrStr,
                                            IP_STR_SIZE) == LE_OVERFLOW);
    LE_ASSERT(le_mdc_GetIPv4GatewayAddress( profileRef, gatewayAddrStr, IP_STR_SIZE )
                                                                                    == LE_FAULT);
    LE_ASSERT(le_mdc_GetIPv6GatewayAddress( profileRef, gatewayAddrStr, IP_STR_SIZE )
                                                                                    == LE_FAULT);

}
Exemple #17
0
//--------------------------------------------------------------------------------------------------
void TestMdc_Stat
(
    void
)
{
    pa_mdc_PktStatistics_t dataStatistics;
    dataStatistics.transmittedBytesCount = 123456789;
    dataStatistics.receivedBytesCount = 369258147;

    /* Set the statistics value to the pa */
    pa_mdcSimu_SetDataFlowStatistics(&dataStatistics);

    uint64_t rxBytes;
    uint64_t txBytes;

    /* Get the statistics and check the values */
    le_result_t res = le_mdc_GetBytesCounters(&rxBytes, &txBytes);
    LE_ASSERT(res == LE_OK);
    LE_ASSERT(rxBytes == dataStatistics.receivedBytesCount);
    LE_ASSERT(txBytes == dataStatistics.transmittedBytesCount);

    /* Reset counter, check again statistics (0 values expected) */
    res = le_mdc_ResetBytesCounter();
    LE_ASSERT(res == LE_OK);

    res = le_mdc_GetBytesCounters(&rxBytes, &txBytes);
    LE_ASSERT(res == LE_OK);
    LE_ASSERT(rxBytes == 0);
    LE_ASSERT(txBytes == 0);
}
Exemple #18
0
static int mangoh_bridge_air_vantage_sessionStart(void* param, const unsigned char* data, uint32_t size)
{
    mangoh_bridge_air_vantage_t* airVantage = (mangoh_bridge_air_vantage_t*)param;
    int32_t res = LE_OK;

    LE_ASSERT(airVantage);
    LE_ASSERT(data);

    LE_DEBUG("---> SESSION START");
    uint8_t* ptr = (uint8_t*)data;

    uint8_t pushAv = *ptr;
    ptr += sizeof(pushAv);
    LE_DEBUG("AV push(%u)", pushAv);

    uint8_t storage = *ptr;
    ptr += sizeof(storage);
    LE_DEBUG("storage(%u)", storage);

    uint8_t len = 0;
    memcpy(&len, ptr, sizeof(len));
    LE_DEBUG("len(%u)", len);
    ptr += sizeof(len);

    char url[MANGOH_BRIDGE_AIR_VANTAGE_VALUE_MAX_LEN] = {0};
    memcpy(url, ptr, len);
    LE_DEBUG("url('%s')", url);
    ptr += len;

    char pw[MANGOH_BRIDGE_AIR_VANTAGE_VALUE_MAX_LEN] = {0};
    memcpy(pw, ptr, size - len - sizeof(len) - sizeof(pushAv) - sizeof(storage));
    LE_DEBUG("pw('%s')", pw);

    dataRouter_SessionStart(url, pw, pushAv, storage);

    res = mangoh_bridge_sendResult(airVantage->bridge, 0);
    if (res != LE_OK)
    {
        LE_ERROR("ERROR mangoh_bridge_sendResult() failed(%d)", res);
        goto cleanup;
    }

cleanup:
    return res;
}
Exemple #19
0
//--------------------------------------------------------------------------------------------------
static void Testle_temp_RadioThresholdEventSetting
(
)
{
    int32_t warningTemperature = 0;
    int32_t criticalTemperature = 0;
    int32_t temperature = 0;

    le_result_t res = LE_FAULT;

    TimeCounter = 0;
    PoolTemp = 1;
    LE_INFO("Set PoolTemp %d", PoolTemp);

    le_thread_Ref_t thread = le_thread_Create("tempTest",DisplayTempThread,NULL);
    le_thread_Start(thread);

    LE_INFO("!!!!!!! YOU HAVE %d SECOND TO SET THE MODULE AT"
           " THE TEMP REFERENCE !!!!!!!", WAIT_TIME);
    TimeCounter = 0;

    PoolTemp = 2;
    LE_INFO("Set PoolTemp %d", PoolTemp);

    sleep(WAIT_TIME);

    // Get current PA Tempeartaure
    res = le_temp_GetRadioTemperature(&temperature);
    LE_ASSERT(res == LE_OK);
    LE_INFO("le_temp_GetRadioTemperature return %d degree Celcus", temperature);

    // Set Warning threshold Tempeartaure
    warningTemperature = temperature + 10;
    criticalTemperature = temperature + 20;

    LE_INFO("temperature threshold are set tole_temp_SetThreshold(%d, %d) in degree Celcus",
        warningTemperature, criticalTemperature);
    res = le_temp_SetRadioThresholds(warningTemperature, criticalTemperature);
    LE_ASSERT(res == LE_OK);

    PoolTemp = 0;
    LE_INFO("Set PoolTemp %d", PoolTemp);
    LE_INFO("!!!!!!! YOU MUST REBOOT THE MODULE !!!!!!!");
    sleep(2);
}
Exemple #20
0
//--------------------------------------------------------------------------------------------------
static void SynchTest( void )
{
    int i=0;

    for (;i<NB_CLIENT;i++)
    {
        LE_ASSERT(le_sem_WaitWithTimeOut(ThreadSemaphore, TimeToWait) == LE_OK);
    }
}
Exemple #21
0
//--------------------------------------------------------------------------------------------------
tdb_TreeRef_t ni_GetTree
(
    ni_ConstIteratorRef_t iteratorRef  ///< The iterator object to read.
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);
    return iteratorRef->treeRef;
}
Exemple #22
0
//--------------------------------------------------------------------------------------------------
tu_UserRef_t ni_GetUser
(
    ni_ConstIteratorRef_t iteratorRef  ///< The iterator object to read.
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);
    return iteratorRef->userRef;
}
Exemple #23
0
//--------------------------------------------------------------------------------------------------
le_msg_SessionRef_t ni_GetSession
(
    ni_ConstIteratorRef_t iteratorRef  ///< The iterator object to read.
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);
    return iteratorRef->sessionRef;
}
Exemple #24
0
//--------------------------------------------------------------------------------------------------
bool ni_IsWriteable
(
    ni_ConstIteratorRef_t iteratorRef  ///< Does this iterator represent a write transaction?
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);
    return iteratorRef->type == NI_WRITE;
}
Exemple #25
0
//--------------------------------------------------------------------------------------------------
bool ni_IsClosed
(
    ni_ConstIteratorRef_t iteratorRef  ///< The iterator object to check.
)
//--------------------------------------------------------------------------------------------------
{
    LE_ASSERT(iteratorRef != NULL);
    return iteratorRef->isClosed;
}
Exemple #26
0
//--------------------------------------------------------------------------------------------------
static void StartBridge
(
    void *param1Ptr,
    void *param2Ptr
)
{
    // dup stdout
    FdAtClient = dup(2);
    le_atServer_BridgeRef_t bridgeRef = le_atServer_OpenBridge(FdAtClient);
    LE_ASSERT(bridgeRef != NULL);
    *(le_atServer_BridgeRef_t*) param1Ptr = bridgeRef;
    le_atServer_DeviceRef_t devRef = param2Ptr;

    LE_ASSERT_OK(le_atServer_AddDeviceToBridge(devRef, bridgeRef));
    LE_ASSERT(le_atServer_AddDeviceToBridge(devRef, bridgeRef) == LE_BUSY);

    le_sem_Post(BridgeSemaphore);
}
Exemple #27
0
static void IdDestructor(void* objPtr)
{
    NumRelease++;
    ReleaseId = ((idObj_t*)objPtr)->id;

    // Test for deadlock on Memory Pool's internal mutex.
    // Also test that the ID Pool (from which this object was allocated) can be found.
    LE_ASSERT(le_mem_FindPool("ID Pool") != NULL);
}
//--------------------------------------------------------------------------------------------------
le_result_t pa_audio_ResetDspAudioPath
(
    le_audio_Stream_t* inputStreamPtr,   ///< [IN] input audio stream
    le_audio_Stream_t* outputStreamPtr   ///< [IN] output audio stream
)
{
    le_audio_If_t inputInterface = inputStreamPtr->audioInterface;
    le_audio_If_t outputInterface = outputStreamPtr->audioInterface;

    LE_ASSERT( IS_INPUT_STREAM(inputInterface) == true );
    LE_ASSERT( IS_OUTPUT_STREAM(outputInterface) == true );

    BuildAudioPath[inputInterface][outputInterface] -= 1;

    LE_ASSERT( BuildAudioPath[inputInterface][outputInterface] >= 0 );

    return LE_OK;
}
//--------------------------------------------------------------------------------------------------
le_result_t pa_audio_StopDtmfDecoder
(
    le_audio_Stream_t* streamPtr   ///< [IN] input audio stream
)
{
    LE_ASSERT( streamPtr->audioInterface == LE_AUDIO_IF_DSP_BACKEND_MODEM_VOICE_RX );

    return LE_OK;
}
Exemple #30
0
//--------------------------------------------------------------------------------------------------
static void HandlerFunc
(
    le_mdc_ProfileRef_t profileRef,
    le_mdc_ConState_t ConnectionStatus,
    void* contextPtr
)
{
    ConnectionStateReceivedByHandler = ( ConnectionStatus == LE_MDC_CONNECTED ) ? true : false;
    ProfileRefReceivedByHandler = (le_mdc_ProfileRef_t) profileRef;

    if (ConnectionStatus == LE_MDC_DISCONNECTED)
    {
        LE_ASSERT( le_mdc_GetDisconnectionReason(profileRef) == LE_MDC_DISC_REGULAR_DEACTIVATION );
        LE_ASSERT( le_mdc_GetPlatformSpecificDisconnectionCode(profileRef) == 2 );
    }

    le_sem_Post(ThreadSemaphore);
}