/*
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
   | Copyright (c) 2010 Facebook, Inc. (http://www.facebook.com)          |
   | Copyright (c) 1997-2010 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.php.net/license/3_01.txt                                  |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
*/

#ifndef __EXTPROFILE_OPENSSL_H__
#define __EXTPROFILE_OPENSSL_H__

// >>>>>> Generated by idl.php. Do NOT modify. <<<<<<

#include <runtime/ext/ext_openssl.h>

namespace HPHP {
///////////////////////////////////////////////////////////////////////////////

inline bool x_openssl_csr_export_to_file(CVarRef csr, CStrRef outfilename, bool notext = true) {
  FUNCTION_INJECTION_BUILTIN(openssl_csr_export_to_file);
  return f_openssl_csr_export_to_file(csr, outfilename, notext);
}

inline bool x_openssl_csr_export(CVarRef csr, Variant out, bool notext = true) {
  FUNCTION_INJECTION_BUILTIN(openssl_csr_export);
  return f_openssl_csr_export(csr, ref(out), notext);
}

inline Variant x_openssl_csr_get_public_key(CVarRef csr) {
  FUNCTION_INJECTION_BUILTIN(openssl_csr_get_public_key);
  return f_openssl_csr_get_public_key(csr);
}

inline Variant x_openssl_csr_get_subject(CVarRef csr, bool use_shortnames = true) {
  FUNCTION_INJECTION_BUILTIN(openssl_csr_get_subject);
  return f_openssl_csr_get_subject(csr, use_shortnames);
}

inline Variant x_openssl_csr_new(CArrRef dn, Variant privkey, CVarRef configargs = null_variant, CVarRef extraattribs = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_csr_new);
  return f_openssl_csr_new(dn, ref(privkey), configargs, extraattribs);
}

inline Variant x_openssl_csr_sign(CVarRef csr, CVarRef cacert, CVarRef priv_key, int days, CVarRef configargs = null_variant, int serial = 0) {
  FUNCTION_INJECTION_BUILTIN(openssl_csr_sign);
  return f_openssl_csr_sign(csr, cacert, priv_key, days, configargs, serial);
}

inline Variant x_openssl_error_string() {
  FUNCTION_INJECTION_BUILTIN(openssl_error_string);
  return f_openssl_error_string();
}

inline bool x_openssl_open(CStrRef sealed_data, Variant open_data, CStrRef env_key, CVarRef priv_key_id) {
  FUNCTION_INJECTION_BUILTIN(openssl_open);
  return f_openssl_open(sealed_data, ref(open_data), env_key, priv_key_id);
}

inline bool x_openssl_pkcs12_export_to_file(CVarRef x509, CStrRef filename, CVarRef priv_key, CStrRef pass, CVarRef args = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs12_export_to_file);
  return f_openssl_pkcs12_export_to_file(x509, filename, priv_key, pass, args);
}

inline bool x_openssl_pkcs12_export(CVarRef x509, Variant out, CVarRef priv_key, CStrRef pass, CVarRef args = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs12_export);
  return f_openssl_pkcs12_export(x509, ref(out), priv_key, pass, args);
}

inline bool x_openssl_pkcs12_read(CStrRef pkcs12, Variant certs, CStrRef pass) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs12_read);
  return f_openssl_pkcs12_read(pkcs12, ref(certs), pass);
}

inline bool x_openssl_pkcs7_decrypt(CStrRef infilename, CStrRef outfilename, CVarRef recipcert, CVarRef recipkey = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs7_decrypt);
  return f_openssl_pkcs7_decrypt(infilename, outfilename, recipcert, recipkey);
}

inline bool x_openssl_pkcs7_encrypt(CStrRef infilename, CStrRef outfilename, CVarRef recipcerts, CArrRef headers, int flags = 0, int cipherid = k_OPENSSL_CIPHER_RC2_40) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs7_encrypt);
  return f_openssl_pkcs7_encrypt(infilename, outfilename, recipcerts, headers, flags, cipherid);
}

inline bool x_openssl_pkcs7_sign(CStrRef infilename, CStrRef outfilename, CVarRef signcert, CVarRef privkey, CVarRef headers, int flags = k_PKCS7_DETACHED, CStrRef extracerts = null_string) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs7_sign);
  return f_openssl_pkcs7_sign(infilename, outfilename, signcert, privkey, headers, flags, extracerts);
}

inline Variant x_openssl_pkcs7_verify(CStrRef filename, int flags, CStrRef outfilename = null_string, CArrRef cainfo = null_array, CStrRef extracerts = null_string, CStrRef content = null_string) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkcs7_verify);
  return f_openssl_pkcs7_verify(filename, flags, outfilename, cainfo, extracerts, content);
}

inline bool x_openssl_pkey_export_to_file(CVarRef key, CStrRef outfilename, CStrRef passphrase = null_string, CVarRef configargs = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_export_to_file);
  return f_openssl_pkey_export_to_file(key, outfilename, passphrase, configargs);
}

inline bool x_openssl_pkey_export(CVarRef key, Variant out, CStrRef passphrase = null_string, CVarRef configargs = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_export);
  return f_openssl_pkey_export(key, ref(out), passphrase, configargs);
}

inline void x_openssl_pkey_free(CObjRef key) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_free);
  f_openssl_pkey_free(key);
}

inline void x_openssl_free_key(CObjRef key) {
  FUNCTION_INJECTION_BUILTIN(openssl_free_key);
  f_openssl_free_key(key);
}

inline Array x_openssl_pkey_get_details(CObjRef key) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_get_details);
  return f_openssl_pkey_get_details(key);
}

inline Variant x_openssl_pkey_get_private(CVarRef key, CStrRef passphrase = null_string) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_get_private);
  return f_openssl_pkey_get_private(key, passphrase);
}

inline Variant x_openssl_get_privatekey(CVarRef key, CStrRef passphrase = null_string) {
  FUNCTION_INJECTION_BUILTIN(openssl_get_privatekey);
  return f_openssl_get_privatekey(key, passphrase);
}

inline Variant x_openssl_pkey_get_public(CVarRef certificate) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_get_public);
  return f_openssl_pkey_get_public(certificate);
}

inline Variant x_openssl_get_publickey(CVarRef certificate) {
  FUNCTION_INJECTION_BUILTIN(openssl_get_publickey);
  return f_openssl_get_publickey(certificate);
}

inline Object x_openssl_pkey_new(CVarRef configargs = null_variant) {
  FUNCTION_INJECTION_BUILTIN(openssl_pkey_new);
  return f_openssl_pkey_new(configargs);
}

inline bool x_openssl_private_decrypt(CStrRef data, Variant decrypted, CVarRef key, int padding = k_OPENSSL_PKCS1_PADDING) {
  FUNCTION_INJECTION_BUILTIN(openssl_private_decrypt);
  return f_openssl_private_decrypt(data, ref(decrypted), key, padding);
}

inline bool x_openssl_private_encrypt(CStrRef data, Variant crypted, CVarRef key, int padding = k_OPENSSL_PKCS1_PADDING) {
  FUNCTION_INJECTION_BUILTIN(openssl_private_encrypt);
  return f_openssl_private_encrypt(data, ref(crypted), key, padding);
}

inline bool x_openssl_public_decrypt(CStrRef data, Variant decrypted, CVarRef key, int padding = k_OPENSSL_PKCS1_PADDING) {
  FUNCTION_INJECTION_BUILTIN(openssl_public_decrypt);
  return f_openssl_public_decrypt(data, ref(decrypted), key, padding);
}

inline bool x_openssl_public_encrypt(CStrRef data, Variant crypted, CVarRef key, int padding = k_OPENSSL_PKCS1_PADDING) {
  FUNCTION_INJECTION_BUILTIN(openssl_public_encrypt);
  return f_openssl_public_encrypt(data, ref(crypted), key, padding);
}

inline Variant x_openssl_seal(CStrRef data, Variant sealed_data, Variant env_keys, CArrRef pub_key_ids) {
  FUNCTION_INJECTION_BUILTIN(openssl_seal);
  return f_openssl_seal(data, ref(sealed_data), ref(env_keys), pub_key_ids);
}

inline bool x_openssl_sign(CStrRef data, Variant signature, CVarRef priv_key_id, int signature_alg = k_OPENSSL_ALGO_SHA1) {
  FUNCTION_INJECTION_BUILTIN(openssl_sign);
  return f_openssl_sign(data, ref(signature), priv_key_id, signature_alg);
}

inline Variant x_openssl_verify(CStrRef data, CStrRef signature, CVarRef pub_key_id, int signature_alg = k_OPENSSL_ALGO_SHA1) {
  FUNCTION_INJECTION_BUILTIN(openssl_verify);
  return f_openssl_verify(data, signature, pub_key_id, signature_alg);
}

inline bool x_openssl_x509_check_private_key(CVarRef cert, CVarRef key) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_check_private_key);
  return f_openssl_x509_check_private_key(cert, key);
}

inline int x_openssl_x509_checkpurpose(CVarRef x509cert, int purpose, CArrRef cainfo = null_array, CStrRef untrustedfile = null_string) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_checkpurpose);
  return f_openssl_x509_checkpurpose(x509cert, purpose, cainfo, untrustedfile);
}

inline bool x_openssl_x509_export_to_file(CVarRef x509, CStrRef outfilename, bool notext = true) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_export_to_file);
  return f_openssl_x509_export_to_file(x509, outfilename, notext);
}

inline bool x_openssl_x509_export(CVarRef x509, Variant output, bool notext = true) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_export);
  return f_openssl_x509_export(x509, ref(output), notext);
}

inline void x_openssl_x509_free(CObjRef x509cert) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_free);
  f_openssl_x509_free(x509cert);
}

inline Variant x_openssl_x509_parse(CVarRef x509cert, bool shortnames = true) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_parse);
  return f_openssl_x509_parse(x509cert, shortnames);
}

inline Variant x_openssl_x509_read(CVarRef x509certdata) {
  FUNCTION_INJECTION_BUILTIN(openssl_x509_read);
  return f_openssl_x509_read(x509certdata);
}


///////////////////////////////////////////////////////////////////////////////
}

#endif // __EXTPROFILE_OPENSSL_H__