# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Name:        NetConnector
# Purpose:     Python urllib wrapper
#
# Author:      Alexander Thiemann
#
# Created:     10.10.2011
# Copyright:   (c) Alexander Thiemann 2011
#-------------------------------------------------------------------------------
 
import urllib.request, urllib.parse, urllib.error
import http.cookiejar
import time, sys
 
class NetConnector:
 
    def __init__(self, encoding='utf-8'):
        self.userAgent = 'Mozilla/5.0 (X11; U; Linux i686; de; rv:1.9) Gecko/2008060309 Firefox/3.0'
 
        self.encoding = encoding
        self.cookiejar = http.cookiejar.CookieJar()
        self.opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(self.cookiejar))
 
        urllib.request.install_opener(self.opener)
        self.opener.addheaders = [('User-agent', self.userAgent)]
 
    def request(self, url, params={}, noencode=False, internalCount=1):
 
        print("URL: " + url);
 
        data = ""
 
        try:
 
            if len(params) != 0:
                if noencode:
                    req = params["query"].encode(self.encoding)
                else:
                    req = urllib.parse.urlencode(params).encode(self.encoding)
                    print("Params: " + str(req))
 
                sock = self.opener.open(url, req)
            else:
                sock = self.opener.open(url)
 
            data = sock.read().decode(self.encoding)
            sock.close()
 
        except urllib.error.HTTPError as e:
            print("HTTP Error: "  + str(e.code))
 
        except urllib.error.URLError as e:
            print(e)
 
            if internalCount >= 2: # edit this!
                print("[error] connection error. returning ''");
                return ""
 
            print("[error] connection error. Sleeping " + str(internalCount) +  " seconds.")
            time.sleep(internalCount)
            data = self.request(url, params, noencode, internalCount+1)
 
        return data

connector = NetConnector();
connector.request("http://google.de") # get-request, returns response
connector.request("http://google.de", {'a': 'asdasd'}) # post-request, returns response

<?php
/**
 * a simple captcha
 *
 * @author Alexander Thiemann <mail@agrafix.net>
 */
class Captcha {
	/**
	 * generate new captcha code
	 *
	 */
	public static function reinit() {
		$_SESSION["xcaptcha"] = rand(10000, 99999);
	}
 
	/**
	 * check the userinput + captcha
	 *
	 * @param string $code
	 * @return bool
	 */
	public static function check($code) {
		if (isset($_SESSION["xcaptcha"]) && !empty($code) && $code == $_SESSION["xcaptcha"]) {
			return true;
		}
		else {
			return false;
		}
	}
 
	/**
	 * generate captcha image
	 *
	 */
	public static function generate() {
		$im = ImageCreate(55, 20);
		$white = ImageColorAllocate($im, 0xFF, 0xFF, 0xFF);
		$black = ImageColorAllocate($im, 0x00, 0x00, 0x00);
		ImageString($im, 4, 3, 3, $_SESSION["xcaptcha"], $black);
 
		header("Content-Type: image/png");
		ImagePNG($im);
		ImageDestroy($im);
	}
}
?>

<?php
/**
 * Simple CURL Wrapper
 *
 * @author Alexander Thiemann <mail@agrafix.net>
 */
class WebBrowser {
	/**
	 * saves curl session
	 *
	 * @var cURL
	 */
	private $ch = null;
 
	/**
	 * saves referer
	 *
	 * @var string
	 */
	private $ref = "";
 
	/**
	 * saves results
	 */
	public $result = "";
 
	/**
	 * init curl
	 *
	 */
	public function __construct() {
		$this->ch = curl_init();
	}
 
	/**
	 * destruct
	 *
	 */
	public function __destruct() {
		curl_close($this->ch);
	}
 
	/**
	 * post
	 *
	 * @param string $url
	 * @param string $data
	 */
	public function post($url, $data) {
		$this->result = "";
		curl_setopt($this->ch, CURLOPT_URL, $url);
		curl_setopt($this->ch, CURLOPT_POST, 1);
		curl_setopt($this->ch, CURLOPT_POSTFIELDS, $data);
		$this->refer($url);
		$this->setopts();
		ob_start();  
		$this->result = curl_exec($this->ch);
		ob_end_clean();
	}
 
	/**
	 * get
	 *
	 * @param string $url
	 */
	public function get($url) {
		$this->result = "";
		curl_setopt($this->ch, CURLOPT_URL, $url);
		$this->refer($url);
		$this->setopts();
		ob_start();  
		$this->result = curl_exec($this->ch);
		ob_end_clean();
	}
 
	/**
	 * update referer
	 *
	 * @param string $url
	 */
	private function refer($url) {
		curl_setopt ($this->ch, CURLOPT_REFERER, $this->ref);
		$this->ref = $url;
	}
 
	/**
	 * set global opts
	 *
	 */
	private function setopts() {
		curl_setopt($this->ch, CURLOPT_FOLLOWLOCATION, 1);
		curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
		// you may want to change this
		curl_setopt($this->ch, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 6.0; de; rv:1.9.0.9) Gecko/2009040821 Firefox/3.0.9 (.NET CLR 3.5.30729)");
		curl_setopt($this->ch, CURLOPT_COOKIEJAR, "cookie");
		curl_setopt($this->ch, CURLOPT_COOKIEFILE, "cookie");
	}
}
?>

$browser = new WebBrowser();
// einfaches get request; Resultat in Datei speichern
$browser->get("http://google.de");
$fp = fopen("tmp.txt", "w+");
fwrite($fp, $browser->result);
fclose($fp);
 
// post request
$browser->post("http://localhost/post.php", "test_data=" . urlencode("asdfg"));
// response is in $browser->result

<?php
/**
 * Solve a Hangman game
 *
 * @author Alexander Thiemann <mail@agrafix.net>
 */
class Hangman {
	/**
	 * asked letters
	 *
	 * @var array
	 */
	public $asked_letters = array();
 
	/**
	 * possible words
	 *
	 * @var array
	 */
	public $possible_worlds = array();
 
	/**
	 * construct hangman ;)
	 *
	 * @param string $state
	 */
	public function __construct($state) {
		$lines = file("wordlist.txt");
 
		foreach($lines As $line) {
			$n = strtolower(trim($line));
			if ($this->WordCompare($state, $n)) {
				$this->possible_worlds[] = $n;
			}
		}
	}
 
	/**
	 * fetch suggestion
	 *
	 * @return string
	 */
	public function getSuggestion() {
		$w = "enisratdhulcgmobwfkzpvjyxq"; // change this if you dont use german words!!
		for($i=0;$i<26;$i++) {
			//echo $w{$i};
			if (!in_array($w{$i}, $this->asked_letters) && $this->LetterInWords($w{$i})) {
				$this->asked_letters[] = $w{$i};
				return $w{$i};
			}
		}
	}
 
	/**
	 * check if letter is usefull
	 *
	 * @param string $letter
	 * @return bool
	 */
	public function LetterInWords($letter) {
 
		foreach ($this->possible_worlds As $w_out) {
			if (strpos($w_out, $letter) !== false) {
				return true;
			}
		}
 
		return false;
	}
 
	/**
	 * compare two words, * is placeholder
	 *
	 * @param string $word
	 * @param string $compare
	 * @return bool
	 */
	public function WordCompare($word, $compare) {
		$ln = strlen($word);
 
		if ($ln != strlen($compare)) {
			return false;
		}
 
		for ($i=0;$i<$ln;$i++) {
			if ($word{$i} != $compare{$i} && $word{$i} != "*") {
				return false;
			}
		}
 
		return true;
	}
}
?>

if (!isset($_GET["state"])) {
	$state = "***";
}
else {
	$state = $_GET["state"];
}
 
$Man = new Hangman($state);
 
if (isset($_GET["letters"])) {
	$Man->asked_letters = explode("|", $_GET["letters"]);
}
echo "Es sind noch ".count($Man->possible_worlds)." Kombinationen möglich.";
if (count($Man->possible_worlds) < 50) {
	echo "<br />".implode(", ", $Man->possible_worlds);
}
echo "<hr />";
echo $Man->getSuggestion();
echo "<hr />";
echo "<form action='Hangman.class.php'>State: <input value='".$state."' name='state' /> 
<input name='letters' value='".implode("|", $Man->asked_letters)."' />
<input type='submit' />
</form>";

<?php
/**
 * mySQL Database Class
 *
 * @author Alexander Thiemann <mail@agrafix.net>
 */
class RealSQL {
	/**
	 * db connector
	 *
	 * @var resource
	 */
	protected $conn;
 
	/**
	 * save last query
	 *
	 * @var string
	 */
	protected $last_query = "";
 
	/**
	 * save query results
	 *
	 * @var array
	 */
	protected $results = array();
 
	/**
	 * Store variables, eg. sql replacements
	 *
	 * @var array
	 */
	private $stored_variables = array();
 
	/**
	 * constructor -> connect
	 *
	 * @param string $host
	 * @param string $user
	 * @param string $pass
	 * @param string $db
	 */
	public function __construct($host, $user, $pass, $db) {
		$this->conn = @mysql_connect($host, $user, $pass);
 
		if (!$this->conn) {
			$this->error();
		}
 
		if (!@mysql_select_db($db, $this->conn)) {
			$this->error();
		}
	}
 
	/**
	 * execute query
	 *
	 * @param string $query
	 * @param int $id
	 */
	public function query($query, $id=0) {
		if (strpos($query, "INSERT INTO") !== false) {
			if (!@mysql_unbuffered_query($query, $this->conn)) {
				$this->last_query = $query;
				$this->error();
			}
		}
		else {
			$this->results[$id] = @mysql_query($query, $this->conn);
 
			if (!$this->results[$id]) {
				$this->last_query = $query;
				$this->error();
			}
		}
	}
 
	/**
	 * fetch as array/numrows/etc
	 *
	 * @param int $id
	 * @param string $fetchtype
	 */
	public function fetch($id=0, $fetchtype="") {
		switch(@$fetchtype) {
			case "num_rows":
				return mysql_num_rows($this->results[$id]);
				break;
 
			default:
				$ass = mysql_fetch_assoc($this->results[$id]);
 
				return $ass;
				break;
		}
	}
 
	/**
	 * fetch all in one array
	 *
	 * @param int $id
	 */
	public function tpl_fetch($id=0) {
		$array = array();
 
		while ($r = $this->fetch($id)) {
			$array[] = $r;
		}
 
		return $array;
	}
 
	/**
	 * insert stuff into db
	 *
	 * @param array $data_array
	 * @param string $table
	 */
	public function insert($data_array, $table) {
		$fields = array_keys($data_array);
 
		foreach ($data_array As $k => $v) {
			if (is_numeric($v)) {
				$data_array[$k] = (double)$v;
			}
			else {
				$data_array[$k] = "'".urlencode($v)."'";
			}
		}
 
		$query = "INSERT INTO `".$table."` (`".implode("`,`", $fields)."`) VALUES (".implode(", ", $data_array).")";
 
		$this->query($query);
	}
 
	/**
	 * update fieldset
	 *
	 * @param array $data_array
	 * @param string $table
	 * @param string $where
	 */
	public function update($data_array, $table, $where) {
 
		$update = array();
 
		foreach ($data_array As $k => $v) {
			if (is_numeric($v)) {
				$data_array[$k] = (int)$v;
			}
			else {
				$data_array[$k] = "'".urlencode($v)."'";
			}
 
			$update[] = "`$k` = ".$data_array[$k];
		}
 
		$query = "UPDATE `$table` SET ".implode(", ", $update)." WHERE $where";
 
		$this->query($query);
	}
 
	/**
	 * set param (automatic urlencode+stripslashes+')
	 *
	 * @param string $key
	 * @param string $value
	 */
	public function setParam($key, $value) {
		if (is_string($value)) {
			$i = "'".urlencode(stripslashes($value))."'";
		}
		elseif (is_numeric($value)) {
			$i = $value;
		}
		else {
			$i = "'".urlencode(stripslashes($value))."'";
		}
 
		$this->stored_variables[$key] = $i;
	}
 
	/**
	 * delete all params
	 *
	 */
	public function clearParams() {
		$this->stored_variables = array();
	}
 
	/**
	 * execute paramed query
	 *
	 * @param string $sql
	 * @param int $id
	 */
	public function exec($sql, $id=0) {
		foreach($this->stored_variables AS $key => $val) {
			$sql = str_replace("[$key]", $val, $sql);
		}
 
		$this->query($sql, $id);
	}
 
	/**
	 * returns last ai-id
	 *
	 * @return int
	 */
	public function lastId() {
		return mysql_insert_id($this->conn);
	}	
 
	/**
	 * error handler
	 *
	 */
	protected function error() {
		// uncomment this line 
		// if you have deployed the app
		#die("Internal Server Error."); 
		
		echo "<div style='border:2px solid red;padding:5px;margin:5px'>";
		echo "<h1>RealSQL Error Occured</h1>";
 
		if ($this->last_query != "") {
			echo "<h2>Query</h2><pr"."e>".htmlspecialchars($this->last_query)."</pr"."e>";
		}
 
		echo "<h2>Error</h2>".htmlspecialchars(mysql_error($this->conn));
 
		echo "<pr"."e>";
		print_r(debug_backtrace());
		echo "</pr"."e>";
 
		echo "</div>";
 
		exit;
	}
}
?>

$db = new RealSQL("localhost", "root", "", "test_db");
 
// einfach eine Query ausführen
$db->query("UPDATE user SET username = 'asdf' WHERE id = 1");
 
// query ausführen und Ergebnisse holen
$db->query("SELECT * FROM user", 1);
 
while ($row = $db->fetch(1))
{
	echo "Benutzer: " . $row['username'];
}
 
// neuen Eintrag in die DB
$db->insert(array('username' => 'test'), 'user');
 
// Eintrag ändern
$db->update(array('username' => 'banana'), 'user', 'id=2');
 
// Query mit Parametern
$db->setParam("user", $_POST['user']);
$db->setParam("pass", md5($_POST['pass']));
 
$db->exec("SELECT * FROM user WHERE username = [user] AND password = [pass]");
 
$db->clearParams();

<?php
/**
 * Language management class
 *
 * @author agrafix
 */
class aLang {
	/**
	 * saves ini section that is used
	 *
	 * @var string
	 */
	var $section = "";
 
	/**
	 * saves current language
	 *
	 * @var string
	 */
	var $lang = "";
 
	/**
	 * where do i find the language inis
	 *
	 * @var string
	 */
	var $path = "lang/";
 
	/**
	 * parsed ini array
	 *
	 * @var array
	 */
	var $parsed = array();
 
	/**
	 * setup the class
	 *
	 * @param string $section
	 * @param string $language
	 * @param string $path
	 */
	function aLang($section, $language, $path="") {
		$this->section = $section;
		$this->lang = $language;
 
		if (!empty($path)) {
			$this->path = $path;
		}
 
		$this->parse();
	}
 
	/**
	 * parse the language file
	 *
	 */
	function parse() {
		$filename = $this->path.$this->lang.".ini";
		$cachedata = $this->path.$this->lang.".cachedata";
		$cachearray = $this->path.$this->lang.".cachearray";
 
		if (!file_exists($filename)) {
			die("aLang Error: Language File for $this->lang doesn't exist!");
		}
 
		// caching system
		$ini_size = filesize($filename);
 
		if (file_exists($cachedata) && file_exists($cachearray)) {
			$cachesize = implode ('', file ($cachedata));
 
			if ($ini_size != $cachesize) { // reparse
				$this->reparse($filename);
			}
			else { // load from cache
				$serialized = base64_decode(implode('', file($cachearray)));
				$this->parsed = unserialize($serialized);
			}
		}
		else { // reparse
			$this->reparse($filename);
		}
	}
 
	/**
	 * parse ini file and write cache
	 *
	 * @param string $fname
	 */
	function reparse($fname) {
		$this->parsed = parse_ini_file($fname, true);
		$ini_size = filesize($fname);
 
		$fp = @fopen($this->path.$this->lang.".cachedata", "w+");
		@fwrite($fp, $ini_size);
		@fclose($fp);
 
		$fp = @fopen($this->path.$this->lang.".cachearray", "w+");
		@fwrite($fp, base64_encode(serialize($this->parsed)));
		@fclose($fp);
	}
 
	/**
	 * grab translation
	 *
	 * @param string $varname
	 * @return string
	 */
	function get($varname) {
		if (!isset($this->parsed[$this->section][$varname])) {
			die("aLang Error: $this->section[$varname] not found!");
		}
		return $this->parsed[$this->section][$varname];
	}
 
	/**
	 * grab translation out of specified section
	 *
	 * @param string $section
	 * @param string $varname
	 * @return string
	 */
	function grab($section, $varname) {
		if (!isset($this->parsed[$section][$varname])) {
			die("aLang Error: $section[$varname] not found!");
		}
 
		return $this->parsed[$section][$varname];
	}
}
?>

[main]
hello=Hallo
test=Das ist ein kleiner Test

$lang = new aLang("main", "de");
echo $lang->get("hello"); // prints Hello
echo "<br />";
echo $lang->get("test"); // prints Das ist ein kleiner Test

string script = @"var distance = function(x1, y1, x2, y2)
{
	return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
};";
 
double dist = (double)new JintEngine()
			.Run(script)
			.CallFunction("distance", 5, 5, 5, 10);

public class Randomizer {
	private Random r = new Random();
 
	public int getRandomInt()
	{
		return r.Next();
	}
}
 
int random123 = (int)new JintEngine()
	.setParameter("Randomizer", new Randomizer())
	.Run(@"var random_number = Randomizer.getRandomInt();
	return random_number + 123;");

#include <iostream>
 
using namespace std;
 
int main()
{
	cout << "Content-Type: text/html" << endl << endl;
 
	cout << "<html><head><title>Hello CGI</title></head><body>" << endl;
	cout << "<h1>C++ says Hi to the CGI API</h1>" << endl;
	cout << "</body></html>" << endl;
 
	return 0;
}

void getVariables(std::unordered_map<std::string, std::string> &variables)
{
	// fetch the query string
	char* raw_query_string = getenv("QUERY_STRING");
 
	// query string empty?
	if (raw_query_string == NULL) 
	{
		variables.clear();
		return variables;
	}
 
	// key and value into a stringstream, init with an empty stream
	// to make sure get-queries such as ?step=1&confirm are parsed 
	// correctly
	std::stringstream key, value;
 
	key.str(std::string(""));
	value.str(std::string(""));
 
	// are we currently parsing a key or a value?
	bool isKey = true;
 
	// loop until we read all raw data
	while (*raw_query_string != '\0')
	{
		// if we read a &, we'll change or type to key and store 
		// are previous key and value variables into out map
		// and clear them
		if (*raw_query_string == '&') 
		{ 
			variables[key.str()] = value.str();
			isKey = true; 
			key.str(std::string(""));
			value.str(std::string(""));
		}
		// if we read a =, we'll change or type to value
		else if (*raw_query_string == '=') 
		{ 
			isKey = false; 
		}
		// anything else goes into the currently active stream
		else 
		{
			if (isKey) { key << *raw_query_string; }
			else { value << *raw_query_string; }
		}
		// move pointer to next char
		raw_query_string++;
	}
 
	// store last key value pair, because query-strings 
	// normaly don't end on &
	variables[key.str()] = value.str();
 
	return variables;
}

std::string htmlspecialchars(std::string input)
{
	replaceAll("&", "&", input);
 
	replaceAll("<", "&lt;", input);
	replaceAll(">", "&gt;", input);
 
	replaceAll("'", "&#039;", input);
	replaceAll("\"", "&quot;", input);
 
	return input;
}
 
void replaceAll(std::string search, std::string replace, std::string &str)
{
	size_t currPos = 0;
	size_t findPos;
	while((findPos = str.find(search, currPos)) != std::string::npos) 
	{
		str.replace(findPos, search.size(), replace);
		currPos = findPos + replace.size();
	}
}

#include <iostream>
 
#include "mysql.h"
 
using namespace std;
 
int main()
{
	cout << "Content-Type: text/html" << endl << endl;
 
	cout << "<html>\n<head><title>mySQL TEST</title></head><body>" << endl;
 
	MYSQL *conn = mysql_init(NULL);
 
	if (mysql_real_connect(conn, "localhost", "root", "", "testdatabase", NULL, 0, NULL) == NULL)
	{
		printf("mySQL Error #%u: %s <br />\n", mysql_errno(conn), mysql_error(conn));
		return 0;
	}
 
	if (mysql_real_query(conn, "SELECT name, age FROM clients") != 0)
	{
		printf("mySQL Error #%u: %s <br />\n", mysql_errno(conn), mysql_error(conn));
		return 0;
	}
 
	cout << "<h1>Client age table:</h1><table> <tr> <th>Name</th> <th>age</th> </tr>" << endl;
 
	MYSQL_RES *result = mysql_store_result(conn);
	MYSQL_ROW row;
 
	while (row = mysql_fetch_row(result))
	{
		printf("<tr><td>%s</td><td>%d</td></tr>\n", row[0], row[1]);
	}
 
	mysql_free_result(result);
	mysql_close(conn);
 
	cout << "</table></body></html>" << endl;
 
	return 0;
}