Why this base64 function stop working when increasing max length?

Question

I am using this class to encode/decode text to base64. It works fine with MAX_LEN up to 512 but if I increase it to 1024 the decode function returns and empty var.

This is the function:

char* Base64::decode(char *src)
{
    unsigned six, dix;
    unsigned int d_len = MAX_LEN;

    memset(dst,'\0', MAX_LEN); 

    unsigned s_len = strlen(src);
    dix = 0;

    for (six = 0; six < s_len; six += 4)
    {
        unsigned long sr;
        unsigned ix;

        sr = 0;
        for (ix = 0; ix < 4; ++ix)
        {
            int sextet;

            if (six+ix >= s_len)
                return NULL;
            if ((sextet = tlu(*(src+six+ix))) < 0)
                break;
            sr <<= 6;
            sr |= (sextet & 0x3f);
        }

        switch (ix)
        {
            case 0: // end of data, no padding
                return 0;

            case 1: // can't happen
                return NULL;

            case 2: // 1 result byte 
                sr >>= 4;
                if (dix > d_len) return NULL;
                *(dst+dix) = (sr & 0xff);
                ++dix;
                break;
            case 3: // 2 result bytes 
                sr >>= 2;
                if (dix+1 > d_len) return NULL;
                *(dst+dix+1) = (sr & 0xff);
                sr >>= 8;
                *(dst+dix) = (sr & 0xff);
                dix += 2;
                break;
            case 4: // 3 result bytes 
                if (dix+2 > d_len) return NULL;
                *(dst+dix+2) = (sr & 0xff);
                sr >>= 8;
                *(dst+dix+1) = (sr & 0xff);
                sr >>= 8;
                *(dst+dix) = (sr & 0xff);
                dix += 3;
                break;
        }
    }

    return dst;
}

Why could be causing this?

Answer 1

Odds are dst is not sized correctly to hold all 1024 bytes. Without seeing dst's declaration there is no way to be sure.