app_base64.c

最新MTK手机软件源码

                                if (destl < (kal_uint32) (temp_dst - dst))
                                {
                                    return -1;
                                }

                                destl -= (kal_uint32) (temp_dst - dst);

                                kal_mem_cpy(dest + rt, dst, ((kal_char*) temp_dst - dst));
                                kal_mem_set(dst, 0, APP_BASE64_BUF_LEN);
                                rt = rt + ((kal_char*) temp_dst - dst);
                                temp_dst = dst; /* Reset the temp_dst back to dst */
                            }
                        }   /* if(srcl==0) */
                        break;

                    case 2:
                        /* expect a second = in quantum 2 */
                        if (srcl == 0)
                        {
                            if (temp_dst != dst)
                            {
                                if (destl < (kal_uint32) (temp_dst - dst))
                                {
                                    return -1;
                                }

                                destl -= (kal_uint32) (temp_dst - dst);

                                kal_mem_cpy(dest + rt, dst, ((kal_char*) temp_dst - dst));
                                kal_mem_set(dst, 0, APP_BASE64_BUF_LEN);
                                rt = rt + ((kal_char*) temp_dst - dst);
                                temp_dst = dst;
                            }
                        }   /* if(srcl==0) */

                        if (srcl && (*src == '='))
                        {
                            break;
                        }

                    default:
                        /* impossible quantum position */
                        return -1;

                }   /* switch */
                break;
        }           /* switch */
    }               /* for */

    /* Any Left over bytes present in the dst and if needs to be copied */
    if (temp_dst != dst)
    {
        if (destl < (kal_uint32) (temp_dst - dst))
        {
            return -1;
        }

        destl -= (kal_uint32) (temp_dst - dst);

        kal_mem_cpy(dest + rt, dst, ((kal_char*) temp_dst - dst));
        kal_mem_set(dst, 0, APP_BASE64_BUF_LEN);
        rt = rt + ((kal_char*) temp_dst - dst);
        temp_dst = dst;
    }

    if (destl < 1)
    {
        return -1;
    }

    *(dest + rt) = '\0';

    return (kal_int32) rt;  /* Assigning the Final decoded data length as in Source buffer */

}   /* end of applib_base64_decode */


/*****************************************************************************
 * FUNCTION
 *  applib_find_base64_boundary
 * DESCRIPTION
 *  This function finds the boundary in the base64 encoded text.
 * PARAMETERS
 *  ptr     [IN]        Pointer to the encoded buffer
 *  len     [IN]        Length of encoded data
 * RETURNS
 *  number of bytes shall be skipped.
 *****************************************************************************/
kal_uint16 applib_find_base64_boundary(kal_char *ptr, kal_int32 len)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 i;

    /* with initial values */
    kal_uint16 left_over_bytes = len;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (len <= 0)   /* no data */
    {
        return 0;
    }

    for (i = len - 1; i > 0; i--)
    {
        if (*(ptr + i - 1) == '\r' && *(ptr + i) == '\n')
        {
            left_over_bytes = len - i + 1 - 2 /* crlf */ ;
            break;
        }

        /* Handle the case that the line is ended with only LF not CRLF */
        if (*(ptr + i) == '\n')
        {
            left_over_bytes = len - i + 1 - 1 /* lf */ ;
            break;
        }
    }

    return left_over_bytes;

}   /* end of applib_find_base64_boundary */


/*****************************************************************************
 * FUNCTION
 *  applib_base64_encode
 * DESCRIPTION
 *  This function is used to encode given string into base64 encoded string.
 * PARAMETERS
 *  src         [IN]            Source data
 *  srcl        [IN]            Source data length
 *  dest        [IN/OUT]        Encoded data
 *  destl       [IN]            Destination buffer length
 * RETURNS
 *  negative: error
 *  ow:length of encoded string
 *****************************************************************************/
kal_int32 applib_base64_encode(kal_char *src, kal_uint32 srcl, kal_char *dest, kal_uint32 destl)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 *d;
    kal_uint8 *s = (kal_uint8*) src;
    kal_uint32 i = ((srcl + 2) / 3) * 4;    /* 6 bit ==> 8 bit */

    kal_int32 ret = (kal_int32) (i += 2 * ((i / 76) + 1));

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    d = (kal_uint8*) dest;

    kal_mem_set(d, 0, destl);   /* reset */

    /* process tuplets */
    for (i = 0; srcl >= 3; s += 3, srcl -= 3)
    {
        APP_BASE64_ENCODE_1(d, s, destl);

        if ((++i) == 19)
        {
            if (destl < 2)
            {
                return -1;
            }

            /* output 76 characters? */
            i = 0;  /* restart line break count, insert CRLF */
            *d++ = '\015';
            *d++ = '\012';

            destl -= 2;
        }
    }

    if (srcl)
    {
        APP_BASE64_ENCODE_2(d, s, srcl, destl);

        if (srcl)
        {
            srcl--; /* count third character if processed */
        }

        if ((++i) == 19)
        {
            if (destl < 2)
            {
                return -1;
            }

            /* output 76 characters? */
            i = 0;  /* restart line break count, insert CRLF */
            *d++ = '\015';
            *d++ = '\012';

            destl -= 2;
        }
    }

    if (destl < 3)
    {
        return -1;
    }

    *d++ = '\015';
    *d++ = '\012';  /* insert final CRLF */
    *d = '\0';      /* tie off string */

    destl -= 3;

    return ret;

}   /* end of applib_base64_encode */