add_action('rss2_head', 'my_logo_rss');
 
# The value of <url> tag needs to point to the image. It DOES NOT have
# to be within the WordPress folder.
function my_logo_rss() {
  echo "<image>\n";
  echo "\t<title>" . get_bloginfo('title') . "</title>\n";
  echo "\t<url>" . get_bloginfo('siteurl)'. "/site_logo_rss.png</url>\n";
# echo "\t<url>http://your-site.com/images/site_logo_rss.png</url>\n";
  echo "\t<link>" . get_bloginfo('url') . "</link>\n";
  echo "\t<width>32</width>\n";
  echo "\t<height>32</height>\n";
  echo "\t</image>\n";
}

echo "\t<image>\n";
echo "\t<title>scenic stopovers</title>\n";
echo "\t<url>http://sgowtham.net/images/site_logo_rss.png</url>\n";
echo "\t<link>http://sgowtham.net/</link>\n";
echo "\t<width>32</width>\n";
echo "\t<height>32</height>\n";
echo "\t</image>\n";

<?php
# Function that accepts email address, width & rating as input parameters and returns
# the URL to the Gravatar associated with that email address.

function display_gravatar ($email, $width, $rating) {
  # MD5 hashed version of requested email address
  $hashed_email  = md5($email);
 
  $gravatar_url  = "http://www.gravatar.com/avatar.php?";
  $gravatar_url .= "gravatar_id=$hashed_email";
  $gravatar_url .= "&rating=$rating";
  $gravatar_url .= "&size=$width";
 
  return $gravatar_url;
}
?>

<?php
 
  # Get Gravatar URL
  # Change the width and rating, if necessary
  $gravatar_url = display_gravatar($email, '80', 'R');
 
  print "<img src=\"$gravatar_url\" border=\"0\" alt=\"Gravatar\" title=\"Gravatar\" align=\"left\">";
?>

<?php
 
# Length of security phrase
$phrase_length   = 6;
 
$security_phrase = SecurityPhrase($phrase_length);
 
function SecurityPhrase ($length) {
 
  # Start with a blank security_phrase
  $security_phrase = "";
 
  # Define possible characters
  # Exlude vowels to prevent offensive phrases
  $characters = "0123456789bcdfghjkmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"; 
 
  # A counter to keep track of number of characters 
  $i = 0;
 
  # Add random characters to $security_phrase until $length is reached
  while ($i < $length) { 
    # Pick a random character from the possible ones
    $character = substr($characters, mt_rand(0, strlen($possible)-1), 1);
 
    # Avoid repetition of characters
    if (!strstr($security_phrase, $character)) { 
      $security_phrase .= $character;
      $i++;
    }
  }
 
  # Temporary location to store the image
  # /var/www/html is the default DocumentRoot in Red Hat like distributions
  # The folder, 'tmp' must have read and write permissions for the apache (or the web) user
  $tmp_image_location = "/var/www/html/tmp/";
 
  # Filename of the image (PNG)
  # Security Phrase itself will be the filename
  $tmp_image_filename = $tmp_image_location . $security_phrase . ".png";
 
  # ImageMagick's 'convert' utility and options
  $text2img  = '/usr/bin/convert ';
  $text2img .= ' -background white ';
  $text2img .= ' -fill black ';
  $text2img .= ' -pointsize 30 ';
  $text2img .= ' -gravity West ';
  $text2img .= ' -wave 2x80';
  $text2img .= ' label:'.$security_phrase.' ';
  $text2img .= $tmp_image_filename;
 
  # Run the command
  system($text2img);
 
  # Display the image
  print "<img src=\"/tmp/$security_phrase.png\" border=\"0\">
         <br>";
 
  return $security_phrase;
 
}
 
?>

<form method="POST" action="APPROPRIATE URL">
<table border="0" cellpadding="5" cellspacing="3" align="center">
 
<tr>
<td valign="top"><b>Name</b></td>
<td valign="top">
  <input type="text" name="name" size="25">
  <font size="1" color="#000066">
  (Required)
  </font>
</td>
</tr>
 
<tr>
<td valign="top"><b>Email</b></td>
<td valign="top">
  <input type="text" name="email" size="25"> 
  <font size="1" color="#000066">
  (Required; must be valid; will not be shared or made public)
  </font>
</td>
</tr>
 
<tr>
<td valign="top"><b>URL</b></td>
<td valign="top">
  <input type="text" name="url" size="25">
  <font size="1" color="#000066">
  (Optional; please include http://)
  </font>
</td>
</tr>
 
<tr>
<td valign="top"><b>Security Phrase</b></td>
<td valign="top">
  <?php include('SecureImage.php'); ?>
  <input type="text" name="security_phrase" size="25"> 
  <font size="1" color="#000066">
  (Required; enter the characters shown above)
  </font>
</td>
</tr>
 
<tr>
<td valign="top"><b>Comments</b></td>
<td valign="top">
  <textarea name="comments" rows="6" cols="40"></textarea>
</td>
</tr>
 
<tr>
<td class="noborder">
&nbsp;
</td>
<td class="noborder">
  <input type="submit" value="Submit">
  <input type="reset" value="Clear">
</td>
</tr>
 
</table>
</form>

#! /usr/bin/php
<?php
# Connect to the database
$host     = "localhost";
$dbuser   = "MYSQL_USERID";
$dbpasswd = "MYSQL_PASSWD";
$database = "MYSQL_DB";
$connect  = mysql_connect($host, $dbuser, $dbpasswd) or die(mysql_error());
mysql_select_db($database,$connect) or die(mysql_error());
 
class FlickrRSSParser {
 
  # In Flickr's RSS file, all the information needed is contained in the <item> 
  # tags in the document. So the first global variable defined will be $insideitem, 
  # which will be set to true when entering an <item> tag and false when exiting one.
  var $insideitem  = false;
  var $tag         = "";
  var $title       = "";
  var $description = "";
  var $link        = "";
  var $pubdate     = "";
 
  # This function will be called by the XML parser whenever an opening tag is 
  # encountered
  # $parser will be passed a reference to the XML parser that is being used to 
  # parse the document
  # $tagName is the ALL-UPPERCASE (the PHP manual calls this 'case-folded')
  # version of the name of the opening tag that triggered the event
  # $attrs is an associative array of the attributes that are present in the tag
  # that triggered the event
  function startElement($parser, $tagName, $attrs) {
    if ($this->insideitem) {
      $this->tag = $tagName;
    } elseif ($tagName == "ITEM") {
      $this->insideitem = true;
    }
  }
 
  # $parser will be passed a reference to the XML parser that is being used to
  # parse the document
  # $tagName is the case-folded name of the closing tag that triggered the event
  function endElement($parser, $tagName) {
    if ($tagName == "ITEM") {
 
      # Image name: flickr.com displays the title as 'Comment on dsc_100-1234'
      # The filename is the 3rd array element
      $title        = htmlspecialchars(trim($this->title));
      $title        = explode(" ", $title);
      $filename     = $title[2];
 
      # Date/Time the comment was made (yyyy-mm-dd hh:mm:ss format)
      $pubdate      = htmlspecialchars(trim($this->pubdate));
      $pubdate      = strtotime($pubdate);
      $pubdate      = date("Y-m-d H:i:s", $pubdate);
 
      $paragraphs   = htmlspecialchars(trim($this->description));
      $paragraphs   = explode("&lt;/p&gt;", $paragraphs);
 
      # The description contains the link to comment-author's flickr profile and 
      # comment-author's name (first <p></p> section)
      $paragraph0   = $paragraphs[0];
      $authorurl    = explode("&quot;", $paragraph0);
      $author_url   = $authorurl[1];
 
      $authorname0  = explode("&gt;", $paragraph0);
      $authorname1  = $authorname0[2];
      $authorname2  = explode("&lt;", $authorname1);
      $author_name  = $authorname2[0];
 
      # The description also contains the comment-text (second <p></p> section)
      # Basic substitutions are done, via ereg_replace(), to get the appropriate part
      # mysql_real_escape_string() is used to make sure comment_text is in MySQL friendly fashion
      $paragraph1   = $paragraphs[1];
      $commenttext  = explode("&lt;p&gt;", $paragraph1);
      $comment_text = $commenttext[1];
      $comment_text = ereg_replace("&lt;br /&gt;", "<br>\r\n", $comment_text);
      $comment_text = mysql_real_escape_string($comment_text);
 
      # The description also contains a link to image-thumbnail (second <p></p> section)
      # but it's not required in this process - as such, it's ignored

      # flickr.com's IP address
      $flickr_ip    = gethostbyname('www.flickr.com');
 
      # comments_table structure
      # CREATE TABLE IF NOT EXISTS `comments_table` (
      #  `id`              int(11)      NOT NULL auto_increment,
      #  `datetime`        DATETIME     NOT NULL default '0000-00-00 00:00:00',
      #  `imagename`       varchar(254) NOT NULL,
      #  `authorip`        varchar(254) NOT NULL default '000.000.000.000',
      #  `authorhostname`  varchar(254) NOT NULL default 'localhost.localdomain',
      #  `authorname`      varchar(254) NOT NULL default 'Unknown',
      #  `authoremail`     varchar(254) NOT NULL default 'Unknown',
      #  `authorurl`       varchar(254) NOT NULL default 'Unknown',
      #  `comments`        text,
      #  `status`          varchar(3) NOT NULL default 'No',
      #
      #  UNIQUE KEY `id` (`id`)
      # ) ENGINE=MyISAM DEFAULT CHARSET latin1 AUTO_INCREMENT=1 ;
      #
      # CREATE UNIQUE INDEX author_datetime ON `comments_table` (`authorname`,`datetime`);
      #

      # Enter into the comments_table in database
      # INSERT IGNORE makes sure that duplicate entries, when exist, 
      # are ignored during insertion
      $sql_q        = "INSERT IGNORE INTO `MYSQL_DB`.`comments_table` ";
      $sql_q       .= "VALUES ('', '$pubdate', '$filename.jpg', '$flickr_ip', ";
      $sql_q       .= "'flickr.com', '$author_name', 'flickr@your-domain.com', ";
      $sql_q       .= "'$author_url', '$comment_text', 'Yes'); ";
      $result       = mysql_query($sql_q);
 
      if (!$result) {
        die('Invalid query: ' . mysql_error());
      }
 
      $this->title       = "";
      $this->description = "";
      $this->link        = "";
      $this->pubdate     = "";
      $this->insideitem  = false;
    }
  }
 
  # $parser will be passed a reference to the XML parser that is being used to
  # parse the document
  # $data is a string of text appearing between XML tags in the document. 
  # The text between two tags will not necessarily trigger a single event. 
  # Blocks of text spread over multiple lines will cause one event per line, 
  # with each event being passed the $data for that line.
  function characterData($parser, $data) {
    if ($this->insideitem) {
      switch ($this->tag) {
        case "TITLE":
        $this->title .= $data;
        break;
        case "DESCRIPTION":
        $this->description .= $data;
        break;
        case "PUBDATE":
        $this->pubdate .= $data;
        break;
        case "LINK":
        $this->link .= $data;
        break;
      }
    }
  }
}
 
# Create an XML parser
# Just as one must create a database connection in PHP to interact with a database, 
# one must create an XML parser to read in an XML file. In this case, a reference to 
# the parser is stored in $xml_parser.
$xml_parser = xml_parser_create();
 
$rss_parser = new FlickrRSSParser();
 
xml_set_object($xml_parser,&$rss_parser);
 
# This function specifies the functions that an XML parser should 
# use to process the events generated opening and closing tags. 
# In this case, the parser is the one stored in our $xml_parser variable, 
# while the functions are called startElement() and endElement()

xml_set_element_handler($xml_parser, "startElement", "endElement");
 
# This function specifies the function that the XML parser should use 
# to process character data appearing between tags in an XML document. 
# The function chosen to process character data is called characterData()
xml_set_character_data_handler($xml_parser, "characterData");
 
# Flickr's RSS Feed Comments URL must be entered here
$rss = "FLICKR_RSS_FEED_FOR_COMMENTS";
 
# Open the specified URL for reading
$fp = fopen($rss, "r")
  or die("Error reading RSS data.");
 
while ($data = fread($fp, 4096)) {
  # This function sends all or part of an XML document to the parser for it 
  # to process. The endOfDocument parameter should be set to true if the 
  # data marks the end of of XML document, or false if more of the document 
  # will follow in a subsequent call to xml_parse(). This allows the parser to 
  # correctly catch unclosed tags at the end of the document and so forth. 
  # In this case, the parser is once again $xml_parser. The $data variable 
  # (up to 4KB in size) retrieved from the file with fread() is passed as the 
  # data to be processed, while the feof() is used to determine whether 
  # PHP has reached the end of the XML file or not, thus providing the 
  # required endOfDocument parameter. If an error occurs in the parsing of 
  # the document, the error message is printed out along with the line of the 
  # file at which it occurs with xml_error_string, xml_get_error_code() and 
  # xml_get_current_line_number()
  xml_parse($xml_parser, $data, feof($fp))
    or die(sprintf("XML error: %s at line %d",
      xml_error_string(xml_get_error_code($xml_parser)),
      xml_get_current_line_number($xml_parser)));
}
 
fclose($fp);
 
# Although all memory resources are freed at the end of a PHP script, 
# one may wish to free up the memory used by the XML parser if the 
# script will perform other potentially memory-intensive tasks after it 
# parses the XML data. This function destroys the specified XML parser, 
# thus freeing up resources and memory it may have allocated for parsing.
xml_parser_free($xml_parser);
 
?>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body>
 
<!-- The data encoding type, enctype, MUST be specified as below -->
<form enctype="multipart/form-data" action="Uploader.php" method="POST">
  <table align="left" cellpadding="5" cellspacing="5" border="0" width="100%">
    <tr>
      <td align="left" valign="top">
        Select A File
      </td>
 
      <td align="left" valign="top">
        <!-- MAX_FILE_SIZE (measured in bytes) must precede the file input field and its value 
        is the maximum filesize accepted by PHP. Fooling this setting on the browser side is 
        quite easy, so never rely on files with a greater size being blocked by this feature. 
        The PHP settings for maximum-size, however, cannot be fooled. This form element 
        should always be used as it saves users the trouble of waiting for a big file being 
        transferred only to find that it was too big and the transfer failed. -->
        <input type="hidden" name="MAX_FILE_SIZE" value="4194304">
 
        <!-- Name of input element determines name in $_FILES array.
        uploaded_file is the reference assigned in the form. This will be needed to 
        tell the $_FILES array which file should be handled -->
        <input name="uploaded_file" type="file">
      </td>
    </tr>
 
    <tr>
      <td align="left" valign="top">
        &nbsp;
      </td>
 
      <td align="left" valign="top">
        <input type="submit" value="Upload This File">
      </td>
    </tr>
  </table>
</form>
 
</body>
</html>

<?php
# Some other MIME types are as follows
# $_FILES['uploaded_file']['type'] == 'application/pdf'
# $_FILES['uploaded_file']['type'] == 'application/xml'  
if ((($_FILES['uploaded_file']['type'] == 'image/gif')    ||
     ($_FILES['uploaded_file']['type'] == 'image/png')    ||
     ($_FILES['uploaded_file']['type'] == 'image/jpeg')   ||
     ($_FILES['uploaded_file']['type'] == 'image/pjpeg')) &&
     ($_FILES['uploaded_file']['size'] < 4194304)) {
 
  if ($_FILES['uploaded_file']['error'] > 0) {
    # The error code  associated with this file upload.
    echo "Error: "     . $_FILES['uploaded_file']['error'] . "<br>";
  } else {
    # The original name of the file on the client machine.
    echo "Upload: "    . $_FILES['uploaded_file']['name'] . "<br>";
 
    # The mime type of the file, if the browser provided this information. 
    # This mime type is however not checked on the PHP side and therefore it's value should
    # should not be taken for granted.
    echo "Type: "      . $_FILES['uploaded_file']['type'] . "<br>";
 
    # The size, in bytes, of the uploaded file.
    echo "Size: "      . ($_FILES['uploaded_file']['size'] / 1024) . " kB<br>";
 
    # The temporary filename of the file in which the uploaded file was stored on the server.
    echo "Stored in: " . $_FILES['uploaded_file']['tmp_name'] . "<br>";
 
    # Where the file is going to be placed and thumbnail will be creatd; choose this judiciously
    # These locations needs to have 'write' permissions for 'apache' (or the web-user)
    $target_path       = "tmp/";
    $target_thumb_path = "$target_path/thumbnails/";
 
    if(!is_writable($target_path)) {
      die('Cannot be uploaded to the specified directory. Please change permission  to 777.');
    }
 
    if(!is_writable($target_thumb_path)) {
      die('Thumbnail cannot be created. Please change permission  to 777.');
    }
 
    # This is the temporary file created by PHP
    $uploaded_file = $_FILES['uploaded_file']['tmp_name'];
    $target_path   = $target_path . basename( $_FILES['uploaded_file']['name']);
 
    # Create an image from the $uploaded_file so that it can be thumbnailed
    $src = imagecreatefromjpeg($uploaded_file);
 
    # Extract the original size of the uploaded image
    list($width, $height)=getimagesize($uploaded_file);
 
    # Let the thumbnail be 150 pixels in width, height adjusted based on original aspect ratio
    $new_width   = 150;
    $new_height  = ($height/$width)*$new_width;
    $tmp         = imagecreatetruecolor($new_width, $new_height);
 
    # The following line does the thumbnailing
    imagecopyresampled($tmp, $src, 0, 0, 0, 0, $new_width, $new_height, $width, $height);
 
    # Write the thumbnailed image to disk
    # Check/modify this part for other image types
    $filename = $target_thumb_path . $_FILES['uploaded_file']['name'];
    imagejpeg($tmp, $filename, 100);
 
    # PHP will clean up the temporary files after the request is completed
    imagedestroy($src);
    imagedestroy($tmp)
 
    if(move_uploaded_file($_FILES['uploaded_file']['tmp_name'], $target_path)) {
      echo "The file " .  basename( $_FILES['uploaded_file']['name']) . " has been uploaded";
    } else{
      echo "There was an error uploading the file, please try again!";
    }
  }
} else {
  echo "Invalid file type!";
}
?>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body>
 
<!-- The data encoding type, enctype, MUST be specified as below -->
<form enctype="multipart/form-data" action="Uploader.php" method="POST">
  <table align="left" cellpadding="5" cellspacing="5" border="0" width="100%">
    <tr>
      <td align="left" valign="top">
        Select A File
      </td>
 
      <td align="left" valign="top">
        <!-- MAX_FILE_SIZE (measured in bytes) must precede the file input field and its value 
        is the maximum filesize accepted by PHP. Fooling this setting on the browser side is 
        quite easy, so never rely on files with a greater size being blocked by this feature. 
        The PHP settings for maximum-size, however, cannot be fooled. This form element 
        should always be used as it saves users the trouble of waiting for a big file being 
        transferred only to find that it was too big and the transfer failed. -->
        <input type="hidden" name="MAX_FILE_SIZE" value="4194304">
 
        <!-- Name of input element determines name in $_FILES array.
        uploaded_file is the reference assigned in the form. This will be needed to 
        tell the $_FILES array which file should be handled -->
        <input name="uploaded_file" type="file">
      </td>
    </tr>
 
    <tr>
      <td align="left" valign="top">
        &nbsp;
      </td>
 
      <td align="left" valign="top">
        <input type="submit" value="Upload This File">
      </td>
    </tr>
  </table>
</form>
 
</body>
</html>

<?php
if ($_FILES['uploaded_file']['error'] > 0) {
  # The error code  associated with this file upload.
  echo "Error: "     . $_FILES['uploaded_file']['error'] . "<br>";
} else {
  # The original name of the file on the client machine.
  echo "Upload: "    . $_FILES['uploaded_file']['name'] . "<br>";
 
  # The mime type of the file, if the browser provided this information. 
  # This mime type is however not checked on the PHP side and therefore it's value should
  # should not be taken for granted.
  echo "Type: "      . $_FILES['uploaded_file']['type'] . "<br>";
 
  # The size, in bytes, of the uploaded file.
  echo "Size: "      . ($_FILES['uploaded_file']['size'] / 1024) . " kB<br>";
 
  # The temporary filename of the file in which the uploaded file was stored on the server.
  echo "Stored in: " . $_FILES['uploaded_file']['tmp_name'] . "<br>";
 
  # Where the file is going to be placed; choose this judiciously
  # This location needs to have 'write' permissions for 'apache' (or the web-user)
  $target_path = "tmp/";
 
  if(!is_writable($target_path)) {
    die('Cannot be uploaded to the specified directory. Please change permission  to 777.');
  }
 
  # This is the temporary file created by PHP.
  $uploaded_file = $_FILES['uploaded_file']['tmp_name'];
 
  $target_path = $target_path . basename( $_FILES['uploaded_file']['name']);
 
  if(move_uploaded_file($_FILES['uploaded_file']['tmp_name'], $target_path)) {
    echo "The file " .  basename( $_FILES['uploaded_file']['name']) . " has been uploaded";
  } else{
    echo "There was an error uploading the file, please try again!";
  }
}
?>