C++ (Cpp) calcDecodeLength 예제들

예제 #1

파일: Utils.cpp 프로젝트: mrG7/VoIPserver

int Base64Decode(char* b64message, char** buffer, int *decl) { //Decodes a base64 encoded string
    BIO *bio, *b64;
    int decodeLen = calcDecodeLength(b64message),
            len = 0;
    *buffer = (char*)malloc(decodeLen+1);
    FILE* stream = fmemopen(b64message, strlen(b64message), "r");
    memset(*buffer, 0x00, decodeLen+1);

    b64 = BIO_new(BIO_f_base64());
    bio = BIO_new_fp(stream, BIO_NOCLOSE);
    // bio = BIO_new_mem_buf(b64message,strlen(b64message) );
    bio = BIO_push(b64, bio);
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer
    len = BIO_read(bio, *buffer, strlen(b64message));
    //Can test here if len == decodeLen - if not, then return an error
    //(*buffer)[len] = '\0';

    // BIO_free(b64);
    BIO_free_all(bio);

    fclose(stream);

    *decl = len;
    return (0); //success
}

예제 #2

파일: polypseud.c 프로젝트: polymorphic-pseudonyms/libpolypseud

int Base64Decode(char* b64message, unsigned char** buffer, size_t* length) { //Decodes a base64 encoded string
    BIO *bio, *b64;

    size_t decodeLen = calcDecodeLength(b64message);
    *buffer = (unsigned char*)malloc(decodeLen + 1);

    bio = BIO_new_mem_buf(b64message, -1);
    b64 = BIO_new(BIO_f_base64());
    bio = BIO_push(b64, bio);

    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer
    *length = BIO_read(bio, *buffer, strlen(b64message));
    assert(*length == decodeLen); //length should equal decodeLen, else something went horribly wrong
    BIO_free_all(bio);

    return (0); //success
}

예제 #3

파일: base64.c 프로젝트: linanfang/usage

int 
Base64Decode(char* b64message, char** buffer) { //Decodes a base64 encoded string
    BIO *bio, *b64;
    int decodeLen = calcDecodeLength(b64message), len = 0;
    *buffer = (char*)malloc(decodeLen+1);
    FILE* stream = fmemopen(b64message, strlen(b64message), "r");
             
    b64 = BIO_new(BIO_f_base64());
    bio = BIO_new_fp(stream, BIO_NOCLOSE);
    bio = BIO_push(b64, bio);
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); //Do not use newlines to flush buffer
    len = BIO_read(bio, *buffer, strlen(b64message));
    (*buffer)[len] = '\0';
                             
    BIO_free_all(bio);
    fclose(stream);
                                  
    return(0);
}

예제 #4

파일: ct_monitor.c 프로젝트: robstradling/ct_monitor

int Base64Decode(char* b64message, char** buffer) { /*Decodes a base64 encoded string*/
  BIO *bio, *b64;
  FILE* stream;
  int decodeLen = calcDecodeLength(b64message),
      len = 0;
  *buffer = (char*)malloc(decodeLen+1);
  stream = fmemopen(b64message, strlen(b64message), "r");
 
  b64 = BIO_new(BIO_f_base64());
  bio = BIO_new_fp(stream, BIO_NOCLOSE);
  bio = BIO_push(b64, bio);
  BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); /*Do not use newlines to flush buffer*/
  len = BIO_read(bio, *buffer, strlen(b64message));
    /*Can test here if len == decodeLen - if not, then return an error*/
  (*buffer)[len] = '\0';
 
  BIO_free_all(bio);
  fclose(stream);
 
  return (0); /*success*/
}

예제 #5

파일: crypto_openssl.cpp 프로젝트: qwertychouskie/stk-code

// ============================================================================
std::vector<uint8_t> Crypto::decode64(std::string input)
{
    BIO *b64, *bmem;
    size_t decode_len = calcDecodeLength(input);
    std::vector<uint8_t> result(decode_len, 0);
    b64 = BIO_new(BIO_f_base64());

    bmem = BIO_new_mem_buf(&input[0], (int)input.size());
    bmem = BIO_push(b64, bmem);

    BIO_set_flags(bmem, BIO_FLAGS_BASE64_NO_NL);
#ifdef DEBUG
    size_t read_l = BIO_read(bmem, result.data(), (int)input.size());
    assert(read_l == decode_len);
#else
    BIO_read(bmem, result.data(), (int)input.size());
#endif
    BIO_free_all(bmem);

    return result;
}   // decode64

예제 #6

파일: base64.cpp 프로젝트: philsong/unitrade

int base64Decode(const char *b64message, const size_t length, unsigned char **buffer) {
    BIO *bio;
    BIO *b64;
    int decodedLength = calcDecodeLength(b64message, length);

    *buffer = (unsigned char*)malloc(decodedLength+1);
    if(*buffer == NULL) {
        fprintf(stderr, "Failed to allocate memory\n");
        exit(1);
    }
    FILE* stream = fmemopen((char*)b64message, length);
     
    b64 = BIO_new(BIO_f_base64());
    bio = BIO_new_fp(stream, BIO_NOCLOSE);
    bio = BIO_push(b64, bio);
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
    decodedLength = BIO_read(bio, *buffer, length);
    (*buffer)[decodedLength] = '\0';
     
    BIO_free_all(bio);
    fclose(stream);     
    return decodedLength;
}