bool TestExtFile::test_file_get_contents() {
Variant f = f_fopen("test/test_ext_file.tmp", "w");
f_fputs(f, "testing file_get_contents");
f_fclose(f);
VS(f_file_get_contents("test/test_ext_file.tmp"),
"testing file_get_contents");
VS(f_unserialize(f_file_get_contents("compress.zlib://test/test_zlib_file")),
CREATE_VECTOR1("rblock:216105"));
return Count(true);
}
bool TestExtOpenssl::test_openssl_csr_export_to_file() {
Variant csr = f_openssl_csr_new(null, null);
VERIFY(!csr.isNull());
const char *tmp = "test/test_csr.tmp";
f_unlink(tmp);
VS(f_file_get_contents(tmp), false);
f_openssl_csr_export_to_file(csr, tmp);
VERIFY(f_file_get_contents(tmp).toString().size() > 400);
f_unlink(tmp);
return Count(true);
}
bool TestExtOpenssl::test_openssl_pkey_export_to_file() {
const char *tmp = "test/test_pkey.tmp";
f_unlink(tmp);
VS(f_file_get_contents(tmp), false);
Variant privkey = f_openssl_pkey_new();
VERIFY(!privkey.isNull());
f_openssl_pkey_export_to_file(privkey, tmp, "1234");
VERIFY(f_file_get_contents(tmp).toString().size() > 400);
f_unlink(tmp);
return Count(true);
}
bool TestExtOpenssl::test_openssl_pkcs12_export_to_file() {
Variant privkey = f_openssl_pkey_new();
VERIFY(!privkey.isNull());
Variant csr = f_openssl_csr_new(null, privkey);
VERIFY(!csr.isNull());
Variant scert = f_openssl_csr_sign(csr, null, privkey, 365);
const char *tmp = "test/test_pkcs12.tmp";
f_unlink(tmp);
VS(f_file_get_contents(tmp), false);
f_openssl_pkcs12_export_to_file(scert, tmp, privkey, "1234");
VERIFY(f_file_get_contents(tmp).toString().size() > 400);
f_unlink(tmp);
return Count(true);
}
bool TestExtOpenssl::test_openssl_x509_free() {
Variant fcert = f_file_get_contents("test/test_x509.crt");
Variant cert = f_openssl_x509_read(fcert);
VERIFY(!cert.toObject().isNull());
f_openssl_x509_free(cert);
return Count(true);
}
bool TestExtOpenssl::test_openssl_pkcs7_sign() {
Variant privkey = f_openssl_pkey_new();
VERIFY(!privkey.isNull());
Variant csr = f_openssl_csr_new(null, privkey);
VERIFY(!csr.isNull());
Variant scert = f_openssl_csr_sign(csr, null, privkey, 365);
Variant pubkey = f_openssl_csr_get_public_key(csr);
VERIFY(!pubkey.isNull());
String data = "some secret data";
const char *infile = "test/test_pkcs7.in";
const char *outfile = "test/test_pkcs7.out";
f_unlink(infile);
f_unlink(outfile);
f_file_put_contents(infile, data);
VERIFY(f_openssl_pkcs7_sign
(infile, outfile, scert, privkey,
CREATE_MAP2("To", "*****@*****.**","From", "*****@*****.**")));
const char *tmp = "test/test_x509.tmp";
f_unlink(tmp);
VS(f_file_get_contents(tmp), false);
VERIFY(f_openssl_x509_export_to_file(scert, tmp));
VS(f_openssl_pkcs7_verify(outfile, 0, infile, Variant(tmp).toArray()), true);
f_unlink(infile);
f_unlink(outfile);
f_unlink(tmp);
return Count(true);
}
bool TestExtOpenssl::test_openssl_x509_parse() {
Variant fcert = f_file_get_contents("test/test_x509.crt");
Variant cert = f_openssl_x509_read(fcert);
Variant info = f_openssl_x509_parse(cert);
VS(info["subject"]["O"], "RSA Data Security, Inc.");
return Count(true);
}
bool TestExtOpenssl::test_openssl_x509_checkpurpose() {
Variant fcert = f_file_get_contents("test/test_x509.crt");
Variant cert = f_openssl_x509_read(fcert);
VS(f_openssl_x509_checkpurpose(cert, k_X509_PURPOSE_SSL_CLIENT), 0);
VS(f_openssl_x509_checkpurpose(cert, k_X509_PURPOSE_SSL_SERVER), 0);
return Count(true);
}
bool TestExtOpenssl::test_openssl_pkey_free() {
Variant fkey = f_file_get_contents("test/test_public.pem");
Variant k = f_openssl_pkey_get_public(fkey);
VERIFY(!same(k, false));
VERIFY(!k.isNull());
f_openssl_pkey_free(k);
return Count(true);
}
bool TestExtOpenssl::test_openssl_x509_export_to_file() {
Variant fcert = f_file_get_contents("test/test_x509.crt");
Variant cert = f_openssl_x509_read(fcert);
const char *tmp = "test/test_x509.tmp";
f_unlink(tmp);
VS(f_file_get_contents(tmp), false);
VERIFY(f_openssl_x509_export_to_file(cert, tmp));
Variant fcert2 = f_file_get_contents(tmp);
Variant cert2 = f_openssl_x509_read(fcert2);
Variant info = f_openssl_x509_parse(cert2);
VS(info["subject"]["O"], "RSA Data Security, Inc.");
f_unlink(tmp);
return Count(true);
}
bool TestExtOpenssl::test_openssl_pkey_get_details() {
{
Variant fkey = f_file_get_contents("test/test_public.pem");
Variant k = f_openssl_pkey_get_public(fkey);
VERIFY(!same(k, false));
VERIFY(!k.isNull());
VS(f_openssl_pkey_get_details(k)["bits"], 1024);
}
{
Variant fkey = f_file_get_contents("test/test_private.pem");
Variant k = f_openssl_pkey_get_private(fkey);
VERIFY(!same(k, false));
VERIFY(!k.isNull());
VS(f_openssl_pkey_get_details(k)["bits"], 512);
}
return Count(true);
}
bool TestExtOpenssl::test_openssl_x509_export() {
Variant fcert = f_file_get_contents("test/test_x509.crt");
Variant cert = f_openssl_x509_read(fcert);
Variant out;
VERIFY(f_openssl_x509_export(cert, ref(out)));
Variant cert2 = f_openssl_x509_read(out);
Variant info = f_openssl_x509_parse(cert2);
VS(info[s_subject][s_O], "RSA Data Security, Inc.");
return Count(true);
}
bool TestExtMailparse::test_mailparse_msg_create() {
const char *files[] = { "mime", "phpcvs1", "qp", "uue" };
for (unsigned int i = 0; i < sizeof(files)/sizeof(files[0]); i++) {
string file = files[i];
string testname = "test/ext/test_ext_mailparse." + file + ".txt";
string expname = "test/ext/test_ext_mailparse." + file + ".exp";
Variant mime = f_mailparse_msg_create();
PlainFile input;
input.open(testname, "r");
while (!input.eof()) {
String data = input.read(1024);
if (!data.isNull()) {
f_mailparse_msg_parse(mime, data);
}
}
input.close();
Array arr = f_mailparse_msg_get_structure(mime);
f_ob_start();
echo("Message: "); echo(file.c_str()); echo("\n");
for (ArrayIter iter(arr); iter; ++iter) {
Variant partname = iter.second();
int depth = f_count(f_explode(".", partname)) - 1;
String indent = f_str_repeat(" ", depth * 2);
Variant subpart = f_mailparse_msg_get_part(mime, partname);
if (subpart.isNull()) {
f_var_dump(partname); echo("\n");
f_var_dump(arr);
break;
}
Variant data = f_mailparse_msg_get_part_data(subpart);
echo("\n"); echo(indent); echo("Part "); echo(partname); echo("\n");
f_ksort(ref(data));
for (ArrayIter iter(data); iter; ++iter) {
String key = iter.first().toString();
if (key != "headers" && key != "ending-pos-body") {
echo(indent); echo(key); echo(" => ");
f_var_dump(iter.second());
}
}
}
String output = f_ob_get_contents();
Variant expect = f_file_get_contents(expname.c_str());
VS(output, expect);
f_ob_end_clean();
}
return Count(true);
}
// Tries to read the contents of the file whose path is specified in m_file.
// If the path cannot be resolved and is relative, the path of the sandbox
// is used to qualify the relative path. If the contents cannot be retrieved
// m_code will be an empty string.
// The function returns false if the reply to the client fails during the
// sending process.
bool CmdList::onServer(DebuggerProxy &proxy) {
auto savedWarningFrequency = RuntimeOption::WarningFrequency;
RuntimeOption::WarningFrequency = 0;
m_code = f_file_get_contents(m_file.c_str());
if (!proxy.isLocal() && !m_code.toBoolean() && m_file[0] != '/') {
DSandboxInfo info = proxy.getSandbox();
if (info.m_path.empty()) {
raise_warning("path for sandbox %s is not setup, run a web request",
info.desc().c_str());
} else {
std::string full_path = info.m_path + m_file;
m_code = f_file_get_contents(full_path.c_str());
}
}
RuntimeOption::WarningFrequency = savedWarningFrequency;
if (!m_code.toBoolean() && m_file == "systemlib.php") {
m_code = SystemLib::s_source;
}
return proxy.sendToClient((DebuggerCommand*)this);
}
bool CmdInstrument::onClientVM(DebuggerClient *client) {
if (DebuggerCommand::onClient(client)) return true;
if (client->argCount() == 1) {
if (client->argValue(1) == "list" || client->argValue(1) == "l") {
listInst(client);
return true;
}
if (client->argValue(1) == "clear" || client->argValue(1) == "c") {
clearInst(client);
return true;
}
}
if (client->argCount() < 2 || client->argValue(1) == "help") {
return help(client);
}
std::string loc = client->argValue(1);
std::string file = client->argValue(2);
std::string desc;
if (client->argCount() >= 3) {
desc = client->argValue(3);
}
Variant code = f_file_get_contents(file.c_str());
if (code.isNull()) {
client->error("Unable to read from file %s", file.c_str());
return false;
}
m_instPoints = client->getInstPoints();
if (loc == "here") {
InstPointInfoPtr ipi(new InstPointInfo());
ipi->setLocHere();
ipi->m_code = code.toString();
ipi->m_desc = desc;
m_instPoints->push_back(ipi);
} else if (loc.rfind("()") == loc.size() - 2){
InstPointInfoPtr ipi(new InstPointInfo());
ipi->setLocFuncEntry(loc.substr(0, loc.size() - 2));
ipi->m_code = code.toString();
ipi->m_desc = desc;
m_instPoints->push_back(ipi);
} else {
client->error("Not implemented\n");
return true;
}
m_type = ActionWrite;
CmdInstrumentPtr instCmdPtr = client->xend<CmdInstrument>(this);
if (!instCmdPtr->m_enabled) {
client->error("Instrumentation is not enabled on the server");
}
client->setInstPoints(instCmdPtr->m_ips);
CmdInstrument::PrintInstPoints(client);
return true;
}
Array f_get_meta_tags(CStrRef filename, bool use_include_path /* = false */) {
String f = f_file_get_contents(filename);
Variant matches;
f_preg_match_all("/<meta\\s+name=\"(.*?)\"\\s+content=\"(.*?)\".*?>/s",
f, ref(matches), k_PREG_SET_ORDER);
Array ret = Array::Create();
for (ArrayIter iter(matches); iter; ++iter) {
Array pair = iter.second();
ret.set(normalize_variable_name(pair[1].toString()), pair[2]);
}
return ret;
}
bool TestExtOpenssl::test_openssl_pkcs7_encrypt() {
Variant privkey = f_openssl_pkey_new();
VERIFY(!privkey.isNull());
Variant csr = f_openssl_csr_new(null, privkey);
VERIFY(!csr.isNull());
Variant scert = f_openssl_csr_sign(csr, null, privkey, 365);
Variant pubkey = f_openssl_csr_get_public_key(csr);
VERIFY(!pubkey.isNull());
String data = "some secret data";
const char *infile = "test/test_pkcs7.in";
const char *outfile = "test/test_pkcs7.out";
f_unlink(infile);
f_unlink(outfile);
f_file_put_contents(infile, data);
VERIFY(f_openssl_pkcs7_encrypt
(infile, outfile, scert,
CREATE_MAP2("To", "*****@*****.**","From", "*****@*****.**")));
f_unlink(infile);
VERIFY(f_openssl_pkcs7_decrypt(outfile, infile, scert, privkey));
Variant decrypted = f_file_get_contents(infile);
f_var_dump(decrypted);
f_unlink(infile);
f_unlink(outfile);
/*
* PHP didn't work either:
$privkey = openssl_pkey_new();
$csr = openssl_csr_new(array(), $privkey);
$scert = openssl_csr_sign($csr, null, $privkey, 365);
$data = "some secret data";
$infile = "test_pkcs7.in";
$outfile = "test_pkcs7.out";
file_put_contents($infile, $data);
openssl_pkcs7_encrypt($infile, $outfile, $scert,
array("To" => "*****@*****.**",
"From" => "*****@*****.**"));
var_dump(openssl_pkcs7_decrypt($outfile, $infile, $scert, $privkey));
$decrypted = file_get_contents($infile);var_dump($decrypted);
*/
return Count(true);
}
xmlDocPtr soap_xmlParseFile(const char *filename) {
const char *url = strstr(filename, "://");
if (url) {
xmlDocPtr ret;
xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(filename);
if (ctxt) {
ctxt->keepBlanks = 0;
ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
ctxt->sax->comment = soap_Comment;
ctxt->sax->warning = NULL;
ctxt->sax->error = NULL;
/*ctxt->sax->fatalError = NULL;*/
xmlParseDocument(ctxt);
if (ctxt->wellFormed) {
ret = ctxt->myDoc;
if (ret->URL == NULL && ctxt->directory != NULL) {
ret->URL = xmlCharStrdup(ctxt->directory);
}
} else {
ret = NULL;
xmlFreeDoc(ctxt->myDoc);
ctxt->myDoc = NULL;
}
xmlFreeParserCtxt(ctxt);
} else {
ret = NULL;
}
if (ret) {
cleanup_xml_node((xmlNodePtr)ret);
}
return ret;
}
Variant content = f_file_get_contents(filename);
if (!same(content, false)) {
String scontent = content.toString();
return soap_xmlParseMemory(scontent.data(), scontent.size());
}
return NULL;
}
bool TestExtFile::test_file_put_contents() {
f_file_put_contents("test/test_ext_file.tmp", "testing file_put_contents");
VS(f_file_get_contents("test/test_ext_file.tmp"),
"testing file_put_contents");
return Count(true);
}
