I have a function that calls itself recursively, I was going to rename the function which of course meant I would also have to change all self-calls. This caused me to wonder.. Can this be done dynamically?

Ten minutes of googling later, nothing found. Time to cobble some random ideas together!

$self_caller = __FUNCTION__;
$self_caller($args); //For functions
$this->$self_caller($args); //For methods

That's it! I'm not sure I would recommend doing this at all, seems hackish... but all concepts used here are documented on the php.net site: Variable functions, Magic constants

You have a bunch of classes that you use ubiquitously, some which you wrote and some which others have written. Each file has a single class in it, but since the classes are from difference sources, some of their files have non-consistent naming conventions. You have to include classes into the files which use them, so you might include all of the classes in a header file, but that will cause unnecessary overhead because even unneeded classes get included in ever file which uses the header at all. The other option is to individually include only the necessary classes into the files that use them, but what a pain in the ass!

Fortunately there is a third option, available in PHP 5.0+; it's called Autoloading Classes. Basically, as soon as an object of a class is created for which the source file has not yet been included a function called __autoload is called. Using that function, we can then include the appropriate class file just before the object is created. Thus avoiding including any additional classes via a header or having to type out extra includes. So how does this magical function work?

Here's a simple example from the PHP site:

function __autoload($class_name) {
    require_once $class_name . '.php';
}

Not bad, but rather restrictive. All it does is attempts to include a file called whateverYourClassIsCalled.php. If that file doesn't exist.. FATAL ERROR! Here is my version, which (at least to me) seems much more robust:

function __autoload($Name)
{
    $seperators = array('.', '-', '', '_');
    $namingConventions = array(
        'class[SEP]'.$Name,
        $Name.'[SEP]class',
        $Name,
    );
    $includePath = array(
        '/includes/',
        '/secondary/path/'
    );
    foreach ($includePath as $path)
        foreach ($seperators as $sep)
            foreach ($namingConventions as $convention)
                if (is_file($file = $_SERVER['DOCUMENT_ROOT'].$path.str_replace('[SEP]', $sep, $convention).'.php'))
                    include_once ($file);
}

My function searches for any of the following files inside any pre-specified includes folder.
class.Example.php
Example.class.php
Example.php
class-Example.php
Example-class.php
Example.php
classExample.php
Exampleclass.php
Example.php
class_Example.php
Example_class.php
Example.php

Efficiency may take a small hit (a ten-thousandth of a second on my machine for each additional path) if you specify multiple include folders, but I think the ease of never having to specify your class files is well worth it. Also, it's worth noting that my function is completely case-insensitive, trust me on that one.

Here's the PHP function:

function Bookmarkletize($source, $ieCompatible = false){
	$source = preg_replace('~[\t\r\n]~', '', $source);
	$source1 = 'javascript:'.rawurlencode($source);
	if($ieCompatible) return $source1;
	$source2 = 'javascript:eval(atob(\''.base64_encode($source).'\'))';
	if(strlen($source1) < strlen($source2))
		return $source1;
	else
		return $source2;
}

As an example, you can try "Bookmarkletizing" the source for the form hijacker I previously posted about. Here's what that would look like:

$source = <<<source
var index=prompt('Form index?', '0');
if(confirm('The action url is:\\n'+document.forms[index].action.substr(0,100)+'\\n\\nDoes that look right?')){
	document.forms[index].action='https://lococobra.com/showreq.php';
	document.forms[index].submit();
}
source;
echo Bookmarkletize($source);

(syntax might look funny, it's just because the PHP highlighting wordpress plugin I'm using doesn't support Heredoc string quoting)

Hope this is useful for someone!

Here's the problem: What information is actually getting submitted with the form?

The only way to form your curl request is if you know every single bit of data that's getting sent to the form. You could do this with a tool like the "Web Developer" add-on for Firefox, but then if there's some onsubmit javascript that affects the form in any way, you don't get those changes.

My solution: Using javascript, hijack the form and have it submit to a custom URL which will then tell you any variables sent through the headers.

The original javascript:

var index=prompt('Form index?', '0');
if(confirm('The action url is:\\n'+document.forms[index].action.substr(0,100)+'\\n\\nDoes that look right?')){
	document.forms[index].action='https://lococobra.com/showreq.php';
	document.forms[index].submit();
}

As you (maybe) can see, the code targets the Xth form on the page you're currently on, tells you where the form submits to (so you can submit to that url in cURL), and finally, submits the form to another script located at 'http://trappar.net/showreq.php'.

Lets make that into a bookmarklet! (Take a look at this to see how I made it)

javascript:eval(atob('dmFyIGluZGV4PXByb21wdCgnRm9ybSBpbmRleD8nLCAnMCcpO2lmKGNvbmZpcm0oJ1RoZSBhY3Rpb24gdXJsIGlzOlxuJytkb2N1bWVudC5mb3Jtc1tpbmRleF0uYWN0aW9uLnN1YnN0cigwLDEwMCkrJ1xuXG5Eb2VzIHRoYXQgbG9vayByaWdodD8nKSl7ZG9jdW1lbnQuZm9ybXNbaW5kZXhdLmFjdGlvbj0naHR0cHM6Ly9sb2NvY29icmEuY29tL3Nob3dyZXEucGhwJztkb2N1bWVudC5mb3Jtc1tpbmRleF0uc3VibWl0KCk7fQ=='))

Here's that in a link, if that helps: Bookmarklet

Now what does that new action URL do? It shows you all of the header variables that were sent through the form. Here's the code for that page (PHP)

<?
$vars = array('$_GET', '$_POST', '$_REQUEST', '$_FILES');
foreach($vars as $var)
	eval('if(count('.$var.') > 0) echo \'<h3>'.$var.'</h3><pre>\'.var_export('.$var.',true).\'</pre>\';');
?>

Voila! With one click you can take over any form and find out exactly what it's doing.

Before I get into what a "reference array" is (I made that term up) let me guide you through the discovery and some practical uses of the theory around references. A while ago I was looking for a way to do something in code that didn't seem very possible. I wanted to do this:

$var1 = 'Hello World';
echo $"var1";

Problem is, that doesn't work.. instead I found that you can use variable variables (also known as dynamic variables)

Variable Variables

$var1 = 'Hello World';
$var2 = 'var1';
echo $$var2;
Output: Hello World

So how does that code work? PHP parses the inside string and evaluates which outside string to call.

IF: $var1 = 'Hello World';
$var2 = 'var1';
THEN: $var1 == $$var2

But what's the practical use? Why on earth would we call a variable that way? When could there possibly be a situation where you don't already know the name of the variables you're accessing? I'll tell you with an example, it's one of my favorite pieces of code I've ever written. It's short and elegant and would probably be used by 80% of developers if they knew about it.

foreach($_REQUEST as $key=>$elem)
	$$key = $elem;

That code takes every $_GET, $_POST, and $_COOKIE variable and converts it like this:

IF: $_POST['foo'] = 'bar';
THEN: $foo = 'bar';

Form processing just became so much easier! Plus if you want you can add trim and stripslashes to make form processing even easier...

foreach($_REQUEST as $key=>$elem)
	$$key = trim(stripslashes($elem));

This is all well and good, but there's still a completely different way to do all this.

Using References

$var1 = 'Hello World';
$var2 = &$var1;
echo $var2;
OUTPUT: Hello World

In that code, $var2 is created as a reference to $var1, meaning the two can be used interchangeably. You can reassign the value of either $var1 or $var2 and both variables will reflect the change. What's interesting is, references can not be used to do the code I wrote earlier! Anyways, one more example before we get to reference arrays.

$var1 = 'Hello';
$var2 = ', ';
$var3 = 'World';
$varArr = array(&$var1, &$var2, &$var3);
$var1 = 'Goodbye';
$var2 = ' Cruel ';
foreach($varArr as $item)
	echo $item;
OUTPUT: Goodbye Cruel World

What's important here? You can use references to create an array which will always reflect the current information being stored in other variables. This can still be replicated by the double string approach though. Example:

$var1 = 'Hello';
$var2 = ', ';
$var3 = 'World';
$varArr = array('var1', 'var2', 'var3');
$var1 = 'Goodbye';
$var2 = ' Cruel ';
foreach($varArr as $item)
	echo $$item;
OUTPUT: Goodbye Cruel World

So by now if you're still even reading you're probably thinking "Why even use this stuff? What's the point? Especially what's the point of reference arrays?"

Using Reference Arrays

Lets say have several arrays filled with similar content, and we need to do some processing to the data in those arrays. You could combine the arrays, but what if you need them to be separate? I'll leave you with this rather simple example. If you have questions please post comments and I'll answer them.

$fruits = array(' appLE', 'pear3', 'banana--');
$vegetables = array('pea', 'broccoli   ');
$processArr = array(&$fruits, &$vegetables);
foreach($processArr as &$array)
	foreach($array as &$item)
	{
		$item = preg_replace('/[^a-z]/i', '', $item);
		$item = ucwords(strtolower($item));
	}
echo '<pre>';
print_r($fruits);
print_r($vegetables);