inet_msg_util.c

最新MTK手机软件源码

    {
        INET_MEM_FREE(buf);
        return NULL;
    }
    return buf;
}   /* inet_msg_struct_2_string */


/*****************************************************************************
 * FUNCTION
 *  inet_msg_get_line
 * DESCRIPTION
 *  This function gets a line from buffer.
 * PARAMETERS
 *  mem     [IN]        Buffer
 * RETURNS
 *  new string pointer
 *****************************************************************************/
kal_char *inet_msg_get_line(inet_mem_struct *mem)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_char *line = mem->pos;
    kal_char dummy = '\0';
    kal_char *cr = &dummy;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (mem->pos)
    {
        while (*(mem->pos) != '\0' && mem->size)
        {
            mem->size--;
            if ((*(cr) == '\r') && (*(mem->pos) == '\n'))
            {
                *(cr) = '\0';
                *(mem->pos) = '\0';
                mem->pos++;
                return line;
            }
            cr = mem->pos++;
        }
    }
    return NULL;
}


/*****************************************************************************
 * FUNCTION
 *  inet_msg_get_next_token
 * DESCRIPTION
 *  This function is is used to get next token from HTTP string fomat 1#. Each token is seperated by ','.
 *  This function will ignore these invalid ','. ex: token1; "80, 780, 1024", token2
 * PARAMETERS
 *  text        [IN]        Input text string
 * RETURNS
 *  new string pointer
 *****************************************************************************/
kal_char *inet_msg_get_next_token(kal_char *text)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_char *text_tp, *next_token;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    text_tp = text;
    while (1)
    {
        if (NULL != (next_token = strchr(text_tp, ',')))
        {
            kal_char *q_start, *q_end;

            if (NULL != (q_start = strchr(text_tp, '"')))
            {
                q_start++;
                if (NULL != (q_end = strchr(q_start, '"')))
                {
                    if (q_end > next_token && next_token >= q_start)
                    {
                        /* Invalid! Find next one */
                        if (*(q_end + 1) == '\0')
                        {
                            /* End of text */
                            next_token = NULL;
                            break;
                        }
                        else
                        {
                            text_tp = q_end++;
                        }

                    }
                    else
                    {
                        *next_token++ = '\0';
                        break;
                    }
                }
                else
                {
                    *next_token++ = '\0';
                    break;
                }
            }
            else
            {
                *next_token++ = '\0';
                break;
            }
        }
        else
        {
            break;
        }
    }
    return next_token;
}


/*****************************************************************************
 * FUNCTION
 *  inet_msg_get_header_pack_size
 * DESCRIPTION
 *  
 * PARAMETERS
 *  app_type        [IN]        
 *  mem_func        [?]         
 *  header_id       [IN]        
 *  arg             [?]         
 *  r_size          [?]         
 * RETURNS
 *  
 *****************************************************************************/
inet_result_enum inet_msg_get_header_pack_size(
                    kal_uint8 app_type,
                    inet_mem_func_struct *mem_func,
                    inet_header_field_enum header_id,
                    void *arg,
                    kal_int32 *r_size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_char *buf = NULL;
    kal_int32 buf_size = 256;
    inet_result_enum result;
    kal_int32 size;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (arg == NULL || header_id > INET_HDR_NUM)
    {
        *r_size = 0;
        return INET_RESULT_INVALID_PARAM;
    }
    while (1)
    {
        buf_size = buf_size * 2;
        if (buf != NULL)
        {
            INET_MEM_FREE(buf);
        }
        buf = (kal_char*) INET_MEM_ALLOC(buf_size);
        if (buf == NULL)
        {
            return INET_RESULT_NO_MEMORY;
        }
        result = inet_msg_header_pack_fn(header_id) (app_type, arg, buf, buf_size, &size);
        if (result == INET_RESULT_OK)
        {
            *r_size = size;
            result = INET_RESULT_OK;
            goto exit;
        }
        else if (result != INET_RESULT_NO_ENBUF)
        {
            goto exit;
        }
    }
  exit:
    if (buf != NULL)
    {
        INET_MEM_FREE(buf);
    }
    return result;
}


/*****************************************************************************
 * FUNCTION
 *  inet_msg_get_method_string
 * DESCRIPTION
 *  This function is used to return method string
 * PARAMETERS
 *  method      [IN]        Mehtod_id (inet_method_enum)
 * RETURNS
 *  ret                String pointer
 *****************************************************************************/
const kal_char *inet_msg_get_method_string(kal_uint8 method)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    extern const kal_char *const inet_method_name_table[INET_METHOD_NUM];

    if (method < INET_METHOD_NUM)
    {
        return inet_method_name_table[method];
    }
    else
    {
        return NULL;
    }
}


/*****************************************************************************
 * FUNCTION
 *  inet_msg_reverse_addr_list
 * DESCRIPTION
 *  This function is used to reserve addrs list
 * PARAMETERS
 *  in_addrs_list       [IN]        
 *  method(?)           [IN]        Mehtod_id (inet_method_enum)
 * RETURNS
 *  ret                String pointer
 *****************************************************************************/
kal_bool inet_msg_reverse_addr_list(inet_addr_list_struct **in_addrs_list)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (in_addrs_list == NULL || *in_addrs_list == NULL)
    {
        return KAL_FALSE;
    }
    else
    {
        inet_addr_list_struct *addrs_list_prev = NULL;
        inet_addr_list_struct *addrs_list_tp = NULL;
        inet_addr_list_struct *addrs_list = *in_addrs_list;

        while (addrs_list)
        {
            if (addrs_list->next)
            {
                addrs_list_tp = addrs_list->next;
            }
            else
            {
                addrs_list->next = addrs_list_prev;
                *in_addrs_list = addrs_list;
                return KAL_TRUE;
            }
            addrs_list->next = addrs_list_prev;
            addrs_list_prev = addrs_list;
            addrs_list = addrs_list_tp;
        }
        return KAL_FALSE;
    }
}


/*****************************************************************************
 * FUNCTION
 *  inet_msg_get_param
 * DESCRIPTION
 *  
 * PARAMETERS
 *  list            [?]     
 *  param_name      [?]     
 * RETURNS
 *  
 *****************************************************************************/
inet_param_struct *inet_msg_get_param(inet_param_list_struct *list, kal_char *param_name)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (!list || !list->object)
    {
        return NULL;
    }

    while (list)
    {
        if (list->object)
        {
            if (inet_msg_compare_cstring(list->object->name, param_name) == 0)
            {
                return list->object;
            }
        }
        else
        {
            break;
        }
        list = list->next;
    }
    return NULL;
}


/*****************************************************************************
 * FUNCTION
 *  inet_msg_get_param_val
 * DESCRIPTION
 *  
 * PARAMETERS
 *  list            [?]     
 *  param_name      [?]     
 * RETURNS
 *  
 *****************************************************************************/
kal_char *inet_msg_get_param_val(inet_param_list_struct *list, kal_char *param_name)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    inet_param_struct *param;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    param = inet_msg_get_param(list, param_name);

    if (param)
    {
        return param->value;
    }

    return NULL;
}


/*****************************************************************************
 * FUNCTION
 *  inet_cvt_hex
 * DESCRIPTION
 *  
 * PARAMETERS
 *  in          [?]         
 *  in_len      [IN]        
 *  out         [?]         
 *  out_len     [IN]        
 * RETURNS
 *  
 *****************************************************************************/
kal_bool inet_cvt_hex(kal_uint8 *in, kal_uint32 in_len, kal_uint8 *out, kal_uint32 out_len)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    unsigned short i;
    unsigned char j;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (((out_len - 1) >> 1) < in_len)
    {
        return KAL_FALSE;
    }

    for (i = 0; i < in_len; i++)
    {
        j = (*(in + i) >> 4) & 0xf;
        if (j <= 9)
        {
            *(out + i * 2) = (j + '0');
        }
        else
        {
            *(out + i * 2) = (j + 'a' - 10);
        }