Back to index

php5  5.3.10
Functions
base64.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

 PHP_FUNCTION (base64_decode)
 PHP_FUNCTION (base64_encode)
PHPAPI unsigned char * php_base64_encode (const unsigned char *, int, int *)
PHPAPI unsigned char * php_base64_decode_ex (const unsigned char *, int, int *, zend_bool)
PHPAPI unsigned char * php_base64_decode (const unsigned char *, int, int *)

Function Documentation

PHPAPI unsigned char* php_base64_decode ( const unsigned char *  ,
int  ,
int  
)

Definition at line 137 of file base64.c.

{
       return php_base64_decode_ex(str, length, ret_length, 0);
}
PHPAPI unsigned char* php_base64_decode_ex ( const unsigned char *  ,
int  ,
int ,
zend_bool   
)

Definition at line 143 of file base64.c.

{
       const unsigned char *current = str;
       int ch, i = 0, j = 0, k;
       /* this sucks for threaded environments */
       unsigned char *result;

       result = (unsigned char *)safe_emalloc(length, 1, 1);

       /* run through the whole string, converting as we go */
       while ((ch = *current++) != '\0' && length-- > 0) {
              if (ch == base64_pad) {
                     if (*current != '=' && ((i % 4) == 1 || (strict && length > 0))) {
                            if ((i % 4) != 1) {
                                   while (isspace(*(++current))) {
                                          continue;
                                   }
                                   if (*current == '\0') {
                                          continue;
                                   }
                            }
                            efree(result);
                            return NULL;
                     }
                     continue;
              }

              ch = base64_reverse_table[ch];
              if ((!strict && ch < 0) || ch == -1) { /* a space or some other separator character, we simply skip over */
                     continue;
              } else if (ch == -2) {
                     efree(result);
                     return NULL;
              }

              switch(i % 4) {
              case 0:
                     result[j] = ch << 2;
                     break;
              case 1:
                     result[j++] |= ch >> 4;
                     result[j] = (ch & 0x0f) << 4;
                     break;
              case 2:
                     result[j++] |= ch >>2;
                     result[j] = (ch & 0x03) << 6;
                     break;
              case 3:
                     result[j++] |= ch;
                     break;
              }
              i++;
       }

       k = j;
       /* mop things up if we ended on a boundary */
       if (ch == base64_pad) {
              switch(i % 4) {
              case 1:
                     efree(result);
                     return NULL;
              case 2:
                     k++;
              case 3:
                     result[k] = 0;
              }
       }
       if(ret_length) {
              *ret_length = j;
       }
       result[j] = '\0';
       return result;
}

Here is the caller graph for this function:

PHPAPI unsigned char* php_base64_encode ( const unsigned char *  ,
int  ,
int  
)

Definition at line 56 of file base64.c.

{
       const unsigned char *current = str;
       unsigned char *p;
       unsigned char *result;

       if ((length + 2) < 0 || ((length + 2) / 3) >= (1 << (sizeof(int) * 8 - 2))) {
              if (ret_length != NULL) {
                     *ret_length = 0;
              }
              return NULL;
       }

       result = (unsigned char *)safe_emalloc(((length + 2) / 3) * 4, sizeof(char), 1);
       p = result;

       while (length > 2) { /* keep going until we have less than 24 bits */
              *p++ = base64_table[current[0] >> 2];
              *p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
              *p++ = base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
              *p++ = base64_table[current[2] & 0x3f];

              current += 3;
              length -= 3; /* we just handle 3 octets of data */
       }

       /* now deal with the tail end of things */
       if (length != 0) {
              *p++ = base64_table[current[0] >> 2];
              if (length > 1) {
                     *p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
                     *p++ = base64_table[(current[1] & 0x0f) << 2];
                     *p++ = base64_pad;
              } else {
                     *p++ = base64_table[(current[0] & 0x03) << 4];
                     *p++ = base64_pad;
                     *p++ = base64_pad;
              }
       }
       if (ret_length != NULL) {
              *ret_length = (int)(p - result);
       }
       *p = '\0';
       return result;
}

Here is the caller graph for this function:

PHP_FUNCTION ( base64_decode  )

Definition at line 240 of file base64.c.

{
       char *str;
       unsigned char *result;
       zend_bool strict = 0;
       int str_len, ret_length;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &str, &str_len, &strict) == FAILURE) {
              return;
       }
       result = php_base64_decode_ex((unsigned char*)str, str_len, &ret_length, strict);
       if (result != NULL) {
              RETVAL_STRINGL((char*)result, ret_length, 0);
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( base64_encode  )

Definition at line 220 of file base64.c.

{
       char *str;
       unsigned char *result;
       int str_len, ret_length;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
              return;
       }
       result = php_base64_encode((unsigned char*)str, str_len, &ret_length);
       if (result != NULL) {
              RETVAL_STRINGL((char*)result, ret_length, 0);
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function: