Пример #1
0
/*---------------------------------------------------------------------------
 *            BipBuildReq
 *---------------------------------------------------------------------------
 *
 * Synopsis:  Builds a request.
 *
 * Return:    OB_STATUS_FAILED - Could not build pull object.    
 *            Otherwise the operation Started Successfully.
 */
ObStatus BipBuildReq(BipObexClient *client)
{
    /* Get a new object store entry. */
    client->pushPull.object = BIPOBS_New(&client->cApp);
    if (client->pushPull.object == 0) {
        return OB_STATUS_FAILED;
    }
    if (client->pushPull.name) {
        BIPOBS_AppendName((BipObStoreHandle)client->pushPull.object,
            (U8*)client->pushPull.name, OS_StrLen((const char *)client->pushPull.name));
    }

    if (client->pushPull.type) {
        BIPOBS_AppendType((BipObStoreHandle)client->pushPull.object,
            (U8*)client->pushPull.type, OS_StrLen((const char *)client->pushPull.type));
    }
      
    /* Save to ObStore structure for use on the response. */
    ((BipObStoreHandle)client->pushPull.object)->bipOp = client->data->bipOp;
    ((BipObStoreHandle)client->pushPull.object)->ocx = client->data->ocx;

    if (client->data->bipOp == BIPOP_PUT_IMAGE || client->data->bipOp == BIPOP_PUT_LINKED_THUMBNAIL) {
        /* Set the object length of the image we are going to Put */
        BIPOBS_SetObjectLen((BipObStoreHandle)client->pushPull.object, client->data->totLen);
        client->pushPull.objectLen = client->data->totLen;
    }

    return OB_STATUS_SUCCESS;
}
Пример #2
0
/*--------------------------------------------------------------------------- 
 * AT_Encode_Common
 * 
 *     Encodes TE originated AT commands. 
 */ 
AtStatus TE_Encode_Common(AtContext *Atc, U16 Type, const AtCommands *Command, XaBufferDesc *Output)
{
    U16     avail = (Output->buffSize - Output->writeOffset) -1;
    U16     len;

    switch (Type) {
    case AT_SET_ERROR_MODE:
        /* Syntax: AT+CMEE=[<n>] */
        if (avail < 1) {
            return AT_STATUS_NO_RESOURCES;
        }
        Output->buff[Output->writeOffset++] = Command->p.error.mode + '0';
        break;

#if (AT_HANDSFREE == XA_ENABLED) || (AT_PHONEBOOK == XA_ENABLED) || (AT_SMS == XA_ENABLED)
    case AT_SELECT_CHARACTER_SET:
        /* Syntax: AT+CSCS=[<chset>] */
        len = OS_StrLen(Command->p.charSet.type);
        if (avail < len) {
            return AT_STATUS_NO_RESOURCES;
        }
        OS_MemCopy(Output->buff + Output->writeOffset, (const U8*)Command->p.charSet.type, len);
        Output->writeOffset += len;
        break;
#endif /* (AT_HANDSFREE == XA_ENABLED) || (AT_PHONEBOOK == XA_ENABLED) */

    default:
        return AT_STATUS_NOT_SUPPORTED;
    }
    return AT_STATUS_OK;
}
Пример #3
0
/*---------------------------------------------------------------------------
 * AT_Range2MinMax
 *
 *     Returns the first and last values found in range strings that contain
 *     a list of integers, such as "(0,1)", "(0-5)" or "(0,1,2)". The input
 *     must be a null-terminated string, devoid of whitespace. On error *Min
 *     and *Max == 0xff. If only one value is present Min == Max.
 */
void AT_Range2MinMax(const char *Range, U16 *Min, U16 *Max)
{
    I8      i;
    U16     len;

    Assert(Min && Max && Range);

    *Min = *Max = 0xff;

    len = OS_StrLen(Range);

    /* Find first (minimum) value in range */
    for (i = 0; i < len; i++) {
        if (Range[i] < '0' || Range[i] > '9')
            continue;
        *Min = *Max = (U16)AtAtoI((const U8 *)(Range + i), (U8)(len - i));
        break;
    }

    /* Find last (maximum) value in range */
    for (i = len; i > 0; i--) {
        if (Range[i - 1] != ',' && Range[i - 1] != '-')
            continue;

        *Max = (U16)AtAtoI((const U8 *)(Range + i), (U8)(len - i));
        break;
    }
}
Пример #4
0
U8 meUtilWriteEirName(U8 *buf, U8 bufLen, const U8 *name, U8 nameLen)
{
    int offset = 0;

    if(name && buf && bufLen > 2){
	nameLen = min(nameLen, OS_StrLen((const char*)name));
	if (nameLen)
	{
	    if (nameLen > bufLen - 2)
	    {
                buf[offset] = bufLen - 1;
		offset++;
		buf[offset++] = BT_EIR_NAME_SHORTENED;
		OS_MemCopy(buf + offset, name, bufLen - offset);
		offset = bufLen;
            }
	    else
	    {
                buf[offset++] = nameLen + 1;
                buf[offset++] = BT_EIR_NAME_COMPLETE;
                OS_MemCopy(buf + offset, name, nameLen);
                offset += nameLen;
            }
        }
    }
    Assert (offset <= bufLen);
    return offset;
}
Пример #5
0
void  OSTaskNameSet (INT8U prio, INT8U *pname, INT8U *perr)
{
    INT8U      len;
    OS_TCB    *ptcb;
#if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */
    OS_CPU_SR  cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
    if (perr == (INT8U *)0) {                        /* Validate 'perr'                                */
        return;
    }
    if (prio > OS_LOWEST_PRIO) {                     /* Task priority valid ?                          */
        if (prio != OS_PRIO_SELF) {
            *perr = OS_ERR_PRIO_INVALID;             /* No                                             */
            return;
        }
    }
    if (pname == (INT8U *)0) {                       /* Is 'pname' a NULL pointer?                     */
        *perr = OS_ERR_PNAME_NULL;                   /* Yes                                            */
        return;
    }
#endif
    if (OSIntNesting > 0) {                          /* See if trying to call from an ISR              */
        *perr = OS_ERR_NAME_SET_ISR;
        return;
    }
    OS_ENTER_CRITICAL();
    if (prio == OS_PRIO_SELF) {                      /* See if caller desires to set it's own name     */
        prio = OSTCBCur->OSTCBPrio;
    }
    ptcb = OSTCBPrioTbl[prio];
    if (ptcb == (OS_TCB *)0) {                       /* Does task exist?                               */
        OS_EXIT_CRITICAL();                          /* No                                             */
        *perr = OS_ERR_TASK_NOT_EXIST;
        return;
    }
    if (ptcb == OS_TCB_RESERVED) {                   /* Task assigned to a Mutex?                      */
        OS_EXIT_CRITICAL();                          /* Yes                                            */
        *perr = OS_ERR_TASK_NOT_EXIST;
        return;
    }
    len = OS_StrLen(pname);                          /* Yes, Can we fit the string in the TCB?         */
    if (len > (OS_TASK_NAME_SIZE - 1)) {             /*      No                                        */
        OS_EXIT_CRITICAL();
        *perr = OS_ERR_TASK_NAME_TOO_LONG;
        return;
    }
    (void)OS_StrCopy(ptcb->OSTCBTaskName, pname);    /*      Yes, copy to TCB                          */
    OS_EXIT_CRITICAL();
    *perr = OS_ERR_NONE;
}
Пример #6
0
INT8U  OSTmrNameGet (OS_TMR   *ptmr,
                     INT8U   **pdest,
                     INT8U    *perr)
{
    INT8U  len;


#ifdef OS_SAFETY_CRITICAL
    if (perr == (INT8U *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return (0u);
    }
#endif

#if OS_ARG_CHK_EN > 0u
    if (pdest == (INT8U **)0) {
        *perr = OS_ERR_TMR_INVALID_DEST;
        return (0u);
    }
    if (ptmr == (OS_TMR *)0) {
        *perr = OS_ERR_TMR_INVALID;
        return (0u);
    }
#endif
    if (ptmr->OSTmrType != OS_TMR_TYPE) {              /* Validate timer structure                                    */
        *perr = OS_ERR_TMR_INVALID_TYPE;
        return (0u);
    }
    if (OSIntNesting > 0u) {                           /* See if trying to call from an ISR                           */
        *perr = OS_ERR_NAME_GET_ISR;
        return (0u);
    }
    OSSchedLock();
    switch (ptmr->OSTmrState) {
        case OS_TMR_STATE_RUNNING:
        case OS_TMR_STATE_STOPPED:
        case OS_TMR_STATE_COMPLETED:
             *pdest = ptmr->OSTmrName;
             len    = OS_StrLen(*pdest);
             OSSchedUnlock();
             *perr = OS_ERR_NONE;
             return (len);

        case OS_TMR_STATE_UNUSED:                      /* Timer is not allocated                                      */
             OSSchedUnlock();
             *perr = OS_ERR_TMR_INACTIVE;
             return (0u);

        default:
             OSSchedUnlock();
             *perr = OS_ERR_TMR_INVALID_STATE;
             return (0u);
    }
}
Пример #7
0
void OSTaskNameSet (INT8U prio, char *pname, INT8U *err)
{
	INT8U len;
	OS_TCB *ptcb;
#if OS_CRITICAL_METHOD == 3                          /* Allocate storage for CPU status register       */
	OS_CPU_SR cpu_sr;

	cpu_sr = 0; /* Prevent compiler warning                       */
#endif    
#if OS_ARG_CHK_EN > 0
	if (prio > OS_LOWEST_PRIO) { /* Task priority valid ?                          */
		if (prio != OS_PRIO_SELF) {
			*err = OS_PRIO_INVALID; /* No                                             */
			return;
		}
	}
	if (pname == (char *)0) { /* Is 'pname' a NULL pointer?                     */
		*err = OS_ERR_PNAME_NULL; /* Yes                                            */
		return;
	}
#endif
	OS_ENTER_CRITICAL();
	if (prio == OS_PRIO_SELF) { /* See if caller desires to set it's own name     */
		prio = OSTCBCur->OSTCBPrio;
	}
	ptcb = OSTCBPrioTbl[prio];
	if (ptcb == (OS_TCB *)0) { /* Does task exist?                               */
		OS_EXIT_CRITICAL(); /* No                                             */
		*err = OS_TASK_NOT_EXIST;
		return;
	}
	if (ptcb == (OS_TCB *)1) { /* Task assigned to a Mutex?                      */
		OS_EXIT_CRITICAL(); /* Yes                                            */
		*err = OS_TASK_NOT_EXIST;
		return;
	}
	len = OS_StrLen(pname); /* Yes, Can we fit the string in the TCB?         */
	if (len > (OS_TASK_NAME_SIZE - 1)) { /*      No                                        */
		OS_EXIT_CRITICAL();
		*err = OS_ERR_TASK_NAME_TOO_LONG;
		return;
	}
	(void)OS_StrCopy(ptcb->OSTCBTaskName, pname); /*      Yes, copy to TCB                          */
	OS_EXIT_CRITICAL();
	*err = OS_NO_ERR;
}
Пример #8
0
/*****************************************************************************
 * FUNCTION
 *  SDPDB_GetLocalServiceName
 * DESCRIPTION
 *  This function is used to get the service provider name and name length
 * PARAMETERS
 *  service_type        [IN]        The kind of service such as SC_DIALUP_NETWORKING, SC_FAX, SC_LAN_ACCESS_PPP, SC_SERIAL_PORT
 *  service_name        [IN]        The pointer points to the service record name.
 * RETURNS
 *  U8 : The length of service name
 *****************************************************************************/
U8 SDPDB_GetLocalServiceName(U16 service_type, const U8 **service_name)
{

#if DUN_SERVER == XA_ENABLED
    if (service_type == SC_DIALUP_NETWORKING)
    {
        *service_name = dialupServiceName;
    }
    else
#endif /* DUN_SERVER == XA_ENABLED */

#if FAX_SERVER == XA_ENABLED
    if (service_type == SC_FAX)
    {
        *service_name = faxServiceName;
    }
    else
#endif /* FAX_SERVER == XA_ENABLED */

#if (SPP_SERVER == XA_ENABLED) && (NUM_SPP_SRVS > 0)
    if ((service_type >= SC_SERIAL_PORT0) && (service_type <= (SC_SERIAL_PORT0 + NUM_SPP_SRVS - 1)))
    {
        (*service_name) = SppSdpDB_GetServiceName(service_type);

    }
    else
#endif /* (SPP_SERVER == XA_ENABLED) && (NUM_SPP_SRVS > 0) */

#if SPP_SCO_SERVER == XA_ENABLED
    if ((service_type >= SC_SPP_SCO0) && (service_type <= (SC_SPP_SCO0 + NUM_SPP_SCO_SRVS - 1)))
    {
        (*service_name) = SppSdpDB_GetServiceName(service_type);

    }
    else
#endif /* SPP_SCO_SERVER == XA_ENABLED */
    {
        *service_name = 0;
        return 0;
    }

    return (U8) OS_StrLen((const char*)(*service_name));
}
Пример #9
0
void  OSMemNameSet (OS_MEM *pmem, INT8U *pname, INT8U *perr)
{
    INT8U      len;
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR  cpu_sr = 0;
#endif



#if OS_ARG_CHK_EN > 0
    if (perr == (INT8U *)0)                      /* Validate 'perr'                                    */
    {
        return;
    }
    if (pmem == (OS_MEM *)0)                     /* Is 'pmem' a NULL pointer?                          */
    {
        *perr = OS_ERR_MEM_INVALID_PMEM;
        return;
    }
    if (pname == (INT8U *)0)                     /* Is 'pname' a NULL pointer?                         */
    {
        *perr = OS_ERR_PNAME_NULL;
        return;
    }
#endif
    if (OSIntNesting > 0)                        /* See if trying to call from an ISR                  */
    {
        *perr = OS_ERR_NAME_SET_ISR;
        return;
    }
    OS_ENTER_CRITICAL();
    len = OS_StrLen(pname);                      /* Can we fit the string in the storage area?         */
    if (len > (OS_MEM_NAME_SIZE - 1))            /* No                                                 */
    {
        OS_EXIT_CRITICAL();
        *perr = OS_ERR_MEM_NAME_TOO_LONG;
        return;
    }
    (void)OS_StrCopy(pmem->OSMemName, pname);    /* Yes, copy name to the memory partition header      */
    OS_EXIT_CRITICAL();
    *perr = OS_ERR_NONE;
}
Пример #10
0
void OSFlagNameSet(OS_FLAG_GRP * pgrp, INT8U * pname, INT8U * perr)
{
  INT8U len;
#if OS_CRITICAL_METHOD == 3     /* Allocate storage for CPU status register           */
  OS_CPU_SR cpu_sr = 0;
#endif

#if OS_ARG_CHK_EN > 0
  if (perr == (INT8U *) 0) {    /* Validate 'perr'                                    */
    return;
  }
  if (pgrp == (OS_FLAG_GRP *) 0) {      /* Is 'pgrp' a NULL pointer?                          */
    *perr = OS_ERR_FLAG_INVALID_PGRP;
    return;
  }
  if (pname == (INT8U *) 0) {   /* Is 'pname' a NULL pointer?                         */
    *perr = OS_ERR_PNAME_NULL;
    return;
  }
#endif
  if (OSIntNesting > 0) {       /* See if trying to call from an ISR                  */
    *perr = OS_ERR_NAME_SET_ISR;
    return;
  }
  OS_ENTER_CRITICAL();
  if (pgrp->OSFlagType != OS_EVENT_TYPE_FLAG) {
    OS_EXIT_CRITICAL();
    *perr = OS_ERR_EVENT_TYPE;
    return;
  }
  len = OS_StrLen(pname);       /* Can we fit the string in the storage area?         */
  if (len > (OS_FLAG_NAME_SIZE - 1)) {  /* No                                                 */
    OS_EXIT_CRITICAL();
    *perr = OS_ERR_FLAG_NAME_TOO_LONG;
    return;
  }
  (void) OS_StrCopy(pgrp->OSFlagName, pname);   /* Yes, copy name from OS_FLAG_GRP                    */
  OS_EXIT_CRITICAL();
  *perr = OS_ERR_NONE;
  return;
}
Пример #11
0
INT8U  OSMemNameGet (OS_MEM   *pmem,
                     INT8U   **pname,
                     INT8U    *perr)
{
    INT8U      len;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */
    OS_CPU_SR  cpu_sr = 0u;
#endif



#ifdef OS_SAFETY_CRITICAL
    if (perr == (INT8U *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return (0u);
    }
#endif

#if OS_ARG_CHK_EN > 0u
    if (pmem == (OS_MEM *)0) {                   /* Is 'pmem' a NULL pointer?                          */
        *perr = OS_ERR_MEM_INVALID_PMEM;
        return (0u);
    }
    if (pname == (INT8U **)0) {                  /* Is 'pname' a NULL pointer?                         */
        *perr = OS_ERR_PNAME_NULL;
        return (0u);
    }
#endif
    if (OSIntNesting > 0u) {                     /* See if trying to call from an ISR                  */
        *perr = OS_ERR_NAME_GET_ISR;
        return (0u);
    }
    OS_ENTER_CRITICAL();
    *pname = pmem->OSMemName;
    len    = OS_StrLen(*pname);
    OS_EXIT_CRITICAL();
    *perr  = OS_ERR_NONE;
    return (len);
}
Пример #12
0
/*****************************************************************************
 * FUNCTION
 *  locateBtRootDir
 * DESCRIPTION
 *
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void locateBtRootDir(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    char *buffer = NULL;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (OS_StrLen(g_bt_dir_buf) == 0 &&
#ifdef BTMTK_ON_LINUX
            (buffer = getcwd(g_bt_dir_buf, FS_MAX_PATH_LEN)) == NULL
#else
            (buffer = _getcwd(g_bt_dir_buf, FS_MAX_PATH_LEN)) != NULL &&
            (buffer = strstr(g_bt_dir_buf, MBT_FS_PATH)) != NULL
#endif
       )
    {
        g_bt_dir_buf[0] = '\0';
    }
}
Пример #13
0
void  OSView_TxStr (INT8U *s, INT16U dly)
{
    INT16U  len;

    len = (INT16U)OS_StrLen(s);/* Make sure string fits in buffer           */
    if (len >= OS_VIEW_TX_STR_SIZE) 
	{/* Force end of string if string too long    */
        len    = OS_VIEW_TX_STR_SIZE - 1;
        s[len] = '\0';
    }
    if (OSView_TxStrLen > 0) 
	{                            /* Are currently busy sending a string?      */
        if (dly > 0) 
		{                                    /* Yes, does caller want to wait?            */
            while (OSView_TxStrLen > 0) 
			{  /* Yes, let other tasks run                  */
                OSView_TxStrDlyCtr++;
                OSTimeDly(dly);
            }
            OSView_TxStrLen = len;                        /* Update the string length                  */
            strcpy((char *)&OSView_TxStrBuf[0], (char *)s);           /* Copy string to send to buffer             */
            if (OSView_TxStrLen > 0) 
			{
                OSView_TxStart();
            }
        }
    } 
	else 
	{
        OSView_TxStrLen = len;                            /* Update the string length                  */
        strcpy((char *)&OSView_TxStrBuf[0], (char *)s);               /* Copy string to send to buffer             */
        if (OSView_TxStrLen > 0) 
		{
            OSView_TxStart();
        }
    }
}
Пример #14
0
void  OSMemNameSet (OS_MEM *pmem, INT8U *pname, INT8U *err)
{
    INT8U      len;
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR  cpu_sr = 0;
#endif



    OS_ENTER_CRITICAL();
#if OS_ARG_CHK_EN > 0
    if (err == (INT8U *)0) {                     /* Validate 'err'                                     */
        OS_EXIT_CRITICAL();
        return;
    }
    if (pmem == (OS_MEM *)0) {                   /* Is 'pmem' a NULL pointer?                          */
        OS_EXIT_CRITICAL();                      /* Yes                                                */
        *err = OS_MEM_INVALID_PMEM;
        return;
    }
    if (pname == (INT8U *)0) {                    /* Is 'pname' a NULL pointer?                         */
        OS_EXIT_CRITICAL();                      /* Yes                                                */
        *err = OS_ERR_PNAME_NULL;
        return;
    }
#endif
    len = OS_StrLen(pname);                      /* Can we fit the string in the storage area?         */
    if (len > (OS_MEM_NAME_SIZE - 1)) {          /* No                                                 */
        OS_EXIT_CRITICAL();
        *err = OS_MEM_NAME_TOO_LONG;
        return;
    }
    (void)OS_StrCopy(pmem->OSMemName, pname);    /* Yes, copy name to the memory partition header      */
    OS_EXIT_CRITICAL();
    *err = OS_NO_ERR;
}
Пример #15
0
/*--------------------------------------------------------------------------- 
 * AT_Encode_Common
 * 
 *     Encodes Audio Gateway (ME) originated AT results.
 */ 
AtStatus ME_Encode_Common(AtContext *Atc, U16 Type, const AtResults *Result, XaBufferDesc *Output)
{
    U16 	 len;
    U16     avail = (Output->buffSize - Output->writeOffset) - 2;

    switch (Type) {
    case AT_OK:         /* Syntax: OK */
    case AT_ERROR:      /* Syntax: ERROR */
    case AT_RING:       /* Syntax: RING */
    case AT_NO_CARRIER: /* Syntax: NO CARRIER */
    case AT_BUSY:       /* Syntax: BUSY */
    case AT_NO_ANSWER:  /* Syntax: NO ANSWER */
    case AT_DELAYED:    /* Syntax: DELAYED */
    case AT_BLACKLISTED:/* Syntax: BLACKLISTED */
        /* No parameters, yank the ':' & ' ' */
        Output->writeOffset -= 2;
        break;

    case AT_EXTENDED_ERROR:
        /* Syntax: +CME ERROR: <err> */
        if (avail < 3) {
            return AT_STATUS_NO_RESOURCES;
        }

        Output->writeOffset += AtItoA(Output->buff + Output->writeOffset, 
                                      Result->p.error.type);
        break;

    case AT_MANUFACTURE_ID:
		/* Subtract "<Cr><Lf>+CGMI: " */
		/* Output->writeOffset -= 7; */ /* For WISE requirement */
		Output->buff[Output->writeOffset++] = '\"';
		OS_MemCopy(Output->buff + Output->writeOffset, (const U8*)Result->p.manufactureID, OS_StrLen((const char *)Result->p.manufactureID));
		Output->writeOffset += OS_StrLen((const char *)Result->p.manufactureID);
		Output->buff[Output->writeOffset++] = '\"';
		break;
    case AT_MODEL_ID:
		/* Subtract "<Cr><Lf>+CGMM: " */
		/* Output->writeOffset -= 7; */ /* For WISE requirement */
		Output->buff[Output->writeOffset++] = '\"';		
		OS_MemCopy(Output->buff + Output->writeOffset, (const U8*)Result->p.modelID, OS_StrLen((const char *)Result->p.modelID));
		Output->writeOffset += OS_StrLen((const char *)Result->p.modelID);		
		Output->buff[Output->writeOffset++] = '\"';
		break;

    case (AT_SELECT_CHARACTER_SET|AT_TEST):
		#if 1
		len = OS_StrLen(Result->p.charset_test);
		if(len == 0)
		{
			return AT_STATUS_INVALID_PARM;
		}
		else if(avail < len+2)
		{
			return AT_STATUS_NO_RESOURCES;
		}
		else
		{
			OS_MemCopy(Output->buff + Output->writeOffset, (const U8*)Result->p.charset_test, len);
			Output->writeOffset += len;
		}
		#else
		if(Result->p.charset_test > 0)
		{
			U8 i, offset = Output->writeOffset;

			if(avail < 2)
				return AT_STATUS_NO_RESOURCES;
			else
				avail -= 2;
			
			Output->buff[Output->writeOffset++] = '(';
			for(i = 0;i < Result->p.charset_test.num; i++)
			{
				if( i != 0 )
				{
					if(avail == 0)
						return AT_STATUS_NO_RESOURCES;
					Output->buff[Output->writeOffset++] = ',';
				}
				
				len = OS_StrLen(Result->p.charset_test.charset[i]);
				if( avail < len+2 )
				{
					return AT_STATUS_NO_RESOURCES;
				}
				else
				{
					Output->buff[Output->writeOffset++] = '\"';
					OS_MemCopy(Output->buff + Output->writeOffset,Result->p.charset_test.charset[i], len);
					Output->writeOffset += len;					
					Output->buff[Output->writeOffset++] = '\"';
					avail -= (len+2);
				}				
		   	}
			Output->buff[Output->writeOffset++] = ')';
	   	}
		else
		{
			return AT_STATUS_INVALID_PARM;
		}
		#endif
		break;

    case AT_SELECT_CHARACTER_SET|AT_READ:
		len = OS_StrLen(Result->p.charset);
		if(len == 0)
		{
			return AT_STATUS_INVALID_PARM;
		}
		else if(avail < len+2)
		{
			return AT_STATUS_NO_RESOURCES;
		}
		else
		{
			Output->buff[Output->writeOffset++] = '\"';
			OS_MemCopy(Output->buff + Output->writeOffset, (const U8*)Result->p.charset, len);
			Output->writeOffset += len;
			Output->buff[Output->writeOffset++] = '\"';
		}
		break;
		
    case AT_RAW:
        Output->writeOffset -= 7; /* Subtract "Cr Lf RAW: " */
        OS_MemCopy(Output->buff + Output->writeOffset, 
                   Result->p.data, OS_StrLen((const char *)Result->p.data));
        Output->writeOffset += OS_StrLen((const char *)Result->p.data);
        break;

    default:
        return AT_STATUS_NOT_SUPPORTED;
    }

    return AT_STATUS_OK;
}
Пример #16
0
/*--------------------------------------------------------------------------- 
 * ME_Encode
 * 
 *     This function encodes an AT result for transmission to the device (TE).
 */ 
AtStatus ME_Encode(AtContext *Atc, const AtResults *Result, XaBufferDesc *Out)
{
    const char *cmdStr = 0;
    AtCommand   idx, grp;
    U16         len;
    AtStatus    status = AT_STATUS_INVALID_PARM;

    CheckUnlockedParm(AT_STATUS_INVALID_PARM, (Atc && Result && Out));

    idx = (Result->type & 0x00ff);
    grp = (Result->type & 0x0f00) >> 8;

    if (idx > Atc->lastCmd[grp] || grp >= AT_NUM_GROUPS) {
        return AT_STATUS_NOT_FOUND;
    }

    cmdStr = AT_CommandTable[grp][(idx)];
    len = OS_StrLen(cmdStr);

    /* Check space for "AT"<base command>"="<cr> */
    /* Check space for <cr><lf><base command>":"<cr><lf> */
    CheckUnlockedParm(AT_STATUS_NO_RESOURCES, (Out->buffSize - Out->writeOffset) > (len + 6));

    Out->buff[Out->writeOffset++] = '\r';
    Out->buff[Out->writeOffset++] = '\n';
    OS_MemCopy(Out->buff + Out->writeOffset, (const U8 *)cmdStr, len);
    Out->writeOffset += len;
    Out->buff[Out->writeOffset++] = ':';
    Out->buff[Out->writeOffset++] = ' ';  /* Required by some Ericsson handsets */

    switch (Result->type & 0x0f00) {
    case AT_GROUP_COMMON:
        status = ME_Encode_Common(Atc, Result->type, Result, Out);
        break;

#if AT_HEADSET == XA_ENABLED
    case AT_GROUP_HEADSET:
        status = ME_Encode_Headset(Atc, Result->type, &Result->p.hs, Out);
        break;
#endif /* AT_HEADSET == XA_ENABLED */

#if AT_HANDSFREE == XA_ENABLED
    case AT_GROUP_HANDSFREE:
        status = ME_Encode_Handsfree(Atc, Result->type, &Result->p.hf, Out);
        break;
#endif /* AT_HANDSFREE == XA_ENABLED */

#if AT_PHONEBOOK == XA_ENABLED
    case AT_GROUP_PHONEBOOK:
        status = ME_Encode_Phonebook(Atc, Result->type, &Result->p.pb, Out);
        break;
#endif /* AT_PHONEBOOK == XA_ENABLED */

#if AT_SMS == XA_ENABLED
	case AT_GROUP_SMS:
		status = ME_Encode_Sms(Atc, Result->type, &Result->p.sms, Out);
		break;
#endif

    default:
        Assert(0);
        break;
    }

    if ((status == AT_STATUS_OK) && (Result->type != AT_RAW)) {
        Out->buff[Out->writeOffset++] = '\r';
        Out->buff[Out->writeOffset++] = '\n';
    }

    return status;
}
Пример #17
0
OS_TMR  *OSTmrCreate (INT32U           dly,
                      INT32U           period,
                      INT8U            opt,
                      OS_TMR_CALLBACK  callback,
                      void            *callback_arg,
                      INT8U           *pname,
                      INT8U           *perr)
{
    OS_TMR   *ptmr;
#if OS_TMR_CFG_NAME_SIZE > 0
    INT8U     len;
#endif


#if OS_ARG_CHK_EN > 0
    if (perr == (INT8U *)0) {                               /* Validate arguments                                     */
        return ((OS_TMR *)0);
    }
    switch (opt) {
        case OS_TMR_OPT_PERIODIC:
             if (period == 0) {
                 *perr = OS_ERR_TMR_INVALID_PERIOD;
                 return ((OS_TMR *)0);
             }
             break;

        case OS_TMR_OPT_ONE_SHOT:
             if (dly == 0) {
                 *perr = OS_ERR_TMR_INVALID_DLY;
                 return ((OS_TMR *)0);
             }
             break;

        default:
             *perr = OS_ERR_TMR_INVALID_OPT;
             return ((OS_TMR *)0);
    }
#endif
    if (OSIntNesting > 0) {                                 /* See if trying to call from an ISR                      */
        *perr  = OS_ERR_TMR_ISR;
        return ((OS_TMR *)0);
    }
    OSTmr_Lock();
    ptmr = OSTmr_Alloc();                                   /* Obtain a timer from the free pool                      */
    if (ptmr == (OS_TMR *)0) {
        OSTmr_Unlock();
        *perr = OS_ERR_TMR_NON_AVAIL;
        return ((OS_TMR *)0);
    }
    ptmr->OSTmrState       = OS_TMR_STATE_STOPPED;          /* Indicate that timer is not running yet                 */
    ptmr->OSTmrDly         = dly;
    ptmr->OSTmrPeriod      = period;
    ptmr->OSTmrOpt         = opt;
    ptmr->OSTmrCallback    = callback;
    ptmr->OSTmrCallbackArg = callback_arg;
#if OS_TMR_CFG_NAME_SIZE > 0
    if (pname !=(INT8U *)0) {
        len = OS_StrLen(pname);                             /* Copy timer name                                        */
        if (len < OS_TMR_CFG_NAME_SIZE) {
            (void)OS_StrCopy(ptmr->OSTmrName, pname);
        } else {
#if OS_TMR_CFG_NAME_SIZE > 1
            ptmr->OSTmrName[0] = '#';                       /* Invalid size specified                                 */
            ptmr->OSTmrName[1] = OS_ASCII_NUL;
#endif
            *perr              = OS_ERR_TMR_NAME_TOO_LONG;
            OSTmr_Unlock();
            return (ptmr);
        }
    }
#endif
    OSTmr_Unlock();
    *perr = OS_ERR_NONE;
    return (ptmr);
}
Пример #18
0
/*--------------------------------------------------------------------------- 
 * TE_Encode
 * 
 *     This function encodes an AT command for transmission to the gateway (ME).
 */ 
AtStatus TE_Encode(AtContext *Atc, const AtCommands *Command, XaBufferDesc *Out)
{
    AtStatus    status;
    const char *cmdStr = 0;
    U8          idx, grp;
    U16         len;

    CheckUnlockedParm(AT_STATUS_INVALID_PARM, Atc && Command && Out);
    
    idx = (Command->type & 0x00ff);
    grp = (Command->type & 0x0f00) >> 8;

    if (idx > Atc->lastCmd[grp]) {
        return AT_STATUS_NOT_FOUND;
    }

    cmdStr = AT_CommandTable[grp][(idx)];
    len = OS_StrLen(cmdStr);

    /* Check space for "AT"<base command>"="<cr> */
    CheckUnlockedParm(AT_STATUS_NO_RESOURCES, (Out->buffSize - Out->writeOffset) > (len + 4));

    Out->buff[Out->writeOffset++] = 'A';
    Out->buff[Out->writeOffset++] = 'T';
    OS_MemCopy(Out->buff + Out->writeOffset, (const U8*)cmdStr, len);
    Out->writeOffset += len;
    Out->buff[Out->writeOffset++] = '=';

    switch (Command->type & 0xff00) {
    case AT_GROUP_COMMON:
        status = TE_Encode_Common(Atc, Command->type, Command, Out);
        break;

#if AT_HEADSET == XA_ENABLED
    case AT_GROUP_HEADSET:
        status = TE_Encode_Headset(Atc, Command->type, &Command->p.hs, Out);
        break;
#endif /* AT_HEADSET == XA_ENABLED */

#if AT_HANDSFREE == XA_ENABLED
    case AT_GROUP_HANDSFREE:
        status = TE_Encode_Handsfree(Atc, Command->type, &Command->p.hf, Out);
        break;
#endif /* AT_HANDSFREE == XA_ENABLED */

#if AT_PHONEBOOK == XA_ENABLED
    case AT_GROUP_PHONEBOOK:
        status = TE_Encode_Phonebook(Atc, Command->type, &Command->p.pb, Out);
        break;
#endif /* AT_HANDSFREE == XA_ENABLED */

    default:
        if (Command->type & AT_TEST) {
            if ((Out->buffSize - Out->writeOffset) < 1) {
                return AT_STATUS_NO_RESOURCES;
            }
        }
        else if (Command->type & AT_READ) {
            Out->writeOffset--;      /* remove the '=' */
        } 
        else {
            Assert(0);
            return AT_STATUS_NOT_SUPPORTED;
        }
        
        Out->buff[Out->writeOffset++] = '?';
        status = AT_STATUS_OK;
        break;
    }
    
    if (status == AT_STATUS_OK)
        Out->buff[Out->writeOffset++] = '\r';

    return status;
}