WEB邮件程序

开发平台：
PHP

class.Validator.inc：源码内容
							<?php
# bookmarker RCS version info:
# $Id: class.Validator.inc,v 1.2 2000/04/11 14:46:24 prenagha Exp $
/*
	Validator 1.2  1999/03/05 CDI
	A class for validating common data from forms
	Copyright (c) 1999 CDI, cdi@thewebmasters.net All Rights Reserved
*/
class Validator
{
	var $ERROR	=	"";
	var $CLEAR	=	false;
	function Validator ()
	{
		return;
	}
	function clear_error ()
	{
		$this->ERROR = "";
	}
//	************************************************************
//	Checks a string for whitespace. True or false
	function has_space ($text)
	{
		if( ereg("[ 	]",$text) )
		{
			return true;
		}
		return false;		
	}
//	************************************************************
	function chconvert ($fragment)
	{
		if      ($fragment == 7) { $result = "rwx"; }
		elseif  ($fragment == 6) { $result = "rw-"; }
		elseif  ($fragment == 5) { $result = "r-x"; }
		elseif  ($fragment == 4) { $result = "r--"; }
		elseif  ($fragment == 3) { $result = "-wx"; }
		elseif  ($fragment == 2) { $result = "-w-"; }
		elseif  ($fragment == 1) { $result = "--x"; }
		elseif  ($fragment == 0) { $result = "---"; }
		else	{ $result = "unk"; }
		return($result);
    }
//	************************************************************
	function get_perms ($fileName )
	{
		if($this->CLEAR) { $this->clear_error(); }
		$atrib = array();
		$perms = fileperms($fileName);
		if(!$perms)
		{
			$this->ERROR = "get_perms: Unable to obtain file perms on [$fileName]";
			return false;
		}
		$octal = sprintf("%lo", ($perms & 07777) );
		$one = substr($octal,0,1);
		$two = substr($octal,1,1);
		$three = substr($octal,2,1);
		$user  = $this->chconvert($one);
		$group = $this->chconvert($two);
		$other = $this->chconvert($three);
		if(is_dir($fileName))
		{
			$user = "d$user";
		}
		$atrib = array(
						"octal"	=>	$octal,
						"user"	=>	$user,
						"group"	=>	$group,
						"other"	=>	$other
					);
		return $atrib;
	}
//	************************************************************
	function is_sane ($filename)
	{
		if($this->CLEAR) { $this->clear_error(); }
		if (!file_exists($filename))
		{
			$this->ERROR = "File does not exist";
			return false;
		}
		if (!is_readable($filename))
		{
			$this->ERROR = "File is not readable";
			return false;
		}
		if(!is_writeable($filename))
		{
			$this->ERROR = "File is not writeable";
			return false;
		}
		if(is_dir($filename))
		{
			$this->ERROR = "File is a directory";
			return false;
		}
		if(is_link($filename))
		{
			$this->ERROR = "File is a symlink";
			return false;
		}
		return true;
	}
//	************************************************************
//	Strips whitespace (tab or space) from a string
	function strip_space ($text)
	{
		$Return = ereg_replace("([ 	]+)","",$text);
		return ($Return);
	}
//	************************************************************
//	Returns true if string contains only numbers
	function is_allnumbers ($text)
	{
		if( (gettype($text)) == "integer")	{ return true; }
		$Bad = $this->strip_numbers($text);
		if(empty($Bad))
		{
			return true;
		}
		return false;
	}
//	************************************************************
//	Strip numbers from a string
	function strip_numbers ($text)
	{
		$Stripped = eregi_replace("([0-9]+)","",$text);
		return ($Stripped);
	}
//	************************************************************
//	Returns true if string contains only letters
	function is_allletters ($text)
	{
		$Bad = $this->strip_letters($text);
		if(empty($Bad))
		{
			return true;
		}
		return false;
	}
//	************************************************************
//	Strips letters from a string
	function strip_letters ($text)
	{
		$Stripped = eregi_replace("([A-Z]+)","",$text);
		return $Stripped;
	}
//	************************************************************
//	Checks for HTML entities in submitted text.
//	If found returns true, otherwise false. HTML specials are:
//
//		"	=>	&quot;
//		<	=>	&lt;
//		>	=>	&gt;
//		&	=>	&amp;
//
//	The presence of ",<,>,&  will force this method to return true.
//
	function has_html ($text = "")
	{
		if(empty($text))
		{
			return false;
		}
		$New = htmlspecialchars($text);
		if($New == $text)
		{
			return false;
		}
		return true;
	}
//	************************************************************
//	strip_html()
//
//	Strips all html entities, attributes, elements and tags from
//	the submitted string data and returns the results.
//
//	Can't use a regex here because there's no way to know
//	how the data is laid out. We have to examine every character
//	that's been submitted. Consequently, this is not a very
//	efficient method. It works, it's very good at removing
//	all html from the data, but don't send gobs of data
//	at it or your program will slow to a crawl.
//	If you're stripping HTML from a file, use PHP's fgetss()
//	and NOT this method, as fgetss() does the same thing
//	about 100x faster.
	function strip_html ($text = "")
	{
		if( (!$text) or (empty($text)) )
		{
			return "";
		}
		$outside = true;
		$rawText = "";
		$length = strlen($text);
		$count = 0;
		for($count=0; $count < $length; $count++)
		{
			$digit = substr($text,$count,1);
			if(!empty($digit))
			{
				if( ($outside) and ($digit != "<") and ($digit != ">") )
				{
					$rawText .= $digit;
				}
				if($digit == "<")
				{
					$outside = false;
				}
				if($digit == ">")
				{
					$outside = true;
				}
			}
		}
		return $rawText;
	}
//	************************************************************
//	Returns true of the submitted text has meta characters in it
//	. \ + * ? [ ^ ] ( $ )
//
// 
	function has_metas ($text = "")
	{
		if(empty($text))
		{
			return false;
		}
		$New = quotemeta($text);
		if($New == $text)
		{
			return false;
		}
		return true;
	}
//	************************************************************
//	Strips "  . \ + * ? [ ^ ] ( $ )  " from submitted string
//
//	Metas are a virtual MINE FIELD for regular expressions,
//  see custom_strip() for how they are removed
 
	function strip_metas ($text = "")
	{
		if(empty($text))
		{
			return false;
		}
		$Metas = array( '.','+','*','?','[','^',']','(','$',')' );
		$text = stripslashes($text);
		$New = $this->custom_strip($Metas,$text);
		return $New;
	}
//	************************************************************
//	$Chars must be an array of characters to remove.
//	This method is meta-character safe.
	function custom_strip ($Chars, $text = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($text))
		{
			return false;
		}
		if( (gettype($Chars)) != "array")
		{
			$this->ERROR = "custom_strip: [$Chars] is not an array";
			return false;
		}
		while ( list ( $key,$val) = each ($Chars) )
		{
			if(!empty($val))
			{
				// str_replace is meta-safe, ereg_replace is not
				$text = str_replace($val,"",$text);
			}
		}
		return $text;
	}
//	************************************************************
//	Array_Echo will walk through an array,
//	continuously printing out key value pairs.
//
//	Multi dimensional arrays are handled recursively.
	function array_echo ($MyArray, $Name = "Array")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if( (gettype($MyArray)) != "array") { return; }
		$count = 0;
		while ( list ($key,$val) = each ($MyArray) )
		{
			if($count == 0)
			{
				echo "nn<P><TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 COLS=8n";
				echo "><TR><TD VALIGN=TOP COLSPAN=4><B>$Name Contents:</B></TDn";
				echo "><TD COLSPAN=2><B>KEY</B></TD><TD COLSPAN=2><B>VAL</B></TD></TRn>";
			}
			if( (gettype($val)) == "array")
			{
				$NewName = "$key [$Name $count]";
				$NewArray = $MyArray[$key];
				echo "</TD></TR></TABLEnn>";
				$this->array_echo($NewArray,$NewName);
				echo "nn<P><TABLE BORDER=1 CELLPADDING=0 CELLSPACING=0 COLS=8n";
				echo "><TR><TD VALIGN=TOP COLSPAN=4><B>$Name Continued:</B></TDn";
				echo "><TD COLSPAN=2><B>KEY</B></TD><TD COLSPAN=2><B>VAL</B></TD></TRn>";
			}
			else
			{
				echo "<TR>";
				$Col1 = sprintf("[%s][%0d]",$Name,$count);
				$Col2 = $key;
				if(empty($val))	{ $val = '&nbsp;'; }
				$Col3 = $val;
				echo "<TD COLSPAN=4>$Col1</TD>";
				echo "<TD COLSPAN=2>$Col2</TDn>";
				echo "<TD COLSPAN=2>$Col3</TD></TRnn>";
			}
			$count++;
		}
		echo "<TR><TD COLSPAN=8><B>Array [$Name] complete.</B></TD></TRn>";
		echo "</TD></TR></TABLEnn>";
		return;
	}
//	************************************************************
//	Valid email format? true or false
//	This checks the raw address, not RFC 822 addresses.
//	Looks for [something]@[valid hostname with DNS record]
	function is_email ($Address = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($Address))
		{
			$this->ERROR = "is_email: No email address submitted";
			return false;
		}
		if(!ereg("@",$Address))
		{
			$this->ERROR = "is_email: Invalid, no @ symbol in string";
			return false;
		}
		
		list($User,$Host) = split("@",$Address);
		if ( (empty($User)) or (empty($Address)) )
		{
			$this->ERROR = "is_email: missing data [$User]@[$Host]";
			return false;
		}
		if( ($this->has_space($User)) or ($this->has_space($Host)) )
		{
			$this->ERROR = "is_email: Whitespace in [$User]@[$Host]";
			return false;
		}
		// Can't look for an MX only record as that precludes
		// CNAME only records. Thanks to everyone that slapped
		// me upside the head for this glaring oversite. :)
		if(!$this->is_host($Host,"ANY"))		{ return false; }
		return true;
	}
//	************************************************************
//	Valid URL format? true or false
//	Checks format of a URL - does NOT handle query strings or
//	urlencoded data.
	function is_url ($Url = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if (empty($Url))
		{
			$this->ERROR = "is_url: No URL submitted";
			return false;
		}
		// Wow, the magic of parse_url!
		$UrlElements = parse_url($Url);
		if( (empty($UrlElements)) or (!$UrlElements) )
		{
			$this->ERROR = "is_url: Parse error reading [$Url]";
			return false;
		}
		$scheme		= $UrlElements[scheme];
		$HostName	= $UrlElements[host];
		if(empty($scheme))
		{
			$this->ERROR = "is_url: Missing protocol declaration";
			return false;
		}
		if(empty($HostName))
		{
			$this->ERROR = "is_url: No hostname in URL";
			return false;
		}
		if (!eregi("^(ht|f)tp",$scheme))
		{
			$this->ERROR = "is_url: No http:// or ftp://";
			return false;
		}
## padraic renaghan change for bookmarker ver 1.4 bug 69
## if hostname is an ip address, check the validity of
## the ip address, otherwise check as if host name
## is specified.
    if (ereg("[0-9]+.[0-9]+.[0-9]+.[0-9]+",$HostName)) {
     if(!$this->is_ipaddress($HostName))	{ return false; }
    } else {
		 if(!$this->is_hostname($HostName))	  { return false; }
	  }
		return true;
	}
//	************************************************************
//	URL responds to requests? true or false
//	This will obviously fail if you're not connected to
//	the internet, or if there are connection problems. (firewall etc)
	function url_responds ($Url = "")
	{
		global $php_errormsg;
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($Url))
		{
			$this->ERROR = "url_responds: No URL submitted";
			return false;
		}
		if(!$this->is_url($Url)) { return false; }
		$fd = @fopen($Url,"r");
		if(!$fd)
		{
			$this->ERROR = "url_responds: Failed : $php_errormsg";
			return false;
		}
		else
		{
			@fclose($fd);
			return true;
		}
	}
//	************************************************************
//	Valid phone number? true or false
//	Tries to validate a phone number
//	Strips (,),-,+ from number prior to checking
//	Less than 7 digits = fail
//	More than 13 digits = fail
//	Anything other than numbers after the stripping = fail
	function is_phone ($Phone = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($Phone))
		{
			$this->ERROR = "is_phone: No Phone number submitted";
			return false;
		}
		$Num = $Phone;
		$Num = $this->strip_space($Num);
		$Num = eregi_replace("((|)|-|+)","",$Num);
		if(!$this->is_allnumbers($Num))
		{
			$this->ERROR = "is_phone: bad data in phone number";
			return false;
		}
		if ( (strlen($Num)) < 7)
		{
			$this->ERROR = "is_phone: number is too short [$Num][$Phone]";
			return false;
		}
		// 000 000 000 0000
 		// CC  AC  PRE SUFX = max 13 digits
		if( (strlen($Num)) > 13)
		{
			$this->ERROR = "is_phone: number is too long [$Num][$Phone]";
			return false;
		}
		return true;
	}
//	************************************************************
//	Valid, fully qualified hostname? true or false
//	Checks the -syntax- of the hostname, not it's actual
//	validity as a reachable internet host
	function is_hostname ($hostname = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		$web = false;
		if(empty($hostname))
		{
			$this->ERROR = "is_hostname: No hostname submitted";
			return false;
		}
		// Only a-z, 0-9, and "-" or "." are permitted in a hostname
		// Patch for POSIX regex lib by Sascha Schumann sas@schell.de
		$Bad = eregi_replace("[-A-Z0-9.]","",$hostname);
		if(!empty($Bad))
		{
			$this->ERROR = "is_hostname: invalid chars [$Bad]";
			return false;
		}
		// See if we're doing www.hostname.tld or hostname.tld
		if(eregi("^www.",$hostname))
		{
			$web = true;
		}
		// double "." is a not permitted
		if(ereg("..",$hostname))
		{
			$this->ERROR = "is_hostname: Double dot in [$hostname]";
			return false;
		}
		if(ereg("^.",$hostname))
		{
			$this->ERROR = "is_hostname: leading dot in [$hostname]";
			return false;
		}
		$chunks = explode(".",$hostname);
		if( (gettype($chunks)) != "array")
		{
			$this->ERROR = "is_hostname: Invalid hostname, no dot seperator [$hostname]";
			return false;
		}
		$count = ( (count($chunks)) - 1);
		if($count < 1)
		{
			$this->ERROR = "is_hostname: Invalid hostname [$count] [$hostname]n";
			return false;
		}
		// Bug that can't be killed without doing an is_host,
		// something.something will return TRUE, even if it's something
		// stupid like NS.SOMETHING (with no tld), because SOMETHING is
		// construed to BE the tld.  The is_bigfour and is_country
		// checks should help eliminate this inconsistancy. To really
		// be sure you've got a valid hostname, do an is_host() on it.
		if( ($web) and ($count < 2) )
		{
			$this->ERROR = "is_hostname: Invalid hostname [$count] [$hostname]n";
			return false;
		}
		$tld = $chunks[$count];
		if(empty($tld))
		{
			$this->ERROR = "is_hostname: No TLD found in [$hostname]";
			return false;
		}
		if(!$this->is_bigfour($tld))
		{
			if(!$this->is_country($tld))
			{
				$this->ERROR = "is_hostname: Unrecognized TLD [$tld]";
				return false;
			}
		}
		
		return true;
	}
//	************************************************************
	function is_bigfour ($tld)
	{
		if(empty($tld))
		{
			return false;
		}
		if(eregi("^.",$tld))
		{
			$tld = eregi_replace("^.","",$tld);
		}
		$BigFour = array (com=>com,edu=>edu,net=>net,org=>org,gov=>gov,mil=>mil,int=>int);
		$tld = strtolower($tld);
		if(isset($BigFour[$tld]))
		{
			return true;
		}
		return false;
	}
//	************************************************************
//	Hostname is a reachable internet host? true or false
	function is_host ($hostname = "", $type = "ANY")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($hostname))
		{
			$this->ERROR = "is_host: No hostname submitted";	
			return false;
		}
		if(!$this->is_hostname($hostname))	{ return false; }
		if(!checkdnsrr($hostname,$type))
		{
			$this->ERROR = "is_host: no DNS records for [$hostname].";
			return false;
		}
		return true;
	}
//	************************************************************
//	Dotted quad IPAddress within valid range? true or false
//	Checks format, leading zeros, and values > 255
//	Does not check for reserved or unroutable IPs.
	function is_ipaddress ($IP = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($IP))
		{
			$this->ERROR = "is_ipaddress: No IP address submitted";
			return false;
		}
		//	123456789012345
		//	xxx.xxx.xxx.xxx
		$len = strlen($IP);
		if( $len > 15 )
		{
			$this->ERROR = "is_ipaddress: too long [$IP][$len]";
			return false;
		}
		$Bad = eregi_replace("([0-9.]+)","",$IP);
		if(!empty($Bad))
		{
			$this->ERROR = "is_ipaddress: Bad data in IP address [$Bad]";
			return false;
		}
		$chunks = explode(".",$IP);
		$count = count($chunks);
		if ($count != 4)
		{
			$this->ERROR = "is_ipaddress: not a dotted quad [$IP]";
			return false;
		}
		while ( list ($key,$val) = each ($chunks) )
		{
			if(ereg("^0",$val))
			{
				$this->ERROR = "is_ipaddress: Invalid IP segment [$val]";
				return false;
			}
			$Num = $val;
			settype($Num,"integer");
			if($Num > 255)
			{
				$this->ERROR = "is_ipaddress: Segment out of range [$Num]";
				return false;
			}
		}
		return true;
	}	// end is_ipaddress
//	************************************************************
//	IP address is valid, and resolves to a hostname? true or false
	function ip_resolves ($IP = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($IP))
		{
			$this->ERROR = "ip_resolves: No IP address submitted";
			return false;
		}
		if(!$this->is_ipaddress($IP))
		{
			return false;
		}
		$Hostname = gethostbyaddr($IP);
		if($Hostname == $IP)
		{
			$this->ERROR = "ip_resolves: IP does not resolve.";
			return false;
		}
		if($Hostname)
		{
			if(!checkdnsrr($Hostname))
			{
				$this->ERROR = "is_ipaddress: no DNS records for resolved hostname [$Hostname]";
				return false;
			}
			if( (gethostbyname($Hostname)) != $IP )
			{
				$this->ERROR = "is_ipaddress: forward:reverse mismatch, possible forgery";
				//	Non-fatal, but it should be noted.
			}
		}
		else
		{
			$this->ERROR = "ip_resolves: IP address does not resolve";
			return false;
		}
		return true;
	}
//	************************************************************
	function browser_gen ()
	{
		if($this->CLEAR) { $this->clear_error(); }
		$generation = "UNKNOWN";
		$client = getenv("HTTP_USER_AGENT");
		if(empty($client))
		{
			$this->ERROR = "browser_gen: No User Agent for Client";
			return $generation;
		}
		$client = $this->strip_metas($client);
		$agents = array(
			'Anonymizer'		=>	"ANONYMIZER",
			'Ahoy'				=>	"SPIDER",
			'Altavista'			=>	"SPIDER",
			'Anzwers'			=>	"SPIDER",
			'Arachnoidea'		=>	"SPIDER",
			'Arachnophilia'		=>	"SPIDER",
			'ArchitextSpider'	=>	"SPIDER",
			'Backrub'			=>	"SPIDER",
			'CherryPicker'		=>	"SPAMMER",
			'Crescent'			=>	"SPAMMER",
			'Duppies'			=>	"SPIDER",
			'EmailCollector'	=>	"SPAMMER",
			'EmailSiphon'		=>	"SPAMMER",
			'EmailWolf'			=>	"SPAMMER",
			'Extractor'			=>	"SPAMMER",
			'Fido'				=>	"SPIDER",
			'Fish'				=>	"SPIDER",
			'GAIS'				=>	"SPIDER",
			'Googlebot'			=>	"SPIDER",
			'Gulliver'			=>	"SPIDER",
			'HipCrime'			=>	"SPAMMER",
			'Hamahakki'			=>	"SPIDER",
			'ia_archive'		=>	"SPIDER",
			'IBrowse'			=>	"THIRD",
			'Incy'				=>	"SPIDER",
			'InfoSeek'			=>	"SPIDER",
			'KIT-Fireball'		=>	"SPIDER",
			'Konqueror'			=>	"THIRD",
			'libwww'			=>	"SECOND",
			'LocalEyes'			=>	"SECOND",
			'Lycos'				=>	"SPIDER",
			'Lynx'				=>	"SECOND",
			'Microsoft.URL'		=>	"SPAMMER",
			'MOMspider'			=>	"SPIDER",
			'Mozilla/1'			=>	"FIRST",
			'Mozilla/2'			=>	"SECOND",
			'Mozilla/3'			=>	"THIRD",
			'Mozilla/4'			=>	"FOURTH",
			'Mozilla/5'			=>	"FIFTH",
			'Namecrawler'		=>	"SPIDER",
			'NICErsPRO'			=>	"SPAMMER",
			'Scooter'			=>	"SPIDER",
			'sexsearch'			=>	"SPIDER",
			'Sidewinder'		=>	"SPIDER",
			'Slurp'				=>	"SPIDER",
			'SwissSearch'		=>	"SPIDER",
			'Ultraseek'			=>	"SPIDER",
			'WebBandit'			=>	"SPAMMER",
			'WebCrawler'		=>	"SPIDER",
			'WiseWire'			=>	"SPIDER",
			'Mozilla/3.0 (compatible; Opera/3'	=>	"THIRD"
			);
		while ( list ($key,$val) = each ($agents) )
		{
			$key = $this->strip_metas($key);
			if(eregi("^$key",$client))
			{
				unset($agents);
				return $val;
			}
		}
		unset($agents);
		return $generation;
	}
//	************************************************************
//	United States valid state code? true or false
	function is_state ($State = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($State))
		{
			$this->ERROR = "is_state: No state submitted";
			return false;
		}
		if( (strlen($State)) != 2)
		{
			$this->ERROR = "is_state: Too many digits in state code";
			return false;
		}
		$State = strtoupper($State);
		// 50 states, Washington DC, Puerto Rico and the US Virgin Islands
		$SCodes = array (
				"AK"	=>	1,
				"AL"	=>	1,
				"AR"	=>	1,
				"AZ"	=>	1,
				"CA"	=>	1,
				"CO"	=>	1,
				"CT"	=>	1,
				"DC"	=>	1,
				"DE"	=>	1,
				"FL"	=>	1,
				"GA"	=>	1,
				"HI"	=>	1,
				"IA"	=>	1,
				"ID"	=>	1,
				"IL"	=>	1,
				"IN"	=>	1,
				"KS"	=>	1,
				"KY"	=>	1,
				"LA"	=>	1,
				"MA"	=>	1,
				"MD"	=>	1,
				"ME"	=>	1,
				"MI"	=>	1,
				"MN"	=>	1,
				"MO"	=>	1,
				"MS"	=>	1,
				"MT"	=>	1,
				"NC"	=>	1,
				"ND"	=>	1,
				"NE"	=>	1,
				"NH"	=>	1,
				"NJ"	=>	1,
				"NM"	=>	1,
				"NV"	=>	1,
				"NY"	=>	1,
				"OH"	=>	1,
				"OK"	=>	1,
				"OR"	=>	1,
				"PA"	=>	1,
				"PR"	=>	1,
				"RI"	=>	1,
				"SC"	=>	1,
				"SD"	=>	1,
				"TN"	=>	1,
				"TX"	=>	1,
				"UT"	=>	1,
				"VA"	=>	1,
				"VI"	=>	1,
				"VT"	=>	1,
				"WA"	=>	1,
				"WI"	=>	1,
				"WV"	=>	1,
				"WY"	=>	1
			);
		if(!isset($SCodes[$State]))
		{
			$this->ERROR = "is_state: Unrecognized state code [$State]";
			return false;
		}
		// Lets not have this big monster camping in memory eh?
		unset($SCodes);
		return true;
	}
//	************************************************************
//	Valid postal zip code? true or false
	function is_zip ($zipcode = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		if(empty($zipcode))
		{
			$this->ERROR = "is_zip: No zipcode submitted";
			return false;
		}
		$Bad = eregi_replace("([-0-9]+)","",$zipcode);
		if(!empty($Bad))
		{
			$this->ERROR = "is_zip: Bad data in zipcode [$Bad]";
			return false;
		}
		$Num = eregi_replace("-","",$zipcode);
		$len = strlen($Num);
		if ( ($len > 10) or ($len < 5) )
		{
			$this->ERROR = "is_zipcode: Invalid length [$len] for zipcode";
			return false;
		}
		return true;
	}
//	************************************************************
//	Valid postal country code?
//	Returns the name of the country, or null on failure
//	Current array recognizes ~232 country codes. 
//	I don't know if all of these are 100% accurate.
//	You don't wanna know how difficult it was just getting
//	this listing in here. :)
	function is_country ($countrycode = "")
	{
		if($this->CLEAR) { $this->clear_error(); }
		$Return = "";
		if(empty($countrycode))
		{
			$this->ERROR = "is_country: No country code submitted";
			return $Return;
		}
		$countrycode = strtolower($countrycode);
		if( (strlen($countrycode)) != 2 )
		{
			$this->ERROR = "is_country: 2 digit codes only [$countrycode]";
			return $Return;
		}
		//	Now for a really big array
		//	Dominican Republic, cc = "do" because it's a reserved
		//	word in PHP. That parse error took 10 minutes of
		//	head-scratching to figure out :)
		//	A (roughly) 3.1 Kbyte array
		$CCodes =	array (
			"do"	=>	"Dominican Republic",
				ad	=>	"Andorra",
				ae	=>	"United Arab Emirates",
				af	=>	"Afghanistan",
				ag	=>	"Antigua and Barbuda",
				ai	=>	"Anguilla",
				al	=>	"Albania",
				am	=>	"Armenia",
				an	=>	"Netherlands Antilles",
				ao	=>	"Angola",
				aq	=>	"Antarctica",
				ar	=>	"Argentina",
				"as"	=>	"American Samoa",
				at	=>	"Austria",
				au	=>	"Australia",
				aw	=>	"Aruba",
				az	=>	"Azerbaijan",
				ba	=>	"Bosnia Hercegovina",
				bb	=>	"Barbados",
				bd	=>	"Bangladesh",
				be	=>	"Belgium",
				bf	=>	"Burkina Faso",
				bg	=>	"Bulgaria",
				bh	=>	"Bahrain",
				bi	=>	"Burundi",
				bj	=>	"Benin",
				bm	=>	"Bermuda",
				bn	=>	"Brunei Darussalam",
				bo	=>	"Bolivia",
				br	=>	"Brazil",
				bs	=>	"Bahamas",
				bt	=>	"Bhutan",
				bv	=>	"Bouvet Island",
				bw	=>	"Botswana",
				by	=>	"Belarus (Byelorussia)",
				bz	=>	"Belize",
				ca	=>	"Canada",
				cc	=>	"Cocos Islands",
				cd	=>	'Congo, The Democratic Republic of the',
				cf	=>	"Central African Republic",
				cg	=>	"Congo",
				ch	=>	"Switzerland",
				ci	=>	"Ivory Coast",
				ck	=>	"Cook Islands",
				cl	=>	"Chile",
				cm	=>	"Cameroon",
				cn	=>	"China",
				co	=>	"Colombia",
				cr	=>	"Costa Rica",
				cs	=>	"Czechoslovakia",
				cu	=>	"Cuba",
				cv	=>	"Cape Verde",
				cx	=>	"Christmas Island",
				cy	=>	"Cyprus",
				cz	=>	'Czech Republic',
				de	=>	"Germany",
				dj	=>	"Djibouti",
				dk	=>	'Denmark',
				dm	=>	"Dominica",
				dz	=>	"Algeria",
				ec	=>	"Ecuador",
				ee	=>	"Estonia",
				eg	=>	"Egypt",
				eh	=>	"Western Sahara",
				er	=>	'Eritrea',
				es	=>	"Spain",
				et	=>	"Ethiopia",
				fi	=>	"Finland",
				fj	=>	"Fiji",
				fk	=>	"Falkland Islands",
				fm	=>	"Micronesia",
				fo	=>	"Faroe Islands",
				fr	=>	"France",
				fx	=>	'France, Metropolitan FX',
				ga	=>	"Gabon",
				gb	=>	'United Kingdom (Great Britain)',
				gd	=>	"Grenada",
				ge	=>	"Georgia",
				gf	=>	"French Guiana",
				gh	=>	"Ghana",
				gi	=>	"Gibraltar",
				gl	=>	"Greenland",
				gm	=>	"Gambia",
				gn	=>	"Guinea",
				gp	=>	"Guadeloupe",
				gq	=>	"Equatorial Guinea",
				gr	=>	"Greece",
				gs	=>	'South Georgia and the South Sandwich Islands',
				gt	=>	"Guatemala",
				gu	=>	"Guam",
				gw	=>	"Guinea-bissau",
				gy	=>	"Guyana",
				hk	=>	"Hong Kong",
				hm	=>	"Heard and McDonald Islands",
				hn	=>	"Honduras",
				hr	=>	"Croatia",
				ht	=>	"Haiti",
				hu	=>	"Hungary",
				id	=>	"Indonesia",
				ie	=>	"Ireland",
				il	=>	"Israel",
				in	=>	"India",
				io	=>	"British Indian Ocean Territory",
				iq	=>	"Iraq",
				ir	=>	"Iran",
				is	=>	"Iceland",
				it	=>	"Italy",
				jm	=>	"Jamaica",
				jo	=>	"Jordan",
				jp	=>	"Japan",
				ke	=>	"Kenya",
				kg	=>	"Kyrgyzstan",
				kh	=>	"Cambodia",
				ki	=>	"Kiribati",
				km	=>	"Comoros",
				kn	=>	"Saint Kitts and Nevis",
				kp	=>	"North Korea",
				kr	=>	"South Korea",
				kw	=>	"Kuwait",
				ky	=>	"Cayman Islands",
				kz	=>	"Kazakhstan",
				la	=>	"Laos",
				lb	=>	"Lebanon",
				lc	=>	"Saint Lucia",
				li	=>	"Lichtenstein",
				lk	=>	"Sri Lanka",
				lr	=>	"Liberia",
				ls	=>	"Lesotho",
				lt	=>	"Lithuania",
				lu	=>	"Luxembourg",
				lv	=>	"Latvia",
				ly	=>	"Libya",
				ma	=>	"Morocco",
				mc	=>	"Monaco",
				md	=>	"Moldova Republic",
				mg	=>	"Madagascar",
				mh	=>	"Marshall Islands",
				mk	=>	'Macedonia, The Former Yugoslav Republic of',
				ml	=>	"Mali",
				mm	=>	"Myanmar",
				mn	=>	"Mongolia",
				mo	=>	"Macau",
				mp	=>	"Northern Mariana Islands",
				mq	=>	"Martinique",
				mr	=>	"Mauritania",
				ms	=>	"Montserrat",
				mt	=>	"Malta",
				mu	=>	"Mauritius",
				mv	=>	"Maldives",
				mw	=>	"Malawi",
				mx	=>	"Mexico",
				my	=>	"Malaysia",
				mz	=>	"Mozambique",
				na	=>	"Namibia",
				nc	=>	"New Caledonia",
				ne	=>	"Niger",
				nf	=>	"Norfolk Island",
				ng	=>	"Nigeria",
				ni	=>	"Nicaragua",
				nl	=>	"Netherlands",
				no	=>	"Norway",
				np	=>	"Nepal",
				nr	=>	"Nauru",
				nt	=>	"Neutral Zone",
				nu	=>	"Niue",
				nz	=>	"New Zealand",
				om	=>	"Oman",
				pa	=>	"Panama",
				pe	=>	"Peru",
				pf	=>	"French Polynesia",
				pg	=>	"Papua New Guinea",
				ph	=>	"Philippines",
				pk	=>	"Pakistan",
				pl	=>	"Poland",
				pm	=>	"St. Pierre and Miquelon",
				pn	=>	"Pitcairn",
				pr	=>	"Puerto Rico",
				pt	=>	"Portugal",
				pw	=>	"Palau",
				py	=>	"Paraguay",
				qa	=>	'Qatar',
				re	=>	"Reunion",
				ro	=>	"Romania",
				ru	=>	"Russia",
				rw	=>	"Rwanda",
				sa	=>	"Saudi Arabia",
				sb	=>	"Solomon Islands",
				sc	=>	"Seychelles",
				sd	=>	"Sudan",
				se	=>	"Sweden",
				sg	=>	"Singapore",
				sh	=>	"St. Helena",
				si	=>	"Slovenia",
				sj	=>	"Svalbard and Jan Mayen Islands",
				sk	=>	'Slovakia (Slovak Republic)',
				sl	=>	"Sierra Leone",
				sm	=>	"San Marino",
				sn	=>	"Senegal",
				so	=>	"Somalia",
				sr	=>	"Suriname",
				st	=>	"Sao Tome and Principe",
				sv	=>	"El Salvador",
				sy	=>	"Syria",
				sz	=>	"Swaziland",
				tc	=>	"Turks and Caicos Islands",
				td	=>	"Chad",
				tf	=>	"French Southern Territories",
				tg	=>	"Togo",
				th	=>	"Thailand",
				tj	=>	"Tajikistan",
				tk	=>	"Tokelau",
				tm	=>	"Turkmenistan",
				tn	=>	"Tunisia",
				to	=>	"Tonga",
				tp	=>	"East Timor",
				tr	=>	"Turkey",
				tt	=>	"Trinidad, Tobago",
				tv	=>	"Tuvalu",
				tw	=>	"Taiwan",
				tz	=>	"Tanzania",
				ua	=>	"Ukraine",
				ug	=>	"Uganda",
				uk	=>	"United Kingdom",
				um	=>	"United States Minor Islands",
				us	=>	"United States of America",
				uy	=>	"Uruguay",
				uz	=>	"Uzbekistan",
				va	=>	"Vatican City",
				vc	=>	"Saint Vincent, Grenadines",
				ve	=>	"Venezuela",
				vg	=>	"Virgin Islands (British)",
				vi	=>	"Virgin Islands (USA)",
				vn	=>	"Viet Nam",
				vu	=>	"Vanuatu",
				wf	=>	'Wallis and Futuna Islands',
				ws	=>	"Samoa",
				ye	=>	'Yemen',
				yt	=>	'Mayotte',
				yu	=>	"Yugoslavia",
				za	=>	"South Africa",
				zm	=>	"Zambia",
				zr	=>	"Zaire",
				zw	=>	"Zimbabwe"
		);
		if(isset($CCodes[$countrycode]))
		{
			$Return = $CCodes[$countrycode];
		}
		else
		{
			$this->ERROR = "is_country: Unrecognized country code [$countrycode]";
			$Return = "";
		}
		// make sure this monster is removed from memory
		unset($CCodes);
		return ($Return);
	}	// end is_country
}	// End class
?>

						